我试图将左右箭头键绑定到Tkinter中的事件,但是当我运行程序时,它似乎没有触发事件.这是代码:

from Tkinter import *

main = Tk()

def leftKey(event):
    print "Left key pressed"

def rightKey(event):
    print "Right key pressed"

frame = Frame(main, width=100, height=100)
frame.bind('<Left>', leftKey)
frame.bind('<Right>', rightKey)
frame.pack()
frame.mainloop()

为什么这不起作用？

我想在Text窗口小部件类绑定之后绑定自身事件,以便在调用绑定函数时更改窗口小部件的文本.例如self.text.bind("<Key>", self.callback),在"文本"窗口小部件中的内容更改之前调用我的绑定.

摘要

在Python Tkinter应用程序中,使用时ttk.Notebook,如何绑定按键事件,以便仅在包含生成事件的帧的选项卡处于活动状态时触发(即,对于按钮热键,如何仅在按钮时捕获事件在活动标签上)？

详情

我正在编写一个Tkinter应用程序(我的第一个),它使用一个ttk.Notebook对象来管理界面的多个部分.我有多个选项卡,其中一些选项卡上有"相同"按钮,但它们具有不同的操作,具体取决于哪个选项卡处于活动状态(即,一个选项卡上的"保存"按钮仅保存该选项卡中的项目,而不是所有标签).

直观的方法是将事件绑定到帧,然后包含"活动"对象的帧将捕获事件,但这似乎不起作用.但是,如果我将事件绑定到根窗口,则无论选项卡上下文如何,都会调用相同的处理程序.

我认为这是一个常见的要求,但我无法找到有关如何执行此操作的信息.

我使用的是Python 3.4.3.

MCVE

这是一个最小的例子,它展示了我观察到的行为.它生成一个带有五个选项卡的主窗口,每个选项卡都有一个事件绑定Alt-t,它应该触发该选项卡中框架的事件处理程序.

import tkinter as tk
from tkinter import ttk

class MyTab(ttk.Frame):
    """Frame to be added to each tab of the notebook.

    """

    def __init__(self, master, idx, *args, **kwargs):
        super().__init__(master, *args, **kwargs)
        self._button = ttk.Button(self, text='Tab {}'.format(idx),
                                  command=lambda *args, x=idx: self._handle_button(x, *args),
                                  underline=0)
        self.bind('<Alt-t>', lambda *args, x=idx: self._handle_button(x, *args))
        self._button.pack()
        self.pack()


    def _handle_button(self, x, *args):
        print('Button: Tab {}'.format(x))



class MainWdw(ttk.Frame):
    """Main application window.

    """

    def …

我想知道如何用一个"绑定"绑定多个小部件.

例如:

我有三个按钮,我想在悬停后改变颜色.

from Tkinter import *

def SetColor(event):
    event.widget.config(bg="red")
    return

def ReturnColor(event):
    event.widget.config(bg="white")
    return

root = Tk()

B1 = Button(root,text="Button 1", bg="white")
B1.pack()

B2 = Button(root, text="Button2", bg="white")
B2.pack()

B3 = Button(root, text= "Button 3", bg="white")
B3.pack()

B1.bind("<Enter>",SetColor)
B2.bind("<Enter>",SetColor)
B3.bind("<Enter>",SetColor)

B1.bind("<Leave>",ReturnColor)
B2.bind("<Leave>",ReturnColor)
B3.bind("<Leave>",ReturnColor)

root.mainloop()

我的目标是只有两个绑定(用于"Enter"和"Leave"事件)而不是上面的六个.

谢谢你的任何想法

我想tkinter text widget用作readonly小部件.它应该作为一个transcript领域.我的想法是将这个脚本保留在一个file用户写入任何内容的时候,只需删除小部件的所有内容,然后重新重写.

代码如下所示:

transcript_entry = SimpleEditor()  # SimpleEditor is inherited from ScrolledText
transcript_entry.text.delete("1.0", END)

# this is just a test string, it should be the contents of the transcript file
transcript_entry.text.insert("1.0", "This is test transcript")  
transcript_entry.text.bind("<KeyPress>", transcript_entry.readonly)

而readonly功能将类似于:

def readonly(self, event):
    self.text.delete("1.0", END)
    # this is just a test string, it should be the contents of the transcript file
    self.text.insert("1.0", "This is test transcript")

这里的错误是用户输入的最后一个字符被添加到记录中.我怀疑原因是调用了readonly函数,then用户输入被写入窗口小部件.如何反转这个顺序并让readonly函数被调用after用户输入被写入窗口小部件？ …

我正在制作一个简单的tkinter文本编辑器,但我希望尽可能删除Text小部件的所有默认绑定.

例如,当我按Ctrl + i时,默认情况下会插入一个Tab字符.我做了一个事件绑定,打印文本框中有多少行,我也将事件绑定设置为Ctrl + i.

当我运行它时,它会打印文本框内的行数,但也会插入制表符.

我想知道如何覆盖默认绑定,或者学习如何删除所有默认绑定.

继承了我的代码btw:

from tkinter import *

class comd: # Contains primary commands
    # Capital Rule ----------------------------
    # G = Get | I = Insert | D = Draw | S = Set
    # -----------------------------------------

    def Ggeo(self): # Get Geometry (Get window geometry)
        x = root.winfo_width()
        y = root.winfo_height()
        print("Current Window Geometry")
        print(str(x) + " x " +str(y))

    def Idum(self): # Insters "Dummy Insert"
        import tkinter …

我有一个使用 tkinter 和键绑定的 python 程序。该程序调用外部程序，然后询问如何处理它，期望 n 键表示“否”，或 y 键表示“是”。问题：如果我按允许的键两次，第二个键将被存储并稍后处理 - 因此是错误的问题。

import tkinter as tk
import time

class App:
    counter = 0

    def __init__(self, master): # Constructor
        # build GUI
        self.label = tk.Label(text="Press <space>", width=40)
        self.label.grid(row=1, column=1, sticky='w')

        # bind keys to buttons
        master.bind('<Key-space>', self.keyPressed)
        pass # __init__


    def keyPressed(self, event):
        print("Step 1")
        self.counter = self.counter + 1
        self.label.configure(text = str(self.counter))
        self.label.update()
        time.sleep(3)
        print("Step  2")
        pass # Key1Pressed
# End of class App

root = tk.Tk()
root.option_add('*font', ('Arial', 11, 'bold')) …

在python 2.7中，每次Tkinter Text小部件中发生更改时，我都试图获取回调。

该程序根据此处找到的代码使用多个帧：在tkinter中的两个帧之间切换

回调部分摘自以下示例：http : //code.activestate.com/recipes/464635-call-a-callback-when-a-tkintertext-is-modified/

两种代码都可以单独很好地工作，但是将这两种代码结合起来对我来说很难。这是我尝试使用尽可能简单的代码。

import Tkinter as tk

class Texter(tk.Tk):

    def __init__(self, *args, **kwargs):
        tk.Tk.__init__(self, *args, **kwargs)

        container = tk.Frame(self)
        container.pack()

        self.frames = {}

        for F in (ConnectPage, EditorPage):
            frame = F(container, self)
            self.frames[F] = frame
            frame.grid(row=0, column=0, sticky="nsew")

        page_name = EditorPage.__name__
        self.frames[page_name] = frame
        self.show_frame(ConnectPage)


    def show_frame(self, cont):
        frame = self.frames[cont]
        frame.tkraise()

    def get_page(self, page_name):
        return self.frames[page_name]


class ConnectPage(tk.Frame):

    def __init__(self, parent, controller):
        tk.Frame.__init__(self, parent)

        button1 = tk.Button(self, text="SecondPage",
                            command=lambda: controller.show_frame(EditorPage))
        button1.grid(row=2, column=3, …

我定义了GCanvas,它是Canvas的扩展.我的目的是在类级别绑定到GCanvas.它不起作用.

我也尝试绑定到tk.Canvas,它也不起作用.绑定到rootGCanvas实例或与GCanvas实例绑定工作正常.(这些替代方案对我来说都没有用,但我只是试着看看发生了什么.)运行OS X,El Capitan.

import Tkinter as tk

class GCanvas(tk.Canvas, object):

    def __init__(self, master, **kwargs):
        tk.Canvas.__init__(self, master, kwargs)

    @staticmethod
    def enter(e):
        print "enter", e.widget, e.x, e.y

    @staticmethod
    def leave(e):
        print "leave", e.widget

    @staticmethod
    def motion(e):
        print "motion", e.widget, e.x, e.y

approach = "bindinstance"

root = tk.Tk()
gc = GCanvas(root, width=400, height=300)
print "root is", root, "gc is", gc
gc.pack()

if approach == "bindGCanvas":
    print "binding to GCanvas"
    root.bind_class(GCanvas, '<Enter>', GCanvas.enter)
    root.bind_class(GCanvas, '<Leave>', GCanvas.leave)
    #root.bind_class(GCanvas, '<Motion>', GCanvas.motion)
elif approach …