Updated for Python 1.4
This commit is contained in:
parent
c30e95f4b0
commit
89cb67bb64
|
@ -24,12 +24,10 @@ class Option:
|
|||
self.master = dialog.top
|
||||
self.default, self.klass = dialog.options[option]
|
||||
self.var = self.varclass(self.master)
|
||||
self.frame = Frame(self.master,
|
||||
{Pack: {'expand': 0, 'fill': 'x'}})
|
||||
self.label = Label(self.frame,
|
||||
{'text': option + ':',
|
||||
Pack: {'side': 'left'},
|
||||
})
|
||||
self.frame = Frame(self.master)
|
||||
self.frame.pack(fill=X)
|
||||
self.label = Label(self.frame, text=(option + ":"))
|
||||
self.label.pack(side=LEFT)
|
||||
self.update()
|
||||
self.addoption()
|
||||
|
||||
|
@ -53,55 +51,48 @@ class BooleanOption(Option):
|
|||
|
||||
def addoption(self):
|
||||
self.button = Checkbutton(self.frame,
|
||||
{'text': 'on/off',
|
||||
'onvalue': '1',
|
||||
'offvalue': '0',
|
||||
'variable': self.var,
|
||||
'relief': 'raised',
|
||||
'borderwidth': 2,
|
||||
'command': self.set,
|
||||
Pack: {'side': 'right'},
|
||||
})
|
||||
text='on/off',
|
||||
onvalue=1,
|
||||
offvalue=0,
|
||||
variable=self.var,
|
||||
relief=RAISED,
|
||||
borderwidth=2,
|
||||
command=self.set)
|
||||
self.button.pack(side=RIGHT)
|
||||
|
||||
class EnumOption(Option):
|
||||
|
||||
def addoption(self):
|
||||
self.button = Menubutton(self.frame,
|
||||
{'textvariable': self.var,
|
||||
'relief': 'raised',
|
||||
'borderwidth': 2,
|
||||
Pack: {'side': 'right'},
|
||||
})
|
||||
textvariable=self.var,
|
||||
relief=RAISED, borderwidth=2)
|
||||
self.button.pack(side=RIGHT)
|
||||
self.menu = Menu(self.button)
|
||||
self.button['menu'] = self.menu
|
||||
for v in self.dialog.classes[self.klass]:
|
||||
self.menu.add_radiobutton(
|
||||
{'label': v,
|
||||
'variable': self.var,
|
||||
'value': v,
|
||||
'command': self.set,
|
||||
})
|
||||
label=v,
|
||||
variable=self.var,
|
||||
value=v,
|
||||
command=self.set)
|
||||
|
||||
class StringOption(Option):
|
||||
|
||||
def addoption(self):
|
||||
self.entry = Entry(self.frame,
|
||||
{'textvariable': self.var,
|
||||
'width': 10,
|
||||
'relief': 'sunken',
|
||||
'borderwidth': 2,
|
||||
Pack: {'side': 'right',
|
||||
'fill': 'x', 'expand': 1},
|
||||
})
|
||||
textvariable=self.var,
|
||||
width=10,
|
||||
relief=SUNKEN,
|
||||
borderwidth=2)
|
||||
self.entry.pack(side=RIGHT, fill=X, expand=1)
|
||||
self.entry.bind('<Return>', self.set)
|
||||
|
||||
class ReadonlyOption(Option):
|
||||
|
||||
def addoption(self):
|
||||
self.label = Label(self.frame,
|
||||
{'textvariable': self.var,
|
||||
'anchor': 'e',
|
||||
Pack: {'side': 'right'}})
|
||||
self.label = Label(self.frame, textvariable=self.var,
|
||||
anchor=E)
|
||||
self.label.pack(side=RIGHT)
|
||||
|
||||
class Dialog:
|
||||
|
||||
|
@ -156,7 +147,7 @@ class PackDialog(Dialog):
|
|||
Dialog.__init__(self, widget)
|
||||
|
||||
def refresh(self):
|
||||
self.current = self.widget.newinfo()
|
||||
self.current = self.widget.info()
|
||||
self.current['.class'] = self.widget.winfo_class()
|
||||
self.current['.name'] = self.widget._w
|
||||
|
||||
|
@ -164,8 +155,8 @@ class PackDialog(Dialog):
|
|||
def set(self, e=None):
|
||||
self.current = self.var.get()
|
||||
try:
|
||||
Pack.config(self.dialog.widget,
|
||||
{self.option: self.current})
|
||||
apply(self.dialog.widget.pack, (),
|
||||
{self.option: self.current})
|
||||
except TclError, msg:
|
||||
print msg
|
||||
self.refresh()
|
||||
|
@ -192,14 +183,14 @@ class PackDialog(Dialog):
|
|||
}
|
||||
|
||||
classes = {
|
||||
'Anchor': ('n','ne', 'e','se', 's','sw', 'w','nw', 'center'),
|
||||
'Anchor': (N, NE, E, SE, S, SW, W, NW, CENTER),
|
||||
'Boolean': 'boolean',
|
||||
'Class': 'readonly',
|
||||
'Expand': 'boolean',
|
||||
'Fill': ('none', 'x', 'y', 'both'),
|
||||
'Fill': (NONE, X, Y, BOTH),
|
||||
'Name': 'readonly',
|
||||
'Pad': 'pixel',
|
||||
'Side': ('top', 'right', 'bottom', 'left'),
|
||||
'Side': (TOP, RIGHT, BOTTOM, LEFT),
|
||||
'Widget': 'readonly',
|
||||
}
|
||||
|
||||
|
@ -220,7 +211,7 @@ class RemotePackDialog(PackDialog):
|
|||
words = self.master.tk.splitlist(
|
||||
self.master.send(self.app,
|
||||
'pack',
|
||||
'newinfo',
|
||||
'info',
|
||||
self.widget))
|
||||
except TclError, msg:
|
||||
print msg
|
||||
|
@ -306,7 +297,7 @@ class WidgetDialog(Dialog):
|
|||
|
||||
# Universal classes
|
||||
classes = {
|
||||
'Anchor': ('n','ne', 'e','se', 's','sw', 'w','nw', 'center'),
|
||||
'Anchor': (N, NE, E, SE, S, SW, W, NW, CENTER),
|
||||
'Aspect': 'integer',
|
||||
'Background': 'color',
|
||||
'Bitmap': 'bitmap',
|
||||
|
@ -325,16 +316,16 @@ class WidgetDialog(Dialog):
|
|||
'Geometry': 'geometry',
|
||||
'Height': 'pixel',
|
||||
'InsertWidth': 'time',
|
||||
'Justify': ('left', 'center', 'right'),
|
||||
'Justify': (LEFT, CENTER, RIGHT),
|
||||
'Label': 'string',
|
||||
'Length': 'pixel',
|
||||
'MenuName': 'widget',
|
||||
'Name': 'readonly',
|
||||
'OffTime': 'time',
|
||||
'OnTime': 'time',
|
||||
'Orient': ('horizontal', 'vertical'),
|
||||
'Orient': (HORIZONTAL, VERTICAL),
|
||||
'Pad': 'pixel',
|
||||
'Relief': ('raised', 'sunken', 'flat', 'ridge', 'groove'),
|
||||
'Relief': (RAISED, SUNKEN, FLAT, RIDGE, GROOVE),
|
||||
'RepeatDelay': 'time',
|
||||
'RepeatInterval': 'time',
|
||||
'ScrollCommand': 'command',
|
||||
|
@ -351,12 +342,12 @@ class WidgetDialog(Dialog):
|
|||
'Variable': 'variable',
|
||||
'Value': 'string',
|
||||
'Width': 'pixel',
|
||||
'Wrap': ('none', 'char', 'word'),
|
||||
'Wrap': (NONE, CHAR, WORD),
|
||||
}
|
||||
|
||||
# Classes that (may) differ per widget type
|
||||
_tristate = {'State': ('normal', 'active', 'disabled')}
|
||||
_bistate = {'State': ('normal', 'disabled')}
|
||||
_tristate = {'State': (NORMAL, ACTIVE, DISABLED)}
|
||||
_bistate = {'State': (NORMAL, DISABLED)}
|
||||
addclasses = {
|
||||
'Button': _tristate,
|
||||
'Radiobutton': _tristate,
|
||||
|
@ -424,14 +415,12 @@ def test():
|
|||
if sys.argv[1:]:
|
||||
remotetest(root, sys.argv[1])
|
||||
else:
|
||||
frame = Frame(root, {'name': 'frame',
|
||||
Pack: {'expand': 1, 'fill': 'both'},
|
||||
})
|
||||
button = Button(frame, {'name': 'button',
|
||||
'text': 'button',
|
||||
Pack: {'expand': 1}})
|
||||
canvas = Canvas(frame, {'name': 'canvas',
|
||||
Pack: {}})
|
||||
frame = Frame(root, name='frame')
|
||||
frame.pack(expand=1, fill=BOTH)
|
||||
button = Button(frame, name='button', text='button')
|
||||
button.pack(expand=1)
|
||||
canvas = Canvas(frame, name='canvas')
|
||||
canvas.pack()
|
||||
fpd = PackDialog(frame)
|
||||
fwd = WidgetDialog(frame)
|
||||
bpd = PackDialog(button)
|
||||
|
|
|
@ -20,14 +20,14 @@ ulprog = regex.compile('^[ \t]*[Xv!_][Xv!_ \t]*\n')
|
|||
class EditableManPage(ScrolledText):
|
||||
|
||||
# Initialize instance
|
||||
def __init__(self, master=None, cnf={}):
|
||||
def __init__(self, master=None, **cnf):
|
||||
# Initialize base class
|
||||
ScrolledText.__init__(self, master, cnf)
|
||||
apply(ScrolledText.__init__, (self, master), cnf)
|
||||
|
||||
# Define tags for formatting styles
|
||||
self.tag_config('X', {'underline': 1})
|
||||
self.tag_config('!', {'font': BOLDFONT})
|
||||
self.tag_config('_', {'font': ITALICFONT})
|
||||
self.tag_config('X', underline=1)
|
||||
self.tag_config('!', font=BOLDFONT)
|
||||
self.tag_config('_', font=ITALICFONT)
|
||||
|
||||
# Set state to idle
|
||||
self.fp = None
|
||||
|
@ -83,8 +83,8 @@ class EditableManPage(ScrolledText):
|
|||
self.empty = 0
|
||||
self.buffer = None
|
||||
savestate = self['state']
|
||||
self['state'] = 'normal'
|
||||
self.delete('1.0', 'end')
|
||||
self['state'] = NORMAL
|
||||
self.delete('1.0', END)
|
||||
self['state'] = savestate
|
||||
|
||||
# End parsing -- must be busy, need not be at EOF
|
||||
|
@ -133,11 +133,11 @@ class EditableManPage(ScrolledText):
|
|||
self.empty = 0
|
||||
return
|
||||
savestate = self['state']
|
||||
self['state'] = 'normal'
|
||||
self['state'] = NORMAL
|
||||
if TkVersion >= 4.0:
|
||||
self.mark_set('insert', 'end-1c')
|
||||
else:
|
||||
self.mark_set('insert', 'end')
|
||||
self.mark_set('insert', END)
|
||||
if self.empty:
|
||||
# One or more previous lines were empty
|
||||
# -- insert one blank line in the text
|
||||
|
@ -176,9 +176,9 @@ class EditableManPage(ScrolledText):
|
|||
class ReadonlyManPage(EditableManPage):
|
||||
|
||||
# Initialize instance
|
||||
def __init__(self, master=None, cnf={}):
|
||||
EditableManPage.__init__(self, master,
|
||||
(cnf, {'state': 'disabled'}))
|
||||
def __init__(self, master=None, **cnf):
|
||||
cnf['state'] = DISABLED
|
||||
apply(EditableManPage.__init__, (self, master), cnf)
|
||||
|
||||
# Alias
|
||||
ManPage = ReadonlyManPage
|
||||
|
@ -206,8 +206,8 @@ def test():
|
|||
name = os.path.join(MANDIR, name)
|
||||
root = Tk()
|
||||
root.minsize(1, 1)
|
||||
manpage = ManPage(root, {'relief': 'sunken', 'bd': 2,
|
||||
Pack: {'expand': 1, 'fill': 'both'}})
|
||||
manpage = ManPage(root, relief=SUNKEN, borderwidth=2)
|
||||
manpage.pack(expand=1, fill=BOTH)
|
||||
if formatted:
|
||||
fp = open(name, 'r')
|
||||
else:
|
||||
|
|
|
@ -6,19 +6,12 @@ from ScrolledText import ScrolledText
|
|||
from Dialog import Dialog
|
||||
import signal
|
||||
|
||||
TK_READABLE = 1
|
||||
TK_WRITABLE = 2
|
||||
TK_EXCEPTION = 4
|
||||
|
||||
BUFSIZE = 512
|
||||
|
||||
class ShellWindow(ScrolledText):
|
||||
|
||||
def __init__(self, master = None, cnf = {}):
|
||||
try:
|
||||
shell = cnf['shell']
|
||||
del cnf['shell']
|
||||
except KeyError:
|
||||
def __init__(self, master=None, shell=None, **cnf):
|
||||
if not shell:
|
||||
try:
|
||||
shell = os.environ['SHELL']
|
||||
except KeyError:
|
||||
|
@ -27,7 +20,7 @@ class ShellWindow(ScrolledText):
|
|||
args = string.split(shell)
|
||||
shell = args[0]
|
||||
|
||||
ScrolledText.__init__(self, master, cnf)
|
||||
apply(ScrolledText.__init__, (self, master), cnf)
|
||||
self.pos = '1.0'
|
||||
self.bind('<Return>', self.inputhandler)
|
||||
self.bind('<Control-c>', self.sigint)
|
||||
|
@ -36,7 +29,7 @@ class ShellWindow(ScrolledText):
|
|||
self.bind('<Control-d>', self.sendeof)
|
||||
|
||||
self.pid, self.fromchild, self.tochild = spawn(shell, args)
|
||||
self.tk.createfilehandler(self.fromchild, TK_READABLE,
|
||||
self.tk.createfilehandler(self.fromchild, READABLE,
|
||||
self.outputhandler)
|
||||
|
||||
def outputhandler(self, file, mask):
|
||||
|
@ -54,68 +47,60 @@ class ShellWindow(ScrolledText):
|
|||
msg = "killed by signal %d" % (cause & 0x7f)
|
||||
if cause & 0x80:
|
||||
msg = msg + " -- core dumped"
|
||||
Dialog(self.master, {
|
||||
'text': msg,
|
||||
'title': "Exit status",
|
||||
'bitmap': 'warning',
|
||||
'default': 0,
|
||||
'strings': ('OK',),
|
||||
})
|
||||
Dialog(self.master,
|
||||
text=msg,
|
||||
title="Exit status",
|
||||
bitmap='warning',
|
||||
default=0,
|
||||
strings=('OK',))
|
||||
return
|
||||
self.insert('end', data)
|
||||
self.pos = self.index('end')
|
||||
self.yview_pickplace('end')
|
||||
self.insert(END, data)
|
||||
self.pos = self.index("end - 1 char")
|
||||
self.yview_pickplace(END)
|
||||
|
||||
def inputhandler(self, *args):
|
||||
if not self.pid:
|
||||
Dialog(self.master, {
|
||||
'text': "No active process",
|
||||
'title': "No process",
|
||||
'bitmap': 'error',
|
||||
'default': 0,
|
||||
'strings': ('OK',),
|
||||
})
|
||||
return
|
||||
self.insert('end', '\n')
|
||||
line = self.get(self.pos, 'end')
|
||||
self.pos = self.index('end')
|
||||
self.no_process()
|
||||
return "break"
|
||||
self.insert(END, "\n")
|
||||
line = self.get(self.pos, "end - 1 char")
|
||||
self.pos = self.index(END)
|
||||
os.write(self.tochild, line)
|
||||
return "break"
|
||||
|
||||
def sendeof(self, *args):
|
||||
if not self.pid:
|
||||
Dialog(self.master, {
|
||||
'text': "No active process",
|
||||
'title': "No process",
|
||||
'bitmap': 'error',
|
||||
'default': 0,
|
||||
'strings': ('OK',),
|
||||
})
|
||||
return
|
||||
self.no_process()
|
||||
return "break"
|
||||
os.close(self.tochild)
|
||||
return "break"
|
||||
|
||||
def sendsig(self, sig):
|
||||
if not self.pid:
|
||||
Dialog(self.master, {
|
||||
'text': "No active process",
|
||||
'title': "No process",
|
||||
'bitmap': 'error',
|
||||
'default': 0,
|
||||
'strings': ('OK',),
|
||||
})
|
||||
return
|
||||
self.no_process()
|
||||
return "break"
|
||||
os.kill(self.pid, sig)
|
||||
return "break"
|
||||
|
||||
def sigint(self, *args):
|
||||
self.sendsig(signal.SIGINT)
|
||||
return self.sendsig(signal.SIGINT)
|
||||
|
||||
def sigquit(self, *args):
|
||||
self.sendsig(signal.SIGQUIT)
|
||||
return self.sendsig(signal.SIGQUIT)
|
||||
|
||||
def sigterm(self, *args):
|
||||
self.sendsig(signal.SIGTERM)
|
||||
return self.sendsig(signal.SIGTERM)
|
||||
|
||||
def sigkill(self, *args):
|
||||
self.sendsig(signal.SIGKILL)
|
||||
return self.sendsig(signal.SIGKILL)
|
||||
|
||||
def no_process(self):
|
||||
Dialog(self.master,
|
||||
text="No active process",
|
||||
title="No process",
|
||||
bitmap='error',
|
||||
default=0,
|
||||
strings=('OK',))
|
||||
|
||||
MAXFD = 100 # Max number of file descriptors (os.getdtablesize()???)
|
||||
|
||||
|
@ -142,7 +127,7 @@ def spawn(prog, args):
|
|||
try:
|
||||
os.execvp(prog, args)
|
||||
finally:
|
||||
print 'execvp failed'
|
||||
sys.stderr.write('execvp failed\n')
|
||||
os._exit(1)
|
||||
os.close(p2cread)
|
||||
os.close(c2pwrite)
|
||||
|
@ -150,13 +135,13 @@ def spawn(prog, args):
|
|||
|
||||
def test():
|
||||
shell = string.join(sys.argv[1:])
|
||||
cnf = {}
|
||||
if shell:
|
||||
cnf['shell'] = shell
|
||||
root = Tk()
|
||||
root.minsize(1, 1)
|
||||
w = ShellWindow(root, cnf)
|
||||
w.pack({'expand': 1, 'fill': 'both'})
|
||||
if shell:
|
||||
w = ShellWindow(root, shell=shell)
|
||||
else:
|
||||
w = ShellWindow(root)
|
||||
w.pack(expand=1, fill=BOTH)
|
||||
w.focus_set()
|
||||
w.tk.mainloop()
|
||||
|
||||
|
|
|
@ -5,55 +5,49 @@
|
|||
# Cf. Ousterhout, Tcl and the Tk Toolkit, Figs. 27.2-3, pp. 269-270.
|
||||
|
||||
from Tkinter import *
|
||||
import sys
|
||||
|
||||
|
||||
def dialog(master, title, text, bitmap, default, *args):
|
||||
|
||||
# 1. Create the top-level window and divide it into top
|
||||
# and bottom parts.
|
||||
|
||||
w = Toplevel(master, {'class': 'Dialog'})
|
||||
w = Toplevel(master, class_='Dialog')
|
||||
w.title(title)
|
||||
w.iconname('Dialog')
|
||||
|
||||
top = Frame(w, {'relief': 'raised', 'bd': 1,
|
||||
Pack: {'side': 'top', 'fill': 'both'}})
|
||||
bot = Frame(w, {'relief': 'raised', 'bd': 1,
|
||||
Pack: {'side': 'bottom', 'fill': 'both'}})
|
||||
top = Frame(w, relief=RAISED, borderwidth=1)
|
||||
top.pack(side=TOP, fill=BOTH)
|
||||
bot = Frame(w, relief=RAISED, borderwidth=1)
|
||||
bot.pack(side=BOTTOM, fill=BOTH)
|
||||
|
||||
# 2. Fill the top part with the bitmap and message.
|
||||
|
||||
msg = Message(top,
|
||||
{'width': '3i',
|
||||
'text': text,
|
||||
'font': '-Adobe-Times-Medium-R-Normal-*-180-*',
|
||||
Pack: {'side': 'right', 'expand': 1,
|
||||
'fill': 'both',
|
||||
'padx': '3m', 'pady': '3m'}})
|
||||
msg = Message(top, width='3i', text=text,
|
||||
font='-Adobe-Times-Medium-R-Normal-*-180-*')
|
||||
msg.pack(side=RIGHT, expand=1, fill=BOTH, padx='3m', pady='3m')
|
||||
if bitmap:
|
||||
bm = Label(top, {'bitmap': bitmap,
|
||||
Pack: {'side': 'left',
|
||||
'padx': '3m', 'pady': '3m'}})
|
||||
bm = Label(top, bitmap=bitmap)
|
||||
bm.pack(side=LEFT, padx='3m', pady='3m')
|
||||
|
||||
# 3. Create a row of buttons at the bottom of the dialog.
|
||||
|
||||
var = IntVar()
|
||||
buttons = []
|
||||
i = 0
|
||||
for but in args:
|
||||
b = Button(bot, {'text': but,
|
||||
'command': ('set', 'button', i)})
|
||||
b = Button(bot, text=but, command=lambda v=var,i=i: v.set(i))
|
||||
buttons.append(b)
|
||||
if i == default:
|
||||
bd = Frame(bot, {'relief': 'sunken', 'bd': 1,
|
||||
Pack: {'side': 'left', 'expand': 1,
|
||||
'padx': '3m', 'pady': '2m'}})
|
||||
bd = Frame(bot, relief=SUNKEN, borderwidth=1)
|
||||
bd.pack(side=LEFT, expand=1, padx='3m', pady='2m')
|
||||
b.lift()
|
||||
b.pack ({'in': bd, 'side': 'left',
|
||||
'padx': '2m', 'pady': '2m',
|
||||
'ipadx': '2m', 'ipady': '1m'})
|
||||
b.pack (in_=bd, side=LEFT,
|
||||
padx='2m', pady='2m', ipadx='2m', ipady='1m')
|
||||
else:
|
||||
b.pack ({'side': 'left', 'expand': 1,
|
||||
'padx': '3m', 'pady': '3m',
|
||||
'ipady': '2m', 'ipady': '1m'})
|
||||
b.pack (side=LEFT, expand=1,
|
||||
padx='3m', pady='3m', ipady='2m', ipady='1m')
|
||||
i = i+1
|
||||
|
||||
# 4. Set up a binding for <Return>, if there's a default,
|
||||
|
@ -61,21 +55,21 @@ def dialog(master, title, text, bitmap, default, *args):
|
|||
|
||||
if default >= 0:
|
||||
w.bind('<Return>',
|
||||
lambda e, b=buttons[default], i=default:
|
||||
lambda e, b=buttons[default], v=var, i=default:
|
||||
(b.flash(),
|
||||
b.setvar('button', i)))
|
||||
v.set(i)))
|
||||
|
||||
oldFocus = w.tk.call('focus') # XXX
|
||||
oldFocus = w.focus_get()
|
||||
w.grab_set()
|
||||
w.focus()
|
||||
w.focus_set()
|
||||
|
||||
# 5. Wait for the user to respond, then restore the focus
|
||||
# and return the index of the selected button.
|
||||
|
||||
w.waitvar('button')
|
||||
w.waitvar(var)
|
||||
w.destroy()
|
||||
w.tk.call('focus', oldFocus) # XXX
|
||||
return w.getint(w.getvar('button'))
|
||||
if oldFocus: oldFocus.focus_set()
|
||||
return var.get()
|
||||
|
||||
# The rest is the test program.
|
||||
|
||||
|
@ -105,13 +99,10 @@ def test():
|
|||
global mainWidget
|
||||
mainWidget = Frame()
|
||||
Pack.config(mainWidget)
|
||||
start = Button(mainWidget,
|
||||
{'text': 'Press Here To Start', 'command': go})
|
||||
start = Button(mainWidget, text='Press Here To Start', command=go)
|
||||
start.pack()
|
||||
endit = Button(mainWidget,
|
||||
{'text': 'Exit',
|
||||
'command': 'exit',
|
||||
Pack: {'fill' : 'both'}})
|
||||
endit = Button(mainWidget, text="Exit", command=sys.exit)
|
||||
endit.pack(fill=BOTH)
|
||||
mainWidget.mainloop()
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
|
|
@ -15,7 +15,6 @@
|
|||
from Tkinter import *
|
||||
|
||||
|
||||
|
||||
# The graphical interface
|
||||
class Electrons:
|
||||
|
||||
|
@ -30,14 +29,13 @@ class Electrons:
|
|||
# Add background bitmap
|
||||
if bitmap:
|
||||
self.bitmap = c.create_bitmap(width/2, height/2,
|
||||
{'bitmap': bitmap,
|
||||
'foreground': 'blue'})
|
||||
bitmap=bitmap,
|
||||
foreground='blue')
|
||||
|
||||
self.pieces = {}
|
||||
x1, y1, x2, y2 = 10,70,14,74
|
||||
for i in range(n,0,-1):
|
||||
p = c.create_oval(x1, y1, x2, y2,
|
||||
{'fill': 'red'})
|
||||
p = c.create_oval(x1, y1, x2, y2, fill='red')
|
||||
self.pieces[i] = p
|
||||
y1, y2 = y1 +2, y2 + 2
|
||||
self.tk.update()
|
||||
|
@ -51,11 +49,12 @@ class Electrons:
|
|||
y = rand.choice(range(-3,4))
|
||||
c.move(p, x, y)
|
||||
self.tk.update()
|
||||
|
||||
# Run -- never returns
|
||||
def run(self):
|
||||
while 1:
|
||||
self.random_move(self.n)
|
||||
self.tk.mainloop() # Hang around...
|
||||
|
||||
|
||||
# Main program
|
||||
def main():
|
||||
|
|
|
@ -36,8 +36,8 @@ class Tkhanoi:
|
|||
# Add background bitmap
|
||||
if bitmap:
|
||||
self.bitmap = c.create_bitmap(width/2, height/2,
|
||||
{'bitmap': bitmap,
|
||||
'foreground': 'blue'})
|
||||
bitmap=bitmap,
|
||||
foreground='blue')
|
||||
|
||||
# Generate pegs
|
||||
pegwidth = 10
|
||||
|
@ -46,13 +46,13 @@ class Tkhanoi:
|
|||
x1, y1 = (pegdist-pegwidth)/2, height*1/3
|
||||
x2, y2 = x1+pegwidth, y1+pegheight
|
||||
self.pegs = []
|
||||
p = c.create_rectangle(x1, y1, x2, y2, {'fill': 'black'})
|
||||
p = c.create_rectangle(x1, y1, x2, y2, fill='black')
|
||||
self.pegs.append(p)
|
||||
x1, x2 = x1+pegdist, x2+pegdist
|
||||
p = c.create_rectangle(x1, y1, x2, y2, {'fill': 'black'})
|
||||
p = c.create_rectangle(x1, y1, x2, y2, fill='black')
|
||||
self.pegs.append(p)
|
||||
x1, x2 = x1+pegdist, x2+pegdist
|
||||
p = c.create_rectangle(x1, y1, x2, y2, {'fill': 'black'})
|
||||
p = c.create_rectangle(x1, y1, x2, y2, fill='black')
|
||||
self.pegs.append(p)
|
||||
self.tk.update()
|
||||
|
||||
|
@ -66,8 +66,7 @@ class Tkhanoi:
|
|||
x2, y2 = x1+maxpiecewidth, y1+pieceheight
|
||||
dx = (maxpiecewidth-minpiecewidth) / (2*max(1, n-1))
|
||||
for i in range(n, 0, -1):
|
||||
p = c.create_rectangle(x1, y1, x2, y2,
|
||||
{'fill': 'red'})
|
||||
p = c.create_rectangle(x1, y1, x2, y2, fill='red')
|
||||
self.pieces[i] = p
|
||||
self.pegstate[0].append(i)
|
||||
x1, x2 = x1 + dx, x2-dx
|
||||
|
|
|
@ -5,14 +5,14 @@ from Tkinter import *
|
|||
from string import splitfields
|
||||
from string import split
|
||||
import commands
|
||||
import posix
|
||||
import os
|
||||
|
||||
class BarButton(Menubutton):
|
||||
_CNF = {Pack: {'side': 'left'}}
|
||||
def __init__(self, master=None, cnf={}):
|
||||
Menubutton.__init__(self, master, (self._CNF, cnf))
|
||||
self.menu = Menu(self, {'name': 'menu'})
|
||||
self['menu'] = self.menu
|
||||
def __init__(self, master=None, **cnf):
|
||||
apply(Menubutton.__init__, (self, master), cnf)
|
||||
self.pack(side=LEFT)
|
||||
self.menu = Menu(self, name='menu')
|
||||
self['menu'] = self.menu
|
||||
|
||||
class Kill(Frame):
|
||||
# List of (name, option, pid_column)
|
||||
|
@ -27,7 +27,7 @@ class Kill(Frame):
|
|||
def kill(self, selected):
|
||||
c = self.format_list[self.format.get()][2]
|
||||
pid = split(selected)[c]
|
||||
posix.system('kill' + ' -9 ' + pid)
|
||||
os.system('kill -9 ' + pid)
|
||||
self.do_update()
|
||||
def do_update(self):
|
||||
name, option, column = self.format_list[self.format.get()]
|
||||
|
@ -35,85 +35,64 @@ class Kill(Frame):
|
|||
list = splitfields(s, '\n')
|
||||
self.header.set(list[0])
|
||||
del list[0]
|
||||
y = self.frame.vscroll.get()[2]
|
||||
y = self.frame.vscroll.get()[0]
|
||||
self.frame.list.delete(0, AtEnd())
|
||||
for line in list:
|
||||
self.frame.list.insert(0, line)
|
||||
self.frame.list.yview(y)
|
||||
self.frame.list.yview(int(y))
|
||||
def do_motion(self, e):
|
||||
e.widget.select_from(e.widget.nearest(e.y))
|
||||
e.widget.select_clear(0, END)
|
||||
e.widget.select_set(e.widget.nearest(e.y))
|
||||
def do_leave(self, e):
|
||||
e.widget.select_clear()
|
||||
e.widget.select_clear(0, END)
|
||||
def do_1(self, e):
|
||||
self.kill(e.widget.get(e.widget.nearest(e.y)))
|
||||
def __init__(self, master=None, cnf={}):
|
||||
def __init__(self, master=None, **cnf):
|
||||
Frame.__init__(self, master, cnf)
|
||||
self.pack({'expand': 'yes', 'fill': 'both'})
|
||||
self.bar = Frame(
|
||||
self,
|
||||
{'name': 'bar',
|
||||
'relief': 'raised',
|
||||
'bd': 2,
|
||||
Pack: {'side': 'top',
|
||||
'fill': 'x'}})
|
||||
self.bar.file = BarButton(self.bar, {'text': 'File'})
|
||||
self.pack(expand=1, fill=BOTH)
|
||||
self.bar = Frame(self, name='bar', relief=RAISED,
|
||||
borderwidth=2)
|
||||
self.bar.pack(fill=X)
|
||||
self.bar.file = BarButton(self.bar, text='File')
|
||||
self.bar.file.menu.add_command(
|
||||
{'label': 'Quit', 'command': self.quit})
|
||||
self.bar.view = BarButton(self.bar, {'text': 'View'})
|
||||
label='Quit', command=self.quit)
|
||||
self.bar.view = BarButton(self.bar, text='View')
|
||||
self.format = IntVar(self)
|
||||
self.format.set(2)
|
||||
for num in range(len(self.format_list)):
|
||||
self.bar.view.menu.add_radiobutton(
|
||||
{'label': self.format_list[num][0],
|
||||
'command': self.do_update,
|
||||
'variable': self.format,
|
||||
'value': num})
|
||||
label=self.format_list[num][0],
|
||||
command=self.do_update,
|
||||
variable=self.format,
|
||||
value=num)
|
||||
#self.bar.view.menu.add_separator()
|
||||
#XXX ...
|
||||
self.bar.tk_menuBar(self.bar.file, self.bar.view)
|
||||
self.frame = Frame(
|
||||
self,
|
||||
{'relief': 'raised', 'bd': 2,
|
||||
Pack: {'side': 'top',
|
||||
'expand': 'yes',
|
||||
'fill': 'both'}})
|
||||
self.frame = Frame(self, relief=RAISED, borderwidth=2)
|
||||
self.frame.pack(expand=1, fill=BOTH)
|
||||
self.header = StringVar(self)
|
||||
self.frame.label = Label(
|
||||
self.frame,
|
||||
{'relief': 'flat',
|
||||
'anchor': 'nw',
|
||||
'borderwidth': 0,
|
||||
'textvariable': self.header,
|
||||
Pack: {'side': 'top',
|
||||
'fill': 'x'}})
|
||||
self.frame.vscroll = Scrollbar(
|
||||
self.frame,
|
||||
{'orient': 'vertical'})
|
||||
self.frame.list = Listbox(
|
||||
self.frame,
|
||||
{'relief': 'sunken',
|
||||
'selectbackground': '#eed5b7',
|
||||
'selectborderwidth': 0,
|
||||
'yscroll': self.frame.vscroll.set})
|
||||
self.frame.label = Label(self.frame, relief=FLAT, anchor=NW,
|
||||
borderwidth=0,
|
||||
textvariable=self.header)
|
||||
self.frame.label.pack(fill=X)
|
||||
self.frame.vscroll = Scrollbar(self.frame, orient=VERTICAL)
|
||||
self.frame.list = Listbox(self.frame, relief=SUNKEN,
|
||||
selectbackground='#eed5b7',
|
||||
selectborderwidth=0,
|
||||
yscroll=self.frame.vscroll.set)
|
||||
self.frame.vscroll['command'] = self.frame.list.yview
|
||||
self.frame.vscroll.pack({'side': 'right', 'fill': 'y'})
|
||||
self.frame.list.pack(
|
||||
{'side': 'top',
|
||||
'expand': 'yes',
|
||||
'fill': 'both'})
|
||||
self.update = Button(
|
||||
self,
|
||||
{'text': 'Update',
|
||||
'command': self.do_update,
|
||||
Pack: {'expand': 'yes',
|
||||
'fill': 'x'}})
|
||||
self.frame.vscroll.pack(side=RIGHT, fill=Y)
|
||||
self.frame.list.pack(expand=1, fill=BOTH)
|
||||
self.update = Button(self, text="Update",
|
||||
command=self.do_update)
|
||||
self.update.pack(expand=1, fill=X)
|
||||
self.frame.list.bind('<Motion>', self.do_motion)
|
||||
self.frame.list.bind('<Leave>', self.do_leave)
|
||||
self.frame.list.bind('<1>', self.do_1)
|
||||
self.do_update()
|
||||
|
||||
if __name__ == '__main__':
|
||||
kill = Kill(None, {'bd': 5})
|
||||
kill = Kill(None, borderwidth=5)
|
||||
kill.winfo_toplevel().title('Tkinter Process Killer')
|
||||
kill.winfo_toplevel().minsize(1, 1)
|
||||
kill.mainloop()
|
||||
|
|
|
@ -6,16 +6,16 @@ import string
|
|||
from Tkinter import *
|
||||
|
||||
def listtree(master, app):
|
||||
list = Listbox(master, {'name': 'list',
|
||||
Pack: {'expand': 1, 'fill': 'both'}})
|
||||
list = Listbox(master, name='list')
|
||||
list.pack(expand=1, fill=BOTH)
|
||||
listnodes(list, app, '.', 0)
|
||||
return list
|
||||
|
||||
def listnodes(list, app, widget, level):
|
||||
klass = list.send(app, 'winfo', 'class', widget)
|
||||
## i = string.rindex(widget, '.')
|
||||
## list.insert('end', '%s%s (%s)' % ((level-1)*'. ', widget[i:], klass))
|
||||
list.insert('end', '%s (%s)' % (widget, klass))
|
||||
## list.insert(END, '%s%s (%s)' % ((level-1)*'. ', widget[i:], klass))
|
||||
list.insert(END, '%s (%s)' % (widget, klass))
|
||||
children = list.tk.splitlist(
|
||||
list.send(app, 'winfo', 'children', widget))
|
||||
for c in children:
|
||||
|
@ -28,7 +28,8 @@ def main():
|
|||
app = sys.argv[1]
|
||||
tk = Tk()
|
||||
tk.minsize(1, 1)
|
||||
f = Frame(tk, {'name': 'f', Pack: {'expand': 1, 'fill': 'both'}})
|
||||
f = Frame(tk, name='f')
|
||||
f.pack(expand=1, fill=BOTH)
|
||||
list = listtree(f, app)
|
||||
tk.mainloop()
|
||||
|
||||
|
|
|
@ -15,10 +15,10 @@ import os
|
|||
user = os.environ['LOGNAME']
|
||||
|
||||
class BarButton(Menubutton):
|
||||
def __init__(self, master=None, cnf={}):
|
||||
Menubutton.__init__(self, master, cnf)
|
||||
self.pack(side='left')
|
||||
self.menu = Menu(self, {'name': 'menu'})
|
||||
def __init__(self, master=None, **cnf):
|
||||
apply(Menubutton.__init__, (self, master), cnf)
|
||||
self.pack(side=LEFT)
|
||||
self.menu = Menu(self, name='menu')
|
||||
self['menu'] = self.menu
|
||||
|
||||
class Kill(Frame):
|
||||
|
@ -41,7 +41,7 @@ class Kill(Frame):
|
|||
def kill(self, selected):
|
||||
c = self.format_list[self.format.get()][2]
|
||||
pid = split(selected)[c]
|
||||
os.system('kill' + ' -9 ' + pid)
|
||||
os.system('kill -9 ' + pid)
|
||||
self.do_update()
|
||||
def do_update(self):
|
||||
format = self.format_list[self.format.get()][1]
|
||||
|
@ -60,21 +60,17 @@ class Kill(Frame):
|
|||
e.widget.select_clear('0', 'end')
|
||||
def do_1(self, e):
|
||||
self.kill(e.widget.get(e.widget.nearest(e.y)))
|
||||
def __init__(self, master=None, cnf={}):
|
||||
Frame.__init__(self, master, cnf)
|
||||
self.pack({'expand': 'yes', 'fill': 'both'})
|
||||
self.bar = Frame(
|
||||
self,
|
||||
{'name': 'bar',
|
||||
'relief': 'raised',
|
||||
'bd': 2,
|
||||
Pack: {'side': 'top',
|
||||
'fill': 'x'}})
|
||||
self.bar.file = BarButton(self.bar, {'text': 'File'})
|
||||
def __init__(self, master=None, **cnf):
|
||||
apply(Frame.__init__, (self, master), cnf)
|
||||
self.pack(expand=1, fill=BOTH)
|
||||
self.bar = Frame(self, name='bar', relief=RAISED,
|
||||
borderwidth=2)
|
||||
self.bar.pack(fill=X)
|
||||
self.bar.file = BarButton(self.bar, text='File')
|
||||
self.bar.file.menu.add_command(
|
||||
{'label': 'Quit', 'command': self.quit})
|
||||
self.bar.view = BarButton(self.bar, {'text': 'View'})
|
||||
self.bar.format = BarButton(self.bar, {'text': 'Format'})
|
||||
label='Quit', command=self.quit)
|
||||
self.bar.view = BarButton(self.bar, text='View')
|
||||
self.bar.format = BarButton(self.bar, text='Format')
|
||||
self.view = IntVar(self)
|
||||
self.view.set(0)
|
||||
self.format = IntVar(self)
|
||||
|
@ -82,68 +78,51 @@ class Kill(Frame):
|
|||
for num in range(len(self.view_list)):
|
||||
label, option = self.view_list[num]
|
||||
self.bar.view.menu.add_radiobutton(
|
||||
{'label': label,
|
||||
'command': self.do_update,
|
||||
'variable': self.view,
|
||||
'value': num})
|
||||
label=label,
|
||||
command=self.do_update,
|
||||
variable=self.view,
|
||||
value=num)
|
||||
for num in range(len(self.format_list)):
|
||||
label, option, col = self.format_list[num]
|
||||
self.bar.format.menu.add_radiobutton(
|
||||
{'label': label,
|
||||
'command': self.do_update,
|
||||
'variable': self.format,
|
||||
'value': num})
|
||||
label=label,
|
||||
command=self.do_update,
|
||||
variable=self.format,
|
||||
value=num)
|
||||
self.bar.tk_menuBar(self.bar.file,
|
||||
self.bar.view,
|
||||
self.bar.format)
|
||||
self.frame = Frame(
|
||||
self,
|
||||
{'relief': 'raised', 'bd': 2,
|
||||
Pack: {'side': 'top',
|
||||
'expand': 'yes',
|
||||
'fill': 'both'}})
|
||||
self.frame = Frame(self, relief=RAISED, borderwidth=2)
|
||||
self.frame.pack(expand=1, fill=BOTH)
|
||||
self.header = StringVar(self)
|
||||
self.frame.label = Label(
|
||||
self.frame,
|
||||
{'relief': 'flat',
|
||||
'anchor': 'nw',
|
||||
'borderwidth': 0,
|
||||
'font': '*-Courier-Bold-R-Normal-*-120-*',
|
||||
'textvariable': self.header,
|
||||
Pack: {'side': 'top',
|
||||
'fill': 'y',
|
||||
'anchor': 'w'}})
|
||||
self.frame.vscroll = Scrollbar(
|
||||
self.frame,
|
||||
{'orient': 'vertical'})
|
||||
self.frame, relief=FLAT, anchor=NW, borderwidth=0,
|
||||
font='*-Courier-Bold-R-Normal-*-120-*',
|
||||
textvariable=self.header)
|
||||
self.frame.label.pack(fill=Y, anchor=W)
|
||||
self.frame.vscroll = Scrollbar(self.frame, orient=VERTICAL)
|
||||
self.frame.list = Listbox(
|
||||
self.frame,
|
||||
{'relief': 'sunken',
|
||||
'font': '*-Courier-Medium-R-Normal-*-120-*',
|
||||
'width': 40, 'height': 10,
|
||||
'selectbackground': '#eed5b7',
|
||||
'selectborderwidth': 0,
|
||||
'selectmode': 'browse',
|
||||
'yscroll': self.frame.vscroll.set})
|
||||
relief=SUNKEN,
|
||||
font='*-Courier-Medium-R-Normal-*-120-*',
|
||||
width=40, height=10,
|
||||
selectbackground='#eed5b7',
|
||||
selectborderwidth=0,
|
||||
selectmode=BROWSE,
|
||||
yscroll=self.frame.vscroll.set)
|
||||
self.frame.vscroll['command'] = self.frame.list.yview
|
||||
self.frame.vscroll.pack({'side': 'right', 'fill': 'y'})
|
||||
self.frame.list.pack(
|
||||
{'side': 'top',
|
||||
'expand': 'yes',
|
||||
'fill': 'both'})
|
||||
self.update = Button(
|
||||
self,
|
||||
{'text': 'Update',
|
||||
'command': self.do_update,
|
||||
Pack: {'expand': 'no',
|
||||
'fill': 'x'}})
|
||||
self.frame.vscroll.pack(side=RIGHT, fill=Y)
|
||||
self.frame.list.pack(expand=1, fill=BOTH)
|
||||
self.update = Button(self, text='Update',
|
||||
command=self.do_update)
|
||||
self.update.pack(fill=X)
|
||||
self.frame.list.bind('<Motion>', self.do_motion)
|
||||
self.frame.list.bind('<Leave>', self.do_leave)
|
||||
self.frame.list.bind('<1>', self.do_1)
|
||||
self.do_update()
|
||||
|
||||
if __name__ == '__main__':
|
||||
kill = Kill(None, {'bd': 5})
|
||||
kill = Kill(None, borderwidth=5)
|
||||
kill.winfo_toplevel().title('Tkinter Process Killer (SYSV)')
|
||||
kill.winfo_toplevel().minsize(1, 1)
|
||||
kill.mainloop()
|
||||
|
|
|
@ -1,4 +1,3 @@
|
|||
#! /home/guido/bin.sgi/python
|
||||
#! /usr/local/bin/python
|
||||
|
||||
# Tk man page browser -- currently only shows the Tcl/Tk man pages
|
||||
|
@ -32,81 +31,66 @@ class SelectionBox:
|
|||
def __init__(self, master=None):
|
||||
self.choices = []
|
||||
|
||||
self.frame = Frame(master, {
|
||||
'name': 'frame',
|
||||
Pack: {'expand': 1, 'fill': 'both'}})
|
||||
self.frame = Frame(master, name="frame")
|
||||
self.frame.pack(expand=1, fill=BOTH)
|
||||
self.master = self.frame.master
|
||||
self.subframe = Frame(self.frame, {
|
||||
'name': 'subframe',
|
||||
Pack: {'expand': 0, 'fill': 'both'}})
|
||||
self.leftsubframe = Frame(self.subframe, {
|
||||
'name': 'leftsubframe',
|
||||
Pack: {'side': 'left', 'expand': 1, 'fill': 'both'}})
|
||||
self.rightsubframe = Frame(self.subframe, {
|
||||
'name': 'rightsubframe',
|
||||
Pack: {'side': 'right', 'expand': 1, 'fill': 'both'}})
|
||||
self.subframe = Frame(self.frame, name="subframe")
|
||||
self.subframe.pack(expand=0, fill=BOTH)
|
||||
self.leftsubframe = Frame(self.subframe, name='leftsubframe')
|
||||
self.leftsubframe.pack(side=LEFT, expand=1, fill=BOTH)
|
||||
self.rightsubframe = Frame(self.subframe, name='rightsubframe')
|
||||
self.rightsubframe.pack(side=RIGHT, expand=1, fill=BOTH)
|
||||
self.chaptervar = StringVar(master)
|
||||
self.chapter = Menubutton(self.rightsubframe,
|
||||
{'name': 'chapter',
|
||||
'text': 'Directory',
|
||||
'relief': 'raised', 'bd': 2,
|
||||
Pack: {'side': 'top'}})
|
||||
self.chaptermenu = Menu(self.chapter, {'name': 'chaptermenu'})
|
||||
self.chaptermenu.add_radiobutton({'label': 'C functions',
|
||||
'value': MAN3DIR,
|
||||
'variable': self.chaptervar,
|
||||
'command': self.newchapter})
|
||||
self.chaptermenu.add_radiobutton({'label': 'Tcl/Tk functions',
|
||||
'value': MANNDIR,
|
||||
'variable': self.chaptervar,
|
||||
'command': self.newchapter})
|
||||
self.chapter = Menubutton(self.rightsubframe, name='chapter',
|
||||
text='Directory', relief=RAISED,
|
||||
borderwidth=2)
|
||||
self.chapter.pack(side=TOP)
|
||||
self.chaptermenu = Menu(self.chapter, name='chaptermenu')
|
||||
self.chaptermenu.add_radiobutton(label='C functions',
|
||||
value=MAN3DIR,
|
||||
variable=self.chaptervar,
|
||||
command=self.newchapter)
|
||||
self.chaptermenu.add_radiobutton(label='Tcl/Tk functions',
|
||||
value=MANNDIR,
|
||||
variable=self.chaptervar,
|
||||
command=self.newchapter)
|
||||
self.chapter['menu'] = self.chaptermenu
|
||||
self.listbox = Listbox(self.rightsubframe,
|
||||
{'name': 'listbox',
|
||||
'relief': 'sunken', 'bd': 2,
|
||||
'width': 20, 'height': 5,
|
||||
Pack: {'expand': 1, 'fill': 'both'}})
|
||||
self.l1 = Button(self.leftsubframe,
|
||||
{'name': 'l1',
|
||||
'text': 'Display manual page named:',
|
||||
'command': self.entry_cb,
|
||||
Pack: {'side': 'top'}})
|
||||
self.entry = Entry(self.leftsubframe,
|
||||
{'name': 'entry',
|
||||
'relief': 'sunken', 'bd': 2,
|
||||
'width': 20,
|
||||
Pack: {'side': 'top',
|
||||
'expand': 0, 'fill': 'x'}})
|
||||
self.l2frame = Frame(self.leftsubframe,
|
||||
{'name': 'l2frame',
|
||||
Pack: {'expand': 0, 'fill': 'none'}})
|
||||
self.l2 = Button(self.l2frame,
|
||||
{'name': 'l2',
|
||||
'text': 'Search regexp:',
|
||||
'command': self.search_cb,
|
||||
Pack: {'side': 'left'}})
|
||||
self.casesense = Checkbutton(self.l2frame,
|
||||
{'name': 'casesense',
|
||||
'text': 'Case sensitive',
|
||||
'variable': 'casesense',
|
||||
'relief': 'flat',
|
||||
Pack: {'side': 'left'}})
|
||||
self.search = Entry(self.leftsubframe,
|
||||
{'name': 'search',
|
||||
'relief': 'sunken', 'bd': 2,
|
||||
'width': 20,
|
||||
Pack: {'side': 'top',
|
||||
'expand': 0, 'fill': 'x'}})
|
||||
self.title = Label(self.leftsubframe,
|
||||
{'name': 'title',
|
||||
'text': '(none)',
|
||||
Pack: {'side': 'bottom'}})
|
||||
self.text = ManPage(self.frame,
|
||||
{'name': 'text',
|
||||
'relief': 'sunken', 'bd': 2,
|
||||
'wrap': 'none', 'width': 72,
|
||||
'selectbackground': 'pink',
|
||||
Pack: {'expand': 1, 'fill': 'both'}})
|
||||
self.listbox = Listbox(self.rightsubframe, name='listbox',
|
||||
relief=SUNKEN, borderwidth=2,
|
||||
width=20, height=5)
|
||||
self.listbox.pack(expand=1, fill=BOTH)
|
||||
self.l1 = Button(self.leftsubframe, name='l1',
|
||||
text='Display manual page named:',
|
||||
command=self.entry_cb)
|
||||
self.l1.pack(side=TOP)
|
||||
self.entry = Entry(self.leftsubframe, name='entry',
|
||||
relief=SUNKEN, borderwidth=2,
|
||||
width=20)
|
||||
self.entry.pack(expand=0, fill=X)
|
||||
self.l2frame = Frame(self.leftsubframe, name='l2frame')
|
||||
self.l2frame.pack(expand=0, fill=NONE)
|
||||
self.l2 = Button(self.l2frame, name='l2',
|
||||
text='Search regexp:',
|
||||
command=self.search_cb)
|
||||
self.l2.pack(side=LEFT)
|
||||
self.casevar = BooleanVar()
|
||||
self.casesense = Checkbutton(self.l2frame, name='casesense',
|
||||
text='Case sensitive',
|
||||
variable=self.casevar,
|
||||
relief=FLAT)
|
||||
self.casesense.pack(side=LEFT)
|
||||
self.search = Entry(self.leftsubframe, name='search',
|
||||
relief=SUNKEN, borderwidth=2,
|
||||
width=20)
|
||||
self.search.pack(expand=0, fill=X)
|
||||
self.title = Label(self.leftsubframe, name='title',
|
||||
text='(none)')
|
||||
self.title.pack(side=BOTTOM)
|
||||
self.text = ManPage(self.frame, name='text',
|
||||
relief=SUNKEN, borderwidth=2,
|
||||
wrap=NONE, width=72,
|
||||
selectbackground='pink')
|
||||
self.text.pack(expand=1, fill=BOTH)
|
||||
|
||||
self.entry.bind('<Return>', self.entry_cb)
|
||||
self.search.bind('<Return>', self.search_cb)
|
||||
|
@ -195,7 +179,7 @@ class SelectionBox:
|
|||
self.frame.bell()
|
||||
print 'Empty search string'
|
||||
return
|
||||
if self.frame.tk.getvar('casesense') != '1':
|
||||
if not self.casevar.get():
|
||||
map = regex.casefold
|
||||
else:
|
||||
map = None
|
||||
|
|
|
@ -8,18 +8,15 @@ class Test(Frame):
|
|||
print "hi"
|
||||
|
||||
def createWidgets(self):
|
||||
self.QUIT = Button(self, {'text': 'QUIT',
|
||||
'fg': 'red',
|
||||
'command': self.quit})
|
||||
self.QUIT = Button(self, text='QUIT', foreground='red',
|
||||
command=self.quit)
|
||||
|
||||
self.QUIT.pack({'side': 'left', 'fill': 'both'})
|
||||
|
||||
self.QUIT.pack(side=LEFT, fill=BOTH)
|
||||
|
||||
# a hello button
|
||||
self.hi_there = Button(self, {'text': 'Hello',
|
||||
'command' : self.printit})
|
||||
self.hi_there.pack({'side': 'left'})
|
||||
|
||||
self.hi_there = Button(self, text='Hello',
|
||||
command=self.printit)
|
||||
self.hi_there.pack(side=LEFT)
|
||||
|
||||
def __init__(self, master=None):
|
||||
Frame.__init__(self, master)
|
||||
|
|
|
@ -7,16 +7,15 @@ class Test(Frame):
|
|||
print "hi"
|
||||
|
||||
def createWidgets(self):
|
||||
self.QUIT = Button(self, {'text': 'QUIT',
|
||||
'fg': 'red',
|
||||
'command': self.quit})
|
||||
self.QUIT.pack({'side': 'left', 'fill': 'both'})
|
||||
self.QUIT = Button(self, text='QUIT', foreground='red',
|
||||
command=self.quit)
|
||||
self.QUIT.pack(side=LEFT, fill=BOTH)
|
||||
|
||||
self.draw = Canvas(self, {"width" : "5i", "height" : "5i"})
|
||||
self.draw = Canvas(self, width="5i", height="5i")
|
||||
|
||||
# all of these work..
|
||||
self.draw.create_polygon("0", "0", "10", "0", "10", "10", "0" , "10", {"tags" : "thing"})
|
||||
self.draw.pack({'side': 'left'})
|
||||
self.draw.create_rectangle(0, 0, 10, 10, tags="thing", fill="blue")
|
||||
self.draw.pack(side=LEFT)
|
||||
|
||||
def moveThing(self, *args):
|
||||
# move 1/10 of an inch every 1/10 sec (1" per second, smoothly)
|
||||
|
|
|
@ -6,29 +6,24 @@ from Tkinter import *
|
|||
# Tkinter is smart enough to start the system if it's not already going.
|
||||
|
||||
|
||||
|
||||
|
||||
class Test(Frame):
|
||||
def printit(self):
|
||||
print "hi"
|
||||
|
||||
def createWidgets(self):
|
||||
self.QUIT = Button(self, {'text': 'QUIT',
|
||||
'fg': 'red',
|
||||
'command': self.quit})
|
||||
self.QUIT.pack({'side': 'bottom', 'fill': 'both'})
|
||||
self.QUIT = Button(self, text='QUIT', foreground='red',
|
||||
command=self.quit)
|
||||
self.QUIT.pack(side=BOTTOM, fill=BOTH)
|
||||
|
||||
self.draw = Canvas(self, {"width" : "5i", "height" : "5i"})
|
||||
self.draw = Canvas(self, width="5i", height="5i")
|
||||
|
||||
self.speed = Scale(self, {"orient": "horiz",
|
||||
"from" : -100,
|
||||
"to" : 100})
|
||||
self.speed = Scale(self, orient=HORIZONTAL, from_=-100, to=100)
|
||||
|
||||
self.speed.pack({'side': 'bottom', "fill" : "x"})
|
||||
self.speed.pack(side=BOTTOM, fill=X)
|
||||
|
||||
# all of these work..
|
||||
self.draw.create_polygon("0", "0", "10", "0", "10", "10", "0" , "10", {"tags" : "thing"})
|
||||
self.draw.pack({'side': 'left'})
|
||||
self.draw.create_rectangle(0, 0, 10, 10, tags="thing", fill="blue")
|
||||
self.draw.pack(side=LEFT)
|
||||
|
||||
def moveThing(self, *args):
|
||||
velocity = self.speed.get()
|
||||
|
@ -37,8 +32,6 @@ class Test(Frame):
|
|||
self.draw.move("thing", str, str)
|
||||
self.after(10, self.moveThing)
|
||||
|
||||
|
||||
|
||||
def __init__(self, master=None):
|
||||
Frame.__init__(self, master)
|
||||
Pack.config(self)
|
||||
|
|
|
@ -18,8 +18,9 @@ class App(Frame):
|
|||
|
||||
# Note that here is where we bind a completely different callback to
|
||||
# the same event. We pass "+" here to indicate that we wish to ADD
|
||||
# this callback to the list associated with this event type. Not specifying "+" would
|
||||
# simply override whatever callback was defined on this event.
|
||||
# this callback to the list associated with this event type.
|
||||
# Not specifying "+" would simply override whatever callback was
|
||||
# defined on this event.
|
||||
self.entrythingy.bind('<Key-Return>', self.print_something_else, "+")
|
||||
|
||||
def print_contents(self, event):
|
||||
|
|
|
@ -7,18 +7,16 @@ class Test(Frame):
|
|||
print "hi"
|
||||
|
||||
def createWidgets(self):
|
||||
self.QUIT = Button(self, {'text': 'QUIT',
|
||||
'fg': 'red',
|
||||
'command': self.quit})
|
||||
self.QUIT.pack({'side': 'bottom', 'fill': 'both'})
|
||||
self.QUIT = Button(self, text='QUIT', foreground='red',
|
||||
command=self.quit)
|
||||
self.QUIT.pack(side=BOTTOM, fill=BOTH)
|
||||
|
||||
self.draw = Canvas(self, {"width" : "5i", "height" : "5i"})
|
||||
self.draw = Canvas(self, width="5i", height="5i")
|
||||
|
||||
# see the other demos for other ways of specifying coords for a polygon
|
||||
self.draw.create_polygon("0i", "0i", "3i", "0i", "3i", "3i", "0i" , "3i")
|
||||
|
||||
self.draw.pack({'side': 'left'})
|
||||
self.draw.create_rectangle(0, 0, "3i", "3i", fill="black")
|
||||
|
||||
self.draw.pack(side=LEFT)
|
||||
|
||||
def __init__(self, master=None):
|
||||
Frame.__init__(self, master)
|
||||
|
|
|
@ -10,15 +10,15 @@ class Test(Frame):
|
|||
print "hi"
|
||||
|
||||
def createWidgets(self):
|
||||
self.QUIT = Button(self, {'text': 'QUIT',
|
||||
'bg': 'red',
|
||||
'fg': 'white',
|
||||
'height' : 3,
|
||||
'command': self.quit})
|
||||
self.QUIT.pack({'side': 'bottom', 'fill': 'both'})
|
||||
self.QUIT = Button(self, text='QUIT',
|
||||
background='red',
|
||||
foreground='white',
|
||||
height=3,
|
||||
command=self.quit)
|
||||
self.QUIT.pack(side=BOTTOM, fill=BOTH)
|
||||
|
||||
self.canvasObject = Canvas(self, {"width" : "5i", "height" : "5i"})
|
||||
self.canvasObject.pack({'side': 'left'})
|
||||
self.canvasObject = Canvas(self, width="5i", height="5i")
|
||||
self.canvasObject.pack(side=LEFT)
|
||||
|
||||
def mouseDown(self, event):
|
||||
# canvas x and y take the screen coords from the event and translate
|
||||
|
@ -29,12 +29,13 @@ class Test(Frame):
|
|||
def mouseMotion(self, event):
|
||||
# canvas x and y take the screen coords from the event and translate
|
||||
# them into the coordinate system of the canvas object
|
||||
x = self.canvasObject.canvasx(event.x, self.griddingsize)
|
||||
y = self.canvasObject.canvasy(event.y, self.griddingsize)
|
||||
x = self.canvasObject.canvasx(event.x, self.griddingSize)
|
||||
y = self.canvasObject.canvasy(event.y, self.griddingSize)
|
||||
|
||||
if (self.startx != event.x) and (self.starty != event.y) :
|
||||
self.canvasObject.delete(self.rubberbandBox)
|
||||
self.rubberbandBox = self.canvasObject.create_rectangle(self.startx, self.starty, x, y)
|
||||
self.rubberbandBox = self.canvasObject.create_rectangle(
|
||||
self.startx, self.starty, x, y)
|
||||
# this flushes the output, making sure that
|
||||
# the rectangle makes it to the screen
|
||||
# before the next event is handled
|
||||
|
|
|
@ -9,26 +9,24 @@ class Test(Frame):
|
|||
###################################################################
|
||||
def mouseDown(self, event):
|
||||
# see if we're inside a dot. If we are, it
|
||||
# gets tagged as "current" for free by tk.
|
||||
|
||||
if not event.widget.find_withtag("current"):
|
||||
# gets tagged as CURRENT for free by tk.
|
||||
if not event.widget.find_withtag(CURRENT):
|
||||
# there is no dot here, so we can make one,
|
||||
# and bind some interesting behavior to it.
|
||||
# ------
|
||||
|
||||
# create a dot, and mark it as current
|
||||
fred = self.draw.create_oval(event.x - 10, event.y -10, event.x +10, event.y + 10,
|
||||
{"fill" : "green", "tag" : "current"})
|
||||
# create a dot, and mark it as CURRENT
|
||||
fred = self.draw.create_oval(
|
||||
event.x - 10, event.y -10, event.x +10, event.y + 10,
|
||||
fill="green", tags=CURRENT)
|
||||
|
||||
self.draw.bind(fred, "<Any-Enter>", self.mouseEnter)
|
||||
self.draw.bind(fred, "<Any-Leave>", self.mouseLeave)
|
||||
|
||||
|
||||
self.lastx = event.x
|
||||
self.lasty = event.y
|
||||
|
||||
|
||||
|
||||
def mouseMove(self, event):
|
||||
self.draw.move("current", event.x - self.lastx, event.y - self.lasty)
|
||||
self.draw.move(CURRENT, event.x - self.lastx, event.y - self.lasty)
|
||||
self.lastx = event.x
|
||||
self.lasty = event.y
|
||||
|
||||
|
@ -36,25 +34,22 @@ class Test(Frame):
|
|||
###### Event callbacks for canvas ITEMS (stuff drawn on the canvas)
|
||||
###################################################################
|
||||
def mouseEnter(self, event):
|
||||
# the "current" tag is applied to the object the cursor is over.
|
||||
# the CURRENT tag is applied to the object the cursor is over.
|
||||
# this happens automatically.
|
||||
self.draw.itemconfig("current", {"fill" : "red"})
|
||||
|
||||
def mouseLeave(self, event):
|
||||
# the "current" tag is applied to the object the cursor is over.
|
||||
# this happens automatically.
|
||||
self.draw.itemconfig("current", {"fill" : "blue"})
|
||||
self.draw.itemconfig(CURRENT, fill="red")
|
||||
|
||||
def mouseLeave(self, event):
|
||||
# the CURRENT tag is applied to the object the cursor is over.
|
||||
# this happens automatically.
|
||||
self.draw.itemconfig(CURRENT, fill="blue")
|
||||
|
||||
def createWidgets(self):
|
||||
self.QUIT = Button(self, {'text': 'QUIT',
|
||||
'fg': 'red',
|
||||
'command': self.quit})
|
||||
self.QUIT.pack({'side': 'left', 'fill': 'both'})
|
||||
self.draw = Canvas(self, {"width" : "5i", "height" : "5i"})
|
||||
self.draw.pack({'side': 'left'})
|
||||
|
||||
|
||||
self.QUIT = Button(self, text='QUIT', foreground='red',
|
||||
command=self.quit)
|
||||
self.QUIT.pack(side=LEFT, fill=BOTH)
|
||||
self.draw = Canvas(self, width="5i", height="5i")
|
||||
self.draw.pack(side=LEFT)
|
||||
|
||||
Widget.bind(self.draw, "<1>", self.mouseDown)
|
||||
Widget.bind(self.draw, "<B1-Motion>", self.mouseMove)
|
||||
|
||||
|
|
|
@ -10,11 +10,10 @@ class Test(Frame):
|
|||
# remember where the mouse went down
|
||||
self.lastx = event.x
|
||||
self.lasty = event.y
|
||||
|
||||
|
||||
|
||||
def mouseMove(self, event):
|
||||
# whatever the mouse is over gets tagged as "current" for free by tk.
|
||||
self.draw.move("current", event.x - self.lastx, event.y - self.lasty)
|
||||
# whatever the mouse is over gets tagged as CURRENT for free by tk.
|
||||
self.draw.move(CURRENT, event.x - self.lastx, event.y - self.lasty)
|
||||
self.lastx = event.x
|
||||
self.lasty = event.y
|
||||
|
||||
|
@ -22,27 +21,24 @@ class Test(Frame):
|
|||
###### Event callbacks for canvas ITEMS (stuff drawn on the canvas)
|
||||
###################################################################
|
||||
def mouseEnter(self, event):
|
||||
# the "current" tag is applied to the object the cursor is over.
|
||||
# the CURRENT tag is applied to the object the cursor is over.
|
||||
# this happens automatically.
|
||||
self.draw.itemconfig("current", {"fill" : "red"})
|
||||
self.draw.itemconfig(CURRENT, fill="red")
|
||||
|
||||
def mouseLeave(self, event):
|
||||
# the "current" tag is applied to the object the cursor is over.
|
||||
# the CURRENT tag is applied to the object the cursor is over.
|
||||
# this happens automatically.
|
||||
self.draw.itemconfig("current", {"fill" : "blue"})
|
||||
|
||||
self.draw.itemconfig(CURRENT, fill="blue")
|
||||
|
||||
def createWidgets(self):
|
||||
self.QUIT = Button(self, {'text': 'QUIT',
|
||||
'fg': 'red',
|
||||
'command': self.quit})
|
||||
self.QUIT.pack({'side': 'left', 'fill': 'both'})
|
||||
self.draw = Canvas(self, {"width" : "5i", "height" : "5i"})
|
||||
self.draw.pack({'side': 'left'})
|
||||
|
||||
self.QUIT = Button(self, text='QUIT', foreground='red',
|
||||
command=self.quit)
|
||||
self.QUIT.pack(side=LEFT, fill=BOTH)
|
||||
self.draw = Canvas(self, width="5i", height="5i")
|
||||
self.draw.pack(side=LEFT)
|
||||
|
||||
fred = self.draw.create_oval(0, 0, 20, 20,
|
||||
{"fill" : "green", "tag" : "selected"})
|
||||
fill="green", tags="selected")
|
||||
|
||||
self.draw.tag_bind(fred, "<Any-Enter>", self.mouseEnter)
|
||||
self.draw.tag_bind(fred, "<Any-Leave>", self.mouseLeave)
|
||||
|
|
|
@ -11,20 +11,20 @@ class Test(Frame):
|
|||
###################################################################
|
||||
def mouseDown(self, event):
|
||||
# see if we're inside a dot. If we are, it
|
||||
# gets tagged as "current" for free by tk.
|
||||
# gets tagged as CURRENT for free by tk.
|
||||
|
||||
if not event.widget.find_withtag("current"):
|
||||
if not event.widget.find_withtag(CURRENT):
|
||||
# we clicked outside of all dots on the canvas. unselect all.
|
||||
|
||||
# re-color everything back to an unselected color
|
||||
self.draw.itemconfig("selected", {"fill" : UNSELECTED_COLOR})
|
||||
self.draw.itemconfig("selected", fill=UNSELECTED_COLOR)
|
||||
# unselect everything
|
||||
self.draw.dtag("selected")
|
||||
else:
|
||||
# mark as "selected" the thing the cursor is under
|
||||
self.draw.addtag("selected", "withtag", "current")
|
||||
self.draw.addtag("selected", "withtag", CURRENT)
|
||||
# color it as selected
|
||||
self.draw.itemconfig("selected", {"fill": SELECTED_COLOR})
|
||||
self.draw.itemconfig("selected", fill=SELECTED_COLOR)
|
||||
|
||||
self.lastx = event.x
|
||||
self.lasty = event.y
|
||||
|
@ -38,40 +38,36 @@ class Test(Frame):
|
|||
def makeNewDot(self):
|
||||
# create a dot, and mark it as current
|
||||
fred = self.draw.create_oval(0, 0, 20, 20,
|
||||
{"fill" : SELECTED_COLOR, "tag" : "current"})
|
||||
fill=SELECTED_COLOR, tags=CURRENT)
|
||||
# and make it selected
|
||||
self.draw.addtag("selected", "withtag", "current")
|
||||
self.draw.addtag("selected", "withtag", CURRENT)
|
||||
|
||||
def createWidgets(self):
|
||||
self.QUIT = Button(self, {'text': 'QUIT',
|
||||
'fg': 'red',
|
||||
'command': self.quit})
|
||||
self.QUIT = Button(self, text='QUIT', foreground='red',
|
||||
command=self.quit)
|
||||
|
||||
################
|
||||
# make the canvas and bind some behavior to it
|
||||
################
|
||||
self.draw = Canvas(self, {"width" : "5i", "height" : "5i"})
|
||||
self.draw = Canvas(self, width="5i", height="5i")
|
||||
Widget.bind(self.draw, "<1>", self.mouseDown)
|
||||
Widget.bind(self.draw, "<B1-Motion>", self.mouseMove)
|
||||
|
||||
|
||||
# and other things.....
|
||||
self.button = Button(self, {"text" : "make a new dot",
|
||||
"command" : self.makeNewDot,
|
||||
"fg" : "blue"})
|
||||
self.button = Button(self, text="make a new dot", foreground="blue",
|
||||
command=self.makeNewDot)
|
||||
|
||||
self.label = Message(self,
|
||||
{"width" : "5i",
|
||||
"text" : SELECTED_COLOR + " dots are selected and can be dragged.\n" +
|
||||
UNSELECTED_COLOR + " are not selected.\n" +
|
||||
"Click in a dot to select it.\n" +
|
||||
"Click on empty space to deselect all dots." })
|
||||
message = ("%s dots are selected and can be dragged.\n"
|
||||
"%s are not selected.\n"
|
||||
"Click in a dot to select it.\n"
|
||||
"Click on empty space to deselect all dots."
|
||||
) % (SELECTED_COLOR, UNSELECTED_COLOR)
|
||||
self.label = Message(self, width="5i", text=message)
|
||||
|
||||
self.QUIT.pack({'side': 'bottom', 'fill': 'both'})
|
||||
self.label.pack({"side" : "bottom", "fill" : "x", "expand" : 1})
|
||||
self.button.pack({"side" : "bottom", "fill" : "x"})
|
||||
self.draw.pack({'side': 'left'})
|
||||
|
||||
self.QUIT.pack(side=BOTTOM, fill=BOTH)
|
||||
self.label.pack(side=BOTTOM, fill=X, expand=1)
|
||||
self.button.pack(side=BOTTOM, fill=X)
|
||||
self.draw.pack(side=LEFT)
|
||||
|
||||
def __init__(self, master=None):
|
||||
Frame.__init__(self, master)
|
||||
|
|
|
@ -6,17 +6,16 @@ class Test(Frame):
|
|||
print "hi"
|
||||
|
||||
def createWidgets(self):
|
||||
self.QUIT = Button(self, {'text': 'QUIT',
|
||||
'fg': 'red',
|
||||
'command': self.quit})
|
||||
self.QUIT.pack({'side': 'bottom', 'fill': 'both'})
|
||||
self.QUIT = Button(self, text='QUIT', foreground='red',
|
||||
command=self.quit)
|
||||
self.QUIT.pack(side=BOTTOM, fill=BOTH)
|
||||
|
||||
self.drawing = Canvas(self, {"width" : "5i", "height" : "5i"})
|
||||
self.drawing = Canvas(self, width="5i", height="5i")
|
||||
|
||||
# make a shape
|
||||
pgon = self.drawing.create_polygon("10", "10", "110", "10", "110", "110", "10" , "110",
|
||||
{"fill" : "red",
|
||||
"tags" : "weee foo groo"})
|
||||
pgon = self.drawing.create_polygon(
|
||||
10, 10, 110, 10, 110, 110, 10 , 110,
|
||||
fill="red", tags=("weee", "foo", "groo"))
|
||||
|
||||
# this is how you query an object for its attributes
|
||||
# config options FOR CANVAS ITEMS always come back in tuples of length 5.
|
||||
|
@ -31,15 +30,14 @@ class Test(Frame):
|
|||
option_value = self.drawing.itemconfig(pgon, "stipple")
|
||||
print "pgon's current stipple value is -->", option_value[4], "<--"
|
||||
option_value = self.drawing.itemconfig(pgon, "fill")
|
||||
print "pgon's current fill value is -->", option_value[4], "<-- when he is usually colored -->", option_value[3], "<--"
|
||||
print "pgon's current fill value is -->", option_value[4], "<--"
|
||||
print " when he is usually colored -->", option_value[3], "<--"
|
||||
|
||||
## here we print out all the tags associated with this object
|
||||
option_value = self.drawing.itemconfig(pgon, "tags")
|
||||
print "pgon's tags are", option_value[4]
|
||||
|
||||
self.drawing.pack({'side': 'left'})
|
||||
|
||||
|
||||
self.drawing.pack(side=LEFT)
|
||||
|
||||
def __init__(self, master=None):
|
||||
Frame.__init__(self, master)
|
||||
|
|
|
@ -7,15 +7,14 @@ class Test(Frame):
|
|||
print "hi"
|
||||
|
||||
def createWidgets(self):
|
||||
self.QUIT = Button(self, {'text': 'QUIT',
|
||||
'fg': 'red',
|
||||
'command': self.quit})
|
||||
self.QUIT.pack({'side': 'bottom', 'fill': 'both'})
|
||||
self.QUIT = Button(self, text='QUIT', foreground='red',
|
||||
command=self.quit)
|
||||
self.QUIT.pack(side=BOTTOM, fill=BOTH)
|
||||
|
||||
self.draw = Canvas(self, {"width" : "5i", "height" : "5i"})
|
||||
self.draw = Canvas(self, width="5i", height="5i")
|
||||
|
||||
self.button = Button(self, {"text" : "this is a button",
|
||||
"command" : self.printhi})
|
||||
self.button = Button(self, text="this is a button",
|
||||
command=self.printhi)
|
||||
|
||||
# note here the coords are given in pixels (form the
|
||||
# upper right and corner of the window, as usual for X)
|
||||
|
@ -23,11 +22,9 @@ class Test(Frame):
|
|||
# whatever...use the "anchor" option to control what point of the
|
||||
# widget (in this case the button) gets mapped to the given x, y.
|
||||
# you can specify corners, edges, center, etc...
|
||||
self.draw.create_window(300, 300, {"window" : self.button})
|
||||
|
||||
self.draw.pack({'side': 'left'})
|
||||
|
||||
self.draw.create_window(300, 300, window=self.button)
|
||||
|
||||
self.draw.pack(side=LEFT)
|
||||
|
||||
def __init__(self, master=None):
|
||||
Frame.__init__(self, master)
|
||||
|
|
|
@ -10,27 +10,23 @@ class Test(Frame):
|
|||
print "hi"
|
||||
|
||||
def createWidgets(self):
|
||||
self.question = Label(self, {"text": "Can Find The BLUE Square??????",
|
||||
Pack : {"side" : "top"}})
|
||||
|
||||
self.QUIT = Button(self, {'text': 'QUIT',
|
||||
'bg': 'red',
|
||||
"height" : "3",
|
||||
'command': self.quit})
|
||||
self.QUIT.pack({'side': 'bottom', 'fill': 'both'})
|
||||
spacer = Frame(self, {"height" : "0.25i",
|
||||
Pack : {"side" : "bottom"}})
|
||||
self.question = Label(self, text="Can Find The BLUE Square??????")
|
||||
self.question.pack()
|
||||
|
||||
self.QUIT = Button(self, text='QUIT', background='red',
|
||||
height=3, command=self.quit)
|
||||
self.QUIT.pack(side=BOTTOM, fill=BOTH)
|
||||
spacer = Frame(self, height="0.25i")
|
||||
spacer.pack(side=BOTTOM)
|
||||
|
||||
# notice that the scroll region (20" x 20") is larger than
|
||||
# displayed size of the widget (5" x 5")
|
||||
self.draw = Canvas(self, {"width" : "5i",
|
||||
"height" : "5i",
|
||||
"bg" : "white",
|
||||
"scrollregion" : "0i 0i 20i 20i"})
|
||||
self.draw = Canvas(self, width="5i", height="5i",
|
||||
background="white",
|
||||
scrollregion=(0, 0, "20i", "20i"))
|
||||
|
||||
|
||||
self.draw.scrollX = Scrollbar(self, {"orient" : "horizontal"})
|
||||
self.draw.scrollY = Scrollbar(self, {"orient" : "vertical"})
|
||||
self.draw.scrollX = Scrollbar(self, orient=HORIZONTAL)
|
||||
self.draw.scrollY = Scrollbar(self, orient=VERTICAL)
|
||||
|
||||
# now tie the three together. This is standard boilerplate text
|
||||
self.draw['xscrollcommand'] = self.draw.scrollX.set
|
||||
|
@ -40,16 +36,13 @@ class Test(Frame):
|
|||
|
||||
# draw something. Note that the first square
|
||||
# is visible, but you need to scroll to see the second one.
|
||||
self.draw.create_polygon("0i", "0i", "3.5i", "0i", "3.5i", "3.5i", "0i" , "3.5i")
|
||||
self.draw.create_polygon("10i", "10i", "13.5i", "10i", "13.5i", "13.5i", "10i" , "13.5i", "-fill", "blue")
|
||||
self.draw.create_rectangle(0, 0, "3.5i", "3.5i", fill="black")
|
||||
self.draw.create_rectangle("10i", "10i", "13.5i", "13.5i", fill="blue")
|
||||
|
||||
|
||||
# pack 'em up
|
||||
self.draw.scrollX.pack({'side': 'bottom',
|
||||
"fill" : "x"})
|
||||
self.draw.scrollY.pack({'side': 'right',
|
||||
"fill" : "y"})
|
||||
self.draw.pack({'side': 'left'})
|
||||
self.draw.scrollX.pack(side=BOTTOM, fill=X)
|
||||
self.draw.scrollY.pack(side=RIGHT, fill=Y)
|
||||
self.draw.pack(side=LEFT)
|
||||
|
||||
|
||||
def scrollCanvasX(self, *args):
|
||||
|
|
|
@ -1,58 +1,57 @@
|
|||
from Tkinter import *
|
||||
from Dialog import Dialog
|
||||
|
||||
# this shows how to create a new window with a button in it that can create new windows
|
||||
# this shows how to create a new window with a button in it
|
||||
# that can create new windows
|
||||
|
||||
class Test(Frame):
|
||||
def printit(self):
|
||||
print "hi"
|
||||
|
||||
def makeWindow(self):
|
||||
# there is no Tkinter interface to the dialog box. Making one would mean putting
|
||||
# a few wrapper functions in the Tkinter.py file.
|
||||
# even better is to put in a SUIT-like selection of commonly-used dialogs.
|
||||
"""Create a top-level dialog with some buttons.
|
||||
|
||||
This uses the Dialog class, which is a wrapper around the Tcl/Tk
|
||||
tk_dialog script. The function returns 0 if the user clicks 'yes'
|
||||
or 1 if the user clicks 'no'.
|
||||
"""
|
||||
# the parameters to this call are as follows:
|
||||
d = Dialog(
|
||||
self, ## name of a toplevel window
|
||||
title="fred the dialog box",## title on the window
|
||||
text="click on a choice", ## message to appear in window
|
||||
bitmap="info", ## bitmap (if any) to appear;
|
||||
## if none, use ""
|
||||
# legal values here are:
|
||||
# string what it looks like
|
||||
# ----------------------------------------------
|
||||
# error a circle with a slash through it
|
||||
# grey25 grey square
|
||||
# grey50 darker grey square
|
||||
# hourglass use for "wait.."
|
||||
# info a large, lower case "i"
|
||||
# questhead a human head with a "?" in it
|
||||
# question a large "?"
|
||||
# warning a large "!"
|
||||
# @fname X bitmap where fname is the path to the file
|
||||
#
|
||||
default=0, # the index of the default button choice.
|
||||
# hitting return selects this
|
||||
strings=("yes", "no"))
|
||||
# values of the 'strings' key are the labels for the
|
||||
# buttons that appear left to right in the dialog box
|
||||
return d.num
|
||||
|
||||
fred = Toplevel() # a toplevel window that the dialog goes into
|
||||
|
||||
|
||||
# this function returns the index of teh button chosen. In this case, 0 for "yes" and 1 for "no"
|
||||
|
||||
print self.tk.call("tk_dialog", # the command name
|
||||
fred, # the name of a toplevel window
|
||||
"fred the dialog box", # the title on the window
|
||||
"click on a choice", # the message to appear in the window
|
||||
"info", # the bitmap (if any) to appear. If no bitmap is desired, pass ""
|
||||
# legal values here are:
|
||||
# string what it looks like
|
||||
# ----------------------------------------------
|
||||
# error a circle with a slash through it
|
||||
# grey25 grey square
|
||||
# grey50 darker grey square
|
||||
# hourglass use for "wait.."
|
||||
# info a large, lower case "i"
|
||||
# questhead a human head with a "?" in it
|
||||
# question a large "?"
|
||||
# warning a large "!"
|
||||
# @fname any X bitmap where fname is the path to the file
|
||||
#
|
||||
"0", # the index of the default button choice. hitting return selects this
|
||||
"yes", "no") # all remaining parameters are the labels for the
|
||||
# buttons that appear left to right in the dialog box
|
||||
|
||||
|
||||
|
||||
def createWidgets(self):
|
||||
self.QUIT = Button(self, {'text': 'QUIT',
|
||||
'fg': 'red',
|
||||
'command': self.quit})
|
||||
|
||||
self.QUIT.pack({'side': 'left', 'fill': 'both'})
|
||||
|
||||
self.QUIT = Button(self, text='QUIT', foreground='red',
|
||||
command=self.quit)
|
||||
self.QUIT.pack(side=LEFT, fill=BOTH)
|
||||
|
||||
# a hello button
|
||||
self.hi_there = Button(self, {'text': 'Make a New Window',
|
||||
'command' : self.makeWindow})
|
||||
self.hi_there.pack({'side': 'left'})
|
||||
self.hi_there = Button(self, text='Make a New Window',
|
||||
command=self.makeWindow)
|
||||
self.hi_there.pack(side=LEFT)
|
||||
|
||||
|
||||
def __init__(self, master=None):
|
||||
|
|
|
@ -11,10 +11,10 @@ class App(Frame):
|
|||
self.entrythingy = Entry()
|
||||
self.entrythingy.pack()
|
||||
|
||||
self.button = Button(self, {"text" : "Uppercase The Entry", "command" : self.upper})
|
||||
self.button = Button(self, text="Uppercase The Entry",
|
||||
command=self.upper)
|
||||
self.button.pack()
|
||||
|
||||
|
||||
# here we have the text in the entry widget tied to a variable.
|
||||
# changes in the variable are echoed in the widget and vice versa.
|
||||
# Very handy.
|
||||
|
@ -22,7 +22,7 @@ class App(Frame):
|
|||
# the other variable types that can be shadowed
|
||||
self.contents = StringVar()
|
||||
self.contents.set("this is a variable")
|
||||
self.entrythingy.config({"textvariable":self.contents})
|
||||
self.entrythingy.config(textvariable=self.contents)
|
||||
|
||||
# and here we get a callback when the user hits return. we could
|
||||
# make the key that triggers the callback anything we wanted to.
|
||||
|
|
|
@ -15,9 +15,8 @@ class Test(Frame):
|
|||
|
||||
def createWidgets(self):
|
||||
# a hello button
|
||||
self.hi_there = Button(self, {'text': 'Hello'})
|
||||
self.hi_there.pack({'side': 'left'})
|
||||
|
||||
self.hi_there = Button(self, text='Hello')
|
||||
self.hi_there.pack(side=LEFT)
|
||||
|
||||
def __init__(self, master=None):
|
||||
Frame.__init__(self, master)
|
||||
|
|
|
@ -37,7 +37,6 @@ from Tkinter import *
|
|||
def new_file():
|
||||
print "opening new file"
|
||||
|
||||
|
||||
def open_file():
|
||||
print "opening OLD file"
|
||||
|
||||
|
@ -55,53 +54,43 @@ def print_anchovies():
|
|||
|
||||
def makeCommandMenu():
|
||||
# make menu button
|
||||
Command_button = Menubutton(mBar, {'text': 'Simple Button Commands',
|
||||
'underline': 0,
|
||||
Pack: {'side': 'left',
|
||||
'padx': '2m'}})
|
||||
Command_button = Menubutton(mBar, text='Simple Button Commands',
|
||||
underline=0)
|
||||
Command_button.pack(side=LEFT, padx="2m")
|
||||
|
||||
# make the pulldown part of the File menu. The parameter passed is the master.
|
||||
# we attach it to the button as a python attribute called "menu" by convention.
|
||||
# hopefully this isn't too confusing...
|
||||
Command_button.menu = Menu(Command_button)
|
||||
|
||||
|
||||
# just to be cute, let's disable the undo option:
|
||||
Command_button.menu.add('command', {"label" : "Undo"} )
|
||||
Command_button.menu.add_command(label="Undo")
|
||||
# undo is the 0th entry...
|
||||
Command_button.menu.entryconfig(0, {"state" : "disabled"})
|
||||
Command_button.menu.entryconfig(0, state=DISABLED)
|
||||
|
||||
Command_button.menu.add('command', {'label': 'New...',
|
||||
|
||||
'underline': 0,
|
||||
'command' : new_file})
|
||||
|
||||
|
||||
Command_button.menu.add('command', {'label': 'Open...',
|
||||
'underline': 0,
|
||||
'command' : open_file})
|
||||
|
||||
Command_button.menu.add('command', {'label': 'Different Font',
|
||||
'underline': 0,
|
||||
'font' : '-*-helvetica-*-r-*-*-*-180-*-*-*-*-*-*',
|
||||
'command' : print_something})
|
||||
Command_button.menu.add_command(label='New...', underline=0,
|
||||
command=new_file)
|
||||
Command_button.menu.add_command(label='Open...', underline=0,
|
||||
command=open_file)
|
||||
Command_button.menu.add_command(label='Different Font', underline=0,
|
||||
font='-*-helvetica-*-r-*-*-*-180-*-*-*-*-*-*',
|
||||
command=print_something)
|
||||
|
||||
# we can make bitmaps be menu entries too. File format is X11 bitmap.
|
||||
# if you use XV, save it under X11 bitmap format. duh-uh.,..
|
||||
# Command_button.menu.add('command', {'bitmap' : '@/home/mjc4y/ftp/tcl/tk3.6/library/demos/bitmaps/face'})
|
||||
Command_button.menu.add('command', {'bitmap' : '@/home/mjc4y/dilbert/project.status.is.doomed.last.panel.bm'})
|
||||
Command_button.menu.add_command(
|
||||
bitmap="info")
|
||||
#bitmap='@/home/mjc4y/dilbert/project.status.is.doomed.last.panel.bm')
|
||||
|
||||
# this is just a line
|
||||
Command_button.menu.add('separator')
|
||||
|
||||
# change the color
|
||||
Command_button.menu.add('command', {'label': 'Quit',
|
||||
'underline': 0,
|
||||
'background' : 'red',
|
||||
'activebackground' : 'green',
|
||||
'command': 'exit'})
|
||||
|
||||
|
||||
Command_button.menu.add_command(label='Quit', underline=0,
|
||||
background='red',
|
||||
activebackground='green',
|
||||
command=Command_button.quit)
|
||||
|
||||
# set up a pointer from the file menubutton back to the file menu
|
||||
Command_button['menu'] = Command_button.menu
|
||||
|
||||
|
@ -111,10 +100,8 @@ def makeCommandMenu():
|
|||
|
||||
def makeCascadeMenu():
|
||||
# make menu button
|
||||
Cascade_button = Menubutton(mBar, {'text': 'Cascading Menus',
|
||||
'underline': 0,
|
||||
Pack: {'side': 'left',
|
||||
'padx': '2m'}})
|
||||
Cascade_button = Menubutton(mBar, text='Cascading Menus', underline=0)
|
||||
Cascade_button.pack(side=LEFT, padx="2m")
|
||||
|
||||
# the primary pulldown
|
||||
Cascade_button.menu = Menu(Cascade_button)
|
||||
|
@ -126,24 +113,24 @@ def makeCascadeMenu():
|
|||
Cascade_button.menu.choices.wierdones = Menu(Cascade_button.menu.choices)
|
||||
|
||||
# then you define the menus from the deepest level on up.
|
||||
Cascade_button.menu.choices.wierdones.add('command', {'label' : 'avacado'})
|
||||
Cascade_button.menu.choices.wierdones.add('command', {'label' : 'belgian endive'})
|
||||
Cascade_button.menu.choices.wierdones.add('command', {'label' : 'beefaroni'})
|
||||
Cascade_button.menu.choices.wierdones.add_command(label='avacado')
|
||||
Cascade_button.menu.choices.wierdones.add_command(label='belgian endive')
|
||||
Cascade_button.menu.choices.wierdones.add_command(label='beefaroni')
|
||||
|
||||
# definition of the menu one level up...
|
||||
Cascade_button.menu.choices.add('command', {'label' : 'Chocolate'})
|
||||
Cascade_button.menu.choices.add('command', {'label' : 'Vanilla'})
|
||||
Cascade_button.menu.choices.add('command', {'label' : 'TuttiFruiti'})
|
||||
Cascade_button.menu.choices.add('command', {'label' : 'WopBopaLoopBapABopBamBoom'})
|
||||
Cascade_button.menu.choices.add('command', {'label' : 'Rocky Road'})
|
||||
Cascade_button.menu.choices.add('command', {'label' : 'BubbleGum'})
|
||||
Cascade_button.menu.choices.add('cascade', {'label' : 'Wierd Flavors',
|
||||
'menu' : Cascade_button.menu.choices.wierdones})
|
||||
Cascade_button.menu.choices.add_command(label='Chocolate')
|
||||
Cascade_button.menu.choices.add_command(label='Vanilla')
|
||||
Cascade_button.menu.choices.add_command(label='TuttiFruiti')
|
||||
Cascade_button.menu.choices.add_command(label='WopBopaLoopBapABopBamBoom')
|
||||
Cascade_button.menu.choices.add_command(label='Rocky Road')
|
||||
Cascade_button.menu.choices.add_command(label='BubbleGum')
|
||||
Cascade_button.menu.choices.add_cascade(
|
||||
label='Wierd Flavors',
|
||||
menu=Cascade_button.menu.choices.wierdones)
|
||||
|
||||
# and finally, the definition for the top level
|
||||
Cascade_button.menu.add('cascade', {'label' : 'more choices',
|
||||
'menu' : Cascade_button.menu.choices})
|
||||
|
||||
Cascade_button.menu.add_cascade(label='more choices',
|
||||
menu=Cascade_button.menu.choices)
|
||||
|
||||
Cascade_button['menu'] = Cascade_button.menu
|
||||
|
||||
|
@ -152,10 +139,9 @@ def makeCascadeMenu():
|
|||
def makeCheckbuttonMenu():
|
||||
global fred
|
||||
# make menu button
|
||||
Checkbutton_button = Menubutton(mBar, {'text': 'Checkbutton Menus',
|
||||
'underline': 0,
|
||||
Pack: {'side': 'left',
|
||||
'padx': '2m'}})
|
||||
Checkbutton_button = Menubutton(mBar, text='Checkbutton Menus',
|
||||
underline=0)
|
||||
Checkbutton_button.pack(side=LEFT, padx='2m')
|
||||
|
||||
# the primary pulldown
|
||||
Checkbutton_button.menu = Menu(Checkbutton_button)
|
||||
|
@ -163,13 +149,13 @@ def makeCheckbuttonMenu():
|
|||
# and all the check buttons. Note that the "variable" "onvalue" and "offvalue" options
|
||||
# are not supported correctly at present. You have to do all your application
|
||||
# work through the calback.
|
||||
Checkbutton_button.menu.add('checkbutton', {'label': 'Pepperoni'})
|
||||
Checkbutton_button.menu.add('checkbutton', {'label': 'Sausage'})
|
||||
Checkbutton_button.menu.add('checkbutton', {'label': 'Extra Cheese'})
|
||||
Checkbutton_button.menu.add_checkbutton(label='Pepperoni')
|
||||
Checkbutton_button.menu.add_checkbutton(label='Sausage')
|
||||
Checkbutton_button.menu.add_checkbutton(label='Extra Cheese')
|
||||
|
||||
# so here's a callback
|
||||
Checkbutton_button.menu.add('checkbutton', {'label': 'Anchovy',
|
||||
'command' : print_anchovies})
|
||||
Checkbutton_button.menu.add_checkbutton(label='Anchovy',
|
||||
command=print_anchovies)
|
||||
|
||||
# and start with anchovies selected to be on. Do this by
|
||||
# calling invoke on this menu option. To refer to the "anchovy" menu
|
||||
|
@ -196,10 +182,9 @@ def makeCheckbuttonMenu():
|
|||
|
||||
def makeRadiobuttonMenu():
|
||||
# make menu button
|
||||
Radiobutton_button = Menubutton(mBar, {'text': 'Radiobutton Menus',
|
||||
'underline': 0,
|
||||
Pack: {'side': 'left',
|
||||
'padx': '2m'}})
|
||||
Radiobutton_button = Menubutton(mBar, text='Radiobutton Menus',
|
||||
underline=0)
|
||||
Radiobutton_button.pack(side=LEFT, padx='2m')
|
||||
|
||||
# the primary pulldown
|
||||
Radiobutton_button.menu = Menu(Radiobutton_button)
|
||||
|
@ -207,16 +192,16 @@ def makeRadiobuttonMenu():
|
|||
# and all the Radio buttons. Note that the "variable" "onvalue" and "offvalue" options
|
||||
# are not supported correctly at present. You have to do all your application
|
||||
# work through the calback.
|
||||
Radiobutton_button.menu.add('radiobutton', {'label': 'Republican'})
|
||||
Radiobutton_button.menu.add('radiobutton', {'label': 'Democrat'})
|
||||
Radiobutton_button.menu.add('radiobutton', {'label': 'Libertarian'})
|
||||
Radiobutton_button.menu.add('radiobutton', {'label': 'Commie'})
|
||||
Radiobutton_button.menu.add('radiobutton', {'label': 'Facist'})
|
||||
Radiobutton_button.menu.add('radiobutton', {'label': 'Labor Party'})
|
||||
Radiobutton_button.menu.add('radiobutton', {'label': 'Torie'})
|
||||
Radiobutton_button.menu.add('radiobutton', {'label': 'Independent'})
|
||||
Radiobutton_button.menu.add('radiobutton', {'label': 'Anarchist'})
|
||||
Radiobutton_button.menu.add('radiobutton', {'label': 'No Opinion'})
|
||||
Radiobutton_button.menu.add_radiobutton(label='Republican')
|
||||
Radiobutton_button.menu.add_radiobutton(label='Democrat')
|
||||
Radiobutton_button.menu.add_radiobutton(label='Libertarian')
|
||||
Radiobutton_button.menu.add_radiobutton(label='Commie')
|
||||
Radiobutton_button.menu.add_radiobutton(label='Facist')
|
||||
Radiobutton_button.menu.add_radiobutton(label='Labor Party')
|
||||
Radiobutton_button.menu.add_radiobutton(label='Torie')
|
||||
Radiobutton_button.menu.add_radiobutton(label='Independent')
|
||||
Radiobutton_button.menu.add_radiobutton(label='Anarchist')
|
||||
Radiobutton_button.menu.add_radiobutton(label='No Opinion')
|
||||
|
||||
# set up a pointer from the file menubutton back to the file menu
|
||||
Radiobutton_button['menu'] = Radiobutton_button.menu
|
||||
|
@ -225,25 +210,22 @@ def makeRadiobuttonMenu():
|
|||
|
||||
|
||||
def makeDisabledMenu():
|
||||
Dummy_button = Menubutton(mBar, {'text': 'Dead Menu',
|
||||
'underline': 0,
|
||||
Pack: {'side': 'left',
|
||||
'padx': '2m'}})
|
||||
Dummy_button = Menubutton(mBar, text='Dead Menu', underline=0)
|
||||
Dummy_button.pack(side=LEFT, padx='2m')
|
||||
|
||||
# this is the standard way of turning off a whole menu
|
||||
Dummy_button["state"] = "disabled"
|
||||
Dummy_button["state"] = DISABLED
|
||||
return Dummy_button
|
||||
|
||||
|
||||
#################################################
|
||||
#### Main starts here ...
|
||||
root = Tk()
|
||||
|
||||
|
||||
# make a menu bar
|
||||
mBar = Frame(root, {'relief': 'raised',
|
||||
'bd': 2,
|
||||
Pack: {'side': 'top',
|
||||
'fill': 'x'}})
|
||||
mBar = Frame(root, relief=RAISED, borderwidth=2)
|
||||
mBar.pack(fill=X)
|
||||
|
||||
Command_button = makeCommandMenu()
|
||||
Cascade_button = makeCascadeMenu()
|
||||
|
|
|
@ -43,33 +43,23 @@ def open_file():
|
|||
|
||||
def makeFileMenu():
|
||||
# make menu button : "File"
|
||||
File_button = Menubutton(mBar, {'text': 'File',
|
||||
'underline': 0,
|
||||
Pack: {'side': 'left',
|
||||
'padx': '1m'}})
|
||||
|
||||
# make the pulldown part of the File menu. The parameter passed is the master.
|
||||
# we attach it to the File button as a python attribute called "menu" by convention.
|
||||
# hopefully this isn't too confusing...
|
||||
File_button = Menubutton(mBar, text='File', underline=0)
|
||||
File_button.pack(side=LEFT, padx="1m")
|
||||
File_button.menu = Menu(File_button)
|
||||
|
||||
# add an item. The first param is a menu entry type,
|
||||
# must be one of: "cascade", "checkbutton", "command", "radiobutton", "seperator"
|
||||
# see menu-demo-2.py for examples of use
|
||||
File_button.menu.add('command', {'label': 'New...',
|
||||
'underline': 0,
|
||||
'command' : new_file})
|
||||
File_button.menu.add_command(label='New...', underline=0,
|
||||
command=new_file)
|
||||
|
||||
|
||||
File_button.menu.add('command', {'label': 'Open...',
|
||||
'underline': 0,
|
||||
'command' : open_file})
|
||||
|
||||
File_button.menu.add('command', {'label': 'Quit',
|
||||
'underline': 0,
|
||||
'command': 'exit'})
|
||||
|
||||
File_button.menu.add_command(label='Open...', underline=0,
|
||||
command=open_file)
|
||||
|
||||
File_button.menu.add_command(label='Quit', underline=0,
|
||||
command='exit')
|
||||
|
||||
# set up a pointer from the file menubutton back to the file menu
|
||||
File_button['menu'] = File_button.menu
|
||||
|
||||
|
@ -78,22 +68,20 @@ def makeFileMenu():
|
|||
|
||||
|
||||
def makeEditMenu():
|
||||
Edit_button = Menubutton(mBar, {'text': 'Edit',
|
||||
'underline': 0,
|
||||
Pack: {'side': 'left',
|
||||
'padx' : '1m'}})
|
||||
Edit_button = Menubutton(mBar, text='Edit', underline=0)
|
||||
Edit_button.pack(side=LEFT, padx="1m")
|
||||
Edit_button.menu = Menu(Edit_button)
|
||||
|
||||
# just to be cute, let's disable the undo option:
|
||||
Edit_button.menu.add('command', {"label" : "Undo"} )
|
||||
Edit_button.menu.add('command', label="Undo")
|
||||
# undo is the 0th entry...
|
||||
Edit_button.menu.entryconfig(0, {"state" : "disabled"})
|
||||
Edit_button.menu.entryconfig(0, state=DISABLED)
|
||||
|
||||
# and these are just for show. No "command" callbacks attached.
|
||||
Edit_button.menu.add('command', {"label" : "Cut"} )
|
||||
Edit_button.menu.add('command', {"label" : "Copy"} )
|
||||
Edit_button.menu.add('command', {"label" : "Paste"} )
|
||||
|
||||
Edit_button.menu.add_command(label="Cut")
|
||||
Edit_button.menu.add_command(label="Copy")
|
||||
Edit_button.menu.add_command(label="Paste")
|
||||
|
||||
# set up a pointer from the file menubutton back to the file menu
|
||||
Edit_button['menu'] = Edit_button.menu
|
||||
|
||||
|
@ -107,10 +95,8 @@ root = Tk()
|
|||
|
||||
|
||||
# make a menu bar
|
||||
mBar = Frame(root, {'relief': 'raised',
|
||||
'bd': 2,
|
||||
Pack: {'side': 'top',
|
||||
'fill': 'x'}})
|
||||
mBar = Frame(root, relief=RAISED, borderwidth=2)
|
||||
mBar.pack(fill=X)
|
||||
|
||||
File_button = makeFileMenu()
|
||||
Edit_button = makeEditMenu()
|
||||
|
@ -119,7 +105,6 @@ Edit_button = makeEditMenu()
|
|||
# This allows for scanning from one menubutton to the next.
|
||||
mBar.tk_menuBar(File_button, Edit_button)
|
||||
|
||||
|
||||
root.title('menu demo')
|
||||
root.iconname('packer')
|
||||
|
||||
|
|
|
@ -4,19 +4,15 @@ from Tkinter import *
|
|||
class Test(Frame):
|
||||
def createWidgets(self):
|
||||
|
||||
self.Gpanel = Frame(self, {'width': '1i',
|
||||
'height' : '1i',
|
||||
'bg' : 'green'})
|
||||
self.Gpanel.pack({'side' : 'left'})
|
||||
|
||||
self.Gpanel = Frame(self, width='1i', height='1i',
|
||||
background='green')
|
||||
self.Gpanel.pack(side=LEFT)
|
||||
|
||||
# a QUIT button
|
||||
self.Gpanel.QUIT = Button(self.Gpanel, {'text': 'QUIT',
|
||||
'fg': 'red',
|
||||
'command': self.quit})
|
||||
self.Gpanel.QUIT.pack( {'side': 'left'})
|
||||
|
||||
|
||||
self.Gpanel.QUIT = Button(self.Gpanel, text='QUIT',
|
||||
foreground='red',
|
||||
command=self.quit)
|
||||
self.Gpanel.QUIT.pack(side=LEFT)
|
||||
|
||||
|
||||
def __init__(self, master=None):
|
||||
|
|
|
@ -4,25 +4,18 @@ from Tkinter import *
|
|||
class Test(Frame):
|
||||
def createWidgets(self):
|
||||
|
||||
self.Gpanel = Frame(self, {'width': '1i',
|
||||
'height' : '1i',
|
||||
'bg' : 'green'})
|
||||
self.Gpanel = Frame(self, width='1i', height='1i',
|
||||
background='green')
|
||||
|
||||
# this line turns off the recalculation of geometry by masters.
|
||||
self.Gpanel.tk.call('pack', 'propagate', str(self.Gpanel), "0")
|
||||
|
||||
self.Gpanel.pack({'side' : 'left'})
|
||||
|
||||
self.Gpanel.propagate(0)
|
||||
|
||||
self.Gpanel.pack(side=LEFT)
|
||||
|
||||
# a QUIT button
|
||||
self.Gpanel.QUIT = Button(self.Gpanel, {'text': 'QUIT',
|
||||
'fg': 'red',
|
||||
'command': self.quit})
|
||||
self.Gpanel.QUIT.pack( {'side': 'left'})
|
||||
|
||||
|
||||
|
||||
self.Gpanel.QUIT = Button(self.Gpanel, text='QUIT', foreground='red',
|
||||
command=self.quit)
|
||||
self.Gpanel.QUIT.pack(side=LEFT)
|
||||
|
||||
def __init__(self, master=None):
|
||||
Frame.__init__(self, master)
|
||||
|
|
|
@ -5,8 +5,7 @@ from Tkinter import *
|
|||
|
||||
|
||||
def do_motion(event):
|
||||
app.button.place({'x' : event.x,
|
||||
'y' : event.y})
|
||||
app.button.place(x=event.x, y=event.y)
|
||||
|
||||
def dothis():
|
||||
print 'calling me!'
|
||||
|
@ -16,27 +15,20 @@ def createWidgets(top):
|
|||
# and the window containing is 400x400. We do this
|
||||
# simply to show that this is possible. The rest of the
|
||||
# area is inaccesssible.
|
||||
f = Frame(top, {'width' : '200',
|
||||
'height' : '200',
|
||||
'bg' : 'green'})
|
||||
f = Frame(top, width=200, height=200, background='green')
|
||||
|
||||
# note that we use a different manager here.
|
||||
# This way, the top level frame widget resizes when the
|
||||
# application window does.
|
||||
f.pack({'fill' : 'both',
|
||||
'expand' : 1})
|
||||
f.pack(fill=BOTH, expand=1)
|
||||
|
||||
# now make a button
|
||||
f.button = Button(f, {'fg' : 'red',
|
||||
'text' : 'amazing',
|
||||
'command' : dothis})
|
||||
|
||||
f.button = Button(f, foreground='red', text='amazing', command=dothis)
|
||||
|
||||
# and place it so that the nw corner is
|
||||
# 1/2 way along the top X edge of its' parent
|
||||
f.button.place({'relx' : '0.5',
|
||||
'rely' : '0.0',
|
||||
'anchor' : 'nw'})
|
||||
|
||||
f.button.place(relx=0.5, rely=0.0, anchor=NW)
|
||||
|
||||
# allow the user to move the button SUIT-style.
|
||||
f.bind('<Control-Shift-Motion>', do_motion)
|
||||
|
||||
|
|
|
@ -7,23 +7,20 @@ class Test(Frame):
|
|||
|
||||
def createWidgets(self):
|
||||
# a hello button
|
||||
self.QUIT = Button(self, {'text': 'QUIT',
|
||||
'fg': 'red',
|
||||
'command': self.quit})
|
||||
|
||||
self.QUIT.pack({'side': 'left', 'fill': 'both'})
|
||||
self.QUIT = Button(self, text='QUIT', foreground='red',
|
||||
command=self.quit)
|
||||
self.QUIT.pack(side=LEFT, fill=BOTH)
|
||||
|
||||
self.hi_there = Button(self, text='Hello',
|
||||
command=self.printit)
|
||||
self.hi_there.pack(side=LEFT)
|
||||
|
||||
self.hi_there = Button(self, {'text': 'Hello',
|
||||
'command' : self.printit})
|
||||
self.hi_there.pack({'side': 'left'})
|
||||
# note how Packer defaults to side=TOP
|
||||
|
||||
# note how Packer defaults to {'side': 'top'}
|
||||
|
||||
self.guy2 = Button(self, {'text': 'button 2'})
|
||||
self.guy2 = Button(self, text='button 2')
|
||||
self.guy2.pack()
|
||||
|
||||
self.guy3 = Button(self, {'text': 'button 3'})
|
||||
self.guy3 = Button(self, text='button 3')
|
||||
self.guy3.pack()
|
||||
|
||||
def __init__(self, master=None):
|
||||
|
|
|
@ -3,8 +3,7 @@ from Tkinter import *
|
|||
# This is a program that tests the placer geom manager
|
||||
|
||||
def do_motion(event):
|
||||
app.button.place({'x' : event.x,
|
||||
'y' : event.y})
|
||||
app.button.place(x=event.x, y=event.y)
|
||||
|
||||
def dothis():
|
||||
print 'calling me!'
|
||||
|
@ -14,27 +13,20 @@ def createWidgets(top):
|
|||
# and the window containing is 400x400. We do this
|
||||
# simply to show that this is possible. The rest of the
|
||||
# area is inaccesssible.
|
||||
f = Frame(top, {'width' : '200',
|
||||
'height' : '200',
|
||||
'bg' : 'green'})
|
||||
f = Frame(top, width=200, height=200, background='green')
|
||||
|
||||
# place it so the upper left hand corner of
|
||||
# the frame is in the upper left corner of
|
||||
# the parent
|
||||
f.place({'relx' : '0.0',
|
||||
'rely' : '0.0'})
|
||||
f.place(relx=0.0, rely=0.0)
|
||||
|
||||
# now make a button
|
||||
f.button = Button(f, {'fg' : 'red',
|
||||
'text' : 'amazing',
|
||||
'command' : dothis})
|
||||
|
||||
f.button = Button(f, foreground='red', text='amazing', command=dothis)
|
||||
|
||||
# and place it so that the nw corner is
|
||||
# 1/2 way along the top X edge of its' parent
|
||||
f.button.place({'relx' : '0.5',
|
||||
'rely' : '0.0',
|
||||
'anchor' : 'nw'})
|
||||
|
||||
f.button.place(relx=0.5, rely=0.0, anchor=NW)
|
||||
|
||||
# allow the user to move the button SUIT-style.
|
||||
f.bind('<Control-Shift-Motion>', do_motion)
|
||||
|
||||
|
|
|
@ -5,31 +5,28 @@ import string
|
|||
|
||||
class Pong(Frame):
|
||||
def createWidgets(self):
|
||||
self.QUIT = Button(self, {'text': 'QUIT',
|
||||
'fg': 'red',
|
||||
'command': self.quit})
|
||||
self.QUIT.pack({'side': 'left', 'fill': 'both'})
|
||||
self.QUIT = Button(self, text='QUIT', foreground='red',
|
||||
command=self.quit)
|
||||
self.QUIT.pack(side=LEFT, fill=BOTH)
|
||||
|
||||
## The playing field
|
||||
self.draw = Canvas(self, {"width" : "5i", "height" : "5i"})
|
||||
self.draw = Canvas(self, width="5i", height="5i")
|
||||
|
||||
## The speed control for the ball
|
||||
self.speed = Scale(self, {"orient": "horiz",
|
||||
"label" : "ball speed",
|
||||
"from" : -100,
|
||||
"to" : 100})
|
||||
self.speed = Scale(self, orient=HORIZONTAL, label="ball speed",
|
||||
from_=-100, to=100)
|
||||
|
||||
self.speed.pack({'side': 'bottom', "fill" : "x"})
|
||||
self.speed.pack(side=BOTTOM, fill=X)
|
||||
|
||||
# The ball
|
||||
self.ball = self.draw.create_oval("0i", "0i", "0.10i", "0.10i", {"fill" : "red"})
|
||||
self.ball = self.draw.create_oval("0i", "0i", "0.10i", "0.10i",
|
||||
fill="red")
|
||||
self.x = 0.05
|
||||
self.y = 0.05
|
||||
self.velocity_x = 0.3
|
||||
self.velocity_y = 0.5
|
||||
|
||||
self.draw.pack({'side': 'left'})
|
||||
|
||||
self.draw.pack(side=LEFT)
|
||||
|
||||
def moveBall(self, *args):
|
||||
if (self.x > 5.0) or (self.x < 0.0):
|
||||
|
@ -44,8 +41,6 @@ class Pong(Frame):
|
|||
|
||||
self.draw.move(self.ball, `deltax` + "i", `deltay` + "i")
|
||||
self.after(10, self.moveBall)
|
||||
|
||||
|
||||
|
||||
def __init__(self, master=None):
|
||||
Frame.__init__(self, master)
|
||||
|
|
|
@ -8,26 +8,23 @@ class Test(Frame):
|
|||
###################################################################
|
||||
def mouseDown(self, event):
|
||||
# see if we're inside a dot. If we are, it
|
||||
# gets tagged as "current" for free by tk.
|
||||
# gets tagged as CURRENT for free by tk.
|
||||
|
||||
if not event.widget.find_withtag("current"):
|
||||
if not event.widget.find_withtag(CURRENT):
|
||||
# there is no dot here, so we can make one,
|
||||
# and bind some interesting behavior to it.
|
||||
# ------
|
||||
|
||||
# create a dot, and mark it as current
|
||||
fred = self.draw.create_oval(event.x - 10, event.y -10, event.x +10, event.y + 10,
|
||||
{"fill" : "green", "tag" : "current"})
|
||||
|
||||
self.draw.bind(fred, "<Any-Enter>", self.mouseEnter)
|
||||
self.draw.bind(fred, "<Any-Leave>", self.mouseLeave)
|
||||
|
||||
fred = self.draw.create_oval(
|
||||
event.x - 10, event.y -10, event.x +10, event.y + 10,
|
||||
fill="green")
|
||||
self.draw.tag_bind(fred, "<Enter>", self.mouseEnter)
|
||||
self.draw.tag_bind(fred, "<Leave>", self.mouseLeave)
|
||||
self.lastx = event.x
|
||||
self.lasty = event.y
|
||||
|
||||
|
||||
|
||||
def mouseMove(self, event):
|
||||
self.draw.move("current", event.x - self.lastx, event.y - self.lasty)
|
||||
self.draw.move(CURRENT, event.x - self.lastx, event.y - self.lasty)
|
||||
self.lastx = event.x
|
||||
self.lasty = event.y
|
||||
|
||||
|
@ -37,23 +34,21 @@ class Test(Frame):
|
|||
def mouseEnter(self, event):
|
||||
# the "current" tag is applied to the object the cursor is over.
|
||||
# this happens automatically.
|
||||
self.draw.itemconfig("current", {"fill" : "red"})
|
||||
print self.tk.splitlist(self.draw.coords("current"))
|
||||
self.draw.itemconfig(CURRENT, fill="red")
|
||||
print self.draw.coords(CURRENT)
|
||||
|
||||
def mouseLeave(self, event):
|
||||
# the "current" tag is applied to the object the cursor is over.
|
||||
# this happens automatically.
|
||||
self.draw.itemconfig("current", {"fill" : "blue"})
|
||||
self.draw.itemconfig(CURRENT, fill="blue")
|
||||
|
||||
def createWidgets(self):
|
||||
self.QUIT = Button(self, {'text': 'QUIT',
|
||||
'fg': 'red',
|
||||
'command': self.quit})
|
||||
self.QUIT.pack({'side': 'left', 'fill': 'both'})
|
||||
self.draw = Canvas(self, {"width" : "5i", "height" : "5i"})
|
||||
self.draw.pack({'side': 'left'})
|
||||
|
||||
|
||||
self.QUIT = Button(self, text='QUIT', foreground='red',
|
||||
command=self.quit)
|
||||
self.QUIT.pack(side=LEFT, fill=BOTH)
|
||||
self.draw = Canvas(self, width="5i", height="5i")
|
||||
self.draw.pack(side=LEFT)
|
||||
|
||||
Widget.bind(self.draw, "<1>", self.mouseDown)
|
||||
Widget.bind(self.draw, "<B1-Motion>", self.mouseMove)
|
||||
|
||||
|
|
|
@ -26,34 +26,30 @@ class Test(Frame):
|
|||
# 'variable' is the name of the variable that all these radio buttons share
|
||||
# 'value' is the value this variable takes on when the radio button is selected
|
||||
# 'anchor' makes the text appear left justified (default is centered. ick)
|
||||
self.radioframe.choc = Radiobutton (self.radioframe, {"text" : "Chocolate Flavor",
|
||||
"variable" : self.flavor,
|
||||
"value" : "chocolate",
|
||||
"anchor" : "w",
|
||||
Pack : {"side" : "top", "fill" : "x"}})
|
||||
self.radioframe.choc = Radiobutton(
|
||||
self.radioframe, text="Chocolate Flavor",
|
||||
variable=self.flavor, value="chocolate",
|
||||
anchor=W)
|
||||
self.radioframe.choc.pack(fill=X)
|
||||
|
||||
self.radioframe.straw = Radiobutton (self.radioframe, {"text" : "Strawberry Flavor",
|
||||
"variable" : self.flavor,
|
||||
"anchor" : "w",
|
||||
"value" : "strawberry",
|
||||
Pack : {"side" : "top", "fill" : "x"}})
|
||||
|
||||
self.radioframe.lemon = Radiobutton (self.radioframe, {"text" : "Lemon Flavor",
|
||||
"anchor" : "w",
|
||||
"variable" : self.flavor,
|
||||
"value" : "lemon",
|
||||
Pack : {"side" : "top", "fill" : "x"}})
|
||||
self.radioframe.straw = Radiobutton(
|
||||
self.radioframe, text="Strawberry Flavor",
|
||||
variable=self.flavor, value="strawberry",
|
||||
anchor=W)
|
||||
self.radioframe.straw.pack(fill=X)
|
||||
|
||||
self.radioframe.lemon = Radiobutton(
|
||||
self.radioframe, text="Lemon Flavor",
|
||||
variable=self.flavor, value="lemon",
|
||||
anchor=W)
|
||||
self.radioframe.lemon.pack(fill=X)
|
||||
|
||||
# this is a text entry that lets you type in the name of a flavor too.
|
||||
self.entry = Entry(self, {"textvariable" : self.flavor,
|
||||
Pack : {"side" : "top", "fill" : "x"}})
|
||||
self.QUIT = Button(self, {'text': 'QUIT',
|
||||
'fg': 'red',
|
||||
'command': self.quit})
|
||||
|
||||
self.QUIT.pack({'side': 'bottom', 'fill': 'both'})
|
||||
|
||||
self.entry = Entry(self, textvariable=self.flavor)
|
||||
self.entry.pack(fill=X)
|
||||
self.QUIT = Button(self, text='QUIT', foreground='red',
|
||||
command=self.quit)
|
||||
self.QUIT.pack(side=BOTTOM, fill=BOTH)
|
||||
|
||||
|
||||
def __init__(self, master=None):
|
||||
|
|
|
@ -5,15 +5,15 @@ class Test(Frame):
|
|||
print "hi"
|
||||
|
||||
def createWidgets(self):
|
||||
self.QUIT = Button(self, {'text': 'QUIT',
|
||||
'bg': 'red',
|
||||
'fg': 'white',
|
||||
'height' : 3,
|
||||
'command': self.quit})
|
||||
self.QUIT.pack({'side': 'bottom', 'fill': 'both'})
|
||||
self.QUIT = Button(self, text='QUIT',
|
||||
background='red',
|
||||
foreground='white',
|
||||
height=3,
|
||||
command=self.quit)
|
||||
self.QUIT.pack(side=BOTTOM, fill=BOTH)
|
||||
|
||||
self.canvasObject = Canvas(self, {"width" : "5i", "height" : "5i"})
|
||||
self.canvasObject.pack({'side': 'left'})
|
||||
self.canvasObject = Canvas(self, width="5i", height="5i")
|
||||
self.canvasObject.pack(side=LEFT)
|
||||
|
||||
def mouseDown(self, event):
|
||||
# canvas x and y take the screen coords from the event and translate
|
||||
|
@ -29,7 +29,8 @@ class Test(Frame):
|
|||
|
||||
if (self.startx != event.x) and (self.starty != event.y) :
|
||||
self.canvasObject.delete(self.rubberbandBox)
|
||||
self.rubberbandBox = self.canvasObject.create_rectangle(self.startx, self.starty, x, y)
|
||||
self.rubberbandBox = self.canvasObject.create_rectangle(
|
||||
self.startx, self.starty, x, y)
|
||||
# this flushes the output, making sure that
|
||||
# the rectangle makes it to the screen
|
||||
# before the next event is handled
|
||||
|
@ -50,7 +51,7 @@ class Test(Frame):
|
|||
Widget.bind(self.canvasObject, "<Button-1>", self.mouseDown)
|
||||
Widget.bind(self.canvasObject, "<Button1-Motion>", self.mouseMotion)
|
||||
Widget.bind(self.canvasObject, "<Button1-ButtonRelease>", self.mouseUp)
|
||||
|
||||
|
||||
|
||||
test = Test()
|
||||
|
||||
|
|
|
@ -5,15 +5,15 @@ class Test(Frame):
|
|||
print "hi"
|
||||
|
||||
def createWidgets(self):
|
||||
self.QUIT = Button(self, {'text': 'QUIT',
|
||||
'bg': 'red',
|
||||
'fg': 'white',
|
||||
'height' : 3,
|
||||
'command': self.quit})
|
||||
self.QUIT.pack({'side': 'bottom', 'fill': 'both'})
|
||||
self.QUIT = Button(self, text='QUIT',
|
||||
background='red',
|
||||
foreground='white',
|
||||
height=3,
|
||||
command=self.quit)
|
||||
self.QUIT.pack(side=BOTTOM, fill=BOTH)
|
||||
|
||||
self.canvasObject = Canvas(self, {"width" : "5i", "height" : "5i"})
|
||||
self.canvasObject.pack({'side': 'left'})
|
||||
self.canvasObject = Canvas(self, width="5i", height="5i")
|
||||
self.canvasObject.pack(side=LEFT)
|
||||
|
||||
def mouseDown(self, event):
|
||||
# canvas x and y take the screen coords from the event and translate
|
||||
|
@ -29,7 +29,8 @@ class Test(Frame):
|
|||
|
||||
if (self.startx != event.x) and (self.starty != event.y) :
|
||||
self.canvasObject.delete(self.rubberbandLine)
|
||||
self.rubberbandLine = self.canvasObject.create_line(self.startx, self.starty, x, y)
|
||||
self.rubberbandLine = self.canvasObject.create_line(
|
||||
self.startx, self.starty, x, y)
|
||||
# this flushes the output, making sure that
|
||||
# the rectangle makes it to the screen
|
||||
# before the next event is handled
|
||||
|
|
|
@ -11,25 +11,21 @@ class Test(Frame):
|
|||
self.slider.set(0)
|
||||
|
||||
def createWidgets(self):
|
||||
self.slider = Scale(self, {"from" : 0,
|
||||
'to': 100,
|
||||
"orient" : "horizontal",
|
||||
"length" : "3i",
|
||||
"label" : "happy slider",
|
||||
'command' : self.print_value})
|
||||
self.slider = Scale(self, from_=0, to=100,
|
||||
orient=HORIZONTAL,
|
||||
length="3i",
|
||||
label="happy slider",
|
||||
command=self.print_value)
|
||||
|
||||
self.reset = Button(self, {'text': 'reset slider',
|
||||
'command': self.reset})
|
||||
|
||||
self.reset = Button(self, text='reset slider',
|
||||
command=self.reset)
|
||||
|
||||
self.QUIT = Button(self, {'text': 'QUIT',
|
||||
'fg': 'red',
|
||||
'command': self.quit})
|
||||
|
||||
self.QUIT = Button(self, text='QUIT', foreground='red',
|
||||
command=self.quit)
|
||||
|
||||
self.slider.pack({'side': 'left'})
|
||||
self.reset.pack({'side': 'left'})
|
||||
self.QUIT.pack({'side': 'left', 'fill': 'both'})
|
||||
self.slider.pack(side=LEFT)
|
||||
self.reset.pack(side=LEFT)
|
||||
self.QUIT.pack(side=LEFT, fill=BOTH)
|
||||
|
||||
def __init__(self, master=None):
|
||||
Frame.__init__(self, master)
|
||||
|
|
|
@ -11,22 +11,18 @@ class New_Button(Button):
|
|||
def createWidgets(top):
|
||||
f = Frame(top)
|
||||
f.pack()
|
||||
f.QUIT = Button(f, {'text': 'QUIT',
|
||||
'fg': 'red',
|
||||
'command': top.quit})
|
||||
|
||||
f.QUIT.pack({'side': 'left', 'fill': 'both'})
|
||||
f.QUIT = Button(f, text='QUIT', foreground='red', command=top.quit)
|
||||
|
||||
f.QUIT.pack(side=LEFT, fill=BOTH)
|
||||
|
||||
# a hello button
|
||||
f.hi_there = New_Button(f, {'text': 'Hello'})
|
||||
f.hi_there = New_Button(f, text='Hello')
|
||||
# we do this on a different line because we need to reference f.hi_there
|
||||
f.hi_there.config({'command' : f.hi_there.callback})
|
||||
f.hi_there.pack({'side': 'left'})
|
||||
f.hi_there.config(command=f.hi_there.callback)
|
||||
f.hi_there.pack(side=LEFT)
|
||||
f.hi_there.counter = 43
|
||||
|
||||
|
||||
|
||||
root = Tk()
|
||||
createWidgets(root)
|
||||
root.mainloop()
|
||||
|
|
|
@ -19,29 +19,27 @@ from Tkinter import *
|
|||
|
||||
|
||||
|
||||
def makePoliticalParties():
|
||||
def makePoliticalParties(var):
|
||||
# make menu button
|
||||
Radiobutton_button = Menubutton(mBar, {'text': 'Political Party',
|
||||
'underline': 0,
|
||||
Pack: {'side': 'left',
|
||||
'padx': '2m'}})
|
||||
Radiobutton_button = Menubutton(mBar, text='Political Party',
|
||||
underline=0)
|
||||
Radiobutton_button.pack(side=LEFT, padx='2m')
|
||||
|
||||
# the primary pulldown
|
||||
Radiobutton_button.menu = Menu(Radiobutton_button)
|
||||
|
||||
Radiobutton_button.menu.add('radiobutton', {'label': 'Republican',
|
||||
'variable' : party,
|
||||
'value' : 1})
|
||||
Radiobutton_button.menu.add_radiobutton(label='Republican',
|
||||
variable=var, value=1)
|
||||
|
||||
Radiobutton_button.menu.add('radiobutton', {'label': 'Democrat',
|
||||
'variable' : party,
|
||||
'variable' : var,
|
||||
'value' : 2})
|
||||
|
||||
Radiobutton_button.menu.add('radiobutton', {'label': 'Libertarian',
|
||||
'variable' : party,
|
||||
'variable' : var,
|
||||
'value' : 3})
|
||||
|
||||
party.set(2)
|
||||
var.set(2)
|
||||
|
||||
# set up a pointer from the file menubutton back to the file menu
|
||||
Radiobutton_button['menu'] = Radiobutton_button.menu
|
||||
|
@ -49,29 +47,26 @@ def makePoliticalParties():
|
|||
return Radiobutton_button
|
||||
|
||||
|
||||
def makeFlavors():
|
||||
def makeFlavors(var):
|
||||
# make menu button
|
||||
Radiobutton_button = Menubutton(mBar, {'text': 'Flavors',
|
||||
'underline': 0,
|
||||
Pack: {'side': 'left',
|
||||
'padx': '2m'}})
|
||||
Radiobutton_button = Menubutton(mBar, text='Flavors',
|
||||
underline=0)
|
||||
Radiobutton_button.pack(side=LEFT, padx='2m')
|
||||
|
||||
# the primary pulldown
|
||||
Radiobutton_button.menu = Menu(Radiobutton_button)
|
||||
|
||||
Radiobutton_button.menu.add('radiobutton', {'label': 'Strawberry',
|
||||
'variable' : flavor,
|
||||
'value' : 'Strawberry'})
|
||||
Radiobutton_button.menu.add_radiobutton(label='Strawberry',
|
||||
variable=var, value='Strawberry')
|
||||
|
||||
Radiobutton_button.menu.add('radiobutton', {'label': 'Chocolate',
|
||||
'variable' : flavor,
|
||||
'value' : 'Chocolate'})
|
||||
Radiobutton_button.menu.add_radiobutton(label='Chocolate',
|
||||
variable=var, value='Chocolate')
|
||||
|
||||
Radiobutton_button.menu.add('radiobutton', {'label': 'Rocky Road',
|
||||
'variable' : flavor,
|
||||
'value' : 'Rocky Road'})
|
||||
Radiobutton_button.menu.add_radiobutton(label='Rocky Road',
|
||||
variable=var, value='Rocky Road')
|
||||
|
||||
# choose a default
|
||||
flavor.set("Chocolate")
|
||||
var.set("Chocolate")
|
||||
|
||||
# set up a pointer from the file menubutton back to the file menu
|
||||
Radiobutton_button['menu'] = Radiobutton_button.menu
|
||||
|
@ -82,7 +77,7 @@ def makeFlavors():
|
|||
def printStuff():
|
||||
print "party is", party.get()
|
||||
print "flavor is", flavor.get()
|
||||
print ""
|
||||
print
|
||||
|
||||
#################################################
|
||||
#### Main starts here ...
|
||||
|
@ -90,27 +85,24 @@ root = Tk()
|
|||
|
||||
|
||||
# make a menu bar
|
||||
mBar = Frame(root, {'relief': 'raised',
|
||||
'bd': 2,
|
||||
Pack: {'side': 'top',
|
||||
'fill': 'x'}})
|
||||
mBar = Frame(root, relief=RAISED, borderwidth=2)
|
||||
mBar.pack(fill=X)
|
||||
|
||||
# make two application variables,
|
||||
# one to control each radio button set
|
||||
party = IntVar()
|
||||
flavor = StringVar()
|
||||
|
||||
Radiobutton_button = makePoliticalParties()
|
||||
Radiobutton_button2 = makeFlavors()
|
||||
Radiobutton_button = makePoliticalParties(party)
|
||||
Radiobutton_button2 = makeFlavors(flavor)
|
||||
|
||||
# finally, install the buttons in the menu bar.
|
||||
# This allows for scanning from one menubutton to the next.
|
||||
mBar.tk_menuBar(Radiobutton_button, Radiobutton_button2)
|
||||
|
||||
b = Button(root, {"text": "print party and flavor",
|
||||
"command" : printStuff,
|
||||
"fg": "red"})
|
||||
b.pack({"side" : "top"})
|
||||
b = Button(root, text="print party and flavor", foreground="red",
|
||||
command=printStuff)
|
||||
b.pack(side=TOP)
|
||||
|
||||
root.title('menu demo')
|
||||
root.iconname('menu demo')
|
||||
|
|
|
@ -1,6 +1,7 @@
|
|||
from Tkinter import *
|
||||
|
||||
# this shows how to create a new window with a button in it that can create new windows
|
||||
# this shows how to create a new window with a button in it
|
||||
# that can create new windows
|
||||
|
||||
class Test(Frame):
|
||||
def printit(self):
|
||||
|
@ -8,24 +9,21 @@ class Test(Frame):
|
|||
|
||||
def makeWindow(self):
|
||||
fred = Toplevel()
|
||||
fred.label = Button(fred, {'text': "This is window number " + `self.windownum` + "." ,
|
||||
'command' : self.makeWindow})
|
||||
fred.label = Button(fred,
|
||||
text="This is window number %d." % self.windownum,
|
||||
command=self.makeWindow)
|
||||
fred.label.pack()
|
||||
self.windownum = self.windownum + 1
|
||||
|
||||
def createWidgets(self):
|
||||
self.QUIT = Button(self, {'text': 'QUIT',
|
||||
'fg': 'red',
|
||||
'command': self.quit})
|
||||
|
||||
self.QUIT.pack({'side': 'left', 'fill': 'both'})
|
||||
|
||||
self.QUIT = Button(self, text='QUIT', foreground='red',
|
||||
command=self.quit)
|
||||
self.QUIT.pack(side=LEFT, fill=BOTH)
|
||||
|
||||
# a hello button
|
||||
self.hi_there = Button(self, {'text': 'Make a New Window',
|
||||
'command' : self.makeWindow})
|
||||
self.hi_there.pack({'side': 'left'})
|
||||
|
||||
self.hi_there = Button(self, text='Make a New Window',
|
||||
command=self.makeWindow)
|
||||
self.hi_there.pack(side=LEFT)
|
||||
|
||||
def __init__(self, master=None):
|
||||
Frame.__init__(self, master)
|
||||
|
|
|
@ -8,22 +8,19 @@ class Test(Frame):
|
|||
|
||||
def makeWindow(self):
|
||||
fred = Toplevel()
|
||||
fred.label = Label(fred, {'text': "Here's a new window",})
|
||||
fred.label = Label(fred, text="Here's a new window")
|
||||
fred.label.pack()
|
||||
|
||||
def createWidgets(self):
|
||||
self.QUIT = Button(self, {'text': 'QUIT',
|
||||
'fg': 'red',
|
||||
'command': self.quit})
|
||||
self.QUIT = Button(self, text='QUIT', foreground='red',
|
||||
command=self.quit)
|
||||
|
||||
self.QUIT.pack({'side': 'left', 'fill': 'both'})
|
||||
|
||||
self.QUIT.pack(side=LEFT, fill=BOTH)
|
||||
|
||||
# a hello button
|
||||
self.hi_there = Button(self, {'text': 'Make a New Window',
|
||||
'command' : self.makeWindow})
|
||||
self.hi_there.pack({'side': 'left'})
|
||||
|
||||
self.hi_there = Button(self, text='Make a New Window',
|
||||
command=self.makeWindow)
|
||||
self.hi_there.pack(side=LEFT)
|
||||
|
||||
def __init__(self, master=None):
|
||||
Frame.__init__(self, master)
|
||||
|
|
|
@ -4,15 +4,15 @@ import sys
|
|||
sys.path.append("/users/mjc4y/projects/python/tkinter/utils")
|
||||
from TkinterUtils import *
|
||||
|
||||
# this shows how to create a new window with a button in it that can create new windows
|
||||
# this shows how to create a new window with a button in it that
|
||||
# can create new windows
|
||||
|
||||
|
||||
class Test(Frame):
|
||||
def makeWindow(self, *args):
|
||||
fred = Toplevel()
|
||||
|
||||
fred.label = Canvas (fred, {"width" : "2i",
|
||||
"height" : "2i"})
|
||||
fred.label = Canvas (fred, width="2i", height="2i")
|
||||
|
||||
fred.label.create_line("0", "0", "2i", "2i")
|
||||
fred.label.create_line("0", "2i", "2i", "0")
|
||||
|
@ -22,14 +22,12 @@ class Test(Frame):
|
|||
|
||||
def createWidgets(self):
|
||||
self.QUIT = QuitButton(self)
|
||||
self.QUIT.pack({'side': 'left', 'fill': 'both'})
|
||||
self.QUIT.pack(side=LEFT, fill=BOTH)
|
||||
|
||||
|
||||
self.makeWindow = Button(self, {'text': 'Make a New Window',
|
||||
'width' : 50,
|
||||
'height' : 20,
|
||||
'command' : self.makeWindow})
|
||||
self.makeWindow.pack({'side': 'left'})
|
||||
self.makeWindow = Button(self, text='Make a New Window',
|
||||
width=50, height=20,
|
||||
command=self.makeWindow)
|
||||
self.makeWindow.pack(side=LEFT)
|
||||
|
||||
def __init__(self, master=None):
|
||||
Frame.__init__(self, master)
|
||||
|
|
Loading…
Reference in New Issue