python guimixin 消息调用 工具dialog封装

""" ############################################################################### a "mixin" class for other frames: common methods for canned dialogs, spawning programs, simple text viewers, etc; this class must be mixed with a Frame (or a subclass derived from Frame) for its quit method ############################################################################### """

from tkinter import * from tkinter.messagebox import * from tkinter.filedialog import * from scrolledtext import ScrolledText # or tkinter.scrolledtext from launchmodes import PortableLauncher, System # or use multiprocessing

class GuiMixin: def infobox(self, title, text, *args): # use standard dialogs return showinfo(title, text) # *args for bkwd compat

def errorbox(self, text):
    showerror('Error!', text)

def question(self, title, text, *args):
    return askyesno(title, text)  # return True or False

def notdone(self):
    showerror('Not implemented', 'Option not available')

def quit(self):
    ans = self.question('Verify quit', 'Are you sure you want to quit?')
    if ans:
        Frame.quit(self)  # quit not recursive!

def help(self):
    self.infobox('RTFM', 'See figure 1...')  # override this better

def selectOpenFile(self, file="", dir="."):  # use standard dialogs
    return askopenfilename(initialdir=dir, initialfile=file)

def selectSaveFile(self, file="", dir="."):
    return asksaveasfilename(initialfile=file, initialdir=dir)

def clone(self, args=()):  # optional constructor args
    new = Toplevel()  # make new in-process version of me
    myclass = self.__class__  # instance's (lowest) class object
    myclass(new, *args)  # attach/run instance to new window

def spawn(self, pycmdline, wait=False):
    if not wait:  # start new process
        PortableLauncher(pycmdline, pycmdline)()  # run Python progam
    else:
        System(pycmdline, pycmdline)()  # wait for it to exit

def browser(self, filename):
    new = Toplevel()  # make new window
    view = ScrolledText(new, file=filename)  # Text with Scrollbar
    view.text.config(height=30, width=85)  # config Text in Frame
    view.text.config(font=('courier', 10, 'normal'))  # use fixed-width font
    new.title("Text Viewer")  # set window mgr attrs
    new.iconname("browser")  # file text added auto

"""
def browser(self, filename):                         # if tkinter.scrolledtext
    new  = Toplevel()                                # included for reference
    text = ScrolledText(new, height=30, width=85)    
    text.config(font=('courier', 10, 'normal'))      
    text.pack(expand=YES, fill=BOTH)
    new.title("Text Viewer")                         
    new.iconname("browser")
    text.insert('0.0', open(filename, 'r').read() )  
"""

if name == 'main': class TestMixin(GuiMixin, Frame): # standalone test def init(self, parent=None): Frame.init(self, parent) self.pack() Button(self, text='quit', command=self.quit).pack(fill=X) Button(self, text='help', command=self.help).pack(fill=X) Button(self, text='clone', command=self.clone).pack(fill=X) Button(self, text='spawn', command=self.other).pack(fill=X)

    def other(self):
        self.spawn('guimixin.py')  # spawn self as separate process


TestMixin().mainloop()

//launchmodes.py """ ################################################################################### launch Python programs with command lines and reusable launcher scheme classes; auto inserts "python" and/or path to Python executable at front of command line; some of this module may assume 'python' is on your system path (see Launcher.py);

subprocess module would work too, but os.popen() uses it internally, and the goal is to start a program running independently here, not to connect to its streams; multiprocessing module also is an option, but this is command-lines, not functions: doesn't make sense to start a process which would just do one of the options here;

new in this edition: runs script filename path through normpath() to change any / to \ for Windows tools where required; fix is inherited by PyEdit and others; on Windows, / is generally allowed for file opens, but not by all launcher tools; ################################################################################### """

import sys, os pyfile = (sys.platform[:3] == 'win' and 'python.exe') or 'python' pypath = sys.executable # use sys in newer pys

def fixWindowsPath(cmdline): """ change all / to \ in script filename path at front of cmdline; used only by classes which run tools that require this on Windows; on other platforms, this does not hurt (e.g., os.system on Unix); """ splitline = cmdline.lstrip().split(' ') # split on spaces fixedpath = os.path.normpath(splitline[0]) # fix forward slashes return ' '.join([fixedpath] + splitline[1:]) # put it back together

class LaunchMode: """ on call to instance, announce label and run command; subclasses format command lines as required in run(); command should begin with name of the Python script file to run, and not with "python" or its full path; """ def init(self, label, command): self.what = label self.where = command def call(self): # on call, ex: button press callback self.announce(self.what) self.run(self.where) # subclasses must define run() def announce(self, text): # subclasses may redefine announce() print(text) # methods instead of if/elif logic def run(self, cmdline): assert False, 'run must be defined'

class System(LaunchMode): """ run Python script named in shell command line caveat: may block caller, unless & added on Unix """ def run(self, cmdline): cmdline = fixWindowsPath(cmdline) os.system('%s %s' % (pypath, cmdline))

class Popen(LaunchMode): """ run shell command line in a new process caveat: may block caller, since pipe closed too soon """ def run(self, cmdline): cmdline = fixWindowsPath(cmdline) os.popen(pypath + ' ' + cmdline) # assume nothing to be read

class Fork(LaunchMode): """ run command in explicitly created new process for Unix-like systems only, including cygwin """ def run(self, cmdline): assert hasattr(os, 'fork') cmdline = cmdline.split() # convert string to list if os.fork() == 0: # start new child process os.execvp(pypath, [pyfile] + cmdline) # run new program in child

class Start(LaunchMode): """ run command independent of caller for Windows only: uses filename associations """ def run(self, cmdline): assert sys.platform[:3] == 'win' cmdline = fixWindowsPath(cmdline) os.startfile(cmdline)

class StartArgs(LaunchMode): """ for Windows only: args may require real start forward slashes are okay here """ def run(self, cmdline): assert sys.platform[:3] == 'win' os.system('start ' + cmdline) # may create pop-up window

class Spawn(LaunchMode): """ run python in new process independent of caller for Windows or Unix; use P_NOWAIT for dos box; forward slashes are okay here """ def run(self, cmdline): os.spawnv(os.P_DETACH, pypath, (pyfile, cmdline))

class Top_level(LaunchMode): """ run in new window, same process tbd: requires GUI class info too """ def run(self, cmdline): assert False, 'Sorry - mode not yet implemented'

pick a "best" launcher for this platform

may need to specialize the choice elsewhere

if sys.platform[:3] == 'win': PortableLauncher = Spawn else: PortableLauncher = Fork

class QuietPortableLauncher(PortableLauncher): def announce(self, text): pass

def selftest(): file = 'echo.py' input('default mode...') launcher = PortableLauncher(file, file) launcher() # no block

input('system mode...')
System(file, file)()                                   # blocks

if sys.platform[:3] == 'win':
    input('DOS start mode...')                         # no block
    StartArgs(file, file)()

if name == 'main': selftest()

//scrolledtext.py "a simple text or file viewer component"

print('PP4E scrolledtext') from tkinter import *

class ScrolledText(Frame): def init(self, parent=None, text='', file=None): Frame.init(self, parent) self.pack(expand=YES, fill=BOTH) # make me expandable self.makewidgets() self.settext(text, file)

def makewidgets(self):
    sbar = Scrollbar(self)
    text = Text(self, relief=SUNKEN)
    sbar.config(command=text.yview)                  # xlink sbar and text
    text.config(yscrollcommand=sbar.set)             # move one moves other
    sbar.pack(side=RIGHT, fill=Y)                    # pack first=clip last
    text.pack(side=LEFT, expand=YES, fill=BOTH)      # text clipped first
    self.text = text

def settext(self, text='', file=None):
    if file:
        text = open(file, 'r').read()
    self.text.delete('1.0', END)                     # delete current text
    self.text.insert('1.0', text)                    # add at line 1, col 0
    self.text.mark_set(INSERT, '1.0')                # set insert cursor
    self.text.focus()                                # save user a click

def gettext(self):                                   # returns a string
    return self.text.get('1.0', END+'-1c')           # first through last

if name == 'main': root = Tk() if len(sys.argv) > 1: st = ScrolledText(file=sys.argv[1]) # filename on cmdline else: st = ScrolledText(text='Words\ngo here') # or not: two lines def show(event): print(repr(st.gettext())) # show as raw string root.bind('<Key-Escape>', show) # esc = dump text root.mainloop()