Python tkinter，制作两个文本小部件'；s滚动同步

我试图使两个文本小部件的滚动同步。到目前为止，我已经实现了使用滚动条，当使用滚动条时，效果很好。但例如，当我将焦点放在其中一个文本小部件上，并使用鼠标滚轮滚动时，只有具有焦点的文本小部件被滚动，滚动条也会更新，但其他文本保持不变。当使用向下翻页或向上翻页键时，以及我所知道的每种不使用滚动条的滚动形式时，都会出现相同的行为

这是我的代码，我认为只有init是我绑定事件的相关部分，但为了以防万一，我决定将所有代码放在：

## HexText class
#
#
class HexText (tkk.Frame):

    __POS_TEXT = "00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F"
    __OFFSET_TEXT = "0x00000000"
    __LINE_LENGTH = len(__POS_TEXT)

    def __init__(self, master):

        super(HexText, self).__init__(master)

        self.__create_widgets()
        self.__organize_widgets()

    def __scrolls(self, *args):
        self.__data.yview(*args)
        self.__offset.yview(*args)

    def __create_widgets(self):

        self.__scrollbar = tkk.Scrollbar(self)
        self.__scrollbar["orient"] = tk.VERTICAL
        self.__scrollbar["command"] = self.__scrolls

        self.__data = tk.Text(self)
        self.__data["height"] = 8
        self.__data["width"] = HexText.__LINE_LENGTH
        self.__data["state"] = tk.DISABLED
        self.__data["relief"] = tk.GROOVE
        self.__data["yscrollcommand"] = self.__scrollbar.set

        self.__offset = tk.Text(self)
        self.__offset["height"] = 8
        self.__offset["width"] = len(HexText.__OFFSET_TEXT)
        self.__offset["state"] = tk.DISABLED
        self.__offset["relief"] = tk.FLAT
        self.__offset["bg"] = self.winfo_toplevel()["bg"]
        self.__offset["yscrollcommand"] = self.__scrollbar.set

        self.__pos = tk.Text(self)
        self.__pos.insert(tk.CURRENT, HexText.__POS_TEXT)
        self.__pos["height"] = 1
        self.__pos["width"] = HexText.__LINE_LENGTH
        self.__pos["state"] = tk.DISABLED
        self.__pos["relief"] = tk.FLAT
        self.__pos["bg"] = self.winfo_toplevel()["bg"]

    def __organize_widgets(self):

        self.__pos.grid(row = 0, column = 1, sticky = tk.N + tk.E + tk.W + tk.S)
        self.__offset.grid(row = 1, column = 0, sticky = tk.N + tk.E + tk.W + tk.S)
        self.__data.grid(row = 1, column = 1, sticky = tk.N + tk.E + tk.W + tk.S)
        self.__scrollbar.grid(row = 1, column = 2, sticky = tk.N + tk.E + tk.W + tk.S)

    @staticmethod
    def __get_char_index(string):
        i = str.find(string, '.')

        if i >= 0:
            i = int(string[i+1:])
        else:
            raise ValueError

        return i

    @staticmethod
    def __get_line_index(string):
        i = str.find(string, '.')

        if i >= 0:
            i = int(string[:i])
        else:
            raise ValueError

        return i

    @staticmethod
    def __get_hex_value(string):

        if (len(string) != 1):
            raise ValueError

        i = "%02X" % ord(string)

        return i

    def __update_offset(self, line_index):

        i = "0x%08X\n" % ((line_index) * 0x10)
        self.__offset["state"] = tk.NORMAL
        self.__offset.insert(tk.CURRENT, i)
        self.__offset["state"] = tk.DISABLED

    def __append(self, string):
        self.__data["state"] = tk.NORMAL
        self.__data.insert(tk.CURRENT, string)
        self.__data["state"] = tk.DISABLED

    def __write_char(self, string):
        str_index = self.__data.index(tk.CURRENT)
        i = HexText.__get_char_index(str_index)

        if (len(string) != 1):
            raise ValueError

        if (i == 0):
            self.__update_offset(HexText.__get_line_index(str_index) - 1)

        if (i == HexText.__LINE_LENGTH - 2):
            self.__append(HexText.__get_hex_value(string) + '\n')
        else:
            self.__append(HexText.__get_hex_value(string) + ' ')

    def write_str(self, string):

        for chars in string:
            self.__write_char(chars)

这是我试图创建的小部件的图像，一个简单的十六进制查看器（两个文本小部件的行数相同）：

---

所以我的问题是，我是否应该独立地处理所有的向上翻页、向下翻页、鼠标滚轮和所有其他形式的滚动？有没有更简单的方法让两个文本小部件始终具有相同的滚动？回答您的问题，是否应该为每个滚动条单独执行事件处理-这是您必须做出的决定。 如果您只想为此目的制作此小部件，您可以同时处理这两个小部件，而不是单独处理。为此创建自定义事件处理程序，并相应地调用setter/getter

如果您有两个小部件（包括两个滚动条）在一个主小部件中，您希望在其中绑定事件，请使用

widget.bind（，handler）

或使用

widget.bind\u all（，handler）

也将从子小部件引发的事件绑定到这些处理程序

由于您已经在代码中使用了相同的处理程序（

self.\uu scrollbar.set

），您可以使用自定义事件处理程序绑定

向上翻页

/

向下翻页

键以按特定偏移量滚动，以及一个自定义按钮以按

鼠标滚轮

-事件滚动

如上所述，如果您独立滚动并在这些处理程序中调用两个滚动函数，或者如果您在一个函数中同时滚动这两个函数，则由您自己决定

---

由于需要为每个

tk.Text

-小部件调用滚动，我个人更喜欢在一个绑定到父小部件和下面所有小部件的处理程序中调用这两个滚动（因此使用

bind\u all

），但我认为这是个人偏好的问题。

我知道这有点旧，但这个解决方案非常有效。默认情况下，文本小部件会对滚动鼠标滚轮做出反应，因此无需绑定任何内容

import sys
if sys.version[0] < '3':
    from Tkinter import *
else:
    from tkinter import *


class ScrolledTextPair(Frame):
    '''Two Text widgets and a Scrollbar in a Frame'''

    def __init__(self, master, **kwargs):
        Frame.__init__(self, master) # no need for super

        # Different default width
        if 'width' not in kwargs:
            kwargs['width'] = 30

        # Creating the widgets
        self.left = Text(self, **kwargs)
        self.left.pack(side=LEFT, fill=BOTH, expand=True)
        self.right = Text(self, **kwargs)
        self.right.pack(side=LEFT, fill=BOTH, expand=True)
        self.scrollbar = Scrollbar(self)
        self.scrollbar.pack(side=RIGHT, fill=Y)

        # Changing the settings to make the scrolling work
        self.scrollbar['command'] = self.on_scrollbar
        self.left['yscrollcommand'] = self.on_textscroll
        self.right['yscrollcommand'] = self.on_textscroll

    def on_scrollbar(self, *args):
        '''Scrolls both text widgets when the scrollbar is moved'''
        self.left.yview(*args)
        self.right.yview(*args)

    def on_textscroll(self, *args):
        '''Moves the scrollbar and scrolls text widgets when the mousewheel
        is moved on a text widget'''
        self.scrollbar.set(*args)
        self.on_scrollbar('moveto', args[0])


# Example
if __name__ == '__main__':
    root = Tk()

    t = ScrolledTextPair(root, bg='white', fg='black')
    t.pack(fill=BOTH, expand=True)
    for i in range(50):
        t.left.insert(END,"foo %s\n" % i)
        t.right.insert(END,"bar %s\n" % i)

    root.title("Text scrolling example")
    root.mainloop()

导入系统 如果系统版本[0]<“3”： 从Tkinter进口* 其他： 从tkinter进口* 类ScrolledTextPair（帧）： ''一个框架中有两个文本小部件和一个滚动条'' 定义初始（自我、主控、**kwargs）： 帧。uuu init（self，master）#不需要超级 #不同的默认宽度 如果“宽度”不以kwargs为单位： kwargs['width']=30 #创建小部件 self.left=文本（self，**kwargs） self.left.pack（side=left，fill=BOTH，expand=True） self.right=文本（self，**kwargs） self.right.pack（side=左侧，fill=两者兼有，expand=True） self.scrollbar=滚动条（self） self.scrollbar.pack（side=RIGHT，fill=Y） #更改设置以使滚动正常工作 self.scrollbar['command']=self.on\u滚动条 self.left['yscrollcommand']=self.on_text滚动 self.right['yscrollcommand']=self.on_text滚动 滚动条上的def（自，*参数）： ''移动滚动条时滚动两个文本小部件'' self.left.yview（*args） self.right.yview（*args） 文本滚动（self，*args）上的定义： ''移动滚动条并在鼠标滚轮启动时滚动文本小部件 已在文本小部件“”上移动 self.scrollbar.set（*args） 滚动条上的self.on（'moveto'，args[0]） #范例 如果uuuu name uuuuuu='\uuuuuuu main\uuuuuuu'： root=Tk（） t=滚动文本对（根，bg='白色'，fg='黑色〕） t、 打包（填充=两者，展开=真） 对于范围（50）内的i： t、 左。插入（结束，“foo%s\n”%i） t、 右。插入（结束，“条%s\n”%i） root.title（“文本滚动示例”） root.mainloop（）

---

添加了一些内容并更正了错误。非常酷。但是，当每个文本中的文本量不一样时，这种行为有点奇怪。