"""
###############################################################################
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()

python guimixin 消息调用工具dialog封装

python guimixin 消息调用工具dialog封装

pick a "best" launcher for this platform

may need to specialize the choice elsewhere

if name == 'main': selftest()

python guimixin 消息调用 工具dialog封装

pick a "best" launcher for this platform

may need to specialize the choice elsewhere

if name == 'main': selftest()

python guimixin 消息调用工具dialog封装