tkinter: множественный список не запускает клавиши со стрелками вверх / вниз - PullRequest
Новая
       1

tkinter: множественный список не запускает клавиши со стрелками вверх / вниз

0 голосов
/ 05 июля 2019

Я хочу выбрать элементы из мультисписка в tkinter, привязав события к клавишам со стрелками.

Мультиспираль работает отлично здесь !с прокруткой мыши.Но это не работает с клавишами со стрелками вверх / вниз.Я добавил привязку клавиш со стрелками вверх / вниз к коду, но она не сработала, когда я нажал на клавиши со стрелками, и ни одно из этих решений из link1 !и ссылка2 !работал для меня.

Ниже приведено то, что я добавил к коду в предоставленной мной ссылке: 

...
lb.bind("<Down>", lambda e, s=self: s._OnEntryDown(e.y))
lb.bind("<Up>", lambda e, s=self: s._OnEntryUp(e.y))
...

...
def downarrow(self, *args):
   for l in self.lists:
       if self.selection < l.size()-1:
           l.select_clear(self.selection)
           self.selection += 1
           l.select_set(self.selection)


def uparrow(self, *args):
    for l in self.lists:
        if self.selection > 0:
            self.l.select_clear(self.selection)
            self.selection -= 1
            self.l.select_set(self.selection)

Я ожидаю, что выбор клавиш со стрелками вверх / вниз будет работать идеальноделает с одним списком в tkinter.Пожалуйста, мне нужна помощь!

1 Ответ

0 голосов
/ 06 июля 2019

Пройдя несколько интернет-серфингов, я смог наткнуться на эту ссылку !на github, но это было написано на python 2.x, поэтому я изменил его для работы и с python 3.x.Ниже приведен модифицированный код: 

#!/usr/bin/env python
import copy
import csv
import logging
import os
import platform
import tkinter as tk
from tkinter import *
from tkinter import ttk
import tkinter.constants as Tkc
import tkinter.filedialog as Tkfc
import tkinter.font as Tkf
import tkinter.messagebox as Tkmb
import webbrowser
import sys

logging.getLogger().setLevel(logging.DEBUG)


class MultiListbox(ttk.Frame):

    def __init__(self, parent, lists):
        ttk.Frame.__init__(self, parent)
        self.lists = []
        self.colmapping = {}
        self.orig_data = None
        self.fonts = {}
        self.y_sel = None
        for label, width in lists:
            frame = Frame(self)
            frame.pack(side=Tkc.LEFT, expand=Tkc.YES, fill=Tkc.BOTH)

            sort_button = Button(frame, text=label, borderwidth=1, relief=Tkc.RAISED)
            sort_button.pack(fill=Tkc.X)
            sort_button.bind("<Button-1>", self._sort)
            sort_button.config(font=self.header_font)

            self.colmapping[sort_button] = (len(self.lists), 1)
            list_box = Listbox(frame, width=width, borderwidth=0, selectborderwidth=0,
                              relief=Tkc.FLAT, exportselection=Tkc.FALSE)
            list_box.pack(expand=Tkc.YES, fill=Tkc.BOTH)
        self.lists.append(list_box)
            list_box.bind("<B1-Motion>", lambda e, s=self: s._select(e.y))
            list_box.bind("<Button-1>", lambda e, s=self: s._select(e.y))
            list_box.bind("<Leave>", lambda e: "break")
            list_box.bind("<B2-Motion>", lambda e, s=self: s._b2motion(e.x, e.y))
            list_box.bind("<Button-2>", lambda e, s=self: s._button2(e.x, e.y))
            list_box.bind("<Double-Button-1>", lambda e, s=self: s._activate(e.y))

        frame = Frame(self)
        frame.pack(side=Tkc.LEFT, fill=Tkc.Y)
        frame_label = Label(frame, borderwidth=1, relief=Tkc.RAISED)
        frame_label.pack(fill=Tkc.X)
        scroll_bar = Scrollbar(frame, orient=Tkc.VERTICAL, command=self._scroll)
        scroll_bar.pack(expand=Tkc.YES, fill=Tkc.Y)
        self.lists[0]["yscrollcommand"] = scroll_bar.set

        # Configure scrolling by arrow keys and Page Up/Down.
        self.bind_all("<Up>", lambda e, s=self: s._scroll("scroll", "-1", "units", select=True))
        self.bind_all("<Down>", lambda e, s=self: s._scroll("scroll", "1", "units", select=True))
        self.bind_all("<Next>", lambda e, s=self: s._scroll("scroll", "1", "pages", select=True))
        self.bind_all("<Prior>", lambda e, s=self: s._scroll("scroll", "-1", "pages", select=True))
        self.bind_all("<Return>", lambda e, s=self: s._activate(e.y))

       self.master.protocol("WM_DELETE_WINDOW", self.master.destroy)

    @property
    def header_font(self):
        if "header" in self.fonts:
            return self.fonts["header"]
        font_families = sorted(Tkf.families(self.master))
        if "Liberation Sans" in font_families:
            family = "Liberation Sans"
        else:
            family = "Tahoma"
        font = Tkf.Font(family=family, size=13, weight=Tkf.BOLD)
        self.fonts["header"] = font
        return font

    def _sort(self, event):

        # Get the listbox to sort by (mapped by the header buttons)
        originating_button = event.widget
        column, direction = self.colmapping[originating_button]

        # Make an in-memory copy of all the table data.
        table_data = self.get(0, Tkc.END)
        if self.orig_data is None:
            self.orig_data = copy.deepcopy(table_data)
        row_count = len(table_data)

        # Remove any old sort indicators (if they exist)
        for button in self.colmapping:
            button_text = button.cget("text")
            if button_text[0] == "[":
                button.config(text=button_text[4:])

        # Sort data based on direction.
        button_label = originating_button.cget("text")
        if direction == 0:
            table_data = self.orig_data
        elif direction == 1:
            originating_button.config(text="[+] {0}".format(button_label))
            table_data.sort(key=lambda obj: obj[column], reverse=False)
        else:  # direction == -1
            originating_button.config(text="[-] {0}".format(button_label))
            table_data.sort(key=lambda obj: obj[column], reverse=True)

        # Clear and refill the widget.
        self.delete(0, Tkc.END)
        for row in range(row_count):
            self.insert(Tkc.END, table_data[row])

        # Finally, toggle the direction flag.
        if direction == 1:
            direction = -1
        else:
            direction += 1
        self.colmapping[originating_button] = column, direction

    def _activate(self, y):
        item_info = self.get(self.curselection()[0])
        logging.info("Opening PyPI web page for item: %s", item_info)
        pypi_url = "https://pypi.python.org/pypi/{0[0]}".format(item_info)
        webbrowser.open_new(pypi_url)

    def _select(self, y):
        row = self.lists[0].nearest(y)
        logging.info("Selecting Y point %s (got row %s)", y, row)
        return self._select_row(row)

    def _select_row(self, row):
        logging.info("Selecting row %d", row)
        self.selection_clear(0, Tkc.END)
        self.selection_set(row)
        # self.see(row)
        return "break"

    def _button2(self, x, y):
        logging.info("Button 2 at (%d, %d)", x, y)
        for list_widget in self.lists:
            list_widget.scan_mark(x, y)
        return "break"

    def _b2motion(self, x, y):
        logging.info("B2 Motion to (%d, %d)", x, y)
        for list_widget in self.lists:
            list_widget.scan_dragto(x, y)
        return "break"

    def _scroll(self, *args, select=False):
        #select = kwargs.pop("select", False)
        logging.info("Scrolling -- args: %s, select: %s", args, select)

        if select and self.curselection():
            new_index, should_do_scroll = self.get_new_selection(args)
            if new_index is None:
                logging.debug("No selection change for args: %s - scrolling...", args)
                should_do_scroll = True
            else:
                old_index = int(self.curselection()[0])
                logging.debug("Changing selection from index %d to %d", old_index, new_index)
                self._select_row(new_index)
        else:
            should_do_scroll = True

        if should_do_scroll:
            for list_widget in self.lists:
                list_widget.yview(*args)

    def get_new_selection(self, scroll_args):
        """
    If selection change upon scrolling is enabled, return the new index that should be selected after the
    scroll operation finishes. If the new index is currently visible, just select it and skip the actual
    scrolling process entirely.

    :param list scroll_args: The arguments passed to the scrollbar widget
    :return tuple: The index that should be selected afterward, followed by its current "selectability"
    """
        cur_selection = self.curselection()

        # If the scrollbar is being dragged, or if nothing is currently selected, then do not select anything.
        if scroll_args[0] != "scroll" or not cur_selection:
            return None, False
        amount = int(scroll_args[1])
        pixel_dict = self.get_pixel_dict()
        page_size = len(pixel_dict) - 2 if scroll_args[2] == "pages" else 1
        scroll_diff = amount * page_size
        old_index = int(cur_selection[0])
        new_index = max(0, min(self.lists[0].size() - 1, old_index + scroll_diff))
        return new_index, new_index not in pixel_dict

    def curselection(self):
        return self.lists[0].curselection()

    def delete(self, first, last=None):
        for list_widget in self.lists:
            list_widget.delete(first, last)

    def get(self, first, last=None):
        result = []
        for list_widget in self.lists:
            result.append(list_widget.get(first, last))
        if last:
            return map(*[None] + result)
        return result

    def index(self, index):
        self.lists[0].index(index)

    def insert(self, index, *elements):
        for elem in elements:
            i = 0
            for list_widget in self.lists:
                list_widget.insert(index, elem[i])
                i += 1

    def size(self):
        return self.lists[0].size()

    def see(self, index):
        for list_widget in self.lists:
            list_widget.see(index)

    def selection_anchor(self, index):
        for list_widget in self.lists:
            list_widget.selection_anchor(index)

    def selection_clear(self, first, last=None):
        for list_widget in self.lists:
            list_widget.selection_clear(first, last)

    def selection_includes(self, index):
        return self.lists[0].selection_includes(index)

    def selection_set(self, first, last=None):
        for list_widget in self.lists:
           list_widget.selection_set(first, last)

    def get_pixel_dict(self):
        list_box = self.lists[0]
        height = list_box.winfo_height() + 1
        pixel_dict = {list_box.nearest(height): height}
        for pixel in range(height, 0, -1):
            pixel_dict[list_box.nearest(pixel)] = pixel
        max_index, bottom_y = max(pixel_dict.items())
        item_height = bottom_y - pixel_dict.get(max_index - 1, 1)
        while bottom_y + item_height < height:
            max_index += 1
            bottom_y += item_height
            pixel_dict[max_index] = bottom_y
        pixel_dict.pop(max_index)
        return pixel_dict


if __name__ == '__main__':
    tk = Tk()
    Label(tk, text='MultiListbox').pack(side=TOP)
    mlb = MultiListbox(tk, (('Subject', 40), ('Sender', 20), ('Date', 10)))

    for i in range(5000):
        mlb.insert(END, ('Important Message: %d' % i, 'John Doe %d' % i, '10/10/%04d' % (1900+i)))
        mlb.pack(expand=YES,fill=BOTH,side=TOP)
    mlb.selection_set(0)
    tk.mainloop()
Добро пожаловать на сайт PullRequest, где вы можете задавать вопросы и получать ответы от других членов сообщества.

Нет похожих вопросов

...