如何将文本小部件的一部分标记为只读?

问题描述

如何将tkinter文本小部件的一部分标记为只读?也就是说，我希望仅允许在窗口小部件的某些部分中进行编辑.例如，我想只允许在提示之后而不是之前进行编辑，以模拟控制台.

How can I mark a portion of a tkinter text widget as readonly? That is, I want to be able to allow editing only in certain parts of the widget. For example, I want to allow editing only after a prompt but not before, to simulate a console.

推荐答案

最安全的解决方案是拦截低级插入和删除命令，并根据其中的某些内容放置逻辑以防止插入和删除.标准.例如，您可以禁止在任何带有标签只读"的文本范围内进行编辑.

The most bullet-proof solution is to intercept the low-level insert and delete commands, and put logic in there to prevent insertions and deletions based on some sort of criteria. For example, you could disallow edits within any range of text that has the tag "readonly".

这是此技术的一个示例.它利用了以下事实:所有插入和删除操作最终都会调用基础tk窗口小部件命令的insert或delete子命令，并且可以使用Tcl proc替换窗口小部件命令.

Here's an example of this technique. It takes advantage of the fact that all insertions and deletions ultimately call the insert or delete subcommand of the underlying tk widget command, and the fact that the widget command can be replaced with a Tcl proc.

try:
    # python 2.x
    import Tkinter as tk
except ImportError:
    # python 3.x
    import tkinter as tk

class Example(tk.Frame):
    def __init__(self, parent):
        tk.Frame.__init__(self, parent)

        text = ReadonlyText(self)
        sb = tk.Scrollbar(self, orient="vertical", command=text.yview)
        text.configure(yscrollcommand=sb.set)
        sb.pack(side="left", fill="y")
        text.pack(side="right", fill="both", expand=True)

        text.insert("end", "You can edit this line\n")
        text.insert("end", "You cannot edit or delete this line\n", "readonly")
        text.insert("end", "You can edit this, too.")

        text.tag_configure("readonly", foreground="darkgray")

class ReadonlyText(tk.Text):
    '''A text widget that doesn't permit inserts and deletes in regions tagged with "readonly"'''
    def __init__(self, *args, **kwargs):
        tk.Text.__init__(self, *args, **kwargs)

        # this code creates a proxy that will intercept
        # each actual insert and delete.
        self.tk.eval(WIDGET_PROXY)

        # this code replaces the low level tk widget
        # with the proxy
        widget = str(self)
        self.tk.eval('''
            rename {widget} _{widget}
            interp alias {{}} ::{widget} {{}} widget_proxy _{widget}
        '''.format(widget=widget))

WIDGET_PROXY = '''
if {[llength [info commands widget_proxy]] == 0} {
    # Tcl code to implement a text widget proxy that disallows
    # insertions and deletions in regions marked with "readonly"
    proc widget_proxy {actual_widget args} {
        set command [lindex $args 0]
        set args [lrange $args 1 end]
        if {$command == "insert"} {
            set index [lindex $args 0]
            if [_is_readonly $actual_widget $index "$index+1c"] {
                bell
                return ""
            }
        }
        if {$command == "delete"} {
            foreach {index1 index2} $args {
                if {[_is_readonly $actual_widget $index1 $index2]} {
                    bell
                    return ""
                }
            }
        }
        # if we passed the previous checks, allow the command to
        # run normally
        $actual_widget $command {*}$args
    }

    proc _is_readonly {widget index1 index2} {
        # return true if any text in the range between
        # index1 and index2 has the tag "readonly"
        set result false
        if {$index2 eq ""} {set index2 "$index1+1c"}
        # see if "readonly" is applied to any character in the
        # range. There's probably a more efficient way to do this, but
        # this is Good Enough
        for {set index $index1} \
            {[$widget compare $index < $index2]} \
            {set index [$widget index "$index+1c"]} {
                if {"readonly" in [$widget tag names $index]} {
                    set result true
                    break
                }
            }
        return $result
    }
}
'''

def main():
    root = tk.Tk()
    Example(root).pack(fill="both", expand=True)
    root.mainloop()

if __name__ == "__main__":
    main()

这篇关于如何将文本小部件的一部分标记为只读?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！