| Current File : /home/mmdealscpanel/yummmdeals.com/lib-tk.tar |
tkSimpleDialog.py 0000644 00000017053 15032720555 0010040 0 ustar 00 #
# An Introduction to Tkinter
# tkSimpleDialog.py
#
# Copyright (c) 1997 by Fredrik Lundh
#
# fredrik@pythonware.com
# http://www.pythonware.com
#
# --------------------------------------------------------------------
# dialog base class
'''Dialog boxes
This module handles dialog boxes. It contains the following
public symbols:
Dialog -- a base class for dialogs
askinteger -- get an integer from the user
askfloat -- get a float from the user
askstring -- get a string from the user
'''
from Tkinter import *
class Dialog(Toplevel):
'''Class to open dialogs.
This class is intended as a base class for custom dialogs
'''
def __init__(self, parent, title = None):
'''Initialize a dialog.
Arguments:
parent -- a parent window (the application window)
title -- the dialog title
'''
Toplevel.__init__(self, parent)
self.withdraw() # remain invisible for now
# If the master is not viewable, don't
# make the child transient, or else it
# would be opened withdrawn
if parent.winfo_viewable():
self.transient(parent)
if title:
self.title(title)
self.parent = parent
self.result = None
body = Frame(self)
self.initial_focus = self.body(body)
body.pack(padx=5, pady=5)
self.buttonbox()
if not self.initial_focus:
self.initial_focus = self
self.protocol("WM_DELETE_WINDOW", self.cancel)
if self.parent is not None:
self.geometry("+%d+%d" % (parent.winfo_rootx()+50,
parent.winfo_rooty()+50))
self.deiconify() # become visibile now
self.initial_focus.focus_set()
# wait for window to appear on screen before calling grab_set
self.wait_visibility()
self.grab_set()
self.wait_window(self)
def destroy(self):
'''Destroy the window'''
self.initial_focus = None
Toplevel.destroy(self)
#
# construction hooks
def body(self, master):
'''create dialog body.
return widget that should have initial focus.
This method should be overridden, and is called
by the __init__ method.
'''
pass
def buttonbox(self):
'''add standard button box.
override if you do not want the standard buttons
'''
box = Frame(self)
w = Button(box, text="OK", width=10, command=self.ok, default=ACTIVE)
w.pack(side=LEFT, padx=5, pady=5)
w = Button(box, text="Cancel", width=10, command=self.cancel)
w.pack(side=LEFT, padx=5, pady=5)
self.bind("<Return>", self.ok)
self.bind("<Escape>", self.cancel)
box.pack()
#
# standard button semantics
def ok(self, event=None):
if not self.validate():
self.initial_focus.focus_set() # put focus back
return
self.withdraw()
self.update_idletasks()
try:
self.apply()
finally:
self.cancel()
def cancel(self, event=None):
# put focus back to the parent window
if self.parent is not None:
self.parent.focus_set()
self.destroy()
#
# command hooks
def validate(self):
'''validate the data
This method is called automatically to validate the data before the
dialog is destroyed. By default, it always validates OK.
'''
return 1 # override
def apply(self):
'''process the data
This method is called automatically to process the data, *after*
the dialog is destroyed. By default, it does nothing.
'''
pass # override
# --------------------------------------------------------------------
# convenience dialogues
class _QueryDialog(Dialog):
def __init__(self, title, prompt,
initialvalue=None,
minvalue = None, maxvalue = None,
parent = None):
if not parent:
import Tkinter
parent = Tkinter._default_root
self.prompt = prompt
self.minvalue = minvalue
self.maxvalue = maxvalue
self.initialvalue = initialvalue
Dialog.__init__(self, parent, title)
def destroy(self):
self.entry = None
Dialog.destroy(self)
def body(self, master):
w = Label(master, text=self.prompt, justify=LEFT)
w.grid(row=0, padx=5, sticky=W)
self.entry = Entry(master, name="entry")
self.entry.grid(row=1, padx=5, sticky=W+E)
if self.initialvalue is not None:
self.entry.insert(0, self.initialvalue)
self.entry.select_range(0, END)
return self.entry
def validate(self):
import tkMessageBox
try:
result = self.getresult()
except ValueError:
tkMessageBox.showwarning(
"Illegal value",
self.errormessage + "\nPlease try again",
parent = self
)
return 0
if self.minvalue is not None and result < self.minvalue:
tkMessageBox.showwarning(
"Too small",
"The allowed minimum value is %s. "
"Please try again." % self.minvalue,
parent = self
)
return 0
if self.maxvalue is not None and result > self.maxvalue:
tkMessageBox.showwarning(
"Too large",
"The allowed maximum value is %s. "
"Please try again." % self.maxvalue,
parent = self
)
return 0
self.result = result
return 1
class _QueryInteger(_QueryDialog):
errormessage = "Not an integer."
def getresult(self):
return int(self.entry.get())
def askinteger(title, prompt, **kw):
'''get an integer from the user
Arguments:
title -- the dialog title
prompt -- the label text
**kw -- see SimpleDialog class
Return value is an integer
'''
d = _QueryInteger(title, prompt, **kw)
return d.result
class _QueryFloat(_QueryDialog):
errormessage = "Not a floating point value."
def getresult(self):
return float(self.entry.get())
def askfloat(title, prompt, **kw):
'''get a float from the user
Arguments:
title -- the dialog title
prompt -- the label text
**kw -- see SimpleDialog class
Return value is a float
'''
d = _QueryFloat(title, prompt, **kw)
return d.result
class _QueryString(_QueryDialog):
def __init__(self, *args, **kw):
if "show" in kw:
self.__show = kw["show"]
del kw["show"]
else:
self.__show = None
_QueryDialog.__init__(self, *args, **kw)
def body(self, master):
entry = _QueryDialog.body(self, master)
if self.__show is not None:
entry.configure(show=self.__show)
return entry
def getresult(self):
return self.entry.get()
def askstring(title, prompt, **kw):
'''get a string from the user
Arguments:
title -- the dialog title
prompt -- the label text
**kw -- see SimpleDialog class
Return value is a string
'''
d = _QueryString(title, prompt, **kw)
return d.result
if __name__ == "__main__":
root = Tk()
root.update()
print askinteger("Spam", "Egg count", initialvalue=12*12)
print askfloat("Spam", "Egg weight\n(in tons)", minvalue=1, maxvalue=100)
print askstring("Spam", "Egg label")
tkFont.pyo 0000644 00000016004 15032720555 0006547 0 ustar 00 �
z fc @ s� d Z d d l Z d Z d Z d Z d Z d � Z d d d � � YZ d d
� Z d d � Z
e d k r�e j � Z
e d
d d d d e � Z e j � GHe j d
� GHe j d � GHe j � GHe j d
� GHe j d � GHe
� GHe j d � Ge j d � GHe j � GHe d d � Z e j d � Ge j d � GHe j e
d d d e �Z e j � e j e
d d d e
j �Z e j � e d e d � j � Z e j d e � e j d e � e j � n d S( s 0.9i����Nt normalt romant boldt italicc C s t d | d t � S( sF Given the name of a tk named font, returns a Font representation.
t namet exists( t Fontt True( R ( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyt
nametofont s R c B s� e Z d Z d � Z d � Z d � Z d d d e d � Z d � Z d � Z
d � Z d � Z d � Z
d
� Z d d � Z d � Z d
� Z e Z d � Z d � Z RS( s� Represents a named font.
Constructor options are:
font -- font specifier (name, system font, or (family, size, style)-tuple)
name -- name to use for this font configuration (defaults to a unique name)
exists -- does a named font by this name already exist?
Creates a new named font if False, points to the existing font if True.
Raises _Tkinter.TclError if the assertion is false.
the following are ignored if font is specified:
family -- font 'family', e.g. Courier, Times, Helvetica
size -- font size in points
weight -- font thickness: NORMAL, BOLD
slant -- font slant: ROMAN, ITALIC
underline -- font underlining: false (0), true (1)
overstrike -- font strikeout: false (0), true (1)
c C si g } xV | j � D]H \ } } t | t � s= t | � } n | j d | � | j | � q Wt | � S( Nt -( t itemst
isinstancet
basestringt strt appendt tuple( t selft kwt optionst kt v( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyt _set/ s c C s2 g } x | D] } | j d | � q
Wt | � S( NR ( R R ( R t argsR R ( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyt _get8 s
c C sG i } x: t d t | � d � D] } | | d | | | d <q W| S( Ni i i ( t ranget len( R R R t i( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyt _mkdict> s c K s= | s t j } n t | d | � } | rK | j | j d d | � � } n | j | � } | sy d t t | � � } n | | _ | r� t | _
| j | j | j d d � � k r� t j j d | j f � n | r| j d d | j | � qn" | j d d | j | � t
| _
| | _ | j | _ | j | _ d S( Nt tkt fontt actualt namess$ named font %s does not already existt configuret create( t Tkintert
_default_roott getattrt splitlistt callR R
t idR t Falset delete_fontt _tkintert TclErrorR t _tkt _splitt _call( R t rootR R R R R ( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyt __init__D s( ! $ c C s | j S( N( R ( R ( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyt __str__a s c C s t | t � o | j | j k S( N( R R R ( R t other( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyt __eq__d s c C s
| j | � S( N( t cget( R t key( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyt __getitem__g s c C s | j i | | 6� d S( N( R ( R R5 t value( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyt __setitem__j s c C sW y& | j r% | j d d | j � n Wn* t t f k
rB � n t k
rR n Xd S( NR t delete( R) R. R t KeyboardInterruptt
SystemExitt Exception( R ( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyt __del__m s
c C s t | j | j � � S( s* Return a distinct copy of the current font( R R, R ( R ( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyt copyv s c C sO | r# | j d d | j d | � S| j | j | j d d | j � � � Sd S( s Return actual font attributesR R R N( R. R R R- ( R t option( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyR z s c C s | j d d | j d | � S( s Get font attributeR t configR ( R. R ( R R? ( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyR4 � s c K sW | r+ | j d d | j | j | � � n( | j | j | j d d | j � � � Sd S( s Modify font attributesR R@ N( R. R R R R- ( R R ( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyR@ � s
c C s t | j d d | j | � � S( s Return text widthR t measure( t intR. R ( R t text( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyRA � s c G s� | r. t | j d d | j | j | � � � S| j | j d d | j � � } i } x@ t d t | � d � D]& } t | | d � | | | d <qn W| Sd S( s} Return font metrics.
For best performance, create a dummy widget
using this font before calling this method.R t metricsi i i N( RB R. R R R- R R ( R R t resR ( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyRD � s %! $N( t __name__t
__module__t __doc__R R R t NoneR( R0 R1 R3 R6 R8 R= R> R R4 R@ R RA RD ( ( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyR s"
c C s1 | s t j } n | j j | j j d d � � S( s Get font families (as a tuple)R t families( R" R# R R% R& ( R/ ( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyRJ � s c C s1 | s t j } n | j j | j j d d � � S( s' Get names of defined fonts (as a tuple)R R ( R" R# R R% R& ( R/ ( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyR � s t __main__t familyt timest sizei t weightt hellot linespaceR t Courieri RC s Hello, worlds Quit!t command( ( RR i R ( t __version__R" t NORMALt ROMANt BOLDt ITALICR R RI RJ R RF t TkR/ t fR R@ R4 RA RD t Labelt wt packt Buttont destroyR> t fbt mainloop( ( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyt <module> s> �
Tkconstants.pyo 0000644 00000004306 15032720555 0007617 0 ustar 00 �
z fc @ s� d Z Z Z d Z Z Z d Z d Z d Z d Z d Z
d Z d Z d Z
d
Z d Z d Z d
Z d Z d Z d Z d Z d Z d Z d Z d Z d Z d Z d Z d Z d Z d Z d Z d Z! d Z" d Z# d Z$ d! Z% d" Z& d# Z' d$ Z( d% Z) d& Z* d' Z+ d( Z, d) Z- d* Z. d+ Z/ d, Z0 d- Z1 d. Z2 d/ Z3 d0 Z4 d1 Z5 d2 Z6 d3 Z7 d4 Z8 d5 Z9 d6 Z: d7 Z; d8 Z< d9 Z= d: Z> d; Z? d< Z@ d= ZA d> ZB d? ZC d@ ZD dA ZE dB ZF dC ZG dD ZH dE ZI dF ZJ dG ZK dH ZL dI S(J i i t nt st wt et nwt swt net set nst ewt nsewt centert nonet xt yt botht leftt topt rightt bottomt raisedt sunkent flatt ridget groovet solidt
horizontalt verticalt numerict chart wordt baselinet insidet outsidet sels sel.firsts sel.lastt endt insertt currentt anchort allt normalt disabledt activet hiddent cascadet checkbuttont commandt radiobuttont separatort singlet browset multiplet extendedt dotboxt underlinet pieslicet chordt arct firstt lastt buttt
projectingt roundt bevelt mitert movetot scrollt unitst pagesN(M t NOt FALSEt OFFt YESt TRUEt ONt Nt St Wt Et NWt SWt NEt SEt NSt EWt NSEWt CENTERt NONEt Xt Yt BOTHt LEFTt TOPt RIGHTt BOTTOMt RAISEDt SUNKENt FLATt RIDGEt GROOVEt SOLIDt
HORIZONTALt VERTICALt NUMERICt CHARt WORDt BASELINEt INSIDEt OUTSIDEt SELt SEL_FIRSTt SEL_LASTt ENDt INSERTt CURRENTt ANCHORt ALLt NORMALt DISABLEDt ACTIVEt HIDDENt CASCADEt CHECKBUTTONt COMMANDt RADIOBUTTONt SEPARATORt SINGLEt BROWSEt MULTIPLEt EXTENDEDt DOTBOXt UNDERLINEt PIESLICEt CHORDt ARCt FIRSTt LASTt BUTTt
PROJECTINGt ROUNDt BEVELt MITERt MOVETOt SCROLLt UNITSt PAGES( ( ( s* /usr/lib64/python2.7/lib-tk/Tkconstants.pyt <module> s� tkFont.py 0000644 00000014022 15032720555 0006366 0 ustar 00 # Tkinter font wrapper
#
# written by Fredrik Lundh, February 1998
#
# FIXME: should add 'displayof' option where relevant (actual, families,
# measure, and metrics)
#
__version__ = "0.9"
import Tkinter
# weight/slant
NORMAL = "normal"
ROMAN = "roman"
BOLD = "bold"
ITALIC = "italic"
def nametofont(name):
"""Given the name of a tk named font, returns a Font representation.
"""
return Font(name=name, exists=True)
class Font:
"""Represents a named font.
Constructor options are:
font -- font specifier (name, system font, or (family, size, style)-tuple)
name -- name to use for this font configuration (defaults to a unique name)
exists -- does a named font by this name already exist?
Creates a new named font if False, points to the existing font if True.
Raises _Tkinter.TclError if the assertion is false.
the following are ignored if font is specified:
family -- font 'family', e.g. Courier, Times, Helvetica
size -- font size in points
weight -- font thickness: NORMAL, BOLD
slant -- font slant: ROMAN, ITALIC
underline -- font underlining: false (0), true (1)
overstrike -- font strikeout: false (0), true (1)
"""
def _set(self, kw):
options = []
for k, v in kw.items():
if not isinstance(v, basestring):
v = str(v)
options.append("-"+k)
options.append(v)
return tuple(options)
def _get(self, args):
options = []
for k in args:
options.append("-"+k)
return tuple(options)
def _mkdict(self, args):
options = {}
for i in range(0, len(args), 2):
options[args[i][1:]] = args[i+1]
return options
def __init__(self, root=None, font=None, name=None, exists=False, **options):
if not root:
root = Tkinter._default_root
tk = getattr(root, 'tk', root)
if font:
# get actual settings corresponding to the given font
font = tk.splitlist(tk.call("font", "actual", font))
else:
font = self._set(options)
if not name:
name = "font" + str(id(self))
self.name = name
if exists:
self.delete_font = False
# confirm font exists
if self.name not in tk.splitlist(tk.call("font", "names")):
raise Tkinter._tkinter.TclError, "named font %s does not already exist" % (self.name,)
# if font config info supplied, apply it
if font:
tk.call("font", "configure", self.name, *font)
else:
# create new font (raises TclError if the font exists)
tk.call("font", "create", self.name, *font)
self.delete_font = True
self._tk = tk
self._split = tk.splitlist
self._call = tk.call
def __str__(self):
return self.name
def __eq__(self, other):
return isinstance(other, Font) and self.name == other.name
def __getitem__(self, key):
return self.cget(key)
def __setitem__(self, key, value):
self.configure(**{key: value})
def __del__(self):
try:
if self.delete_font:
self._call("font", "delete", self.name)
except (KeyboardInterrupt, SystemExit):
raise
except Exception:
pass
def copy(self):
"Return a distinct copy of the current font"
return Font(self._tk, **self.actual())
def actual(self, option=None):
"Return actual font attributes"
if option:
return self._call("font", "actual", self.name, "-"+option)
else:
return self._mkdict(
self._split(self._call("font", "actual", self.name))
)
def cget(self, option):
"Get font attribute"
return self._call("font", "config", self.name, "-"+option)
def config(self, **options):
"Modify font attributes"
if options:
self._call("font", "config", self.name,
*self._set(options))
else:
return self._mkdict(
self._split(self._call("font", "config", self.name))
)
configure = config
def measure(self, text):
"Return text width"
return int(self._call("font", "measure", self.name, text))
def metrics(self, *options):
"""Return font metrics.
For best performance, create a dummy widget
using this font before calling this method."""
if options:
return int(
self._call("font", "metrics", self.name, self._get(options))
)
else:
res = self._split(self._call("font", "metrics", self.name))
options = {}
for i in range(0, len(res), 2):
options[res[i][1:]] = int(res[i+1])
return options
def families(root=None):
"Get font families (as a tuple)"
if not root:
root = Tkinter._default_root
return root.tk.splitlist(root.tk.call("font", "families"))
def names(root=None):
"Get names of defined fonts (as a tuple)"
if not root:
root = Tkinter._default_root
return root.tk.splitlist(root.tk.call("font", "names"))
# --------------------------------------------------------------------
# test stuff
if __name__ == "__main__":
root = Tkinter.Tk()
# create a font
f = Font(family="times", size=30, weight=NORMAL)
print f.actual()
print f.actual("family")
print f.actual("weight")
print f.config()
print f.cget("family")
print f.cget("weight")
print names()
print f.measure("hello"), f.metrics("linespace")
print f.metrics()
f = Font(font=("Courier", 20, "bold"))
print f.measure("hello"), f.metrics("linespace")
w = Tkinter.Label(root, text="Hello, world", font=f)
w.pack()
w = Tkinter.Button(root, text="Quit!", command=root.destroy)
w.pack()
fb = Font(font=w["font"]).copy()
fb.config(weight=BOLD)
w.config(font=fb)
Tkinter.mainloop()
tkCommonDialog.pyc 0000644 00000002754 15032720555 0010204 0 ustar 00 �
z fc @ s! d d l Td d d � � YZ d S( i����( t *t Dialogc B s5 e Z d Z d d � Z d � Z d � Z d � Z RS( c K sT t d k r t d � n | | _ | | _ | rP | j d � rP | d | _ n d S( Ng������@s$ this module requires Tk 4.2 or newert parent( t TkVersiont TclErrort mastert optionst get( t selfR R ( ( s- /usr/lib64/python2.7/lib-tk/tkCommonDialog.pyt __init__ s c C s d S( N( ( R ( ( s- /usr/lib64/python2.7/lib-tk/tkCommonDialog.pyt _fixoptions s c C s | S( N( ( R t widgett result( ( s- /usr/lib64/python2.7/lib-tk/tkCommonDialog.pyt
_fixresult s c K s� x' | j � D] \ } } | | j | <q
W| j � t | j � } z: | j j | j | j | j � � } | j | | � } Wd y | j
� Wn n XX| S( N( t itemsR R
t FrameR t tkt callt commandt _optionsR
t destroy( R R t kt vt wt s( ( s- /usr/lib64/python2.7/lib-tk/tkCommonDialog.pyt show" s
$N( t __name__t
__module__t NoneR R R
R
R ( ( ( s- /usr/lib64/python2.7/lib-tk/tkCommonDialog.pyR
s
N( ( t TkinterR ( ( ( s- /usr/lib64/python2.7/lib-tk/tkCommonDialog.pyt <module> s
ttk.py 0000644 00000155555 15032720555 0005744 0 ustar 00 """Ttk wrapper.
This module provides classes to allow using Tk themed widget set.
Ttk is based on a revised and enhanced version of
TIP #48 (http://tip.tcl.tk/48) specified style engine.
Its basic idea is to separate, to the extent possible, the code
implementing a widget's behavior from the code implementing its
appearance. Widget class bindings are primarily responsible for
maintaining the widget state and invoking callbacks, all aspects
of the widgets appearance lies at Themes.
"""
__version__ = "0.3.1"
__author__ = "Guilherme Polo <ggpolo@gmail.com>"
__all__ = ["Button", "Checkbutton", "Combobox", "Entry", "Frame", "Label",
"Labelframe", "LabelFrame", "Menubutton", "Notebook", "Panedwindow",
"PanedWindow", "Progressbar", "Radiobutton", "Scale", "Scrollbar",
"Separator", "Sizegrip", "Style", "Treeview",
# Extensions
"LabeledScale", "OptionMenu",
# functions
"tclobjs_to_py", "setup_master"]
import Tkinter
from Tkinter import _flatten, _join, _stringify, _splitdict
# Verify if Tk is new enough to not need the Tile package
_REQUIRE_TILE = True if Tkinter.TkVersion < 8.5 else False
def _load_tile(master):
if _REQUIRE_TILE:
import os
tilelib = os.environ.get('TILE_LIBRARY')
if tilelib:
# append custom tile path to the list of directories that
# Tcl uses when attempting to resolve packages with the package
# command
master.tk.eval(
'global auto_path; '
'lappend auto_path {%s}' % tilelib)
master.tk.eval('package require tile') # TclError may be raised here
master._tile_loaded = True
def _format_optvalue(value, script=False):
"""Internal function."""
if script:
# if caller passes a Tcl script to tk.call, all the values need to
# be grouped into words (arguments to a command in Tcl dialect)
value = _stringify(value)
elif isinstance(value, (list, tuple)):
value = _join(value)
return value
def _format_optdict(optdict, script=False, ignore=None):
"""Formats optdict to a tuple to pass it to tk.call.
E.g. (script=False):
{'foreground': 'blue', 'padding': [1, 2, 3, 4]} returns:
('-foreground', 'blue', '-padding', '1 2 3 4')"""
opts = []
for opt, value in optdict.iteritems():
if not ignore or opt not in ignore:
opts.append("-%s" % opt)
if value is not None:
opts.append(_format_optvalue(value, script))
return _flatten(opts)
def _mapdict_values(items):
# each value in mapdict is expected to be a sequence, where each item
# is another sequence containing a state (or several) and a value
# E.g. (script=False):
# [('active', 'selected', 'grey'), ('focus', [1, 2, 3, 4])]
# returns:
# ['active selected', 'grey', 'focus', [1, 2, 3, 4]]
opt_val = []
for item in items:
state = item[:-1]
val = item[-1]
# hacks for bakward compatibility
state[0] # raise IndexError if empty
if len(state) == 1:
# if it is empty (something that evaluates to False), then
# format it to Tcl code to denote the "normal" state
state = state[0] or ''
else:
# group multiple states
state = ' '.join(state) # raise TypeError if not str
opt_val.append(state)
if val is not None:
opt_val.append(val)
return opt_val
def _format_mapdict(mapdict, script=False):
"""Formats mapdict to pass it to tk.call.
E.g. (script=False):
{'expand': [('active', 'selected', 'grey'), ('focus', [1, 2, 3, 4])]}
returns:
('-expand', '{active selected} grey focus {1, 2, 3, 4}')"""
opts = []
for opt, value in mapdict.iteritems():
opts.extend(("-%s" % opt,
_format_optvalue(_mapdict_values(value), script)))
return _flatten(opts)
def _format_elemcreate(etype, script=False, *args, **kw):
"""Formats args and kw according to the given element factory etype."""
spec = None
opts = ()
if etype in ("image", "vsapi"):
if etype == "image": # define an element based on an image
# first arg should be the default image name
iname = args[0]
# next args, if any, are statespec/value pairs which is almost
# a mapdict, but we just need the value
imagespec = _join(_mapdict_values(args[1:]))
spec = "%s %s" % (iname, imagespec)
else:
# define an element whose visual appearance is drawn using the
# Microsoft Visual Styles API which is responsible for the
# themed styles on Windows XP and Vista.
# Availability: Tk 8.6, Windows XP and Vista.
class_name, part_id = args[:2]
statemap = _join(_mapdict_values(args[2:]))
spec = "%s %s %s" % (class_name, part_id, statemap)
opts = _format_optdict(kw, script)
elif etype == "from": # clone an element
# it expects a themename and optionally an element to clone from,
# otherwise it will clone {} (empty element)
spec = args[0] # theme name
if len(args) > 1: # elementfrom specified
opts = (_format_optvalue(args[1], script),)
if script:
spec = '{%s}' % spec
opts = ' '.join(opts)
return spec, opts
def _format_layoutlist(layout, indent=0, indent_size=2):
"""Formats a layout list so we can pass the result to ttk::style
layout and ttk::style settings. Note that the layout doesn't have to
be a list necessarily.
E.g.:
[("Menubutton.background", None),
("Menubutton.button", {"children":
[("Menubutton.focus", {"children":
[("Menubutton.padding", {"children":
[("Menubutton.label", {"side": "left", "expand": 1})]
})]
})]
}),
("Menubutton.indicator", {"side": "right"})
]
returns:
Menubutton.background
Menubutton.button -children {
Menubutton.focus -children {
Menubutton.padding -children {
Menubutton.label -side left -expand 1
}
}
}
Menubutton.indicator -side right"""
script = []
for layout_elem in layout:
elem, opts = layout_elem
opts = opts or {}
fopts = ' '.join(_format_optdict(opts, True, ("children",)))
head = "%s%s%s" % (' ' * indent, elem, (" %s" % fopts) if fopts else '')
if "children" in opts:
script.append(head + " -children {")
indent += indent_size
newscript, indent = _format_layoutlist(opts['children'], indent,
indent_size)
script.append(newscript)
indent -= indent_size
script.append('%s}' % (' ' * indent))
else:
script.append(head)
return '\n'.join(script), indent
def _script_from_settings(settings):
"""Returns an appropriate script, based on settings, according to
theme_settings definition to be used by theme_settings and
theme_create."""
script = []
# a script will be generated according to settings passed, which
# will then be evaluated by Tcl
for name, opts in settings.iteritems():
# will format specific keys according to Tcl code
if opts.get('configure'): # format 'configure'
s = ' '.join(_format_optdict(opts['configure'], True))
script.append("ttk::style configure %s %s;" % (name, s))
if opts.get('map'): # format 'map'
s = ' '.join(_format_mapdict(opts['map'], True))
script.append("ttk::style map %s %s;" % (name, s))
if 'layout' in opts: # format 'layout' which may be empty
if not opts['layout']:
s = 'null' # could be any other word, but this one makes sense
else:
s, _ = _format_layoutlist(opts['layout'])
script.append("ttk::style layout %s {\n%s\n}" % (name, s))
if opts.get('element create'): # format 'element create'
eopts = opts['element create']
etype = eopts[0]
# find where args end, and where kwargs start
argc = 1 # etype was the first one
while argc < len(eopts) and not hasattr(eopts[argc], 'iteritems'):
argc += 1
elemargs = eopts[1:argc]
elemkw = eopts[argc] if argc < len(eopts) and eopts[argc] else {}
spec, opts = _format_elemcreate(etype, True, *elemargs, **elemkw)
script.append("ttk::style element create %s %s %s %s" % (
name, etype, spec, opts))
return '\n'.join(script)
def _list_from_statespec(stuple):
"""Construct a list from the given statespec tuple according to the
accepted statespec accepted by _format_mapdict."""
nval = []
for val in stuple:
typename = getattr(val, 'typename', None)
if typename is None:
nval.append(val)
else: # this is a Tcl object
val = str(val)
if typename == 'StateSpec':
val = val.split()
nval.append(val)
it = iter(nval)
return [_flatten(spec) for spec in zip(it, it)]
def _list_from_layouttuple(tk, ltuple):
"""Construct a list from the tuple returned by ttk::layout, this is
somewhat the reverse of _format_layoutlist."""
ltuple = tk.splitlist(ltuple)
res = []
indx = 0
while indx < len(ltuple):
name = ltuple[indx]
opts = {}
res.append((name, opts))
indx += 1
while indx < len(ltuple): # grab name's options
opt, val = ltuple[indx:indx + 2]
if not opt.startswith('-'): # found next name
break
opt = opt[1:] # remove the '-' from the option
indx += 2
if opt == 'children':
val = _list_from_layouttuple(tk, val)
opts[opt] = val
return res
def _val_or_dict(tk, options, *args):
"""Format options then call Tk command with args and options and return
the appropriate result.
If no option is specified, a dict is returned. If an option is
specified with the None value, the value for that option is returned.
Otherwise, the function just sets the passed options and the caller
shouldn't be expecting a return value anyway."""
options = _format_optdict(options)
res = tk.call(*(args + options))
if len(options) % 2: # option specified without a value, return its value
return res
return _splitdict(tk, res, conv=_tclobj_to_py)
def _convert_stringval(value):
"""Converts a value to, hopefully, a more appropriate Python object."""
value = unicode(value)
try:
value = int(value)
except (ValueError, TypeError):
pass
return value
def _to_number(x):
if isinstance(x, str):
if '.' in x:
x = float(x)
else:
x = int(x)
return x
def _tclobj_to_py(val):
"""Return value converted from Tcl object to Python object."""
if val and hasattr(val, '__len__') and not isinstance(val, basestring):
if getattr(val[0], 'typename', None) == 'StateSpec':
val = _list_from_statespec(val)
else:
val = map(_convert_stringval, val)
elif hasattr(val, 'typename'): # some other (single) Tcl object
val = _convert_stringval(val)
return val
def tclobjs_to_py(adict):
"""Returns adict with its values converted from Tcl objects to Python
objects."""
for opt, val in adict.items():
adict[opt] = _tclobj_to_py(val)
return adict
def setup_master(master=None):
"""If master is not None, itself is returned. If master is None,
the default master is returned if there is one, otherwise a new
master is created and returned.
If it is not allowed to use the default root and master is None,
RuntimeError is raised."""
if master is None:
if Tkinter._support_default_root:
master = Tkinter._default_root or Tkinter.Tk()
else:
raise RuntimeError(
"No master specified and Tkinter is "
"configured to not support default root")
return master
class Style(object):
"""Manipulate style database."""
_name = "ttk::style"
def __init__(self, master=None):
master = setup_master(master)
if not getattr(master, '_tile_loaded', False):
# Load tile now, if needed
_load_tile(master)
self.master = master
self.tk = self.master.tk
def configure(self, style, query_opt=None, **kw):
"""Query or sets the default value of the specified option(s) in
style.
Each key in kw is an option and each value is either a string or
a sequence identifying the value for that option."""
if query_opt is not None:
kw[query_opt] = None
return _val_or_dict(self.tk, kw, self._name, "configure", style)
def map(self, style, query_opt=None, **kw):
"""Query or sets dynamic values of the specified option(s) in
style.
Each key in kw is an option and each value should be a list or a
tuple (usually) containing statespecs grouped in tuples, or list,
or something else of your preference. A statespec is compound of
one or more states and then a value."""
if query_opt is not None:
return _list_from_statespec(self.tk.splitlist(
self.tk.call(self._name, "map", style, '-%s' % query_opt)))
return _splitdict(
self.tk,
self.tk.call(self._name, "map", style, *_format_mapdict(kw)),
conv=_tclobj_to_py)
def lookup(self, style, option, state=None, default=None):
"""Returns the value specified for option in style.
If state is specified it is expected to be a sequence of one
or more states. If the default argument is set, it is used as
a fallback value in case no specification for option is found."""
state = ' '.join(state) if state else ''
return self.tk.call(self._name, "lookup", style, '-%s' % option,
state, default)
def layout(self, style, layoutspec=None):
"""Define the widget layout for given style. If layoutspec is
omitted, return the layout specification for given style.
layoutspec is expected to be a list or an object different than
None that evaluates to False if you want to "turn off" that style.
If it is a list (or tuple, or something else), each item should be
a tuple where the first item is the layout name and the second item
should have the format described below:
LAYOUTS
A layout can contain the value None, if takes no options, or
a dict of options specifying how to arrange the element.
The layout mechanism uses a simplified version of the pack
geometry manager: given an initial cavity, each element is
allocated a parcel. Valid options/values are:
side: whichside
Specifies which side of the cavity to place the
element; one of top, right, bottom or left. If
omitted, the element occupies the entire cavity.
sticky: nswe
Specifies where the element is placed inside its
allocated parcel.
children: [sublayout... ]
Specifies a list of elements to place inside the
element. Each element is a tuple (or other sequence)
where the first item is the layout name, and the other
is a LAYOUT."""
lspec = None
if layoutspec:
lspec = _format_layoutlist(layoutspec)[0]
elif layoutspec is not None: # will disable the layout ({}, '', etc)
lspec = "null" # could be any other word, but this may make sense
# when calling layout(style) later
return _list_from_layouttuple(self.tk,
self.tk.call(self._name, "layout", style, lspec))
def element_create(self, elementname, etype, *args, **kw):
"""Create a new element in the current theme of given etype."""
spec, opts = _format_elemcreate(etype, False, *args, **kw)
self.tk.call(self._name, "element", "create", elementname, etype,
spec, *opts)
def element_names(self):
"""Returns the list of elements defined in the current theme."""
return self.tk.splitlist(self.tk.call(self._name, "element", "names"))
def element_options(self, elementname):
"""Return the list of elementname's options."""
return self.tk.splitlist(self.tk.call(self._name, "element", "options", elementname))
def theme_create(self, themename, parent=None, settings=None):
"""Creates a new theme.
It is an error if themename already exists. If parent is
specified, the new theme will inherit styles, elements and
layouts from the specified parent theme. If settings are present,
they are expected to have the same syntax used for theme_settings."""
script = _script_from_settings(settings) if settings else ''
if parent:
self.tk.call(self._name, "theme", "create", themename,
"-parent", parent, "-settings", script)
else:
self.tk.call(self._name, "theme", "create", themename,
"-settings", script)
def theme_settings(self, themename, settings):
"""Temporarily sets the current theme to themename, apply specified
settings and then restore the previous theme.
Each key in settings is a style and each value may contain the
keys 'configure', 'map', 'layout' and 'element create' and they
are expected to have the same format as specified by the methods
configure, map, layout and element_create respectively."""
script = _script_from_settings(settings)
self.tk.call(self._name, "theme", "settings", themename, script)
def theme_names(self):
"""Returns a list of all known themes."""
return self.tk.splitlist(self.tk.call(self._name, "theme", "names"))
def theme_use(self, themename=None):
"""If themename is None, returns the theme in use, otherwise, set
the current theme to themename, refreshes all widgets and emits
a <<ThemeChanged>> event."""
if themename is None:
# Starting on Tk 8.6, checking this global is no longer needed
# since it allows doing self.tk.call(self._name, "theme", "use")
return self.tk.eval("return $ttk::currentTheme")
# using "ttk::setTheme" instead of "ttk::style theme use" causes
# the variable currentTheme to be updated, also, ttk::setTheme calls
# "ttk::style theme use" in order to change theme.
self.tk.call("ttk::setTheme", themename)
class Widget(Tkinter.Widget):
"""Base class for Tk themed widgets."""
def __init__(self, master, widgetname, kw=None):
"""Constructs a Ttk Widget with the parent master.
STANDARD OPTIONS
class, cursor, takefocus, style
SCROLLABLE WIDGET OPTIONS
xscrollcommand, yscrollcommand
LABEL WIDGET OPTIONS
text, textvariable, underline, image, compound, width
WIDGET STATES
active, disabled, focus, pressed, selected, background,
readonly, alternate, invalid
"""
master = setup_master(master)
if not getattr(master, '_tile_loaded', False):
# Load tile now, if needed
_load_tile(master)
Tkinter.Widget.__init__(self, master, widgetname, kw=kw)
def identify(self, x, y):
"""Returns the name of the element at position x, y, or the empty
string if the point does not lie within any element.
x and y are pixel coordinates relative to the widget."""
return self.tk.call(self._w, "identify", x, y)
def instate(self, statespec, callback=None, *args, **kw):
"""Test the widget's state.
If callback is not specified, returns True if the widget state
matches statespec and False otherwise. If callback is specified,
then it will be invoked with *args, **kw if the widget state
matches statespec. statespec is expected to be a sequence."""
ret = self.tk.getboolean(
self.tk.call(self._w, "instate", ' '.join(statespec)))
if ret and callback:
return callback(*args, **kw)
return ret
def state(self, statespec=None):
"""Modify or inquire widget state.
Widget state is returned if statespec is None, otherwise it is
set according to the statespec flags and then a new state spec
is returned indicating which flags were changed. statespec is
expected to be a sequence."""
if statespec is not None:
statespec = ' '.join(statespec)
return self.tk.splitlist(str(self.tk.call(self._w, "state", statespec)))
class Button(Widget):
"""Ttk Button widget, displays a textual label and/or image, and
evaluates a command when pressed."""
def __init__(self, master=None, **kw):
"""Construct a Ttk Button widget with the parent master.
STANDARD OPTIONS
class, compound, cursor, image, state, style, takefocus,
text, textvariable, underline, width
WIDGET-SPECIFIC OPTIONS
command, default, width
"""
Widget.__init__(self, master, "ttk::button", kw)
def invoke(self):
"""Invokes the command associated with the button."""
return self.tk.call(self._w, "invoke")
class Checkbutton(Widget):
"""Ttk Checkbutton widget which is either in on- or off-state."""
def __init__(self, master=None, **kw):
"""Construct a Ttk Checkbutton widget with the parent master.
STANDARD OPTIONS
class, compound, cursor, image, state, style, takefocus,
text, textvariable, underline, width
WIDGET-SPECIFIC OPTIONS
command, offvalue, onvalue, variable
"""
Widget.__init__(self, master, "ttk::checkbutton", kw)
def invoke(self):
"""Toggles between the selected and deselected states and
invokes the associated command. If the widget is currently
selected, sets the option variable to the offvalue option
and deselects the widget; otherwise, sets the option variable
to the option onvalue.
Returns the result of the associated command."""
return self.tk.call(self._w, "invoke")
class Entry(Widget, Tkinter.Entry):
"""Ttk Entry widget displays a one-line text string and allows that
string to be edited by the user."""
def __init__(self, master=None, widget=None, **kw):
"""Constructs a Ttk Entry widget with the parent master.
STANDARD OPTIONS
class, cursor, style, takefocus, xscrollcommand
WIDGET-SPECIFIC OPTIONS
exportselection, invalidcommand, justify, show, state,
textvariable, validate, validatecommand, width
VALIDATION MODES
none, key, focus, focusin, focusout, all
"""
Widget.__init__(self, master, widget or "ttk::entry", kw)
def bbox(self, index):
"""Return a tuple of (x, y, width, height) which describes the
bounding box of the character given by index."""
return self._getints(self.tk.call(self._w, "bbox", index))
def identify(self, x, y):
"""Returns the name of the element at position x, y, or the
empty string if the coordinates are outside the window."""
return self.tk.call(self._w, "identify", x, y)
def validate(self):
"""Force revalidation, independent of the conditions specified
by the validate option. Returns False if validation fails, True
if it succeeds. Sets or clears the invalid state accordingly."""
return self.tk.getboolean(self.tk.call(self._w, "validate"))
class Combobox(Entry):
"""Ttk Combobox widget combines a text field with a pop-down list of
values."""
def __init__(self, master=None, **kw):
"""Construct a Ttk Combobox widget with the parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
exportselection, justify, height, postcommand, state,
textvariable, values, width
"""
Entry.__init__(self, master, "ttk::combobox", **kw)
def current(self, newindex=None):
"""If newindex is supplied, sets the combobox value to the
element at position newindex in the list of values. Otherwise,
returns the index of the current value in the list of values
or -1 if the current value does not appear in the list."""
if newindex is None:
return self.tk.getint(self.tk.call(self._w, "current"))
return self.tk.call(self._w, "current", newindex)
def set(self, value):
"""Sets the value of the combobox to value."""
self.tk.call(self._w, "set", value)
class Frame(Widget):
"""Ttk Frame widget is a container, used to group other widgets
together."""
def __init__(self, master=None, **kw):
"""Construct a Ttk Frame with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
borderwidth, relief, padding, width, height
"""
Widget.__init__(self, master, "ttk::frame", kw)
class Label(Widget):
"""Ttk Label widget displays a textual label and/or image."""
def __init__(self, master=None, **kw):
"""Construct a Ttk Label with parent master.
STANDARD OPTIONS
class, compound, cursor, image, style, takefocus, text,
textvariable, underline, width
WIDGET-SPECIFIC OPTIONS
anchor, background, font, foreground, justify, padding,
relief, text, wraplength
"""
Widget.__init__(self, master, "ttk::label", kw)
class Labelframe(Widget):
"""Ttk Labelframe widget is a container used to group other widgets
together. It has an optional label, which may be a plain text string
or another widget."""
def __init__(self, master=None, **kw):
"""Construct a Ttk Labelframe with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
labelanchor, text, underline, padding, labelwidget, width,
height
"""
Widget.__init__(self, master, "ttk::labelframe", kw)
LabelFrame = Labelframe # Tkinter name compatibility
class Menubutton(Widget):
"""Ttk Menubutton widget displays a textual label and/or image, and
displays a menu when pressed."""
def __init__(self, master=None, **kw):
"""Construct a Ttk Menubutton with parent master.
STANDARD OPTIONS
class, compound, cursor, image, state, style, takefocus,
text, textvariable, underline, width
WIDGET-SPECIFIC OPTIONS
direction, menu
"""
Widget.__init__(self, master, "ttk::menubutton", kw)
class Notebook(Widget):
"""Ttk Notebook widget manages a collection of windows and displays
a single one at a time. Each child window is associated with a tab,
which the user may select to change the currently-displayed window."""
def __init__(self, master=None, **kw):
"""Construct a Ttk Notebook with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
height, padding, width
TAB OPTIONS
state, sticky, padding, text, image, compound, underline
TAB IDENTIFIERS (tab_id)
The tab_id argument found in several methods may take any of
the following forms:
* An integer between zero and the number of tabs
* The name of a child window
* A positional specification of the form "@x,y", which
defines the tab
* The string "current", which identifies the
currently-selected tab
* The string "end", which returns the number of tabs (only
valid for method index)
"""
Widget.__init__(self, master, "ttk::notebook", kw)
def add(self, child, **kw):
"""Adds a new tab to the notebook.
If window is currently managed by the notebook but hidden, it is
restored to its previous position."""
self.tk.call(self._w, "add", child, *(_format_optdict(kw)))
def forget(self, tab_id):
"""Removes the tab specified by tab_id, unmaps and unmanages the
associated window."""
self.tk.call(self._w, "forget", tab_id)
def hide(self, tab_id):
"""Hides the tab specified by tab_id.
The tab will not be displayed, but the associated window remains
managed by the notebook and its configuration remembered. Hidden
tabs may be restored with the add command."""
self.tk.call(self._w, "hide", tab_id)
def identify(self, x, y):
"""Returns the name of the tab element at position x, y, or the
empty string if none."""
return self.tk.call(self._w, "identify", x, y)
def index(self, tab_id):
"""Returns the numeric index of the tab specified by tab_id, or
the total number of tabs if tab_id is the string "end"."""
return self.tk.getint(self.tk.call(self._w, "index", tab_id))
def insert(self, pos, child, **kw):
"""Inserts a pane at the specified position.
pos is either the string end, an integer index, or the name of
a managed child. If child is already managed by the notebook,
moves it to the specified position."""
self.tk.call(self._w, "insert", pos, child, *(_format_optdict(kw)))
def select(self, tab_id=None):
"""Selects the specified tab.
The associated child window will be displayed, and the
previously-selected window (if different) is unmapped. If tab_id
is omitted, returns the widget name of the currently selected
pane."""
return self.tk.call(self._w, "select", tab_id)
def tab(self, tab_id, option=None, **kw):
"""Query or modify the options of the specific tab_id.
If kw is not given, returns a dict of the tab option values. If option
is specified, returns the value of that option. Otherwise, sets the
options to the corresponding values."""
if option is not None:
kw[option] = None
return _val_or_dict(self.tk, kw, self._w, "tab", tab_id)
def tabs(self):
"""Returns a list of windows managed by the notebook."""
return self.tk.splitlist(self.tk.call(self._w, "tabs") or ())
def enable_traversal(self):
"""Enable keyboard traversal for a toplevel window containing
this notebook.
This will extend the bindings for the toplevel window containing
this notebook as follows:
Control-Tab: selects the tab following the currently selected
one
Shift-Control-Tab: selects the tab preceding the currently
selected one
Alt-K: where K is the mnemonic (underlined) character of any
tab, will select that tab.
Multiple notebooks in a single toplevel may be enabled for
traversal, including nested notebooks. However, notebook traversal
only works properly if all panes are direct children of the
notebook."""
# The only, and good, difference I see is about mnemonics, which works
# after calling this method. Control-Tab and Shift-Control-Tab always
# works (here at least).
self.tk.call("ttk::notebook::enableTraversal", self._w)
class Panedwindow(Widget, Tkinter.PanedWindow):
"""Ttk Panedwindow widget displays a number of subwindows, stacked
either vertically or horizontally."""
def __init__(self, master=None, **kw):
"""Construct a Ttk Panedwindow with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
orient, width, height
PANE OPTIONS
weight
"""
Widget.__init__(self, master, "ttk::panedwindow", kw)
forget = Tkinter.PanedWindow.forget # overrides Pack.forget
def insert(self, pos, child, **kw):
"""Inserts a pane at the specified positions.
pos is either the string end, and integer index, or the name
of a child. If child is already managed by the paned window,
moves it to the specified position."""
self.tk.call(self._w, "insert", pos, child, *(_format_optdict(kw)))
def pane(self, pane, option=None, **kw):
"""Query or modify the options of the specified pane.
pane is either an integer index or the name of a managed subwindow.
If kw is not given, returns a dict of the pane option values. If
option is specified then the value for that option is returned.
Otherwise, sets the options to the corresponding values."""
if option is not None:
kw[option] = None
return _val_or_dict(self.tk, kw, self._w, "pane", pane)
def sashpos(self, index, newpos=None):
"""If newpos is specified, sets the position of sash number index.
May adjust the positions of adjacent sashes to ensure that
positions are monotonically increasing. Sash positions are further
constrained to be between 0 and the total size of the widget.
Returns the new position of sash number index."""
return self.tk.getint(self.tk.call(self._w, "sashpos", index, newpos))
PanedWindow = Panedwindow # Tkinter name compatibility
class Progressbar(Widget):
"""Ttk Progressbar widget shows the status of a long-running
operation. They can operate in two modes: determinate mode shows the
amount completed relative to the total amount of work to be done, and
indeterminate mode provides an animated display to let the user know
that something is happening."""
def __init__(self, master=None, **kw):
"""Construct a Ttk Progressbar with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
orient, length, mode, maximum, value, variable, phase
"""
Widget.__init__(self, master, "ttk::progressbar", kw)
def start(self, interval=None):
"""Begin autoincrement mode: schedules a recurring timer event
that calls method step every interval milliseconds.
interval defaults to 50 milliseconds (20 steps/second) if omitted."""
self.tk.call(self._w, "start", interval)
def step(self, amount=None):
"""Increments the value option by amount.
amount defaults to 1.0 if omitted."""
self.tk.call(self._w, "step", amount)
def stop(self):
"""Stop autoincrement mode: cancels any recurring timer event
initiated by start."""
self.tk.call(self._w, "stop")
class Radiobutton(Widget):
"""Ttk Radiobutton widgets are used in groups to show or change a
set of mutually-exclusive options."""
def __init__(self, master=None, **kw):
"""Construct a Ttk Radiobutton with parent master.
STANDARD OPTIONS
class, compound, cursor, image, state, style, takefocus,
text, textvariable, underline, width
WIDGET-SPECIFIC OPTIONS
command, value, variable
"""
Widget.__init__(self, master, "ttk::radiobutton", kw)
def invoke(self):
"""Sets the option variable to the option value, selects the
widget, and invokes the associated command.
Returns the result of the command, or an empty string if
no command is specified."""
return self.tk.call(self._w, "invoke")
class Scale(Widget, Tkinter.Scale):
"""Ttk Scale widget is typically used to control the numeric value of
a linked variable that varies uniformly over some range."""
def __init__(self, master=None, **kw):
"""Construct a Ttk Scale with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
command, from, length, orient, to, value, variable
"""
Widget.__init__(self, master, "ttk::scale", kw)
def configure(self, cnf=None, **kw):
"""Modify or query scale options.
Setting a value for any of the "from", "from_" or "to" options
generates a <<RangeChanged>> event."""
if cnf:
kw.update(cnf)
Widget.configure(self, **kw)
if any(['from' in kw, 'from_' in kw, 'to' in kw]):
self.event_generate('<<RangeChanged>>')
def get(self, x=None, y=None):
"""Get the current value of the value option, or the value
corresponding to the coordinates x, y if they are specified.
x and y are pixel coordinates relative to the scale widget
origin."""
return self.tk.call(self._w, 'get', x, y)
class Scrollbar(Widget, Tkinter.Scrollbar):
"""Ttk Scrollbar controls the viewport of a scrollable widget."""
def __init__(self, master=None, **kw):
"""Construct a Ttk Scrollbar with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
command, orient
"""
Widget.__init__(self, master, "ttk::scrollbar", kw)
class Separator(Widget):
"""Ttk Separator widget displays a horizontal or vertical separator
bar."""
def __init__(self, master=None, **kw):
"""Construct a Ttk Separator with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
orient
"""
Widget.__init__(self, master, "ttk::separator", kw)
class Sizegrip(Widget):
"""Ttk Sizegrip allows the user to resize the containing toplevel
window by pressing and dragging the grip."""
def __init__(self, master=None, **kw):
"""Construct a Ttk Sizegrip with parent master.
STANDARD OPTIONS
class, cursor, state, style, takefocus
"""
Widget.__init__(self, master, "ttk::sizegrip", kw)
class Treeview(Widget, Tkinter.XView, Tkinter.YView):
"""Ttk Treeview widget displays a hierarchical collection of items.
Each item has a textual label, an optional image, and an optional list
of data values. The data values are displayed in successive columns
after the tree label."""
def __init__(self, master=None, **kw):
"""Construct a Ttk Treeview with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus, xscrollcommand,
yscrollcommand
WIDGET-SPECIFIC OPTIONS
columns, displaycolumns, height, padding, selectmode, show
ITEM OPTIONS
text, image, values, open, tags
TAG OPTIONS
foreground, background, font, image
"""
Widget.__init__(self, master, "ttk::treeview", kw)
def bbox(self, item, column=None):
"""Returns the bounding box (relative to the treeview widget's
window) of the specified item in the form x y width height.
If column is specified, returns the bounding box of that cell.
If the item is not visible (i.e., if it is a descendant of a
closed item or is scrolled offscreen), returns an empty string."""
return self._getints(self.tk.call(self._w, "bbox", item, column)) or ''
def get_children(self, item=None):
"""Returns a tuple of children belonging to item.
If item is not specified, returns root children."""
return self.tk.splitlist(
self.tk.call(self._w, "children", item or '') or ())
def set_children(self, item, *newchildren):
"""Replaces item's child with newchildren.
Children present in item that are not present in newchildren
are detached from tree. No items in newchildren may be an
ancestor of item."""
self.tk.call(self._w, "children", item, newchildren)
def column(self, column, option=None, **kw):
"""Query or modify the options for the specified column.
If kw is not given, returns a dict of the column option values. If
option is specified then the value for that option is returned.
Otherwise, sets the options to the corresponding values."""
if option is not None:
kw[option] = None
return _val_or_dict(self.tk, kw, self._w, "column", column)
def delete(self, *items):
"""Delete all specified items and all their descendants. The root
item may not be deleted."""
self.tk.call(self._w, "delete", items)
def detach(self, *items):
"""Unlinks all of the specified items from the tree.
The items and all of their descendants are still present, and may
be reinserted at another point in the tree, but will not be
displayed. The root item may not be detached."""
self.tk.call(self._w, "detach", items)
def exists(self, item):
"""Returns True if the specified item is present in the tree,
False otherwise."""
return self.tk.getboolean(self.tk.call(self._w, "exists", item))
def focus(self, item=None):
"""If item is specified, sets the focus item to item. Otherwise,
returns the current focus item, or '' if there is none."""
return self.tk.call(self._w, "focus", item)
def heading(self, column, option=None, **kw):
"""Query or modify the heading options for the specified column.
If kw is not given, returns a dict of the heading option values. If
option is specified then the value for that option is returned.
Otherwise, sets the options to the corresponding values.
Valid options/values are:
text: text
The text to display in the column heading
image: image_name
Specifies an image to display to the right of the column
heading
anchor: anchor
Specifies how the heading text should be aligned. One of
the standard Tk anchor values
command: callback
A callback to be invoked when the heading label is
pressed.
To configure the tree column heading, call this with column = "#0" """
cmd = kw.get('command')
if cmd and not isinstance(cmd, basestring):
# callback not registered yet, do it now
kw['command'] = self.master.register(cmd, self._substitute)
if option is not None:
kw[option] = None
return _val_or_dict(self.tk, kw, self._w, 'heading', column)
def identify(self, component, x, y):
"""Returns a description of the specified component under the
point given by x and y, or the empty string if no such component
is present at that position."""
return self.tk.call(self._w, "identify", component, x, y)
def identify_row(self, y):
"""Returns the item ID of the item at position y."""
return self.identify("row", 0, y)
def identify_column(self, x):
"""Returns the data column identifier of the cell at position x.
The tree column has ID #0."""
return self.identify("column", x, 0)
def identify_region(self, x, y):
"""Returns one of:
heading: Tree heading area.
separator: Space between two columns headings;
tree: The tree area.
cell: A data cell.
* Availability: Tk 8.6"""
return self.identify("region", x, y)
def identify_element(self, x, y):
"""Returns the element at position x, y.
* Availability: Tk 8.6"""
return self.identify("element", x, y)
def index(self, item):
"""Returns the integer index of item within its parent's list
of children."""
return self.tk.getint(self.tk.call(self._w, "index", item))
def insert(self, parent, index, iid=None, **kw):
"""Creates a new item and return the item identifier of the newly
created item.
parent is the item ID of the parent item, or the empty string
to create a new top-level item. index is an integer, or the value
end, specifying where in the list of parent's children to insert
the new item. If index is less than or equal to zero, the new node
is inserted at the beginning, if index is greater than or equal to
the current number of children, it is inserted at the end. If iid
is specified, it is used as the item identifier, iid must not
already exist in the tree. Otherwise, a new unique identifier
is generated."""
opts = _format_optdict(kw)
if iid is not None:
res = self.tk.call(self._w, "insert", parent, index,
"-id", iid, *opts)
else:
res = self.tk.call(self._w, "insert", parent, index, *opts)
return res
def item(self, item, option=None, **kw):
"""Query or modify the options for the specified item.
If no options are given, a dict with options/values for the item
is returned. If option is specified then the value for that option
is returned. Otherwise, sets the options to the corresponding
values as given by kw."""
if option is not None:
kw[option] = None
return _val_or_dict(self.tk, kw, self._w, "item", item)
def move(self, item, parent, index):
"""Moves item to position index in parent's list of children.
It is illegal to move an item under one of its descendants. If
index is less than or equal to zero, item is moved to the
beginning, if greater than or equal to the number of children,
it is moved to the end. If item was detached it is reattached."""
self.tk.call(self._w, "move", item, parent, index)
reattach = move # A sensible method name for reattaching detached items
def next(self, item):
"""Returns the identifier of item's next sibling, or '' if item
is the last child of its parent."""
return self.tk.call(self._w, "next", item)
def parent(self, item):
"""Returns the ID of the parent of item, or '' if item is at the
top level of the hierarchy."""
return self.tk.call(self._w, "parent", item)
def prev(self, item):
"""Returns the identifier of item's previous sibling, or '' if
item is the first child of its parent."""
return self.tk.call(self._w, "prev", item)
def see(self, item):
"""Ensure that item is visible.
Sets all of item's ancestors open option to True, and scrolls
the widget if necessary so that item is within the visible
portion of the tree."""
self.tk.call(self._w, "see", item)
def selection(self, selop=None, items=None):
"""If selop is not specified, returns selected items."""
if isinstance(items, basestring):
items = (items,)
return self.tk.splitlist(self.tk.call(self._w, "selection", selop, items))
def selection_set(self, items):
"""items becomes the new selection."""
self.selection("set", items)
def selection_add(self, items):
"""Add items to the selection."""
self.selection("add", items)
def selection_remove(self, items):
"""Remove items from the selection."""
self.selection("remove", items)
def selection_toggle(self, items):
"""Toggle the selection state of each item in items."""
self.selection("toggle", items)
def set(self, item, column=None, value=None):
"""Query or set the value of given item.
With one argument, return a dictionary of column/value pairs
for the specified item. With two arguments, return the current
value of the specified column. With three arguments, set the
value of given column in given item to the specified value."""
res = self.tk.call(self._w, "set", item, column, value)
if column is None and value is None:
return _splitdict(self.tk, res,
cut_minus=False, conv=_tclobj_to_py)
else:
return res
def tag_bind(self, tagname, sequence=None, callback=None):
"""Bind a callback for the given event sequence to the tag tagname.
When an event is delivered to an item, the callbacks for each
of the item's tags option are called."""
self._bind((self._w, "tag", "bind", tagname), sequence, callback, add=0)
def tag_configure(self, tagname, option=None, **kw):
"""Query or modify the options for the specified tagname.
If kw is not given, returns a dict of the option settings for tagname.
If option is specified, returns the value for that option for the
specified tagname. Otherwise, sets the options to the corresponding
values for the given tagname."""
if option is not None:
kw[option] = None
return _val_or_dict(self.tk, kw, self._w, "tag", "configure",
tagname)
def tag_has(self, tagname, item=None):
"""If item is specified, returns 1 or 0 depending on whether the
specified item has the given tagname. Otherwise, returns a list of
all items which have the specified tag.
* Availability: Tk 8.6"""
if item is None:
return self.tk.splitlist(
self.tk.call(self._w, "tag", "has", tagname))
else:
return self.tk.getboolean(
self.tk.call(self._w, "tag", "has", tagname, item))
# Extensions
class LabeledScale(Frame, object):
"""A Ttk Scale widget with a Ttk Label widget indicating its
current value.
The Ttk Scale can be accessed through instance.scale, and Ttk Label
can be accessed through instance.label"""
def __init__(self, master=None, variable=None, from_=0, to=10, **kw):
"""Construct a horizontal LabeledScale with parent master, a
variable to be associated with the Ttk Scale widget and its range.
If variable is not specified, a Tkinter.IntVar is created.
WIDGET-SPECIFIC OPTIONS
compound: 'top' or 'bottom'
Specifies how to display the label relative to the scale.
Defaults to 'top'.
"""
self._label_top = kw.pop('compound', 'top') == 'top'
Frame.__init__(self, master, **kw)
self._variable = variable or Tkinter.IntVar(master)
self._variable.set(from_)
self._last_valid = from_
self.label = Label(self)
self.scale = Scale(self, variable=self._variable, from_=from_, to=to)
self.scale.bind('<<RangeChanged>>', self._adjust)
# position scale and label according to the compound option
scale_side = 'bottom' if self._label_top else 'top'
label_side = 'top' if scale_side == 'bottom' else 'bottom'
self.scale.pack(side=scale_side, fill='x')
tmp = Label(self).pack(side=label_side) # place holder
self.label.place(anchor='n' if label_side == 'top' else 's')
# update the label as scale or variable changes
self.__tracecb = self._variable.trace_variable('w', self._adjust)
self.bind('<Configure>', self._adjust)
self.bind('<Map>', self._adjust)
def destroy(self):
"""Destroy this widget and possibly its associated variable."""
try:
self._variable.trace_vdelete('w', self.__tracecb)
except AttributeError:
# widget has been destroyed already
pass
else:
del self._variable
Frame.destroy(self)
self.label = None
self.scale = None
def _adjust(self, *args):
"""Adjust the label position according to the scale."""
def adjust_label():
self.update_idletasks() # "force" scale redraw
x, y = self.scale.coords()
if self._label_top:
y = self.scale.winfo_y() - self.label.winfo_reqheight()
else:
y = self.scale.winfo_reqheight() + self.label.winfo_reqheight()
self.label.place_configure(x=x, y=y)
from_ = _to_number(self.scale['from'])
to = _to_number(self.scale['to'])
if to < from_:
from_, to = to, from_
newval = self._variable.get()
if not from_ <= newval <= to:
# value outside range, set value back to the last valid one
self.value = self._last_valid
return
self._last_valid = newval
self.label['text'] = newval
self.after_idle(adjust_label)
def _get_value(self):
"""Return current scale value."""
return self._variable.get()
def _set_value(self, val):
"""Set new scale value."""
self._variable.set(val)
value = property(_get_value, _set_value)
class OptionMenu(Menubutton):
"""Themed OptionMenu, based after Tkinter's OptionMenu, which allows
the user to select a value from a menu."""
def __init__(self, master, variable, default=None, *values, **kwargs):
"""Construct a themed OptionMenu widget with master as the parent,
the resource textvariable set to variable, the initially selected
value specified by the default parameter, the menu values given by
*values and additional keywords.
WIDGET-SPECIFIC OPTIONS
style: stylename
Menubutton style.
direction: 'above', 'below', 'left', 'right', or 'flush'
Menubutton direction.
command: callback
A callback that will be invoked after selecting an item.
"""
kw = {'textvariable': variable, 'style': kwargs.pop('style', None),
'direction': kwargs.pop('direction', None)}
Menubutton.__init__(self, master, **kw)
self['menu'] = Tkinter.Menu(self, tearoff=False)
self._variable = variable
self._callback = kwargs.pop('command', None)
if kwargs:
raise Tkinter.TclError('unknown option -%s' % (
kwargs.iterkeys().next()))
self.set_menu(default, *values)
def __getitem__(self, item):
if item == 'menu':
return self.nametowidget(Menubutton.__getitem__(self, item))
return Menubutton.__getitem__(self, item)
def set_menu(self, default=None, *values):
"""Build a new menu of radiobuttons with *values and optionally
a default value."""
menu = self['menu']
menu.delete(0, 'end')
for val in values:
menu.add_radiobutton(label=val,
command=Tkinter._setit(self._variable, val, self._callback),
variable=self._variable)
if default:
self._variable.set(default)
def destroy(self):
"""Destroy this widget and its associated variable."""
try:
del self._variable
except AttributeError:
pass
Menubutton.destroy(self)
turtle.pyc 0000644 00000420471 15032720555 0006614 0 ustar 00 �
z fc O @ s+ d Z d Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l m Z m
Z
m Z d d l m
Z
d d l Td d d d
d d d
d d g Z d d d d d d d d d d d d d d d d d d! d" d# d$ d% d& d' d( d) g Z d* d+ d, d- d. d/ d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 d: d; d< d= d> d? d@ dA dB dC dD dE dF dG dH dI dJ dK dL dM dN dO dP dQ dR dS dT dU dV dW dX dY dZ d[ d\ d] d^ d_ d` da db dc dd de df dg dh di dj dk dl dm d% dn do dp dq dr d( d) ds dt du gO Z dv dw dx g Z dy dz d{ d| d} d~ d d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� g Z e e e e d� g e Z d d+ d. d; dG dK dO dU dW d\ d] d_ d` di dn dq dr g Z i d� dr 6d� d� 6d� d� 6d� d� 6e d� 6e d� 6d� d 6d� d 6d� d 6d� d� 6d� de 6d� dQ 6d� d= 6d� d[ 6e d� 6d� d� 6d� d� 6d� d� 6d� d$ 6e d� 6Z d� � Z d� � Z y e e � Wn e k
rfd� GHn Xd e f d� � � YZ d� � Z d� � Z d� d� Z f d� � Z! d e j" f d� � � YZ# e! e# e j$ d� � d� e j% f d� � � YZ& e j$ Z$ d� e' f d� � � YZ( d� e) f d� � � YZ* d� e) f d� � � YZ+ d e' f d� � � YZ, d� e' f d� � � YZ- d e( f d� � � YZ. d� e' f d� � � YZ/ d� e' f d� � � YZ0 d� e' f d� � � YZ1 d
e0 e/ f d� � � YZ2 e2 Z3 d� � Z4 d� e. f d� � � YZ5 d e2 f d� � � YZ6 e6 Z7 d� d� � Z8 d� � Z9 e d� Z: y e: d� k rNe9 e: � n Wn3 e; k
rkd� Ge: GHn e k
r�d� e: GHn Xd� � Z< d� � Z= d� � Z> d� Z? d� � Z@ e@ e e5 d� d� e> � e@ e e6 d� d� e= � e jA ZB ZA eC d� k r'd� � ZD d� � ZE d� � ZF eE � eF � eG � n d S(� s�
Turtle graphics is a popular way for introducing programming to
kids. It was part of the original Logo programming language developed
by Wally Feurzig and Seymour Papert in 1966.
Imagine a robotic turtle starting at (0, 0) in the x-y plane. After an ``import turtle``, give it
the command turtle.forward(15), and it moves (on-screen!) 15 pixels in
the direction it is facing, drawing a line as it moves. Give it the
command turtle.right(25), and it rotates in-place 25 degrees clockwise.
By combining together these and similar commands, intricate shapes and
pictures can easily be drawn.
----- turtle.py
This module is an extended reimplementation of turtle.py from the
Python standard distribution up to Python 2.5. (See: http://www.python.org)
It tries to keep the merits of turtle.py and to be (nearly) 100%
compatible with it. This means in the first place to enable the
learning programmer to use all the commands, classes and methods
interactively when using the module from within IDLE run with
the -n switch.
Roughly it has the following features added:
- Better animation of the turtle movements, especially of turning the
turtle. So the turtles can more easily be used as a visual feedback
instrument by the (beginning) programmer.
- Different turtle shapes, gif-images as turtle shapes, user defined
and user controllable turtle shapes, among them compound
(multicolored) shapes. Turtle shapes can be stretched and tilted, which
makes turtles very versatile geometrical objects.
- Fine control over turtle movement and screen updates via delay(),
and enhanced tracer() and speed() methods.
- Aliases for the most commonly used commands, like fd for forward etc.,
following the early Logo traditions. This reduces the boring work of
typing long sequences of commands, which often occur in a natural way
when kids try to program fancy pictures on their first encounter with
turtle graphics.
- Turtles now have an undo()-method with configurable undo-buffer.
- Some simple commands/methods for creating event driven programs
(mouse-, key-, timer-events). Especially useful for programming games.
- A scrollable Canvas class. The default scrollable Canvas can be
extended interactively as needed while playing around with the turtle(s).
- A TurtleScreen class with methods controlling background color or
background image, window and canvas size and other properties of the
TurtleScreen.
- There is a method, setworldcoordinates(), to install a user defined
coordinate-system for the TurtleScreen.
- The implementation uses a 2-vector class named Vec2D, derived from tuple.
This class is public, so it can be imported by the application programmer,
which makes certain types of computations very natural and compact.
- Appearance of the TurtleScreen and the Turtles at startup/import can be
configured by means of a turtle.cfg configuration file.
The default configuration mimics the appearance of the old turtle module.
- If configured appropriately the module reads in docstrings from a docstring
dictionary in some different language, supplied separately and replaces
the English ones by those read in. There is a utility function
write_docstringdict() to write a dictionary with the original (English)
docstrings to disc, so it can serve as a template for translations.
Behind the scenes there are some features included with possible
extensions in mind. These will be commented and documented elsewhere.
s5 turtle 1.0b1 - for Python 2.6 - 30. 5. 2008, 18:08i����N( t isfilet splitt join( t deepcopy( t *t ScrolledCanvast TurtleScreent Screent RawTurtlet Turtlet RawPent Pent Shapet Vec2Dt addshapet bgcolort bgpict byet clearscreent colormodet delayt exitonclickt getcanvast getshapest listent modet onkeyt
onscreenclickt ontimert register_shapet resetscreent
screensizet setupt setworldcoordinatest titlet tracert turtlest updatet
window_heightt window_widtht backt backwardt
begin_fillt
begin_polyt bkt circlet cleart
clearstampt clearstampst clonet colort degreest distancet dott downt end_fillt end_polyt fdt fillt fillcolort forwardt get_polyt getpent getscreent getturtlet gotot headingt
hideturtlet homet htt isdownt isvisiblet leftt ltt onclickt ondragt onreleaset pdt pent pencolort pendownt pensizet penupt post positiont put radianst rightt resett
resizemodet rtt setht
setheadingt setpost setpositiont settiltanglet
setundobuffert setxt setyt shapet shapesizet
showturtlet speedt stt stampt tiltt tiltanglet towardst
turtlesizet undot undobufferentriest upt widtht writet xcort ycort write_docstringdictt donet mainloopt acost asint atant atan2t ceilt cost cosht et expt fabst floort fmodt frexpt hypott ldexpt logt log10t modft pit powt sint sinht sqrtt tant tanht
Terminatorg �?g �?t heighti� t canvwidthi, t
canvheightt leftrightt topbottomt standardg �?i
i� t undobuffersizet classict blackt noresizet visiblet englisht languaget turtlet
exampleturtlet screent
examplescreens Python Turtle Graphicst
using_IDLEc C s# t | d � } | j � } | j � i } x� | D]� } | j � } | s2 | j d � r` q2 n y | j d � \ } } Wn# t k
r� d | | f GHq2 n X| j � } | j � } | d k r� t | � } n? y+ d
| k r� t | � } n t | � } Wn t k
rn X| | | <q2 W| S( s/ Convert content of config-file into dictionary.t rt #t =s Bad line in config-file %s:
%st Truet Falset Nones ''s ""t .( R� R� R� s ''s ""(
t opent readlinest closet stript
startswithR t
ValueErrort evalt floatt int( t filenamet ft cfglinest cfgdictt linet keyt value( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt config_dict� s2
c C s� d } i } i } t | � r- t | � } n d | k rJ d | d } n y% t t � \ } } t | | � } Wn t k
r� d } n Xt | � r� t | � } n t j | � t j | � d S( s@ Read config-files, change configuration-dict accordingly.
If there is a turtle.cfg file in the current working directory,
read it from there. If this contains an importconfig-value,
say 'myway', construct filename turtle_mayway.cfg else use
turtle.cfg and read it from the import-directory, where
turtle.py is located.
Update configuration dictionary first according to config-file,
in the import directory, then according to config-file in the
current working directory.
If no config-file is found, the default configuration is used.
s
turtle.cfgt importconfigs
turtle_%s.cfgt N( R R� R t __file__R t
BaseExceptiont _CFGR% ( R� t default_cfgt cfgdict1t cfgdict2t headt tailt cfg_file2( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt
readconfig� s
s" No configfile read, reason unknownc B sh e Z d Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d
� Z RS( s� A 2 dimensional vector class, used as a helper class
for implementing turtle graphics.
May be useful for turtle graphics programs also.
Derived from tuple, so a vector is a tuple!
Provides (for a, b vectors, k number):
a+b vector addition
a-b vector subtraction
a*b inner product
k*a and a*k multiplication with scalar
|a| absolute value of a
a.rotate(angle) rotation
c C s t j | | | f � S( N( t tuplet __new__( t clst xt y( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� s c C s% t | d | d | d | d � S( Ni i ( R
( t selft other( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt __add__ s c C sL t | t � r/ | d | d | d | d St | d | | d | � S( Ni i ( t
isinstanceR
( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt __mul__ s c C s9 t | t t t f � r5 t | d | | d | � Sd S( Ni i ( R� R� t longR� R
( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt __rmul__ s c C s% t | d | d | d | d � S( Ni i ( R
( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt __sub__ s c C s t | d | d � S( Ni i ( R
( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt __neg__ s c C s | d d | d d d S( Ni i i g �?( ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt __abs__ s c C s} t | d | d � } | t j d } t j | � t j | � } } t | d | | d | | d | | d | � S( s. rotate self counterclockwise by angle
i i g �f@( R
t mathR� R| R� ( R� t anglet perpt ct s( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt rotate s c C s | d | d f S( Ni i ( ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt __getnewargs__& s c C s d | S( Ns (%.2f,%.2f)( ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt __repr__( s (
t __name__t
__module__t __doc__R� R� R� R� R� R� R� R� R� R� ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR
s
c C s} t | j � } | j � x | D] } t | | � q Wx? | j j � D]. \ } } t | � t j k rG | | | <qG qG Wd S( s# helper function for Scrolled CanvasN( t listt __bases__t reverset __methodDictt __dict__t itemst typet typest FunctionType( R� t _dictt baseListt _superR� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� 4 s
c C s i } t | | � | j � S( s# helper function for Scrolled Canvas( R� t keys( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt __methods> s
s* def %(method)s(self, *args, **kw): return s* self.%(attribute)s.%(method)s(*args, **kw)c
B s& i } e | | � x> | j � D]0 } | d d k sF | d d k r | | =q q Wx$ | D] } | | k r[ | | =q[ q[ Wx* e | � D] } | | k r� | | =q� q� Wxw | j � D]i \ } } i | d 6| d 6} e | � e j k re i | d 6| d 6} n | | U| | | j | <q� Wd S( sn Helper functions for Scrolled Canvas, used to forward
ScrolledCanvas-methods to Tkinter.Canvas class.
i t _i����t methodt funct attributeN( R� R� R� R� R� R� t
StringTypet __stringBodyR� (
t fromClasst toClasst toPartt excludeR� t exR� R� t dt
execString( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt __forwardmethodsH s"
c B s} e Z d Z d d d d d � Z d d d d � Z d � Z d � Z d � Z d � Z d
� Z
d � Z d � Z d
� Z
RS( s� Modeled after the scrolled canvas class from Grayons's Tkinter book.
Used as the default canvas, which pops up automatically when
using turtle graphics functions or the Turtle class.
i� i^ iX c C s
t j j | | d | d | �| j � | _ | | | _ | _ | | | _ | _ d | _ t j
| d | d | d | j d t j d d �| _ t j
| d | j j d t j �| _ t j
| d | j j �| _ | j j d
| j j d | j j � | j d d
d d d �| j d d
d d d �| j j d d d | d d d d d d d d d d d d � | j j d d d | d d d d d d d d d d d d � | j j d d d | d d d d d d d d d d d d � | j � | j j d | j � d S( NRp R� t whitet bgt relieft borderwidthi t commandt orientt xscrollcommandt yscrollcommandi t weighti t minsizet padxt in_t padyt rowt columnt rowspant
columnspant stickyt newss <Configure>( t TKt Framet __init__t winfo_toplevelt _rootwindowRp R� R� R� R� t Canvast SUNKENt _canvast Scrollbart xviewt
HORIZONTALt hscrollt yviewt vscrollt configuret sett rowconfiguret columnconfiguret gridRX t bindt onResize( R� t masterRp R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR g s,
$$$
c C s� | r | | _ n | r$ | | _ n | r6 | | _ n | j j d | d | j d | j d | j d | j d f � | j j d | j | j d | j � | j j d | j | j d | j � | j � d S( s< Adjust canvas and scrollbars according to given canvas size.R� t scrollregioni g �?i N(
R� R� R� R t configt xview_movetoRp t yview_movetoR� t
adjustScrolls( R� R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRX � s c C s | j j � } | j j � } | j j d | j | | j � | j j d | j | | j � | | j k s� | | j k r� | j j d d d | d d d d d d d d d
d d d � | j j d d d | d d d d d d d d d
d d d � n | j j
� | j j
� d
S( sA Adjust scrollbars according to window- and canvas-size.
g �?R i R R R
R i R R
R R N( R t winfo_widtht winfo_heightR( R� R) R� R R" R t grid_forget( R� t cwidtht cheight( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR* � s "" $$
c C s | j � d S( s self-explanatoryN( R* ( R� t event( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR$ � s c G s | j j | � S( s@ 'forward' method, which canvas itself has inherited...
( R t bbox( R� t args( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR1 � s c O s | j j | | � S( s@ 'forward' method, which canvas itself has inherited...
( R t cget( R� R2 t kwargs( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR3 � s c O s | j j | | � d S( s@ 'forward' method, which canvas itself has inherited...
N( R R' ( R� R2 R4 ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR' � s c O s | j j | | � d S( s@ 'forward' method, which canvas itself has inherited...
N( R R# ( R� R2 R4 ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR# � s c O s | j j | | � d S( s@ 'forward' method, which canvas itself has inherited...
N( R t unbind( R� R2 R4 ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR5 � s c C s | j j � d S( s@ 'forward' method, which canvas itself has inherited...
N( R t focus_force( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR6 � s N( R� R� R� R R� RX R* R$ R1 R3 R' R# R5 R6 ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR a s R t _Rootc B sM e Z d Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z RS( s' Root class for Screen based on Tkinter.c C s t j j | � d S( N( R t TkR ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR � s c C s8 t | | | | | � | _ | j j d d d d � d S( Nt expandi R: t both( R R t pack( R� Rp R� R. R/ ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt setupcanvas� s c C s | j S( N( R ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt
_getcanvas� s c C s! | j d | | | | f � d S( Ns %dx%d%+d%+d( t geometry( R� Rp R� t startxt starty( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt set_geometry� s c C s | j d | � d S( Nt WM_DELETE_WINDOW( t wm_protocol( R� t destroy( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt ondestroy� s c C s
| j � S( N( t winfo_screenwidth( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt win_width� s c C s
| j � S( N( t winfo_screenheight( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt
win_height� s (
R� R� R� R R< R= RA RE RG RI ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR7 � s t TurtleScreenBasec B s[ e Z d Z e d � � Z e d � � Z d � Z d � Z d d d e d � Z
d � Z d d d e d � Z d � Z
d � Z d
� Z d � Z d d � Z d
� Z d d d � Z d d d � Z d d d � Z d d d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d d d d � Z! d � Z" RS( s� Provide the basic graphics functionality.
Interface between Tkinter and turtle.py.
To port turtle.py to some different graphics toolkit
a corresponding TurtleScreenBase class has to be implemented.
c C s& t j d d d d � } | j � | S( s$ return a blank image object
Rp i R� ( R t
PhotoImaget blank( t img( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _blankimage� s
c C s t j d | � S( s` return an image object containing the
imagedata from a gif-file named filename.
t file( R RK ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _image� s c C s� | | _ t | t � r3 | j j } | j j } na t | j j d � � } t | j j d � � } | j j d | d | d | d | d f � | | _ | | _ d | _ | _ d S( NRp R� R& i g �?(
t cvR� R R� R� R� R3 R' t xscalet yscale( R� RQ t wt h( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR � s 1 c C s | j j d d d d d �S( s< Create an invisible polygon item on canvas self.cv)
i R: R� t outline( i i i i i i ( RQ t create_polygon( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _createpoly s c
C s� g } x= | D]5 \ } } | j | | j � | j | | j � q
W| j j | | � | d k r~ | j j | d | �n | d k r� | j j | d | �n | d k r� | j j | d | �n | r� | j j | � n d S( s` Configure polygonitem polyitem according to provided
arguments:
coordlist is sequence of coordinates
fill is filling color
outline is outline color
top is a boolean value, which specifies if polyitem
will be put on top of the canvas' displaylist so it
will not be covered by other items.
R: RV Rp N( t appendRR RS RQ t coordsR� t
itemconfiguret tag_raise(
R� t polyitemt coordlistR: RV Rp t topt clR� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _drawpoly s c C s. | j j d d d d d d d d d t j �S( s9 Create an invisible line item on canvas self.cv)
i R: R� Rp i t capstyle( RQ t create_lineR t ROUND( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _createline$ s $c C s� | d k rh g } x= | D]5 \ } } | j | | j � | j | | j � q W| j j | | � n | d k r� | j j | d | �n | d k r� | j j | d | �n | r� | j j | � n d S( sQ Configure lineitem according to provided arguments:
coordlist is sequence of coordinates
fill is drawing color
width is width of drawn line.
top is a boolean value, which specifies if polyitem
will be put on top of the canvas' displaylist so it
will not be covered by other items.
R: Rp N( R� RY RR RS RQ RZ R[ R\ ( R� t lineitemR^ R: Rp R_ R` R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _drawline* s
c C s | j j | � d S( s] Delete graphics item from canvas.
If item is"all" delete all graphics items.
N( RQ t delete( R� t item( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _deleteA s c C s | j j � d S( s( Redraw graphics items on canvas
N( RQ R% ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _updateG s c C s | j j | � d S( s- Delay subsequent canvas actions for delay ms.N( RQ t after( R� R ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _delayL s c C s= y | j j | � } t } Wn t j k
r8 t } n X| S( sC Check if the string color is a legal Tkinter color string.
( RQ t winfo_rgbR� R t TclErrorR� ( R� R2 t rgbt ok( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _iscolorstringP s
c C s@ | d k r, | j j d | � | j � n | j j d � Sd S( sV Set canvas' backgroundcolor if color is not None,
else return backgroundcolor.R� N( R� RQ R' Rk R3 ( R� R2 ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _bgcolorZ s
c C s� | \ } } | | j } | | j } i d d 6d d 6d d 6} | j j | d | d | d | | d
| d | �} | j j | � \ }
} } }
| j j � | | d f S( s� Write txt at pos in canvas with specified font
and color.
Return text item and x-coord of right bottom corner
of text's bounding box.t swRH R� t centert seRW i t textt anchorR: t font( RR RS RQ t create_textR1 R% ( R� RS t txtt alignRy RO R� R� Rx Ri t x0t y0t x1t y1( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _writec s
'
i c sY � d k r& � j j | d | � n/ � � f d � } � j j | d | | | � d S( s� Bind fun to mouse-click event on turtle.
fun must be a function with two arguments, the coordinates
of the clicked point on the canvas.
num, the number of the mouse-button defaults to 1
s <Button-%s>c sK � j j | j � � j � j j | j � � j } } � | | � d S( N( RQ t canvasxR� RR t canvasyR� RS ( R0 R� R� ( t funR� ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt eventfun~ s !N( R� RQ t
tag_unbindt tag_bind( R� Ri R� t numt addR� ( ( R� R� s% /usr/lib64/python2.7/lib-tk/turtle.pyt _onclicku s c sY � d k r& � j j | d | � n/ � � f d � } � j j | d | | | � d S( sg Bind fun to mouse-button-release event on turtle.
fun must be a function with two arguments, the coordinates
of the point on the canvas where mouse button is released.
num, the number of the mouse-button defaults to 1
If a turtle is clicked, first _onclick-event will be performed,
then _onscreensclick-event.
s <Button%s-ButtonRelease>c sK � j j | j � � j � j j | j � � j } } � | | � d S( N( RQ R� R� RR R� R� RS ( R0 R� R� ( R� R� ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� � s !N( R� RQ R� R� ( R� Ri R� R� R� R� ( ( R� R� s% /usr/lib64/python2.7/lib-tk/turtle.pyt
_onrelease� s
c sY � d k r& � j j | d | � n/ � � f d � } � j j | d | | | � d S( sq Bind fun to mouse-move-event (with pressed mouse button) on turtle.
fun must be a function with two arguments, the coordinates of the
actual mouse position on the canvas.
num, the number of the mouse-button defaults to 1
Every sequence of mouse-move-events on a turtle is preceded by a
mouse-click event on that turtle.
s <Button%s-Motion>c sc yK � j j | j � � j � j j | j � � j } } � | | � Wn t k
r^ n Xd S( N( RQ R� R� RR R� R� RS R� ( R0 R� R� ( R� R� ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� � s !
N( R� RQ R� R� ( R� Ri R� R� R� R� ( ( R� R� s% /usr/lib64/python2.7/lib-tk/turtle.pyt _ondrag� s c sS � d k r# � j j d | � n, � � f d � } � j j d | | | � d S( sG Bind fun to mouse-click event on canvas.
fun must be a function with two arguments, the coordinates
of the clicked point on the canvas.
num, the number of the mouse-button defaults to 1
If a turtle is clicked, first _onclick-event will be performed,
then _onscreensclick-event.
s <Button-%s>c sK � j j | j � � j � j j | j � � j } } � | | � d S( N( RQ R� R� RR R� R� RS ( R0 R� R� ( R� R� ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� � s !N( R� RQ R5 R# ( R� R� R� R� R� ( ( R� R� s% /usr/lib64/python2.7/lib-tk/turtle.pyt _onscreenclick� s c sP � d k r& | j j d | d � n& � f d � } | j j d | | � d S( s` Bind fun to key-release event of key.
Canvas must have focus. See method listen
s <KeyRelease-%s>c s � � d S( N( ( R0 ( R� ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� � s N( R� RQ R5 R# ( R� R� R� R� ( ( R� s% /usr/lib64/python2.7/lib-tk/turtle.pyt _onkey� s c C s | j j � d S( s= Set focus on canvas (in order to collect key-events)
N( RQ R6 ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _listen� s c C s6 | d k r | j j | � n | j j | | � d S( s? Install a timer, which calls fun after t milliseconds.
i N( RQ t
after_idleRl ( R� R� t t( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _ontimer� s c C s | j j d d d | �S( s0 Create and return image item on canvas.
i t image( RQ t create_image( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _createimage� s c C sN | \ } } | j j | | | j | | j f � | j j | d | �d S( sZ Configure image item as to draw image object
at position (x,y) on canvas)
R� N( RQ RZ RR RS t
itemconfig( R� Ri RS R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt
_drawimage� s (c C s* | j j | d | �| j j | � d S( s� Configure image item as to draw image object
at center of canvas. Set item to the first item
in the displaylist, so it will be drawn below
any other item .R� N( RQ R� t tag_lower( R� Ri R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _setbgpic� s c C s | j j | � S( sQ Return 'line' or 'polygon' or 'image' depending on
type of item.
( RQ R� ( R� Ri ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _type� s c C sT | j j | � } g t d t | � d � D] } | | | | d f ^ q+ } | S( s returns list of coordinate-pairs of points of item
Example (for insiders):
>>> from turtle import *
>>> getscreen()._pointlist(getturtle().turtle._item)
[(0.0, 9.9999999999999982), (0.0, -9.9999999999999982),
(9.9999999999999982, 0.0)]
>>> i i i ( RQ RZ t ranget len( R� Ri R` t it pl( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt
_pointlist� s >c C s# | j j d | | | | f � d S( NR& ( RQ R' ( R� t srx1t sry1t srx2t sry2( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _setscrollregion� s c C s� | j j � } x� | D]z } | j j | � } g } xF | r| | d \ } } | j | | � | j | | � | d } q7 W| j j | | � q Wd S( Ni ( RQ t find_allRZ RY ( R� t xscalefactort yscalefactorR� Ri t coordinatest newcoordlistR� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _rescale s
c C s� t | j t � s" | j | j f S| | k oD | k oD d k n r_ | j j | j j f S| d k rw | | _ n | d k r� | | _ n | j j | | | � d S( sa Resize the canvas the turtles are drawing on. Does
not alter the drawing window.
N( R� RQ R R� R� R� RX ( R� R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _resize s ' c C s` | j j � } | d k r+ | j d } n | j j � } | d k rV | j d } n | | f S( s; Return the width and height of the turtle window.
i Rp R� ( RQ R+ R, ( R� Rp R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _window_size s N(# R� R� R� t staticmethodRN RP R RX R� R� Ra Re Rg Rj Rk Rm Rr Rs R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRJ � s@
c B s e Z d Z RS( s� Will be raised in TurtleScreen.update, if _RUNNING becomes False.
This stops execution of a turtle graphics script.
Main purpose: use in the Demo-Viewer turtle.Demo.py.
( R� R� R� ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� , s t TurtleGraphicsErrorc B s e Z d Z RS( s Some TurtleGraphics Error
( R� R� R� ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� 5 s c B s& e Z d Z d d � Z d d � Z RS( s� Data structure modeling shapes.
attribute _type is one of "polygon", "image", "compound"
attribute _data is - depending on _type a poygon-tuple,
an image or a list constructed using the addcomponent method.
c C s� | | _ | d k r6 t | t � r� t | � } q� ny | d k r� t | t � r� | j � j d � r� t | � r� t j | � } q� q� n% | d k r� g } n t
d | � � | | _ d S( Nt polygonR� s .gift compounds There is no shape type %s( R� R� R� R� t
basestringt lowert endswithR R RP R� t _data( R� t type_t data( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR A s ! c C sW | j d k r% t d | j � � n | d k r: | } n | j j | | | g � d S( s- Add component to a shape of type compound.
Arguments: poly is a polygon, i. e. a tuple of number pairs.
fill is the fillcolor of the component,
outline is the outline color of the component.
call (for a Shapeobject namend s):
-- s.addcomponent(((0,0), (10,10), (-10,10)), "red", "blue")
Example:
>>> poly = ((0,0),(10,-5),(0,10),(-10,-5))
>>> s = Shape("compound")
>>> s.addcomponent(poly, "red", "blue")
>>> # .. add more components and then use register_shape()
R� s Cannot add component to %s ShapeN( R� R� R� R� RY ( R� t polyR: RV ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt addcomponentQ s N( R� R� R� R� R R� ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR : s t Tbufferc B sJ e Z d Z d d � Z d d � Z d � Z d � Z d � Z d � Z RS( s5 Ring buffer used as undobuffer for RawTurtle objects.i
c C s2 | | _ d g g | | _ d | _ t | _ d S( Ni����( t bufsizeR� t buffert ptrR� t cumulate( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR k s c C sb | d k r9 xF t | j � D] } d g | j | <q Wn | | _ d g g | | _ d | _ d S( Ni����( R� R� R� R� R� ( R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRX p s c C s` | j d k r\ | j sB | j d | j | _ | | j | j <q\ | j | j j | � n d S( Ni i ( R� R� R� R� RY ( R� Ri ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt pushx s
c C sd | j d k r` | j | j } | d k r/ d Sd g | j | j <| j d | j | _ | Sn d S( Ni i ( R� R� R� R� ( R� Ri ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt pop s c C s | j | j j d g � S( N( R� R� t countR� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt nr_of_items� s c C s t | j � d t | j � S( Nt ( t strR� R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� � s N(
R� R� R� R R� RX R� R� R� R� ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� i s c B sO e Z d Z e Z e d e d e d d � Z d � Z d d � Z d � Z
d d � Z d � Z d
� Z
d d � Z d � Z d
� Z d � Z d d d � Z d d � Z d � Z d � Z d � Z d � Z d � Z d � Z d d d � Z d � Z d d d � Z d d � Z d d � Z d d d d � Z e Z e Z! e Z" e Z# RS( s� Provides screen oriented methods like setbg etc.
Only relies upon the methods of TurtleScreenBase and NOT
upon components of the underlying graphics toolkit -
which is Tkinter in this case.
R R R c C s� i t d d/ d0 d1 f � d 6t d d2 d3 d4 d5 d6 d7 d8 d9 d: d; d< d= d> d? d@ dA dB dC dD dE dF dG dH dI f � d 6t d dJ dK dL dM dN dO dP dQ dR dS dT dU dV dW dX dY dZ d[ d\ d] f � d$ 6t d d^ d_ d` da f � d% 6t d db dc dd f � d( 6t d de df dg dh f � d) 6t d* | j � � d+ 6| _ i d, d- 6| _ t j | | � | | _ | | _ t d. | _ g | _
| j � d S(i NR� i����i i
t arrowi i����i i����i����i i����i i����i i����i i i����i����i����i i i R� g��Q� #@g� ��Q�@g�G�z. @g��Q� �@g� ��Q��g��Q� ��g�G�z. �g��Q� #�g �g $�R- t squareg�G�z�g�����'@t triangleR� R� RL R� t nopicR ( i����i ( i
i ( i i
( i i ( i����i ( i����i
( i����i ( i����i ( i����i ( i����i ( i����i ( i����i����( i����i����( i����i����( i����i����( i i����( i i����( i i����( i i����( i i����( i i ( i i ( i i ( i i ( i i ( i i
( i i ( i
i ( g��Q� #@g� ��Q�@( g�G�z. @g��Q� �@( g��Q� �@g�G�z. @( g� ��Q�@g��Q� #@( i i
( g� ��Q��g��Q� #@( g��Q� ��g�G�z. @( g�G�z. �g��Q� �@( g��Q� #�g� ��Q�@( i����i ( g��Q� #�g� ��Q��( g�G�z. �g��Q� ��( g��Q� ��g�G�z. �( g� ��Q��g��Q� #�( g �g $�( g� ��Q�@g��Q� #�( g��Q� �@g�G�z. �( g�G�z. @g��Q� ��( g��Q� #@g� ��Q��( i
i����( i
i
( i����i
( i����i����( i
g�G�z�( i g�����'@( i����g�G�z�( i i ( i����i����( i i����( i i����( R RN t _shapest _bgpicsRJ R t _modet _delayvalueR� t
_colormodet _keysR. ( R� RQ R R R ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR � s4
c C s� t d | _ t d | _ | j d � | j d � | _ d | _ d | _ d | _ g | _ | j
d � x d D] } | j d | � qq Wx" | j
D] } | j d | � q� Wd t _ d S(
sq Delete all drawings and all turtles from the TurtleScreen.
Reset empty TurtleScreen to its initial state: white background,
no backgroundimage, no eventbindings and tracing on.
No argument.
Example (for a TurtleScreen instance named screen):
>>> screen.clear()
Note: this method is not available as function.
R R t allR� R� i i R� i i N( i i i ( R� R� R� Rj R� t _bgpict
_bgpicnamet _tracingt _updatecountert _turtlesR RJ R� R� R R t _pen( R� t btnR� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR. � s
c C s� | d k r | j S| j � } | d k r> t d | � � n | | _ | d k r� | j | j d | j d | j d | j d � d | _ | _ n | j � d S(
sh Set turtle-mode ('standard', 'logo' or 'world') and perform reset.
Optional argument:
mode -- one of the strings 'standard', 'logo' or 'world'
Mode 'standard' is compatible with turtle.py.
Mode 'logo' is compatible with most Logo-Turtle-Graphics.
Mode 'world' uses userdefined 'worldcoordinates'. *Attention*: in
this mode angles appear distorted if x/y unit-ratio doesn't equal 1.
If mode is not given, return the current mode.
Mode Initial turtle heading positive angles
------------|-------------------------|-------------------
'standard' to the right (east) counterclockwise
'logo' upward (north) clockwise
Examples:
>>> mode('logo') # resets turtle heading to north
>>> mode()
'logo'
R� t logot worlds No turtle-graphics-mode %si g �?N( R� R� R� ( R� R� (
R� R� R� R� R� R� R� RR RS RX ( R� R ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR � s c C s | j � d k r" | j d � n t | | � } t | | � } | j � \ } } | j | d | d � | j | j } }
| j | | _ | j | | _ | | j } | | j } | j | }
| j | } | j | | |
| � | j | j | | j |
� | j
� d S( ss Set up a user defined coordinate-system.
Arguments:
llx -- a number, x-coordinate of lower left corner of canvas
lly -- a number, y-coordinate of lower left corner of canvas
urx -- a number, x-coordinate of upper right corner of canvas
ury -- a number, y-coordinate of upper right corner of canvas
Set up user coodinat-system and switch to mode 'world' if necessary.
This performs a screen.reset. If mode 'world' is already active,
all drawings are redrawn according to the new coordinates.
But ATTENTION: in user-defined coordinatesystems angles may appear
distorted. (see Screen.mode())
Example (for a TurtleScreen instance named screen):
>>> screen.setworldcoordinates(-10,-0.5,50,1.5)
>>> for _ in range(36):
... left(10)
... forward(0.5)
R� i N( R R� R� R RR RS R� R� R� R� R% ( R� t llxt llyt urxt uryt xspant yspant wxt wyt oldxscalet oldyscaleR� R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR! � s
c C s� | d k rO | j � j d � r< t d | j | � � } qp t d d � � n! t | t � rp t d | � } n | | j | <d S( s� Adds a turtle shape to TurtleScreen's shapelist.
Arguments:
(1) name is the name of a gif-file and shape is None.
Installs the corresponding image shape.
!! Image-shapes DO NOT rotate when turning the turtle,
!! so they do not display the heading of the turtle!
(2) name is an arbitrary string and shape is a tuple
of pairs of coordinates. Installs the corresponding
polygon shape
(3) name is an arbitrary string and shape is a
(compound) Shape object. Installs the corresponding
compound shape.
To use a shape, you have to issue the command shape(shapename).
call: register_shape("turtle.gif")
--or: register_shape("tri", ((0,0), (10,10), (-10,10)))
Example (for a TurtleScreen instance named screen):
>>> screen.register_shape("triangle", ((5,-3),(0,5),(-5,-3)))
s .gifR� s" Bad arguments for register_shape.
s Use help(register_shape)R� N( R� R� R� R RP R� R� R� R� ( R� t nameRc ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR s
c C sn t | � d k r | d } n t | t � rf | j | � sI | d k rM | St d t | � � � n y | \ } } } Wn- t t f k
r� t d t | � � � n X| j d k r� g | | | f D] } t d | � ^ q� \ } } } n d | k od k n oAd | k o#d k n oAd | k o?d k n s]t d t | � � � n d
| | | f S( s Return color string corresponding to args.
Argument may be a string or a tuple of three
numbers corresponding to actual colormode,
i.e. in the range 0<=n<=colormode.
If the argument doesn't represent a color,
an error is raised.
i i R� s bad color string: %ss bad color arguments: %sg �?g �o@i� s bad color sequence: %ss
#%02x%02x%02x(
R� R� R� Rr R� R� t TypeErrorR� R� t round( R� R2 R� t gt bR� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _colorstrB s
8Tc C s� | j d � s | St | � d k rU g d D] } t | | | d !d � ^ q, } nS t | � d k r� g | d D] } d t | | d � ^ qr } n t d | � � t g | D] } | | j d
^ q� � S( NR� i i i i i i i s bad colorstring: %si� ( i i i ( R� R� R� R� R� R� ( R� t cstrR� R` RU R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _color] s 01c C sS | d k r | j S| d k r1 t | � | _ n | d k rO t | � | _ n d S( sq Return the colormode or set it to 1.0 or 255.
Optional argument:
cmode -- one of the values 1.0 or 255
r, g, b values of colortriples have to be in range 0..cmode.
Example (for a TurtleScreen instance named screen):
>>> screen.colormode()
1.0
>>> screen.colormode(255)
>>> pencolor(240,160,80)
g �?i� N( R� R� R� R� ( R� t cmode( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR h s c C s2 x+ | j D] } | j | j � | j � q
Wd S( s� Reset all Turtles on the Screen to their initial state.
No argument.
Example (for a TurtleScreen instance named screen):
>>> screen.reset()
N( R� t _setmodeR� RX ( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRX } s c C s | j S( s� Return the list of turtles on the screen.
Example (for a TurtleScreen instance named screen):
>>> screen.turtles()
[<turtle.Turtle object at 0x00E11FB0>]
( R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR$ � s c G sO | r | j | � } n d } | j | � } | d k rK | j | � } n | S( s� Set or return backgroundcolor of the TurtleScreen.
Arguments (if given): a color string or three numbers
in the range 0..colormode or a 3-tuple of such numbers.
Example (for a TurtleScreen instance named screen):
>>> screen.bgcolor("orange")
>>> screen.bgcolor()
'orange'
>>> screen.bgcolor(0.5,0,0.5)
>>> screen.bgcolor()
'#800080'
N( R� R� Rs R� ( R� R2 R2 ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR � s c C sc | d k r | j St | � | _ d | _ | d k rI t | � | _ n | j r_ | j � n d S( se Turns turtle animation on/off and set delay for update drawings.
Optional arguments:
n -- nonnegative integer
delay -- nonnegative integer
If n is given, only each n-th regular screen update is really performed.
(Can be used to accelerate the drawing of complex graphics.)
Second arguments sets delay value (see RawTurtle.delay())
Example (for a TurtleScreen instance named screen):
>>> screen.tracer(8, 25)
>>> dist = 2
>>> for i in range(200):
... fd(dist)
... rt(90)
... dist += 2
i N( R� R� R� R� R� R% ( R� t nR ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR# � s c C s& | d k r | j St | � | _ d S( s� Return or set the drawing delay in milliseconds.
Optional argument:
delay -- positive integer
Example (for a TurtleScreen instance named screen):
>>> screen.delay(15)
>>> screen.delay()
15
N( R� R� R� ( R� R ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR � s c C sR t j s t t _ t � n | j d k rN | j d 7_ | j | j ;_ n d S( s Increment update counter.i i N( R t _RUNNINGR� R� R� R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt
_incrementudc� s c C sT | j } t | _ x( | j � D] } | j � | j � q W| | _ | j � d S( s' Perform a TurtleScreen update.
N( R� R� R$ t _update_datat _drawturtleRk ( R� t tracingR� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR% � s
c C s | j � d S( s� Return the width of the turtle window.
Example (for a TurtleScreen instance named screen):
>>> screen.window_width()
640
i ( R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR' � s c C s | j � d S( s� Return the height of the turtle window.
Example (for a TurtleScreen instance named screen):
>>> screen.window_height()
480
i ( R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR& � s c C s | j S( s� Return the Canvas of this TurtleScreen.
No argument.
Example (for a Screen instance named screen):
>>> cv = screen.getcanvas()
>>> cv
<turtle.ScrolledCanvas instance at 0x010742D8>
( RQ ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR � s
c C s t | j j � � S( s� Return a list of names of all currently available turtle shapes.
No argument.
Example (for a TurtleScreen instance named screen):
>>> screen.getshapes()
['arrow', 'blank', 'circle', ... , 'turtle']
( t sortedR� R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR s i c C s | j | | | � d S( s Bind fun to mouse-click event on canvas.
Arguments:
fun -- a function with two arguments, the coordinates of the
clicked point on the canvas.
btn -- the number of the mouse-button, defaults to 1
Example (for a TurtleScreen instance named screen
and a Turtle instance named turtle):
>>> screen.onclick(goto)
>>> # Subsequently clicking into the TurtleScreen will
>>> # make the turtle move to the clicked point.
>>> screen.onclick(None)
N( R� ( R� R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRJ s c C sg | d k r1 | | j k rS | j j | � qS n" | | j k rS | j j | � n | j | | � d S( sm Bind fun to key-release event of key.
Arguments:
fun -- a function with no arguments
key -- a string: key (e.g. "a") or key-symbol (e.g. "space")
In order to be able to register key-events, TurtleScreen
must have focus. (See method listen.)
Example (for a TurtleScreen instance named screen):
>>> def f():
... fd(50)
... lt(60)
...
>>> screen.onkey(f, "Up")
>>> screen.listen()
Subsequently the turtle can be moved by repeatedly pressing
the up-arrow key, consequently drawing a hexagon
N( R� R� t removeRY R� ( R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR # s c C s | j � d S( s Set focus on TurtleScreen (in order to collect key-events)
No arguments.
Dummy arguments are provided in order
to be able to pass listen to the onclick method.
Example (for a TurtleScreen instance named screen):
>>> screen.listen()
N( R� ( R� t xdummyt ydummy( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR A s
i c C s | j | | � d S( s� Install a timer, which calls fun after t milliseconds.
Arguments:
fun -- a function with no arguments.
t -- a number >= 0
Example (for a TurtleScreen instance named screen):
>>> running = True
>>> def f():
... if running:
... fd(50)
... lt(60)
... screen.ontimer(f, 250)
...
>>> f() # makes the turtle marching around
>>> running = False
N( R� ( R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR M s c C sb | d k r | j S| | j k r; | j | � | j | <n | j | j | j | � | | _ d S( sF Set background image or return name of current backgroundimage.
Optional argument:
picname -- a string, name of a gif-file or "nopic".
If picname is a filename, set the corresponding image as background.
If picname is "nopic", delete backgroundimage, if present.
If picname is None, return the filename of the current backgroundimage.
Example (for a TurtleScreen instance named screen):
>>> screen.bgpic()
'nopic'
>>> screen.bgpic("landscape.gif")
>>> screen.bgpic()
'landscape.gif'
N( R� R� R� RP R� R� ( R� t picname( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR b s c C s | j | | | � S( s� Resize the canvas the turtles are drawing on.
Optional arguments:
canvwidth -- positive integer, new width of canvas in pixels
canvheight -- positive integer, new height of canvas in pixels
bg -- colorstring or color-tuple, new backgroundcolor
If no arguments are given, return current (canvaswidth, canvasheight)
Do not alter the drawing window. To observe hidden parts of
the canvas use the scrollbars. (Can make visible those parts
of a drawing, which were outside the canvas before!)
Example (for a Turtle instance named turtle):
>>> turtle.screensize(2000,1500)
>>> # e. g. to search for an erroneously escaped turtle ;-)
( R� ( R� R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR z s N($ R� R� R� R� R� R� R R. R� R R! R R� R� R RX R$ R R# R R� R% R' R& R R RJ R R R R R R R R R ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR � s@ " ' $ t
TNavigatorc B s� e Z d Z i e d d � d 6e d d � d 6e d d � d 6Z d Z d Z d Z e d � Z d � Z d% d
� Z d � Z d d
� Z
d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d% d � Z d � Z d � Z d � Z d% d � Z d% d � Z d � Z d � Z d% d% d! � Z! d d" � Z" d% d% d# � Z# d% d$ � Z$ e Z% e Z& e Z' e Z( e Z) e Z* e Z+ e Z, e Z- RS(& sR Navigation part of the RawTurtle.
Implements methods for turtle movement.
g �?g R� R� R� i i c C s[ | j | _ | j | _ | | _ d | _ | j � d | _ | j | � t j
| � d S( N( t DEFAULT_ANGLEOFFSETt _angleOffsett DEFAULT_ANGLEORIENTt _angleOrientR� R� t
undobufferR3 R� R� RX ( R� R ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR � s
c C s) t d d � | _ t j | j | _ d S( sX reset turtle to its initial values
Will be overwritten by parent class
g N( R
t _positionR� t START_ORIENTATIONR� t _orient( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRX � s c C sj | d k r | j S| d k r# d S| | _ | d
k rM d | _ d | _ n | j d | _ d | _ d S( s: Set turtle-mode to 'standard', 'world' or 'logo'.
R� R� R� Ni i g @i����( R� R� R� ( R� R� ( R� R� R� R� t _fullcircle( R� R ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� � s c C sB | | _ d | | _ | j d k r1 d | _ n
| d | _ d S( s+ Helper function for degrees() and radians()ih R� i g @N( R t
_degreesPerAUR� R� ( R� t
fullcircle( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _setDegreesPerAU� s
g �v@c C s | j | � d S( s> Set angle measurement units to degrees.
Optional argument:
fullcircle - a number
Set angle measurement units, i. e. set number
of 'degrees' for a full circle. Dafault value is
360 degrees.
Example (for a Turtle instance named turtle):
>>> turtle.left(90)
>>> turtle.heading()
90
Change angle measurement unit to grad (also known as gon,
grade, or gradian and equals 1/100-th of the right angle.)
>>> turtle.degrees(400.0)
>>> turtle.heading()
100
N( R ( R� R ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR3 � s c C s | j d t j � d S( s Set the angle measurement units to radians.
No arguments.
Example (for a Turtle instance named turtle):
>>> turtle.heading()
90
>>> turtle.radians()
>>> turtle.heading()
1.5707963267948966
i N( R R� R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRV � s c C s% | j | j | } | j | � d S( s) move turtle forward by specified distanceN( R� R� t _goto( R� R4 t ende( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _go� s c C s& | | j 9} | j j | � | _ d S( s= Turn turtle counterclockwise by specified angle if angle > 0.N( R R� R� ( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _rotate� s
c C s
| | _ d S( s move turtle to position end.N( R� ( R� t end( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR � s c C s | j | � d S( s Move the turtle forward by the specified distance.
Aliases: forward | fd
Argument:
distance -- a number (integer or float)
Move the turtle forward by the specified distance, in the direction
the turtle is headed.
Example (for a Turtle instance named turtle):
>>> turtle.position()
(0.00, 0.00)
>>> turtle.forward(25)
>>> turtle.position()
(25.00,0.00)
>>> turtle.forward(-75)
>>> turtle.position()
(-50.00,0.00)
N( R ( R� R4 ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR< � s c C s | j | � d S( s� Move the turtle backward by distance.
Aliases: back | backward | bk
Argument:
distance -- a number
Move the turtle backward by distance ,opposite to the direction the
turtle is headed. Do not change the turtle's heading.
Example (for a Turtle instance named turtle):
>>> turtle.position()
(0.00, 0.00)
>>> turtle.backward(30)
>>> turtle.position()
(-30.00, 0.00)
N( R ( R� R4 ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR( s c C s | j | � d S( s� Turn turtle right by angle units.
Aliases: right | rt
Argument:
angle -- a number (integer or float)
Turn turtle right by angle units. (Units are by default degrees,
but can be set via the degrees() and radians() functions.)
Angle orientation depends on mode. (See this.)
Example (for a Turtle instance named turtle):
>>> turtle.heading()
22.0
>>> turtle.right(45)
>>> turtle.heading()
337.0
N( R ( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRW ' s c C s | j | � d S( s� Turn turtle left by angle units.
Aliases: left | lt
Argument:
angle -- a number (integer or float)
Turn turtle left by angle units. (Units are by default degrees,
but can be set via the degrees() and radians() functions.)
Angle orientation depends on mode. (See this.)
Example (for a Turtle instance named turtle):
>>> turtle.heading()
22.0
>>> turtle.left(45)
>>> turtle.heading()
67.0
N( R ( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRH < s c C s | j S( s� Return the turtle's current location (x,y), as a Vec2D-vector.
Aliases: pos | position
No arguments.
Example (for a Turtle instance named turtle):
>>> turtle.pos()
(0.00, 240.00)
( R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRS Q s c C s | j d S( s� Return the turtle's x coordinate.
No arguments.
Example (for a Turtle instance named turtle):
>>> reset()
>>> turtle.left(60)
>>> turtle.forward(100)
>>> print turtle.xcor()
50.0
i ( R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRr ^ s c C s | j d S( s Return the turtle's y coordinate
---
No arguments.
Example (for a Turtle instance named turtle):
>>> reset()
>>> turtle.left(60)
>>> turtle.forward(100)
>>> print turtle.ycor()
86.6025403784
i ( R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRs l s c C s< | d k r" | j t | � � n | j t | | � � d S( st Move turtle to an absolute position.
Aliases: setpos | setposition | goto:
Arguments:
x -- a number or a pair/vector of numbers
y -- a number None
call: goto(x, y) # two coordinates
--or: goto((x, y)) # a pair (tuple) of coordinates
--or: goto(vec) # e.g. as returned by pos()
Move turtle to an absolute position. If the pen is down,
a line will be drawn. The turtle's orientation does not change.
Example (for a Turtle instance named turtle):
>>> tp = turtle.pos()
>>> tp
(0.00, 0.00)
>>> turtle.setpos(60,30)
>>> turtle.pos()
(60.00,30.00)
>>> turtle.setpos((20,80))
>>> turtle.pos()
(20.00,80.00)
>>> turtle.setpos(tp)
>>> turtle.pos()
(0.00,0.00)
N( R� R R
( R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRA { s c C s! | j d d � | j d � d S( s$ Move turtle to the origin - coordinates (0,0).
No arguments.
Move turtle to the origin - coordinates (0,0) and set its
heading to its start-orientation (which depends on mode).
Example (for a Turtle instance named turtle):
>>> turtle.home()
i N( RA R\ ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRD � s c C s! | j t | | j d � � d S( s� Set the turtle's first coordinate to x
Argument:
x -- a number (integer or float)
Set the turtle's first coordinate to x, leave second coordinate
unchanged.
Example (for a Turtle instance named turtle):
>>> turtle.position()
(0.00, 240.00)
>>> turtle.setx(10)
>>> turtle.position()
(10.00, 240.00)
i N( R R
R� ( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRa � s c C s! | j t | j d | � � d S( s� Set the turtle's second coordinate to y
Argument:
y -- a number (integer or float)
Set the turtle's first coordinate to x, second coordinate remains
unchanged.
Example (for a Turtle instance named turtle):
>>> turtle.position()
(0.00, 40.00)
>>> turtle.sety(-10)
>>> turtle.position()
(0.00, -10.00)
i N( R R
R� ( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRb � s c C s� | d k r t | | � } n t | t � r6 | } n9 t | t � rT t | � } n t | t � ro | j } n t | | j � S( s� Return the distance from the turtle to (x,y) in turtle step units.
Arguments:
x -- a number or a pair/vector of numbers or a turtle instance
y -- a number None None
call: distance(x, y) # two coordinates
--or: distance((x, y)) # a pair (tuple) of coordinates
--or: distance(vec) # e.g. as returned by pos()
--or: distance(mypen) # where mypen is another turtle
Example (for a Turtle instance named turtle):
>>> turtle.pos()
(0.00, 0.00)
>>> turtle.distance(30,40)
50.0
>>> pen = Turtle()
>>> pen.forward(77)
>>> turtle.distance(pen)
77.0
N( R� R
R� R� R� R� t abs( R� R� R� RS ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR4 � s c C s� | d k r t | | � } n t | t � r6 | } n9 t | t � rT t | � } n t | t � ro | j } n | | j \ } } t t j | | � d t j d � d } | | j
:} | j | j | | j
S( sC Return the angle of the line from the turtle's position to (x, y).
Arguments:
x -- a number or a pair/vector of numbers or a turtle instance
y -- a number None None
call: distance(x, y) # two coordinates
--or: distance((x, y)) # a pair (tuple) of coordinates
--or: distance(vec) # e.g. as returned by pos()
--or: distance(mypen) # where mypen is another turtle
Return the angle, between the line from turtle-position to position
specified by x, y and the turtle's start orientation. (Depends on
modes - "standard" or "logo")
Example (for a Turtle instance named turtle):
>>> turtle.pos()
(10.00, 10.00)
>>> turtle.towards(0,0)
225.0
g �f@i
g �v@N( R� R
R� R� R� R� R� R� Rz R� R R� R� R ( R� R� R� RS t result( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRk � s *
c C s_ | j \ } } t t j | | � d t j d � d } | | j :} | j | j | | j S( s� Return the turtle's current heading.
No arguments.
Example (for a Turtle instance named turtle):
>>> turtle.left(67)
>>> turtle.heading()
67.0
g �f@i
g �v@( R� R� R� Rz R� R R� R� R ( R� R� R� R
( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRB s
*
c C sK | | j � | j } | j } | | d | | d } | j | � d S( s� Set the orientation of the turtle to to_angle.
Aliases: setheading | seth
Argument:
to_angle -- a number (integer or float)
Set the orientation of the turtle to to_angle.
Here are some common directions in degrees:
standard - mode: logo-mode:
-------------------|--------------------
0 - east 0 - north
90 - north 90 - east
180 - west 180 - south
270 - south 270 - west
Example (for a Turtle instance named turtle):
>>> turtle.setheading(90)
>>> turtle.heading()
90
g @N( RB R� R R ( R� t to_angleR� t full( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR\ " s c C s� | j r+ | j j d g � t | j _ n | j � } | d k rO | j } n | d k r� t | � | j } d t t d t | � d d � | � } n d | | } d | } d | t
j | t
j d | j
� } | d
k r| | | } } } n | j � } | j � }
| d
k r:| j d
d
� n
| j d
� | j | � xH t | � D]: } | j | � | j | � | j d
� | j | � qaW| j | � | d
k r�| j | |
� n | j | � | j r�t | j _ n d S( s� Draw a circle with given radius.
Arguments:
radius -- a number
extent (optional) -- a number
steps (optional) -- an integer
Draw a circle with given radius. The center is radius units left
of the turtle; extent - an angle - determines which part of the
circle is drawn. If extent is not given, draw the entire circle.
If extent is not a full circle, one endpoint of the arc is the
current pen position. Draw the arc in counterclockwise direction
if radius is positive, otherwise in clockwise direction. Finally
the direction of the turtle is changed by the amount of extent.
As the circle is approximated by an inscribed regular polygon,
steps determines the number of steps to use. If not given,
it will be calculated automatically. Maybe used to draw regular
polygons.
call: circle(radius) # full circle
--or: circle(radius, extent) # arc
--or: circle(radius, extent, steps)
--or: circle(radius, steps=6) # 6-sided polygon
Example (for a Turtle instance named turtle):
>>> turtle.circle(50)
>>> turtle.circle(120, 180) # semicircle
t seqi i g @g �M@g �?g �?g @g �f@i N( R� R� R� R� Rf R� R R R� t minR� R� R� R R# Rm R R� R R� ( R� t radiust extentt stepsRf t fracRT t w2t lt trt dlR� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR- > s> .
)
c C s d S( s/ dummy method - to be overwritten by child classN( ( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRf R� c C s d S( s/ dummy method - to be overwritten by child classN( ( R� t aR� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR# � R� c C s d S( s/ dummy method - to be overwritten by child classN( ( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRm � R� N(. R� R� R� R
R� t DEFAULT_MODER� R� R RX R� R� R R3 RV R R R R< R( RW RH RS Rr Rs RA RD Ra Rb R4 Rk RB R\ R- Rf R# Rm R9 R, R) RZ RI RT R] R^ R[ ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� � sZ
# # A t TPenc B s
e Z d Z e d d � Z e d e d d � Z d d � Z d d � Z d � Z d � Z
d
� Z d d � Z d � Z
d
� Z d � Z d � Z d � Z d � Z d d � Z e d � Z e e d � Z d � Z d � Z e Z e Z e Z e
Z e
Z e Z e Z RS( sF Drawing part of the RawTurtle.
Implements drawing properties.
RY c C s# | | _ d | _ t j | � d S( N( t _resizemodeR� R� R t _reset( R� RY ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR � s RO R; c C sU d | _ t | _ | | _ | | _ t | _ d | _ d | _ d | _ d | _ d S( Ni i i ( i i (
t _pensizeR� t _shownt _pencolort
_fillcolort _drawingt _speedt _stretchfactort _tiltt
_outlinewidth( R� RO R; ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR � s c C sB | d k r | j S| j � } | d k r> | j d | � n d S( sz Set resizemode to one of the values: "auto", "user", "noresize".
(Optional) Argument:
rmode -- one of the strings "auto", "user", "noresize"
Different resizemodes have the following effects:
- "auto" adapts the appearance of the turtle
corresponding to the value of pensize.
- "user" adapts the appearance of the turtle according to the
values of stretchfactor and outlinewidth (outline),
which are set by shapesize()
- "noresize" no adaption of the turtle's appearance takes place.
If no argument is given, return current resizemode.
resizemode("user") is called by a call of shapesize with arguments.
Examples (for a Turtle instance named turtle):
>>> turtle.resizemode("noresize")
>>> turtle.resizemode()
'noresize'
t autot userR� RY N( R% R& R� ( R� R R� RN ( R� t rmode( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRY � s
c C s' | d k r | j S| j d | � d S( s! Set or return the line thickness.
Aliases: pensize | width
Argument:
width -- positive number
Set the line thickness to width or return it. If resizemode is set
to "auto" and turtleshape is a polygon, that polygon is drawn with
the same line thickness. If no argument is given, current pensize
is returned.
Example (for a Turtle instance named turtle):
>>> turtle.pensize()
1
>>> turtle.pensize(10) # from here on lines of width 10 are drawn
RQ N( R� R RN ( R� Rp ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRQ � s c C s! | j s
d S| j d t � d S( s� Pull the pen up -- no drawing when moving.
Aliases: penup | pu | up
No argument
Example (for a Turtle instance named turtle):
>>> turtle.penup()
NRP ( R RN R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRR � s
c C s! | j r
d S| j d t � d S( s� Pull the pen down -- drawing when moving.
Aliases: pendown | pd | down
No argument.
Example (for a Turtle instance named turtle):
>>> turtle.pendown()
NRP ( R RN R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRP � s
c C s | j S( s Return True if pen is down, False if it's up.
No argument.
Example (for a Turtle instance named turtle):
>>> turtle.penup()
>>> turtle.isdown()
False
>>> turtle.pendown()
>>> turtle.isdown()
True
( R ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRF � s
c C s� i d d 6d d 6d d 6d d 6d d
6} | d k r< | j S| | k rU | | } n7 d | k ol d k n r� t t | � � } n d } | j d
| � d S( s� Return or set the turtle's speed.
Optional argument:
speed -- an integer in the range 0..10 or a speedstring (see below)
Set the turtle's speed to an integer value in the range 0 .. 10.
If no argument is given: return current speed.
If input is a number greater than 10 or smaller than 0.5,
speed is set to 0.
Speedstrings are mapped to speedvalues in the following way:
'fastest' : 0
'fast' : 10
'normal' : 6
'slow' : 3
'slowest' : 1
speeds from 1 to 10 enforce increasingly faster animation of
line drawing and turtle turning.
Attention:
speed = 0 : *no* animation takes place. forward/back makes turtle jump
and likewise left/right make the turtle turn instantly.
Example (for a Turtle instance named turtle):
>>> turtle.speed(3)
i t fastesti
t fasti t normali t slowi t slowestg �?g %@Rf N( R� R! R� R� RN ( R� Rf t speeds( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRf s )
c G s� | r� t | � } | d k r/ | d } } n4 | d k rJ | \ } } n | d k rc | } } n | j | � } | j | � } | j d | d | � n" | j | j � | j | j � f Sd S( s� Return or set the pencolor and fillcolor.
Arguments:
Several input formats are allowed.
They use 0, 1, 2, or 3 arguments as follows:
color()
Return the current pencolor and the current fillcolor
as a pair of color specification strings as are returned
by pencolor and fillcolor.
color(colorstring), color((r,g,b)), color(r,g,b)
inputs as in pencolor, set both, fillcolor and pencolor,
to the given value.
color(colorstring1, colorstring2),
color((r1,g1,b1), (r2,g2,b2))
equivalent to pencolor(colorstring1) and fillcolor(colorstring2)
and analogously, if the other input format is used.
If turtleshape is a polygon, outline and interior of that polygon
is drawn with the newly set colors.
For mor info see: pencolor, fillcolor
Example (for a Turtle instance named turtle):
>>> turtle.color('red', 'green')
>>> turtle.color()
('red', 'green')
>>> colormode(255)
>>> color((40, 80, 120), (160, 200, 240))
>>> color()
('#285078', '#a0c8f0')
i i i i RO R; N( R� R� RN R� R R ( R� R2 R t pcolort fcolor( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR2 + s
c G sO | r; | j | � } | | j k r( d S| j d | � n | j | j � Sd S( sZ Return or set the pencolor.
Arguments:
Four input formats are allowed:
- pencolor()
Return the current pencolor as color specification string,
possibly in hex-number format (see example).
May be used as input to another color/pencolor/fillcolor call.
- pencolor(colorstring)
s is a Tk color specification string, such as "red" or "yellow"
- pencolor((r, g, b))
*a tuple* of r, g, and b, which represent, an RGB color,
and each of r, g, and b are in the range 0..colormode,
where colormode is either 1.0 or 255
- pencolor(r, g, b)
r, g, and b represent an RGB color, and each of r, g, and b
are in the range 0..colormode
If turtleshape is a polygon, the outline of that polygon is drawn
with the newly set pencolor.
Example (for a Turtle instance named turtle):
>>> turtle.pencolor('brown')
>>> tup = (0.2, 0.8, 0.55)
>>> turtle.pencolor(tup)
>>> turtle.pencolor()
'#33cc8c'
NRO ( R� R RN R� ( R� R2 R2 ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRO Y s c G sO | r; | j | � } | | j k r( d S| j d | � n | j | j � Sd S( s] Return or set the fillcolor.
Arguments:
Four input formats are allowed:
- fillcolor()
Return the current fillcolor as color specification string,
possibly in hex-number format (see example).
May be used as input to another color/pencolor/fillcolor call.
- fillcolor(colorstring)
s is a Tk color specification string, such as "red" or "yellow"
- fillcolor((r, g, b))
*a tuple* of r, g, and b, which represent, an RGB color,
and each of r, g, and b are in the range 0..colormode,
where colormode is either 1.0 or 255
- fillcolor(r, g, b)
r, g, and b represent an RGB color, and each of r, g, and b
are in the range 0..colormode
If turtleshape is a polygon, the interior of that polygon is drawn
with the newly set fillcolor.
Example (for a Turtle instance named turtle):
>>> turtle.fillcolor('violet')
>>> col = turtle.pencolor()
>>> turtle.fillcolor(col)
>>> turtle.fillcolor(0, .5, 0)
NR; ( R� R RN R� ( R� R2 R2 ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR; ~ s c C s | j d t � d S( s� Makes the turtle visible.
Aliases: showturtle | st
No argument.
Example (for a Turtle instance named turtle):
>>> turtle.hideturtle()
>>> turtle.showturtle()
t shownN( RN R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRe � s c C s | j d t � d S( sY Makes the turtle invisible.
Aliases: hideturtle | ht
No argument.
It's a good idea to do this while you're in the
middle of a complicated drawing, because hiding
the turtle speeds up the drawing observably.
Example (for a Turtle instance named turtle):
>>> turtle.hideturtle()
R0 N( RN R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRC � s c C s | j S( s� Return True if the Turtle is shown, False if it's hidden.
No argument.
Example (for a Turtle instance named turtle):
>>> turtle.hideturtle()
>>> print turtle.isvisible():
False
( R ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRG � s
c K s9 i
| j d 6| j d 6| j d 6| j d 6| j d 6| j d 6| j d 6| j d 6| j d 6| j d
6} | ps | sz | St
| t � r� | } n i } | j | � i } x | D] } | | | | <q� W| j
r� | j
j d | f � n t } d | k r | j | d k r t } q n d | k rxt
| d t � rY| j | d f � | d <n | j | d k rxt } qxn d | k r�| j | d k r�t } q�n | r�| j � n d | k r�| d | _ n d | k r�| d | _ n d | k r
| d | _ n d | k rVt
| d t � rF| j | d f � | d <n | d | _ n d | k rr| d | _ n d | k r�| d | _ n d | k r�| d } t
| t t t f � r�| | f } n | | _ n d | k r�| d | _ n d | k r| d | _ n d
| k r+| d
| _ n | j � d S(
s� Return or set the pen's attributes.
Arguments:
pen -- a dictionary with some or all of the below listed keys.
**pendict -- one or more keyword-arguments with the below
listed keys as keywords.
Return or set the pen's attributes in a 'pen-dictionary'
with the following key/value pairs:
"shown" : True/False
"pendown" : True/False
"pencolor" : color-string or color-tuple
"fillcolor" : color-string or color-tuple
"pensize" : positive number
"speed" : number in range 0..10
"resizemode" : "auto" or "user" or "noresize"
"stretchfactor": (positive number, positive number)
"outline" : positive number
"tilt" : number
This dictionary can be used as argument for a subsequent
pen()-call to restore the former pen-state. Moreover one
or more of these attributes can be provided as keyword-arguments.
This can be used to set several pen attributes in one statement.
Examples (for a Turtle instance named turtle):
>>> turtle.pen(fillcolor="black", pencolor="red", pensize=10)
>>> turtle.pen()
{'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,
'pencolor': 'red', 'pendown': True, 'fillcolor': 'black',
'stretchfactor': (1,1), 'speed': 3}
>>> penstate=turtle.pen()
>>> turtle.color("yellow","")
>>> turtle.penup()
>>> turtle.pen()
{'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,
'pencolor': 'yellow', 'pendown': False, 'fillcolor': '',
'stretchfactor': (1,1), 'speed': 3}
>>> p.pen(penstate, fillcolor="green")
>>> p.pen()
{'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,
'pencolor': 'red', 'pendown': True, 'fillcolor': 'green',
'stretchfactor': (1,1), 'speed': 3}
R0 RP RO R; RQ Rf RY t
stretchfactorRV Ri RN N( R R R R R R! R R" R$ R# R� t dictR% R� R� R� R� R� R� t _newLineR� R� R� Rk ( R� RN t pendictt _pdt pt _p_bufR� t newLinet sf( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRN � sz .
c C s d S( s/ dummy method - to be overwritten by child classN( ( R� t usePos( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR3 @ R� c C s d S( s/ dummy method - to be overwritten by child classN( ( R� R� t forced( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRk B R� c C s d S( s/ dummy method - to be overwritten by child classN( ( R� R2 ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� D R� c C s d S( s/ dummy method - to be overwritten by child classN( ( R� R2 ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� F R� N(! R� R� R� R� R R R� RY RQ RR RP RF Rf R2 RO R; Re RC RG RN R� R3 R� Rk R� R� Rp Ro RU RM R6 Rg RE ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR � s8 & . % $
u t _TurtleImagec B s e Z d Z d � Z d � Z RS( s6 Helper class: Datatype to store Turtle attributes
c C s# | | _ d | _ | j | � d S( N( R� R� R� t _setshape( R� R� t
shapeIndex( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR V s c C se | j } | | _ | j d k o6 | j | j k n r? d S| j d k oc | j | j k n rl d S| j d k r� | j | j � n3 | j d k r� x! | j D] } | j | � q� Wn | j | j | _ | j d k r� | j � | _ nl | j d k r#| j | j d j � | _ n> | j d k rag | j | j D] } | j � ^ qC| _ n d S( NR� R� R� RL ( R� R� ( R� R> R� R� Rj t _itemRX R� R� ( R� R> R� Ri ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR= [ s& )) ( R� R� R� R R= ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR< R s c B s e Z d Z g Z d8 e d e d e d d � Z d � Z d � Z d � Z d � Z
d � Z d
� Z d � Z
d8 d8 d � Z d
� Z d � Z d � Z d � Z d8 d � Z d8 d8 d8 d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d8 d � Z d � Z d � Z d � Z e! d � Z" d8 d � Z# d! � Z$ d" � Z% d8 d# � Z& d$ � Z' e( d% d9 d) � Z) d* � Z* d+ � Z+ d, � Z, d- � Z- d. � Z. e. Z/ d/ � Z0 d0 � Z1 d8 d1 � Z2 d2 d8 d3 � Z3 d2 d8 d4 � Z4 d2 d8 d5 � Z5 d6 � Z6 d7 � Z7 e Z8 RS(: sv Animation part of the RawTurtle.
Puts RawTurtle upon a TurtleScreen and provides tools for
its animation.
Rc R� R� c C s� t | t � r | | _ n� t | t � rX | t j k rL t j j | � n | | _ nz t | t t f � r� xb t j D]" } | j | k rw | | _ Pqw qw Wt | � | _ t j j | j � n t
d | � � | j } t j | | j
� � t j | � | j j | � | j � | _ t | | � | _ d | _ t | _ d | _ | _ | | _ t | _ | j � | _ | j g | _ | j g | _ g | _ | | _! t" | � | _# | j$ � d S( Ns bad canvas argument %s(% R� t _ScreenR� R R t screensRY R R RQ R� R� R R R R� Re t drawingLineItemR< R� R� t _polyR� t
_creatingPolyt _fillitemt _fillpathR t _hidden_from_screent currentLineItemR� t currentLineR� t
stampItemst _undobuffersizeR� R� Rk ( R� t canvasRc R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR x s@
c C s< t j | � t j | � | j � | j � | j � d S( s� Delete the turtle's drawings and restore its default values.
No argument.
,
Delete the turtle's drawings from the screen, re-center the turtle
and set variables to the default values.
Example (for a Turtle instance named turtle):
>>> turtle.position()
(0.00,-22.00)
>>> turtle.heading()
100.0
>>> turtle.reset()
>>> turtle.position()
(0.00,0.00)
>>> turtle.heading()
0.0
N( R� RX R R t _clearR� Rk ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRX � s
c C s7 | d k s | d k r$ d | _ n t | � | _ d S( s� Set or disable undobuffer.
Argument:
size -- an integer or None
If size is an integer an empty undobuffer of given size is installed.
Size gives the maximum number of turtle-actions that can be undone
by the undo() function.
If size is None, no undobuffer is present.
Example (for a Turtle instance named turtle):
>>> turtle.setundobuffer(42)
i N( R� R� R� ( R� t size( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR` � s c C s | j d k r d S| j j � S( s� Return count of entries in the undobuffer.
No argument.
Example (for a Turtle instance named turtle):
>>> while undobufferentries():
... undo()
i N( R� R� R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRn � s c C s� d | _ | _ x! | j D] } | j j | � q W| j j � | _ g | _ | j rn | j j
| j � n | j g | _ | j � | j
| j � d S( s Delete all of pen's drawingsN( R� RE RF R� R� Rj Re RH RI R RY R� R0 R` RK ( R� Ri ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRM � s
c C s | j � | j � d S( sg Delete the turtle's drawings from the screen. Do not move turtle.
No arguments.
Delete the turtle's drawings from the screen. Do not move turtle.
State and position of the turtle as well as drawings of other
turtles are not affected.
Examples (for a Turtle instance named turtle):
>>> turtle.clear()
N( RM Rk ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR. � s
c C sd | j j � | j j d k r# d St | j � d k r` | j j | j | j | j | j � n d S( Ni i ( R� R� R� R� RI Rg RH R R ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� � s
c C s� | j } | j d k r d S| j d k r\ | j � | j � | j � | j | j � nG | j � | j d k r� x | j � D] } | j � q� W| j � n d S( s& Perform a Turtle-data update.
i Ni ( R� R� R� R� Rk Rm R� R� R$ ( R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRk � s
c C s | j j | | � S( sm Turns turtle animation on/off and set delay for update drawings.
Optional arguments:
n -- nonnegative integer
delay -- nonnegative integer
If n is given, only each n-th regular screen update is really performed.
(Can be used to accelerate the drawing of complex graphics.)
Second arguments sets delay value (see RawTurtle.delay())
Example (for a Turtle instance named turtle):
>>> turtle.tracer(8, 25)
>>> dist = 2
>>> for i in range(200):
... turtle.fd(dist)
... turtle.rt(90)
... dist += 2
( R� R# ( R� t flagR ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR#
s c C s | j j | � S( N( R� R� ( R� R2 ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� %
s c C s | j j | � S( N( R� R� ( R� R2 ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� (
s c C s t | t � r | Sy | \ } } } Wn- t t f k
rU t d t | � � � n X| j j d k r� g | | | f D] } t d | � ^ qx \ } } } n d | k o� d k n o� d | k o� d k n o� d | k o� d k n s
t d t | � � � n d | | | f S( s, Convert colortriples to hexstrings.
s bad color arguments: %sg �?g �o@i i� s bad color sequence: %ss
#%02x%02x%02x( R� R� R� R� R� R� R� R� R� ( R� R2 R� R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _cc+
s 8Tc C sI | j } | j | j � | j } d | _ d | _ t | � } | | _ | | _ | | _ t | | j j � | _ | j j | � | j
| j j j } | d k r� | j � | j _
nr | d k r� | j | j
d j � | j _
nD | d k r,g | j
| j j j D] } | j � ^ q | j _
n | j � | _ | j � | S( s Create and return a clone of the turtle.
No argument.
Create and return a clone of the turtle with same position, heading
and turtle properties.
Example (for a Turtle instance named mick):
mick = Turtle()
joe = mick.clone()
R� R� RL R� N( R� R3 R R� R� R R< R> R� RY R� R� RX R? R� R� Re RH Rk ( R� R� R� t qt ttypeRi ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR1 :
s, " 5
c C s\ | d k r | j j S| | j j � k r> t d | � � n | j j | � | j � d S( s� Set turtle shape to shape with given name / return current shapename.
Optional argument:
name -- a string, which is a valid shapename
Set turtle shape to shape with given name or, if name is not given,
return name of current shape.
Shape with name must exist in the TurtleScreen's shape dictionary.
Initially there are the following polygon shapes:
'arrow', 'turtle', 'circle', 'square', 'triangle', 'classic'.
To learn about how to deal with shapes see Screen-method register_shape.
Example (for a Turtle instance named turtle):
>>> turtle.shape()
'arrow'
>>> turtle.shape("turtle")
>>> turtle.shape()
'turtle'
s There is no shape named %sN( R� R� R> R� R R� R= Rk ( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRc b
s
c C s� | | k o" | k o" d k n rF | j \ } } | | | j f S| d k r| | d k rm | | f } q� | | f } n+ | d k r� | j d | f } n | j } | d k r� | j } n | j d d d | d | � d S( sO Set/return turtle's stretchfactors/outline. Set resizemode to "user".
Optional arguments:
stretch_wid : positive number
stretch_len : positive number
outline : positive number
Return or set the pen's attributes x/y-stretchfactors and/or outline.
Set resizemode to "user".
If and only if resizemode is set to "user", the turtle will be displayed
stretched according to its stretchfactors:
stretch_wid is stretchfactor perpendicular to orientation
stretch_len is stretchfactor in direction of turtles orientation.
outline determines the width of the shapes's outline.
Examples (for a Turtle instance named turtle):
>>> turtle.resizemode("user")
>>> turtle.shapesize(5, 5, 12)
>>> turtle.shapesize(outline=8)
i RY R& R1 RV N( R� R" R$ RN ( R� t stretch_widt stretch_lenRV R1 ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRd }
s ' c C sK | | j | j } | t j d d t j } | j d d d | � d S( sZ Rotate the turtleshape to point in the specified direction
Optional argument:
angle -- number
Rotate the turtleshape to point in the direction specified by angle,
regardless of its current tilt-angle. DO NOT change the turtle's
heading (direction of movement).
Examples (for a Turtle instance named turtle):
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.settiltangle(45)
>>> stamp()
>>> turtle.fd(50)
>>> turtle.settiltangle(-45)
>>> stamp()
>>> turtle.fd(50)
g �f@i RY R& Ri N( R R� R� R� RN ( R� R� Ri ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR_ �
s c C s. | j d t j | j } | | j | j S( s� Return the current tilt-angle.
No argument.
Return the current tilt-angle, i. e. the angle between the
orientation of the turtleshape and the heading of the turtle
(its direction of movement).
Examples (for a Turtle instance named turtle):
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.tilt(45)
>>> turtle.tiltangle()
g �f@( R# R� R� R� R R ( R� Ri ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRj �
s c C s | j | | j � � d S( s� Rotate the turtleshape by angle.
Argument:
angle - a number
Rotate the turtleshape by angle from its current tilt-angle,
but do NOT change the turtle's heading (direction of movement).
Examples (for a Turtle instance named turtle):
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.tilt(30)
>>> turtle.fd(50)
>>> turtle.tilt(30)
>>> turtle.fd(50)
N( R_ Rj ( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRi �
s c
C s� | j } | j \ } } | j \ } } t | | | j | j � } d t | � | \ } } g | D]G \ } } | | | | | | j | | | | | | j f ^ qe S( sl Computes transformed polygon shapes from a shape
according to current position and heading.
g �?( R� R� R� R
RS RR R (
R� R� R� t p0t p1t e0t e1R~ R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt
_polytrafo�
s c C s} | j } | j | j j } | j } | j j } | j r�| j d k r�| j d k r�t | _
| j } | d k r�| j d k r� d } | } n� | j d k r� t
d | j d � } } | j } d } n3 | j d k r| j \ } } | j } | j } n g | D] \ }
} | |
| | f ^ q } t j | � t j | � } }
g | D]1 \ }
} |
|
| | | |
|
| f ^ qU} | j | � } | j | j } } | j | | d | d | d
| d t �qy| d k r�| j | | j | � qy| d
k ry| j \ } } | j } x� t | | � D]� \ } \ } } } g | D] \ }
} | |
| | f ^ qN} | j | � } | j | | d | j | � d | j | � d
| d t �q2Wqyn� | j
r�d S| d k r| j | d d d f d d � nn | d k r1| j | | j | j d j � n? | d
k rpx0 | D]% } | j | d d d f d d � qDWn t | _
d S( sp Manages the correct rendering of the turtle with respect to
its shape, resizemode, stretch and tilt etc.i R� R� i R% g @R& R: RV Rp R_ R� R� NR� RL ( i i ( i i ( i i ( i i ( i i ( i i ( R� R� R� R> R� R? R R� R� R� RG R� R t maxR R" R$ R# R� R� R| RY R R Ra R� R� R� t zipRP ( R� R� Rc RR t titemt tshapeRT t lxt lyRj R� R� t t0t t1t fct ocRi R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� �
s^ ' - > %- & "
&c C s | j } | j | j j } | j } | j } | d k r�| j � } | j d k rd d } | } n� | j d k r� t d | j d � } } | j } d } n3 | j d k r� | j
\ } } | j } | j } n g | D] \ }
} | |
| | f ^ q� } t
j | � t
j | � } }
g | D]1 \ }
} |
|
| | | |
|
| f ^ q%} | j | � } | j | j } } | j | | d | d | d
| d t �n6| d k r�| j d
� } | j | | j | � n| d k r�g } x' | D] } | j � } | j | � q�Wt | � } | j
\ } } | j } x� t | | � D]� \ } \ } } } g | D] \ }
} | |
| | f ^ qi} | j | � } | j | | d | j | � d | j | � d
| d t �qMWn | j j | � | j j d | f � | S( s� Stamp a copy of the turtleshape onto the canvas and return its id.
No argument.
Stamp a copy of the turtle shape onto the canvas at the current
turtle position. Return a stamp_id for that stamp, which can be
used to delete it by calling clearstamp(stamp_id).
Example (for a Turtle instance named turtle):
>>> turtle.color("blue")
>>> turtle.stamp()
13
>>> turtle.fd(50)
R� R� i R% g @i R& R: RV Rp R_ R� R� R� Rh ( R� R� R� R> R� R� RX R RZ R R" R$ R# R� R� R| RY R R Ra R� R� R� R� RY R� R[ RP RJ R� R� ( R� R� Rc RR R] t stitemRT R^ R_ Rj R� R� R` Ra Rb Rc t elementRi R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRh $ sV - >
%- #c C s | | j k re t | t � rB x1 | D] } | j j | � q% Wn | j j | � | j j | � n d | f } | j } | | j k r� d S| j j | � } | j j | � | | j k r� | j d | j
| _ n | j j | j d | j
d g � d S( s9 does the work for clearstamp() and clearstamps()
Rh Ni (
RJ R� R� R� Rj R� R� R� t indexR� R� t insertR� ( R� t stampidt subitemRi t bufRf ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _clearstamp` s
c C s | j | � | j � d S( sD Delete stamp with given stampid
Argument:
stampid - an integer, must be return value of previous stamp() call.
Example (for a Turtle instance named turtle):
>>> turtle.color("blue")
>>> astamp = turtle.stamp()
>>> turtle.fd(50)
>>> turtle.clearstamp(astamp)
N( Rk Rk ( R� Rh ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR/ v s
c C sn | d k r | j } n) | d k r5 | j | } n
| j | } x | D] } | j | � qI W| j � d S( s� Delete all or first/last n of turtle's stamps.
Optional argument:
n -- an integer
If n is None, delete all of pen's stamps,
else if n > 0 delete first n stamps
else if n < 0 delete last n stamps.
Example (for a Turtle instance named turtle):
>>> for i in range(8):
... turtle.stamp(); turtle.fd(30)
...
>>> turtle.clearstamps(2)
>>> turtle.clearstamps(-2)
>>> turtle.clearstamps()
i N( R� RJ Rk Rk ( R� R� t toDeleteRi ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR0 � s
c C sf | j | j | j t | j t � f } | j } d | j | | | j | j | j
| j � | j f f } | j r� | j j
| � n | j } | j r�| j d k r�| | } | d | j d | d | j d } d t | d d d | j | j � } | d | } x� t d | � D]s }
|
d k r=t } n t } | | |
| _ | j r�| j | j | | j f | j | j | � n | j � q"W| j r�| j | j d d f d d
d | j �q�n | j r�| j j | � n t | j t � r| j j | � n | | _ | j r6| j j | � n t | j � d k rX| j � n | j � d
S( s� Move the pen to the point end, thereby drawing a line
if pen is down. All other methods for turtle movement depend
on this one.
t goi i i g �?i g�������?g �?R: R� Rp i* N( i i ( i i ( R R R R� RF R� R� R� RH RI R� R� R� R� R! R� RR RS R� R� R� R� Rg RB Rk RY RD RC R� R3 ( R� R t go_modesR� t
undo_entryt startt difft diffsqt nhopst deltaR� R_ ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR � sR
(*
c C s | \ } } } } | \ } } } } | \ }
} } }
| j } t | j | � d k r` d GHn |
| _ | | _ | d d g k r� d } n | } | j |
| d | d | �g | j D]- } | |
k r� | j | � d k r� | ^ q� } x+ | D]# } | j | � | j j | � q� W| } | j
rQ| j d k rQ| | } | d | j d | d | j
d } d t | d d
d | j
| j
� } | d | } x{ t d | � D]j } | d k r�t } n t } | | | | _ | r| j | j | | j f | | | � n | j � q�W| rQ| j | j d d f d d d | �qQn | | _ | j r�t | j � d k r�| j j � n | j g k r�t | _ d | _ q�n | r�| j g k r�d | _ d
GHq�| j d k r�| j j � q�n | j � d S( s) Reverse a _goto. Used for undo()
g �?s$ undogoto: HALLO-DA-STIMMT-WAS-NICHT!i R� R: Rp R� i i i g�������?g �?s Unwahrscheinlich in _undogoto!N( i i ( i i ( i i ( i i ( R� R R� RH RI Rg R� R� Rj R� R! R� RR RS R� R� R� R� RB Rk RD R� RC R� R� RF ( R� t entryt oldt newRn t coodatat drawingt pct pst fillingt cLIt cLR� R� R� t usepcR� t todeleteRp Rq Rr Rs Rt R� R_ ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _undogoto� sd !
(* c C s� | j r( | j j d | | j f � n | | j 9} | j j | � } | j j } | d k r� | j d k r� d | j } d t t | � | � } d | | } x6 t
| � D]% } | j j | � | _ | j � q� Wn | | _ | j � d S( s& Turns pen clockwise by angle.
t roti i g @g �?N( R� R� R R� R� R� R� R! R� R R� Rk ( R� R� t neworientR� t anglevelR Rt R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR s
c C s� t | j � d k rb | j j | j | j | j | j � | j j � | _ | j j | j � n | j j | j d t
�g | _ | r� | j g | _ n d S( s� Closes current line item and starts a new one.
Remark: if current line became too long, animation
performance (via _drawline) slowed down considerably.
i R_ N( R� RI R� Rg RH R R Re R� RY R� R� ( R� R: ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR3 ) s c C sm t | j t � } | d k r" | S| j } d } } | r� t | j � d k r� | j j | j | j d | j �d | j f } q� n | r� | j j � | _ | j
j | j � | j g | _ d | j f } | j
� n d | _ | _ | j r_| d k r$| d k r\| j j | � q\q_| d
k rC| j j | � q_| j j d | | g � n | j � d S( s� Call fill(True) before drawing a shape to fill, fill(False) when done.
Optional argument:
flag -- True/False (or 1/0 respectively)
Call fill(True) before drawing the shape you want to fill,
and fill(False) when done.
When used without argument: return fillstate (True if filling,
False else)
Example (for a Turtle instance named turtle):
>>> turtle.fill(True)
>>> turtle.forward(100)
>>> turtle.left(90)
>>> turtle.forward(100)
>>> turtle.left(90)
>>> turtle.forward(100)
>>> turtle.left(90)
>>> turtle.forward(100)
>>> turtle.fill(False)
i R: t dofillt beginfillR
N( ( ( ( ( R� RF R� R� R� R� Ra RE R RX R� RY R� R3 R� R� Rk ( R� RO R| R� t entry1t entry2( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR: 9 s2
c C s | j t � d S( s� Called just before drawing a shape to be filled.
No argument.
Example (for a Turtle instance named turtle):
>>> turtle.begin_fill()
>>> turtle.forward(100)
>>> turtle.left(90)
>>> turtle.forward(100)
>>> turtle.left(90)
>>> turtle.forward(100)
>>> turtle.left(90)
>>> turtle.forward(100)
>>> turtle.end_fill()
N( R: R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR* l s c C s | j t � d S( s� Fill the shape drawn after the call begin_fill().
No argument.
Example (for a Turtle instance named turtle):
>>> turtle.begin_fill()
>>> turtle.forward(100)
>>> turtle.left(90)
>>> turtle.forward(100)
>>> turtle.left(90)
>>> turtle.forward(100)
>>> turtle.left(90)
>>> turtle.forward(100)
>>> turtle.end_fill()
N( R: R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR7 ~ s c G s� | st t | t t f � rF | j | � } | j t | j d � } q� | j } | s� | j t | j d � } q� n7 | d k r� | j t | j d � } n | j | � } t | j d � r
| j j
| j | | � } | j j
| � | j r�| j j d | f � q�n� | j � } | j rD| j j d g � t | j _ n zT | j � d k rf| j � n | j � | j | � | j | � | j d � Wd | j | � X| j r�t | j _ n d S( s� Draw a dot with diameter size, using color.
Optional arguments:
size -- an integer >= 1 (if given)
color -- a colorstring or a numeric color tuple
Draw a circular dot with diameter size, using color.
If size is not given, the maximum of pensize+4 and 2*pensize is used.
Example (for a Turtle instance named turtle):
>>> turtle.dot()
>>> turtle.fd(50); turtle.dot(20, "blue"); turtle.fd(50)
i t _dotR5 R
R% i N( R� R� R� R� R RZ R R� t hasattrR� R� R� R� RY R� R� RN R� R� RY RE RP RQ RO R< R� ( R� RN R2 Ri RN ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR5 � s:
c C s` | j j | j | | | | j � \ } } | j j | � | j r\ | j j d | f � n | S( s) Performs the writing for write()
t wri( R� R� R� R R� RY R� R� ( R� R{ R| Ry Ri R ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� � s RH t Ariali R* c C s� | j r+ | j j d g � t | j _ n | j t | � | j � | � } | rw | j � \ } } | j | | � n | j r� t | j _ n d S( s� Write text at the current turtle position.
Arguments:
arg -- info, which is to be written to the TurtleScreen
move (optional) -- True/False
align (optional) -- one of the strings "left", "center" or right"
font (optional) -- a triple (fontname, fontsize, fonttype)
Write text - the string representation of arg - at the current
turtle position according to align ("left", "center" or right")
and with the given font.
If move is True, the pen is moved to the bottom-right corner
of the text. By default, move is False.
Example (for a Turtle instance named turtle):
>>> turtle.write('Home = ', True, align="center")
>>> turtle.write((0,0), True)
R
N(
R� R� R� R� R� R� R� RS R] R� ( R� t argt moveR| Ry R R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRq � s ! c C s | j g | _ t | _ d S( s Start recording the vertices of a polygon.
No argument.
Start recording the vertices of a polygon. Current turtle position
is first point of polygon.
Example (for a Turtle instance named turtle):
>>> turtle.begin_poly()
N( R� RC R� RD ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR+ � s c C s
t | _ d S( s7 Stop recording the vertices of a polygon.
No argument.
Stop recording the vertices of a polygon. Current turtle position is
last point of polygon. This will be connected with the first point.
Example (for a Turtle instance named turtle):
>>> turtle.end_poly()
N( R� RD ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR8 � s c C s | j d k r t | j � Sd S( s� Return the lastly recorded polygon.
No argument.
Example (for a Turtle instance named turtle):
>>> p = turtle.get_poly()
>>> turtle.register_shape("myFavouriteShape", p)
N( RC R� R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR=
s
c C s | j S( s� Return the TurtleScreen object, the turtle is drawing on.
No argument.
Return the TurtleScreen object, the turtle is drawing on.
So TurtleScreen-methods can be called for that object.
Example (for a Turtle instance named turtle):
>>> ts = turtle.getscreen()
>>> ts
<turtle.TurtleScreen object at 0x0106B770>
>>> ts.bgcolor("pink")
( R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR?
s c C s | S( sU Return the Turtleobject itself.
No argument.
Only reasonable use: as a function to return the 'anonymous turtle':
Example:
>>> pet = getturtle()
>>> pet.fd(50)
>>> pet
<turtle.Turtle object at 0x0187D810>
>>> turtles()
[<turtle.Turtle object at 0x0187D810>]
( ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR@ "
s c C s | j j � d S( s� Returns the width of the turtle window.
No argument.
Example (for a TurtleScreen instance named screen):
>>> screen.window_width()
640
i ( R� R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR' :
s c C s | j j � d S( s� Return the height of the turtle window.
No argument.
Example (for a TurtleScreen instance named screen):
>>> screen.window_height()
480
i ( R� R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR& E
s c C s | j j | � S( sD Set delay value which determines speed of turtle animation.
( R� R ( R� R ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRm P
s i c C s- | j j | j j | | | � | j � d S( s� Bind fun to mouse-click event on this turtle on canvas.
Arguments:
fun -- a function with two arguments, to which will be assigned
the coordinates of the clicked point on the canvas.
btn -- number of the mouse-button defaults to 1 (left mouse button).
add -- True or False. If True, new binding will be added, otherwise
it will replace a former binding.
Example for the anonymous turtle, i. e. the procedural way:
>>> def turn(x, y):
... left(360)
...
>>> onclick(turn) # Now clicking into the turtle will turn it.
>>> onclick(None) # event-binding will be removed
N( R� R� R� R? Rk ( R� R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRJ W
s c C s- | j j | j j | | | � | j � d S( s� Bind fun to mouse-button-release event on this turtle on canvas.
Arguments:
fun -- a function with two arguments, to which will be assigned
the coordinates of the clicked point on the canvas.
btn -- number of the mouse-button defaults to 1 (left mouse button).
Example (for a MyTurtle instance named joe):
>>> class MyTurtle(Turtle):
... def glow(self,x,y):
... self.fillcolor("red")
... def unglow(self,x,y):
... self.fillcolor("")
...
>>> joe = MyTurtle()
>>> joe.onclick(joe.glow)
>>> joe.onrelease(joe.unglow)
Clicking on joe turns fillcolor red, unclicking turns it to
transparent.
N( R� R� R� R? Rk ( R� R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRL l
s c C s# | j j | j j | | | � d S( s� Bind fun to mouse-move event on this turtle on canvas.
Arguments:
fun -- a function with two arguments, to which will be assigned
the coordinates of the clicked point on the canvas.
btn -- number of the mouse-button defaults to 1 (left mouse button).
Every sequence of mouse-move-events on a turtle is preceded by a
mouse-click event on that turtle.
Example (for a Turtle instance named turtle):
>>> turtle.ondrag(turtle.goto)
Subsequently clicking and dragging a Turtle will move it
across the screen thereby producing handdrawings (if pen is
down).
N( R� R� R� R? ( R� R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRK �
s c C s� | j d k r d S| d k rV | \ } } | j | | | j � | j j � } n5| d k r| | d } | j | � n| d k r� | j | � n� | d k r� | d } | j j | � | j j
| � n� | d k r| d } | j j | d d d f d d
d d
�ny | d k r[| d } d | _ | _
| j j | � | j j
| � n0 | d
k r�t j | | d � | j j � n d S( s2 Does the main part of the work for undo()
NR� Rh i Rm R� R5 R� R: R� RV R� RN ( R� R5 ( i i ( i i ( i i ( R� R� R R R� R/ R� R� Rj R� R� Ra RE RF R RN ( R� t actionR� R� t degPAUt dummyRd Ri ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _undo�
s6
c C s� | j d k r d S| j j � } | d } | d } | d k rv xA | rr | j � } | j | d | d � qE Wn | j | | � d S( s� undo (repeatedly) the last turtle action.
No argument.
undo (repeatedly) the last turtle action.
Number of available undo actions is determined by the size of
the undobuffer.
Example (for a Turtle instance named turtle):
>>> for i in range(4):
... turtle.fd(50); turtle.lt(80)
...
>>> for i in range(8):
... turtle.undo()
...
Ni i R
( R� R� R� R� ( R� Ri R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRm �
s
N( R� i R* (9 R� R� R� RA R� R� R RX R` Rn RM R. R� Rk R# R� R� RP R1 Rc Rd R_ Rj Ri RY R� Rh Rk R/ R0 R R� R R� R3 R: R* R7 R5 R� R� Rq R+ R8 R= R? R@ R> R' R& Rm RJ RL RK R� Rm Rl ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR q sl %
( & 7 < 5 A 3 3
c C s% t j d k r t � t _ n t j S( s� Return the singleton screen object.
If none exists at the moment, create a new one and return it,
else return the existing one.N( R t _screenR� R@ ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR �
s R@ c B sp e Z d Z d Z e d Z d � Z e d e d e d e d d � Z d � Z d � Z
d � Z d
� Z RS( R" c C s� t j d k rK t � t _ | _ | j j t j � | j j | j � n t j d k r� t d } t d } t d } t d } t d } t d } | j j
| | | | � | j j � t _ t j
| t j � | j | | | | � n d S( NRp R� R� R� R� R� ( R@ t _rootR� R7 R" t _titleRE t _destroyR R� R< R= R R R ( R� Rp R� R� R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR �
s
Rp R� R� R� c C s t | j d � s d S| j j � } | j j � } t | t � rl d | k oZ d k n rl | | } n | d k r� | | d } n t | t � r� d | k o� d k n r� | | } n | d k r� | | d } n | j j | | | | � | j � d S( s Set the size and position of the main window.
Arguments:
width: as integer a size in pixels, as float a fraction of the screen.
Default is 50% of screen.
height: as integer the height in pixels, as float a fraction of the
screen. Default is 75% of screen.
startx: if positive, starting position in pixels from the left
edge of the screen, if negative from the right edge
Default, startx=None is to center window horizontally.
starty: if positive, starting position in pixels from the top
edge of the screen, if negative from the bottom edge
Default, starty=None is to center window vertically.
Examples (for a Screen instance named screen):
>>> screen.setup (width=200, height=200, startx=0, starty=0)
sets window to 200x200 pixels, in upper left of screen
>>> screen.setup(width=.75, height=0.5, startx=None, starty=None)
sets window to 75% of screen by 50% of screen and centers
RA Ni i i ( R� R� RG RI R� R� R� RA R% ( R� Rp R� R? R@ Rt t sh( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR s +
+
c C s/ t j d k r" t j j | � n | t _ d S( sq Set title of turtle-window
Argument:
titlestring -- a string, to appear in the titlebar of the
turtle graphics window.
This is a method of Screen-class. Not available for TurtleScreen-
objects.
Example (for a Screen instance named screen):
>>> screen.title("Welcome to the turtle-zoo!")
N( R@ R� R� R" R� ( R� t titlestring( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR" ( s
c C sV | j } | t j k r? d t _ d t _ d t _ d t _ n t t _ | j
� d S( N( R� R@ R� R R� R� R R� R R� RD ( R� t root( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� 9 s c C s | j � d S( s~ Shut the turtlegraphics window.
Example (for a TurtleScreen instance named screen):
>>> screen.bye()
N( R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR C s c sW � f d � } � j | � t d r* d Sy t � Wn t k
rR t d � n Xd S( sl Go into mainloop until the mouse is clicked.
No arguments.
Bind bye() method to mouseclick on TurtleScreen.
If "using_IDLE" - value in configuration dictionary is False
(default value), enter mainloop.
If IDLE with -n switch (no subprocess) is used, this value should be
set to True in turtle.cfg. In this case IDLE's mainloop
is active also for the client script.
This is a method of the Screen-class and not available for
TurtleScreen instances.
Example (for a Screen instance named screen):
>>> screen.exitonclick()
c s � j � d S( s& Screen.bye() with two dummy-parametersN( R ( R� R� ( R� ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt exitGracefully^ s R� Ni ( RJ R� Rv t AttributeErrort exit( R� R� ( ( R� s% /usr/lib64/python2.7/lib-tk/turtle.pyR K s
N(
R� R� R� R� R R� R� R R R" R� R R ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR@ �
s
'
c B s8 e Z d Z d Z d Z e d e d e d d � Z RS( s� RawTurtle auto-creating (scrolled) canvas.
When a Turtle object is created or a function derived from some
Turtle method is called a TurtleScreen object is automatically created.
Rc R� R� c C sG t j d k r t � t _ n t j | t j d | d | d | �d S( NRc R� R� ( R R� R� R R R ( R� Rc R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR r s N( R� R� R� R� R� R� R� R ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR i s t turtle_docstringdictc C sR i } x+ t D]# } d | } t | � j | | <q
Wx+ t D]# } d | } t | � j | | <q; Wt d | d � } t g | j � D]% } | j d � d t k r� | ^ q� � } | j d � x> | d D]2 } | j d t
| � � | j d
| | � q� W| d } | j d t
| � � | j d | | � | j d � | j � d
S( s� Create and write docstring-dictionary to file.
Optional argument:
filename -- a string, used as filename
default value is turtle_docstringdict
Has to be called explicitly, (not used by the turtle-graphics classes)
The docstring dictionary will be written to the Python script <filname>.py
It is intended to serve as a template for translation of the docstrings
into different languages.
s _Screen.s Turtle.s %s.pyRT R� i s docsdict = {
i����s %s :
s """%s
""",
s """%s
"""
s }
N( t _tg_screen_functionsR� R� t _tg_turtle_functionsR� R� R� R t _alias_listRq t reprR� ( R� t docsdictt
methodnameR� R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRt s&
(
c C sx d i | j � d 6} t | � } | j } xE | D]= } y | | t | � j _ Wq3 t k
ro d | GHq3 Xq3 Wd S( s� Read in docstrings from lang-specific docstring dictionary.
Transfer docstrings, translated to lang, from a dictionary-file
to the methods of classes Screen and Turtle and - in revised form -
to the corresponding functions.
s! turtle_docstringdict_%(language)sR� s Bad docstring-entry: %sN( R� t
__import__R� R� t im_funcR� R� ( t langt modnamet moduleR� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt read_docstrings� s
s Cannot find docsdict fors; Unknown Error when trying to import %s-docstring-dictionaryc
C s� d } } t | � t j k r1 | j } d } n | } d } t | � t j t j g k r�yg| j j } t | j j | | !� } | j j | | !} | j
p� g } t t d � | � � } d g t | � t | � | } t d � | | � } | j j
d @rF| j d | j j | � | j d | j j | � | d 7} n | j j
d @r�| j d | j j | � | j d | j j | � n d
j | � } d | } d
j | � } d | } Wq�q�Xn | | f S( s9 Get strings describing the arguments for the given objectR� i i c S s d t | � S( Ns =%s( R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt <lambda>� R� c S s | | S( N( ( R� t dflt( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� � R� i R i s **s , s (%s)( R� R� t
MethodTypeR� R� t
LambdaTypet func_codet co_argcountR� t co_varnamest
func_defaultst mapR� t co_flagsRY R (
t obt argText1t argText2t fobt argOffsett countert items2t realArgst defaultst items1( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt getmethparlist� s:
!
c C se d d l } | d k r d St d } | j d | d � } | j d | � } | j d | � } | S( s< To reduce docstrings from RawTurtle class for functions
i����NR� s %s.R� s \(.+ %s\):t :( t reR� R� t replacet compilet sub( t docstrR� t
turtlenamet newdocstrt parexp( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _turtle_docrevise� s
c C se d d l } | d k r d St d } | j d | d � } | j d | � } | j d | � } | S( s? To reduce docstrings from TurtleScreen class for functions
i����NR� s %s.R� s \(.+ %s\):R� ( R� R� R� R� R� R� ( R� R� t
screennameR� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _screen_docrevise� s
sr def {name}{paramslist}:
if {obj} is None:
if not TurtleScreen._RUNNING:
TurtleScreen._RUNNING = True
raise Terminator
{obj} = {init}
try:
return {obj}.{name}{argslist}
except TK.TclError:
if not TurtleScreen._RUNNING:
TurtleScreen._RUNNING = True
raise Terminator
raise
c
B s� x� | D]� } e | | � } e | � \ } } | d k rM d G| G| GHq n e j d | d | d | d | d | � } | e � U| | j � e � | _ q Wd S( NR� s >>>>>>t objt initR� t
paramslistt argslist( t getattrR� t __func_bodyt formatt globalsR� (
t functionsR� R� R� t docreviseR� R� t pl1t pl2t defstr( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _make_global_funcs s
s Turtle._screens Screen()s Turtle._pens Turtle()t __main__c C s t � r t � n t � d S( N( RF RU RM ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt switchpen# s
c C s� t � t t � t � t d � t � t d � x� t d � D]� } | d k r_ t d � n x( t d � D] } t d � t
d � ql W| d k r� t d � t d � n t � t d
� t � q@ Wt d � t d � t t � t � t
d � t d � t
d � t d � t
d � t � t d
d � t d d � t d � x< t d � D]. } t d � t
d � t d � t
d � qXWt t � t d � x< t d � D]. } t d � t
d � t d � t
d � q�Wt d � d S( s Demo of old turtle.py - moduleid i i i i i iZ t marooni i R� i� t
startstartu startt redi N( RX R# R� Ro R) R6 Rp R� R: R< RH R2 R� RW Rq ( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt demo1) sX
c C sO t d � t � t d � t t d d � � t d d � d } t d � x( t d � D] } t � t | d � qX Wt
d � x t � r� t � q� Wt
� t d � t d � d } t d
� t d � t d � x� t d d
� D]� } | d k r t � t d d | d d | � n x( t d � D] } t | � t d � q+W| d 7} t d � t t � d d � q� Wt � t d � t � t d � t d � t � t d d � t d � t d � x? t d � D]1 } t d d � t d � t d � t d � q�Wt d � t d � t � t d � t � t d � t � } | j d � t � } | j d � | j d � | j
� | j d � | j d � | j � | j d d � | j d � | j � | j d � | j d d � | j d � | j d � t t | � � d } x� | j | � d k r�| j d � | j d! � | j | j | � � | j d � | d" d k r�| j! � | j! � t � n | d 7} q W| j
d# d$ d/ d' d( �| j d) � | j d* � d+ � } t" j# d � x! t � r| j � | j � q�W| j d � | j
d, d$ d0 �| j$ | d � d. S(1 s Demo of some new features.i i i g @iZ i i
s wait a moment...i� t greeni� i����i i ix i iF i R� t yellowi i2 R� R% u autoi i( i t blueu orangei g @g333333�?i s CAUGHT! Ry R� t boldR| u rightR� u redc S s t � t � d S( N( R R ( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt baba� s s Click me!t CourierN( R� i R� ( R� i R� (% Rf Rg RQ R\ Rk R4 RZ R� R� R- Rq Rn Rm RX RI R RO R* R; R9 R7 RU RM R2 R: Rc R@ RY R RH Ro RA R6 Rh t timet sleepRJ ( R R� t laengeR� t triR� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt demo2^ s�
(H R� t _vert TkinterR R� R� R� t ost os.pathR R R t copyR t _tg_classesR� R� t
_tg_utilitiest _math_functionst __all__R� R� R� R� R� R� R� R� R� R
R� R� R� R� R R R R8 R7 t objectRJ t ExceptionR� R� R R� R R� R R< R R
R R@ R R Rt R� t _LANGUAGEt ImportErrorR� R� R� R� R� Rv Ru R� R� R� R� R ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt <module>e s�
!
%
4
c � K /&� � � � � � � � � � k � "
$
5 b tkMessageBox.pyc 0000644 00000007466 15032720555 0007676 0 ustar 00 �
z fc @ s� d d l m Z d Z d Z d Z d Z d Z d Z d Z d Z d
Z
d Z d Z d
Z
d Z d Z d Z d Z d Z d e f d � � YZ d+ d+ d+ d+ d � Z d+ d+ d � Z d+ d+ d � Z d+ d+ d � Z d+ d+ d � Z d+ d+ d � Z d+ d+ d � Z d+ d+ d � Z d+ d+ d � Z e d k r�d Ge d d � GHd Ge d d � GHd Ge d d! � GHd Ge d d" � GHd# Ge d d$ � GHd% Ge d d& � GHd' Ge d d( � GHd) Ge d d* � GHn d+ S(, i����( t Dialogt errort infot questiont warningt abortretryignoret okt okcancelt retrycancelt yesnot yesnocancelt abortt retryt ignoret cancelt yest not Messagec B s e Z d Z d Z RS( s
A message boxt
tk_messageBox( t __name__t
__module__t __doc__t command( ( ( s+ /usr/lib64/python2.7/lib-tk/tkMessageBox.pyR 9 s c K s� | r d | k r | | d <n | r> d | k r> | | d <n | rQ | | d <n | rd | | d <n t | � j � } t | t � r� | r� t St St | � S( Nt icont typet titlet message( R t showt
isinstancet boolt YESt NOt str( R R t _icont _typet optionst res( ( s+ /usr/lib64/python2.7/lib-tk/tkMessageBox.pyt _showC s
c K s t | | t t | � S( s Show an info message( R% t INFOt OK( R R R# ( ( s+ /usr/lib64/python2.7/lib-tk/tkMessageBox.pyt showinfoQ s c K s t | | t t | � S( s Show a warning message( R% t WARNINGR' ( R R R# ( ( s+ /usr/lib64/python2.7/lib-tk/tkMessageBox.pyt showwarningU s c K s t | | t t | � S( s Show an error message( R% t ERRORR' ( R R R# ( ( s+ /usr/lib64/python2.7/lib-tk/tkMessageBox.pyt showerrorY s c K s t | | t t | � S( s Ask a question( R% t QUESTIONt YESNO( R R R# ( ( s+ /usr/lib64/python2.7/lib-tk/tkMessageBox.pyt askquestion] s c K s" t | | t t | � } | t k S( s@ Ask if operation should proceed; return true if the answer is ok( R% R- t OKCANCELR' ( R R R# t s( ( s+ /usr/lib64/python2.7/lib-tk/tkMessageBox.pyt askokcancela s c K s" t | | t t | � } | t k S( s0 Ask a question; return true if the answer is yes( R% R- R. R ( R R R# R1 ( ( s+ /usr/lib64/python2.7/lib-tk/tkMessageBox.pyt askyesnof s c K s> t | | t t | � } t | � } | t k r4 d S| t k S( sD Ask a question; return true if the answer is yes, None if cancelled.N( R% R- t YESNOCANCELR t CANCELt NoneR ( R R R# R1 ( ( s+ /usr/lib64/python2.7/lib-tk/tkMessageBox.pyt askyesnocancelk s
c K s" t | | t t | � } | t k S( sD Ask if operation should be retried; return true if the answer is yes( R% R) t RETRYCANCELt RETRY( R R R# R1 ( ( s+ /usr/lib64/python2.7/lib-tk/tkMessageBox.pyt askretrycancelt s t __main__t Spams Egg Informations Egg Warnings Egg Alerts Question?t proceeds Proceed?s yes/nos Got it?s
yes/no/cancels Want it?s try agains
Try again?N( t tkCommonDialogR R+ R& R- R) t ABORTRETRYIGNORER' R0 R8 R. R4 t ABORTR9 t IGNORER5 R R R R6 R% R( R* R, R/ R2 R3 R7 R: R ( ( ( s+ /usr/lib64/python2.7/lib-tk/tkMessageBox.pyt <module> sH
FileDialog.pyo 0000644 00000022766 15032720555 0007315 0 ustar 00 �
z fc @ s� d Z d d l Td d l m Z d d l Z d d l Z i Z d d
d � � YZ d e f d � � YZ d e f d
� � YZ d � Z e
d k r� e � n d S( sZ File selection dialog classes.
Classes:
- FileDialog
- LoadFileDialog
- SaveFileDialog
i����( t *( t DialogNt
FileDialogc B s� e Z d Z d Z d d � Z e j d d d d � Z d d � Z d � Z
d � Z d � Z d
� Z
d � Z d � Z d d
� Z d � Z d � Z d d � Z d � Z d � Z RS( s� Standard file selection dialog -- no checks on selected file.
Usage:
d = FileDialog(master)
fname = d.go(dir_or_file, pattern, default, key)
if fname is None: ...canceled...
else: ...open file...
All arguments to go() are optional.
The 'key' argument specifies a key in the global dictionary
'dialogstates', which keeps track of the values for the directory
and pattern arguments, overriding the values passed in (it does
not keep track of the default argument!). If no key is specified,
the dialog keeps no memory of previous state. Note that memory is
kept even when the dialog is canceled. (All this emulates the
behavior of the Macintosh file selection dialogs.)
s File Selection Dialogc C s� | d k r | j } n | | _ d | _ t | � | _ | j j | � | j j | � t | j � | _ | j j d t
d t � t | j � | _
| j
j d t
d t � | j
j d | j � t | j � | _ | j j d t d t � | j j d | j � t | j � | _ | j j d t d t � t | j � | _ | j j d t d t � t | j d d d | j d f �| _ | j j d t d t d t � | j j � } | j j | d | d � | j j d
| j � | j j d | j � | j j d | j d
f � t | j � | _ | j j d t! d t � t | j d d d | j d f �| _" | j" j d t! d t d t � | j j d | j" d
f � | j" j � } | j" j | d | d � | j" j d
| j# � | j" j d | j$ � t% | j d d d | j& �| _' | j' j d t! � t% | j d d d | j �| _( | j( j d t! d t � t% | j d d d | j) �| _* | j* j d t � | j j+ d | j) � | j j d | j) � | j j d | j) � d S( Nt sidet fills <Return>t expandt exportselectioni t yscrollcommandt seti s <ButtonRelease-1>s <Double-ButtonRelease-1>t commandt yviewt textt OKt Filtert Cancelt WM_DELETE_WINDOWs <Alt-w>s <Alt-W>(, t Nonet titlet mastert directoryt Toplevelt topt iconnamet Framet botframet packt BOTTOMt Xt Entryt selectiont bindt ok_eventt filtert TOPt filter_commandt midframet YESt BOTHt Scrollbart filesbart RIGHTt Yt Listboxt filest bindtagst files_select_eventt files_double_eventt configt dirsbart LEFTt dirst dirs_select_eventt dirs_double_eventt Buttont
ok_commandt ok_buttont
filter_buttont cancel_commandt
cancel_buttont protocol( t selfR R t btags( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyt __init__. sh R t c C s: | r( | t k r( t | \ | _ } nK t j j | � } t j j | � rX | | _ n t j j | � \ | _ } | j | j | � | j | � | j � | j
j � | j j
� | j j � d | _ | j j � | r&| j � \ } } | j rt j j | j � } n | | f t | <n | j j � | j S( N( t dialogstatesR t ost patht
expandusert isdirt splitt
set_filtert
set_selectionR" R t focus_setR t wait_visibilityt grab_setR t howR t mainloopt
get_filtert dirnamet destroy( R< t dir_or_filet patternt defaultt keyR ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyt gom s*
c C s | | _ | j j � d S( N( RK R t quit( R< RK ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyRU � s c C s | j � d S( N( R" ( R< t event( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyR4 � s c C s\ | j � \ } } | j j d � } t j j t j j | j | � � } | j | | � d S( Nt active( RM R2 t getRA RB t normpatht joinR RF ( R< RV t dirt patt subdir( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyR3 � s $c C s | j � d S( N( R6 ( R< RV ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyR. � s c C s# | j j d � } | j | � d S( NRW ( R+ RX RG ( R< RV t file( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyR- � s c C s | j � d S( N( R6 ( R< RV ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyR � s c C s | j | j � � d S( N( RU t
get_selection( R< ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyR6 � s c C s� | j � \ } } y t j | � } Wn" t j k
rI | j j � d SX| | _ | j | | � | j � t j g } g } xg | D]_ } t j
j | | � } t j
j | � r� | j
| � q� t j | | � r� | j
| � q� q� W| j j d t � x! | D] } | j j t | � qW| j j d t � x! | D] } | j j t | � q:Wt j
j | j � � \ } }
|
t j k r�d }
n | j |
� d S( Ni R? ( RM RA t listdirt errorR t bellR RF t sortt pardirRB RZ RD t appendt fnmatchR2 t deletet ENDt insertR+ RE R_ t curdirRG ( R< RV R[ R\ t namest subdirst
matchingfilest namet fullnamet headt tail( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyR" � s6
c C sn | j j � } t j j | � } | d t j k sF t j j | � r^ t j j | d � } n t j j | � S( Ni����R ( R RX RA RB RC t sepRD RZ RE ( R< R ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyRM � s
%c C s% | j j � } t j j | � } | S( N( R RX RA RB RC ( R< R^ ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyR_ � s c C s | j � d S( N( RU ( R< RV ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyR9 � s c C s� t j j | � sr y t j � } Wn t j k
r> d } n X| rr t j j | | � } t j j | � } qr n | j j d t
� | j j t
t j j | p� t j | p� d � � d S( Ni R (
RA RB t isabst getcwdRa R RZ RY R Rg Rh Ri Rj ( R< R[ R\ t pwd( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyRF � s
c C s< | j j d t � | j j t t j j | j | � � d S( Ni ( R Rg Rh Ri RA RB RZ R ( R< R^ ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyRG � s N( t __name__t
__module__t __doc__R R R> RA Rj RT RU R4 R3 R. R- R R6 R" RM R_ R9 RF RG ( ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyR s" ? t LoadFileDialogc B s e Z d Z d Z d � Z RS( s8 File selection dialog which checks that the file exists.s Load File Selection Dialogc C s? | j � } t j j | � s. | j j � n
| j | � d S( N( R_ RA RB t isfileR Rb RU ( R< R^ ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyR6 � s ( Rv Rw Rx R R6 ( ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyRy � s t SaveFileDialogc B s e Z d Z d Z d � Z RS( s@ File selection dialog which checks that the file may be created.s Save File Selection Dialogc
C s� | j � } t j j | � r� t j j | � rA | j j � d St | j d d d d | f d d d d d d
�} | j d k r� d Sn; t j j
| � \ } } t j j | � s� | j j � d S| j | � d S( NR s Overwrite Existing File QuestionR s Overwrite existing file %r?t bitmapt questheadRR i t stringst YesR i ( R R ( R_ RA RB t existsRD R Rb R R t numRE RU ( R< R^ t dRp Rq ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyR6 � s$
( Rv Rw Rx R R6 ( ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyR{ � s c C s\ t � } | j � t | � } | j d d � } t | � } | j d d � } | G| GHd S( s Simple test program.RS t testN( t Tkt withdrawRy RT R{ ( t roott fdt loadfilet savefile( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyR� s
t __main__( ( Rx t TkinterR RA Rf R@ R Ry R{ R� Rv ( ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyt <module> s
� tkColorChooser.pyc 0000644 00000002614 15032720555 0010230 0 ustar 00 �
z fc @ sQ d d l m Z d e f d � � YZ d d � Z e d k rM d Ge � GHn d S( i����( t Dialogt Chooserc B s& e Z d Z d Z d � Z d � Z RS( s Ask for a colort tk_chooseColorc C sL y4 | j d } t | t � r3 d | | j d <n Wn t k
rG n Xd S( Nt initialcolors
#%02x%02x%02x( t optionst
isinstancet tuplet KeyError( t selft color( ( s- /usr/lib64/python2.7/lib-tk/tkColorChooser.pyt _fixoptions! s
c C sU | s t | � r d S| j | � \ } } } | d | d | d f t | � f S( Ni ( NN( t strt Nonet winfo_rgb( R t widgett resultt rt gt b( ( s- /usr/lib64/python2.7/lib-tk/tkColorChooser.pyt
_fixresult+ s ( t __name__t
__module__t __doc__t commandR
R ( ( ( s- /usr/lib64/python2.7/lib-tk/tkColorChooser.pyR s
c K s/ | r | j � } | | d <n t | � j � S( s Ask for a colorR ( t copyR t show( R R ( ( s- /usr/lib64/python2.7/lib-tk/tkColorChooser.pyt askcolor: s
t __main__R N( t tkCommonDialogR R R R R ( ( ( s- /usr/lib64/python2.7/lib-tk/tkColorChooser.pyt <module> s
tkCommonDialog.pyo 0000644 00000002754 15032720555 0010220 0 ustar 00 �
z fc @ s! d d l Td d d � � YZ d S( i����( t *t Dialogc B s5 e Z d Z d d � Z d � Z d � Z d � Z RS( c K sT t d k r t d � n | | _ | | _ | rP | j d � rP | d | _ n d S( Ng������@s$ this module requires Tk 4.2 or newert parent( t TkVersiont TclErrort mastert optionst get( t selfR R ( ( s- /usr/lib64/python2.7/lib-tk/tkCommonDialog.pyt __init__ s c C s d S( N( ( R ( ( s- /usr/lib64/python2.7/lib-tk/tkCommonDialog.pyt _fixoptions s c C s | S( N( ( R t widgett result( ( s- /usr/lib64/python2.7/lib-tk/tkCommonDialog.pyt
_fixresult s c K s� x' | j � D] \ } } | | j | <q
W| j � t | j � } z: | j j | j | j | j � � } | j | | � } Wd y | j
� Wn n XX| S( N( t itemsR R
t FrameR t tkt callt commandt _optionsR
t destroy( R R t kt vt wt s( ( s- /usr/lib64/python2.7/lib-tk/tkCommonDialog.pyt show" s
$N( t __name__t
__module__t NoneR R R
R
R ( ( ( s- /usr/lib64/python2.7/lib-tk/tkCommonDialog.pyR
s
N( ( t TkinterR ( ( ( s- /usr/lib64/python2.7/lib-tk/tkCommonDialog.pyt <module> s
Tkinter.pyc 0000644 00000606777 15032720555 0006734 0 ustar 00 �
z fc @ s� d Z d Z d d l Z e j d k r6 d d l Z n d d l Z e Z e j Z d d l Td d l Td d l
Z
d Z e e j
� Z e e j � Z e j Z e j Z e j Z y e j Wn e k
r� e e _ n Xy e j Wn e k
r� e e _ n Xe
j d � Z e
j d � Z d � Z d
� Z d � Z y
e j Z Wn e k
rYn Xd � Z y
e j Z Wn e k
r�n Xe e d
� Z d f d � � YZ! d a" e a# d � Z$ d � Z% d d � Z& d a' d f d � � YZ( d e( f d � � YZ) d e( f d � � YZ* d e( f d � � YZ+ d e( f d � � YZ, d d � Z- e. Z/ e Z0 d � Z1 d f d! � � YZ2 d" f d# � � YZ3 d$ f d% � � YZ4 d& f d' � � YZ5 d( f d) � � YZ6 d* e2 e6 f d+ � � YZ7 e e d* d d, � Z8 d- f d. � � YZ9 d/ f d0 � � YZ: d1 f d2 � � YZ; d3 e2 f d4 � � YZ< d5 e< e9 e: e; f d6 � � YZ= d7 e< e6 f d8 � � YZ> d9 e= f d: � � YZ? d; � Z@ d< � ZA d= � ZB d> � ZC e d? � ZD d@ e= e4 e5 f dA � � YZE dB e= f dC � � YZF dD e= e4 f dE � � YZG dF e= f dG � � YZH dH e= f dI � � YZI dJ e= e4 e5 f dK � � YZJ dL e= f dM � � YZK dN e= f dO � � YZL dP e= f dQ � � YZM dR e= f dS � � YZN dT e= f dU � � YZO dV e= f dW � � YZP dX e= e4 e5 f dY � � YZQ dZ f d[ � � YZR d\ eL f d] � � YZS d^ f d_ � � YZT d` eT f da � � YZU db eT f dc � � YZV dd � ZW de � ZX df e= e4 f dg � � YZY dh e= f di � � YZZ dj e= f dk � � YZ[ dl e? f dm � � YZ\ dn e? f do � � YZ] dp � Z^ e_ dq k r�e^ � n d S(r s2 Wrapper functions for Tcl/Tk.
Tkinter provides classes which allow the display, positioning and
control of widgets. Toplevel widgets are Tk and Toplevel. Other
widgets are Frame, Label, Entry, Text, Canvas, Button, Radiobutton,
Checkbutton, Scale, Listbox, Scrollbar, OptionMenu, Spinbox
LabelFrame and PanedWindow.
Properties of the widgets are specified with keyword arguments.
Keyword arguments have the same name as the corresponding resource
under Tk.
Widgets are positioned with one of the geometry managers Place, Pack
or Grid. These managers can be called with methods place, pack, grid
available in every Widget.
Actions are bound to events by resources (e.g. keyword argument
command) or with the method bind.
Example (Hello, World):
import Tkinter
from Tkconstants import *
tk = Tkinter.Tk()
frame = Tkinter.Frame(tk, relief=RIDGE, borderwidth=2)
frame.pack(fill=BOTH,expand=1)
label = Tkinter.Label(frame, text="Hello, World")
label.pack(fill=X, expand=1)
button = Tkinter.Button(frame,text="Exit",command=tk.destroy)
button.pack(side=BOTTOM)
tk.mainloop()
s $Revision: 81008 $i����Nt win32( t *i s ([\\{}])s ([\s])c C s d j t t | � � S( s Internal function.t ( t joint mapt
_stringify( t value( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _joinA s c C sL t | t t f � ri t | � d k rV t | d � } t j | � rf d | } qf qHd t | � } n� t | t � r� t | d � } n t | t � s� t | � } n | s� d } n� t j | � r t j
d | � } | j d d � } t j
d | � } | d d k rHd
| } qHn, | d d k s;t j | � rHd | } n | S( s Internal function.i i s {%s}s utf-8s {}s \\\1s
s \nt "s \(
t
isinstancet listt tuplet lenR t _magic_ret searchR t strt unicodet subt replacet _space_re( R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR E s*
c C sb d } xU | D]M } t | � t t f k r> | t | � } q
| d k r
| | f } q
q
W| S( s Internal function.( N( t typet TupleTypet ListTypet _flattent None( R t rest item( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR ` s
c C s� t | � t k r | St | � t t f k r2 | Si } xq t | � D]c } y | j | � WqE t t f k
r� } d G| GHx( | j � D] \ } } | | | <q� WqE XqE W| Sd S( s Internal function.s _cnfmerge: fallback due to:N( R t DictionaryTypet NoneTypet
StringTypeR t updatet AttributeErrort TypeErrort items( t cnfst cnft ct msgt kt v( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _cnfmergem s c C s� | j | � } t | � d r. t d � � n t | � } i } xk t | | � D]Z \ } } t | � } | r� | d d k r� | d } n | r� | | � } n | | | <qP W| S( s Return a properly formatted dict built from Tcl list pairs.
If cut_minus is True, the supposed '-' prefix will be removed from
keys. If conv is specified, it is used to convert values.
Tcl list is expected to contain an even number of elements.
i sN Tcl list representing a dict is expected to contain an even number of elementsi t -i ( t splitlistR t RuntimeErrort itert zipR ( t tkR' t cut_minust convt tt itt dictt keyR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
_splitdict� s
t Eventc B s e Z d Z RS( s� Container for the properties of an event.
Instances of this type are generated if one of the following events occurs:
KeyPress, KeyRelease - for keyboard events
ButtonPress, ButtonRelease, Motion, Enter, Leave, MouseWheel - for mouse events
Visibility, Unmap, Map, Expose, FocusIn, FocusOut, Circulate,
Colormap, Gravity, Reparent, Property, Destroy, Activate,
Deactivate - for window events.
If a callback function for one of these events is registered
using bind, bind_all, bind_class, or tag_bind, the callback is
called with an Event as first argument. It will have the
following attributes (in braces are the event types for which
the attribute is valid):
serial - serial number of event
num - mouse button pressed (ButtonPress, ButtonRelease)
focus - whether the window has the focus (Enter, Leave)
height - height of the exposed window (Configure, Expose)
width - width of the exposed window (Configure, Expose)
keycode - keycode of the pressed key (KeyPress, KeyRelease)
state - state of the event as a number (ButtonPress, ButtonRelease,
Enter, KeyPress, KeyRelease,
Leave, Motion)
state - state as a string (Visibility)
time - when the event occurred
x - x-position of the mouse
y - y-position of the mouse
x_root - x-position of the mouse on the screen
(ButtonPress, ButtonRelease, KeyPress, KeyRelease, Motion)
y_root - y-position of the mouse on the screen
(ButtonPress, ButtonRelease, KeyPress, KeyRelease, Motion)
char - pressed character (KeyPress, KeyRelease)
send_event - see X/Windows documentation
keysym - keysym of the event as a string (KeyPress, KeyRelease)
keysym_num - keysym of the event as a number (KeyPress, KeyRelease)
type - type of the event as a number
widget - widget in which the event occurred
delta - delta of wheel movement (MouseWheel)
( t __name__t
__module__t __doc__( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR6 � s )c C s d a d a b d S( s� Inhibit setting of default root window.
Call this function to inhibit that the first instance of
Tk is used for windows without an explicit parent window.
i N( t _support_default_rootR t
_default_root( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
NoDefaultRoot� s c C s d S( s Internal function.N( ( t err( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _tkerror� s i c C s1 y t | � } Wn t k
r# n Xt | � d S( sB Internal function. Calling it will raise the exception SystemExit.N( t intt
ValueErrort
SystemExit( t code( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _exit� s
t Variablec B sz e Z d Z d Z d Z d d d d � Z d � Z d � Z d � Z d � Z
d � Z e Z d � Z
d � Z d
� Z RS( s� Class to define value holders for e.g. buttons.
Subclasses StringVar, IntVar, DoubleVar, BooleanVar are specializations
that constrain the type of the value returned from get().t c C s� | s t } n | j � | _ | j | _ | r< | | _ n d t t � | _ t d 7a | d k ru | j | � n: | j j | j j
d d | j � � s� | j | j � n d S( s. Construct a variable
MASTER can be given as master widget.
VALUE is an optional value (defaults to "")
NAME is an optional Tcl name (defaults to PY_VARnum).
If NAME matches an existing variable and VALUE is omitted
then the existing value is retained.
t PY_VARi t infot existsN( R; t _rootR. t _tkt _namet reprt _varnumR t sett
getbooleant callt _default( t selft masterR t name( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt __init__� s
'c C s� | j d k r d S| j j | j j d d | j � � rP | j j | j � n | j d k r� x! | j D] } | j j | � qi Wd | _ n d S( s Unset the variable in Tcl.NRG RH ( RJ R RO RP RK t globalunsetvart _tclCommandst
deletecommand( RR RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt __del__� s 'c C s | j S( s' Return the name of the variable in Tcl.( RK ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt __str__
s c C s | j j | j | � S( s Set the variable to VALUE.( RJ t globalsetvarRK ( RR R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRN
s c C s | j j | j � S( s Return value of variable.( RJ t globalgetvarRK ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt get s c C s� t | d | j � j } t t | � � } y
| j } Wn t k
rJ n Xy | | j } Wn t k
ro n X| j j
| | � | j d k r� g | _ n | j j | � | j j
d d | j | | � | S( s
Define a trace callback for the variable.
MODE is one of "r", "w", "u" for read, write, undefine.
CALLBACK must be a function which is called when
the variable is read, written or undefined.
Return the name of the callback.
t tracet variableN( t CallWrapperR RI t __call__RL t idt im_funcR R7 RJ t
createcommandRW t appendRP RK ( RR t modet callbackt ft cbname( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt trace_variable s
c C s� | j j d d | j | | � | j j | � d } xr | j � D], \ } } | j j | � d | k rB PqB qB W| j j | � y | j j | � Wn t k
r� n Xd S( s� Delete the trace callback for a variable.
MODE is one of "r", "w", "u" for read, write, undefine.
CBNAME is the name of the callback returned from trace_variable or trace.
R^ t vdeletei N( RJ RP RK R* t trace_vinfoRX RW t removeR@ ( RR Rf Ri t mt ca( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
trace_vdelete- s
c C s4 t | j j | j j | j j d d | j � � � S( s& Return all trace callback information.R^ t vinfo( R RJ R* RP RK ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRl > s c C s( | j j | j j k o' | j | j k S( s� Comparison for equality (==).
Note: if the Variable's master matters to behavior
also compare self._master == other._master
( t __class__R7 RK ( RR t other( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt __eq__B s N( R7 R8 R9 RQ R RW RU RY RZ RN R] Rj R^ Rp Rl Rt ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRD � s t StringVarc B s/ e Z d Z d Z d d d d � Z d � Z RS( s# Value holder for strings variables.RE c C s t j | | | | � d S( s6 Construct a string variable.
MASTER can be given as master widget.
VALUE is an optional value (defaults to "")
NAME is an optional Tcl name (defaults to PY_VARnum).
If NAME matches an existing variable and VALUE is omitted
then the existing value is retained.
N( RD RU ( RR RS R RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU N s
c C s2 | j j | j � } t | t � r( | St | � S( s# Return value of variable as string.( RJ R\ RK R t
basestringR ( RR R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR] Z s N( R7 R8 R9 RQ R RU R] ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRu K s t IntVarc B s8 e Z d Z d Z d d d d � Z d � Z d � Z RS( s# Value holder for integer variables.i c C s t j | | | | � d S( s7 Construct an integer variable.
MASTER can be given as master widget.
VALUE is an optional value (defaults to 0)
NAME is an optional Tcl name (defaults to PY_VARnum).
If NAME matches an existing variable and VALUE is omitted
then the existing value is retained.
N( RD RU ( RR RS R RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU d s
c C s. t | t � r t | � } n t j | | � S( s; Set the variable to value, converting booleans to integers.( R t boolR? RD RN ( RR R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRN p s c C s t | j j | j � � S( s/ Return the value of the variable as an integer.( t getintRJ R\ RK ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR] v s N( R7 R8 R9 RQ R RU RN R] ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRw a s
t DoubleVarc B s/ e Z d Z d Z d d d d � Z d � Z RS( s! Value holder for float variables.g c C s t j | | | | � d S( s6 Construct a float variable.
MASTER can be given as master widget.
VALUE is an optional value (defaults to 0.0)
NAME is an optional Tcl name (defaults to PY_VARnum).
If NAME matches an existing variable and VALUE is omitted
then the existing value is retained.
N( RD RU ( RR RS R RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU } s
c C s t | j j | j � � S( s, Return the value of the variable as a float.( t getdoubleRJ R\ RK ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR] � s N( R7 R8 R9 RQ R RU R] ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRz z s t
BooleanVarc B s8 e Z d Z e Z d d d d � Z d � Z d � Z RS( s# Value holder for boolean variables.c C s t j | | | | � d S( s: Construct a boolean variable.
MASTER can be given as master widget.
VALUE is an optional value (defaults to False)
NAME is an optional Tcl name (defaults to PY_VARnum).
If NAME matches an existing variable and VALUE is omitted
then the existing value is retained.
N( RD RU ( RR RS R RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU � s
c C s" | j j | j | j j | � � S( s Set the variable to VALUE.( RJ R[ RK RO ( RR R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRN � s c C s | j j | j j | j � � S( s+ Return the value of the variable as a bool.( RJ RO R\ RK ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR] � s N( R7 R8 R9 t FalseRQ R RU RN R] ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR| � s
c C s t j j | � d S( s Run the main loop of Tcl.N( R; R. t mainloop( t n( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR~ � s c C s t j j | � S( s1 Convert true and false to integer values 1 and 0.( R; R. RO ( t s( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRO � s t Miscc B sD e Z d Z d� Z d � Z d � Z d� d � Z d � Z d � Z d � Z
d d � Z e Z d� d � Z
d� d
� Z d d d � Z d d
� Z e Z e Z d � Z d � Z e Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d� d � Z d � Z d � Z! d d � Z" d � Z# d � Z$ d � Z% d � Z& d � Z' d! � Z( d" � Z) d# � Z* d� d$ � Z+ d% � Z, d& � Z- d� d' � Z. d( � Z/ d) � Z0 d* � Z1 d+ � Z2 d, � Z3 d- � Z4 d� d. � Z5 d� d/ � Z6 e6 Z7 d� d0 � Z8 d d1 � Z9 d d2 � Z: d3 � Z; d4 � Z< d5 � Z= d6 � Z> d d7 � Z? d8 � Z@ d9 � ZA d: � ZB d; � ZC d< � ZD d= � ZE d d> � ZF d? � ZG d@ � ZH dA � ZI dB � ZJ d dC � ZK dD � ZL dE � ZM dF � ZN dG � ZO dH � ZP dI � ZQ dJ � ZR dK � ZS dL � ZT dM � ZU dN � ZV dO � ZW dP � ZX dQ � ZY dR � ZZ dS � Z[ dT � Z\ dU � Z] dV � Z^ dW � Z_ dX � Z` dY � Za d dZ � Zb d[ � Zc d\ � Zd d] � Ze d^ � Zf d_ � Zg d` � Zh da � Zi db � Zj dc � Zk dd � Zl de � Zm d� df � Zn dg dh � Zo d� d� d� di � Zp d� dj � Zq d� d� d� dk � Zr dl � Zs d� d� d� dm � Zt dn � Zu d do � Zv dp � Zw dq � Zx dr � Zy ds � Zz dt � Z{ e| du � � Z} d� dv � Z~ dw � Z e Z� d� dg dx � Z� e� Z� dy � Z� d� Z� d� j� e� � Z� d� � Z� d� � Z� d� � Z� d� � Z� d� � Z� d� d� � Z� e� Z� d� � Z� e� Z� d� � Z� d� � Z� d� � Z� d� � Z� d� g Z� e� d� � Z� e� Z� d� � Z� e� Z� d� � Z� d� d� d� d� d� � Z� e� Z� d� � Z� d� � Z� i d� � Z� e� Z� d� � Z� e� d� � Z� i d� � Z� e� Z� d� � Z� e� Z� d� d� d� � Z� d� � Z� d� � Z� d� � Z� d� d� � Z� d� � Z� d� � Z� RS(� sR Internal class.
Base class which defines methods common for interior widgets.c C sC | j d k r? x! | j D] } | j j | � q Wd | _ n d S( sk Internal function.
Delete all Tcl commands created for
this widget in the Tcl interpreter.N( RW R R. RX ( RR RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt destroy� s c C s< | j j | � y | j j | � Wn t k
r7 n Xd S( sD Internal function.
Delete the Tcl command provided in NAME.N( R. RX RW Rm R@ ( RR RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRX � s
c C s" | j j | j j d d | � � S( s� Set Tcl internal variable, whether the look and feel
should adhere to Motif.
A parameter of 1 means adhere to Motif (e.g. no color
change if mouse passes over slider).
Returns the set value.RN t tk_strictMotif( R. RO RP ( RR t boolean( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s | j j d � d S( sD Change the color scheme to light brown as used in Tk 3.6 and before.t tk_bisqueN( R. RP ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c O s. | j j d t | � t | j � � � d S( s Set a new color scheme for all widget elements.
A single color as argument will cause that all colors of Tk
widget elements are derived from this.
Alternatively several keyword parameters and its associated
colors can be given. The following keywords are valid:
activeBackground, foreground, selectColor,
activeForeground, highlightBackground, selectBackground,
background, highlightColor, selectForeground,
disabledForeground, insertBackground, troughColor.t
tk_setPaletteN( R� ( R. RP R R! ( RR t argst kw( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c G s& d d l } | j d t d d �d S( s) Do not use. Needed in Tk 3.6 and earlier.i����Ns4 tk_menuBar() does nothing and will be removed in 3.6t
stackleveli ( t warningst warnt DeprecationWarning( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
tk_menuBar� s RF c C s | j j d d | � d S( s� Wait until the variable is modified.
A parameter of type IntVar, StringVar, DoubleVar or
BooleanVar must be given.t tkwaitR_ N( R. RP ( RR RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
wait_variable� s c C s2 | d k r | } n | j j d d | j � d S( sQ Wait until a WIDGET is destroyed.
If no parameter is given self is used.R� t windowN( R R. RP t _w( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wait_window� s c C s2 | d k r | } n | j j d d | j � d S( sx Wait until the visibility of a WIDGET changes
(e.g. it appears).
If no parameter is given self is used.R� t
visibilityN( R R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wait_visibility� s t 1c C s | j j | | � d S( s Set Tcl variable NAME to VALUE.N( R. t setvar( RR RT R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� s c C s | j j | � S( s" Return value of Tcl variable NAME.( R. t getvar( RR RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� s c C s | j j | � S( sP Return a boolean value for Tcl boolean values true and false given as parameter.( R. RO ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRO s c C s | j j d | j � d S( s� Direct input focus to this widget.
If the application currently does not have the focus
this widget will get the focus if the application gets
the focus through the window manager.t focusN( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt focus_set s c C s | j j d d | j � d S( st Direct input focus to this widget even if the
application does not have the focus. Use with
caution!R� s -forceN( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt focus_force s c C s6 | j j d � } | d k s% | r) d S| j | � S( s� Return the widget which has currently the focus in the
application.
Use focus_displayof to allow working with several
displays. Return None if application does not have
the focus.R� t noneN( R. RP R t
_nametowidget( RR RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt focus_get s c C s? | j j d d | j � } | d k s. | r2 d S| j | � S( s� Return the widget which has currently the focus on the
display where this widget is located.
Return None if the application does not have the focus.R� s
-displayofR� N( R. RP R� R R� ( RR RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt focus_displayof# s c C s? | j j d d | j � } | d k s. | r2 d S| j | � S( sy Return the widget which would have the focus if top level
for this widget gets the focus from the window manager.R� s -lastforR� N( R. RP R� R R� ( RR RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
focus_lastfor+ s c C s | j j d � d S( sX The widget under mouse will get automatically focus. Can not
be disabled easily.t tk_focusFollowsMouseN( R. RP ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� 1 s c C s/ | j j d | j � } | s" d S| j | � S( sn Return the next widget in the focus order which follows
widget which has currently the focus.
The focus order first goes to the next child, then to
the children of the child recursively and then to the
next sibling which is higher in the stacking order. A
widget is omitted if it has the takefocus resource set
to 0.t tk_focusNextN( R. RP R� R R� ( RR RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� 5 s c C s/ | j j d | j � } | s" d S| j | � S( sH Return previous widget in the focus order. See tk_focusNext for details.t tk_focusPrevN( R. RP R� R R� ( RR RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� A s c sj � s � j j d | � d S� � � � f d � } � j | _ � j | � � � j j d | � � Sd S( s Call function once after given time.
MS specifies the time in milliseconds. FUNC gives the
function which shall be called. Additional parameters
are given as parameters to the function call. Return
identifier to cancel scheduling with after_cancel.t afterc s; z � � � Wd y � j � � Wn t k
r5 n XXd S( N( RX t TclError( ( R� t funcRT RR ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt callitR s
N( R. RP R R7 t _register( RR t msR� R� R� ( ( R� R� RT RR s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� F s c G s | j d | | � S( s� Call FUNC once if the Tcl main loop has no event to
process.
Return an identifier to cancel the scheduling with
after_cancel.t idle( R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
after_idle] s c C s� | s t d � � n y? | j j d d | � } | j j | � d } | j | � Wn t k
rg n X| j j d d | � d S( s� Cancel scheduling of function identified with ID.
Identifier returned by after or after_idle must be
given as first parameter.
s? id must be a valid identifier returned from after or after_idleR� RG i t cancelN( R@ R. RP R* RX R� ( RR Rb t datat script( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt after_canceld s
i c C s! | j j d | j | � � d S( s Ring a display's bell.t bellN( R� ( R. RP t
_displayof( RR t displayof( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� t s c K s� d | k rd | j d k rd y+ d | d <| j j d | j | � � SWqd t k
r` | d =qd Xn | j j d | j | � � S( s� Retrieve data from the clipboard on window's display.
The window keyword defaults to the root window of the Tkinter
application.
The type keyword specifies the form in which the data is
to be returned and should be an atom name such as STRING
or FILE_NAME. Type defaults to STRING, except on X11, where the default
is to try UTF8_STRING and fall back to STRING.
This command is equivalent to:
selection_get(CLIPBOARD)
R t x11t UTF8_STRINGt clipboardR] ( R� R] ( R� R] ( t _windowingsystemR. RP t _optionsR� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
clipboard_gety s
!
c K s= d | k r | j | d <n | j j d | j | � � d S( s� Clear the data in the Tk clipboard.
A widget specified for the optional displayof keyword
argument specifies the target display.R� R� t clearN( R� R� ( R� R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt clipboard_clear� s c K sG d | k r | j | d <n | j j d | j | � d | f � d S( s� Append STRING to the Tk clipboard.
A widget specified at the optional displayof keyword
argument specifies the target display. The clipboard
can be retrieved with selection_get.R� R� Re s --N( R� Re ( R� R. RP R� ( RR t stringR� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt clipboard_append� s c C s2 | j j d d | j � } | s% d S| j | � S( sO Return widget which has currently the grab in this application
or None.t grabt currentN( R. RP R� R R� ( RR RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grab_current� s c C s | j j d d | j � d S( s. Release grab for this widget if currently set.R� t releaseN( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grab_release� s c C s | j j d d | j � d S( sw Set grab for this widget.
A grab directs all events to this and descendant
widgets in the application.R� RN N( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grab_set� s c C s | j j d d d | j � d S( s� Set global grab for this widget.
A global grab directs all events to this and
descendant widgets on the display. Use with caution -
other applications do not get events anymore.R� RN s -globalN( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grab_set_global� s c C s4 | j j d d | j � } | d k r0 d } n | S( sY Return None, "local" or "global" if this widget has
no, a local or a global grab.R� t statusR� N( R. RP R� R ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grab_status� s c C s | j j d d | | | � d S( s� Set a VALUE (second parameter) for an option
PATTERN (first parameter).
An optional third parameter gives the numeric priority
(defaults to 80).t optiont addN( R. RP ( RR t patternR t priority( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
option_add� s c C s | j j d d � d S( sP Clear the option database.
It will be reloaded if option_add is called.R� R� N( R. RP ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt option_clear� s c C s | j j d d | j | | � S( s� Return the value for an option NAME for this widget
with CLASSNAME.
Values with higher priority override lower values.R� R] ( R. RP R� ( RR RT t className( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
option_get� s c C s | j j d d | | � d S( sv Read file FILENAME into the option database.
An optional second parameter gives the numeric
priority.R� t readfileN( R. RP ( RR t fileNameR� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt option_readfile� s c K s= d | k r | j | d <n | j j d | j | � � d S( s Clear the current X selection.R� t selectionR� N( R� R� ( R� R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt selection_clear� s c K s� d | k r | j | d <n d | k r� | j d k r� y+ d | d <| j j d | j | � � SWq� t k
r| | d =q� Xn | j j d | j | � � S( s� Return the contents of the current X selection.
A keyword parameter selection specifies the name of
the selection and defaults to PRIMARY. A keyword
parameter displayof specifies a widget on the display
to use. A keyword parameter type specifies the form of data to be
fetched, defaulting to STRING except on X11, where UTF8_STRING is tried
before STRING.R� R R� R� R� R] ( R� R] ( R� R] ( R� R� R. RP R� R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
selection_get� s
!
c K s= | j | � } | j j d | j | � | j | f � d S( s Specify a function COMMAND to call if the X
selection owned by this widget is queried by another
application.
This function must return the contents of the
selection. The function will be called with the
arguments OFFSET and LENGTH which allows the chunking
of very long selections. The following keyword
parameters can be provided:
selection - name of the selection (default PRIMARY),
type - type of the selection (e.g. STRING, FILE_NAME).R� t handleN( R� R� ( R� R. RP R� R� ( RR t commandR� RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt selection_handle� s c K s+ | j j d | j | � | j f � d S( s� Become owner of X selection.
A keyword parameter selection specifies the name of
the selection (default PRIMARY).R� t ownN( R� R� ( R. RP R� R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
selection_own� s c K sR d | k r | j | d <n | j j d | j | � � } | sE d S| j | � S( s� Return owner of X selection.
The following keyword parameter can
be provided:
selection - name of the selection (default PRIMARY),
type - type of the selection (e.g. STRING, FILE_NAME).R� R� R� ( R� R� N( R� R. RP R� R R� ( RR R� RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt selection_own_get s c G s | j j d | | f | � S( sD Send Tcl command CMD to different interpreter INTERP to be executed.t send( R. RP ( RR t interpt cmdR� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� s c C s | j j d | j | � d S( s( Lower this widget in the stacking order.t lowerN( R. RP R� ( RR t belowThis( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� s c C s | j j d | j | � d S( s( Raise this widget in the stacking order.t raiseN( R. RP R� ( RR t aboveThis( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt tkraise s c C s | j j d d | j | � S( s Useless. Not implemented in Tk.R. t
colormodel( R. RP R� ( RR R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� s c C s0 d | j | � | f } t | j j | � � S( s* Return integer which represents atom NAME.t winfot atom( R� R� ( R� Ry R. RP ( RR RT R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
winfo_atom s c C s* d | j | � | f } | j j | � S( s' Return name of atom with identifier ID.R� t atomname( R� R� ( R� R. RP ( RR Rb R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_atomname s c C s t | j j d d | j � � S( s7 Return number of cells in the colormap for this widget.R� t cells( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_cells! s c C sj g } x] | j j | j j d d | j � � D]4 } y | j | j | � � Wq. t k
ra q. Xq. W| S( s? Return a list of all widgets which are children of this widget.R� t children( R. R* RP R� Re R� t KeyError( RR t resultt child( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_children% s "
c C s | j j d d | j � S( s( Return window class name of this widget.R� t class( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_class2 s c C s% | j j | j j d d | j � � S( s? Return true if at the last color request the colormap was full.R� t colormapfull( R. RO RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_colormapfull5 s c C sF d | j | � | | f } | j j | � } | s9 d S| j | � S( s@ Return the widget which is at the root coordinates ROOTX, ROOTY.R� t
containing( R� R� N( R� R. RP R R� ( RR t rootXt rootYR� R� RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_containing9 s
c C s t | j j d d | j � � S( s$ Return the number of bits per pixel.R� t depth( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_depth@ s c C s t | j j d d | j � � S( s" Return true if this widget exists.R� RH ( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_existsC s c C s" t | j j d d | j | � � S( sW Return the number of pixels for the given distance NUMBER
(e.g. "3c") as float.R� t fpixels( R{ R. RP R� ( RR t number( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
winfo_fpixelsG s c C s | j j d d | j � S( sF Return geometry string for this widget in the form "widthxheight+X+Y".R� t geometry( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_geometryL s c C s t | j j d d | j � � S( s Return height of this widget.R� t height( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_heightO s c C s" t | j j d d | j � d � S( s% Return identifier ID for this widget.R� Rb i ( R? R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_idS s c C s/ d | j | � } | j j | j j | � � S( s9 Return the name of all Tcl interpreters for this display.R� t interps( R� R ( R� R. R* RP ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
winfo_interpsV s c C s t | j j d d | j � � S( s% Return true if this widget is mapped.R� t ismapped( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_ismappedZ s c C s | j j d d | j � S( s/ Return the window manager name for this widget.R� t manager( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
winfo_manager^ s c C s | j j d d | j � S( s Return the name of this widget.R� RT ( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
winfo_namea s c C s | j j d d | j � S( s- Return the name of the parent of this widget.R� t parent( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_parentd s c C s* d | j | � | f } | j j | � S( s. Return the pathname of the widget given by ID.R� t pathname( R� R
( R� R. RP ( RR Rb R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_pathnameg s c C s" t | j j d d | j | � � S( s' Rounded integer value of winfo_fpixels.R� t pixels( Ry R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_pixelsl s c C s t | j j d d | j � � S( s: Return the x coordinate of the pointer on the root window.R� t pointerx( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_pointerxp s c C s" | j | j j d d | j � � S( sH Return a tuple of x and y coordinates of the pointer on the root window.R� t pointerxy( t _getintsR. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_pointerxyt s c C s t | j j d d | j � � S( s: Return the y coordinate of the pointer on the root window.R� t pointery( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_pointeryx s c C s t | j j d d | j � � S( s' Return requested height of this widget.R� t reqheight( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_reqheight| s c C s t | j j d d | j � � S( s& Return requested width of this widget.R� t reqwidth( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_reqwidth� s c C s% | j | j j d d | j | � � S( sU Return tuple of decimal values for red, green, blue for
COLOR in this widget.R� t rgb( R R. RP R� ( RR t color( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_rgb� s c C s t | j j d d | j � � S( sS Return x coordinate of upper left corner of this widget on the
root window.R� t rootx( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_rootx� s c C s t | j j d d | j � � S( sS Return y coordinate of upper left corner of this widget on the
root window.R� t rooty( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_rooty� s c C s | j j d d | j � S( s& Return the screen name of this widget.R� t screen( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_screen� s c C s t | j j d d | j � � S( sT Return the number of the cells in the colormap of the screen
of this widget.R� t screencells( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_screencells� s c C s t | j j d d | j � � S( s\ Return the number of bits per pixel of the root window of the
screen of this widget.R� t screendepth( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_screendepth� s c C s t | j j d d | j � � S( sX Return the number of pixels of the height of the screen of this widget
in pixel.R� t screenheight( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_screenheight� s c C s t | j j d d | j � � S( sU Return the number of pixels of the height of the screen of
this widget in mm.R� t screenmmheight( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_screenmmheight� s c C s t | j j d d | j � � S( sT Return the number of pixels of the width of the screen of
this widget in mm.R� t
screenmmwidth( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_screenmmwidth� s c C s | j j d d | j � S( s� Return one of the strings directcolor, grayscale, pseudocolor,
staticcolor, staticgray, or truecolor for the default
colormodel of this screen.R� t screenvisual( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_screenvisual� s c C s t | j j d d | j � � S( sW Return the number of pixels of the width of the screen of
this widget in pixel.R� t screenwidth( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_screenwidth� s c C s | j j d d | j � S( sx Return information of the X-Server of the screen of this widget in
the form "XmajorRminor vendor vendorVersion".R� t server( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_server� s c C s" | j | j j d d | j � � S( s* Return the toplevel widget of this widget.R� t toplevel( R� R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_toplevel� s c C s t | j j d d | j � � S( sB Return true if the widget and all its higher ancestors are mapped.R� t viewable( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_viewable� s c C s | j j d d | j � S( s� Return one of the strings directcolor, grayscale, pseudocolor,
staticcolor, staticgray, or truecolor for the
colormodel of this widget.R� t visual( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_visual� s c C s | j j d d | j � S( s7 Return the X identifier for the visual for this widget.R� t visualid( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_visualid� s c C sp | j j | j j d d | j | r* d p- d � � } t | � t k r` | j j | � g } n t | j | � S( s� Return a list of all visuals available for the screen
of this widget.
Each item in the list consists of a visual name (see winfo_visual), a
depth and if INCLUDEIDS=1 is given also the X identifier.R� t visualsavailablet
includeidsN( R. t splitRP R� R R R R t _Misc__winfo_parseitem( RR R; R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_visualsavailable� s c C s" | d t t | j | d � � S( s Internal function.i ( R R t _Misc__winfo_getint( RR R1 ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt __winfo_parseitem� s c C s
t | d � S( s Internal function.i ( R? ( RR t x( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt __winfo_getint� s c C s t | j j d d | j � � S( s� Return the height of the virtual root window associated with this
widget in pixels. If there is no virtual root window return the
height of the screen.R� t vrootheight( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_vrootheight� s c C s t | j j d d | j � � S( s� Return the width of the virtual root window associated with this
widget in pixel. If there is no virtual root window return the
width of the screen.R� t
vrootwidth( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_vrootwidth� s c C s t | j j d d | j � � S( si Return the x offset of the virtual root relative to the root
window of the screen of this widget.R� t vrootx( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_vrootx� s c C s t | j j d d | j � � S( si Return the y offset of the virtual root relative to the root
window of the screen of this widget.R� t vrooty( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_vrooty� s c C s t | j j d d | j � � S( s Return the width of this widget.R� t width( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_width� s c C s t | j j d d | j � � S( sV Return the x coordinate of the upper left corner of this widget
in the parent.R� RA ( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_x� s c C s t | j j d d | j � � S( sV Return the y coordinate of the upper left corner of this widget
in the parent.R� t y( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_y� s c C s | j j d � d S( sE Enter event loop until all pending events have been processed by Tcl.R N( R. RP ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR s c C s | j j d d � d S( s� Enter event loop until all idle callbacks have been called. This
will update the display of windows but not process events caused by
the user.R t idletasksN( R. RP ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt update_idletasks s c C sK | d k r. | j j | j j d | j � � S| j j d | j | � d S( s, Set or get the list of bindtags for this widget.
With no argument return the list of all bindtags associated with
this widget. With a list of strings as argument the bindtags are
set to this list. The bindtags determine in which order events are
processed (see bind).t bindtagsN( R R. R* RP R� ( RR t tagList( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRR s i c C s� t | � t k r/ | j j | | | f � n� | r� | j | | j | � } d | r\ d p_ d | | j f } | j j | | | f � | S| r� | j j | | f � S| j j | j j | � � Sd S( s Internal function.s" %sif {"[%s %s]" == "break"} break
t +RE N( R R R. RP R� t _substitutet _subst_format_strR* ( RR t whatt sequenceR� R� t needcleanupt funcidR� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _bind s c C s | j d | j f | | | � S( sO Bind to this widget at event SEQUENCE a call to function FUNC.
SEQUENCE is a string of concatenated event
patterns. An event pattern is of the form
<MODIFIER-MODIFIER-TYPE-DETAIL> where MODIFIER is one
of Control, Mod2, M2, Shift, Mod3, M3, Lock, Mod4, M4,
Button1, B1, Mod5, M5 Button2, B2, Meta, M, Button3,
B3, Alt, Button4, B4, Double, Button5, B5 Triple,
Mod1, M1. TYPE is one of Activate, Enter, Map,
ButtonPress, Button, Expose, Motion, ButtonRelease
FocusIn, MouseWheel, Circulate, FocusOut, Property,
Colormap, Gravity Reparent, Configure, KeyPress, Key,
Unmap, Deactivate, KeyRelease Visibility, Destroy,
Leave and DETAIL is the button number for ButtonPress,
ButtonRelease and DETAIL is the Keysym for KeyPress and
KeyRelease. Examples are
<Control-Button-1> for pressing Control and mouse button 1 or
<Alt-A> for pressing A and the Alt key (KeyPress can be omitted).
An event pattern can also be a virtual event of the form
<<AString>> where AString can be arbitrary. This
event can be generated by event_generate.
If events are concatenated they must appear shortly
after each other.
FUNC will be called if the event sequence occurs with an
instance of Event as argument. If the return value of FUNC is
"break" no further bound function is invoked.
An additional boolean parameter ADD specifies whether FUNC will
be called additionally to the other bound function or whether
it will replace the previous function.
Bind will return an identifier to allow deletion of the bound function with
unbind without memory leak.
If FUNC or SEQUENCE is omitted the bound function or list
of bound events are returned.t bind( R[ R� ( RR RX R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR\ ( s 'c C s6 | j j d | j | d � | r2 | j | � n d S( sW Unbind for this widget for event SEQUENCE the
function identified with FUNCID.R\ RE N( R. RP R� RX ( RR RX RZ ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt unbindP s c C s | j d | | | d � S( s Bind to all widgets at an event SEQUENCE a call to function FUNC.
An additional boolean parameter ADD specifies whether FUNC will
be called additionally to the other bound function or whether
it will replace the previous function. See bind for the return value.R\ t alli ( R\ R^ ( R[ ( RR RX R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt bind_allV s c C s | j j d d | d � d S( s8 Unbind for all widgets for event SEQUENCE all functions.R\ R^ RE N( R. RP ( RR RX ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
unbind_all\ s c C s | j d | f | | | d � S( s= Bind to widgets with bindtag CLASSNAME at event
SEQUENCE a call of function FUNC. An additional
boolean parameter ADD specifies whether FUNC will be
called additionally to the other bound function or
whether it will replace the previous function. See bind for
the return value.R\ i ( R[ ( RR R� RX R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
bind_class_ s c C s | j j d | | d � d S( sW Unbind for all widgets with bindtag CLASSNAME for event SEQUENCE
all functions.R\ RE N( R. RP ( RR R� RX ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt unbind_classi s c C s | j j | � d S( s Call the mainloop of Tk.N( R. R~ ( RR R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR~ m s c C s | j j � d S( s8 Quit the Tcl interpreter. All widgets will be destroyed.N( R. t quit( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRc p s c C s) | r% t t t | j j | � � � Sd S( s Internal function.N( R R Ry R. R* ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR s s c C s) | r% t t t | j j | � � � Sd S( s Internal function.N( R R R{ R. R* ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _getdoublesw s c C s | r | j j | � Sd S( s Internal function.N( R. RO ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _getboolean{ s c C s- | r d | f S| d k r) d | j f Sd S( s Internal function.s
-displayofN( ( R R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� s
c C sL y | j � j SWn4 t k
rG | j j d d � } | j � _ | SXd S( s Internal function.R. t windowingsystemN( RI t _windowingsystem_cachedR R. RP ( RR t ws( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s
"c C sE | r t | | f � } n t | � } d } x| j � D]\ } } | d k r: | d d k ro | d } n t | d � r� | j | � } n� t | t t f � r&g } xx | D]^ } t | t t t
f � s� Pq� t | t t
f � r� | j d | � q� | j t | � � q� Wd j
| � } n | d | | f } q: q: W| S( s Internal function.i����t _Ra s %dR R) ( N( R( R! R t hasattrR� R R R
Rv R? t longRe R R ( RR R# R� R R& R' t nvR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s*
c C sj t | � j d � } | } | d s> | j � } | d } n x% | D] } | sU Pn | j | } qE W| S( sP Return the Tkinter instance of a widget identified by
its Tcl name NAME.t .i i ( R R< RI R� ( RR RT t wR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt nametowidget� s
c C s� t | | | � j } t t | � � } y
| j } Wn t k
rG n Xy | | j } Wn t k
rl n X| j j | | � | r� | j d k r� g | _ n | j j | � n | S( s� Return a newly created Tcl function. If this
function is called, the Python function FUNC will
be executed. An optional function SUBST can
be given which will be executed before FUNC.N( R` Ra RL Rb Rc R R7 R. Rd RW R Re ( RR R� t substRY Rh RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s
c C s# | } x | j r | j } q W| S( s Internal function.( RS ( RR Rn ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRI � s
s %#s %bs %fs %hs %ks %ss %ts %ws %xs %ys %As %Es %Ks %Ns %Ws %Ts %Xs %Ys %DR c G s t | � t | j � k r | S| j j } t } d � } | \ } } } } } }
} } }
} } } } } } } } } } t � } | | � | _ | | � | _ y | | � | _ Wn t k
r� n X| | � | _
| | � | _ | |
� | _ | | � | _
| | � | _ | |
� | _ | | � | _ | | _ y | | � | _ Wn t k
r_n X| | _ | | � | _ | | _ y | j | � | _ Wn t k
r�| | _ n X| | � | _ | | � | _ y | | � | _ Wn t k
rd | _ n X| f S( s Internal function.c S s' y t | � SWn t k
r" | SXd S( s? Tk changed behavior in 8.4.2, returning "??" rather more often.N( R? R@ ( R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt getint_event� s
i ( R t
_subst_formatR. RO R? R6 t serialt numR� R� R� t keycodet statet timeRK RA RN t chart
send_eventt keysymt
keysym_numR R� t widgetR� t x_roott y_roott deltaR@ ( RR R� RO Ry Rq t nsignt bRh t hR& R� R1 Rn RA RN t At Et Kt Nt Wt Tt Xt Yt Dt e( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU � sN ?
c C sL d d l } | j | j | j } } } | j � } | j | | | � d S( s Internal function.i����N( t syst exc_typet exc_valuet
exc_tracebackRI t report_callback_exception( RR R� t exct valt tbt root( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _report_exception s c G sj i } x] | j j | j j | � � D]= } | j j | � } | d d f | d | | d d <q% W| S( s; Call Tcl configure command and return the result as a dict.i i ( R. R* RP ( RR R� R# RA ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
_getconfigure s
%)c G s5 | j j | j j | � � } | d d f | d S( Ni i ( R. R* RP ( RR R� RA ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _getconfigure1! s c C s� | r t | | f � } n | r0 t | � } n | d k rX | j t | j | f � � St | � t k r� | j t | j | d | f � � S| j j t | j | f � | j
| � � d S( s Internal function.R) N( R( R R� R R� R R R� R. RP R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
_configure% s #c K s | j d | | � S( s� Configure resources of a widget.
The values for resources are specified as keyword
arguments. To get an overview about
the allowed keyword arguments call the method keys.
t configure( R� ( RR R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� 1 s c C s | j j | j d d | � S( s4 Return the resource value for a KEY given as string.t cgetR) ( R. RP R� ( RR R4 ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� : s c C s | j i | | 6� d S( N( R� ( RR R4 R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt __setitem__> s c C s t d � � d S( Ns) Tkinter objects don't support 'in' tests.( R ( RR R4 ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt __contains__@ s c C sI | j j } g | | j j | j d � � D] } | | � d d ^ q+ S( s3 Return a list of all resource names of this widget.R� i i ( R. R* RP R� ( RR R* RA ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt keysB s c C s | j S( s+ Return the window path name of this widget.( R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRZ G s t _noarg_c C sQ | t j k r1 | j | j j d d | j � � S| j j d d | j | � d S( s Set or get the status for propagation of geometry information.
A boolean argument specifies whether the geometry information
of the slaves will determine the size of this widget. If no argument
is given the current setting will be returned.
t packt propagateN( R� R� Re R. RP R� ( RR t flag( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt pack_propagateL s c C s1 t | j | j j | j j d d | j � � � S( sH Return a list of all slaves of this widget
in its packing order.R� t slaves( R R� R. R* RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt pack_slavesY s c C s1 t | j | j j | j j d d | j � � � S( sH Return a list of all slaves of this widget
in its packing order.t placeR� ( R R� R. R* RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt place_slavesa s c C s� d d | j f } | d k r= | d k r= | | | f } n | d k rh | d k rh | | | f } n | j | j j | � � p� d S( s� Return a tuple of integer coordinates for the bounding
box of this widget controlled by the geometry manager grid.
If COLUMN, ROW is given the bounding box applies from
the cell with row and column 0 to the specified
cell. If COL2 and ROW2 are given the bounding box
starts at that cell.
The returned integers specify the offset of the upper left
corner in the master widget and the width and height.
t gridt bboxN( R� R R R. RP ( RR t columnt rowt col2t row2R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grid_bboxi s c C sm t | t t j f � ri y: t | � } | s1 d Sd | k rG t | � St | � SWqi t k
re qi Xn | S( NRm ( R R t _tkintert Tcl_ObjR R{ Ry R@ ( RR R t svalue( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _gridconvvalue~ s
c C s� t | � t k r_ | r_ | d d k r6 | d } n | d d k rS d | } n | f } n | j | | � } | s� t | j | j j d | | j | � d | j �S| j j d | | j | f | � } t | � d k r� | j | � Sd S( s Internal function.i����Ri i R) R� R0 N( R R R� R5 R. RP R� R� R ( RR R� t indexR# R� t optionsR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _grid_configure� s"
c K s | j d | | | � S( s� Configure column INDEX of a grid.
Valid resources are minsize (minimum size of the column),
weight (how much does additional space propagate to this column)
and pad (how much space to let additionally).t columnconfigure( R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grid_columnconfigure� s c C s. | j | j j d d | j | | � � p- d S( s� Return a tuple of column and row which identify the cell
at which the pixel at position X and Y inside the master
widget is located.R� t locationN( R R. RP R� R ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
grid_location� s c C sQ | t j k r1 | j | j j d d | j � � S| j j d d | j | � d S( s Set or get the status for propagation of geometry information.
A boolean argument specifies whether the geometry information
of the slaves will determine the size of this widget. If no argument
is given, the current setting will be returned.
R� R� N( R� R� Re R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grid_propagate� s c K s | j d | | | � S( s� Configure row INDEX of a grid.
Valid resources are minsize (minimum size of the row),
weight (how much does additional space propagate to this row)
and pad (how much space to let additionally).t rowconfigure( R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grid_rowconfigure� s c C s( | j | j j d d | j � � p' d S( s< Return a tuple of the number of column and rows in the grid.R� t sizeN( R R. RP R� R ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grid_size� s c C s| d } | d k r% | d | f } n | d k rD | d | f } n t | j | j j | j j d d | j f | � � � S( sH Return a list of all slaves of this widget
in its packing order.s -rows -columnR� R� ( N( R R R� R. R* RP R� ( RR R� R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grid_slaves� s c G s' d d | f | } | j j | � d S( s� Bind a virtual event VIRTUAL (of the form <<Name>>)
to an event SEQUENCE such that the virtual event is triggered
whenever SEQUENCE occurs.t eventR� N( R. RP ( RR t virtualt sequencesR� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt event_add� s c G s' d d | f | } | j j | � d S( s- Unbind a virtual event VIRTUAL from SEQUENCE.R� t deleteN( R. RP ( RR R� R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt event_delete� s c K s` d d | j | f } x4 | j � D]& \ } } | d | t | � f } q" W| j j | � d S( s� Generate an event SEQUENCE. Additional
keyword arguments specify parameter of the event
(e.g. x, y, rootx, rooty).R� t generates -%sN( R� R! R R. RP ( RR RX R� R� R& R' ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt event_generate� s c C s" | j j | j j d d | � � S( su Return a list of all virtual events or the information
about the SEQUENCE bound to the virtual event VIRTUAL.R� RG ( R. R* RP ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
event_info� s c C s | j j | j j d d � � S( s* Return a list of all existing image names.t imaget names( R. R* RP ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt image_names� s c C s | j j | j j d d � � S( s? Return a list of all available image types (e.g. photo bitmap).R� t types( R. R* RP ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt image_types� s N( s %#s %bs %fs %hs %ks %ss %ts %ws %xs %ys %As %Es %Ks %Ns %Ws %Ts %Xs %Ys %D(� R7 R8 R9 R RW R� RX R� R� R� R� R� t waitvarR� R� R� R� R? Ry t floatR{ RO R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� t liftR� R� R� R� R� R� R� R� R� R� R� R� R� R R R R R R R R
R R R R R R R R R! R# R% R' R) R+ R- R/ R1 R3 R5 R7 R9 R> R= R? RD RF RH RJ RL RM RO R RQ RR R[ R\ R] R_ R` Ra Rb R~ Rc R Rd Re R� t propertyR� R� Ro R� R� t registerRI Rr R RV RU R� R� R� R� R� t configR� t __getitem__R� R� R� RZ R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � sP
(
9 R` c B s e Z d Z d � Z d � Z RS( sw Internal class. Stores function to call when some user
defined Tcl function is called e.g. after an event occurred.c C s | | _ | | _ | | _ d S( s( Store FUNC, SUBST and WIDGET as members.N( R� Rp R| ( RR R� Rp R| ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU s c G sb y, | j r | j | � } n | j | � SWn/ t k
rJ } t | � n | j j � n Xd S( s3 Apply first function SUBST to arguments, than FUNC.N( Rp R� RA R| R� ( RR R� R% ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRa s ( R7 R8 R9 RU Ra ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR` � s t XViewc B s) e Z d Z d � Z d � Z d � Z RS( sX Mix-in class for querying and changing the horizontal position
of a widget's window.c G s2 | j j | j d | � } | s. | j | � Sd S( s5 Query and change the horizontal position of the view.t xviewN( R. RP R� Rd ( RR R� R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� s c C s | j j | j d d | � d S( ss Adjusts the view in the window so that FRACTION of the
total width of the canvas is off-screen to the left.R� t movetoN( R. RP R� ( RR t fraction( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt xview_moveto s c C s# | j j | j d d | | � d S( s\ Shift the x-view according to NUMBER which is measured in "units"
or "pages" (WHAT).R� t scrollN( R. RP R� ( RR R� RW ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt xview_scroll! s ( R7 R8 R9 R� R� R� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� s t YViewc B s) e Z d Z d � Z d � Z d � Z RS( sV Mix-in class for querying and changing the vertical position
of a widget's window.c G s2 | j j | j d | � } | s. | j | � Sd S( s3 Query and change the vertical position of the view.t yviewN( R. RP R� Rd ( RR R� R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� + s c C s | j j | j d d | � d S( ss Adjusts the view in the window so that FRACTION of the
total height of the canvas is off-screen to the top.R� R� N( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt yview_moveto1 s c C s# | j j | j d d | | � d S( s\ Shift the y-view according to NUMBER which is measured in
"units" or "pages" (WHAT).R� R� N( R. RP R� ( RR R� RW ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt yview_scroll6 s ( R7 R8 R9 R� R� R� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� ' s t Wmc B s e Z d Z d d d d d � Z e Z d � Z e Z d d � Z e Z d � Z
e
Z d d � Z e Z
d � Z e Z d d � Z e Z d � Z e Z d d � Z e Z d d d d d
� Z e Z d d � Z e Z d d d � Z e Z d
� Z e Z d d � Z e Z d d � Z e Z! d d d � Z" e" Z# d d � Z$ e$ Z% d d d � Z& e& Z' d d d � Z( e( Z) d d � Z* e* Z+ d d � Z, e, Z- d d d � Z. e. Z/ d d d � Z0 e0 Z1 d d � Z2 e2 Z3 d d � Z4 e4 Z5 d d � Z6 e6 Z7 d d � Z8 e8 Z9 d � Z: e: Z; RS( sA Provides functions for the communication with the window manager.c C s. | j | j j d d | j | | | | � � S( s� Instruct the window manager to set the aspect ratio (width/height)
of this widget to be between MINNUMER/MINDENOM and MAXNUMER/MAXDENOM. Return a tuple
of the actual values if no argument is given.t wmt aspect( R R. RP R� ( RR t minNumert minDenomt maxNumert maxDenom( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_aspect? s c G s& d d | j f | } | j j | � S( s� This subcommand returns or sets platform specific attributes
The first form returns a list of the platform specific flags and
their values. The second form returns the value for the specific
option. The third form sets one or more of the values. The values
are as follows:
On Windows, -disabled gets or sets whether the window is in a
disabled state. -toolwindow gets or sets the style of the window
to toolwindow (as defined in the MSDN). -topmost gets or sets
whether this is a topmost window (displays above all other
windows).
On Macintosh, XXXXX
On Unix, there are currently no special attribute values.
R� t
attributes( R� R. RP ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
wm_attributesK s c C s | j j d d | j | � S( sV Store NAME in WM_CLIENT_MACHINE property of this widget. Return
current value.R� t client( R. RP R� ( RR RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_clienta s c G sy t | � d k r | f } n d d | j f | } | rM | j j | � n( t | j | j j | j j | � � � Sd S( s� Store list of window names (WLIST) into WM_COLORMAPWINDOWS property
of this widget. This list contains windows whose colormaps differ from their
parents. Return current list of widgets if WLIST is empty.i R� t colormapwindowsN( R R� R. RP R R� R* ( RR t wlistR� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_colormapwindowsf s c C s | j j d d | j | � S( s� Store VALUE in WM_COMMAND property. It is the command
which shall be used to invoke the application. Return current
command if VALUE is None.R� R� ( R. RP R� ( RR R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
wm_commandr s c C s | j j d d | j � S( s� Deiconify this widget. If it was never mapped it will not be mapped.
On Windows it will raise this widget and give it the focus.R� t deiconify( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_deiconifyx s c C s | j j d d | j | � S( s� Set focus model to MODEL. "active" means that this widget will claim
the focus itself, "passive" means that the window manager shall give
the focus. Return current focus model if MODEL is None.R� t
focusmodel( R. RP R� ( RR t model( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
wm_focusmodel} s c C s | j j d d | j � S( sA Return identifier for decorative frame of this widget if present.R� t frame( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_frame� s c C s | j j d d | j | � S( si Set geometry to NEWGEOMETRY of the form =widthxheight+x+y. Return
current value if None is given.R� R� ( R. RP R� ( RR t newGeometry( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_geometry� s c C s. | j | j j d d | j | | | | � � S( s Instruct the window manager that this widget shall only be
resized on grid boundaries. WIDTHINC and HEIGHTINC are the width and
height of a grid unit in pixels. BASEWIDTH and BASEHEIGHT are the
number of grid units requested in Tk_GeometryRequest.R� R� ( R R. RP R� ( RR t baseWidtht
baseHeightt widthInct heightInc( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_grid� s c C s | j j d d | j | � S( s~ Set the group leader widgets for related widgets to PATHNAME. Return
the group leader of this widget if None is given.R� t group( R. RP R� ( RR t pathName( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_group� s c C sE | r% | j j d d | j d | � S| j j d d | j | � Sd S( s� Set bitmap for the iconified widget to BITMAP. Return
the bitmap if None is given.
Under Windows, the DEFAULT parameter can be used to set the icon
for the widget and any descendents that don't have an icon set
explicitly. DEFAULT can be the relative path to a .ico file
(example: root.iconbitmap(default='myicon.ico') ). See Tk
documentation for more information.R� t
iconbitmaps -defaultN( R. RP R� ( RR t bitmapt default( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
wm_iconbitmap� s c C s | j j d d | j � S( s Display widget as icon.R� t iconify( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
wm_iconify� s c C s | j j d d | j | � S( sV Set mask for the icon bitmap of this widget. Return the
mask if None is given.R� t iconmask( R. RP R� ( RR R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_iconmask� s c C s | j j d d | j | � S( sS Set the name of the icon for this widget. Return the name if
None is given.R� t iconname( R. RP R� ( RR t newName( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_iconname� s c C s( | j | j j d d | j | | � � S( s� Set the position of the icon of this widget to X and Y. Return
a tuple of the current values of X and X if None is given.R� t iconposition( R R. RP R� ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_iconposition� s c C s | j j d d | j | � S( sg Set widget PATHNAME to be displayed instead of icon. Return the current
value if None is given.R� t
iconwindow( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
wm_iconwindow� s c C s( | j | j j d d | j | | � � S( s� Set max WIDTH and HEIGHT for this widget. If the window is gridded
the values are given in grid units. Return the current values if None
is given.R� t maxsize( R R. RP R� ( RR RK R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
wm_maxsize� s c C s( | j | j j d d | j | | � � S( s� Set min WIDTH and HEIGHT for this widget. If the window is gridded
the values are given in grid units. Return the current values if None
is given.R� t minsize( R R. RP R� ( RR RK R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
wm_minsize� s c C s% | j | j j d d | j | � � S( s� Instruct the window manager to ignore this widget
if BOOLEAN is given with 1. Return the current value if None
is given.R� t overrideredirect( Re R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_overrideredirect� s c C s | j j d d | j | � S( s� Instruct the window manager that the position of this widget shall
be defined by the user if WHO is "user", and by its own policy if WHO is
"program".R� t positionfrom( R. RP R� ( RR t who( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_positionfrom� s c C sF t | d � r! | j | � } n | } | j j d d | j | | � S( s� Bind function FUNC to command NAME for this widget.
Return the function bound to NAME if None is given. NAME could be
e.g. "WM_SAVE_YOURSELF" or "WM_DELETE_WINDOW".Ra R� t protocol( Rj R� R. RP R� ( RR RT R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_protocol� s
c C s | j j d d | j | | � S( sy Instruct the window manager whether this width can be resized
in WIDTH or HEIGHT. Both values are boolean values.R� t resizable( R. RP R� ( RR RK R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_resizable� s c C s | j j d d | j | � S( s� Instruct the window manager that the size of this widget shall
be defined by the user if WHO is "user", and by its own policy if WHO is
"program".R� t sizefrom( R. RP R� ( RR R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_sizefrom� s c C s | j j d d | j | � S( s� Query or set the state of this widget as one of normal, icon,
iconic (see wm_iconwindow), withdrawn, or zoomed (Windows only).R� Rv ( R. RP R� ( RR t newstate( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_state� s c C s | j j d d | j | � S( s Set the title of this widget.R� t title( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_title� s c C s | j j d d | j | � S( s_ Instruct the window manager that this widget is transient
with regard to widget MASTER.R� t transient( R. RP R� ( RR RS ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_transient� s c C s | j j d d | j � S( s� Withdraw this widget from the screen such that it is unmapped
and forgotten by the window manager. Re-draw it with wm_deiconify.R� t withdraw( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_withdraw s N(< R7 R8 R9 R R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R R� R R R R R R R R R
R R R R R R R R R R R R R R R R R R Rv R" R! R$ R# R& R% ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� < sv
t Tkc B se e Z d Z d Z d d d d d d d � Z d � Z d � Z d � Z d � Z d
� Z
d � Z RS(
sz Toplevel widget of Tk which represents mostly the main window
of an application. It has an associated Tcl interpreter.Rm R' i i c
C s� d | _ i | _ d | _ d | _ | d k r� d d l } | j j t j d � } | j j
| � \ } } | d k r� | | } q� n d } t j | | | | t
| | | � | _ | r� | j � n t j j s� | j | | � n d S( s@ Return a new Toplevel widget on screen SCREENNAME. A new Tcl interpreter will
be created. BASENAME will be used for the identification of the profile file (see
readprofile).
It is constructed from sys.argv[0] without extensions if None is given. CLASSNAME
is the name of the widget class.i i����Ns .pys .pycs .pyo( s .pys .pycs .pyo( R RS R� t _tkloadedR. t ost patht basenameR� t argvt splitextR� t createt wantobjectst _loadtkt flagst ignore_environmentt readprofile(
RR t
screenNamet baseNameR� t useTkt synct useR) t extt interactive( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU
s '
c C s' | j s# | j j � | j � n d S( N( R( R. t loadtkR0 ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR; ' s
c C s3 d | _ | j j d � } | t j k rC t d t j | f � n t | j j d � � } | t j k r� t d t j | f � n t d k r� t d t t � � n | j d k r� g | _ n | j j d t � | j j d t
� | j j d � | j j d � t r t r | a n | j d
| j � d S( Ni t
tk_versions4 tk.h version (%s) doesn't match libtk.a version (%s)t tcl_versions6 tcl.h version (%s) doesn't match libtcl.a version (%s)g @s) Tk 4.0 or higher is required; found Tk %st tkerrort exitt WM_DELETE_WINDOW( R( R. R� R� t
TK_VERSIONR+ R t TCL_VERSIONt TkVersionRW R Rd R> RC Re R: R; R R� ( RR R< R= ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR0 + s0
c C sf x! | j j � D] } | j � q W| j j d | j � t j | � t rb t | k rb d a n d S( sh Destroy this and all descendants widgets. This will
end the application of this Tcl interpreter.R� N(
R� t valuesR� R. RP R� R� R: R; R ( RR R$ ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� J s
c
B sE d d l } d | j k r+ | j d } n | j } | j j | d | � } | j j | d | � } | j j | d | � } | j j | d | � } i | d 6} d | U| j j | � r� | j j d | � n | j j | � r� e | | � n | j j | � r | j j d | � n | j j | � rAe | | � n d S( s� Internal function. It reads BASENAME.tcl and CLASSNAME.tcl into
the Tcl Interpreter and calls execfile on BASENAME.py and CLASSNAME.py if
such a file exists in the home directory.i����Nt HOMEs .%s.tcls .%s.pyRR s from Tkinter import *t source( R) t environt curdirR* R t isfileR. RP t execfile(
RR R5 R� R) t homet class_tclt class_pyt base_tclt base_pyt dir( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR3 S s$
c C sW d d l } d d l } | j d IJ| | _ | | _ | | _ | j | | | � d S( s� Report callback exception on sys.stderr.
Applications may want to override this internal function, and
should when sys.stderr is None.i����Ns Exception in Tkinter callback( t tracebackR� t stderrt last_typet
last_valuet last_tracebackt print_exception( RR R� R� R� RQ R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� h s
c C s t | j | � S( s3 Delegate attribute access to the interpreter object( t getattrR. ( RR t attr( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt __getattr__s s N( R7 R8 R9 R� R RU R; R0 R� R3 R� RY ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR' s c C s t | | | | � S( N( R' ( R4 R5 R� R6 ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt Tcl� s t Packc B s` e Z d Z i d � Z e Z Z Z d � Z e Z d � Z e Z
e j Z
Z e j Z Z RS( sQ Geometry manager Pack.
Base class to use the methods pack_* in every widget.c K s0 | j j d d | j f | j | | � � d S( s( Pack a widget in the parent widget. Use as options:
after=widget - pack it after you have packed widget
anchor=NSEW (or subset) - position widget according to
given direction
before=widget - pack it before you will pack widget
expand=bool - expand widget if parent size grows
fill=NONE or X or Y or BOTH - fill widget if widget grows
in=master - use master to contain this widget
in_=master - see 'in' option description
ipadx=amount - add internal padding in x direction
ipady=amount - add internal padding in y direction
padx=amount - add padding in x direction
pady=amount - add padding in y direction
side=TOP or BOTTOM or LEFT or RIGHT - where to add this widget.
R� R� N( R. RP R� R� ( RR R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt pack_configure� s c C s | j j d d | j � d S( s: Unmap this widget and do not use it for the packing order.R� t forgetN( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt pack_forget� s c C sQ t | j | j j d d | j � � } d | k rM | j | d � | d <n | S( sE Return information about the packing options
for this widget.R� RG t in( R5 R. RP R� Ro ( RR t d( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt pack_info� s ' ( R7 R8 R9 R\ R� R� R� R^ R] Ra RG R� R� R� R� R� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR[ � s
t Placec B sS e Z d Z i d � Z e Z Z Z d � Z e Z d � Z e Z
e j Z
Z RS( sS Geometry manager Place.
Base class to use the methods place_* in every widget.c K s0 | j j d d | j f | j | | � � d S( s Place a widget in the parent widget. Use as options:
in=master - master relative to which the widget is placed
in_=master - see 'in' option description
x=amount - locate anchor of this widget at position x of master
y=amount - locate anchor of this widget at position y of master
relx=amount - locate anchor of this widget between 0.0 and 1.0
relative to width of master (1.0 is right edge)
rely=amount - locate anchor of this widget between 0.0 and 1.0
relative to height of master (1.0 is bottom edge)
anchor=NSEW (or subset) - position anchor according to given direction
width=amount - width of this widget in pixel
height=amount - height of this widget in pixel
relwidth=amount - width of this widget between 0.0 and 1.0
relative to width of master (1.0 is the same width
as the master)
relheight=amount - height of this widget between 0.0 and 1.0
relative to height of master (1.0 is the same
height as the master)
bordermode="inside" or "outside" - whether to take border width of
master widget into account
R� R� N( R. RP R� R� ( RR R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt place_configure� s c C s | j j d d | j � d S( s Unmap this widget.R� R] N( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt place_forget� s c C sQ t | j | j j d d | j � � } d | k rM | j | d � | d <n | S( sE Return information about the placing options
for this widget.R� RG R_ ( R5 R. RP R� Ro ( RR R` ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
place_info� s ' ( R7 R8 R9 Rc R� R� R� Rd R] Re RG R� R� R� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRb � s t Gridc B s� e Z d Z i d � Z e Z Z Z e j Z Z e j
Z Z
d � Z e Z
d � Z d � Z e Z e j Z Z e j Z Z e j Z Z e j Z Z e j Z Z RS( sQ Geometry manager Grid.
Base class to use the methods grid_* in every widget.c K s0 | j j d d | j f | j | | � � d S( s Position a widget in the parent widget in a grid. Use as options:
column=number - use cell identified with given column (starting with 0)
columnspan=number - this widget will span several columns
in=master - use master to contain this widget
in_=master - see 'in' option description
ipadx=amount - add internal padding in x direction
ipady=amount - add internal padding in y direction
padx=amount - add padding in x direction
pady=amount - add padding in y direction
row=number - use cell identified with given row (starting with 0)
rowspan=number - this widget will span several rows
sticky=NSEW - if cell is larger on which sides will this
widget stick to the cell boundary
R� R� N( R. RP R� R� ( RR R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grid_configure� s c C s | j j d d | j � d S( s Unmap this widget.R� R] N( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grid_forget� s c C s | j j d d | j � d S( s0 Unmap this widget but remember the grid options.R� Rm N( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grid_remove� s c C sQ t | j | j j d d | j � � } d | k rM | j | d � | d <n | S( sS Return information about the options
for positioning this widget in a grid.R� RG R_ ( R5 R. RP R� Ro ( RR R` ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grid_info� s ' ( R7 R8 R9 Rg R� R� R� R� R� R� R� R� Rh R] Ri Rj RG R� R� R� R� R� R� R� R� R� R� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRf � s
t
BaseWidgetc B s> e Z d Z d � Z i i d d � Z d � Z d d � Z RS( s Internal class.c C s t r* | s* t s t � a n t } q* n | | _ | j | _ d } d | k re | d } | d =n | s� t t | � � } n | | _ | j d k r� d | | _ n | j d | | _ i | _
| j | j j
k r� | j j
| j j � n | | j j
| j <d S( s6 Internal function. Sets up information about children.RT Rm N( R: R; R' RS R. R RL Rb RK R� R� R� ( RR RS R# RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _setup
s*
c C s� | r t | | f � } n | | _ t j | | | � | j d k rR g | _ n g } xG | j � D]9 } t | � t k re | j | | | f � | | =qe qe W| j
j | | j f | | j
| � � x$ | D] \ } } | j | | � q� Wd S( sd Construct a widget with the parent widget MASTER, a name WIDGETNAME
and appropriate options.N( R( t
widgetNameRk Rl RW R R� R t ClassTypeRe R. RP R� R� R� ( RR RS Rm R# R� t extrat classesR& R' ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU & s !c C ss x! | j j � D] } | j � q W| j j d | j � | j | j j k rb | j j | j =n t j | � d S( s) Destroy this and all descendants widgets.R� N( R� RD R� R. RP R� RK RS R� ( RR R$ ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� 8 s c C s | j j | j | f | � S( N( R. RP R� ( RR RT R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _do? s ( ( ( R7 R8 R9 Rl RU R� Rq ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRk s
t Widgetc B s e Z d Z RS( sx Internal class.
Base class for a widget which can be positioned with the geometry managers
Pack, Place or Grid.( R7 R8 R9 ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRr C s t Toplevelc B s e Z d Z d i d � Z RS( s" Toplevel widget, e.g. for dialogs.c K s | r t | | f � } n d } xx d d d d d g D]a } | | k r7 | | } | d d k rt d | d } n
d | } | | | f } | | =q7 q7 Wt j | | d | i | � | j � } | j | j � � | j | j � � | j d
| j � d S(
s% Construct a toplevel widget with the parent MASTER.
Valid resource names: background, bd, bg, borderwidth, class,
colormap, container, cursor, height, highlightbackground,
highlightcolor, highlightthickness, menu, relief, screen, takefocus,
use, visual, width.R t class_R� R6 t colormapi����Ri R) R2 R@ N( ( R( Rk RU RI R R! R R� ( RR RS R# R� Ro t wmkeyR� t optR� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU L s"
N( R7 R8 R9 R RU ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRs J s t Buttonc B s\ e Z d Z d i d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z RS(
s Button widget.c K s t j | | d | | � d S( sU Construct a button widget with the parent MASTER.
STANDARD OPTIONS
activebackground, activeforeground, anchor,
background, bitmap, borderwidth, cursor,
disabledforeground, font, foreground
highlightbackground, highlightcolor,
highlightthickness, image, justify,
padx, pady, relief, repeatdelay,
repeatinterval, takefocus, text,
textvariable, underline, wraplength
WIDGET-SPECIFIC OPTIONS
command, compound, default, height,
overrelief, state, width
t buttonN( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU h s c G s | j j d | j � d S( Nt
tkButtonEnter( R. RP R� ( RR t dummy( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRz } s c G s | j j d | j � d S( Nt
tkButtonLeave( R. RP R� ( RR R{ ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR| � s c G s | j j d | j � d S( Nt tkButtonDown( R. RP R� ( RR R{ ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR} � s c G s | j j d | j � d S( Nt
tkButtonUp( R. RP R� ( RR R{ ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR~ � s c G s | j j d | j � d S( Nt tkButtonInvoke( R. RP R� ( RR R{ ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR � s c C s | j j | j d � d S( s_ Flash the button.
This is accomplished by redisplaying
the button several times, alternating between active and
normal colors. At the end of the flash the button is left
in the same normal/active state as when the command was
invoked. This command is ignored if the button's state is
disabled.
t flashN( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s
c C s | j j | j d � S( s Invoke the command associated with the button.
The return value is the return value from the command,
or an empty string if there is no command associated with
the button. This command is ignored if the button's state
is disabled.
t invoke( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s N( R7 R8 R9 R RU Rz R| R} R~ R R� R� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRx f s c C s d S( Nt end( ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt AtEnd� s c G s2 d } x% | D] } | r
| d | } q
q
W| S( Nt insertR ( ( R� R� t a( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt AtInsert� s
c C s d S( Ns sel.first( ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
AtSelFirst� s c C s d S( Ns sel.last( ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt AtSelLast� s c C s) | d k r d | f Sd | | f Sd S( Ns @%rs @%r,%r( R ( RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt At� s t Canvasc B sI e Z d Z d: i d � Z d � Z d � Z d � Z d � Z d: d: d � Z d � Z
d � Z d � Z d
� Z
d: d � Z d: d: d: d � Z d: d
� Z d: d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z! d � Z" d � Z# d: d: d! � Z$ d" � Z% d# � Z& d$ � Z' d% � Z( d& � Z) d' � Z* d( � Z+ d) � Z, d* � Z- d: d+ � Z. e. Z/ d, � Z0 e0 Z1 d- � Z2 i d. � Z3 d/ � Z4 e4 Z5 Z6 d0 � Z7 d1 � Z8 d2 d3 � Z9 d4 � Z: d5 � Z; d6 � Z< d7 � Z= d8 � Z> d9 � Z? RS(; s? Canvas widget to display graphical elements like lines or text.c K s t j | | d | | � d S( s Construct a canvas widget with the parent MASTER.
Valid resource names: background, bd, bg, borderwidth, closeenough,
confine, cursor, height, highlightbackground, highlightcolor,
highlightthickness, insertbackground, insertborderwidth,
insertofftime, insertontime, insertwidth, offset, relief,
scrollregion, selectbackground, selectborderwidth, selectforeground,
state, takefocus, width, xscrollcommand, xscrollincrement,
yscrollcommand, yscrollincrement.t canvasN( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU � s
c G s! | j j | j d f | � d S( s Internal function.t addtagN( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s | j | d | � d S( s* Add tag NEWTAG to all items above TAGORID.t aboveN( R� ( RR t newtagt tagOrId( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt addtag_above� s c C s | j | d � d S( s Add tag NEWTAG to all items.R^ N( R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
addtag_all� s c C s | j | d | � d S( s* Add tag NEWTAG to all items below TAGORID.t belowN( R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt addtag_below� s c C s | j | d | | | | � d S( s� Add tag NEWTAG to item which is closest to pixel at X, Y.
If several match take the top-most.
All items closer than HALO are considered overlapping (all are
closests). If START is specified the next below this tag is taken.t closestN( R� ( RR R� RA RN t halot start( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt addtag_closest� s c C s | j | d | | | | � d S( sL Add tag NEWTAG to all items in the rectangle defined
by X1,Y1,X2,Y2.t enclosedN( R� ( RR R� t x1t y1t x2t y2( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt addtag_enclosed� s c C s | j | d | | | | � d S( sW Add tag NEWTAG to all items which overlap the rectangle
defined by X1,Y1,X2,Y2.t overlappingN( R� ( RR R� R� R� R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt addtag_overlapping� s c C s | j | d | � d S( s) Add tag NEWTAG to all items with TAGORID.t withtagN( R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt addtag_withtag� s c G s, | j | j j | j d f | � � p+ d S( s| Return a tuple of X1,Y1,X2,Y2 coordinates for a rectangle
which encloses all items with tags specified as arguments.R� N( R R. RP R� R ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s9 | j j | j d | | d � | r5 | j | � n d S( sb Unbind for all items with TAGORID for event SEQUENCE the
function identified with FUNCID.R\ RE N( R. RP R� RX ( RR R� RX RZ ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
tag_unbind� s c C s" | j | j d | f | | | � S( s& Bind to all items with TAGORID at event SEQUENCE a call to function FUNC.
An additional boolean parameter ADD specifies whether FUNC will be
called additionally to the other bound function or whether it will
replace the previous function. See bind for the return value.R\ ( R[ R� ( RR R� RX R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt tag_bind� s c C s" t | j j | j d | | � � S( sr Return the canvas x coordinate of pixel position SCREENX rounded
to nearest multiple of GRIDSPACING units.t canvasx( R{ R. RP R� ( RR t screenxt gridspacing( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s" t | j j | j d | | � � S( sr Return the canvas y coordinate of pixel position SCREENY rounded
to nearest multiple of GRIDSPACING units.t canvasy( R{ R. RP R� ( RR t screenyR� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c G s2 t t | j j | j j | j d f | � � � S( s8 Return a list of coordinates for the item given in ARGS.t coords( R R{ R. R* RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C ss t | � } | d } t | � t t f k r; | d } n i } t | j j | j d | | | j | | � � � S( s Internal function.i����R. ( R R R R Ry R. RP R� R� ( RR t itemTypeR� R� R# ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _create s
c O s | j d | | � S( s6 Create arc shaped region with coordinates x1,y1,x2,y2.t arc( R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
create_arc
s c O s | j d | | � S( s% Create bitmap with coordinates x1,y1.R ( R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
create_bitmap s c O s | j d | | � S( s) Create image item with coordinates x1,y1.R� ( R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt create_image s c O s | j d | | � S( s- Create line with coordinates x1,y1,...,xn,yn.t line( R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt create_line s c O s | j d | | � S( s) Create oval with coordinates x1,y1,x2,y2.t oval( R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt create_oval s c O s | j d | | � S( s0 Create polygon with coordinates x1,y1,...,xn,yn.t polygon( R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt create_polygon s c O s | j d | | � S( s. Create rectangle with coordinates x1,y1,x2,y2.t rectangle( R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt create_rectangle s c O s | j d | | � S( s# Create text with coordinates x1,y1.t text( R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt create_text" s c O s | j d | | � S( s+ Create window with coordinates x1,y1,x2,y2.R� ( R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
create_window% s c G s! | j j | j d f | � d S( s� Delete characters of text items identified by tag or id in ARGS (possibly
several times) from FIRST to LAST character (including).t dcharsN( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� ( s c G s! | j j | j d f | � d S( s< Delete items identified by all tag or ids contained in ARGS.R� N( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� , s c G s! | j j | j d f | � d S( si Delete tag or id given as last arguments in ARGS from items
identified by first argument in ARGS.t dtagN( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� / s c G s, | j | j j | j d f | � � p+ d S( s Internal function.t find( ( R R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� 3 s c C s | j d | � S( s Return items above TAGORID.R� ( R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
find_above7 s c C s
| j d � S( s Return all items.R^ ( R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt find_all: s c C s | j d | � S( s Return all items below TAGORID.R� ( R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
find_below= s c C s | j d | | | | � S( s� Return item which is closest to pixel at X, Y.
If several match take the top-most.
All items closer than HALO are considered overlapping (all are
closest). If START is specified the next below this tag is taken.R� ( R� ( RR RA RN R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt find_closest@ s c C s | j d | | | | � S( s= Return all items in rectangle defined
by X1,Y1,X2,Y2.R� ( R� ( RR R� R� R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
find_enclosedF s c C s | j d | | | | � S( sL Return all items which overlap the rectangle
defined by X1,Y1,X2,Y2.R� ( R� ( RR R� R� R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt find_overlappingJ s c C s | j d | � S( s Return all items with TAGORID.R� ( R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt find_withtagN s c G s | j j | j d f | � S( s. Set focus to the first item specified in ARGS.R� ( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� Q s c G s) | j j | j j | j d f | � � S( s= Return tags associated with the first item specified in ARGS.t gettags( R. R* RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� T s c G s! | j j | j d f | � d S( sd Set cursor at position POS in the item identified by TAGORID.
In ARGS TAGORID must be first.t icursorN( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� X s c G s# t | j j | j d f | � � S( s? Return position of cursor as integer in item specified in ARGS.R� ( Ry R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� \ s c G s! | j j | j d f | � d S( sS Insert TEXT in item TAGORID at position POS. ARGS must
be TAGORID POS TEXT.R� N( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� _ s c C s' | j j | j d f | d | f � S( s9 Return the resource value for an OPTION for item TAGORID.t itemcgetR) ( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� c s c K s | j d | f | | � S( s� Configure resources of an item TAGORID.
The values for resources are specified as keyword
arguments. To get an overview about
the allowed keyword arguments call the method without arguments.
t
itemconfigure( R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� g s c G s! | j j | j d f | � d S( sJ Lower an item TAGORID given in ARGS
(optional below another item).R� N( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt tag_lowert s c G s! | j j | j d f | � d S( s# Move an item TAGORID given in ARGS.t moveN( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� y s c K s) | j j | j d f | j | | � � S( s� Print the contents of the canvas to a postscript
file. Valid options: colormap, colormode, file, fontmap,
height, pageanchor, pageheight, pagewidth, pagex, pagey,
rotate, width, x, y.t
postscript( R. RP R� R� ( RR R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� | s c G s! | j j | j d f | � d S( sJ Raise an item TAGORID given in ARGS
(optional above another item).R� N( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt tag_raise� s c G s! | j j | j d f | � d S( s9 Scale item TAGORID with XORIGIN, YORIGIN, XSCALE, YSCALE.t scaleN( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s# | j j | j d d | | � d S( s& Remember the current X, Y coordinates.t scant markN( R. RP R� ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt scan_mark� s i
c C s& | j j | j d d | | | � d S( s� Adjust the view of the canvas to GAIN times the
difference between X and Y and the coordinates given in
scan_mark.R� t dragtoN( R. RP R� ( RR RA RN t gain( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt scan_dragto� s c C s# | j j | j d d | | � d S( sL Adjust the end of the selection near the cursor of an item TAGORID to index.t selectt adjustN( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
select_adjust� s c C s | j j | j d d � d S( s, Clear the selection if it is in this widget.R� R� N( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt select_clear� s c C s# | j j | j d d | | � d S( s: Set the fixed end of a selection in item TAGORID to INDEX.R� t fromN( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt select_from� s c C s | j j | j d d � p d S( s( Return the item which has the selection.R� R N( R. RP R� R ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt select_item� s c C s# | j j | j d d | | � d S( s= Set the variable end of a selection in item TAGORID to INDEX.R� t toN( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt select_to� s c C s | j j | j d | � p d S( s$ Return the type of the item TAGORID.R N( R. RP R� R ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR � s N(@ R7 R8 R9 R RU R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� t
itemconfigR� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � sx
t Checkbuttonc B sJ e Z d Z d i d � Z d � Z d � Z d � Z d � Z d � Z RS( s7 Checkbutton widget which is either in on- or off-state.c K s t j | | d | | � d S( s Construct a checkbutton widget with the parent MASTER.
Valid resource names: activebackground, activeforeground, anchor,
background, bd, bg, bitmap, borderwidth, command, cursor,
disabledforeground, fg, font, foreground, height,
highlightbackground, highlightcolor, highlightthickness, image,
indicatoron, justify, offvalue, onvalue, padx, pady, relief,
selectcolor, selectimage, state, takefocus, text, textvariable,
underline, variable, width, wraplength.t checkbuttonN( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU � s
c C s | j j | j d � d S( s Put the button in off-state.t deselectN( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s | j j | j d � d S( s Flash the button.R� N( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s | j j | j d � S( s< Toggle the button and invoke a command if given as resource.R� ( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s | j j | j d � d S( s Put the button in on-state.R� N( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s | j j | j d � d S( s Toggle the button.t toggleN( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s N(
R7 R8 R9 R RU R� R� R� R� R� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s t Entryc B s� e Z d Z d i d � Z d d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d � Z e Z
d
� Z e Z d � Z e Z d � Z e Z d
� Z e Z d � Z e Z RS( s1 Entry widget which allows displaying simple text.c K s t j | | d | | � d S( s Construct an entry widget with the parent MASTER.
Valid resource names: background, bd, bg, borderwidth, cursor,
exportselection, fg, font, foreground, highlightbackground,
highlightcolor, highlightthickness, insertbackground,
insertborderwidth, insertofftime, insertontime, insertwidth,
invalidcommand, invcmd, justify, relief, selectbackground,
selectborderwidth, selectforeground, show, state, takefocus,
textvariable, validate, validatecommand, vcmd, width,
xscrollcommand.t entryN( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU � s c C s | j j | j d | | � d S( s. Delete text from FIRST to LAST (not included).R� N( R. RP R� ( RR t firstt last( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s | j j | j d � S( s Return the text.R] ( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR] � s c C s | j j | j d | � d S( s Insert cursor at INDEX.R� N( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s t | j j | j d | � � S( s Return position of cursor.R� ( Ry R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s | j j | j d | | � d S( s Insert STRING at INDEX.R� N( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s | j j | j d d | � d S( s& Remember the current X, Y coordinates.R� R� N( R. RP R� ( RR RA ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s | j j | j d d | � d S( s� Adjust the view of the canvas to 10 times the
difference between X and Y and the coordinates given in
scan_mark.R� R� N( R. RP R� ( RR RA ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s | j j | j d d | � d S( s9 Adjust the end of the selection near the cursor to INDEX.R� R� N( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt selection_adjust� s c C s | j j | j d d � d S( s, Clear the selection if it is in this widget.R� R� N( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s | j j | j d d | � d S( s* Set the fixed end of a selection to INDEX.R� R� N( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt selection_from� s c C s% | j j | j j | j d d � � S( sS Return True if there are characters selected in the entry, False
otherwise.R� t present( R. RO RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt selection_present� s c C s# | j j | j d d | | � d S( s3 Set the selection from START to END (not included).R� t rangeN( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt selection_range� s c C s | j j | j d d | � d S( s- Set the variable end of a selection to INDEX.R� R� N( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt selection_to� s N( R7 R8 R9 R RU R� R] R� R� R� R� R� R� R� R� R� R� R� R� t select_presentR� t select_rangeR� R� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s* t Framec B s e Z d Z d i d � Z RS( sF Frame widget which may contain other widgets and can have a 3D border.c K s� t | | f � } d } d | k r> d | d f } | d =n& d | k rd d | d f } | d =n t j | | d | i | � d S( s Construct a frame widget with the parent MASTER.
Valid resource names: background, bd, bg, borderwidth, class,
colormap, container, cursor, height, highlightbackground,
highlightcolor, highlightthickness, relief, takefocus, visual, width.Rt s -classR� R� N( ( R( Rr RU ( RR RS R# R� Ro ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU
s
N( R7 R8 R9 R RU ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR�
s t Labelc B s e Z d Z d i d � Z RS( s0 Label widget which can display text and bitmaps.c K s t j | | d | | � d S( s� Construct a label widget with the parent MASTER.
STANDARD OPTIONS
activebackground, activeforeground, anchor,
background, bitmap, borderwidth, cursor,
disabledforeground, font, foreground,
highlightbackground, highlightcolor,
highlightthickness, image, justify,
padx, pady, relief, takefocus, text,
textvariable, underline, wraplength
WIDGET-SPECIFIC OPTIONS
height, state, width
t labelN( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU
s N( R7 R8 R9 R RU ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR�
s t Listboxc B s� e Z d Z d i d � Z d � Z d � Z d � Z d d � Z d d � Z d � Z
d � Z d � Z d
� Z
d � Z d � Z d
� Z e Z d d � Z e Z d � Z e Z d d � Z e Z d � Z d � Z d d � Z e Z RS( s3 Listbox widget which can display a list of strings.c K s t j | | d | | � d S( s� Construct a listbox widget with the parent MASTER.
Valid resource names: background, bd, bg, borderwidth, cursor,
exportselection, fg, font, foreground, height, highlightbackground,
highlightcolor, highlightthickness, relief, selectbackground,
selectborderwidth, selectforeground, selectmode, setgrid, takefocus,
width, xscrollcommand, yscrollcommand, listvariable.t listboxN( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU .
s c C s | j j | j d | � d S( s" Activate item identified by INDEX.t activateN( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� 7
s c C s( | j | j j | j d | � � p' d S( sx Return a tuple of X1,Y1,X2,Y2 coordinates for a rectangle
which encloses the item identified by the given index.R� N( R R. RP R� R ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� :
s c C s% | j | j j | j d � � p$ d S( s. Return the indices of currently selected item.t curselection( ( R R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� >
s c C s | j j | j d | | � d S( s+ Delete items from FIRST to LAST (included).R� N( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� A
s c C sQ | d k r4 | j j | j j | j d | | � � S| j j | j d | � Sd S( s0 Get list of items from FIRST to LAST (included).R] N( R R. R* RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR] D
s c C s5 | j j | j d | � } | d k r+ d St | � S( s+ Return index of item identified with INDEX.R� R� N( R. RP R� R Ry ( RR R� t i( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� K
s c G s$ | j j | j d | f | � d S( s Insert ELEMENTS at INDEX.R� N( R. RP R� ( RR R� t elements( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� P
s c C s t | j j | j d | � � S( s5 Get index of item which is nearest to y coordinate Y.t nearest( Ry R. RP R� ( RR RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� S
s c C s# | j j | j d d | | � d S( s& Remember the current X, Y coordinates.R� R� N( R. RP R� ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� W
s c C s# | j j | j d d | | � d S( s� Adjust the view of the listbox to 10 times the
difference between X and Y and the coordinates given in
scan_mark.R� R� N( R. RP R� ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� Z
s c C s | j j | j d | � d S( s" Scroll such that INDEX is visible.t seeN( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� _
s c C s | j j | j d d | � d S( s- Set the fixed end oft the selection to INDEX.R� t anchorN( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt selection_anchorb
s c C s# | j j | j d d | | � d S( s2 Clear the selection from FIRST to LAST (included).R� R� N( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� f
s c C s( | j j | j j | j d d | � � S( s+ Return 1 if INDEX is part of the selection.R� t includes( R. RO RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt selection_includesk
s c C s# | j j | j d d | | � d S( si Set the selection from FIRST to LAST (included) without
changing the currently selected elements.R� RN N( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
selection_setp
s c C s t | j j | j d � � S( s- Return the number of elements in the listbox.R� ( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� u
s c C s' | j j | j d f | d | f � S( s4 Return the resource value for an ITEM and an OPTION.R� R) ( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� x
s c K s | j d | f | | � S( s9 Configure resources of an ITEM.
The values for resources are specified as keyword arguments.
To get an overview about the allowed keyword arguments
call the method without arguments.
Valid resource names: background, bg, foreground, fg,
selectbackground, selectforeground.R� ( R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� |
s N( R7 R8 R9 R RU R� R� R� R� R] R� R� R� R� R� R� R� t
select_anchorR� R� R� t select_includesR� t
select_setR� R� R� R� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� ,
s2 t Menuc B s� e Z d Z d% i d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d � Z d
� Z
d � Z d � Z d
d � Z d � Z i d � Z i d � Z i d � Z i d � Z i d � Z i d � Z i d � Z i d � Z i d � Z i d � Z i d � Z i d � Z d% d � Z d � Z d% d � Z e Z! d � Z" d � Z# d! � Z$ d" � Z% d# � Z& d$ � Z' RS(& sP Menu widget which allows displaying menu bars, pull-down menus and pop-up menus.c K s t j | | d | | � d S( sA Construct menu widget with the parent MASTER.
Valid resource names: activebackground, activeborderwidth,
activeforeground, background, bd, bg, borderwidth, cursor,
disabledforeground, fg, font, foreground, postcommand, relief,
selectcolor, takefocus, tearoff, tearoffcommand, title, type.t menuN( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU �
s c C s& d d l } | j d t d d �d S( Ni����s= tk_bindForTraversal() does nothing and will be removed in 3.6R� i ( R� R� R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt tk_bindForTraversal�
s c C s | j j d | j � d S( Nt tk_mbPost( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR �
s c C s | j j d � d S( Nt tk_mbUnpost( R. RP ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR �
s c C s | j j d | j | � d S( Nt tk_traverseToMenu( R. RP R� ( RR Rx ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR �
s c C s | j j d | j | � d S( Nt tk_traverseWithinMenu( R. RP R� ( RR Rx ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR �
s c C s | j j d | j � S( Nt tk_getMenuButtons( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR �
s c C s | j j d | � d S( Nt tk_nextMenu( R. RP ( RR t count( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR
�
s c C s | j j d | � d S( Nt tk_nextMenuEntry( R. RP ( RR R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR �
s c C s | j j d | j � d S( Nt
tk_invokeMenu( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR
�
s c C s | j j d | j � d S( Nt tk_firstMenu( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR �
s c C s | j j d | j � d S( Nt tk_mbButtonDown( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR �
s RE c C s# | j j d | j | | | � d S( s/ Post the menu at position X,Y with entry ENTRY.t tk_popupN( R. RP R� ( RR RA RN R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR �
s c C s | j j | j d | � d S( s Activate entry at INDEX.R� N( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c K s0 | j j | j d | f | j | | � � d S( s Internal function.R� N( R. RP R� R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c K s | j d | p | � d S( s Add hierarchical menu item.t cascadeN( R� ( RR R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt add_cascade�
s c K s | j d | p | � d S( s Add checkbutton menu item.R� N( R� ( RR R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt add_checkbutton�
s c K s | j d | p | � d S( s Add command menu item.R� N( R� ( RR R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt add_command�
s c K s | j d | p | � d S( s Addd radio menu item.t radiobuttonN( R� ( RR R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt add_radiobutton�
s c K s | j d | p | � d S( s Add separator.t separatorN( R� ( RR R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
add_separator�
s c K s3 | j j | j d | | f | j | | � � d S( s Internal function.R� N( R. RP R� R� ( RR R� R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c K s | j | d | p | � d S( s$ Add hierarchical menu item at INDEX.R N( R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt insert_cascade�
s c K s | j | d | p | � d S( s# Add checkbutton menu item at INDEX.R� N( R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt insert_checkbutton�
s c K s | j | d | p | � d S( s Add command menu item at INDEX.R� N( R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt insert_command�
s c K s | j | d | p | � d S( s Addd radio menu item at INDEX.R N( R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt insert_radiobutton�
s c K s | j | d | p | � d S( s Add separator at INDEX.R N( R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt insert_separator�
s c C s� | d k r | } n | j | � | j | � } } | d k sL | d k r[ d \ } } n xa t | | d � D]L } d | j | � k ro t | j | d � � } | r� | j | � q� qo qo W| j j | j d | | � d S( s7 Delete menu items between INDEX1 and INDEX2 (included).i i����i R� R� N( i i����(
R R� R� t entryconfigR t entrycgetRX R. RP R� ( RR t index1t index2t
num_index1t
num_index2R� R$ ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c C s | j j | j d | d | � S( s= Return the resource value of a menu item for OPTION at INDEX.R R) ( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR �
s c K s | j d | f | | � S( s Configure a menu item at INDEX.t entryconfigure( R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR$ �
s c C s5 | j j | j d | � } | d k r+ d St | � S( s4 Return the index of a menu item identified by INDEX.R� R� N( R. RP R� R Ry ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c C s | j j | j d | � S( sR Invoke a menu item identified by INDEX and execute
the associated command.R� ( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c C s | j j | j d | | � d S( s Display a menu at position X,Y.t postN( R. RP R� ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR% �
s c C s | j j | j d | � S( s* Return the type of the menu item at INDEX.R ( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR �
s c C s | j j | j d � d S( s
Unmap a menu.t unpostN( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR& �
s c C s t | j j | j d | � � S( sE Return the y-position of the topmost pixel of the menu item at INDEX.t yposition( Ry R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR' �
s N(( R7 R8 R9 R RU R R R R R R R
R R
R R R R� R� R R R R R R� R R R R R R� R R$ R R� R� R% R R& R' ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR �
sJ t
Menubuttonc B s e Z d Z d i d � Z RS( s( Menubutton widget, obsolete since Tk8.0.c K s t j | | d | | � d S( Nt
menubutton( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU s N( R7 R8 R9 R RU ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR( s t Messagec B s e Z d Z d i d � Z RS( sK Message widget to display multiline text. Obsolete since Label does it too.c K s t j | | d | | � d S( Nt message( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU s N( R7 R8 R9 R RU ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR* s t Radiobuttonc B sA e Z d Z d i d � Z d � Z d � Z d � Z d � Z RS( sG Radiobutton widget which shows only one of several buttons in on-state.c K s t j | | d | | � d S( s� Construct a radiobutton widget with the parent MASTER.
Valid resource names: activebackground, activeforeground, anchor,
background, bd, bg, bitmap, borderwidth, command, cursor,
disabledforeground, fg, font, foreground, height,
highlightbackground, highlightcolor, highlightthickness, image,
indicatoron, justify, padx, pady, relief, selectcolor, selectimage,
state, takefocus, text, textvariable, underline, value, variable,
width, wraplength.R N( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU s
c C s | j j | j d � d S( s Put the button in off-state.R� N( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� s c C s | j j | j d � d S( s Flash the button.R� N( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� s c C s | j j | j d � S( s< Toggle the button and invoke a command if given as resource.R� ( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� " s c C s | j j | j d � d S( s Put the button in on-state.R� N( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� % s N( R7 R8 R9 R RU R� R� R� R� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR, s t Scalec B sD e Z d Z d i d � Z d � Z d � Z d d � Z d � Z RS( s1 Scale widget which can display a numerical scale.c K s t j | | d | | � d S( s� Construct a scale widget with the parent MASTER.
Valid resource names: activebackground, background, bigincrement, bd,
bg, borderwidth, command, cursor, digits, fg, font, foreground, from,
highlightbackground, highlightcolor, highlightthickness, label,
length, orient, relief, repeatdelay, repeatinterval, resolution,
showvalue, sliderlength, sliderrelief, state, takefocus,
tickinterval, to, troughcolor, variable, width.R� N( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU + s c C sE | j j | j d � } y t | � SWn t k
r@ t | � SXd S( s* Get the current value as integer or float.R] N( R. RP R� Ry R@ R{ ( RR R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR] 5 s
c C s | j j | j d | � d S( s Set the value to VALUE.RN N( R. RP R� ( RR R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRN < s c C s" | j | j j | j d | � � S( s� Return a tuple (X,Y) of the point along the centerline of the
trough that corresponds to VALUE or the current value if None is
given.R� ( R R. RP R� ( RR R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� ? s c C s | j j | j d | | � S( sc Return where the point X,Y lies. Valid return values are "slider",
"though1" and "though2".t identify( R. RP R� ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR. E s N( R7 R8 R9 R RU R] RN R� R. ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR- ) s
t Scrollbarc B sS e Z d Z d i d � Z d � Z d � Z d � Z d � Z d � Z d � Z
RS( s? Scrollbar widget which displays a slider at a certain position.c K s t j | | d | | � d S( sl Construct a scrollbar widget with the parent MASTER.
Valid resource names: activebackground, activerelief,
background, bd, bg, borderwidth, command, cursor,
elementborderwidth, highlightbackground,
highlightcolor, highlightthickness, jump, orient,
relief, repeatdelay, repeatinterval, takefocus,
troughcolor, width.t scrollbarN( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU L s c C s | j j | j d | � d S( sx Display the element at INDEX with activebackground and activerelief.
INDEX can be "arrow1","slider" or "arrow2".R� N( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� V s c C s" t | j j | j d | | � � S( sn Return the fractional change of the scrollbar setting if it
would be moved by DELTAX or DELTAY pixels.R ( R{ R. RP R� ( RR t deltaxt deltay( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR Z s c C s" t | j j | j d | | � � S( sR Return the fractional value which corresponds to a slider
position of X,Y.R� ( R{ R. RP R� ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� _ s c C s | j j | j d | | � S( sY Return the element under position X,Y as one of
"arrow1","slider","arrow2" or "".R. ( R. RP R� ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR. c s c C s | j | j j | j d � � S( sZ Return the current fractional values (upper and lower end)
of the slider position.R] ( Rd R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR] g s c G s! | j j | j d f | � d S( si Set the fractional values of the slider position (upper and
lower ends as value between 0 and 1).RN N( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRN k s N( R7 R8 R9 R RU R� R R� R. R] RN ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR/ J s
t Textc B sH e Z d Z d5 i d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d5 d � Z d5 d � Z d
� Z
d5 d5 d � Z d � Z d5 d
� Z d � Z d � Z d � Z d � Z d5 d � Z d � Z d5 d � Z i d � Z d � Z d � Z d � Z d5 d � Z d � Z d � Z d � Z d � Z d � Z! d � Z" d � Z# d5 d5 d5 d5 d5 d5 d5 d5 d! � Z$ d" � Z% d# � Z& d5 d$ � Z' d5 d% � Z( d& � Z) d5 d' � Z* e* Z+ d( � Z, d5 d) � Z- d5 d* � Z. d5 d+ � Z/ d5 d, � Z0 d5 d- � Z1 d. � Z2 d5 d/ � Z3 d0 � Z4 d5 d1 � Z5 e5 Z6 i d2 � Z7 d3 � Z8 d4 � Z9 RS(6 s4 Text widget which can display text in various forms.c K s t j | | d | | � d S( s� Construct a text widget with the parent MASTER.
STANDARD OPTIONS
background, borderwidth, cursor,
exportselection, font, foreground,
highlightbackground, highlightcolor,
highlightthickness, insertbackground,
insertborderwidth, insertofftime,
insertontime, insertwidth, padx, pady,
relief, selectbackground,
selectborderwidth, selectforeground,
setgrid, takefocus,
xscrollcommand, yscrollcommand,
WIDGET-SPECIFIC OPTIONS
autoseparators, height, maxundo,
spacing1, spacing2, spacing3,
state, tabs, undo, width, wrap,
R� N( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU t s c G s, | j | j j | j d f | � � p+ d S( s� Return a tuple of (x,y,width,height) which gives the bounding
box of the visible part of the character at the index in ARGS.R� N( R R. RP R� R ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s | j j d | j | � d S( Nt tk_textSelectTo( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR4 � s c C s | j j d | j � d S( Nt tk_textBackspace( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR5 � s c C s# | j j d | j | | | � d S( Nt tk_textIndexCloser( R. RP R� ( RR R� R� R$ ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR6 � s c C s | j j d | j | � d S( Nt tk_textResetAnchor( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR7 � s c C s+ | j j | j j | j d | | | � � S( s� Return whether between index INDEX1 and index INDEX2 the
relation OP is satisfied. OP is one of <, <=, ==, >=, >, or !=.t compare( R. RO RP R� ( RR R t opR! ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR8 � s c C sK | d k r. | j j | j j | j d � � S| j j | j d | � d S( sj Turn on the internal consistency checks of the B-Tree inside the text
widget according to BOOLEAN.t debugN( R R. RO RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR: � s "c C s | j j | j d | | � d S( s? Delete the characters between INDEX1 and INDEX2 (not included).R� N( R. RP R� ( RR R R! ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s" | j | j j | j d | � � S( s� Return tuple (x,y,width,height,baseline) giving the bounding box
and baseline position of the visible part of the line containing
the character at INDEX.t dlineinfo( R R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR; � s c
K s� g } d } d } | s3 g } | d � } | } n z� t | t � s[ | j | � } } n | d | g 7} x, | D]$ } | | rr | j d | � qr qr W| j | � | r� | j | � n | j j | j d | � | SWd | r� | j | � n Xd S( s� Return the contents of the widget between index1 and index2.
The type of contents returned in filtered based on the keyword
parameters; if 'all', 'image', 'mark', 'tag', 'text', or 'window' are
given and true, then the corresponding items are returned. The result
is a list of triples of the form (key, value, index). If none of the
keywords are true then 'all' is used by default.
If the 'command' argument is given, it is called once for each element
of the list of triples, with the values of each triple serving as the
arguments to the function. In this case the list is not returned.c S s | j | | | f � d S( N( Re ( R4 R R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
append_triple� s s -commandR) t dumpN( R R R R� Re R. RP R� RX (
RR R R! R� R� R� t func_nameR� R< R4 ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR= � s*
c G s | j j | j d | � S( sr Internal method
This method controls the undo mechanism and
the modified flag. The exact behavior of the
command depends on the option argument that
follows the edit argument. The following forms
of the command are currently supported:
edit_modified, edit_redo, edit_reset, edit_separator
and edit_undo
t edit( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR? � s
c C s | j d | � S( s; Get or Set the modified flag
If arg is not specified, returns the modified
flag of the widget. The insert, delete, edit undo and
edit redo commands or the user can set or clear the
modified flag. If boolean is specified, sets the
modified flag of the widget to arg.
t modified( R? ( RR t arg( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
edit_modified� s c C s
| j d � S( s Redo the last undone edit
When the undo option is true, reapplies the last
undone edits provided no other edits were done since
then. Generates an error when the redo stack is empty.
Does nothing when the undo option is false.
t redo( R? ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt edit_redo� s c C s
| j d � S( s( Clears the undo and redo stacks
t reset( R? ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
edit_reset� s c C s
| j d � S( sn Inserts a separator (boundary) on the undo stack.
Does nothing when the undo option is false
R ( R? ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt edit_separator� s c C s
| j d � S( sD Undoes the last edit action
If the undo option is true. An edit action is defined
as all the insert and delete commands that are recorded
on the undo stack in between two separators. Generates
an error when the undo stack is empty. Does nothing
when the undo option is false
t undo( R? ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt edit_undo s c C s | j j | j d | | � S( s5 Return the text from INDEX1 to INDEX2 (not included).R] ( R. RP R� ( RR R R! ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR] s c C sY | d d k r d | } n | d d k r: | d } n | j j | j d d | | � S( s9 Return the value of OPTION of an embedded image at INDEX.i R) i����Ri R� R� ( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
image_cget s
c K s | j d d | f | | � S( s% Configure an embedded image at INDEX.R� R� ( R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt image_configure s c K s+ | j j | j d d | | j | | � � S( s" Create an embedded image at INDEX.R� R. ( R. RP R� R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt image_create s c C s | j j | j d d � S( s3 Return all names of embedded images in this widget.R� R� ( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� " s c C s t | j j | j d | � � S( s1 Return the index in the form line.char for INDEX.R� ( R R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� % s c G s' | j j | j d | | f | � d S( s� Insert CHARS before the characters at INDEX. An additional
tag can be given in ARGS. Additional CHARS and tags can follow in ARGS.R� N( R. RP R� ( RR R� t charsR� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� ( s c C s" | j j | j d d | | f � S( s� Change the gravity of a mark MARKNAME to DIRECTION (LEFT or RIGHT).
Return the current value if None is given for DIRECTION.R� t gravity( R. RP R� ( RR t markNamet direction( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt mark_gravity, s c C s% | j j | j j | j d d � � S( s Return all mark names.R� R� ( R. R* RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
mark_names1 s c C s# | j j | j d d | | � d S( s0 Set mark MARKNAME before the character at INDEX.R� RN N( R. RP R� ( RR RO R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt mark_set5 s c G s$ | j j | j d d f | � d S( s Delete all marks in MARKNAMES.R� t unsetN( R. RP R� ( RR t markNames( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
mark_unset8 s c C s" | j j | j d d | � p! d S( s- Return the name of the next mark after INDEX.R� t nextN( R. RP R� R ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt mark_next; s c C s" | j j | j d d | � p! d S( s2 Return the name of the previous mark before INDEX.R� t previousN( R. RP R� R ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
mark_previous> s c C s# | j j | j d d | | � d S( s& Remember the current X, Y coordinates.R� R� N( R. RP R� ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� A s c C s# | j j | j d d | | � d S( s~ Adjust the view of the text to 10 times the
difference between X and Y and the coordinates given in
scan_mark.R� R� N( R. RP R� ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� D s c C s( | j d g } | r% | j d � n | r; | j d � n | rQ | j d � n | rg | j d � n | r} | j d � n |
r� | j d � n | r� | j d � | j | � n | r� | d d
k r� | j d � n | j | � | j | � | r | j | � n t | j j t | � � � S( s� Search PATTERN beginning from INDEX until STOPINDEX.
Return the index of the first character of a match or an
empty string.R s -forwardss
-backwardss -exacts -regexps -nocases -elides -counti R) s --( R� Re R R. RP R ( RR R� R� t stopindext forwardst backwardst exactt regexpt nocaseR t elideR� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR I s.
c C s | j j | j d | � d S( s3 Scroll such that the character at INDEX is visible.R� N( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� \ s c G s* | j j | j d d | | f | � d S( s| Add tag TAGNAME to all characters between INDEX1 and index2 in ARGS.
Additional pairs of indices may follow in ARGS.t tagR� N( R. RP R� ( RR t tagNameR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt tag_add_ s c C s< | j j | j d d | | d � | r8 | j | � n d S( sg Unbind for all characters with TAGNAME for event SEQUENCE the
function identified with FUNCID.Rb R\ RE N( R. RP R� RX ( RR Rc RX RZ ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� d s "c C s% | j | j d d | f | | | � S( s+ Bind to all characters with TAGNAME at event SEQUENCE a call to function FUNC.
An additional boolean parameter ADD specifies whether FUNC will be
called additionally to the other bound function or whether it will
replace the previous function. See bind for the return value.Rb R\ ( R[ R� ( RR Rc RX R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� j s c C sY | d d k r d | } n | d d k r: | d } n | j j | j d d | | � S( s+ Return the value of OPTION for tag TAGNAME.i R) i����Ri Rb R� ( R. RP R� ( RR Rc R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt tag_cgetr s
c K s | j d d | f | | � S( s Configure a tag TAGNAME.Rb R� ( R� ( RR Rc R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
tag_configurey s c G s$ | j j | j d d f | � d S( s Delete all tags in TAGNAMES.Rb R� N( R. RP R� ( RR t tagNames( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
tag_delete} s c C s# | j j | j d d | | � d S( s` Change the priority of tag TAGNAME such that it is lower
than the priority of BELOWTHIS.Rb R� N( R. RP R� ( RR Rc R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s( | j j | j j | j d d | � � S( s Return a list of all tag names.Rb R� ( R. R* RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt tag_names� s c C s. | j j | j j | j d d | | | � � S( s� Return a list of start and end index for the first sequence of
characters between INDEX1 and INDEX2 which all have tag TAGNAME.
The text is searched forward from INDEX1.Rb t nextrange( R. R* RP R� ( RR Rc R R! ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
tag_nextrange� s c C s. | j j | j j | j d d | | | � � S( s� Return a list of start and end index for the first sequence of
characters between INDEX1 and INDEX2 which all have tag TAGNAME.
The text is searched backwards from INDEX1.Rb t prevrange( R. R* RP R� ( RR Rc R R! ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
tag_prevrange� s c C s# | j j | j d d | | � d S( sa Change the priority of tag TAGNAME such that it is higher
than the priority of ABOVETHIS.Rb R� N( R. RP R� ( RR Rc R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s( | j j | j j | j d d | � � S( s7 Return a list of ranges of text which have tag TAGNAME.Rb t ranges( R. R* RP R� ( RR Rc ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
tag_ranges� s c C s& | j j | j d d | | | � d S( sA Remove tag TAGNAME from all characters between INDEX1 and INDEX2.Rb Rm N( R. RP R� ( RR Rc R R! ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
tag_remove� s c C sY | d d k r d | } n | d d k r: | d } n | j j | j d d | | � S( s: Return the value of OPTION of an embedded window at INDEX.i R) i����Ri R� R� ( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt window_cget� s
c K s | j d d | f | | � S( s& Configure an embedded window at INDEX.R� R� ( R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt window_configure� s c K s3 | j j | j d d | f | j | | � � d S( s Create a window at INDEX.R� R. N( R. RP R� R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
window_create� s c C s% | j j | j j | j d d � � S( s4 Return all names of embedded windows in this widget.R� R� ( R. R* RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt window_names� s c G s$ | j j | j d d f | � d S( s Obsolete function, use see.R� s
-pickplaceN( R. RP R� ( RR RW ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt yview_pickplace� s N(: R7 R8 R9 R RU R� R4 R5 R6 R7 R8 R: R� R; R= R? RB RD RF RG RI R] RJ RK RL R� R� R� RQ RR RS RV RX RZ R� R� R R� Rd R� R� Re Rf t
tag_configRh R� Ri Rk Rm R� Ro Rp Rq Rr t
window_configRs Rt Ru ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR3 r sr (
t _setitc B s# e Z d Z d d � Z d � Z RS( s> Internal class. It wraps the command in the widget OptionMenu.c C s | | _ | | _ | | _ d S( N( t
_setit__valuet _setit__vart _setit__callback( RR t varR Rg ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU � s c G s6 | j j | j � | j r2 | j | j | � n d S( N( Rz RN Ry R{ ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRa � s N( R7 R8 R9 R RU Ra ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRx � s t
OptionMenuc B s) e Z d Z d � Z d � Z d � Z RS( s? OptionMenu which allows the user to select a value from a menu.c
O s" i d d 6| d 6d d 6t d 6d d 6d d 6} t j | | d
| � d | _ t | d d
d d �} | _ | j | _ | j d � } d | k r� | d =n | r� t d | j
� d � n | j d | d t | | | � � x0 | D]( } | j d | d t | | | � � q� W| | d
<d S( s� Construct an optionmenu widget with the parent MASTER, with
the resource textvariable set to VARIABLE, the initially selected
value VALUE, the other menu values VALUES and an additional
keyword argument command.i t borderwidtht textvariablei t indicatoront reliefR$ R� t highlightthicknessR) t
tk_optionMenuRT R t tearoffi R� s unknown option -R� N(
t RAISEDRr RU Rm R t _OptionMenu__menuR� t menunameR] R� R� R Rx (
RR RS R_ R RD t kwargsR� R Rg R' ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU � s$
c C s# | d k r | j St j | | � S( NR ( R� Rr R� ( RR RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s t j | � d | _ d S( s, Destroy this widget and the associated menu.N( R( R� R R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s
( R7 R8 R9 RU R� R� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR} � s t Imagec B st e Z d Z d Z d i d d � Z d � Z d � Z d � Z d � Z d � Z
e
Z d � Z d � Z
d
� Z RS( s Base class for images.i c K s^ d | _ | s* t } | s* t d � q* n t | d | � | _ | s� t j d 7_ d t j f } | d d k r� d | d } q� n | r� | r� t | | f � } n | r� | } n d
} xp | j � D]b \ } } t
| d � r� | j | � } n! | d k r| j j | � } n | d | | f } q� W| j j
d d | | f | � | | _ d S( Ns Too early to create imageR. i s pyimage%ri R) Ri Ra R� t maskdataR� R. ( ( R� R� ( R RT R; R+ RW R. R� t _last_idR( R! Rj R� t _createbytearrayRP ( RR t imgtypeRT R# RS R� R� R& R' ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU � s0 c C s | j S( N( RT ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRZ
RE c C sA | j r= y | j j d d | j � Wq= t k
r9 q= Xn d S( NR� R� ( RT R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRY
s
c C s$ | j j | j d d | | � d S( NR� R) ( R. RP RT ( RR R4 R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR�
s c C s | j j | j d d | � S( NR� R) ( R. RP RT ( RR R4 ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR�
s c K s� d } x� t | � j � D]� \ } } | d k r | d d k rN | d } n t | d � ro | j | � } n! | d
k r� | j j | � } n | d | | f } q q W| j j | j d f | � d S( s Configure the image.i����Ri Ra R� R� R) R� N( ( R� R� ( R( R! R Rj R� R. R� RP RT ( RR R� R R& R' ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR�
s
c C s t | j j d d | j � � S( s Return the height of the image.R� R� ( Ry R. RP RT ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR�
s c C s | j j d d | j � S( s7 Return the type of the image, e.g. "photo" or "bitmap".R� R ( R. RP RT ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR "
s c C s t | j j d d | j � � S( s Return the width of the image.R� RK ( Ry R. RP RT ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRK %
s N( R7 R8 R9 R� R RU RZ RY R� R� R� R� R� R RK ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s t
PhotoImagec B s� e Z d Z d i d d � Z d � Z d � Z d � Z d � Z d d � Z d d � Z
d � Z d d
� Z d d d � Z
RS(
s= Widget which can display images in PGM, PPM, GIF, PNG format.c K s t j | d | | | | � d S( st Create an image with NAME.
Valid resource names: data, format, file, gamma, height, palette,
width.t photoN( R� RU ( RR RT R# RS R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU ,
s c C s | j j | j d � d S( s Display a transparent image.t blankN( R. RP RT ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� 2
s c C s | j j | j d d | � S( s Return the value of OPTION.R� R) ( R. RP RT ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� 5
s c C s | j j | j d d | � S( NR� R) ( R. RP RT ( RR R4 ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� 9
s c C s/ t d | j � } | j j | d | j � | S( s; Return a new PhotoImage with the same image as this widget.RS t copy( R� R. RP RT ( RR t destImage( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� <
s RE c C sM t d | j � } | d k r' | } n | j j | d | j d | | � | S( s� Return a new PhotoImage with the same image as this widget
but zoom it with a factor of x in the X direction and y in the Y
direction. If y is not given, the default value is the same as x.
RS RE R� s -zoom( R� R. RP RT ( RR RA RN R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt zoomA
s
"c C sM t d | j � } | d k r' | } n | j j | d | j d | | � | S( s� Return a new PhotoImage based on the same image as this widget
but use only every Xth or Yth pixel. If y is not given, the
default value is the same as x.
RS RE R� s
-subsample( R� R. RP RT ( RR RA RN R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt subsampleJ
s
"c C s | j j | j d | | � S( s8 Return the color (red, green, blue) of the pixel at X,Y.R] ( R. RP RT ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR] S
s c C s` | j d | f } | rL | d d k r5 | d } n | d t | � } n | j j | � d S( sz Put row formatted colors to image starting from
position TO, e.g. image.put("{red green} {blue yellow}", to=(4,6))t puti s -toi N( s -to( RT R R. RP ( RR R� R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� V
s
c C s\ | j d | f } | r+ | d | f } n | rH | d t | � } n | j j | � d S( sR Write image to file FILENAME in FORMAT starting from
position FROM_COORDS.t writes -formats -fromN( s -from( RT R R. RP ( RR t filenamet formatt from_coordsR� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� `
s N( R7 R8 R9 R RU R� R� R� R� R� R� R] R� R� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� *
s
t BitmapImagec B s e Z d Z d i d d � Z RS( s. Widget which can display images in XBM format.c K s t j | d | | | | � d S( sq Create a bitmap with NAME.
Valid resource names: background, data, file, foreground, maskdata, maskfile.R N( R� RU ( RR RT R# RS R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU l
s N( R7 R8 R9 R RU ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� j
s c C s t j j t j j d d � � S( NR� R� ( R; R. R* RP ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� r
s c C s t j j t j j d d � � S( NR� R� ( R; R. R* RP ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� u
s t Spinboxc B s� e Z d Z d i d � Z d � Z d d � Z d � Z d � Z d � Z d � Z
d � Z d � Z d
� Z
d � Z d � Z d
� Z d � Z d � Z d d � Z RS( s spinbox widget.c K s t j | | d | | � d S( s� Construct a spinbox widget with the parent MASTER.
STANDARD OPTIONS
activebackground, background, borderwidth,
cursor, exportselection, font, foreground,
highlightbackground, highlightcolor,
highlightthickness, insertbackground,
insertborderwidth, insertofftime,
insertontime, insertwidth, justify, relief,
repeatdelay, repeatinterval,
selectbackground, selectborderwidth
selectforeground, takefocus, textvariable
xscrollcommand.
WIDGET-SPECIFIC OPTIONS
buttonbackground, buttoncursor,
buttondownrelief, buttonuprelief,
command, disabledbackground,
disabledforeground, format, from,
invalidcommand, increment,
readonlybackground, state, to,
validate, validatecommand values,
width, wrap,
t spinboxN( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU {
s c C s( | j | j j | j d | � � p' d S( s� Return a tuple of X1,Y1,X2,Y2 coordinates for a
rectangle which encloses the character given by index.
The first two elements of the list give the x and y
coordinates of the upper-left corner of the screen
area covered by the character (in pixels relative
to the widget) and the last two elements give the
width and height of the character, in pixels. The
bounding box may refer to a region outside the
visible area of the window.
R� N( R R. RP R� R ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c C s | j j | j d | | � S( sW Delete one or more elements of the spinbox.
First is the index of the first character to delete,
and last is the index of the character just after
the last one to delete. If last isn't specified it
defaults to first+1, i.e. a single character is
deleted. This command returns an empty string.
R� ( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c C s | j j | j d � S( s Returns the spinbox's stringR] ( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR] �
s c C s | j j | j d | � S( s� Alter the position of the insertion cursor.
The insertion cursor will be displayed just before
the character given by index. Returns an empty string
R� ( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c C s | j j | j d | | � S( s{ Returns the name of the widget at position x, y
Return value is one of: none, buttondown, buttonup, entry
R. ( R. RP R� ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR. �
s c C s | j j | j d | � S( s; Returns the numerical index corresponding to index
R� ( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c C s | j j | j d | | � S( sD Insert string s at index
Returns an empty string.
R� ( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c C s | j j | j d | � S( s� Causes the specified element to be invoked
The element could be buttondown or buttonup
triggering the action associated with it.
R� ( R. RP R� ( RR t element( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c G s, | j | j j | j d f | � � p+ d S( s Internal function.R� ( ( R R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c C s | j d | � S( s� Records x and the current view in the spinbox window;
used in conjunction with later scan dragto commands.
Typically this command is associated with a mouse button
press in the widget. It returns an empty string.
R� ( R� ( RR RA ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c C s | j d | � S( s� Compute the difference between the given x argument
and the x argument to the last scan mark command
It then adjusts the view left or right by 10 times the
difference in x-coordinates. This command is typically
associated with mouse motion events in the widget, to
produce the effect of dragging the spinbox at high speed
through the window. The return value is an empty string.
R� ( R� ( RR RA ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s
c G s, | j | j j | j d f | � � p+ d S( s Internal function.R� ( ( R R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c C s | j d | � S( s� Locate the end of the selection nearest to the character
given by index,
Then adjust that end of the selection to be at index
(i.e including but not going beyond index). The other
end of the selection is made the anchor point for future
select to commands. If the selection isn't currently in
the spinbox, then a new selection is created to include
the characters between index and the most recent selection
anchor point, inclusive.
R� ( R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c C s
| j d � S( ss Clear the selection
If the selection isn't in this widget then the
command has no effect.
R� ( R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� s c C s | j j | j d d | � S( s� Sets or gets the currently selected element.
If a spinbutton element is specified, it will be
displayed depressed.
R� R� ( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt selection_element
s N( R7 R8 R9 R RU R� R� R] R� R. R� R� R� R� R� R� R� R� R� R� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� y
s" t
LabelFramec B s e Z d Z d i d � Z RS( s labelframe widget.c K s t j | | d | | � d S( s� Construct a labelframe widget with the parent MASTER.
STANDARD OPTIONS
borderwidth, cursor, font, foreground,
highlightbackground, highlightcolor,
highlightthickness, padx, pady, relief,
takefocus, text
WIDGET-SPECIFIC OPTIONS
background, class, colormap, container,
height, labelanchor, labelwidget,
visual, width
t
labelframeN( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU s N( R7 R8 R9 R RU ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� s t PanedWindowc B s� e Z d Z d i d � Z d � Z d � Z e Z d � Z d � Z d � Z
d � Z d � Z d � Z
d
� Z d � Z d � Z d
� Z d d � Z e Z d � Z RS( s panedwindow widget.c K s t j | | d | | � d S( sT Construct a panedwindow widget with the parent MASTER.
STANDARD OPTIONS
background, borderwidth, cursor, height,
orient, relief, width
WIDGET-SPECIFIC OPTIONS
handlepad, handlesize, opaqueresize,
sashcursor, sashpad, sashrelief,
sashwidth, showhandle,
t panedwindowN( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU / s c K s- | j j | j d | f | j | � � d S( s+ Add a child widget to the panedwindow in a new pane.
The child argument is the name of the child widget
followed by pairs of arguments that specify how to
manage the windows. The possible options and values
are the ones accepted by the paneconfigure method.
R� N( R. RP R� R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� ? s c C s | j j | j d | � d S( s� Remove the pane containing child from the panedwindow
All geometry management options for child will be forgotten.
R] N( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRm I s c C s | j j | j d | | � S( s� Identify the panedwindow component at point x, y
If the point is over a sash or a sash handle, the result
is a two element list containing the index of the sash or
handle, and a word indicating whether it is over a sash
or a handle, such as {0 sash} or {2 handle}. If the point
is over any other part of the panedwindow, the result is
an empty list.
R. ( R. RP R� ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR. Q s
c G s, | j | j j | j d f | � � p+ d S( s Internal function.t proxy( ( R R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� ] s c C s
| j d � S( sB Return the x and y pair of the most recent proxy location
t coord( R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt proxy_coordb s c C s
| j d � S( s+ Remove the proxy from the display.
R] ( R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt proxy_forgetg s c C s | j d | | � S( s: Place the proxy at the given x and y coordinates.
R� ( R� ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt proxy_placel s c G s, | j | j j | j d f | � � p+ d S( s Internal function.t sash( ( R R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� q s c C s | j d | � S( sA Return the current x and y pair for the sash given by index.
Index must be an integer between 0 and 1 less than the
number of panes in the panedwindow. The coordinates given are
those of the top left corner of the region containing the sash.
pathName sash dragto index x y This command computes the
difference between the given coordinates and the coordinates
given to the last sash coord command for the given sash. It then
moves that sash the computed difference. The return value is the
empty string.
R� ( R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
sash_coordv s c C s | j d | � S( s Records x and y for the sash given by index;
Used in conjunction with later dragto commands to move the sash.
R� ( R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt sash_mark� s c C s | j d | | | � S( s? Place the sash given by index at the given coordinates
R� ( R� ( RR R� RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
sash_place� s c C s' | j j | j d f | d | f � S( sw Query a management option for window.
Option may be any value allowed by the paneconfigure subcommand
t panecgetR) ( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c K s� | d k r) | r) | j | j d | � St | � t k r_ | r_ | j | j d | d | � S| j j | j d | f | j | | � � d S( s�
Query or modify the management options for window.
If no option is specified, returns a list describing all
of the available options for pathName. If option is
specified with no value, then the command returns a list
describing the one named option (this list will be identical
to the corresponding sublist of the value returned if no
option is specified). If one or more option-value pairs are
specified, then the command modifies the given widget
option(s) to have the given value(s); in this case the
command returns an empty string. The following options
are supported:
after window
Insert the window after the window specified. window
should be the name of a window already managed by pathName.
before window
Insert the window before the window specified. window
should be the name of a window already managed by pathName.
height size
Specify a height for the window. The height will be the
outer dimension of the window including its border, if
any. If size is an empty string, or if -height is not
specified, then the height requested internally by the
window will be used initially; the height may later be
adjusted by the movement of sashes in the panedwindow.
Size may be any value accepted by Tk_GetPixels.
minsize n
Specifies that the size of the window cannot be made
less than n. This constraint only affects the size of
the widget in the paned dimension -- the x dimension
for horizontal panedwindows, the y dimension for
vertical panedwindows. May be any value accepted by
Tk_GetPixels.
padx n
Specifies a non-negative value indicating how much
extra space to leave on each side of the window in
the X-direction. The value may have any of the forms
accepted by Tk_GetPixels.
pady n
Specifies a non-negative value indicating how much
extra space to leave on each side of the window in
the Y-direction. The value may have any of the forms
accepted by Tk_GetPixels.
sticky style
If a window's pane is larger than the requested
dimensions of the window, this option may be used
to position (or stretch) the window within its pane.
Style is a string that contains zero or more of the
characters n, s, e or w. The string can optionally
contains spaces or commas, but they are ignored. Each
letter refers to a side (north, south, east, or west)
that the window will "stick" to. If both n and s
(or e and w) are specified, the window will be
stretched to fill the entire height (or width) of
its cavity.
width size
Specify a width for the window. The width will be
the outer dimension of the window including its
border, if any. If size is an empty string, or
if -width is not specified, then the width requested
internally by the window will be used initially; the
width may later be adjusted by the movement of sashes
in the panedwindow. Size may be any value accepted by
Tk_GetPixels.
t
paneconfigureR) N( R R� R� R R R� R. RP R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s Dc C s" | j j | j j | j d � � S( s+ Returns an ordered list of the child panes.t panes( R. R* RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s N( R7 R8 R9 R RU R� Rm R] R. R� R� R� R� R� R� R� R� R� R� t
paneconfigR� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� - s$
Kt
Studbuttonc B s e Z d i d � Z RS( c K si t j | | d | | � | j d | j � | j d | j � | j d | j � | j d | j � d S( Nt
studbuttons <Any-Enter>s <Any-Leave>s <1>s <ButtonRelease-1>( Rr RU R\ Rz R| R} R~ ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU � s
N( R7 R8 R RU ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s t Tributtonc B s e Z d i d � Z RS( c K s� t j | | d | | � | j d | j � | j d | j � | j d | j � | j d | j � | d | d <| d | d <d S( Nt tributtons <Any-Enter>s <Any-Leave>s <1>s <ButtonRelease-1>t bgt fgt activebackground( Rr RU R\ Rz R| R} R~ ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU � s N( R7 R8 R RU ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s� t � } d t } t d k rM y | t d d � } WqM t k
rI qM Xn t | d | �} | j � t | d d d | d � �} | j � | | _ t | d d d | j �} | j � | j � | j
� | j � | j � d S(
Ns This is Tcl/Tk version %sg333333 @s
This should be a cedilla: �s
iso-8859-1R� s Click me!R� c S s | j j d d | j d � S( NR� s [%s]( t testR� ( R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt <lambda>
s t QUIT(
R' t
TclVersionR t NameErrorR� R� Rx R� R� R R R� R~ ( R� R� R� R� Rc ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _test s(
t __main__(` R9 t __version__R� t platformt FixTkR� t tkinterR� R� t Tkconstantst reR/ R� RA RC RB R� t READABLEt WRITABLEt EXCEPTIONt createfilehandlerR R t deletefilehandlert compileR
R R R R R( t TrueR5 R6 R: R; R< R> RC RM RD Ru Rw Rz R| R~ R? Ry R{ RO R� R` R� R� R� R' RZ R[ Rb Rf Rk Rr Rs Rx R� R� R� R� R� R� R� R� R� R� R� R R( R* R, R- R/ R3 Rx R} R� R� R� R� R� R� R� R� R� R� R� R7 ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt <module> s�
, k � � � � Q�}',/8 > � A [}!( � I %@@ ��
Canvas.py 0000644 00000016447 15032720555 0006351 0 ustar 00 # This module exports classes for the various canvas item types
# NOTE: This module was an experiment and is now obsolete.
# It's best to use the Tkinter.Canvas class directly.
from warnings import warnpy3k
warnpy3k("the Canvas module has been removed in Python 3.0", stacklevel=2)
del warnpy3k
from Tkinter import Canvas, _cnfmerge, _flatten
class CanvasItem:
def __init__(self, canvas, itemType, *args, **kw):
self.canvas = canvas
self.id = canvas._create(itemType, args, kw)
if not hasattr(canvas, 'items'):
canvas.items = {}
canvas.items[self.id] = self
def __str__(self):
return str(self.id)
def __repr__(self):
return '<%s, id=%d>' % (self.__class__.__name__, self.id)
def delete(self):
del self.canvas.items[self.id]
self.canvas.delete(self.id)
def __getitem__(self, key):
v = self.canvas.tk.split(self.canvas.tk.call(
self.canvas._w, 'itemconfigure',
self.id, '-' + key))
return v[4]
cget = __getitem__
def __setitem__(self, key, value):
self.canvas.itemconfig(self.id, {key: value})
def keys(self):
if not hasattr(self, '_keys'):
self._keys = map(lambda x, tk=self.canvas.tk:
tk.splitlist(x)[0][1:],
self.canvas.tk.splitlist(
self.canvas._do(
'itemconfigure',
(self.id,))))
return self._keys
def has_key(self, key):
return key in self.keys()
def __contains__(self, key):
return key in self.keys()
def addtag(self, tag, option='withtag'):
self.canvas.addtag(tag, option, self.id)
def bbox(self):
x1, y1, x2, y2 = self.canvas.bbox(self.id)
return (x1, y1), (x2, y2)
def bind(self, sequence=None, command=None, add=None):
return self.canvas.tag_bind(self.id, sequence, command, add)
def unbind(self, sequence, funcid=None):
self.canvas.tag_unbind(self.id, sequence, funcid)
def config(self, cnf={}, **kw):
return self.canvas.itemconfig(self.id, _cnfmerge((cnf, kw)))
def coords(self, pts = ()):
flat = ()
for x, y in pts: flat = flat + (x, y)
return self.canvas.coords(self.id, *flat)
def dchars(self, first, last=None):
self.canvas.dchars(self.id, first, last)
def dtag(self, ttd):
self.canvas.dtag(self.id, ttd)
def focus(self):
self.canvas.focus(self.id)
def gettags(self):
return self.canvas.gettags(self.id)
def icursor(self, index):
self.canvas.icursor(self.id, index)
def index(self, index):
return self.canvas.index(self.id, index)
def insert(self, beforethis, string):
self.canvas.insert(self.id, beforethis, string)
def lower(self, belowthis=None):
self.canvas.tag_lower(self.id, belowthis)
def move(self, xamount, yamount):
self.canvas.move(self.id, xamount, yamount)
def tkraise(self, abovethis=None):
self.canvas.tag_raise(self.id, abovethis)
raise_ = tkraise # BW compat
def scale(self, xorigin, yorigin, xscale, yscale):
self.canvas.scale(self.id, xorigin, yorigin, xscale, yscale)
def type(self):
return self.canvas.type(self.id)
class Arc(CanvasItem):
def __init__(self, canvas, *args, **kw):
CanvasItem.__init__(self, canvas, 'arc', *args, **kw)
class Bitmap(CanvasItem):
def __init__(self, canvas, *args, **kw):
CanvasItem.__init__(self, canvas, 'bitmap', *args, **kw)
class ImageItem(CanvasItem):
def __init__(self, canvas, *args, **kw):
CanvasItem.__init__(self, canvas, 'image', *args, **kw)
class Line(CanvasItem):
def __init__(self, canvas, *args, **kw):
CanvasItem.__init__(self, canvas, 'line', *args, **kw)
class Oval(CanvasItem):
def __init__(self, canvas, *args, **kw):
CanvasItem.__init__(self, canvas, 'oval', *args, **kw)
class Polygon(CanvasItem):
def __init__(self, canvas, *args, **kw):
CanvasItem.__init__(self, canvas, 'polygon', *args, **kw)
class Rectangle(CanvasItem):
def __init__(self, canvas, *args, **kw):
CanvasItem.__init__(self, canvas, 'rectangle', *args, **kw)
# XXX "Text" is taken by the Text widget...
class CanvasText(CanvasItem):
def __init__(self, canvas, *args, **kw):
CanvasItem.__init__(self, canvas, 'text', *args, **kw)
class Window(CanvasItem):
def __init__(self, canvas, *args, **kw):
CanvasItem.__init__(self, canvas, 'window', *args, **kw)
class Group:
def __init__(self, canvas, tag=None):
if not tag:
tag = 'Group%d' % id(self)
self.tag = self.id = tag
self.canvas = canvas
self.canvas.dtag(self.tag)
def str(self):
return self.tag
__str__ = str
def _do(self, cmd, *args):
return self.canvas._do(cmd, (self.tag,) + _flatten(args))
def addtag_above(self, tagOrId):
self._do('addtag', 'above', tagOrId)
def addtag_all(self):
self._do('addtag', 'all')
def addtag_below(self, tagOrId):
self._do('addtag', 'below', tagOrId)
def addtag_closest(self, x, y, halo=None, start=None):
self._do('addtag', 'closest', x, y, halo, start)
def addtag_enclosed(self, x1, y1, x2, y2):
self._do('addtag', 'enclosed', x1, y1, x2, y2)
def addtag_overlapping(self, x1, y1, x2, y2):
self._do('addtag', 'overlapping', x1, y1, x2, y2)
def addtag_withtag(self, tagOrId):
self._do('addtag', 'withtag', tagOrId)
def bbox(self):
return self.canvas._getints(self._do('bbox'))
def bind(self, sequence=None, command=None, add=None):
return self.canvas.tag_bind(self.id, sequence, command, add)
def unbind(self, sequence, funcid=None):
self.canvas.tag_unbind(self.id, sequence, funcid)
def coords(self, *pts):
return self._do('coords', pts)
def dchars(self, first, last=None):
self._do('dchars', first, last)
def delete(self):
self._do('delete')
def dtag(self, tagToDelete=None):
self._do('dtag', tagToDelete)
def focus(self):
self._do('focus')
def gettags(self):
return self.canvas.tk.splitlist(self._do('gettags', self.tag))
def icursor(self, index):
return self._do('icursor', index)
def index(self, index):
return self.canvas.tk.getint(self._do('index', index))
def insert(self, beforeThis, string):
self._do('insert', beforeThis, string)
def config(self, cnf={}, **kw):
return self.canvas.itemconfigure(self.tag, _cnfmerge((cnf,kw)))
def lower(self, belowThis=None):
self._do('lower', belowThis)
def move(self, xAmount, yAmount):
self._do('move', xAmount, yAmount)
def tkraise(self, aboveThis=None):
self._do('raise', aboveThis)
lift = tkraise
def scale(self, xOrigin, yOrigin, xScale, yScale):
self._do('scale', xOrigin, yOrigin, xScale, yScale)
def select_adjust(self, index):
self.canvas._do('select', ('adjust', self.tag, index))
def select_from(self, index):
self.canvas._do('select', ('from', self.tag, index))
def select_to(self, index):
self.canvas._do('select', ('to', self.tag, index))
def type(self):
return self._do('type')
tkFileDialog.pyc 0000644 00000012051 15032720555 0007622 0 ustar 00 �
z fc @ s� d d l m Z d e f d � � YZ d e f d � � YZ d e f d � � YZ d e f d � � YZ d
� Z d � Z d � Z d
d � Z d
d � Z
d d � Z d � Z e
d k r�d Z d d l Z y5 d d l Z e j e j d � e j e j � Z Wn e e f k
r n Xe d d g � Z y e e d
� Z e j � Wn d GHe j � d GHn Xd Ge j e � GHe � Z d Ge j e � GHn d S( i����( t Dialogt _Dialogc B s e Z d � Z d � Z RS( c C s6 y t | j d � | j d <Wn t k
r1 n Xd S( Nt filetypes( t tuplet optionst KeyError( t self( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyt _fixoptions/ s
c C su | rh d d l } y
| j } Wn t k
r2 n X| j j | � \ } } | | j d <| | j d <n | | _ | S( Ni����t
initialdirt initialfile( t ost stringt AttributeErrort patht splitR t filename( R t widgett resultR
R
t file( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyt
_fixresult6 s
( t __name__t
__module__R R ( ( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyR - s t Openc B s e Z d Z d Z d � Z RS( s Ask for a filename to opent tk_getOpenFilec C s� t | t � r| t g | D] } t | d | � ^ q � } | rx d d l } | j j | d � \ } } | | j d <n | S| j j � r� d | j k r� | j | | j j
| � � St j | | | � S( NR i����i R t multiple( t
isinstanceR t getattrR
R
R R t tkt wantobjectsR t splitlistR ( R R R t rR
R
R ( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyR O s + ( R R t __doc__t commandR ( ( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyR J s t SaveAsc B s e Z d Z d Z RS( s Ask for a filename to save ast tk_getSaveFile( R R R R ( ( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyR! ^ s t Directoryc B s e Z d Z d Z d � Z RS( s Ask for a directoryt tk_chooseDirectoryc C sD | r7 y
| j } Wn t k
r& n X| | j d <n | | _ | S( NR ( R R R t directory( R R R ( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyR j s
( R R R R R ( ( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyR# e s c K s t | � j � S( s Ask for a filename to open( R t show( R ( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyt askopenfilenamez s c K s t | � j � S( s Ask for a filename to save as( R! R& ( R ( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyt asksaveasfilename s c K s d | d <t | � j � S( st Ask for multiple filenames to open
Returns a list of filenames or empty list if
cancel button selected
i R ( R R& ( R ( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyt askopenfilenames� s
R c K s) t | � j � } | r% t | | � Sd S( s8 Ask for a filename to open, and returned the opened fileN( R R& t opent None( t modeR R ( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyt askopenfile� s
c K sL t | � } | rH g } x$ | D] } | j t | | � � q W| } n | S( s� Ask for multiple filenames and return the open file
objects
returns a list of open file objects or an empty list if
cancel selected
( R) t appendR* ( R, R t filest ofilesR ( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyt askopenfiles� s
t wc K s) t | � j � } | r% t | | � Sd S( s; Ask for a filename to save as, and returned the opened fileN( R! R& R* R+ ( R, R R ( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyt
asksaveasfile� s
c K s t | � j � S( s- Ask for a directory, and return the file name( R# R& ( R ( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyt askdirectory� s t __main__s utf-8Nt R s all filest *s Could not open File: i R* t saveas( s all filesR7 ( t tkCommonDialogR R R R! R# R' R( R) R- R1 R3 R4 R t enct syst localet setlocalet LC_ALLt nl_langinfot CODESETt ImportErrorR t openfilenameR* t fpt closet exc_infot encodet saveasfilename( ( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyt <module>+ s< Tkdnd.py 0000644 00000026340 15032720555 0006173 0 ustar 00 """Drag-and-drop support for Tkinter.
This is very preliminary. I currently only support dnd *within* one
application, between different windows (or within the same window).
I am trying to make this as generic as possible -- not dependent on
the use of a particular widget or icon type, etc. I also hope that
this will work with Pmw.
To enable an object to be dragged, you must create an event binding
for it that starts the drag-and-drop process. Typically, you should
bind <ButtonPress> to a callback function that you write. The function
should call Tkdnd.dnd_start(source, event), where 'source' is the
object to be dragged, and 'event' is the event that invoked the call
(the argument to your callback function). Even though this is a class
instantiation, the returned instance should not be stored -- it will
be kept alive automatically for the duration of the drag-and-drop.
When a drag-and-drop is already in process for the Tk interpreter, the
call is *ignored*; this normally averts starting multiple simultaneous
dnd processes, e.g. because different button callbacks all
dnd_start().
The object is *not* necessarily a widget -- it can be any
application-specific object that is meaningful to potential
drag-and-drop targets.
Potential drag-and-drop targets are discovered as follows. Whenever
the mouse moves, and at the start and end of a drag-and-drop move, the
Tk widget directly under the mouse is inspected. This is the target
widget (not to be confused with the target object, yet to be
determined). If there is no target widget, there is no dnd target
object. If there is a target widget, and it has an attribute
dnd_accept, this should be a function (or any callable object). The
function is called as dnd_accept(source, event), where 'source' is the
object being dragged (the object passed to dnd_start() above), and
'event' is the most recent event object (generally a <Motion> event;
it can also be <ButtonPress> or <ButtonRelease>). If the dnd_accept()
function returns something other than None, this is the new dnd target
object. If dnd_accept() returns None, or if the target widget has no
dnd_accept attribute, the target widget's parent is considered as the
target widget, and the search for a target object is repeated from
there. If necessary, the search is repeated all the way up to the
root widget. If none of the target widgets can produce a target
object, there is no target object (the target object is None).
The target object thus produced, if any, is called the new target
object. It is compared with the old target object (or None, if there
was no old target widget). There are several cases ('source' is the
source object, and 'event' is the most recent event object):
- Both the old and new target objects are None. Nothing happens.
- The old and new target objects are the same object. Its method
dnd_motion(source, event) is called.
- The old target object was None, and the new target object is not
None. The new target object's method dnd_enter(source, event) is
called.
- The new target object is None, and the old target object is not
None. The old target object's method dnd_leave(source, event) is
called.
- The old and new target objects differ and neither is None. The old
target object's method dnd_leave(source, event), and then the new
target object's method dnd_enter(source, event) is called.
Once this is done, the new target object replaces the old one, and the
Tk mainloop proceeds. The return value of the methods mentioned above
is ignored; if they raise an exception, the normal exception handling
mechanisms take over.
The drag-and-drop processes can end in two ways: a final target object
is selected, or no final target object is selected. When a final
target object is selected, it will always have been notified of the
potential drop by a call to its dnd_enter() method, as described
above, and possibly one or more calls to its dnd_motion() method; its
dnd_leave() method has not been called since the last call to
dnd_enter(). The target is notified of the drop by a call to its
method dnd_commit(source, event).
If no final target object is selected, and there was an old target
object, its dnd_leave(source, event) method is called to complete the
dnd sequence.
Finally, the source object is notified that the drag-and-drop process
is over, by a call to source.dnd_end(target, event), specifying either
the selected target object, or None if no target object was selected.
The source object can use this to implement the commit action; this is
sometimes simpler than to do it in the target's dnd_commit(). The
target's dnd_commit() method could then simply be aliased to
dnd_leave().
At any time during a dnd sequence, the application can cancel the
sequence by calling the cancel() method on the object returned by
dnd_start(). This will call dnd_leave() if a target is currently
active; it will never call dnd_commit().
"""
import Tkinter
# The factory function
def dnd_start(source, event):
h = DndHandler(source, event)
if h.root:
return h
else:
return None
# The class that does the work
class DndHandler:
root = None
def __init__(self, source, event):
if event.num > 5:
return
root = event.widget._root()
try:
root.__dnd
return # Don't start recursive dnd
except AttributeError:
root.__dnd = self
self.root = root
self.source = source
self.target = None
self.initial_button = button = event.num
self.initial_widget = widget = event.widget
self.release_pattern = "<B%d-ButtonRelease-%d>" % (button, button)
self.save_cursor = widget['cursor'] or ""
widget.bind(self.release_pattern, self.on_release)
widget.bind("<Motion>", self.on_motion)
widget['cursor'] = "hand2"
def __del__(self):
root = self.root
self.root = None
if root:
try:
del root.__dnd
except AttributeError:
pass
def on_motion(self, event):
x, y = event.x_root, event.y_root
target_widget = self.initial_widget.winfo_containing(x, y)
source = self.source
new_target = None
while target_widget:
try:
attr = target_widget.dnd_accept
except AttributeError:
pass
else:
new_target = attr(source, event)
if new_target:
break
target_widget = target_widget.master
old_target = self.target
if old_target is new_target:
if old_target:
old_target.dnd_motion(source, event)
else:
if old_target:
self.target = None
old_target.dnd_leave(source, event)
if new_target:
new_target.dnd_enter(source, event)
self.target = new_target
def on_release(self, event):
self.finish(event, 1)
def cancel(self, event=None):
self.finish(event, 0)
def finish(self, event, commit=0):
target = self.target
source = self.source
widget = self.initial_widget
root = self.root
try:
del root.__dnd
self.initial_widget.unbind(self.release_pattern)
self.initial_widget.unbind("<Motion>")
widget['cursor'] = self.save_cursor
self.target = self.source = self.initial_widget = self.root = None
if target:
if commit:
target.dnd_commit(source, event)
else:
target.dnd_leave(source, event)
finally:
source.dnd_end(target, event)
# ----------------------------------------------------------------------
# The rest is here for testing and demonstration purposes only!
class Icon:
def __init__(self, name):
self.name = name
self.canvas = self.label = self.id = None
def attach(self, canvas, x=10, y=10):
if canvas is self.canvas:
self.canvas.coords(self.id, x, y)
return
if self.canvas:
self.detach()
if not canvas:
return
label = Tkinter.Label(canvas, text=self.name,
borderwidth=2, relief="raised")
id = canvas.create_window(x, y, window=label, anchor="nw")
self.canvas = canvas
self.label = label
self.id = id
label.bind("<ButtonPress>", self.press)
def detach(self):
canvas = self.canvas
if not canvas:
return
id = self.id
label = self.label
self.canvas = self.label = self.id = None
canvas.delete(id)
label.destroy()
def press(self, event):
if dnd_start(self, event):
# where the pointer is relative to the label widget:
self.x_off = event.x
self.y_off = event.y
# where the widget is relative to the canvas:
self.x_orig, self.y_orig = self.canvas.coords(self.id)
def move(self, event):
x, y = self.where(self.canvas, event)
self.canvas.coords(self.id, x, y)
def putback(self):
self.canvas.coords(self.id, self.x_orig, self.y_orig)
def where(self, canvas, event):
# where the corner of the canvas is relative to the screen:
x_org = canvas.winfo_rootx()
y_org = canvas.winfo_rooty()
# where the pointer is relative to the canvas widget:
x = event.x_root - x_org
y = event.y_root - y_org
# compensate for initial pointer offset
return x - self.x_off, y - self.y_off
def dnd_end(self, target, event):
pass
class Tester:
def __init__(self, root):
self.top = Tkinter.Toplevel(root)
self.canvas = Tkinter.Canvas(self.top, width=100, height=100)
self.canvas.pack(fill="both", expand=1)
self.canvas.dnd_accept = self.dnd_accept
def dnd_accept(self, source, event):
return self
def dnd_enter(self, source, event):
self.canvas.focus_set() # Show highlight border
x, y = source.where(self.canvas, event)
x1, y1, x2, y2 = source.canvas.bbox(source.id)
dx, dy = x2-x1, y2-y1
self.dndid = self.canvas.create_rectangle(x, y, x+dx, y+dy)
self.dnd_motion(source, event)
def dnd_motion(self, source, event):
x, y = source.where(self.canvas, event)
x1, y1, x2, y2 = self.canvas.bbox(self.dndid)
self.canvas.move(self.dndid, x-x1, y-y1)
def dnd_leave(self, source, event):
self.top.focus_set() # Hide highlight border
self.canvas.delete(self.dndid)
self.dndid = None
def dnd_commit(self, source, event):
self.dnd_leave(source, event)
x, y = source.where(self.canvas, event)
source.attach(self.canvas, x, y)
def test():
root = Tkinter.Tk()
root.geometry("+1+1")
Tkinter.Button(command=root.quit, text="Quit").pack()
t1 = Tester(root)
t1.top.geometry("+1+60")
t2 = Tester(root)
t2.top.geometry("+120+60")
t3 = Tester(root)
t3.top.geometry("+240+60")
i1 = Icon("ICON1")
i2 = Icon("ICON2")
i3 = Icon("ICON3")
i1.attach(t1.canvas)
i2.attach(t2.canvas)
i3.attach(t3.canvas)
root.mainloop()
if __name__ == '__main__':
test()
turtle.pyo 0000644 00000420471 15032720555 0006630 0 ustar 00 �
z fc O @ s+ d Z d Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l m Z m
Z
m Z d d l m
Z
d d l Td d d d
d d d
d d g Z d d d d d d d d d d d d d d d d d d! d" d# d$ d% d& d' d( d) g Z d* d+ d, d- d. d/ d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 d: d; d< d= d> d? d@ dA dB dC dD dE dF dG dH dI dJ dK dL dM dN dO dP dQ dR dS dT dU dV dW dX dY dZ d[ d\ d] d^ d_ d` da db dc dd de df dg dh di dj dk dl dm d% dn do dp dq dr d( d) ds dt du gO Z dv dw dx g Z dy dz d{ d| d} d~ d d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� d� g Z e e e e d� g e Z d d+ d. d; dG dK dO dU dW d\ d] d_ d` di dn dq dr g Z i d� dr 6d� d� 6d� d� 6d� d� 6e d� 6e d� 6d� d 6d� d 6d� d 6d� d� 6d� de 6d� dQ 6d� d= 6d� d[ 6e d� 6d� d� 6d� d� 6d� d� 6d� d$ 6e d� 6Z d� � Z d� � Z y e e � Wn e k
rfd� GHn Xd e f d� � � YZ d� � Z d� � Z d� d� Z f d� � Z! d e j" f d� � � YZ# e! e# e j$ d� � d� e j% f d� � � YZ& e j$ Z$ d� e' f d� � � YZ( d� e) f d� � � YZ* d� e) f d� � � YZ+ d e' f d� � � YZ, d� e' f d� � � YZ- d e( f d� � � YZ. d� e' f d� � � YZ/ d� e' f d� � � YZ0 d� e' f d� � � YZ1 d
e0 e/ f d� � � YZ2 e2 Z3 d� � Z4 d� e. f d� � � YZ5 d e2 f d� � � YZ6 e6 Z7 d� d� � Z8 d� � Z9 e d� Z: y e: d� k rNe9 e: � n Wn3 e; k
rkd� Ge: GHn e k
r�d� e: GHn Xd� � Z< d� � Z= d� � Z> d� Z? d� � Z@ e@ e e5 d� d� e> � e@ e e6 d� d� e= � e jA ZB ZA eC d� k r'd� � ZD d� � ZE d� � ZF eE � eF � eG � n d S(� s�
Turtle graphics is a popular way for introducing programming to
kids. It was part of the original Logo programming language developed
by Wally Feurzig and Seymour Papert in 1966.
Imagine a robotic turtle starting at (0, 0) in the x-y plane. After an ``import turtle``, give it
the command turtle.forward(15), and it moves (on-screen!) 15 pixels in
the direction it is facing, drawing a line as it moves. Give it the
command turtle.right(25), and it rotates in-place 25 degrees clockwise.
By combining together these and similar commands, intricate shapes and
pictures can easily be drawn.
----- turtle.py
This module is an extended reimplementation of turtle.py from the
Python standard distribution up to Python 2.5. (See: http://www.python.org)
It tries to keep the merits of turtle.py and to be (nearly) 100%
compatible with it. This means in the first place to enable the
learning programmer to use all the commands, classes and methods
interactively when using the module from within IDLE run with
the -n switch.
Roughly it has the following features added:
- Better animation of the turtle movements, especially of turning the
turtle. So the turtles can more easily be used as a visual feedback
instrument by the (beginning) programmer.
- Different turtle shapes, gif-images as turtle shapes, user defined
and user controllable turtle shapes, among them compound
(multicolored) shapes. Turtle shapes can be stretched and tilted, which
makes turtles very versatile geometrical objects.
- Fine control over turtle movement and screen updates via delay(),
and enhanced tracer() and speed() methods.
- Aliases for the most commonly used commands, like fd for forward etc.,
following the early Logo traditions. This reduces the boring work of
typing long sequences of commands, which often occur in a natural way
when kids try to program fancy pictures on their first encounter with
turtle graphics.
- Turtles now have an undo()-method with configurable undo-buffer.
- Some simple commands/methods for creating event driven programs
(mouse-, key-, timer-events). Especially useful for programming games.
- A scrollable Canvas class. The default scrollable Canvas can be
extended interactively as needed while playing around with the turtle(s).
- A TurtleScreen class with methods controlling background color or
background image, window and canvas size and other properties of the
TurtleScreen.
- There is a method, setworldcoordinates(), to install a user defined
coordinate-system for the TurtleScreen.
- The implementation uses a 2-vector class named Vec2D, derived from tuple.
This class is public, so it can be imported by the application programmer,
which makes certain types of computations very natural and compact.
- Appearance of the TurtleScreen and the Turtles at startup/import can be
configured by means of a turtle.cfg configuration file.
The default configuration mimics the appearance of the old turtle module.
- If configured appropriately the module reads in docstrings from a docstring
dictionary in some different language, supplied separately and replaces
the English ones by those read in. There is a utility function
write_docstringdict() to write a dictionary with the original (English)
docstrings to disc, so it can serve as a template for translations.
Behind the scenes there are some features included with possible
extensions in mind. These will be commented and documented elsewhere.
s5 turtle 1.0b1 - for Python 2.6 - 30. 5. 2008, 18:08i����N( t isfilet splitt join( t deepcopy( t *t ScrolledCanvast TurtleScreent Screent RawTurtlet Turtlet RawPent Pent Shapet Vec2Dt addshapet bgcolort bgpict byet clearscreent colormodet delayt exitonclickt getcanvast getshapest listent modet onkeyt
onscreenclickt ontimert register_shapet resetscreent
screensizet setupt setworldcoordinatest titlet tracert turtlest updatet
window_heightt window_widtht backt backwardt
begin_fillt
begin_polyt bkt circlet cleart
clearstampt clearstampst clonet colort degreest distancet dott downt end_fillt end_polyt fdt fillt fillcolort forwardt get_polyt getpent getscreent getturtlet gotot headingt
hideturtlet homet htt isdownt isvisiblet leftt ltt onclickt ondragt onreleaset pdt pent pencolort pendownt pensizet penupt post positiont put radianst rightt resett
resizemodet rtt setht
setheadingt setpost setpositiont settiltanglet
setundobuffert setxt setyt shapet shapesizet
showturtlet speedt stt stampt tiltt tiltanglet towardst
turtlesizet undot undobufferentriest upt widtht writet xcort ycort write_docstringdictt donet mainloopt acost asint atant atan2t ceilt cost cosht et expt fabst floort fmodt frexpt hypott ldexpt logt log10t modft pit powt sint sinht sqrtt tant tanht
Terminatorg �?g �?t heighti� t canvwidthi, t
canvheightt leftrightt topbottomt standardg �?i
i� t undobuffersizet classict blackt noresizet visiblet englisht languaget turtlet
exampleturtlet screent
examplescreens Python Turtle Graphicst
using_IDLEc C s# t | d � } | j � } | j � i } x� | D]� } | j � } | s2 | j d � r` q2 n y | j d � \ } } Wn# t k
r� d | | f GHq2 n X| j � } | j � } | d k r� t | � } n? y+ d
| k r� t | � } n t | � } Wn t k
rn X| | | <q2 W| S( s/ Convert content of config-file into dictionary.t rt #t =s Bad line in config-file %s:
%st Truet Falset Nones ''s ""t .( R� R� R� s ''s ""(
t opent readlinest closet stript
startswithR t
ValueErrort evalt floatt int( t filenamet ft cfglinest cfgdictt linet keyt value( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt config_dict� s2
c C s� d } i } i } t | � r- t | � } n d | k rJ d | d } n y% t t � \ } } t | | � } Wn t k
r� d } n Xt | � r� t | � } n t j | � t j | � d S( s@ Read config-files, change configuration-dict accordingly.
If there is a turtle.cfg file in the current working directory,
read it from there. If this contains an importconfig-value,
say 'myway', construct filename turtle_mayway.cfg else use
turtle.cfg and read it from the import-directory, where
turtle.py is located.
Update configuration dictionary first according to config-file,
in the import directory, then according to config-file in the
current working directory.
If no config-file is found, the default configuration is used.
s
turtle.cfgt importconfigs
turtle_%s.cfgt N( R R� R t __file__R t
BaseExceptiont _CFGR% ( R� t default_cfgt cfgdict1t cfgdict2t headt tailt cfg_file2( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt
readconfig� s
s" No configfile read, reason unknownc B sh e Z d Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d
� Z RS( s� A 2 dimensional vector class, used as a helper class
for implementing turtle graphics.
May be useful for turtle graphics programs also.
Derived from tuple, so a vector is a tuple!
Provides (for a, b vectors, k number):
a+b vector addition
a-b vector subtraction
a*b inner product
k*a and a*k multiplication with scalar
|a| absolute value of a
a.rotate(angle) rotation
c C s t j | | | f � S( N( t tuplet __new__( t clst xt y( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� s c C s% t | d | d | d | d � S( Ni i ( R
( t selft other( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt __add__ s c C sL t | t � r/ | d | d | d | d St | d | | d | � S( Ni i ( t
isinstanceR
( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt __mul__ s c C s9 t | t t t f � r5 t | d | | d | � Sd S( Ni i ( R� R� t longR� R
( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt __rmul__ s c C s% t | d | d | d | d � S( Ni i ( R
( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt __sub__ s c C s t | d | d � S( Ni i ( R
( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt __neg__ s c C s | d d | d d d S( Ni i i g �?( ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt __abs__ s c C s} t | d | d � } | t j d } t j | � t j | � } } t | d | | d | | d | | d | � S( s. rotate self counterclockwise by angle
i i g �f@( R
t mathR� R| R� ( R� t anglet perpt ct s( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt rotate s c C s | d | d f S( Ni i ( ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt __getnewargs__& s c C s d | S( Ns (%.2f,%.2f)( ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt __repr__( s (
t __name__t
__module__t __doc__R� R� R� R� R� R� R� R� R� R� ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR
s
c C s} t | j � } | j � x | D] } t | | � q Wx? | j j � D]. \ } } t | � t j k rG | | | <qG qG Wd S( s# helper function for Scrolled CanvasN( t listt __bases__t reverset __methodDictt __dict__t itemst typet typest FunctionType( R� t _dictt baseListt _superR� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� 4 s
c C s i } t | | � | j � S( s# helper function for Scrolled Canvas( R� t keys( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt __methods> s
s* def %(method)s(self, *args, **kw): return s* self.%(attribute)s.%(method)s(*args, **kw)c
B s& i } e | | � x> | j � D]0 } | d d k sF | d d k r | | =q q Wx$ | D] } | | k r[ | | =q[ q[ Wx* e | � D] } | | k r� | | =q� q� Wxw | j � D]i \ } } i | d 6| d 6} e | � e j k re i | d 6| d 6} n | | U| | | j | <q� Wd S( sn Helper functions for Scrolled Canvas, used to forward
ScrolledCanvas-methods to Tkinter.Canvas class.
i t _i����t methodt funct attributeN( R� R� R� R� R� R� t
StringTypet __stringBodyR� (
t fromClasst toClasst toPartt excludeR� t exR� R� t dt
execString( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt __forwardmethodsH s"
c B s} e Z d Z d d d d d � Z d d d d � Z d � Z d � Z d � Z d � Z d
� Z
d � Z d � Z d
� Z
RS( s� Modeled after the scrolled canvas class from Grayons's Tkinter book.
Used as the default canvas, which pops up automatically when
using turtle graphics functions or the Turtle class.
i� i^ iX c C s
t j j | | d | d | �| j � | _ | | | _ | _ | | | _ | _ d | _ t j
| d | d | d | j d t j d d �| _ t j
| d | j j d t j �| _ t j
| d | j j �| _ | j j d
| j j d | j j � | j d d
d d d �| j d d
d d d �| j j d d d | d d d d d d d d d d d d � | j j d d d | d d d d d d d d d d d d � | j j d d d | d d d d d d d d d d d d � | j � | j j d | j � d S( NRp R� t whitet bgt relieft borderwidthi t commandt orientt xscrollcommandt yscrollcommandi t weighti t minsizet padxt in_t padyt rowt columnt rowspant
columnspant stickyt newss <Configure>( t TKt Framet __init__t winfo_toplevelt _rootwindowRp R� R� R� R� t Canvast SUNKENt _canvast Scrollbart xviewt
HORIZONTALt hscrollt yviewt vscrollt configuret sett rowconfiguret columnconfiguret gridRX t bindt onResize( R� t masterRp R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR g s,
$$$
c C s� | r | | _ n | r$ | | _ n | r6 | | _ n | j j d | d | j d | j d | j d | j d f � | j j d | j | j d | j � | j j d | j | j d | j � | j � d S( s< Adjust canvas and scrollbars according to given canvas size.R� t scrollregioni g �?i N(
R� R� R� R t configt xview_movetoRp t yview_movetoR� t
adjustScrolls( R� R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRX � s c C s | j j � } | j j � } | j j d | j | | j � | j j d | j | | j � | | j k s� | | j k r� | j j d d d | d d d d d d d d d
d d d � | j j d d d | d d d d d d d d d
d d d � n | j j
� | j j
� d
S( sA Adjust scrollbars according to window- and canvas-size.
g �?R i R R R
R i R R
R R N( R t winfo_widtht winfo_heightR( R� R) R� R R" R t grid_forget( R� t cwidtht cheight( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR* � s "" $$
c C s | j � d S( s self-explanatoryN( R* ( R� t event( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR$ � s c G s | j j | � S( s@ 'forward' method, which canvas itself has inherited...
( R t bbox( R� t args( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR1 � s c O s | j j | | � S( s@ 'forward' method, which canvas itself has inherited...
( R t cget( R� R2 t kwargs( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR3 � s c O s | j j | | � d S( s@ 'forward' method, which canvas itself has inherited...
N( R R' ( R� R2 R4 ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR' � s c O s | j j | | � d S( s@ 'forward' method, which canvas itself has inherited...
N( R R# ( R� R2 R4 ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR# � s c O s | j j | | � d S( s@ 'forward' method, which canvas itself has inherited...
N( R t unbind( R� R2 R4 ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR5 � s c C s | j j � d S( s@ 'forward' method, which canvas itself has inherited...
N( R t focus_force( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR6 � s N( R� R� R� R R� RX R* R$ R1 R3 R' R# R5 R6 ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR a s R t _Rootc B sM e Z d Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z RS( s' Root class for Screen based on Tkinter.c C s t j j | � d S( N( R t TkR ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR � s c C s8 t | | | | | � | _ | j j d d d d � d S( Nt expandi R: t both( R R t pack( R� Rp R� R. R/ ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt setupcanvas� s c C s | j S( N( R ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt
_getcanvas� s c C s! | j d | | | | f � d S( Ns %dx%d%+d%+d( t geometry( R� Rp R� t startxt starty( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt set_geometry� s c C s | j d | � d S( Nt WM_DELETE_WINDOW( t wm_protocol( R� t destroy( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt ondestroy� s c C s
| j � S( N( t winfo_screenwidth( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt win_width� s c C s
| j � S( N( t winfo_screenheight( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt
win_height� s (
R� R� R� R R< R= RA RE RG RI ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR7 � s t TurtleScreenBasec B s[ e Z d Z e d � � Z e d � � Z d � Z d � Z d d d e d � Z
d � Z d d d e d � Z d � Z
d � Z d
� Z d � Z d d � Z d
� Z d d d � Z d d d � Z d d d � Z d d d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d d d d � Z! d � Z" RS( s� Provide the basic graphics functionality.
Interface between Tkinter and turtle.py.
To port turtle.py to some different graphics toolkit
a corresponding TurtleScreenBase class has to be implemented.
c C s& t j d d d d � } | j � | S( s$ return a blank image object
Rp i R� ( R t
PhotoImaget blank( t img( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _blankimage� s
c C s t j d | � S( s` return an image object containing the
imagedata from a gif-file named filename.
t file( R RK ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _image� s c C s� | | _ t | t � r3 | j j } | j j } na t | j j d � � } t | j j d � � } | j j d | d | d | d | d f � | | _ | | _ d | _ | _ d S( NRp R� R& i g �?(
t cvR� R R� R� R� R3 R' t xscalet yscale( R� RQ t wt h( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR � s 1 c C s | j j d d d d d �S( s< Create an invisible polygon item on canvas self.cv)
i R: R� t outline( i i i i i i ( RQ t create_polygon( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _createpoly s c
C s� g } x= | D]5 \ } } | j | | j � | j | | j � q
W| j j | | � | d k r~ | j j | d | �n | d k r� | j j | d | �n | d k r� | j j | d | �n | r� | j j | � n d S( s` Configure polygonitem polyitem according to provided
arguments:
coordlist is sequence of coordinates
fill is filling color
outline is outline color
top is a boolean value, which specifies if polyitem
will be put on top of the canvas' displaylist so it
will not be covered by other items.
R: RV Rp N( t appendRR RS RQ t coordsR� t
itemconfiguret tag_raise(
R� t polyitemt coordlistR: RV Rp t topt clR� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _drawpoly s c C s. | j j d d d d d d d d d t j �S( s9 Create an invisible line item on canvas self.cv)
i R: R� Rp i t capstyle( RQ t create_lineR t ROUND( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _createline$ s $c C s� | d k rh g } x= | D]5 \ } } | j | | j � | j | | j � q W| j j | | � n | d k r� | j j | d | �n | d k r� | j j | d | �n | r� | j j | � n d S( sQ Configure lineitem according to provided arguments:
coordlist is sequence of coordinates
fill is drawing color
width is width of drawn line.
top is a boolean value, which specifies if polyitem
will be put on top of the canvas' displaylist so it
will not be covered by other items.
R: Rp N( R� RY RR RS RQ RZ R[ R\ ( R� t lineitemR^ R: Rp R_ R` R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _drawline* s
c C s | j j | � d S( s] Delete graphics item from canvas.
If item is"all" delete all graphics items.
N( RQ t delete( R� t item( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _deleteA s c C s | j j � d S( s( Redraw graphics items on canvas
N( RQ R% ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _updateG s c C s | j j | � d S( s- Delay subsequent canvas actions for delay ms.N( RQ t after( R� R ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _delayL s c C s= y | j j | � } t } Wn t j k
r8 t } n X| S( sC Check if the string color is a legal Tkinter color string.
( RQ t winfo_rgbR� R t TclErrorR� ( R� R2 t rgbt ok( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _iscolorstringP s
c C s@ | d k r, | j j d | � | j � n | j j d � Sd S( sV Set canvas' backgroundcolor if color is not None,
else return backgroundcolor.R� N( R� RQ R' Rk R3 ( R� R2 ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _bgcolorZ s
c C s� | \ } } | | j } | | j } i d d 6d d 6d d 6} | j j | d | d | d | | d
| d | �} | j j | � \ }
} } }
| j j � | | d f S( s� Write txt at pos in canvas with specified font
and color.
Return text item and x-coord of right bottom corner
of text's bounding box.t swRH R� t centert seRW i t textt anchorR: t font( RR RS RQ t create_textR1 R% ( R� RS t txtt alignRy RO R� R� Rx Ri t x0t y0t x1t y1( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _writec s
'
i c sY � d k r& � j j | d | � n/ � � f d � } � j j | d | | | � d S( s� Bind fun to mouse-click event on turtle.
fun must be a function with two arguments, the coordinates
of the clicked point on the canvas.
num, the number of the mouse-button defaults to 1
s <Button-%s>c sK � j j | j � � j � j j | j � � j } } � | | � d S( N( RQ t canvasxR� RR t canvasyR� RS ( R0 R� R� ( t funR� ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt eventfun~ s !N( R� RQ t
tag_unbindt tag_bind( R� Ri R� t numt addR� ( ( R� R� s% /usr/lib64/python2.7/lib-tk/turtle.pyt _onclicku s c sY � d k r& � j j | d | � n/ � � f d � } � j j | d | | | � d S( sg Bind fun to mouse-button-release event on turtle.
fun must be a function with two arguments, the coordinates
of the point on the canvas where mouse button is released.
num, the number of the mouse-button defaults to 1
If a turtle is clicked, first _onclick-event will be performed,
then _onscreensclick-event.
s <Button%s-ButtonRelease>c sK � j j | j � � j � j j | j � � j } } � | | � d S( N( RQ R� R� RR R� R� RS ( R0 R� R� ( R� R� ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� � s !N( R� RQ R� R� ( R� Ri R� R� R� R� ( ( R� R� s% /usr/lib64/python2.7/lib-tk/turtle.pyt
_onrelease� s
c sY � d k r& � j j | d | � n/ � � f d � } � j j | d | | | � d S( sq Bind fun to mouse-move-event (with pressed mouse button) on turtle.
fun must be a function with two arguments, the coordinates of the
actual mouse position on the canvas.
num, the number of the mouse-button defaults to 1
Every sequence of mouse-move-events on a turtle is preceded by a
mouse-click event on that turtle.
s <Button%s-Motion>c sc yK � j j | j � � j � j j | j � � j } } � | | � Wn t k
r^ n Xd S( N( RQ R� R� RR R� R� RS R� ( R0 R� R� ( R� R� ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� � s !
N( R� RQ R� R� ( R� Ri R� R� R� R� ( ( R� R� s% /usr/lib64/python2.7/lib-tk/turtle.pyt _ondrag� s c sS � d k r# � j j d | � n, � � f d � } � j j d | | | � d S( sG Bind fun to mouse-click event on canvas.
fun must be a function with two arguments, the coordinates
of the clicked point on the canvas.
num, the number of the mouse-button defaults to 1
If a turtle is clicked, first _onclick-event will be performed,
then _onscreensclick-event.
s <Button-%s>c sK � j j | j � � j � j j | j � � j } } � | | � d S( N( RQ R� R� RR R� R� RS ( R0 R� R� ( R� R� ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� � s !N( R� RQ R5 R# ( R� R� R� R� R� ( ( R� R� s% /usr/lib64/python2.7/lib-tk/turtle.pyt _onscreenclick� s c sP � d k r& | j j d | d � n& � f d � } | j j d | | � d S( s` Bind fun to key-release event of key.
Canvas must have focus. See method listen
s <KeyRelease-%s>c s � � d S( N( ( R0 ( R� ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� � s N( R� RQ R5 R# ( R� R� R� R� ( ( R� s% /usr/lib64/python2.7/lib-tk/turtle.pyt _onkey� s c C s | j j � d S( s= Set focus on canvas (in order to collect key-events)
N( RQ R6 ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _listen� s c C s6 | d k r | j j | � n | j j | | � d S( s? Install a timer, which calls fun after t milliseconds.
i N( RQ t
after_idleRl ( R� R� t t( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _ontimer� s c C s | j j d d d | �S( s0 Create and return image item on canvas.
i t image( RQ t create_image( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _createimage� s c C sN | \ } } | j j | | | j | | j f � | j j | d | �d S( sZ Configure image item as to draw image object
at position (x,y) on canvas)
R� N( RQ RZ RR RS t
itemconfig( R� Ri RS R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt
_drawimage� s (c C s* | j j | d | �| j j | � d S( s� Configure image item as to draw image object
at center of canvas. Set item to the first item
in the displaylist, so it will be drawn below
any other item .R� N( RQ R� t tag_lower( R� Ri R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _setbgpic� s c C s | j j | � S( sQ Return 'line' or 'polygon' or 'image' depending on
type of item.
( RQ R� ( R� Ri ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _type� s c C sT | j j | � } g t d t | � d � D] } | | | | d f ^ q+ } | S( s returns list of coordinate-pairs of points of item
Example (for insiders):
>>> from turtle import *
>>> getscreen()._pointlist(getturtle().turtle._item)
[(0.0, 9.9999999999999982), (0.0, -9.9999999999999982),
(9.9999999999999982, 0.0)]
>>> i i i ( RQ RZ t ranget len( R� Ri R` t it pl( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt
_pointlist� s >c C s# | j j d | | | | f � d S( NR& ( RQ R' ( R� t srx1t sry1t srx2t sry2( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _setscrollregion� s c C s� | j j � } x� | D]z } | j j | � } g } xF | r| | d \ } } | j | | � | j | | � | d } q7 W| j j | | � q Wd S( Ni ( RQ t find_allRZ RY ( R� t xscalefactort yscalefactorR� Ri t coordinatest newcoordlistR� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _rescale s
c C s� t | j t � s" | j | j f S| | k oD | k oD d k n r_ | j j | j j f S| d k rw | | _ n | d k r� | | _ n | j j | | | � d S( sa Resize the canvas the turtles are drawing on. Does
not alter the drawing window.
N( R� RQ R R� R� R� RX ( R� R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _resize s ' c C s` | j j � } | d k r+ | j d } n | j j � } | d k rV | j d } n | | f S( s; Return the width and height of the turtle window.
i Rp R� ( RQ R+ R, ( R� Rp R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _window_size s N(# R� R� R� t staticmethodRN RP R RX R� R� Ra Re Rg Rj Rk Rm Rr Rs R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRJ � s@
c B s e Z d Z RS( s� Will be raised in TurtleScreen.update, if _RUNNING becomes False.
This stops execution of a turtle graphics script.
Main purpose: use in the Demo-Viewer turtle.Demo.py.
( R� R� R� ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� , s t TurtleGraphicsErrorc B s e Z d Z RS( s Some TurtleGraphics Error
( R� R� R� ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� 5 s c B s& e Z d Z d d � Z d d � Z RS( s� Data structure modeling shapes.
attribute _type is one of "polygon", "image", "compound"
attribute _data is - depending on _type a poygon-tuple,
an image or a list constructed using the addcomponent method.
c C s� | | _ | d k r6 t | t � r� t | � } q� ny | d k r� t | t � r� | j � j d � r� t | � r� t j | � } q� q� n% | d k r� g } n t
d | � � | | _ d S( Nt polygonR� s .gift compounds There is no shape type %s( R� R� R� R� t
basestringt lowert endswithR R RP R� t _data( R� t type_t data( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR A s ! c C sW | j d k r% t d | j � � n | d k r: | } n | j j | | | g � d S( s- Add component to a shape of type compound.
Arguments: poly is a polygon, i. e. a tuple of number pairs.
fill is the fillcolor of the component,
outline is the outline color of the component.
call (for a Shapeobject namend s):
-- s.addcomponent(((0,0), (10,10), (-10,10)), "red", "blue")
Example:
>>> poly = ((0,0),(10,-5),(0,10),(-10,-5))
>>> s = Shape("compound")
>>> s.addcomponent(poly, "red", "blue")
>>> # .. add more components and then use register_shape()
R� s Cannot add component to %s ShapeN( R� R� R� R� RY ( R� t polyR: RV ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt addcomponentQ s N( R� R� R� R� R R� ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR : s t Tbufferc B sJ e Z d Z d d � Z d d � Z d � Z d � Z d � Z d � Z RS( s5 Ring buffer used as undobuffer for RawTurtle objects.i
c C s2 | | _ d g g | | _ d | _ t | _ d S( Ni����( t bufsizeR� t buffert ptrR� t cumulate( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR k s c C sb | d k r9 xF t | j � D] } d g | j | <q Wn | | _ d g g | | _ d | _ d S( Ni����( R� R� R� R� R� ( R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRX p s c C s` | j d k r\ | j sB | j d | j | _ | | j | j <q\ | j | j j | � n d S( Ni i ( R� R� R� R� RY ( R� Ri ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt pushx s
c C sd | j d k r` | j | j } | d k r/ d Sd g | j | j <| j d | j | _ | Sn d S( Ni i ( R� R� R� R� ( R� Ri ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt pop s c C s | j | j j d g � S( N( R� R� t countR� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt nr_of_items� s c C s t | j � d t | j � S( Nt ( t strR� R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� � s N(
R� R� R� R R� RX R� R� R� R� ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� i s c B sO e Z d Z e Z e d e d e d d � Z d � Z d d � Z d � Z
d d � Z d � Z d
� Z
d d � Z d � Z d
� Z d � Z d d d � Z d d � Z d � Z d � Z d � Z d � Z d � Z d � Z d d d � Z d � Z d d d � Z d d � Z d d � Z d d d d � Z e Z e Z! e Z" e Z# RS( s� Provides screen oriented methods like setbg etc.
Only relies upon the methods of TurtleScreenBase and NOT
upon components of the underlying graphics toolkit -
which is Tkinter in this case.
R R R c C s� i t d d/ d0 d1 f � d 6t d d2 d3 d4 d5 d6 d7 d8 d9 d: d; d< d= d> d? d@ dA dB dC dD dE dF dG dH dI f � d 6t d dJ dK dL dM dN dO dP dQ dR dS dT dU dV dW dX dY dZ d[ d\ d] f � d$ 6t d d^ d_ d` da f � d% 6t d db dc dd f � d( 6t d de df dg dh f � d) 6t d* | j � � d+ 6| _ i d, d- 6| _ t j | | � | | _ | | _ t d. | _ g | _
| j � d S(i NR� i����i i
t arrowi i����i i����i����i i����i i����i i����i i i����i����i����i i i R� g��Q� #@g� ��Q�@g�G�z. @g��Q� �@g� ��Q��g��Q� ��g�G�z. �g��Q� #�g �g $�R- t squareg�G�z�g�����'@t triangleR� R� RL R� t nopicR ( i����i ( i
i ( i i
( i i ( i����i ( i����i
( i����i ( i����i ( i����i ( i����i ( i����i ( i����i����( i����i����( i����i����( i����i����( i i����( i i����( i i����( i i����( i i����( i i ( i i ( i i ( i i ( i i ( i i
( i i ( i
i ( g��Q� #@g� ��Q�@( g�G�z. @g��Q� �@( g��Q� �@g�G�z. @( g� ��Q�@g��Q� #@( i i
( g� ��Q��g��Q� #@( g��Q� ��g�G�z. @( g�G�z. �g��Q� �@( g��Q� #�g� ��Q�@( i����i ( g��Q� #�g� ��Q��( g�G�z. �g��Q� ��( g��Q� ��g�G�z. �( g� ��Q��g��Q� #�( g �g $�( g� ��Q�@g��Q� #�( g��Q� �@g�G�z. �( g�G�z. @g��Q� ��( g��Q� #@g� ��Q��( i
i����( i
i
( i����i
( i����i����( i
g�G�z�( i g�����'@( i����g�G�z�( i i ( i����i����( i i����( i i����( R RN t _shapest _bgpicsRJ R t _modet _delayvalueR� t
_colormodet _keysR. ( R� RQ R R R ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR � s4
c C s� t d | _ t d | _ | j d � | j d � | _ d | _ d | _ d | _ g | _ | j
d � x d D] } | j d | � qq Wx" | j
D] } | j d | � q� Wd t _ d S(
sq Delete all drawings and all turtles from the TurtleScreen.
Reset empty TurtleScreen to its initial state: white background,
no backgroundimage, no eventbindings and tracing on.
No argument.
Example (for a TurtleScreen instance named screen):
>>> screen.clear()
Note: this method is not available as function.
R R t allR� R� i i R� i i N( i i i ( R� R� R� Rj R� t _bgpict
_bgpicnamet _tracingt _updatecountert _turtlesR RJ R� R� R R t _pen( R� t btnR� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR. � s
c C s� | d k r | j S| j � } | d k r> t d | � � n | | _ | d k r� | j | j d | j d | j d | j d � d | _ | _ n | j � d S(
sh Set turtle-mode ('standard', 'logo' or 'world') and perform reset.
Optional argument:
mode -- one of the strings 'standard', 'logo' or 'world'
Mode 'standard' is compatible with turtle.py.
Mode 'logo' is compatible with most Logo-Turtle-Graphics.
Mode 'world' uses userdefined 'worldcoordinates'. *Attention*: in
this mode angles appear distorted if x/y unit-ratio doesn't equal 1.
If mode is not given, return the current mode.
Mode Initial turtle heading positive angles
------------|-------------------------|-------------------
'standard' to the right (east) counterclockwise
'logo' upward (north) clockwise
Examples:
>>> mode('logo') # resets turtle heading to north
>>> mode()
'logo'
R� t logot worlds No turtle-graphics-mode %si g �?N( R� R� R� ( R� R� (
R� R� R� R� R� R� R� RR RS RX ( R� R ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR � s c C s | j � d k r" | j d � n t | | � } t | | � } | j � \ } } | j | d | d � | j | j } }
| j | | _ | j | | _ | | j } | | j } | j | }
| j | } | j | | |
| � | j | j | | j |
� | j
� d S( ss Set up a user defined coordinate-system.
Arguments:
llx -- a number, x-coordinate of lower left corner of canvas
lly -- a number, y-coordinate of lower left corner of canvas
urx -- a number, x-coordinate of upper right corner of canvas
ury -- a number, y-coordinate of upper right corner of canvas
Set up user coodinat-system and switch to mode 'world' if necessary.
This performs a screen.reset. If mode 'world' is already active,
all drawings are redrawn according to the new coordinates.
But ATTENTION: in user-defined coordinatesystems angles may appear
distorted. (see Screen.mode())
Example (for a TurtleScreen instance named screen):
>>> screen.setworldcoordinates(-10,-0.5,50,1.5)
>>> for _ in range(36):
... left(10)
... forward(0.5)
R� i N( R R� R� R RR RS R� R� R� R� R% ( R� t llxt llyt urxt uryt xspant yspant wxt wyt oldxscalet oldyscaleR� R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR! � s
c C s� | d k rO | j � j d � r< t d | j | � � } qp t d d � � n! t | t � rp t d | � } n | | j | <d S( s� Adds a turtle shape to TurtleScreen's shapelist.
Arguments:
(1) name is the name of a gif-file and shape is None.
Installs the corresponding image shape.
!! Image-shapes DO NOT rotate when turning the turtle,
!! so they do not display the heading of the turtle!
(2) name is an arbitrary string and shape is a tuple
of pairs of coordinates. Installs the corresponding
polygon shape
(3) name is an arbitrary string and shape is a
(compound) Shape object. Installs the corresponding
compound shape.
To use a shape, you have to issue the command shape(shapename).
call: register_shape("turtle.gif")
--or: register_shape("tri", ((0,0), (10,10), (-10,10)))
Example (for a TurtleScreen instance named screen):
>>> screen.register_shape("triangle", ((5,-3),(0,5),(-5,-3)))
s .gifR� s" Bad arguments for register_shape.
s Use help(register_shape)R� N( R� R� R� R RP R� R� R� R� ( R� t nameRc ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR s
c C sn t | � d k r | d } n t | t � rf | j | � sI | d k rM | St d t | � � � n y | \ } } } Wn- t t f k
r� t d t | � � � n X| j d k r� g | | | f D] } t d | � ^ q� \ } } } n d | k od k n oAd | k o#d k n oAd | k o?d k n s]t d t | � � � n d
| | | f S( s Return color string corresponding to args.
Argument may be a string or a tuple of three
numbers corresponding to actual colormode,
i.e. in the range 0<=n<=colormode.
If the argument doesn't represent a color,
an error is raised.
i i R� s bad color string: %ss bad color arguments: %sg �?g �o@i� s bad color sequence: %ss
#%02x%02x%02x(
R� R� R� Rr R� R� t TypeErrorR� R� t round( R� R2 R� t gt bR� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _colorstrB s
8Tc C s� | j d � s | St | � d k rU g d D] } t | | | d !d � ^ q, } nS t | � d k r� g | d D] } d t | | d � ^ qr } n t d | � � t g | D] } | | j d
^ q� � S( NR� i i i i i i i s bad colorstring: %si� ( i i i ( R� R� R� R� R� R� ( R� t cstrR� R` RU R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _color] s 01c C sS | d k r | j S| d k r1 t | � | _ n | d k rO t | � | _ n d S( sq Return the colormode or set it to 1.0 or 255.
Optional argument:
cmode -- one of the values 1.0 or 255
r, g, b values of colortriples have to be in range 0..cmode.
Example (for a TurtleScreen instance named screen):
>>> screen.colormode()
1.0
>>> screen.colormode(255)
>>> pencolor(240,160,80)
g �?i� N( R� R� R� R� ( R� t cmode( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR h s c C s2 x+ | j D] } | j | j � | j � q
Wd S( s� Reset all Turtles on the Screen to their initial state.
No argument.
Example (for a TurtleScreen instance named screen):
>>> screen.reset()
N( R� t _setmodeR� RX ( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRX } s c C s | j S( s� Return the list of turtles on the screen.
Example (for a TurtleScreen instance named screen):
>>> screen.turtles()
[<turtle.Turtle object at 0x00E11FB0>]
( R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR$ � s c G sO | r | j | � } n d } | j | � } | d k rK | j | � } n | S( s� Set or return backgroundcolor of the TurtleScreen.
Arguments (if given): a color string or three numbers
in the range 0..colormode or a 3-tuple of such numbers.
Example (for a TurtleScreen instance named screen):
>>> screen.bgcolor("orange")
>>> screen.bgcolor()
'orange'
>>> screen.bgcolor(0.5,0,0.5)
>>> screen.bgcolor()
'#800080'
N( R� R� Rs R� ( R� R2 R2 ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR � s c C sc | d k r | j St | � | _ d | _ | d k rI t | � | _ n | j r_ | j � n d S( se Turns turtle animation on/off and set delay for update drawings.
Optional arguments:
n -- nonnegative integer
delay -- nonnegative integer
If n is given, only each n-th regular screen update is really performed.
(Can be used to accelerate the drawing of complex graphics.)
Second arguments sets delay value (see RawTurtle.delay())
Example (for a TurtleScreen instance named screen):
>>> screen.tracer(8, 25)
>>> dist = 2
>>> for i in range(200):
... fd(dist)
... rt(90)
... dist += 2
i N( R� R� R� R� R� R% ( R� t nR ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR# � s c C s& | d k r | j St | � | _ d S( s� Return or set the drawing delay in milliseconds.
Optional argument:
delay -- positive integer
Example (for a TurtleScreen instance named screen):
>>> screen.delay(15)
>>> screen.delay()
15
N( R� R� R� ( R� R ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR � s c C sR t j s t t _ t � n | j d k rN | j d 7_ | j | j ;_ n d S( s Increment update counter.i i N( R t _RUNNINGR� R� R� R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt
_incrementudc� s c C sT | j } t | _ x( | j � D] } | j � | j � q W| | _ | j � d S( s' Perform a TurtleScreen update.
N( R� R� R$ t _update_datat _drawturtleRk ( R� t tracingR� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR% � s
c C s | j � d S( s� Return the width of the turtle window.
Example (for a TurtleScreen instance named screen):
>>> screen.window_width()
640
i ( R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR' � s c C s | j � d S( s� Return the height of the turtle window.
Example (for a TurtleScreen instance named screen):
>>> screen.window_height()
480
i ( R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR& � s c C s | j S( s� Return the Canvas of this TurtleScreen.
No argument.
Example (for a Screen instance named screen):
>>> cv = screen.getcanvas()
>>> cv
<turtle.ScrolledCanvas instance at 0x010742D8>
( RQ ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR � s
c C s t | j j � � S( s� Return a list of names of all currently available turtle shapes.
No argument.
Example (for a TurtleScreen instance named screen):
>>> screen.getshapes()
['arrow', 'blank', 'circle', ... , 'turtle']
( t sortedR� R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR s i c C s | j | | | � d S( s Bind fun to mouse-click event on canvas.
Arguments:
fun -- a function with two arguments, the coordinates of the
clicked point on the canvas.
btn -- the number of the mouse-button, defaults to 1
Example (for a TurtleScreen instance named screen
and a Turtle instance named turtle):
>>> screen.onclick(goto)
>>> # Subsequently clicking into the TurtleScreen will
>>> # make the turtle move to the clicked point.
>>> screen.onclick(None)
N( R� ( R� R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRJ s c C sg | d k r1 | | j k rS | j j | � qS n" | | j k rS | j j | � n | j | | � d S( sm Bind fun to key-release event of key.
Arguments:
fun -- a function with no arguments
key -- a string: key (e.g. "a") or key-symbol (e.g. "space")
In order to be able to register key-events, TurtleScreen
must have focus. (See method listen.)
Example (for a TurtleScreen instance named screen):
>>> def f():
... fd(50)
... lt(60)
...
>>> screen.onkey(f, "Up")
>>> screen.listen()
Subsequently the turtle can be moved by repeatedly pressing
the up-arrow key, consequently drawing a hexagon
N( R� R� t removeRY R� ( R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR # s c C s | j � d S( s Set focus on TurtleScreen (in order to collect key-events)
No arguments.
Dummy arguments are provided in order
to be able to pass listen to the onclick method.
Example (for a TurtleScreen instance named screen):
>>> screen.listen()
N( R� ( R� t xdummyt ydummy( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR A s
i c C s | j | | � d S( s� Install a timer, which calls fun after t milliseconds.
Arguments:
fun -- a function with no arguments.
t -- a number >= 0
Example (for a TurtleScreen instance named screen):
>>> running = True
>>> def f():
... if running:
... fd(50)
... lt(60)
... screen.ontimer(f, 250)
...
>>> f() # makes the turtle marching around
>>> running = False
N( R� ( R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR M s c C sb | d k r | j S| | j k r; | j | � | j | <n | j | j | j | � | | _ d S( sF Set background image or return name of current backgroundimage.
Optional argument:
picname -- a string, name of a gif-file or "nopic".
If picname is a filename, set the corresponding image as background.
If picname is "nopic", delete backgroundimage, if present.
If picname is None, return the filename of the current backgroundimage.
Example (for a TurtleScreen instance named screen):
>>> screen.bgpic()
'nopic'
>>> screen.bgpic("landscape.gif")
>>> screen.bgpic()
'landscape.gif'
N( R� R� R� RP R� R� ( R� t picname( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR b s c C s | j | | | � S( s� Resize the canvas the turtles are drawing on.
Optional arguments:
canvwidth -- positive integer, new width of canvas in pixels
canvheight -- positive integer, new height of canvas in pixels
bg -- colorstring or color-tuple, new backgroundcolor
If no arguments are given, return current (canvaswidth, canvasheight)
Do not alter the drawing window. To observe hidden parts of
the canvas use the scrollbars. (Can make visible those parts
of a drawing, which were outside the canvas before!)
Example (for a Turtle instance named turtle):
>>> turtle.screensize(2000,1500)
>>> # e. g. to search for an erroneously escaped turtle ;-)
( R� ( R� R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR z s N($ R� R� R� R� R� R� R R. R� R R! R R� R� R RX R$ R R# R R� R% R' R& R R RJ R R R R R R R R R ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR � s@ " ' $ t
TNavigatorc B s� e Z d Z i e d d � d 6e d d � d 6e d d � d 6Z d Z d Z d Z e d � Z d � Z d% d
� Z d � Z d d
� Z
d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d% d � Z d � Z d � Z d � Z d% d � Z d% d � Z d � Z d � Z d% d% d! � Z! d d" � Z" d% d% d# � Z# d% d$ � Z$ e Z% e Z& e Z' e Z( e Z) e Z* e Z+ e Z, e Z- RS(& sR Navigation part of the RawTurtle.
Implements methods for turtle movement.
g �?g R� R� R� i i c C s[ | j | _ | j | _ | | _ d | _ | j � d | _ | j | � t j
| � d S( N( t DEFAULT_ANGLEOFFSETt _angleOffsett DEFAULT_ANGLEORIENTt _angleOrientR� R� t
undobufferR3 R� R� RX ( R� R ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR � s
c C s) t d d � | _ t j | j | _ d S( sX reset turtle to its initial values
Will be overwritten by parent class
g N( R
t _positionR� t START_ORIENTATIONR� t _orient( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRX � s c C sj | d k r | j S| d k r# d S| | _ | d
k rM d | _ d | _ n | j d | _ d | _ d S( s: Set turtle-mode to 'standard', 'world' or 'logo'.
R� R� R� Ni i g @i����( R� R� R� ( R� R� ( R� R� R� R� t _fullcircle( R� R ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� � s c C sB | | _ d | | _ | j d k r1 d | _ n
| d | _ d S( s+ Helper function for degrees() and radians()ih R� i g @N( R t
_degreesPerAUR� R� ( R� t
fullcircle( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _setDegreesPerAU� s
g �v@c C s | j | � d S( s> Set angle measurement units to degrees.
Optional argument:
fullcircle - a number
Set angle measurement units, i. e. set number
of 'degrees' for a full circle. Dafault value is
360 degrees.
Example (for a Turtle instance named turtle):
>>> turtle.left(90)
>>> turtle.heading()
90
Change angle measurement unit to grad (also known as gon,
grade, or gradian and equals 1/100-th of the right angle.)
>>> turtle.degrees(400.0)
>>> turtle.heading()
100
N( R ( R� R ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR3 � s c C s | j d t j � d S( s Set the angle measurement units to radians.
No arguments.
Example (for a Turtle instance named turtle):
>>> turtle.heading()
90
>>> turtle.radians()
>>> turtle.heading()
1.5707963267948966
i N( R R� R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRV � s c C s% | j | j | } | j | � d S( s) move turtle forward by specified distanceN( R� R� t _goto( R� R4 t ende( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _go� s c C s& | | j 9} | j j | � | _ d S( s= Turn turtle counterclockwise by specified angle if angle > 0.N( R R� R� ( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _rotate� s
c C s
| | _ d S( s move turtle to position end.N( R� ( R� t end( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR � s c C s | j | � d S( s Move the turtle forward by the specified distance.
Aliases: forward | fd
Argument:
distance -- a number (integer or float)
Move the turtle forward by the specified distance, in the direction
the turtle is headed.
Example (for a Turtle instance named turtle):
>>> turtle.position()
(0.00, 0.00)
>>> turtle.forward(25)
>>> turtle.position()
(25.00,0.00)
>>> turtle.forward(-75)
>>> turtle.position()
(-50.00,0.00)
N( R ( R� R4 ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR< � s c C s | j | � d S( s� Move the turtle backward by distance.
Aliases: back | backward | bk
Argument:
distance -- a number
Move the turtle backward by distance ,opposite to the direction the
turtle is headed. Do not change the turtle's heading.
Example (for a Turtle instance named turtle):
>>> turtle.position()
(0.00, 0.00)
>>> turtle.backward(30)
>>> turtle.position()
(-30.00, 0.00)
N( R ( R� R4 ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR( s c C s | j | � d S( s� Turn turtle right by angle units.
Aliases: right | rt
Argument:
angle -- a number (integer or float)
Turn turtle right by angle units. (Units are by default degrees,
but can be set via the degrees() and radians() functions.)
Angle orientation depends on mode. (See this.)
Example (for a Turtle instance named turtle):
>>> turtle.heading()
22.0
>>> turtle.right(45)
>>> turtle.heading()
337.0
N( R ( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRW ' s c C s | j | � d S( s� Turn turtle left by angle units.
Aliases: left | lt
Argument:
angle -- a number (integer or float)
Turn turtle left by angle units. (Units are by default degrees,
but can be set via the degrees() and radians() functions.)
Angle orientation depends on mode. (See this.)
Example (for a Turtle instance named turtle):
>>> turtle.heading()
22.0
>>> turtle.left(45)
>>> turtle.heading()
67.0
N( R ( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRH < s c C s | j S( s� Return the turtle's current location (x,y), as a Vec2D-vector.
Aliases: pos | position
No arguments.
Example (for a Turtle instance named turtle):
>>> turtle.pos()
(0.00, 240.00)
( R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRS Q s c C s | j d S( s� Return the turtle's x coordinate.
No arguments.
Example (for a Turtle instance named turtle):
>>> reset()
>>> turtle.left(60)
>>> turtle.forward(100)
>>> print turtle.xcor()
50.0
i ( R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRr ^ s c C s | j d S( s Return the turtle's y coordinate
---
No arguments.
Example (for a Turtle instance named turtle):
>>> reset()
>>> turtle.left(60)
>>> turtle.forward(100)
>>> print turtle.ycor()
86.6025403784
i ( R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRs l s c C s< | d k r" | j t | � � n | j t | | � � d S( st Move turtle to an absolute position.
Aliases: setpos | setposition | goto:
Arguments:
x -- a number or a pair/vector of numbers
y -- a number None
call: goto(x, y) # two coordinates
--or: goto((x, y)) # a pair (tuple) of coordinates
--or: goto(vec) # e.g. as returned by pos()
Move turtle to an absolute position. If the pen is down,
a line will be drawn. The turtle's orientation does not change.
Example (for a Turtle instance named turtle):
>>> tp = turtle.pos()
>>> tp
(0.00, 0.00)
>>> turtle.setpos(60,30)
>>> turtle.pos()
(60.00,30.00)
>>> turtle.setpos((20,80))
>>> turtle.pos()
(20.00,80.00)
>>> turtle.setpos(tp)
>>> turtle.pos()
(0.00,0.00)
N( R� R R
( R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRA { s c C s! | j d d � | j d � d S( s$ Move turtle to the origin - coordinates (0,0).
No arguments.
Move turtle to the origin - coordinates (0,0) and set its
heading to its start-orientation (which depends on mode).
Example (for a Turtle instance named turtle):
>>> turtle.home()
i N( RA R\ ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRD � s c C s! | j t | | j d � � d S( s� Set the turtle's first coordinate to x
Argument:
x -- a number (integer or float)
Set the turtle's first coordinate to x, leave second coordinate
unchanged.
Example (for a Turtle instance named turtle):
>>> turtle.position()
(0.00, 240.00)
>>> turtle.setx(10)
>>> turtle.position()
(10.00, 240.00)
i N( R R
R� ( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRa � s c C s! | j t | j d | � � d S( s� Set the turtle's second coordinate to y
Argument:
y -- a number (integer or float)
Set the turtle's first coordinate to x, second coordinate remains
unchanged.
Example (for a Turtle instance named turtle):
>>> turtle.position()
(0.00, 40.00)
>>> turtle.sety(-10)
>>> turtle.position()
(0.00, -10.00)
i N( R R
R� ( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRb � s c C s� | d k r t | | � } n t | t � r6 | } n9 t | t � rT t | � } n t | t � ro | j } n t | | j � S( s� Return the distance from the turtle to (x,y) in turtle step units.
Arguments:
x -- a number or a pair/vector of numbers or a turtle instance
y -- a number None None
call: distance(x, y) # two coordinates
--or: distance((x, y)) # a pair (tuple) of coordinates
--or: distance(vec) # e.g. as returned by pos()
--or: distance(mypen) # where mypen is another turtle
Example (for a Turtle instance named turtle):
>>> turtle.pos()
(0.00, 0.00)
>>> turtle.distance(30,40)
50.0
>>> pen = Turtle()
>>> pen.forward(77)
>>> turtle.distance(pen)
77.0
N( R� R
R� R� R� R� t abs( R� R� R� RS ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR4 � s c C s� | d k r t | | � } n t | t � r6 | } n9 t | t � rT t | � } n t | t � ro | j } n | | j \ } } t t j | | � d t j d � d } | | j
:} | j | j | | j
S( sC Return the angle of the line from the turtle's position to (x, y).
Arguments:
x -- a number or a pair/vector of numbers or a turtle instance
y -- a number None None
call: distance(x, y) # two coordinates
--or: distance((x, y)) # a pair (tuple) of coordinates
--or: distance(vec) # e.g. as returned by pos()
--or: distance(mypen) # where mypen is another turtle
Return the angle, between the line from turtle-position to position
specified by x, y and the turtle's start orientation. (Depends on
modes - "standard" or "logo")
Example (for a Turtle instance named turtle):
>>> turtle.pos()
(10.00, 10.00)
>>> turtle.towards(0,0)
225.0
g �f@i
g �v@N( R� R
R� R� R� R� R� R� Rz R� R R� R� R ( R� R� R� RS t result( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRk � s *
c C s_ | j \ } } t t j | | � d t j d � d } | | j :} | j | j | | j S( s� Return the turtle's current heading.
No arguments.
Example (for a Turtle instance named turtle):
>>> turtle.left(67)
>>> turtle.heading()
67.0
g �f@i
g �v@( R� R� R� Rz R� R R� R� R ( R� R� R� R
( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRB s
*
c C sK | | j � | j } | j } | | d | | d } | j | � d S( s� Set the orientation of the turtle to to_angle.
Aliases: setheading | seth
Argument:
to_angle -- a number (integer or float)
Set the orientation of the turtle to to_angle.
Here are some common directions in degrees:
standard - mode: logo-mode:
-------------------|--------------------
0 - east 0 - north
90 - north 90 - east
180 - west 180 - south
270 - south 270 - west
Example (for a Turtle instance named turtle):
>>> turtle.setheading(90)
>>> turtle.heading()
90
g @N( RB R� R R ( R� t to_angleR� t full( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR\ " s c C s� | j r+ | j j d g � t | j _ n | j � } | d k rO | j } n | d k r� t | � | j } d t t d t | � d d � | � } n d | | } d | } d | t
j | t
j d | j
� } | d
k r| | | } } } n | j � } | j � }
| d
k r:| j d
d
� n
| j d
� | j | � xH t | � D]: } | j | � | j | � | j d
� | j | � qaW| j | � | d
k r�| j | |
� n | j | � | j r�t | j _ n d S( s� Draw a circle with given radius.
Arguments:
radius -- a number
extent (optional) -- a number
steps (optional) -- an integer
Draw a circle with given radius. The center is radius units left
of the turtle; extent - an angle - determines which part of the
circle is drawn. If extent is not given, draw the entire circle.
If extent is not a full circle, one endpoint of the arc is the
current pen position. Draw the arc in counterclockwise direction
if radius is positive, otherwise in clockwise direction. Finally
the direction of the turtle is changed by the amount of extent.
As the circle is approximated by an inscribed regular polygon,
steps determines the number of steps to use. If not given,
it will be calculated automatically. Maybe used to draw regular
polygons.
call: circle(radius) # full circle
--or: circle(radius, extent) # arc
--or: circle(radius, extent, steps)
--or: circle(radius, steps=6) # 6-sided polygon
Example (for a Turtle instance named turtle):
>>> turtle.circle(50)
>>> turtle.circle(120, 180) # semicircle
t seqi i g @g �M@g �?g �?g @g �f@i N( R� R� R� R� Rf R� R R R� t minR� R� R� R R# Rm R R� R R� ( R� t radiust extentt stepsRf t fracRT t w2t lt trt dlR� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR- > s> .
)
c C s d S( s/ dummy method - to be overwritten by child classN( ( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRf R� c C s d S( s/ dummy method - to be overwritten by child classN( ( R� t aR� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR# � R� c C s d S( s/ dummy method - to be overwritten by child classN( ( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRm � R� N(. R� R� R� R
R� t DEFAULT_MODER� R� R RX R� R� R R3 RV R R R R< R( RW RH RS Rr Rs RA RD Ra Rb R4 Rk RB R\ R- Rf R# Rm R9 R, R) RZ RI RT R] R^ R[ ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� � sZ
# # A t TPenc B s
e Z d Z e d d � Z e d e d d � Z d d � Z d d � Z d � Z d � Z
d
� Z d d � Z d � Z
d
� Z d � Z d � Z d � Z d � Z d d � Z e d � Z e e d � Z d � Z d � Z e Z e Z e Z e
Z e
Z e Z e Z RS( sF Drawing part of the RawTurtle.
Implements drawing properties.
RY c C s# | | _ d | _ t j | � d S( N( t _resizemodeR� R� R t _reset( R� RY ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR � s RO R; c C sU d | _ t | _ | | _ | | _ t | _ d | _ d | _ d | _ d | _ d S( Ni i i ( i i (
t _pensizeR� t _shownt _pencolort
_fillcolort _drawingt _speedt _stretchfactort _tiltt
_outlinewidth( R� RO R; ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR � s c C sB | d k r | j S| j � } | d k r> | j d | � n d S( sz Set resizemode to one of the values: "auto", "user", "noresize".
(Optional) Argument:
rmode -- one of the strings "auto", "user", "noresize"
Different resizemodes have the following effects:
- "auto" adapts the appearance of the turtle
corresponding to the value of pensize.
- "user" adapts the appearance of the turtle according to the
values of stretchfactor and outlinewidth (outline),
which are set by shapesize()
- "noresize" no adaption of the turtle's appearance takes place.
If no argument is given, return current resizemode.
resizemode("user") is called by a call of shapesize with arguments.
Examples (for a Turtle instance named turtle):
>>> turtle.resizemode("noresize")
>>> turtle.resizemode()
'noresize'
t autot userR� RY N( R% R& R� ( R� R R� RN ( R� t rmode( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRY � s
c C s' | d k r | j S| j d | � d S( s! Set or return the line thickness.
Aliases: pensize | width
Argument:
width -- positive number
Set the line thickness to width or return it. If resizemode is set
to "auto" and turtleshape is a polygon, that polygon is drawn with
the same line thickness. If no argument is given, current pensize
is returned.
Example (for a Turtle instance named turtle):
>>> turtle.pensize()
1
>>> turtle.pensize(10) # from here on lines of width 10 are drawn
RQ N( R� R RN ( R� Rp ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRQ � s c C s! | j s
d S| j d t � d S( s� Pull the pen up -- no drawing when moving.
Aliases: penup | pu | up
No argument
Example (for a Turtle instance named turtle):
>>> turtle.penup()
NRP ( R RN R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRR � s
c C s! | j r
d S| j d t � d S( s� Pull the pen down -- drawing when moving.
Aliases: pendown | pd | down
No argument.
Example (for a Turtle instance named turtle):
>>> turtle.pendown()
NRP ( R RN R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRP � s
c C s | j S( s Return True if pen is down, False if it's up.
No argument.
Example (for a Turtle instance named turtle):
>>> turtle.penup()
>>> turtle.isdown()
False
>>> turtle.pendown()
>>> turtle.isdown()
True
( R ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRF � s
c C s� i d d 6d d 6d d 6d d 6d d
6} | d k r< | j S| | k rU | | } n7 d | k ol d k n r� t t | � � } n d } | j d
| � d S( s� Return or set the turtle's speed.
Optional argument:
speed -- an integer in the range 0..10 or a speedstring (see below)
Set the turtle's speed to an integer value in the range 0 .. 10.
If no argument is given: return current speed.
If input is a number greater than 10 or smaller than 0.5,
speed is set to 0.
Speedstrings are mapped to speedvalues in the following way:
'fastest' : 0
'fast' : 10
'normal' : 6
'slow' : 3
'slowest' : 1
speeds from 1 to 10 enforce increasingly faster animation of
line drawing and turtle turning.
Attention:
speed = 0 : *no* animation takes place. forward/back makes turtle jump
and likewise left/right make the turtle turn instantly.
Example (for a Turtle instance named turtle):
>>> turtle.speed(3)
i t fastesti
t fasti t normali t slowi t slowestg �?g %@Rf N( R� R! R� R� RN ( R� Rf t speeds( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRf s )
c G s� | r� t | � } | d k r/ | d } } n4 | d k rJ | \ } } n | d k rc | } } n | j | � } | j | � } | j d | d | � n" | j | j � | j | j � f Sd S( s� Return or set the pencolor and fillcolor.
Arguments:
Several input formats are allowed.
They use 0, 1, 2, or 3 arguments as follows:
color()
Return the current pencolor and the current fillcolor
as a pair of color specification strings as are returned
by pencolor and fillcolor.
color(colorstring), color((r,g,b)), color(r,g,b)
inputs as in pencolor, set both, fillcolor and pencolor,
to the given value.
color(colorstring1, colorstring2),
color((r1,g1,b1), (r2,g2,b2))
equivalent to pencolor(colorstring1) and fillcolor(colorstring2)
and analogously, if the other input format is used.
If turtleshape is a polygon, outline and interior of that polygon
is drawn with the newly set colors.
For mor info see: pencolor, fillcolor
Example (for a Turtle instance named turtle):
>>> turtle.color('red', 'green')
>>> turtle.color()
('red', 'green')
>>> colormode(255)
>>> color((40, 80, 120), (160, 200, 240))
>>> color()
('#285078', '#a0c8f0')
i i i i RO R; N( R� R� RN R� R R ( R� R2 R t pcolort fcolor( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR2 + s
c G sO | r; | j | � } | | j k r( d S| j d | � n | j | j � Sd S( sZ Return or set the pencolor.
Arguments:
Four input formats are allowed:
- pencolor()
Return the current pencolor as color specification string,
possibly in hex-number format (see example).
May be used as input to another color/pencolor/fillcolor call.
- pencolor(colorstring)
s is a Tk color specification string, such as "red" or "yellow"
- pencolor((r, g, b))
*a tuple* of r, g, and b, which represent, an RGB color,
and each of r, g, and b are in the range 0..colormode,
where colormode is either 1.0 or 255
- pencolor(r, g, b)
r, g, and b represent an RGB color, and each of r, g, and b
are in the range 0..colormode
If turtleshape is a polygon, the outline of that polygon is drawn
with the newly set pencolor.
Example (for a Turtle instance named turtle):
>>> turtle.pencolor('brown')
>>> tup = (0.2, 0.8, 0.55)
>>> turtle.pencolor(tup)
>>> turtle.pencolor()
'#33cc8c'
NRO ( R� R RN R� ( R� R2 R2 ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRO Y s c G sO | r; | j | � } | | j k r( d S| j d | � n | j | j � Sd S( s] Return or set the fillcolor.
Arguments:
Four input formats are allowed:
- fillcolor()
Return the current fillcolor as color specification string,
possibly in hex-number format (see example).
May be used as input to another color/pencolor/fillcolor call.
- fillcolor(colorstring)
s is a Tk color specification string, such as "red" or "yellow"
- fillcolor((r, g, b))
*a tuple* of r, g, and b, which represent, an RGB color,
and each of r, g, and b are in the range 0..colormode,
where colormode is either 1.0 or 255
- fillcolor(r, g, b)
r, g, and b represent an RGB color, and each of r, g, and b
are in the range 0..colormode
If turtleshape is a polygon, the interior of that polygon is drawn
with the newly set fillcolor.
Example (for a Turtle instance named turtle):
>>> turtle.fillcolor('violet')
>>> col = turtle.pencolor()
>>> turtle.fillcolor(col)
>>> turtle.fillcolor(0, .5, 0)
NR; ( R� R RN R� ( R� R2 R2 ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR; ~ s c C s | j d t � d S( s� Makes the turtle visible.
Aliases: showturtle | st
No argument.
Example (for a Turtle instance named turtle):
>>> turtle.hideturtle()
>>> turtle.showturtle()
t shownN( RN R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRe � s c C s | j d t � d S( sY Makes the turtle invisible.
Aliases: hideturtle | ht
No argument.
It's a good idea to do this while you're in the
middle of a complicated drawing, because hiding
the turtle speeds up the drawing observably.
Example (for a Turtle instance named turtle):
>>> turtle.hideturtle()
R0 N( RN R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRC � s c C s | j S( s� Return True if the Turtle is shown, False if it's hidden.
No argument.
Example (for a Turtle instance named turtle):
>>> turtle.hideturtle()
>>> print turtle.isvisible():
False
( R ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRG � s
c K s9 i
| j d 6| j d 6| j d 6| j d 6| j d 6| j d 6| j d 6| j d 6| j d 6| j d
6} | ps | sz | St
| t � r� | } n i } | j | � i } x | D] } | | | | <q� W| j
r� | j
j d | f � n t } d | k r | j | d k r t } q n d | k rxt
| d t � rY| j | d f � | d <n | j | d k rxt } qxn d | k r�| j | d k r�t } q�n | r�| j � n d | k r�| d | _ n d | k r�| d | _ n d | k r
| d | _ n d | k rVt
| d t � rF| j | d f � | d <n | d | _ n d | k rr| d | _ n d | k r�| d | _ n d | k r�| d } t
| t t t f � r�| | f } n | | _ n d | k r�| d | _ n d | k r| d | _ n d
| k r+| d
| _ n | j � d S(
s� Return or set the pen's attributes.
Arguments:
pen -- a dictionary with some or all of the below listed keys.
**pendict -- one or more keyword-arguments with the below
listed keys as keywords.
Return or set the pen's attributes in a 'pen-dictionary'
with the following key/value pairs:
"shown" : True/False
"pendown" : True/False
"pencolor" : color-string or color-tuple
"fillcolor" : color-string or color-tuple
"pensize" : positive number
"speed" : number in range 0..10
"resizemode" : "auto" or "user" or "noresize"
"stretchfactor": (positive number, positive number)
"outline" : positive number
"tilt" : number
This dictionary can be used as argument for a subsequent
pen()-call to restore the former pen-state. Moreover one
or more of these attributes can be provided as keyword-arguments.
This can be used to set several pen attributes in one statement.
Examples (for a Turtle instance named turtle):
>>> turtle.pen(fillcolor="black", pencolor="red", pensize=10)
>>> turtle.pen()
{'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,
'pencolor': 'red', 'pendown': True, 'fillcolor': 'black',
'stretchfactor': (1,1), 'speed': 3}
>>> penstate=turtle.pen()
>>> turtle.color("yellow","")
>>> turtle.penup()
>>> turtle.pen()
{'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,
'pencolor': 'yellow', 'pendown': False, 'fillcolor': '',
'stretchfactor': (1,1), 'speed': 3}
>>> p.pen(penstate, fillcolor="green")
>>> p.pen()
{'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,
'pencolor': 'red', 'pendown': True, 'fillcolor': 'green',
'stretchfactor': (1,1), 'speed': 3}
R0 RP RO R; RQ Rf RY t
stretchfactorRV Ri RN N( R R R R R R! R R" R$ R# R� t dictR% R� R� R� R� R� R� t _newLineR� R� R� Rk ( R� RN t pendictt _pdt pt _p_bufR� t newLinet sf( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRN � sz .
c C s d S( s/ dummy method - to be overwritten by child classN( ( R� t usePos( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR3 @ R� c C s d S( s/ dummy method - to be overwritten by child classN( ( R� R� t forced( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRk B R� c C s d S( s/ dummy method - to be overwritten by child classN( ( R� R2 ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� D R� c C s d S( s/ dummy method - to be overwritten by child classN( ( R� R2 ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� F R� N(! R� R� R� R� R R R� RY RQ RR RP RF Rf R2 RO R; Re RC RG RN R� R3 R� Rk R� R� Rp Ro RU RM R6 Rg RE ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR � s8 & . % $
u t _TurtleImagec B s e Z d Z d � Z d � Z RS( s6 Helper class: Datatype to store Turtle attributes
c C s# | | _ d | _ | j | � d S( N( R� R� R� t _setshape( R� R� t
shapeIndex( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR V s c C se | j } | | _ | j d k o6 | j | j k n r? d S| j d k oc | j | j k n rl d S| j d k r� | j | j � n3 | j d k r� x! | j D] } | j | � q� Wn | j | j | _ | j d k r� | j � | _ nl | j d k r#| j | j d j � | _ n> | j d k rag | j | j D] } | j � ^ qC| _ n d S( NR� R� R� RL ( R� R� ( R� R> R� R� Rj t _itemRX R� R� ( R� R> R� Ri ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR= [ s& )) ( R� R� R� R R= ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR< R s c B s e Z d Z g Z d8 e d e d e d d � Z d � Z d � Z d � Z d � Z
d � Z d
� Z d � Z
d8 d8 d � Z d
� Z d � Z d � Z d � Z d8 d � Z d8 d8 d8 d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d8 d � Z d � Z d � Z d � Z e! d � Z" d8 d � Z# d! � Z$ d" � Z% d8 d# � Z& d$ � Z' e( d% d9 d) � Z) d* � Z* d+ � Z+ d, � Z, d- � Z- d. � Z. e. Z/ d/ � Z0 d0 � Z1 d8 d1 � Z2 d2 d8 d3 � Z3 d2 d8 d4 � Z4 d2 d8 d5 � Z5 d6 � Z6 d7 � Z7 e Z8 RS(: sv Animation part of the RawTurtle.
Puts RawTurtle upon a TurtleScreen and provides tools for
its animation.
Rc R� R� c C s� t | t � r | | _ n� t | t � rX | t j k rL t j j | � n | | _ nz t | t t f � r� xb t j D]" } | j | k rw | | _ Pqw qw Wt | � | _ t j j | j � n t
d | � � | j } t j | | j
� � t j | � | j j | � | j � | _ t | | � | _ d | _ t | _ d | _ | _ | | _ t | _ | j � | _ | j g | _ | j g | _ g | _ | | _! t" | � | _# | j$ � d S( Ns bad canvas argument %s(% R� t _ScreenR� R R t screensRY R R RQ R� R� R R R R� Re t drawingLineItemR< R� R� t _polyR� t
_creatingPolyt _fillitemt _fillpathR t _hidden_from_screent currentLineItemR� t currentLineR� t
stampItemst _undobuffersizeR� R� Rk ( R� t canvasRc R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR x s@
c C s< t j | � t j | � | j � | j � | j � d S( s� Delete the turtle's drawings and restore its default values.
No argument.
,
Delete the turtle's drawings from the screen, re-center the turtle
and set variables to the default values.
Example (for a Turtle instance named turtle):
>>> turtle.position()
(0.00,-22.00)
>>> turtle.heading()
100.0
>>> turtle.reset()
>>> turtle.position()
(0.00,0.00)
>>> turtle.heading()
0.0
N( R� RX R R t _clearR� Rk ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRX � s
c C s7 | d k s | d k r$ d | _ n t | � | _ d S( s� Set or disable undobuffer.
Argument:
size -- an integer or None
If size is an integer an empty undobuffer of given size is installed.
Size gives the maximum number of turtle-actions that can be undone
by the undo() function.
If size is None, no undobuffer is present.
Example (for a Turtle instance named turtle):
>>> turtle.setundobuffer(42)
i N( R� R� R� ( R� t size( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR` � s c C s | j d k r d S| j j � S( s� Return count of entries in the undobuffer.
No argument.
Example (for a Turtle instance named turtle):
>>> while undobufferentries():
... undo()
i N( R� R� R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRn � s c C s� d | _ | _ x! | j D] } | j j | � q W| j j � | _ g | _ | j rn | j j
| j � n | j g | _ | j � | j
| j � d S( s Delete all of pen's drawingsN( R� RE RF R� R� Rj Re RH RI R RY R� R0 R` RK ( R� Ri ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRM � s
c C s | j � | j � d S( sg Delete the turtle's drawings from the screen. Do not move turtle.
No arguments.
Delete the turtle's drawings from the screen. Do not move turtle.
State and position of the turtle as well as drawings of other
turtles are not affected.
Examples (for a Turtle instance named turtle):
>>> turtle.clear()
N( RM Rk ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR. � s
c C sd | j j � | j j d k r# d St | j � d k r` | j j | j | j | j | j � n d S( Ni i ( R� R� R� R� RI Rg RH R R ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� � s
c C s� | j } | j d k r d S| j d k r\ | j � | j � | j � | j | j � nG | j � | j d k r� x | j � D] } | j � q� W| j � n d S( s& Perform a Turtle-data update.
i Ni ( R� R� R� R� Rk Rm R� R� R$ ( R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRk � s
c C s | j j | | � S( sm Turns turtle animation on/off and set delay for update drawings.
Optional arguments:
n -- nonnegative integer
delay -- nonnegative integer
If n is given, only each n-th regular screen update is really performed.
(Can be used to accelerate the drawing of complex graphics.)
Second arguments sets delay value (see RawTurtle.delay())
Example (for a Turtle instance named turtle):
>>> turtle.tracer(8, 25)
>>> dist = 2
>>> for i in range(200):
... turtle.fd(dist)
... turtle.rt(90)
... dist += 2
( R� R# ( R� t flagR ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR#
s c C s | j j | � S( N( R� R� ( R� R2 ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� %
s c C s | j j | � S( N( R� R� ( R� R2 ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� (
s c C s t | t � r | Sy | \ } } } Wn- t t f k
rU t d t | � � � n X| j j d k r� g | | | f D] } t d | � ^ qx \ } } } n d | k o� d k n o� d | k o� d k n o� d | k o� d k n s
t d t | � � � n d | | | f S( s, Convert colortriples to hexstrings.
s bad color arguments: %sg �?g �o@i i� s bad color sequence: %ss
#%02x%02x%02x( R� R� R� R� R� R� R� R� R� ( R� R2 R� R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _cc+
s 8Tc C sI | j } | j | j � | j } d | _ d | _ t | � } | | _ | | _ | | _ t | | j j � | _ | j j | � | j
| j j j } | d k r� | j � | j _
nr | d k r� | j | j
d j � | j _
nD | d k r,g | j
| j j j D] } | j � ^ q | j _
n | j � | _ | j � | S( s Create and return a clone of the turtle.
No argument.
Create and return a clone of the turtle with same position, heading
and turtle properties.
Example (for a Turtle instance named mick):
mick = Turtle()
joe = mick.clone()
R� R� RL R� N( R� R3 R R� R� R R< R> R� RY R� R� RX R? R� R� Re RH Rk ( R� R� R� t qt ttypeRi ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR1 :
s, " 5
c C s\ | d k r | j j S| | j j � k r> t d | � � n | j j | � | j � d S( s� Set turtle shape to shape with given name / return current shapename.
Optional argument:
name -- a string, which is a valid shapename
Set turtle shape to shape with given name or, if name is not given,
return name of current shape.
Shape with name must exist in the TurtleScreen's shape dictionary.
Initially there are the following polygon shapes:
'arrow', 'turtle', 'circle', 'square', 'triangle', 'classic'.
To learn about how to deal with shapes see Screen-method register_shape.
Example (for a Turtle instance named turtle):
>>> turtle.shape()
'arrow'
>>> turtle.shape("turtle")
>>> turtle.shape()
'turtle'
s There is no shape named %sN( R� R� R> R� R R� R= Rk ( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRc b
s
c C s� | | k o" | k o" d k n rF | j \ } } | | | j f S| d k r| | d k rm | | f } q� | | f } n+ | d k r� | j d | f } n | j } | d k r� | j } n | j d d d | d | � d S( sO Set/return turtle's stretchfactors/outline. Set resizemode to "user".
Optional arguments:
stretch_wid : positive number
stretch_len : positive number
outline : positive number
Return or set the pen's attributes x/y-stretchfactors and/or outline.
Set resizemode to "user".
If and only if resizemode is set to "user", the turtle will be displayed
stretched according to its stretchfactors:
stretch_wid is stretchfactor perpendicular to orientation
stretch_len is stretchfactor in direction of turtles orientation.
outline determines the width of the shapes's outline.
Examples (for a Turtle instance named turtle):
>>> turtle.resizemode("user")
>>> turtle.shapesize(5, 5, 12)
>>> turtle.shapesize(outline=8)
i RY R& R1 RV N( R� R" R$ RN ( R� t stretch_widt stretch_lenRV R1 ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRd }
s ' c C sK | | j | j } | t j d d t j } | j d d d | � d S( sZ Rotate the turtleshape to point in the specified direction
Optional argument:
angle -- number
Rotate the turtleshape to point in the direction specified by angle,
regardless of its current tilt-angle. DO NOT change the turtle's
heading (direction of movement).
Examples (for a Turtle instance named turtle):
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.settiltangle(45)
>>> stamp()
>>> turtle.fd(50)
>>> turtle.settiltangle(-45)
>>> stamp()
>>> turtle.fd(50)
g �f@i RY R& Ri N( R R� R� R� RN ( R� R� Ri ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR_ �
s c C s. | j d t j | j } | | j | j S( s� Return the current tilt-angle.
No argument.
Return the current tilt-angle, i. e. the angle between the
orientation of the turtleshape and the heading of the turtle
(its direction of movement).
Examples (for a Turtle instance named turtle):
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.tilt(45)
>>> turtle.tiltangle()
g �f@( R# R� R� R� R R ( R� Ri ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRj �
s c C s | j | | j � � d S( s� Rotate the turtleshape by angle.
Argument:
angle - a number
Rotate the turtleshape by angle from its current tilt-angle,
but do NOT change the turtle's heading (direction of movement).
Examples (for a Turtle instance named turtle):
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.tilt(30)
>>> turtle.fd(50)
>>> turtle.tilt(30)
>>> turtle.fd(50)
N( R_ Rj ( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRi �
s c
C s� | j } | j \ } } | j \ } } t | | | j | j � } d t | � | \ } } g | D]G \ } } | | | | | | j | | | | | | j f ^ qe S( sl Computes transformed polygon shapes from a shape
according to current position and heading.
g �?( R� R� R� R
RS RR R (
R� R� R� t p0t p1t e0t e1R~ R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt
_polytrafo�
s c C s} | j } | j | j j } | j } | j j } | j r�| j d k r�| j d k r�t | _
| j } | d k r�| j d k r� d } | } n� | j d k r� t
d | j d � } } | j } d } n3 | j d k r| j \ } } | j } | j } n g | D] \ }
} | |
| | f ^ q } t j | � t j | � } }
g | D]1 \ }
} |
|
| | | |
|
| f ^ qU} | j | � } | j | j } } | j | | d | d | d
| d t �qy| d k r�| j | | j | � qy| d
k ry| j \ } } | j } x� t | | � D]� \ } \ } } } g | D] \ }
} | |
| | f ^ qN} | j | � } | j | | d | j | � d | j | � d
| d t �q2Wqyn� | j
r�d S| d k r| j | d d d f d d � nn | d k r1| j | | j | j d j � n? | d
k rpx0 | D]% } | j | d d d f d d � qDWn t | _
d S( sp Manages the correct rendering of the turtle with respect to
its shape, resizemode, stretch and tilt etc.i R� R� i R% g @R& R: RV Rp R_ R� R� NR� RL ( i i ( i i ( i i ( i i ( i i ( i i ( R� R� R� R> R� R? R R� R� R� RG R� R t maxR R" R$ R# R� R� R| RY R R Ra R� R� R� t zipRP ( R� R� Rc RR t titemt tshapeRT t lxt lyRj R� R� t t0t t1t fct ocRi R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� �
s^ ' - > %- & "
&c C s | j } | j | j j } | j } | j } | d k r�| j � } | j d k rd d } | } n� | j d k r� t d | j d � } } | j } d } n3 | j d k r� | j
\ } } | j } | j } n g | D] \ }
} | |
| | f ^ q� } t
j | � t
j | � } }
g | D]1 \ }
} |
|
| | | |
|
| f ^ q%} | j | � } | j | j } } | j | | d | d | d
| d t �n6| d k r�| j d
� } | j | | j | � n| d k r�g } x' | D] } | j � } | j | � q�Wt | � } | j
\ } } | j } x� t | | � D]� \ } \ } } } g | D] \ }
} | |
| | f ^ qi} | j | � } | j | | d | j | � d | j | � d
| d t �qMWn | j j | � | j j d | f � | S( s� Stamp a copy of the turtleshape onto the canvas and return its id.
No argument.
Stamp a copy of the turtle shape onto the canvas at the current
turtle position. Return a stamp_id for that stamp, which can be
used to delete it by calling clearstamp(stamp_id).
Example (for a Turtle instance named turtle):
>>> turtle.color("blue")
>>> turtle.stamp()
13
>>> turtle.fd(50)
R� R� i R% g @i R& R: RV Rp R_ R� R� R� Rh ( R� R� R� R> R� R� RX R RZ R R" R$ R# R� R� R| RY R R Ra R� R� R� R� RY R� R[ RP RJ R� R� ( R� R� Rc RR R] t stitemRT R^ R_ Rj R� R� R` Ra Rb Rc t elementRi R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRh $ sV - >
%- #c C s | | j k re t | t � rB x1 | D] } | j j | � q% Wn | j j | � | j j | � n d | f } | j } | | j k r� d S| j j | � } | j j | � | | j k r� | j d | j
| _ n | j j | j d | j
d g � d S( s9 does the work for clearstamp() and clearstamps()
Rh Ni (
RJ R� R� R� Rj R� R� R� t indexR� R� t insertR� ( R� t stampidt subitemRi t bufRf ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _clearstamp` s
c C s | j | � | j � d S( sD Delete stamp with given stampid
Argument:
stampid - an integer, must be return value of previous stamp() call.
Example (for a Turtle instance named turtle):
>>> turtle.color("blue")
>>> astamp = turtle.stamp()
>>> turtle.fd(50)
>>> turtle.clearstamp(astamp)
N( Rk Rk ( R� Rh ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR/ v s
c C sn | d k r | j } n) | d k r5 | j | } n
| j | } x | D] } | j | � qI W| j � d S( s� Delete all or first/last n of turtle's stamps.
Optional argument:
n -- an integer
If n is None, delete all of pen's stamps,
else if n > 0 delete first n stamps
else if n < 0 delete last n stamps.
Example (for a Turtle instance named turtle):
>>> for i in range(8):
... turtle.stamp(); turtle.fd(30)
...
>>> turtle.clearstamps(2)
>>> turtle.clearstamps(-2)
>>> turtle.clearstamps()
i N( R� RJ Rk Rk ( R� R� t toDeleteRi ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR0 � s
c C sf | j | j | j t | j t � f } | j } d | j | | | j | j | j
| j � | j f f } | j r� | j j
| � n | j } | j r�| j d k r�| | } | d | j d | d | j d } d t | d d d | j | j � } | d | } x� t d | � D]s }
|
d k r=t } n t } | | |
| _ | j r�| j | j | | j f | j | j | � n | j � q"W| j r�| j | j d d f d d
d | j �q�n | j r�| j j | � n t | j t � r| j j | � n | | _ | j r6| j j | � n t | j � d k rX| j � n | j � d
S( s� Move the pen to the point end, thereby drawing a line
if pen is down. All other methods for turtle movement depend
on this one.
t goi i i g �?i g�������?g �?R: R� Rp i* N( i i ( i i ( R R R R� RF R� R� R� RH RI R� R� R� R� R! R� RR RS R� R� R� R� Rg RB Rk RY RD RC R� R3 ( R� R t go_modesR� t
undo_entryt startt difft diffsqt nhopst deltaR� R_ ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR � sR
(*
c C s | \ } } } } | \ } } } } | \ }
} } }
| j } t | j | � d k r` d GHn |
| _ | | _ | d d g k r� d } n | } | j |
| d | d | �g | j D]- } | |
k r� | j | � d k r� | ^ q� } x+ | D]# } | j | � | j j | � q� W| } | j
rQ| j d k rQ| | } | d | j d | d | j
d } d t | d d
d | j
| j
� } | d | } x{ t d | � D]j } | d k r�t } n t } | | | | _ | r| j | j | | j f | | | � n | j � q�W| rQ| j | j d d f d d d | �qQn | | _ | j r�t | j � d k r�| j j � n | j g k r�t | _ d | _ q�n | r�| j g k r�d | _ d
GHq�| j d k r�| j j � q�n | j � d S( s) Reverse a _goto. Used for undo()
g �?s$ undogoto: HALLO-DA-STIMMT-WAS-NICHT!i R� R: Rp R� i i i g�������?g �?s Unwahrscheinlich in _undogoto!N( i i ( i i ( i i ( i i ( R� R R� RH RI Rg R� R� Rj R� R! R� RR RS R� R� R� R� RB Rk RD R� RC R� R� RF ( R� t entryt oldt newRn t coodatat drawingt pct pst fillingt cLIt cLR� R� R� t usepcR� t todeleteRp Rq Rr Rs Rt R� R_ ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _undogoto� sd !
(* c C s� | j r( | j j d | | j f � n | | j 9} | j j | � } | j j } | d k r� | j d k r� d | j } d t t | � | � } d | | } x6 t
| � D]% } | j j | � | _ | j � q� Wn | | _ | j � d S( s& Turns pen clockwise by angle.
t roti i g @g �?N( R� R� R R� R� R� R� R! R� R R� Rk ( R� R� t neworientR� t anglevelR Rt R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR s
c C s� t | j � d k rb | j j | j | j | j | j � | j j � | _ | j j | j � n | j j | j d t
�g | _ | r� | j g | _ n d S( s� Closes current line item and starts a new one.
Remark: if current line became too long, animation
performance (via _drawline) slowed down considerably.
i R_ N( R� RI R� Rg RH R R Re R� RY R� R� ( R� R: ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR3 ) s c C sm t | j t � } | d k r" | S| j } d } } | r� t | j � d k r� | j j | j | j d | j �d | j f } q� n | r� | j j � | _ | j
j | j � | j g | _ d | j f } | j
� n d | _ | _ | j r_| d k r$| d k r\| j j | � q\q_| d
k rC| j j | � q_| j j d | | g � n | j � d S( s� Call fill(True) before drawing a shape to fill, fill(False) when done.
Optional argument:
flag -- True/False (or 1/0 respectively)
Call fill(True) before drawing the shape you want to fill,
and fill(False) when done.
When used without argument: return fillstate (True if filling,
False else)
Example (for a Turtle instance named turtle):
>>> turtle.fill(True)
>>> turtle.forward(100)
>>> turtle.left(90)
>>> turtle.forward(100)
>>> turtle.left(90)
>>> turtle.forward(100)
>>> turtle.left(90)
>>> turtle.forward(100)
>>> turtle.fill(False)
i R: t dofillt beginfillR
N( ( ( ( ( R� RF R� R� R� R� Ra RE R RX R� RY R� R3 R� R� Rk ( R� RO R| R� t entry1t entry2( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR: 9 s2
c C s | j t � d S( s� Called just before drawing a shape to be filled.
No argument.
Example (for a Turtle instance named turtle):
>>> turtle.begin_fill()
>>> turtle.forward(100)
>>> turtle.left(90)
>>> turtle.forward(100)
>>> turtle.left(90)
>>> turtle.forward(100)
>>> turtle.left(90)
>>> turtle.forward(100)
>>> turtle.end_fill()
N( R: R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR* l s c C s | j t � d S( s� Fill the shape drawn after the call begin_fill().
No argument.
Example (for a Turtle instance named turtle):
>>> turtle.begin_fill()
>>> turtle.forward(100)
>>> turtle.left(90)
>>> turtle.forward(100)
>>> turtle.left(90)
>>> turtle.forward(100)
>>> turtle.left(90)
>>> turtle.forward(100)
>>> turtle.end_fill()
N( R: R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR7 ~ s c G s� | st t | t t f � rF | j | � } | j t | j d � } q� | j } | s� | j t | j d � } q� n7 | d k r� | j t | j d � } n | j | � } t | j d � r
| j j
| j | | � } | j j
| � | j r�| j j d | f � q�n� | j � } | j rD| j j d g � t | j _ n zT | j � d k rf| j � n | j � | j | � | j | � | j d � Wd | j | � X| j r�t | j _ n d S( s� Draw a dot with diameter size, using color.
Optional arguments:
size -- an integer >= 1 (if given)
color -- a colorstring or a numeric color tuple
Draw a circular dot with diameter size, using color.
If size is not given, the maximum of pensize+4 and 2*pensize is used.
Example (for a Turtle instance named turtle):
>>> turtle.dot()
>>> turtle.fd(50); turtle.dot(20, "blue"); turtle.fd(50)
i t _dotR5 R
R% i N( R� R� R� R� R RZ R R� t hasattrR� R� R� R� RY R� R� RN R� R� RY RE RP RQ RO R< R� ( R� RN R2 Ri RN ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR5 � s:
c C s` | j j | j | | | | j � \ } } | j j | � | j r\ | j j d | f � n | S( s) Performs the writing for write()
t wri( R� R� R� R R� RY R� R� ( R� R{ R| Ry Ri R ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� � s RH t Ariali R* c C s� | j r+ | j j d g � t | j _ n | j t | � | j � | � } | rw | j � \ } } | j | | � n | j r� t | j _ n d S( s� Write text at the current turtle position.
Arguments:
arg -- info, which is to be written to the TurtleScreen
move (optional) -- True/False
align (optional) -- one of the strings "left", "center" or right"
font (optional) -- a triple (fontname, fontsize, fonttype)
Write text - the string representation of arg - at the current
turtle position according to align ("left", "center" or right")
and with the given font.
If move is True, the pen is moved to the bottom-right corner
of the text. By default, move is False.
Example (for a Turtle instance named turtle):
>>> turtle.write('Home = ', True, align="center")
>>> turtle.write((0,0), True)
R
N(
R� R� R� R� R� R� R� RS R] R� ( R� t argt moveR| Ry R R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRq � s ! c C s | j g | _ t | _ d S( s Start recording the vertices of a polygon.
No argument.
Start recording the vertices of a polygon. Current turtle position
is first point of polygon.
Example (for a Turtle instance named turtle):
>>> turtle.begin_poly()
N( R� RC R� RD ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR+ � s c C s
t | _ d S( s7 Stop recording the vertices of a polygon.
No argument.
Stop recording the vertices of a polygon. Current turtle position is
last point of polygon. This will be connected with the first point.
Example (for a Turtle instance named turtle):
>>> turtle.end_poly()
N( R� RD ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR8 � s c C s | j d k r t | j � Sd S( s� Return the lastly recorded polygon.
No argument.
Example (for a Turtle instance named turtle):
>>> p = turtle.get_poly()
>>> turtle.register_shape("myFavouriteShape", p)
N( RC R� R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR=
s
c C s | j S( s� Return the TurtleScreen object, the turtle is drawing on.
No argument.
Return the TurtleScreen object, the turtle is drawing on.
So TurtleScreen-methods can be called for that object.
Example (for a Turtle instance named turtle):
>>> ts = turtle.getscreen()
>>> ts
<turtle.TurtleScreen object at 0x0106B770>
>>> ts.bgcolor("pink")
( R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR?
s c C s | S( sU Return the Turtleobject itself.
No argument.
Only reasonable use: as a function to return the 'anonymous turtle':
Example:
>>> pet = getturtle()
>>> pet.fd(50)
>>> pet
<turtle.Turtle object at 0x0187D810>
>>> turtles()
[<turtle.Turtle object at 0x0187D810>]
( ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR@ "
s c C s | j j � d S( s� Returns the width of the turtle window.
No argument.
Example (for a TurtleScreen instance named screen):
>>> screen.window_width()
640
i ( R� R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR' :
s c C s | j j � d S( s� Return the height of the turtle window.
No argument.
Example (for a TurtleScreen instance named screen):
>>> screen.window_height()
480
i ( R� R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR& E
s c C s | j j | � S( sD Set delay value which determines speed of turtle animation.
( R� R ( R� R ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRm P
s i c C s- | j j | j j | | | � | j � d S( s� Bind fun to mouse-click event on this turtle on canvas.
Arguments:
fun -- a function with two arguments, to which will be assigned
the coordinates of the clicked point on the canvas.
btn -- number of the mouse-button defaults to 1 (left mouse button).
add -- True or False. If True, new binding will be added, otherwise
it will replace a former binding.
Example for the anonymous turtle, i. e. the procedural way:
>>> def turn(x, y):
... left(360)
...
>>> onclick(turn) # Now clicking into the turtle will turn it.
>>> onclick(None) # event-binding will be removed
N( R� R� R� R? Rk ( R� R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRJ W
s c C s- | j j | j j | | | � | j � d S( s� Bind fun to mouse-button-release event on this turtle on canvas.
Arguments:
fun -- a function with two arguments, to which will be assigned
the coordinates of the clicked point on the canvas.
btn -- number of the mouse-button defaults to 1 (left mouse button).
Example (for a MyTurtle instance named joe):
>>> class MyTurtle(Turtle):
... def glow(self,x,y):
... self.fillcolor("red")
... def unglow(self,x,y):
... self.fillcolor("")
...
>>> joe = MyTurtle()
>>> joe.onclick(joe.glow)
>>> joe.onrelease(joe.unglow)
Clicking on joe turns fillcolor red, unclicking turns it to
transparent.
N( R� R� R� R? Rk ( R� R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRL l
s c C s# | j j | j j | | | � d S( s� Bind fun to mouse-move event on this turtle on canvas.
Arguments:
fun -- a function with two arguments, to which will be assigned
the coordinates of the clicked point on the canvas.
btn -- number of the mouse-button defaults to 1 (left mouse button).
Every sequence of mouse-move-events on a turtle is preceded by a
mouse-click event on that turtle.
Example (for a Turtle instance named turtle):
>>> turtle.ondrag(turtle.goto)
Subsequently clicking and dragging a Turtle will move it
across the screen thereby producing handdrawings (if pen is
down).
N( R� R� R� R? ( R� R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRK �
s c C s� | j d k r d S| d k rV | \ } } | j | | | j � | j j � } n5| d k r| | d } | j | � n| d k r� | j | � n� | d k r� | d } | j j | � | j j
| � n� | d k r| d } | j j | d d d f d d
d d
�ny | d k r[| d } d | _ | _
| j j | � | j j
| � n0 | d
k r�t j | | d � | j j � n d S( s2 Does the main part of the work for undo()
NR� Rh i Rm R� R5 R� R: R� RV R� RN ( R� R5 ( i i ( i i ( i i ( R� R� R R R� R/ R� R� Rj R� R� Ra RE RF R RN ( R� t actionR� R� t degPAUt dummyRd Ri ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _undo�
s6
c C s� | j d k r d S| j j � } | d } | d } | d k rv xA | rr | j � } | j | d | d � qE Wn | j | | � d S( s� undo (repeatedly) the last turtle action.
No argument.
undo (repeatedly) the last turtle action.
Number of available undo actions is determined by the size of
the undobuffer.
Example (for a Turtle instance named turtle):
>>> for i in range(4):
... turtle.fd(50); turtle.lt(80)
...
>>> for i in range(8):
... turtle.undo()
...
Ni i R
( R� R� R� R� ( R� Ri R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRm �
s
N( R� i R* (9 R� R� R� RA R� R� R RX R` Rn RM R. R� Rk R# R� R� RP R1 Rc Rd R_ Rj Ri RY R� Rh Rk R/ R0 R R� R R� R3 R: R* R7 R5 R� R� Rq R+ R8 R= R? R@ R> R' R& Rm RJ RL RK R� Rm Rl ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR q sl %
( & 7 < 5 A 3 3
c C s% t j d k r t � t _ n t j S( s� Return the singleton screen object.
If none exists at the moment, create a new one and return it,
else return the existing one.N( R t _screenR� R@ ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR �
s R@ c B sp e Z d Z d Z e d Z d � Z e d e d e d e d d � Z d � Z d � Z
d � Z d
� Z RS( R" c C s� t j d k rK t � t _ | _ | j j t j � | j j | j � n t j d k r� t d } t d } t d } t d } t d } t d } | j j
| | | | � | j j � t _ t j
| t j � | j | | | | � n d S( NRp R� R� R� R� R� ( R@ t _rootR� R7 R" t _titleRE t _destroyR R� R< R= R R R ( R� Rp R� R� R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR �
s
Rp R� R� R� c C s t | j d � s d S| j j � } | j j � } t | t � rl d | k oZ d k n rl | | } n | d k r� | | d } n t | t � r� d | k o� d k n r� | | } n | d k r� | | d } n | j j | | | | � | j � d S( s Set the size and position of the main window.
Arguments:
width: as integer a size in pixels, as float a fraction of the screen.
Default is 50% of screen.
height: as integer the height in pixels, as float a fraction of the
screen. Default is 75% of screen.
startx: if positive, starting position in pixels from the left
edge of the screen, if negative from the right edge
Default, startx=None is to center window horizontally.
starty: if positive, starting position in pixels from the top
edge of the screen, if negative from the bottom edge
Default, starty=None is to center window vertically.
Examples (for a Screen instance named screen):
>>> screen.setup (width=200, height=200, startx=0, starty=0)
sets window to 200x200 pixels, in upper left of screen
>>> screen.setup(width=.75, height=0.5, startx=None, starty=None)
sets window to 75% of screen by 50% of screen and centers
RA Ni i i ( R� R� RG RI R� R� R� RA R% ( R� Rp R� R? R@ Rt t sh( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR s +
+
c C s/ t j d k r" t j j | � n | t _ d S( sq Set title of turtle-window
Argument:
titlestring -- a string, to appear in the titlebar of the
turtle graphics window.
This is a method of Screen-class. Not available for TurtleScreen-
objects.
Example (for a Screen instance named screen):
>>> screen.title("Welcome to the turtle-zoo!")
N( R@ R� R� R" R� ( R� t titlestring( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR" ( s
c C sV | j } | t j k r? d t _ d t _ d t _ d t _ n t t _ | j
� d S( N( R� R@ R� R R� R� R R� R R� RD ( R� t root( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� 9 s c C s | j � d S( s~ Shut the turtlegraphics window.
Example (for a TurtleScreen instance named screen):
>>> screen.bye()
N( R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR C s c sW � f d � } � j | � t d r* d Sy t � Wn t k
rR t d � n Xd S( sl Go into mainloop until the mouse is clicked.
No arguments.
Bind bye() method to mouseclick on TurtleScreen.
If "using_IDLE" - value in configuration dictionary is False
(default value), enter mainloop.
If IDLE with -n switch (no subprocess) is used, this value should be
set to True in turtle.cfg. In this case IDLE's mainloop
is active also for the client script.
This is a method of the Screen-class and not available for
TurtleScreen instances.
Example (for a Screen instance named screen):
>>> screen.exitonclick()
c s � j � d S( s& Screen.bye() with two dummy-parametersN( R ( R� R� ( R� ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt exitGracefully^ s R� Ni ( RJ R� Rv t AttributeErrort exit( R� R� ( ( R� s% /usr/lib64/python2.7/lib-tk/turtle.pyR K s
N(
R� R� R� R� R R� R� R R R" R� R R ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR@ �
s
'
c B s8 e Z d Z d Z d Z e d e d e d d � Z RS( s� RawTurtle auto-creating (scrolled) canvas.
When a Turtle object is created or a function derived from some
Turtle method is called a TurtleScreen object is automatically created.
Rc R� R� c C sG t j d k r t � t _ n t j | t j d | d | d | �d S( NRc R� R� ( R R� R� R R R ( R� Rc R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR r s N( R� R� R� R� R� R� R� R ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR i s t turtle_docstringdictc C sR i } x+ t D]# } d | } t | � j | | <q
Wx+ t D]# } d | } t | � j | | <q; Wt d | d � } t g | j � D]% } | j d � d t k r� | ^ q� � } | j d � x> | d D]2 } | j d t
| � � | j d
| | � q� W| d } | j d t
| � � | j d | | � | j d � | j � d
S( s� Create and write docstring-dictionary to file.
Optional argument:
filename -- a string, used as filename
default value is turtle_docstringdict
Has to be called explicitly, (not used by the turtle-graphics classes)
The docstring dictionary will be written to the Python script <filname>.py
It is intended to serve as a template for translation of the docstrings
into different languages.
s _Screen.s Turtle.s %s.pyRT R� i s docsdict = {
i����s %s :
s """%s
""",
s """%s
"""
s }
N( t _tg_screen_functionsR� R� t _tg_turtle_functionsR� R� R� R t _alias_listRq t reprR� ( R� t docsdictt
methodnameR� R� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyRt s&
(
c C sx d i | j � d 6} t | � } | j } xE | D]= } y | | t | � j _ Wq3 t k
ro d | GHq3 Xq3 Wd S( s� Read in docstrings from lang-specific docstring dictionary.
Transfer docstrings, translated to lang, from a dictionary-file
to the methods of classes Screen and Turtle and - in revised form -
to the corresponding functions.
s! turtle_docstringdict_%(language)sR� s Bad docstring-entry: %sN( R� t
__import__R� R� t im_funcR� R� ( t langt modnamet moduleR� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt read_docstrings� s
s Cannot find docsdict fors; Unknown Error when trying to import %s-docstring-dictionaryc
C s� d } } t | � t j k r1 | j } d } n | } d } t | � t j t j g k r�yg| j j } t | j j | | !� } | j j | | !} | j
p� g } t t d � | � � } d g t | � t | � | } t d � | | � } | j j
d @rF| j d | j j | � | j d | j j | � | d 7} n | j j
d @r�| j d | j j | � | j d | j j | � n d
j | � } d | } d
j | � } d | } Wq�q�Xn | | f S( s9 Get strings describing the arguments for the given objectR� i i c S s d t | � S( Ns =%s( R� ( R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt <lambda>� R� c S s | | S( N( ( R� t dflt( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyR� � R� i R i s **s , s (%s)( R� R� t
MethodTypeR� R� t
LambdaTypet func_codet co_argcountR� t co_varnamest
func_defaultst mapR� t co_flagsRY R (
t obt argText1t argText2t fobt argOffsett countert items2t realArgst defaultst items1( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt getmethparlist� s:
!
c C se d d l } | d k r d St d } | j d | d � } | j d | � } | j d | � } | S( s< To reduce docstrings from RawTurtle class for functions
i����NR� s %s.R� s \(.+ %s\):t :( t reR� R� t replacet compilet sub( t docstrR� t
turtlenamet newdocstrt parexp( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _turtle_docrevise� s
c C se d d l } | d k r d St d } | j d | d � } | j d | � } | j d | � } | S( s? To reduce docstrings from TurtleScreen class for functions
i����NR� s %s.R� s \(.+ %s\):R� ( R� R� R� R� R� R� ( R� R� t
screennameR� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _screen_docrevise� s
sr def {name}{paramslist}:
if {obj} is None:
if not TurtleScreen._RUNNING:
TurtleScreen._RUNNING = True
raise Terminator
{obj} = {init}
try:
return {obj}.{name}{argslist}
except TK.TclError:
if not TurtleScreen._RUNNING:
TurtleScreen._RUNNING = True
raise Terminator
raise
c
B s� x� | D]� } e | | � } e | � \ } } | d k rM d G| G| GHq n e j d | d | d | d | d | � } | e � U| | j � e � | _ q Wd S( NR� s >>>>>>t objt initR� t
paramslistt argslist( t getattrR� t __func_bodyt formatt globalsR� (
t functionsR� R� R� t docreviseR� R� t pl1t pl2t defstr( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt _make_global_funcs s
s Turtle._screens Screen()s Turtle._pens Turtle()t __main__c C s t � r t � n t � d S( N( RF RU RM ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt switchpen# s
c C s� t � t t � t � t d � t � t d � x� t d � D]� } | d k r_ t d � n x( t d � D] } t d � t
d � ql W| d k r� t d � t d � n t � t d
� t � q@ Wt d � t d � t t � t � t
d � t d � t
d � t d � t
d � t � t d
d � t d d � t d � x< t d � D]. } t d � t
d � t d � t
d � qXWt t � t d � x< t d � D]. } t d � t
d � t d � t
d � q�Wt d � d S( s Demo of old turtle.py - moduleid i i i i i iZ t marooni i R� i� t
startstartu startt redi N( RX R# R� Ro R) R6 Rp R� R: R< RH R2 R� RW Rq ( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt demo1) sX
c C sO t d � t � t d � t t d d � � t d d � d } t d � x( t d � D] } t � t | d � qX Wt
d � x t � r� t � q� Wt
� t d � t d � d } t d
� t d � t d � x� t d d
� D]� } | d k r t � t d d | d d | � n x( t d � D] } t | � t d � q+W| d 7} t d � t t � d d � q� Wt � t d � t � t d � t d � t � t d d � t d � t d � x? t d � D]1 } t d d � t d � t d � t d � q�Wt d � t d � t � t d � t � t d � t � } | j d � t � } | j d � | j d � | j
� | j d � | j d � | j � | j d d � | j d � | j � | j d � | j d d � | j d � | j d � t t | � � d } x� | j | � d k r�| j d � | j d! � | j | j | � � | j d � | d" d k r�| j! � | j! � t � n | d 7} q W| j
d# d$ d/ d' d( �| j d) � | j d* � d+ � } t" j# d � x! t � r| j � | j � q�W| j d � | j
d, d$ d0 �| j$ | d � d. S(1 s Demo of some new features.i i i g @iZ i i
s wait a moment...i� t greeni� i����i i ix i iF i R� t yellowi i2 R� R% u autoi i( i t blueu orangei g @g333333�?i s CAUGHT! Ry R� t boldR| u rightR� u redc S s t � t � d S( N( R R ( R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt baba� s s Click me!t CourierN( R� i R� ( R� i R� (% Rf Rg RQ R\ Rk R4 RZ R� R� R- Rq Rn Rm RX RI R RO R* R; R9 R7 RU RM R2 R: Rc R@ RY R RH Ro RA R6 Rh t timet sleepRJ ( R R� t laengeR� t triR� R� R� ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt demo2^ s�
(H R� t _vert TkinterR R� R� R� t ost os.pathR R R t copyR t _tg_classesR� R� t
_tg_utilitiest _math_functionst __all__R� R� R� R� R� R� R� R� R� R
R� R� R� R� R R R R8 R7 t objectRJ t ExceptionR� R� R R� R R� R R< R R
R R@ R R Rt R� t _LANGUAGEt ImportErrorR� R� R� R� R� Rv Ru R� R� R� R� R ( ( ( s% /usr/lib64/python2.7/lib-tk/turtle.pyt <module>e s�
!
%
4
c � K /&� � � � � � � � � � k � "
$
5 b FixTk.py 0000644 00000005712 15032720555 0006154 0 ustar 00 import sys, os
# Delay import _tkinter until we have set TCL_LIBRARY,
# so that Tcl_FindExecutable has a chance to locate its
# encoding directory.
# Unfortunately, we cannot know the TCL_LIBRARY directory
# if we don't know the tcl version, which we cannot find out
# without import Tcl. Fortunately, Tcl will itself look in
# <TCL_LIBRARY>\..\tcl<TCL_VERSION>, so anything close to
# the real Tcl library will do.
# Expand symbolic links on Vista
try:
import ctypes
ctypes.windll.kernel32.GetFinalPathNameByHandleW
except (ImportError, AttributeError):
def convert_path(s):
return s
else:
def convert_path(s):
assert isinstance(s, str) # sys.prefix contains only bytes
udir = s.decode("mbcs")
hdir = ctypes.windll.kernel32.\
CreateFileW(udir, 0x80, # FILE_READ_ATTRIBUTES
1, # FILE_SHARE_READ
None, 3, # OPEN_EXISTING
0x02000000, # FILE_FLAG_BACKUP_SEMANTICS
None)
if hdir == -1:
# Cannot open directory, give up
return s
buf = ctypes.create_unicode_buffer(u"", 32768)
res = ctypes.windll.kernel32.\
GetFinalPathNameByHandleW(hdir, buf, len(buf),
0) # VOLUME_NAME_DOS
ctypes.windll.kernel32.CloseHandle(hdir)
if res == 0:
# Conversion failed (e.g. network location)
return s
s = buf[:res].encode("mbcs")
# Ignore leading \\?\
if s.startswith("\\\\?\\"):
s = s[4:]
if s.startswith("UNC"):
s = "\\" + s[3:]
return s
prefix = os.path.join(sys.prefix,"tcl")
if not os.path.exists(prefix):
# devdir/externals/tcltk/lib
tcltk = 'tcltk'
if sys.maxsize > 2**31 - 1:
tcltk = 'tcltk64'
prefix = os.path.join(sys.prefix, "externals", tcltk, "lib")
prefix = os.path.abspath(prefix)
# if this does not exist, no further search is needed
if os.path.exists(prefix):
prefix = convert_path(prefix)
if "TCL_LIBRARY" not in os.environ:
for name in os.listdir(prefix):
if name.startswith("tcl"):
tcldir = os.path.join(prefix,name)
if os.path.isdir(tcldir):
os.environ["TCL_LIBRARY"] = tcldir
# Compute TK_LIBRARY, knowing that it has the same version
# as Tcl
import _tkinter
ver = str(_tkinter.TCL_VERSION)
if "TK_LIBRARY" not in os.environ:
v = os.path.join(prefix, 'tk'+ver)
if os.path.exists(os.path.join(v, "tclIndex")):
os.environ['TK_LIBRARY'] = v
# We don't know the Tix version, so we must search the entire
# directory
if "TIX_LIBRARY" not in os.environ:
for name in os.listdir(prefix):
if name.startswith("tix"):
tixdir = os.path.join(prefix,name)
if os.path.isdir(tixdir):
os.environ["TIX_LIBRARY"] = tixdir
ScrolledText.pyc 0000644 00000005150 15032720555 0007702 0 ustar 00 �
z fc @ s� d Z d g Z d d l m Z m Z m Z m Z m Z m Z d d l m
Z
m Z m Z m
Z
d e f d � � YZ d � Z e d k r� e � n d S( s A ScrolledText widget feels like a text widget but also has a
vertical scroll bar on its right. (Later, options may be added to
add a horizontal bar as well, to make the bars disappear
automatically when not needed, to move them to the other side of the
window, etc.)
Configuration options are passed to the Text widget.
A Frame widget is inserted between the master and the text, to hold
the Scrollbar widget.
Most methods calls are inherited from the Text widget; Pack, Grid and
Place methods are redirected to the Frame widget however.
t ScrolledTexti����( t Framet Textt Scrollbart Packt Gridt Place( t RIGHTt LEFTt Yt BOTHc B s e Z d d � Z d � Z RS( c K sK t | � | _ t | j � | _ | j j d t d t � | j i | j j d 6� t j
| | j | � | j d t d t d t
� | j | j d <t t � j � } t t � j � t t � j � t t � j � } t | � j | � } xU | D]M } | d d k r� | d k r� | d k r� t | | t | j | � � q� q� Wd S(
Nt sidet fillt yscrollcommandt expandt commandi t _t configt configure( R t frameR t vbart packR R t updatet setR t __init__R R
t Truet yviewt varst keysR R R t
differencet setattrt getattr( t selft mastert kwt
text_methst methodst m( ( s+ /usr/lib64/python2.7/lib-tk/ScrolledText.pyR s 2
(c C s
t | j � S( N( t strR ( R ( ( s+ /usr/lib64/python2.7/lib-tk/ScrolledText.pyt __str__( s N( t __name__t
__module__t NoneR R' ( ( ( s+ /usr/lib64/python2.7/lib-tk/ScrolledText.pyR s c C sx d d l } d d l m } t d d d d � } | j | | j � | j d t d t d t � | j
� | j � d S(
Ni����( t ENDt bgt whitet heighti
R R R ( t __main__t TkconstantsR+ R t insertt __doc__R R
R R t focus_sett mainloop( R/ R+ t stext( ( s+ /usr/lib64/python2.7/lib-tk/ScrolledText.pyt example, s
R/ N( R2 t __all__t TkinterR R R R R R R0 R R R R
R R6 R( ( ( ( s+ /usr/lib64/python2.7/lib-tk/ScrolledText.pyt <module> s ."
ttk.pyo 0000644 00000172244 15032720555 0006115 0 ustar 00 �
z fc @ sY d Z d Z d Z d d d d d d d d
d d d
d d d d d d d d d d d d d g Z d d l Z d d l m Z m Z m Z m Z e j d k r� e
n e Z d � Z
e d � Z e e d! � Z d" � Z e d# � Z e d$ � Z d% d& d' � Z d( � Z d) � Z d* � Z d+ � Z d, � Z d- � Z d. � Z d/ � Z e d0 � Z d e f d1 � � YZ d2 e j f d3 � � YZ d e f d4 � � YZ! d e f d5 � � YZ" d e e j# f d6 � � YZ# d e# f d7 � � YZ$ d e f d8 � � YZ% d e f d9 � � YZ& d e f d: � � YZ' e' Z( d e f d; � � YZ) d e f d< � � YZ* d
e e j+ f d= � � YZ, e, Z+ d e f d> � � YZ- d e f d? � � YZ. d e e j/ f d@ � � YZ/ d e e j0 f dA � � YZ0 d e f dB � � YZ1 d e f dC � � YZ2 d e e j3 e j4 f dD � � YZ5 d e% e f dE � � YZ6 d e) f dF � � YZ7 d S(G s� Ttk wrapper.
This module provides classes to allow using Tk themed widget set.
Ttk is based on a revised and enhanced version of
TIP #48 (http://tip.tcl.tk/48) specified style engine.
Its basic idea is to separate, to the extent possible, the code
implementing a widget's behavior from the code implementing its
appearance. Widget class bindings are primarily responsible for
maintaining the widget state and invoking callbacks, all aspects
of the widgets appearance lies at Themes.
s 0.3.1s! Guilherme Polo <ggpolo@gmail.com>t Buttont Checkbuttont Comboboxt Entryt Framet Labelt
Labelframet
LabelFramet
Menubuttont Notebookt Panedwindowt PanedWindowt Progressbart Radiobuttont Scalet Scrollbart Separatort Sizegript Stylet Treeviewt LabeledScalet
OptionMenut
tclobjs_to_pyt setup_masteri����N( t _flattent _joint
_stringifyt
_splitdictg !@c C sa t r] d d l } | j j d � } | rA | j j d | � n | j j d � t | _ n d S( Ni����t TILE_LIBRARYs( global auto_path; lappend auto_path {%s}s package require tile( t
_REQUIRE_TILEt ost environt gett tkt evalt Truet _tile_loaded( t masterR t tilelib( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt
_load_tile" s c C s= | r t | � } n$ t | t t f � r9 t | � } n | S( s Internal function.( R t
isinstancet listt tupleR ( t valuet script( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt _format_optvalue1 s
c C sy g } xf | j � D]X \ } } | s2 | | k r | j d | � | d k rk | j t | | � � qk q q Wt | � S( s� Formats optdict to a tuple to pass it to tk.call.
E.g. (script=False):
{'foreground': 'blue', 'padding': [1, 2, 3, 4]} returns:
('-foreground', 'blue', '-padding', '1 2 3 4')s -%sN( t iteritemst appendt NoneR- R ( t optdictR, t ignoret optst optR+ ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt _format_optdict; s c C s� g } x� | D] } | d } | d } | d t | � d k rT | d pN d } n d j | � } | j | � | d k r
| j | � q
q
W| S( Ni����i i t t ( t lent joinR/ R0 ( t itemst opt_valt itemt statet val( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt _mapdict_valuesK s
c C sS g } x@ | j � D]2 \ } } | j d | t t | � | � f � q Wt | � S( s� Formats mapdict to pass it to tk.call.
E.g. (script=False):
{'expand': [('active', 'selected', 'grey'), ('focus', [1, 2, 3, 4])]}
returns:
('-expand', '{active selected} grey focus {1, 2, 3, 4}')s -%s( R. t extendR- R? R ( t mapdictR, R3 R4 R+ ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt _format_mapdictd s
c O s d } d } | d
k r� | d k rW | d } t t | d � � } d | | f } n9 | d \ } } t t | d � � }
d | | |
f } t | | � } nD | d k r� | d } t | � d k r� t | d | � f } q� n | rd | } d
j | � } n | | f S( sA Formats args and kw according to the given element factory etype.t imaget vsapii i s %s %si s %s %s %st froms {%s}R7 N( ( RC RD ( R0 R R? R5 R8 R- R9 ( t etypeR, t argst kwt specR3 t inamet imagespect
class_namet part_idt statemap( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt _format_elemcreateu s&
i i c
C s g } x� | D]� } | \ } } | p( i } d j t | t d � � } d d | | | rc d | n d f } d | k r� | j | d � | | 7} t | d | | � \ } } | j | � | | 8} | j d d | � q
| j | � q
Wd j | � | f S(
s$ Formats a layout list so we can pass the result to ttk::style
layout and ttk::style settings. Note that the layout doesn't have to
be a list necessarily.
E.g.:
[("Menubutton.background", None),
("Menubutton.button", {"children":
[("Menubutton.focus", {"children":
[("Menubutton.padding", {"children":
[("Menubutton.label", {"side": "left", "expand": 1})]
})]
})]
}),
("Menubutton.indicator", {"side": "right"})
]
returns:
Menubutton.background
Menubutton.button -children {
Menubutton.focus -children {
Menubutton.padding -children {
Menubutton.label -side left -expand 1
}
}
}
Menubutton.indicator -side rightR7 t childrens %s%s%ss %sR6 s -children {s %s}s
( RP ( R9 R5 R# R/ t _format_layoutlist(
t layoutt indentt indent_sizeR, t layout_elemt elemR3 t foptst headt newscript( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyRQ � s
'
c C s� g } x�| j � D]�\ } } | j d � rd d j t | d t � � } | j d | | f � n | j d � r� d j t | d t � � } | j d | | f � n d | k r� | d s� d } n t | d � \ } } | j d | | f � n | j d � r | d } | d
} d } x4 | t | � k rWt | | d � rW| d 7} q$W| d | !} | t | � k r�| | r�| | n i }
t
| t | |
� \ } } | j d
| | | | f � q q Wd j | � S( s� Returns an appropriate script, based on settings, according to
theme_settings definition to be used by theme_settings and
theme_create.t configureR7 s ttk::style configure %s %s;t maps ttk::style map %s %s;RR t nulls ttk::style layout %s {
%s
}s element createi i R. s% ttk::style element create %s %s %s %ss
( R. R R9 R5 R# R/ RB RQ R8 t hasattrRO ( t settingsR, t nameR3 t st _t eoptsRF t argct elemargst elemkwRI ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt _script_from_settings� s2
)
, c C s� g } xp | D]h } t | d d � } | d k rA | j | � q
t | � } | d k rh | j � } n | j | � q
Wt | � } g t | | � D] } t | � ^ q� S( st Construct a list from the given statespec tuple according to the
accepted statespec accepted by _format_mapdict.t typenamet StateSpecN( t getattrR0 R/ t strt splitt itert zipR ( t stuplet nvalR> Rg t itRI ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt _list_from_statespec� s
c C s� | j | � } g } d } x� | t | � k r� | | } i } | j | | f � | d 7} x| | t | � k r� | | | d !\ } } | j d � s� Pn | d } | d 7} | d k r� t | | � } n | | | <q` Wq W| S( sp Construct a list from the tuple returned by ttk::layout, this is
somewhat the reverse of _format_layoutlist.i i i t -RP ( t splitlistR8 R/ t
startswitht _list_from_layouttuple( R! t ltuplet rest indxR_ R3 R4 R> ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyRu s$
c G sF t | � } | j | | � } t | � d r3 | St | | d t �S( sh Format options then call Tk command with args and options and return
the appropriate result.
If no option is specified, a dict is returned. If an option is
specified with the None value, the value for that option is returned.
Otherwise, the function just sets the passed options and the caller
shouldn't be expecting a return value anyway.i t conv( R5 t callR8 R t
_tclobj_to_py( R! t optionsRG Rw ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt _val_or_dict" s
c C s: t | � } y t | � } Wn t t f k
r5 n X| S( sA Converts a value to, hopefully, a more appropriate Python object.( t unicodet intt
ValueErrort TypeError( R+ ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt _convert_stringval2 s c C s= t | t � r9 d | k r* t | � } q9 t | � } n | S( Nt .( R( Rj t floatR ( t x( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt
_to_number< s
c C s� | rb t | d � rb t | t � rb t | d d d � d k rP t | � } q� t t | � } n t | d � r� t | � } n | S( s8 Return value converted from Tcl object to Python object.t __len__i Rg Rh N( R] R( t
basestringRi R0 Rq R[ R� ( R> ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR{ D s % c C s1 x* | j � D] \ } } t | � | | <q
W| S( sO Returns adict with its values converted from Tcl objects to Python
objects.( R: R{ ( t adictR4 R> ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR Q s c C s@ | d k r< t j r- t j p' t j � } q< t d � � n | S( s If master is not None, itself is returned. If master is None,
the default master is returned if there is one, otherwise a new
master is created and returned.
If it is not allowed to use the default root and master is None,
RuntimeError is raised.sI No master specified and Tkinter is configured to not support default rootN( R0 t Tkintert _support_default_roott
_default_roott Tkt RuntimeError( R% ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR Y s c B s� e Z d Z d Z d d � Z d d � Z d d � Z d d d � Z d d � Z d � Z
d � Z d � Z d d d
� Z
d � Z d � Z d d
� Z RS( s Manipulate style database.s
ttk::stylec C sG t | � } t | d t � s+ t | � n | | _ | j j | _ d S( NR$ ( R Ri t FalseR' R% R! ( t selfR% ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt __init__o s
c K s5 | d k r d | | <n t | j | | j d | � S( s� Query or sets the default value of the specified option(s) in
style.
Each key in kw is an option and each value is either a string or
a sequence identifying the value for that option.RZ N( R0 R} R! t _name( R� t stylet query_optRH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyRZ z s
c K sr | d k r> t | j j | j j | j d | d | � � � St | j | j j | j d | t | � � d t �S( sS Query or sets dynamic values of the specified option(s) in
style.
Each key in kw is an option and each value should be a list or a
tuple (usually) containing statespecs grouped in tuples, or list,
or something else of your preference. A statespec is compound of
one or more states and then a value.R[ s -%sRy N( R0 Rq R! Rs Rz R� R RB R{ ( R� R� R� RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR[ � s &$c C sA | r d j | � n d } | j j | j d | d | | | � S( s Returns the value specified for option in style.
If state is specified it is expected to be a sequence of one
or more states. If the default argument is set, it is used as
a fallback value in case no specification for option is found.R7 R6 t lookups -%s( R9 R! Rz R� ( R� R� t optionR= t default( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c C s\ d } | r t | � d } n | d k r4 d } n t | j | j j | j d | | � � S( s� Define the widget layout for given style. If layoutspec is
omitted, return the layout specification for given style.
layoutspec is expected to be a list or an object different than
None that evaluates to False if you want to "turn off" that style.
If it is a list (or tuple, or something else), each item should be
a tuple where the first item is the layout name and the second item
should have the format described below:
LAYOUTS
A layout can contain the value None, if takes no options, or
a dict of options specifying how to arrange the element.
The layout mechanism uses a simplified version of the pack
geometry manager: given an initial cavity, each element is
allocated a parcel. Valid options/values are:
side: whichside
Specifies which side of the cavity to place the
element; one of top, right, bottom or left. If
omitted, the element occupies the entire cavity.
sticky: nswe
Specifies where the element is placed inside its
allocated parcel.
children: [sublayout... ]
Specifies a list of elements to place inside the
element. Each element is a tuple (or other sequence)
where the first item is the layout name, and the other
is a LAYOUT.i R\ RR N( R0 RQ Ru R! Rz R� ( R� R� t
layoutspect lspec( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyRR � s c O sD t | t | | � \ } } | j j | j d d | | | | � d S( s9 Create a new element in the current theme of given etype.t elementt createN( RO R� R! Rz R� ( R� t elementnameRF RG RH RI R3 ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt element_create� s c C s% | j j | j j | j d d � � S( s: Returns the list of elements defined in the current theme.R� t names( R! Rs Rz R� ( R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt
element_names� s c C s( | j j | j j | j d d | � � S( s) Return the list of elementname's options.R� R| ( R! Rs Rz R� ( R� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt element_options� s c C so | r t | � n d } | rI | j j | j d d | d | d | � n" | j j | j d d | d | � d S( s. Creates a new theme.
It is an error if themename already exists. If parent is
specified, the new theme will inherit styles, elements and
layouts from the specified parent theme. If settings are present,
they are expected to have the same syntax used for theme_settings.R6 t themeR� s -parents -settingsN( Rf R! Rz R� ( R� t themenamet parentR^ R, ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt theme_create� s c C s/ t | � } | j j | j d d | | � d S( s� Temporarily sets the current theme to themename, apply specified
settings and then restore the previous theme.
Each key in settings is a style and each value may contain the
keys 'configure', 'map', 'layout' and 'element create' and they
are expected to have the same format as specified by the methods
configure, map, layout and element_create respectively.R� R^ N( Rf R! Rz R� ( R� R� R^ R, ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt theme_settings� s c C s% | j j | j j | j d d � � S( s# Returns a list of all known themes.R� R� ( R! Rs Rz R� ( R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt theme_names� s c C s3 | d k r | j j d � S| j j d | � d S( s� If themename is None, returns the theme in use, otherwise, set
the current theme to themename, refreshes all widgets and emits
a <<ThemeChanged>> event.s return $ttk::currentThemes
ttk::setThemeN( R0 R! R" Rz ( R� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt theme_use s N( t __name__t
__module__t __doc__R� R0 R� RZ R[ R� RR R� R� R� R� R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR j s + t Widgetc B s; e Z d Z d d � Z d � Z d d � Z d d � Z RS( s! Base class for Tk themed widgets.c C sK t | � } t | d t � s+ t | � n t j j | | | d | �d S( s� Constructs a Ttk Widget with the parent master.
STANDARD OPTIONS
class, cursor, takefocus, style
SCROLLABLE WIDGET OPTIONS
xscrollcommand, yscrollcommand
LABEL WIDGET OPTIONS
text, textvariable, underline, image, compound, width
WIDGET STATES
active, disabled, focus, pressed, selected, background,
readonly, alternate, invalid
R$ RH N( R Ri R� R' R� R� R� ( R� R% t
widgetnameRH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� s
c C s | j j | j d | | � S( s� Returns the name of the element at position x, y, or the empty
string if the point does not lie within any element.
x and y are pixel coordinates relative to the widget.t identify( R! Rz t _w( R� R� t y( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� . s c O sM | j j | j j | j d d j | � � � } | rI | rI | | | � S| S( s1 Test the widget's state.
If callback is not specified, returns True if the widget state
matches statespec and False otherwise. If callback is specified,
then it will be invoked with *args, **kw if the widget state
matches statespec. statespec is expected to be a sequence.t instateR7 ( R! t
getbooleanRz R� R9 ( R� t statespect callbackRG RH t ret( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� 6 s
'
c C sI | d k r d j | � } n | j j t | j j | j d | � � � S( s Modify or inquire widget state.
Widget state is returned if statespec is None, otherwise it is
set according to the statespec flags and then a new state spec
is returned indicating which flags were changed. statespec is
expected to be a sequence.R7 R= N( R0 R9 R! Rs Rj Rz R� ( R� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR= E s N( R� R� R� R0 R� R� R� R= ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� s
c B s# e Z d Z d d � Z d � Z RS( sc Ttk Button widget, displays a textual label and/or image, and
evaluates a command when pressed.c K s t j | | d | � d S( s Construct a Ttk Button widget with the parent master.
STANDARD OPTIONS
class, compound, cursor, image, state, style, takefocus,
text, textvariable, underline, width
WIDGET-SPECIFIC OPTIONS
command, default, width
s ttk::buttonN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� V s c C s | j j | j d � S( s/ Invokes the command associated with the button.t invoke( R! Rz R� ( R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� e s N( R� R� R� R0 R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR R s c B s# e Z d Z d d � Z d � Z RS( s; Ttk Checkbutton widget which is either in on- or off-state.c K s t j | | d | � d S( s' Construct a Ttk Checkbutton widget with the parent master.
STANDARD OPTIONS
class, compound, cursor, image, state, style, takefocus,
text, textvariable, underline, width
WIDGET-SPECIFIC OPTIONS
command, offvalue, onvalue, variable
s ttk::checkbuttonN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� m s c C s | j j | j d � S( sW Toggles between the selected and deselected states and
invokes the associated command. If the widget is currently
selected, sets the option variable to the offvalue option
and deselects the widget; otherwise, sets the option variable
to the option onvalue.
Returns the result of the associated command.R� ( R! Rz R� ( R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� | s N( R� R� R� R0 R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR j s c B s8 e Z d Z d d d � Z d � Z d � Z d � Z RS( se Ttk Entry widget displays a one-line text string and allows that
string to be edited by the user.c K s t j | | | p d | � d S( s� Constructs a Ttk Entry widget with the parent master.
STANDARD OPTIONS
class, cursor, style, takefocus, xscrollcommand
WIDGET-SPECIFIC OPTIONS
exportselection, invalidcommand, justify, show, state,
textvariable, validate, validatecommand, width
VALIDATION MODES
none, key, focus, focusin, focusout, all
s
ttk::entryN( R� R� ( R� R% t widgetRH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c C s" | j | j j | j d | � � S( sq Return a tuple of (x, y, width, height) which describes the
bounding box of the character given by index.t bbox( t _getintsR! Rz R� ( R� t index( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c C s | j j | j d | | � S( sx Returns the name of the element at position x, y, or the
empty string if the coordinates are outside the window.R� ( R! Rz R� ( R� R� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c C s" | j j | j j | j d � � S( s� Force revalidation, independent of the conditions specified
by the validate option. Returns False if validation fails, True
if it succeeds. Sets or clears the invalid state accordingly.t validate( R! R� Rz R� ( R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s N( R� R� R� R0 R� R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR � s
c B s/ e Z d Z d d � Z d d � Z d � Z RS( sM Ttk Combobox widget combines a text field with a pop-down list of
values.c K s t j | | d | � d S( s Construct a Ttk Combobox widget with the parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
exportselection, justify, height, postcommand, state,
textvariable, values, width
s
ttk::comboboxN( R R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c C sG | d k r. | j j | j j | j d � � S| j j | j d | � S( s If newindex is supplied, sets the combobox value to the
element at position newindex in the list of values. Otherwise,
returns the index of the current value in the list of values
or -1 if the current value does not appear in the list.t currentN( R0 R! t getintRz R� ( R� t newindex( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s "c C s | j j | j d | � d S( s( Sets the value of the combobox to value.t setN( R! Rz R� ( R� R+ ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s N( R� R� R� R0 R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR � s
c B s e Z d Z d d � Z RS( sJ Ttk Frame widget is a container, used to group other widgets
together.c K s t j | | d | � d S( s� Construct a Ttk Frame with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
borderwidth, relief, padding, width, height
s
ttk::frameN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s N( R� R� R� R0 R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR � s c B s e Z d Z d d � Z RS( s7 Ttk Label widget displays a textual label and/or image.c K s t j | | d | � d S( sG Construct a Ttk Label with parent master.
STANDARD OPTIONS
class, compound, cursor, image, style, takefocus, text,
textvariable, underline, width
WIDGET-SPECIFIC OPTIONS
anchor, background, font, foreground, justify, padding,
relief, text, wraplength
s
ttk::labelN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s
N( R� R� R� R0 R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR � s c B s e Z d Z d d � Z RS( s� Ttk Labelframe widget is a container used to group other widgets
together. It has an optional label, which may be a plain text string
or another widget.c K s t j | | d | � d S( s� Construct a Ttk Labelframe with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
labelanchor, text, underline, padding, labelwidget, width,
height
s ttk::labelframeN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s N( R� R� R� R0 R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR � s c B s e Z d Z d d � Z RS( sb Ttk Menubutton widget displays a textual label and/or image, and
displays a menu when pressed.c K s t j | | d | � d S( s Construct a Ttk Menubutton with parent master.
STANDARD OPTIONS
class, compound, cursor, image, state, style, takefocus,
text, textvariable, underline, width
WIDGET-SPECIFIC OPTIONS
direction, menu
s ttk::menubuttonN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� s N( R� R� R� R0 R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR
s c B sz e Z d Z d d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d d � Z d d � Z d
� Z
d � Z RS(
s� Ttk Notebook widget manages a collection of windows and displays
a single one at a time. Each child window is associated with a tab,
which the user may select to change the currently-displayed window.c K s t j | | d | � d S( s\ Construct a Ttk Notebook with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
height, padding, width
TAB OPTIONS
state, sticky, padding, text, image, compound, underline
TAB IDENTIFIERS (tab_id)
The tab_id argument found in several methods may take any of
the following forms:
* An integer between zero and the number of tabs
* The name of a child window
* A positional specification of the form "@x,y", which
defines the tab
* The string "current", which identifies the
currently-selected tab
* The string "end", which returns the number of tabs (only
valid for method index)
s
ttk::notebookN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� % s c K s& | j j | j d | t | � � d S( s� Adds a new tab to the notebook.
If window is currently managed by the notebook but hidden, it is
restored to its previous position.t addN( R! Rz R� R5 ( R� t childRH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� E s c C s | j j | j d | � d S( sX Removes the tab specified by tab_id, unmaps and unmanages the
associated window.t forgetN( R! Rz R� ( R� t tab_id( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� M s c C s | j j | j d | � d S( s� Hides the tab specified by tab_id.
The tab will not be displayed, but the associated window remains
managed by the notebook and its configuration remembered. Hidden
tabs may be restored with the add command.t hideN( R! Rz R� ( R� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� S s c C s | j j | j d | | � S( sZ Returns the name of the tab element at position x, y, or the
empty string if none.R� ( R! Rz R� ( R� R� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� \ s c C s% | j j | j j | j d | � � S( s| Returns the numeric index of the tab specified by tab_id, or
the total number of tabs if tab_id is the string "end".R� ( R! R� Rz R� ( R� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� b s c K s) | j j | j d | | t | � � d S( s� Inserts a pane at the specified position.
pos is either the string end, an integer index, or the name of
a managed child. If child is already managed by the notebook,
moves it to the specified position.t insertN( R! Rz R� R5 ( R� t posR� RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� h s c C s | j j | j d | � S( s� Selects the specified tab.
The associated child window will be displayed, and the
previously-selected window (if different) is unmapped. If tab_id
is omitted, returns the widget name of the currently selected
pane.t select( R! Rz R� ( R� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� q s c K s5 | d k r d | | <n t | j | | j d | � S( s� Query or modify the options of the specific tab_id.
If kw is not given, returns a dict of the tab option values. If option
is specified, returns the value of that option. Otherwise, sets the
options to the corresponding values.t tabN( R0 R} R! R� ( R� R� R� RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� { s
c C s( | j j | j j | j d � p$ d � S( s2 Returns a list of windows managed by the notebook.t tabs( ( R! Rs Rz R� ( R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c C s | j j d | j � d S( s� Enable keyboard traversal for a toplevel window containing
this notebook.
This will extend the bindings for the toplevel window containing
this notebook as follows:
Control-Tab: selects the tab following the currently selected
one
Shift-Control-Tab: selects the tab preceding the currently
selected one
Alt-K: where K is the mnemonic (underlined) character of any
tab, will select that tab.
Multiple notebooks in a single toplevel may be enabled for
traversal, including nested notebooks. However, notebook traversal
only works properly if all panes are direct children of the
notebook.s ttk::notebook::enableTraversalN( R! Rz R� ( R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt enable_traversal� s N( R� R� R� R0 R� R� R� R� R� R� R� R� R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR s
c B sG e Z d Z d d � Z e j j Z d � Z d d � Z d d � Z
RS( sf Ttk Panedwindow widget displays a number of subwindows, stacked
either vertically or horizontally.c K s t j | | d | � d S( s� Construct a Ttk Panedwindow with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
orient, width, height
PANE OPTIONS
weight
s ttk::panedwindowN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c K s) | j j | j d | | t | � � d S( s� Inserts a pane at the specified positions.
pos is either the string end, and integer index, or the name
of a child. If child is already managed by the paned window,
moves it to the specified position.R� N( R! Rz R� R5 ( R� R� R� RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c K s5 | d k r d | | <n t | j | | j d | � S( sQ Query or modify the options of the specified pane.
pane is either an integer index or the name of a managed subwindow.
If kw is not given, returns a dict of the pane option values. If
option is specified then the value for that option is returned.
Otherwise, sets the options to the corresponding values.t paneN( R0 R} R! R� ( R� R� R� RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s
c C s( | j j | j j | j d | | � � S( sL If newpos is specified, sets the position of sash number index.
May adjust the positions of adjacent sashes to ensure that
positions are monotonically increasing. Sash positions are further
constrained to be between 0 and the total size of the widget.
Returns the new position of sash number index.t sashpos( R! R� Rz R� ( R� R� t newpos( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s N( R� R� R� R0 R� R� R R� R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR
� s c B s; e Z d Z d d � Z d d � Z d d � Z d � Z RS( s6 Ttk Progressbar widget shows the status of a long-running
operation. They can operate in two modes: determinate mode shows the
amount completed relative to the total amount of work to be done, and
indeterminate mode provides an animated display to let the user know
that something is happening.c K s t j | | d | � d S( s� Construct a Ttk Progressbar with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
orient, length, mode, maximum, value, variable, phase
s ttk::progressbarN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c C s | j j | j d | � d S( s� Begin autoincrement mode: schedules a recurring timer event
that calls method step every interval milliseconds.
interval defaults to 50 milliseconds (20 steps/second) if omitted.t startN( R! Rz R� ( R� t interval( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c C s | j j | j d | � d S( sR Increments the value option by amount.
amount defaults to 1.0 if omitted.t stepN( R! Rz R� ( R� t amount( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c C s | j j | j d � d S( sV Stop autoincrement mode: cancels any recurring timer event
initiated by start.t stopN( R! Rz R� ( R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� s N( R� R� R� R0 R� R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR � s
c B s# e Z d Z d d � Z d � Z RS( se Ttk Radiobutton widgets are used in groups to show or change a
set of mutually-exclusive options.c K s t j | | d | � d S( s Construct a Ttk Radiobutton with parent master.
STANDARD OPTIONS
class, compound, cursor, image, state, style, takefocus,
text, textvariable, underline, width
WIDGET-SPECIFIC OPTIONS
command, value, variable
s ttk::radiobuttonN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� s c C s | j j | j d � S( s� Sets the option variable to the option value, selects the
widget, and invokes the associated command.
Returns the result of the command, or an empty string if
no command is specified.R� ( R! Rz R� ( R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� s N( R� R� R� R0 R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR
s c B s5 e Z d Z d d � Z d d � Z d d d � Z RS( s Ttk Scale widget is typically used to control the numeric value of
a linked variable that varies uniformly over some range.c K s t j | | d | � d S( s� Construct a Ttk Scale with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
command, from, length, orient, to, value, variable
s
ttk::scaleN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� * s c K sa | r | j | � n t j | | � t d | k d | k d | k g � r] | j d � n d S( s� Modify or query scale options.
Setting a value for any of the "from", "from_" or "to" options
generates a <<RangeChanged>> event.RE t from_t tos <<RangeChanged>>N( t updateR� RZ t anyt event_generate( R� t cnfRH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyRZ 8 s
'c C s | j j | j d | | � S( s� Get the current value of the value option, or the value
corresponding to the coordinates x, y if they are specified.
x and y are pixel coordinates relative to the scale widget
origin.R ( R! Rz R� ( R� R� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR D s N( R� R� R� R0 R� RZ R ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR & s c B s e Z d Z d d � Z RS( s; Ttk Scrollbar controls the viewport of a scrollable widget.c K s t j | | d | � d S( s� Construct a Ttk Scrollbar with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
command, orient
s ttk::scrollbarN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� P s N( R� R� R� R0 R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR M s c B s e Z d Z d d � Z RS( sI Ttk Separator widget displays a horizontal or vertical separator
bar.c K s t j | | d | � d S( s� Construct a Ttk Separator with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
orient
s ttk::separatorN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� b s N( R� R� R� R0 R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR ^ s c B s e Z d Z d d � Z RS( sl Ttk Sizegrip allows the user to resize the containing toplevel
window by pressing and dragging the grip.c K s t j | | d | � d S( s� Construct a Ttk Sizegrip with parent master.
STANDARD OPTIONS
class, cursor, state, style, takefocus
s
ttk::sizegripN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� t s N( R� R� R� R0 R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR p s c B sd e Z d Z d! d � Z d! d � Z d! d � Z d � Z d! d � Z d � Z d � Z
d � Z d! d � Z d! d
� Z
d � Z d � Z d
� Z d � Z d � Z d � Z d! d � Z d! d � Z d � Z e Z d � Z d � Z d � Z d � Z d! d! d � Z d � Z d � Z d � Z d � Z d! d! d � Z! d! d! d � Z" d! d � Z# d! d � Z$ RS(" s� Ttk Treeview widget displays a hierarchical collection of items.
Each item has a textual label, an optional image, and an optional list
of data values. The data values are displayed in successive columns
after the tree label.c K s t j | | d | � d S( s� Construct a Ttk Treeview with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus, xscrollcommand,
yscrollcommand
WIDGET-SPECIFIC OPTIONS
columns, displaycolumns, height, padding, selectmode, show
ITEM OPTIONS
text, image, values, open, tags
TAG OPTIONS
foreground, background, font, image
s
ttk::treeviewN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c C s+ | j | j j | j d | | � � p* d S( sT Returns the bounding box (relative to the treeview widget's
window) of the specified item in the form x y width height.
If column is specified, returns the bounding box of that cell.
If the item is not visible (i.e., if it is a descendant of a
closed item or is scrolled offscreen), returns an empty string.R� R6 ( R� R! Rz R� ( R� R< t column( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c C s1 | j j | j j | j d | p$ d � p- d � S( sh Returns a tuple of children belonging to item.
If item is not specified, returns root children.RP R6 ( ( R! Rs Rz R� ( R� R< ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt get_children� s c G s | j j | j d | | � d S( s� Replaces item's child with newchildren.
Children present in item that are not present in newchildren
are detached from tree. No items in newchildren may be an
ancestor of item.RP N( R! Rz R� ( R� R< t newchildren( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt set_children� s c K s5 | d k r d | | <n t | j | | j d | � S( s
Query or modify the options for the specified column.
If kw is not given, returns a dict of the column option values. If
option is specified then the value for that option is returned.
Otherwise, sets the options to the corresponding values.R� N( R0 R} R! R� ( R� R� R� RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s
c G s | j j | j d | � d S( s_ Delete all specified items and all their descendants. The root
item may not be deleted.t deleteN( R! Rz R� ( R� R: ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c G s | j j | j d | � d S( s� Unlinks all of the specified items from the tree.
The items and all of their descendants are still present, and may
be reinserted at another point in the tree, but will not be
displayed. The root item may not be detached.t detachN( R! Rz R� ( R� R: ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c C s% | j j | j j | j d | � � S( sS Returns True if the specified item is present in the tree,
False otherwise.t exists( R! R� Rz R� ( R� R< ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c C s | j j | j d | � S( s} If item is specified, sets the focus item to item. Otherwise,
returns the current focus item, or '' if there is none.t focus( R! Rz R� ( R� R< ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c K sy | j d � } | rD t | t � rD | j j | | j � | d <n | d k r] d | | <n t | j | | j d | � S( s_ Query or modify the heading options for the specified column.
If kw is not given, returns a dict of the heading option values. If
option is specified then the value for that option is returned.
Otherwise, sets the options to the corresponding values.
Valid options/values are:
text: text
The text to display in the column heading
image: image_name
Specifies an image to display to the right of the column
heading
anchor: anchor
Specifies how the heading text should be aligned. One of
the standard Tk anchor values
command: callback
A callback to be invoked when the heading label is
pressed.
To configure the tree column heading, call this with column = "#0" t commandt headingN(
R R( R� R% t registert _substituteR0 R} R! R� ( R� R� R� RH t cmd( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s
c C s | j j | j d | | | � S( s� Returns a description of the specified component under the
point given by x and y, or the empty string if no such component
is present at that position.R� ( R! Rz R� ( R� t componentR� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c C s | j d d | � S( s. Returns the item ID of the item at position y.t rowi ( R� ( R� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt identify_row s c C s | j d | d � S( sa Returns the data column identifier of the cell at position x.
The tree column has ID #0.R� i ( R� ( R� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt identify_column s c C s | j d | | � S( s� Returns one of:
heading: Tree heading area.
separator: Space between two columns headings;
tree: The tree area.
cell: A data cell.
* Availability: Tk 8.6t region( R� ( R� R� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt identify_region s c C s | j d | | � S( sE Returns the element at position x, y.
* Availability: Tk 8.6R� ( R� ( R� R� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt identify_element s c C s% | j j | j j | j d | � � S( sO Returns the integer index of item within its parent's list
of children.R� ( R! R� Rz R� ( R� R< ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� # s c K sg t | � } | d k rB | j j | j d | | d | | � } n! | j j | j d | | | � } | S( s� Creates a new item and return the item identifier of the newly
created item.
parent is the item ID of the parent item, or the empty string
to create a new top-level item. index is an integer, or the value
end, specifying where in the list of parent's children to insert
the new item. If index is less than or equal to zero, the new node
is inserted at the beginning, if index is greater than or equal to
the current number of children, it is inserted at the end. If iid
is specified, it is used as the item identifier, iid must not
already exist in the tree. Otherwise, a new unique identifier
is generated.R� s -idN( R5 R0 R! Rz R� ( R� R� R� t iidRH R3 Rw ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� ) s
!c K s5 | d k r d | | <n t | j | | j d | � S( s- Query or modify the options for the specified item.
If no options are given, a dict with options/values for the item
is returned. If option is specified then the value for that option
is returned. Otherwise, sets the options to the corresponding
values as given by kw.R< N( R0 R} R! R� ( R� R< R� RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR< @ s
c C s# | j j | j d | | | � d S( sR Moves item to position index in parent's list of children.
It is illegal to move an item under one of its descendants. If
index is less than or equal to zero, item is moved to the
beginning, if greater than or equal to the number of children,
it is moved to the end. If item was detached it is reattached.t moveN( R! Rz R� ( R� R< R� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� L s c C s | j j | j d | � S( se Returns the identifier of item's next sibling, or '' if item
is the last child of its parent.t next( R! Rz R� ( R� R< ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� X s c C s | j j | j d | � S( sa Returns the ID of the parent of item, or '' if item is at the
top level of the hierarchy.R� ( R! Rz R� ( R� R< ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� ^ s c C s | j j | j d | � S( sj Returns the identifier of item's previous sibling, or '' if
item is the first child of its parent.t prev( R! Rz R� ( R� R< ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� d s c C s | j j | j d | � d S( s� Ensure that item is visible.
Sets all of item's ancestors open option to True, and scrolls
the widget if necessary so that item is within the visible
portion of the tree.t seeN( R! Rz R� ( R� R< ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� j s c C sC t | t � r | f } n | j j | j j | j d | | � � S( s2 If selop is not specified, returns selected items.t selection( R( R� R! Rs Rz R� ( R� t selopR: ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� s s c C s | j d | � d S( s items becomes the new selection.R� N( R� ( R� R: ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt
selection_setz s c C s | j d | � d S( s Add items to the selection.R� N( R� ( R� R: ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt
selection_add s c C s | j d | � d S( s Remove items from the selection.t removeN( R� ( R� R: ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt selection_remove� s c C s | j d | � d S( s1 Toggle the selection state of each item in items.t toggleN( R� ( R� R: ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt selection_toggle� s c C s] | j j | j d | | | � } | d k rU | d k rU t | j | d t d t �S| Sd S( s; Query or set the value of given item.
With one argument, return a dictionary of column/value pairs
for the specified item. With two arguments, return the current
value of the specified column. With three arguments, set the
value of given column in given item to the specified value.R� t cut_minusRy N( R! Rz R� R0 R R� R{ ( R� R< R� R+ Rw ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s
!
c C s, | j | j d d | f | | d d �d S( s� Bind a callback for the given event sequence to the tag tagname.
When an event is delivered to an item, the callbacks for each
of the item's tags option are called.t tagt bindR� i N( t _bindR� ( R� t tagnamet sequenceR� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt tag_bind� s c K s8 | d k r d | | <n t | j | | j d d | � S( sB Query or modify the options for the specified tagname.
If kw is not given, returns a dict of the option settings for tagname.
If option is specified, returns the value for that option for the
specified tagname. Otherwise, sets the options to the corresponding
values for the given tagname.R� RZ N( R0 R} R! R� ( R� R� R� RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt
tag_configure� s
c C sc | d k r4 | j j | j j | j d d | � � S| j j | j j | j d d | | � � Sd S( s� If item is specified, returns 1 or 0 depending on whether the
specified item has the given tagname. Otherwise, returns a list of
all items which have the specified tag.
* Availability: Tk 8.6R� t hasN( R0 R! Rs Rz R� R� ( R� R� R< ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt tag_has� s
N(% R� R� R� R0 R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R< R� t reattachR� R� R� R� R� R� R� R� R� R� R� R R ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR ~ sD
c B sV e Z d Z d d d d d � Z d � Z d � Z d � Z d � Z e e e � Z
RS( s� A Ttk Scale widget with a Ttk Label widget indicating its
current value.
The Ttk Scale can be accessed through instance.scale, and Ttk Label
can be accessed through instance.labeli i
c K sp | j d d � d k | _ t j | | | � | p@ t j | � | _ | j j | � | | _ t | � | _
t | d | j d | d | �| _ | j j
d | j � | j r� d n d } | d k r� d n d } | j j d | d d
� t | � j d | � } | j
j d | d k r$d n d
� | j j d | j � | _ | j
d | j � | j
d | j � d S( s� Construct a horizontal LabeledScale with parent master, a
variable to be associated with the Ttk Scale widget and its range.
If variable is not specified, a Tkinter.IntVar is created.
WIDGET-SPECIFIC OPTIONS
compound: 'top' or 'bottom'
Specifies how to display the label relative to the scale.
Defaults to 'top'.
t compoundt topt variableR� R� s <<RangeChanged>>t bottomt sidet fillR� t anchort nR` t ws <Configure>s <Map>N( t popt
_label_topR R� R� t IntVart _variableR� t _last_validR t labelR t scaleR� t _adjustt packt placet trace_variablet _LabeledScale__tracecb( R� R% R R� R� RH t
scale_sidet
label_sidet tmp( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s $%c C sW y | j j d | j � Wn t k
r- n X| ` t j | � d | _ d | _ d S( s9 Destroy this widget and possibly its associated variable.R N( R t
trace_vdeleteR t AttributeErrorR t destroyR0 R R ( R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR � s
c s� � f d � } t � j d � } t � j d � } | | k rQ | | } } n � j j � } | | k ow | k n s� � j � _ d S| � _ | � j d <� j | � d S( s1 Adjust the label position according to the scale.c s� � j � � j j � \ } } � j rG � j j � � j j � } n � j j � � j j � } � j j d | d | � d S( NR� R� ( t update_idletasksR t coordsR t winfo_yR t winfo_reqheightt place_configure( R� R� ( R� ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt adjust_label� s
RE R� Nt text( R� R R R R R+ R t
after_idle( R� RG R$ R� R� t newval( ( R� s" /usr/lib64/python2.7/lib-tk/ttk.pyR � s
c C s
| j j � S( s Return current scale value.( R R ( R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt
_get_value s c C s | j j | � d S( s Set new scale value.N( R R� ( R� R> ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt
_set_value s N( R� R� R� R0 R� R R R( R) t propertyR+ ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR � s # c B s8 e Z d Z d d � Z d � Z d d � Z d � Z RS( sm Themed OptionMenu, based after Tkinter's OptionMenu, which allows
the user to select a value from a menu.c O s� i | d 6| j d d � d 6| j d d � d 6} t j | | | � t j | d t �| d <| | _ | j d d � | _ | r� t j d | j
� j � � � n | j | | � d S( s9 Construct a themed OptionMenu widget with master as the parent,
the resource textvariable set to variable, the initially selected
value specified by the default parameter, the menu values given by
*values and additional keywords.
WIDGET-SPECIFIC OPTIONS
style: stylename
Menubutton style.
direction: 'above', 'below', 'left', 'right', or 'flush'
Menubutton direction.
command: callback
A callback that will be invoked after selecting an item.
t textvariableR� t directiont tearofft menuR� s unknown option -%sN(
R
R0 R R� R� t MenuR� R t _callbackt TclErrort iterkeysR� t set_menu( R� R% R R� t valuest kwargsRH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� & s c C s5 | d k r% | j t j | | � � St j | | � S( NR. ( t nametowidgetR t __getitem__( R� R< ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR7 C s c G s| | d } | j d d � xB | D]: } | j d | d t j | j | | j � d | j � q! W| rx | j j | � n d S( sU Build a new menu of radiobuttons with *values and optionally
a default value.R. i t endR R� R N( R� t add_radiobuttonR� t _setitR R0 R� ( R� R� R4 R. R> ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR3 J s
c C s/ y
| ` Wn t k
r n Xt j | � d S( s0 Destroy this widget and its associated variable.N( R R R R ( R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR X s
N( R� R� R� R0 R� R7 R3 R ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR " s
(8 R� t __version__t
__author__t __all__R� R R R R t TkVersionR# R� R R' R- R0 R5 R? RB RO RQ Rf Rq Ru R} R� R� R{ R R t objectR R� R R R R R R R R R R R R
R R
R R R R t XViewt YViewR R R ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt <module>
sf "
%1 *
�B *"� 8* ' "� Da Tix.pyc 0000644 00000273532 15032720555 0006045 0 ustar 00 �
z fc @ sx d d l Z d d l Z d d l Td d l m Z m Z e d k rP e d � n d d l Z d Z d Z d Z d Z
d
Z d Z d Z
d
Z d Z d Z d Z d Z d Z d Z d Z d Z d Z d Z d Z d Z d Z d Z d� Z d� Z d� Z d� Z d� Z! d! Z" d" d� d# � � YZ# d$ e j$ e# f d% � � YZ$ d& d� d' � � YZ% e j& j' e% f e j& _' d( e j& f d) � � YZ( d* e( f d+ � � YZ) d, d� d- � � YZ* d. e( f d/ � � YZ+ d0 e( f d1 � � YZ, d2 e( f d3 � � YZ- d4 e( f d5 � � YZ. d6 e( f d7 � � YZ/ d8 e( f d9 � � YZ0 d: e( f d; � � YZ1 d< e( f d= � � YZ2 d> e( f d? � � YZ3 d@ e( f dA � � YZ4 dB e( f dC � � YZ5 dD e( f dE � � YZ6 dF e( f dG � � YZ7 dH e( e8 e9 f dI � � YZ: dJ e( f dK � � YZ; dL e( f dM � � YZ< dN e( f dO � � YZ= dP e( f dQ � � YZ> dR e( f dS � � YZ? dT e( f dU � � YZ@ dV e( f dW � � YZA dX e( f dY � � YZB dZ e( f d[ � � YZC d\ e( f d] � � YZD d^ e( f d_ � � YZE d` e( f da � � YZF db e( f dc � � YZG dd e( f de � � YZH df e( f dg � � YZI dh e( f di � � YZJ dj e( f dk � � YZK dl e( f dm � � YZL dn e( f do � � YZM dp e( f dq � � YZN dr e( e8 e9 f ds � � YZO dt e( f du � � YZP dv e( f dw � � YZQ dx eR e) f dy � � YZS dz eT e) f d{ � � YZU d| eV e) f d} � � YZW d~ eX e) f d � � YZY d� eZ e) f d� � � YZ[ d� e\ e) f d� � � YZ] d� e^ e) f d� � � YZ_ d� e` e) f d� � � YZa d� eb e) f d� � � YZc d� ed e) f d� � � YZe d� eG e) f d� � � YZf d� e: e) f d� � � YZg d� eF e) f d� � � YZh d� eO e) f d� � � YZi d� e- e) f d� � � YZj d� e/ e) f d� � � YZk d� e1 e) f d� � � YZl d� e2 e) f d� � � YZm d� e5 e) f d� � � YZn d� e- e) f d� � � YZo d� eN e) f d� � � YZp d� eA e) f d� � � YZq d� eC e) f d� � � YZr d� � Zs d� � Zt d� e( f d� � � YZu d� e( e8 e9 f d� � � YZv d� ev f d� � � YZw d S(� i����N( t *( t _flattent _cnfmergegˡE��@s0 This version of Tix.py requires Tk 4.0 or highert windowt textt statust immediatet imaget imagetextt balloont autot acrosstopt asciit cellt columnt
decreasingt
increasingt integert maint maxt realt rows s-regions x-regions y-regioni i i i i i t
tixCommandc B s_ e Z d Z d � Z d � Z d d � Z d d � Z d � Z d � Z d � Z
d d � Z RS(
s� The tix commands provide access to miscellaneous elements
of Tix's internal state and the Tix application context.
Most of the information manipulated by these commands pertains
to the application as a whole, or to a screen or
display, rather than to a particular window.
This is a mixin class, assumed to be mixed to Tkinter.Tk
that supports the self.tk.call method.
c C s | j j d d | � S( s� Tix maintains a list of directories under which
the tix_getimage and tix_getbitmap commands will
search for image files. The standard bitmap directory
is $TIX_LIBRARY/bitmaps. The addbitmapdir command
adds directory into this list. By using this
command, the image files of an applications can
also be located using the tix_getimage or tix_getbitmap
command.
t tixt addbitmapdir( t tkt call( t selft directory( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt tix_addbitmapdirV s
c C s | j j d d | � S( s� Returns the current value of the configuration
option given by option. Option may be any of the
options described in the CONFIGURATION OPTIONS section.
R t cget( R R ( R t option( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt tix_cgetb s c K s� | r t | | f � } n | r0 t | � } n | d k rL | j d d � St | t � rr | j d d d | � S| j j d | j | � � S( s� Query or modify the configuration options of the Tix application
context. If no option is specified, returns a dictionary all of the
available options. If option is specified with no value, then the
command returns a list describing the one named option (this list
will be identical to the corresponding sublist of the value
returned if no option is specified). If one or more option-value
pairs are specified, then the command modifies the given option(s)
to have the given value(s); in this case the command returns an
empty string. Option may be any of the configuration options.
R t configuret -N( R R! ( R t Nonet
_getconfiguret
isinstancet
StringTypet _getconfigure1R R t _options( R t cnft kw( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
tix_configurei s c C s9 | d k r" | j j d d | � S| j j d d � Sd S( s� Returns the file selection dialog that may be shared among
different calls from this application. This command will create a
file selection dialog widget when it is called the first time. This
dialog will be returned by all subsequent calls to tix_filedialog.
An optional dlgclass parameter can be passed to specified what type
of file selection dialog widget is desired. Possible options are
tix FileSelectDialog or tixExFileSelectDialog.
R t
filedialogN( R# R R ( R t dlgclass( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt tix_filedialog s c C s | j j d d | � S( s� Locates a bitmap file of the name name.xpm or name in one of the
bitmap directories (see the tix_addbitmapdir command above). By
using tix_getbitmap, you can avoid hard coding the pathnames of the
bitmap files in your application. When successful, it returns the
complete pathname of the bitmap file, prefixed with the character
'@'. The returned value can be used to configure the -bitmap
option of the TK and Tix widgets.
R t getbitmap( R R ( R t name( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
tix_getbitmap� s c C s | j j d d | � S( s� Locates an image file of the name name.xpm, name.xbm or name.ppm
in one of the bitmap directories (see the addbitmapdir command
above). If more than one file with the same name (but different
extensions) exist, then the image type is chosen according to the
depth of the X display: xbm images are chosen on monochrome
displays and color images are chosen on color displays. By using
tix_ getimage, you can avoid hard coding the pathnames of the
image files in your application. When successful, this command
returns the name of the newly created image, which can be used to
configure the -image option of the Tk and Tix widgets.
R t getimage( R R ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt tix_getimage� s c C s | j j d d d | � S( s@ Gets the options maintained by the Tix
scheme mechanism. Available options include:
active_bg active_fg bg
bold_font dark1_bg dark1_fg
dark2_bg dark2_fg disabled_fg
fg fixed_font font
inactive_bg inactive_fg input1_bg
input2_bg italic_font light1_bg
light1_fg light2_bg light2_fg
menu_font output1_bg output2_bg
select_bg select_fg selector
R R t get( R R ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt tix_option_get� s c C sE | d k r( | j j d d | | | � S| j j d d | | � Sd S( s� Resets the scheme and fontset of the Tix application to
newScheme and newFontSet, respectively. This affects only those
widgets created after this call. Therefore, it is best to call the
resetoptions command before the creation of any widgets in a Tix
application.
The optional parameter newScmPrio can be given to reset the
priority level of the Tk options set by the Tix schemes.
Because of the way Tk handles the X option database, after Tix has
been has imported and inited, it is not possible to reset the color
schemes and font sets using the tix config command. Instead, the
tix_resetoptions command must be used.
R t resetoptionsN( R# R R ( R t newSchemet
newFontSett
newScmPrio( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt tix_resetoptions� s N( t __name__t
__module__t __doc__R R R# R+ R. R1 R3 R5 R: ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR K s t Tkc B s) e Z d Z d d d d � Z d � Z RS( s{ Toplevel widget of Tix which represents mostly the main window
of an application. It has an associated Tcl interpreter.t Tixc C s� t j j | | | | � t j j d � } | j j d � | d k rr | j j d | � | j j d | � n | j j d � d S( Nt TIX_LIBRARYs< global auto_path; lappend auto_path [file dir [info nameof]]s( global auto_path; lappend auto_path {%s}s, global tcl_pkgPath; lappend tcl_pkgPath {%s}s package require Tix( t TkinterR> t __init__t ost environR4 R t evalR# ( R t
screenNamet baseNamet classNamet tixlib( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s c C s$ | j d d � t j j | � d S( Nt WM_DELETE_WINDOWt ( t protocolRA R> t destroy( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRM � s N( R; R< R= R# RB RM ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR> � s t Formc B s_ e Z d Z i d � Z e Z d � Z d � Z d � Z d d d � Z d d � Z
d � Z RS(
s� The Tix Form geometry manager
Widgets can be arranged by specifying attachments to other widgets.
See Tix documentation for complete detailsc K s) | j j d | j | j | | � � d S( Nt tixForm( R R t _wR( ( R R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt config� s c C s t j | i | | 6� d S( N( RN t form( R t keyt value( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt __setitem__� s c C s | j j d d | j � S( NRO t check( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRV � s c C s | j j d d | j � d S( NRO t forget( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRW � s i c C s� | ro | ro | j j d d | j � } | j j | � } d } x' | D] } | | j j | � f } qH W| S| j j d d | j | | � S( NRO t grid( ( R R RP t splitlistt getint( R t xsizet ysizet xt yt z( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRX � s
c C sX | s | j j d d | j � S| d d k r< d | } n | j j d d | j | � S( NRO t infoi R" ( R R RP ( R R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR` s
c C s1 t | j | j j | j j d d | j � � � S( NRO t slaves( t mapt
_nametowidgetR RY R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRa s N( R; R< R= RQ RR RU RV RW RX R# R` Ra ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRN � s
t TixWidgetc B s} e Z d Z d d d i i d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z i d d � Z d
� Z
RS( sQ A TixWidget class is used to package all (or most) Tix widgets.
Widget initialization is extended in two ways:
1) It is possible to give a list of options which must be part of
the creation command (so called Tix 'static' options). These cannot be
given as a 'config' command later.
2) It is possible to give the name of an existing TK widget. These are
child widgets created automatically by a Tix mega-widget. The Tk call
to create these widgets is therefore bypassed in TixWidget.__init__
Both options are for use by subclasses only.
c C s� | r t | | f � } n t | � } d } | rC | j d � n d g } xE | j � D]6 \ } } | | k rZ | d | | f } | | =qZ qZ W| | _ t j | | | � | r� | j j | | j | � n | r� t j | | � n i | _
d S( Nt optionsR" ( ( R t appendt itemst
widgetNamet Widgett _setupR R RP RQ t subwidget_list( R t masterRh t static_optionsR) R* t extrat kt v( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB s$ c C s' | | j k r | j | St | � d S( N( Rk t AttributeError( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt __getattr__K s c C s | j j d | j | � d S( s1 Set a variable without calling its action routinet tixSetSilentN( R R RP ( R RT ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
set_silentP s c C sT | j | � } | s0 t d | d | j � n | t | j � d } | j | � S( sS Return the named subwidget (which must have been created by
the sub-class).s
Subwidget s not child of i ( t _subwidget_namet TclErrort _namet lenRP Rc ( R R0 t n( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt subwidgetT s
c C sl | j � } | s g Sg } xI | D]A } | t | j � d } y | j | j | � � Wq# q# Xq# W| S( s Return all subwidgets.i ( t _subwidget_namesRx RP Rf Rc ( R t namest retlistR0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt subwidgets_all^ s
c C s6 y | j j | j d | � SWn t k
r1 d SXd S( s7 Get a subwidget name (returns a String, not a Widget !)Rz N( R R RP Rv R# ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRu m s
c C sH y/ | j j | j d d � } | j j | � SWn t k
rC d SXd S( s" Return the name of all subwidgets.t
subwidgetss -allN( R R RP RY Rv R# ( R R] ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR{ t s
c C s� | d k r d St | t � s. t | � } n t | t � sL t | � } n | j � } x+ | D]# } | j j | d d | | � q_ Wd S( s8 Set configuration options for all subwidgets (and self).RK NR! R" ( R% R& t reprR{ R R ( R R RT R| R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
config_all| s
c K s� | s$ t j } | s$ t d � q$ n | rE | rE t | | f � } n | rT | } n d } xO | j � D]A \ } } t | d � r� | j | � } n | d | | f } qg W| j j d d | f | � S( Ns Too early to create imaget __call__R" R t create( ( RA t
_default_roott RuntimeErrorR Rg t hasattrt _registerR R ( R t imgtypeR) Rl R* Re Ro Rp ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt image_create� s c C s2 y | j j d d | � Wn t k
r- n Xd S( NR t delete( R R Rv ( R t imgname( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt image_delete� s
N( R; R< R= R# RB Rr Rt Rz R~ Ru R{ R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRd s ,
t TixSubWidgetc B s& e Z d Z d d d � Z d � Z RS( s� Subwidget class.
This is used to mirror child widgets automatically created
by Tix/Tk as part of a mega-widget in Python (which is not informed
of this)i c C sE | rR | j | � } y* | t | j � d } | j d � } WqR g } qR Xn | s{ t j | | d d i | d 6� n� | } x� t t | � d � D]i } d j | | d � } y | j | � }
|
} Wq� t
k
r t | | | d d d d �} q� Xq� W| r| d } n t j | | d d i | d 6� | | _ d S( Ni t .R0 t destroy_physicallyi t check_intermediatei����(
Ru Rx RP t splitRd RB R# t ranget joinRc t KeyErrorR� R� ( R Rl R0 R� R� t patht plistt parentt iRy t w( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s.
#
c C s� x! | j j � D] } | j � q W| j | j j k rL | j j | j =n | j | j j k rt | j j | j =n | j r� | j j d | j � n d S( NRM (
t childrent valuesRM Rw Rl Rk R� R R RP ( R t c( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRM � s ( R; R< R= RB RM ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s t DisplayStylec B sS e Z d Z i d � Z d � Z d � Z d � Z d � Z i d � Z d � Z RS( sR DisplayStyle - handle configuration options shared by
(multiple) Display Itemsc K s� d | k r | d } n7 d | k r2 | d } n t j } | sP t d � � n | j | _ | j j d | | j | | � � | _ d S( Nt refwindows1 Too early to create display style: no root windowt tixDisplayStyle( RA R� R� R R R( t stylename( R t itemtypeR) R* Rl ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s
c C s | j S( N( R� ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt __str__� s c C sk | r! | r! t | | f � } n | r0 | } n d } x. | j � D] \ } } | d | | f } qC W| S( NR" ( ( R Rg ( R R) R* t optsRo Rp ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR( � s c C s | j j | j d � d S( NR� ( R R R� ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C s$ | j j | j d d | | � d S( NR! s -%s( R R R� ( R RS RT ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRU � s c K s" | j | j d | j | | � � S( NR! ( R$ R� R( ( R R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRQ � s c C s | j j | j d d | � S( NR s -%s( R R R� ( R RS ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt __getitem__� s (
R; R< R= RB R� R( R� RU RQ R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s
t Balloonc B s2 e Z d Z d i d � Z i d � Z d � Z RS( s Balloon help widget.
Subwidget Class
--------- -----
label Label
message Messagec K sm d d d d d g } t j | | d | | | � t | d d d �| j d <t | d
d d �| j d
<d S( NRe t installcolormapt initwaitt statusbart cursort
tixBalloont labelR� i t message( Rd RB t _dummyLabelRk ( R Rl R) R* t static( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB s c K s/ | j j | j d | j | j | | � � d S( sk Bind balloon widget to another.
One balloon widget may be bound to several widgets at the same timet bindN( R R RP R( ( R t widgetR) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt bind_widget s c C s | j j | j d | j � d S( Nt unbind( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
unbind_widget s N( R; R< R= R# RB R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� s
t ButtonBoxc B s2 e Z d Z d i d � Z i d � Z d � Z RS( sg ButtonBox - A container for pushbuttons.
Subwidgets are the buttons added with the add method.
c K s& t j | | d d d g | | � d S( Nt tixButtonBoxt orientationRe ( Rd RB ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB & s c K sD | j j | j d | | j | | � � } t | | � | j | <| S( s$ Add a button with given name to box.t add( R R RP R( t _dummyButtonRk ( R R0 R) R* t btn( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� * s *c C s/ | | j k r+ | j j | j d | � n d S( Nt invoke( Rk R R RP ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� 1 s N( R; R< R= R# RB R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� " s t ComboBoxc B sA e Z d Z d i d � Z d � Z d � Z d � Z d � Z RS( s� ComboBox - an Entry field with a dropdown menu. The user can select a
choice by either typing in the entry subwidget or selecting from the
listbox subwidget.
Subwidget Class
--------- -----
entry Entry
arrow Button
slistbox ScrolledListBox
tick Button
cross Button : present if created with the fancy optionc K s� t j | | d d d d d g | | � t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <y0 t | d
� | j d
<t | d � | j d <Wn t k
r� n Xd S( Nt tixComboBoxt editablet dropdownt fancyRe R� t entryt arrowt slistboxt tickt cross( Rd RB R� Rk t _dummyEntryR� t _dummyScrolledListBoxt TypeError( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB C s
c C s | j j | j d | � d S( Nt
addhistory( R R RP ( R t str( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt add_historyU s c C s | j j | j d | � d S( Nt
appendhistory( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt append_historyX s c C s | j j | j d | | � d S( Nt insert( R R RP ( R t indexR� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� [ s c C s | j j | j d | � d S( Nt pick( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� ^ s N( R; R< R= R# RB R� R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� 5 s t Controlc B sA e Z d Z d i d � Z d � Z d � Z d � Z d � Z RS( s� Control - An entry field with value change arrows. The user can
adjust the value by pressing the two arrow buttons or by entering
the value directly into the entry. The new value will be checked
against the user-defined upper and lower limits.
Subwidget Class
--------- -----
incr Button
decr Button
entry Entry
label Labelc K s{ t j | | d d g | | � t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <d S( Nt
tixControlRe t incrt decrR� R� ( Rd RB R� Rk R� R� ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB o s
c C s | j j | j d � d S( NR� ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt decrementv s c C s | j j | j d � d S( NR� ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt incrementy s c C s | j j | j d � d S( NR� ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� | s c C s | j j | j d � d S( Nt update( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� s N( R; R< R= R# RB R� R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� a s t DirListc B s# e Z d Z i d � Z d � Z RS( sR DirList - displays a list view of a directory, its previous
directories and its sub-directories. The user can choose one of
the directories displayed in the list or change to another directory.
Subwidget Class
--------- -----
hlist HList
hsb Scrollbar
vsb Scrollbarc K se t j | | d d g | | � t | d � | j d <t | d � | j d <t | d � | j d <d S( Nt
tixDirListRe t hlistt vsbt hsb( Rd RB t _dummyHListRk t _dummyScrollbar( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s c C s | j j | j d | � d S( Nt chdir( R R RP ( R t dir( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s ( R; R< R= RB R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s t DirTreec B s# e Z d Z i d � Z d � Z RS( s� DirTree - Directory Listing in a hierarchical view.
Displays a tree view of a directory, its previous directories and its
sub-directories. The user can choose one of the directories displayed
in the list or change to another directory.
Subwidget Class
--------- -----
hlist HList
hsb Scrollbar
vsb Scrollbarc K se t j | | d d g | | � t | d � | j d <t | d � | j d <t | d � | j d <d S( Nt
tixDirTreeRe R� R� R� ( Rd RB R� Rk R� ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s c C s | j j | j d | � d S( NR� ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s ( R; R< R= RB R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s
t DirSelectBoxc B s e Z d Z i d � Z RS( s� DirSelectBox - Motif style file select box.
It is generally used for
the user to choose a file. FileSelectBox stores the files mostly
recently selected into a ComboBox widget so that they can be quickly
selected again.
Subwidget Class
--------- -----
selection ComboBox
filter ComboBox
dirlist ScrolledListBox
filelist ScrolledListBoxc K sO t j | | d d g | | � t | d � | j d <t | d � | j d <d S( Nt tixDirSelectBoxRe t dirlistt dircbx( Rd RB t
_dummyDirListRk t _dummyFileComboBox( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s ( R; R< R= RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s t ExFileSelectBoxc B s, e Z d Z i d � Z d � Z d � Z RS( s� ExFileSelectBox - MS Windows style file select box.
It provides a convenient method for the user to select files.
Subwidget Class
--------- -----
cancel Button
ok Button
hidden Checkbutton
types ComboBox
dir ComboBox
file ComboBox
dirlist ScrolledListBox
filelist ScrolledListBoxc K s� t j | | d d g | | � t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <t | d
� | j d
<d S( Nt tixExFileSelectBoxRe t cancelt okt hiddent typesR� R� t filet filelist( Rd RB R� Rk t _dummyCheckbuttont _dummyComboBoxR� R� ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s c C s | j j | j d � d S( Nt filter( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C s | j j | j d � d S( NR� ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s ( R; R< R= RB R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s
t DirSelectDialogc B s, e Z d Z i d � Z d � Z d � Z RS( s# The DirSelectDialog widget presents the directories in the file
system in a dialog window. The user can use this dialog window to
navigate through the file system to select the desired directory.
Subwidgets Class
---------- -----
dirbox DirSelectDialogc K s9 t j | | d d g | | � t | d � | j d <d S( Nt tixDirSelectDialogRe t dirbox( Rd RB t _dummyDirSelectBoxRk ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s c C s | j j | j d � d S( Nt popup( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C s | j j | j d � d S( Nt popdown( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s ( R; R< R= RB R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s t ExFileSelectDialogc B s, e Z d Z i d � Z d � Z d � Z RS( s� ExFileSelectDialog - MS Windows style file select dialog.
It provides a convenient method for the user to select files.
Subwidgets Class
---------- -----
fsbox ExFileSelectBoxc K s9 t j | | d d g | | � t | d � | j d <d S( Nt tixExFileSelectDialogRe t fsbox( Rd RB t _dummyExFileSelectBoxRk ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB s c C s | j j | j d � d S( NR� ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� s c C s | j j | j d � d S( NR� ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� s ( R; R< R= RB R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s t
FileSelectBoxc B s, e Z d Z i d � Z d � Z d � Z RS( s� ExFileSelectBox - Motif style file select box.
It is generally used for
the user to choose a file. FileSelectBox stores the files mostly
recently selected into a ComboBox widget so that they can be quickly
selected again.
Subwidget Class
--------- -----
selection ComboBox
filter ComboBox
dirlist ScrolledListBox
filelist ScrolledListBoxc K s{ t j | | d d g | | � t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <d S( Nt tixFileSelectBoxRe R� R� R� t selection( Rd RB R� Rk R� ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB s
c C s | j j | j d � d S( NR� ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt apply_filter# s c C s | j j | j d � d S( NR� ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� & s ( R; R< R= RB R R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� s t FileSelectDialogc B s, e Z d Z i d � Z d � Z d � Z RS( s� FileSelectDialog - Motif style file select dialog.
Subwidgets Class
---------- -----
btns StdButtonBox
fsbox FileSelectBoxc K sO t j | | d d g | | � t | d � | j d <t | d � | j d <d S( Nt tixFileSelectDialogRe t btnsR� ( Rd RB t _dummyStdButtonBoxRk t _dummyFileSelectBox( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB 3 s c C s | j j | j d � d S( NR� ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� 9 s c C s | j j | j d � d S( NR� ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� < s ( R; R< R= RB R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR * s t FileEntryc B s, e Z d Z i d � Z d � Z d � Z RS( s_ FileEntry - Entry field with button that invokes a FileSelectDialog.
The user can type in the filename manually. Alternatively, the user can
press the button widget that sits next to the entry, which will bring
up a file selection dialog.
Subwidgets Class
---------- -----
button Button
entry Entryc K sR t j | | d d d g | | � t | d � | j d <t | d � | j d <d S( Nt tixFileEntryt
dialogtypeRe t buttonR� ( Rd RB R� Rk R� ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB K s c C s | j j | j d � d S( NR� ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� Q s c C s d S( N( ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt file_dialogT s ( R; R< R= RB R� R
( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR ? s t HListc B s e Z d Z d6 i d � Z i d � Z d6 i d � Z d � Z d � Z d d6 d6 d � Z d � Z
d � Z d
� Z d � Z
d � Z d
� Z d � Z d � Z i d � Z i d � Z d � Z d � Z e Z d � Z d � Z d � Z i d � Z i d � Z d � Z d � Z d � Z d � Z d � Z d � Z! d6 d � Z" d � Z# d! � Z$ d" � Z% d# � Z& d$ � Z' d% � Z( d& � Z) d' � Z* d( � Z+ d) � Z, i d* � Z- i d+ � Z. d, � Z/ d- � Z0 d. � Z1 i d/ � Z2 d0 � Z3 d1 � Z4 i d2 � Z5 d3 � Z6 d6 d4 � Z7 d5 � Z8 RS(7 s HList - Hierarchy display widget can be used to display any data
that have a hierarchical structure, for example, file system directory
trees. The list entries are indented and connected by branch lines
according to their places in the hierarchy.
Subwidgets - Nonec K s& t j | | d d d g | | � d S( Nt tixHListt columnsRe ( Rd RB ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB ` s c K s( | j j | j d | | j | | � � S( NR� ( R R RP R( ( R R� R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� d s c K s7 | s d } n | j j | j d | | j | | � � S( NRK t addchild( R R RP R( ( R R� R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt add_childg s c C s | j j | j d d | � d S( Nt anchort set( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
anchor_setm s c C s | j j | j d d � d S( NR t clear( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt anchor_clearp s i c C sK | s% | j j | j d d | | � S| j j | j d d | d | � Sd S( NR t widths -char( R R RP ( R t colR t chars( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt column_widths s c C s | j j | j d d � d S( NR� t all( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
delete_allz s c C s | j j | j d d | � d S( NR� R� ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt delete_entry} s c C s | j j | j d d | � d S( NR� t
offsprings( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt delete_offsprings� s c C s | j j | j d d | � d S( NR� t siblings( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt delete_siblings� s c C s | j j | j d d | � d S( Nt dragsiteR ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt dragsite_set� s c C s | j j | j d d � d S( NR R ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt dragsite_clear� s c C s | j j | j d d | � d S( Nt dropsiteR ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt dropsite_set� s c C s | j j | j d d � d S( NR# R ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt dropsite_clear� s c K s/ | j j | j d d | | j | | � � d S( Nt headerR� ( R R RP R( ( R R R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
header_create� s c K sT | d k r% | j | j d d | � S| j j | j d d | | j | | � � d S( NR& R! ( R# R$ RP R R R( ( R R R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt header_configure� s c C s | j j | j d d | | � S( NR& R ( R R RP ( R R t opt( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt header_cget� s c C s( | j j | j j | j d d | � � S( NR& t exist( R t
getbooleanR RP ( R R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
header_exists� s c C s | j j | j d d | � d S( NR& R� ( R R RP ( R R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
header_delete� s c C s | j j | j d d | � S( NR& t size( R R RP ( R R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt header_size� s c C s | j j | j d d | � d S( Nt hideR� ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
hide_entry� s c K s/ | j j | j d d | | j | | � � d S( Nt indicatorR� ( R R RP R( ( R R� R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt indicator_create� s c K sT | d k r% | j | j d d | � S| j j | j d d | | j | | � � d S( NR3 R! ( R# R$ RP R R R( ( R R� R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt indicator_configure� s
c C s | j j | j d d | | � S( NR3 R ( R R RP ( R R� R) ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt indicator_cget� s c C s | j j | j d d | � S( NR3 t exists( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt indicator_exists� s c C s | j j | j d d | � d S( NR3 R� ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt indicator_delete� s c C s | j j | j d d | � S( NR3 R/ ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt indicator_size� s c C s | j j | j d d � S( NR` R ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt info_anchor� s c C s+ | j | j j | j d d | � � p* d S( NR` t bbox( t _getintsR R RP R# ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt info_bbox� s c C s. | j j | j d d | � } | j j | � S( NR` R� ( R R RP RY ( R R� R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
info_children� s c C s | j j | j d d | � S( NR` t data( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt info_data� s c C s | j j | j d d � S( NR` R ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
info_dragsite� s c C s | j j | j d d � S( NR` R# ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
info_dropsite� s c C s | j j | j d d | � S( NR` R7 ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt info_exists� s c C s | j j | j d d | � S( NR` R� ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt info_hidden� s c C s | j j | j d d | � S( NR` t next( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt info_next� s c C s | j j | j d d | � S( NR` R� ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt info_parent� s c C s | j j | j d d | � S( NR` t prev( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt info_prev� s c C s+ | j j | j d d � } | j j | � S( NR` R� ( R R RP RY ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt info_selection� s c C s" | j j | j d d | | | � S( Nt itemR ( R R RP ( R R� R R) ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt item_cget� s c K sZ | d k r( | j | j d d | | � S| j j | j d d | | | j | | � � d S( NRL R! ( R# R$ RP R R R( ( R R� R R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt item_configure� s c K s2 | j j | j d d | | | j | | � � d S( NRL R� ( R R RP R( ( R R� R R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt item_create� s c C s | j j | j d d | | � S( NRL R7 ( R R RP ( R R� R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt item_exists� s c C s# | j j | j d d | | � d S( NRL R� ( R R RP ( R R� R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt item_delete� s c C s | j j | j d | | � S( Nt entrycget( R R RP ( R R� R) ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRR � s c K sN | d k r" | j | j d | � S| j j | j d | | j | | � � d S( Nt entryconfigure( R# R$ RP R R R( ( R R� R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRS s c C s | j j | j d | � S( Nt nearest( R R RP ( R R^ ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRT s c C s | j j | j d | � d S( Nt see( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRU s c K s, | j j | j d d | j | | � � d S( NR� R ( R R RP R( ( R R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt selection_clear s c C s | j j | j d d | � S( NR� t includes( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt selection_includes s c C s# | j j | j d d | | � d S( NR� R ( R R RP ( R t firstt last( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
selection_set s c C s | j j | j d d | � S( Nt showR� ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
show_entry s N(9 R; R< R= R# RB R� R R R R R R R R R! R" R$ R% R' R( R* R- t header_existR. R0 R2 R4 R5 R6 R8 R9 R: R; R> R? RA RB RC RD RE RG RH RJ RK RM RN RO RP RQ RR RS RT RU RV RX R[ R] ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR X sl t InputOnlyc B s e Z d Z d i d � Z RS( s? InputOnly - Invisible widget. Unix only.
Subwidgets - Nonec K s t j | | d d | | � d S( Nt tixInputOnly( Rd RB R# ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB s N( R; R< R= R# RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR_ s t
LabelEntryc B s e Z d Z d i d � Z RS( s LabelEntry - Entry field with label. Packages an entry widget
and a label into one mega widget. It can be used to simplify the creation
of ``entry-form'' type of interface.
Subwidgets Class
---------- -----
label Label
entry Entryc K sR t j | | d d d g | | � t | d � | j d <t | d � | j d <d S( Nt
tixLabelEntryt labelsideRe R� R� ( Rd RB R� Rk R� ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB , s N( R; R< R= R# RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRa " s t
LabelFramec B s e Z d Z d i d � Z RS( se LabelFrame - Labelled Frame container. Packages a frame widget
and a label into one mega widget. To create widgets inside a
LabelFrame widget, one creates the new widgets relative to the
frame subwidget and manage them inside the frame subwidget.
Subwidgets Class
---------- -----
label Label
frame Framec K sR t j | | d d d g | | � t | d � | j d <t | d � | j d <d S( Nt
tixLabelFrameRc Re R� t frame( Rd RB R� Rk t _dummyFrame( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB = s N( R; R< R= R# RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRd 2 s t ListNoteBookc B sA e Z d Z i d � Z i d � Z d � Z d � Z d � Z RS( s A ListNoteBook widget is very similar to the TixNoteBook widget:
it can be used to display many windows in a limited space using a
notebook metaphor. The notebook is divided into a stack of pages
(windows). At one time only one of these pages can be shown.
The user can navigate through these pages by
choosing the name of the desired page in the hlist subwidget.c K sk t j | | d d g | | � t | d d d �| j d <t | d � | j d <t | d � | j d <d S( Nt tixListNoteBookRe t paneR� i R� t shlist( Rd RB t _dummyPanedWindowRk R� t _dummyScrolledHList( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB L s
c K sI | j j | j d | | j | | � � t | | � | j | <| j | S( NR� ( R R RP R( R� Rk ( R R0 R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� T s (c C s
| j | � S( N( Rz ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt pageY s c C sU | j j | j j | j d � � } g } x$ | D] } | j | j | � � q1 W| S( Nt pages( R R� R RP Rf Rz ( R R| t retR] ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRo \ s
$
c C s | j j | j d | � d S( Nt raise( R R RP ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
raise_paged s ( R; R< R= RB R� Rn Ro Rr ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRh D s t Meterc B s e Z d Z d i d � Z RS( su The Meter widget can be used to show the progress of a background
job which may take a long time to execute.
c K s# t j | | d d g | | � d S( Nt tixMeterRe ( Rd RB ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB l s N( R; R< R= R# RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRs g s t NoteBookc B sV e Z d Z d i d � Z i d � Z d � Z d � Z d � Z d � Z d � Z
RS( s� NoteBook - Multi-page container widget (tabbed notebook metaphor).
Subwidgets Class
---------- -----
nbframe NoteBookFrame
<pages> page widgets added dynamically with the add methodc K s? t j | | d d g | | � t | d d d �| j d <d S( Nt tixNoteBookRe t nbframeR� i ( Rd RB R� Rk ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB x s c K sI | j j | j d | | j | | � � t | | � | j | <| j | S( NR� ( R R RP R( R� Rk ( R R0 R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� } s (c C s8 | j j | j d | � | j | j � | j | =d S( NR� ( R R RP Rk RM ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C s
| j | � S( N( Rz ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRn � s c C sU | j j | j j | j d � � } g } x$ | D] } | j | j | � � q1 W| S( NRo ( R R� R RP Rf Rz ( R R| Rp R] ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRo � s
$
c C s | j j | j d | � d S( NRq ( R R RP ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRr � s c C s | j j | j d � S( Nt raised( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRx � s N( R; R< R= R# RB R� R� Rn Ro Rr Rx ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRu p s t
NoteBookFramec B s e Z RS( ( R; R< ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRy � s t
OptionMenuc B sM e Z d Z i d � Z i d � Z i d � Z d � Z d � Z d � Z RS( s� OptionMenu - creates a menu button of options.
Subwidget Class
--------- -----
menubutton Menubutton
menu Menuc K sR t j | | d d d g | | � t | d � | j d <t | d � | j d <d S( Nt
tixOptionMenuRc Re t
menubuttont menu( Rd RB t _dummyMenubuttonRk t
_dummyMenu( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s c K s/ | j j | j d d | | j | | � � d S( NR� t command( R R RP R( ( R R0 R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt add_command� s c K s/ | j j | j d d | | j | | � � d S( NR� t separator( R R RP R( ( R R0 R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
add_separator� s c C s | j j | j d | � d S( NR� ( R R RP ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C s | j j | j d | � d S( Nt disable( R R RP ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C s | j j | j d | � d S( Nt enable( R R RP ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s ( R; R< R= RB R� R� R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRz � s t PanedWindowc B sV e Z d Z i d � Z i d � Z d � Z d � Z d � Z i d � Z d � Z RS( s� PanedWindow - Multi-pane container widget
allows the user to interactively manipulate the sizes of several
panes. The panes can be arranged either vertically or horizontally.The
user changes the sizes of the panes by dragging the resize handle
between two panes.
Subwidgets Class
---------- -----
<panes> g/p widgets added dynamically with the add method.c K s& t j | | d d d g | | � d S( Nt tixPanedWindowR� Re ( Rd RB ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s c K sO | j j | j d | | j | | � � t | | d d �| j | <| j | S( NR� R� i ( R R RP R( R� Rk ( R R0 R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s ( c C s8 | j j | j d | � | j | j � | j | =d S( NR� ( R R RP Rk RM ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C s | j j | j d | � d S( NRW ( R R RP ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRW � s c C s | j j | j d | | � S( Nt panecget( R R RP ( R R� R) ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c K sN | d k r" | j | j d | � S| j j | j d | | j | | � � d S( Nt
paneconfigure( R# R$ RP R R R( ( R R� R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C sD | j j | j j | j d � � } g | D] } | j | � ^ q+ S( Nt panes( R RY R RP Rz ( R R| R] ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s $(
R; R< R= RB R� R� RW R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s t PopupMenuc B s5 e Z d Z i d � Z d � Z d � Z d � Z RS( s PopupMenu widget can be used as a replacement of the tk_popup command.
The advantage of the Tix PopupMenu widget is it requires less application
code to manipulate.
Subwidgets Class
---------- -----
menubutton Menubutton
menu Menuc K sO t j | | d d g | | � t | d � | j d <t | d � | j d <d S( Nt tixPopupMenuRe R| R} ( Rd RB R~ Rk R ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s c C s | j j | j d | j � d S( NR� ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C s | j j | j d | j � d S( NR� ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C s& | j j | j d | j | | � d S( Nt post( R R RP ( R R� R] R^ ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt post_widget� s ( R; R< R= RB R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s
t ResizeHandlec B s> e Z d Z i d � Z d � Z d � Z d � Z d � Z RS( s; Internal widget to draw resize handles on Scrolled widgets.c K sA d d d d d d d d d g } t j | | d
| | | � d S( NRe R� t cursorfgt cursorbgt
handlesizet hintcolort hintwidthR] R^ t tixResizeHandle( Rd RB ( R Rl R) R* t flags( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s
c C s | j j | j d | j � d S( Nt attachwidget( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
attach_widget s c C s | j j | j d | j � d S( Nt detachwidget( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
detach_widget s c C s | j j | j d | j � d S( NR1 ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR1 s c C s | j j | j d | j � d S( NR\ ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR\ s ( R; R< R= RB R� R� R1 R\ ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s
t
ScrolledHListc B s e Z d Z i d � Z RS( s0 ScrolledHList - HList with automatic scrollbars.c K se t j | | d d g | | � t | d � | j d <t | d � | j d <t | d � | j d <d S( Nt tixScrolledHListRe R� R� R� ( Rd RB R� Rk R� ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB s
( R; R< R= RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� s t ScrolledListBoxc B s e Z d Z i d � Z RS( s4 ScrolledListBox - Listbox with automatic scrollbars.c K se t j | | d d g | | � t | d � | j d <t | d � | j d <t | d � | j d <d S( Nt tixScrolledListBoxRe t listboxR� R� ( Rd RB t
_dummyListboxRk R� ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB # s ( R; R< R= RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� s t ScrolledTextc B s e Z d Z i d � Z RS( s. ScrolledText - Text with automatic scrollbars.c K se t j | | d d g | | � t | d � | j d <t | d � | j d <t | d � | j d <d S( Nt tixScrolledTextRe R R� R� ( Rd RB t
_dummyTextRk R� ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB - s ( R; R< R= RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� ) s t
ScrolledTListc B s e Z d Z i d � Z RS( s0 ScrolledTList - TList with automatic scrollbars.c K se t j | | d d g | | � t | d � | j d <t | d � | j d <t | d � | j d <d S( Nt tixScrolledTListRe t tlistR� R� ( Rd RB t _dummyTListRk R� ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB 7 s
( R; R< R= RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� 3 s t ScrolledWindowc B s e Z d Z i d � Z RS( s2 ScrolledWindow - Window with automatic scrollbars.c K se t j | | d d g | | � t | d � | j d <t | d � | j d <t | d � | j d <d S( Nt tixScrolledWindowRe R R� R� ( Rd RB Rg Rk R� ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB B s ( R; R< R= RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� > s t Selectc B s/ e Z d Z i d � Z i d � Z d � Z RS( s� Select - Container of button subwidgets. It can be used to provide
radio-box or check-box style of selection options for the user.
Subwidgets are buttons added dynamically using the add method.c K sE t j | | d d d d d d g | | � t | d � | j d <d S( Nt tixSelectt allowzerot radioR� Rc Re R� ( Rd RB R� Rk ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB O s
c K sI | j j | j d | | j | | � � t | | � | j | <| j | S( NR� ( R R RP R( R� Rk ( R R0 R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� V s (c C s | j j | j d | � d S( NR� ( R R RP ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� [ s ( R; R< R= RB R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� H s t Shellc B s e Z d Z d i d � Z RS( s' Toplevel window.
Subwidgets - Nonec K s& t j | | d d d g | | � d S( Nt tixShellRe t title( Rd RB ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB c s N( R; R< R= R# RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� ^ s t DialogShellc B s8 e Z d Z d i d � Z d � Z d � Z d � Z RS( s� Toplevel window, with popup popdown and center methods.
It tells the window manager that it is a dialog window and should be
treated specially. The exact treatment depends on the treatment of
the window manager.
Subwidgets - Nonec K s5 t j | | d d d d d d d d g | | � d S( Nt tixDialogShellRe R� t mappedt minheightt minwidthR� t transient( Rd RB ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB o s
c C s | j j | j d � d S( NR� ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� v s c C s | j j | j d � d S( NR� ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� y s c C s | j j | j d � d S( Nt center( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� | s N( R; R< R= R# RB R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� f s
t StdButtonBoxc B s& e Z d Z d i d � Z d � Z RS( s@ StdButtonBox - Standard Button Box (OK, Apply, Cancel and Help) c K s~ t j | | d d d g | | � t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <d S( Nt tixStdButtonBoxR� Re R� t applyR� t help( Rd RB R� Rk ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s c C s/ | | j k r+ | j j | j d | � n d S( NR� ( Rk R R RP ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s N( R; R< R= R# RB R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� s t TListc B s� e Z d Z d i d � Z d � Z d � Z d � Z d � Z d d � Z d � Z
d � Z d � Z d
� Z
i d � Z d � Z d
� Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z i d � Z d � Z d d � Z RS( s� TList - Hierarchy display widget which can be
used to display data in a tabular format. The list entries of a TList
widget are similar to the entries in the Tk listbox widget. The main
differences are (1) the TList widget can display the list entries in a
two dimensional format and (2) you can use graphical images as well as
multiple colors and fonts for the list entries.
Subwidgets - Nonec K s# t j | | d d g | | � d S( Nt tixTListRe ( Rd RB ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s c C s | j j | j d d | � d S( Nt activeR ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
active_set� s c C s | j j | j d d � d S( NR� R ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt active_clear� s c C s | j j | j d d | � d S( NR R ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR � s c C s | j j | j d d � d S( NR R ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR � s c C s | j j | j d | | � d S( NR� ( R R RP ( R t from_t to( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C s | j j | j d d | � d S( NR R ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR! � s c C s | j j | j d d � d S( NR R ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR" � s c C s | j j | j d d | � d S( NR# R ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR$ � s c C s | j j | j d d � d S( NR# R ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR% � s c K s, | j j | j d | | j | | � � d S( NR� ( R R RP R( ( R R� R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C s | j j | j d d � S( NR` R� ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt info_active� s c C s | j j | j d d � S( NR` R ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR; � s c C s | j j | j d d | � S( NR` t down( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt info_down� s c C s | j j | j d d | � S( NR` t left( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt info_left� s c C s | j j | j d d | � S( NR` t right( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
info_right� s c C s+ | j j | j d d � } | j j | � S( NR` R� ( R R RP RY ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRK � s c C s | j j | j d d � S( NR` R/ ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt info_size� s c C s | j j | j d d | � S( NR` t up( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt info_up� s c C s | j j | j d | | � S( NRT ( R R RP ( R R] R^ ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRT � s c C s | j j | j d | � d S( NRU ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRU � s c K s, | j j | j d d | j | | � � d S( NR� R ( R R RP R( ( R R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRV � s c C s | j j | j d d | � S( NR� RW ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRX � s c C s# | j j | j d d | | � d S( NR� R ( R R RP ( R RY RZ ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR[ � s N( R; R< R= R# RB R� R� R R R� R! R" R$ R% R� R� R; R� R� R� RK R� R� RT RU RV RX R[ ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s2 t Treec B sM e Z d Z d i d � Z d � Z d � Z d � Z d � Z d d � Z RS( s� Tree - The tixTree widget can be used to display hierarchical
data in a tree form. The user can adjust
the view of the tree by opening or closing parts of the tree.c K se t j | | d d g | | � t | d � | j d <t | d � | j d <t | d � | j d <d S( Nt tixTreeRe R� R� R� ( Rd RB R� Rk R� ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s
c C s | j j | j d � d S( s This command calls the setmode method for all the entries in this
Tree widget: if an entry has no child entries, its mode is set to
none. Otherwise, if the entry has any hidden child entries, its mode is
set to open; otherwise its mode is set to close.t autosetmodeN( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C s | j j | j d | � d S( s8 Close the entry given by entryPath if its mode is close.t closeN( R R RP ( R t entrypath( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C s | j j | j d | � S( s9 Returns the current mode of the entry given by entryPath.t getmode( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C s | j j | j d | � d S( s6 Open the entry given by entryPath if its mode is open.t openN( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s t nonec C s | j j | j d | | � d S( s� This command is used to indicate whether the entry given by
entryPath has children entries and whether the children are visible. mode
must be one of open, close or none. If mode is set to open, a (+)
indicator is drawn next to the entry. If mode is set to close, a (-)
indicator is drawn next to the entry. If mode is set to none, no
indicators will be drawn for this entry. The default mode is none. The
open mode indicates the entry has hidden children and this entry can be
opened by the user. The close mode indicates that all the children of the
entry are now visible and the entry can be closed by the user.t setmodeN( R R RP ( R R� t mode( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� s
N(
R; R< R= R# RB R� R� R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s t CheckListc B sb e Z d Z d
i d � Z d � Z d � Z d � Z d � Z d d � Z d � Z
d d � Z RS( s� The CheckList widget
displays a list of items to be selected by the user. CheckList acts
similarly to the Tk checkbutton or radiobutton widgets, except it is
capable of handling many more items than checkbuttons or radiobuttons.
c K sh t j | | d d d g | | � t | d � | j d <t | d � | j d <t | d � | j d <d S( Nt tixCheckListRe R� R� R� R� ( Rd RB R� Rk R� ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB s
c C s | j j | j d � d S( s This command calls the setmode method for all the entries in this
Tree widget: if an entry has no child entries, its mode is set to
none. Otherwise, if the entry has any hidden child entries, its mode is
set to open; otherwise its mode is set to close.R� N( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� s c C s | j j | j d | � d S( s8 Close the entry given by entryPath if its mode is close.R� N( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� $ s c C s | j j | j d | � S( s9 Returns the current mode of the entry given by entryPath.R� ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� ( s c C s | j j | j d | � d S( s6 Open the entry given by entryPath if its mode is open.R� N( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� , s t onc C s7 | j j | j j | j d | � � } | j j | � S( s� Returns a list of items whose status matches status. If status is
not specified, the list of items in the "on" status will be returned.
Mode can be on, off, defaultt getselection( R R� R RP RY ( R R� R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� 0 s 'c C s | j j | j d | � S( s( Returns the current status of entryPath.t getstatus( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� 7 s c C s | j j | j d | | � d S( s~ Sets the status of entryPath to be status. A bitmap will be
displayed next to the entry its status is on, off or default.t setstatusN( R R RP ( R R� R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� ; s N( R; R< R= R# RB R� R� R� R� R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� s R� c B s e Z d d � Z RS( i c C s t j | | | | � d S( N( R� RB ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB G s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� F s R� c B s e Z d d � Z RS( i c C s t j | | | | � d S( N( R� RB ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB K s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� J s R� c B s e Z d d � Z RS( i c C s t j | | | | � d S( N( R� RB ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB O s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� N s Rg c B s e Z d d � Z RS( i c C s t j | | | | � d S( N( R� RB ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB S s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRg R s R� c B s e Z d d � Z RS( i c C s t j | | | | � d S( N( R� RB ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB W s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� V s R� c B s e Z d d � Z RS( i c C s t j | | | | � d S( N( R� RB ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB [ s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� Z s R c B s e Z d d � Z RS( i c C s t j | | | | � d S( N( R� RB ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB _ s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR ^ s R~ c B s e Z d d � Z RS( i c C s t j | | | | � d S( N( R� RB ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB c s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR~ b s R� c B s e Z d d � Z RS( i c C s t j | | | | � d S( N( R� RB ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB g s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� f s R� c B s e Z d d � Z RS( i c C s t j | | | | � d S( N( R� RB ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB k s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� j s R� c B s e Z d d � Z RS( i c C s\ t j | | | | � t | d � | j d <t | d � | j d <t | d � | j d <d S( NR� R� R� ( R� RB R� Rk R� ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB o s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� n s R� c B s e Z d d � Z RS( i c C s t j | | | | � d S( N( R� RB ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB v s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� u s Rm c B s e Z d d � Z RS( i c C s\ t j | | | | � t | d � | j d <t | d � | j d <t | d � | j d <d S( NR� R� R� ( R� RB R� Rk R� ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB z s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRm y s R� c B s e Z d d � Z RS( i c C s t j | | | | � d S( N( R� RB ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s R� c B s e Z d d � Z RS( i c C s� t j | | | d | g � t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <y0 t | d � | j d <t | d � | j d <Wn t k
r� n Xd S( NR� R� R� R� R� R� R� ( R� RB R� Rk R� R� R� R� ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s
( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s R� c B s e Z d d � Z RS( i c C s\ t j | | | | � t | d � | j d <t | d � | j d <t | d � | j d <d S( NR� R� R� ( R� RB R� Rk R� ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s R� c B s e Z d d � Z RS( i c C sF t j | | | | � t | d � | j d <t | d � | j d <d S( NR� R� ( R� RB R� Rk R� ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s R� c B s e Z d d � Z RS( i c C s� t j | | | | � t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <d S( NR� R� R� R� R� R� R� R� ( R� RB R� Rk R� R� R� ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s R c B s e Z d d � Z RS( i c C sr t j | | | | � t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <d S( NR� R� R� R� ( R� RB R� Rk R� ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s
( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR � s R� c B s e Z d d � Z RS( i c C s0 t j | | | | � t | d � | j d <d S( NR� ( R� RB R� Rk ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s R c B s e Z d d � Z RS( i c C sr t j | | | | � t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <d S( NR� R� R� R� ( R� RB R� Rk ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s
( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR � s t _dummyNoteBookFramec B s e Z d d � Z RS( i c C s t j | | | | � d S( N( R� RB ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s Rl c B s e Z d d � Z RS( i c C s t j | | | | � d S( N( R� RB ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRl � s c C s | j j d | j � S( sz Returns the qualified path name for the widget. Normally used to set
default options for subwidgets. See tixwidgets.pyt
tixOptionName( R R RP ( R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
OptionName� s c C sG d } x: | j � D], } | d | d | d | | d } q W| S( NRK s {{s } {s - s }} ( t keys( t dictt st type( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt FileTypeList� s *t CObjViewc B s e Z d Z RS( sB This file implements the Canvas Object View widget. This is a base
class of IconView. It implements automatic placement/adjustment of the
scrollbars according to the canvas objects inside the canvas subwidget.
The scrollbars are adjusted so that the canvas is just large enough
to see all the objects.
( R; R< R= ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s t Gridc B s� e Z d Z d i d � Z d � Z d � Z d � Z d d � Z d d � Z d � Z
d � Z d � Z d d
� Z
d � Z d � Z d
� Z d � Z d � Z d d � Z d � Z d � Z d � Z RS( s} The Tix Grid command creates a new window and makes it into a
tixGrid widget. Additional options, may be specified on the command
line or in the option database to configure aspects such as its cursor
and relief.
A Grid widget displays its contents in a two dimensional grid of cells.
Each cell may contain one Tix display item, which may be in text,
graphics or other formats. See the DisplayStyle class for more information
about Tix display items. Individual cells, or groups of cells, can be
formatted with a wide range of attributes, such as its color, relief and
border.
Subwidgets - Nonec K s/ g } | | _ t j | | d | | | � d S( Nt tixGrid( R) Rd RB ( R Rl R) R* R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB s c C s | j j | d d � d S( s Removes the selection anchor.R R N( R R ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR s c C s | j | j j | d d � � S( s3 Get the (x,y) coordinate of the current anchor cellR R4 ( R= R R ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
anchor_get
s c C s | j j | d d | | � d S( s/ Set the selection anchor to the cell at (x, y).R R N( R R ( R R] R^ ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR s c C sH | d k r( | j j | d d | � n | j j | d d | | � d S( sd Delete rows between from_ and to inclusive.
If to is not provided, delete only row at from_R� R N( R# R R ( R R� R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
delete_row s c C sH | d k r( | j j | d d | � n | j j | d d | | � d S( sj Delete columns between from_ and to inclusive.
If to is not provided, delete only column at from_R� R N( R# R R ( R R� R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
delete_column s c C s | j j | d d � d S( sU If any cell is being edited, de-highlight the cell and applies
the changes.t editR� N( R R ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
edit_apply% s c C s | j j | d d | | � d S( sm Highlights the cell at (x, y) for editing, if the -editnotify
command returns True for this cell.R� R N( R R ( R R] R^ ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt edit_set* s c C s? | r# | d d k r# d | } n | j j | d | | | � S( s& Get the option value for cell at (x,y)i R" RR ( R R ( R R] R^ R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRR / s
c K s | j d | | f | | � S( NRS ( t
_configure( R R] R^ R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRS 5 s c C s% | j | j j | d d | | � � S( s+ Return True if display item exists at (x,y)R` R7 ( t _getbooleanR R ( R R] R^ ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRD ; s c C s | j j | d d | | � S( NR` R< ( R R ( R R] R^ ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR> ? s c C s# | j j | d d | | | � d S( s� Moves the range of columns from position FROM through TO by
the distance indicated by OFFSET. For example, move_column(2, 4, 1)
moves the columns 2,3,4 to columns 3,4,5.t moveR N( R R ( R R� R� t offset( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt move_columnC s c C s# | j j | d d | | | � d S( s� Moves the range of rows from position FROM through TO by
the distance indicated by OFFSET.
For example, move_row(2, 4, 1) moves the rows 2,3,4 to rows 3,4,5.R� R N( R R ( R R� R� R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt move_rowI s c C s" | j | j j | d | | � � S( s8 Return coordinate of cell nearest pixel coordinate (x,y)RT ( R= R R ( R R] R^ ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRT O s c K sT | j | j | � } | d k r4 d | f | } n | j j | d | | | � d S( Ns -itemtypeR ( R( R) R# R R ( R R] R^ R� R* t args( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR Y s c K s7 | j j | j j | j d d | | j i | � � � S( s� Queries or sets the size of the column given by
INDEX. INDEX may be any non-negative
integer that gives the position of a given column.
INDEX can also be the string "default"; in this case, this command
queries or sets the default size of all columns.
When no option-value pair is given, this command returns a tuple
containing the current size setting of the given column. When
option-value pairs are given, the corresponding options of the
size setting of the given column are changed. Options may be one
of the follwing:
pad0 pixels
Specifies the paddings to the left of a column.
pad1 pixels
Specifies the paddings to the right of a column.
size val
Specifies the width of a column. Val may be:
"auto" -- the width of the column is set to the
width of the widest cell in the column;
a valid Tk screen distance unit;
or a real number following by the word chars
(e.g. 3.4chars) that sets the width of the column to the
given number of characters.R/ R ( R R� R RP R( ( R R� R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt size_column_ s !c K s4 | j j | j j | d d | | j i | � � � S( s� Queries or sets the size of the row given by
INDEX. INDEX may be any non-negative
integer that gives the position of a given row .
INDEX can also be the string "default"; in this case, this command
queries or sets the default size of all rows.
When no option-value pair is given, this command returns a list con-
taining the current size setting of the given row . When option-value
pairs are given, the corresponding options of the size setting of the
given row are changed. Options may be one of the follwing:
pad0 pixels
Specifies the paddings to the top of a row.
pad1 pixels
Specifies the paddings to the bottom of a row.
size val
Specifies the height of a row. Val may be:
"auto" -- the height of the row is set to the
height of the highest cell in the row;
a valid Tk screen distance unit;
or a real number following by the word chars
(e.g. 3.4chars) that sets the height of the row to the
given number of characters.R/ R ( R R� R R( ( R R� R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt size_rowy s c C s | j j | j d | | � d S( s7 Clears the cell at (x, y) by removing its display item.t unsetN( R R RP ( R R] R^ ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s N( R; R< R= R# RB R R� R R� R� R� R� RR RS RD R> R� R� RT R R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s(
t ScrolledGridc B s e Z d Z d i d � Z RS( s Scrolled Grid widgetsc K s/ g } | | _ t j | | d | | | � d S( Nt tixScrolledGrid( R) Rd RB ( R Rl R) R* R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s N( R; R< R= R# RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s i i i i i ( ( ( (x RC RA R R t TkVersiont ImportErrort _tkintert WINDOWt TEXTt STATUSt IMMEDIATEt IMAGEt IMAGETEXTt BALLOONt AUTOt ACROSSTOPt ASCIIt CELLt COLUMNt
DECREASINGt
INCREASINGt INTEGERt MAINt MAXt REALt ROWt S_REGIONt X_REGIONt Y_REGIONt
TCL_DONT_WAITt TCL_WINDOW_EVENTSt TCL_FILE_EVENTSt TCL_TIMER_EVENTSt TCL_IDLE_EVENTSt TCL_ALL_EVENTSR R> RN Ri t __bases__Rd R� R� R� R� R� R� R� R� R� R� R� R� R� R R t XViewt YViewR R_ Ra Rd Rh Rs Ru Ry Rz R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� t ButtonR� t CheckbuttonR� t EntryR� t FrameRg t LabelR� t ListboxR� t MenuR t
MenubuttonR~ t ScrollbarR� t TextR� R� R� Rm R� R� R� R� R� R R� R R� Rl R� R� R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt <module> s�
� -�80,!" �# ( )
S.7
� tkFileDialog.py 0000644 00000013137 15032720555 0007465 0 ustar 00 #
# Instant Python
# $Id: tkFileDialog.py 36560 2004-07-18 06:16:08Z tim_one $
#
# tk common file dialogues
#
# this module provides interfaces to the native file dialogues
# available in Tk 4.2 and newer, and the directory dialogue available
# in Tk 8.3 and newer.
#
# written by Fredrik Lundh, May 1997.
#
#
# options (all have default values):
#
# - defaultextension: added to filename if not explicitly given
#
# - filetypes: sequence of (label, pattern) tuples. the same pattern
# may occur with several patterns. use "*" as pattern to indicate
# all files.
#
# - initialdir: initial directory. preserved by dialog instance.
#
# - initialfile: initial file (ignored by the open dialog). preserved
# by dialog instance.
#
# - parent: which window to place the dialog on top of
#
# - title: dialog title
#
# - multiple: if true user may select more than one file
#
# options for the directory chooser:
#
# - initialdir, parent, title: see above
#
# - mustexist: if true, user must pick an existing directory
#
#
from tkCommonDialog import Dialog
class _Dialog(Dialog):
def _fixoptions(self):
try:
# make sure "filetypes" is a tuple
self.options["filetypes"] = tuple(self.options["filetypes"])
except KeyError:
pass
def _fixresult(self, widget, result):
if result:
# keep directory and filename until next time
import os
# convert Tcl path objects to strings
try:
result = result.string
except AttributeError:
# it already is a string
pass
path, file = os.path.split(result)
self.options["initialdir"] = path
self.options["initialfile"] = file
self.filename = result # compatibility
return result
#
# file dialogs
class Open(_Dialog):
"Ask for a filename to open"
command = "tk_getOpenFile"
def _fixresult(self, widget, result):
if isinstance(result, tuple):
# multiple results:
result = tuple([getattr(r, "string", r) for r in result])
if result:
import os
path, file = os.path.split(result[0])
self.options["initialdir"] = path
# don't set initialfile or filename, as we have multiple of these
return result
if not widget.tk.wantobjects() and "multiple" in self.options:
# Need to split result explicitly
return self._fixresult(widget, widget.tk.splitlist(result))
return _Dialog._fixresult(self, widget, result)
class SaveAs(_Dialog):
"Ask for a filename to save as"
command = "tk_getSaveFile"
# the directory dialog has its own _fix routines.
class Directory(Dialog):
"Ask for a directory"
command = "tk_chooseDirectory"
def _fixresult(self, widget, result):
if result:
# convert Tcl path objects to strings
try:
result = result.string
except AttributeError:
# it already is a string
pass
# keep directory until next time
self.options["initialdir"] = result
self.directory = result # compatibility
return result
#
# convenience stuff
def askopenfilename(**options):
"Ask for a filename to open"
return Open(**options).show()
def asksaveasfilename(**options):
"Ask for a filename to save as"
return SaveAs(**options).show()
def askopenfilenames(**options):
"""Ask for multiple filenames to open
Returns a list of filenames or empty list if
cancel button selected
"""
options["multiple"]=1
return Open(**options).show()
# FIXME: are the following perhaps a bit too convenient?
def askopenfile(mode = "r", **options):
"Ask for a filename to open, and returned the opened file"
filename = Open(**options).show()
if filename:
return open(filename, mode)
return None
def askopenfiles(mode = "r", **options):
"""Ask for multiple filenames and return the open file
objects
returns a list of open file objects or an empty list if
cancel selected
"""
files = askopenfilenames(**options)
if files:
ofiles=[]
for filename in files:
ofiles.append(open(filename, mode))
files=ofiles
return files
def asksaveasfile(mode = "w", **options):
"Ask for a filename to save as, and returned the opened file"
filename = SaveAs(**options).show()
if filename:
return open(filename, mode)
return None
def askdirectory (**options):
"Ask for a directory, and return the file name"
return Directory(**options).show()
# --------------------------------------------------------------------
# test stuff
if __name__ == "__main__":
# Since the file name may contain non-ASCII characters, we need
# to find an encoding that likely supports the file name, and
# displays correctly on the terminal.
# Start off with UTF-8
enc = "utf-8"
import sys
# See whether CODESET is defined
try:
import locale
locale.setlocale(locale.LC_ALL,'')
enc = locale.nl_langinfo(locale.CODESET)
except (ImportError, AttributeError):
pass
# dialog for openening files
openfilename=askopenfilename(filetypes=[("all files", "*")])
try:
fp=open(openfilename,"r")
fp.close()
except:
print "Could not open File: "
print sys.exc_info()[1]
print "open", openfilename.encode(enc)
# dialog for saving files
saveasfilename=asksaveasfilename()
print "saveas", saveasfilename.encode(enc)
Canvas.pyc 0000644 00000036314 15032720555 0006507 0 ustar 00 �
z fc @ s/ d d l m Z e d d d �[ d d l m Z m Z m Z d d d � � YZ d e f d � � YZ d
e f d � � YZ d e f d
� � YZ d e f d � � YZ
d e f d � � YZ d e f d � � YZ d e f d � � YZ
d e f d � � YZ d e f d � � YZ d d d � � YZ d S( i����( t warnpy3ks0 the Canvas module has been removed in Python 3.0t
stackleveli ( t Canvast _cnfmerget _flattent
CanvasItemc B s% e Z d � Z d � Z d � Z d � Z d � Z e Z d � Z d � Z d � Z
d � Z d d
� Z d � Z
d d d d � Z d d
� Z i d � Z d d � Z d d � Z d � Z d � Z d � Z d � Z d � Z d � Z d d � Z d � Z d d � Z e Z d � Z d � Z RS( c O sP | | _ | j | | | � | _ t | d � s< i | _ n | | j | j <d S( Nt items( t canvast _createt idt hasattrR ( t selfR t itemTypet argst kw( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt __init__ s
c C s
t | j � S( N( t strR ( R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt __str__ s c C s d | j j | j f S( Ns <%s, id=%d>( t __class__t __name__R ( R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt __repr__ s c C s' | j j | j =| j j | j � d S( N( R R R t delete( R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR s c C sB | j j j | j j j | j j d | j d | � � } | d S( Nt
itemconfiguret -i ( R t tkt splitt callt _wR ( R t keyt v( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt __getitem__ s c C s! | j j | j i | | 6� d S( N( R t
itemconfigR ( R R t value( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt __setitem__! s c C s[ t | d � sT t | j j d � | j j j | j j d | j f � � � | _ n | j S( Nt _keysc S s | j | � d d S( Ni i ( t splitlist( t xR ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt <lambda>% s R ( R
t mapR R R# t _doR R" ( R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt keys# s c C s | | j � k S( N( R( ( R R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt has_key, s c C s | | j � k S( N( R( ( R R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt __contains__. s t withtagc C s | j j | | | j � d S( N( R t addtagR ( R t tagt option( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR, 0 s c C s7 | j j | j � \ } } } } | | f | | f f S( N( R t bboxR ( R t x1t y1t x2t y2( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR/ 2 s !c C s | j j | j | | | � S( N( R t tag_bindR ( R t sequencet commandt add( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt bind5 s c C s | j j | j | | � d S( N( R t
tag_unbindR ( R R5 t funcid( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt unbind7 s c K s" | j j | j t | | f � � S( N( R R R R ( R t cnfR ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt config9 s c C sC d } x$ | D] \ } } | | | f } q
W| j j | j | � S( N( ( R t coordsR ( R t ptst flatR$ t y( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR> ; s c C s | j j | j | | � d S( N( R t dcharsR ( R t firstt last( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRB ? s c C s | j j | j | � d S( N( R t dtagR ( R t ttd( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRE A s c C s | j j | j � d S( N( R t focusR ( R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRG C s c C s | j j | j � S( N( R t gettagsR ( R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRH E s c C s | j j | j | � d S( N( R t icursorR ( R t index( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRI G s c C s | j j | j | � S( N( R RJ R ( R RJ ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRJ I s c C s | j j | j | | � d S( N( R t insertR ( R t
beforethist string( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRK K s c C s | j j | j | � d S( N( R t tag_lowerR ( R t belowthis( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt lowerM s c C s | j j | j | | � d S( N( R t moveR ( R t xamountt yamount( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRQ O s c C s | j j | j | � d S( N( R t tag_raiseR ( R t abovethis( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt tkraiseQ s c C s# | j j | j | | | | � d S( N( R t scaleR ( R t xorigint yorigint xscalet yscale( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRW T s c C s | j j | j � S( N( R t typeR ( R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR\ V s N( ( R t
__module__R R R R R t cgetR! R( R) R* R, R/ t NoneR8 R; R= R> RB RE RG RH RI RJ RK RP RQ RV t raise_RW R\ ( ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR
s: t Arcc B s e Z d � Z RS( c O s t j | | d | | � d S( Nt arc( R R ( R R R
R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR Z s ( R R] R ( ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRa Y s t Bitmapc B s e Z d � Z RS( c O s t j | | d | | � d S( Nt bitmap( R R ( R R R
R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR ^ s ( R R] R ( ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRc ] s t ImageItemc B s e Z d � Z RS( c O s t j | | d | | � d S( Nt image( R R ( R R R
R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR b s ( R R] R ( ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRe a s t Linec B s e Z d � Z RS( c O s t j | | d | | � d S( Nt line( R R ( R R R
R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR f s ( R R] R ( ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRg e s t Ovalc B s e Z d � Z RS( c O s t j | | d | | � d S( Nt oval( R R ( R R R
R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR j s ( R R] R ( ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRi i s t Polygonc B s e Z d � Z RS( c O s t j | | d | | � d S( Nt polygon( R R ( R R R
R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR n s ( R R] R ( ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRk m s t Rectanglec B s e Z d � Z RS( c O s t j | | d | | � d S( Nt rectangle( R R ( R R R
R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR r s ( R R] R ( ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRm q s t
CanvasTextc B s e Z d � Z RS( c O s t j | | d | | � d S( Nt text( R R ( R R R
R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR w s ( R R] R ( ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRo v s t Windowc B s e Z d � Z RS( c O s t j | | d | | � d S( Nt window( R R ( R R R
R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR { s ( R R] R ( ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRq z s t Groupc B sO e Z d d � Z d � Z e Z d � Z d � Z d � Z d � Z d d d � Z
d � Z d � Z d � Z
d
� Z d d d d � Z d d � Z d
� Z d d � Z d � Z d d � Z d � Z d � Z d � Z d � Z d � Z i d � Z d d � Z d � Z d d � Z e Z d � Z d � Z d � Z! d � Z" d � Z# RS( c C sI | s d t | � } n | | _ | _ | | _ | j j | j � d S( Ns Group%d( R R- R RE ( R R R- ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR s
c C s | j S( N( R- ( R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR � s c G s# | j j | | j f t | � � S( N( R R' R- R ( R t cmdR
( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR' � s c C s | j d d | � d S( NR, t above( R' ( R t tagOrId( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt addtag_above� s c C s | j d d � d S( NR, t all( R' ( R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt
addtag_all� s c C s | j d d | � d S( NR, t below( R' ( R Rv ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt addtag_below� s c C s | j d d | | | | � d S( NR, t closest( R' ( R R$ RA t halot start( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt addtag_closest� s c C s | j d d | | | | � d S( NR, t enclosed( R' ( R R0 R1 R2 R3 ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt addtag_enclosed� s c C s | j d d | | | | � d S( NR, t overlapping( R' ( R R0 R1 R2 R3 ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt addtag_overlapping� s c C s | j d d | � d S( NR, R+ ( R' ( R Rv ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt addtag_withtag� s c C s | j j | j d � � S( NR/ ( R t _getintsR' ( R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR/ � s c C s | j j | j | | | � S( N( R R4 R ( R R5 R6 R7 ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR8 � s c C s | j j | j | | � d S( N( R R9 R ( R R5 R: ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR; � s c G s | j d | � S( NR> ( R' ( R R? ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR> � s c C s | j d | | � d S( NRB ( R' ( R RC RD ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRB � s c C s | j d � d S( NR ( R' ( R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR � s c C s | j d | � d S( NRE ( R' ( R t tagToDelete( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRE � s c C s | j d � d S( NRG ( R' ( R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRG � s c C s" | j j j | j d | j � � S( NRH ( R R R# R' R- ( R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRH � s c C s | j d | � S( NRI ( R' ( R RJ ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRI � s c C s | j j j | j d | � � S( NRJ ( R R t getintR' ( R RJ ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRJ � s c C s | j d | | � d S( NRK ( R' ( R t
beforeThisRM ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRK � s c K s" | j j | j t | | f � � S( N( R R R- R ( R R< R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR= � s c C s | j d | � d S( NRP ( R' ( R t belowThis( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRP � s c C s | j d | | � d S( NRQ ( R' ( R t xAmountt yAmount( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRQ � s c C s | j d | � d S( Nt raise( R' ( R t aboveThis( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRV � s c C s | j d | | | | � d S( NRW ( R' ( R t xOrigint yOrigint xScalet yScale( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRW � s c C s# | j j d d | j | f � d S( Nt selectt adjust( R R' R- ( R RJ ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt
select_adjust� s c C s# | j j d d | j | f � d S( NR� t from( R R' R- ( R RJ ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt select_from� s c C s# | j j d d | j | f � d S( NR� t to( R R' R- ( R RJ ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt select_to� s c C s
| j d � S( NR\ ( R' ( R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR\ � s N($ R R] R_ R R R R' Rw Ry R{ R R� R� R� R/ R8 R; R> RB R RE RG RH RI RJ RK R= RP RQ RV t liftRW R� R� R� R\ ( ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRs ~ sB N( ( ( t warningsR t TkinterR R R R Ra Rc Re Rg Ri Rk Rm Ro Rq Rs ( ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt <module> s L tkColorChooser.pyo 0000644 00000002614 15032720555 0010244 0 ustar 00 �
z fc @ sQ d d l m Z d e f d � � YZ d d � Z e d k rM d Ge � GHn d S( i����( t Dialogt Chooserc B s& e Z d Z d Z d � Z d � Z RS( s Ask for a colort tk_chooseColorc C sL y4 | j d } t | t � r3 d | | j d <n Wn t k
rG n Xd S( Nt initialcolors
#%02x%02x%02x( t optionst
isinstancet tuplet KeyError( t selft color( ( s- /usr/lib64/python2.7/lib-tk/tkColorChooser.pyt _fixoptions! s
c C sU | s t | � r d S| j | � \ } } } | d | d | d f t | � f S( Ni ( NN( t strt Nonet winfo_rgb( R t widgett resultt rt gt b( ( s- /usr/lib64/python2.7/lib-tk/tkColorChooser.pyt
_fixresult+ s ( t __name__t
__module__t __doc__t commandR
R ( ( ( s- /usr/lib64/python2.7/lib-tk/tkColorChooser.pyR s
c K s/ | r | j � } | | d <n t | � j � S( s Ask for a colorR ( t copyR t show( R R ( ( s- /usr/lib64/python2.7/lib-tk/tkColorChooser.pyt askcolor: s
t __main__R N( t tkCommonDialogR R R R R ( ( ( s- /usr/lib64/python2.7/lib-tk/tkColorChooser.pyt <module> s
test/widget_tests.pyo 0000644 00000063575 15032720555 0011005 0 ustar 00 �
z fc @ sV d d l Z d d l Z d d l Z d d l m Z d d l m Z m Z m Z m
Z
m Z m Z d d l
Z e Z Z e
� d d d f k r� e Z n e o� e e � Z d � Z e Z e
� d d d d f k r� e Z n e � Z d e f d
� � YZ d e f d � � YZ d
e f d � � YZ d e f d � � YZ d � Z d � Z d S( i����N( t Scale( t AbstractTkTestt tcl_versiont requires_tclt get_tk_patchlevelt pixels_convt
tcl_obj_eqi i i c C s t t | � � S( N( t intt round( t x( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt int_round s i t AbstractWidgetTestc B s� e Z e e � Z d Z e Z e d � � Z
d � Z d e j
d � Z e e d d � Z d e d � Z d � Z d � Z d � Z d � Z d d � Z d
� Z d � Z d � Z d
� Z d � Z d � Z d � Z d � Z d � Z RS( c C sE y | j SWn3 t k
r@ t | j j d d � � | _ | j SXd S( Nt tkt scaling( t _scalingt AttributeErrort floatt roott call( t self( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyR
" s
c C sU | j r# | j r# t d k r# | St | t � rK d j t | j | � � St | � S( Ni i t ( i i ( t
_stringifyt wantobjectsR t
isinstancet tuplet joint mapt _strt str( R t value( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyR * s
c C s* | | | � r d S| j | | | � d S( N( t assertEqual( R t actualt expectedt msgt eq( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt assertEqual21 s c C s | | | <| t k r | } n | r4 | | � } n | j sG | j rw t | t � rh t j | � } qw t | � } n | d k r� t } n | j
| | | d | �| j
| j | � | d | �t | t � s| j
| � } | j t | � d � | j
| d | d | �n d S( NR" i i ( t _sentinelR R R R t tkintert _joinR t NoneR R# t cgetR t configureR t len( R t widgett nameR R t convR" t t( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt
checkParam6 s"
c C s | | } | d k r( | j | � } n | j t j � � } | | | <Wd QX| d k ru | j t | j � | � n | r� | j | | | � n
| | | <| j t j � � } | j i | | 6� Wd QX| d k r� | j t | j � | � n | r| j | | | � n
| | | <d S( N( R' t formatt assertRaisesR% t TclErrorR R t exceptionR) ( R R+ R, R t errmsgt keep_origt origt cm( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt checkInvalidParamL s"
c O s+ x$ | D] } | j | | | | � q Wd S( N( R/ ( R R+ R, t valuest kwargsR ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt checkParamsb s
c O se | j | | | | � | j | | d d d �| j | | d d d �| j | | d d d �d S( Nt R4 s expected integer but got ""t 10ps expected integer but got "10p"g������ @s expected integer but got "3.2"( R; R8 ( R R+ R, R9 R: ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt checkIntegerParamf s c O s� d | k r | j d � } n t } x* | D]" } | j | | | d | | �q+ W| j | | d d d �| j | | d d d �d S( NR- R< R4 s) expected floating-point number but got ""t spams- expected floating-point number but got "spam"( t popR R/ R8 ( R R+ R, R9 R: R- R ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt checkFloatParamo s
c C s� x6 t d d d d f D] } | j | | | d d �q Wx6 t d d d d f D] } | j | | | d d �qO W| j | | d
d d �| j | | d
d d �d S( Ni t falset not offR i t truet yest onR< R4 s! expected boolean value but got ""R? s% expected boolean value but got "spam"( t FalseR/ t TrueR8 ( R R+ R, R ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt checkBooleanParam{ s c K sN | j | | d d d d d d d d d d
| � | j | | d d d
�d S( Ns #ff0000s #00ff00s #0000ffs #123456t redt greent bluet whitet blackt greyR? R4 s unknown color name "spam"( R; R8 ( R R+ R, t allow_emptyR: ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt checkColorParam� s c K s^ | j | | d d d d | � t d k rA | j | | d � n | j | | d d d
�d S( Nt arrowt watcht crossR< i i t noneR? R4 s bad cursor spec "spam"( i i ( R; R R/ R8 ( R R+ R, R: ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt checkCursorParam� s
c C s; d � } | | | <| j | | � | j | | d � d S( Nc W s d S( N( ( t args( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt command� s R< ( t
assertTrueR; ( R R+ R, RY ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt checkCommandParam� s
c O s� d | k r | j d � } n d } | j | | | | � | d k r� d | d j | d � t | � d k rt d n d | d f } | j | | d d d | �d | } n | j | | d
d | �d S( NR4 s %s "{}": must be %s%s or %ss , i����i t ,R< t ambiguoust badR? ( R@ R' R; R R* R8 ( R R+ R, R9 R: R4 t errmsg2( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt checkEnumParam� s
c
O s! d | k r | j d � } n d } | d k r< | j } n d | k rZ | j d � } n t } x| | D]t } t } | } t | t � r� | r� | t k r� t | � | j } t } q� n | j
| | | d | d | | �qg W| j | | d d d d | �| j | | d d d d | �d S( NR- R5 R t 6xR4 s bad screen distance "6x"R? s bad screen distance "spam"( R@ R' t _conv_pixelsRI R$ R R R R
R
R/ R8 (
R R+ R, R9 R: R- R5 R R t conv1( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt checkPixelsParam� s*
c C sZ | j | | d d d d d d � d } t d k r= d } n | j | | d
d | �d S(
Nt flatt groovet raisedt ridget solidt sunkensH bad relief "spam": must be flat, groove, raised, ridge, solid, or sunkeni i R? R4 ( i i ( R; R R' R8 ( R R+ R, R4 ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt checkReliefParam� s c C s[ t j d | j d d � } | j | | | d t �| j | | d d d �d | | <d S( Nt masterR, t image1R- R? R4 s image "spam" doesn't existR< ( R% t
PhotoImageR R/ R R8 ( R R+ R, t image( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt checkImageParam� s
c C s | j | | | d t �d S( NR- ( R/ R ( R R+ R, t var( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt checkVariableParam� s c C s� | j | � | j | t � t | � d k rF | j d | f � n x5 | D]- } t | t � sM | j d | f � PqM qM Wd S( Ni s Invalid bounding box: %r( t assertIsNotNonet assertIsInstanceR R* t failR R ( R t bboxt item( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt assertIsBoundingBox� s
c C s | j � } | j � } t | t � sL | j t | � t | j � � � n x | D] } | | qS Wt j j ri d d 6d d 6d d 6d d 6d d
6} t
| � } t
| j � } x_ t | | � D]J } | | k o� | | | k o� | | | k s� d | j j
| f GHq� q� Wn d S( Nt borderwidtht bdt
backgroundt bgt
foregroundt fgt invalidcommandt invcmdt validatecommandt vcmds %s.OPTIONS doesn't contain "%s"( t createt keysR R R t sortedR) t testt test_supportt verboset sett OPTIONSt __class__t __name__( R R+ R� t kt aliasesR ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_keys� s* %
N(! R� t
__module__t staticmethodt pixels_roundRb R' t _conv_pad_pixelsRH R t propertyR
R t objectt __eq__R# R$ R/ RI R8 R; R> RA RJ RR RW R[ R` Rd Rk Rp Rr Rx R� ( ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyR s0
t StandardOptionsTestsc * B s e Z db Z d* � Z d+ � Z d, � Z d- � Z d. � Z d/ � Z d0 � Z d1 � Z
d2 � Z d3 � Z d4 � Z
d5 � Z d6 � Z d7 � Z d8 � Z d9 � Z e j e j d: k d; � d< � � Z d= � Z d> � Z d? � Z d@ � Z dA � Z dB � Z dC � Z dD � Z dE � Z dF � Z! dG � Z" dH � Z# dI � Z$ dJ � Z% dK � Z& dL � Z' dM � Z( dN � Z) dO � Z* dP � Z+ dQ � Z, dR � Z- dS � Z. dT � Z/ dU � Z0 dV � Z1 dW � Z2 dX � Z3 dY � Z4 dZ � Z5 d[ � Z6 d\ � Z7 e8 d] d^ � d_ � � Z9 e8 d] d^ � d` � � Z: da � Z; RS(c t activebackgroundt activeborderwidtht activeforegroundt anchorR{ t bitmapRy t compoundt cursort disabledforegroundt exportselectiont fontR} t highlightbackgroundt highlightcolort highlightthicknessRo t insertbackgroundt insertborderwidtht
insertofftimet insertontimet insertwidtht jumpt justifyt orientt padxt padyt relieft repeatdelayt repeatintervalt selectbackgroundt selectborderwidtht selectforegroundt setgridt takefocust textt textvariablet troughcolort underlinet
wraplengtht xscrollcommandt yscrollcommandc C s | j � } | j | d � d S( NR� ( R� RR ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_activebackground
s c C s2 | j � } | j | d d d d d d d � d S( NR� i g�������?g333333@i i����R= ( R� Rd ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_activeborderwidth s c C s | j � } | j | d � d S( NR� ( R� RR ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_activeforeground s c C s; | j � } | j | d d d d d d d d d d
� d S( NR� t nt net et set st swt wt nwt center( R� R` ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_anchor s c C sB | j � } | j | d � d | j k r> | j | d � n d S( NR{ R| ( R� RR R� ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_background s c C s� | j � } | j | d d � | j | d d � t j j d d d �} | j | d d | � d | j j j d d
� k o� d | j j � k s� | j | d d d
d �n d S( NR� t questheadt gray50s
python.xbmt subdirt
imghdrdatat @t aquaR t windowingsystemt AppKitR? R4 s bitmap "spam" not defined(
R� R/ R� R� t findfileR R R t winfo_serverR8 ( R R+ t filename( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_bitmap% s c C sf | j � } | j | d d d d d d d � d | j k rb | j | d d d d d d d � n d S( NRy i g�������?g������@i i����R= Rz ( R� Rd R� ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_borderwidth2 s
c C s2 | j � } | j | d d d d d d d � d S( NR� t bottomR� t leftRV t rightt top( R� R` ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt
test_compound9 s c C s | j � } | j | d � d S( NR� ( R� RW ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_cursor> s c C s | j � } | j | d � d S( NR� ( R� RR ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_disabledforegroundB s c C s | j � } | j | d � d S( NR� ( R� RJ ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_exportselectionF s c C s< | j � } | j | d d � | j | d d d d �d S( NR� s3 -Adobe-Helvetica-Medium-R-Normal--*-120-*-*-*-*-*-*R< R4 s font "" doesn't exist( R� R/ R8 ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_fontJ s
c C sB | j � } | j | d � d | j k r> | j | d � n d S( NR} R~ ( R� RR R� ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_foregroundQ s c C s | j � } | j | d � d S( NR� ( R� RR ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_highlightbackgroundW s c C s | j � } | j | d � d S( NR� ( R� RR ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_highlightcolor[ s c C sQ | j � } | j | d d d d d d � | j | d d d d d | j �d S(
NR� i g�������?g������@i R= i����R R- ( R� Rd R/ Rb ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_highlightthickness_ s
t darwins" crashes with Cocoa Tk (issue19733)c C s | j � } | j | d � d S( NRo ( R� Rp ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt
test_imagef s c C s | j � } | j | d � d S( NR� ( R� RR ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_insertbackgroundl s c C s2 | j � } | j | d d d d d d d � d S( NR� i g�������?g������@i i����R= ( R� Rd ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_insertborderwidthp s c C s# | j � } | j | d d � d S( NR� id ( R� R> ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_insertofftimeu s c C s# | j � } | j | d d � d S( NR� id ( R� R> ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_insertontimey s c C s, | j � } | j | d d d d d � d S( NR� g�������?g������@i����R= ( R� Rd ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_insertwidth} s c C s | j � } | j | d � d S( NR� ( R� RJ ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_jump� s c C sH | j � } | j | d d d d d d �| j | d d d d �d S( NR� R� R� R� R4 s6 bad justification "{}": must be left, right, or centerR< s: ambiguous justification "": must be left, right, or center( R� R` R8 ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_justify� s
c C sC | j � } | j t | d � | j � | j | d d d � d S( NR� t
horizontalt vertical( R� R R t default_orientR` ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_orient� s c
C s8 | j � } | j | d d d d d d d | j �d S( NR� i g������@gffffff@i����t 12mR- ( R� Rd R� ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_padx� s c
C s8 | j � } | j | d d d d d d d | j �d S( NR� i g������@gffffff@i����R� R- ( R� Rd R� ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_pady� s c C s | j � } | j | d � d S( NR� ( R� Rk ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_relief� s c C s& | j � } | j | d d d � d S( NR� i ���i� ( R� R> ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_repeatdelay� s c C s& | j � } | j | d d d � d S( NR� i ���i� ( R� R> ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_repeatinterval� s c C s | j � } | j | d � d S( NR� ( R� RR ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_selectbackground� s c C s, | j � } | j | d d d d d � d S( NR� g�������?g������@i����R= ( R� Rd ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_selectborderwidth� s c C s | j � } | j | d � d S( NR� ( R� RR ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_selectforeground� s c C s | j � } | j | d � d S( NR� ( R� RJ ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_setgrid� s c C s) | j � } | j | d d d d � d S( Nt statet activet disabledt normal( R� R` ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt
test_state� s c C s) | j � } | j | d d d d � d S( NR� t 0t 1R< ( R� R; ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_takefocus� s c C s& | j � } | j | d d d � d S( NR� R< s
any string( R� R; ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_text� s c C s5 | j � } t j | j � } | j | d | � d S( NR� ( R� R% t StringVarR Rr ( R R+ Rq ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_textvariable� s c C s | j � } | j | d � d S( NR� ( R� RR ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_troughcolor� s c C s) | j � } | j | d d d d � d S( NR� i i i
( R� R> ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_underline� s c C s# | j � } | j | d d � d S( NR� id ( R� Rd ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_wraplength� s c C s | j � } | j | d � d S( NR� ( R� R[ ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_xscrollcommand� s c C s | j � } | j | d � d S( NR� ( R� R[ ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_yscrollcommand� s c C s | j � } | j | d � d S( NRY ( R� R[ ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_command� s c C s | j � } | j | d � d S( Nt indicatoron( R� RJ ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_indicatoron� s c C s | j � } | j | d � d S( Nt offrelief( R� Rk ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_offrelief� s c C s | j � } | j | d � d S( Nt
overrelief( R� Rk ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_overrelief� s c C s | j � } | j | d � d S( Nt selectcolor( R� RR ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_selectcolor� s c C s | j � } | j | d � d S( Nt selectimage( R� Rp ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_selectimage� s i i c C s | j � } | j | d � d S( Nt
tristateimage( R� Rp ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_tristateimage� s c C s# | j � } | j | d d � d S( Nt
tristatevaluet
unknowable( R� R/ ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_tristatevalue� s c C s5 | j � } t j | j � } | j | d | � d S( Nt variable( R� R% t DoubleVarR Rr ( R R+ Rq ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt
test_variable s (* R� R� R� R� R{ R� Ry R� R� R� R� R� R} R� R� R� Ro R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� (< R� R� t STANDARD_OPTIONSR� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� t unittestt skipIft syst platformR� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R R R R R R R
R R R
R R R R R R R R R ( ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyR� � s�
t IntegerSizeTestsc B s e Z d � Z d � Z RS( c C s) | j � } | j | d d d d � d S( Nt heightid i����i ( R� R> ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_height s c C s) | j � } | j | d d d d � d S( Nt widthi� in���i ( R� R> ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt
test_width
s ( R� R� R' R) ( ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyR% s t PixelSizeTestsc B s e Z d � Z d � Z RS( c C s2 | j � } | j | d d d d d d d � d S( NR& id g�����LY@gfffff�Y@i����i t 3c( R� Rd ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyR' s c C s2 | j � } | j | d d d d d d d � d S( NR( i� gfffff6y@g�����Iy@in���i t 5i( R� Rd ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyR) s ( R� R� R' R) ( ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyR* s c s � f d � } | S( Nc s� x� � j D]� } d | } t � | � s
xk � D]5 } t | | � r0 t � | t | | � j � Pq0 q0 W| � f d � } | | _ t � | | � q
q
W� S( Nt test_c s1 | j � } | | t d | � j f � � d S( Ns Option "%s" is not tested in %s( R� t AssertionErrorR� ( R t optionR+ ( t cls( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyR� ) s ( R� t hasattrt setattrt getattrt im_funcR� ( R0 R/ t
methodnamet source_classR� ( t source_classes( R0 s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt decorator s
( ( R7 R8 ( ( R7 s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt add_standard_options s c C s4 t j j r0 t j � } d G| j d d � GHn d S( Ns patchlevel =t infot
patchlevel( R� R� R� R% t TclR ( t tcl( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt setUpModule3 s ( R! R# t TkinterR% t ttkR t test_ttk.supportR R R R R R t test.test_supportR� RH t noconvt noconv_methR R� R
R� R R� R$ R R� R% R* R9 R> ( ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt <module> s* .
��
test/runtktests.pyo 0000644 00000005453 15032720555 0010515 0 ustar 00 �
z fc @ s� d Z d d l Z d d l Z d d l Z d d l Z d d l Z e j j e j j e
� � Z d � Z e e
d d � Z e
e
d d � Z e d k r� e j j e � � n d S( s�
Use this module to get and run all tk tests.
Tkinter tests should live in a package inside the directory where this file
lives, like test_tkinter.
Extensions also should live in packages following the same rule as above.
i����Nc C s. x' t j | � D] } | d k r t Sq Wt S( Ns __init__.pys __init__.pycs
__init.pyo( s __init__.pys __init__.pycs
__init.pyo( t ost listdirt Truet False( t patht name( ( s. /usr/lib64/python2.7/lib-tk/test/runtktests.pyt
is_package s c # s- d � x t j | � D]\ } } } x4 t | � D]& } | d d k r2 | j | � q2 q2 Wt | � r | r | t | � t t j � j d d � } | r� | | k r� q n t � f d � | � } x[ | D]P } y$ t j
d | t � � | � VWq� t j j
k
r | r � q q� Xq� Wq q Wd S( s� This will import and yield modules whose names start with test_
and are inside packages found in the path starting at basepath.
If packages is specified it should contain package names that want
their tests collected.
s .pyi t .t /c s | j d � o | j � � S( Nt test_( t
startswitht endswith( t x( t py_ext( s. /usr/lib64/python2.7/lib-tk/test/runtktests.pyt <lambda>+ t s .%sN( R t walkt listt removeR t lent sept replacet filtert importlibt
import_modulet testt test_supportt ResourceDenied( t basepatht guit packagest dirpatht dirnamest filenamest dirnamet pkg_nameR ( ( R
s. /usr/lib64/python2.7/lib-tk/test/runtktests.pyt get_tests_modules s& )
c c s� g } | r | j d � n | r2 | j d � n xP t d | d | � D]9 } x0 | D]( } x t | | d � D] } | Vqn WqU WqH Wd S( s� Yield all the tests in the modules found by get_tests_modules.
If nogui is True, only tests that do not require a GUI will be
returned.t tests_noguit tests_guiR R N( ( t appendR$ t getattr( t textR R t attrst modulet attrR ( ( s. /usr/lib64/python2.7/lib-tk/test/runtktests.pyt get_tests6 s
t __main__( t __doc__R t syst unittestR t test.test_supportR R t abspathR" t __file__t
this_dir_pathR R t NoneR$ R- t __name__R t run_unittest( ( ( s. /usr/lib64/python2.7/lib-tk/test/runtktests.pyt <module> s test/widget_tests.py 0000644 00000050155 15032720555 0010614 0 ustar 00 # Common tests for test_tkinter/test_widgets.py and test_ttk/test_widgets.py
import unittest
import sys
import Tkinter as tkinter
from ttk import Scale
from test_ttk.support import (AbstractTkTest, tcl_version, requires_tcl,
get_tk_patchlevel, pixels_conv, tcl_obj_eq)
import test.test_support
noconv = noconv_meth = False
if get_tk_patchlevel() < (8, 5, 11):
noconv = str
noconv_meth = noconv and staticmethod(noconv)
def int_round(x):
return int(round(x))
pixels_round = int_round
if get_tk_patchlevel()[:3] == (8, 5, 11):
# Issue #19085: Workaround a bug in Tk
# http://core.tcl.tk/tk/info/3497848
pixels_round = int
_sentinel = object()
class AbstractWidgetTest(AbstractTkTest):
_conv_pixels = staticmethod(pixels_round)
_conv_pad_pixels = None
_stringify = False
@property
def scaling(self):
try:
return self._scaling
except AttributeError:
self._scaling = float(self.root.call('tk', 'scaling'))
return self._scaling
def _str(self, value):
if not self._stringify and self.wantobjects and tcl_version >= (8, 6):
return value
if isinstance(value, tuple):
return ' '.join(map(self._str, value))
return str(value)
def assertEqual2(self, actual, expected, msg=None, eq=object.__eq__):
if eq(actual, expected):
return
self.assertEqual(actual, expected, msg)
def checkParam(self, widget, name, value, expected=_sentinel,
conv=False, eq=None):
widget[name] = value
if expected is _sentinel:
expected = value
if conv:
expected = conv(expected)
if self._stringify or not self.wantobjects:
if isinstance(expected, tuple):
expected = tkinter._join(expected)
else:
expected = str(expected)
if eq is None:
eq = tcl_obj_eq
self.assertEqual2(widget[name], expected, eq=eq)
self.assertEqual2(widget.cget(name), expected, eq=eq)
# XXX
if not isinstance(widget, Scale):
t = widget.configure(name)
self.assertEqual(len(t), 5)
self.assertEqual2(t[4], expected, eq=eq)
def checkInvalidParam(self, widget, name, value, errmsg=None,
keep_orig=True):
orig = widget[name]
if errmsg is not None:
errmsg = errmsg.format(value)
with self.assertRaises(tkinter.TclError) as cm:
widget[name] = value
if errmsg is not None:
self.assertEqual(str(cm.exception), errmsg)
if keep_orig:
self.assertEqual(widget[name], orig)
else:
widget[name] = orig
with self.assertRaises(tkinter.TclError) as cm:
widget.configure({name: value})
if errmsg is not None:
self.assertEqual(str(cm.exception), errmsg)
if keep_orig:
self.assertEqual(widget[name], orig)
else:
widget[name] = orig
def checkParams(self, widget, name, *values, **kwargs):
for value in values:
self.checkParam(widget, name, value, **kwargs)
def checkIntegerParam(self, widget, name, *values, **kwargs):
self.checkParams(widget, name, *values, **kwargs)
self.checkInvalidParam(widget, name, '',
errmsg='expected integer but got ""')
self.checkInvalidParam(widget, name, '10p',
errmsg='expected integer but got "10p"')
self.checkInvalidParam(widget, name, 3.2,
errmsg='expected integer but got "3.2"')
def checkFloatParam(self, widget, name, *values, **kwargs):
if 'conv' in kwargs:
conv = kwargs.pop('conv')
else:
conv = float
for value in values:
self.checkParam(widget, name, value, conv=conv, **kwargs)
self.checkInvalidParam(widget, name, '',
errmsg='expected floating-point number but got ""')
self.checkInvalidParam(widget, name, 'spam',
errmsg='expected floating-point number but got "spam"')
def checkBooleanParam(self, widget, name):
for value in (False, 0, 'false', 'no', 'off'):
self.checkParam(widget, name, value, expected=0)
for value in (True, 1, 'true', 'yes', 'on'):
self.checkParam(widget, name, value, expected=1)
self.checkInvalidParam(widget, name, '',
errmsg='expected boolean value but got ""')
self.checkInvalidParam(widget, name, 'spam',
errmsg='expected boolean value but got "spam"')
def checkColorParam(self, widget, name, allow_empty=None, **kwargs):
self.checkParams(widget, name,
'#ff0000', '#00ff00', '#0000ff', '#123456',
'red', 'green', 'blue', 'white', 'black', 'grey',
**kwargs)
self.checkInvalidParam(widget, name, 'spam',
errmsg='unknown color name "spam"')
def checkCursorParam(self, widget, name, **kwargs):
self.checkParams(widget, name, 'arrow', 'watch', 'cross', '',**kwargs)
if tcl_version >= (8, 5):
self.checkParam(widget, name, 'none')
self.checkInvalidParam(widget, name, 'spam',
errmsg='bad cursor spec "spam"')
def checkCommandParam(self, widget, name):
def command(*args):
pass
widget[name] = command
self.assertTrue(widget[name])
self.checkParams(widget, name, '')
def checkEnumParam(self, widget, name, *values, **kwargs):
if 'errmsg' in kwargs:
errmsg = kwargs.pop('errmsg')
else:
errmsg = None
self.checkParams(widget, name, *values, **kwargs)
if errmsg is None:
errmsg2 = ' %s "{}": must be %s%s or %s' % (
name,
', '.join(values[:-1]),
',' if len(values) > 2 else '',
values[-1])
self.checkInvalidParam(widget, name, '',
errmsg='ambiguous' + errmsg2)
errmsg = 'bad' + errmsg2
self.checkInvalidParam(widget, name, 'spam', errmsg=errmsg)
def checkPixelsParam(self, widget, name, *values, **kwargs):
if 'conv' in kwargs:
conv = kwargs.pop('conv')
else:
conv = None
if conv is None:
conv = self._conv_pixels
if 'keep_orig' in kwargs:
keep_orig = kwargs.pop('keep_orig')
else:
keep_orig = True
for value in values:
expected = _sentinel
conv1 = conv
if isinstance(value, str):
if conv1 and conv1 is not str:
expected = pixels_conv(value) * self.scaling
conv1 = int_round
self.checkParam(widget, name, value, expected=expected,
conv=conv1, **kwargs)
self.checkInvalidParam(widget, name, '6x',
errmsg='bad screen distance "6x"', keep_orig=keep_orig)
self.checkInvalidParam(widget, name, 'spam',
errmsg='bad screen distance "spam"', keep_orig=keep_orig)
def checkReliefParam(self, widget, name):
self.checkParams(widget, name,
'flat', 'groove', 'raised', 'ridge', 'solid', 'sunken')
errmsg='bad relief "spam": must be '\
'flat, groove, raised, ridge, solid, or sunken'
if tcl_version < (8, 6):
errmsg = None
self.checkInvalidParam(widget, name, 'spam',
errmsg=errmsg)
def checkImageParam(self, widget, name):
image = tkinter.PhotoImage(master=self.root, name='image1')
self.checkParam(widget, name, image, conv=str)
self.checkInvalidParam(widget, name, 'spam',
errmsg='image "spam" doesn\'t exist')
widget[name] = ''
def checkVariableParam(self, widget, name, var):
self.checkParam(widget, name, var, conv=str)
def assertIsBoundingBox(self, bbox):
self.assertIsNotNone(bbox)
self.assertIsInstance(bbox, tuple)
if len(bbox) != 4:
self.fail('Invalid bounding box: %r' % (bbox,))
for item in bbox:
if not isinstance(item, int):
self.fail('Invalid bounding box: %r' % (bbox,))
break
def test_keys(self):
widget = self.create()
keys = widget.keys()
# XXX
if not isinstance(widget, Scale):
self.assertEqual(sorted(keys), sorted(widget.configure()))
for k in keys:
widget[k]
# Test if OPTIONS contains all keys
if test.test_support.verbose:
aliases = {
'bd': 'borderwidth',
'bg': 'background',
'fg': 'foreground',
'invcmd': 'invalidcommand',
'vcmd': 'validatecommand',
}
keys = set(keys)
expected = set(self.OPTIONS)
for k in sorted(keys - expected):
if not (k in aliases and
aliases[k] in keys and
aliases[k] in expected):
print('%s.OPTIONS doesn\'t contain "%s"' %
(self.__class__.__name__, k))
class StandardOptionsTests(object):
STANDARD_OPTIONS = (
'activebackground', 'activeborderwidth', 'activeforeground', 'anchor',
'background', 'bitmap', 'borderwidth', 'compound', 'cursor',
'disabledforeground', 'exportselection', 'font', 'foreground',
'highlightbackground', 'highlightcolor', 'highlightthickness',
'image', 'insertbackground', 'insertborderwidth',
'insertofftime', 'insertontime', 'insertwidth',
'jump', 'justify', 'orient', 'padx', 'pady', 'relief',
'repeatdelay', 'repeatinterval',
'selectbackground', 'selectborderwidth', 'selectforeground',
'setgrid', 'takefocus', 'text', 'textvariable', 'troughcolor',
'underline', 'wraplength', 'xscrollcommand', 'yscrollcommand',
)
def test_activebackground(self):
widget = self.create()
self.checkColorParam(widget, 'activebackground')
def test_activeborderwidth(self):
widget = self.create()
self.checkPixelsParam(widget, 'activeborderwidth',
0, 1.3, 2.9, 6, -2, '10p')
def test_activeforeground(self):
widget = self.create()
self.checkColorParam(widget, 'activeforeground')
def test_anchor(self):
widget = self.create()
self.checkEnumParam(widget, 'anchor',
'n', 'ne', 'e', 'se', 's', 'sw', 'w', 'nw', 'center')
def test_background(self):
widget = self.create()
self.checkColorParam(widget, 'background')
if 'bg' in self.OPTIONS:
self.checkColorParam(widget, 'bg')
def test_bitmap(self):
widget = self.create()
self.checkParam(widget, 'bitmap', 'questhead')
self.checkParam(widget, 'bitmap', 'gray50')
filename = test.test_support.findfile('python.xbm', subdir='imghdrdata')
self.checkParam(widget, 'bitmap', '@' + filename)
# Cocoa Tk widgets don't detect invalid -bitmap values
# See https://core.tcl.tk/tk/info/31cd33dbf0
if not ('aqua' in self.root.tk.call('tk', 'windowingsystem') and
'AppKit' in self.root.winfo_server()):
self.checkInvalidParam(widget, 'bitmap', 'spam',
errmsg='bitmap "spam" not defined')
def test_borderwidth(self):
widget = self.create()
self.checkPixelsParam(widget, 'borderwidth',
0, 1.3, 2.6, 6, -2, '10p')
if 'bd' in self.OPTIONS:
self.checkPixelsParam(widget, 'bd', 0, 1.3, 2.6, 6, -2, '10p')
def test_compound(self):
widget = self.create()
self.checkEnumParam(widget, 'compound',
'bottom', 'center', 'left', 'none', 'right', 'top')
def test_cursor(self):
widget = self.create()
self.checkCursorParam(widget, 'cursor')
def test_disabledforeground(self):
widget = self.create()
self.checkColorParam(widget, 'disabledforeground')
def test_exportselection(self):
widget = self.create()
self.checkBooleanParam(widget, 'exportselection')
def test_font(self):
widget = self.create()
self.checkParam(widget, 'font',
'-Adobe-Helvetica-Medium-R-Normal--*-120-*-*-*-*-*-*')
self.checkInvalidParam(widget, 'font', '',
errmsg='font "" doesn\'t exist')
def test_foreground(self):
widget = self.create()
self.checkColorParam(widget, 'foreground')
if 'fg' in self.OPTIONS:
self.checkColorParam(widget, 'fg')
def test_highlightbackground(self):
widget = self.create()
self.checkColorParam(widget, 'highlightbackground')
def test_highlightcolor(self):
widget = self.create()
self.checkColorParam(widget, 'highlightcolor')
def test_highlightthickness(self):
widget = self.create()
self.checkPixelsParam(widget, 'highlightthickness',
0, 1.3, 2.6, 6, '10p')
self.checkParam(widget, 'highlightthickness', -2, expected=0,
conv=self._conv_pixels)
@unittest.skipIf(sys.platform == 'darwin',
'crashes with Cocoa Tk (issue19733)')
def test_image(self):
widget = self.create()
self.checkImageParam(widget, 'image')
def test_insertbackground(self):
widget = self.create()
self.checkColorParam(widget, 'insertbackground')
def test_insertborderwidth(self):
widget = self.create()
self.checkPixelsParam(widget, 'insertborderwidth',
0, 1.3, 2.6, 6, -2, '10p')
def test_insertofftime(self):
widget = self.create()
self.checkIntegerParam(widget, 'insertofftime', 100)
def test_insertontime(self):
widget = self.create()
self.checkIntegerParam(widget, 'insertontime', 100)
def test_insertwidth(self):
widget = self.create()
self.checkPixelsParam(widget, 'insertwidth', 1.3, 2.6, -2, '10p')
def test_jump(self):
widget = self.create()
self.checkBooleanParam(widget, 'jump')
def test_justify(self):
widget = self.create()
self.checkEnumParam(widget, 'justify', 'left', 'right', 'center',
errmsg='bad justification "{}": must be '
'left, right, or center')
self.checkInvalidParam(widget, 'justify', '',
errmsg='ambiguous justification "": must be '
'left, right, or center')
def test_orient(self):
widget = self.create()
self.assertEqual(str(widget['orient']), self.default_orient)
self.checkEnumParam(widget, 'orient', 'horizontal', 'vertical')
def test_padx(self):
widget = self.create()
self.checkPixelsParam(widget, 'padx', 3, 4.4, 5.6, -2, '12m',
conv=self._conv_pad_pixels)
def test_pady(self):
widget = self.create()
self.checkPixelsParam(widget, 'pady', 3, 4.4, 5.6, -2, '12m',
conv=self._conv_pad_pixels)
def test_relief(self):
widget = self.create()
self.checkReliefParam(widget, 'relief')
def test_repeatdelay(self):
widget = self.create()
self.checkIntegerParam(widget, 'repeatdelay', -500, 500)
def test_repeatinterval(self):
widget = self.create()
self.checkIntegerParam(widget, 'repeatinterval', -500, 500)
def test_selectbackground(self):
widget = self.create()
self.checkColorParam(widget, 'selectbackground')
def test_selectborderwidth(self):
widget = self.create()
self.checkPixelsParam(widget, 'selectborderwidth', 1.3, 2.6, -2, '10p')
def test_selectforeground(self):
widget = self.create()
self.checkColorParam(widget, 'selectforeground')
def test_setgrid(self):
widget = self.create()
self.checkBooleanParam(widget, 'setgrid')
def test_state(self):
widget = self.create()
self.checkEnumParam(widget, 'state', 'active', 'disabled', 'normal')
def test_takefocus(self):
widget = self.create()
self.checkParams(widget, 'takefocus', '0', '1', '')
def test_text(self):
widget = self.create()
self.checkParams(widget, 'text', '', 'any string')
def test_textvariable(self):
widget = self.create()
var = tkinter.StringVar(self.root)
self.checkVariableParam(widget, 'textvariable', var)
def test_troughcolor(self):
widget = self.create()
self.checkColorParam(widget, 'troughcolor')
def test_underline(self):
widget = self.create()
self.checkIntegerParam(widget, 'underline', 0, 1, 10)
def test_wraplength(self):
widget = self.create()
self.checkPixelsParam(widget, 'wraplength', 100)
def test_xscrollcommand(self):
widget = self.create()
self.checkCommandParam(widget, 'xscrollcommand')
def test_yscrollcommand(self):
widget = self.create()
self.checkCommandParam(widget, 'yscrollcommand')
# non-standard but common options
def test_command(self):
widget = self.create()
self.checkCommandParam(widget, 'command')
def test_indicatoron(self):
widget = self.create()
self.checkBooleanParam(widget, 'indicatoron')
def test_offrelief(self):
widget = self.create()
self.checkReliefParam(widget, 'offrelief')
def test_overrelief(self):
widget = self.create()
self.checkReliefParam(widget, 'overrelief')
def test_selectcolor(self):
widget = self.create()
self.checkColorParam(widget, 'selectcolor')
def test_selectimage(self):
widget = self.create()
self.checkImageParam(widget, 'selectimage')
@requires_tcl(8, 5)
def test_tristateimage(self):
widget = self.create()
self.checkImageParam(widget, 'tristateimage')
@requires_tcl(8, 5)
def test_tristatevalue(self):
widget = self.create()
self.checkParam(widget, 'tristatevalue', 'unknowable')
def test_variable(self):
widget = self.create()
var = tkinter.DoubleVar(self.root)
self.checkVariableParam(widget, 'variable', var)
class IntegerSizeTests(object):
def test_height(self):
widget = self.create()
self.checkIntegerParam(widget, 'height', 100, -100, 0)
def test_width(self):
widget = self.create()
self.checkIntegerParam(widget, 'width', 402, -402, 0)
class PixelSizeTests(object):
def test_height(self):
widget = self.create()
self.checkPixelsParam(widget, 'height', 100, 101.2, 102.6, -100, 0, '3c')
def test_width(self):
widget = self.create()
self.checkPixelsParam(widget, 'width', 402, 403.4, 404.6, -402, 0, '5i')
def add_standard_options(*source_classes):
# This decorator adds test_xxx methods from source classes for every xxx
# option in the OPTIONS class attribute if they are not defined explicitly.
def decorator(cls):
for option in cls.OPTIONS:
methodname = 'test_' + option
if not hasattr(cls, methodname):
for source_class in source_classes:
if hasattr(source_class, methodname):
setattr(cls, methodname,
getattr(source_class, methodname).im_func)
break
else:
def test(self, option=option):
widget = self.create()
widget[option]
raise AssertionError('Option "%s" is not tested in %s' %
(option, cls.__name__))
test.__name__ = methodname
setattr(cls, methodname, test)
return cls
return decorator
def setUpModule():
if test.test_support.verbose:
tcl = tkinter.Tcl()
print 'patchlevel =', tcl.call('info', 'patchlevel')
test/README 0000644 00000001066 15032720555 0006412 0 ustar 00 Writing new tests
=================
Precaution
----------
New tests should always use only one Tk window at once, like all the
current tests do. This means that you have to destroy the current window
before creating another one, and clean up after the test. The motivation
behind this is that some tests may depend on having its window focused
while it is running to work properly, and it may be hard to force focus
on your window across platforms (right now only test_traversal at
test_ttk.test_widgets.NotebookTest depends on this).
test/widget_tests.pyc 0000644 00000063575 15032720555 0010771 0 ustar 00 �
z fc @ sV d d l Z d d l Z d d l Z d d l m Z d d l m Z m Z m Z m
Z
m Z m Z d d l
Z e Z Z e
� d d d f k r� e Z n e o� e e � Z d � Z e Z e
� d d d d f k r� e Z n e � Z d e f d
� � YZ d e f d � � YZ d
e f d � � YZ d e f d � � YZ d � Z d � Z d S( i����N( t Scale( t AbstractTkTestt tcl_versiont requires_tclt get_tk_patchlevelt pixels_convt
tcl_obj_eqi i i c C s t t | � � S( N( t intt round( t x( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt int_round s i t AbstractWidgetTestc B s� e Z e e � Z d Z e Z e d � � Z
d � Z d e j
d � Z e e d d � Z d e d � Z d � Z d � Z d � Z d � Z d d � Z d
� Z d � Z d � Z d
� Z d � Z d � Z d � Z d � Z d � Z RS( c C sE y | j SWn3 t k
r@ t | j j d d � � | _ | j SXd S( Nt tkt scaling( t _scalingt AttributeErrort floatt roott call( t self( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyR
" s
c C sU | j r# | j r# t d k r# | St | t � rK d j t | j | � � St | � S( Ni i t ( i i ( t
_stringifyt wantobjectsR t
isinstancet tuplet joint mapt _strt str( R t value( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyR * s
c C s* | | | � r d S| j | | | � d S( N( t assertEqual( R t actualt expectedt msgt eq( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt assertEqual21 s c C s | | | <| t k r | } n | r4 | | � } n | j sG | j rw t | t � rh t j | � } qw t | � } n | d k r� t } n | j
| | | d | �| j
| j | � | d | �t | t � s| j
| � } | j t | � d � | j
| d | d | �n d S( NR" i i ( t _sentinelR R R R t tkintert _joinR t NoneR R# t cgetR t configureR t len( R t widgett nameR R t convR" t t( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt
checkParam6 s"
c C s | | } | d k r( | j | � } n | j t j � � } | | | <Wd QX| d k ru | j t | j � | � n | r� | j | | | � n
| | | <| j t j � � } | j i | | 6� Wd QX| d k r� | j t | j � | � n | r| j | | | � n
| | | <d S( N( R' t formatt assertRaisesR% t TclErrorR R t exceptionR) ( R R+ R, R t errmsgt keep_origt origt cm( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt checkInvalidParamL s"
c O s+ x$ | D] } | j | | | | � q Wd S( N( R/ ( R R+ R, t valuest kwargsR ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt checkParamsb s
c O se | j | | | | � | j | | d d d �| j | | d d d �| j | | d d d �d S( Nt R4 s expected integer but got ""t 10ps expected integer but got "10p"g������ @s expected integer but got "3.2"( R; R8 ( R R+ R, R9 R: ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt checkIntegerParamf s c O s� d | k r | j d � } n t } x* | D]" } | j | | | d | | �q+ W| j | | d d d �| j | | d d d �d S( NR- R< R4 s) expected floating-point number but got ""t spams- expected floating-point number but got "spam"( t popR R/ R8 ( R R+ R, R9 R: R- R ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt checkFloatParamo s
c C s� x6 t d d d d f D] } | j | | | d d �q Wx6 t d d d d f D] } | j | | | d d �qO W| j | | d
d d �| j | | d
d d �d S( Ni t falset not offR i t truet yest onR< R4 s! expected boolean value but got ""R? s% expected boolean value but got "spam"( t FalseR/ t TrueR8 ( R R+ R, R ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt checkBooleanParam{ s c K sN | j | | d d d d d d d d d d
| � | j | | d d d
�d S( Ns #ff0000s #00ff00s #0000ffs #123456t redt greent bluet whitet blackt greyR? R4 s unknown color name "spam"( R; R8 ( R R+ R, t allow_emptyR: ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt checkColorParam� s c K s^ | j | | d d d d | � t d k rA | j | | d � n | j | | d d d
�d S( Nt arrowt watcht crossR< i i t noneR? R4 s bad cursor spec "spam"( i i ( R; R R/ R8 ( R R+ R, R: ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt checkCursorParam� s
c C s; d � } | | | <| j | | � | j | | d � d S( Nc W s d S( N( ( t args( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt command� s R< ( t
assertTrueR; ( R R+ R, RY ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt checkCommandParam� s
c O s� d | k r | j d � } n d } | j | | | | � | d k r� d | d j | d � t | � d k rt d n d | d f } | j | | d d d | �d | } n | j | | d
d | �d S( NR4 s %s "{}": must be %s%s or %ss , i����i t ,R< t ambiguoust badR? ( R@ R' R; R R* R8 ( R R+ R, R9 R: R4 t errmsg2( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt checkEnumParam� s
c
O s! d | k r | j d � } n d } | d k r< | j } n d | k rZ | j d � } n t } x| | D]t } t } | } t | t � r� | r� | t k r� t | � | j } t } q� n | j
| | | d | d | | �qg W| j | | d d d d | �| j | | d d d d | �d S( NR- R5 R t 6xR4 s bad screen distance "6x"R? s bad screen distance "spam"( R@ R' t _conv_pixelsRI R$ R R R R
R
R/ R8 (
R R+ R, R9 R: R- R5 R R t conv1( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt checkPixelsParam� s*
c C sZ | j | | d d d d d d � d } t d k r= d } n | j | | d
d | �d S(
Nt flatt groovet raisedt ridget solidt sunkensH bad relief "spam": must be flat, groove, raised, ridge, solid, or sunkeni i R? R4 ( i i ( R; R R' R8 ( R R+ R, R4 ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt checkReliefParam� s c C s[ t j d | j d d � } | j | | | d t �| j | | d d d �d | | <d S( Nt masterR, t image1R- R? R4 s image "spam" doesn't existR< ( R% t
PhotoImageR R/ R R8 ( R R+ R, t image( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt checkImageParam� s
c C s | j | | | d t �d S( NR- ( R/ R ( R R+ R, t var( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt checkVariableParam� s c C s� | j | � | j | t � t | � d k rF | j d | f � n x5 | D]- } t | t � sM | j d | f � PqM qM Wd S( Ni s Invalid bounding box: %r( t assertIsNotNonet assertIsInstanceR R* t failR R ( R t bboxt item( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt assertIsBoundingBox� s
c C s | j � } | j � } t | t � sL | j t | � t | j � � � n x | D] } | | qS Wt j j ri d d 6d d 6d d 6d d 6d d
6} t
| � } t
| j � } x_ t | | � D]J } | | k o� | | | k o� | | | k s� d | j j
| f GHq� q� Wn d S( Nt borderwidtht bdt
backgroundt bgt
foregroundt fgt invalidcommandt invcmdt validatecommandt vcmds %s.OPTIONS doesn't contain "%s"( t createt keysR R R t sortedR) t testt test_supportt verboset sett OPTIONSt __class__t __name__( R R+ R� t kt aliasesR ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_keys� s* %
N(! R� t
__module__t staticmethodt pixels_roundRb R' t _conv_pad_pixelsRH R t propertyR
R t objectt __eq__R# R$ R/ RI R8 R; R> RA RJ RR RW R[ R` Rd Rk Rp Rr Rx R� ( ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyR s0
t StandardOptionsTestsc * B s e Z db Z d* � Z d+ � Z d, � Z d- � Z d. � Z d/ � Z d0 � Z d1 � Z
d2 � Z d3 � Z d4 � Z
d5 � Z d6 � Z d7 � Z d8 � Z d9 � Z e j e j d: k d; � d< � � Z d= � Z d> � Z d? � Z d@ � Z dA � Z dB � Z dC � Z dD � Z dE � Z dF � Z! dG � Z" dH � Z# dI � Z$ dJ � Z% dK � Z& dL � Z' dM � Z( dN � Z) dO � Z* dP � Z+ dQ � Z, dR � Z- dS � Z. dT � Z/ dU � Z0 dV � Z1 dW � Z2 dX � Z3 dY � Z4 dZ � Z5 d[ � Z6 d\ � Z7 e8 d] d^ � d_ � � Z9 e8 d] d^ � d` � � Z: da � Z; RS(c t activebackgroundt activeborderwidtht activeforegroundt anchorR{ t bitmapRy t compoundt cursort disabledforegroundt exportselectiont fontR} t highlightbackgroundt highlightcolort highlightthicknessRo t insertbackgroundt insertborderwidtht
insertofftimet insertontimet insertwidtht jumpt justifyt orientt padxt padyt relieft repeatdelayt repeatintervalt selectbackgroundt selectborderwidtht selectforegroundt setgridt takefocust textt textvariablet troughcolort underlinet
wraplengtht xscrollcommandt yscrollcommandc C s | j � } | j | d � d S( NR� ( R� RR ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_activebackground
s c C s2 | j � } | j | d d d d d d d � d S( NR� i g�������?g333333@i i����R= ( R� Rd ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_activeborderwidth s c C s | j � } | j | d � d S( NR� ( R� RR ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_activeforeground s c C s; | j � } | j | d d d d d d d d d d
� d S( NR� t nt net et set st swt wt nwt center( R� R` ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_anchor s c C sB | j � } | j | d � d | j k r> | j | d � n d S( NR{ R| ( R� RR R� ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_background s c C s� | j � } | j | d d � | j | d d � t j j d d d �} | j | d d | � d | j j j d d
� k o� d | j j � k s� | j | d d d
d �n d S( NR� t questheadt gray50s
python.xbmt subdirt
imghdrdatat @t aquaR t windowingsystemt AppKitR? R4 s bitmap "spam" not defined(
R� R/ R� R� t findfileR R R t winfo_serverR8 ( R R+ t filename( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_bitmap% s c C sf | j � } | j | d d d d d d d � d | j k rb | j | d d d d d d d � n d S( NRy i g�������?g������@i i����R= Rz ( R� Rd R� ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_borderwidth2 s
c C s2 | j � } | j | d d d d d d d � d S( NR� t bottomR� t leftRV t rightt top( R� R` ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt
test_compound9 s c C s | j � } | j | d � d S( NR� ( R� RW ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_cursor> s c C s | j � } | j | d � d S( NR� ( R� RR ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_disabledforegroundB s c C s | j � } | j | d � d S( NR� ( R� RJ ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_exportselectionF s c C s< | j � } | j | d d � | j | d d d d �d S( NR� s3 -Adobe-Helvetica-Medium-R-Normal--*-120-*-*-*-*-*-*R< R4 s font "" doesn't exist( R� R/ R8 ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_fontJ s
c C sB | j � } | j | d � d | j k r> | j | d � n d S( NR} R~ ( R� RR R� ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_foregroundQ s c C s | j � } | j | d � d S( NR� ( R� RR ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_highlightbackgroundW s c C s | j � } | j | d � d S( NR� ( R� RR ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_highlightcolor[ s c C sQ | j � } | j | d d d d d d � | j | d d d d d | j �d S(
NR� i g�������?g������@i R= i����R R- ( R� Rd R/ Rb ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_highlightthickness_ s
t darwins" crashes with Cocoa Tk (issue19733)c C s | j � } | j | d � d S( NRo ( R� Rp ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt
test_imagef s c C s | j � } | j | d � d S( NR� ( R� RR ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_insertbackgroundl s c C s2 | j � } | j | d d d d d d d � d S( NR� i g�������?g������@i i����R= ( R� Rd ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_insertborderwidthp s c C s# | j � } | j | d d � d S( NR� id ( R� R> ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_insertofftimeu s c C s# | j � } | j | d d � d S( NR� id ( R� R> ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_insertontimey s c C s, | j � } | j | d d d d d � d S( NR� g�������?g������@i����R= ( R� Rd ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_insertwidth} s c C s | j � } | j | d � d S( NR� ( R� RJ ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_jump� s c C sH | j � } | j | d d d d d d �| j | d d d d �d S( NR� R� R� R� R4 s6 bad justification "{}": must be left, right, or centerR< s: ambiguous justification "": must be left, right, or center( R� R` R8 ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_justify� s
c C sC | j � } | j t | d � | j � | j | d d d � d S( NR� t
horizontalt vertical( R� R R t default_orientR` ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_orient� s c
C s8 | j � } | j | d d d d d d d | j �d S( NR� i g������@gffffff@i����t 12mR- ( R� Rd R� ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_padx� s c
C s8 | j � } | j | d d d d d d d | j �d S( NR� i g������@gffffff@i����R� R- ( R� Rd R� ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_pady� s c C s | j � } | j | d � d S( NR� ( R� Rk ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_relief� s c C s& | j � } | j | d d d � d S( NR� i ���i� ( R� R> ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_repeatdelay� s c C s& | j � } | j | d d d � d S( NR� i ���i� ( R� R> ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_repeatinterval� s c C s | j � } | j | d � d S( NR� ( R� RR ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_selectbackground� s c C s, | j � } | j | d d d d d � d S( NR� g�������?g������@i����R= ( R� Rd ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_selectborderwidth� s c C s | j � } | j | d � d S( NR� ( R� RR ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_selectforeground� s c C s | j � } | j | d � d S( NR� ( R� RJ ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_setgrid� s c C s) | j � } | j | d d d d � d S( Nt statet activet disabledt normal( R� R` ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt
test_state� s c C s) | j � } | j | d d d d � d S( NR� t 0t 1R< ( R� R; ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_takefocus� s c C s& | j � } | j | d d d � d S( NR� R< s
any string( R� R; ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_text� s c C s5 | j � } t j | j � } | j | d | � d S( NR� ( R� R% t StringVarR Rr ( R R+ Rq ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_textvariable� s c C s | j � } | j | d � d S( NR� ( R� RR ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_troughcolor� s c C s) | j � } | j | d d d d � d S( NR� i i i
( R� R> ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_underline� s c C s# | j � } | j | d d � d S( NR� id ( R� Rd ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_wraplength� s c C s | j � } | j | d � d S( NR� ( R� R[ ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_xscrollcommand� s c C s | j � } | j | d � d S( NR� ( R� R[ ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_yscrollcommand� s c C s | j � } | j | d � d S( NRY ( R� R[ ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_command� s c C s | j � } | j | d � d S( Nt indicatoron( R� RJ ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_indicatoron� s c C s | j � } | j | d � d S( Nt offrelief( R� Rk ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_offrelief� s c C s | j � } | j | d � d S( Nt
overrelief( R� Rk ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_overrelief� s c C s | j � } | j | d � d S( Nt selectcolor( R� RR ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_selectcolor� s c C s | j � } | j | d � d S( Nt selectimage( R� Rp ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_selectimage� s i i c C s | j � } | j | d � d S( Nt
tristateimage( R� Rp ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_tristateimage� s c C s# | j � } | j | d d � d S( Nt
tristatevaluet
unknowable( R� R/ ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_tristatevalue� s c C s5 | j � } t j | j � } | j | d | � d S( Nt variable( R� R% t DoubleVarR Rr ( R R+ Rq ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt
test_variable s (* R� R� R� R� R{ R� Ry R� R� R� R� R� R} R� R� R� Ro R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� (< R� R� t STANDARD_OPTIONSR� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� t unittestt skipIft syst platformR� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R R R R R R R
R R R
R R R R R R R R R ( ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyR� � s�
t IntegerSizeTestsc B s e Z d � Z d � Z RS( c C s) | j � } | j | d d d d � d S( Nt heightid i����i ( R� R> ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt test_height s c C s) | j � } | j | d d d d � d S( Nt widthi� in���i ( R� R> ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt
test_width
s ( R� R� R' R) ( ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyR% s t PixelSizeTestsc B s e Z d � Z d � Z RS( c C s2 | j � } | j | d d d d d d d � d S( NR& id g�����LY@gfffff�Y@i����i t 3c( R� Rd ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyR' s c C s2 | j � } | j | d d d d d d d � d S( NR( i� gfffff6y@g�����Iy@in���i t 5i( R� Rd ( R R+ ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyR) s ( R� R� R' R) ( ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyR* s c s � f d � } | S( Nc s� x� � j D]� } d | } t � | � s
xk � D]5 } t | | � r0 t � | t | | � j � Pq0 q0 W| � f d � } | | _ t � | | � q
q
W� S( Nt test_c s1 | j � } | | t d | � j f � � d S( Ns Option "%s" is not tested in %s( R� t AssertionErrorR� ( R t optionR+ ( t cls( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyR� ) s ( R� t hasattrt setattrt getattrt im_funcR� ( R0 R/ t
methodnamet source_classR� ( t source_classes( R0 s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt decorator s
( ( R7 R8 ( ( R7 s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt add_standard_options s c C s4 t j j r0 t j � } d G| j d d � GHn d S( Ns patchlevel =t infot
patchlevel( R� R� R� R% t TclR ( t tcl( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt setUpModule3 s ( R! R# t TkinterR% t ttkR t test_ttk.supportR R R R R R t test.test_supportR� RH t noconvt noconv_methR R� R
R� R R� R$ R R� R% R* R9 R> ( ( ( s0 /usr/lib64/python2.7/lib-tk/test/widget_tests.pyt <module> s* .
��
test/runtktests.pyc 0000644 00000005453 15032720555 0010501 0 ustar 00 �
z fc @ s� d Z d d l Z d d l Z d d l Z d d l Z d d l Z e j j e j j e
� � Z d � Z e e
d d � Z e
e
d d � Z e d k r� e j j e � � n d S( s�
Use this module to get and run all tk tests.
Tkinter tests should live in a package inside the directory where this file
lives, like test_tkinter.
Extensions also should live in packages following the same rule as above.
i����Nc C s. x' t j | � D] } | d k r t Sq Wt S( Ns __init__.pys __init__.pycs
__init.pyo( s __init__.pys __init__.pycs
__init.pyo( t ost listdirt Truet False( t patht name( ( s. /usr/lib64/python2.7/lib-tk/test/runtktests.pyt
is_package s c # s- d � x t j | � D]\ } } } x4 t | � D]& } | d d k r2 | j | � q2 q2 Wt | � r | r | t | � t t j � j d d � } | r� | | k r� q n t � f d � | � } x[ | D]P } y$ t j
d | t � � | � VWq� t j j
k
r | r � q q� Xq� Wq q Wd S( s� This will import and yield modules whose names start with test_
and are inside packages found in the path starting at basepath.
If packages is specified it should contain package names that want
their tests collected.
s .pyi t .t /c s | j d � o | j � � S( Nt test_( t
startswitht endswith( t x( t py_ext( s. /usr/lib64/python2.7/lib-tk/test/runtktests.pyt <lambda>+ t s .%sN( R t walkt listt removeR t lent sept replacet filtert importlibt
import_modulet testt test_supportt ResourceDenied( t basepatht guit packagest dirpatht dirnamest filenamest dirnamet pkg_nameR ( ( R
s. /usr/lib64/python2.7/lib-tk/test/runtktests.pyt get_tests_modules s& )
c c s� g } | r | j d � n | r2 | j d � n xP t d | d | � D]9 } x0 | D]( } x t | | d � D] } | Vqn WqU WqH Wd S( s� Yield all the tests in the modules found by get_tests_modules.
If nogui is True, only tests that do not require a GUI will be
returned.t tests_noguit tests_guiR R N( ( t appendR$ t getattr( t textR R t attrst modulet attrR ( ( s. /usr/lib64/python2.7/lib-tk/test/runtktests.pyt get_tests6 s
t __main__( t __doc__R t syst unittestR t test.test_supportR R t abspathR" t __file__t
this_dir_pathR R t NoneR$ R- t __name__R t run_unittest( ( ( s. /usr/lib64/python2.7/lib-tk/test/runtktests.pyt <module> s test/test_ttk/test_widgets.py 0000644 00000166617 15032720555 0012470 0 ustar 00 import unittest
import Tkinter as tkinter
from Tkinter import TclError
import ttk
from test.test_support import requires, run_unittest, have_unicode, u
import sys
from test_functions import MockTclObj
from support import (AbstractTkTest, tcl_version, get_tk_patchlevel,
simulate_mouse_click)
from widget_tests import (add_standard_options, noconv, noconv_meth,
AbstractWidgetTest, StandardOptionsTests,
IntegerSizeTests, PixelSizeTests,
setUpModule)
requires('gui')
class StandardTtkOptionsTests(StandardOptionsTests):
def test_class(self):
widget = self.create()
self.assertEqual(widget['class'], '')
errmsg='attempt to change read-only option'
if get_tk_patchlevel() < (8, 6, 0, 'beta', 3):
errmsg='Attempt to change read-only option'
self.checkInvalidParam(widget, 'class', 'Foo', errmsg=errmsg)
widget2 = self.create(class_='Foo')
self.assertEqual(widget2['class'], 'Foo')
def test_padding(self):
widget = self.create()
self.checkParam(widget, 'padding', 0, expected=('0',))
self.checkParam(widget, 'padding', 5, expected=('5',))
self.checkParam(widget, 'padding', (5, 6), expected=('5', '6'))
self.checkParam(widget, 'padding', (5, 6, 7),
expected=('5', '6', '7'))
self.checkParam(widget, 'padding', (5, 6, 7, 8),
expected=('5', '6', '7', '8'))
self.checkParam(widget, 'padding', ('5p', '6p', '7p', '8p'))
self.checkParam(widget, 'padding', (), expected='')
def test_style(self):
widget = self.create()
self.assertEqual(widget['style'], '')
errmsg = 'Layout Foo not found'
if hasattr(self, 'default_orient'):
errmsg = ('Layout %s.Foo not found' %
getattr(self, 'default_orient').title())
self.checkInvalidParam(widget, 'style', 'Foo',
errmsg=errmsg)
widget2 = self.create(class_='Foo')
self.assertEqual(widget2['class'], 'Foo')
# XXX
pass
class WidgetTest(AbstractTkTest, unittest.TestCase):
"""Tests methods available in every ttk widget."""
def setUp(self):
super(WidgetTest, self).setUp()
self.widget = ttk.Button(self.root, width=0, text="Text")
self.widget.pack()
self.widget.wait_visibility()
def test_identify(self):
self.widget.update_idletasks()
self.assertEqual(self.widget.identify(
self.widget.winfo_width() // 2,
self.widget.winfo_height() // 2
), "label")
self.assertEqual(self.widget.identify(-1, -1), "")
self.assertRaises(tkinter.TclError, self.widget.identify, None, 5)
self.assertRaises(tkinter.TclError, self.widget.identify, 5, None)
self.assertRaises(tkinter.TclError, self.widget.identify, 5, '')
def test_widget_state(self):
# XXX not sure about the portability of all these tests
self.assertEqual(self.widget.state(), ())
self.assertEqual(self.widget.instate(['!disabled']), True)
# changing from !disabled to disabled
self.assertEqual(self.widget.state(['disabled']), ('!disabled', ))
# no state change
self.assertEqual(self.widget.state(['disabled']), ())
# change back to !disable but also active
self.assertEqual(self.widget.state(['!disabled', 'active']),
('!active', 'disabled'))
# no state changes, again
self.assertEqual(self.widget.state(['!disabled', 'active']), ())
self.assertEqual(self.widget.state(['active', '!disabled']), ())
def test_cb(arg1, **kw):
return arg1, kw
self.assertEqual(self.widget.instate(['!disabled'],
test_cb, "hi", **{"msg": "there"}),
('hi', {'msg': 'there'}))
# attempt to set invalid statespec
currstate = self.widget.state()
self.assertRaises(tkinter.TclError, self.widget.instate,
['badstate'])
self.assertRaises(tkinter.TclError, self.widget.instate,
['disabled', 'badstate'])
# verify that widget didn't change its state
self.assertEqual(currstate, self.widget.state())
# ensuring that passing None as state doesn't modify current state
self.widget.state(['active', '!disabled'])
self.assertEqual(self.widget.state(), ('active', ))
class AbstractToplevelTest(AbstractWidgetTest, PixelSizeTests):
_conv_pixels = noconv_meth
@add_standard_options(StandardTtkOptionsTests)
class FrameTest(AbstractToplevelTest, unittest.TestCase):
OPTIONS = (
'borderwidth', 'class', 'cursor', 'height',
'padding', 'relief', 'style', 'takefocus',
'width',
)
def create(self, **kwargs):
return ttk.Frame(self.root, **kwargs)
@add_standard_options(StandardTtkOptionsTests)
class LabelFrameTest(AbstractToplevelTest, unittest.TestCase):
OPTIONS = (
'borderwidth', 'class', 'cursor', 'height',
'labelanchor', 'labelwidget',
'padding', 'relief', 'style', 'takefocus',
'text', 'underline', 'width',
)
def create(self, **kwargs):
return ttk.LabelFrame(self.root, **kwargs)
def test_labelanchor(self):
widget = self.create()
self.checkEnumParam(widget, 'labelanchor',
'e', 'en', 'es', 'n', 'ne', 'nw', 's', 'se', 'sw', 'w', 'wn', 'ws',
errmsg='Bad label anchor specification {}')
self.checkInvalidParam(widget, 'labelanchor', 'center')
def test_labelwidget(self):
widget = self.create()
label = ttk.Label(self.root, text='Mupp', name='foo')
self.checkParam(widget, 'labelwidget', label, expected='.foo')
label.destroy()
class AbstractLabelTest(AbstractWidgetTest):
def checkImageParam(self, widget, name):
image = tkinter.PhotoImage(master=self.root, name='image1')
image2 = tkinter.PhotoImage(master=self.root, name='image2')
self.checkParam(widget, name, image, expected=('image1',))
self.checkParam(widget, name, 'image1', expected=('image1',))
self.checkParam(widget, name, (image,), expected=('image1',))
self.checkParam(widget, name, (image, 'active', image2),
expected=('image1', 'active', 'image2'))
self.checkParam(widget, name, 'image1 active image2',
expected=('image1', 'active', 'image2'))
self.checkInvalidParam(widget, name, 'spam',
errmsg='image "spam" doesn\'t exist')
def test_compound(self):
widget = self.create()
self.checkEnumParam(widget, 'compound',
'none', 'text', 'image', 'center',
'top', 'bottom', 'left', 'right')
def test_state(self):
widget = self.create()
self.checkParams(widget, 'state', 'active', 'disabled', 'normal')
def test_width(self):
widget = self.create()
self.checkParams(widget, 'width', 402, -402, 0)
@add_standard_options(StandardTtkOptionsTests)
class LabelTest(AbstractLabelTest, unittest.TestCase):
OPTIONS = (
'anchor', 'background', 'borderwidth',
'class', 'compound', 'cursor', 'font', 'foreground',
'image', 'justify', 'padding', 'relief', 'state', 'style',
'takefocus', 'text', 'textvariable',
'underline', 'width', 'wraplength',
)
_conv_pixels = noconv_meth
def create(self, **kwargs):
return ttk.Label(self.root, **kwargs)
def test_font(self):
widget = self.create()
self.checkParam(widget, 'font',
'-Adobe-Helvetica-Medium-R-Normal--*-120-*-*-*-*-*-*')
@add_standard_options(StandardTtkOptionsTests)
class ButtonTest(AbstractLabelTest, unittest.TestCase):
OPTIONS = (
'class', 'command', 'compound', 'cursor', 'default',
'image', 'padding', 'state', 'style',
'takefocus', 'text', 'textvariable',
'underline', 'width',
)
def create(self, **kwargs):
return ttk.Button(self.root, **kwargs)
def test_default(self):
widget = self.create()
self.checkEnumParam(widget, 'default', 'normal', 'active', 'disabled')
def test_invoke(self):
success = []
btn = ttk.Button(self.root, command=lambda: success.append(1))
btn.invoke()
self.assertTrue(success)
@add_standard_options(StandardTtkOptionsTests)
class CheckbuttonTest(AbstractLabelTest, unittest.TestCase):
OPTIONS = (
'class', 'command', 'compound', 'cursor',
'image',
'offvalue', 'onvalue',
'padding', 'state', 'style',
'takefocus', 'text', 'textvariable',
'underline', 'variable', 'width',
)
def create(self, **kwargs):
return ttk.Checkbutton(self.root, **kwargs)
def test_offvalue(self):
widget = self.create()
self.checkParams(widget, 'offvalue', 1, 2.3, '', 'any string')
def test_onvalue(self):
widget = self.create()
self.checkParams(widget, 'onvalue', 1, 2.3, '', 'any string')
def test_invoke(self):
success = []
def cb_test():
success.append(1)
return "cb test called"
cbtn = ttk.Checkbutton(self.root, command=cb_test)
# the variable automatically created by ttk.Checkbutton is actually
# undefined till we invoke the Checkbutton
self.assertEqual(cbtn.state(), ('alternate', ))
self.assertRaises(tkinter.TclError, cbtn.tk.globalgetvar,
cbtn['variable'])
res = cbtn.invoke()
self.assertEqual(res, "cb test called")
self.assertEqual(cbtn['onvalue'],
cbtn.tk.globalgetvar(cbtn['variable']))
self.assertTrue(success)
cbtn['command'] = ''
res = cbtn.invoke()
self.assertFalse(str(res))
self.assertLessEqual(len(success), 1)
self.assertEqual(cbtn['offvalue'],
cbtn.tk.globalgetvar(cbtn['variable']))
@add_standard_options(IntegerSizeTests, StandardTtkOptionsTests)
class EntryTest(AbstractWidgetTest, unittest.TestCase):
OPTIONS = (
'background', 'class', 'cursor',
'exportselection', 'font', 'foreground',
'invalidcommand', 'justify',
'show', 'state', 'style', 'takefocus', 'textvariable',
'validate', 'validatecommand', 'width', 'xscrollcommand',
)
def setUp(self):
super(EntryTest, self).setUp()
self.entry = self.create()
def create(self, **kwargs):
return ttk.Entry(self.root, **kwargs)
def test_invalidcommand(self):
widget = self.create()
self.checkCommandParam(widget, 'invalidcommand')
def test_show(self):
widget = self.create()
self.checkParam(widget, 'show', '*')
self.checkParam(widget, 'show', '')
self.checkParam(widget, 'show', ' ')
def test_state(self):
widget = self.create()
self.checkParams(widget, 'state',
'disabled', 'normal', 'readonly')
def test_validate(self):
widget = self.create()
self.checkEnumParam(widget, 'validate',
'all', 'key', 'focus', 'focusin', 'focusout', 'none')
def test_validatecommand(self):
widget = self.create()
self.checkCommandParam(widget, 'validatecommand')
def test_bbox(self):
self.assertIsBoundingBox(self.entry.bbox(0))
self.assertRaises(tkinter.TclError, self.entry.bbox, 'noindex')
self.assertRaises(tkinter.TclError, self.entry.bbox, None)
def test_identify(self):
self.entry.pack()
self.entry.wait_visibility()
self.entry.update_idletasks()
# bpo-27313: macOS Cocoa widget differs from X, allow either
if sys.platform == 'darwin':
self.assertIn(self.entry.identify(5, 5),
("textarea", "Combobox.button") )
else:
self.assertEqual(self.entry.identify(5, 5), "textarea")
self.assertEqual(self.entry.identify(-1, -1), "")
self.assertRaises(tkinter.TclError, self.entry.identify, None, 5)
self.assertRaises(tkinter.TclError, self.entry.identify, 5, None)
self.assertRaises(tkinter.TclError, self.entry.identify, 5, '')
def test_validation_options(self):
success = []
test_invalid = lambda: success.append(True)
self.entry['validate'] = 'none'
self.entry['validatecommand'] = lambda: False
self.entry['invalidcommand'] = test_invalid
self.entry.validate()
self.assertTrue(success)
self.entry['invalidcommand'] = ''
self.entry.validate()
self.assertEqual(len(success), 1)
self.entry['invalidcommand'] = test_invalid
self.entry['validatecommand'] = lambda: True
self.entry.validate()
self.assertEqual(len(success), 1)
self.entry['validatecommand'] = ''
self.entry.validate()
self.assertEqual(len(success), 1)
self.entry['validatecommand'] = True
self.assertRaises(tkinter.TclError, self.entry.validate)
def test_validation(self):
validation = []
def validate(to_insert):
if not 'a' <= to_insert.lower() <= 'z':
validation.append(False)
return False
validation.append(True)
return True
self.entry['validate'] = 'key'
self.entry['validatecommand'] = self.entry.register(validate), '%S'
self.entry.insert('end', 1)
self.entry.insert('end', 'a')
self.assertEqual(validation, [False, True])
self.assertEqual(self.entry.get(), 'a')
def test_revalidation(self):
def validate(content):
for letter in content:
if not 'a' <= letter.lower() <= 'z':
return False
return True
self.entry['validatecommand'] = self.entry.register(validate), '%P'
self.entry.insert('end', 'avocado')
self.assertEqual(self.entry.validate(), True)
self.assertEqual(self.entry.state(), ())
self.entry.delete(0, 'end')
self.assertEqual(self.entry.get(), '')
self.entry.insert('end', 'a1b')
self.assertEqual(self.entry.validate(), False)
self.assertEqual(self.entry.state(), ('invalid', ))
self.entry.delete(1)
self.assertEqual(self.entry.validate(), True)
self.assertEqual(self.entry.state(), ())
@add_standard_options(IntegerSizeTests, StandardTtkOptionsTests)
class ComboboxTest(EntryTest, unittest.TestCase):
OPTIONS = (
'background', 'class', 'cursor', 'exportselection',
'font', 'foreground', 'height', 'invalidcommand',
'justify', 'postcommand', 'show', 'state', 'style',
'takefocus', 'textvariable',
'validate', 'validatecommand', 'values',
'width', 'xscrollcommand',
)
def setUp(self):
super(ComboboxTest, self).setUp()
self.combo = self.create()
def create(self, **kwargs):
return ttk.Combobox(self.root, **kwargs)
def test_height(self):
widget = self.create()
self.checkParams(widget, 'height', 100, 101.2, 102.6, -100, 0, '1i')
def _show_drop_down_listbox(self):
width = self.combo.winfo_width()
self.combo.event_generate('<ButtonPress-1>', x=width - 5, y=5)
self.combo.event_generate('<ButtonRelease-1>', x=width - 5, y=5)
self.combo.update_idletasks()
def test_virtual_event(self):
success = []
self.combo['values'] = [1]
self.combo.bind('<<ComboboxSelected>>',
lambda evt: success.append(True))
self.combo.pack()
self.combo.wait_visibility()
height = self.combo.winfo_height()
self._show_drop_down_listbox()
self.combo.update()
self.combo.event_generate('<Return>')
self.combo.update()
self.assertTrue(success)
def test_postcommand(self):
success = []
self.combo['postcommand'] = lambda: success.append(True)
self.combo.pack()
self.combo.wait_visibility()
self._show_drop_down_listbox()
self.assertTrue(success)
# testing postcommand removal
self.combo['postcommand'] = ''
self._show_drop_down_listbox()
self.assertEqual(len(success), 1)
def test_values(self):
def check_get_current(getval, currval):
self.assertEqual(self.combo.get(), getval)
self.assertEqual(self.combo.current(), currval)
self.assertEqual(self.combo['values'],
() if tcl_version < (8, 5) else '')
check_get_current('', -1)
self.checkParam(self.combo, 'values', 'mon tue wed thur',
expected=('mon', 'tue', 'wed', 'thur'))
self.checkParam(self.combo, 'values', ('mon', 'tue', 'wed', 'thur'))
self.checkParam(self.combo, 'values', (42, 3.14, '', 'any string'))
self.checkParam(self.combo, 'values', () if tcl_version < (8, 5) else '')
self.combo['values'] = ['a', 1, 'c']
self.combo.set('c')
check_get_current('c', 2)
self.combo.current(0)
check_get_current('a', 0)
self.combo.set('d')
check_get_current('d', -1)
# testing values with empty string
self.combo.set('')
self.combo['values'] = (1, 2, '', 3)
check_get_current('', 2)
# testing values with empty string set through configure
self.combo.configure(values=[1, '', 2])
self.assertEqual(self.combo['values'],
('1', '', '2') if self.wantobjects else
'1 {} 2')
# testing values with spaces
self.combo['values'] = ['a b', 'a\tb', 'a\nb']
self.assertEqual(self.combo['values'],
('a b', 'a\tb', 'a\nb') if self.wantobjects else
'{a b} {a\tb} {a\nb}')
# testing values with special characters
self.combo['values'] = [r'a\tb', '"a"', '} {']
self.assertEqual(self.combo['values'],
(r'a\tb', '"a"', '} {') if self.wantobjects else
r'a\\tb {"a"} \}\ \{')
# out of range
self.assertRaises(tkinter.TclError, self.combo.current,
len(self.combo['values']))
# it expects an integer (or something that can be converted to int)
self.assertRaises(tkinter.TclError, self.combo.current, '')
# testing creating combobox with empty string in values
combo2 = ttk.Combobox(self.root, values=[1, 2, ''])
self.assertEqual(combo2['values'],
('1', '2', '') if self.wantobjects else '1 2 {}')
combo2.destroy()
@add_standard_options(IntegerSizeTests, StandardTtkOptionsTests)
class PanedWindowTest(AbstractWidgetTest, unittest.TestCase):
OPTIONS = (
'class', 'cursor', 'height',
'orient', 'style', 'takefocus', 'width',
)
def setUp(self):
super(PanedWindowTest, self).setUp()
self.paned = self.create()
def create(self, **kwargs):
return ttk.PanedWindow(self.root, **kwargs)
def test_orient(self):
widget = self.create()
self.assertEqual(str(widget['orient']), 'vertical')
errmsg='attempt to change read-only option'
if get_tk_patchlevel() < (8, 6, 0, 'beta', 3):
errmsg='Attempt to change read-only option'
self.checkInvalidParam(widget, 'orient', 'horizontal',
errmsg=errmsg)
widget2 = self.create(orient='horizontal')
self.assertEqual(str(widget2['orient']), 'horizontal')
def test_add(self):
# attempt to add a child that is not a direct child of the paned window
label = ttk.Label(self.paned)
child = ttk.Label(label)
self.assertRaises(tkinter.TclError, self.paned.add, child)
label.destroy()
child.destroy()
# another attempt
label = ttk.Label(self.root)
child = ttk.Label(label)
self.assertRaises(tkinter.TclError, self.paned.add, child)
child.destroy()
label.destroy()
good_child = ttk.Label(self.root)
self.paned.add(good_child)
# re-adding a child is not accepted
self.assertRaises(tkinter.TclError, self.paned.add, good_child)
other_child = ttk.Label(self.paned)
self.paned.add(other_child)
self.assertEqual(self.paned.pane(0), self.paned.pane(1))
self.assertRaises(tkinter.TclError, self.paned.pane, 2)
good_child.destroy()
other_child.destroy()
self.assertRaises(tkinter.TclError, self.paned.pane, 0)
def test_forget(self):
self.assertRaises(tkinter.TclError, self.paned.forget, None)
self.assertRaises(tkinter.TclError, self.paned.forget, 0)
self.paned.add(ttk.Label(self.root))
self.paned.forget(0)
self.assertRaises(tkinter.TclError, self.paned.forget, 0)
def test_insert(self):
self.assertRaises(tkinter.TclError, self.paned.insert, None, 0)
self.assertRaises(tkinter.TclError, self.paned.insert, 0, None)
self.assertRaises(tkinter.TclError, self.paned.insert, 0, 0)
child = ttk.Label(self.root)
child2 = ttk.Label(self.root)
child3 = ttk.Label(self.root)
self.assertRaises(tkinter.TclError, self.paned.insert, 0, child)
self.paned.insert('end', child2)
self.paned.insert(0, child)
self.assertEqual(self.paned.panes(), (str(child), str(child2)))
self.paned.insert(0, child2)
self.assertEqual(self.paned.panes(), (str(child2), str(child)))
self.paned.insert('end', child3)
self.assertEqual(self.paned.panes(),
(str(child2), str(child), str(child3)))
# reinserting a child should move it to its current position
panes = self.paned.panes()
self.paned.insert('end', child3)
self.assertEqual(panes, self.paned.panes())
# moving child3 to child2 position should result in child2 ending up
# in previous child position and child ending up in previous child3
# position
self.paned.insert(child2, child3)
self.assertEqual(self.paned.panes(),
(str(child3), str(child2), str(child)))
def test_pane(self):
self.assertRaises(tkinter.TclError, self.paned.pane, 0)
child = ttk.Label(self.root)
self.paned.add(child)
self.assertIsInstance(self.paned.pane(0), dict)
self.assertEqual(self.paned.pane(0, weight=None),
0 if self.wantobjects else '0')
# newer form for querying a single option
self.assertEqual(self.paned.pane(0, 'weight'),
0 if self.wantobjects else '0')
self.assertEqual(self.paned.pane(0), self.paned.pane(str(child)))
self.assertRaises(tkinter.TclError, self.paned.pane, 0,
badoption='somevalue')
def test_sashpos(self):
self.assertRaises(tkinter.TclError, self.paned.sashpos, None)
self.assertRaises(tkinter.TclError, self.paned.sashpos, '')
self.assertRaises(tkinter.TclError, self.paned.sashpos, 0)
child = ttk.Label(self.paned, text='a')
self.paned.add(child, weight=1)
self.assertRaises(tkinter.TclError, self.paned.sashpos, 0)
child2 = ttk.Label(self.paned, text='b')
self.paned.add(child2)
self.assertRaises(tkinter.TclError, self.paned.sashpos, 1)
self.paned.pack(expand=True, fill='both')
self.paned.wait_visibility()
curr_pos = self.paned.sashpos(0)
self.paned.sashpos(0, 1000)
self.assertNotEqual(curr_pos, self.paned.sashpos(0))
self.assertIsInstance(self.paned.sashpos(0), int)
@add_standard_options(StandardTtkOptionsTests)
class RadiobuttonTest(AbstractLabelTest, unittest.TestCase):
OPTIONS = (
'class', 'command', 'compound', 'cursor',
'image',
'padding', 'state', 'style',
'takefocus', 'text', 'textvariable',
'underline', 'value', 'variable', 'width',
)
def create(self, **kwargs):
return ttk.Radiobutton(self.root, **kwargs)
def test_value(self):
widget = self.create()
self.checkParams(widget, 'value', 1, 2.3, '', 'any string')
def test_invoke(self):
success = []
def cb_test():
success.append(1)
return "cb test called"
myvar = tkinter.IntVar(self.root)
cbtn = ttk.Radiobutton(self.root, command=cb_test,
variable=myvar, value=0)
cbtn2 = ttk.Radiobutton(self.root, command=cb_test,
variable=myvar, value=1)
if self.wantobjects:
conv = lambda x: x
else:
conv = int
res = cbtn.invoke()
self.assertEqual(res, "cb test called")
self.assertEqual(conv(cbtn['value']), myvar.get())
self.assertEqual(myvar.get(),
conv(cbtn.tk.globalgetvar(cbtn['variable'])))
self.assertTrue(success)
cbtn2['command'] = ''
res = cbtn2.invoke()
self.assertEqual(str(res), '')
self.assertLessEqual(len(success), 1)
self.assertEqual(conv(cbtn2['value']), myvar.get())
self.assertEqual(myvar.get(),
conv(cbtn.tk.globalgetvar(cbtn['variable'])))
self.assertEqual(str(cbtn['variable']), str(cbtn2['variable']))
class MenubuttonTest(AbstractLabelTest, unittest.TestCase):
OPTIONS = (
'class', 'compound', 'cursor', 'direction',
'image', 'menu', 'padding', 'state', 'style',
'takefocus', 'text', 'textvariable',
'underline', 'width',
)
def create(self, **kwargs):
return ttk.Menubutton(self.root, **kwargs)
def test_direction(self):
widget = self.create()
self.checkEnumParam(widget, 'direction',
'above', 'below', 'left', 'right', 'flush')
def test_menu(self):
widget = self.create()
menu = tkinter.Menu(widget, name='menu')
self.checkParam(widget, 'menu', menu, conv=str)
menu.destroy()
@add_standard_options(StandardTtkOptionsTests)
class ScaleTest(AbstractWidgetTest, unittest.TestCase):
OPTIONS = (
'class', 'command', 'cursor', 'from', 'length',
'orient', 'style', 'takefocus', 'to', 'value', 'variable',
)
_conv_pixels = noconv_meth
default_orient = 'horizontal'
def setUp(self):
super(ScaleTest, self).setUp()
self.scale = self.create()
self.scale.pack()
self.scale.update()
def create(self, **kwargs):
return ttk.Scale(self.root, **kwargs)
def test_from(self):
widget = self.create()
self.checkFloatParam(widget, 'from', 100, 14.9, 15.1, conv=False)
def test_length(self):
widget = self.create()
self.checkPixelsParam(widget, 'length', 130, 131.2, 135.6, '5i')
def test_to(self):
widget = self.create()
self.checkFloatParam(widget, 'to', 300, 14.9, 15.1, -10, conv=False)
def test_value(self):
widget = self.create()
self.checkFloatParam(widget, 'value', 300, 14.9, 15.1, -10, conv=False)
def test_custom_event(self):
failure = [1, 1, 1] # will need to be empty
funcid = self.scale.bind('<<RangeChanged>>', lambda evt: failure.pop())
self.scale['from'] = 10
self.scale['from_'] = 10
self.scale['to'] = 3
self.assertFalse(failure)
failure = [1, 1, 1]
self.scale.configure(from_=2, to=5)
self.scale.configure(from_=0, to=-2)
self.scale.configure(to=10)
self.assertFalse(failure)
def test_get(self):
if self.wantobjects:
conv = lambda x: x
else:
conv = float
scale_width = self.scale.winfo_width()
self.assertEqual(self.scale.get(scale_width, 0), self.scale['to'])
self.assertEqual(conv(self.scale.get(0, 0)), conv(self.scale['from']))
self.assertEqual(self.scale.get(), self.scale['value'])
self.scale['value'] = 30
self.assertEqual(self.scale.get(), self.scale['value'])
self.assertRaises(tkinter.TclError, self.scale.get, '', 0)
self.assertRaises(tkinter.TclError, self.scale.get, 0, '')
def test_set(self):
if self.wantobjects:
conv = lambda x: x
else:
conv = float
# set restricts the max/min values according to the current range
max = conv(self.scale['to'])
new_max = max + 10
self.scale.set(new_max)
self.assertEqual(conv(self.scale.get()), max)
min = conv(self.scale['from'])
self.scale.set(min - 1)
self.assertEqual(conv(self.scale.get()), min)
# changing directly the variable doesn't impose this limitation tho
var = tkinter.DoubleVar(self.root)
self.scale['variable'] = var
var.set(max + 5)
self.assertEqual(conv(self.scale.get()), var.get())
self.assertEqual(conv(self.scale.get()), max + 5)
del var
# the same happens with the value option
self.scale['value'] = max + 10
self.assertEqual(conv(self.scale.get()), max + 10)
self.assertEqual(conv(self.scale.get()), conv(self.scale['value']))
# nevertheless, note that the max/min values we can get specifying
# x, y coords are the ones according to the current range
self.assertEqual(conv(self.scale.get(0, 0)), min)
self.assertEqual(conv(self.scale.get(self.scale.winfo_width(), 0)), max)
self.assertRaises(tkinter.TclError, self.scale.set, None)
@add_standard_options(StandardTtkOptionsTests)
class ProgressbarTest(AbstractWidgetTest, unittest.TestCase):
OPTIONS = (
'class', 'cursor', 'orient', 'length',
'mode', 'maximum', 'phase',
'style', 'takefocus', 'value', 'variable',
)
_conv_pixels = noconv_meth
default_orient = 'horizontal'
def create(self, **kwargs):
return ttk.Progressbar(self.root, **kwargs)
def test_length(self):
widget = self.create()
self.checkPixelsParam(widget, 'length', 100.1, 56.7, '2i')
def test_maximum(self):
widget = self.create()
self.checkFloatParam(widget, 'maximum', 150.2, 77.7, 0, -10, conv=False)
def test_mode(self):
widget = self.create()
self.checkEnumParam(widget, 'mode', 'determinate', 'indeterminate')
def test_phase(self):
# XXX
pass
def test_value(self):
widget = self.create()
self.checkFloatParam(widget, 'value', 150.2, 77.7, 0, -10,
conv=False)
@unittest.skipIf(sys.platform == 'darwin',
'ttk.Scrollbar is special on MacOSX')
@add_standard_options(StandardTtkOptionsTests)
class ScrollbarTest(AbstractWidgetTest, unittest.TestCase):
OPTIONS = (
'class', 'command', 'cursor', 'orient', 'style', 'takefocus',
)
default_orient = 'vertical'
def create(self, **kwargs):
return ttk.Scrollbar(self.root, **kwargs)
@add_standard_options(IntegerSizeTests, StandardTtkOptionsTests)
class NotebookTest(AbstractWidgetTest, unittest.TestCase):
OPTIONS = (
'class', 'cursor', 'height', 'padding', 'style', 'takefocus', 'width',
)
def setUp(self):
super(NotebookTest, self).setUp()
self.nb = self.create(padding=0)
self.child1 = ttk.Label(self.root)
self.child2 = ttk.Label(self.root)
self.nb.add(self.child1, text='a')
self.nb.add(self.child2, text='b')
def create(self, **kwargs):
return ttk.Notebook(self.root, **kwargs)
def test_tab_identifiers(self):
self.nb.forget(0)
self.nb.hide(self.child2)
self.assertRaises(tkinter.TclError, self.nb.tab, self.child1)
self.assertEqual(self.nb.index('end'), 1)
self.nb.add(self.child2)
self.assertEqual(self.nb.index('end'), 1)
self.nb.select(self.child2)
self.assertTrue(self.nb.tab('current'))
self.nb.add(self.child1, text='a')
self.nb.pack()
self.nb.wait_visibility()
if sys.platform == 'darwin':
tb_idx = "@20,5"
else:
tb_idx = "@5,5"
self.assertEqual(self.nb.tab(tb_idx), self.nb.tab('current'))
for i in range(5, 100, 5):
try:
if self.nb.tab('@%d, 5' % i, text=None) == 'a':
break
except tkinter.TclError:
pass
else:
self.fail("Tab with text 'a' not found")
def test_add_and_hidden(self):
self.assertRaises(tkinter.TclError, self.nb.hide, -1)
self.assertRaises(tkinter.TclError, self.nb.hide, 'hi')
self.assertRaises(tkinter.TclError, self.nb.hide, None)
self.assertRaises(tkinter.TclError, self.nb.add, None)
self.assertRaises(tkinter.TclError, self.nb.add, ttk.Label(self.root),
unknown='option')
tabs = self.nb.tabs()
self.nb.hide(self.child1)
self.nb.add(self.child1)
self.assertEqual(self.nb.tabs(), tabs)
child = ttk.Label(self.root)
self.nb.add(child, text='c')
tabs = self.nb.tabs()
curr = self.nb.index('current')
# verify that the tab gets readded at its previous position
child2_index = self.nb.index(self.child2)
self.nb.hide(self.child2)
self.nb.add(self.child2)
self.assertEqual(self.nb.tabs(), tabs)
self.assertEqual(self.nb.index(self.child2), child2_index)
self.assertEqual(str(self.child2), self.nb.tabs()[child2_index])
# but the tab next to it (not hidden) is the one selected now
self.assertEqual(self.nb.index('current'), curr + 1)
def test_forget(self):
self.assertRaises(tkinter.TclError, self.nb.forget, -1)
self.assertRaises(tkinter.TclError, self.nb.forget, 'hi')
self.assertRaises(tkinter.TclError, self.nb.forget, None)
tabs = self.nb.tabs()
child1_index = self.nb.index(self.child1)
self.nb.forget(self.child1)
self.assertNotIn(str(self.child1), self.nb.tabs())
self.assertEqual(len(tabs) - 1, len(self.nb.tabs()))
self.nb.add(self.child1)
self.assertEqual(self.nb.index(self.child1), 1)
self.assertNotEqual(child1_index, self.nb.index(self.child1))
def test_index(self):
self.assertRaises(tkinter.TclError, self.nb.index, -1)
self.assertRaises(tkinter.TclError, self.nb.index, None)
self.assertIsInstance(self.nb.index('end'), int)
self.assertEqual(self.nb.index(self.child1), 0)
self.assertEqual(self.nb.index(self.child2), 1)
self.assertEqual(self.nb.index('end'), 2)
def test_insert(self):
# moving tabs
tabs = self.nb.tabs()
self.nb.insert(1, tabs[0])
self.assertEqual(self.nb.tabs(), (tabs[1], tabs[0]))
self.nb.insert(self.child1, self.child2)
self.assertEqual(self.nb.tabs(), tabs)
self.nb.insert('end', self.child1)
self.assertEqual(self.nb.tabs(), (tabs[1], tabs[0]))
self.nb.insert('end', 0)
self.assertEqual(self.nb.tabs(), tabs)
# bad moves
self.assertRaises(tkinter.TclError, self.nb.insert, 2, tabs[0])
self.assertRaises(tkinter.TclError, self.nb.insert, -1, tabs[0])
# new tab
child3 = ttk.Label(self.root)
self.nb.insert(1, child3)
self.assertEqual(self.nb.tabs(), (tabs[0], str(child3), tabs[1]))
self.nb.forget(child3)
self.assertEqual(self.nb.tabs(), tabs)
self.nb.insert(self.child1, child3)
self.assertEqual(self.nb.tabs(), (str(child3), ) + tabs)
self.nb.forget(child3)
self.assertRaises(tkinter.TclError, self.nb.insert, 2, child3)
self.assertRaises(tkinter.TclError, self.nb.insert, -1, child3)
# bad inserts
self.assertRaises(tkinter.TclError, self.nb.insert, 'end', None)
self.assertRaises(tkinter.TclError, self.nb.insert, None, 0)
self.assertRaises(tkinter.TclError, self.nb.insert, None, None)
def test_select(self):
self.nb.pack()
self.nb.wait_visibility()
success = []
tab_changed = []
self.child1.bind('<Unmap>', lambda evt: success.append(True))
self.nb.bind('<<NotebookTabChanged>>',
lambda evt: tab_changed.append(True))
self.assertEqual(self.nb.select(), str(self.child1))
self.nb.select(self.child2)
self.assertTrue(success)
self.assertEqual(self.nb.select(), str(self.child2))
self.nb.update()
self.assertTrue(tab_changed)
def test_tab(self):
self.assertRaises(tkinter.TclError, self.nb.tab, -1)
self.assertRaises(tkinter.TclError, self.nb.tab, 'notab')
self.assertRaises(tkinter.TclError, self.nb.tab, None)
self.assertIsInstance(self.nb.tab(self.child1), dict)
self.assertEqual(self.nb.tab(self.child1, text=None), 'a')
# newer form for querying a single option
self.assertEqual(self.nb.tab(self.child1, 'text'), 'a')
self.nb.tab(self.child1, text='abc')
self.assertEqual(self.nb.tab(self.child1, text=None), 'abc')
self.assertEqual(self.nb.tab(self.child1, 'text'), 'abc')
def test_tabs(self):
self.assertEqual(len(self.nb.tabs()), 2)
self.nb.forget(self.child1)
self.nb.forget(self.child2)
self.assertEqual(self.nb.tabs(), ())
def test_traversal(self):
self.nb.pack()
self.nb.wait_visibility()
self.nb.select(0)
simulate_mouse_click(self.nb, 5, 5)
self.nb.focus_force()
self.nb.event_generate('<Control-Tab>')
self.assertEqual(self.nb.select(), str(self.child2))
self.nb.focus_force()
self.nb.event_generate('<Shift-Control-Tab>')
self.assertEqual(self.nb.select(), str(self.child1))
self.nb.focus_force()
self.nb.event_generate('<Shift-Control-Tab>')
self.assertEqual(self.nb.select(), str(self.child2))
self.nb.tab(self.child1, text='a', underline=0)
self.nb.enable_traversal()
self.nb.focus_force()
simulate_mouse_click(self.nb, 5, 5)
if sys.platform == 'darwin':
self.nb.event_generate('<Option-a>')
else:
self.nb.event_generate('<Alt-a>')
self.assertEqual(self.nb.select(), str(self.child1))
@add_standard_options(StandardTtkOptionsTests)
class TreeviewTest(AbstractWidgetTest, unittest.TestCase):
OPTIONS = (
'class', 'columns', 'cursor', 'displaycolumns',
'height', 'padding', 'selectmode', 'show',
'style', 'takefocus', 'xscrollcommand', 'yscrollcommand',
)
def setUp(self):
super(TreeviewTest, self).setUp()
self.tv = self.create(padding=0)
def create(self, **kwargs):
return ttk.Treeview(self.root, **kwargs)
def test_columns(self):
widget = self.create()
self.checkParam(widget, 'columns', 'a b c',
expected=('a', 'b', 'c'))
self.checkParam(widget, 'columns', ('a', 'b', 'c'))
self.checkParam(widget, 'columns', () if tcl_version < (8, 5) else '')
def test_displaycolumns(self):
widget = self.create()
widget['columns'] = ('a', 'b', 'c')
self.checkParam(widget, 'displaycolumns', 'b a c',
expected=('b', 'a', 'c'))
self.checkParam(widget, 'displaycolumns', ('b', 'a', 'c'))
self.checkParam(widget, 'displaycolumns', '#all',
expected=('#all',))
self.checkParam(widget, 'displaycolumns', (2, 1, 0))
self.checkInvalidParam(widget, 'displaycolumns', ('a', 'b', 'd'),
errmsg='Invalid column index d')
self.checkInvalidParam(widget, 'displaycolumns', (1, 2, 3),
errmsg='Column index 3 out of bounds')
self.checkInvalidParam(widget, 'displaycolumns', (1, -2),
errmsg='Column index -2 out of bounds')
def test_height(self):
widget = self.create()
self.checkPixelsParam(widget, 'height', 100, -100, 0, '3c', conv=False)
self.checkPixelsParam(widget, 'height', 101.2, 102.6, conv=noconv)
def test_selectmode(self):
widget = self.create()
self.checkEnumParam(widget, 'selectmode',
'none', 'browse', 'extended')
def test_show(self):
widget = self.create()
self.checkParam(widget, 'show', 'tree headings',
expected=('tree', 'headings'))
self.checkParam(widget, 'show', ('tree', 'headings'))
self.checkParam(widget, 'show', ('headings', 'tree'))
self.checkParam(widget, 'show', 'tree', expected=('tree',))
self.checkParam(widget, 'show', 'headings', expected=('headings',))
def test_bbox(self):
self.tv.pack()
self.assertEqual(self.tv.bbox(''), '')
self.tv.wait_visibility()
self.tv.update()
item_id = self.tv.insert('', 'end')
children = self.tv.get_children()
self.assertTrue(children)
bbox = self.tv.bbox(children[0])
self.assertIsBoundingBox(bbox)
# compare width in bboxes
self.tv['columns'] = ['test']
self.tv.column('test', width=50)
bbox_column0 = self.tv.bbox(children[0], 0)
root_width = self.tv.column('#0', width=None)
if not self.wantobjects:
root_width = int(root_width)
self.assertEqual(bbox_column0[0], bbox[0] + root_width)
# verify that bbox of a closed item is the empty string
child1 = self.tv.insert(item_id, 'end')
self.assertEqual(self.tv.bbox(child1), '')
def test_children(self):
# no children yet, should get an empty tuple
self.assertEqual(self.tv.get_children(), ())
item_id = self.tv.insert('', 'end')
self.assertIsInstance(self.tv.get_children(), tuple)
self.assertEqual(self.tv.get_children()[0], item_id)
# add item_id and child3 as children of child2
child2 = self.tv.insert('', 'end')
child3 = self.tv.insert('', 'end')
self.tv.set_children(child2, item_id, child3)
self.assertEqual(self.tv.get_children(child2), (item_id, child3))
# child3 has child2 as parent, thus trying to set child2 as a children
# of child3 should result in an error
self.assertRaises(tkinter.TclError,
self.tv.set_children, child3, child2)
# remove child2 children
self.tv.set_children(child2)
self.assertEqual(self.tv.get_children(child2), ())
# remove root's children
self.tv.set_children('')
self.assertEqual(self.tv.get_children(), ())
def test_column(self):
# return a dict with all options/values
self.assertIsInstance(self.tv.column('#0'), dict)
# return a single value of the given option
if self.wantobjects:
self.assertIsInstance(self.tv.column('#0', width=None), int)
# set a new value for an option
self.tv.column('#0', width=10)
# testing new way to get option value
self.assertEqual(self.tv.column('#0', 'width'),
10 if self.wantobjects else '10')
self.assertEqual(self.tv.column('#0', width=None),
10 if self.wantobjects else '10')
# check read-only option
self.assertRaises(tkinter.TclError, self.tv.column, '#0', id='X')
self.assertRaises(tkinter.TclError, self.tv.column, 'invalid')
invalid_kws = [
{'unknown_option': 'some value'}, {'stretch': 'wrong'},
{'anchor': 'wrong'}, {'width': 'wrong'}, {'minwidth': 'wrong'}
]
for kw in invalid_kws:
self.assertRaises(tkinter.TclError, self.tv.column, '#0',
**kw)
def test_delete(self):
self.assertRaises(tkinter.TclError, self.tv.delete, '#0')
item_id = self.tv.insert('', 'end')
item2 = self.tv.insert(item_id, 'end')
self.assertEqual(self.tv.get_children(), (item_id, ))
self.assertEqual(self.tv.get_children(item_id), (item2, ))
self.tv.delete(item_id)
self.assertFalse(self.tv.get_children())
# reattach should fail
self.assertRaises(tkinter.TclError,
self.tv.reattach, item_id, '', 'end')
# test multiple item delete
item1 = self.tv.insert('', 'end')
item2 = self.tv.insert('', 'end')
self.assertEqual(self.tv.get_children(), (item1, item2))
self.tv.delete(item1, item2)
self.assertFalse(self.tv.get_children())
def test_detach_reattach(self):
item_id = self.tv.insert('', 'end')
item2 = self.tv.insert(item_id, 'end')
# calling detach without items is valid, although it does nothing
prev = self.tv.get_children()
self.tv.detach() # this should do nothing
self.assertEqual(prev, self.tv.get_children())
self.assertEqual(self.tv.get_children(), (item_id, ))
self.assertEqual(self.tv.get_children(item_id), (item2, ))
# detach item with children
self.tv.detach(item_id)
self.assertFalse(self.tv.get_children())
# reattach item with children
self.tv.reattach(item_id, '', 'end')
self.assertEqual(self.tv.get_children(), (item_id, ))
self.assertEqual(self.tv.get_children(item_id), (item2, ))
# move a children to the root
self.tv.move(item2, '', 'end')
self.assertEqual(self.tv.get_children(), (item_id, item2))
self.assertEqual(self.tv.get_children(item_id), ())
# bad values
self.assertRaises(tkinter.TclError,
self.tv.reattach, 'nonexistent', '', 'end')
self.assertRaises(tkinter.TclError,
self.tv.detach, 'nonexistent')
self.assertRaises(tkinter.TclError,
self.tv.reattach, item2, 'otherparent', 'end')
self.assertRaises(tkinter.TclError,
self.tv.reattach, item2, '', 'invalid')
# multiple detach
self.tv.detach(item_id, item2)
self.assertEqual(self.tv.get_children(), ())
self.assertEqual(self.tv.get_children(item_id), ())
def test_exists(self):
self.assertEqual(self.tv.exists('something'), False)
self.assertEqual(self.tv.exists(''), True)
self.assertEqual(self.tv.exists({}), False)
# the following will make a tk.call equivalent to
# tk.call(treeview, "exists") which should result in an error
# in the tcl interpreter since tk requires an item.
self.assertRaises(tkinter.TclError, self.tv.exists, None)
def test_focus(self):
# nothing is focused right now
self.assertEqual(self.tv.focus(), '')
item1 = self.tv.insert('', 'end')
self.tv.focus(item1)
self.assertEqual(self.tv.focus(), item1)
self.tv.delete(item1)
self.assertEqual(self.tv.focus(), '')
# try focusing inexistent item
self.assertRaises(tkinter.TclError, self.tv.focus, 'hi')
def test_heading(self):
# check a dict is returned
self.assertIsInstance(self.tv.heading('#0'), dict)
# check a value is returned
self.tv.heading('#0', text='hi')
self.assertEqual(self.tv.heading('#0', 'text'), 'hi')
self.assertEqual(self.tv.heading('#0', text=None), 'hi')
# invalid option
self.assertRaises(tkinter.TclError, self.tv.heading, '#0',
background=None)
# invalid value
self.assertRaises(tkinter.TclError, self.tv.heading, '#0',
anchor=1)
def test_heading_callback(self):
def simulate_heading_click(x, y):
simulate_mouse_click(self.tv, x, y)
self.tv.update()
success = [] # no success for now
self.tv.pack()
self.tv.wait_visibility()
self.tv.heading('#0', command=lambda: success.append(True))
self.tv.column('#0', width=100)
self.tv.update()
# assuming that the coords (5, 5) fall into heading #0
simulate_heading_click(5, 5)
if not success:
self.fail("The command associated to the treeview heading wasn't "
"invoked.")
success = []
commands = self.tv.master._tclCommands
self.tv.heading('#0', command=str(self.tv.heading('#0', command=None)))
self.assertEqual(commands, self.tv.master._tclCommands)
simulate_heading_click(5, 5)
if not success:
self.fail("The command associated to the treeview heading wasn't "
"invoked.")
# XXX The following raises an error in a tcl interpreter, but not in
# Python
#self.tv.heading('#0', command='I dont exist')
#simulate_heading_click(5, 5)
def test_index(self):
# item 'what' doesn't exist
self.assertRaises(tkinter.TclError, self.tv.index, 'what')
self.assertEqual(self.tv.index(''), 0)
item1 = self.tv.insert('', 'end')
item2 = self.tv.insert('', 'end')
c1 = self.tv.insert(item1, 'end')
c2 = self.tv.insert(item1, 'end')
self.assertEqual(self.tv.index(item1), 0)
self.assertEqual(self.tv.index(c1), 0)
self.assertEqual(self.tv.index(c2), 1)
self.assertEqual(self.tv.index(item2), 1)
self.tv.move(item2, '', 0)
self.assertEqual(self.tv.index(item2), 0)
self.assertEqual(self.tv.index(item1), 1)
# check that index still works even after its parent and siblings
# have been detached
self.tv.detach(item1)
self.assertEqual(self.tv.index(c2), 1)
self.tv.detach(c1)
self.assertEqual(self.tv.index(c2), 0)
# but it fails after item has been deleted
self.tv.delete(item1)
self.assertRaises(tkinter.TclError, self.tv.index, c2)
def test_insert_item(self):
# parent 'none' doesn't exist
self.assertRaises(tkinter.TclError, self.tv.insert, 'none', 'end')
# open values
self.assertRaises(tkinter.TclError, self.tv.insert, '', 'end',
open='')
self.assertRaises(tkinter.TclError, self.tv.insert, '', 'end',
open='please')
self.assertFalse(self.tv.delete(self.tv.insert('', 'end', open=True)))
self.assertFalse(self.tv.delete(self.tv.insert('', 'end', open=False)))
# invalid index
self.assertRaises(tkinter.TclError, self.tv.insert, '', 'middle')
# trying to duplicate item id is invalid
itemid = self.tv.insert('', 'end', 'first-item')
self.assertEqual(itemid, 'first-item')
self.assertRaises(tkinter.TclError, self.tv.insert, '', 'end',
'first-item')
self.assertRaises(tkinter.TclError, self.tv.insert, '', 'end',
MockTclObj('first-item'))
# unicode values
value = u'\xe1ba'
item = self.tv.insert('', 'end', values=(value, ))
self.assertEqual(self.tv.item(item, 'values'),
(value,) if self.wantobjects else value)
self.assertEqual(self.tv.item(item, values=None),
(value,) if self.wantobjects else value)
self.tv.item(item, values=self.root.splitlist(self.tv.item(item, values=None)))
self.assertEqual(self.tv.item(item, values=None),
(value,) if self.wantobjects else value)
self.assertIsInstance(self.tv.item(item), dict)
# erase item values
self.tv.item(item, values='')
self.assertFalse(self.tv.item(item, values=None))
# item tags
item = self.tv.insert('', 'end', tags=[1, 2, value])
self.assertEqual(self.tv.item(item, tags=None),
('1', '2', value) if self.wantobjects else
'1 2 %s' % value)
self.tv.item(item, tags=[])
self.assertFalse(self.tv.item(item, tags=None))
self.tv.item(item, tags=(1, 2))
self.assertEqual(self.tv.item(item, tags=None),
('1', '2') if self.wantobjects else '1 2')
# values with spaces
item = self.tv.insert('', 'end', values=('a b c',
'%s %s' % (value, value)))
self.assertEqual(self.tv.item(item, values=None),
('a b c', '%s %s' % (value, value)) if self.wantobjects else
'{a b c} {%s %s}' % (value, value))
# text
self.assertEqual(self.tv.item(
self.tv.insert('', 'end', text="Label here"), text=None),
"Label here")
self.assertEqual(self.tv.item(
self.tv.insert('', 'end', text=value), text=None),
value)
# test for values which are not None
itemid = self.tv.insert('', 'end', 0)
self.assertEqual(itemid, '0')
itemid = self.tv.insert('', 'end', 0.0)
self.assertEqual(itemid, '0.0')
# this is because False resolves to 0 and element with 0 iid is already present
self.assertRaises(tkinter.TclError, self.tv.insert, '', 'end', False)
self.assertRaises(tkinter.TclError, self.tv.insert, '', 'end', '')
def test_selection(self):
# item 'none' doesn't exist
self.assertRaises(tkinter.TclError, self.tv.selection_set, 'none')
self.assertRaises(tkinter.TclError, self.tv.selection_add, 'none')
self.assertRaises(tkinter.TclError, self.tv.selection_remove, 'none')
self.assertRaises(tkinter.TclError, self.tv.selection_toggle, 'none')
item1 = self.tv.insert('', 'end')
item2 = self.tv.insert('', 'end')
c1 = self.tv.insert(item1, 'end')
c2 = self.tv.insert(item1, 'end')
c3 = self.tv.insert(item1, 'end')
self.assertEqual(self.tv.selection(), ())
self.tv.selection_set((c1, item2))
self.assertEqual(self.tv.selection(), (c1, item2))
self.tv.selection_set(c2)
self.assertEqual(self.tv.selection(), (c2,))
self.tv.selection_add((c1, item2))
self.assertEqual(self.tv.selection(), (c1, c2, item2))
self.tv.selection_add(item1)
self.assertEqual(self.tv.selection(), (item1, c1, c2, item2))
self.tv.selection_remove((item1, c3))
self.assertEqual(self.tv.selection(), (c1, c2, item2))
self.tv.selection_remove(c2)
self.assertEqual(self.tv.selection(), (c1, item2))
self.tv.selection_toggle((c1, c3))
self.assertEqual(self.tv.selection(), (c3, item2))
self.tv.selection_toggle(item2)
self.assertEqual(self.tv.selection(), (c3,))
self.tv.insert('', 'end', id='with spaces')
self.tv.selection_set('with spaces')
self.assertEqual(self.tv.selection(), ('with spaces',))
self.tv.insert('', 'end', id='{brace')
self.tv.selection_set('{brace')
self.assertEqual(self.tv.selection(), ('{brace',))
if have_unicode:
self.tv.insert('', 'end', id=u(r'unicode\u20ac'))
self.tv.selection_set(u(r'unicode\u20ac'))
self.assertEqual(self.tv.selection(), (u(r'unicode\u20ac'),))
self.tv.insert('', 'end', id='bytes\xe2\x82\xac')
self.tv.selection_set('bytes\xe2\x82\xac')
self.assertEqual(self.tv.selection(),
(u(r'bytes\u20ac') if have_unicode else
'bytes\xe2\x82\xac',))
def test_set(self):
self.tv['columns'] = ['A', 'B']
item = self.tv.insert('', 'end', values=['a', 'b'])
self.assertEqual(self.tv.set(item), {'A': 'a', 'B': 'b'})
self.tv.set(item, 'B', 'a')
self.assertEqual(self.tv.item(item, values=None),
('a', 'a') if self.wantobjects else 'a a')
self.tv['columns'] = ['B']
self.assertEqual(self.tv.set(item), {'B': 'a'})
self.tv.set(item, 'B', 'b')
self.assertEqual(self.tv.set(item, column='B'), 'b')
self.assertEqual(self.tv.item(item, values=None),
('b', 'a') if self.wantobjects else 'b a')
self.tv.set(item, 'B', 123)
self.assertEqual(self.tv.set(item, 'B'),
123 if self.wantobjects else '123')
self.assertEqual(self.tv.item(item, values=None),
(123, 'a') if self.wantobjects else '123 a')
self.assertEqual(self.tv.set(item),
{'B': 123} if self.wantobjects else {'B': '123'})
# inexistent column
self.assertRaises(tkinter.TclError, self.tv.set, item, 'A')
self.assertRaises(tkinter.TclError, self.tv.set, item, 'A', 'b')
# inexistent item
self.assertRaises(tkinter.TclError, self.tv.set, 'notme')
def test_tag_bind(self):
events = []
item1 = self.tv.insert('', 'end', tags=['call'])
item2 = self.tv.insert('', 'end', tags=['call'])
self.tv.tag_bind('call', '<ButtonPress-1>',
lambda evt: events.append(1))
self.tv.tag_bind('call', '<ButtonRelease-1>',
lambda evt: events.append(2))
self.tv.pack()
self.tv.wait_visibility()
self.tv.update()
pos_y = set()
found = set()
for i in range(0, 100, 10):
if len(found) == 2: # item1 and item2 already found
break
item_id = self.tv.identify_row(i)
if item_id and item_id not in found:
pos_y.add(i)
found.add(item_id)
self.assertEqual(len(pos_y), 2) # item1 and item2 y pos
for y in pos_y:
simulate_mouse_click(self.tv, 0, y)
# by now there should be 4 things in the events list, since each
# item had a bind for two events that were simulated above
self.assertEqual(len(events), 4)
for evt in zip(events[::2], events[1::2]):
self.assertEqual(evt, (1, 2))
def test_tag_configure(self):
# Just testing parameter passing for now
self.assertRaises(TypeError, self.tv.tag_configure)
self.assertRaises(tkinter.TclError, self.tv.tag_configure,
'test', sky='blue')
self.tv.tag_configure('test', foreground='blue')
self.assertEqual(str(self.tv.tag_configure('test', 'foreground')),
'blue')
self.assertEqual(str(self.tv.tag_configure('test', foreground=None)),
'blue')
self.assertIsInstance(self.tv.tag_configure('test'), dict)
def test_tag_has(self):
item1 = self.tv.insert('', 'end', text='Item 1', tags=['tag1'])
item2 = self.tv.insert('', 'end', text='Item 2', tags=['tag2'])
self.assertRaises(TypeError, self.tv.tag_has)
self.assertRaises(TclError, self.tv.tag_has, 'tag1', 'non-existing')
self.assertTrue(self.tv.tag_has('tag1', item1))
self.assertFalse(self.tv.tag_has('tag1', item2))
self.assertFalse(self.tv.tag_has('tag2', item1))
self.assertTrue(self.tv.tag_has('tag2', item2))
self.assertFalse(self.tv.tag_has('tag3', item1))
self.assertFalse(self.tv.tag_has('tag3', item2))
self.assertEqual(self.tv.tag_has('tag1'), (item1,))
self.assertEqual(self.tv.tag_has('tag2'), (item2,))
self.assertEqual(self.tv.tag_has('tag3'), ())
@add_standard_options(StandardTtkOptionsTests)
class SeparatorTest(AbstractWidgetTest, unittest.TestCase):
OPTIONS = (
'class', 'cursor', 'orient', 'style', 'takefocus',
# 'state'?
)
default_orient = 'horizontal'
def create(self, **kwargs):
return ttk.Separator(self.root, **kwargs)
@add_standard_options(StandardTtkOptionsTests)
class SizegripTest(AbstractWidgetTest, unittest.TestCase):
OPTIONS = (
'class', 'cursor', 'style', 'takefocus',
# 'state'?
)
def create(self, **kwargs):
return ttk.Sizegrip(self.root, **kwargs)
tests_gui = (
ButtonTest, CheckbuttonTest, ComboboxTest, EntryTest,
FrameTest, LabelFrameTest, LabelTest, MenubuttonTest,
NotebookTest, PanedWindowTest, ProgressbarTest,
RadiobuttonTest, ScaleTest, ScrollbarTest, SeparatorTest,
SizegripTest, TreeviewTest, WidgetTest,
)
if __name__ == "__main__":
run_unittest(*tests_gui)
test/test_ttk/__init__.py 0000644 00000000000 15032720555 0011467 0 ustar 00 test/test_ttk/test_extensions.pyc 0000644 00000023675 15032720555 0013360 0 ustar 00 �
z fc @ s� d d l Z d d l Z d d l Z d d l Z d d l m Z m Z m Z d d l m
Z
m Z e d � d e
e j f d � � YZ
d e
e j f d � � YZ e
e f Z e d k r� e e � n d S(
i����N( t requirest run_unittestt swap_attr( t AbstractTkTestt destroy_default_roott guit LabeledScaleTestc B sG e Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c C s$ | j j � t t | � j � d S( N( t roott update_idletaskst superR t tearDown( t self( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyR
s
c C sl t j | j � } | j j } | j � | j t j | j j
| � t j | j � } | j } t j | j d | �} | j � | j r� | j
| j j
| � | j � � n( | j
t | j j
| � � | j � � ~ | j t j | j j
| � t j | j � } t j | j d | �} | j � t j | j d | �t t d � rh| j t j t j � n d S( Nt variablet last_type( t ttkt LabeledScaleR t _variablet _namet destroyt assertRaisest tkintert TclErrort tkt globalgetvart DoubleVart wantobjectst assertEqualt gett floatt IntVart hasattrt syst assertNotEqualR
( R t xt vart myvart name( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyt test_widget_destroy s&
%(
c C s� t t d d � �� t t d t � �i zY t j � } | j t j � | j | j t j � | j | j
t j j
� | j � Wd t � XWd QXWd QXd S( Nt
_default_roott _support_default_root(
R R t Nonet TrueR R t assertIsNotNoneR& R t masterR R R ( R R! ( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyt test_initialization_no_master2 s c s� t j � j � } t j | � } � j | j | � | j � d d d d t j d t j d f f } � j
r} | d 7} n xK | D]C } t j � j d | d �} � j | j | d � | j � q� Wt j � j d d �} � j t
| j j � | j � t j � j d d �} � j t
| j j � | j � t j � j d
d �} t j � j d | �} � j | j d � | j � t j � j d | d d
�} � j | j d
� � j | j j | j � | j � � f d � } t j � j d d �} | | j d | j d � | j � t j � j d d �} | | j d | j d � | j � t j � j d d �} | | j d | j d � | j � t j � j � } | | j d | j d � | j � � j t j t j | d d �d S( Nt 0i i
i����i g @i t from_s 2.5t valuei R g �?c s8 � j | j � d | � � j | j � d | � d S( Nt sidet anchor( R t pack_infot
place_info( t scalet scale_post labelt label_pos( R ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyt check_positionsa s t compoundt topt bottomt nt st unknownt at b( R- i ( i i ( i
i
( i����i����( g @i ( ( g @i ( R t FrameR R R R R+ R R t maxintR R/ R t
ValueErrorR R R( R R R4 R6 R ( R R+ R! t passed_expectedt pairR# R8 ( ( R s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyt test_initialization? sP
c C s^ t j | j d d d d �} | j � | j � | j � | j j � } | j j � d } | j
| t | d � � | j j d d d d � | j � | j j � d } | j
| | � | j j � } | j
| j d | j r� d n d � | j
| t | d � � | j j d d d d � | j
| | � | j
| t | d � � | j � d S(
NR. i t toi
R! i����i t textR- ( R R R t packt wait_visibilityt updateR6 R3 R4 t coordsR t intt configureR R R ( R t lscalet linfo_1t prev_xcoordt curr_xcoordt linfo_2( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyt test_horizontal_rangev s$
&c C sv t j | j � } | j � | j � | j � | j j � d } | j d } | | _ | j � | j | j
d | j r� | n t | � � | j
| j j � d | � | j | j j � d t | j
j � d � � | j r� d � } n t } | | j d � d | _ | j � | j | | j
d � | � | j | j j � d t | j
j � d � � | j � d S( Ni i RH R! c S s | S( N( ( R! ( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyt <lambda>� t RG ( R R R RI RJ RK R4 RL R/ R R6 R t strt
assertGreaterRM R3 R ( R R! RR t newvalt conv( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyt test_variable_change� s,
c C s� t j | j � } | j d t d d � | j � | j � | j j � | j j � } } | d | d } } d | _
| j � | j j d | | f � | j t
| j j � d � | j j � d � | j j d | | f � | j � d S( Nt expandt fillt bothi i s %dx%dR! i ( R R R RI R) RJ RK R+ t winfo_widtht winfo_heightR/ t wm_geometryR RM R6 R3 R4 RL R ( R R! t widtht heightt width_newt
height_new( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyt test_resize� s
( t __name__t
__module__R
R% R, RF RT R[ Rf ( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyR
s "
7 t OptionMenuTestc B s> e Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c C s, t t | � j � t j | j � | _ d S( N( R Ri t setUpR t StringVarR t textvar( R ( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyRj � s c C s | ` t t | � j � d S( N( Rl R Ri R
( R ( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyR
� s c C s� t j | j � } t j | j | � } | j } | j � | j � | j | j j
| � | j � � ~ | j t j
| j j
| � d S( N( R Rk R R t
OptionMenuR R R R R R R R R ( R R" t optmenuR$ ( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyR% � s
"c C s� | j t j t j | j | j d d �t j | j | j d d d � } | j | j j � d � | j
| d � | j
| d � | j � d S( Nt invalidt thingR@ R? t menut textvariable( R R R R Rm R Rl R R R t
assertTrueR ( R Rn ( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyRF � s !c s7 d
� d } t j � j � j | � � } t } xY t t � � � D]E } | d j | d � } � j | � | � | | k rC t } qC qC W� j
| � | j � d } t j � j � j | � � } d } d } xQ t r&| | d j
| d � } } | | k r Pn � j | | � | d 7} q� W� j | t � � � | j � | j � | d j d � � j | j j � � d � � j t j | d j d � � j | j j � � d � | j � g � � � � f d
� } t j � j � j d d | � �} | d j d � � s)� j d � n | j � d S( NR? R@ t cRq R/ t di i i����c s% � j | � d � � j t � d S( Ni ( R t appendR) ( t item( t itemsR t success( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyt cb_test s t commands Menu callback not invoked( R? R@ Rt ( R Rm R Rl t Falset ranget lent entrycgetR R) Rs R R( t entryconfigureR RI RJ t invokeR R R R R t fail( R t defaultRn t
found_defaultt iR/ t currt lastRz ( ( Rx R Ry s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyt test_menu� sJ
c C s; d } d } t j | j | j | | � } t j | j � } t j | j | | | � } | j � | j � | j � | j � | d j d � | d j d � | d j d d � } | d j d d � } | j
| | � | j | j j j
| � | d � | j | j j j
| � | d � | j � | j � d S(
NR? R@ Rt Rq i i i R ( R? R@ Rt ( R Rm R Rl R Rk RI RJ R� R R R R R R ( R Rx R� Rn t textvar2t optmenu2t optmenu_stringvar_namet optmenu2_stringvar_name( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyt test_unique_radiobuttons s*
( Rg Rh Rj R
R% RF R� R� ( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyRi � s
4t __main__( R t unittestt TkinterR R t test.test_supportR R R t test_ttk.supportR R t TestCaseR Ri t tests_guiRg ( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyt <module> s
� q test/test_ttk/__init__.pyo 0000644 00000000214 15032720555 0011655 0 ustar 00 �
z fc @ s d S( N( ( ( ( s5 /usr/lib64/python2.7/lib-tk/test/test_ttk/__init__.pyt <module> t test/test_ttk/test_functions.py 0000644 00000041677 15032720555 0013030 0 ustar 00 # -*- encoding: utf-8 -*-
import sys
import unittest
import ttk
class MockTkApp:
def splitlist(self, arg):
if isinstance(arg, tuple):
return arg
return arg.split(':')
def wantobjects(self):
return True
class MockTclObj(object):
typename = 'test'
def __init__(self, val):
self.val = val
def __str__(self):
return unicode(self.val)
class MockStateSpec(object):
typename = 'StateSpec'
def __init__(self, *args):
self.val = args
def __str__(self):
return ' '.join(self.val)
class InternalFunctionsTest(unittest.TestCase):
def test_format_optdict(self):
def check_against(fmt_opts, result):
for i in range(0, len(fmt_opts), 2):
self.assertEqual(result.pop(fmt_opts[i]), fmt_opts[i + 1])
if result:
self.fail("result still got elements: %s" % result)
# passing an empty dict should return an empty object (tuple here)
self.assertFalse(ttk._format_optdict({}))
# check list formatting
check_against(
ttk._format_optdict({'fg': 'blue', 'padding': [1, 2, 3, 4]}),
{'-fg': 'blue', '-padding': '1 2 3 4'})
# check tuple formatting (same as list)
check_against(
ttk._format_optdict({'test': (1, 2, '', 0)}),
{'-test': '1 2 {} 0'})
# check untouched values
check_against(
ttk._format_optdict({'test': {'left': 'as is'}}),
{'-test': {'left': 'as is'}})
# check script formatting
check_against(
ttk._format_optdict(
{'test': [1, -1, '', '2m', 0], 'test2': 3,
'test3': '', 'test4': 'abc def',
'test5': '"abc"', 'test6': '{}',
'test7': '} -spam {'}, script=True),
{'-test': '{1 -1 {} 2m 0}', '-test2': '3',
'-test3': '{}', '-test4': '{abc def}',
'-test5': '{"abc"}', '-test6': r'\{\}',
'-test7': r'\}\ -spam\ \{'})
opts = {u'αβγ': True, u'á': False}
orig_opts = opts.copy()
# check if giving unicode keys is fine
check_against(ttk._format_optdict(opts), {u'-αβγ': True, u'-á': False})
# opts should remain unchanged
self.assertEqual(opts, orig_opts)
# passing values with spaces inside a tuple/list
check_against(
ttk._format_optdict(
{'option': ('one two', 'three')}),
{'-option': '{one two} three'})
check_against(
ttk._format_optdict(
{'option': ('one\ttwo', 'three')}),
{'-option': '{one\ttwo} three'})
# passing empty strings inside a tuple/list
check_against(
ttk._format_optdict(
{'option': ('', 'one')}),
{'-option': '{} one'})
# passing values with braces inside a tuple/list
check_against(
ttk._format_optdict(
{'option': ('one} {two', 'three')}),
{'-option': r'one\}\ \{two three'})
# passing quoted strings inside a tuple/list
check_against(
ttk._format_optdict(
{'option': ('"one"', 'two')}),
{'-option': '{"one"} two'})
check_against(
ttk._format_optdict(
{'option': ('{one}', 'two')}),
{'-option': r'\{one\} two'})
# ignore an option
amount_opts = len(ttk._format_optdict(opts, ignore=(u'á'))) // 2
self.assertEqual(amount_opts, len(opts) - 1)
# ignore non-existing options
amount_opts = len(ttk._format_optdict(opts, ignore=(u'á', 'b'))) // 2
self.assertEqual(amount_opts, len(opts) - 1)
# ignore every option
self.assertFalse(ttk._format_optdict(opts, ignore=opts.keys()))
def test_format_mapdict(self):
opts = {'a': [('b', 'c', 'val'), ('d', 'otherval'), ('', 'single')]}
result = ttk._format_mapdict(opts)
self.assertEqual(len(result), len(opts.keys()) * 2)
self.assertEqual(result, ('-a', '{b c} val d otherval {} single'))
self.assertEqual(ttk._format_mapdict(opts, script=True),
('-a', '{{b c} val d otherval {} single}'))
self.assertEqual(ttk._format_mapdict({2: []}), ('-2', ''))
opts = {u'üñíćódè': [(u'á', u'vãl')]}
result = ttk._format_mapdict(opts)
self.assertEqual(result, (u'-üñíćódè', u'á vãl'))
# empty states
valid = {'opt': [('', u'', 'hi')]}
self.assertEqual(ttk._format_mapdict(valid), ('-opt', '{ } hi'))
# when passing multiple states, they all must be strings
invalid = {'opt': [(1, 2, 'valid val')]}
self.assertRaises(TypeError, ttk._format_mapdict, invalid)
invalid = {'opt': [([1], '2', 'valid val')]}
self.assertRaises(TypeError, ttk._format_mapdict, invalid)
# but when passing a single state, it can be anything
valid = {'opt': [[1, 'value']]}
self.assertEqual(ttk._format_mapdict(valid), ('-opt', '1 value'))
# special attention to single states which evalute to False
for stateval in (None, 0, False, '', set()): # just some samples
valid = {'opt': [(stateval, 'value')]}
self.assertEqual(ttk._format_mapdict(valid),
('-opt', '{} value'))
# values must be iterable
opts = {'a': None}
self.assertRaises(TypeError, ttk._format_mapdict, opts)
# items in the value must have size >= 2
self.assertRaises(IndexError, ttk._format_mapdict,
{'a': [('invalid', )]})
def test_format_elemcreate(self):
self.assertTrue(ttk._format_elemcreate(None), (None, ()))
## Testing type = image
# image type expects at least an image name, so this should raise
# IndexError since it tries to access the index 0 of an empty tuple
self.assertRaises(IndexError, ttk._format_elemcreate, 'image')
# don't format returned values as a tcl script
# minimum acceptable for image type
self.assertEqual(ttk._format_elemcreate('image', False, 'test'),
("test ", ()))
# specifying a state spec
self.assertEqual(ttk._format_elemcreate('image', False, 'test',
('', 'a')), ("test {} a", ()))
# state spec with multiple states
self.assertEqual(ttk._format_elemcreate('image', False, 'test',
('a', 'b', 'c')), ("test {a b} c", ()))
# state spec and options
res = ttk._format_elemcreate('image', False, 'test',
('a', 'b'), a='x', b='y')
self.assertEqual(res[0], "test a b")
self.assertEqual(set(res[1]), {"-a", "x", "-b", "y"})
# format returned values as a tcl script
# state spec with multiple states and an option with a multivalue
self.assertEqual(ttk._format_elemcreate('image', True, 'test',
('a', 'b', 'c', 'd'), x=[2, 3]), ("{test {a b c} d}", "-x {2 3}"))
## Testing type = vsapi
# vsapi type expects at least a class name and a part_id, so this
# should raise a ValueError since it tries to get two elements from
# an empty tuple
self.assertRaises(ValueError, ttk._format_elemcreate, 'vsapi')
# don't format returned values as a tcl script
# minimum acceptable for vsapi
self.assertEqual(ttk._format_elemcreate('vsapi', False, 'a', 'b'),
("a b ", ()))
# now with a state spec with multiple states
self.assertEqual(ttk._format_elemcreate('vsapi', False, 'a', 'b',
('a', 'b', 'c')), ("a b {a b} c", ()))
# state spec and option
self.assertEqual(ttk._format_elemcreate('vsapi', False, 'a', 'b',
('a', 'b'), opt='x'), ("a b a b", ("-opt", "x")))
# format returned values as a tcl script
# state spec with a multivalue and an option
self.assertEqual(ttk._format_elemcreate('vsapi', True, 'a', 'b',
('a', 'b', [1, 2]), opt='x'), ("{a b {a b} {1 2}}", "-opt x"))
# Testing type = from
# from type expects at least a type name
self.assertRaises(IndexError, ttk._format_elemcreate, 'from')
self.assertEqual(ttk._format_elemcreate('from', False, 'a'),
('a', ()))
self.assertEqual(ttk._format_elemcreate('from', False, 'a', 'b'),
('a', ('b', )))
self.assertEqual(ttk._format_elemcreate('from', True, 'a', 'b'),
('{a}', 'b'))
def test_format_layoutlist(self):
def sample(indent=0, indent_size=2):
return ttk._format_layoutlist(
[('a', {'other': [1, 2, 3], 'children':
[('b', {'children':
[('c', {'children':
[('d', {'nice': 'opt'})], 'something': (1, 2)
})]
})]
})], indent=indent, indent_size=indent_size)[0]
def sample_expected(indent=0, indent_size=2):
spaces = lambda amount=0: ' ' * (amount + indent)
return (
"%sa -other {1 2 3} -children {\n"
"%sb -children {\n"
"%sc -something {1 2} -children {\n"
"%sd -nice opt\n"
"%s}\n"
"%s}\n"
"%s}" % (spaces(), spaces(indent_size),
spaces(2 * indent_size), spaces(3 * indent_size),
spaces(2 * indent_size), spaces(indent_size), spaces()))
# empty layout
self.assertEqual(ttk._format_layoutlist([])[0], '')
# smallest (after an empty one) acceptable layout
smallest = ttk._format_layoutlist([('a', None)], indent=0)
self.assertEqual(smallest,
ttk._format_layoutlist([('a', '')], indent=0))
self.assertEqual(smallest[0], 'a')
# testing indentation levels
self.assertEqual(sample(), sample_expected())
for i in range(4):
self.assertEqual(sample(i), sample_expected(i))
self.assertEqual(sample(i, i), sample_expected(i, i))
# invalid layout format, different kind of exceptions will be
# raised
# plain wrong format
self.assertRaises(ValueError, ttk._format_layoutlist,
['bad', 'format'])
self.assertRaises(TypeError, ttk._format_layoutlist, None)
# _format_layoutlist always expects the second item (in every item)
# to act like a dict (except when the value evalutes to False).
self.assertRaises(AttributeError,
ttk._format_layoutlist, [('a', 'b')])
# bad children formatting
self.assertRaises(ValueError, ttk._format_layoutlist,
[('name', {'children': {'a': None}})])
def test_script_from_settings(self):
# empty options
self.assertFalse(ttk._script_from_settings({'name':
{'configure': None, 'map': None, 'element create': None}}))
# empty layout
self.assertEqual(
ttk._script_from_settings({'name': {'layout': None}}),
"ttk::style layout name {\nnull\n}")
configdict = {u'αβγ': True, u'á': False}
self.assertTrue(
ttk._script_from_settings({'name': {'configure': configdict}}))
mapdict = {u'üñíćódè': [(u'á', u'vãl')]}
self.assertTrue(
ttk._script_from_settings({'name': {'map': mapdict}}))
# invalid image element
self.assertRaises(IndexError,
ttk._script_from_settings, {'name': {'element create': ['image']}})
# minimal valid image
self.assertTrue(ttk._script_from_settings({'name':
{'element create': ['image', 'name']}}))
image = {'thing': {'element create':
['image', 'name', ('state1', 'state2', 'val')]}}
self.assertEqual(ttk._script_from_settings(image),
"ttk::style element create thing image {name {state1 state2} val} ")
image['thing']['element create'].append({'opt': 30})
self.assertEqual(ttk._script_from_settings(image),
"ttk::style element create thing image {name {state1 state2} val} "
"-opt 30")
image['thing']['element create'][-1]['opt'] = [MockTclObj(3),
MockTclObj('2m')]
self.assertEqual(ttk._script_from_settings(image),
"ttk::style element create thing image {name {state1 state2} val} "
"-opt {3 2m}")
def test_tclobj_to_py(self):
self.assertEqual(
ttk._tclobj_to_py((MockStateSpec('a', 'b'), 'val')),
[('a', 'b', 'val')])
self.assertEqual(
ttk._tclobj_to_py([MockTclObj('1'), 2, MockTclObj('3m')]),
[1, 2, '3m'])
def test_list_from_statespec(self):
def test_it(sspec, value, res_value, states):
self.assertEqual(ttk._list_from_statespec(
(sspec, value)), [states + (res_value, )])
states_even = tuple('state%d' % i for i in range(6))
statespec = MockStateSpec(*states_even)
test_it(statespec, 'val', 'val', states_even)
test_it(statespec, MockTclObj('val'), 'val', states_even)
states_odd = tuple('state%d' % i for i in range(5))
statespec = MockStateSpec(*states_odd)
test_it(statespec, 'val', 'val', states_odd)
test_it(('a', 'b', 'c'), MockTclObj('val'), 'val', ('a', 'b', 'c'))
def test_list_from_layouttuple(self):
tk = MockTkApp()
# empty layout tuple
self.assertFalse(ttk._list_from_layouttuple(tk, ()))
# shortest layout tuple
self.assertEqual(ttk._list_from_layouttuple(tk, ('name', )),
[('name', {})])
# not so interesting ltuple
sample_ltuple = ('name', '-option', 'value')
self.assertEqual(ttk._list_from_layouttuple(tk, sample_ltuple),
[('name', {'option': 'value'})])
# empty children
self.assertEqual(ttk._list_from_layouttuple(tk,
('something', '-children', ())),
[('something', {'children': []})]
)
# more interesting ltuple
ltuple = (
'name', '-option', 'niceone', '-children', (
('otherone', '-children', (
('child', )), '-otheropt', 'othervalue'
)
)
)
self.assertEqual(ttk._list_from_layouttuple(tk, ltuple),
[('name', {'option': 'niceone', 'children':
[('otherone', {'otheropt': 'othervalue', 'children':
[('child', {})]
})]
})]
)
# bad tuples
self.assertRaises(ValueError, ttk._list_from_layouttuple, tk,
('name', 'no_minus'))
self.assertRaises(ValueError, ttk._list_from_layouttuple, tk,
('name', 'no_minus', 'value'))
self.assertRaises(ValueError, ttk._list_from_layouttuple, tk,
('something', '-children')) # no children
def test_val_or_dict(self):
def func(res, opt=None, val=None):
if opt is None:
return res
if val is None:
return "test val"
return (opt, val)
tk = MockTkApp()
tk.call = func
self.assertEqual(ttk._val_or_dict(tk, {}, '-test:3'),
{'test': '3'})
self.assertEqual(ttk._val_or_dict(tk, {}, ('-test', 3)),
{'test': 3})
self.assertEqual(ttk._val_or_dict(tk, {'test': None}, 'x:y'),
'test val')
self.assertEqual(ttk._val_or_dict(tk, {'test': 3}, 'x:y'),
{'test': 3})
def test_convert_stringval(self):
tests = (
(0, 0), ('09', 9), ('a', 'a'), (u'áÚ', u'áÚ'), ([], '[]'),
(None, 'None')
)
for orig, expected in tests:
self.assertEqual(ttk._convert_stringval(orig), expected)
if sys.getdefaultencoding() == 'ascii':
self.assertRaises(UnicodeDecodeError,
ttk._convert_stringval, 'á')
class TclObjsToPyTest(unittest.TestCase):
def test_unicode(self):
adict = {'opt': u'välúè'}
self.assertEqual(ttk.tclobjs_to_py(adict), {'opt': u'välúè'})
adict['opt'] = MockTclObj(adict['opt'])
self.assertEqual(ttk.tclobjs_to_py(adict), {'opt': u'välúè'})
def test_multivalues(self):
adict = {'opt': [1, 2, 3, 4]}
self.assertEqual(ttk.tclobjs_to_py(adict), {'opt': [1, 2, 3, 4]})
adict['opt'] = [1, 'xm', 3]
self.assertEqual(ttk.tclobjs_to_py(adict), {'opt': [1, 'xm', 3]})
adict['opt'] = (MockStateSpec('a', 'b'), u'válũè')
self.assertEqual(ttk.tclobjs_to_py(adict),
{'opt': [('a', 'b', u'válũè')]})
self.assertEqual(ttk.tclobjs_to_py({'x': ['y z']}),
{'x': ['y z']})
def test_nosplit(self):
self.assertEqual(ttk.tclobjs_to_py({'text': 'some text'}),
{'text': 'some text'})
tests_nogui = (InternalFunctionsTest, TclObjsToPyTest)
if __name__ == "__main__":
from test.test_support import run_unittest
run_unittest(*tests_nogui)
test/test_ttk/test_functions.pyc 0000644 00000037242 15032720555 0013164 0 ustar 00 �
z fc @ s� d d l Z d d l Z d d l Z d f d � � YZ d e f d � � YZ d e f d � � YZ d e j f d � � YZ d
e j f d � � YZ e e f Z
e d k r� d d
l m
Z
e
e
� n d S( i����Nt MockTkAppc B s e Z d � Z d � Z RS( c C s t | t � r | S| j d � S( Nt :( t
isinstancet tuplet split( t selft arg( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt splitlist s c C s t S( N( t True( R ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt wantobjects
s ( t __name__t
__module__R R ( ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyR s t
MockTclObjc B s e Z d Z d � Z d � Z RS( t testc C s
| | _ d S( N( t val( R R ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt __init__ s c C s
t | j � S( N( t unicodeR ( R ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt __str__ s ( R
R t typenameR R ( ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyR s t
MockStateSpecc B s e Z d Z d � Z d � Z RS( t StateSpecc G s
| | _ d S( N( R ( R t args( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyR s c C s d j | j � S( Nt ( t joinR ( R ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyR ! s ( R
R R R R ( ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyR s t InternalFunctionsTestc B sb e Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z RS(
c s
� f d � } � j t j i � � | t j i d d 6d d d d g d 6� i d d 6d
d 6� | t j i dB d 6� i d d 6� | t j i i d d 6d 6� i i d d 6d 6� | t j i d d d d d
g d 6d d 6d d 6d d 6d d 6d d 6d d 6d t �i d d 6d! d" 6d d# 6d$ d% 6d& d' 6d( d) 6d* d+ 6� i t d, 6t d- 6} | j � } | t j | � i t d. 6t d/ 6� � j | | � | t j i dC d2 6� i d3 d4 6� | t j i dD d2 6� i d6 d4 6� | t j i dE d2 6� i d8 d4 6� | t j i dF d2 6� i d: d4 6� | t j i dG d2 6� i d= d4 6� | t j i dH d2 6� i d? d4 6� t t j | d@ d- �� d } � j | t | � d � t t j | d@ dI �� d } � j | t | � d � � j t j | d@ | j � �� d S(J Nc sf xE t d t | � d � D]+ } � j | j | | � | | d � q W| rb � j d | � n d S( Ni i i s result still got elements: %s( t ranget lent assertEqualt popt fail( t fmt_optst resultt i( R ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt
check_against( s )t bluet fgi i i i t paddings -fgs 1 2 3 4s -paddingt i R
s 1 2 {} 0s -tests as ist lefti����t 2mt test2t test3s abc deft test4s "abc"t test5s {}t test6s } -spam {t test7t scripts {1 -1 {} 2m 0}t 3s -test2s -test3s {abc def}s -test4s {"abc"}s -test5s \{\}s -test6s
\}\ -spam\ \{s -test7u αβγu áu -αβγu -ás one twot threet options {one two} threes -options one twos {one two} threet ones {} ones one} {twos one\}\ \{two threes "one"t twos {"one"} twos {one}s \{one\} twot ignoret b( i i R% i ( s one twoR0 ( s one twoR0 ( R% R2 ( s one} {twoR0 ( s "one"R3 ( s {one}R3 ( u áR5 ( t assertFalset ttkt _format_optdictR t Falset copyR R t keys( R R! t optst orig_optst amount_opts( ( R s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt test_format_optdict' sl & $
c C s i d! d" d# g d 6} t j | � } | j t | � t | j � � d � | j | d$ � | j t j | d t �d% � | j t j i g d 6� d& � i d' g d 6} t j | � } | j | d( � i d) g d 6} | j t j | � d* � i d+ g d 6} | j t t j | � i d g d d f g d 6} | j t t j | � i d d g g d 6} | j t j | � d, � xO d d t d t
� f D]5 } i | d f g d 6} | j t j | � d- � q�Wi d d 6} | j t t j | � | j t t j i d. g d 6� d S(/ NR5 t cR t dt othervalR% t singlet ai s -as {b c} val d otherval {} singleR. s {{b c} val d otherval {} single}s -2u áu vãlu
üñíćódèu -üñíćódèu á vãlu t hit opts -opts { } hii s valid valt 2t values 1 valuei s {} valuet invalid( R5 R@ R ( RA RB ( R% RC ( s -as {b c} val d otherval {} single( s -as {{b c} val d otherval {} single}( s -2R% ( u áu vãl( u -üñíćódèu á vãl( R% u RE ( s -opts { } hi( i i s valid val( s -opts 1 value( s -opts {} value( RI ( R7 t _format_mapdictR R R; R t assertRaisest TypeErrort NoneR9 t sett
IndexError( R R< R t validRI t stateval( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt test_format_mapdict s4 &
c
C s� | j t j d � d d f � | j t t j d � | j t j d t d � d d! f � | j t j d t d d" � d d# f � | j t j d t d d$ � d d% f � t j d t d d& d d
d d �} | j | d d
� | j t | d � d d
d d h � | j t j d t d d' d
d d g �d( � | j t
t j d � | j t j d t d d � d d) f � | j t j d t d d d* � d d+ f � | j t j d t d d d, d d
�d d- f � | j t j d t d d d d d d g f d d
�d. � | j t t j d � | j t j d t d � d d/ f � | j t j d t d d � d d0 f � | j t j d t d d � d1 � d S(2 Nt imageR
s test R% RD s test {} aR5 R@ s test {a b} ct xt yi s test a bi s -as -bRA i i s {test {a b c} d}s -x {2 3}t vsapis a b s a b {a b} cRF s a b a bs -opts {a b {a b} {1 2}}s -opt xt froms {a}( ( ( R% RD ( ( RD R5 R@ ( ( RD R5 ( RD R5 R@ RA ( s {test {a b c} d}s -x {2 3}( ( RD R5 R@ ( ( RD R5 ( s -optRT ( s {a b {a b} {1 2}}s -opt x( ( R5 ( s {a}R5 ( t
assertTrueR7 t _format_elemcreateRM RK RO R R9 RN R t
ValueError( R t res( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt test_format_elemcreate� s<
&
"
c C sp d d d � } d d d � } | j t j g � d d � t j d g d d �} | j | t j d g d d �� | j | d d � | j | � | � � xR t d � D]D } | j | | � | | � � | j | | | � | | | � � q� W| j t t j d d
g � | j t t j d � | j t t j d g � | j t t j d i i d d 6d
6f g � d S( Ni i c S st t j d i d d d g d 6d i d i d i d d
6f g d 6d d 6f g d 6f g d 6f g d
| d | �d S( NRD i i i t otherR5 R@ RA RF t nicet childrent somethingt indentt indent_sizei ( i i ( R7 t _format_layoutlist( Ra Rb ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt sample� s ;c s_ d � f d � } d | � | | � | d | � | d | � | d | � | | � | � f S( Ni c s d | � S( NR ( ( t amount( Ra ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt <lambda>� R% si %sa -other {1 2 3} -children {
%sb -children {
%sc -something {1 2} -children {
%sd -nice opt
%s}
%s}
%s}i i ( ( Ra Rb t spaces( ( Ra s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt sample_expected� s
R% RD Ra i t badt formatR5 t nameR_ ( RD N( RD R% ( RD R5 ( R R7 Rc RM R RK RZ RL t AttributeError( R Rd Rh t smallestR ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt test_format_layoutlist� s$
&
c C s� | j t j i i d d 6d d 6d d 6d 6� � | j t j i i d d 6d 6� d � i t d 6t d 6} | j t j i i | d 6d 6� � i d g d
6} | j t j i i | d 6d 6� � | j t t j i i d g d 6d 6� | j t j i i d d g d 6d 6� � i i d d d g d 6d 6} | j t j | � d � | d d j
i d d 6� | j t j | � d � t d � t d � g | d d d d <| j t j | � d � d S( Nt configuret maps element createRk t layouts ttk::style layout name {
null
}u αβγu áu vãlu
üñíćódèRS t state1t state2R t thingsA ttk::style element create thing image {name {state1 state2} val} i RF sH ttk::style element create thing image {name {state1 state2} val} -opt 30i R' i����sL ttk::style element create thing image {name {state1 state2} val} -opt {3 2m}( u áu vãl( Rr Rs R ( R6 R7 t _script_from_settingsRM R R R9 RX RK RO t appendR ( R t
configdictt mapdictRS ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt test_script_from_settings s4 # c C sf | j t j t d d � d f � d g � | j t j t d � d t d � g � d d d g � d S( NRD R5 R t 1i t 3mi ( RD R5 R ( R R7 t
_tclobj_to_pyR R ( R ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt test_tclobj_to_pyG s
!c s� � f d � } t d � t d � D� � } t | � } | | d d | � | | t d � d | � t d � t d � D� � } t | � } | | d d | � | d
t d � d d � d S( Nc s- � j t j | | f � | | f g � d S( N( R R7 t _list_from_statespec( t sspecRH t res_valuet states( R ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt test_itQ s c s s | ] } d | Vq d S( s state%dN( ( t .0R ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pys <genexpr>U s i R c s s | ] } d | Vq d S( s state%dN( ( R� R ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pys <genexpr>Z s i RD R5 R@ ( RD R5 R@ ( RD R5 R@ ( R R R R ( R R� t states_event statespect
states_odd( ( R s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt test_list_from_statespecP s c C st t � } | j t j | d � � | j t j | d � d i f g � d } | j t j | | � d i d d 6f g � | j t j | d d d f � d i g d 6f g � d d d d d d d d d f f } | j t j | | � d i d d 6d i d d
6d
i f g d 6f g d 6f g � | j t t j | d � | j t t j | d � | j t t j | d � d S( NRk s -optionRH R1 R` s -childrenR_ t niceonet otheronet childs -otheroptt
othervaluet otheroptt no_minus( ( Rk ( Rk s -optionRH ( ( R� ( Rk R� ( Rk R� RH ( R` s -children( R R6 R7 t _list_from_layouttupleR RK RZ ( R t tkt
sample_ltuplet ltuple( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt test_list_from_layouttuplea s.
$c C s� d d d � } t � } | | _ | j t j | i d � i d d 6� | j t j | i d � i d d 6� | j t j | i d d 6d � d � | j t j | i d d 6d � i d d 6� d S(
Nc S s* | d k r | S| d k r d S| | f S( Ns test val( RM ( R[ RF R ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt func� s
s -test:3R/ R
s -testi s x:ys test val( s -testi ( RM R t callR R7 t _val_or_dict( R R� R� ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt test_val_or_dict� s c C s} d
d d d
g d f d f } x- | D]% \ } } | j t j | � | � q% Wt j � d k ry | j t t j d � n d S( Ni t 09i RD u áÚs []RM t asciis á( i i ( R� i ( RD RD ( u áÚu áÚ( NRM ( RM R R7 t _convert_stringvalt syst getdefaultencodingRK t UnicodeDecodeError( R t testst origt expected( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt test_convert_stringval� s ( R
R R? RR R\ Rn Ry R} R� R� R� R� ( ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyR % s X ) = 7 + . t TclObjsToPyTestc B s# e Z d � Z d � Z d � Z RS( c C se i d d 6} | j t j | � i d d 6� t | d � | d <| j t j | � i d d 6� d S( Nu välúèRF ( R R7 t
tclobjs_to_pyR ( R t adict( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt test_unicode� s
c C s� i d d d d g d 6} | j t j | � i d d d d g d 6� d d d g | d <| j t j | � i d d d g d 6� t d d � d f | d <| j t j | � i d g d 6� | j t j i d
g d 6� i d
g d 6� d S(
Ni i i i RF t xmRD R5 u válũès y zRT ( RD R5 u válũè( R R7 R� R ( R R� ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt test_multivalues� s ,) c C s+ | j t j i d d 6� i d d 6� d S( Ns some textt text( R R7 R� ( R ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt test_nosplit� s ( R
R R� R� R� ( ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyR� � s t __main__( t run_unittest( R� t unittestR7 R t objectR R t TestCaseR R� t tests_noguiR
t test.test_supportR� ( ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt <module> s
� � test/test_ttk/support.pyc 0000644 00000012334 15032720555 0011624 0 ustar 00 �
z fc @ s� d d l Z d d l Z d d l Z d d l Z d d d � � YZ d � Z d � Z d d l Z e e
e e j j
d � � � Z d � Z d a d � Z i d d
d 6d d 6d d
d 6d d 6Z d � Z d � Z d � Z d S( i����Nt AbstractTkTestc B s8 e Z e d � � Z e d � � Z d � Z d � Z RS( c C s� t j | _ t � t j � t j � | _ | j j � | _ | j j d � y | j j d t
� Wn t j k
r{ n Xd S( Nt normals -zoomed( t tkintert _support_default_roott _old_support_default_roott destroy_default_roott
NoDefaultRoott Tkt roott wantobjectst wm_statet
wm_attributest Falset TclError( t cls( ( s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyt
setUpClass s
c C s9 | j j � | j j � | ` d t _ | j t _ d S( N( R t update_idletaskst destroyt NoneR t
_default_rootR R ( R ( ( s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyt
tearDownClass s
c C s | j j � d S( N( R t deiconify( t self( ( s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyt setUp s c C s5 x! | j j � D] } | j � q W| j j � d S( N( R t winfo_childrenR t withdraw( R t w( ( s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyt tearDown" s ( t __name__t
__module__t classmethodR R R R ( ( ( s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyR s c C s< t t d d � r8 t j j � t j j � d t _ n d S( NR ( t getattrR R R R R ( ( ( s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyR ' s
c C sh | j d d d d d �| j d d | d | �| j d d | d | �| j d d | d | �d S( sY Generate proper events to click at the x, y position (tries to act
like an X server).s <Enter>t xi t ys <Motion>s <ButtonPress-1>s <ButtonRelease-1>N( t event_generate( t widgetR R! ( ( s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyt simulate_mouse_click- s t .c sQ t � � d k r> t j t � k d d j t t � � � � S� f d � } | S( Ni s requires Tcl version >= R% c s% t j � � � � f d � � } | S( Nc sC t � � k r5 | j d d j t t � � � � n � | � d S( Ns requires Tcl version >= R% ( t get_tk_patchlevelt skipTestt joint mapt str( R ( t testt version( s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyt newtest? s ( t functoolst wraps( R+ R- ( R, ( R+ s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyt deco> s !( t lent unittestt
skipUnlesst tcl_versionR( R) R* ( R, R0 ( ( R, s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyt requires_tcl9 s
c C s� t d k r� t j � } | j d d � } t j d | � } | j � \ } } } } t | � t | � t | � } } } i d d 6d d 6d d 6| } | d k r� | | | | d
f a q� | | d
| | f a n t S( Nt infot
patchlevels (\d+)\.(\d+)([ab.])(\d+)$t alphat at betat bt finalR% i ( t _tk_patchlevelR R t Tclt callt ret matcht groupst int( t tclR7 t mt majort minort releaselevelt serial( ( s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyR& I s & iH gR� ��Q@t ct igffffff9@RE i t pc C s t | d � t | d S( Ni����( t floatt units( t value( ( s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyt pixels_conv_ s c C s� | | k r t St | t j � rD t | t � rD t | � | k Sn t | t � r� t | t � r� t | � t | � k o� t d � t | | � D� � Sn t S( Nc s s$ | ] \ } } t | | � Vq d S( N( t
tcl_obj_eq( t .0t actt exp( ( s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pys <genexpr>k s (
t Truet
isinstancet _tkintert Tcl_ObjR* t tupleR1 t allt zipR ( t actualt expected( ( s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyRQ b s c C s] | | k r t St | t t j f � rY t | t t j f � rY t | � t | � k Sn t S( N( RU RV R* R t WidgetR ( R\ R] ( ( s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyt widget_eqo s ( ( R. R@ R2 t TkinterR R R R$ RW RY R) RC t TCL_VERSIONt splitR4 R5 R R= R& RN RP RQ R_ ( ( ( s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyt <module> s& ! !
test/test_ttk/test_extensions.pyo 0000644 00000023675 15032720555 0013374 0 ustar 00 �
z fc @ s� d d l Z d d l Z d d l Z d d l Z d d l m Z m Z m Z d d l m
Z
m Z e d � d e
e j f d � � YZ
d e
e j f d � � YZ e
e f Z e d k r� e e � n d S(
i����N( t requirest run_unittestt swap_attr( t AbstractTkTestt destroy_default_roott guit LabeledScaleTestc B sG e Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c C s$ | j j � t t | � j � d S( N( t roott update_idletaskst superR t tearDown( t self( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyR
s
c C sl t j | j � } | j j } | j � | j t j | j j
| � t j | j � } | j } t j | j d | �} | j � | j r� | j
| j j
| � | j � � n( | j
t | j j
| � � | j � � ~ | j t j | j j
| � t j | j � } t j | j d | �} | j � t j | j d | �t t d � rh| j t j t j � n d S( Nt variablet last_type( t ttkt LabeledScaleR t _variablet _namet destroyt assertRaisest tkintert TclErrort tkt globalgetvart DoubleVart wantobjectst assertEqualt gett floatt IntVart hasattrt syst assertNotEqualR
( R t xt vart myvart name( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyt test_widget_destroy s&
%(
c C s� t t d d � �� t t d t � �i zY t j � } | j t j � | j | j t j � | j | j
t j j
� | j � Wd t � XWd QXWd QXd S( Nt
_default_roott _support_default_root(
R R t Nonet TrueR R t assertIsNotNoneR& R t masterR R R ( R R! ( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyt test_initialization_no_master2 s c s� t j � j � } t j | � } � j | j | � | j � d d d d t j d t j d f f } � j
r} | d 7} n xK | D]C } t j � j d | d �} � j | j | d � | j � q� Wt j � j d d �} � j t
| j j � | j � t j � j d d �} � j t
| j j � | j � t j � j d
d �} t j � j d | �} � j | j d � | j � t j � j d | d d
�} � j | j d
� � j | j j | j � | j � � f d � } t j � j d d �} | | j d | j d � | j � t j � j d d �} | | j d | j d � | j � t j � j d d �} | | j d | j d � | j � t j � j � } | | j d | j d � | j � � j t j t j | d d �d S( Nt 0i i
i����i g @i t from_s 2.5t valuei R g �?c s8 � j | j � d | � � j | j � d | � d S( Nt sidet anchor( R t pack_infot
place_info( t scalet scale_post labelt label_pos( R ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyt check_positionsa s t compoundt topt bottomt nt st unknownt at b( R- i ( i i ( i
i
( i����i����( g @i ( ( g @i ( R t FrameR R R R R+ R R t maxintR R/ R t
ValueErrorR R R( R R R4 R6 R ( R R+ R! t passed_expectedt pairR# R8 ( ( R s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyt test_initialization? sP
c C s^ t j | j d d d d �} | j � | j � | j � | j j � } | j j � d } | j
| t | d � � | j j d d d d � | j � | j j � d } | j
| | � | j j � } | j
| j d | j r� d n d � | j
| t | d � � | j j d d d d � | j
| | � | j
| t | d � � | j � d S(
NR. i t toi
R! i����i t textR- ( R R R t packt wait_visibilityt updateR6 R3 R4 t coordsR t intt configureR R R ( R t lscalet linfo_1t prev_xcoordt curr_xcoordt linfo_2( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyt test_horizontal_rangev s$
&c C sv t j | j � } | j � | j � | j � | j j � d } | j d } | | _ | j � | j | j
d | j r� | n t | � � | j
| j j � d | � | j | j j � d t | j
j � d � � | j r� d � } n t } | | j d � d | _ | j � | j | | j
d � | � | j | j j � d t | j
j � d � � | j � d S( Ni i RH R! c S s | S( N( ( R! ( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyt <lambda>� t RG ( R R R RI RJ RK R4 RL R/ R R6 R t strt
assertGreaterRM R3 R ( R R! RR t newvalt conv( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyt test_variable_change� s,
c C s� t j | j � } | j d t d d � | j � | j � | j j � | j j � } } | d | d } } d | _
| j � | j j d | | f � | j t
| j j � d � | j j � d � | j j d | | f � | j � d S( Nt expandt fillt bothi i s %dx%dR! i ( R R R RI R) RJ RK R+ t winfo_widtht winfo_heightR/ t wm_geometryR RM R6 R3 R4 RL R ( R R! t widtht heightt width_newt
height_new( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyt test_resize� s
( t __name__t
__module__R
R% R, RF RT R[ Rf ( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyR
s "
7 t OptionMenuTestc B s> e Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c C s, t t | � j � t j | j � | _ d S( N( R Ri t setUpR t StringVarR t textvar( R ( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyRj � s c C s | ` t t | � j � d S( N( Rl R Ri R
( R ( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyR
� s c C s� t j | j � } t j | j | � } | j } | j � | j � | j | j j
| � | j � � ~ | j t j
| j j
| � d S( N( R Rk R R t
OptionMenuR R R R R R R R R ( R R" t optmenuR$ ( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyR% � s
"c C s� | j t j t j | j | j d d �t j | j | j d d d � } | j | j j � d � | j
| d � | j
| d � | j � d S( Nt invalidt thingR@ R? t menut textvariable( R R R R Rm R Rl R R R t
assertTrueR ( R Rn ( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyRF � s !c s7 d
� d } t j � j � j | � � } t } xY t t � � � D]E } | d j | d � } � j | � | � | | k rC t } qC qC W� j
| � | j � d } t j � j � j | � � } d } d } xQ t r&| | d j
| d � } } | | k r Pn � j | | � | d 7} q� W� j | t � � � | j � | j � | d j d � � j | j j � � d � � j t j | d j d � � j | j j � � d � | j � g � � � � f d
� } t j � j � j d d | � �} | d j d � � s)� j d � n | j � d S( NR? R@ t cRq R/ t di i i����c s% � j | � d � � j t � d S( Ni ( R t appendR) ( t item( t itemsR t success( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyt cb_test s t commands Menu callback not invoked( R? R@ Rt ( R Rm R Rl t Falset ranget lent entrycgetR R) Rs R R( t entryconfigureR RI RJ t invokeR R R R R t fail( R t defaultRn t
found_defaultt iR/ t currt lastRz ( ( Rx R Ry s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyt test_menu� sJ
c C s; d } d } t j | j | j | | � } t j | j � } t j | j | | | � } | j � | j � | j � | j � | d j d � | d j d � | d j d d � } | d j d d � } | j
| | � | j | j j j
| � | d � | j | j j j
| � | d � | j � | j � d S(
NR? R@ Rt Rq i i i R ( R? R@ Rt ( R Rm R Rl R Rk RI RJ R� R R R R R R ( R Rx R� Rn t textvar2t optmenu2t optmenu_stringvar_namet optmenu2_stringvar_name( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyt test_unique_radiobuttons s*
( Rg Rh Rj R
R% RF R� R� ( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyRi � s
4t __main__( R t unittestt TkinterR R t test.test_supportR R R t test_ttk.supportR R t TestCaseR Ri t tests_guiRg ( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_ttk/test_extensions.pyt <module> s
� q test/test_ttk/support.py 0000644 00000007222 15032720555 0011461 0 ustar 00 import functools
import re
import unittest
import Tkinter as tkinter
class AbstractTkTest:
@classmethod
def setUpClass(cls):
cls._old_support_default_root = tkinter._support_default_root
destroy_default_root()
tkinter.NoDefaultRoot()
cls.root = tkinter.Tk()
cls.wantobjects = cls.root.wantobjects()
# De-maximize main window.
# Some window managers can maximize new windows.
cls.root.wm_state('normal')
try:
cls.root.wm_attributes('-zoomed', False)
except tkinter.TclError:
pass
@classmethod
def tearDownClass(cls):
cls.root.update_idletasks()
cls.root.destroy()
del cls.root
tkinter._default_root = None
tkinter._support_default_root = cls._old_support_default_root
def setUp(self):
self.root.deiconify()
def tearDown(self):
for w in self.root.winfo_children():
w.destroy()
self.root.withdraw()
def destroy_default_root():
if getattr(tkinter, '_default_root', None):
tkinter._default_root.update_idletasks()
tkinter._default_root.destroy()
tkinter._default_root = None
def simulate_mouse_click(widget, x, y):
"""Generate proper events to click at the x, y position (tries to act
like an X server)."""
widget.event_generate('<Enter>', x=0, y=0)
widget.event_generate('<Motion>', x=x, y=y)
widget.event_generate('<ButtonPress-1>', x=x, y=y)
widget.event_generate('<ButtonRelease-1>', x=x, y=y)
import _tkinter
tcl_version = tuple(map(int, _tkinter.TCL_VERSION.split('.')))
def requires_tcl(*version):
if len(version) <= 2:
return unittest.skipUnless(tcl_version >= version,
'requires Tcl version >= ' + '.'.join(map(str, version)))
def deco(test):
@functools.wraps(test)
def newtest(self):
if get_tk_patchlevel() < version:
self.skipTest('requires Tcl version >= ' +
'.'.join(map(str, version)))
test(self)
return newtest
return deco
_tk_patchlevel = None
def get_tk_patchlevel():
global _tk_patchlevel
if _tk_patchlevel is None:
tcl = tkinter.Tcl()
patchlevel = tcl.call('info', 'patchlevel')
m = re.match(r'(\d+)\.(\d+)([ab.])(\d+)$', patchlevel)
major, minor, releaselevel, serial = m.groups()
major, minor, serial = int(major), int(minor), int(serial)
releaselevel = {'a': 'alpha', 'b': 'beta', '.': 'final'}[releaselevel]
if releaselevel == 'final':
_tk_patchlevel = major, minor, serial, releaselevel, 0
else:
_tk_patchlevel = major, minor, 0, releaselevel, serial
return _tk_patchlevel
units = {
'c': 72 / 2.54, # centimeters
'i': 72, # inches
'm': 72 / 25.4, # millimeters
'p': 1, # points
}
def pixels_conv(value):
return float(value[:-1]) * units[value[-1:]]
def tcl_obj_eq(actual, expected):
if actual == expected:
return True
if isinstance(actual, _tkinter.Tcl_Obj):
if isinstance(expected, str):
return str(actual) == expected
if isinstance(actual, tuple):
if isinstance(expected, tuple):
return (len(actual) == len(expected) and
all(tcl_obj_eq(act, exp)
for act, exp in zip(actual, expected)))
return False
def widget_eq(actual, expected):
if actual == expected:
return True
if isinstance(actual, (str, tkinter.Widget)):
if isinstance(expected, (str, tkinter.Widget)):
return str(actual) == str(expected)
return False
test/test_ttk/test_functions.pyo 0000644 00000037242 15032720555 0013200 0 ustar 00 �
z fc @ s� d d l Z d d l Z d d l Z d f d � � YZ d e f d � � YZ d e f d � � YZ d e j f d � � YZ d
e j f d � � YZ e e f Z
e d k r� d d
l m
Z
e
e
� n d S( i����Nt MockTkAppc B s e Z d � Z d � Z RS( c C s t | t � r | S| j d � S( Nt :( t
isinstancet tuplet split( t selft arg( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt splitlist s c C s t S( N( t True( R ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt wantobjects
s ( t __name__t
__module__R R ( ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyR s t
MockTclObjc B s e Z d Z d � Z d � Z RS( t testc C s
| | _ d S( N( t val( R R ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt __init__ s c C s
t | j � S( N( t unicodeR ( R ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt __str__ s ( R
R t typenameR R ( ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyR s t
MockStateSpecc B s e Z d Z d � Z d � Z RS( t StateSpecc G s
| | _ d S( N( R ( R t args( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyR s c C s d j | j � S( Nt ( t joinR ( R ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyR ! s ( R
R R R R ( ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyR s t InternalFunctionsTestc B sb e Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z RS(
c s
� f d � } � j t j i � � | t j i d d 6d d d d g d 6� i d d 6d
d 6� | t j i dB d 6� i d d 6� | t j i i d d 6d 6� i i d d 6d 6� | t j i d d d d d
g d 6d d 6d d 6d d 6d d 6d d 6d d 6d t �i d d 6d! d" 6d d# 6d$ d% 6d& d' 6d( d) 6d* d+ 6� i t d, 6t d- 6} | j � } | t j | � i t d. 6t d/ 6� � j | | � | t j i dC d2 6� i d3 d4 6� | t j i dD d2 6� i d6 d4 6� | t j i dE d2 6� i d8 d4 6� | t j i dF d2 6� i d: d4 6� | t j i dG d2 6� i d= d4 6� | t j i dH d2 6� i d? d4 6� t t j | d@ d- �� d } � j | t | � d � t t j | d@ dI �� d } � j | t | � d � � j t j | d@ | j � �� d S(J Nc sf xE t d t | � d � D]+ } � j | j | | � | | d � q W| rb � j d | � n d S( Ni i i s result still got elements: %s( t ranget lent assertEqualt popt fail( t fmt_optst resultt i( R ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt
check_against( s )t bluet fgi i i i t paddings -fgs 1 2 3 4s -paddingt i R
s 1 2 {} 0s -tests as ist lefti����t 2mt test2t test3s abc deft test4s "abc"t test5s {}t test6s } -spam {t test7t scripts {1 -1 {} 2m 0}t 3s -test2s -test3s {abc def}s -test4s {"abc"}s -test5s \{\}s -test6s
\}\ -spam\ \{s -test7u αβγu áu -αβγu -ás one twot threet options {one two} threes -options one twos {one two} threet ones {} ones one} {twos one\}\ \{two threes "one"t twos {"one"} twos {one}s \{one\} twot ignoret b( i i R% i ( s one twoR0 ( s one twoR0 ( R% R2 ( s one} {twoR0 ( s "one"R3 ( s {one}R3 ( u áR5 ( t assertFalset ttkt _format_optdictR t Falset copyR R t keys( R R! t optst orig_optst amount_opts( ( R s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt test_format_optdict' sl & $
c C s i d! d" d# g d 6} t j | � } | j t | � t | j � � d � | j | d$ � | j t j | d t �d% � | j t j i g d 6� d& � i d' g d 6} t j | � } | j | d( � i d) g d 6} | j t j | � d* � i d+ g d 6} | j t t j | � i d g d d f g d 6} | j t t j | � i d d g g d 6} | j t j | � d, � xO d d t d t
� f D]5 } i | d f g d 6} | j t j | � d- � q�Wi d d 6} | j t t j | � | j t t j i d. g d 6� d S(/ NR5 t cR t dt othervalR% t singlet ai s -as {b c} val d otherval {} singleR. s {{b c} val d otherval {} single}s -2u áu vãlu
üñíćódèu -üñíćódèu á vãlu t hit opts -opts { } hii s valid valt 2t values 1 valuei s {} valuet invalid( R5 R@ R ( RA RB ( R% RC ( s -as {b c} val d otherval {} single( s -as {{b c} val d otherval {} single}( s -2R% ( u áu vãl( u -üñíćódèu á vãl( R% u RE ( s -opts { } hi( i i s valid val( s -opts 1 value( s -opts {} value( RI ( R7 t _format_mapdictR R R; R t assertRaisest TypeErrort NoneR9 t sett
IndexError( R R< R t validRI t stateval( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt test_format_mapdict s4 &
c
C s� | j t j d � d d f � | j t t j d � | j t j d t d � d d! f � | j t j d t d d" � d d# f � | j t j d t d d$ � d d% f � t j d t d d& d d
d d �} | j | d d
� | j t | d � d d
d d h � | j t j d t d d' d
d d g �d( � | j t
t j d � | j t j d t d d � d d) f � | j t j d t d d d* � d d+ f � | j t j d t d d d, d d
�d d- f � | j t j d t d d d d d d g f d d
�d. � | j t t j d � | j t j d t d � d d/ f � | j t j d t d d � d d0 f � | j t j d t d d � d1 � d S(2 Nt imageR
s test R% RD s test {} aR5 R@ s test {a b} ct xt yi s test a bi s -as -bRA i i s {test {a b c} d}s -x {2 3}t vsapis a b s a b {a b} cRF s a b a bs -opts {a b {a b} {1 2}}s -opt xt froms {a}( ( ( R% RD ( ( RD R5 R@ ( ( RD R5 ( RD R5 R@ RA ( s {test {a b c} d}s -x {2 3}( ( RD R5 R@ ( ( RD R5 ( s -optRT ( s {a b {a b} {1 2}}s -opt x( ( R5 ( s {a}R5 ( t
assertTrueR7 t _format_elemcreateRM RK RO R R9 RN R t
ValueError( R t res( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt test_format_elemcreate� s<
&
"
c C sp d d d � } d d d � } | j t j g � d d � t j d g d d �} | j | t j d g d d �� | j | d d � | j | � | � � xR t d � D]D } | j | | � | | � � | j | | | � | | | � � q� W| j t t j d d
g � | j t t j d � | j t t j d g � | j t t j d i i d d 6d
6f g � d S( Ni i c S st t j d i d d d g d 6d i d i d i d d
6f g d 6d d 6f g d 6f g d 6f g d
| d | �d S( NRD i i i t otherR5 R@ RA RF t nicet childrent somethingt indentt indent_sizei ( i i ( R7 t _format_layoutlist( Ra Rb ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt sample� s ;c s_ d � f d � } d | � | | � | d | � | d | � | d | � | | � | � f S( Ni c s d | � S( NR ( ( t amount( Ra ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt <lambda>� R% si %sa -other {1 2 3} -children {
%sb -children {
%sc -something {1 2} -children {
%sd -nice opt
%s}
%s}
%s}i i ( ( Ra Rb t spaces( ( Ra s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt sample_expected� s
R% RD Ra i t badt formatR5 t nameR_ ( RD N( RD R% ( RD R5 ( R R7 Rc RM R RK RZ RL t AttributeError( R Rd Rh t smallestR ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt test_format_layoutlist� s$
&
c C s� | j t j i i d d 6d d 6d d 6d 6� � | j t j i i d d 6d 6� d � i t d 6t d 6} | j t j i i | d 6d 6� � i d g d
6} | j t j i i | d 6d 6� � | j t t j i i d g d 6d 6� | j t j i i d d g d 6d 6� � i i d d d g d 6d 6} | j t j | � d � | d d j
i d d 6� | j t j | � d � t d � t d � g | d d d d <| j t j | � d � d S( Nt configuret maps element createRk t layouts ttk::style layout name {
null
}u αβγu áu vãlu
üñíćódèRS t state1t state2R t thingsA ttk::style element create thing image {name {state1 state2} val} i RF sH ttk::style element create thing image {name {state1 state2} val} -opt 30i R' i����sL ttk::style element create thing image {name {state1 state2} val} -opt {3 2m}( u áu vãl( Rr Rs R ( R6 R7 t _script_from_settingsRM R R R9 RX RK RO t appendR ( R t
configdictt mapdictRS ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt test_script_from_settings s4 # c C sf | j t j t d d � d f � d g � | j t j t d � d t d � g � d d d g � d S( NRD R5 R t 1i t 3mi ( RD R5 R ( R R7 t
_tclobj_to_pyR R ( R ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt test_tclobj_to_pyG s
!c s� � f d � } t d � t d � D� � } t | � } | | d d | � | | t d � d | � t d � t d � D� � } t | � } | | d d | � | d
t d � d d � d S( Nc s- � j t j | | f � | | f g � d S( N( R R7 t _list_from_statespec( t sspecRH t res_valuet states( R ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt test_itQ s c s s | ] } d | Vq d S( s state%dN( ( t .0R ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pys <genexpr>U s i R c s s | ] } d | Vq d S( s state%dN( ( R� R ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pys <genexpr>Z s i RD R5 R@ ( RD R5 R@ ( RD R5 R@ ( R R R R ( R R� t states_event statespect
states_odd( ( R s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt test_list_from_statespecP s c C st t � } | j t j | d � � | j t j | d � d i f g � d } | j t j | | � d i d d 6f g � | j t j | d d d f � d i g d 6f g � d d d d d d d d d f f } | j t j | | � d i d d 6d i d d
6d
i f g d 6f g d 6f g � | j t t j | d � | j t t j | d � | j t t j | d � d S( NRk s -optionRH R1 R` s -childrenR_ t niceonet otheronet childs -otheroptt
othervaluet otheroptt no_minus( ( Rk ( Rk s -optionRH ( ( R� ( Rk R� ( Rk R� RH ( R` s -children( R R6 R7 t _list_from_layouttupleR RK RZ ( R t tkt
sample_ltuplet ltuple( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt test_list_from_layouttuplea s.
$c C s� d d d � } t � } | | _ | j t j | i d � i d d 6� | j t j | i d � i d d 6� | j t j | i d d 6d � d � | j t j | i d d 6d � i d d 6� d S(
Nc S s* | d k r | S| d k r d S| | f S( Ns test val( RM ( R[ RF R ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt func� s
s -test:3R/ R
s -testi s x:ys test val( s -testi ( RM R t callR R7 t _val_or_dict( R R� R� ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt test_val_or_dict� s c C s} d
d d d
g d f d f } x- | D]% \ } } | j t j | � | � q% Wt j � d k ry | j t t j d � n d S( Ni t 09i RD u áÚs []RM t asciis á( i i ( R� i ( RD RD ( u áÚu áÚ( NRM ( RM R R7 t _convert_stringvalt syst getdefaultencodingRK t UnicodeDecodeError( R t testst origt expected( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt test_convert_stringval� s ( R
R R? RR R\ Rn Ry R} R� R� R� R� ( ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyR % s X ) = 7 + . t TclObjsToPyTestc B s# e Z d � Z d � Z d � Z RS( c C se i d d 6} | j t j | � i d d 6� t | d � | d <| j t j | � i d d 6� d S( Nu välúèRF ( R R7 t
tclobjs_to_pyR ( R t adict( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt test_unicode� s
c C s� i d d d d g d 6} | j t j | � i d d d d g d 6� d d d g | d <| j t j | � i d d d g d 6� t d d � d f | d <| j t j | � i d g d 6� | j t j i d
g d 6� i d
g d 6� d S(
Ni i i i RF t xmRD R5 u válũès y zRT ( RD R5 u válũè( R R7 R� R ( R R� ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt test_multivalues� s ,) c C s+ | j t j i d d 6� i d d 6� d S( Ns some textt text( R R7 R� ( R ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt test_nosplit� s ( R
R R� R� R� ( ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyR� � s t __main__( t run_unittest( R� t unittestR7 R t objectR R t TestCaseR R� t tests_noguiR
t test.test_supportR� ( ( ( s; /usr/lib64/python2.7/lib-tk/test/test_ttk/test_functions.pyt <module> s
� � test/test_ttk/test_extensions.py 0000644 00000026325 15032720555 0013210 0 ustar 00 import sys
import unittest
import Tkinter as tkinter
import ttk
from test.test_support import requires, run_unittest, swap_attr
from test_ttk.support import AbstractTkTest, destroy_default_root
requires('gui')
class LabeledScaleTest(AbstractTkTest, unittest.TestCase):
def tearDown(self):
self.root.update_idletasks()
super(LabeledScaleTest, self).tearDown()
def test_widget_destroy(self):
# automatically created variable
x = ttk.LabeledScale(self.root)
var = x._variable._name
x.destroy()
self.assertRaises(tkinter.TclError, x.tk.globalgetvar, var)
# manually created variable
myvar = tkinter.DoubleVar(self.root)
name = myvar._name
x = ttk.LabeledScale(self.root, variable=myvar)
x.destroy()
if self.wantobjects:
self.assertEqual(x.tk.globalgetvar(name), myvar.get())
else:
self.assertEqual(float(x.tk.globalgetvar(name)), myvar.get())
del myvar
self.assertRaises(tkinter.TclError, x.tk.globalgetvar, name)
# checking that the tracing callback is properly removed
myvar = tkinter.IntVar(self.root)
# LabeledScale will start tracing myvar
x = ttk.LabeledScale(self.root, variable=myvar)
x.destroy()
# Unless the tracing callback was removed, creating a new
# LabeledScale with the same var will cause an error now. This
# happens because the variable will be set to (possibly) a new
# value which causes the tracing callback to be called and then
# it tries calling instance attributes not yet defined.
ttk.LabeledScale(self.root, variable=myvar)
if hasattr(sys, 'last_type'):
self.assertNotEqual(sys.last_type, tkinter.TclError)
def test_initialization_no_master(self):
# no master passing
with swap_attr(tkinter, '_default_root', None), \
swap_attr(tkinter, '_support_default_root', True):
try:
x = ttk.LabeledScale()
self.assertIsNotNone(tkinter._default_root)
self.assertEqual(x.master, tkinter._default_root)
self.assertEqual(x.tk, tkinter._default_root.tk)
x.destroy()
finally:
destroy_default_root()
def test_initialization(self):
# master passing
master = tkinter.Frame(self.root)
x = ttk.LabeledScale(master)
self.assertEqual(x.master, master)
x.destroy()
# variable initialization/passing
passed_expected = (('0', 0), (0, 0), (10, 10),
(-1, -1), (sys.maxint + 1, sys.maxint + 1))
if self.wantobjects:
passed_expected += ((2.5, 2),)
for pair in passed_expected:
x = ttk.LabeledScale(self.root, from_=pair[0])
self.assertEqual(x.value, pair[1])
x.destroy()
x = ttk.LabeledScale(self.root, from_='2.5')
self.assertRaises(ValueError, x._variable.get)
x.destroy()
x = ttk.LabeledScale(self.root, from_=None)
self.assertRaises(ValueError, x._variable.get)
x.destroy()
# variable should have its default value set to the from_ value
myvar = tkinter.DoubleVar(self.root, value=20)
x = ttk.LabeledScale(self.root, variable=myvar)
self.assertEqual(x.value, 0)
x.destroy()
# check that it is really using a DoubleVar
x = ttk.LabeledScale(self.root, variable=myvar, from_=0.5)
self.assertEqual(x.value, 0.5)
self.assertEqual(x._variable._name, myvar._name)
x.destroy()
# widget positionment
def check_positions(scale, scale_pos, label, label_pos):
self.assertEqual(scale.pack_info()['side'], scale_pos)
self.assertEqual(label.place_info()['anchor'], label_pos)
x = ttk.LabeledScale(self.root, compound='top')
check_positions(x.scale, 'bottom', x.label, 'n')
x.destroy()
x = ttk.LabeledScale(self.root, compound='bottom')
check_positions(x.scale, 'top', x.label, 's')
x.destroy()
# invert default positions
x = ttk.LabeledScale(self.root, compound='unknown')
check_positions(x.scale, 'top', x.label, 's')
x.destroy()
x = ttk.LabeledScale(self.root) # take default positions
check_positions(x.scale, 'bottom', x.label, 'n')
x.destroy()
# extra, and invalid, kwargs
self.assertRaises(tkinter.TclError, ttk.LabeledScale, master, a='b')
def test_horizontal_range(self):
lscale = ttk.LabeledScale(self.root, from_=0, to=10)
lscale.pack()
lscale.wait_visibility()
lscale.update()
linfo_1 = lscale.label.place_info()
prev_xcoord = lscale.scale.coords()[0]
self.assertEqual(prev_xcoord, int(linfo_1['x']))
# change range to: from -5 to 5. This should change the x coord of
# the scale widget, since 0 is at the middle of the new
# range.
lscale.scale.configure(from_=-5, to=5)
# The following update is needed since the test doesn't use mainloop,
# at the same time this shouldn't affect test outcome
lscale.update()
curr_xcoord = lscale.scale.coords()[0]
self.assertNotEqual(prev_xcoord, curr_xcoord)
# the label widget should have been repositioned too
linfo_2 = lscale.label.place_info()
self.assertEqual(lscale.label['text'], 0 if self.wantobjects else '0')
self.assertEqual(curr_xcoord, int(linfo_2['x']))
# change the range back
lscale.scale.configure(from_=0, to=10)
self.assertNotEqual(prev_xcoord, curr_xcoord)
self.assertEqual(prev_xcoord, int(linfo_1['x']))
lscale.destroy()
def test_variable_change(self):
x = ttk.LabeledScale(self.root)
x.pack()
x.wait_visibility()
x.update()
curr_xcoord = x.scale.coords()[0]
newval = x.value + 1
x.value = newval
# The following update is needed since the test doesn't use mainloop,
# at the same time this shouldn't affect test outcome
x.update()
self.assertEqual(x.label['text'],
newval if self.wantobjects else str(newval))
self.assertGreater(x.scale.coords()[0], curr_xcoord)
self.assertEqual(x.scale.coords()[0],
int(x.label.place_info()['x']))
# value outside range
if self.wantobjects:
conv = lambda x: x
else:
conv = int
x.value = conv(x.scale['to']) + 1 # no changes shouldn't happen
x.update()
self.assertEqual(conv(x.label['text']), newval)
self.assertEqual(x.scale.coords()[0],
int(x.label.place_info()['x']))
x.destroy()
def test_resize(self):
x = ttk.LabeledScale(self.root)
x.pack(expand=True, fill='both')
x.wait_visibility()
x.update()
width, height = x.master.winfo_width(), x.master.winfo_height()
width_new, height_new = width * 2, height * 2
x.value = 3
x.update()
x.master.wm_geometry("%dx%d" % (width_new, height_new))
self.assertEqual(int(x.label.place_info()['x']),
x.scale.coords()[0])
# Reset geometry
x.master.wm_geometry("%dx%d" % (width, height))
x.destroy()
class OptionMenuTest(AbstractTkTest, unittest.TestCase):
def setUp(self):
super(OptionMenuTest, self).setUp()
self.textvar = tkinter.StringVar(self.root)
def tearDown(self):
del self.textvar
super(OptionMenuTest, self).tearDown()
def test_widget_destroy(self):
var = tkinter.StringVar(self.root)
optmenu = ttk.OptionMenu(self.root, var)
name = var._name
optmenu.update_idletasks()
optmenu.destroy()
self.assertEqual(optmenu.tk.globalgetvar(name), var.get())
del var
self.assertRaises(tkinter.TclError, optmenu.tk.globalgetvar, name)
def test_initialization(self):
self.assertRaises(tkinter.TclError,
ttk.OptionMenu, self.root, self.textvar, invalid='thing')
optmenu = ttk.OptionMenu(self.root, self.textvar, 'b', 'a', 'b')
self.assertEqual(optmenu._variable.get(), 'b')
self.assertTrue(optmenu['menu'])
self.assertTrue(optmenu['textvariable'])
optmenu.destroy()
def test_menu(self):
items = ('a', 'b', 'c')
default = 'a'
optmenu = ttk.OptionMenu(self.root, self.textvar, default, *items)
found_default = False
for i in range(len(items)):
value = optmenu['menu'].entrycget(i, 'value')
self.assertEqual(value, items[i])
if value == default:
found_default = True
self.assertTrue(found_default)
optmenu.destroy()
# default shouldn't be in menu if it is not part of values
default = 'd'
optmenu = ttk.OptionMenu(self.root, self.textvar, default, *items)
curr = None
i = 0
while True:
last, curr = curr, optmenu['menu'].entryconfigure(i, 'value')
if last == curr:
# no more menu entries
break
self.assertNotEqual(curr, default)
i += 1
self.assertEqual(i, len(items))
# check that variable is updated correctly
optmenu.pack()
optmenu.wait_visibility()
optmenu['menu'].invoke(0)
self.assertEqual(optmenu._variable.get(), items[0])
# changing to an invalid index shouldn't change the variable
self.assertRaises(tkinter.TclError, optmenu['menu'].invoke, -1)
self.assertEqual(optmenu._variable.get(), items[0])
optmenu.destroy()
# specifying a callback
success = []
def cb_test(item):
self.assertEqual(item, items[1])
success.append(True)
optmenu = ttk.OptionMenu(self.root, self.textvar, 'a', command=cb_test,
*items)
optmenu['menu'].invoke(1)
if not success:
self.fail("Menu callback not invoked")
optmenu.destroy()
def test_unique_radiobuttons(self):
# check that radiobuttons are unique across instances (bpo25684)
items = ('a', 'b', 'c')
default = 'a'
optmenu = ttk.OptionMenu(self.root, self.textvar, default, *items)
textvar2 = tkinter.StringVar(self.root)
optmenu2 = ttk.OptionMenu(self.root, textvar2, default, *items)
optmenu.pack()
optmenu.wait_visibility()
optmenu2.pack()
optmenu2.wait_visibility()
optmenu['menu'].invoke(1)
optmenu2['menu'].invoke(2)
optmenu_stringvar_name = optmenu['menu'].entrycget(0, 'variable')
optmenu2_stringvar_name = optmenu2['menu'].entrycget(0, 'variable')
self.assertNotEqual(optmenu_stringvar_name,
optmenu2_stringvar_name)
self.assertEqual(self.root.tk.globalgetvar(optmenu_stringvar_name),
items[1])
self.assertEqual(self.root.tk.globalgetvar(optmenu2_stringvar_name),
items[2])
optmenu.destroy()
optmenu2.destroy()
tests_gui = (LabeledScaleTest, OptionMenuTest)
if __name__ == "__main__":
run_unittest(*tests_gui)
test/test_ttk/support.pyo 0000644 00000012334 15032720555 0011640 0 ustar 00 �
z fc @ s� d d l Z d d l Z d d l Z d d l Z d d d � � YZ d � Z d � Z d d l Z e e
e e j j
d � � � Z d � Z d a d � Z i d d
d 6d d 6d d
d 6d d 6Z d � Z d � Z d � Z d S( i����Nt AbstractTkTestc B s8 e Z e d � � Z e d � � Z d � Z d � Z RS( c C s� t j | _ t � t j � t j � | _ | j j � | _ | j j d � y | j j d t
� Wn t j k
r{ n Xd S( Nt normals -zoomed( t tkintert _support_default_roott _old_support_default_roott destroy_default_roott
NoDefaultRoott Tkt roott wantobjectst wm_statet
wm_attributest Falset TclError( t cls( ( s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyt
setUpClass s
c C s9 | j j � | j j � | ` d t _ | j t _ d S( N( R t update_idletaskst destroyt NoneR t
_default_rootR R ( R ( ( s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyt
tearDownClass s
c C s | j j � d S( N( R t deiconify( t self( ( s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyt setUp s c C s5 x! | j j � D] } | j � q W| j j � d S( N( R t winfo_childrenR t withdraw( R t w( ( s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyt tearDown" s ( t __name__t
__module__t classmethodR R R R ( ( ( s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyR s c C s< t t d d � r8 t j j � t j j � d t _ n d S( NR ( t getattrR R R R R ( ( ( s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyR ' s
c C sh | j d d d d d �| j d d | d | �| j d d | d | �| j d d | d | �d S( sY Generate proper events to click at the x, y position (tries to act
like an X server).s <Enter>t xi t ys <Motion>s <ButtonPress-1>s <ButtonRelease-1>N( t event_generate( t widgetR R! ( ( s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyt simulate_mouse_click- s t .c sQ t � � d k r> t j t � k d d j t t � � � � S� f d � } | S( Ni s requires Tcl version >= R% c s% t j � � � � f d � � } | S( Nc sC t � � k r5 | j d d j t t � � � � n � | � d S( Ns requires Tcl version >= R% ( t get_tk_patchlevelt skipTestt joint mapt str( R ( t testt version( s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyt newtest? s ( t functoolst wraps( R+ R- ( R, ( R+ s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyt deco> s !( t lent unittestt
skipUnlesst tcl_versionR( R) R* ( R, R0 ( ( R, s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyt requires_tcl9 s
c C s� t d k r� t j � } | j d d � } t j d | � } | j � \ } } } } t | � t | � t | � } } } i d d 6d d 6d d 6| } | d k r� | | | | d
f a q� | | d
| | f a n t S( Nt infot
patchlevels (\d+)\.(\d+)([ab.])(\d+)$t alphat at betat bt finalR% i ( t _tk_patchlevelR R t Tclt callt ret matcht groupst int( t tclR7 t mt majort minort releaselevelt serial( ( s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyR& I s & iH gR� ��Q@t ct igffffff9@RE i t pc C s t | d � t | d S( Ni����( t floatt units( t value( ( s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyt pixels_conv_ s c C s� | | k r t St | t j � rD t | t � rD t | � | k Sn t | t � r� t | t � r� t | � t | � k o� t d � t | | � D� � Sn t S( Nc s s$ | ] \ } } t | | � Vq d S( N( t
tcl_obj_eq( t .0t actt exp( ( s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pys <genexpr>k s (
t Truet
isinstancet _tkintert Tcl_ObjR* t tupleR1 t allt zipR ( t actualt expected( ( s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyRQ b s c C s] | | k r t St | t t j f � rY t | t t j f � rY t | � t | � k Sn t S( N( RU RV R* R t WidgetR ( R\ R] ( ( s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyt widget_eqo s ( ( R. R@ R2 t TkinterR R R R$ RW RY R) RC t TCL_VERSIONt splitR4 R5 R R= R& RN RP RQ R_ ( ( ( s4 /usr/lib64/python2.7/lib-tk/test/test_ttk/support.pyt <module> s& ! !
test/test_ttk/test_style.py 0000644 00000005542 15032720555 0012147 0 ustar 00 import unittest
import Tkinter as tkinter
import ttk
from test.test_support import requires, run_unittest
from test_ttk.support import AbstractTkTest
requires('gui')
class StyleTest(AbstractTkTest, unittest.TestCase):
def setUp(self):
super(StyleTest, self).setUp()
self.style = ttk.Style(self.root)
def test_configure(self):
style = self.style
style.configure('TButton', background='yellow')
self.assertEqual(style.configure('TButton', 'background'),
'yellow')
self.assertIsInstance(style.configure('TButton'), dict)
def test_map(self):
style = self.style
style.map('TButton', background=[('active', 'background', 'blue')])
self.assertEqual(style.map('TButton', 'background'),
[('active', 'background', 'blue')] if self.wantobjects else
[('active background', 'blue')])
self.assertIsInstance(style.map('TButton'), dict)
def test_lookup(self):
style = self.style
style.configure('TButton', background='yellow')
style.map('TButton', background=[('active', 'background', 'blue')])
self.assertEqual(style.lookup('TButton', 'background'), 'yellow')
self.assertEqual(style.lookup('TButton', 'background',
['active', 'background']), 'blue')
self.assertEqual(style.lookup('TButton', 'optionnotdefined',
default='iknewit'), 'iknewit')
def test_layout(self):
style = self.style
self.assertRaises(tkinter.TclError, style.layout, 'NotALayout')
tv_style = style.layout('Treeview')
# "erase" Treeview layout
style.layout('Treeview', '')
self.assertEqual(style.layout('Treeview'),
[('null', {'sticky': 'nswe'})]
)
# restore layout
style.layout('Treeview', tv_style)
self.assertEqual(style.layout('Treeview'), tv_style)
# should return a list
self.assertIsInstance(style.layout('TButton'), list)
# correct layout, but "option" doesn't exist as option
self.assertRaises(tkinter.TclError, style.layout, 'Treeview',
[('name', {'option': 'inexistent'})])
def test_theme_use(self):
self.assertRaises(tkinter.TclError, self.style.theme_use,
'nonexistingname')
curr_theme = self.style.theme_use()
new_theme = None
for theme in self.style.theme_names():
if theme != curr_theme:
new_theme = theme
self.style.theme_use(theme)
break
else:
# just one theme available, can't go on with tests
return
self.assertFalse(curr_theme == new_theme)
self.assertFalse(new_theme != self.style.theme_use())
self.style.theme_use(curr_theme)
tests_gui = (StyleTest, )
if __name__ == "__main__":
run_unittest(*tests_gui)
test/test_ttk/test_widgets.pyo 0000644 00000170617 15032720555 0012642 0 ustar 00 �
z fc @ sU d d l Z d d l Z d d l m Z d d l Z d d l m Z m Z m Z m Z d d l
Z
d d l m Z d d l
m Z m Z m Z m Z d d l m Z m Z m Z m Z m Z m Z m Z m Z e d � d e f d � � YZ d
e e j f d � � YZ d e e f d
� � YZ e e � d e e j f d � � Y� Z e e � d e e j f d � � Y� Z d e f d � � YZ! e e � d e! e j f d � � Y� Z" e e � d e! e j f d � � Y� Z# e e � d e! e j f d � � Y� Z$ e e e � d e e j f d � � Y� Z% e e e � d e% e j f d � � Y� Z& e e e � d e e j f d � � Y� Z' e e � d e! e j f d! � � Y� Z( d" e! e j f d# � � YZ) e e � d$ e e j f d% � � Y� Z* e e � d& e e j f d' � � Y� Z+ e j, e
j- d( k d) � e e � d* e e j f d+ � � Y� � Z. e e e � d, e e j f d- � � Y� Z/ e e � d. e e j f d/ � � Y� Z0 e e � d0 e e j f d1 � � Y� Z1 e e � d2 e e j f d3 � � Y� Z2 e# e$ e& e% e e e" e) e/ e' e+ e( e* e. e1 e2 e0 e f Z3 e4 d4 k rQe e3 � n d S(5 i����N( t TclError( t requirest run_unittestt have_unicodet u( t
MockTclObj( t AbstractTkTestt tcl_versiont get_tk_patchlevelt simulate_mouse_click( t add_standard_optionst noconvt noconv_metht AbstractWidgetTestt StandardOptionsTestst IntegerSizeTestst PixelSizeTestst setUpModulet guit StandardTtkOptionsTestsc B s# e Z d � Z d � Z d � Z RS( c C s� | j � } | j | d d � d } t � d
k r> d } n | j | d d
d | �| j d d
� } | j | d d
� d S( Nt classt s" attempt to change read-only optioni i i t betai s" Attempt to change read-only optiont Foot errmsgt class_( i i i R i ( t createt assertEqualR t checkInvalidParam( t selft widgetR t widget2( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt
test_class s c C s� | j � } | j | d d d d �| j | d d d d �| j | d d d d �| j | d d d d �| j | d d d d �| j | d d � | j | d d d d �d S( Nt paddingi t expectedt 0i t 5i t 6i t 7i t 8t 5pt 6pt 7pt 8pR ( R# ( R$ ( i i ( R$ R% ( i i i ( R$ R% R& ( i i i i ( R$ R% R& R' ( R( R) R* R+ ( ( R t
checkParam( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_padding s c C s� | j � } | j | d d � d } t | d � rQ d t | d � j � } n | j | d d d | �| j d d � } | j | d d � d S(
Nt styleR s Layout Foo not foundt default_orients Layout %s.Foo not foundR R R R ( R R t hasattrt getattrt titleR ( R R R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt
test_style+ s ( t __name__t
__module__R R- R3 ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR s
t
WidgetTestc B s) e Z d Z d � Z d � Z d � Z RS( s, Tests methods available in every ttk widget.c C sR t t | � j � t j | j d d d d �| _ | j j � | j j � d S( Nt widthi t textt Text( t superR6 t setUpt ttkt Buttont rootR t packt wait_visibility( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR; = s !
c C s� | j j � | j | j j | j j � d | j j � d � d � | j | j j d d � d � | j t j | j j d d � | j t j | j j d d � | j t j | j j d d � d S( Ni t labeli����R i (
R t update_idletasksR t identifyt winfo_widtht winfo_heightt assertRaisest tkinterR t None( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt
test_identifyD s
c C s� | j | j j � d
� | j | j j d g � t � | j | j j d g � d � | j | j j d g � d � | j | j j d d g � d
� | j | j j d d g � d � | j | j j d d g � d � d � } | j | j j d g | d i d d 6� d i d d 6f � | j j � } | j t j | j j d g � | j t j | j j d d g � | j | | j j � � | j j d d g � | j | j j � d � d S( Ns !disabledt disabledt actives !activec [ s
| | f S( N( ( t arg1t kw( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_cba s t hit theret msgt badstate( ( s !disabled( ( s !activeRJ ( ( ( RK ( R R t statet instatet TrueRF RG R ( R RN t currstate( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_widget_stateQ s( ""
( R4 R5 t __doc__R; RI RW ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR6 : s
t AbstractToplevelTestc B s e Z e Z RS( ( R4 R5 R t _conv_pixels( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyRY u s t FrameTestc B s e Z d
Z d � Z RS( t borderwidthR t cursort heightR! t reliefR. t takefocusR7 c K s t j | j | � S( N( R< t FrameR> ( R t kwargs( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR � s ( R\ R R] R^ R! R_ R. R` R7 ( R4 R5 t OPTIONSR ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR[ y s t LabelFrameTestc
B s) e Z d Z d
� Z d � Z d � Z RS( R\ R R] R^ t labelanchort labelwidgetR! R_ R. R` R8 t underlineR7 c K s t j | j | � S( N( R< t
LabelFrameR> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR � s c C s] | j � } | j | d d d d d d d d d d
d d d
d d �| j | d d � d S( NRe t et ent est nt net nwt st set swt wt wnt wsR s! Bad label anchor specification {}t center( R t checkEnumParamR ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_labelanchor� s
'c C sQ | j � } t j | j d d d d �} | j | d | d d �| j � d S( NR8 t Muppt namet fooRf R" s .foo( R R< t LabelR> R, t destroy( R R RA ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_labelwidget� s (
R\ R R] R^ Re Rf R! R_ R. R` R8 Rg R7 ( R4 R5 Rc R Rw R} ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyRd � s t AbstractLabelTestc B s, e Z d � Z d � Z d � Z d � Z RS( c C s� t j d | j d d � } t j d | j d d � } | j | | | d d �| j | | d d d �| j | | | f d d
�| j | | | d | f d d �| j | | d d d �| j | | d d d
�d S( Nt masterRy t image1t image2R" RK s image1 active image2t spamR s image "spam" doesn't exist( R� ( R� ( R� ( R� RK R� ( R� RK R� ( RG t
PhotoImageR> R, R ( R R Ry t imageR� ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt checkImageParam� s c C s8 | j � } | j | d d d d d d d d d �
d S(
Nt compoundt noneR8 R� Ru t topt bottomt leftt right( R Rv ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt
test_compound� s c C s) | j � } | j | d d d d � d S( NRS RK RJ t normal( R t checkParams( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt
test_state� s c C s) | j � } | j | d d d d � d S( NR7 i� in���i ( R R� ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt
test_width� s ( R4 R5 R� R� R� R� ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR~ � s
t LabelTestc B s& e Z d Z e Z d � Z d � Z RS( t anchort
backgroundR\ R R� R] t fontt
foregroundR� t justifyR! R_ RS R. R` R8 t textvariableRg R7 t
wraplengthc K s t j | j | � S( N( R< R{ R> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR � s c C s# | j � } | j | d d � d S( NR� s3 -Adobe-Helvetica-Medium-R-Normal--*-120-*-*-*-*-*-*( R R, ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_font� s ( R� R� R\ R R� R] R� R� R� R� R! R_ RS R. R` R8 R� Rg R7 R� ( R4 R5 Rc R RZ R R� ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � s t
ButtonTestc B s) e Z d Z d � Z d � Z d � Z RS( R t commandR� R] t defaultR� R! RS R. R` R8 R� Rg R7 c K s t j | j | � S( N( R< R= R> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR � s c C s) | j � } | j | d d d d � d S( NR� R� RK RJ ( R Rv ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_default� s c sB g � t j | j d � f d � �} | j � | j � � d S( NR� c s
� j d � S( Ni ( t append( ( t success( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt <lambda>� R ( R< R= R> t invoket
assertTrue( R t btn( ( R� s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_invoke� s !
( R R� R� R] R� R� R! RS R. R` R8 R� Rg R7 ( R4 R5 Rc R R� R� ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � s t CheckbuttonTestc B s2 e Z d Z d � Z d � Z d � Z d � Z RS( R R� R� R] R� t offvaluet onvalueR! RS R. R` R8 R� Rg t variableR7 c K s t j | j | � S( N( R< t CheckbuttonR> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR � s c C s, | j � } | j | d d d d d � d S( NR� i gffffff@R s
any string( R R� ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt
test_offvalue� s c C s, | j � } | j | d d d d d � d S( NR� i gffffff@R s
any string( R R� ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_onvalue� s c s g � � f d � } t j | j d | �} | j | j � d
� | j t j | j j | d � | j
� } | j | d � | j | d | j j | d � � | j � � d | d <| j
� } | j t
| � � | j t � � d � | j | d | j j | d � � d S( Nc s � j d � d S( Ni s cb test called( R� ( ( R� ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt cb_test s
R� t alternateR� s cb test calledR� R i R� ( R� ( R< R� R> R RS RF RG R t tkt globalgetvarR� R� t assertFalset strt assertLessEqualt len( R R� t cbtnt res( ( R� s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � s"
( R R� R� R] R� R� R� R! RS R. R` R8 R� Rg R� R7 ( R4 R5 Rc R R� R� R� ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � s t EntryTestc B sz e Z d Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d � Z d � Z
d � Z RS( R� R R] t exportselectionR� R� t invalidcommandR� t showRS R. R` R� t validatet validatecommandR7 t xscrollcommandc C s& t t | � j � | j � | _ d S( N( R: R� R; R t entry( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR; # s c K s t j | j | � S( N( R< t EntryR> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR ' s c C s | j � } | j | d � d S( NR� ( R t checkCommandParam( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_invalidcommand* s c C sI | j � } | j | d d � | j | d d � | j | d d � d S( NR� t *R t ( R R, ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_show. s c C s) | j � } | j | d d d d � d S( NRS RJ R� t readonly( R R� ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� 4 s c C s2 | j � } | j | d d d d d d d � d S( NR� t allt keyt focust focusint focusoutR� ( R Rv ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt
test_validate9 s c C s | j � } | j | d � d S( NR� ( R R� ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_validatecommand> s c C sU | j | j j d � � | j t j | j j d � | j t j | j j d � d S( Ni t noindex( t assertIsBoundingBoxR� t bboxRF RG R RH ( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_bboxC s c C s� | j j � | j j � | j j � t j d k rX | j | j j d d � d � n | j | j j d d � d � | j | j j d d � d � | j t
j | j j d d � | j t
j | j j d d � | j t
j | j j d d � d S( Nt darwini t textareas Combobox.buttoni����R ( R� s Combobox.button(
R� R? R@ RB t syst platformt assertInRC R RF RG R RH ( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyRI I s
c s# g � � f d � } d | j d <d � | j d <| | j d <| j j � | j � � d | j d <| j j � | j t � � d � | | j d <d � | j d <| j j � | j t � � d � d | j d <| j j � | j t � � d � t | j d <| j t j | j j � d S(
Nc s
� j t � S( N( R� RU ( ( R� ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� ] R R� R� c S s t S( N( t False( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� ` R R� R� R i c S s t S( N( RU ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� k R ( R� R� R� R R� RU RF RG R ( R t test_invalid( ( R� s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_validation_options[ s&
c s� g � � f d � } d | j d <| j j | � d f | j d <| j j d d � | j j d d � | j � t t g � | j | j j � d � d S( Nc sD d | j � k o d k n s3 � j t � t S� j t � t S( Nt at z( t lowerR� R� RU ( t to_insert( t
validation( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� y s
"
R� R� s %SR� t endi R� ( R� t registert insertR R� RU t get( R R� ( ( R� s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_validationw s
c C s$ d � } | j j | � d f | j d <| j j d d � | j | j j � t � | j | j j � d � | j j d d � | j | j j � d � | j j d d � | j | j j � t � | j | j j � d � | j j d
� | j | j j � t � | j | j j � d
� d S( Nc S s; x4 | D], } d | j � k o* d k n s t Sq Wt S( NR� R� ( R� R� RU ( t contentt letter( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � s
"s %PR� R� t avocadoi R t a1bt invalidi ( ( R� ( (
R� R� R� R R� RU RS t deleteR� R� ( R R� ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_revalidation� s ( R� R R] R� R� R� R� R� R� RS R. R` R� R� R� R7 R� ( R4 R5 Rc R; R R� R� R� R� R� R� RI R� R� R� ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� s" t ComboboxTestc B sM e Z d Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z RS( R� R R] R� R� R� R^ R� R� t postcommandR� RS R. R` R� R� R� t valuesR7 R� c C s& t t | � j � | j � | _ d S( N( R: R� R; R t combo( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR; � s c K s t j | j | � S( N( R< t ComboboxR> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR � s c C s2 | j � } | j | d d d d d d d � d S( NR^ id g�����LY@gfffff�Y@i����i t 1i( R R� ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_height� s c C s` | j j � } | j j d d | d d d �| j j d d | d d d �| j j � d S( Ns <ButtonPress-1>t xi t ys <ButtonRelease-1>( R� RD t event_generateRB ( R R7 ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt _show_drop_down_listbox� s c s� g � d g | j d <| j j d � f d � � | j j � | j j � | j j � } | j � | j j � | j j d � | j j � | j � � d S( Ni R� s <<ComboboxSelected>>c s
� j t � S( N( R� RU ( t evt( R� ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � R s <Return>( R� t bindR? R@ RE R� t updateR� R� ( R R^ ( ( R� s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_virtual_event� s
c s~ g � � f d � | j d <| j j � | j j � | j � | j � � d | j d <| j � | j t � � d � d S( Nc s
� j t � S( N( R� RU ( ( R� ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � R R� R i ( R� R? R@ R� R� R R� ( R ( ( R� s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_postcommand� s
c s� � f d � } � j � j d t d# k r1 d$ n d � | d d � � j � j d d d d% �� j � j d d& � � j � j d d' � � j � j d t d( k r� d) n d � d d d g � j d <� j j d � | d d � � j j d � | d d � � j j d � | d d � � j j d � d* � j d <| d d � � j j d d d d g � � j � j d � j r�d+ n d � d d d g � j d <� j � j d � j r�d, n d � d d d g � j d <� j � j d � j r�d- n d! � � j t j
� j j t � j d � � � j t j
� j j d � t j
� j d d d d g �} � j | d � j r�d. n d" � | j � d S(/ Nc s6 � j � j j � | � � j � j j � | � d S( N( R R� R� t current( t getvalt currval( R ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt check_get_current� s R� i i R i����s mon tue wed thurR" t mont tuet wedt thuri* g ��Q� @s
any stringR� i t ci i t di t 1t 2s 1 {} 2s a bs a bs a
bs {a b} {a b} {a
b}s a\tbs "a"s } {s a\\tb {"a"} \}\ \{s 1 2 {}( i i ( ( R� R� R� R ( R� R� R� R ( i* g ��Q� @R s
any string( i i ( ( i i R i ( R R R ( s a bs a bs a
b( s a\tbs "a"s } {( R R R ( R R� R R, t setR� t configuret wantobjectsRF RG R R� R< R� R> R| ( R R� t combo2( ( R s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_values� sL
(
!
( R� R R] R� R� R� R^ R� R� R� R� RS R. R` R� R� R� R� R7 R� (
R4 R5 Rc R; R R� R� R� R� R ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � s t PanedWindowTestc B sV e Z d Z d � Z d � Z d � Z d
� Z d � Z d � Z d
� Z d � Z
RS( R R] R^ t orientR. R` R7 c C s& t t | � j � | j � | _ d S( N( R: R
R; R t paned( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR; & s c K s t j | j | � S( N( R< t PanedWindowR> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR * s c C s� | j � } | j t | d � d � d } t � d k rD d } n | j | d d
d | �| j d d
� } | j t | d � d
� d S(
NR t verticals" attempt to change read-only optioni i i R i s" Attempt to change read-only optiont
horizontalR ( i i i R i ( R R R� R R ( R R R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_orient- s c C sz t j | j � } t j | � } | j t j | j j | � | j � | j � t j | j � } t j | � } | j t j | j j | � | j � | j � t j | j � } | j j | � | j t j | j j | � t j | j � } | j j | � | j | j j
d � | j j
d � � | j t j | j j
d � | j � | j � | j t j | j j
d � d S( Ni i i ( R< R{ R RF RG R t addR| R> R t pane( R RA t childt
good_childt other_child( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_add8 s(
(
c C s� | j t j | j j d � | j t j | j j d � | j j t j | j � � | j j d � | j t j | j j d � d S( Ni (
RF RG R R t forgetRH R R< R{ R> ( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_forgetT s
c C s | j t j | j j d d � | j t j | j j d d � | j t j | j j d d � t j | j � } t j | j � } t j | j � } | j t j | j j d | � | j j d | � | j j d | � | j | j j
� t | � t | � f � | j j d | � | j | j j
� t | � t | � f � | j j d | � | j | j j
� t | � t | � t | � f � | j j
� } | j j d | � | j | | j j
� � | j j | | � | j | j j
� t | � t | � t | � f � d S( Ni R� ( RF RG R R R� RH R< R{ R> R t panesR� ( R R t child2t child3R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_insert] s* ++"c C s
| j t j | j j d � t j | j � } | j j | � | j | j j d � t
� | j | j j d d d �| j
r� d n d � | j | j j d d � | j
r� d n d � | j | j j d � | j j t | � � � | j t j | j j d d d �d S( Ni t weightR# t badoptiont somevalue( RF RG R R R R< R{ R> R t assertIsInstancet dictR RH R R� ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_pane� s .c C si | j t j | j j d � | j t j | j j d � | j t j | j j d � t j | j d d �} | j j | d d �| j t j | j j d � t j | j d d �} | j j | � | j t j | j j d � | j j d t
d d
� | j j � | j j d � } | j j d d � | j | | j j d � � | j
| j j d � t � d S( NR i R8 R� R i t bt expandt fillt bothi� ( RF RG R R t sashposRH R< R{ R R? RU R@ t assertNotEqualR t int( R R R t curr_pos( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_sashpos� s
( R R] R^ R R. R` R7 ( R4 R5 Rc R; R R R R R R" R+ ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR
s # t RadiobuttonTestc B s) e Z d Z d � Z d � Z d � Z RS( R R� R� R] R� R! RS R. R` R8 R� Rg t valueR� R7 c K s t j | j | � S( N( R< t RadiobuttonR> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR � s c C s, | j � } | j | d d d d d � d S( NR- i gffffff@R s
any string( R R� ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt
test_value� s c s� g � � f d � } t j | j � } t j | j d | d | d d �} t j | j d | d | d d �} | j r� d � } n t } | j � } | j | d � | j | | d � | j � � | j | j � | | j
j | d � � � | j � � d | d <| j � } | j t
| � d � | j t � � d � | j | | d � | j � � | j | j � | | j
j | d � � � | j t
| d � t
| d � � d S(
Nc s � j d � d S( Ni s cb test called( R� ( ( R� ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � s
R� R� R- i i c S s | S( N( ( R� ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � R s cb test calledR ( RG t IntVarR> R< R. R R) R� R R� R� R� R� R� R� R� ( R R� t myvarR� t cbtn2t convR� ( ( R� s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � s0
( R R� R� R] R� R! RS R. R` R8 R� Rg R- R� R7 ( R4 R5 Rc R R/ R� ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR, � s t MenubuttonTestc B s) e Z d Z d � Z d � Z d � Z RS( R R� R] t directionR� t menuR! RS R. R` R8 R� Rg R7 c K s t j | j | � S( N( R< t
MenubuttonR> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR � s c C s/ | j � } | j | d d d d d d � d S( NR5 t abovet belowR� R� t flush( R Rv ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_direction� s c C sH | j � } t j | d d �} | j | d | d t �| j � d S( NRy R6 R3 ( R RG t MenuR, R� R| ( R R R6 ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_menu� s ( R R� R] R5 R� R6 R! RS R. R` R8 R� Rg R7 ( R4 R5 Rc R R; R= ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR4 � s t ScaleTestc B sk e Z d Z e Z d Z d � Z d
� Z d � Z d � Z d � Z
d � Z d � Z d � Z
d � Z RS( R R� R] t fromt lengthR R. R` t toR- R� R c C s@ t t | � j � | j � | _ | j j � | j j � d S( N( R: R> R; R t scaleR? R� ( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR; � s
c K s t j | j | � S( N( R< t ScaleR> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR s c C s/ | j � } | j | d d d d d t �d S( NR? id g������-@g333333.@R3 ( R t checkFloatParamR� ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_from s c C s, | j � } | j | d d d d d � d S( NR@ i� gffffff`@g33333�`@t 5i( R t checkPixelsParam( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_length s c C s2 | j � } | j | d d d d d d t �d S( NRA i, g������-@g333333.@i����R3 ( R RD R� ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_to s c C s2 | j � } | j | d d d d d d t �d S( NR- i, g������-@g333333.@i����R3 ( R RD R� ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR/ s c s� d d d g � | j j d � f d � � } d | j d <d | j d <d | j d <| j � � d d d g � | j j d d d d
� | j j d d d d � | j j d d � | j � � d S(
Ni s <<RangeChanged>>c s
� j � S( N( t pop( R� ( t failure( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� R i
R? t from_i RA i i i i����( RB R� R� R ( R t funcid( ( RK s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_custom_event s
c C s | j r d � } n t } | j j � } | j | j j | d � | j d � | j | | j j d d � � | | j d � � | j | j j � | j d � d | j d <| j | j j � | j d � | j t j | j j d d � | j t j | j j d d � d S( Nc S s | S( N( ( R� ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� ( R i RA R? R- i R ( R t floatRB RD R R� RF RG R ( R R3 t scale_width( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_get& s &2
c C s� | j r d � } n t } | | j d � } | d } | j j | � | j | | j j � � | � | | j d � } | j j | d � | j | | j j � � | � t j | j � } | | j d <| j | d � | j | | j j � � | j � � | j | | j j � � | d � ~ | d | j d <| j | | j j � � | d � | j | | j j � � | | j d � � | j | | j j d d � � | � | j | | j j | j j � d � � | � | j
t j | j j d � d S(
Nc S s | S( N( ( R� ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� : R RA i
R? i R� i R- i (
R RO RB R R R� RG t DoubleVarR> RD RF R RH ( R R3 t maxt new_maxt mint var( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_set8 s,
%##,%.( R R� R] R? R@ R R. R` RA R- R� ( R4 R5 Rc R RZ R/ R; R RE RH RI R/ RN RQ RW ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR> � s t ProgressbarTestc B sP e Z d Z e Z d Z d � Z d
� Z d � Z d � Z d � Z
d � Z RS( R R] R R@ t modet maximumt phaseR. R` R- R� R c K s t j | j | � S( N( R< t ProgressbarR> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR f s c C s) | j � } | j | d d d d � d S( NR@ gfffffY@g�����YL@t 2i( R RG ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyRH i s c C s2 | j � } | j | d d d d d d t �d S( NRZ gfffff�b@g�����lS@i i����R3 ( R RD R� ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_maximumm s c C s& | j � } | j | d d d � d S( NRY t determinatet
indeterminate( R Rv ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_modeq s c C s d S( N( ( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt
test_phaseu s c C s2 | j � } | j | d d d d d d t �d S( NR- gfffff�b@g�����lS@i i����R3 ( R RD R� ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR/ y s ( R R] R R@ RY RZ R[ R. R` R- R� ( R4 R5 Rc R RZ R/ R RH R^ Ra Rb R/ ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyRX \ s R� s" ttk.Scrollbar is special on MacOSXt
ScrollbarTestc B s e Z d Z d Z d � Z RS( R R� R] R R. R` R c K s t j | j | � S( N( R< t ScrollbarR> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR � s ( R R� R] R R. R` ( R4 R5 Rc R/ R ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyRc s t NotebookTestc B sq e Z d Z d � Z d � Z d � Z d
� Z d � Z d � Z d
� Z d � Z
d � Z d � Z d � Z
RS( R R] R^ R! R. R` R7 c C s� t t | � j � | j d d � | _ t j | j � | _ t j | j � | _ | j j
| j d d �| j j
| j d d �d S( NR! i R8 R� R# ( R: Re R; R t nbR< R{ R> t child1R R ( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR; � s c K s t j | j | � S( N( R< t NotebookR> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR � s c C s� | j j d � | j j | j � | j t j | j j | j � | j | j j
d � d � | j j | j � | j | j j
d � d � | j j | j � | j
| j j d � � | j j | j d d �| j j � | j j � t j d k rd } n d } | j | j j | � | j j d � � xh t d
d d
� D]G } y* | j j d | d d �d k rtPn WqEt j k
r�qEXqEW| j d
� d S( Ni R� i R� R8 R� R� s @20,5s @5,5i id s @%d, 5s Tab with text 'a' not found( Rf R t hideR RF RG R t tabRg R t indexR t selectR� R? R@ R� R� t rangeRH t fail( R t tb_idxt i( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_tab_identifiers� s,
("c C s� | j t j | j j d � | j t j | j j d � | j t j | j j d � | j t j | j j d � | j t j | j j t j | j � d d �| j j
� } | j j | j � | j j | j � | j | j j
� | � t j | j � } | j j | d d �| j j
� } | j j
d � } | j j
| j � } | j j | j � | j j | j � | j | j j
� | � | j | j j
| j � | � | j t | j � | j j
� | � | j | j j
d � | d � d S( Ni����RO t unknownt optionR8 R R� i ( RF RG R Rf Ri RH R R< R{ R> t tabsRg R Rk R R� ( R Rt R t currt child2_index( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_add_and_hidden� s* ' &c C s+ | j t j | j j d � | j t j | j j d � | j t j | j j d � | j j � } | j j | j � } | j j | j � | j t
| j � | j j � � | j t | � d t | j j � � � | j j
| j � | j | j j | j � d � | j | | j j | j � � d S( Ni����RO i ( RF RG R Rf R RH Rt Rk Rg t assertNotInR� R R� R R( ( R Rt t child1_index( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR � s ") c C s� | j t j | j j d � | j t j | j j d � | j | j j d � t � | j | j j | j � d � | j | j j | j
� d � | j | j j d � d � d S( Ni����R� i i i ( RF RG R Rf Rk RH R R) R Rg R ( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt
test_index� s c C s� | j j � } | j j d | d � | j | j j � | d | d f � | j j | j | j � | j | j j � | � | j j d | j � | j | j j � | d | d f � | j j d d � | j | j j � | � | j t j | j j d | d � | j t j | j j d | d � t j
| j � } | j j d | � | j | j j � | d t | � | d f � | j j
| � | j | j j � | � | j j | j | � | j | j j � t | � f | � | j j
| � | j t j | j j d | � | j t j | j j d | � | j t j | j j d d � | j t j | j j d d � | j t j | j j d d � d S( Ni i R� i i����( Rf Rt R� R Rg R RF RG R R< R{ R> R� R RH ( R Rt R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR � s0 ''##0& c s� | j j � | j j � g � g � | j j d � f d � � | j j d � f d � � | j | j j � t | j � � | j j | j � | j � � | j | j j � t | j � � | j j
� | j � � d S( Ns <Unmap>c s
� j t � S( N( R� RU ( R� ( R� ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� R s <<NotebookTabChanged>>c s
� j t � S( N( R� RU ( R� ( t tab_changed( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� R ( Rf R? R@ Rg R� R Rl R� R R� R� ( R ( ( R� R{ s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_select s
"
"
c C s | j t j | j j d � | j t j | j j d � | j t j | j j d � | j | j j | j � t � | j | j j | j d d �d � | j | j j | j d � d � | j j | j d d �| j | j j | j d d �d � | j | j j | j d � d � d S( Ni����t notabR8 R� t abc(
RF RG R Rf Rj RH R Rg R! R ( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_tab( s %"%c C sb | j t | j j � � d � | j j | j � | j j | j � | j | j j � d � d S( Ni ( ( R R� Rf Rt R Rg R ( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_tabs6 s c C s� | j j � | j j � | j j d � t | j d d � | j j � | j j d � | j | j j � t | j � � | j j � | j j d � | j | j j � t | j
� � | j j � | j j d � | j | j j � t | j � � | j j | j
d d d d �| j j � | j j � t | j d d � t
j d k rh| j j d � n | j j d
� | j | j j � t | j
� � d S( Ni i s
<Control-Tab>s <Shift-Control-Tab>R8 R� Rg R� s
<Option-a>s <Alt-a>( Rf R? R@ Rl R t focus_forceR� R R� R Rg Rj t enable_traversalR� R� ( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_traversal? s*
"
"
"
( R R] R^ R! R. R` R7 ( R4 R5 Rc R; R Rq Rw R Rz R R| R R� R� ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyRe � s
! t TreeviewTestc B s� e Z d# Z d � Z d
� Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d � Z d � Z
d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d! � Z d" � Z RS($ R t columnsR] t displaycolumnsR^ R! t
selectmodeR� R. R` R� t yscrollcommandc C s, t t | � j � | j d d � | _ d S( NR! i ( R: R� R; R t tv( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR; c s c K s t j | j | � S( N( R< t TreeviewR> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR g s c C sa | j � } | j | d d d d
�| j | d d � | j | d t d k rV d
n d � d S( NR� s a b cR" R� R# R i i R ( R� R# R ( R� R# R ( i i ( ( R R, R ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_columnsj s
c C s� | j � } d | d <| j | d d d d �| j | d d � | j | d d d d �| j | d d � | j | d d d
d �| j | d d d
d �| j | d d d
d �d S( NR� R# R R� R� s b a cR" s #alli i i R R s Invalid column index di s Column index 3 out of boundsi����s Column index -2 out of bounds( R� R# R ( R# R� R ( R# R� R ( s #all( i i i ( R� R# R ( i i i ( i i����( R R, R ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_displaycolumnsq s
c C sN | j � } | j | d d d d d d t �| j | d d d d t �d S( NR^ id i����i t 3cR3 g�����LY@gfffff�Y@( R RG R� R ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � s "c C s) | j � } | j | d d d d � d S( NR� R� t browset extended( R Rv ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_selectmode� s c C s� | j � } | j | d d d d �| j | d d � | j | d d � | j | d d d d �| j | d d d d
�d S( NR� s
tree headingsR" t treet headings( R� R� ( R� R� ( R� R� ( R� ( R� ( R R, ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � s c C sW | j j � | j | j j d � d � | j j � | j j � | j j d d � } | j j � } | j | � | j j | d � } | j | � d g | j d <| j j
d d d �| j j | d d � } | j j
d d d �} | j st
| � } n | j | d | d | � | j j | d � } | j | j j | � d � d S( NR R� i t testR� R7 i2 s #0( R� R? R R� R@ R� R� t get_childrenR� R� t columnRH R R) ( R t item_idt childrenR� t bbox_column0t
root_widthRg ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � s$
c C s> | j | j j � d � | j j d d � } | j | j j � t � | j | j j � d | � | j j d d � } | j j d d � } | j j | | | � | j | j j | � | | f � | j t j | j j | | � | j j | � | j | j j | � d � | j j d � | j | j j � d � d S( NR R� i ( ( ( (
R R� R� R� R t tuplet set_childrenRF RG R ( R R� R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt
test_children� s " c C si | j | j j d � t � | j rJ | j | j j d d d �t � n | j j d d d �| j | j j d d � | j r� d n d � | j | j j d d d �| j r� d n d � | j t j
| j j d d d �| j t j
| j j d � i d d 6i d
d 6i d
d 6i d
d 6i d
d
6g } x- | D]% } | j t j
| j j d | � q<Wd S( Ns #0R7 i
t 10t idt XR� s
some valuet unknown_optiont wrongt stretchR� t minwidth( R R� R� R! R RH R) R RF RG R ( R t invalid_kwsRM ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_column� s %" $
c C s? | j t j | j j d � | j j d d � } | j j | d � } | j | j j � | f � | j | j j | � | f � | j j | � | j | j j � � | j t j | j j | d d � | j j d d � } | j j d d � } | j | j j � | | f � | j j | | � | j | j j � � d S( Ns #0R R� (
RF RG R R� R� R� R R� R� t reattach( R R� t item2t item1( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_delete� s c C s0 | j j d d � } | j j | d � } | j j � } | j j � | j | | j j � � | j | j j � | f � | j | j j | � | f � | j j | � | j | j j � � | j j | d d � | j | j j � | f � | j | j j | � | f � | j j | d d � | j | j j � | | f � | j | j j | � d � | j t j
| j j d d d � | j t j
| j j d � | j t j
| j j | d d � | j t j
| j j | d d � | j j | | � | j | j j � d � | j | j j | � d � d S( NR R� t nonexistentt otherparentR� ( ( ( ( R� R� R� t detachR R� R� t moveRF RG R ( R R� R� t prev( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_detach_reattach� s4
c C st | j | j j d � t � | j | j j d � t � | j | j j i � t � | j t j | j j d � d S( Nt somethingR ( R R� t existsR� RU RF RG R RH ( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_exists' s c C s� | j | j j � d � | j j d d � } | j j | � | j | j j � | � | j j | � | j | j j � d � | j t j | j j d � d S( NR R� RO ( R R� R� R� R� RF RG R ( R R� ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt
test_focus2 s c C s� | j | j j d � t � | j j d d d �| j | j j d d � d � | j | j j d d d �d � | j t j | j j d d d �| j t j | j j d d d �d S( Ns #0R8 RO R� R� i ( R R� t headingR! R RH RF RG R ( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_headingA s "c s � f d � } g � � j j � � j j � � j j d d � f d � �� j j d d d �� j j � | d d � � s� � j d � n g � � j j j } � j j d d t � j j d d d �� �� j | � j j j � | d d � � s� j d � n d S( Nc s$ t � j | | � � j j � d S( N( R R� R� ( R� R� ( R ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt simulate_heading_clickR s s #0R� c s
� j t � S( N( R� RU ( ( R� ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� Z R R7 id i s> The command associated to the treeview heading wasn't invoked.( R� R? R@ R� R� R� Rn R t _tclCommandsR� RH R ( R R� t commands( ( R R� s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_heading_callbackQ s"
.
c C s� | j t j | j j d � | j | j j d � d � | j j d d � } | j j d d � } | j j | d � } | j j | d � } | j | j j | � d � | j | j j | � d � | j | j j | � d � | j | j j | � d � | j j | d d � | j | j j | � d � | j | j j | � d � | j j | � | j | j j | � d � | j j | � | j | j j | � d � | j j | � | j t j | j j | � d S( Nt whatR i R� i (
RF RG R R� Rk R R� R� R� R� ( R R� R� t c1t c2( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyRz s s& c C s� | j t j | j j d d � | j t j | j j d d d d �| j t j | j j d d d d �| j | j j | j j d d d t �� � | j | j j | j j d d d t �� � | j t j | j j d d � | j j d d d � } | j | d � | j t j | j j d d d � | j t j | j j d d t
d � � d } | j j d d d | f �} | j | j j | d � | j r�| f n | � | j | j j | d d �| j r�| f n | � | j j | d | j j | j j | d d �� �| j | j j | d d �| j r@| f n | � | j | j j | � t � | j j | d d �| j | j j | d d �� | j j d d d
d d | g �} | j | j j | d
d �| j r�d
d | f n d | � | j j | d
g �| j | j j | d
d �� | j j | d
d �| j | j j | d
d �| j rod n d � | j j d d d d d | | f f �} | j | j j | d d �| j r�d d | | f f n
d | | f � | j | j j | j j d d d d �d d �d � | j | j j | j j d d d | �d d �| � | j j d d d � } | j | d � | j j d d d � } | j | d � | j t j | j j d d t � | j t j | j j d d d � d S( NR� R� R t opent pleaset middles
first-itemu ábaR� t tagsi i R R s 1 2 %ss 1 2s a b cs %s %ss {a b c} {%s %s}R8 s
Label herei R# g s 0.0( i i ( R R ( RF RG R R� R� R� R� RU R� R R t itemR RH R> t splitlistR R! ( R t itemidR- R� ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_insert_item� sh ..
4 $ !!"c C s� | j t j | j j d � | j t j | j j d � | j t j | j j d � | j t j | j j d � | j j d d � } | j j d d � } | j j | d � } | j j | d � } | j j | d � } | j | j j
� d
� | j j | | f � | j | j j
� | | f � | j j | � | j | j j
� | f � | j j | | f � | j | j j
� | | | f � | j j | � | j | j j
� | | | | f � | j j | | f � | j | j j
� | | | f � | j j | � | j | j j
� | | f � | j j | | f � | j | j j
� | | f � | j j | � | j | j j
� | f � | j j d d d d �| j j d � | j | j j
� d � | j j d d d d �| j j d � | j | j j
� d � t rl| j j d d d t d � �| j j t d � � | j | j j
� t d � f � n | j j d d d d �| j j d � | j | j j
� t r�t d � n d f � d S(
NR� R R� R� s with spacess {braces
unicode\u20acs bytes€s bytes\u20ac( ( s with spaces( s {brace(
RF RG R R� t
selection_sett
selection_addt selection_removet selection_toggleR� R t selectionR R ( R R� R� R� R� t c3( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_selection� sR "%" %c C sP d d g | j d <| j j d d d d d g �} | j | j j | � i d d 6d d 6� | j j | d d � | j | j j | d d �| j r� d n d � d g | j d <| j | j j | � i d d 6� | j j | d d � | j | j j | d
d �d � | j | j j | d d �| j r:d n d � | j j | d d � | j | j j | d � | j r~d n d
� | j | j j | d d �| j r�d n d � | j | j j | � | j r�i d d 6n
i d
d 6� | j t j | j j | d � | j t j | j j | d d � | j t j | j j d � d S( Nt At BR� R R� R� R� R# s a aR� s b ai{ t 123s 123 at notme( R� R� ( R# R� ( i{ R� (
R� R� R R R� RH R RF RG R ( R R� ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyRW s, !*#"$ "c s� g � | j j d d d d g �} | j j d d d d g �} | j j d d � f d � � | j j d d � f d � � | j j � | j j � | j j � t � } t � } xq t d d
d � D]] } t | � d k r� Pn | j j | � } | r� | | k r� | j
| � | j
| � q� q� W| j t | � d � x! | D] } t | j d | � qJW| j t � � d
� xA t
� d d d � � d d d � � D] } | j | d � q�Wd S( NR R� R� t calls <ButtonPress-1>c s
� j d � S( Ni ( R� ( R� ( t events( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� ; R s <ButtonRelease-1>c s
� j d � S( Ni ( R� ( R� ( R� ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� = R i id i
i i i ( i i ( R� R� t tag_bindR? R@ R� R Rm R� t identify_rowR R R t zip( R R� R� t pos_yt foundRp R� R� R� ( ( R� s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt
test_tag_bind6 s2
0c C s� | j t | j j � | j t j | j j d d d �| j j d d d �| j t | j j d d � � d � | j t | j j d d d �� d � | j | j j d � t
� d S( NR� t skyt blueR� ( RF t TypeErrorR� t
tag_configureRG R R R� RH R R! ( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_tag_configureX s
!c C s� | j j d d d d d d g �} | j j d d d d d d g �} | j t | j j � | j t | j j d d � | j | j j d | � � | j | j j d | � � | j | j j d | � � | j | j j d | � � | j | j j d
| � � | j | j j d
| � � | j | j j d � | f � | j | j j d � | f � | j | j j d
� d � d S( NR R� R8 s Item 1R� t tag1s Item 2t tag2s non-existingt tag3( ( R� R� RF R� t tag_hasR R� R� R ( R R� R� ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_tag_hasd s $$ ( R R� R] R� R^ R! R� R� R. R` R� R� ( R4 R5 Rc R; R R� R� R� R� R� R� R� R� R� R� R� R� R� R� Rz R� R� RW R� R� R� ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� [ s4 * " M 6 ! " t
SeparatorTestc B s e Z d Z d Z d � Z RS( R R] R R. R` R c K s t j | j | � S( N( R< t SeparatorR> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR | s ( R R] R R. R` ( R4 R5 Rc R/ R ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� t s t SizegripTestc B s e Z d Z d � Z RS( R R] R. R` c K s t j | j | � S( N( R< t SizegripR> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR � s ( R R] R. R` ( R4 R5 Rc R ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � s t __main__(5 t unittestt TkinterRG R R< t test.test_supportR R R R R� t test_functionsR t supportR R R R t widget_testsR
R R R
R R R R R t TestCaseR6 RY R[ Rd R~ R� R� R� R� R� R
R, R4 R> RX t skipIfR� Rc Re R� R� R� t tests_guiR4 ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt <module> sr " ":
' ; 0 � | � 3 j "
� � � test/test_ttk/test_style.pyo 0000644 00000006341 15032720555 0012324 0 ustar 00 �
z fc @ s� d d l Z d d l Z d d l Z d d l m Z m Z d d l m Z e d � d e e j f d � � YZ
e
f Z e d k r� e e � n d S( i����N( t requirest run_unittest( t AbstractTkTestt guit StyleTestc B s> e Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c C s, t t | � j � t j | j � | _ d S( N( t superR t setUpt ttkt Stylet roott style( t self( ( s7 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_style.pyR s c C sU | j } | j d d d �| j | j d d � d � | j | j d � t � d S( Nt TButtont
backgroundt yellow( R
t configuret assertEqualt assertIsInstancet dict( R R
( ( s7 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_style.pyt test_configure s
c C sm | j } | j d d d g �| j | j d d � | j rF d g n d g � | j | j d � t � d S( NR R
t activet blues active background( R R
R ( R R
R ( s active backgroundR ( R
t mapR t wantobjectsR R ( R R
( ( s7 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_style.pyt test_map s
c C s� | j } | j d d d �| j d d d g �| j | j d d � d � | j | j d d d d g � d � | j | j d d d d �d � d S(
NR R
R R R t optionnotdefinedt defaultt iknewit( R R
R ( R
R R R t lookup( R R
( ( s7 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_style.pyt test_lookup! s c C s� | j } | j t j | j d � | j d � } | j d d � | j | j d � d i d d 6f g � | j d | � | j | j d � | � | j | j d � t � | j t j | j d d i d d
6f g � d S( Nt
NotALayoutt Treeviewt t nullt nswet stickyR t namet
inexistentt option( R
t assertRaisest tkintert TclErrort layoutR R t list( R R
t tv_style( ( s7 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_style.pyt test_layout- s c C s� | j t j | j j d � | j j � } d } xA | j j � D], } | | k rA | } | j j | � PqA qA Wd S| j | | k � | j | | j j � k � | j j | � d S( Nt nonexistingname( R' R( R) R
t theme_uset Nonet theme_namest assertFalse( R t
curr_themet new_themet theme( ( s7 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_style.pyt test_theme_useD s ( t __name__t
__module__R R R R R- R6 ( ( ( s7 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_style.pyR s t __main__(
t unittestt TkinterR( R t test.test_supportR R t test_ttk.supportR t TestCaseR t tests_guiR7 ( ( ( s7 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_style.pyt <module> s
P test/test_ttk/__init__.pyc 0000644 00000000214 15032720555 0011641 0 ustar 00 �
z fc @ s d S( N( ( ( ( s5 /usr/lib64/python2.7/lib-tk/test/test_ttk/__init__.pyt <module> t test/test_ttk/test_style.pyc 0000644 00000006341 15032720555 0012310 0 ustar 00 �
z fc @ s� d d l Z d d l Z d d l Z d d l m Z m Z d d l m Z e d � d e e j f d � � YZ
e
f Z e d k r� e e � n d S( i����N( t requirest run_unittest( t AbstractTkTestt guit StyleTestc B s> e Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c C s, t t | � j � t j | j � | _ d S( N( t superR t setUpt ttkt Stylet roott style( t self( ( s7 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_style.pyR s c C sU | j } | j d d d �| j | j d d � d � | j | j d � t � d S( Nt TButtont
backgroundt yellow( R
t configuret assertEqualt assertIsInstancet dict( R R
( ( s7 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_style.pyt test_configure s
c C sm | j } | j d d d g �| j | j d d � | j rF d g n d g � | j | j d � t � d S( NR R
t activet blues active background( R R
R ( R R
R ( s active backgroundR ( R
t mapR t wantobjectsR R ( R R
( ( s7 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_style.pyt test_map s
c C s� | j } | j d d d �| j d d d g �| j | j d d � d � | j | j d d d d g � d � | j | j d d d d �d � d S(
NR R
R R R t optionnotdefinedt defaultt iknewit( R R
R ( R
R R R t lookup( R R
( ( s7 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_style.pyt test_lookup! s c C s� | j } | j t j | j d � | j d � } | j d d � | j | j d � d i d d 6f g � | j d | � | j | j d � | � | j | j d � t � | j t j | j d d i d d
6f g � d S( Nt
NotALayoutt Treeviewt t nullt nswet stickyR t namet
inexistentt option( R
t assertRaisest tkintert TclErrort layoutR R t list( R R
t tv_style( ( s7 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_style.pyt test_layout- s c C s� | j t j | j j d � | j j � } d } xA | j j � D], } | | k rA | } | j j | � PqA qA Wd S| j | | k � | j | | j j � k � | j j | � d S( Nt nonexistingname( R' R( R) R
t theme_uset Nonet theme_namest assertFalse( R t
curr_themet new_themet theme( ( s7 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_style.pyt test_theme_useD s ( t __name__t
__module__R R R R R- R6 ( ( ( s7 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_style.pyR s t __main__(
t unittestt TkinterR( R t test.test_supportR R t test_ttk.supportR t TestCaseR t tests_guiR7 ( ( ( s7 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_style.pyt <module> s
P test/test_ttk/test_widgets.pyc 0000644 00000170617 15032720555 0012626 0 ustar 00 �
z fc @ sU d d l Z d d l Z d d l m Z d d l Z d d l m Z m Z m Z m Z d d l
Z
d d l m Z d d l
m Z m Z m Z m Z d d l m Z m Z m Z m Z m Z m Z m Z m Z e d � d e f d � � YZ d
e e j f d � � YZ d e e f d
� � YZ e e � d e e j f d � � Y� Z e e � d e e j f d � � Y� Z d e f d � � YZ! e e � d e! e j f d � � Y� Z" e e � d e! e j f d � � Y� Z# e e � d e! e j f d � � Y� Z$ e e e � d e e j f d � � Y� Z% e e e � d e% e j f d � � Y� Z& e e e � d e e j f d � � Y� Z' e e � d e! e j f d! � � Y� Z( d" e! e j f d# � � YZ) e e � d$ e e j f d% � � Y� Z* e e � d& e e j f d' � � Y� Z+ e j, e
j- d( k d) � e e � d* e e j f d+ � � Y� � Z. e e e � d, e e j f d- � � Y� Z/ e e � d. e e j f d/ � � Y� Z0 e e � d0 e e j f d1 � � Y� Z1 e e � d2 e e j f d3 � � Y� Z2 e# e$ e& e% e e e" e) e/ e' e+ e( e* e. e1 e2 e0 e f Z3 e4 d4 k rQe e3 � n d S(5 i����N( t TclError( t requirest run_unittestt have_unicodet u( t
MockTclObj( t AbstractTkTestt tcl_versiont get_tk_patchlevelt simulate_mouse_click( t add_standard_optionst noconvt noconv_metht AbstractWidgetTestt StandardOptionsTestst IntegerSizeTestst PixelSizeTestst setUpModulet guit StandardTtkOptionsTestsc B s# e Z d � Z d � Z d � Z RS( c C s� | j � } | j | d d � d } t � d
k r> d } n | j | d d
d | �| j d d
� } | j | d d
� d S( Nt classt s" attempt to change read-only optioni i i t betai s" Attempt to change read-only optiont Foot errmsgt class_( i i i R i ( t createt assertEqualR t checkInvalidParam( t selft widgetR t widget2( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt
test_class s c C s� | j � } | j | d d d d �| j | d d d d �| j | d d d d �| j | d d d d �| j | d d d d �| j | d d � | j | d d d d �d S( Nt paddingi t expectedt 0i t 5i t 6i t 7i t 8t 5pt 6pt 7pt 8pR ( R# ( R$ ( i i ( R$ R% ( i i i ( R$ R% R& ( i i i i ( R$ R% R& R' ( R( R) R* R+ ( ( R t
checkParam( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_padding s c C s� | j � } | j | d d � d } t | d � rQ d t | d � j � } n | j | d d d | �| j d d � } | j | d d � d S(
Nt styleR s Layout Foo not foundt default_orients Layout %s.Foo not foundR R R R ( R R t hasattrt getattrt titleR ( R R R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt
test_style+ s ( t __name__t
__module__R R- R3 ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR s
t
WidgetTestc B s) e Z d Z d � Z d � Z d � Z RS( s, Tests methods available in every ttk widget.c C sR t t | � j � t j | j d d d d �| _ | j j � | j j � d S( Nt widthi t textt Text( t superR6 t setUpt ttkt Buttont rootR t packt wait_visibility( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR; = s !
c C s� | j j � | j | j j | j j � d | j j � d � d � | j | j j d d � d � | j t j | j j d d � | j t j | j j d d � | j t j | j j d d � d S( Ni t labeli����R i (
R t update_idletasksR t identifyt winfo_widtht winfo_heightt assertRaisest tkinterR t None( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt
test_identifyD s
c C s� | j | j j � d
� | j | j j d g � t � | j | j j d g � d � | j | j j d g � d � | j | j j d d g � d
� | j | j j d d g � d � | j | j j d d g � d � d � } | j | j j d g | d i d d 6� d i d d 6f � | j j � } | j t j | j j d g � | j t j | j j d d g � | j | | j j � � | j j d d g � | j | j j � d � d S( Ns !disabledt disabledt actives !activec [ s
| | f S( N( ( t arg1t kw( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_cba s t hit theret msgt badstate( ( s !disabled( ( s !activeRJ ( ( ( RK ( R R t statet instatet TrueRF RG R ( R RN t currstate( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_widget_stateQ s( ""
( R4 R5 t __doc__R; RI RW ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR6 : s
t AbstractToplevelTestc B s e Z e Z RS( ( R4 R5 R t _conv_pixels( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyRY u s t FrameTestc B s e Z d
Z d � Z RS( t borderwidthR t cursort heightR! t reliefR. t takefocusR7 c K s t j | j | � S( N( R< t FrameR> ( R t kwargs( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR � s ( R\ R R] R^ R! R_ R. R` R7 ( R4 R5 t OPTIONSR ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR[ y s t LabelFrameTestc
B s) e Z d Z d
� Z d � Z d � Z RS( R\ R R] R^ t labelanchort labelwidgetR! R_ R. R` R8 t underlineR7 c K s t j | j | � S( N( R< t
LabelFrameR> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR � s c C s] | j � } | j | d d d d d d d d d d
d d d
d d �| j | d d � d S( NRe t et ent est nt net nwt st set swt wt wnt wsR s! Bad label anchor specification {}t center( R t checkEnumParamR ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_labelanchor� s
'c C sQ | j � } t j | j d d d d �} | j | d | d d �| j � d S( NR8 t Muppt namet fooRf R" s .foo( R R< t LabelR> R, t destroy( R R RA ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_labelwidget� s (
R\ R R] R^ Re Rf R! R_ R. R` R8 Rg R7 ( R4 R5 Rc R Rw R} ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyRd � s t AbstractLabelTestc B s, e Z d � Z d � Z d � Z d � Z RS( c C s� t j d | j d d � } t j d | j d d � } | j | | | d d �| j | | d d d �| j | | | f d d
�| j | | | d | f d d �| j | | d d d �| j | | d d d
�d S( Nt masterRy t image1t image2R" RK s image1 active image2t spamR s image "spam" doesn't exist( R� ( R� ( R� ( R� RK R� ( R� RK R� ( RG t
PhotoImageR> R, R ( R R Ry t imageR� ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt checkImageParam� s c C s8 | j � } | j | d d d d d d d d d �
d S(
Nt compoundt noneR8 R� Ru t topt bottomt leftt right( R Rv ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt
test_compound� s c C s) | j � } | j | d d d d � d S( NRS RK RJ t normal( R t checkParams( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt
test_state� s c C s) | j � } | j | d d d d � d S( NR7 i� in���i ( R R� ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt
test_width� s ( R4 R5 R� R� R� R� ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR~ � s
t LabelTestc B s& e Z d Z e Z d � Z d � Z RS( t anchort
backgroundR\ R R� R] t fontt
foregroundR� t justifyR! R_ RS R. R` R8 t textvariableRg R7 t
wraplengthc K s t j | j | � S( N( R< R{ R> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR � s c C s# | j � } | j | d d � d S( NR� s3 -Adobe-Helvetica-Medium-R-Normal--*-120-*-*-*-*-*-*( R R, ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_font� s ( R� R� R\ R R� R] R� R� R� R� R! R_ RS R. R` R8 R� Rg R7 R� ( R4 R5 Rc R RZ R R� ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � s t
ButtonTestc B s) e Z d Z d � Z d � Z d � Z RS( R t commandR� R] t defaultR� R! RS R. R` R8 R� Rg R7 c K s t j | j | � S( N( R< R= R> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR � s c C s) | j � } | j | d d d d � d S( NR� R� RK RJ ( R Rv ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_default� s c sB g � t j | j d � f d � �} | j � | j � � d S( NR� c s
� j d � S( Ni ( t append( ( t success( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt <lambda>� R ( R< R= R> t invoket
assertTrue( R t btn( ( R� s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_invoke� s !
( R R� R� R] R� R� R! RS R. R` R8 R� Rg R7 ( R4 R5 Rc R R� R� ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � s t CheckbuttonTestc B s2 e Z d Z d � Z d � Z d � Z d � Z RS( R R� R� R] R� t offvaluet onvalueR! RS R. R` R8 R� Rg t variableR7 c K s t j | j | � S( N( R< t CheckbuttonR> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR � s c C s, | j � } | j | d d d d d � d S( NR� i gffffff@R s
any string( R R� ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt
test_offvalue� s c C s, | j � } | j | d d d d d � d S( NR� i gffffff@R s
any string( R R� ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_onvalue� s c s g � � f d � } t j | j d | �} | j | j � d
� | j t j | j j | d � | j
� } | j | d � | j | d | j j | d � � | j � � d | d <| j
� } | j t
| � � | j t � � d � | j | d | j j | d � � d S( Nc s � j d � d S( Ni s cb test called( R� ( ( R� ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt cb_test s
R� t alternateR� s cb test calledR� R i R� ( R� ( R< R� R> R RS RF RG R t tkt globalgetvarR� R� t assertFalset strt assertLessEqualt len( R R� t cbtnt res( ( R� s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � s"
( R R� R� R] R� R� R� R! RS R. R` R8 R� Rg R� R7 ( R4 R5 Rc R R� R� R� ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � s t EntryTestc B sz e Z d Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d � Z d � Z
d � Z RS( R� R R] t exportselectionR� R� t invalidcommandR� t showRS R. R` R� t validatet validatecommandR7 t xscrollcommandc C s& t t | � j � | j � | _ d S( N( R: R� R; R t entry( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR; # s c K s t j | j | � S( N( R< t EntryR> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR ' s c C s | j � } | j | d � d S( NR� ( R t checkCommandParam( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_invalidcommand* s c C sI | j � } | j | d d � | j | d d � | j | d d � d S( NR� t *R t ( R R, ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_show. s c C s) | j � } | j | d d d d � d S( NRS RJ R� t readonly( R R� ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� 4 s c C s2 | j � } | j | d d d d d d d � d S( NR� t allt keyt focust focusint focusoutR� ( R Rv ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt
test_validate9 s c C s | j � } | j | d � d S( NR� ( R R� ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_validatecommand> s c C sU | j | j j d � � | j t j | j j d � | j t j | j j d � d S( Ni t noindex( t assertIsBoundingBoxR� t bboxRF RG R RH ( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_bboxC s c C s� | j j � | j j � | j j � t j d k rX | j | j j d d � d � n | j | j j d d � d � | j | j j d d � d � | j t
j | j j d d � | j t
j | j j d d � | j t
j | j j d d � d S( Nt darwini t textareas Combobox.buttoni����R ( R� s Combobox.button(
R� R? R@ RB t syst platformt assertInRC R RF RG R RH ( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyRI I s
c s# g � � f d � } d | j d <d � | j d <| | j d <| j j � | j � � d | j d <| j j � | j t � � d � | | j d <d � | j d <| j j � | j t � � d � d | j d <| j j � | j t � � d � t | j d <| j t j | j j � d S(
Nc s
� j t � S( N( R� RU ( ( R� ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� ] R R� R� c S s t S( N( t False( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� ` R R� R� R i c S s t S( N( RU ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� k R ( R� R� R� R R� RU RF RG R ( R t test_invalid( ( R� s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_validation_options[ s&
c s� g � � f d � } d | j d <| j j | � d f | j d <| j j d d � | j j d d � | j � t t g � | j | j j � d � d S( Nc sD d | j � k o d k n s3 � j t � t S� j t � t S( Nt at z( t lowerR� R� RU ( t to_insert( t
validation( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� y s
"
R� R� s %SR� t endi R� ( R� t registert insertR R� RU t get( R R� ( ( R� s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_validationw s
c C s$ d � } | j j | � d f | j d <| j j d d � | j | j j � t � | j | j j � d � | j j d d � | j | j j � d � | j j d d � | j | j j � t � | j | j j � d � | j j d
� | j | j j � t � | j | j j � d
� d S( Nc S s; x4 | D], } d | j � k o* d k n s t Sq Wt S( NR� R� ( R� R� RU ( t contentt letter( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � s
"s %PR� R� t avocadoi R t a1bt invalidi ( ( R� ( (
R� R� R� R R� RU RS t deleteR� R� ( R R� ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_revalidation� s ( R� R R] R� R� R� R� R� R� RS R. R` R� R� R� R7 R� ( R4 R5 Rc R; R R� R� R� R� R� R� RI R� R� R� ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� s" t ComboboxTestc B sM e Z d Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z RS( R� R R] R� R� R� R^ R� R� t postcommandR� RS R. R` R� R� R� t valuesR7 R� c C s& t t | � j � | j � | _ d S( N( R: R� R; R t combo( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR; � s c K s t j | j | � S( N( R< t ComboboxR> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR � s c C s2 | j � } | j | d d d d d d d � d S( NR^ id g�����LY@gfffff�Y@i����i t 1i( R R� ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_height� s c C s` | j j � } | j j d d | d d d �| j j d d | d d d �| j j � d S( Ns <ButtonPress-1>t xi t ys <ButtonRelease-1>( R� RD t event_generateRB ( R R7 ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt _show_drop_down_listbox� s c s� g � d g | j d <| j j d � f d � � | j j � | j j � | j j � } | j � | j j � | j j d � | j j � | j � � d S( Ni R� s <<ComboboxSelected>>c s
� j t � S( N( R� RU ( t evt( R� ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � R s <Return>( R� t bindR? R@ RE R� t updateR� R� ( R R^ ( ( R� s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_virtual_event� s
c s~ g � � f d � | j d <| j j � | j j � | j � | j � � d | j d <| j � | j t � � d � d S( Nc s
� j t � S( N( R� RU ( ( R� ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � R R� R i ( R� R? R@ R� R� R R� ( R ( ( R� s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_postcommand� s
c s� � f d � } � j � j d t d# k r1 d$ n d � | d d � � j � j d d d d% �� j � j d d& � � j � j d d' � � j � j d t d( k r� d) n d � d d d g � j d <� j j d � | d d � � j j d � | d d � � j j d � | d d � � j j d � d* � j d <| d d � � j j d d d d g � � j � j d � j r�d+ n d � d d d g � j d <� j � j d � j r�d, n d � d d d g � j d <� j � j d � j r�d- n d! � � j t j
� j j t � j d � � � j t j
� j j d � t j
� j d d d d g �} � j | d � j r�d. n d" � | j � d S(/ Nc s6 � j � j j � | � � j � j j � | � d S( N( R R� R� t current( t getvalt currval( R ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt check_get_current� s R� i i R i����s mon tue wed thurR" t mont tuet wedt thuri* g ��Q� @s
any stringR� i t ci i t di t 1t 2s 1 {} 2s a bs a bs a
bs {a b} {a b} {a
b}s a\tbs "a"s } {s a\\tb {"a"} \}\ \{s 1 2 {}( i i ( ( R� R� R� R ( R� R� R� R ( i* g ��Q� @R s
any string( i i ( ( i i R i ( R R R ( s a bs a bs a
b( s a\tbs "a"s } {( R R R ( R R� R R, t setR� t configuret wantobjectsRF RG R R� R< R� R> R| ( R R� t combo2( ( R s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_values� sL
(
!
( R� R R] R� R� R� R^ R� R� R� R� RS R. R` R� R� R� R� R7 R� (
R4 R5 Rc R; R R� R� R� R� R ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � s t PanedWindowTestc B sV e Z d Z d � Z d � Z d � Z d
� Z d � Z d � Z d
� Z d � Z
RS( R R] R^ t orientR. R` R7 c C s& t t | � j � | j � | _ d S( N( R: R
R; R t paned( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR; & s c K s t j | j | � S( N( R< t PanedWindowR> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR * s c C s� | j � } | j t | d � d � d } t � d k rD d } n | j | d d
d | �| j d d
� } | j t | d � d
� d S(
NR t verticals" attempt to change read-only optioni i i R i s" Attempt to change read-only optiont
horizontalR ( i i i R i ( R R R� R R ( R R R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_orient- s c C sz t j | j � } t j | � } | j t j | j j | � | j � | j � t j | j � } t j | � } | j t j | j j | � | j � | j � t j | j � } | j j | � | j t j | j j | � t j | j � } | j j | � | j | j j
d � | j j
d � � | j t j | j j
d � | j � | j � | j t j | j j
d � d S( Ni i i ( R< R{ R RF RG R t addR| R> R t pane( R RA t childt
good_childt other_child( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_add8 s(
(
c C s� | j t j | j j d � | j t j | j j d � | j j t j | j � � | j j d � | j t j | j j d � d S( Ni (
RF RG R R t forgetRH R R< R{ R> ( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_forgetT s
c C s | j t j | j j d d � | j t j | j j d d � | j t j | j j d d � t j | j � } t j | j � } t j | j � } | j t j | j j d | � | j j d | � | j j d | � | j | j j
� t | � t | � f � | j j d | � | j | j j
� t | � t | � f � | j j d | � | j | j j
� t | � t | � t | � f � | j j
� } | j j d | � | j | | j j
� � | j j | | � | j | j j
� t | � t | � t | � f � d S( Ni R� ( RF RG R R R� RH R< R{ R> R t panesR� ( R R t child2t child3R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_insert] s* ++"c C s
| j t j | j j d � t j | j � } | j j | � | j | j j d � t
� | j | j j d d d �| j
r� d n d � | j | j j d d � | j
r� d n d � | j | j j d � | j j t | � � � | j t j | j j d d d �d S( Ni t weightR# t badoptiont somevalue( RF RG R R R R< R{ R> R t assertIsInstancet dictR RH R R� ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_pane� s .c C si | j t j | j j d � | j t j | j j d � | j t j | j j d � t j | j d d �} | j j | d d �| j t j | j j d � t j | j d d �} | j j | � | j t j | j j d � | j j d t
d d
� | j j � | j j d � } | j j d d � | j | | j j d � � | j
| j j d � t � d S( NR i R8 R� R i t bt expandt fillt bothi� ( RF RG R R t sashposRH R< R{ R R? RU R@ t assertNotEqualR t int( R R R t curr_pos( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_sashpos� s
( R R] R^ R R. R` R7 ( R4 R5 Rc R; R R R R R R" R+ ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR
s # t RadiobuttonTestc B s) e Z d Z d � Z d � Z d � Z RS( R R� R� R] R� R! RS R. R` R8 R� Rg t valueR� R7 c K s t j | j | � S( N( R< t RadiobuttonR> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR � s c C s, | j � } | j | d d d d d � d S( NR- i gffffff@R s
any string( R R� ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt
test_value� s c s� g � � f d � } t j | j � } t j | j d | d | d d �} t j | j d | d | d d �} | j r� d � } n t } | j � } | j | d � | j | | d � | j � � | j | j � | | j
j | d � � � | j � � d | d <| j � } | j t
| � d � | j t � � d � | j | | d � | j � � | j | j � | | j
j | d � � � | j t
| d � t
| d � � d S(
Nc s � j d � d S( Ni s cb test called( R� ( ( R� ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � s
R� R� R- i i c S s | S( N( ( R� ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � R s cb test calledR ( RG t IntVarR> R< R. R R) R� R R� R� R� R� R� R� R� ( R R� t myvarR� t cbtn2t convR� ( ( R� s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � s0
( R R� R� R] R� R! RS R. R` R8 R� Rg R- R� R7 ( R4 R5 Rc R R/ R� ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR, � s t MenubuttonTestc B s) e Z d Z d � Z d � Z d � Z RS( R R� R] t directionR� t menuR! RS R. R` R8 R� Rg R7 c K s t j | j | � S( N( R< t
MenubuttonR> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR � s c C s/ | j � } | j | d d d d d d � d S( NR5 t abovet belowR� R� t flush( R Rv ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_direction� s c C sH | j � } t j | d d �} | j | d | d t �| j � d S( NRy R6 R3 ( R RG t MenuR, R� R| ( R R R6 ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_menu� s ( R R� R] R5 R� R6 R! RS R. R` R8 R� Rg R7 ( R4 R5 Rc R R; R= ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR4 � s t ScaleTestc B sk e Z d Z e Z d Z d � Z d
� Z d � Z d � Z d � Z
d � Z d � Z d � Z
d � Z RS( R R� R] t fromt lengthR R. R` t toR- R� R c C s@ t t | � j � | j � | _ | j j � | j j � d S( N( R: R> R; R t scaleR? R� ( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR; � s
c K s t j | j | � S( N( R< t ScaleR> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR s c C s/ | j � } | j | d d d d d t �d S( NR? id g������-@g333333.@R3 ( R t checkFloatParamR� ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_from s c C s, | j � } | j | d d d d d � d S( NR@ i� gffffff`@g33333�`@t 5i( R t checkPixelsParam( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_length s c C s2 | j � } | j | d d d d d d t �d S( NRA i, g������-@g333333.@i����R3 ( R RD R� ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_to s c C s2 | j � } | j | d d d d d d t �d S( NR- i, g������-@g333333.@i����R3 ( R RD R� ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR/ s c s� d d d g � | j j d � f d � � } d | j d <d | j d <d | j d <| j � � d d d g � | j j d d d d
� | j j d d d d � | j j d d � | j � � d S(
Ni s <<RangeChanged>>c s
� j � S( N( t pop( R� ( t failure( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� R i
R? t from_i RA i i i i����( RB R� R� R ( R t funcid( ( RK s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_custom_event s
c C s | j r d � } n t } | j j � } | j | j j | d � | j d � | j | | j j d d � � | | j d � � | j | j j � | j d � d | j d <| j | j j � | j d � | j t j | j j d d � | j t j | j j d d � d S( Nc S s | S( N( ( R� ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� ( R i RA R? R- i R ( R t floatRB RD R R� RF RG R ( R R3 t scale_width( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_get& s &2
c C s� | j r d � } n t } | | j d � } | d } | j j | � | j | | j j � � | � | | j d � } | j j | d � | j | | j j � � | � t j | j � } | | j d <| j | d � | j | | j j � � | j � � | j | | j j � � | d � ~ | d | j d <| j | | j j � � | d � | j | | j j � � | | j d � � | j | | j j d d � � | � | j | | j j | j j � d � � | � | j
t j | j j d � d S(
Nc S s | S( N( ( R� ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� : R RA i
R? i R� i R- i (
R RO RB R R R� RG t DoubleVarR> RD RF R RH ( R R3 t maxt new_maxt mint var( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_set8 s,
%##,%.( R R� R] R? R@ R R. R` RA R- R� ( R4 R5 Rc R RZ R/ R; R RE RH RI R/ RN RQ RW ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR> � s t ProgressbarTestc B sP e Z d Z e Z d Z d � Z d
� Z d � Z d � Z d � Z
d � Z RS( R R] R R@ t modet maximumt phaseR. R` R- R� R c K s t j | j | � S( N( R< t ProgressbarR> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR f s c C s) | j � } | j | d d d d � d S( NR@ gfffffY@g�����YL@t 2i( R RG ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyRH i s c C s2 | j � } | j | d d d d d d t �d S( NRZ gfffff�b@g�����lS@i i����R3 ( R RD R� ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_maximumm s c C s& | j � } | j | d d d � d S( NRY t determinatet
indeterminate( R Rv ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_modeq s c C s d S( N( ( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt
test_phaseu s c C s2 | j � } | j | d d d d d d t �d S( NR- gfffff�b@g�����lS@i i����R3 ( R RD R� ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR/ y s ( R R] R R@ RY RZ R[ R. R` R- R� ( R4 R5 Rc R RZ R/ R RH R^ Ra Rb R/ ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyRX \ s R� s" ttk.Scrollbar is special on MacOSXt
ScrollbarTestc B s e Z d Z d Z d � Z RS( R R� R] R R. R` R c K s t j | j | � S( N( R< t ScrollbarR> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR � s ( R R� R] R R. R` ( R4 R5 Rc R/ R ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyRc s t NotebookTestc B sq e Z d Z d � Z d � Z d � Z d
� Z d � Z d � Z d
� Z d � Z
d � Z d � Z d � Z
RS( R R] R^ R! R. R` R7 c C s� t t | � j � | j d d � | _ t j | j � | _ t j | j � | _ | j j
| j d d �| j j
| j d d �d S( NR! i R8 R� R# ( R: Re R; R t nbR< R{ R> t child1R R ( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR; � s c K s t j | j | � S( N( R< t NotebookR> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR � s c C s� | j j d � | j j | j � | j t j | j j | j � | j | j j
d � d � | j j | j � | j | j j
d � d � | j j | j � | j
| j j d � � | j j | j d d �| j j � | j j � t j d k rd } n d } | j | j j | � | j j d � � xh t d
d d
� D]G } y* | j j d | d d �d k rtPn WqEt j k
r�qEXqEW| j d
� d S( Ni R� i R� R8 R� R� s @20,5s @5,5i id s @%d, 5s Tab with text 'a' not found( Rf R t hideR RF RG R t tabRg R t indexR t selectR� R? R@ R� R� t rangeRH t fail( R t tb_idxt i( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_tab_identifiers� s,
("c C s� | j t j | j j d � | j t j | j j d � | j t j | j j d � | j t j | j j d � | j t j | j j t j | j � d d �| j j
� } | j j | j � | j j | j � | j | j j
� | � t j | j � } | j j | d d �| j j
� } | j j
d � } | j j
| j � } | j j | j � | j j | j � | j | j j
� | � | j | j j
| j � | � | j t | j � | j j
� | � | j | j j
d � | d � d S( Ni����RO t unknownt optionR8 R R� i ( RF RG R Rf Ri RH R R< R{ R> t tabsRg R Rk R R� ( R Rt R t currt child2_index( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_add_and_hidden� s* ' &c C s+ | j t j | j j d � | j t j | j j d � | j t j | j j d � | j j � } | j j | j � } | j j | j � | j t
| j � | j j � � | j t | � d t | j j � � � | j j
| j � | j | j j | j � d � | j | | j j | j � � d S( Ni����RO i ( RF RG R Rf R RH Rt Rk Rg t assertNotInR� R R� R R( ( R Rt t child1_index( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR � s ") c C s� | j t j | j j d � | j t j | j j d � | j | j j d � t � | j | j j | j � d � | j | j j | j
� d � | j | j j d � d � d S( Ni����R� i i i ( RF RG R Rf Rk RH R R) R Rg R ( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt
test_index� s c C s� | j j � } | j j d | d � | j | j j � | d | d f � | j j | j | j � | j | j j � | � | j j d | j � | j | j j � | d | d f � | j j d d � | j | j j � | � | j t j | j j d | d � | j t j | j j d | d � t j
| j � } | j j d | � | j | j j � | d t | � | d f � | j j
| � | j | j j � | � | j j | j | � | j | j j � t | � f | � | j j
| � | j t j | j j d | � | j t j | j j d | � | j t j | j j d d � | j t j | j j d d � | j t j | j j d d � d S( Ni i R� i i����( Rf Rt R� R Rg R RF RG R R< R{ R> R� R RH ( R Rt R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR � s0 ''##0& c s� | j j � | j j � g � g � | j j d � f d � � | j j d � f d � � | j | j j � t | j � � | j j | j � | j � � | j | j j � t | j � � | j j
� | j � � d S( Ns <Unmap>c s
� j t � S( N( R� RU ( R� ( R� ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� R s <<NotebookTabChanged>>c s
� j t � S( N( R� RU ( R� ( t tab_changed( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� R ( Rf R? R@ Rg R� R Rl R� R R� R� ( R ( ( R� R{ s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_select s
"
"
c C s | j t j | j j d � | j t j | j j d � | j t j | j j d � | j | j j | j � t � | j | j j | j d d �d � | j | j j | j d � d � | j j | j d d �| j | j j | j d d �d � | j | j j | j d � d � d S( Ni����t notabR8 R� t abc(
RF RG R Rf Rj RH R Rg R! R ( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_tab( s %"%c C sb | j t | j j � � d � | j j | j � | j j | j � | j | j j � d � d S( Ni ( ( R R� Rf Rt R Rg R ( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_tabs6 s c C s� | j j � | j j � | j j d � t | j d d � | j j � | j j d � | j | j j � t | j � � | j j � | j j d � | j | j j � t | j
� � | j j � | j j d � | j | j j � t | j � � | j j | j
d d d d �| j j � | j j � t | j d d � t
j d k rh| j j d � n | j j d
� | j | j j � t | j
� � d S( Ni i s
<Control-Tab>s <Shift-Control-Tab>R8 R� Rg R� s
<Option-a>s <Alt-a>( Rf R? R@ Rl R t focus_forceR� R R� R Rg Rj t enable_traversalR� R� ( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_traversal? s*
"
"
"
( R R] R^ R! R. R` R7 ( R4 R5 Rc R; R Rq Rw R Rz R R| R R� R� ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyRe � s
! t TreeviewTestc B s� e Z d# Z d � Z d
� Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d � Z d � Z
d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d! � Z d" � Z RS($ R t columnsR] t displaycolumnsR^ R! t
selectmodeR� R. R` R� t yscrollcommandc C s, t t | � j � | j d d � | _ d S( NR! i ( R: R� R; R t tv( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR; c s c K s t j | j | � S( N( R< t TreeviewR> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR g s c C sa | j � } | j | d d d d
�| j | d d � | j | d t d k rV d
n d � d S( NR� s a b cR" R� R# R i i R ( R� R# R ( R� R# R ( i i ( ( R R, R ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_columnsj s
c C s� | j � } d | d <| j | d d d d �| j | d d � | j | d d d d �| j | d d � | j | d d d
d �| j | d d d
d �| j | d d d
d �d S( NR� R# R R� R� s b a cR" s #alli i i R R s Invalid column index di s Column index 3 out of boundsi����s Column index -2 out of bounds( R� R# R ( R# R� R ( R# R� R ( s #all( i i i ( R� R# R ( i i i ( i i����( R R, R ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_displaycolumnsq s
c C sN | j � } | j | d d d d d d t �| j | d d d d t �d S( NR^ id i����i t 3cR3 g�����LY@gfffff�Y@( R RG R� R ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � s "c C s) | j � } | j | d d d d � d S( NR� R� t browset extended( R Rv ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_selectmode� s c C s� | j � } | j | d d d d �| j | d d � | j | d d � | j | d d d d �| j | d d d d
�d S( NR� s
tree headingsR" t treet headings( R� R� ( R� R� ( R� R� ( R� ( R� ( R R, ( R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � s c C sW | j j � | j | j j d � d � | j j � | j j � | j j d d � } | j j � } | j | � | j j | d � } | j | � d g | j d <| j j
d d d �| j j | d d � } | j j
d d d �} | j st
| � } n | j | d | d | � | j j | d � } | j | j j | � d � d S( NR R� i t testR� R7 i2 s #0( R� R? R R� R@ R� R� t get_childrenR� R� t columnRH R R) ( R t item_idt childrenR� t bbox_column0t
root_widthRg ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � s$
c C s> | j | j j � d � | j j d d � } | j | j j � t � | j | j j � d | � | j j d d � } | j j d d � } | j j | | | � | j | j j | � | | f � | j t j | j j | | � | j j | � | j | j j | � d � | j j d � | j | j j � d � d S( NR R� i ( ( ( (
R R� R� R� R t tuplet set_childrenRF RG R ( R R� R R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt
test_children� s " c C si | j | j j d � t � | j rJ | j | j j d d d �t � n | j j d d d �| j | j j d d � | j r� d n d � | j | j j d d d �| j r� d n d � | j t j
| j j d d d �| j t j
| j j d � i d d 6i d
d 6i d
d 6i d
d 6i d
d
6g } x- | D]% } | j t j
| j j d | � q<Wd S( Ns #0R7 i
t 10t idt XR� s
some valuet unknown_optiont wrongt stretchR� t minwidth( R R� R� R! R RH R) R RF RG R ( R t invalid_kwsRM ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_column� s %" $
c C s? | j t j | j j d � | j j d d � } | j j | d � } | j | j j � | f � | j | j j | � | f � | j j | � | j | j j � � | j t j | j j | d d � | j j d d � } | j j d d � } | j | j j � | | f � | j j | | � | j | j j � � d S( Ns #0R R� (
RF RG R R� R� R� R R� R� t reattach( R R� t item2t item1( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_delete� s c C s0 | j j d d � } | j j | d � } | j j � } | j j � | j | | j j � � | j | j j � | f � | j | j j | � | f � | j j | � | j | j j � � | j j | d d � | j | j j � | f � | j | j j | � | f � | j j | d d � | j | j j � | | f � | j | j j | � d � | j t j
| j j d d d � | j t j
| j j d � | j t j
| j j | d d � | j t j
| j j | d d � | j j | | � | j | j j � d � | j | j j | � d � d S( NR R� t nonexistentt otherparentR� ( ( ( ( R� R� R� t detachR R� R� t moveRF RG R ( R R� R� t prev( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_detach_reattach� s4
c C st | j | j j d � t � | j | j j d � t � | j | j j i � t � | j t j | j j d � d S( Nt somethingR ( R R� t existsR� RU RF RG R RH ( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_exists' s c C s� | j | j j � d � | j j d d � } | j j | � | j | j j � | � | j j | � | j | j j � d � | j t j | j j d � d S( NR R� RO ( R R� R� R� R� RF RG R ( R R� ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt
test_focus2 s c C s� | j | j j d � t � | j j d d d �| j | j j d d � d � | j | j j d d d �d � | j t j | j j d d d �| j t j | j j d d d �d S( Ns #0R8 RO R� R� i ( R R� t headingR! R RH RF RG R ( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_headingA s "c s � f d � } g � � j j � � j j � � j j d d � f d � �� j j d d d �� j j � | d d � � s� � j d � n g � � j j j } � j j d d t � j j d d d �� �� j | � j j j � | d d � � s� j d � n d S( Nc s$ t � j | | � � j j � d S( N( R R� R� ( R� R� ( R ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt simulate_heading_clickR s s #0R� c s
� j t � S( N( R� RU ( ( R� ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� Z R R7 id i s> The command associated to the treeview heading wasn't invoked.( R� R? R@ R� R� R� Rn R t _tclCommandsR� RH R ( R R� t commands( ( R R� s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_heading_callbackQ s"
.
c C s� | j t j | j j d � | j | j j d � d � | j j d d � } | j j d d � } | j j | d � } | j j | d � } | j | j j | � d � | j | j j | � d � | j | j j | � d � | j | j j | � d � | j j | d d � | j | j j | � d � | j | j j | � d � | j j | � | j | j j | � d � | j j | � | j | j j | � d � | j j | � | j t j | j j | � d S( Nt whatR i R� i (
RF RG R R� Rk R R� R� R� R� ( R R� R� t c1t c2( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyRz s s& c C s� | j t j | j j d d � | j t j | j j d d d d �| j t j | j j d d d d �| j | j j | j j d d d t �� � | j | j j | j j d d d t �� � | j t j | j j d d � | j j d d d � } | j | d � | j t j | j j d d d � | j t j | j j d d t
d � � d } | j j d d d | f �} | j | j j | d � | j r�| f n | � | j | j j | d d �| j r�| f n | � | j j | d | j j | j j | d d �� �| j | j j | d d �| j r@| f n | � | j | j j | � t � | j j | d d �| j | j j | d d �� | j j d d d
d d | g �} | j | j j | d
d �| j r�d
d | f n d | � | j j | d
g �| j | j j | d
d �� | j j | d
d �| j | j j | d
d �| j rod n d � | j j d d d d d | | f f �} | j | j j | d d �| j r�d d | | f f n
d | | f � | j | j j | j j d d d d �d d �d � | j | j j | j j d d d | �d d �| � | j j d d d � } | j | d � | j j d d d � } | j | d � | j t j | j j d d t � | j t j | j j d d d � d S( NR� R� R t opent pleaset middles
first-itemu ábaR� t tagsi i R R s 1 2 %ss 1 2s a b cs %s %ss {a b c} {%s %s}R8 s
Label herei R# g s 0.0( i i ( R R ( RF RG R R� R� R� R� RU R� R R t itemR RH R> t splitlistR R! ( R t itemidR- R� ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_insert_item� sh ..
4 $ !!"c C s� | j t j | j j d � | j t j | j j d � | j t j | j j d � | j t j | j j d � | j j d d � } | j j d d � } | j j | d � } | j j | d � } | j j | d � } | j | j j
� d
� | j j | | f � | j | j j
� | | f � | j j | � | j | j j
� | f � | j j | | f � | j | j j
� | | | f � | j j | � | j | j j
� | | | | f � | j j | | f � | j | j j
� | | | f � | j j | � | j | j j
� | | f � | j j | | f � | j | j j
� | | f � | j j | � | j | j j
� | f � | j j d d d d �| j j d � | j | j j
� d � | j j d d d d �| j j d � | j | j j
� d � t rl| j j d d d t d � �| j j t d � � | j | j j
� t d � f � n | j j d d d d �| j j d � | j | j j
� t r�t d � n d f � d S(
NR� R R� R� s with spacess {braces
unicode\u20acs bytes€s bytes\u20ac( ( s with spaces( s {brace(
RF RG R R� t
selection_sett
selection_addt selection_removet selection_toggleR� R t selectionR R ( R R� R� R� R� t c3( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_selection� sR "%" %c C sP d d g | j d <| j j d d d d d g �} | j | j j | � i d d 6d d 6� | j j | d d � | j | j j | d d �| j r� d n d � d g | j d <| j | j j | � i d d 6� | j j | d d � | j | j j | d
d �d � | j | j j | d d �| j r:d n d � | j j | d d � | j | j j | d � | j r~d n d
� | j | j j | d d �| j r�d n d � | j | j j | � | j r�i d d 6n
i d
d 6� | j t j | j j | d � | j t j | j j | d d � | j t j | j j d � d S( Nt At BR� R R� R� R� R# s a aR� s b ai{ t 123s 123 at notme( R� R� ( R# R� ( i{ R� (
R� R� R R R� RH R RF RG R ( R R� ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyRW s, !*#"$ "c s� g � | j j d d d d g �} | j j d d d d g �} | j j d d � f d � � | j j d d � f d � � | j j � | j j � | j j � t � } t � } xq t d d
d � D]] } t | � d k r� Pn | j j | � } | r� | | k r� | j
| � | j
| � q� q� W| j t | � d � x! | D] } t | j d | � qJW| j t � � d
� xA t
� d d d � � d d d � � D] } | j | d � q�Wd S( NR R� R� t calls <ButtonPress-1>c s
� j d � S( Ni ( R� ( R� ( t events( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� ; R s <ButtonRelease-1>c s
� j d � S( Ni ( R� ( R� ( R� ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� = R i id i
i i i ( i i ( R� R� t tag_bindR? R@ R� R Rm R� t identify_rowR R R t zip( R R� R� t pos_yt foundRp R� R� R� ( ( R� s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt
test_tag_bind6 s2
0c C s� | j t | j j � | j t j | j j d d d �| j j d d d �| j t | j j d d � � d � | j t | j j d d d �� d � | j | j j d � t
� d S( NR� t skyt blueR� ( RF t TypeErrorR� t
tag_configureRG R R R� RH R R! ( R ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_tag_configureX s
!c C s� | j j d d d d d d g �} | j j d d d d d d g �} | j t | j j � | j t | j j d d � | j | j j d | � � | j | j j d | � � | j | j j d | � � | j | j j d | � � | j | j j d
| � � | j | j j d
| � � | j | j j d � | f � | j | j j d � | f � | j | j j d
� d � d S( NR R� R8 s Item 1R� t tag1s Item 2t tag2s non-existingt tag3( ( R� R� RF R� t tag_hasR R� R� R ( R R� R� ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt test_tag_hasd s $$ ( R R� R] R� R^ R! R� R� R. R` R� R� ( R4 R5 Rc R; R R� R� R� R� R� R� R� R� R� R� R� R� R� R� Rz R� R� RW R� R� R� ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� [ s4 * " M 6 ! " t
SeparatorTestc B s e Z d Z d Z d � Z RS( R R] R R. R` R c K s t j | j | � S( N( R< t SeparatorR> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR | s ( R R] R R. R` ( R4 R5 Rc R/ R ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� t s t SizegripTestc B s e Z d Z d � Z RS( R R] R. R` c K s t j | j | � S( N( R< t SizegripR> ( R Rb ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR � s ( R R] R. R` ( R4 R5 Rc R ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyR� � s t __main__(5 t unittestt TkinterRG R R< t test.test_supportR R R R R� t test_functionsR t supportR R R R t widget_testsR
R R R
R R R R R t TestCaseR6 RY R[ Rd R~ R� R� R� R� R� R
R, R4 R> RX t skipIfR� Rc Re R� R� R� t tests_guiR4 ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_ttk/test_widgets.pyt <module> sr " ":
' ; 0 � | � 3 j "
� � � test/runtktests.py 0000644 00000004305 15032720555 0010331 0 ustar 00 """
Use this module to get and run all tk tests.
Tkinter tests should live in a package inside the directory where this file
lives, like test_tkinter.
Extensions also should live in packages following the same rule as above.
"""
import os
import sys
import unittest
import importlib
import test.test_support
this_dir_path = os.path.abspath(os.path.dirname(__file__))
def is_package(path):
for name in os.listdir(path):
if name in ('__init__.py', '__init__.pyc', '__init.pyo'):
return True
return False
def get_tests_modules(basepath=this_dir_path, gui=True, packages=None):
"""This will import and yield modules whose names start with test_
and are inside packages found in the path starting at basepath.
If packages is specified it should contain package names that want
their tests collected.
"""
py_ext = '.py'
for dirpath, dirnames, filenames in os.walk(basepath):
for dirname in list(dirnames):
if dirname[0] == '.':
dirnames.remove(dirname)
if is_package(dirpath) and filenames:
pkg_name = dirpath[len(basepath) + len(os.sep):].replace('/', '.')
if packages and pkg_name not in packages:
continue
filenames = filter(
lambda x: x.startswith('test_') and x.endswith(py_ext),
filenames)
for name in filenames:
try:
yield importlib.import_module(
".%s" % name[:-len(py_ext)], pkg_name)
except test.test_support.ResourceDenied:
if gui:
raise
def get_tests(text=True, gui=True, packages=None):
"""Yield all the tests in the modules found by get_tests_modules.
If nogui is True, only tests that do not require a GUI will be
returned."""
attrs = []
if text:
attrs.append('tests_nogui')
if gui:
attrs.append('tests_gui')
for module in get_tests_modules(gui=gui, packages=packages):
for attr in attrs:
for test in getattr(module, attr, ()):
yield test
if __name__ == "__main__":
test.test_support.run_unittest(*get_tests())
test/test_tkinter/test_variables.py 0000644 00000020305 15032720555 0013627 0 ustar 00 import unittest
import gc
from Tkinter import (Variable, StringVar, IntVar, DoubleVar, BooleanVar, Tcl,
TclError)
class TestBase(unittest.TestCase):
def setUp(self):
self.root = Tcl()
def tearDown(self):
del self.root
class TestVariable(TestBase):
def info_exists(self, *args):
return self.root.getboolean(self.root.call("info", "exists", *args))
def test_default(self):
v = Variable(self.root)
self.assertEqual("", v.get())
self.assertRegexpMatches(str(v), r"^PY_VAR(\d+)$")
def test_name_and_value(self):
v = Variable(self.root, "sample string", "varname")
self.assertEqual("sample string", v.get())
self.assertEqual("varname", str(v))
def test___del__(self):
self.assertFalse(self.info_exists("varname"))
v = Variable(self.root, "sample string", "varname")
self.assertTrue(self.info_exists("varname"))
del v
self.assertFalse(self.info_exists("varname"))
def test_dont_unset_not_existing(self):
self.assertFalse(self.info_exists("varname"))
v1 = Variable(self.root, name="name")
v2 = Variable(self.root, name="name")
del v1
self.assertFalse(self.info_exists("name"))
# shouldn't raise exception
del v2
self.assertFalse(self.info_exists("name"))
def test___eq__(self):
# values doesn't matter, only class and name are checked
v1 = Variable(self.root, name="abc")
v2 = Variable(self.root, name="abc")
self.assertEqual(v1, v2)
v3 = Variable(self.root, name="abc")
v4 = StringVar(self.root, name="abc")
self.assertNotEqual(v3, v4)
def test_invalid_name(self):
with self.assertRaises(TypeError):
Variable(self.root, name=123)
def test_null_in_name(self):
with self.assertRaises(ValueError):
Variable(self.root, name='var\x00name')
with self.assertRaises(ValueError):
self.root.globalsetvar('var\x00name', "value")
with self.assertRaises(ValueError):
self.root.setvar('var\x00name', "value")
def test_trace(self):
v = Variable(self.root)
vname = str(v)
trace = []
def read_tracer(*args):
trace.append(('read',) + args)
def write_tracer(*args):
trace.append(('write',) + args)
cb1 = v.trace_variable('r', read_tracer)
cb2 = v.trace_variable('wu', write_tracer)
self.assertEqual(sorted(v.trace_vinfo()), [('r', cb1), ('wu', cb2)])
self.assertEqual(trace, [])
v.set('spam')
self.assertEqual(trace, [('write', vname, '', 'w')])
trace = []
v.get()
self.assertEqual(trace, [('read', vname, '', 'r')])
trace = []
info = sorted(v.trace_vinfo())
v.trace_vdelete('w', cb1) # Wrong mode
self.assertEqual(sorted(v.trace_vinfo()), info)
with self.assertRaises(TclError):
v.trace_vdelete('r', 'spam') # Wrong command name
self.assertEqual(sorted(v.trace_vinfo()), info)
v.trace_vdelete('r', (cb1, 43)) # Wrong arguments
self.assertEqual(sorted(v.trace_vinfo()), info)
v.get()
self.assertEqual(trace, [('read', vname, '', 'r')])
trace = []
v.trace_vdelete('r', cb1)
self.assertEqual(v.trace_vinfo(), [('wu', cb2)])
v.get()
self.assertEqual(trace, [])
trace = []
del write_tracer
gc.collect()
v.set('eggs')
self.assertEqual(trace, [('write', vname, '', 'w')])
#trace = []
#del v
#gc.collect()
#self.assertEqual(trace, [('write', vname, '', 'u')])
class TestStringVar(TestBase):
def test_default(self):
v = StringVar(self.root)
self.assertEqual("", v.get())
def test_get(self):
v = StringVar(self.root, "abc", "name")
self.assertEqual("abc", v.get())
self.root.globalsetvar("name", "value")
self.assertEqual("value", v.get())
def test_get_null(self):
v = StringVar(self.root, "abc\x00def", "name")
self.assertEqual("abc\x00def", v.get())
self.root.globalsetvar("name", "val\x00ue")
self.assertEqual("val\x00ue", v.get())
class TestIntVar(TestBase):
def test_default(self):
v = IntVar(self.root)
self.assertEqual(0, v.get())
def test_get(self):
v = IntVar(self.root, 123, "name")
self.assertEqual(123, v.get())
self.root.globalsetvar("name", "345")
self.assertEqual(345, v.get())
def test_invalid_value(self):
v = IntVar(self.root, name="name")
self.root.globalsetvar("name", "value")
with self.assertRaises(ValueError):
v.get()
self.root.globalsetvar("name", "345.0")
with self.assertRaises(ValueError):
v.get()
class TestDoubleVar(TestBase):
def test_default(self):
v = DoubleVar(self.root)
self.assertEqual(0.0, v.get())
def test_get(self):
v = DoubleVar(self.root, 1.23, "name")
self.assertAlmostEqual(1.23, v.get())
self.root.globalsetvar("name", "3.45")
self.assertAlmostEqual(3.45, v.get())
def test_get_from_int(self):
v = DoubleVar(self.root, 1.23, "name")
self.assertAlmostEqual(1.23, v.get())
self.root.globalsetvar("name", "3.45")
self.assertAlmostEqual(3.45, v.get())
self.root.globalsetvar("name", "456")
self.assertAlmostEqual(456, v.get())
def test_invalid_value(self):
v = DoubleVar(self.root, name="name")
self.root.globalsetvar("name", "value")
with self.assertRaises(ValueError):
v.get()
class TestBooleanVar(TestBase):
def test_default(self):
v = BooleanVar(self.root)
self.assertIs(v.get(), False)
def test_get(self):
v = BooleanVar(self.root, True, "name")
self.assertIs(v.get(), True)
self.root.globalsetvar("name", "0")
self.assertIs(v.get(), False)
self.root.globalsetvar("name", 42 if self.root.wantobjects() else 1)
self.assertIs(v.get(), True)
self.root.globalsetvar("name", 0)
self.assertIs(v.get(), False)
self.root.globalsetvar("name", 42L if self.root.wantobjects() else 1L)
self.assertIs(v.get(), True)
self.root.globalsetvar("name", 0L)
self.assertIs(v.get(), False)
self.root.globalsetvar("name", "on")
self.assertIs(v.get(), True)
self.root.globalsetvar("name", u"0")
self.assertIs(v.get(), False)
self.root.globalsetvar("name", u"on")
self.assertIs(v.get(), True)
def test_set(self):
true = 1 if self.root.wantobjects() else "1"
false = 0 if self.root.wantobjects() else "0"
v = BooleanVar(self.root, name="name")
v.set(True)
self.assertEqual(self.root.globalgetvar("name"), true)
v.set("0")
self.assertEqual(self.root.globalgetvar("name"), false)
v.set(42)
self.assertEqual(self.root.globalgetvar("name"), true)
v.set(0)
self.assertEqual(self.root.globalgetvar("name"), false)
v.set(42L)
self.assertEqual(self.root.globalgetvar("name"), true)
v.set(0L)
self.assertEqual(self.root.globalgetvar("name"), false)
v.set("on")
self.assertEqual(self.root.globalgetvar("name"), true)
v.set(u"0")
self.assertEqual(self.root.globalgetvar("name"), false)
v.set(u"on")
self.assertEqual(self.root.globalgetvar("name"), true)
def test_invalid_value_domain(self):
false = 0 if self.root.wantobjects() else "0"
v = BooleanVar(self.root, name="name")
with self.assertRaises(TclError):
v.set("value")
self.assertEqual(self.root.globalgetvar("name"), false)
self.root.globalsetvar("name", "value")
with self.assertRaises(TclError):
v.get()
self.root.globalsetvar("name", "1.0")
with self.assertRaises(TclError):
v.get()
tests_gui = (TestVariable, TestStringVar, TestIntVar,
TestDoubleVar, TestBooleanVar)
if __name__ == "__main__":
from test.support import run_unittest
run_unittest(*tests_gui)
test/test_tkinter/test_misc.pyo 0000644 00000007400 15032720555 0012772 0 ustar 00 �
z fc @ s� d d l Z d d l Z d d l m Z m Z d d l m Z e d � d e e j f d � � YZ e f Z
e d k r� e e
� n d S( i����N( t requirest run_unittest( t AbstractTkTestt guit MiscTestc B s# e Z d � Z d � Z d � Z RS( c s� | j } i d d 6� d d � f d � } | j | j d � � d � d <| j d | � } | j | | j j d d � � | j j | j j d d | � � \ } } | j � | j � d d � | j t
j � � | j j | � Wd QXd � d <| j d | d d � } | j � | j � d d � | j d
| � } | j | | j j d d � � | j j | j j d d | � � \ } } | j | � | j � d d � | j t
j � � | j j | � Wd QXd S( Ni t counti c s | | � d <d S( NR ( ( t startt step( t cbcount( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_misc.pyt callback s t aftert infoi* i i5 i� (
t roott assertIsNoneR
t assertInt tkt callt splitlistt updatet assertEqualt assertRaisest tkintert TclErrort after_cancel( t selfR R t timer1t scriptt _( ( R s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_misc.pyt
test_after
s.
*
*
c s� | j } i d d 6� d d � f d � } d � d <| j | � } | j | | j j d d � � | j j | j j d d | � � \ } } | j � | j � d d � | j t j
� � | j j | � Wd QXd � d <| j | d d � } | j � | j � d d � | j | � } | j | | j j d d � � | j j | j j d d | � � \ } } | j | � | j � d d � | j t j
� � | j j | � Wd QXd S(
Ni R i c s | | � d <d S( NR ( ( R R ( R ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_misc.pyR 1 s R
R i* i i5 ( R t
after_idleR R R R t update_idletasksR R R R R ( R R R t idle1R R ( ( R s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_misc.pyt test_after_idle- s,
*
*
c s | j } i d d 6� � f d � } | j d | � } | j | � } | j t � � | j d � Wd QXd � d <| j j | j j d d | � � \ } } | j j | � | j
� d d � | j | � | j t j � � | j j | � Wd QX| j
� d d � | j t j � � | j j d d | � Wd QX| j | � d � d <| j j | j j d d | � � \ } } | j j | � | j
� d d � | j | � | j t j � � | j j | � Wd QX| j
� d d � | j t j � � | j j d d | � Wd QXd S( Ni R c s � d c d 7<d S( NR i ( ( ( R ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_misc.pyR Q s i� R
R i (
R R
R R t
ValueErrorR t NoneR R R R R R ( R R R R R R R ( ( R s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_misc.pyt test_after_cancelM s8
*
*
( t __name__t
__module__R R R# ( ( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_misc.pyR s # t __main__( t unittestt TkinterR t test.test_supportR R t test_ttk.supportR t TestCaseR t tests_guiR$ ( ( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_misc.pyt <module> s
o test/test_tkinter/test_widgets.py 0000644 00000134207 15032720555 0013334 0 ustar 00 import unittest
import Tkinter as tkinter
from Tkinter import TclError
import os
import sys
from test.test_support import requires, run_unittest
from test_ttk.support import (tcl_version, requires_tcl, get_tk_patchlevel,
widget_eq)
from widget_tests import (
add_standard_options, noconv, noconv_meth, int_round, pixels_round,
AbstractWidgetTest, StandardOptionsTests,
IntegerSizeTests, PixelSizeTests,
setUpModule)
requires('gui')
class AbstractToplevelTest(AbstractWidgetTest, PixelSizeTests):
_conv_pad_pixels = noconv_meth
def test_class(self):
widget = self.create()
self.assertEqual(widget['class'],
widget.__class__.__name__.title())
self.checkInvalidParam(widget, 'class', 'Foo',
errmsg="can't modify -class option after widget is created")
widget2 = self.create(class_='Foo')
self.assertEqual(widget2['class'], 'Foo')
def test_colormap(self):
widget = self.create()
self.assertEqual(widget['colormap'], '')
self.checkInvalidParam(widget, 'colormap', 'new',
errmsg="can't modify -colormap option after widget is created")
widget2 = self.create(colormap='new')
self.assertEqual(widget2['colormap'], 'new')
def test_container(self):
widget = self.create()
self.assertEqual(widget['container'], 0 if self.wantobjects else '0')
self.checkInvalidParam(widget, 'container', 1,
errmsg="can't modify -container option after widget is created")
widget2 = self.create(container=True)
self.assertEqual(widget2['container'], 1 if self.wantobjects else '1')
def test_visual(self):
widget = self.create()
self.assertEqual(widget['visual'], '')
self.checkInvalidParam(widget, 'visual', 'default',
errmsg="can't modify -visual option after widget is created")
widget2 = self.create(visual='default')
self.assertEqual(widget2['visual'], 'default')
@add_standard_options(StandardOptionsTests)
class ToplevelTest(AbstractToplevelTest, unittest.TestCase):
OPTIONS = (
'background', 'borderwidth',
'class', 'colormap', 'container', 'cursor', 'height',
'highlightbackground', 'highlightcolor', 'highlightthickness',
'menu', 'padx', 'pady', 'relief', 'screen',
'takefocus', 'use', 'visual', 'width',
)
def create(self, **kwargs):
return tkinter.Toplevel(self.root, **kwargs)
def test_menu(self):
widget = self.create()
menu = tkinter.Menu(self.root)
self.checkParam(widget, 'menu', menu, eq=widget_eq)
self.checkParam(widget, 'menu', '')
def test_screen(self):
widget = self.create()
self.assertEqual(widget['screen'], '')
try:
display = os.environ['DISPLAY']
except KeyError:
self.skipTest('No $DISPLAY set.')
self.checkInvalidParam(widget, 'screen', display,
errmsg="can't modify -screen option after widget is created")
widget2 = self.create(screen=display)
self.assertEqual(widget2['screen'], display)
def test_use(self):
widget = self.create()
self.assertEqual(widget['use'], '')
parent = self.create(container=True)
# hex() adds the 'L' suffix for longs
wid = '%#x' % parent.winfo_id()
widget2 = self.create(use=wid)
self.assertEqual(widget2['use'], wid)
@add_standard_options(StandardOptionsTests)
class FrameTest(AbstractToplevelTest, unittest.TestCase):
OPTIONS = (
'background', 'borderwidth',
'class', 'colormap', 'container', 'cursor', 'height',
'highlightbackground', 'highlightcolor', 'highlightthickness',
'padx', 'pady', 'relief', 'takefocus', 'visual', 'width',
)
def create(self, **kwargs):
return tkinter.Frame(self.root, **kwargs)
@add_standard_options(StandardOptionsTests)
class LabelFrameTest(AbstractToplevelTest, unittest.TestCase):
OPTIONS = (
'background', 'borderwidth',
'class', 'colormap', 'container', 'cursor',
'font', 'foreground', 'height',
'highlightbackground', 'highlightcolor', 'highlightthickness',
'labelanchor', 'labelwidget', 'padx', 'pady', 'relief',
'takefocus', 'text', 'visual', 'width',
)
def create(self, **kwargs):
return tkinter.LabelFrame(self.root, **kwargs)
def test_labelanchor(self):
widget = self.create()
self.checkEnumParam(widget, 'labelanchor',
'e', 'en', 'es', 'n', 'ne', 'nw',
's', 'se', 'sw', 'w', 'wn', 'ws')
self.checkInvalidParam(widget, 'labelanchor', 'center')
def test_labelwidget(self):
widget = self.create()
label = tkinter.Label(self.root, text='Mupp', name='foo')
self.checkParam(widget, 'labelwidget', label, expected='.foo')
label.destroy()
class AbstractLabelTest(AbstractWidgetTest, IntegerSizeTests):
_conv_pixels = noconv_meth
def test_highlightthickness(self):
widget = self.create()
self.checkPixelsParam(widget, 'highlightthickness',
0, 1.3, 2.6, 6, -2, '10p')
@add_standard_options(StandardOptionsTests)
class LabelTest(AbstractLabelTest, unittest.TestCase):
OPTIONS = (
'activebackground', 'activeforeground', 'anchor',
'background', 'bitmap', 'borderwidth', 'compound', 'cursor',
'disabledforeground', 'font', 'foreground', 'height',
'highlightbackground', 'highlightcolor', 'highlightthickness',
'image', 'justify', 'padx', 'pady', 'relief', 'state',
'takefocus', 'text', 'textvariable',
'underline', 'width', 'wraplength',
)
def create(self, **kwargs):
return tkinter.Label(self.root, **kwargs)
@add_standard_options(StandardOptionsTests)
class ButtonTest(AbstractLabelTest, unittest.TestCase):
OPTIONS = (
'activebackground', 'activeforeground', 'anchor',
'background', 'bitmap', 'borderwidth',
'command', 'compound', 'cursor', 'default',
'disabledforeground', 'font', 'foreground', 'height',
'highlightbackground', 'highlightcolor', 'highlightthickness',
'image', 'justify', 'overrelief', 'padx', 'pady', 'relief',
'repeatdelay', 'repeatinterval',
'state', 'takefocus', 'text', 'textvariable',
'underline', 'width', 'wraplength')
def create(self, **kwargs):
return tkinter.Button(self.root, **kwargs)
def test_default(self):
widget = self.create()
self.checkEnumParam(widget, 'default', 'active', 'disabled', 'normal')
@add_standard_options(StandardOptionsTests)
class CheckbuttonTest(AbstractLabelTest, unittest.TestCase):
OPTIONS = (
'activebackground', 'activeforeground', 'anchor',
'background', 'bitmap', 'borderwidth',
'command', 'compound', 'cursor',
'disabledforeground', 'font', 'foreground', 'height',
'highlightbackground', 'highlightcolor', 'highlightthickness',
'image', 'indicatoron', 'justify',
'offrelief', 'offvalue', 'onvalue', 'overrelief',
'padx', 'pady', 'relief', 'selectcolor', 'selectimage', 'state',
'takefocus', 'text', 'textvariable',
'tristateimage', 'tristatevalue',
'underline', 'variable', 'width', 'wraplength',
)
def create(self, **kwargs):
return tkinter.Checkbutton(self.root, **kwargs)
def test_offvalue(self):
widget = self.create()
self.checkParams(widget, 'offvalue', 1, 2.3, '', 'any string')
def test_onvalue(self):
widget = self.create()
self.checkParams(widget, 'onvalue', 1, 2.3, '', 'any string')
@add_standard_options(StandardOptionsTests)
class RadiobuttonTest(AbstractLabelTest, unittest.TestCase):
OPTIONS = (
'activebackground', 'activeforeground', 'anchor',
'background', 'bitmap', 'borderwidth',
'command', 'compound', 'cursor',
'disabledforeground', 'font', 'foreground', 'height',
'highlightbackground', 'highlightcolor', 'highlightthickness',
'image', 'indicatoron', 'justify', 'offrelief', 'overrelief',
'padx', 'pady', 'relief', 'selectcolor', 'selectimage', 'state',
'takefocus', 'text', 'textvariable',
'tristateimage', 'tristatevalue',
'underline', 'value', 'variable', 'width', 'wraplength',
)
def create(self, **kwargs):
return tkinter.Radiobutton(self.root, **kwargs)
def test_value(self):
widget = self.create()
self.checkParams(widget, 'value', 1, 2.3, '', 'any string')
@add_standard_options(StandardOptionsTests)
class MenubuttonTest(AbstractLabelTest, unittest.TestCase):
OPTIONS = (
'activebackground', 'activeforeground', 'anchor',
'background', 'bitmap', 'borderwidth',
'compound', 'cursor', 'direction',
'disabledforeground', 'font', 'foreground', 'height',
'highlightbackground', 'highlightcolor', 'highlightthickness',
'image', 'indicatoron', 'justify', 'menu',
'padx', 'pady', 'relief', 'state',
'takefocus', 'text', 'textvariable',
'underline', 'width', 'wraplength',
)
_conv_pixels = staticmethod(pixels_round)
def create(self, **kwargs):
return tkinter.Menubutton(self.root, **kwargs)
def test_direction(self):
widget = self.create()
self.checkEnumParam(widget, 'direction',
'above', 'below', 'flush', 'left', 'right')
def test_height(self):
widget = self.create()
self.checkIntegerParam(widget, 'height', 100, -100, 0, conv=str)
test_highlightthickness = StandardOptionsTests.test_highlightthickness.im_func
@unittest.skipIf(sys.platform == 'darwin',
'crashes with Cocoa Tk (issue19733)')
def test_image(self):
widget = self.create()
image = tkinter.PhotoImage(master=self.root, name='image1')
self.checkParam(widget, 'image', image, conv=str)
errmsg = 'image "spam" doesn\'t exist'
with self.assertRaises(tkinter.TclError) as cm:
widget['image'] = 'spam'
if errmsg is not None:
self.assertEqual(str(cm.exception), errmsg)
with self.assertRaises(tkinter.TclError) as cm:
widget.configure({'image': 'spam'})
if errmsg is not None:
self.assertEqual(str(cm.exception), errmsg)
def test_menu(self):
widget = self.create()
menu = tkinter.Menu(widget, name='menu')
self.checkParam(widget, 'menu', menu, eq=widget_eq)
menu.destroy()
def test_padx(self):
widget = self.create()
self.checkPixelsParam(widget, 'padx', 3, 4.4, 5.6, '12m')
self.checkParam(widget, 'padx', -2, expected=0)
def test_pady(self):
widget = self.create()
self.checkPixelsParam(widget, 'pady', 3, 4.4, 5.6, '12m')
self.checkParam(widget, 'pady', -2, expected=0)
def test_width(self):
widget = self.create()
self.checkIntegerParam(widget, 'width', 402, -402, 0, conv=str)
class OptionMenuTest(MenubuttonTest, unittest.TestCase):
def create(self, default='b', values=('a', 'b', 'c'), **kwargs):
return tkinter.OptionMenu(self.root, None, default, *values, **kwargs)
@add_standard_options(IntegerSizeTests, StandardOptionsTests)
class EntryTest(AbstractWidgetTest, unittest.TestCase):
OPTIONS = (
'background', 'borderwidth', 'cursor',
'disabledbackground', 'disabledforeground',
'exportselection', 'font', 'foreground',
'highlightbackground', 'highlightcolor', 'highlightthickness',
'insertbackground', 'insertborderwidth',
'insertofftime', 'insertontime', 'insertwidth',
'invalidcommand', 'justify', 'readonlybackground', 'relief',
'selectbackground', 'selectborderwidth', 'selectforeground',
'show', 'state', 'takefocus', 'textvariable',
'validate', 'validatecommand', 'width', 'xscrollcommand',
)
def create(self, **kwargs):
return tkinter.Entry(self.root, **kwargs)
def test_disabledbackground(self):
widget = self.create()
self.checkColorParam(widget, 'disabledbackground')
def test_insertborderwidth(self):
widget = self.create(insertwidth=100)
self.checkPixelsParam(widget, 'insertborderwidth',
0, 1.3, 2.6, 6, -2, '10p')
# insertborderwidth is bounded above by a half of insertwidth.
self.checkParam(widget, 'insertborderwidth', 60, expected=100//2)
def test_insertwidth(self):
widget = self.create()
self.checkPixelsParam(widget, 'insertwidth', 1.3, 3.6, '10p')
self.checkParam(widget, 'insertwidth', 0.1, expected=2)
self.checkParam(widget, 'insertwidth', -2, expected=2)
if pixels_round(0.9) <= 0:
self.checkParam(widget, 'insertwidth', 0.9, expected=2)
else:
self.checkParam(widget, 'insertwidth', 0.9, expected=1)
def test_invalidcommand(self):
widget = self.create()
self.checkCommandParam(widget, 'invalidcommand')
self.checkCommandParam(widget, 'invcmd')
def test_readonlybackground(self):
widget = self.create()
self.checkColorParam(widget, 'readonlybackground')
def test_show(self):
widget = self.create()
self.checkParam(widget, 'show', '*')
self.checkParam(widget, 'show', '')
self.checkParam(widget, 'show', ' ')
def test_state(self):
widget = self.create()
self.checkEnumParam(widget, 'state',
'disabled', 'normal', 'readonly')
def test_validate(self):
widget = self.create()
self.checkEnumParam(widget, 'validate',
'all', 'key', 'focus', 'focusin', 'focusout', 'none')
def test_validatecommand(self):
widget = self.create()
self.checkCommandParam(widget, 'validatecommand')
self.checkCommandParam(widget, 'vcmd')
@add_standard_options(StandardOptionsTests)
class SpinboxTest(EntryTest, unittest.TestCase):
OPTIONS = (
'activebackground', 'background', 'borderwidth',
'buttonbackground', 'buttoncursor', 'buttondownrelief', 'buttonuprelief',
'command', 'cursor', 'disabledbackground', 'disabledforeground',
'exportselection', 'font', 'foreground', 'format', 'from',
'highlightbackground', 'highlightcolor', 'highlightthickness',
'increment',
'insertbackground', 'insertborderwidth',
'insertofftime', 'insertontime', 'insertwidth',
'invalidcommand', 'justify', 'relief', 'readonlybackground',
'repeatdelay', 'repeatinterval',
'selectbackground', 'selectborderwidth', 'selectforeground',
'state', 'takefocus', 'textvariable', 'to',
'validate', 'validatecommand', 'values',
'width', 'wrap', 'xscrollcommand',
)
def create(self, **kwargs):
return tkinter.Spinbox(self.root, **kwargs)
test_show = None
def test_buttonbackground(self):
widget = self.create()
self.checkColorParam(widget, 'buttonbackground')
def test_buttoncursor(self):
widget = self.create()
self.checkCursorParam(widget, 'buttoncursor')
def test_buttondownrelief(self):
widget = self.create()
self.checkReliefParam(widget, 'buttondownrelief')
def test_buttonuprelief(self):
widget = self.create()
self.checkReliefParam(widget, 'buttonuprelief')
def test_format(self):
widget = self.create()
self.checkParam(widget, 'format', '%2f')
self.checkParam(widget, 'format', '%2.2f')
self.checkParam(widget, 'format', '%.2f')
self.checkParam(widget, 'format', '%2.f')
self.checkInvalidParam(widget, 'format', '%2e-1f')
self.checkInvalidParam(widget, 'format', '2.2')
self.checkInvalidParam(widget, 'format', '%2.-2f')
self.checkParam(widget, 'format', '%-2.02f')
self.checkParam(widget, 'format', '% 2.02f')
self.checkParam(widget, 'format', '% -2.200f')
self.checkParam(widget, 'format', '%09.200f')
self.checkInvalidParam(widget, 'format', '%d')
def test_from(self):
widget = self.create()
self.checkParam(widget, 'to', 100.0)
self.checkFloatParam(widget, 'from', -10, 10.2, 11.7)
self.checkInvalidParam(widget, 'from', 200,
errmsg='-to value must be greater than -from value')
def test_increment(self):
widget = self.create()
self.checkFloatParam(widget, 'increment', -1, 1, 10.2, 12.8, 0)
def test_to(self):
widget = self.create()
self.checkParam(widget, 'from', -100.0)
self.checkFloatParam(widget, 'to', -10, 10.2, 11.7)
self.checkInvalidParam(widget, 'to', -200,
errmsg='-to value must be greater than -from value')
def test_values(self):
# XXX
widget = self.create()
self.assertEqual(widget['values'], '')
self.checkParam(widget, 'values', 'mon tue wed thur')
self.checkParam(widget, 'values', ('mon', 'tue', 'wed', 'thur'),
expected='mon tue wed thur')
self.checkParam(widget, 'values', (42, 3.14, '', 'any string'),
expected='42 3.14 {} {any string}')
self.checkParam(widget, 'values', '')
def test_wrap(self):
widget = self.create()
self.checkBooleanParam(widget, 'wrap')
def test_bbox(self):
widget = self.create()
self.assertIsBoundingBox(widget.bbox(0))
self.assertRaises(tkinter.TclError, widget.bbox, 'noindex')
self.assertRaises(tkinter.TclError, widget.bbox, None)
self.assertRaises(TypeError, widget.bbox)
self.assertRaises(TypeError, widget.bbox, 0, 1)
def test_selection_element(self):
widget = self.create()
self.assertEqual(widget.selection_element(), "none")
widget.selection_element("buttonup")
self.assertEqual(widget.selection_element(), "buttonup")
widget.selection_element("buttondown")
self.assertEqual(widget.selection_element(), "buttondown")
@add_standard_options(StandardOptionsTests)
class TextTest(AbstractWidgetTest, unittest.TestCase):
OPTIONS = (
'autoseparators', 'background', 'blockcursor', 'borderwidth',
'cursor', 'endline', 'exportselection',
'font', 'foreground', 'height',
'highlightbackground', 'highlightcolor', 'highlightthickness',
'inactiveselectbackground', 'insertbackground', 'insertborderwidth',
'insertofftime', 'insertontime', 'insertunfocussed', 'insertwidth',
'maxundo', 'padx', 'pady', 'relief',
'selectbackground', 'selectborderwidth', 'selectforeground',
'setgrid', 'spacing1', 'spacing2', 'spacing3', 'startline', 'state',
'tabs', 'tabstyle', 'takefocus', 'undo', 'width', 'wrap',
'xscrollcommand', 'yscrollcommand',
)
if tcl_version < (8, 5):
_stringify = True
def create(self, **kwargs):
return tkinter.Text(self.root, **kwargs)
def test_autoseparators(self):
widget = self.create()
self.checkBooleanParam(widget, 'autoseparators')
@requires_tcl(8, 5)
def test_blockcursor(self):
widget = self.create()
self.checkBooleanParam(widget, 'blockcursor')
@requires_tcl(8, 5)
def test_endline(self):
widget = self.create()
text = '\n'.join('Line %d' for i in range(100))
widget.insert('end', text)
self.checkParam(widget, 'endline', 200, expected='')
self.checkParam(widget, 'endline', -10, expected='')
self.checkInvalidParam(widget, 'endline', 'spam',
errmsg='expected integer but got "spam"')
self.checkParam(widget, 'endline', 50)
self.checkParam(widget, 'startline', 15)
self.checkInvalidParam(widget, 'endline', 10,
errmsg='-startline must be less than or equal to -endline')
def test_height(self):
widget = self.create()
self.checkPixelsParam(widget, 'height', 100, 101.2, 102.6, '3c')
self.checkParam(widget, 'height', -100, expected=1)
self.checkParam(widget, 'height', 0, expected=1)
def test_maxundo(self):
widget = self.create()
self.checkIntegerParam(widget, 'maxundo', 0, 5, -1)
@requires_tcl(8, 5)
def test_inactiveselectbackground(self):
widget = self.create()
self.checkColorParam(widget, 'inactiveselectbackground')
@requires_tcl(8, 6)
def test_insertunfocussed(self):
widget = self.create()
self.checkEnumParam(widget, 'insertunfocussed',
'hollow', 'none', 'solid')
def test_selectborderwidth(self):
widget = self.create()
self.checkPixelsParam(widget, 'selectborderwidth',
1.3, 2.6, -2, '10p', conv=noconv,
keep_orig=tcl_version >= (8, 5))
def test_spacing1(self):
widget = self.create()
self.checkPixelsParam(widget, 'spacing1', 20, 21.4, 22.6, '0.5c')
self.checkParam(widget, 'spacing1', -5, expected=0)
def test_spacing2(self):
widget = self.create()
self.checkPixelsParam(widget, 'spacing2', 5, 6.4, 7.6, '0.1c')
self.checkParam(widget, 'spacing2', -1, expected=0)
def test_spacing3(self):
widget = self.create()
self.checkPixelsParam(widget, 'spacing3', 20, 21.4, 22.6, '0.5c')
self.checkParam(widget, 'spacing3', -10, expected=0)
@requires_tcl(8, 5)
def test_startline(self):
widget = self.create()
text = '\n'.join('Line %d' for i in range(100))
widget.insert('end', text)
self.checkParam(widget, 'startline', 200, expected='')
self.checkParam(widget, 'startline', -10, expected='')
self.checkInvalidParam(widget, 'startline', 'spam',
errmsg='expected integer but got "spam"')
self.checkParam(widget, 'startline', 10)
self.checkParam(widget, 'endline', 50)
self.checkInvalidParam(widget, 'startline', 70,
errmsg='-startline must be less than or equal to -endline')
def test_state(self):
widget = self.create()
if tcl_version < (8, 5):
self.checkParams(widget, 'state', 'disabled', 'normal')
else:
self.checkEnumParam(widget, 'state', 'disabled', 'normal')
def test_tabs(self):
widget = self.create()
if get_tk_patchlevel() < (8, 5, 11):
self.checkParam(widget, 'tabs', (10.2, 20.7, '1i', '2i'),
expected=('10.2', '20.7', '1i', '2i'))
else:
self.checkParam(widget, 'tabs', (10.2, 20.7, '1i', '2i'))
self.checkParam(widget, 'tabs', '10.2 20.7 1i 2i',
expected=('10.2', '20.7', '1i', '2i'))
self.checkParam(widget, 'tabs', '2c left 4c 6c center',
expected=('2c', 'left', '4c', '6c', 'center'))
self.checkInvalidParam(widget, 'tabs', 'spam',
errmsg='bad screen distance "spam"',
keep_orig=tcl_version >= (8, 5))
@requires_tcl(8, 5)
def test_tabstyle(self):
widget = self.create()
self.checkEnumParam(widget, 'tabstyle', 'tabular', 'wordprocessor')
def test_undo(self):
widget = self.create()
self.checkBooleanParam(widget, 'undo')
def test_width(self):
widget = self.create()
self.checkIntegerParam(widget, 'width', 402)
self.checkParam(widget, 'width', -402, expected=1)
self.checkParam(widget, 'width', 0, expected=1)
def test_wrap(self):
widget = self.create()
if tcl_version < (8, 5):
self.checkParams(widget, 'wrap', 'char', 'none', 'word')
else:
self.checkEnumParam(widget, 'wrap', 'char', 'none', 'word')
def test_bbox(self):
widget = self.create()
self.assertIsBoundingBox(widget.bbox('1.1'))
self.assertIsNone(widget.bbox('end'))
self.assertRaises(tkinter.TclError, widget.bbox, 'noindex')
self.assertRaises(tkinter.TclError, widget.bbox, None)
self.assertRaises(tkinter.TclError, widget.bbox)
self.assertRaises(tkinter.TclError, widget.bbox, '1.1', 'end')
@add_standard_options(PixelSizeTests, StandardOptionsTests)
class CanvasTest(AbstractWidgetTest, unittest.TestCase):
OPTIONS = (
'background', 'borderwidth',
'closeenough', 'confine', 'cursor', 'height',
'highlightbackground', 'highlightcolor', 'highlightthickness',
'insertbackground', 'insertborderwidth',
'insertofftime', 'insertontime', 'insertwidth',
'offset', 'relief', 'scrollregion',
'selectbackground', 'selectborderwidth', 'selectforeground',
'state', 'takefocus',
'xscrollcommand', 'xscrollincrement',
'yscrollcommand', 'yscrollincrement', 'width',
)
_conv_pixels = staticmethod(int_round)
_stringify = True
def create(self, **kwargs):
return tkinter.Canvas(self.root, **kwargs)
def test_closeenough(self):
widget = self.create()
self.checkFloatParam(widget, 'closeenough', 24, 2.4, 3.6, -3,
conv=float)
def test_confine(self):
widget = self.create()
self.checkBooleanParam(widget, 'confine')
def test_offset(self):
widget = self.create()
self.assertEqual(widget['offset'], '0,0')
self.checkParams(widget, 'offset',
'n', 'ne', 'e', 'se', 's', 'sw', 'w', 'nw', 'center')
self.checkParam(widget, 'offset', '10,20')
self.checkParam(widget, 'offset', '#5,6')
self.checkInvalidParam(widget, 'offset', 'spam')
def test_scrollregion(self):
widget = self.create()
self.checkParam(widget, 'scrollregion', '0 0 200 150')
self.checkParam(widget, 'scrollregion', (0, 0, 200, 150),
expected='0 0 200 150')
self.checkParam(widget, 'scrollregion', '')
self.checkInvalidParam(widget, 'scrollregion', 'spam',
errmsg='bad scrollRegion "spam"')
self.checkInvalidParam(widget, 'scrollregion', (0, 0, 200, 'spam'))
self.checkInvalidParam(widget, 'scrollregion', (0, 0, 200))
self.checkInvalidParam(widget, 'scrollregion', (0, 0, 200, 150, 0))
def test_state(self):
widget = self.create()
self.checkEnumParam(widget, 'state', 'disabled', 'normal',
errmsg='bad state value "{}": must be normal or disabled')
def test_xscrollincrement(self):
widget = self.create()
self.checkPixelsParam(widget, 'xscrollincrement',
40, 0, 41.2, 43.6, -40, '0.5i')
def test_yscrollincrement(self):
widget = self.create()
self.checkPixelsParam(widget, 'yscrollincrement',
10, 0, 11.2, 13.6, -10, '0.1i')
@add_standard_options(IntegerSizeTests, StandardOptionsTests)
class ListboxTest(AbstractWidgetTest, unittest.TestCase):
OPTIONS = (
'activestyle', 'background', 'borderwidth', 'cursor',
'disabledforeground', 'exportselection',
'font', 'foreground', 'height',
'highlightbackground', 'highlightcolor', 'highlightthickness',
'justify', 'listvariable', 'relief',
'selectbackground', 'selectborderwidth', 'selectforeground',
'selectmode', 'setgrid', 'state',
'takefocus', 'width', 'xscrollcommand', 'yscrollcommand',
)
def create(self, **kwargs):
return tkinter.Listbox(self.root, **kwargs)
def test_activestyle(self):
widget = self.create()
self.checkEnumParam(widget, 'activestyle',
'dotbox', 'none', 'underline')
test_justify = requires_tcl(8, 6, 5)(StandardOptionsTests.test_justify.im_func)
def test_listvariable(self):
widget = self.create()
var = tkinter.DoubleVar(self.root)
self.checkVariableParam(widget, 'listvariable', var)
def test_selectmode(self):
widget = self.create()
self.checkParam(widget, 'selectmode', 'single')
self.checkParam(widget, 'selectmode', 'browse')
self.checkParam(widget, 'selectmode', 'multiple')
self.checkParam(widget, 'selectmode', 'extended')
def test_state(self):
widget = self.create()
self.checkEnumParam(widget, 'state', 'disabled', 'normal')
def test_itemconfigure(self):
widget = self.create()
with self.assertRaisesRegexp(TclError, 'item number "0" out of range'):
widget.itemconfigure(0)
colors = 'red orange yellow green blue white violet'.split()
widget.insert('end', *colors)
for i, color in enumerate(colors):
widget.itemconfigure(i, background=color)
with self.assertRaises(TypeError):
widget.itemconfigure()
with self.assertRaisesRegexp(TclError, 'bad listbox index "red"'):
widget.itemconfigure('red')
self.assertEqual(widget.itemconfigure(0, 'background'),
('background', 'background', 'Background', '', 'red'))
self.assertEqual(widget.itemconfigure('end', 'background'),
('background', 'background', 'Background', '', 'violet'))
self.assertEqual(widget.itemconfigure('@0,0', 'background'),
('background', 'background', 'Background', '', 'red'))
d = widget.itemconfigure(0)
self.assertIsInstance(d, dict)
for k, v in d.items():
self.assertIn(len(v), (2, 5))
if len(v) == 5:
self.assertEqual(v, widget.itemconfigure(0, k))
self.assertEqual(v[4], widget.itemcget(0, k))
def check_itemconfigure(self, name, value):
widget = self.create()
widget.insert('end', 'a', 'b', 'c', 'd')
widget.itemconfigure(0, **{name: value})
self.assertEqual(widget.itemconfigure(0, name)[4], value)
self.assertEqual(widget.itemcget(0, name), value)
with self.assertRaisesRegexp(TclError, 'unknown color name "spam"'):
widget.itemconfigure(0, **{name: 'spam'})
def test_itemconfigure_background(self):
self.check_itemconfigure('background', '#ff0000')
def test_itemconfigure_bg(self):
self.check_itemconfigure('bg', '#ff0000')
def test_itemconfigure_fg(self):
self.check_itemconfigure('fg', '#110022')
def test_itemconfigure_foreground(self):
self.check_itemconfigure('foreground', '#110022')
def test_itemconfigure_selectbackground(self):
self.check_itemconfigure('selectbackground', '#110022')
def test_itemconfigure_selectforeground(self):
self.check_itemconfigure('selectforeground', '#654321')
def test_box(self):
lb = self.create()
lb.insert(0, *('el%d' % i for i in range(8)))
lb.pack()
self.assertIsBoundingBox(lb.bbox(0))
self.assertIsNone(lb.bbox(-1))
self.assertIsNone(lb.bbox(10))
self.assertRaises(TclError, lb.bbox, 'noindex')
self.assertRaises(TclError, lb.bbox, None)
self.assertRaises(TypeError, lb.bbox)
self.assertRaises(TypeError, lb.bbox, 0, 1)
def test_curselection(self):
lb = self.create()
lb.insert(0, *('el%d' % i for i in range(8)))
lb.selection_clear(0, tkinter.END)
lb.selection_set(2, 4)
lb.selection_set(6)
self.assertEqual(lb.curselection(), (2, 3, 4, 6))
self.assertRaises(TypeError, lb.curselection, 0)
def test_get(self):
lb = self.create()
lb.insert(0, *('el%d' % i for i in range(8)))
self.assertEqual(lb.get(0), 'el0')
self.assertEqual(lb.get(3), 'el3')
self.assertEqual(lb.get('end'), 'el7')
self.assertEqual(lb.get(8), '')
self.assertEqual(lb.get(-1), '')
self.assertEqual(lb.get(3, 5), ('el3', 'el4', 'el5'))
self.assertEqual(lb.get(5, 'end'), ('el5', 'el6', 'el7'))
self.assertEqual(lb.get(5, 0), ())
self.assertEqual(lb.get(0, 0), ('el0',))
self.assertRaises(TclError, lb.get, 'noindex')
self.assertRaises(TclError, lb.get, None)
self.assertRaises(TypeError, lb.get)
self.assertRaises(TclError, lb.get, 'end', 'noindex')
self.assertRaises(TypeError, lb.get, 1, 2, 3)
self.assertRaises(TclError, lb.get, 2.4)
@add_standard_options(PixelSizeTests, StandardOptionsTests)
class ScaleTest(AbstractWidgetTest, unittest.TestCase):
OPTIONS = (
'activebackground', 'background', 'bigincrement', 'borderwidth',
'command', 'cursor', 'digits', 'font', 'foreground', 'from',
'highlightbackground', 'highlightcolor', 'highlightthickness',
'label', 'length', 'orient', 'relief',
'repeatdelay', 'repeatinterval',
'resolution', 'showvalue', 'sliderlength', 'sliderrelief', 'state',
'takefocus', 'tickinterval', 'to', 'troughcolor', 'variable', 'width',
)
default_orient = 'vertical'
def create(self, **kwargs):
return tkinter.Scale(self.root, **kwargs)
def test_bigincrement(self):
widget = self.create()
self.checkFloatParam(widget, 'bigincrement', 12.4, 23.6, -5)
def test_digits(self):
widget = self.create()
self.checkIntegerParam(widget, 'digits', 5, 0)
def test_from(self):
widget = self.create()
self.checkFloatParam(widget, 'from', 100, 14.9, 15.1, conv=round)
def test_label(self):
widget = self.create()
self.checkParam(widget, 'label', 'any string')
self.checkParam(widget, 'label', '')
def test_length(self):
widget = self.create()
self.checkPixelsParam(widget, 'length', 130, 131.2, 135.6, '5i')
def test_resolution(self):
widget = self.create()
self.checkFloatParam(widget, 'resolution', 4.2, 0, 6.7, -2)
def test_showvalue(self):
widget = self.create()
self.checkBooleanParam(widget, 'showvalue')
def test_sliderlength(self):
widget = self.create()
self.checkPixelsParam(widget, 'sliderlength',
10, 11.2, 15.6, -3, '3m')
def test_sliderrelief(self):
widget = self.create()
self.checkReliefParam(widget, 'sliderrelief')
def test_tickinterval(self):
widget = self.create()
self.checkFloatParam(widget, 'tickinterval', 1, 4.3, 7.6, 0,
conv=round)
self.checkParam(widget, 'tickinterval', -2, expected=2,
conv=round)
def test_to(self):
widget = self.create()
self.checkFloatParam(widget, 'to', 300, 14.9, 15.1, -10,
conv=round)
@add_standard_options(PixelSizeTests, StandardOptionsTests)
class ScrollbarTest(AbstractWidgetTest, unittest.TestCase):
OPTIONS = (
'activebackground', 'activerelief',
'background', 'borderwidth',
'command', 'cursor', 'elementborderwidth',
'highlightbackground', 'highlightcolor', 'highlightthickness',
'jump', 'orient', 'relief',
'repeatdelay', 'repeatinterval',
'takefocus', 'troughcolor', 'width',
)
_conv_pixels = staticmethod(int_round)
_stringify = True
default_orient = 'vertical'
def create(self, **kwargs):
return tkinter.Scrollbar(self.root, **kwargs)
def test_activerelief(self):
widget = self.create()
self.checkReliefParam(widget, 'activerelief')
def test_elementborderwidth(self):
widget = self.create()
self.checkPixelsParam(widget, 'elementborderwidth', 4.3, 5.6, -2, '1m')
def test_orient(self):
widget = self.create()
self.checkEnumParam(widget, 'orient', 'vertical', 'horizontal',
errmsg='bad orientation "{}": must be vertical or horizontal')
def test_activate(self):
sb = self.create()
for e in ('arrow1', 'slider', 'arrow2'):
sb.activate(e)
sb.activate('')
self.assertRaises(TypeError, sb.activate)
self.assertRaises(TypeError, sb.activate, 'arrow1', 'arrow2')
def test_set(self):
sb = self.create()
sb.set(0.2, 0.4)
self.assertEqual(sb.get(), (0.2, 0.4))
self.assertRaises(TclError, sb.set, 'abc', 'def')
self.assertRaises(TclError, sb.set, 0.6, 'def')
self.assertRaises(TclError, sb.set, 0.6, None)
self.assertRaises(TclError, sb.set, 0.6)
self.assertRaises(TclError, sb.set, 0.6, 0.7, 0.8)
@add_standard_options(StandardOptionsTests)
class PanedWindowTest(AbstractWidgetTest, unittest.TestCase):
OPTIONS = (
'background', 'borderwidth', 'cursor',
'handlepad', 'handlesize', 'height',
'opaqueresize', 'orient',
'proxybackground', 'proxyborderwidth', 'proxyrelief',
'relief',
'sashcursor', 'sashpad', 'sashrelief', 'sashwidth',
'showhandle', 'width',
)
default_orient = 'horizontal'
def create(self, **kwargs):
return tkinter.PanedWindow(self.root, **kwargs)
def test_handlepad(self):
widget = self.create()
self.checkPixelsParam(widget, 'handlepad', 5, 6.4, 7.6, -3, '1m')
def test_handlesize(self):
widget = self.create()
self.checkPixelsParam(widget, 'handlesize', 8, 9.4, 10.6, -3, '2m',
conv=noconv)
def test_height(self):
widget = self.create()
self.checkPixelsParam(widget, 'height', 100, 101.2, 102.6, -100, 0, '1i',
conv=noconv)
def test_opaqueresize(self):
widget = self.create()
self.checkBooleanParam(widget, 'opaqueresize')
@requires_tcl(8, 6, 5)
def test_proxybackground(self):
widget = self.create()
self.checkColorParam(widget, 'proxybackground')
@requires_tcl(8, 6, 5)
def test_proxyborderwidth(self):
widget = self.create()
self.checkPixelsParam(widget, 'proxyborderwidth',
0, 1.3, 2.9, 6, -2, '10p',
conv=noconv)
@requires_tcl(8, 6, 5)
def test_proxyrelief(self):
widget = self.create()
self.checkReliefParam(widget, 'proxyrelief')
def test_sashcursor(self):
widget = self.create()
self.checkCursorParam(widget, 'sashcursor')
def test_sashpad(self):
widget = self.create()
self.checkPixelsParam(widget, 'sashpad', 8, 1.3, 2.6, -2, '2m')
def test_sashrelief(self):
widget = self.create()
self.checkReliefParam(widget, 'sashrelief')
def test_sashwidth(self):
widget = self.create()
self.checkPixelsParam(widget, 'sashwidth', 10, 11.1, 15.6, -3, '1m',
conv=noconv)
def test_showhandle(self):
widget = self.create()
self.checkBooleanParam(widget, 'showhandle')
def test_width(self):
widget = self.create()
self.checkPixelsParam(widget, 'width', 402, 403.4, 404.6, -402, 0, '5i',
conv=noconv)
def create2(self):
p = self.create()
b = tkinter.Button(p)
c = tkinter.Button(p)
p.add(b)
p.add(c)
return p, b, c
def test_paneconfigure(self):
p, b, c = self.create2()
self.assertRaises(TypeError, p.paneconfigure)
d = p.paneconfigure(b)
self.assertIsInstance(d, dict)
for k, v in d.items():
self.assertEqual(len(v), 5)
self.assertEqual(v, p.paneconfigure(b, k))
self.assertEqual(v[4], p.panecget(b, k))
def check_paneconfigure(self, p, b, name, value, expected, stringify=False):
conv = lambda x: x
if not self.wantobjects or stringify:
expected = str(expected)
if self.wantobjects and stringify:
conv = str
p.paneconfigure(b, **{name: value})
self.assertEqual(conv(p.paneconfigure(b, name)[4]), expected)
self.assertEqual(conv(p.panecget(b, name)), expected)
def check_paneconfigure_bad(self, p, b, name, msg):
with self.assertRaisesRegexp(TclError, msg):
p.paneconfigure(b, **{name: 'badValue'})
def test_paneconfigure_after(self):
p, b, c = self.create2()
self.check_paneconfigure(p, b, 'after', c, str(c))
self.check_paneconfigure_bad(p, b, 'after',
'bad window path name "badValue"')
def test_paneconfigure_before(self):
p, b, c = self.create2()
self.check_paneconfigure(p, b, 'before', c, str(c))
self.check_paneconfigure_bad(p, b, 'before',
'bad window path name "badValue"')
def test_paneconfigure_height(self):
p, b, c = self.create2()
self.check_paneconfigure(p, b, 'height', 10, 10,
stringify=get_tk_patchlevel() < (8, 5, 11))
self.check_paneconfigure_bad(p, b, 'height',
'bad screen distance "badValue"')
@requires_tcl(8, 5)
def test_paneconfigure_hide(self):
p, b, c = self.create2()
self.check_paneconfigure(p, b, 'hide', False, 0)
self.check_paneconfigure_bad(p, b, 'hide',
'expected boolean value but got "badValue"')
def test_paneconfigure_minsize(self):
p, b, c = self.create2()
self.check_paneconfigure(p, b, 'minsize', 10, 10)
self.check_paneconfigure_bad(p, b, 'minsize',
'bad screen distance "badValue"')
def test_paneconfigure_padx(self):
p, b, c = self.create2()
self.check_paneconfigure(p, b, 'padx', 1.3, 1)
self.check_paneconfigure_bad(p, b, 'padx',
'bad screen distance "badValue"')
def test_paneconfigure_pady(self):
p, b, c = self.create2()
self.check_paneconfigure(p, b, 'pady', 1.3, 1)
self.check_paneconfigure_bad(p, b, 'pady',
'bad screen distance "badValue"')
def test_paneconfigure_sticky(self):
p, b, c = self.create2()
self.check_paneconfigure(p, b, 'sticky', 'nsew', 'nesw')
self.check_paneconfigure_bad(p, b, 'sticky',
'bad stickyness value "badValue": must '
'be a string containing zero or more of '
'n, e, s, and w')
@requires_tcl(8, 5)
def test_paneconfigure_stretch(self):
p, b, c = self.create2()
self.check_paneconfigure(p, b, 'stretch', 'alw', 'always')
self.check_paneconfigure_bad(p, b, 'stretch',
'bad stretch "badValue": must be '
'always, first, last, middle, or never')
def test_paneconfigure_width(self):
p, b, c = self.create2()
self.check_paneconfigure(p, b, 'width', 10, 10,
stringify=get_tk_patchlevel() < (8, 5, 11))
self.check_paneconfigure_bad(p, b, 'width',
'bad screen distance "badValue"')
@add_standard_options(StandardOptionsTests)
class MenuTest(AbstractWidgetTest, unittest.TestCase):
OPTIONS = (
'activebackground', 'activeborderwidth', 'activeforeground',
'background', 'borderwidth', 'cursor',
'disabledforeground', 'font', 'foreground',
'postcommand', 'relief', 'selectcolor', 'takefocus',
'tearoff', 'tearoffcommand', 'title', 'type',
)
_conv_pixels = noconv_meth
def create(self, **kwargs):
return tkinter.Menu(self.root, **kwargs)
def test_postcommand(self):
widget = self.create()
self.checkCommandParam(widget, 'postcommand')
def test_tearoff(self):
widget = self.create()
self.checkBooleanParam(widget, 'tearoff')
def test_tearoffcommand(self):
widget = self.create()
self.checkCommandParam(widget, 'tearoffcommand')
def test_title(self):
widget = self.create()
self.checkParam(widget, 'title', 'any string')
def test_type(self):
widget = self.create()
self.checkEnumParam(widget, 'type',
'normal', 'tearoff', 'menubar')
def test_entryconfigure(self):
m1 = self.create()
m1.add_command(label='test')
self.assertRaises(TypeError, m1.entryconfigure)
with self.assertRaisesRegexp(TclError, 'bad menu entry index "foo"'):
m1.entryconfigure('foo')
d = m1.entryconfigure(1)
self.assertIsInstance(d, dict)
for k, v in d.items():
self.assertIsInstance(k, str)
self.assertIsInstance(v, tuple)
self.assertEqual(len(v), 5)
self.assertEqual(v[0], k)
self.assertEqual(m1.entrycget(1, k), v[4])
m1.destroy()
def test_entryconfigure_label(self):
m1 = self.create()
m1.add_command(label='test')
self.assertEqual(m1.entrycget(1, 'label'), 'test')
m1.entryconfigure(1, label='changed')
self.assertEqual(m1.entrycget(1, 'label'), 'changed')
def test_entryconfigure_variable(self):
m1 = self.create()
v1 = tkinter.BooleanVar(self.root)
v2 = tkinter.BooleanVar(self.root)
m1.add_checkbutton(variable=v1, onvalue=True, offvalue=False,
label='Nonsense')
self.assertEqual(str(m1.entrycget(1, 'variable')), str(v1))
m1.entryconfigure(1, variable=v2)
self.assertEqual(str(m1.entrycget(1, 'variable')), str(v2))
@add_standard_options(PixelSizeTests, StandardOptionsTests)
class MessageTest(AbstractWidgetTest, unittest.TestCase):
OPTIONS = (
'anchor', 'aspect', 'background', 'borderwidth',
'cursor', 'font', 'foreground',
'highlightbackground', 'highlightcolor', 'highlightthickness',
'justify', 'padx', 'pady', 'relief',
'takefocus', 'text', 'textvariable', 'width',
)
_conv_pad_pixels = noconv_meth
def create(self, **kwargs):
return tkinter.Message(self.root, **kwargs)
def test_aspect(self):
widget = self.create()
self.checkIntegerParam(widget, 'aspect', 250, 0, -300)
tests_gui = [
ButtonTest, CanvasTest, CheckbuttonTest, EntryTest,
FrameTest, LabelFrameTest,LabelTest, ListboxTest,
MenubuttonTest, MenuTest, MessageTest, OptionMenuTest,
PanedWindowTest, RadiobuttonTest, ScaleTest, ScrollbarTest,
SpinboxTest, TextTest, ToplevelTest,
]
if __name__ == '__main__':
run_unittest(*tests_gui)
test/test_tkinter/__init__.py 0000644 00000000000 15032720555 0012345 0 ustar 00 test/test_tkinter/test_text.pyc 0000644 00000003467 15032720555 0013020 0 ustar 00 �
z fc @ s� d d l Z d d l Z d d l m Z m Z d d l m Z e d � d e e j f d � � YZ e f Z
e d k r� e e
� n d S( i����N( t requirest run_unittest( t AbstractTkTestt guit TextTestc B s# e Z d � Z d � Z d � Z RS( c C s, t t | � j � t j | j � | _ d S( N( t superR t setUpt tkintert Textt roott text( t self( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_text.pyR
s c C s� | j } | j � } zJ | j d � | j | j � d � | j d � | j | j � d � Wd | j | � | j | j � | � Xd S( Ni i ( R
t debugt assertEqual( R R
t olddebug( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_text.pyt
test_debug s
c C s� | j } | j t j | j d d � | j t j | j d d � | j t j | j d d � | j t j | j d d � | j d d � | j | j d d d � d � | j | j d d d � d
� d S( Ns 1.0t at i s hi-tests -testt ends 1.2t tests 1.3( R
t assertRaisesR t TclErrort searcht Nonet insertR
( R R
( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_text.pyt test_search s ( t __name__t
__module__R R R ( ( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_text.pyR s t __main__( t unittestt TkinterR t test.test_supportR R t test_ttk.supportR t TestCaseR t tests_guiR ( ( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_text.pyt <module> s
$ test/test_tkinter/test_images.py 0000644 00000032050 15032720555 0013124 0 ustar 00 import unittest
import Tkinter as tkinter
import ttk
import test.test_support as support
from test_ttk.support import AbstractTkTest, requires_tcl
support.requires('gui')
class MiscTest(AbstractTkTest, unittest.TestCase):
def test_image_types(self):
image_types = self.root.image_types()
self.assertIsInstance(image_types, tuple)
self.assertIn('photo', image_types)
self.assertIn('bitmap', image_types)
def test_image_names(self):
image_names = self.root.image_names()
self.assertIsInstance(image_names, tuple)
class BitmapImageTest(AbstractTkTest, unittest.TestCase):
@classmethod
def setUpClass(cls):
AbstractTkTest.setUpClass.__func__(cls)
cls.testfile = support.findfile('python.xbm', subdir='imghdrdata')
def test_create_from_file(self):
image = tkinter.BitmapImage('::img::test', master=self.root,
foreground='yellow', background='blue',
file=self.testfile)
self.assertEqual(str(image), '::img::test')
self.assertEqual(image.type(), 'bitmap')
self.assertEqual(image.width(), 16)
self.assertEqual(image.height(), 16)
self.assertIn('::img::test', self.root.image_names())
del image
self.assertNotIn('::img::test', self.root.image_names())
def test_create_from_data(self):
with open(self.testfile, 'rb') as f:
data = f.read()
image = tkinter.BitmapImage('::img::test', master=self.root,
foreground='yellow', background='blue',
data=data)
self.assertEqual(str(image), '::img::test')
self.assertEqual(image.type(), 'bitmap')
self.assertEqual(image.width(), 16)
self.assertEqual(image.height(), 16)
self.assertIn('::img::test', self.root.image_names())
del image
self.assertNotIn('::img::test', self.root.image_names())
def assertEqualStrList(self, actual, expected):
self.assertIsInstance(actual, str)
self.assertEqual(self.root.splitlist(actual), expected)
def test_configure_data(self):
image = tkinter.BitmapImage('::img::test', master=self.root)
self.assertEqual(image['data'], '-data {} {} {} {}')
with open(self.testfile, 'rb') as f:
data = f.read()
image.configure(data=data)
self.assertEqualStrList(image['data'],
('-data', '', '', '', data))
self.assertEqual(image.width(), 16)
self.assertEqual(image.height(), 16)
self.assertEqual(image['maskdata'], '-maskdata {} {} {} {}')
image.configure(maskdata=data)
self.assertEqualStrList(image['maskdata'],
('-maskdata', '', '', '', data))
def test_configure_file(self):
image = tkinter.BitmapImage('::img::test', master=self.root)
self.assertEqual(image['file'], '-file {} {} {} {}')
image.configure(file=self.testfile)
self.assertEqualStrList(image['file'],
('-file', '', '', '',self.testfile))
self.assertEqual(image.width(), 16)
self.assertEqual(image.height(), 16)
self.assertEqual(image['maskfile'], '-maskfile {} {} {} {}')
image.configure(maskfile=self.testfile)
self.assertEqualStrList(image['maskfile'],
('-maskfile', '', '', '', self.testfile))
def test_configure_background(self):
image = tkinter.BitmapImage('::img::test', master=self.root)
self.assertEqual(image['background'], '-background {} {} {} {}')
image.configure(background='blue')
self.assertEqual(image['background'], '-background {} {} {} blue')
def test_configure_foreground(self):
image = tkinter.BitmapImage('::img::test', master=self.root)
self.assertEqual(image['foreground'],
'-foreground {} {} #000000 #000000')
image.configure(foreground='yellow')
self.assertEqual(image['foreground'],
'-foreground {} {} #000000 yellow')
class PhotoImageTest(AbstractTkTest, unittest.TestCase):
@classmethod
def setUpClass(cls):
AbstractTkTest.setUpClass.__func__(cls)
cls.testfile = support.findfile('python.gif', subdir='imghdrdata')
def create(self):
return tkinter.PhotoImage('::img::test', master=self.root,
file=self.testfile)
def colorlist(self, *args):
if tkinter.TkVersion >= 8.6 and self.wantobjects:
return args
else:
return tkinter._join(args)
def check_create_from_file(self, ext):
testfile = support.findfile('python.' + ext, subdir='imghdrdata')
image = tkinter.PhotoImage('::img::test', master=self.root,
file=testfile)
self.assertEqual(str(image), '::img::test')
self.assertEqual(image.type(), 'photo')
self.assertEqual(image.width(), 16)
self.assertEqual(image.height(), 16)
self.assertEqual(image['data'], '')
self.assertEqual(image['file'], testfile)
self.assertIn('::img::test', self.root.image_names())
del image
self.assertNotIn('::img::test', self.root.image_names())
def check_create_from_data(self, ext):
testfile = support.findfile('python.' + ext, subdir='imghdrdata')
with open(testfile, 'rb') as f:
data = f.read()
image = tkinter.PhotoImage('::img::test', master=self.root,
data=data)
self.assertEqual(str(image), '::img::test')
self.assertEqual(image.type(), 'photo')
self.assertEqual(image.width(), 16)
self.assertEqual(image.height(), 16)
self.assertEqual(image['data'], data if self.wantobjects
else data.decode('latin1'))
self.assertEqual(image['file'], '')
self.assertIn('::img::test', self.root.image_names())
del image
self.assertNotIn('::img::test', self.root.image_names())
def test_create_from_ppm_file(self):
self.check_create_from_file('ppm')
def test_create_from_ppm_data(self):
self.check_create_from_data('ppm')
def test_create_from_pgm_file(self):
self.check_create_from_file('pgm')
def test_create_from_pgm_data(self):
self.check_create_from_data('pgm')
def test_create_from_gif_file(self):
self.check_create_from_file('gif')
def test_create_from_gif_data(self):
self.check_create_from_data('gif')
@requires_tcl(8, 6)
def test_create_from_png_file(self):
self.check_create_from_file('png')
@requires_tcl(8, 6)
def test_create_from_png_data(self):
self.check_create_from_data('png')
def test_configure_data(self):
image = tkinter.PhotoImage('::img::test', master=self.root)
self.assertEqual(image['data'], '')
with open(self.testfile, 'rb') as f:
data = f.read()
image.configure(data=data)
self.assertEqual(image['data'], data if self.wantobjects
else data.decode('latin1'))
self.assertEqual(image.width(), 16)
self.assertEqual(image.height(), 16)
def test_configure_format(self):
image = tkinter.PhotoImage('::img::test', master=self.root)
self.assertEqual(image['format'], '')
image.configure(file=self.testfile, format='gif')
self.assertEqual(image['format'], ('gif',) if self.wantobjects
else 'gif')
self.assertEqual(image.width(), 16)
self.assertEqual(image.height(), 16)
def test_configure_file(self):
image = tkinter.PhotoImage('::img::test', master=self.root)
self.assertEqual(image['file'], '')
image.configure(file=self.testfile)
self.assertEqual(image['file'], self.testfile)
self.assertEqual(image.width(), 16)
self.assertEqual(image.height(), 16)
def test_configure_gamma(self):
image = tkinter.PhotoImage('::img::test', master=self.root)
self.assertEqual(image['gamma'], '1.0')
image.configure(gamma=2.0)
self.assertEqual(image['gamma'], '2.0')
def test_configure_width_height(self):
image = tkinter.PhotoImage('::img::test', master=self.root)
self.assertEqual(image['width'], '0')
self.assertEqual(image['height'], '0')
image.configure(width=20)
image.configure(height=10)
self.assertEqual(image['width'], '20')
self.assertEqual(image['height'], '10')
self.assertEqual(image.width(), 20)
self.assertEqual(image.height(), 10)
def test_configure_palette(self):
image = tkinter.PhotoImage('::img::test', master=self.root)
self.assertEqual(image['palette'], '')
image.configure(palette=256)
self.assertEqual(image['palette'], '256')
image.configure(palette='3/4/2')
self.assertEqual(image['palette'], '3/4/2')
def test_blank(self):
image = self.create()
image.blank()
self.assertEqual(image.width(), 16)
self.assertEqual(image.height(), 16)
self.assertEqual(image.get(4, 6), self.colorlist(0, 0, 0))
def test_copy(self):
image = self.create()
image2 = image.copy()
self.assertEqual(image2.width(), 16)
self.assertEqual(image2.height(), 16)
self.assertEqual(image.get(4, 6), image.get(4, 6))
def test_subsample(self):
image = self.create()
image2 = image.subsample(2, 3)
self.assertEqual(image2.width(), 8)
self.assertEqual(image2.height(), 6)
self.assertEqual(image2.get(2, 2), image.get(4, 6))
image2 = image.subsample(2)
self.assertEqual(image2.width(), 8)
self.assertEqual(image2.height(), 8)
self.assertEqual(image2.get(2, 3), image.get(4, 6))
def test_zoom(self):
image = self.create()
image2 = image.zoom(2, 3)
self.assertEqual(image2.width(), 32)
self.assertEqual(image2.height(), 48)
self.assertEqual(image2.get(8, 18), image.get(4, 6))
self.assertEqual(image2.get(9, 20), image.get(4, 6))
image2 = image.zoom(2)
self.assertEqual(image2.width(), 32)
self.assertEqual(image2.height(), 32)
self.assertEqual(image2.get(8, 12), image.get(4, 6))
self.assertEqual(image2.get(9, 13), image.get(4, 6))
def test_put(self):
image = self.create()
image.put('{red green} {blue yellow}', to=(4, 6))
self.assertEqual(image.get(4, 6), self.colorlist(255, 0, 0))
self.assertEqual(image.get(5, 6),
self.colorlist(0, 128 if tkinter.TkVersion >= 8.6
else 255, 0))
self.assertEqual(image.get(4, 7), self.colorlist(0, 0, 255))
self.assertEqual(image.get(5, 7), self.colorlist(255, 255, 0))
image.put((('#f00', '#00ff00'), ('#000000fff', '#ffffffff0000')))
self.assertEqual(image.get(0, 0), self.colorlist(255, 0, 0))
self.assertEqual(image.get(1, 0), self.colorlist(0, 255, 0))
self.assertEqual(image.get(0, 1), self.colorlist(0, 0, 255))
self.assertEqual(image.get(1, 1), self.colorlist(255, 255, 0))
def test_get(self):
image = self.create()
self.assertEqual(image.get(4, 6), self.colorlist(62, 116, 162))
self.assertEqual(image.get(0, 0), self.colorlist(0, 0, 0))
self.assertEqual(image.get(15, 15), self.colorlist(0, 0, 0))
self.assertRaises(tkinter.TclError, image.get, -1, 0)
self.assertRaises(tkinter.TclError, image.get, 0, -1)
self.assertRaises(tkinter.TclError, image.get, 16, 15)
self.assertRaises(tkinter.TclError, image.get, 15, 16)
def test_write(self):
image = self.create()
self.addCleanup(support.unlink, support.TESTFN)
image.write(support.TESTFN)
image2 = tkinter.PhotoImage('::img::test2', master=self.root,
format='ppm',
file=support.TESTFN)
self.assertEqual(str(image2), '::img::test2')
self.assertEqual(image2.type(), 'photo')
self.assertEqual(image2.width(), 16)
self.assertEqual(image2.height(), 16)
self.assertEqual(image2.get(0, 0), image.get(0, 0))
self.assertEqual(image2.get(15, 8), image.get(15, 8))
image.write(support.TESTFN, format='gif', from_coords=(4, 6, 6, 9))
image3 = tkinter.PhotoImage('::img::test3', master=self.root,
format='gif',
file=support.TESTFN)
self.assertEqual(str(image3), '::img::test3')
self.assertEqual(image3.type(), 'photo')
self.assertEqual(image3.width(), 2)
self.assertEqual(image3.height(), 3)
self.assertEqual(image3.get(0, 0), image.get(4, 6))
self.assertEqual(image3.get(1, 2), image.get(5, 8))
tests_gui = (MiscTest, BitmapImageTest, PhotoImageTest,)
if __name__ == "__main__":
support.run_unittest(*tests_gui)
test/test_tkinter/__init__.pyo 0000644 00000000220 15032720555 0012530 0 ustar 00 �
z fc @ s d S( N( ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_tkinter/__init__.pyt <module> t test/test_tkinter/test_variables.pyo 0000644 00000026236 15032720555 0014017 0 ustar 00 �
z fc @ s d d l Z d d l Z d d l m Z m Z m Z m Z m Z m Z m Z d e j
f d � � YZ d e f d � � YZ d e f d � � YZ
d e f d
� � YZ d e f d � � YZ d
e f d � � YZ e e
e e e f Z e d k rd d l m Z e e � n d S( i����N( t Variablet StringVart IntVart DoubleVart
BooleanVart Tclt TclErrort TestBasec B s e Z d � Z d � Z RS( c C s t � | _ d S( N( R t root( t self( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt setUp s c C s
| ` d S( N( R ( R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt tearDown s ( t __name__t
__module__R
R ( ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyR s t TestVariablec B sY e Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
RS( c G s" | j j | j j d d | � � S( Nt infot exists( R t
getbooleant call( R t args( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt info_exists s c C s? t | j � } | j d | j � � | j t | � d � d S( Nt s
^PY_VAR(\d+)$( R R t assertEqualt gett assertRegexpMatchest str( R t v( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt test_default s c C sE t | j d d � } | j d | j � � | j d t | � � d S( Ns
sample stringt varname( R R R R R ( R R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt test_name_and_value s c C s^ | j | j d � � t | j d d � } | j | j d � � ~ | j | j d � � d S( NR s
sample string( t assertFalseR R R t
assertTrue( R R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt test___del__ s
c C sv | j | j d � � t | j d d �} t | j d d �} ~ | j | j d � � ~ | j | j d � � d S( NR t name( R R R R ( R t v1t v2( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt test_dont_unset_not_existing& s c C sx t | j d d �} t | j d d �} | j | | � t | j d d �} t | j d d �} | j | | � d S( NR! t abc( R R R R t assertNotEqual( R R" R# t v3t v4( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt test___eq__0 s c C s- | j t � � t | j d d �Wd QXd S( NR! i{ ( t assertRaisest TypeErrorR R ( R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt test_invalid_name: s c C s | j t � � t | j d d �Wd QX| j t � � | j j d d � Wd QX| j t � � | j j d d � Wd QXd S( NR! s var namet value( R* t
ValueErrorR R t globalsetvart setvar( R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt test_null_in_name> s c so t | j � } t | � } g � � f d � } � f d � } | j d | � } | j d | � } | j t | j � � d | f d | f g � | j � g � | j d � | j � d | d d f g � g � | j � | j � d | d d f g � g � t | j � � } | j d | � | j t | j � � | � | j
t � � | j d d � Wd QX| j t | j � � | � | j d | d
f � | j t | j � � | � | j � | j � d | d d f g � g � | j d | � | j | j � d | f g � | j � | j � g � g � ~ t j
� | j d � | j � d | d d f g � d S( Nc s � j d | � d S( Nt read( R2 ( t append( R ( t trace( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt read_tracerJ s c s � j d | � d S( Nt write( R6 ( R3 ( R ( R4 ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt write_tracerL s t rt wut spamR6 R t wR2 i+ t eggs( R R R t trace_variableR t sortedt trace_vinfot setR t
trace_vdeleteR* R t gct collect( R R t vnameR5 R7 t cb1t cb2R ( ( R4 s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt
test_traceF sF .
( R R
R R R R R$ R) R, R1 RG ( ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyR s
t
TestStringVarc B s# e Z d � Z d � Z d � Z RS( c C s) t | j � } | j d | j � � d S( NR ( R R R R ( R R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyR z s c C sX t | j d d � } | j d | j � � | j j d d � | j d | j � � d S( NR% R! R- ( R R R R R/ ( R R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt test_get~ s c C sX t | j d d � } | j d | j � � | j j d d � | j d | j � � d S( Ns abc defR! s val ue( R R R R R/ ( R R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt
test_get_null� s ( R R
R RI RJ ( ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyRH x s t
TestIntVarc B s# e Z d � Z d � Z d � Z RS( c C s) t | j � } | j d | j � � d S( Ni ( R R R R ( R R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyR � s c C sX t | j d d � } | j d | j � � | j j d d � | j d | j � � d S( Ni{ R! t 345iY ( R R R R R/ ( R R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyRI � s c C s t | j d d �} | j j d d � | j t � � | j � Wd QX| j j d d � | j t � � | j � Wd QXd S( NR! R- s 345.0( R R R/ R* R. R ( R R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt test_invalid_value� s ( R R
R RI RM ( ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyRK � s t
TestDoubleVarc B s, e Z d � Z d � Z d � Z d � Z RS( c C s) t | j � } | j d | j � � d S( Ng ( R R R R ( R R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyR � s c C sX t | j d d � } | j d | j � � | j j d d � | j d | j � � d S( Ng�G�z��?R! s 3.45g������ @( R R t assertAlmostEqualR R/ ( R R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyRI � s c C s� t | j d d � } | j d | j � � | j j d d � | j d | j � � | j j d d � | j d | j � � d S( Ng�G�z��?R! s 3.45g������ @t 456i� ( R R RO R R/ ( R R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt test_get_from_int� s c C sL t | j d d �} | j j d d � | j t � � | j � Wd QXd S( NR! R- ( R R R/ R* R. R ( R R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyRM � s ( R R
R RI RQ RM ( ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyRN � s t TestBooleanVarc B s, e Z d � Z d � Z d � Z d � Z RS( c C s) t | j � } | j | j � t � d S( N( R R t assertIsR t False( R R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyR � s c C s� t | j t d � } | j | j � t � | j j d d � | j | j � t � | j j d | j j � ru d n d � | j | j � t � | j j d d � | j | j � t � | j j d | j j � r� d n d � | j | j � t � | j j d d � | j | j � t � | j j d d � | j | j � t � | j j d d
� | j | j � t � | j j d d � | j | j � t � d S( NR! t 0i* i i l * l l t onu 0u on( R R t TrueRS R R/ RT t wantobjects( R R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyRI � s$ ((c C s� | j j � r d n d } | j j � r0 d n d } t | j d d �} | j t � | j | j j d � | � | j d � | j | j j d � | � | j d � | j | j j d � | � | j d � | j | j j d � | � | j d � | j | j j d � | � | j d � | j | j j d � | � | j d � | j | j j d � | � | j d
� | j | j j d � | � | j d � | j | j j d � | � d S( Ni t 1i RU R! i* l * l RV u 0u on( R RX R R@ RW R t globalgetvar( R t truet falseR ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt test_set� s*
c C s� | j j � r d n d } t | j d d �} | j t � � | j d � Wd QX| j | j j d � | � | j j d d � | j t � � | j � Wd QX| j j d d � | j t � � | j � Wd QXd S( Ni RU R! R- s 1.0(
R RX R R* R R@ R RZ R/ R ( R R\ R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt test_invalid_value_domain� s ( R R
R RI R] R^ ( ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyRR � s t __main__( t run_unittest( t unittestRB t TkinterR R R R R R R t TestCaseR R RH RK RN RR t tests_guiR t test.supportR` ( ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt <module> s 4 h? test/test_tkinter/test_font.pyo 0000644 00000011672 15032720555 0013013 0 ustar 00 �
z fc @ s� d d l Z d d l Z d d l Z d d l m Z m Z m Z d d l m
Z
e d � d Z d e
e j f d � � YZ
e
f Z e d k r� e e � n d S( i����N( t requirest run_unittestt
gc_collect( t AbstractTkTestt guit
TkDefaultFontt FontTestc B sh e Z e d � � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d � Z RS(
c C sw t j j | � y( t j d | j d t d t � | _ Wn8 t j k
rr t j d | j d t d t
� | _ n Xd S( Nt roott namet exists( R t
setUpClasst __func__t fontt FontR t fontnamet Truet tkintert TclErrort False( t cls( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_font.pyR
s
(c C sL | j j � } | j t | � d d d d d d h � xI | D]A } | j | j j | � | | � | j | j | | | � q> WxU d D]M } | j | | t � | j | j j | � t � | j | j | t � q� W| j r� t n t } xU d D]M } | j | | | � | j | j j | � | � | j | j | | � q� Wd S( Nt familyt sizet weightt slantt underlinet
overstrike( R R R ( R R R (
R t configuret assertGreaterEqualt sett assertEqualt cgett assertIsInstancet strt wantobjectst int( t selft optionst keyt sizetype( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_font.pyt test_configure s
c C s� d } y% t j d | j d | d t � } Wn5 t j k
rb t j d | j d | d t � } n X| j | j d � | � ~ t � d S( Nu MS ゴシックR R R (
R R
R R R R R R R R ( R# R t f( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_font.pyt test_unicode_family& s %%c C s | j j � } | j t | � d d d d d d h � x. | D]& } | j | j j | � | | � q> Wx> d D]6 } | j | | t � | j | j j | � t � qo W| j r� t n t } x> d D]6 } | j | | | � | j | j j | � | � q� Wd S( NR R R R R R ( R R R ( R R R ( R t actualR R R R R R! R" ( R# R$ R% R& ( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_font.pyt test_actual0 s
$
c C s3 | j | j j t � | j t | j � t � d S( N( R R R R R ( R# ( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_font.pyt test_name> s c C s� t j d | j d t d t � } t j d | j d t d t � } | j | | � | j | | � | j | | j � � | j | d � | j | d g � d S( NR R R i (
R R
R R R t assertIsNotR t assertNotEqualt copyt assertNotIn( R# t font1t font2( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_font.pyt test_eqB s !!c C s | j | j j d � t � d S( Nt abc( R R t measureR" ( R# ( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_font.pyt test_measureK s c C s� | j j � } | j t | � d d d d h � x^ | D]V } | j | j j | � | | � | j | | t � | j | j j | � t � q8 Wd S( Nt ascentt descentt linespacet fixed( R t metricsR R R R R" ( R# R; R% ( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_font.pyt test_metricsN s
c C sg t j | j � } | j | t � | j | � x1 | D]) } | j | t t f � | j | � q6 Wd S( N( R t familiesR R t tuplet
assertTrueR t unicode( R# R= R ( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_font.pyt
test_familiesW s
c C sw t j | j � } | j | t � | j | � x1 | D]) } | j | t t f � | j | � q6 W| j t | � d S( N(
R t namesR R R> R? R R@ t assertInR ( R# RB R ( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_font.pyt
test_names_ s
(
t __name__t
__module__t classmethodR
R' R) R+ R, R3 R6 R< RA RD ( ( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_font.pyR s
t __main__( t unittestt TkinterR t tkFontR t test.test_supportR R R t test_ttk.supportR R t TestCaseR t tests_guiRE ( ( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_font.pyt <module> s
] test/test_tkinter/test_font.pyc 0000644 00000011672 15032720555 0012777 0 ustar 00 �
z fc @ s� d d l Z d d l Z d d l Z d d l m Z m Z m Z d d l m
Z
e d � d Z d e
e j f d � � YZ
e
f Z e d k r� e e � n d S( i����N( t requirest run_unittestt
gc_collect( t AbstractTkTestt guit
TkDefaultFontt FontTestc B sh e Z e d � � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d � Z RS(
c C sw t j j | � y( t j d | j d t d t � | _ Wn8 t j k
rr t j d | j d t d t
� | _ n Xd S( Nt roott namet exists( R t
setUpClasst __func__t fontt FontR t fontnamet Truet tkintert TclErrort False( t cls( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_font.pyR
s
(c C sL | j j � } | j t | � d d d d d d h � xI | D]A } | j | j j | � | | � | j | j | | | � q> WxU d D]M } | j | | t � | j | j j | � t � | j | j | t � q� W| j r� t n t } xU d D]M } | j | | | � | j | j j | � | � | j | j | | � q� Wd S( Nt familyt sizet weightt slantt underlinet
overstrike( R R R ( R R R (
R t configuret assertGreaterEqualt sett assertEqualt cgett assertIsInstancet strt wantobjectst int( t selft optionst keyt sizetype( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_font.pyt test_configure s
c C s� d } y% t j d | j d | d t � } Wn5 t j k
rb t j d | j d | d t � } n X| j | j d � | � ~ t � d S( Nu MS ゴシックR R R (
R R
R R R R R R R R ( R# R t f( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_font.pyt test_unicode_family& s %%c C s | j j � } | j t | � d d d d d d h � x. | D]& } | j | j j | � | | � q> Wx> d D]6 } | j | | t � | j | j j | � t � qo W| j r� t n t } x> d D]6 } | j | | | � | j | j j | � | � q� Wd S( NR R R R R R ( R R R ( R R R ( R t actualR R R R R R! R" ( R# R$ R% R& ( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_font.pyt test_actual0 s
$
c C s3 | j | j j t � | j t | j � t � d S( N( R R R R R ( R# ( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_font.pyt test_name> s c C s� t j d | j d t d t � } t j d | j d t d t � } | j | | � | j | | � | j | | j � � | j | d � | j | d g � d S( NR R R i (
R R
R R R t assertIsNotR t assertNotEqualt copyt assertNotIn( R# t font1t font2( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_font.pyt test_eqB s !!c C s | j | j j d � t � d S( Nt abc( R R t measureR" ( R# ( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_font.pyt test_measureK s c C s� | j j � } | j t | � d d d d h � x^ | D]V } | j | j j | � | | � | j | | t � | j | j j | � t � q8 Wd S( Nt ascentt descentt linespacet fixed( R t metricsR R R R R" ( R# R; R% ( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_font.pyt test_metricsN s
c C sg t j | j � } | j | t � | j | � x1 | D]) } | j | t t f � | j | � q6 Wd S( N( R t familiesR R t tuplet
assertTrueR t unicode( R# R= R ( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_font.pyt
test_familiesW s
c C sw t j | j � } | j | t � | j | � x1 | D]) } | j | t t f � | j | � q6 W| j t | � d S( N(
R t namesR R R> R? R R@ t assertInR ( R# RB R ( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_font.pyt
test_names_ s
(
t __name__t
__module__t classmethodR
R' R) R+ R, R3 R6 R< RA RD ( ( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_font.pyR s
t __main__( t unittestt TkinterR t tkFontR t test.test_supportR R R t test_ttk.supportR R t TestCaseR t tests_guiRE ( ( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_font.pyt <module> s
] test/test_tkinter/test_text.py 0000644 00000002674 15032720555 0012654 0 ustar 00 import unittest
import Tkinter as tkinter
from test.test_support import requires, run_unittest
from test_ttk.support import AbstractTkTest
requires('gui')
class TextTest(AbstractTkTest, unittest.TestCase):
def setUp(self):
super(TextTest, self).setUp()
self.text = tkinter.Text(self.root)
def test_debug(self):
text = self.text
olddebug = text.debug()
try:
text.debug(0)
self.assertEqual(text.debug(), 0)
text.debug(1)
self.assertEqual(text.debug(), 1)
finally:
text.debug(olddebug)
self.assertEqual(text.debug(), olddebug)
def test_search(self):
text = self.text
# pattern and index are obligatory arguments.
self.assertRaises(tkinter.TclError, text.search, None, '1.0')
self.assertRaises(tkinter.TclError, text.search, 'a', None)
self.assertRaises(tkinter.TclError, text.search, None, None)
# Invalid text index.
self.assertRaises(tkinter.TclError, text.search, '', 0)
# Check if we are getting the indices as strings -- you are likely
# to get Tcl_Obj under Tk 8.5 if Tkinter doesn't convert it.
text.insert('1.0', 'hi-test')
self.assertEqual(text.search('-test', '1.0', 'end'), '1.2')
self.assertEqual(text.search('test', '1.0', 'end'), '1.3')
tests_gui = (TextTest, )
if __name__ == "__main__":
run_unittest(*tests_gui)
test/test_tkinter/test_variables.pyc 0000644 00000026236 15032720555 0014003 0 ustar 00 �
z fc @ s d d l Z d d l Z d d l m Z m Z m Z m Z m Z m Z m Z d e j
f d � � YZ d e f d � � YZ d e f d � � YZ
d e f d
� � YZ d e f d � � YZ d
e f d � � YZ e e
e e e f Z e d k rd d l m Z e e � n d S( i����N( t Variablet StringVart IntVart DoubleVart
BooleanVart Tclt TclErrort TestBasec B s e Z d � Z d � Z RS( c C s t � | _ d S( N( R t root( t self( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt setUp s c C s
| ` d S( N( R ( R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt tearDown s ( t __name__t
__module__R
R ( ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyR s t TestVariablec B sY e Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
RS( c G s" | j j | j j d d | � � S( Nt infot exists( R t
getbooleant call( R t args( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt info_exists s c C s? t | j � } | j d | j � � | j t | � d � d S( Nt s
^PY_VAR(\d+)$( R R t assertEqualt gett assertRegexpMatchest str( R t v( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt test_default s c C sE t | j d d � } | j d | j � � | j d t | � � d S( Ns
sample stringt varname( R R R R R ( R R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt test_name_and_value s c C s^ | j | j d � � t | j d d � } | j | j d � � ~ | j | j d � � d S( NR s
sample string( t assertFalseR R R t
assertTrue( R R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt test___del__ s
c C sv | j | j d � � t | j d d �} t | j d d �} ~ | j | j d � � ~ | j | j d � � d S( NR t name( R R R R ( R t v1t v2( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt test_dont_unset_not_existing& s c C sx t | j d d �} t | j d d �} | j | | � t | j d d �} t | j d d �} | j | | � d S( NR! t abc( R R R R t assertNotEqual( R R" R# t v3t v4( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt test___eq__0 s c C s- | j t � � t | j d d �Wd QXd S( NR! i{ ( t assertRaisest TypeErrorR R ( R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt test_invalid_name: s c C s | j t � � t | j d d �Wd QX| j t � � | j j d d � Wd QX| j t � � | j j d d � Wd QXd S( NR! s var namet value( R* t
ValueErrorR R t globalsetvart setvar( R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt test_null_in_name> s c so t | j � } t | � } g � � f d � } � f d � } | j d | � } | j d | � } | j t | j � � d | f d | f g � | j � g � | j d � | j � d | d d f g � g � | j � | j � d | d d f g � g � t | j � � } | j d | � | j t | j � � | � | j
t � � | j d d � Wd QX| j t | j � � | � | j d | d
f � | j t | j � � | � | j � | j � d | d d f g � g � | j d | � | j | j � d | f g � | j � | j � g � g � ~ t j
� | j d � | j � d | d d f g � d S( Nc s � j d | � d S( Nt read( R2 ( t append( R ( t trace( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt read_tracerJ s c s � j d | � d S( Nt write( R6 ( R3 ( R ( R4 ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt write_tracerL s t rt wut spamR6 R t wR2 i+ t eggs( R R R t trace_variableR t sortedt trace_vinfot setR t
trace_vdeleteR* R t gct collect( R R t vnameR5 R7 t cb1t cb2R ( ( R4 s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt
test_traceF sF .
( R R
R R R R R$ R) R, R1 RG ( ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyR s
t
TestStringVarc B s# e Z d � Z d � Z d � Z RS( c C s) t | j � } | j d | j � � d S( NR ( R R R R ( R R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyR z s c C sX t | j d d � } | j d | j � � | j j d d � | j d | j � � d S( NR% R! R- ( R R R R R/ ( R R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt test_get~ s c C sX t | j d d � } | j d | j � � | j j d d � | j d | j � � d S( Ns abc defR! s val ue( R R R R R/ ( R R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt
test_get_null� s ( R R
R RI RJ ( ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyRH x s t
TestIntVarc B s# e Z d � Z d � Z d � Z RS( c C s) t | j � } | j d | j � � d S( Ni ( R R R R ( R R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyR � s c C sX t | j d d � } | j d | j � � | j j d d � | j d | j � � d S( Ni{ R! t 345iY ( R R R R R/ ( R R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyRI � s c C s t | j d d �} | j j d d � | j t � � | j � Wd QX| j j d d � | j t � � | j � Wd QXd S( NR! R- s 345.0( R R R/ R* R. R ( R R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt test_invalid_value� s ( R R
R RI RM ( ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyRK � s t
TestDoubleVarc B s, e Z d � Z d � Z d � Z d � Z RS( c C s) t | j � } | j d | j � � d S( Ng ( R R R R ( R R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyR � s c C sX t | j d d � } | j d | j � � | j j d d � | j d | j � � d S( Ng�G�z��?R! s 3.45g������ @( R R t assertAlmostEqualR R/ ( R R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyRI � s c C s� t | j d d � } | j d | j � � | j j d d � | j d | j � � | j j d d � | j d | j � � d S( Ng�G�z��?R! s 3.45g������ @t 456i� ( R R RO R R/ ( R R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt test_get_from_int� s c C sL t | j d d �} | j j d d � | j t � � | j � Wd QXd S( NR! R- ( R R R/ R* R. R ( R R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyRM � s ( R R
R RI RQ RM ( ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyRN � s t TestBooleanVarc B s, e Z d � Z d � Z d � Z d � Z RS( c C s) t | j � } | j | j � t � d S( N( R R t assertIsR t False( R R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyR � s c C s� t | j t d � } | j | j � t � | j j d d � | j | j � t � | j j d | j j � ru d n d � | j | j � t � | j j d d � | j | j � t � | j j d | j j � r� d n d � | j | j � t � | j j d d � | j | j � t � | j j d d � | j | j � t � | j j d d
� | j | j � t � | j j d d � | j | j � t � d S( NR! t 0i* i i l * l l t onu 0u on( R R t TrueRS R R/ RT t wantobjects( R R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyRI � s$ ((c C s� | j j � r d n d } | j j � r0 d n d } t | j d d �} | j t � | j | j j d � | � | j d � | j | j j d � | � | j d � | j | j j d � | � | j d � | j | j j d � | � | j d � | j | j j d � | � | j d � | j | j j d � | � | j d � | j | j j d � | � | j d
� | j | j j d � | � | j d � | j | j j d � | � d S( Ni t 1i RU R! i* l * l RV u 0u on( R RX R R@ RW R t globalgetvar( R t truet falseR ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt test_set� s*
c C s� | j j � r d n d } t | j d d �} | j t � � | j d � Wd QX| j | j j d � | � | j j d d � | j t � � | j � Wd QX| j j d d � | j t � � | j � Wd QXd S( Ni RU R! R- s 1.0(
R RX R R* R R@ R RZ R/ R ( R R\ R ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt test_invalid_value_domain� s ( R R
R RI R] R^ ( ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyRR � s t __main__( t run_unittest( t unittestRB t TkinterR R R R R R R t TestCaseR R RH RK RN RR t tests_guiR t test.supportR` ( ( ( s? /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_variables.pyt <module> s 4 h? test/test_tkinter/test_geometry_managers.py 0000644 00000117167 15032720555 0015404 0 ustar 00 import unittest
import re
import Tkinter as tkinter
from Tkinter import TclError
from test.test_support import requires, run_unittest
from test_ttk.support import pixels_conv, tcl_version, requires_tcl
from widget_tests import AbstractWidgetTest, int_round
requires('gui')
class PackTest(AbstractWidgetTest, unittest.TestCase):
test_keys = None
def create2(self):
pack = tkinter.Toplevel(self.root, name='pack')
pack.wm_geometry('300x200+0+0')
pack.wm_minsize(1, 1)
a = tkinter.Frame(pack, name='a', width=20, height=40, bg='red')
b = tkinter.Frame(pack, name='b', width=50, height=30, bg='blue')
c = tkinter.Frame(pack, name='c', width=80, height=80, bg='green')
d = tkinter.Frame(pack, name='d', width=40, height=30, bg='yellow')
return pack, a, b, c, d
def test_pack_configure_after(self):
pack, a, b, c, d = self.create2()
with self.assertRaisesRegexp(TclError, 'window "%s" isn\'t packed' % b):
a.pack_configure(after=b)
with self.assertRaisesRegexp(TclError, 'bad window path name ".foo"'):
a.pack_configure(after='.foo')
a.pack_configure(side='top')
b.pack_configure(side='top')
c.pack_configure(side='top')
d.pack_configure(side='top')
self.assertEqual(pack.pack_slaves(), [a, b, c, d])
a.pack_configure(after=b)
self.assertEqual(pack.pack_slaves(), [b, a, c, d])
a.pack_configure(after=a)
self.assertEqual(pack.pack_slaves(), [b, a, c, d])
def test_pack_configure_anchor(self):
pack, a, b, c, d = self.create2()
def check(anchor, geom):
a.pack_configure(side='top', ipadx=5, padx=10, ipady=15, pady=20,
expand=True, anchor=anchor)
self.root.update()
self.assertEqual(a.winfo_geometry(), geom)
check('n', '30x70+135+20')
check('ne', '30x70+260+20')
check('e', '30x70+260+65')
check('se', '30x70+260+110')
check('s', '30x70+135+110')
check('sw', '30x70+10+110')
check('w', '30x70+10+65')
check('nw', '30x70+10+20')
check('center', '30x70+135+65')
def test_pack_configure_before(self):
pack, a, b, c, d = self.create2()
with self.assertRaisesRegexp(TclError, 'window "%s" isn\'t packed' % b):
a.pack_configure(before=b)
with self.assertRaisesRegexp(TclError, 'bad window path name ".foo"'):
a.pack_configure(before='.foo')
a.pack_configure(side='top')
b.pack_configure(side='top')
c.pack_configure(side='top')
d.pack_configure(side='top')
self.assertEqual(pack.pack_slaves(), [a, b, c, d])
a.pack_configure(before=d)
self.assertEqual(pack.pack_slaves(), [b, c, a, d])
a.pack_configure(before=a)
self.assertEqual(pack.pack_slaves(), [b, c, a, d])
def test_pack_configure_expand(self):
pack, a, b, c, d = self.create2()
def check(*geoms):
self.root.update()
self.assertEqual(a.winfo_geometry(), geoms[0])
self.assertEqual(b.winfo_geometry(), geoms[1])
self.assertEqual(c.winfo_geometry(), geoms[2])
self.assertEqual(d.winfo_geometry(), geoms[3])
a.pack_configure(side='left')
b.pack_configure(side='top')
c.pack_configure(side='right')
d.pack_configure(side='bottom')
check('20x40+0+80', '50x30+135+0', '80x80+220+75', '40x30+100+170')
a.pack_configure(side='left', expand='yes')
b.pack_configure(side='top', expand='on')
c.pack_configure(side='right', expand=True)
d.pack_configure(side='bottom', expand=1)
check('20x40+40+80', '50x30+175+35', '80x80+180+110', '40x30+100+135')
a.pack_configure(side='left', expand='yes', fill='both')
b.pack_configure(side='top', expand='on', fill='both')
c.pack_configure(side='right', expand=True, fill='both')
d.pack_configure(side='bottom', expand=1, fill='both')
check('100x200+0+0', '200x100+100+0', '160x100+140+100', '40x100+100+100')
def test_pack_configure_in(self):
pack, a, b, c, d = self.create2()
a.pack_configure(side='top')
b.pack_configure(side='top')
c.pack_configure(side='top')
d.pack_configure(side='top')
a.pack_configure(in_=pack)
self.assertEqual(pack.pack_slaves(), [b, c, d, a])
a.pack_configure(in_=c)
self.assertEqual(pack.pack_slaves(), [b, c, d])
self.assertEqual(c.pack_slaves(), [a])
with self.assertRaisesRegexp(TclError,
'can\'t pack %s inside itself' % (a,)):
a.pack_configure(in_=a)
with self.assertRaisesRegexp(TclError, 'bad window path name ".foo"'):
a.pack_configure(in_='.foo')
def test_pack_configure_padx_ipadx_fill(self):
pack, a, b, c, d = self.create2()
def check(geom1, geom2, **kwargs):
a.pack_forget()
b.pack_forget()
a.pack_configure(**kwargs)
b.pack_configure(expand=True, fill='both')
self.root.update()
self.assertEqual(a.winfo_geometry(), geom1)
self.assertEqual(b.winfo_geometry(), geom2)
check('20x40+260+80', '240x200+0+0', side='right', padx=20)
check('20x40+250+80', '240x200+0+0', side='right', padx=(10, 30))
check('60x40+240+80', '240x200+0+0', side='right', ipadx=20)
check('30x40+260+80', '250x200+0+0', side='right', ipadx=5, padx=10)
check('20x40+260+80', '240x200+0+0', side='right', padx=20, fill='x')
check('20x40+249+80', '240x200+0+0',
side='right', padx=(9, 31), fill='x')
check('60x40+240+80', '240x200+0+0', side='right', ipadx=20, fill='x')
check('30x40+260+80', '250x200+0+0',
side='right', ipadx=5, padx=10, fill='x')
check('30x40+255+80', '250x200+0+0',
side='right', ipadx=5, padx=(5, 15), fill='x')
check('20x40+140+0', '300x160+0+40', side='top', padx=20)
check('20x40+120+0', '300x160+0+40', side='top', padx=(0, 40))
check('60x40+120+0', '300x160+0+40', side='top', ipadx=20)
check('30x40+135+0', '300x160+0+40', side='top', ipadx=5, padx=10)
check('30x40+130+0', '300x160+0+40', side='top', ipadx=5, padx=(5, 15))
check('260x40+20+0', '300x160+0+40', side='top', padx=20, fill='x')
check('260x40+25+0', '300x160+0+40',
side='top', padx=(25, 15), fill='x')
check('300x40+0+0', '300x160+0+40', side='top', ipadx=20, fill='x')
check('280x40+10+0', '300x160+0+40',
side='top', ipadx=5, padx=10, fill='x')
check('280x40+5+0', '300x160+0+40',
side='top', ipadx=5, padx=(5, 15), fill='x')
a.pack_configure(padx='1c')
self.assertEqual(a.pack_info()['padx'],
self._str(pack.winfo_pixels('1c')))
a.pack_configure(ipadx='1c')
self.assertEqual(a.pack_info()['ipadx'],
self._str(pack.winfo_pixels('1c')))
def test_pack_configure_pady_ipady_fill(self):
pack, a, b, c, d = self.create2()
def check(geom1, geom2, **kwargs):
a.pack_forget()
b.pack_forget()
a.pack_configure(**kwargs)
b.pack_configure(expand=True, fill='both')
self.root.update()
self.assertEqual(a.winfo_geometry(), geom1)
self.assertEqual(b.winfo_geometry(), geom2)
check('20x40+280+80', '280x200+0+0', side='right', pady=20)
check('20x40+280+70', '280x200+0+0', side='right', pady=(10, 30))
check('20x80+280+60', '280x200+0+0', side='right', ipady=20)
check('20x50+280+75', '280x200+0+0', side='right', ipady=5, pady=10)
check('20x40+280+80', '280x200+0+0', side='right', pady=20, fill='x')
check('20x40+280+69', '280x200+0+0',
side='right', pady=(9, 31), fill='x')
check('20x80+280+60', '280x200+0+0', side='right', ipady=20, fill='x')
check('20x50+280+75', '280x200+0+0',
side='right', ipady=5, pady=10, fill='x')
check('20x50+280+70', '280x200+0+0',
side='right', ipady=5, pady=(5, 15), fill='x')
check('20x40+140+20', '300x120+0+80', side='top', pady=20)
check('20x40+140+0', '300x120+0+80', side='top', pady=(0, 40))
check('20x80+140+0', '300x120+0+80', side='top', ipady=20)
check('20x50+140+10', '300x130+0+70', side='top', ipady=5, pady=10)
check('20x50+140+5', '300x130+0+70', side='top', ipady=5, pady=(5, 15))
check('300x40+0+20', '300x120+0+80', side='top', pady=20, fill='x')
check('300x40+0+25', '300x120+0+80',
side='top', pady=(25, 15), fill='x')
check('300x80+0+0', '300x120+0+80', side='top', ipady=20, fill='x')
check('300x50+0+10', '300x130+0+70',
side='top', ipady=5, pady=10, fill='x')
check('300x50+0+5', '300x130+0+70',
side='top', ipady=5, pady=(5, 15), fill='x')
a.pack_configure(pady='1c')
self.assertEqual(a.pack_info()['pady'],
self._str(pack.winfo_pixels('1c')))
a.pack_configure(ipady='1c')
self.assertEqual(a.pack_info()['ipady'],
self._str(pack.winfo_pixels('1c')))
def test_pack_configure_side(self):
pack, a, b, c, d = self.create2()
def check(side, geom1, geom2):
a.pack_configure(side=side)
self.assertEqual(a.pack_info()['side'], side)
b.pack_configure(expand=True, fill='both')
self.root.update()
self.assertEqual(a.winfo_geometry(), geom1)
self.assertEqual(b.winfo_geometry(), geom2)
check('top', '20x40+140+0', '300x160+0+40')
check('bottom', '20x40+140+160', '300x160+0+0')
check('left', '20x40+0+80', '280x200+20+0')
check('right', '20x40+280+80', '280x200+0+0')
def test_pack_forget(self):
pack, a, b, c, d = self.create2()
a.pack_configure()
b.pack_configure()
c.pack_configure()
self.assertEqual(pack.pack_slaves(), [a, b, c])
b.pack_forget()
self.assertEqual(pack.pack_slaves(), [a, c])
b.pack_forget()
self.assertEqual(pack.pack_slaves(), [a, c])
d.pack_forget()
def test_pack_info(self):
pack, a, b, c, d = self.create2()
with self.assertRaisesRegexp(TclError, 'window "%s" isn\'t packed' % a):
a.pack_info()
a.pack_configure()
b.pack_configure(side='right', in_=a, anchor='s', expand=True, fill='x',
ipadx=5, padx=10, ipady=2, pady=(5, 15))
info = a.pack_info()
self.assertIsInstance(info, dict)
self.assertEqual(info['anchor'], 'center')
self.assertEqual(info['expand'], self._str(0))
self.assertEqual(info['fill'], 'none')
self.assertEqual(info['in'], pack)
self.assertEqual(info['ipadx'], self._str(0))
self.assertEqual(info['ipady'], self._str(0))
self.assertEqual(info['padx'], self._str(0))
self.assertEqual(info['pady'], self._str(0))
self.assertEqual(info['side'], 'top')
info = b.pack_info()
self.assertIsInstance(info, dict)
self.assertEqual(info['anchor'], 's')
self.assertEqual(info['expand'], self._str(1))
self.assertEqual(info['fill'], 'x')
self.assertEqual(info['in'], a)
self.assertEqual(info['ipadx'], self._str(5))
self.assertEqual(info['ipady'], self._str(2))
self.assertEqual(info['padx'], self._str(10))
self.assertEqual(info['pady'], self._str((5, 15)))
self.assertEqual(info['side'], 'right')
def test_pack_propagate(self):
pack, a, b, c, d = self.create2()
pack.configure(width=300, height=200)
a.pack_configure()
pack.pack_propagate(False)
self.root.update()
self.assertEqual(pack.winfo_reqwidth(), 300)
self.assertEqual(pack.winfo_reqheight(), 200)
pack.pack_propagate(True)
self.root.update()
self.assertEqual(pack.winfo_reqwidth(), 20)
self.assertEqual(pack.winfo_reqheight(), 40)
def test_pack_slaves(self):
pack, a, b, c, d = self.create2()
self.assertEqual(pack.pack_slaves(), [])
a.pack_configure()
self.assertEqual(pack.pack_slaves(), [a])
b.pack_configure()
self.assertEqual(pack.pack_slaves(), [a, b])
class PlaceTest(AbstractWidgetTest, unittest.TestCase):
test_keys = None
def create2(self):
t = tkinter.Toplevel(self.root, width=300, height=200, bd=0)
t.wm_geometry('300x200+0+0')
f = tkinter.Frame(t, width=154, height=84, bd=2, relief='raised')
f.place_configure(x=48, y=38)
f2 = tkinter.Frame(t, width=30, height=60, bd=2, relief='raised')
self.root.update()
return t, f, f2
def test_place_configure_in(self):
t, f, f2 = self.create2()
self.assertEqual(f2.winfo_manager(), '')
with self.assertRaisesRegexp(TclError, "can't place %s relative to "
"itself" % re.escape(str(f2))):
f2.place_configure(in_=f2)
if tcl_version >= (8, 5):
self.assertEqual(f2.winfo_manager(), '')
with self.assertRaisesRegexp(TclError, 'bad window path name'):
f2.place_configure(in_='spam')
f2.place_configure(in_=f)
self.assertEqual(f2.winfo_manager(), 'place')
def test_place_configure_x(self):
t, f, f2 = self.create2()
f2.place_configure(in_=f)
self.assertEqual(f2.place_info()['x'], '0')
self.root.update()
self.assertEqual(f2.winfo_x(), 50)
f2.place_configure(x=100)
self.assertEqual(f2.place_info()['x'], '100')
self.root.update()
self.assertEqual(f2.winfo_x(), 150)
f2.place_configure(x=-10, relx=1)
self.assertEqual(f2.place_info()['x'], '-10')
self.root.update()
self.assertEqual(f2.winfo_x(), 190)
with self.assertRaisesRegexp(TclError, 'bad screen distance "spam"'):
f2.place_configure(in_=f, x='spam')
def test_place_configure_y(self):
t, f, f2 = self.create2()
f2.place_configure(in_=f)
self.assertEqual(f2.place_info()['y'], '0')
self.root.update()
self.assertEqual(f2.winfo_y(), 40)
f2.place_configure(y=50)
self.assertEqual(f2.place_info()['y'], '50')
self.root.update()
self.assertEqual(f2.winfo_y(), 90)
f2.place_configure(y=-10, rely=1)
self.assertEqual(f2.place_info()['y'], '-10')
self.root.update()
self.assertEqual(f2.winfo_y(), 110)
with self.assertRaisesRegexp(TclError, 'bad screen distance "spam"'):
f2.place_configure(in_=f, y='spam')
def test_place_configure_relx(self):
t, f, f2 = self.create2()
f2.place_configure(in_=f)
self.assertEqual(f2.place_info()['relx'], '0')
self.root.update()
self.assertEqual(f2.winfo_x(), 50)
f2.place_configure(relx=0.5)
self.assertEqual(f2.place_info()['relx'], '0.5')
self.root.update()
self.assertEqual(f2.winfo_x(), 125)
f2.place_configure(relx=1)
self.assertEqual(f2.place_info()['relx'], '1')
self.root.update()
self.assertEqual(f2.winfo_x(), 200)
with self.assertRaisesRegexp(TclError, 'expected floating-point number '
'but got "spam"'):
f2.place_configure(in_=f, relx='spam')
def test_place_configure_rely(self):
t, f, f2 = self.create2()
f2.place_configure(in_=f)
self.assertEqual(f2.place_info()['rely'], '0')
self.root.update()
self.assertEqual(f2.winfo_y(), 40)
f2.place_configure(rely=0.5)
self.assertEqual(f2.place_info()['rely'], '0.5')
self.root.update()
self.assertEqual(f2.winfo_y(), 80)
f2.place_configure(rely=1)
self.assertEqual(f2.place_info()['rely'], '1')
self.root.update()
self.assertEqual(f2.winfo_y(), 120)
with self.assertRaisesRegexp(TclError, 'expected floating-point number '
'but got "spam"'):
f2.place_configure(in_=f, rely='spam')
def test_place_configure_anchor(self):
f = tkinter.Frame(self.root)
with self.assertRaisesRegexp(TclError, 'bad anchor "j"'):
f.place_configure(anchor='j')
with self.assertRaisesRegexp(TclError, 'ambiguous anchor ""'):
f.place_configure(anchor='')
for value in 'n', 'ne', 'e', 'se', 's', 'sw', 'w', 'nw', 'center':
f.place_configure(anchor=value)
self.assertEqual(f.place_info()['anchor'], value)
def test_place_configure_width(self):
t, f, f2 = self.create2()
f2.place_configure(in_=f, width=120)
self.root.update()
self.assertEqual(f2.winfo_width(), 120)
f2.place_configure(width='')
self.root.update()
self.assertEqual(f2.winfo_width(), 30)
with self.assertRaisesRegexp(TclError, 'bad screen distance "abcd"'):
f2.place_configure(width='abcd')
def test_place_configure_height(self):
t, f, f2 = self.create2()
f2.place_configure(in_=f, height=120)
self.root.update()
self.assertEqual(f2.winfo_height(), 120)
f2.place_configure(height='')
self.root.update()
self.assertEqual(f2.winfo_height(), 60)
with self.assertRaisesRegexp(TclError, 'bad screen distance "abcd"'):
f2.place_configure(height='abcd')
def test_place_configure_relwidth(self):
t, f, f2 = self.create2()
f2.place_configure(in_=f, relwidth=0.5)
self.root.update()
self.assertEqual(f2.winfo_width(), 75)
f2.place_configure(relwidth='')
self.root.update()
self.assertEqual(f2.winfo_width(), 30)
with self.assertRaisesRegexp(TclError, 'expected floating-point number '
'but got "abcd"'):
f2.place_configure(relwidth='abcd')
def test_place_configure_relheight(self):
t, f, f2 = self.create2()
f2.place_configure(in_=f, relheight=0.5)
self.root.update()
self.assertEqual(f2.winfo_height(), 40)
f2.place_configure(relheight='')
self.root.update()
self.assertEqual(f2.winfo_height(), 60)
with self.assertRaisesRegexp(TclError, 'expected floating-point number '
'but got "abcd"'):
f2.place_configure(relheight='abcd')
def test_place_configure_bordermode(self):
f = tkinter.Frame(self.root)
with self.assertRaisesRegexp(TclError, 'bad bordermode "j"'):
f.place_configure(bordermode='j')
with self.assertRaisesRegexp(TclError, 'ambiguous bordermode ""'):
f.place_configure(bordermode='')
for value in 'inside', 'outside', 'ignore':
f.place_configure(bordermode=value)
self.assertEqual(f.place_info()['bordermode'], value)
def test_place_forget(self):
foo = tkinter.Frame(self.root)
foo.place_configure(width=50, height=50)
self.root.update()
foo.place_forget()
self.root.update()
self.assertFalse(foo.winfo_ismapped())
with self.assertRaises(TypeError):
foo.place_forget(0)
def test_place_info(self):
t, f, f2 = self.create2()
f2.place_configure(in_=f, x=1, y=2, width=3, height=4,
relx=0.1, rely=0.2, relwidth=0.3, relheight=0.4,
anchor='se', bordermode='outside')
info = f2.place_info()
self.assertIsInstance(info, dict)
self.assertEqual(info['x'], '1')
self.assertEqual(info['y'], '2')
self.assertEqual(info['width'], '3')
self.assertEqual(info['height'], '4')
self.assertEqual(info['relx'], '0.1')
self.assertEqual(info['rely'], '0.2')
self.assertEqual(info['relwidth'], '0.3')
self.assertEqual(info['relheight'], '0.4')
self.assertEqual(info['anchor'], 'se')
self.assertEqual(info['bordermode'], 'outside')
self.assertEqual(info['x'], '1')
self.assertEqual(info['x'], '1')
with self.assertRaises(TypeError):
f2.place_info(0)
def test_place_slaves(self):
foo = tkinter.Frame(self.root)
bar = tkinter.Frame(self.root)
self.assertEqual(foo.place_slaves(), [])
bar.place_configure(in_=foo)
self.assertEqual(foo.place_slaves(), [bar])
with self.assertRaises(TypeError):
foo.place_slaves(0)
class GridTest(AbstractWidgetTest, unittest.TestCase):
test_keys = None
def tearDown(self):
cols, rows = self.root.grid_size()
for i in range(cols + 1):
self.root.grid_columnconfigure(i, weight=0, minsize=0, pad=0, uniform='')
for i in range(rows + 1):
self.root.grid_rowconfigure(i, weight=0, minsize=0, pad=0, uniform='')
self.root.grid_propagate(1)
super(GridTest, self).tearDown()
def test_grid_configure(self):
b = tkinter.Button(self.root)
self.assertEqual(b.grid_info(), {})
b.grid_configure()
self.assertEqual(b.grid_info()['in'], self.root)
self.assertEqual(b.grid_info()['column'], self._str(0))
self.assertEqual(b.grid_info()['row'], self._str(0))
b.grid_configure({'column': 1}, row=2)
self.assertEqual(b.grid_info()['column'], self._str(1))
self.assertEqual(b.grid_info()['row'], self._str(2))
def test_grid_configure_column(self):
b = tkinter.Button(self.root)
with self.assertRaisesRegexp(TclError, 'bad column value "-1": '
'must be a non-negative integer'):
b.grid_configure(column=-1)
b.grid_configure(column=2)
self.assertEqual(b.grid_info()['column'], self._str(2))
def test_grid_configure_columnspan(self):
b = tkinter.Button(self.root)
with self.assertRaisesRegexp(TclError, 'bad columnspan value "0": '
'must be a positive integer'):
b.grid_configure(columnspan=0)
b.grid_configure(columnspan=2)
self.assertEqual(b.grid_info()['columnspan'], self._str(2))
def test_grid_configure_in(self):
f = tkinter.Frame(self.root)
b = tkinter.Button(self.root)
self.assertEqual(b.grid_info(), {})
b.grid_configure()
self.assertEqual(b.grid_info()['in'], self.root)
b.grid_configure(in_=f)
self.assertEqual(b.grid_info()['in'], f)
b.grid_configure({'in': self.root})
self.assertEqual(b.grid_info()['in'], self.root)
def test_grid_configure_ipadx(self):
b = tkinter.Button(self.root)
with self.assertRaisesRegexp(TclError, 'bad ipadx value "-1": '
'must be positive screen distance'):
b.grid_configure(ipadx=-1)
b.grid_configure(ipadx=1)
self.assertEqual(b.grid_info()['ipadx'], self._str(1))
b.grid_configure(ipadx='.5c')
self.assertEqual(b.grid_info()['ipadx'],
self._str(int_round(pixels_conv('.5c') * self.scaling)))
def test_grid_configure_ipady(self):
b = tkinter.Button(self.root)
with self.assertRaisesRegexp(TclError, 'bad ipady value "-1": '
'must be positive screen distance'):
b.grid_configure(ipady=-1)
b.grid_configure(ipady=1)
self.assertEqual(b.grid_info()['ipady'], self._str(1))
b.grid_configure(ipady='.5c')
self.assertEqual(b.grid_info()['ipady'],
self._str(int_round(pixels_conv('.5c') * self.scaling)))
def test_grid_configure_padx(self):
b = tkinter.Button(self.root)
with self.assertRaisesRegexp(TclError, 'bad pad value "-1": '
'must be positive screen distance'):
b.grid_configure(padx=-1)
b.grid_configure(padx=1)
self.assertEqual(b.grid_info()['padx'], self._str(1))
b.grid_configure(padx=(10, 5))
self.assertEqual(b.grid_info()['padx'], self._str((10, 5)))
b.grid_configure(padx='.5c')
self.assertEqual(b.grid_info()['padx'],
self._str(int_round(pixels_conv('.5c') * self.scaling)))
def test_grid_configure_pady(self):
b = tkinter.Button(self.root)
with self.assertRaisesRegexp(TclError, 'bad pad value "-1": '
'must be positive screen distance'):
b.grid_configure(pady=-1)
b.grid_configure(pady=1)
self.assertEqual(b.grid_info()['pady'], self._str(1))
b.grid_configure(pady=(10, 5))
self.assertEqual(b.grid_info()['pady'], self._str((10, 5)))
b.grid_configure(pady='.5c')
self.assertEqual(b.grid_info()['pady'],
self._str(int_round(pixels_conv('.5c') * self.scaling)))
def test_grid_configure_row(self):
b = tkinter.Button(self.root)
with self.assertRaisesRegexp(TclError, 'bad (row|grid) value "-1": '
'must be a non-negative integer'):
b.grid_configure(row=-1)
b.grid_configure(row=2)
self.assertEqual(b.grid_info()['row'], self._str(2))
def test_grid_configure_rownspan(self):
b = tkinter.Button(self.root)
with self.assertRaisesRegexp(TclError, 'bad rowspan value "0": '
'must be a positive integer'):
b.grid_configure(rowspan=0)
b.grid_configure(rowspan=2)
self.assertEqual(b.grid_info()['rowspan'], self._str(2))
def test_grid_configure_sticky(self):
f = tkinter.Frame(self.root, bg='red')
with self.assertRaisesRegexp(TclError, 'bad stickyness value "glue"'):
f.grid_configure(sticky='glue')
f.grid_configure(sticky='ne')
self.assertEqual(f.grid_info()['sticky'], 'ne')
f.grid_configure(sticky='n,s,e,w')
self.assertEqual(f.grid_info()['sticky'], 'nesw')
def test_grid_columnconfigure(self):
with self.assertRaises(TypeError):
self.root.grid_columnconfigure()
self.assertEqual(self.root.grid_columnconfigure(0),
{'minsize': 0, 'pad': 0, 'uniform': None, 'weight': 0})
with self.assertRaisesRegexp(TclError, 'bad option "-foo"'):
self.root.grid_columnconfigure(0, 'foo')
self.root.grid_columnconfigure((0, 3), weight=2)
with self.assertRaisesRegexp(TclError,
'must specify a single element on retrieval'):
self.root.grid_columnconfigure((0, 3))
b = tkinter.Button(self.root)
b.grid_configure(column=0, row=0)
if tcl_version >= (8, 5):
self.root.grid_columnconfigure('all', weight=3)
with self.assertRaisesRegexp(TclError, 'expected integer but got "all"'):
self.root.grid_columnconfigure('all')
self.assertEqual(self.root.grid_columnconfigure(0, 'weight'), 3)
self.assertEqual(self.root.grid_columnconfigure(3, 'weight'), 2)
self.assertEqual(self.root.grid_columnconfigure(265, 'weight'), 0)
if tcl_version >= (8, 5):
self.root.grid_columnconfigure(b, weight=4)
self.assertEqual(self.root.grid_columnconfigure(0, 'weight'), 4)
def test_grid_columnconfigure_minsize(self):
with self.assertRaisesRegexp(TclError, 'bad screen distance "foo"'):
self.root.grid_columnconfigure(0, minsize='foo')
self.root.grid_columnconfigure(0, minsize=10)
self.assertEqual(self.root.grid_columnconfigure(0, 'minsize'), 10)
self.assertEqual(self.root.grid_columnconfigure(0)['minsize'], 10)
def test_grid_columnconfigure_weight(self):
with self.assertRaisesRegexp(TclError, 'expected integer but got "bad"'):
self.root.grid_columnconfigure(0, weight='bad')
with self.assertRaisesRegexp(TclError, 'invalid arg "-weight": '
'should be non-negative'):
self.root.grid_columnconfigure(0, weight=-3)
self.root.grid_columnconfigure(0, weight=3)
self.assertEqual(self.root.grid_columnconfigure(0, 'weight'), 3)
self.assertEqual(self.root.grid_columnconfigure(0)['weight'], 3)
def test_grid_columnconfigure_pad(self):
with self.assertRaisesRegexp(TclError, 'bad screen distance "foo"'):
self.root.grid_columnconfigure(0, pad='foo')
with self.assertRaisesRegexp(TclError, 'invalid arg "-pad": '
'should be non-negative'):
self.root.grid_columnconfigure(0, pad=-3)
self.root.grid_columnconfigure(0, pad=3)
self.assertEqual(self.root.grid_columnconfigure(0, 'pad'), 3)
self.assertEqual(self.root.grid_columnconfigure(0)['pad'], 3)
def test_grid_columnconfigure_uniform(self):
self.root.grid_columnconfigure(0, uniform='foo')
self.assertEqual(self.root.grid_columnconfigure(0, 'uniform'), 'foo')
self.assertEqual(self.root.grid_columnconfigure(0)['uniform'], 'foo')
def test_grid_rowconfigure(self):
with self.assertRaises(TypeError):
self.root.grid_rowconfigure()
self.assertEqual(self.root.grid_rowconfigure(0),
{'minsize': 0, 'pad': 0, 'uniform': None, 'weight': 0})
with self.assertRaisesRegexp(TclError, 'bad option "-foo"'):
self.root.grid_rowconfigure(0, 'foo')
self.root.grid_rowconfigure((0, 3), weight=2)
with self.assertRaisesRegexp(TclError,
'must specify a single element on retrieval'):
self.root.grid_rowconfigure((0, 3))
b = tkinter.Button(self.root)
b.grid_configure(column=0, row=0)
if tcl_version >= (8, 5):
self.root.grid_rowconfigure('all', weight=3)
with self.assertRaisesRegexp(TclError, 'expected integer but got "all"'):
self.root.grid_rowconfigure('all')
self.assertEqual(self.root.grid_rowconfigure(0, 'weight'), 3)
self.assertEqual(self.root.grid_rowconfigure(3, 'weight'), 2)
self.assertEqual(self.root.grid_rowconfigure(265, 'weight'), 0)
if tcl_version >= (8, 5):
self.root.grid_rowconfigure(b, weight=4)
self.assertEqual(self.root.grid_rowconfigure(0, 'weight'), 4)
def test_grid_rowconfigure_minsize(self):
with self.assertRaisesRegexp(TclError, 'bad screen distance "foo"'):
self.root.grid_rowconfigure(0, minsize='foo')
self.root.grid_rowconfigure(0, minsize=10)
self.assertEqual(self.root.grid_rowconfigure(0, 'minsize'), 10)
self.assertEqual(self.root.grid_rowconfigure(0)['minsize'], 10)
def test_grid_rowconfigure_weight(self):
with self.assertRaisesRegexp(TclError, 'expected integer but got "bad"'):
self.root.grid_rowconfigure(0, weight='bad')
with self.assertRaisesRegexp(TclError, 'invalid arg "-weight": '
'should be non-negative'):
self.root.grid_rowconfigure(0, weight=-3)
self.root.grid_rowconfigure(0, weight=3)
self.assertEqual(self.root.grid_rowconfigure(0, 'weight'), 3)
self.assertEqual(self.root.grid_rowconfigure(0)['weight'], 3)
def test_grid_rowconfigure_pad(self):
with self.assertRaisesRegexp(TclError, 'bad screen distance "foo"'):
self.root.grid_rowconfigure(0, pad='foo')
with self.assertRaisesRegexp(TclError, 'invalid arg "-pad": '
'should be non-negative'):
self.root.grid_rowconfigure(0, pad=-3)
self.root.grid_rowconfigure(0, pad=3)
self.assertEqual(self.root.grid_rowconfigure(0, 'pad'), 3)
self.assertEqual(self.root.grid_rowconfigure(0)['pad'], 3)
def test_grid_rowconfigure_uniform(self):
self.root.grid_rowconfigure(0, uniform='foo')
self.assertEqual(self.root.grid_rowconfigure(0, 'uniform'), 'foo')
self.assertEqual(self.root.grid_rowconfigure(0)['uniform'], 'foo')
def test_grid_forget(self):
b = tkinter.Button(self.root)
c = tkinter.Button(self.root)
b.grid_configure(row=2, column=2, rowspan=2, columnspan=2,
padx=3, pady=4, sticky='ns')
self.assertEqual(self.root.grid_slaves(), [b])
b.grid_forget()
c.grid_forget()
self.assertEqual(self.root.grid_slaves(), [])
self.assertEqual(b.grid_info(), {})
b.grid_configure(row=0, column=0)
info = b.grid_info()
self.assertEqual(info['row'], self._str(0))
self.assertEqual(info['column'], self._str(0))
self.assertEqual(info['rowspan'], self._str(1))
self.assertEqual(info['columnspan'], self._str(1))
self.assertEqual(info['padx'], self._str(0))
self.assertEqual(info['pady'], self._str(0))
self.assertEqual(info['sticky'], '')
def test_grid_remove(self):
b = tkinter.Button(self.root)
c = tkinter.Button(self.root)
b.grid_configure(row=2, column=2, rowspan=2, columnspan=2,
padx=3, pady=4, sticky='ns')
self.assertEqual(self.root.grid_slaves(), [b])
b.grid_remove()
c.grid_remove()
self.assertEqual(self.root.grid_slaves(), [])
self.assertEqual(b.grid_info(), {})
b.grid_configure(row=0, column=0)
info = b.grid_info()
self.assertEqual(info['row'], self._str(0))
self.assertEqual(info['column'], self._str(0))
self.assertEqual(info['rowspan'], self._str(2))
self.assertEqual(info['columnspan'], self._str(2))
self.assertEqual(info['padx'], self._str(3))
self.assertEqual(info['pady'], self._str(4))
self.assertEqual(info['sticky'], 'ns')
def test_grid_info(self):
b = tkinter.Button(self.root)
self.assertEqual(b.grid_info(), {})
b.grid_configure(row=2, column=2, rowspan=2, columnspan=2,
padx=3, pady=4, sticky='ns')
info = b.grid_info()
self.assertIsInstance(info, dict)
self.assertEqual(info['in'], self.root)
self.assertEqual(info['row'], self._str(2))
self.assertEqual(info['column'], self._str(2))
self.assertEqual(info['rowspan'], self._str(2))
self.assertEqual(info['columnspan'], self._str(2))
self.assertEqual(info['padx'], self._str(3))
self.assertEqual(info['pady'], self._str(4))
self.assertEqual(info['sticky'], 'ns')
def test_grid_bbox(self):
self.assertEqual(self.root.grid_bbox(), (0, 0, 0, 0))
self.assertEqual(self.root.grid_bbox(0, 0), (0, 0, 0, 0))
self.assertEqual(self.root.grid_bbox(0, 0, 1, 1), (0, 0, 0, 0))
with self.assertRaisesRegexp(TclError, 'expected integer but got "x"'):
self.root.grid_bbox('x', 0)
with self.assertRaisesRegexp(TclError, 'expected integer but got "x"'):
self.root.grid_bbox(0, 'x')
with self.assertRaisesRegexp(TclError, 'expected integer but got "x"'):
self.root.grid_bbox(0, 0, 'x', 0)
with self.assertRaisesRegexp(TclError, 'expected integer but got "x"'):
self.root.grid_bbox(0, 0, 0, 'x')
with self.assertRaises(TypeError):
self.root.grid_bbox(0, 0, 0, 0, 0)
t = self.root
# de-maximize
t.wm_geometry('1x1+0+0')
t.wm_geometry('')
f1 = tkinter.Frame(t, width=75, height=75, bg='red')
f2 = tkinter.Frame(t, width=90, height=90, bg='blue')
f1.grid_configure(row=0, column=0)
f2.grid_configure(row=1, column=1)
self.root.update()
self.assertEqual(t.grid_bbox(), (0, 0, 165, 165))
self.assertEqual(t.grid_bbox(0, 0), (0, 0, 75, 75))
self.assertEqual(t.grid_bbox(0, 0, 1, 1), (0, 0, 165, 165))
self.assertEqual(t.grid_bbox(1, 1), (75, 75, 90, 90))
self.assertEqual(t.grid_bbox(10, 10, 0, 0), (0, 0, 165, 165))
self.assertEqual(t.grid_bbox(-2, -2, -1, -1), (0, 0, 0, 0))
self.assertEqual(t.grid_bbox(10, 10, 12, 12), (165, 165, 0, 0))
def test_grid_location(self):
with self.assertRaises(TypeError):
self.root.grid_location()
with self.assertRaises(TypeError):
self.root.grid_location(0)
with self.assertRaises(TypeError):
self.root.grid_location(0, 0, 0)
with self.assertRaisesRegexp(TclError, 'bad screen distance "x"'):
self.root.grid_location('x', 'y')
with self.assertRaisesRegexp(TclError, 'bad screen distance "y"'):
self.root.grid_location('1c', 'y')
t = self.root
# de-maximize
t.wm_geometry('1x1+0+0')
t.wm_geometry('')
f = tkinter.Frame(t, width=200, height=100,
highlightthickness=0, bg='red')
self.assertEqual(f.grid_location(10, 10), (-1, -1))
f.grid_configure()
self.root.update()
self.assertEqual(t.grid_location(-10, -10), (-1, -1))
self.assertEqual(t.grid_location(-10, 0), (-1, 0))
self.assertEqual(t.grid_location(-1, 0), (-1, 0))
self.assertEqual(t.grid_location(0, -10), (0, -1))
self.assertEqual(t.grid_location(0, -1), (0, -1))
self.assertEqual(t.grid_location(0, 0), (0, 0))
self.assertEqual(t.grid_location(200, 0), (0, 0))
self.assertEqual(t.grid_location(201, 0), (1, 0))
self.assertEqual(t.grid_location(0, 100), (0, 0))
self.assertEqual(t.grid_location(0, 101), (0, 1))
self.assertEqual(t.grid_location(201, 101), (1, 1))
def test_grid_propagate(self):
self.assertEqual(self.root.grid_propagate(), True)
with self.assertRaises(TypeError):
self.root.grid_propagate(False, False)
self.root.grid_propagate(False)
self.assertFalse(self.root.grid_propagate())
f = tkinter.Frame(self.root, width=100, height=100, bg='red')
f.grid_configure(row=0, column=0)
self.root.update()
self.assertEqual(f.winfo_width(), 100)
self.assertEqual(f.winfo_height(), 100)
f.grid_propagate(False)
g = tkinter.Frame(self.root, width=75, height=85, bg='green')
g.grid_configure(in_=f, row=0, column=0)
self.root.update()
self.assertEqual(f.winfo_width(), 100)
self.assertEqual(f.winfo_height(), 100)
f.grid_propagate(True)
self.root.update()
self.assertEqual(f.winfo_width(), 75)
self.assertEqual(f.winfo_height(), 85)
def test_grid_size(self):
with self.assertRaises(TypeError):
self.root.grid_size(0)
self.assertEqual(self.root.grid_size(), (0, 0))
f = tkinter.Scale(self.root)
f.grid_configure(row=0, column=0)
self.assertEqual(self.root.grid_size(), (1, 1))
f.grid_configure(row=4, column=5)
self.assertEqual(self.root.grid_size(), (6, 5))
def test_grid_slaves(self):
self.assertEqual(self.root.grid_slaves(), [])
a = tkinter.Label(self.root)
a.grid_configure(row=0, column=1)
b = tkinter.Label(self.root)
b.grid_configure(row=1, column=0)
c = tkinter.Label(self.root)
c.grid_configure(row=1, column=1)
d = tkinter.Label(self.root)
d.grid_configure(row=1, column=1)
self.assertEqual(self.root.grid_slaves(), [d, c, b, a])
self.assertEqual(self.root.grid_slaves(row=0), [a])
self.assertEqual(self.root.grid_slaves(row=1), [d, c, b])
self.assertEqual(self.root.grid_slaves(column=0), [b])
self.assertEqual(self.root.grid_slaves(column=1), [d, c, a])
self.assertEqual(self.root.grid_slaves(row=1, column=1), [d, c])
tests_gui = (
PackTest, PlaceTest, GridTest,
)
if __name__ == '__main__':
run_unittest(*tests_gui)
test/test_tkinter/test_loadtk.pyo 0000644 00000003314 15032720555 0013315 0 ustar 00 �
z fc @ s� d d l Z d d l Z d d l Z d d l m Z d d l m Z m Z e j d � d e j f d � � YZ
e
f Z e d k r� e j
e � n d S( i����N( t test_support( t Tclt TclErrort guit
TkLoadTestc B s5 e Z e j d e j k d � d � � Z d � Z RS( t DISPLAYs No $DISPLAY set.c C sJ t � } | j t | j � | j � | j d | j � � | j � d S( Ns 1x1+0+0( R t assertRaisesR t winfo_geometryt loadtkt assertEqualt destroy( t selft tcl( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_loadtk.pyt
testLoadTk s
c C s� d } t j j d � r d St j � �t } d t j k ri | d =t j d � j � j
� } | ri d Sn t � } | j t
| j � | j t
| j � Wd QXd S( Nt wint darwint cygwinR s
echo $DISPLAY( R R R ( t Nonet syst platformt
startswithR t EnvironmentVarGuardt ost environt popent readt stripR R R R R ( R t old_displayt envt displayR ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_loadtk.pyt testLoadTkFailure s ( t __name__t
__module__t unittestt skipIfR R R
R ( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_loadtk.pyR s $t __main__( R R R! t testR t TkinterR R t requirest TestCaseR t tests_guiR t run_unittest( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_loadtk.pyt <module> s
! test/test_tkinter/test_loadtk.py 0000644 00000002662 15032720555 0013143 0 ustar 00 import os
import sys
import unittest
from test import test_support
from Tkinter import Tcl, TclError
test_support.requires('gui')
class TkLoadTest(unittest.TestCase):
@unittest.skipIf('DISPLAY' not in os.environ, 'No $DISPLAY set.')
def testLoadTk(self):
tcl = Tcl()
self.assertRaises(TclError,tcl.winfo_geometry)
tcl.loadtk()
self.assertEqual('1x1+0+0', tcl.winfo_geometry())
tcl.destroy()
def testLoadTkFailure(self):
old_display = None
if sys.platform.startswith(('win', 'darwin', 'cygwin')):
# no failure possible on windows?
# XXX Maybe on tk older than 8.4.13 it would be possible,
# see tkinter.h.
return
with test_support.EnvironmentVarGuard() as env:
if 'DISPLAY' in os.environ:
del env['DISPLAY']
# on some platforms, deleting environment variables
# doesn't actually carry through to the process level
# because they don't support unsetenv
# If that's the case, abort.
display = os.popen('echo $DISPLAY').read().strip()
if display:
return
tcl = Tcl()
self.assertRaises(TclError, tcl.winfo_geometry)
self.assertRaises(TclError, tcl.loadtk)
tests_gui = (TkLoadTest, )
if __name__ == "__main__":
test_support.run_unittest(*tests_gui)
test/test_tkinter/test_geometry_managers.pyc 0000644 00000120324 15032720555 0015534 0 ustar 00 �
z fc @ s d d l Z d d l Z d d l Z d d l m Z d d l m Z m Z d d l m Z m
Z
m Z d d l m
Z
m Z e d � d e
e j f d � � YZ d e
e j f d
� � YZ d e
e j f d � � YZ e e e f Z e d
k re e � n d S( i����N( t TclError( t requirest run_unittest( t pixels_convt tcl_versiont requires_tcl( t AbstractWidgetTestt int_roundt guit PackTestc B s� e Z d
Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d � Z d � Z
d
� Z d � Z d � Z RS( c
C s� t j | j d d �} | j d � | j d d � t j | d d d d d d d
d �} t j | d d d d
d d d
d �} t j | d d d d d d d
d �} t j | d d d d d d d
d �} | | | | | f S( Nt namet packs 300x200+0+0i t at widthi t heighti( t bgt redt bi2 i t bluet ciP t greent dt yellow( t tkintert Toplevelt roott wm_geometryt
wm_minsizet Frame( t selfR R R R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt create2 s
''''c C s; | j � \ } } } } } | j t d | � � | j d | � Wd QX| j t d � � | j d d � Wd QX| j d d � | j d d � | j d d � | j d d � | j | j � | | | | g � | j d | � | j | j � | | | | g � | j d | � | j | j � | | | | g � d S( Ns window "%s" isn't packedt afters bad window path name ".foo"s .foot sidet top( R t assertRaisesRegexpR t pack_configuret assertEqualt pack_slaves( R R R R R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_pack_configure_after s ""c s� � j � \ } � } } } � � f d � } | d d � | d d � | d d � | d d � | d
d � | d d
� | d d � | d d � | d d � d S( Nc s[ � j d d d d d d d d d d
d t d | � � j j � � j � j � | � d S(
NR R! t ipadxi t padxi
t ipadyi t padyi t expandt anchor( R# t TrueR t updateR$ t winfo_geometry( R, t geom( R R ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt check- s '
t ns 30x70+135+20t nes 30x70+260+20t es 30x70+260+65t ses
30x70+260+110t ss
30x70+135+110t sws 30x70+10+110t ws 30x70+10+65t nws 30x70+10+20t centers 30x70+135+65( R ( R R R R R R1 ( ( R R sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_pack_configure_anchor+ s
c C s; | j � \ } } } } } | j t d | � � | j d | � Wd QX| j t d � � | j d d � Wd QX| j d d � | j d d � | j d d � | j d d � | j | j � | | | | g � | j d | � | j | j � | | | | g � | j d | � | j | j � | | | | g � d S( Ns window "%s" isn't packedt befores bad window path name ".foo"s .fooR R! ( R R" R R# R$ R% ( R R R R R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_pack_configure_before< s ""c s{ � j � \ } � � � � � � � � � f d � } � j d d � � j d d � � j d d � � j d d � | d d d d
� � j d d d d � � j d d d d
� � j d d d t � � j d d d d � | d d d d � � j d d d d d d � � j d d d d
d d � � j d d d t d d � � j d d d d d d � | d d d d � d S( Nc sy � j j � � j � j � | d � � j � j � | d � � j � j � | d � � j � j � | d � d S( Ni i i i ( R R. R$ R/ ( t geoms( R R R R R ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyR1 N s
R t leftR! t rightt bottoms
20x40+0+80s 50x30+135+0s 80x80+220+75s
40x30+100+170R+ t yest oni s 20x40+40+80s 50x30+175+35s
80x80+180+110s
40x30+100+135t fillt boths 100x200+0+0s
200x100+100+0s 160x100+140+100s 40x100+100+100( R R# R- ( R R R1 ( ( R R R R R sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_pack_configure_expandL s" c C s2 | j � \ } } } } } | j d d � | j d d � | j d d � | j d d � | j d | � | j | j � | | | | g � | j d | � | j | j � | | | g � | j | j � | g � | j t d | f � � | j d | � Wd QX| j t d � � | j d d � Wd QXd S( NR R! t in_s can't pack %s inside itselfs bad window path name ".foo"s .foo( R R# R$ R% R" R ( R R R R R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_pack_configure_ind s " c s� � j � \ } � � } } � � � f d � } | d d d d d d �| d d d d d d' �| d d d d d d �| d
d d d d d d d �| d d d d d d d d �| d d d d d d( d d �| d d d d d d d d �| d
d d d d d d d d d �| d d d d d d d d) d d �| d d d d d d �| d d d d d d* �| d d d d d d �| d d d d d d d d �| d d d d d d d d+ �| d d d d d d d d �| d! d d d d d, d d �| d# d d d d d d d �| d$ d d d d d d d d d �| d% d d d d d d d- d d �� j d d& � � j � j � d � j | j d& � � � � j d d& � � j � j � d � j | j d& � � � d S(. Nc st � j � � j � � j | � � j d t d d � � j j � � j � j � | � � j � j � | � d S( NR+ RD RE ( t pack_forgetR# R- R R. R$ R/ ( t geom1t geom2t kwargs( R R R ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyR1 w s
s 20x40+260+80s 240x200+0+0R R@ R( i s 20x40+250+80i
i s 60x40+240+80R' s 30x40+260+80s 250x200+0+0i RD t xs 20x40+249+80i i s 30x40+255+80i s 20x40+140+0s 300x160+0+40R! s 20x40+120+0i i( s 60x40+120+0s 30x40+135+0s 30x40+130+0s 260x40+20+0s 260x40+25+0i s
300x40+0+0s 280x40+10+0s
280x40+5+0t 1c( i
i ( i i ( i i ( i i( ( i i ( i i ( i i ( R R# R$ t pack_infot _strt winfo_pixels( R R R R R1 ( ( R R R sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt# test_pack_configure_padx_ipadx_fillu sB c s� � j � \ } � � } } � � � f d � } | d d d d d d �| d d d d d d' �| d d d d d d �| d
d d d d d d d �| d d d d d d d d �| d d d d d d( d d �| d d d d d d d d �| d
d d d d d d d d d �| d d d d d d d d) d d �| d d d d d d �| d d d d d d* �| d d d d d d �| d d d d d d d d �| d d d d d d d d+ �| d d d d d d d d �| d! d d d d d, d d �| d# d d d d d d d �| d$ d d d d d d d d d �| d% d d d d d d d- d d �� j d d& � � j � j � d � j | j d& � � � � j d d& � � j � j � d � j | j d& � � � d S(. Nc st � j � � j � � j | � � j d t d d � � j j � � j � j � | � � j � j � | � d S( NR+ RD RE ( RI R# R- R R. R$ R/ ( RJ RK RL ( R R R ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyR1 � s
s 20x40+280+80s 280x200+0+0R R@ R* i s 20x40+280+70i
i s 20x80+280+60R) s 20x50+280+75i RD RM s 20x40+280+69i i s 20x50+280+70i s 20x40+140+20s 300x120+0+80R! s 20x40+140+0i i( s 20x80+140+0s 20x50+140+10s 300x130+0+70s 20x50+140+5s 300x40+0+20s 300x40+0+25i s
300x80+0+0s 300x50+0+10s
300x50+0+5RN ( i
i ( i i ( i i ( i i( ( i i ( i i ( i i ( R R# R$ RO RP RQ ( R R R R R1 ( ( R R R sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt# test_pack_configure_pady_ipady_fill� sB c st � j � \ } � � } } � � � f d � } | d d d � | d d d � | d d d
� | d d d
� d S( Nc s} � j d | � � j � j � d | � � j d t d d � � j j � � j � j � | � � j � j � | � d S( NR R+ RD RE ( R# R$ RO R- R R. R/ ( R RJ RK ( R R R ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyR1 � s
R! s 20x40+140+0s 300x160+0+40RA s
20x40+140+160s 300x160+0+0R? s
20x40+0+80s 280x200+20+0R@ s 20x40+280+80s 280x200+0+0( R ( R R R R R1 ( ( R R R sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_pack_configure_side� s c C s� | j � \ } } } } } | j � | j � | j � | j | j � | | | g � | j � | j | j � | | g � | j � | j | j � | | g � | j � d S( N( R R# R$ R% RI ( R R R R R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_pack_forget� s
c C s� | j � \ } } } } } | j t d | � � | j � Wd QX| j � | j d d d | d d d t d d d
d d d
d d d d � | j � } | j | t � | j | d d � | j | d | j d � � | j | d d � | j | d | � | j | d
| j d � � | j | d | j d � � | j | d | j d � � | j | d | j d � � | j | d d � | j � } | j | t � | j | d d � | j | d | j d � � | j | d d � | j | d | � | j | d
| j d � � | j | d | j d � � | j | d | j d
� � | j | d | j d � � | j | d d � d S( Ns window "%s" isn't packedR R@ RG R, R6 R+ RD RM R' i R( i
R) i R* i R: i t nonet inR! i ( i i ( i i (
R R" R RO R# R- t assertIsInstancet dictR$ RP ( R R R R R R t info( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_pack_info� s8
' c C s� | j � \ } } } } } | j d d d d � | j � | j t � | j j � | j | j � d � | j | j � d � | j t
� | j j � | j | j � d � | j | j � d � d S( NR
i, R i� i i( ( R t configureR# t pack_propagatet FalseR R. R$ t winfo_reqwidtht winfo_reqheightR- ( R R R R R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_pack_propagate s
c C s~ | j � \ } } } } } | j | j � g � | j � | j | j � | g � | j � | j | j � | | g � d S( N( R R$ R% R# ( R R R R R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_pack_slaves s
N( t __name__t
__module__t Nonet test_keysR R& R; R= RF RH RR RS RT RU R[ Ra Rb ( ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyR
s
* *
t PlaceTestc B s� e Z d Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d � Z d � Z
d
� Z d � Z d � Z d
� Z d � Z RS( c
C s� t j | j d d d d d d �} | j d � t j | d d d d d d
d d �} | j d
d d d � t j | d d d d d d
d d �} | j j � | | | f S( NR
i, R i� t bdi s 300x200+0+0i� iT i t relieft raisedRM i0 t yi& i i< ( R R R R R t place_configureR. ( R t tt ft f2( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyR s $
''
c C s� | j � \ } } } | j | j � d � | j t d t j t | � � � � | j d | � Wd QXt d k r� | j | j � d � n | j t d � � | j d d � Wd QX| j d | � | j | j � d � d S(
Nt s! can't place %s relative to itselfRG i i s bad window path namet spamt place( i i (
R R$ t
winfo_managerR" R t ret escapet strRl R ( R Rm Rn Ro ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_place_configure_in$ s c C s5 | j � \ } } } | j d | � | j | j � d d � | j j � | j | j � d � | j d d � | j | j � d d � | j j � | j | j � d � | j d d d d
� | j | j � d d � | j j � | j | j � d � | j t d
� � | j d | d d � Wd QXd S( NRG RM t 0i2 id t 100i� i����t relxi s -10i� s bad screen distance "spam"Rq ( R Rl R$ t
place_infoR R. t winfo_xR" R ( R Rm Rn Ro ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_place_configure_x1 s
c C s5 | j � \ } } } | j d | � | j | j � d d � | j j � | j | j � d � | j d d � | j | j � d d � | j j � | j | j � d � | j d d d d
� | j | j � d d � | j j � | j | j � d � | j t d
� � | j d | d d � Wd QXd S( NRG Rk Rx i( i2 t 50iZ i����t relyi s -10in s bad screen distance "spam"Rq ( R Rl R$ R{ R R. t winfo_yR" R ( R Rm Rn Ro ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_place_configure_yB s
c C s/ | j � \ } } } | j d | � | j | j � d d � | j j � | j | j � d � | j d d � | j | j � d d � | j j � | j | j � d � | j d d � | j | j � d d � | j j � | j | j � d
� | j t d � � | j d | d d � Wd QXd S(
NRG Rz Rx i2 g �?s 0.5i} i t 1i� s- expected floating-point number but got "spam"Rq ( R Rl R$ R{ R R. R| R" R ( R Rm Rn Ro ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_place_configure_relxS s
c C s/ | j � \ } } } | j d | � | j | j � d d � | j j � | j | j � d � | j d d � | j | j � d d � | j j � | j | j � d � | j d d � | j | j � d d � | j j � | j | j � d
� | j t d � � | j d | d d � Wd QXd S(
NRG R Rx i( g �?s 0.5iP i R� ix s- expected floating-point number but got "spam"Rq ( R Rl R$ R{ R R. R� R" R ( R Rm Rn Ro ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_place_configure_relye s
c C s� t j | j � } | j t d � � | j d d � Wd QX| j t d � � | j d d � Wd QXx8 d D]0 } | j d | � | j | j � d | � qk Wd S( Ns bad anchor "j"R, t js ambiguous anchor ""Rp R2 R3 R4 R5 R6 R7 R8 R9 R: ( R2 R3 R4 R5 R6 R7 R8 R9 R: ( R R R R" R Rl R$ R{ ( R Rn t value( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_place_configure_anchorw s
c C s� | j � \ } } } | j d | d d � | j j � | j | j � d � | j d d � | j j � | j | j � d � | j t d � � | j d d � Wd QXd S( NRG R
ix Rp i s bad screen distance "abcd"t abcd( R Rl R R. R$ t winfo_widthR" R ( R Rm Rn Ro ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_place_configure_width� s
c C s� | j � \ } } } | j d | d d � | j j � | j | j � d � | j d d � | j j � | j | j � d � | j t d � � | j d d � Wd QXd S( NRG R ix Rp i< s bad screen distance "abcd"R� ( R Rl R R. R$ t winfo_heightR" R ( R Rm Rn Ro ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_place_configure_height� s
c C s� | j � \ } } } | j d | d d � | j j � | j | j � d � | j d d � | j j � | j | j � d � | j t d � � | j d d � Wd QXd S( NRG t relwidthg �?iK Rp i s- expected floating-point number but got "abcd"R� ( R Rl R R. R$ R� R" R ( R Rm Rn Ro ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_place_configure_relwidth� s
c C s� | j � \ } } } | j d | d d � | j j � | j | j � d � | j d d � | j j � | j | j � d � | j t d � � | j d d � Wd QXd S( NRG t relheightg �?i( Rp i< s- expected floating-point number but got "abcd"R� ( R Rl R R. R$ R� R" R ( R Rm Rn Ro ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_place_configure_relheight� s
c C s� t j | j � } | j t d � � | j d d � Wd QX| j t d � � | j d d � Wd QXx8 d D]0 } | j d | � | j | j � d | � qk Wd S(
Ns bad bordermode "j"t
bordermodeR� s ambiguous bordermode ""Rp t insidet outsidet ignore( R� R� R� ( R R R R" R Rl R$ R{ ( R Rn R� ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_place_configure_bordermode� s
c C s� t j | j � } | j d d d d � | j j � | j � | j j � | j | j � � | j t � � | j d � Wd QXd S( NR
i2 R i (
R R R Rl R. t place_forgett assertFalset winfo_ismappedt assertRaisest TypeError( R t foo( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_place_forget� s
c C s� | j � \ } } } | j d | d d d d d d d d d
d d d
d d d d d d d d � | j � } | j | t � | j | d d � | j | d d � | j | d d � | j | d d � | j | d
d � | j | d d � | j | d d � | j | d d � | j | d d � | j | d d � | j | d d � | j | d d � | j t � � | j d � Wd QXd S( NRG RM i Rk i R
i R i Rz g�������?R g�������?R� g333333�?R� g�������?R, R5 R� R� R� t 2t 3t 4s 0.1s 0.2s 0.3s 0.4i ( R Rl R{ RX RY R$ R� R� ( R Rm Rn Ro RZ ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_place_info� s( '
c C s� t j | j � } t j | j � } | j | j � g � | j d | � | j | j � | g � | j t � � | j d � Wd QXd S( NRG i ( R R R R$ t place_slavesRl R� R� ( R R� t bar( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_place_slaves� s N( Rc Rd Re Rf R Rw R} R� R� R� R� R� R� R� R� R� R� R� R� ( ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyRg s
t GridTestc B s e Z d Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d � Z d � Z
d
� Z d � Z d � Z d
� Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z! RS( c C s� | j j � \ } } x@ t | d � D]. } | j j | d d d d d d d d �q& Wx@ t | d � D]. } | j j | d d d d d d d d �qi W| j j d � t t | � j � d S( Ni t weighti t minsizet padt uniformRp ( R t grid_sizet ranget grid_columnconfiguret grid_rowconfiguret grid_propagatet superR� t tearDown( R t colst rowst i( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyR� � s ,,c C s� t j | j � } | j | j � i � | j � | j | j � d | j � | j | j � d | j d � � | j | j � d | j d � � | j i d d 6d d �| j | j � d | j d � � | j | j � d | j d � � d S( NRW t columni t rowi i ( R t ButtonR R$ t grid_infot grid_configureRP ( R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_configure� s
###c C sr t j | j � } | j t d � � | j d d � Wd QX| j d d � | j | j � d | j d � � d S( Ns5 bad column value "-1": must be a non-negative integerR� i����i ( R R� R R" R R� R$ R� RP ( R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_configure_column� s
c C sr t j | j � } | j t d � � | j d d � Wd QX| j d d � | j | j � d | j d � � d S( Ns4 bad columnspan value "0": must be a positive integert
columnspani i ( R R� R R" R R� R$ R� RP ( R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_configure_columnspan s
c C s� t j | j � } t j | j � } | j | j � i � | j � | j | j � d | j � | j d | � | j | j � d | � | j i | j d 6� | j | j � d | j � d S( NRW RG ( R R R R� R$ R� R� ( R Rn R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_configure_in s
c C s� t j | j � } | j t d � � | j d d � Wd QX| j d d � | j | j � d | j d � � | j d d � | j | j � d | j t t
d � | j � � � d S( Ns6 bad ipadx value "-1": must be positive screen distanceR' i����i s .5c( R R� R R" R R� R$ R� RP R R t scaling( R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_configure_ipadx s #c C s� t j | j � } | j t d � � | j d d � Wd QX| j d d � | j | j � d | j d � � | j d d � | j | j � d | j t t
d � | j � � � d S( Ns6 bad ipady value "-1": must be positive screen distanceR) i����i s .5c( R R� R R" R R� R$ R� RP R R R� ( R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_configure_ipady! s #c C s� t j | j � } | j t d � � | j d d � Wd QX| j d d � | j | j � d | j d � � | j d d � | j | j � d | j d � � | j d d � | j | j � d | j t t
d � | j � � � d S(
Ns4 bad pad value "-1": must be positive screen distanceR( i����i i
i s .5c( i
i ( i
i ( R R� R R" R R� R$ R� RP R R R� ( R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_configure_padx, s ##c C s� t j | j � } | j t d � � | j d d � Wd QX| j d d � | j | j � d | j d � � | j d d � | j | j � d | j d � � | j d d � | j | j � d | j t t
d � | j � � � d S(
Ns4 bad pad value "-1": must be positive screen distanceR* i����i i
i s .5c( i
i ( i
i ( R R� R R" R R� R$ R� RP R R R� ( R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_configure_pady9 s ##c C sr t j | j � } | j t d � � | j d d � Wd QX| j d d � | j | j � d | j d � � d S( Ns9 bad (row|grid) value "-1": must be a non-negative integerR� i����i ( R R� R R" R R� R$ R� RP ( R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_configure_rowF s
c C sr t j | j � } | j t d � � | j d d � Wd QX| j d d � | j | j � d | j d � � d S( Ns1 bad rowspan value "0": must be a positive integert rowspani i ( R R� R R" R R� R$ R� RP ( R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_configure_rownspanN s
c C s� t j | j d d �} | j t d � � | j d d � Wd QX| j d d � | j | j � d d � | j d d � | j | j � d d � d S( NR R s bad stickyness value "glue"t stickyt glueR3 s n,s,e,wt nesw( R R R R" R R� R$ R� ( R Rn ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_configure_stickyV s c C s� | j t � � | j j � Wd QX| j | j j d � i d d 6d d 6d d 6d d 6� | j t d � � | j j d d � Wd QX| j j d d d �| j t d
� � | j j d � Wd QXt j | j � } | j
d d d d � t d k r[| j j d d d �| j t d � � | j j d � Wd QX| j | j j d d � d � n | j | j j d d � d � | j | j j d d � d � t d k r�| j j | d d �| j | j j d d � d � n d S( Ni R� R� R� R� s bad option "-foo"R� i i s* must specify a single element on retrievalR� R� i i t alls expected integer but got "all"i i ( i i ( i i ( i i ( i i ( R� R� R R� R$ Re R" R R R� R� R ( R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_columnconfigure_ s, #
" c C s� | j t d � � | j j d d d �Wd QX| j j d d d �| j | j j d d � d � | j | j j d � d d � d S( Ns bad screen distance "foo"i R� R� i
( R" R R R� R$ ( R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt! test_grid_columnconfigure_minsizew s
c C s� | j t d � � | j j d d d �Wd QX| j t d � � | j j d d d �Wd QX| j j d d d �| j | j j d d � d � | j | j j d � d d � d S( Ns expected integer but got "bad"i R� t bads- invalid arg "-weight": should be non-negativei����i ( R" R R R� R$ ( R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_columnconfigure_weight~ s c C s� | j t d � � | j j d d d �Wd QX| j t d � � | j j d d d �Wd QX| j j d d d �| j | j j d d � d � | j | j j d � d d � d S( Ns bad screen distance "foo"i R� R� s* invalid arg "-pad": should be non-negativei����i ( R" R R R� R$ ( R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_columnconfigure_pad� s c C sY | j j d d d �| j | j j d d � d � | j | j j d � d d � d S( Ni R� R� ( R R� R$ ( R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt! test_grid_columnconfigure_uniform� s c C s� | j t � � | j j � Wd QX| j | j j d � i d d 6d d 6d d 6d d 6� | j t d � � | j j d d � Wd QX| j j d d d �| j t d
� � | j j d � Wd QXt j | j � } | j
d d d d � t d k r[| j j d d d �| j t d � � | j j d � Wd QX| j | j j d d � d � n | j | j j d d � d � | j | j j d d � d � t d k r�| j j | d d �| j | j j d d � d � n d S( Ni R� R� R� R� s bad option "-foo"R� i i s* must specify a single element on retrievalR� R� i i R� s expected integer but got "all"i i ( i i ( i i ( i i ( i i ( R� R� R R� R$ Re R" R R R� R� R ( R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_rowconfigure� s, #
" c C s� | j t d � � | j j d d d �Wd QX| j j d d d �| j | j j d d � d � | j | j j d � d d � d S( Ns bad screen distance "foo"i R� R� i
( R" R R R� R$ ( R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_rowconfigure_minsize� s
c C s� | j t d � � | j j d d d �Wd QX| j t d � � | j j d d d �Wd QX| j j d d d �| j | j j d d � d � | j | j j d � d d � d S( Ns expected integer but got "bad"i R� R� s- invalid arg "-weight": should be non-negativei����i ( R" R R R� R$ ( R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_rowconfigure_weight� s c C s� | j t d � � | j j d d d �Wd QX| j t d � � | j j d d d �Wd QX| j j d d d �| j | j j d d � d � | j | j j d � d d � d S( Ns bad screen distance "foo"i R� R� s* invalid arg "-pad": should be non-negativei����i ( R" R R R� R$ ( R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_rowconfigure_pad� s c C sY | j j d d d �| j | j j d d � d � | j | j j d � d d � d S( Ni R� R� ( R R� R$ ( R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_rowconfigure_uniform� s c C s� t j | j � } t j | j � } | j d d d d d d d d d d d d d
d � | j | j j � | g � | j � | j � | j | j j � g � | j | j � i � | j d d d d � | j � } | j | d | j d � � | j | d | j d � � | j | d | j d
� � | j | d | j d
� � | j | d | j d � � | j | d | j d � � | j | d
d � d S( NR� i R� R� R� R( i R* i R� t nsi i Rp ( R R� R R� R$ t grid_slavest grid_forgetR� RP ( R R R RZ ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_forget� s$ !
c C s� t j | j � } t j | j � } | j d d d d d d d d d d d d d
d � | j | j j � | g � | j � | j � | j | j j � g � | j | j � i � | j d d d d � | j � } | j | d | j d � � | j | d | j d � � | j | d | j d � � | j | d | j d � � | j | d | j d � � | j | d | j d � � | j | d
d � d S(
NR� i R� R� R� R( i R* i R� R� i ( R R� R R� R$ R� t grid_removeR� RP ( R R R RZ ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_remove� s$ !
c C sU t j | j � } | j | j � i � | j d d d d d d d d d d d d d
d � | j � } | j | t � | j | d | j � | j | d | j d � � | j | d | j d � � | j | d | j d � � | j | d | j d � � | j | d | j d � � | j | d | j d � � | j | d
d � d S(
NR� i R� R� R� R( i R* i R� R� RW ( R R� R R$ R� R� RX RY RP ( R R RZ ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_info� s ! c C s� | j | j j � d � | j | j j d d � d � | j | j j d d d d � d � | j t d � � | j j d d � Wd QX| j t d � � | j j d d � Wd QX| j t d � � | j j d d d d � Wd QX| j t d � � | j j d d d d � Wd QX| j t � �! | j j d d d d d � Wd QX| j } | j d � | j d � t j | d d d d d
d �} t j | d d d d d
d
�} | j
d d d d � | j
d d d d � | j j � | j | j � d � | j | j d d � d � | j | j d d d d � d � | j | j d d � d � | j | j d d d d � d � | j | j d d d d � d � | j | j d d d d � d � d S( Ni i s expected integer but got "x"RM s 1x1+0+0Rp R
iK R R R iZ R R� R� i� i
i����i����i ( i i i i ( i i i i ( i i i i ( i i i� i� ( i i iK iK ( i i i� i� ( iK iK iZ iZ ( i i i� i� ( i i i i ( i� i� i i ( R$ R t grid_bboxR" R R� R� R R R R� R. ( R Rm t f1Ro ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_bbox s8 % "
!!
" ""c C s� | j t � � | j j � Wd QX| j t � � | j j d � Wd QX| j t � � | j j d d d � Wd QX| j t d � � | j j d d � Wd QX| j t d � � | j j d d � Wd QX| j } | j d � | j d � t j | d d
d d d
d d d �} | j | j d d � d � | j
� | j j � | j | j d d � d � | j | j d d � d � | j | j d d � d � | j | j d d � d � | j | j d d � d � | j | j d d � d � | j | j d
d � d � | j | j d d � d � | j | j d d � d � | j | j d d � d � | j | j d d � d! � d S(" Ni s bad screen distance "x"RM Rk s bad screen distance "y"RN s 1x1+0+0Rp R
i� R id t highlightthicknessR R i
i����i����i� i ie ( i����i����( i����i����( i����i ( i����i ( i i����( i i����( i i ( i i ( i i ( i i ( i i ( i i ( R� R� R t
grid_locationR" R R R R R$ R� R. ( R Rm Rn ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_location& s:
c C s� | j | j j � t � | j t � � | j j t t � Wd QX| j j t � | j | j j � � t j | j d d d d d d �} | j
d d d d � | j j � | j | j � d � | j | j
� d � | j t � t j | j d d d d
d d �} | j
d | d d d d � | j j � | j | j � d � | j | j
� d � | j t � | j j � | j | j � d � | j | j
� d
� d S(
NR
id R R R R� i R� iK iU R RG ( R$ R R� R- R� R� R^ R� R R R� R. R� R� ( R Rn t g( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_propagateF s( $
$
c C s� | j t � � | j j d � Wd QX| j | j j � d � t j | j � } | j d d d d � | j | j j � d � | j d d d d � | j | j j � d
� d S( Ni R� R� i i i i ( i i ( i i ( i i ( R� R� R R� R$ R t ScaleR� ( R Rn ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_size\ s c C s� | j | j j � g � t j | j � } | j d d d d � t j | j � } | j d d d d � t j | j � } | j d d d d � t j | j � } | j d d d d � | j | j j � | | | | g � | j | j j d d � | g � | j | j j d d � | | | g � | j | j j d d � | g � | j | j j d d � | | | g � | j | j j d d d d � | | g � d S( NR� i R� i ( R$ R R� R t LabelR� ( R R R R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_slavesf s %"("(N(" Rc Rd Re Rf R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� ( ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyR� � s>
t __main__( t unittestRt t TkinterR R t test.test_supportR R t test_ttk.supportR R R t widget_testsR R t TestCaseR Rg R� t tests_guiRc ( ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt <module> s
� � � � test/test_tkinter/test_font.py 0000644 00000007746 15032720555 0012643 0 ustar 00 import unittest
import Tkinter as tkinter
import tkFont as font
from test.test_support import requires, run_unittest, gc_collect
from test_ttk.support import AbstractTkTest
requires('gui')
fontname = "TkDefaultFont"
class FontTest(AbstractTkTest, unittest.TestCase):
@classmethod
def setUpClass(cls):
AbstractTkTest.setUpClass.__func__(cls)
try:
cls.font = font.Font(root=cls.root, name=fontname, exists=True)
except tkinter.TclError:
cls.font = font.Font(root=cls.root, name=fontname, exists=False)
def test_configure(self):
options = self.font.configure()
self.assertGreaterEqual(set(options),
{'family', 'size', 'weight', 'slant', 'underline', 'overstrike'})
for key in options:
self.assertEqual(self.font.cget(key), options[key])
self.assertEqual(self.font[key], options[key])
for key in 'family', 'weight', 'slant':
self.assertIsInstance(options[key], str)
self.assertIsInstance(self.font.cget(key), str)
self.assertIsInstance(self.font[key], str)
sizetype = int if self.wantobjects else str
for key in 'size', 'underline', 'overstrike':
self.assertIsInstance(options[key], sizetype)
self.assertIsInstance(self.font.cget(key), sizetype)
self.assertIsInstance(self.font[key], sizetype)
def test_unicode_family(self):
family = u'MS \u30b4\u30b7\u30c3\u30af'
try:
f = font.Font(root=self.root, family=family, exists=True)
except tkinter.TclError:
f = font.Font(root=self.root, family=family, exists=False)
self.assertEqual(f.cget('family'), family)
del f
gc_collect()
def test_actual(self):
options = self.font.actual()
self.assertGreaterEqual(set(options),
{'family', 'size', 'weight', 'slant', 'underline', 'overstrike'})
for key in options:
self.assertEqual(self.font.actual(key), options[key])
for key in 'family', 'weight', 'slant':
self.assertIsInstance(options[key], str)
self.assertIsInstance(self.font.actual(key), str)
sizetype = int if self.wantobjects else str
for key in 'size', 'underline', 'overstrike':
self.assertIsInstance(options[key], sizetype)
self.assertIsInstance(self.font.actual(key), sizetype)
def test_name(self):
self.assertEqual(self.font.name, fontname)
self.assertEqual(str(self.font), fontname)
def test_eq(self):
font1 = font.Font(root=self.root, name=fontname, exists=True)
font2 = font.Font(root=self.root, name=fontname, exists=True)
self.assertIsNot(font1, font2)
self.assertEqual(font1, font2)
self.assertNotEqual(font1, font1.copy())
self.assertNotEqual(font1, 0)
self.assertNotIn(font1, [0])
def test_measure(self):
self.assertIsInstance(self.font.measure('abc'), int)
def test_metrics(self):
metrics = self.font.metrics()
self.assertGreaterEqual(set(metrics),
{'ascent', 'descent', 'linespace', 'fixed'})
for key in metrics:
self.assertEqual(self.font.metrics(key), metrics[key])
self.assertIsInstance(metrics[key], int)
self.assertIsInstance(self.font.metrics(key), int)
def test_families(self):
families = font.families(self.root)
self.assertIsInstance(families, tuple)
self.assertTrue(families)
for family in families:
self.assertIsInstance(family, (str, unicode))
self.assertTrue(family)
def test_names(self):
names = font.names(self.root)
self.assertIsInstance(names, tuple)
self.assertTrue(names)
for name in names:
self.assertIsInstance(name, (str, unicode))
self.assertTrue(name)
self.assertIn(fontname, names)
tests_gui = (FontTest, )
if __name__ == "__main__":
run_unittest(*tests_gui)
test/test_tkinter/test_images.pyo 0000644 00000037047 15032720555 0013316 0 ustar 00 �
z fc @ s� d d l Z d d l Z d d l Z d d l j Z d d l m Z m Z e j
d � d e e j f d � � YZ d e e j f d � � YZ
d e e j f d � � YZ e e
e f Z e d
k r� e j e � n d S( i����N( t AbstractTkTestt requires_tclt guit MiscTestc B s e Z d � Z d � Z RS( c C sC | j j � } | j | t � | j d | � | j d | � d S( Nt photot bitmap( t roott image_typest assertIsInstancet tuplet assertIn( t selfR ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_image_types s c C s# | j j � } | j | t � d S( N( R t image_namesR R ( R R
( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_image_names s ( t __name__t
__module__R R ( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyR
s t BitmapImageTestc B sV e Z e d � � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
RS( c C s, t j j | � t j d d d �| _ d S( Ns
python.xbmt subdirt
imghdrdata( R t
setUpClasst __func__t supportt findfilet testfile( t cls( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyR s c
C s� t j d d | j d d d d d | j �} | j t | � d � | j | j � d � | j | j � d � | j | j � d � | j d | j j
� � ~ | j d | j j
� � d S(
Ns ::img::testt mastert
foregroundt yellowt
backgroundt bluet fileR i ( t tkintert BitmapImageR R t assertEqualt strt typet widtht heightR
R
t assertNotIn( R t image( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_create_from_file s c C s� t | j d � � } | j � } Wd QXt j d d | j d d d d d | �} | j t | � d � | j | j � d � | j | j � d
� | j | j
� d
� | j d | j j � � ~ | j
d | j j � � d S( Nt rbs ::img::testR R R R R t dataR i ( t openR t readR R! R R" R# R$ R% R& R
R
R' ( R t fR+ R( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_create_from_data* s c C s0 | j | t � | j | j j | � | � d S( N( R R# R" R t splitlist( R t actualt expected( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt assertEqualStrList8 s c C s� t j d d | j �} | j | d d � t | j d � � } | j � } Wd QX| j d | � | j | d d d d d | f � | j | j � d � | j | j
� d � | j | d d
� | j d | � | j | d d d d d | f � d S( Ns ::img::testR R+ s -data {} {} {} {}R* s -datat i t maskdatas -maskdata {} {} {} {}s -maskdata( R R! R R" R, R R- t configureR3 R% R& ( R R( R. R+ ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_configure_data< s
c C s� t j d d | j �} | j | d d � | j d | j � | j | d d d d d | j f � | j | j � d � | j | j � d � | j | d d � | j d | j � | j | d d
d d d | j f � d S( Ns ::img::testR R s -file {} {} {} {}s -fileR4 i t maskfiles -maskfile {} {} {} {}s -maskfile( R R! R R" R6 R R3 R% R& ( R R( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_configure_fileL s
c C sT t j d d | j �} | j | d d � | j d d � | j | d d � d S( Ns ::img::testR R s -background {} {} {} {}R s -background {} {} {} blue( R R! R R" R6 ( R R( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_configure_backgroundZ s c C sT t j d d | j �} | j | d d � | j d d � | j | d d � d S( Ns ::img::testR R s! -foreground {} {} #000000 #000000R s -foreground {} {} #000000 yellow( R R! R R" R6 ( R R( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_configure_foreground` s
( R R t classmethodR R) R/ R3 R7 R9 R: R; ( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyR s t PhotoImageTestc B s e Z e d � � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d � Z d
� Z
e d d � d
� � Z e d d � d � � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c C s, t j j | � t j d d d �| _ d S( Ns
python.gifR R ( R R R R R R ( R ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyR k s c C s t j d d | j d | j �S( Ns ::img::testR R ( R t
PhotoImageR R ( R ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt createp s c G s- t j d k r | j r | St j | � Sd S( Ng333333!@( R t TkVersiont wantobjectst _join( R t args( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt colorlistt s c C s� t j d | d d �} t j d d | j d | �} | j t | � d � | j | j � d � | j | j � d � | j | j � d � | j | d d
� | j | d | � | j
d | j j � � ~ | j d | j j � � d S( Ns python.R R s ::img::testR R R i R+ R4 (
R R R R> R R" R# R$ R% R& R
R
R' ( R t extR R( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt check_create_from_filez s c C s, t j d | d d �} t | d � � } | j � } Wd QXt j d d | j d | �} | j t | � d � | j | j � d � | j | j
� d � | j | j � d � | j | d | j r� | n | j
d
� � | j | d d � | j d | j j � � ~ | j d | j j � � d S(
Ns python.R R R* s ::img::testR R+ R i t latin1R R4 ( R R R, R- R R> R R" R# R$ R% R& RA t decodeR
R
R' ( R RE R R. R+ R( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt check_create_from_data� s c C s | j d � d S( Nt ppm( RF ( R ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_create_from_ppm_file� s c C s | j d � d S( NRJ ( RI ( R ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_create_from_ppm_data� s c C s | j d � d S( Nt pgm( RF ( R ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_create_from_pgm_file� s c C s | j d � d S( NRM ( RI ( R ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_create_from_pgm_data� s c C s | j d � d S( Nt gif( RF ( R ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_create_from_gif_file� s c C s | j d � d S( NRP ( RI ( R ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_create_from_gif_data� s i i c C s | j d � d S( Nt png( RF ( R ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_create_from_png_file� s c C s | j d � d S( NRS ( RI ( R ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_create_from_png_data� s c C s� t j d d | j �} | j | d d � t | j d � � } | j � } Wd QX| j d | � | j | d | j r | n | j d � � | j | j
� d � | j | j � d � d S( Ns ::img::testR R+ R4 R* RG i ( R R> R R" R, R R- R6 RA RH R% R& ( R R( R. R+ ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyR7 � s c C s� t j d d | j �} | j | d d � | j d | j d d � | j | d | j ra d n d � | j | j � d � | j | j � d � d S( Ns ::img::testR t formatR4 R RP i ( RP ( R R> R R" R6 R RA R% R& ( R R( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_configure_format� s c C s� t j d d | j �} | j | d d � | j d | j � | j | d | j � | j | j � d � | j | j � d � d S( Ns ::img::testR R R4 i ( R R> R R" R6 R R% R& ( R R( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyR9 � s c C sT t j d d | j �} | j | d d � | j d d � | j | d d � d S( Ns ::img::testR t gammas 1.0g @s 2.0( R R> R R" R6 ( R R( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_configure_gamma� s c C s� t j d d | j �} | j | d d � | j | d d � | j d d � | j d d � | j | d d � | j | d d � | j | j � d � | j | j � d � d S(
Ns ::img::testR R% t 0R& i i
t 20t 10( R R> R R" R6 R% R& ( R R( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_configure_width_height� s c C sx t j d d | j �} | j | d d � | j d d � | j | d d � | j d d � | j | d d � d S( Ns ::img::testR t paletteR4 i t 256s 3/4/2( R R> R R" R6 ( R R( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_configure_palette� s c C sq | j � } | j � | j | j � d � | j | j � d � | j | j d d � | j d d d � � d S( Ni i i i ( R? t blankR" R% R& t getRD ( R R( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt
test_blank� s
c C sp | j � } | j � } | j | j � d � | j | j � d � | j | j d d � | j d d � � d S( Ni i i ( R? t copyR" R% R& Rb ( R R( t image2( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_copy� s
c C s� | j � } | j d d � } | j | j � d � | j | j � d � | j | j d d � | j d d � � | j d � } | j | j � d � | j | j � d � | j | j d d � | j d d � � d S( Ni i i i i ( R? t subsampleR" R% R& Rb ( R R( Re ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_subsample� s (c C s) | j � } | j d d � } | j | j � d � | j | j � d � | j | j d d � | j d d � � | j | j d d
� | j d d � � | j d � } | j | j � d � | j | j � d � | j | j d d � | j d d � � | j | j d d � | j d d � � d S(
Ni i i i0 i i i i i i i i
( R? t zoomR" R% R& Rb ( R R( Re ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_zoom s (((c C s� | j � } | j d d d �| j | j d d � | j d d d � � | j | j d d � | j d t j d k r} d n d d � � | j | j d d
� | j d d d � � | j | j d d
� | j d d d � � | j d d f � | j | j d d � | j d d d � � | j | j d d � | j d d d � � | j | j d d � | j d d d � � | j | j d d � | j d d d � � d S( Ns {red green} {blue yellow}t toi i i� i i g333333!@i� i s #f00s #00ff00s
#000000fffs
#ffffffff0000i ( i i ( s #f00s #00ff00( s
#000000fffs
#ffffffff0000( R? t putR" Rb RD R R@ ( R R( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_put s +
+++++c C s | j � } | j | j d d � | j d d d � � | j | j d d � | j d d d � � | j | j d d � | j d d d � � | j t j | j d d � | j t j | j d d � | j t j | j d d � | j t j | j d d � d S(
Ni i i> it i� i i i����i ( R? R" Rb RD t assertRaisesR t TclError( R R( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_get s +++ c C s� | j � } | j t j t j � | j t j � t j d d | j d d d t j �} | j t
| � d � | j | j � d � | j | j � d � | j | j
� d � | j | j d d � | j d d � � | j | j d d
� | j d d
� � | j t j d d d d �t j d d | j d d d t j �} | j t
| � d � | j | j � d � | j | j � d � | j | j
� d � | j | j d d � | j d
d � � | j | j d d � | j d d
� � d S( Ns ::img::test2R RV RJ R R i i i i RP t from_coordsi i i s ::img::test3i i i i ( i i i i ( R? t
addCleanupR t unlinkt TESTFNt writeR R> R R" R# R$ R% R& Rb ( R R( Re t image3( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt
test_write* s, (( (( R R R< R R? RD RF RI RK RL RN RO RQ RR R RT RU R7 RW R9 RY R] R` Rc Rf Rh Rj Rm Rp Rw ( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyR= i s4
t __main__( t unittestt TkinterR t ttkt test.test_supportt test_supportR t test_ttk.supportR R t requirest TestCaseR R R= t tests_guiR t run_unittest( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt <module> s
R � test/test_tkinter/test_widgets.pyo 0000644 00000172022 15032720555 0013510 0 ustar 00 �
z fc @ sT d d l Z d d l Z d d l m Z d d l Z d d l Z d d l m Z m Z d d l m
Z
m Z m Z m
Z
d d l m Z m Z m Z m Z m Z m Z m Z m Z m Z m Z e d � d e e f d � � YZ e e � d e e j f d
� � Y� Z e e � d e e j f d � � Y� Z e e � d
e e j f d � � Y� Z d e e f d � � YZ e e � d e e j f d � � Y� Z e e � d e e j f d � � Y� Z e e � d e e j f d � � Y� Z! e e � d e e j f d � � Y� Z" e e � d e e j f d � � Y� Z# d e# e j f d � � YZ$ e e e � d e e j f d � � Y� Z% e e � d e% e j f d � � Y� Z& e e � d! e e j f d" � � Y� Z' e e e � d# e e j f d$ � � Y� Z( e e e � d% e e j f d& � � Y� Z) e e e � d' e e j f d( � � Y� Z* e e e � d) e e j f d* � � Y� Z+ e e � d+ e e j f d, � � Y� Z, e e � d- e e j f d. � � Y� Z- e e e � d/ e e j f d0 � � Y� Z. e e( e! e% e e e e) e# e- e. e$ e, e" e* e+ e& e' e g Z/ e0 d1 k rPe e/ � n d S(2 i����N( t TclError( t requirest run_unittest( t tcl_versiont requires_tclt get_tk_patchlevelt widget_eq(
t add_standard_optionst noconvt noconv_metht int_roundt pixels_roundt AbstractWidgetTestt StandardOptionsTestst IntegerSizeTestst PixelSizeTestst setUpModulet guit AbstractToplevelTestc B s2 e Z e Z d � Z d � Z d � Z d � Z RS( c C so | j � } | j | d | j j j � � | j | d d d d �| j d d � } | j | d d � d S( Nt classt Foot errmsgs2 can't modify -class option after widget is createdt class_( t createt assertEqualt __class__t __name__t titlet checkInvalidParam( t selft widgett widget2( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_class s
c C sc | j � } | j | d d � | j | d d d d �| j d d � } | j | d d � d S( Nt colormapt t newR s5 can't modify -colormap option after widget is created( R R R ( R R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_colormap s c C s� | j � } | j | d | j r( d n d � | j | d d d d �| j d t � } | j | d | j rv d n d � d S( Nt containeri t 0i R s6 can't modify -container option after widget is createdt 1( R R t wantobjectsR t True( R R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_container' s #c C sc | j � } | j | d d � | j | d d d d �| j d d � } | j | d d � d S( Nt visualR" t defaultR s3 can't modify -visual option after widget is created( R R R ( R R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_visual/ s ( R t
__module__R t _conv_pad_pixelsR R$ R* R- ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR s
t ToplevelTestc B s2 e Z d Z d � Z d � Z d � Z d � Z RS( t
backgroundt borderwidthR R! R% t cursort heightt highlightbackgroundt highlightcolort highlightthicknesst menut padxt padyt relieft screent takefocust useR+ t widthc K s t j | j | � S( N( t tkintert Toplevelt root( R t kwargs( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR B s c C sN | j � } t j | j � } | j | d | d t �| j | d d � d S( NR8 t eqR" ( R R@ t MenuRB t
checkParamR ( R R R8 ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_menuE s c C s� | j � } | j | d d � y t j d } Wn t k
rQ | j d � n X| j | d | d d �| j d | � } | j | d | � d S( NR< R" t DISPLAYs No $DISPLAY set.R s3 can't modify -screen option after widget is created( R R t ost environt KeyErrort skipTestR ( R R t displayR ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_screenK s
c C sl | j � } | j | d d � | j d t � } d | j � } | j d | � } | j | d | � d S( NR> R" R% s %#x( R R R) t winfo_id( R R t parentt widR ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_useW s ( R1 R2 R R! R% R3 R4 R5 R6 R7 R8 R9 R: R; R< R= R> R+ R? ( R R. t OPTIONSR RG RN RR ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR0 8 s t FrameTestc B s e Z d Z d � Z RS( R1 R2 R R! R% R3 R4 R5 R6 R7 R9 R: R; R= R+ R? c K s t j | j | � S( N( R@ t FrameRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR j s ( R1 R2 R R! R% R3 R4 R5 R6 R7 R9 R: R; R= R+ R? ( R R. RS R ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyRT a s
t LabelFrameTestc B s) e Z d Z d � Z d � Z d � Z RS( R1 R2 R R! R% R3 t fontt
foregroundR4 R5 R6 R7 t labelanchort labelwidgetR9 R: R; R= t textR+ R? c K s t j | j | � S( N( R@ t
LabelFrameRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR y s c C sW | j � } | j | d d d d d d d d d d
d d d
� | j | d d � d S( NRY t et ent est nt net nwt st set swt wt wnt wst center( R t checkEnumParamR ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_labelanchor| s
c C sQ | j � } t j | j d d d d �} | j | d | d d �| j � d S( NR[ t Muppt namet fooRZ t expecteds .foo( R R@ t LabelRB RF t destroy( R R t label( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_labelwidget� s ( R1 R2 R R! R% R3 RW RX R4 R5 R6 R7 RY RZ R9 R: R; R= R[ R+ R? ( R R. RS R Rk Rs ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyRV n s t AbstractLabelTestc B s e Z e Z d � Z RS( c C s2 | j � } | j | d d d d d d d � d S( NR7 i g�������?g������@i i����t 10p( R t checkPixelsParam( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_highlightthickness� s ( R R. R t _conv_pixelsRw ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyRt � s t LabelTestc B s e Z d Z d � Z RS( t activebackgroundt activeforegroundt anchorR1 t bitmapR2 t compoundR3 t disabledforegroundRW RX R4 R5 R6 R7 t imaget justifyR9 R: R; t stateR= R[ t textvariablet underlineR? t
wraplengthc K s t j | j | � S( N( R@ Rp RB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � s ( Rz R{ R| R1 R} R2 R~ R3 R RW RX R4 R5 R6 R7 R� R� R9 R: R; R� R= R[ R� R� R? R� ( R R. RS R ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyRy � s t
ButtonTestc B s e Z d" Z d � Z d! � Z RS(# Rz R{ R| R1 R} R2 t commandR~ R3 R, R RW RX R4 R5 R6 R7 R� R� t
overreliefR9 R: R; t repeatdelayt repeatintervalR� R= R[ R� R� R? R� c K s t j | j | � S( N( R@ t ButtonRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � s c C s) | j � } | j | d d d d � d S( NR, t activet disabledt normal( R Rj ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_default� s ( Rz R{ R| R1 R} R2 R� R~ R3 R, R RW RX R4 R5 R6 R7 R� R� R� R9 R: R; R� R� R� R= R[ R� R� R? R� ( R R. RS R R� ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� � s t CheckbuttonTestc & B s) e Z d) Z d& � Z d' � Z d( � Z RS(* Rz R{ R| R1 R} R2 R� R~ R3 R RW RX R4 R5 R6 R7 R� t indicatoronR� t offrelieft offvaluet onvalueR� R9 R: R; t selectcolort selectimageR� R= R[ R� t
tristateimaget
tristatevalueR� t variableR? R� c K s t j | j | � S( N( R@ t CheckbuttonRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � s c C s, | j � } | j | d d d d d � d S( NR� i gffffff@R" s
any string( R t checkParams( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_offvalue� s c C s, | j � } | j | d d d d d � d S( NR� i gffffff@R" s
any string( R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_onvalue� s (& Rz R{ R| R1 R} R2 R� R~ R3 R RW RX R4 R5 R6 R7 R� R� R� R� R� R� R� R9 R: R; R� R� R� R= R[ R� R� R� R� R� R? R� ( R R. RS R R� R� ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� � s t RadiobuttonTestc % B s e Z d' Z d% � Z d& � Z RS(( Rz R{ R| R1 R} R2 R� R~ R3 R RW RX R4 R5 R6 R7 R� R� R� R� R� R9 R: R; R� R� R� R= R[ R� R� R� R� t valueR� R? R� c K s t j | j | � S( N( R@ t RadiobuttonRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � s c C s, | j � } | j | d d d d d � d S( NR� i gffffff@R" s
any string( R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_value� s (% Rz R{ R| R1 R} R2 R� R~ R3 R RW RX R4 R5 R6 R7 R� R� R� R� R� R9 R: R; R� R� R� R= R[ R� R� R� R� R� R� R? R� ( R R. RS R R� ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� � s t MenubuttonTestc B s� e Z d( Z e e � Z d � Z d � Z d � Z e j
j Z
e j
e j d! k d" � d# � � Z d$ � Z d% � Z d& � Z d' � Z RS() Rz R{ R| R1 R} R2 R~ R3 t directionR RW RX R4 R5 R6 R7 R� R� R� R8 R9 R: R; R� R= R[ R� R� R? R� c K s t j | j | � S( N( R@ t
MenubuttonRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � s c C s/ | j � } | j | d d d d d d � d S( NR� t abovet belowt flusht leftt right( R Rj ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_direction� s c C s/ | j � } | j | d d d d d t �d S( NR4 id i����i t conv( R t checkIntegerParamt str( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_height s t darwins" crashes with Cocoa Tk (issue19733)c C s� | j � } t j d | j d d � } | j | d | d t �d } | j t j � � } d | d <Wd QX| d k r� | j t | j
� | � n | j t j � � } | j i d d 6� Wd QX| d k r� | j t | j
� | � n d S( Nt masterRm t image1R� R� s image "spam" doesn't existt spam( R R@ t
PhotoImageRB RF R� t assertRaisesR t NoneR t exceptiont configure( R R R� R t cm( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_image s c C sH | j � } t j | d d �} | j | d | d t �| j � d S( NRm R8 RD ( R R@ RE RF R Rq ( R R R8 ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyRG s c C sE | j � } | j | d d d d d � | j | d d d d �d S( NR9 i g������@gffffff@t 12mi����Ro i ( R Rv RF ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_padx s c C sE | j � } | j | d d d d d � | j | d d d d �d S( NR: i g������@gffffff@R� i����Ro i ( R Rv RF ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_pady$ s c C s/ | j � } | j | d d d d d t �d S( NR? i� in���i R� ( R R� R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_width) s ( Rz R{ R| R1 R} R2 R~ R3 R� R RW RX R4 R5 R6 R7 R� R� R� R8 R9 R: R; R� R= R[ R� R� R? R� ( R R. RS t staticmethodR Rx R R� R� R
Rw t im_funct unittestt skipIft syst platformR� RG R� R� R� ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� � s( t OptionMenuTestc B s e Z d d d � Z RS( t bt at cc K s t j | j d | | | � S( N( R@ t
OptionMenuRB R� ( R R, t valuesRC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR 0 s ( R� R� R� ( R R. R ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� . s t EntryTestc B sh e Z d) Z d � Z d � Z d! � Z d" � Z d# � Z d$ � Z d% � Z d& � Z
d' � Z d( � Z RS(* R1 R2 R3 t disabledbackgroundR t exportselectionRW RX R5 R6 R7 t insertbackgroundt insertborderwidtht
insertofftimet insertontimet insertwidtht invalidcommandR� t readonlybackgroundR; t selectbackgroundt selectborderwidtht selectforegroundt showR� R= R� t validatet validatecommandR? t xscrollcommandc K s t j | j | � S( N( R@ t EntryRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR C s c C s | j � } | j | d � d S( NR� ( R t checkColorParam( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_disabledbackgroundF s c C sQ | j d d � } | j | d d d d d d d � | j | d d
d d
�d S( NR� id R� i g�������?g������@i i����Ru i< Ro i i2 ( R Rv RF ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_insertborderwidthJ s c C s� | j � } | j | d d d d � | j | d d d d �| j | d d d d �t d � d
k r� | j | d d d d �n | j | d d d d �d S( NR� g�������?g������ @Ru g�������?Ro i i����g�������?i i ( R Rv RF R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_insertwidthQ s c C s0 | j � } | j | d � | j | d � d S( NR� t invcmd( R t checkCommandParam( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_invalidcommand[ s c C s | j � } | j | d � d S( NR� ( R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_readonlybackground` s c C sI | j � } | j | d d � | j | d d � | j | d d � d S( NR� t *R" t ( R RF ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_showd s c C s) | j � } | j | d d d d � d S( NR� R� R� t readonly( R Rj ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_statej s c C s2 | j � } | j | d d d d d d d � d S( NR� t allt keyt focust focusint focusoutt none( R Rj ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_validateo s c C s0 | j � } | j | d � | j | d � d S( NR� t vcmd( R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_validatecommandt s ( R1 R2 R3 R� R R� RW RX R5 R6 R7 R� R� R� R� R� R� R� R� R; R� R� R� R� R� R= R� R� R� R? R� (
R R. RS R R� R� R� R� R� R� R� R� R� ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� 4 s(
t SpinboxTestc , B s� e Z d9 Z d, � Z d: Z d- � Z d. � Z d/ � Z d0 � Z d1 � Z
d2 � Z d3 � Z d4 � Z
d5 � Z d6 � Z d7 � Z d8 � Z RS(; Rz R1 R2 t buttonbackgroundt buttoncursort buttondownrelieft buttonupreliefR� R3 R� R R� RW RX t formatt fromR5 R6 R7 t incrementR� R� R� R� R� R� R� R; R� R� R� R� R� R� R� R= R� t toR� R� R� R? t wrapR� c K s t j | j | � S( N( R@ t SpinboxRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � s c C s | j � } | j | d � d S( NR� ( R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_buttonbackground� s c C s | j � } | j | d � d S( NR� ( R t checkCursorParam( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_buttoncursor� s c C s | j � } | j | d � d S( NR� ( R t checkReliefParam( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_buttondownrelief� s c C s | j � } | j | d � d S( NR� ( R R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_buttonuprelief� s c C s� | j � } | j | d d � | j | d d � | j | d d � | j | d d � | j | d d � | j | d d � | j | d d � | j | d d � | j | d d
� | j | d d � | j | d d � | j | d d
� d S( NR� s %2fs %2.2fs %.2fs %2.fs %2e-1fs 2.2s %2.-2fs %-2.02fs % 2.02fs % -2.200fs %09.200fs %d( R RF R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_format� s c C sU | j � } | j | d d � | j | d d d d � | j | d d d d �d S(
NR� g Y@R� i����gffffff$@gffffff'@i� R s* -to value must be greater than -from value( R RF t checkFloatParamR ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_from� s
c C s/ | j � } | j | d d d d d d � d S( NR� i����i gffffff$@g������)@i ( R R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_increment� s c C sU | j � } | j | d d � | j | d d d d � | j | d d d d �d S(
NR� g Y�R� i����gffffff$@gffffff'@i8���R s* -to value must be greater than -from value( R RF R R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_to� s
c C s| | j � } | j | d d � | j | d d � | j | d d
d d �| j | d d d d �| j | d d � d S( NR� R" s mon tue wed thurt mont tuet wedt thurRo i* g ��Q� @s
any strings 42 3.14 {} {any string}( R R R
R ( i* g ��Q� @R" s
any string( R R RF ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_values� s c C s | j � } | j | d � d S( NR� ( R t checkBooleanParam( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_wrap� s c C s� | j � } | j | j d � � | j t j | j d � | j t j | j d � | j t | j � | j t | j d d � d S( Ni t noindexi ( R t assertIsBoundingBoxt bboxR� R@ R R� t TypeError( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_bbox� s c C sl | j � } | j | j � d � | j d � | j | j � d � | j d � | j | j � d � d S( NR� t buttonupt
buttondown( R R t selection_element( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_selection_element� s
(, Rz R1 R2 R� R� R� R� R� R3 R� R R� RW RX R� R� R5 R6 R7 R� R� R� R� R� R� R� R� R; R� R� R� R� R� R� R� R= R� R� R� R� R� R? R� R� N( R R. RS R R� R� R� R� R R R R R R R R R R ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� z s8 t TextTestc ) B s1 e Z d@ Z e dA k r! e Z n d+ � Z d, � Z e d) d* � d- � � Z e d) d* � d. � � Z
d/ � Z d0 � Z e d) d* � d1 � � Z
e d) d2 � d3 � � Z d4 � Z d5 � Z d6 � Z d7 � Z e d) d* � d8 � � Z d9 � Z d: � Z e d) d* � d; � � Z d< � Z d= � Z d> � Z d? � Z RS(B t autoseparatorsR1 t blockcursorR2 R3 t endlineR� RW RX R4 R5 R6 R7 t inactiveselectbackgroundR� R� R� R� t insertunfocussedR� t maxundoR9 R: R; R� R� R� t setgridt spacing1t spacing2t spacing3t startlineR� t tabst tabstyleR= t undoR? R� R� t yscrollcommandi i c K s t j | j | � S( N( R@ t TextRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � s c C s | j � } | j | d � d S( NR ( R R
( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_autoseparators� s c C s | j � } | j | d � d S( NR ( R R
( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_blockcursor� s c C s� | j � } d j d � t d � D� � } | j d | � | j | d d d d �| j | d d d d �| j | d d
d d �| j | d d
� | j | d d � | j | d d d d �d S( Ns
c s s | ] } d Vq d S( s Line %dN( ( t .0t i( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pys <genexpr> s id t endR i� Ro R" i����R� R s expected integer but got "spam"i2 R# i i
s1 -startline must be less than or equal to -endline( R t joint ranget insertRF R ( R R R[ ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_endline s c C s^ | j � } | j | d d d d d � | j | d d d d �| j | d d d d �d S(
NR4 id g�����LY@gfffff�Y@t 3ci����Ro i i ( R Rv RF ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� s c C s) | j � } | j | d d d d � d S( NR i i i����( R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_maxundo s c C s | j � } | j | d � d S( NR ( R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_inactiveselectbackground s i c C s) | j � } | j | d d d d � d S( NR t hollowR� t solid( R Rj ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_insertunfocussed s c
C s> | j � } | j | d d d d d d t d t d
k �d S( NR� g�������?g������@i����Ru R� t keep_origi i ( i i ( R Rv R R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_selectborderwidth$ s c C sE | j � } | j | d d d d d � | j | d d d d �d S( NR i gffffff5@g������6@s 0.5ci����Ro i ( R Rv RF ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_spacing1* s c C sE | j � } | j | d d d d d � | j | d d d d �d S( NR! i g������@gffffff @s 0.1ci����Ro i ( R Rv RF ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_spacing2/ s c C sE | j � } | j | d d d d d � | j | d d d d �d S( NR" i gffffff5@g������6@s 0.5ci����Ro i ( R Rv RF ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_spacing34 s c C s� | j � } d j d � t d � D� � } | j d | � | j | d d d d �| j | d d d d �| j | d d
d d �| j | d d
� | j | d d � | j | d d d d �d S( Ns
c s s | ] } d Vq d S( s Line %dN( ( R+ R, ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pys <genexpr>< s id R- R# i� Ro R" i����R� R s expected integer but got "spam"i
R i2 iF s1 -startline must be less than or equal to -endline( R R. R/ R0 RF R ( R R R[ ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_startline9 s c C sK | j � } t d k r1 | j | d d d � n | j | d d d � d S( Ni i R� R� R� ( i i ( R R R� Rj ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� G s c
C s� | j � } t � d k r7 | j | d d d d �n | j | d d � | j | d d d d �| j | d d
d d �| j | d d d d d t d k �d S( Ni i i R$ gffffff$@g33333�4@t 1it 2iRo s 10.2s 20.7s 10.2 20.7 1i 2is 2c left 4c 6c centert 2cR� t 4ct 6cRi R� R s bad screen distance "spam"R8 ( i i i ( gffffff$@g33333�4@R> R? ( s 10.2s 20.7R> R? ( gffffff$@g33333�4@R> R? ( s 10.2s 20.7R> R? ( R@ R� RA RB Ri ( i i ( R R RF R R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_tabsN s
c C s& | j � } | j | d d d � d S( NR% t tabulart
wordprocessor( R Rj ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_tabstyle] s c C s | j � } | j | d � d S( NR& ( R R
( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_undob s c C sU | j � } | j | d d � | j | d d d d �| j | d d d d �d S( NR? i� in���Ro i i ( R R� RF ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� f s c C sQ | j � } t d k r4 | j | d d d d � n | j | d d d d � d S( Ni i R� t charR� t word( i i ( R R R� Rj ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR l s c C s� | j � } | j | j d � � | j | j d � � | j t j | j d � | j t j | j d � | j t j | j � | j t j | j d d � d S( Ns 1.1R- R ( R R R t assertIsNoneR� R@ R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR s s () R R1 R R2 R3 R R� RW RX R4 R5 R6 R7 R R� R� R� R� R R� R R9 R: R; R� R� R� R R R! R" R# R� R$ R% R= R& R? R� R� R' ( i i ( R R. RS R R) t
_stringifyR R) R R* R1 R� R3 R4 R7 R9 R: R; R< R= R� RC RF RG R� R R ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � sB t
CanvasTestc B sh e Z d# Z e e � Z e Z d � Z d � Z d � Z
d � Z d � Z d � Z
d! � Z d" � Z RS($ R1 R2 t closeenought confineR3 R4 R5 R6 R7 R� R� R� R� R� t offsetR; t scrollregionR� R� R� R� R= R� t xscrollincrementR' t yscrollincrementR? c K s t j | j | � S( N( R@ t CanvasRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � s c C s2 | j � } | j | d d d d d d t �d S( NRM i g333333@g������ @i����R� ( R R t float( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_closeenough� s c C s | j � } | j | d � d S( NRN ( R R
( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_confine� s c C s� | j � } | j | d d � | j | d d d d d d d d d
d � | j | d d � | j | d d
� | j | d d � d S( NRO s 0,0R` Ra R] Rd Rc Re Rf Rb Ri s 10,20s #5,6R� ( R R R� RF R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_offset� s c C s� | j � } | j | d d � | j | d d d d �| j | d d � | j | d d d d
�| j | d d � | j | d d
� | j | d d � d S( NRP s 0 0 200 150i i� i� Ro R" R� R s bad scrollRegion "spam"( i i i� i� ( i i i� R� ( i i i� ( i i i� i� i ( R RF R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_scrollregion� s c C s, | j � } | j | d d d d d �d S( NR� R� R� R s0 bad state value "{}": must be normal or disabled( R Rj ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� � s c C s2 | j � } | j | d d d d d d d � d S( NRQ i( i g������D@g������E@i���s 0.5i( R Rv ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_xscrollincrement� s c C s2 | j � } | j | d d d d d d d � d S( NRR i
i gffffff&@g333333+@i����s 0.1i( R Rv ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_yscrollincrement� s ( R1 R2 RM RN R3 R4 R5 R6 R7 R� R� R� R� R� RO R; RP R� R� R� R� R= R� RQ R' RR R? ( R R. RS R� R
Rx R) RK R RU RV RW RX R� RY RZ ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyRL } s( t ListboxTestc B s� e Z d, Z d � Z d � Z e d d d � e j j � Z d � Z d � Z
d � Z d! � Z d" � Z
d# � Z d$ � Z d% � Z d& � Z d' � Z d( � Z d) � Z d* � Z d+ � Z RS(- t activestyleR1 R2 R3 R R� RW RX R4 R5 R6 R7 R� t listvariableR; R� R� R� t
selectmodeR R� R= R? R� R' c K s t j | j | � S( N( R@ t ListboxRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � s c C s) | j � } | j | d d d d � d S( NR\ t dotboxR� R� ( R Rj ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_activestyle� s i i i c C s5 | j � } t j | j � } | j | d | � d S( NR] ( R R@ t DoubleVarRB t checkVariableParam( R R t var( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_listvariable� s c C s\ | j � } | j | d d � | j | d d � | j | d d � | j | d d � d S( NR^ t singlet browset multiplet extended( R RF ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_selectmode� s
c C s& | j � } | j | d d d � d S( NR� R� R� ( R Rj ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� � s c
C s� | j � } | j t d � � | j d � Wd QXd j � } | j d | � x- t | � D] \ } } | j | d | �q[ W| j t � � | j � Wd QX| j t d � � | j d � Wd QX| j | j d d � d � | j | j d d � d � | j | j d d � d � | j d � } | j
| t � x� | j � D]s \ } } | j
t | � d � t | � d
k rD| j | | j d | � � | j | d | j d | � � qDqDWd S( Ns item number "0" out of rangei s) red orange yellow green blue white violetR- R1 s bad listbox index "red"t redt
BackgroundR" t violets @0,0i i i ( R1 R1 Rl R" Rk ( R1 R1 Rl R" Rm ( R1 R1 Rl R" Rk ( i i ( R t assertRaisesRegexpR t
itemconfiguret splitR0 t enumerateR� R R t assertIsInstancet dictt itemst assertInt lent itemcget( R R t colorsR, t colort dt kt v( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_itemconfigure� s0 c C s� | j � } | j d d d d d � | j d i | | 6� | j | j d | � d | � | j | j d | � | � | j t d � � | j d i d | 6� Wd QXd S(
NR- R� R� R� Rz i i s unknown color name "spam"R� ( R R0 Ro R Rw Rn R ( R Rm R� R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt check_itemconfigure s c C s | j d d � d S( NR1 s #ff0000( R~ ( R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_itemconfigure_background s c C s | j d d � d S( Nt bgs #ff0000( R~ ( R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_itemconfigure_bg s c C s | j d d � d S( Nt fgs #110022( R~ ( R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_itemconfigure_fg s c C s | j d d � d S( NRX s #110022( R~ ( R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_itemconfigure_foreground s c C s | j d d � d S( NR� s #110022( R~ ( R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt# test_itemconfigure_selectbackground s c C s | j d d � d S( NR� s #654321( R~ ( R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt# test_itemconfigure_selectforeground s c C s� | j � } | j d d � t d � D� � | j � | j | j d � � | j | j d � � | j | j d � � | j t | j d � | j t | j d � | j t
| j � | j t
| j d d � d S( Ni c s s | ] } d | Vq d S( s el%dN( ( R+ R, ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pys <genexpr> s i i����i
R i ( R R0 R/ t packR R RJ R� R R� R ( R t lb( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_box s
c C s� | j � } | j d d � t d � D� � | j d t j � | j d d � | j d � | j | j � d � | j t
| j d � d S( Ni c s s | ] } d | Vq d S( s el%dN( ( R+ R, ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pys <genexpr>+ s i i i i i ( i i i i ( R R0 R/ t selection_clearR@ t ENDt
selection_setR t curselectionR� R ( R R� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_curselection) s
c C s� | j � } | j d d � t d � D� � | j | j d � d � | j | j d � d � | j | j d � d � | j | j d � d � | j | j d
� d � | j | j d d � d � | j | j d d � d � | j | j d d � d � | j | j d d � d � | j t | j d � | j t | j d � | j t | j � | j t | j d d � | j t | j d d d � | j t | j d � d S( Ni c s s | ] } d | Vq d S( s el%dN( ( R+ R, ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pys <genexpr>4 s i t el0i t el3R- t el7R" i����i t el4t el5t el6R i i g333333@( R� R� R� ( R� R� R� ( ( R� ( R R0 R/ R t getR� R R� R ( R R� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_get2 s" ( R\ R1 R2 R3 R R� RW RX R4 R5 R6 R7 R� R] R; R� R� R� R^ R R� R= R? R� R' ( R R. RS R Ra R R
t test_justifyR� Re Rj R� R} R~ R R� R� R� R� R� R� R� R� ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR[ � s2 t ScaleTestc B s� e Z d+ Z d Z d � Z d � Z d! � Z d" � Z d# � Z d$ � Z d% � Z
d& � Z d' � Z d( � Z
d) � Z d* � Z RS(, Rz R1 t bigincrementR2 R� R3 t digitsRW RX R� R5 R6 R7 Rr t lengtht orientR; R� R� t
resolutiont showvaluet sliderlengtht sliderreliefR� R= t tickintervalR� t troughcolorR� R? t verticalc K s t j | j | � S( N( R@ t ScaleRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR S s c C s) | j � } | j | d d d d � d S( NR� g������(@g������7@i����( R R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_bigincrementV s c C s& | j � } | j | d d d � d S( NR� i i ( R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_digitsZ s c C s/ | j � } | j | d d d d d t �d S( NR� id g������-@g333333.@R� ( R R t round( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR ^ s c C s6 | j � } | j | d d � | j | d d � d S( NRr s
any stringR" ( R RF ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_labelb s c C s, | j � } | j | d d d d d � d S( NR� i� gffffff`@g33333�`@t 5i( R Rv ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_lengthg s c C s, | j � } | j | d d d d d � d S( NR� g������@i g������@i����( R R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_resolutionk s c C s | j � } | j | d � d S( NR� ( R R
( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_showvalueo s c C s/ | j � } | j | d d d d d d � d S( NR� i
gffffff&@g333333/@i����t 3m( R Rv ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_sliderlengths s c C s | j � } | j | d � d S( NR� ( R R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_sliderreliefx s c C sQ | j � } | j | d d d d d d t �| j | d d d d d t �d S(
NR� i g333333@gffffff @i R� i����Ro i ( R R R� RF ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_tickinterval| s
c C s2 | j � } | j | d d d d d d t �d S( NR� i, g������-@g333333.@i����R� ( R R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � s ( Rz R1 R� R2 R� R3 R� RW RX R� R5 R6 R7 Rr R� R� R; R� R� R� R� R� R� R� R= R� R� R� R� R? ( R R. RS t default_orientR R� R� R R� R� R� R� R� R� R� R ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� F s( t
ScrollbarTestc B s\ e Z d Z e e � Z e Z d Z d � Z d � Z
d � Z d � Z d � Z
d � Z RS( Rz t activereliefR1 R2 R� R3 t elementborderwidthR5 R6 R7 t jumpR� R; R� R� R= R� R? R� c K s t j | j | � S( N( R@ t ScrollbarRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � s c C s | j � } | j | d � d S( NR� ( R R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_activerelief� s c C s, | j � } | j | d d d d d � d S( NR� g333333@gffffff@i����t 1m( R Rv ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_elementborderwidth� s c C s, | j � } | j | d d d d d �d S( NR� R� t
horizontalR s4 bad orientation "{}": must be vertical or horizontal( R Rj ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_orient� s c C sg | j � } x d D] } | j | � q W| j d � | j t | j � | j t | j d d � d S( Nt arrow1t slidert arrow2R" ( R� R� R� ( R t activateR� R ( R t sbR] ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_activate� s
c C s� | j � } | j d d � | j | j � d � | j t | j d d � | j t | j d d � | j t | j d d � | j t | j d � | j t | j d d d � d S( Ng�������?g�������?t abct defg333333�?gffffff�?g�������?( g�������?g�������?( R t setR R� R� R R� ( R R� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_set� s ( Rz R� R1 R2 R� R3 R� R5 R6 R7 R� R� R; R� R� R= R� R? ( R R. RS R� R
Rx R) RK R� R R� R� R� R� R� ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� � s t PanedWindowTestc B sg e Z d2 Z d Z d � Z d � Z d � Z d � Z d � Z e d d d � d � � Z
e d d d � d � � Z e d d d � d � � Z d � Z
d � Z d � Z d! � Z d" � Z d# � Z d$ � Z d% � Z e d& � Z d' � Z d( � Z d) � Z d* � Z e d d � d+ � � Z d, � Z d- � Z d. � Z d/ � Z e d d � d0 � � Z d1 � Z! RS(3 R1 R2 R3 t handlepadt
handlesizeR4 t opaqueresizeR� t proxybackgroundt proxyborderwidtht proxyreliefR; t
sashcursort sashpadt
sashrelieft sashwidtht
showhandleR? R� c K s t j | j | � S( N( R@ t PanedWindowRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � s c C s/ | j � } | j | d d d d d d � d S( NR� i g������@gffffff @i����R� ( R Rv ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_handlepad� s c
C s5 | j � } | j | d d d d d d d t �d S( NR� i g������"@g333333%@i����t 2mR� ( R Rv R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_handlesize� s c C s8 | j � } | j | d d d d d d d d t �d S( NR4 id g�����LY@gfffff�Y@i����i R> R� ( R Rv R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� � s !c C s | j � } | j | d � d S( NR� ( R R
( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_opaqueresize� s i i i c C s | j � } | j | d � d S( NR� ( R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_proxybackground� s c C s8 | j � } | j | d d d d d d d d t �d S( NR� i g�������?g333333@i i����Ru R� ( R Rv R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_proxyborderwidth� s c C s | j � } | j | d � d S( NR� ( R R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_proxyrelief� s c C s | j � } | j | d � d S( NR� ( R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_sashcursor� s c C s/ | j � } | j | d d d d d d � d S( NR� i g�������?g������@i����R� ( R Rv ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_sashpad� s c C s | j � } | j | d � d S( NR� ( R R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_sashrelief� s c
C s5 | j � } | j | d d d d d d d t �d S( NR� i
g333333&@g333333/@i����R� R� ( R Rv R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_sashwidth� s c C s | j � } | j | d � d S( NR� ( R R
( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_showhandle� s c C s8 | j � } | j | d d d d d d d d t �d S( NR? i� gfffff6y@g�����Iy@in���i R� R� ( R Rv R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� s !c C sQ | j � } t j | � } t j | � } | j | � | j | � | | | f S( N( R R@ R� t add( R t pR� R� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt create2 s
c C s� | j � \ } } } | j t | j � | j | � } | j | t � xl | j � D]^ \ } } | j t | � d � | j | | j | | � � | j | d | j | | � � qT Wd S( Ni i (
R� R� R t
paneconfigureRr Rs Rt R Rv t panecget( R R� R� R� Rz R{ R| ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_paneconfigure s c C s� d � } | j s | r( t | � } n | j r@ | r@ t } n | j | i | | 6� | j | | j | | � d � | � | j | | j | | � � | � d S( Nc S s | S( N( ( t x( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt <lambda> R" i ( R( R� R� R R� ( R R� R� Rm R� Ro t stringifyR� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt check_paneconfigure s &c C s4 | j t | � � | j | i d | 6� Wd QXd S( Nt badValue( Rn R R� ( R R� R� Rm t msg( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt check_paneconfigure_bad$ s c C sN | j � \ } } } | j | | d | t | � � | j | | d d � d S( Nt afters bad window path name "badValue"( R� R� R� R� ( R R� R� R� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_paneconfigure_after( s c C sN | j � \ } } } | j | | d | t | � � | j | | d d � d S( Nt befores bad window path name "badValue"( R� R� R� R� ( R R� R� R� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_paneconfigure_before. s c C sW | j � \ } } } | j | | d d d d t � d k �| j | | d d � d S( NR4 i
R� i i i s bad screen distance "badValue"( i i i ( R� R� R R� ( R R� R� R� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_paneconfigure_height4 s
c C sH | j � \ } } } | j | | d t d � | j | | d d � d S( Nt hidei s) expected boolean value but got "badValue"( R� R� t FalseR� ( R R� R� R� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_paneconfigure_hide; s c C sH | j � \ } } } | j | | d d d � | j | | d d � d S( Nt minsizei
s bad screen distance "badValue"( R� R� R� ( R R� R� R� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_paneconfigure_minsizeB s c C sH | j � \ } } } | j | | d d d � | j | | d d � d S( NR9 g�������?i s bad screen distance "badValue"( R� R� R� ( R R� R� R� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_paneconfigure_padxH s c C sH | j � \ } } } | j | | d d d � | j | | d d � d S( NR: g�������?i s bad screen distance "badValue"( R� R� R� ( R R� R� R� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_paneconfigure_padyN s c C sH | j � \ } } } | j | | d d d � | j | | d d � d S( Nt stickyt nsewt nesws[ bad stickyness value "badValue": must be a string containing zero or more of n, e, s, and w( R� R� R� ( R R� R� R� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_paneconfigure_stickyT s c C sH | j � \ } } } | j | | d d d � | j | | d d � d S( Nt stretcht alwt alwayssE bad stretch "badValue": must be always, first, last, middle, or never( R� R� R� ( R R� R� R� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_paneconfigure_stretch\ s c C sW | j � \ } } } | j | | d d d d t � d k �| j | | d d � d S( NR? i
R� i i i s bad screen distance "badValue"( i i i ( R� R� R R� ( R R� R� R� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_paneconfigure_widthd s
( R1 R2 R3 R� R� R4 R� R� R� R� R� R; R� R� R� R� R� R? (" R R. RS R� R R� R� R� R� R R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� � sH
t MenuTestc B se e Z d Z e Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d � Z d � Z
RS( Rz t activeborderwidthR{ R1 R2 R3 R RW RX t postcommandR; R� R= t tearofft tearoffcommandR t typec K s t j | j | � S( N( R@ RE RB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR w s c C s | j � } | j | d � d S( NR ( R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_postcommandz s c C s | j � } | j | d � d S( NR ( R R
( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_tearoff~ s c C s | j � } | j | d � d S( NR ( R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_tearoffcommand� s c C s# | j � } | j | d d � d S( NR s
any string( R RF ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_title� s c C s) | j � } | j | d d d d � d S( NR R� R t menubar( R Rj ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_type� s c C s | j � } | j d d � | j t | j � | j t d � � | j d � Wd QX| j d � } | j | t � x� | j � D]v \ } } | j | t
� | j | t � | j t
| � d � | j | d | � | j | j d | � | d � q� W| j � d S( NRr t tests bad menu entry index "foo"Rn i i i i ( R t add_commandR� R t entryconfigureRn R Rr Rs Rt R� t tupleR Rv t entrycgetRq ( R t m1Rz R{ R| ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_entryconfigure� s $c C sk | j � } | j d d � | j | j d d � d � | j d d d �| j | j d d � d � d S( NRr R
i t changed( R R R R R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_entryconfigure_label� s
c C s� | j � } t j | j � } t j | j � } | j d | d t d t d d � | j t | j d d � � t | � � | j
d d | �| j t | j d d � � t | � � d S( NR� R� R� Rr t Nonsensei ( R R@ t
BooleanVarRB t add_checkbuttonR) R� R R� R R ( R R t v1t v2( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_entryconfigure_variable� s (( Rz R R{ R1 R2 R3 R RW RX R R; R� R= R R R R ( R R. RS R Rx R R R R R
R R R R ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR l s t MessageTestc B s& e Z d Z e Z d � Z d � Z RS( R| t aspectR1 R2 R3 RW RX R5 R6 R7 R� R9 R: R; R= R[ R� R? c K s t j | j | � S( N( R@ t MessageRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � s c C s) | j � } | j | d d d d � d S( NR i� i i���( R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_aspect� s ( R| R R1 R2 R3 RW RX R5 R6 R7 R� R9 R: R; R= R[ R� R? ( R R. RS R R/ R R ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � s t __main__(1 R� t TkinterR@ R RI R� t test.test_supportR R t test_ttk.supportR R R R t widget_testsR R R R
R R R
R R R R t TestCaseR0 RT RV Rt Ry R� R� R� R� R� R� R� R RL R[ R� R� R� R R t tests_guiR ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt <module> sl "F
% ( A E h � B � B 1 � D test/test_tkinter/test_loadtk.pyc 0000644 00000003314 15032720555 0013301 0 ustar 00 �
z fc @ s� d d l Z d d l Z d d l Z d d l m Z d d l m Z m Z e j d � d e j f d � � YZ
e
f Z e d k r� e j
e � n d S( i����N( t test_support( t Tclt TclErrort guit
TkLoadTestc B s5 e Z e j d e j k d � d � � Z d � Z RS( t DISPLAYs No $DISPLAY set.c C sJ t � } | j t | j � | j � | j d | j � � | j � d S( Ns 1x1+0+0( R t assertRaisesR t winfo_geometryt loadtkt assertEqualt destroy( t selft tcl( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_loadtk.pyt
testLoadTk s
c C s� d } t j j d � r d St j � �t } d t j k ri | d =t j d � j � j
� } | ri d Sn t � } | j t
| j � | j t
| j � Wd QXd S( Nt wint darwint cygwinR s
echo $DISPLAY( R R R ( t Nonet syst platformt
startswithR t EnvironmentVarGuardt ost environt popent readt stripR R R R R ( R t old_displayt envt displayR ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_loadtk.pyt testLoadTkFailure s ( t __name__t
__module__t unittestt skipIfR R R
R ( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_loadtk.pyR s $t __main__( R R R! t testR t TkinterR R t requirest TestCaseR t tests_guiR t run_unittest( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_loadtk.pyt <module> s
! test/test_tkinter/test_geometry_managers.pyo 0000644 00000120324 15032720555 0015550 0 ustar 00 �
z fc @ s d d l Z d d l Z d d l Z d d l m Z d d l m Z m Z d d l m Z m
Z
m Z d d l m
Z
m Z e d � d e
e j f d � � YZ d e
e j f d
� � YZ d e
e j f d � � YZ e e e f Z e d
k re e � n d S( i����N( t TclError( t requirest run_unittest( t pixels_convt tcl_versiont requires_tcl( t AbstractWidgetTestt int_roundt guit PackTestc B s� e Z d
Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d � Z d � Z
d
� Z d � Z d � Z RS( c
C s� t j | j d d �} | j d � | j d d � t j | d d d d d d d
d �} t j | d d d d
d d d
d �} t j | d d d d d d d
d �} t j | d d d d d d d
d �} | | | | | f S( Nt namet packs 300x200+0+0i t at widthi t heighti( t bgt redt bi2 i t bluet ciP t greent dt yellow( t tkintert Toplevelt roott wm_geometryt
wm_minsizet Frame( t selfR R R R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt create2 s
''''c C s; | j � \ } } } } } | j t d | � � | j d | � Wd QX| j t d � � | j d d � Wd QX| j d d � | j d d � | j d d � | j d d � | j | j � | | | | g � | j d | � | j | j � | | | | g � | j d | � | j | j � | | | | g � d S( Ns window "%s" isn't packedt afters bad window path name ".foo"s .foot sidet top( R t assertRaisesRegexpR t pack_configuret assertEqualt pack_slaves( R R R R R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_pack_configure_after s ""c s� � j � \ } � } } } � � f d � } | d d � | d d � | d d � | d d � | d
d � | d d
� | d d � | d d � | d d � d S( Nc s[ � j d d d d d d d d d d
d t d | � � j j � � j � j � | � d S(
NR R! t ipadxi t padxi
t ipadyi t padyi t expandt anchor( R# t TrueR t updateR$ t winfo_geometry( R, t geom( R R ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt check- s '
t ns 30x70+135+20t nes 30x70+260+20t es 30x70+260+65t ses
30x70+260+110t ss
30x70+135+110t sws 30x70+10+110t ws 30x70+10+65t nws 30x70+10+20t centers 30x70+135+65( R ( R R R R R R1 ( ( R R sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_pack_configure_anchor+ s
c C s; | j � \ } } } } } | j t d | � � | j d | � Wd QX| j t d � � | j d d � Wd QX| j d d � | j d d � | j d d � | j d d � | j | j � | | | | g � | j d | � | j | j � | | | | g � | j d | � | j | j � | | | | g � d S( Ns window "%s" isn't packedt befores bad window path name ".foo"s .fooR R! ( R R" R R# R$ R% ( R R R R R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_pack_configure_before< s ""c s{ � j � \ } � � � � � � � � � f d � } � j d d � � j d d � � j d d � � j d d � | d d d d
� � j d d d d � � j d d d d
� � j d d d t � � j d d d d � | d d d d � � j d d d d d d � � j d d d d
d d � � j d d d t d d � � j d d d d d d � | d d d d � d S( Nc sy � j j � � j � j � | d � � j � j � | d � � j � j � | d � � j � j � | d � d S( Ni i i i ( R R. R$ R/ ( t geoms( R R R R R ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyR1 N s
R t leftR! t rightt bottoms
20x40+0+80s 50x30+135+0s 80x80+220+75s
40x30+100+170R+ t yest oni s 20x40+40+80s 50x30+175+35s
80x80+180+110s
40x30+100+135t fillt boths 100x200+0+0s
200x100+100+0s 160x100+140+100s 40x100+100+100( R R# R- ( R R R1 ( ( R R R R R sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_pack_configure_expandL s" c C s2 | j � \ } } } } } | j d d � | j d d � | j d d � | j d d � | j d | � | j | j � | | | | g � | j d | � | j | j � | | | g � | j | j � | g � | j t d | f � � | j d | � Wd QX| j t d � � | j d d � Wd QXd S( NR R! t in_s can't pack %s inside itselfs bad window path name ".foo"s .foo( R R# R$ R% R" R ( R R R R R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_pack_configure_ind s " c s� � j � \ } � � } } � � � f d � } | d d d d d d �| d d d d d d' �| d d d d d d �| d
d d d d d d d �| d d d d d d d d �| d d d d d d( d d �| d d d d d d d d �| d
d d d d d d d d d �| d d d d d d d d) d d �| d d d d d d �| d d d d d d* �| d d d d d d �| d d d d d d d d �| d d d d d d d d+ �| d d d d d d d d �| d! d d d d d, d d �| d# d d d d d d d �| d$ d d d d d d d d d �| d% d d d d d d d- d d �� j d d& � � j � j � d � j | j d& � � � � j d d& � � j � j � d � j | j d& � � � d S(. Nc st � j � � j � � j | � � j d t d d � � j j � � j � j � | � � j � j � | � d S( NR+ RD RE ( t pack_forgetR# R- R R. R$ R/ ( t geom1t geom2t kwargs( R R R ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyR1 w s
s 20x40+260+80s 240x200+0+0R R@ R( i s 20x40+250+80i
i s 60x40+240+80R' s 30x40+260+80s 250x200+0+0i RD t xs 20x40+249+80i i s 30x40+255+80i s 20x40+140+0s 300x160+0+40R! s 20x40+120+0i i( s 60x40+120+0s 30x40+135+0s 30x40+130+0s 260x40+20+0s 260x40+25+0i s
300x40+0+0s 280x40+10+0s
280x40+5+0t 1c( i
i ( i i ( i i ( i i( ( i i ( i i ( i i ( R R# R$ t pack_infot _strt winfo_pixels( R R R R R1 ( ( R R R sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt# test_pack_configure_padx_ipadx_fillu sB c s� � j � \ } � � } } � � � f d � } | d d d d d d �| d d d d d d' �| d d d d d d �| d
d d d d d d d �| d d d d d d d d �| d d d d d d( d d �| d d d d d d d d �| d
d d d d d d d d d �| d d d d d d d d) d d �| d d d d d d �| d d d d d d* �| d d d d d d �| d d d d d d d d �| d d d d d d d d+ �| d d d d d d d d �| d! d d d d d, d d �| d# d d d d d d d �| d$ d d d d d d d d d �| d% d d d d d d d- d d �� j d d& � � j � j � d � j | j d& � � � � j d d& � � j � j � d � j | j d& � � � d S(. Nc st � j � � j � � j | � � j d t d d � � j j � � j � j � | � � j � j � | � d S( NR+ RD RE ( RI R# R- R R. R$ R/ ( RJ RK RL ( R R R ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyR1 � s
s 20x40+280+80s 280x200+0+0R R@ R* i s 20x40+280+70i
i s 20x80+280+60R) s 20x50+280+75i RD RM s 20x40+280+69i i s 20x50+280+70i s 20x40+140+20s 300x120+0+80R! s 20x40+140+0i i( s 20x80+140+0s 20x50+140+10s 300x130+0+70s 20x50+140+5s 300x40+0+20s 300x40+0+25i s
300x80+0+0s 300x50+0+10s
300x50+0+5RN ( i
i ( i i ( i i ( i i( ( i i ( i i ( i i ( R R# R$ RO RP RQ ( R R R R R1 ( ( R R R sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt# test_pack_configure_pady_ipady_fill� sB c st � j � \ } � � } } � � � f d � } | d d d � | d d d � | d d d
� | d d d
� d S( Nc s} � j d | � � j � j � d | � � j d t d d � � j j � � j � j � | � � j � j � | � d S( NR R+ RD RE ( R# R$ RO R- R R. R/ ( R RJ RK ( R R R ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyR1 � s
R! s 20x40+140+0s 300x160+0+40RA s
20x40+140+160s 300x160+0+0R? s
20x40+0+80s 280x200+20+0R@ s 20x40+280+80s 280x200+0+0( R ( R R R R R1 ( ( R R R sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_pack_configure_side� s c C s� | j � \ } } } } } | j � | j � | j � | j | j � | | | g � | j � | j | j � | | g � | j � | j | j � | | g � | j � d S( N( R R# R$ R% RI ( R R R R R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_pack_forget� s
c C s� | j � \ } } } } } | j t d | � � | j � Wd QX| j � | j d d d | d d d t d d d
d d d
d d d d � | j � } | j | t � | j | d d � | j | d | j d � � | j | d d � | j | d | � | j | d
| j d � � | j | d | j d � � | j | d | j d � � | j | d | j d � � | j | d d � | j � } | j | t � | j | d d � | j | d | j d � � | j | d d � | j | d | � | j | d
| j d � � | j | d | j d � � | j | d | j d
� � | j | d | j d � � | j | d d � d S( Ns window "%s" isn't packedR R@ RG R, R6 R+ RD RM R' i R( i
R) i R* i R: i t nonet inR! i ( i i ( i i (
R R" R RO R# R- t assertIsInstancet dictR$ RP ( R R R R R R t info( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_pack_info� s8
' c C s� | j � \ } } } } } | j d d d d � | j � | j t � | j j � | j | j � d � | j | j � d � | j t
� | j j � | j | j � d � | j | j � d � d S( NR
i, R i� i i( ( R t configureR# t pack_propagatet FalseR R. R$ t winfo_reqwidtht winfo_reqheightR- ( R R R R R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_pack_propagate s
c C s~ | j � \ } } } } } | j | j � g � | j � | j | j � | g � | j � | j | j � | | g � d S( N( R R$ R% R# ( R R R R R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_pack_slaves s
N( t __name__t
__module__t Nonet test_keysR R& R; R= RF RH RR RS RT RU R[ Ra Rb ( ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyR
s
* *
t PlaceTestc B s� e Z d Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d � Z d � Z
d
� Z d � Z d � Z d
� Z d � Z RS( c
C s� t j | j d d d d d d �} | j d � t j | d d d d d d
d d �} | j d
d d d � t j | d d d d d d
d d �} | j j � | | | f S( NR
i, R i� t bdi s 300x200+0+0i� iT i t relieft raisedRM i0 t yi& i i< ( R R R R R t place_configureR. ( R t tt ft f2( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyR s $
''
c C s� | j � \ } } } | j | j � d � | j t d t j t | � � � � | j d | � Wd QXt d k r� | j | j � d � n | j t d � � | j d d � Wd QX| j d | � | j | j � d � d S(
Nt s! can't place %s relative to itselfRG i i s bad window path namet spamt place( i i (
R R$ t
winfo_managerR" R t ret escapet strRl R ( R Rm Rn Ro ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_place_configure_in$ s c C s5 | j � \ } } } | j d | � | j | j � d d � | j j � | j | j � d � | j d d � | j | j � d d � | j j � | j | j � d � | j d d d d
� | j | j � d d � | j j � | j | j � d � | j t d
� � | j d | d d � Wd QXd S( NRG RM t 0i2 id t 100i� i����t relxi s -10i� s bad screen distance "spam"Rq ( R Rl R$ t
place_infoR R. t winfo_xR" R ( R Rm Rn Ro ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_place_configure_x1 s
c C s5 | j � \ } } } | j d | � | j | j � d d � | j j � | j | j � d � | j d d � | j | j � d d � | j j � | j | j � d � | j d d d d
� | j | j � d d � | j j � | j | j � d � | j t d
� � | j d | d d � Wd QXd S( NRG Rk Rx i( i2 t 50iZ i����t relyi s -10in s bad screen distance "spam"Rq ( R Rl R$ R{ R R. t winfo_yR" R ( R Rm Rn Ro ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_place_configure_yB s
c C s/ | j � \ } } } | j d | � | j | j � d d � | j j � | j | j � d � | j d d � | j | j � d d � | j j � | j | j � d � | j d d � | j | j � d d � | j j � | j | j � d
� | j t d � � | j d | d d � Wd QXd S(
NRG Rz Rx i2 g �?s 0.5i} i t 1i� s- expected floating-point number but got "spam"Rq ( R Rl R$ R{ R R. R| R" R ( R Rm Rn Ro ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_place_configure_relxS s
c C s/ | j � \ } } } | j d | � | j | j � d d � | j j � | j | j � d � | j d d � | j | j � d d � | j j � | j | j � d � | j d d � | j | j � d d � | j j � | j | j � d
� | j t d � � | j d | d d � Wd QXd S(
NRG R Rx i( g �?s 0.5iP i R� ix s- expected floating-point number but got "spam"Rq ( R Rl R$ R{ R R. R� R" R ( R Rm Rn Ro ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_place_configure_relye s
c C s� t j | j � } | j t d � � | j d d � Wd QX| j t d � � | j d d � Wd QXx8 d D]0 } | j d | � | j | j � d | � qk Wd S( Ns bad anchor "j"R, t js ambiguous anchor ""Rp R2 R3 R4 R5 R6 R7 R8 R9 R: ( R2 R3 R4 R5 R6 R7 R8 R9 R: ( R R R R" R Rl R$ R{ ( R Rn t value( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_place_configure_anchorw s
c C s� | j � \ } } } | j d | d d � | j j � | j | j � d � | j d d � | j j � | j | j � d � | j t d � � | j d d � Wd QXd S( NRG R
ix Rp i s bad screen distance "abcd"t abcd( R Rl R R. R$ t winfo_widthR" R ( R Rm Rn Ro ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_place_configure_width� s
c C s� | j � \ } } } | j d | d d � | j j � | j | j � d � | j d d � | j j � | j | j � d � | j t d � � | j d d � Wd QXd S( NRG R ix Rp i< s bad screen distance "abcd"R� ( R Rl R R. R$ t winfo_heightR" R ( R Rm Rn Ro ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_place_configure_height� s
c C s� | j � \ } } } | j d | d d � | j j � | j | j � d � | j d d � | j j � | j | j � d � | j t d � � | j d d � Wd QXd S( NRG t relwidthg �?iK Rp i s- expected floating-point number but got "abcd"R� ( R Rl R R. R$ R� R" R ( R Rm Rn Ro ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_place_configure_relwidth� s
c C s� | j � \ } } } | j d | d d � | j j � | j | j � d � | j d d � | j j � | j | j � d � | j t d � � | j d d � Wd QXd S( NRG t relheightg �?i( Rp i< s- expected floating-point number but got "abcd"R� ( R Rl R R. R$ R� R" R ( R Rm Rn Ro ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_place_configure_relheight� s
c C s� t j | j � } | j t d � � | j d d � Wd QX| j t d � � | j d d � Wd QXx8 d D]0 } | j d | � | j | j � d | � qk Wd S(
Ns bad bordermode "j"t
bordermodeR� s ambiguous bordermode ""Rp t insidet outsidet ignore( R� R� R� ( R R R R" R Rl R$ R{ ( R Rn R� ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_place_configure_bordermode� s
c C s� t j | j � } | j d d d d � | j j � | j � | j j � | j | j � � | j t � � | j d � Wd QXd S( NR
i2 R i (
R R R Rl R. t place_forgett assertFalset winfo_ismappedt assertRaisest TypeError( R t foo( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_place_forget� s
c C s� | j � \ } } } | j d | d d d d d d d d d
d d d
d d d d d d d d � | j � } | j | t � | j | d d � | j | d d � | j | d d � | j | d d � | j | d
d � | j | d d � | j | d d � | j | d d � | j | d d � | j | d d � | j | d d � | j | d d � | j t � � | j d � Wd QXd S( NRG RM i Rk i R
i R i Rz g�������?R g�������?R� g333333�?R� g�������?R, R5 R� R� R� t 2t 3t 4s 0.1s 0.2s 0.3s 0.4i ( R Rl R{ RX RY R$ R� R� ( R Rm Rn Ro RZ ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_place_info� s( '
c C s� t j | j � } t j | j � } | j | j � g � | j d | � | j | j � | g � | j t � � | j d � Wd QXd S( NRG i ( R R R R$ t place_slavesRl R� R� ( R R� t bar( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_place_slaves� s N( Rc Rd Re Rf R Rw R} R� R� R� R� R� R� R� R� R� R� R� R� ( ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyRg s
t GridTestc B s e Z d Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d � Z d � Z
d
� Z d � Z d � Z d
� Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z! RS( c C s� | j j � \ } } x@ t | d � D]. } | j j | d d d d d d d d �q& Wx@ t | d � D]. } | j j | d d d d d d d d �qi W| j j d � t t | � j � d S( Ni t weighti t minsizet padt uniformRp ( R t grid_sizet ranget grid_columnconfiguret grid_rowconfiguret grid_propagatet superR� t tearDown( R t colst rowst i( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyR� � s ,,c C s� t j | j � } | j | j � i � | j � | j | j � d | j � | j | j � d | j d � � | j | j � d | j d � � | j i d d 6d d �| j | j � d | j d � � | j | j � d | j d � � d S( NRW t columni t rowi i ( R t ButtonR R$ t grid_infot grid_configureRP ( R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_configure� s
###c C sr t j | j � } | j t d � � | j d d � Wd QX| j d d � | j | j � d | j d � � d S( Ns5 bad column value "-1": must be a non-negative integerR� i����i ( R R� R R" R R� R$ R� RP ( R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_configure_column� s
c C sr t j | j � } | j t d � � | j d d � Wd QX| j d d � | j | j � d | j d � � d S( Ns4 bad columnspan value "0": must be a positive integert
columnspani i ( R R� R R" R R� R$ R� RP ( R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_configure_columnspan s
c C s� t j | j � } t j | j � } | j | j � i � | j � | j | j � d | j � | j d | � | j | j � d | � | j i | j d 6� | j | j � d | j � d S( NRW RG ( R R R R� R$ R� R� ( R Rn R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_configure_in s
c C s� t j | j � } | j t d � � | j d d � Wd QX| j d d � | j | j � d | j d � � | j d d � | j | j � d | j t t
d � | j � � � d S( Ns6 bad ipadx value "-1": must be positive screen distanceR' i����i s .5c( R R� R R" R R� R$ R� RP R R t scaling( R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_configure_ipadx s #c C s� t j | j � } | j t d � � | j d d � Wd QX| j d d � | j | j � d | j d � � | j d d � | j | j � d | j t t
d � | j � � � d S( Ns6 bad ipady value "-1": must be positive screen distanceR) i����i s .5c( R R� R R" R R� R$ R� RP R R R� ( R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_configure_ipady! s #c C s� t j | j � } | j t d � � | j d d � Wd QX| j d d � | j | j � d | j d � � | j d d � | j | j � d | j d � � | j d d � | j | j � d | j t t
d � | j � � � d S(
Ns4 bad pad value "-1": must be positive screen distanceR( i����i i
i s .5c( i
i ( i
i ( R R� R R" R R� R$ R� RP R R R� ( R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_configure_padx, s ##c C s� t j | j � } | j t d � � | j d d � Wd QX| j d d � | j | j � d | j d � � | j d d � | j | j � d | j d � � | j d d � | j | j � d | j t t
d � | j � � � d S(
Ns4 bad pad value "-1": must be positive screen distanceR* i����i i
i s .5c( i
i ( i
i ( R R� R R" R R� R$ R� RP R R R� ( R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_configure_pady9 s ##c C sr t j | j � } | j t d � � | j d d � Wd QX| j d d � | j | j � d | j d � � d S( Ns9 bad (row|grid) value "-1": must be a non-negative integerR� i����i ( R R� R R" R R� R$ R� RP ( R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_configure_rowF s
c C sr t j | j � } | j t d � � | j d d � Wd QX| j d d � | j | j � d | j d � � d S( Ns1 bad rowspan value "0": must be a positive integert rowspani i ( R R� R R" R R� R$ R� RP ( R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_configure_rownspanN s
c C s� t j | j d d �} | j t d � � | j d d � Wd QX| j d d � | j | j � d d � | j d d � | j | j � d d � d S( NR R s bad stickyness value "glue"t stickyt glueR3 s n,s,e,wt nesw( R R R R" R R� R$ R� ( R Rn ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_configure_stickyV s c C s� | j t � � | j j � Wd QX| j | j j d � i d d 6d d 6d d 6d d 6� | j t d � � | j j d d � Wd QX| j j d d d �| j t d
� � | j j d � Wd QXt j | j � } | j
d d d d � t d k r[| j j d d d �| j t d � � | j j d � Wd QX| j | j j d d � d � n | j | j j d d � d � | j | j j d d � d � t d k r�| j j | d d �| j | j j d d � d � n d S( Ni R� R� R� R� s bad option "-foo"R� i i s* must specify a single element on retrievalR� R� i i t alls expected integer but got "all"i i ( i i ( i i ( i i ( i i ( R� R� R R� R$ Re R" R R R� R� R ( R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_columnconfigure_ s, #
" c C s� | j t d � � | j j d d d �Wd QX| j j d d d �| j | j j d d � d � | j | j j d � d d � d S( Ns bad screen distance "foo"i R� R� i
( R" R R R� R$ ( R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt! test_grid_columnconfigure_minsizew s
c C s� | j t d � � | j j d d d �Wd QX| j t d � � | j j d d d �Wd QX| j j d d d �| j | j j d d � d � | j | j j d � d d � d S( Ns expected integer but got "bad"i R� t bads- invalid arg "-weight": should be non-negativei����i ( R" R R R� R$ ( R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_columnconfigure_weight~ s c C s� | j t d � � | j j d d d �Wd QX| j t d � � | j j d d d �Wd QX| j j d d d �| j | j j d d � d � | j | j j d � d d � d S( Ns bad screen distance "foo"i R� R� s* invalid arg "-pad": should be non-negativei����i ( R" R R R� R$ ( R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_columnconfigure_pad� s c C sY | j j d d d �| j | j j d d � d � | j | j j d � d d � d S( Ni R� R� ( R R� R$ ( R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt! test_grid_columnconfigure_uniform� s c C s� | j t � � | j j � Wd QX| j | j j d � i d d 6d d 6d d 6d d 6� | j t d � � | j j d d � Wd QX| j j d d d �| j t d
� � | j j d � Wd QXt j | j � } | j
d d d d � t d k r[| j j d d d �| j t d � � | j j d � Wd QX| j | j j d d � d � n | j | j j d d � d � | j | j j d d � d � t d k r�| j j | d d �| j | j j d d � d � n d S( Ni R� R� R� R� s bad option "-foo"R� i i s* must specify a single element on retrievalR� R� i i R� s expected integer but got "all"i i ( i i ( i i ( i i ( i i ( R� R� R R� R$ Re R" R R R� R� R ( R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_rowconfigure� s, #
" c C s� | j t d � � | j j d d d �Wd QX| j j d d d �| j | j j d d � d � | j | j j d � d d � d S( Ns bad screen distance "foo"i R� R� i
( R" R R R� R$ ( R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_rowconfigure_minsize� s
c C s� | j t d � � | j j d d d �Wd QX| j t d � � | j j d d d �Wd QX| j j d d d �| j | j j d d � d � | j | j j d � d d � d S( Ns expected integer but got "bad"i R� R� s- invalid arg "-weight": should be non-negativei����i ( R" R R R� R$ ( R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_rowconfigure_weight� s c C s� | j t d � � | j j d d d �Wd QX| j t d � � | j j d d d �Wd QX| j j d d d �| j | j j d d � d � | j | j j d � d d � d S( Ns bad screen distance "foo"i R� R� s* invalid arg "-pad": should be non-negativei����i ( R" R R R� R$ ( R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_rowconfigure_pad� s c C sY | j j d d d �| j | j j d d � d � | j | j j d � d d � d S( Ni R� R� ( R R� R$ ( R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_rowconfigure_uniform� s c C s� t j | j � } t j | j � } | j d d d d d d d d d d d d d
d � | j | j j � | g � | j � | j � | j | j j � g � | j | j � i � | j d d d d � | j � } | j | d | j d � � | j | d | j d � � | j | d | j d
� � | j | d | j d
� � | j | d | j d � � | j | d | j d � � | j | d
d � d S( NR� i R� R� R� R( i R* i R� t nsi i Rp ( R R� R R� R$ t grid_slavest grid_forgetR� RP ( R R R RZ ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_forget� s$ !
c C s� t j | j � } t j | j � } | j d d d d d d d d d d d d d
d � | j | j j � | g � | j � | j � | j | j j � g � | j | j � i � | j d d d d � | j � } | j | d | j d � � | j | d | j d � � | j | d | j d � � | j | d | j d � � | j | d | j d � � | j | d | j d � � | j | d
d � d S(
NR� i R� R� R� R( i R* i R� R� i ( R R� R R� R$ R� t grid_removeR� RP ( R R R RZ ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_remove� s$ !
c C sU t j | j � } | j | j � i � | j d d d d d d d d d d d d d
d � | j � } | j | t � | j | d | j � | j | d | j d � � | j | d | j d � � | j | d | j d � � | j | d | j d � � | j | d | j d � � | j | d | j d � � | j | d
d � d S(
NR� i R� R� R� R( i R* i R� R� RW ( R R� R R$ R� R� RX RY RP ( R R RZ ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_info� s ! c C s� | j | j j � d � | j | j j d d � d � | j | j j d d d d � d � | j t d � � | j j d d � Wd QX| j t d � � | j j d d � Wd QX| j t d � � | j j d d d d � Wd QX| j t d � � | j j d d d d � Wd QX| j t � �! | j j d d d d d � Wd QX| j } | j d � | j d � t j | d d d d d
d �} t j | d d d d d
d
�} | j
d d d d � | j
d d d d � | j j � | j | j � d � | j | j d d � d � | j | j d d d d � d � | j | j d d � d � | j | j d d d d � d � | j | j d d d d � d � | j | j d d d d � d � d S( Ni i s expected integer but got "x"RM s 1x1+0+0Rp R
iK R R R iZ R R� R� i� i
i����i����i ( i i i i ( i i i i ( i i i i ( i i i� i� ( i i iK iK ( i i i� i� ( iK iK iZ iZ ( i i i� i� ( i i i i ( i� i� i i ( R$ R t grid_bboxR" R R� R� R R R R� R. ( R Rm t f1Ro ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_bbox s8 % "
!!
" ""c C s� | j t � � | j j � Wd QX| j t � � | j j d � Wd QX| j t � � | j j d d d � Wd QX| j t d � � | j j d d � Wd QX| j t d � � | j j d d � Wd QX| j } | j d � | j d � t j | d d
d d d
d d d �} | j | j d d � d � | j
� | j j � | j | j d d � d � | j | j d d � d � | j | j d d � d � | j | j d d � d � | j | j d d � d � | j | j d d � d � | j | j d
d � d � | j | j d d � d � | j | j d d � d � | j | j d d � d � | j | j d d � d! � d S(" Ni s bad screen distance "x"RM Rk s bad screen distance "y"RN s 1x1+0+0Rp R
i� R id t highlightthicknessR R i
i����i����i� i ie ( i����i����( i����i����( i����i ( i����i ( i i����( i i����( i i ( i i ( i i ( i i ( i i ( i i ( R� R� R t
grid_locationR" R R R R R$ R� R. ( R Rm Rn ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_location& s:
c C s� | j | j j � t � | j t � � | j j t t � Wd QX| j j t � | j | j j � � t j | j d d d d d d �} | j
d d d d � | j j � | j | j � d � | j | j
� d � | j t � t j | j d d d d
d d �} | j
d | d d d d � | j j � | j | j � d � | j | j
� d � | j t � | j j � | j | j � d � | j | j
� d
� d S(
NR
id R R R R� i R� iK iU R RG ( R$ R R� R- R� R� R^ R� R R R� R. R� R� ( R Rn t g( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_propagateF s( $
$
c C s� | j t � � | j j d � Wd QX| j | j j � d � t j | j � } | j d d d d � | j | j j � d � | j d d d d � | j | j j � d
� d S( Ni R� R� i i i i ( i i ( i i ( i i ( R� R� R R� R$ R t ScaleR� ( R Rn ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_size\ s c C s� | j | j j � g � t j | j � } | j d d d d � t j | j � } | j d d d d � t j | j � } | j d d d d � t j | j � } | j d d d d � | j | j j � | | | | g � | j | j j d d � | g � | j | j j d d � | | | g � | j | j j d d � | g � | j | j j d d � | | | g � | j | j j d d d d � | | g � d S( NR� i R� i ( R$ R R� R t LabelR� ( R R R R R ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt test_grid_slavesf s %"("(N(" Rc Rd Re Rf R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� ( ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyR� � s>
t __main__( t unittestRt t TkinterR R t test.test_supportR R t test_ttk.supportR R R t widget_testsR R t TestCaseR Rg R� t tests_guiRc ( ( ( sG /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_geometry_managers.pyt <module> s
� � � � test/test_tkinter/test_images.pyc 0000644 00000037047 15032720555 0013302 0 ustar 00 �
z fc @ s� d d l Z d d l Z d d l Z d d l j Z d d l m Z m Z e j
d � d e e j f d � � YZ d e e j f d � � YZ
d e e j f d � � YZ e e
e f Z e d
k r� e j e � n d S( i����N( t AbstractTkTestt requires_tclt guit MiscTestc B s e Z d � Z d � Z RS( c C sC | j j � } | j | t � | j d | � | j d | � d S( Nt photot bitmap( t roott image_typest assertIsInstancet tuplet assertIn( t selfR ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_image_types s c C s# | j j � } | j | t � d S( N( R t image_namesR R ( R R
( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_image_names s ( t __name__t
__module__R R ( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyR
s t BitmapImageTestc B sV e Z e d � � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
RS( c C s, t j j | � t j d d d �| _ d S( Ns
python.xbmt subdirt
imghdrdata( R t
setUpClasst __func__t supportt findfilet testfile( t cls( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyR s c
C s� t j d d | j d d d d d | j �} | j t | � d � | j | j � d � | j | j � d � | j | j � d � | j d | j j
� � ~ | j d | j j
� � d S(
Ns ::img::testt mastert
foregroundt yellowt
backgroundt bluet fileR i ( t tkintert BitmapImageR R t assertEqualt strt typet widtht heightR
R
t assertNotIn( R t image( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_create_from_file s c C s� t | j d � � } | j � } Wd QXt j d d | j d d d d d | �} | j t | � d � | j | j � d � | j | j � d
� | j | j
� d
� | j d | j j � � ~ | j
d | j j � � d S( Nt rbs ::img::testR R R R R t dataR i ( t openR t readR R! R R" R# R$ R% R& R
R
R' ( R t fR+ R( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_create_from_data* s c C s0 | j | t � | j | j j | � | � d S( N( R R# R" R t splitlist( R t actualt expected( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt assertEqualStrList8 s c C s� t j d d | j �} | j | d d � t | j d � � } | j � } Wd QX| j d | � | j | d d d d d | f � | j | j � d � | j | j
� d � | j | d d
� | j d | � | j | d d d d d | f � d S( Ns ::img::testR R+ s -data {} {} {} {}R* s -datat i t maskdatas -maskdata {} {} {} {}s -maskdata( R R! R R" R, R R- t configureR3 R% R& ( R R( R. R+ ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_configure_data< s
c C s� t j d d | j �} | j | d d � | j d | j � | j | d d d d d | j f � | j | j � d � | j | j � d � | j | d d � | j d | j � | j | d d
d d d | j f � d S( Ns ::img::testR R s -file {} {} {} {}s -fileR4 i t maskfiles -maskfile {} {} {} {}s -maskfile( R R! R R" R6 R R3 R% R& ( R R( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_configure_fileL s
c C sT t j d d | j �} | j | d d � | j d d � | j | d d � d S( Ns ::img::testR R s -background {} {} {} {}R s -background {} {} {} blue( R R! R R" R6 ( R R( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_configure_backgroundZ s c C sT t j d d | j �} | j | d d � | j d d � | j | d d � d S( Ns ::img::testR R s! -foreground {} {} #000000 #000000R s -foreground {} {} #000000 yellow( R R! R R" R6 ( R R( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_configure_foreground` s
( R R t classmethodR R) R/ R3 R7 R9 R: R; ( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyR s t PhotoImageTestc B s e Z e d � � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d � Z d
� Z
e d d � d
� � Z e d d � d � � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c C s, t j j | � t j d d d �| _ d S( Ns
python.gifR R ( R R R R R R ( R ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyR k s c C s t j d d | j d | j �S( Ns ::img::testR R ( R t
PhotoImageR R ( R ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt createp s c G s- t j d k r | j r | St j | � Sd S( Ng333333!@( R t TkVersiont wantobjectst _join( R t args( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt colorlistt s c C s� t j d | d d �} t j d d | j d | �} | j t | � d � | j | j � d � | j | j � d � | j | j � d � | j | d d
� | j | d | � | j
d | j j � � ~ | j d | j j � � d S( Ns python.R R s ::img::testR R R i R+ R4 (
R R R R> R R" R# R$ R% R& R
R
R' ( R t extR R( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt check_create_from_filez s c C s, t j d | d d �} t | d � � } | j � } Wd QXt j d d | j d | �} | j t | � d � | j | j � d � | j | j
� d � | j | j � d � | j | d | j r� | n | j
d
� � | j | d d � | j d | j j � � ~ | j d | j j � � d S(
Ns python.R R R* s ::img::testR R+ R i t latin1R R4 ( R R R, R- R R> R R" R# R$ R% R& RA t decodeR
R
R' ( R RE R R. R+ R( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt check_create_from_data� s c C s | j d � d S( Nt ppm( RF ( R ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_create_from_ppm_file� s c C s | j d � d S( NRJ ( RI ( R ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_create_from_ppm_data� s c C s | j d � d S( Nt pgm( RF ( R ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_create_from_pgm_file� s c C s | j d � d S( NRM ( RI ( R ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_create_from_pgm_data� s c C s | j d � d S( Nt gif( RF ( R ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_create_from_gif_file� s c C s | j d � d S( NRP ( RI ( R ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_create_from_gif_data� s i i c C s | j d � d S( Nt png( RF ( R ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_create_from_png_file� s c C s | j d � d S( NRS ( RI ( R ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_create_from_png_data� s c C s� t j d d | j �} | j | d d � t | j d � � } | j � } Wd QX| j d | � | j | d | j r | n | j d � � | j | j
� d � | j | j � d � d S( Ns ::img::testR R+ R4 R* RG i ( R R> R R" R, R R- R6 RA RH R% R& ( R R( R. R+ ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyR7 � s c C s� t j d d | j �} | j | d d � | j d | j d d � | j | d | j ra d n d � | j | j � d � | j | j � d � d S( Ns ::img::testR t formatR4 R RP i ( RP ( R R> R R" R6 R RA R% R& ( R R( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_configure_format� s c C s� t j d d | j �} | j | d d � | j d | j � | j | d | j � | j | j � d � | j | j � d � d S( Ns ::img::testR R R4 i ( R R> R R" R6 R R% R& ( R R( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyR9 � s c C sT t j d d | j �} | j | d d � | j d d � | j | d d � d S( Ns ::img::testR t gammas 1.0g @s 2.0( R R> R R" R6 ( R R( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_configure_gamma� s c C s� t j d d | j �} | j | d d � | j | d d � | j d d � | j d d � | j | d d � | j | d d � | j | j � d � | j | j � d � d S(
Ns ::img::testR R% t 0R& i i
t 20t 10( R R> R R" R6 R% R& ( R R( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_configure_width_height� s c C sx t j d d | j �} | j | d d � | j d d � | j | d d � | j d d � | j | d d � d S( Ns ::img::testR t paletteR4 i t 256s 3/4/2( R R> R R" R6 ( R R( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_configure_palette� s c C sq | j � } | j � | j | j � d � | j | j � d � | j | j d d � | j d d d � � d S( Ni i i i ( R? t blankR" R% R& t getRD ( R R( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt
test_blank� s
c C sp | j � } | j � } | j | j � d � | j | j � d � | j | j d d � | j d d � � d S( Ni i i ( R? t copyR" R% R& Rb ( R R( t image2( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_copy� s
c C s� | j � } | j d d � } | j | j � d � | j | j � d � | j | j d d � | j d d � � | j d � } | j | j � d � | j | j � d � | j | j d d � | j d d � � d S( Ni i i i i ( R? t subsampleR" R% R& Rb ( R R( Re ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_subsample� s (c C s) | j � } | j d d � } | j | j � d � | j | j � d � | j | j d d � | j d d � � | j | j d d
� | j d d � � | j d � } | j | j � d � | j | j � d � | j | j d d � | j d d � � | j | j d d � | j d d � � d S(
Ni i i i0 i i i i i i i i
( R? t zoomR" R% R& Rb ( R R( Re ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_zoom s (((c C s� | j � } | j d d d �| j | j d d � | j d d d � � | j | j d d � | j d t j d k r} d n d d � � | j | j d d
� | j d d d � � | j | j d d
� | j d d d � � | j d d f � | j | j d d � | j d d d � � | j | j d d � | j d d d � � | j | j d d � | j d d d � � | j | j d d � | j d d d � � d S( Ns {red green} {blue yellow}t toi i i� i i g333333!@i� i s #f00s #00ff00s
#000000fffs
#ffffffff0000i ( i i ( s #f00s #00ff00( s
#000000fffs
#ffffffff0000( R? t putR" Rb RD R R@ ( R R( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_put s +
+++++c C s | j � } | j | j d d � | j d d d � � | j | j d d � | j d d d � � | j | j d d � | j d d d � � | j t j | j d d � | j t j | j d d � | j t j | j d d � | j t j | j d d � d S(
Ni i i> it i� i i i����i ( R? R" Rb RD t assertRaisesR t TclError( R R( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt test_get s +++ c C s� | j � } | j t j t j � | j t j � t j d d | j d d d t j �} | j t
| � d � | j | j � d � | j | j � d � | j | j
� d � | j | j d d � | j d d � � | j | j d d
� | j d d
� � | j t j d d d d �t j d d | j d d d t j �} | j t
| � d � | j | j � d � | j | j � d � | j | j
� d � | j | j d d � | j d
d � � | j | j d d � | j d d
� � d S( Ns ::img::test2R RV RJ R R i i i i RP t from_coordsi i i s ::img::test3i i i i ( i i i i ( R? t
addCleanupR t unlinkt TESTFNt writeR R> R R" R# R$ R% R& Rb ( R R( Re t image3( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt
test_write* s, (( (( R R R< R R? RD RF RI RK RL RN RO RQ RR R RT RU R7 RW R9 RY R] R` Rc Rf Rh Rj Rm Rp Rw ( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyR= i s4
t __main__( t unittestt TkinterR t ttkt test.test_supportt test_supportR t test_ttk.supportR R t requirest TestCaseR R R= t tests_guiR t run_unittest( ( ( s< /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_images.pyt <module> s
R � test/test_tkinter/test_misc.py 0000644 00000010233 15032720555 0012611 0 ustar 00 import unittest
import Tkinter as tkinter
from test.test_support import requires, run_unittest
from test_ttk.support import AbstractTkTest
requires('gui')
class MiscTest(AbstractTkTest, unittest.TestCase):
def test_after(self):
root = self.root
cbcount = {'count': 0}
def callback(start=0, step=1):
cbcount['count'] = start + step
# Without function, sleeps for ms.
self.assertIsNone(root.after(1))
# Set up with callback with no args.
cbcount['count'] = 0
timer1 = root.after(0, callback)
self.assertIn(timer1, root.tk.call('after', 'info'))
(script, _) = root.tk.splitlist(root.tk.call('after', 'info', timer1))
root.update() # Process all pending events.
self.assertEqual(cbcount['count'], 1)
with self.assertRaises(tkinter.TclError):
root.tk.call(script)
# Set up with callback with args.
cbcount['count'] = 0
timer1 = root.after(0, callback, 42, 11)
root.update() # Process all pending events.
self.assertEqual(cbcount['count'], 53)
# Cancel before called.
timer1 = root.after(1000, callback)
self.assertIn(timer1, root.tk.call('after', 'info'))
(script, _) = root.tk.splitlist(root.tk.call('after', 'info', timer1))
root.after_cancel(timer1) # Cancel this event.
self.assertEqual(cbcount['count'], 53)
with self.assertRaises(tkinter.TclError):
root.tk.call(script)
def test_after_idle(self):
root = self.root
cbcount = {'count': 0}
def callback(start=0, step=1):
cbcount['count'] = start + step
# Set up with callback with no args.
cbcount['count'] = 0
idle1 = root.after_idle(callback)
self.assertIn(idle1, root.tk.call('after', 'info'))
(script, _) = root.tk.splitlist(root.tk.call('after', 'info', idle1))
root.update_idletasks() # Process all pending events.
self.assertEqual(cbcount['count'], 1)
with self.assertRaises(tkinter.TclError):
root.tk.call(script)
# Set up with callback with args.
cbcount['count'] = 0
idle1 = root.after_idle(callback, 42, 11)
root.update_idletasks() # Process all pending events.
self.assertEqual(cbcount['count'], 53)
# Cancel before called.
idle1 = root.after_idle(callback)
self.assertIn(idle1, root.tk.call('after', 'info'))
(script, _) = root.tk.splitlist(root.tk.call('after', 'info', idle1))
root.after_cancel(idle1) # Cancel this event.
self.assertEqual(cbcount['count'], 53)
with self.assertRaises(tkinter.TclError):
root.tk.call(script)
def test_after_cancel(self):
root = self.root
cbcount = {'count': 0}
def callback():
cbcount['count'] += 1
timer1 = root.after(5000, callback)
idle1 = root.after_idle(callback)
# No value for id raises a ValueError.
with self.assertRaises(ValueError):
root.after_cancel(None)
# Cancel timer event.
cbcount['count'] = 0
(script, _) = root.tk.splitlist(root.tk.call('after', 'info', timer1))
root.tk.call(script)
self.assertEqual(cbcount['count'], 1)
root.after_cancel(timer1)
with self.assertRaises(tkinter.TclError):
root.tk.call(script)
self.assertEqual(cbcount['count'], 1)
with self.assertRaises(tkinter.TclError):
root.tk.call('after', 'info', timer1)
# Cancel same event - nothing happens.
root.after_cancel(timer1)
# Cancel idle event.
cbcount['count'] = 0
(script, _) = root.tk.splitlist(root.tk.call('after', 'info', idle1))
root.tk.call(script)
self.assertEqual(cbcount['count'], 1)
root.after_cancel(idle1)
with self.assertRaises(tkinter.TclError):
root.tk.call(script)
self.assertEqual(cbcount['count'], 1)
with self.assertRaises(tkinter.TclError):
root.tk.call('after', 'info', idle1)
tests_gui = (MiscTest, )
if __name__ == "__main__":
run_unittest(*tests_gui)
test/test_tkinter/test_misc.pyc 0000644 00000007400 15032720555 0012756 0 ustar 00 �
z fc @ s� d d l Z d d l Z d d l m Z m Z d d l m Z e d � d e e j f d � � YZ e f Z
e d k r� e e
� n d S( i����N( t requirest run_unittest( t AbstractTkTestt guit MiscTestc B s# e Z d � Z d � Z d � Z RS( c s� | j } i d d 6� d d � f d � } | j | j d � � d � d <| j d | � } | j | | j j d d � � | j j | j j d d | � � \ } } | j � | j � d d � | j t
j � � | j j | � Wd QXd � d <| j d | d d � } | j � | j � d d � | j d
| � } | j | | j j d d � � | j j | j j d d | � � \ } } | j | � | j � d d � | j t
j � � | j j | � Wd QXd S( Ni t counti c s | | � d <d S( NR ( ( t startt step( t cbcount( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_misc.pyt callback s t aftert infoi* i i5 i� (
t roott assertIsNoneR
t assertInt tkt callt splitlistt updatet assertEqualt assertRaisest tkintert TclErrort after_cancel( t selfR R t timer1t scriptt _( ( R s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_misc.pyt
test_after
s.
*
*
c s� | j } i d d 6� d d � f d � } d � d <| j | � } | j | | j j d d � � | j j | j j d d | � � \ } } | j � | j � d d � | j t j
� � | j j | � Wd QXd � d <| j | d d � } | j � | j � d d � | j | � } | j | | j j d d � � | j j | j j d d | � � \ } } | j | � | j � d d � | j t j
� � | j j | � Wd QXd S(
Ni R i c s | | � d <d S( NR ( ( R R ( R ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_misc.pyR 1 s R
R i* i i5 ( R t
after_idleR R R R t update_idletasksR R R R R ( R R R t idle1R R ( ( R s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_misc.pyt test_after_idle- s,
*
*
c s | j } i d d 6� � f d � } | j d | � } | j | � } | j t � � | j d � Wd QXd � d <| j j | j j d d | � � \ } } | j j | � | j
� d d � | j | � | j t j � � | j j | � Wd QX| j
� d d � | j t j � � | j j d d | � Wd QX| j | � d � d <| j j | j j d d | � � \ } } | j j | � | j
� d d � | j | � | j t j � � | j j | � Wd QX| j
� d d � | j t j � � | j j d d | � Wd QXd S( Ni R c s � d c d 7<d S( NR i ( ( ( R ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_misc.pyR Q s i� R
R i (
R R
R R t
ValueErrorR t NoneR R R R R R ( R R R R R R R ( ( R s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_misc.pyt test_after_cancelM s8
*
*
( t __name__t
__module__R R R# ( ( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_misc.pyR s # t __main__( t unittestt TkinterR t test.test_supportR R t test_ttk.supportR t TestCaseR t tests_guiR$ ( ( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_misc.pyt <module> s
o test/test_tkinter/__init__.pyc 0000644 00000000220 15032720555 0012514 0 ustar 00 �
z fc @ s d S( N( ( ( ( s9 /usr/lib64/python2.7/lib-tk/test/test_tkinter/__init__.pyt <module> t test/test_tkinter/test_text.pyo 0000644 00000003467 15032720555 0013034 0 ustar 00 �
z fc @ s� d d l Z d d l Z d d l m Z m Z d d l m Z e d � d e e j f d � � YZ e f Z
e d k r� e e
� n d S( i����N( t requirest run_unittest( t AbstractTkTestt guit TextTestc B s# e Z d � Z d � Z d � Z RS( c C s, t t | � j � t j | j � | _ d S( N( t superR t setUpt tkintert Textt roott text( t self( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_text.pyR
s c C s� | j } | j � } zJ | j d � | j | j � d � | j d � | j | j � d � Wd | j | � | j | j � | � Xd S( Ni i ( R
t debugt assertEqual( R R
t olddebug( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_text.pyt
test_debug s
c C s� | j } | j t j | j d d � | j t j | j d d � | j t j | j d d � | j t j | j d d � | j d d � | j | j d d d � d � | j | j d d d � d
� d S( Ns 1.0t at i s hi-tests -testt ends 1.2t tests 1.3( R
t assertRaisesR t TclErrort searcht Nonet insertR
( R R
( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_text.pyt test_search s ( t __name__t
__module__R R R ( ( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_text.pyR s t __main__( t unittestt TkinterR t test.test_supportR R t test_ttk.supportR t TestCaseR t tests_guiR ( ( ( s: /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_text.pyt <module> s
$ test/test_tkinter/test_widgets.pyc 0000644 00000172022 15032720555 0013474 0 ustar 00 �
z fc @ sT d d l Z d d l Z d d l m Z d d l Z d d l Z d d l m Z m Z d d l m
Z
m Z m Z m
Z
d d l m Z m Z m Z m Z m Z m Z m Z m Z m Z m Z e d � d e e f d � � YZ e e � d e e j f d
� � Y� Z e e � d e e j f d � � Y� Z e e � d
e e j f d � � Y� Z d e e f d � � YZ e e � d e e j f d � � Y� Z e e � d e e j f d � � Y� Z e e � d e e j f d � � Y� Z! e e � d e e j f d � � Y� Z" e e � d e e j f d � � Y� Z# d e# e j f d � � YZ$ e e e � d e e j f d � � Y� Z% e e � d e% e j f d � � Y� Z& e e � d! e e j f d" � � Y� Z' e e e � d# e e j f d$ � � Y� Z( e e e � d% e e j f d& � � Y� Z) e e e � d' e e j f d( � � Y� Z* e e e � d) e e j f d* � � Y� Z+ e e � d+ e e j f d, � � Y� Z, e e � d- e e j f d. � � Y� Z- e e e � d/ e e j f d0 � � Y� Z. e e( e! e% e e e e) e# e- e. e$ e, e" e* e+ e& e' e g Z/ e0 d1 k rPe e/ � n d S(2 i����N( t TclError( t requirest run_unittest( t tcl_versiont requires_tclt get_tk_patchlevelt widget_eq(
t add_standard_optionst noconvt noconv_metht int_roundt pixels_roundt AbstractWidgetTestt StandardOptionsTestst IntegerSizeTestst PixelSizeTestst setUpModulet guit AbstractToplevelTestc B s2 e Z e Z d � Z d � Z d � Z d � Z RS( c C so | j � } | j | d | j j j � � | j | d d d d �| j d d � } | j | d d � d S( Nt classt Foot errmsgs2 can't modify -class option after widget is createdt class_( t createt assertEqualt __class__t __name__t titlet checkInvalidParam( t selft widgett widget2( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_class s
c C sc | j � } | j | d d � | j | d d d d �| j d d � } | j | d d � d S( Nt colormapt t newR s5 can't modify -colormap option after widget is created( R R R ( R R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_colormap s c C s� | j � } | j | d | j r( d n d � | j | d d d d �| j d t � } | j | d | j rv d n d � d S( Nt containeri t 0i R s6 can't modify -container option after widget is createdt 1( R R t wantobjectsR t True( R R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_container' s #c C sc | j � } | j | d d � | j | d d d d �| j d d � } | j | d d � d S( Nt visualR" t defaultR s3 can't modify -visual option after widget is created( R R R ( R R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_visual/ s ( R t
__module__R t _conv_pad_pixelsR R$ R* R- ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR s
t ToplevelTestc B s2 e Z d Z d � Z d � Z d � Z d � Z RS( t
backgroundt borderwidthR R! R% t cursort heightt highlightbackgroundt highlightcolort highlightthicknesst menut padxt padyt relieft screent takefocust useR+ t widthc K s t j | j | � S( N( t tkintert Toplevelt root( R t kwargs( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR B s c C sN | j � } t j | j � } | j | d | d t �| j | d d � d S( NR8 t eqR" ( R R@ t MenuRB t
checkParamR ( R R R8 ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_menuE s c C s� | j � } | j | d d � y t j d } Wn t k
rQ | j d � n X| j | d | d d �| j d | � } | j | d | � d S( NR< R" t DISPLAYs No $DISPLAY set.R s3 can't modify -screen option after widget is created( R R t ost environt KeyErrort skipTestR ( R R t displayR ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_screenK s
c C sl | j � } | j | d d � | j d t � } d | j � } | j d | � } | j | d | � d S( NR> R" R% s %#x( R R R) t winfo_id( R R t parentt widR ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_useW s ( R1 R2 R R! R% R3 R4 R5 R6 R7 R8 R9 R: R; R< R= R> R+ R? ( R R. t OPTIONSR RG RN RR ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR0 8 s t FrameTestc B s e Z d Z d � Z RS( R1 R2 R R! R% R3 R4 R5 R6 R7 R9 R: R; R= R+ R? c K s t j | j | � S( N( R@ t FrameRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR j s ( R1 R2 R R! R% R3 R4 R5 R6 R7 R9 R: R; R= R+ R? ( R R. RS R ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyRT a s
t LabelFrameTestc B s) e Z d Z d � Z d � Z d � Z RS( R1 R2 R R! R% R3 t fontt
foregroundR4 R5 R6 R7 t labelanchort labelwidgetR9 R: R; R= t textR+ R? c K s t j | j | � S( N( R@ t
LabelFrameRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR y s c C sW | j � } | j | d d d d d d d d d d
d d d
� | j | d d � d S( NRY t et ent est nt net nwt st set swt wt wnt wst center( R t checkEnumParamR ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_labelanchor| s
c C sQ | j � } t j | j d d d d �} | j | d | d d �| j � d S( NR[ t Muppt namet fooRZ t expecteds .foo( R R@ t LabelRB RF t destroy( R R t label( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_labelwidget� s ( R1 R2 R R! R% R3 RW RX R4 R5 R6 R7 RY RZ R9 R: R; R= R[ R+ R? ( R R. RS R Rk Rs ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyRV n s t AbstractLabelTestc B s e Z e Z d � Z RS( c C s2 | j � } | j | d d d d d d d � d S( NR7 i g�������?g������@i i����t 10p( R t checkPixelsParam( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_highlightthickness� s ( R R. R t _conv_pixelsRw ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyRt � s t LabelTestc B s e Z d Z d � Z RS( t activebackgroundt activeforegroundt anchorR1 t bitmapR2 t compoundR3 t disabledforegroundRW RX R4 R5 R6 R7 t imaget justifyR9 R: R; t stateR= R[ t textvariablet underlineR? t
wraplengthc K s t j | j | � S( N( R@ Rp RB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � s ( Rz R{ R| R1 R} R2 R~ R3 R RW RX R4 R5 R6 R7 R� R� R9 R: R; R� R= R[ R� R� R? R� ( R R. RS R ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyRy � s t
ButtonTestc B s e Z d" Z d � Z d! � Z RS(# Rz R{ R| R1 R} R2 t commandR~ R3 R, R RW RX R4 R5 R6 R7 R� R� t
overreliefR9 R: R; t repeatdelayt repeatintervalR� R= R[ R� R� R? R� c K s t j | j | � S( N( R@ t ButtonRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � s c C s) | j � } | j | d d d d � d S( NR, t activet disabledt normal( R Rj ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_default� s ( Rz R{ R| R1 R} R2 R� R~ R3 R, R RW RX R4 R5 R6 R7 R� R� R� R9 R: R; R� R� R� R= R[ R� R� R? R� ( R R. RS R R� ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� � s t CheckbuttonTestc & B s) e Z d) Z d& � Z d' � Z d( � Z RS(* Rz R{ R| R1 R} R2 R� R~ R3 R RW RX R4 R5 R6 R7 R� t indicatoronR� t offrelieft offvaluet onvalueR� R9 R: R; t selectcolort selectimageR� R= R[ R� t
tristateimaget
tristatevalueR� t variableR? R� c K s t j | j | � S( N( R@ t CheckbuttonRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � s c C s, | j � } | j | d d d d d � d S( NR� i gffffff@R" s
any string( R t checkParams( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_offvalue� s c C s, | j � } | j | d d d d d � d S( NR� i gffffff@R" s
any string( R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_onvalue� s (& Rz R{ R| R1 R} R2 R� R~ R3 R RW RX R4 R5 R6 R7 R� R� R� R� R� R� R� R9 R: R; R� R� R� R= R[ R� R� R� R� R� R? R� ( R R. RS R R� R� ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� � s t RadiobuttonTestc % B s e Z d' Z d% � Z d& � Z RS(( Rz R{ R| R1 R} R2 R� R~ R3 R RW RX R4 R5 R6 R7 R� R� R� R� R� R9 R: R; R� R� R� R= R[ R� R� R� R� t valueR� R? R� c K s t j | j | � S( N( R@ t RadiobuttonRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � s c C s, | j � } | j | d d d d d � d S( NR� i gffffff@R" s
any string( R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_value� s (% Rz R{ R| R1 R} R2 R� R~ R3 R RW RX R4 R5 R6 R7 R� R� R� R� R� R9 R: R; R� R� R� R= R[ R� R� R� R� R� R� R? R� ( R R. RS R R� ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� � s t MenubuttonTestc B s� e Z d( Z e e � Z d � Z d � Z d � Z e j
j Z
e j
e j d! k d" � d# � � Z d$ � Z d% � Z d& � Z d' � Z RS() Rz R{ R| R1 R} R2 R~ R3 t directionR RW RX R4 R5 R6 R7 R� R� R� R8 R9 R: R; R� R= R[ R� R� R? R� c K s t j | j | � S( N( R@ t
MenubuttonRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � s c C s/ | j � } | j | d d d d d d � d S( NR� t abovet belowt flusht leftt right( R Rj ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_direction� s c C s/ | j � } | j | d d d d d t �d S( NR4 id i����i t conv( R t checkIntegerParamt str( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_height s t darwins" crashes with Cocoa Tk (issue19733)c C s� | j � } t j d | j d d � } | j | d | d t �d } | j t j � � } d | d <Wd QX| d k r� | j t | j
� | � n | j t j � � } | j i d d 6� Wd QX| d k r� | j t | j
� | � n d S( Nt masterRm t image1R� R� s image "spam" doesn't existt spam( R R@ t
PhotoImageRB RF R� t assertRaisesR t NoneR t exceptiont configure( R R R� R t cm( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_image s c C sH | j � } t j | d d �} | j | d | d t �| j � d S( NRm R8 RD ( R R@ RE RF R Rq ( R R R8 ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyRG s c C sE | j � } | j | d d d d d � | j | d d d d �d S( NR9 i g������@gffffff@t 12mi����Ro i ( R Rv RF ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_padx s c C sE | j � } | j | d d d d d � | j | d d d d �d S( NR: i g������@gffffff@R� i����Ro i ( R Rv RF ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_pady$ s c C s/ | j � } | j | d d d d d t �d S( NR? i� in���i R� ( R R� R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_width) s ( Rz R{ R| R1 R} R2 R~ R3 R� R RW RX R4 R5 R6 R7 R� R� R� R8 R9 R: R; R� R= R[ R� R� R? R� ( R R. RS t staticmethodR Rx R R� R� R
Rw t im_funct unittestt skipIft syst platformR� RG R� R� R� ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� � s( t OptionMenuTestc B s e Z d d d � Z RS( t bt at cc K s t j | j d | | | � S( N( R@ t
OptionMenuRB R� ( R R, t valuesRC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR 0 s ( R� R� R� ( R R. R ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� . s t EntryTestc B sh e Z d) Z d � Z d � Z d! � Z d" � Z d# � Z d$ � Z d% � Z d& � Z
d' � Z d( � Z RS(* R1 R2 R3 t disabledbackgroundR t exportselectionRW RX R5 R6 R7 t insertbackgroundt insertborderwidtht
insertofftimet insertontimet insertwidtht invalidcommandR� t readonlybackgroundR; t selectbackgroundt selectborderwidtht selectforegroundt showR� R= R� t validatet validatecommandR? t xscrollcommandc K s t j | j | � S( N( R@ t EntryRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR C s c C s | j � } | j | d � d S( NR� ( R t checkColorParam( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_disabledbackgroundF s c C sQ | j d d � } | j | d d d d d d d � | j | d d
d d
�d S( NR� id R� i g�������?g������@i i����Ru i< Ro i i2 ( R Rv RF ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_insertborderwidthJ s c C s� | j � } | j | d d d d � | j | d d d d �| j | d d d d �t d � d
k r� | j | d d d d �n | j | d d d d �d S( NR� g�������?g������ @Ru g�������?Ro i i����g�������?i i ( R Rv RF R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_insertwidthQ s c C s0 | j � } | j | d � | j | d � d S( NR� t invcmd( R t checkCommandParam( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_invalidcommand[ s c C s | j � } | j | d � d S( NR� ( R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_readonlybackground` s c C sI | j � } | j | d d � | j | d d � | j | d d � d S( NR� t *R" t ( R RF ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_showd s c C s) | j � } | j | d d d d � d S( NR� R� R� t readonly( R Rj ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_statej s c C s2 | j � } | j | d d d d d d d � d S( NR� t allt keyt focust focusint focusoutt none( R Rj ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_validateo s c C s0 | j � } | j | d � | j | d � d S( NR� t vcmd( R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_validatecommandt s ( R1 R2 R3 R� R R� RW RX R5 R6 R7 R� R� R� R� R� R� R� R� R; R� R� R� R� R� R= R� R� R� R? R� (
R R. RS R R� R� R� R� R� R� R� R� R� ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� 4 s(
t SpinboxTestc , B s� e Z d9 Z d, � Z d: Z d- � Z d. � Z d/ � Z d0 � Z d1 � Z
d2 � Z d3 � Z d4 � Z
d5 � Z d6 � Z d7 � Z d8 � Z RS(; Rz R1 R2 t buttonbackgroundt buttoncursort buttondownrelieft buttonupreliefR� R3 R� R R� RW RX t formatt fromR5 R6 R7 t incrementR� R� R� R� R� R� R� R; R� R� R� R� R� R� R� R= R� t toR� R� R� R? t wrapR� c K s t j | j | � S( N( R@ t SpinboxRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � s c C s | j � } | j | d � d S( NR� ( R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_buttonbackground� s c C s | j � } | j | d � d S( NR� ( R t checkCursorParam( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_buttoncursor� s c C s | j � } | j | d � d S( NR� ( R t checkReliefParam( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_buttondownrelief� s c C s | j � } | j | d � d S( NR� ( R R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_buttonuprelief� s c C s� | j � } | j | d d � | j | d d � | j | d d � | j | d d � | j | d d � | j | d d � | j | d d � | j | d d � | j | d d
� | j | d d � | j | d d � | j | d d
� d S( NR� s %2fs %2.2fs %.2fs %2.fs %2e-1fs 2.2s %2.-2fs %-2.02fs % 2.02fs % -2.200fs %09.200fs %d( R RF R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_format� s c C sU | j � } | j | d d � | j | d d d d � | j | d d d d �d S(
NR� g Y@R� i����gffffff$@gffffff'@i� R s* -to value must be greater than -from value( R RF t checkFloatParamR ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_from� s
c C s/ | j � } | j | d d d d d d � d S( NR� i����i gffffff$@g������)@i ( R R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_increment� s c C sU | j � } | j | d d � | j | d d d d � | j | d d d d �d S(
NR� g Y�R� i����gffffff$@gffffff'@i8���R s* -to value must be greater than -from value( R RF R R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_to� s
c C s| | j � } | j | d d � | j | d d � | j | d d
d d �| j | d d d d �| j | d d � d S( NR� R" s mon tue wed thurt mont tuet wedt thurRo i* g ��Q� @s
any strings 42 3.14 {} {any string}( R R R
R ( i* g ��Q� @R" s
any string( R R RF ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_values� s c C s | j � } | j | d � d S( NR� ( R t checkBooleanParam( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_wrap� s c C s� | j � } | j | j d � � | j t j | j d � | j t j | j d � | j t | j � | j t | j d d � d S( Ni t noindexi ( R t assertIsBoundingBoxt bboxR� R@ R R� t TypeError( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_bbox� s c C sl | j � } | j | j � d � | j d � | j | j � d � | j d � | j | j � d � d S( NR� t buttonupt
buttondown( R R t selection_element( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_selection_element� s
(, Rz R1 R2 R� R� R� R� R� R3 R� R R� RW RX R� R� R5 R6 R7 R� R� R� R� R� R� R� R� R; R� R� R� R� R� R� R� R= R� R� R� R� R� R? R� R� N( R R. RS R R� R� R� R� R R R R R R R R R R ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� z s8 t TextTestc ) B s1 e Z d@ Z e dA k r! e Z n d+ � Z d, � Z e d) d* � d- � � Z e d) d* � d. � � Z
d/ � Z d0 � Z e d) d* � d1 � � Z
e d) d2 � d3 � � Z d4 � Z d5 � Z d6 � Z d7 � Z e d) d* � d8 � � Z d9 � Z d: � Z e d) d* � d; � � Z d< � Z d= � Z d> � Z d? � Z RS(B t autoseparatorsR1 t blockcursorR2 R3 t endlineR� RW RX R4 R5 R6 R7 t inactiveselectbackgroundR� R� R� R� t insertunfocussedR� t maxundoR9 R: R; R� R� R� t setgridt spacing1t spacing2t spacing3t startlineR� t tabst tabstyleR= t undoR? R� R� t yscrollcommandi i c K s t j | j | � S( N( R@ t TextRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � s c C s | j � } | j | d � d S( NR ( R R
( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_autoseparators� s c C s | j � } | j | d � d S( NR ( R R
( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_blockcursor� s c C s� | j � } d j d � t d � D� � } | j d | � | j | d d d d �| j | d d d d �| j | d d
d d �| j | d d
� | j | d d � | j | d d d d �d S( Ns
c s s | ] } d Vq d S( s Line %dN( ( t .0t i( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pys <genexpr> s id t endR i� Ro R" i����R� R s expected integer but got "spam"i2 R# i i
s1 -startline must be less than or equal to -endline( R t joint ranget insertRF R ( R R R[ ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_endline s c C s^ | j � } | j | d d d d d � | j | d d d d �| j | d d d d �d S(
NR4 id g�����LY@gfffff�Y@t 3ci����Ro i i ( R Rv RF ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� s c C s) | j � } | j | d d d d � d S( NR i i i����( R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_maxundo s c C s | j � } | j | d � d S( NR ( R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_inactiveselectbackground s i c C s) | j � } | j | d d d d � d S( NR t hollowR� t solid( R Rj ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_insertunfocussed s c
C s> | j � } | j | d d d d d d t d t d
k �d S( NR� g�������?g������@i����Ru R� t keep_origi i ( i i ( R Rv R R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_selectborderwidth$ s c C sE | j � } | j | d d d d d � | j | d d d d �d S( NR i gffffff5@g������6@s 0.5ci����Ro i ( R Rv RF ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_spacing1* s c C sE | j � } | j | d d d d d � | j | d d d d �d S( NR! i g������@gffffff @s 0.1ci����Ro i ( R Rv RF ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_spacing2/ s c C sE | j � } | j | d d d d d � | j | d d d d �d S( NR" i gffffff5@g������6@s 0.5ci����Ro i ( R Rv RF ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_spacing34 s c C s� | j � } d j d � t d � D� � } | j d | � | j | d d d d �| j | d d d d �| j | d d
d d �| j | d d
� | j | d d � | j | d d d d �d S( Ns
c s s | ] } d Vq d S( s Line %dN( ( R+ R, ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pys <genexpr>< s id R- R# i� Ro R" i����R� R s expected integer but got "spam"i
R i2 iF s1 -startline must be less than or equal to -endline( R R. R/ R0 RF R ( R R R[ ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_startline9 s c C sK | j � } t d k r1 | j | d d d � n | j | d d d � d S( Ni i R� R� R� ( i i ( R R R� Rj ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� G s c
C s� | j � } t � d k r7 | j | d d d d �n | j | d d � | j | d d d d �| j | d d
d d �| j | d d d d d t d k �d S( Ni i i R$ gffffff$@g33333�4@t 1it 2iRo s 10.2s 20.7s 10.2 20.7 1i 2is 2c left 4c 6c centert 2cR� t 4ct 6cRi R� R s bad screen distance "spam"R8 ( i i i ( gffffff$@g33333�4@R> R? ( s 10.2s 20.7R> R? ( gffffff$@g33333�4@R> R? ( s 10.2s 20.7R> R? ( R@ R� RA RB Ri ( i i ( R R RF R R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_tabsN s
c C s& | j � } | j | d d d � d S( NR% t tabulart
wordprocessor( R Rj ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_tabstyle] s c C s | j � } | j | d � d S( NR& ( R R
( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_undob s c C sU | j � } | j | d d � | j | d d d d �| j | d d d d �d S( NR? i� in���Ro i i ( R R� RF ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� f s c C sQ | j � } t d k r4 | j | d d d d � n | j | d d d d � d S( Ni i R� t charR� t word( i i ( R R R� Rj ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR l s c C s� | j � } | j | j d � � | j | j d � � | j t j | j d � | j t j | j d � | j t j | j � | j t j | j d d � d S( Ns 1.1R- R ( R R R t assertIsNoneR� R@ R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR s s () R R1 R R2 R3 R R� RW RX R4 R5 R6 R7 R R� R� R� R� R R� R R9 R: R; R� R� R� R R R! R" R# R� R$ R% R= R& R? R� R� R' ( i i ( R R. RS R R) t
_stringifyR R) R R* R1 R� R3 R4 R7 R9 R: R; R< R= R� RC RF RG R� R R ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � sB t
CanvasTestc B sh e Z d# Z e e � Z e Z d � Z d � Z d � Z
d � Z d � Z d � Z
d! � Z d" � Z RS($ R1 R2 t closeenought confineR3 R4 R5 R6 R7 R� R� R� R� R� t offsetR; t scrollregionR� R� R� R� R= R� t xscrollincrementR' t yscrollincrementR? c K s t j | j | � S( N( R@ t CanvasRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � s c C s2 | j � } | j | d d d d d d t �d S( NRM i g333333@g������ @i����R� ( R R t float( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_closeenough� s c C s | j � } | j | d � d S( NRN ( R R
( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_confine� s c C s� | j � } | j | d d � | j | d d d d d d d d d
d � | j | d d � | j | d d
� | j | d d � d S( NRO s 0,0R` Ra R] Rd Rc Re Rf Rb Ri s 10,20s #5,6R� ( R R R� RF R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_offset� s c C s� | j � } | j | d d � | j | d d d d �| j | d d � | j | d d d d
�| j | d d � | j | d d
� | j | d d � d S( NRP s 0 0 200 150i i� i� Ro R" R� R s bad scrollRegion "spam"( i i i� i� ( i i i� R� ( i i i� ( i i i� i� i ( R RF R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_scrollregion� s c C s, | j � } | j | d d d d d �d S( NR� R� R� R s0 bad state value "{}": must be normal or disabled( R Rj ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� � s c C s2 | j � } | j | d d d d d d d � d S( NRQ i( i g������D@g������E@i���s 0.5i( R Rv ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_xscrollincrement� s c C s2 | j � } | j | d d d d d d d � d S( NRR i
i gffffff&@g333333+@i����s 0.1i( R Rv ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_yscrollincrement� s ( R1 R2 RM RN R3 R4 R5 R6 R7 R� R� R� R� R� RO R; RP R� R� R� R� R= R� RQ R' RR R? ( R R. RS R� R
Rx R) RK R RU RV RW RX R� RY RZ ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyRL } s( t ListboxTestc B s� e Z d, Z d � Z d � Z e d d d � e j j � Z d � Z d � Z
d � Z d! � Z d" � Z
d# � Z d$ � Z d% � Z d& � Z d' � Z d( � Z d) � Z d* � Z d+ � Z RS(- t activestyleR1 R2 R3 R R� RW RX R4 R5 R6 R7 R� t listvariableR; R� R� R� t
selectmodeR R� R= R? R� R' c K s t j | j | � S( N( R@ t ListboxRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � s c C s) | j � } | j | d d d d � d S( NR\ t dotboxR� R� ( R Rj ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_activestyle� s i i i c C s5 | j � } t j | j � } | j | d | � d S( NR] ( R R@ t DoubleVarRB t checkVariableParam( R R t var( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_listvariable� s c C s\ | j � } | j | d d � | j | d d � | j | d d � | j | d d � d S( NR^ t singlet browset multiplet extended( R RF ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_selectmode� s
c C s& | j � } | j | d d d � d S( NR� R� R� ( R Rj ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� � s c
C s� | j � } | j t d � � | j d � Wd QXd j � } | j d | � x- t | � D] \ } } | j | d | �q[ W| j t � � | j � Wd QX| j t d � � | j d � Wd QX| j | j d d � d � | j | j d d � d � | j | j d d � d � | j d � } | j
| t � x� | j � D]s \ } } | j
t | � d � t | � d
k rD| j | | j d | � � | j | d | j d | � � qDqDWd S( Ns item number "0" out of rangei s) red orange yellow green blue white violetR- R1 s bad listbox index "red"t redt
BackgroundR" t violets @0,0i i i ( R1 R1 Rl R" Rk ( R1 R1 Rl R" Rm ( R1 R1 Rl R" Rk ( i i ( R t assertRaisesRegexpR t
itemconfiguret splitR0 t enumerateR� R R t assertIsInstancet dictt itemst assertInt lent itemcget( R R t colorsR, t colort dt kt v( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_itemconfigure� s0 c C s� | j � } | j d d d d d � | j d i | | 6� | j | j d | � d | � | j | j d | � | � | j t d � � | j d i d | 6� Wd QXd S(
NR- R� R� R� Rz i i s unknown color name "spam"R� ( R R0 Ro R Rw Rn R ( R Rm R� R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt check_itemconfigure s c C s | j d d � d S( NR1 s #ff0000( R~ ( R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_itemconfigure_background s c C s | j d d � d S( Nt bgs #ff0000( R~ ( R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_itemconfigure_bg s c C s | j d d � d S( Nt fgs #110022( R~ ( R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_itemconfigure_fg s c C s | j d d � d S( NRX s #110022( R~ ( R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_itemconfigure_foreground s c C s | j d d � d S( NR� s #110022( R~ ( R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt# test_itemconfigure_selectbackground s c C s | j d d � d S( NR� s #654321( R~ ( R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt# test_itemconfigure_selectforeground s c C s� | j � } | j d d � t d � D� � | j � | j | j d � � | j | j d � � | j | j d � � | j t | j d � | j t | j d � | j t
| j � | j t
| j d d � d S( Ni c s s | ] } d | Vq d S( s el%dN( ( R+ R, ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pys <genexpr> s i i����i
R i ( R R0 R/ t packR R RJ R� R R� R ( R t lb( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_box s
c C s� | j � } | j d d � t d � D� � | j d t j � | j d d � | j d � | j | j � d � | j t
| j d � d S( Ni c s s | ] } d | Vq d S( s el%dN( ( R+ R, ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pys <genexpr>+ s i i i i i ( i i i i ( R R0 R/ t selection_clearR@ t ENDt
selection_setR t curselectionR� R ( R R� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_curselection) s
c C s� | j � } | j d d � t d � D� � | j | j d � d � | j | j d � d � | j | j d � d � | j | j d � d � | j | j d
� d � | j | j d d � d � | j | j d d � d � | j | j d d � d � | j | j d d � d � | j t | j d � | j t | j d � | j t | j � | j t | j d d � | j t | j d d d � | j t | j d � d S( Ni c s s | ] } d | Vq d S( s el%dN( ( R+ R, ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pys <genexpr>4 s i t el0i t el3R- t el7R" i����i t el4t el5t el6R i i g333333@( R� R� R� ( R� R� R� ( ( R� ( R R0 R/ R t getR� R R� R ( R R� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_get2 s" ( R\ R1 R2 R3 R R� RW RX R4 R5 R6 R7 R� R] R; R� R� R� R^ R R� R= R? R� R' ( R R. RS R Ra R R
t test_justifyR� Re Rj R� R} R~ R R� R� R� R� R� R� R� R� ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR[ � s2 t ScaleTestc B s� e Z d+ Z d Z d � Z d � Z d! � Z d" � Z d# � Z d$ � Z d% � Z
d& � Z d' � Z d( � Z
d) � Z d* � Z RS(, Rz R1 t bigincrementR2 R� R3 t digitsRW RX R� R5 R6 R7 Rr t lengtht orientR; R� R� t
resolutiont showvaluet sliderlengtht sliderreliefR� R= t tickintervalR� t troughcolorR� R? t verticalc K s t j | j | � S( N( R@ t ScaleRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR S s c C s) | j � } | j | d d d d � d S( NR� g������(@g������7@i����( R R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_bigincrementV s c C s& | j � } | j | d d d � d S( NR� i i ( R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_digitsZ s c C s/ | j � } | j | d d d d d t �d S( NR� id g������-@g333333.@R� ( R R t round( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR ^ s c C s6 | j � } | j | d d � | j | d d � d S( NRr s
any stringR" ( R RF ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_labelb s c C s, | j � } | j | d d d d d � d S( NR� i� gffffff`@g33333�`@t 5i( R Rv ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_lengthg s c C s, | j � } | j | d d d d d � d S( NR� g������@i g������@i����( R R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_resolutionk s c C s | j � } | j | d � d S( NR� ( R R
( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_showvalueo s c C s/ | j � } | j | d d d d d d � d S( NR� i
gffffff&@g333333/@i����t 3m( R Rv ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_sliderlengths s c C s | j � } | j | d � d S( NR� ( R R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_sliderreliefx s c C sQ | j � } | j | d d d d d d t �| j | d d d d d t �d S(
NR� i g333333@gffffff @i R� i����Ro i ( R R R� RF ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_tickinterval| s
c C s2 | j � } | j | d d d d d d t �d S( NR� i, g������-@g333333.@i����R� ( R R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � s ( Rz R1 R� R2 R� R3 R� RW RX R� R5 R6 R7 Rr R� R� R; R� R� R� R� R� R� R� R= R� R� R� R� R? ( R R. RS t default_orientR R� R� R R� R� R� R� R� R� R� R ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� F s( t
ScrollbarTestc B s\ e Z d Z e e � Z e Z d Z d � Z d � Z
d � Z d � Z d � Z
d � Z RS( Rz t activereliefR1 R2 R� R3 t elementborderwidthR5 R6 R7 t jumpR� R; R� R� R= R� R? R� c K s t j | j | � S( N( R@ t ScrollbarRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � s c C s | j � } | j | d � d S( NR� ( R R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_activerelief� s c C s, | j � } | j | d d d d d � d S( NR� g333333@gffffff@i����t 1m( R Rv ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_elementborderwidth� s c C s, | j � } | j | d d d d d �d S( NR� R� t
horizontalR s4 bad orientation "{}": must be vertical or horizontal( R Rj ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_orient� s c C sg | j � } x d D] } | j | � q W| j d � | j t | j � | j t | j d d � d S( Nt arrow1t slidert arrow2R" ( R� R� R� ( R t activateR� R ( R t sbR] ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_activate� s
c C s� | j � } | j d d � | j | j � d � | j t | j d d � | j t | j d d � | j t | j d d � | j t | j d � | j t | j d d d � d S( Ng�������?g�������?t abct defg333333�?gffffff�?g�������?( g�������?g�������?( R t setR R� R� R R� ( R R� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_set� s ( Rz R� R1 R2 R� R3 R� R5 R6 R7 R� R� R; R� R� R= R� R? ( R R. RS R� R
Rx R) RK R� R R� R� R� R� R� ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� � s t PanedWindowTestc B sg e Z d2 Z d Z d � Z d � Z d � Z d � Z d � Z e d d d � d � � Z
e d d d � d � � Z e d d d � d � � Z d � Z
d � Z d � Z d! � Z d" � Z d# � Z d$ � Z d% � Z e d& � Z d' � Z d( � Z d) � Z d* � Z e d d � d+ � � Z d, � Z d- � Z d. � Z d/ � Z e d d � d0 � � Z d1 � Z! RS(3 R1 R2 R3 t handlepadt
handlesizeR4 t opaqueresizeR� t proxybackgroundt proxyborderwidtht proxyreliefR; t
sashcursort sashpadt
sashrelieft sashwidtht
showhandleR? R� c K s t j | j | � S( N( R@ t PanedWindowRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � s c C s/ | j � } | j | d d d d d d � d S( NR� i g������@gffffff @i����R� ( R Rv ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_handlepad� s c
C s5 | j � } | j | d d d d d d d t �d S( NR� i g������"@g333333%@i����t 2mR� ( R Rv R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_handlesize� s c C s8 | j � } | j | d d d d d d d d t �d S( NR4 id g�����LY@gfffff�Y@i����i R> R� ( R Rv R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� � s !c C s | j � } | j | d � d S( NR� ( R R
( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_opaqueresize� s i i i c C s | j � } | j | d � d S( NR� ( R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_proxybackground� s c C s8 | j � } | j | d d d d d d d d t �d S( NR� i g�������?g333333@i i����Ru R� ( R Rv R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_proxyborderwidth� s c C s | j � } | j | d � d S( NR� ( R R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_proxyrelief� s c C s | j � } | j | d � d S( NR� ( R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_sashcursor� s c C s/ | j � } | j | d d d d d d � d S( NR� i g�������?g������@i����R� ( R Rv ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_sashpad� s c C s | j � } | j | d � d S( NR� ( R R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_sashrelief� s c
C s5 | j � } | j | d d d d d d d t �d S( NR� i
g333333&@g333333/@i����R� R� ( R Rv R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_sashwidth� s c C s | j � } | j | d � d S( NR� ( R R
( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_showhandle� s c C s8 | j � } | j | d d d d d d d d t �d S( NR? i� gfffff6y@g�����Iy@in���i R� R� ( R Rv R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� s !c C sQ | j � } t j | � } t j | � } | j | � | j | � | | | f S( N( R R@ R� t add( R t pR� R� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt create2 s
c C s� | j � \ } } } | j t | j � | j | � } | j | t � xl | j � D]^ \ } } | j t | � d � | j | | j | | � � | j | d | j | | � � qT Wd S( Ni i (
R� R� R t
paneconfigureRr Rs Rt R Rv t panecget( R R� R� R� Rz R{ R| ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_paneconfigure s c C s� d � } | j s | r( t | � } n | j r@ | r@ t } n | j | i | | 6� | j | | j | | � d � | � | j | | j | | � � | � d S( Nc S s | S( N( ( t x( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt <lambda> R" i ( R( R� R� R R� ( R R� R� Rm R� Ro t stringifyR� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt check_paneconfigure s &c C s4 | j t | � � | j | i d | 6� Wd QXd S( Nt badValue( Rn R R� ( R R� R� Rm t msg( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt check_paneconfigure_bad$ s c C sN | j � \ } } } | j | | d | t | � � | j | | d d � d S( Nt afters bad window path name "badValue"( R� R� R� R� ( R R� R� R� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_paneconfigure_after( s c C sN | j � \ } } } | j | | d | t | � � | j | | d d � d S( Nt befores bad window path name "badValue"( R� R� R� R� ( R R� R� R� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_paneconfigure_before. s c C sW | j � \ } } } | j | | d d d d t � d k �| j | | d d � d S( NR4 i
R� i i i s bad screen distance "badValue"( i i i ( R� R� R R� ( R R� R� R� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_paneconfigure_height4 s
c C sH | j � \ } } } | j | | d t d � | j | | d d � d S( Nt hidei s) expected boolean value but got "badValue"( R� R� t FalseR� ( R R� R� R� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_paneconfigure_hide; s c C sH | j � \ } } } | j | | d d d � | j | | d d � d S( Nt minsizei
s bad screen distance "badValue"( R� R� R� ( R R� R� R� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_paneconfigure_minsizeB s c C sH | j � \ } } } | j | | d d d � | j | | d d � d S( NR9 g�������?i s bad screen distance "badValue"( R� R� R� ( R R� R� R� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_paneconfigure_padxH s c C sH | j � \ } } } | j | | d d d � | j | | d d � d S( NR: g�������?i s bad screen distance "badValue"( R� R� R� ( R R� R� R� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_paneconfigure_padyN s c C sH | j � \ } } } | j | | d d d � | j | | d d � d S( Nt stickyt nsewt nesws[ bad stickyness value "badValue": must be a string containing zero or more of n, e, s, and w( R� R� R� ( R R� R� R� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_paneconfigure_stickyT s c C sH | j � \ } } } | j | | d d d � | j | | d d � d S( Nt stretcht alwt alwayssE bad stretch "badValue": must be always, first, last, middle, or never( R� R� R� ( R R� R� R� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_paneconfigure_stretch\ s c C sW | j � \ } } } | j | | d d d d t � d k �| j | | d d � d S( NR? i
R� i i i s bad screen distance "badValue"( i i i ( R� R� R R� ( R R� R� R� ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_paneconfigure_widthd s
( R1 R2 R3 R� R� R4 R� R� R� R� R� R; R� R� R� R� R� R? (" R R. RS R� R R� R� R� R� R R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR� � sH
t MenuTestc B se e Z d Z e Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d � Z d � Z
RS( Rz t activeborderwidthR{ R1 R2 R3 R RW RX t postcommandR; R� R= t tearofft tearoffcommandR t typec K s t j | j | � S( N( R@ RE RB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR w s c C s | j � } | j | d � d S( NR ( R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_postcommandz s c C s | j � } | j | d � d S( NR ( R R
( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_tearoff~ s c C s | j � } | j | d � d S( NR ( R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_tearoffcommand� s c C s# | j � } | j | d d � d S( NR s
any string( R RF ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt
test_title� s c C s) | j � } | j | d d d d � d S( NR R� R t menubar( R Rj ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_type� s c C s | j � } | j d d � | j t | j � | j t d � � | j d � Wd QX| j d � } | j | t � x� | j � D]v \ } } | j | t
� | j | t � | j t
| � d � | j | d | � | j | j d | � | d � q� W| j � d S( NRr t tests bad menu entry index "foo"Rn i i i i ( R t add_commandR� R t entryconfigureRn R Rr Rs Rt R� t tupleR Rv t entrycgetRq ( R t m1Rz R{ R| ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_entryconfigure� s $c C sk | j � } | j d d � | j | j d d � d � | j d d d �| j | j d d � d � d S( NRr R
i t changed( R R R R R ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_entryconfigure_label� s
c C s� | j � } t j | j � } t j | j � } | j d | d t d t d d � | j t | j d d � � t | � � | j
d d | �| j t | j d d � � t | � � d S( NR� R� R� Rr t Nonsensei ( R R@ t
BooleanVarRB t add_checkbuttonR) R� R R� R R ( R R t v1t v2( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_entryconfigure_variable� s (( Rz R R{ R1 R2 R3 R RW RX R R; R� R= R R R R ( R R. RS R Rx R R R R R
R R R R ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR l s t MessageTestc B s& e Z d Z e Z d � Z d � Z RS( R| t aspectR1 R2 R3 RW RX R5 R6 R7 R� R9 R: R; R= R[ R� R? c K s t j | j | � S( N( R@ t MessageRB ( R RC ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � s c C s) | j � } | j | d d d d � d S( NR i� i i���( R R� ( R R ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt test_aspect� s ( R| R R1 R2 R3 RW RX R5 R6 R7 R� R9 R: R; R= R[ R� R? ( R R. RS R R/ R R ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyR � s t __main__(1 R� t TkinterR@ R RI R� t test.test_supportR R t test_ttk.supportR R R R t widget_testsR R R R
R R R
R R R R t TestCaseR0 RT RV Rt Ry R� R� R� R� R� R� R� R RL R[ R� R� R� R R t tests_guiR ( ( ( s= /usr/lib64/python2.7/lib-tk/test/test_tkinter/test_widgets.pyt <module> sl "F
% ( A E h � B � B 1 � D Tkdnd.pyo 0000644 00000031031 15032720555 0006343 0 ustar 00 �
z fc @ sw d Z d d l Z d � Z d d d � � YZ d d
d � � YZ d d d � � YZ d
� Z e d k rs e � n d S( sF Drag-and-drop support for Tkinter.
This is very preliminary. I currently only support dnd *within* one
application, between different windows (or within the same window).
I am trying to make this as generic as possible -- not dependent on
the use of a particular widget or icon type, etc. I also hope that
this will work with Pmw.
To enable an object to be dragged, you must create an event binding
for it that starts the drag-and-drop process. Typically, you should
bind <ButtonPress> to a callback function that you write. The function
should call Tkdnd.dnd_start(source, event), where 'source' is the
object to be dragged, and 'event' is the event that invoked the call
(the argument to your callback function). Even though this is a class
instantiation, the returned instance should not be stored -- it will
be kept alive automatically for the duration of the drag-and-drop.
When a drag-and-drop is already in process for the Tk interpreter, the
call is *ignored*; this normally averts starting multiple simultaneous
dnd processes, e.g. because different button callbacks all
dnd_start().
The object is *not* necessarily a widget -- it can be any
application-specific object that is meaningful to potential
drag-and-drop targets.
Potential drag-and-drop targets are discovered as follows. Whenever
the mouse moves, and at the start and end of a drag-and-drop move, the
Tk widget directly under the mouse is inspected. This is the target
widget (not to be confused with the target object, yet to be
determined). If there is no target widget, there is no dnd target
object. If there is a target widget, and it has an attribute
dnd_accept, this should be a function (or any callable object). The
function is called as dnd_accept(source, event), where 'source' is the
object being dragged (the object passed to dnd_start() above), and
'event' is the most recent event object (generally a <Motion> event;
it can also be <ButtonPress> or <ButtonRelease>). If the dnd_accept()
function returns something other than None, this is the new dnd target
object. If dnd_accept() returns None, or if the target widget has no
dnd_accept attribute, the target widget's parent is considered as the
target widget, and the search for a target object is repeated from
there. If necessary, the search is repeated all the way up to the
root widget. If none of the target widgets can produce a target
object, there is no target object (the target object is None).
The target object thus produced, if any, is called the new target
object. It is compared with the old target object (or None, if there
was no old target widget). There are several cases ('source' is the
source object, and 'event' is the most recent event object):
- Both the old and new target objects are None. Nothing happens.
- The old and new target objects are the same object. Its method
dnd_motion(source, event) is called.
- The old target object was None, and the new target object is not
None. The new target object's method dnd_enter(source, event) is
called.
- The new target object is None, and the old target object is not
None. The old target object's method dnd_leave(source, event) is
called.
- The old and new target objects differ and neither is None. The old
target object's method dnd_leave(source, event), and then the new
target object's method dnd_enter(source, event) is called.
Once this is done, the new target object replaces the old one, and the
Tk mainloop proceeds. The return value of the methods mentioned above
is ignored; if they raise an exception, the normal exception handling
mechanisms take over.
The drag-and-drop processes can end in two ways: a final target object
is selected, or no final target object is selected. When a final
target object is selected, it will always have been notified of the
potential drop by a call to its dnd_enter() method, as described
above, and possibly one or more calls to its dnd_motion() method; its
dnd_leave() method has not been called since the last call to
dnd_enter(). The target is notified of the drop by a call to its
method dnd_commit(source, event).
If no final target object is selected, and there was an old target
object, its dnd_leave(source, event) method is called to complete the
dnd sequence.
Finally, the source object is notified that the drag-and-drop process
is over, by a call to source.dnd_end(target, event), specifying either
the selected target object, or None if no target object was selected.
The source object can use this to implement the commit action; this is
sometimes simpler than to do it in the target's dnd_commit(). The
target's dnd_commit() method could then simply be aliased to
dnd_leave().
At any time during a dnd sequence, the application can cancel the
sequence by calling the cancel() method on the object returned by
dnd_start(). This will call dnd_leave() if a target is currently
active; it will never call dnd_commit().
i����Nc C s$ t | | � } | j r | Sd Sd S( N( t
DndHandlert roott None( t sourcet eventt h( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyt dnd_startl s R c B sJ e Z d Z d � Z d � Z d � Z d � Z d d � Z d d � Z RS( c C s� | j d k r d S| j j � } y | j d SWn# t k
rV | | _ | | _ n X| | _ d | _ | j | _ } | j | _
} d | | f | _ | d p� d | _ | j
| j | j � | j
d | j � d | d <d S( Ni s <B%d-ButtonRelease-%d>t cursort s <Motion>t hand2( t numt widgett _roott _DndHandler__dndt AttributeErrorR R R t targett initial_buttont initial_widgett release_patternt save_cursort bindt
on_releaset on_motion( t selfR R R t buttonR ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyt __init__z s$
c C s= | j } d | _ | r9 y
| ` Wq9 t k
r5 q9 Xn d S( N( R R R
R ( R R ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyt __del__� s
c C s | j | j } } | j j | | � } | j } d } xM | r� y
| j } Wn t k
r` n X| | | � } | rz Pn | j } q: W| j } | | k r� | r� | j
| | � q� nD | r� d | _ | j | | � n | r� | j | | � | | _ n d S( N(
t x_roott y_rootR t winfo_containingR R t
dnd_acceptR t masterR t
dnd_motiont dnd_leavet dnd_enter( R R t xt yt
target_widgetR t
new_targett attrt
old_target( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyR � s.
c C s | j | d � d S( Ni ( t finish( R R ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyR � s c C s | j | d � d S( Ni ( R) ( R R ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyt cancel� s i c C s� | j } | j } | j } | j } z� | ` | j j | j � | j j d � | j | d <d | _ | _ | _ | _ | r� | r� | j | | � q� | j
| | � n Wd | j | | � Xd S( Ns <Motion>R ( R R R R R
t unbindR R R t
dnd_commitR! t dnd_end( R R t commitR R R R ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyR) � s
N(
t __name__t
__module__R R R R R R R* R) ( ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyR v s t Iconc B sV e Z d � Z d d d � Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c C s$ | | _ d | _ | _ | _ d S( N( t nameR t canvast labelt id( R R2 ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyR � s i
c C s� | | j k r, | j j | j | | � d S| j rB | j � n | sL d St j | d | j d d d d �} | j | | d | d d �} | | _ | | _ | | _ | j d | j
� d S(
Nt textt borderwidthi t relieft raisedt windowt anchort nws
<ButtonPress>( R3 t coordsR5 t detacht Tkintert LabelR2 t
create_windowR4 R t press( R R3 R# R$ R4 R5 ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyt attach� s
c C sW | j } | s d S| j } | j } d | _ | _ | _ | j | � | j � d S( N( R3 R5 R4 R t deletet destroy( R R3 R5 R4 ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyR> � s
c C sO t | | � rK | j | _ | j | _ | j j | j � \ | _ | _ n d S( N(
R R# t x_offR$ t y_offR3 R= R5 t x_origt y_orig( R R ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyRB � s c C s8 | j | j | � \ } } | j j | j | | � d S( N( t whereR3 R= R5 ( R R R# R$ ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyt move� s c C s# | j j | j | j | j � d S( N( R3 R= R5 RH RI ( R ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyt putback� s c C sJ | j � } | j � } | j | } | j | } | | j | | j f S( N( t winfo_rootxt winfo_rootyR R RF RG ( R R3 R t x_orgt y_orgR# R$ ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyRJ � s
c C s d S( N( ( R R R ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyR- s (
R/ R0 R RC R> RB RK RL RJ R- ( ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyR1 � s
t Testerc B s> e Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c C s_ t j | � | _ t j | j d d d d �| _ | j j d d d d � | j | j _ d S( Nt widthid t heightt fillt botht expandi ( R? t Toplevelt topt CanvasR3 t packR ( R R ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyR s !c C s | S( N( ( R R R ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyR s c C s� | j j � | j | j | � \ } } | j j | j � \ } } } } | | | | } }
| j j | | | | | |
� | _ | j | | � d S( N( R3 t focus_setRJ t bboxR5 t create_rectanglet dndidR ( R R R R# R$ t x1t y1t x2t y2t dxt dy( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyR" s
!&c C sa | j | j | � \ } } | j j | j � \ } } } } | j j | j | | | | � d S( N( RJ R3 R\ R^ RK ( R R R R# R$ R_ R` Ra Rb ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyR s !c C s- | j j � | j j | j � d | _ d S( N( RX R[ R3 RD R^ R ( R R R ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyR! $ s
c C sE | j | | � | j | j | � \ } } | j | j | | � d S( N( R! RJ R3 RC ( R R R R# R$ ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyR, ) s ( R/ R0 R R R" R R! R, ( ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyRQ s c C s� t j � } | j d � t j d | j d d � j � t | � } | j j d � t | � } | j j d � t | � } | j j d � t d � } t d � } t d
� } | j | j
� | j | j
� | j | j
� | j � d S( Ns +1+1t commandR6 t Quits +1+60s +120+60s +240+60t ICON1t ICON2t ICON3( R? t Tkt geometryt Buttont quitRZ RQ RX R1 RC R3 t mainloop( R t t1t t2t t3t i1t i2t i3( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyt test. s
t __main__( ( ( ( t __doc__R? R R R1 RQ Ru R/ ( ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyt <module>d s
Z<" Dialog.pyc 0000644 00000003600 15032720555 0006463 0 ustar 00 �
z fc @ s� d d l Td d l m Z e d k r/ d Z n d Z d e f d � � YZ d � Z e d k r� e d i d
d 6e d 6i e
6� Z e d i d
d 6e j d 6i e
6� Z
e j � n d S( i����( t *( t _cnfmergeg������ @t warningt questheadt Dialogc B s e Z d i d � Z d � Z RS( c
K s� t | | f � } d | _ t j | | | � | j j | j j d | j | d | d | d | d | d � � | _ y t j | � Wn t
k
r� n Xd S( Nt
__dialog__t tk_dialogt titlet textt bitmapt defaultt strings( R t
widgetNamet Widgett _setupt tkt getintt callt _wt numt destroyt TclError( t selft mastert cnft kw( ( s% /usr/lib64/python2.7/lib-tk/Dialog.pyt __init__
s
c C s d S( N( ( R ( ( s% /usr/lib64/python2.7/lib-tk/Dialog.pyR t N( t __name__t
__module__t NoneR R ( ( ( s% /usr/lib64/python2.7/lib-tk/Dialog.pyR s c C s> t d i d d 6d d 6t d 6d d 6d d 6� } | j GHd S(
Ns
File ModifiedR sz File "Python.h" has been modified since the last time it was saved. Do you want to save it before exiting the application.R R i R
s Save Files Discard Changess Return to EditorR ( s Save Files Discard Changess Return to Editor( R R t DIALOG_ICONR ( t d( ( s% /usr/lib64/python2.7/lib-tk/Dialog.pyt _test s
t __main__t TestR t commandt QuitN( t TkinterR t TkVersionR R
R R! R t ButtonR t Packt tt quitt qt mainloop( ( ( s% /usr/lib64/python2.7/lib-tk/Dialog.pyt <module> s
SimpleDialog.pyc 0000644 00000010363 15032720555 0007641 0 ustar 00 �
z fc @ sF d Z d d l Td d d � � YZ e d k rB d � Z e � n d S( s' A simple but flexible modal dialog box.i����( t *t SimpleDialogc B sV e Z d g d d d d d � Z d d d � Z d � Z d � Z d � Z d � Z RS(
t c C s� | r t | d | �| _ n t | � | _ | rV | j j | � | j j | � n t | j d | d d �| _ | j j d d d t � t | j � | _ | j j � | | _
| | _ | | _ | j j
d | j � x� t t | � � D]u } | | } t | j d | d | | d
� �}
| | k rI|
j d t d d
� n |
j d t d t d d � q� W| j j d | j � | j | � d S( Nt class_t textt aspecti� t expandi t fills <Return>t commandc S s
| j | � S( N( t done( t selft num( ( s+ /usr/lib64/python2.7/lib-tk/SimpleDialog.pyt <lambda> R t relieft borderwidthi t sidet WM_DELETE_WINDOW( t Toplevelt roott titlet iconnamet Messaget messaget packt BOTHt Framet frameR t cancelt defaultt bindt return_eventt ranget lent Buttont configt RIDGEt LEFTt protocolt wm_delete_windowt _set_transient( R
t masterR t buttonsR R R R R t st b( ( s+ /usr/lib64/python2.7/lib-tk/SimpleDialog.pyt __init__ s.
g �?g333333�?c
C sh | j } | j � | j | � | j � | j � ri | j � } | j � } | j � } | j � } n" | j � } | j
� } d } } | j � } | j � }
| | | | } | | |
| } | | | j � k r� | j � | } n | d k rd } n | |
| j
� k r.| j
� |
} n | d k rCd } n | j
d | | f � | j � d S( Ni s +%d+%d( R t withdrawt transientt update_idletaskst winfo_ismappedt winfo_widtht winfo_heightt winfo_rootxt winfo_rootyt winfo_screenwidtht winfo_screenheightt winfo_reqwidtht winfo_reqheightt geometryt deiconify(
R
R( t relxt relyt widgett m_widtht m_heightt m_xt m_yt w_widtht w_heightt xt y( ( s+ /usr/lib64/python2.7/lib-tk/SimpleDialog.pyR' % s4
c C s; | j j � | j j � | j j � | j j � | j S( N( R t wait_visibilityt grab_sett mainloopt destroyR ( R
( ( s+ /usr/lib64/python2.7/lib-tk/SimpleDialog.pyt goB s
c C s3 | j d k r | j j � n | j | j � d S( N( R t NoneR t bellR ( R
t event( ( s+ /usr/lib64/python2.7/lib-tk/SimpleDialog.pyR I s c C s3 | j d k r | j j � n | j | j � d S( N( R RK R RL R ( R
( ( s+ /usr/lib64/python2.7/lib-tk/SimpleDialog.pyR& O s c C s | | _ | j j � d S( N( R R t quit( R
R ( ( s+ /usr/lib64/python2.7/lib-tk/SimpleDialog.pyR U s N( t __name__t
__module__RK R, R' RJ R R& R ( ( ( s+ /usr/lib64/python2.7/lib-tk/SimpleDialog.pyR s t __main__c C sj t � } | d � } t | d d d | �} | j � t | d d d | j �} | j � | j � d S( Nc S sB t | d d d d d d g d d d d
d d �} | j � GHd S(
NR s� This is a test dialog. Would this have been an actual dialog, the buttons below would have been glowing in soft pink light.
Do you believe this?R) t Yest Not CancelR i R i R s Test Dialog( R RJ ( R t d( ( s+ /usr/lib64/python2.7/lib-tk/SimpleDialog.pyt doit^ s R t TestR t Quit( t TkR! R RN RH ( R RV t tt q( ( s+ /usr/lib64/python2.7/lib-tk/SimpleDialog.pyt test\ s
N( ( t __doc__t TkinterR RO R\ ( ( ( s+ /usr/lib64/python2.7/lib-tk/SimpleDialog.pyt <module> s
S Tkinter.pyo 0000644 00000606777 15032720555 0006750 0 ustar 00 �
z fc @ s� d Z d Z d d l Z e j d k r6 d d l Z n d d l Z e Z e j Z d d l Td d l Td d l
Z
d Z e e j
� Z e e j � Z e j Z e j Z e j Z y e j Wn e k
r� e e _ n Xy e j Wn e k
r� e e _ n Xe
j d � Z e
j d � Z d � Z d
� Z d � Z y
e j Z Wn e k
rYn Xd � Z y
e j Z Wn e k
r�n Xe e d
� Z d f d � � YZ! d a" e a# d � Z$ d � Z% d d � Z& d a' d f d � � YZ( d e( f d � � YZ) d e( f d � � YZ* d e( f d � � YZ+ d e( f d � � YZ, d d � Z- e. Z/ e Z0 d � Z1 d f d! � � YZ2 d" f d# � � YZ3 d$ f d% � � YZ4 d& f d' � � YZ5 d( f d) � � YZ6 d* e2 e6 f d+ � � YZ7 e e d* d d, � Z8 d- f d. � � YZ9 d/ f d0 � � YZ: d1 f d2 � � YZ; d3 e2 f d4 � � YZ< d5 e< e9 e: e; f d6 � � YZ= d7 e< e6 f d8 � � YZ> d9 e= f d: � � YZ? d; � Z@ d< � ZA d= � ZB d> � ZC e d? � ZD d@ e= e4 e5 f dA � � YZE dB e= f dC � � YZF dD e= e4 f dE � � YZG dF e= f dG � � YZH dH e= f dI � � YZI dJ e= e4 e5 f dK � � YZJ dL e= f dM � � YZK dN e= f dO � � YZL dP e= f dQ � � YZM dR e= f dS � � YZN dT e= f dU � � YZO dV e= f dW � � YZP dX e= e4 e5 f dY � � YZQ dZ f d[ � � YZR d\ eL f d] � � YZS d^ f d_ � � YZT d` eT f da � � YZU db eT f dc � � YZV dd � ZW de � ZX df e= e4 f dg � � YZY dh e= f di � � YZZ dj e= f dk � � YZ[ dl e? f dm � � YZ\ dn e? f do � � YZ] dp � Z^ e_ dq k r�e^ � n d S(r s2 Wrapper functions for Tcl/Tk.
Tkinter provides classes which allow the display, positioning and
control of widgets. Toplevel widgets are Tk and Toplevel. Other
widgets are Frame, Label, Entry, Text, Canvas, Button, Radiobutton,
Checkbutton, Scale, Listbox, Scrollbar, OptionMenu, Spinbox
LabelFrame and PanedWindow.
Properties of the widgets are specified with keyword arguments.
Keyword arguments have the same name as the corresponding resource
under Tk.
Widgets are positioned with one of the geometry managers Place, Pack
or Grid. These managers can be called with methods place, pack, grid
available in every Widget.
Actions are bound to events by resources (e.g. keyword argument
command) or with the method bind.
Example (Hello, World):
import Tkinter
from Tkconstants import *
tk = Tkinter.Tk()
frame = Tkinter.Frame(tk, relief=RIDGE, borderwidth=2)
frame.pack(fill=BOTH,expand=1)
label = Tkinter.Label(frame, text="Hello, World")
label.pack(fill=X, expand=1)
button = Tkinter.Button(frame,text="Exit",command=tk.destroy)
button.pack(side=BOTTOM)
tk.mainloop()
s $Revision: 81008 $i����Nt win32( t *i s ([\\{}])s ([\s])c C s d j t t | � � S( s Internal function.t ( t joint mapt
_stringify( t value( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _joinA s c C sL t | t t f � ri t | � d k rV t | d � } t j | � rf d | } qf qHd t | � } n� t | t � r� t | d � } n t | t � s� t | � } n | s� d } n� t j | � r t j
d | � } | j d d � } t j
d | � } | d d k rHd
| } qHn, | d d k s;t j | � rHd | } n | S( s Internal function.i i s {%s}s utf-8s {}s \\\1s
s \nt "s \(
t
isinstancet listt tuplet lenR t _magic_ret searchR t strt unicodet subt replacet _space_re( R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR E s*
c C sb d } xU | D]M } t | � t t f k r> | t | � } q
| d k r
| | f } q
q
W| S( s Internal function.( N( t typet TupleTypet ListTypet _flattent None( R t rest item( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR ` s
c C s� t | � t k r | St | � t t f k r2 | Si } xq t | � D]c } y | j | � WqE t t f k
r� } d G| GHx( | j � D] \ } } | | | <q� WqE XqE W| Sd S( s Internal function.s _cnfmerge: fallback due to:N( R t DictionaryTypet NoneTypet
StringTypeR t updatet AttributeErrort TypeErrort items( t cnfst cnft ct msgt kt v( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _cnfmergem s c C s� | j | � } t | � d r. t d � � n t | � } i } xk t | | � D]Z \ } } t | � } | r� | d d k r� | d } n | r� | | � } n | | | <qP W| S( s Return a properly formatted dict built from Tcl list pairs.
If cut_minus is True, the supposed '-' prefix will be removed from
keys. If conv is specified, it is used to convert values.
Tcl list is expected to contain an even number of elements.
i sN Tcl list representing a dict is expected to contain an even number of elementsi t -i ( t splitlistR t RuntimeErrort itert zipR ( t tkR' t cut_minust convt tt itt dictt keyR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
_splitdict� s
t Eventc B s e Z d Z RS( s� Container for the properties of an event.
Instances of this type are generated if one of the following events occurs:
KeyPress, KeyRelease - for keyboard events
ButtonPress, ButtonRelease, Motion, Enter, Leave, MouseWheel - for mouse events
Visibility, Unmap, Map, Expose, FocusIn, FocusOut, Circulate,
Colormap, Gravity, Reparent, Property, Destroy, Activate,
Deactivate - for window events.
If a callback function for one of these events is registered
using bind, bind_all, bind_class, or tag_bind, the callback is
called with an Event as first argument. It will have the
following attributes (in braces are the event types for which
the attribute is valid):
serial - serial number of event
num - mouse button pressed (ButtonPress, ButtonRelease)
focus - whether the window has the focus (Enter, Leave)
height - height of the exposed window (Configure, Expose)
width - width of the exposed window (Configure, Expose)
keycode - keycode of the pressed key (KeyPress, KeyRelease)
state - state of the event as a number (ButtonPress, ButtonRelease,
Enter, KeyPress, KeyRelease,
Leave, Motion)
state - state as a string (Visibility)
time - when the event occurred
x - x-position of the mouse
y - y-position of the mouse
x_root - x-position of the mouse on the screen
(ButtonPress, ButtonRelease, KeyPress, KeyRelease, Motion)
y_root - y-position of the mouse on the screen
(ButtonPress, ButtonRelease, KeyPress, KeyRelease, Motion)
char - pressed character (KeyPress, KeyRelease)
send_event - see X/Windows documentation
keysym - keysym of the event as a string (KeyPress, KeyRelease)
keysym_num - keysym of the event as a number (KeyPress, KeyRelease)
type - type of the event as a number
widget - widget in which the event occurred
delta - delta of wheel movement (MouseWheel)
( t __name__t
__module__t __doc__( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR6 � s )c C s d a d a b d S( s� Inhibit setting of default root window.
Call this function to inhibit that the first instance of
Tk is used for windows without an explicit parent window.
i N( t _support_default_rootR t
_default_root( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
NoDefaultRoot� s c C s d S( s Internal function.N( ( t err( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _tkerror� s i c C s1 y t | � } Wn t k
r# n Xt | � d S( sB Internal function. Calling it will raise the exception SystemExit.N( t intt
ValueErrort
SystemExit( t code( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _exit� s
t Variablec B sz e Z d Z d Z d Z d d d d � Z d � Z d � Z d � Z d � Z
d � Z e Z d � Z
d � Z d
� Z RS( s� Class to define value holders for e.g. buttons.
Subclasses StringVar, IntVar, DoubleVar, BooleanVar are specializations
that constrain the type of the value returned from get().t c C s� | s t } n | j � | _ | j | _ | r< | | _ n d t t � | _ t d 7a | d k ru | j | � n: | j j | j j
d d | j � � s� | j | j � n d S( s. Construct a variable
MASTER can be given as master widget.
VALUE is an optional value (defaults to "")
NAME is an optional Tcl name (defaults to PY_VARnum).
If NAME matches an existing variable and VALUE is omitted
then the existing value is retained.
t PY_VARi t infot existsN( R; t _rootR. t _tkt _namet reprt _varnumR t sett
getbooleant callt _default( t selft masterR t name( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt __init__� s
'c C s� | j d k r d S| j j | j j d d | j � � rP | j j | j � n | j d k r� x! | j D] } | j j | � qi Wd | _ n d S( s Unset the variable in Tcl.NRG RH ( RJ R RO RP RK t globalunsetvart _tclCommandst
deletecommand( RR RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt __del__� s 'c C s | j S( s' Return the name of the variable in Tcl.( RK ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt __str__
s c C s | j j | j | � S( s Set the variable to VALUE.( RJ t globalsetvarRK ( RR R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRN
s c C s | j j | j � S( s Return value of variable.( RJ t globalgetvarRK ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt get s c C s� t | d | j � j } t t | � � } y
| j } Wn t k
rJ n Xy | | j } Wn t k
ro n X| j j
| | � | j d k r� g | _ n | j j | � | j j
d d | j | | � | S( s
Define a trace callback for the variable.
MODE is one of "r", "w", "u" for read, write, undefine.
CALLBACK must be a function which is called when
the variable is read, written or undefined.
Return the name of the callback.
t tracet variableN( t CallWrapperR RI t __call__RL t idt im_funcR R7 RJ t
createcommandRW t appendRP RK ( RR t modet callbackt ft cbname( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt trace_variable s
c C s� | j j d d | j | | � | j j | � d } xr | j � D], \ } } | j j | � d | k rB PqB qB W| j j | � y | j j | � Wn t k
r� n Xd S( s� Delete the trace callback for a variable.
MODE is one of "r", "w", "u" for read, write, undefine.
CBNAME is the name of the callback returned from trace_variable or trace.
R^ t vdeletei N( RJ RP RK R* t trace_vinfoRX RW t removeR@ ( RR Rf Ri t mt ca( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
trace_vdelete- s
c C s4 t | j j | j j | j j d d | j � � � S( s& Return all trace callback information.R^ t vinfo( R RJ R* RP RK ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRl > s c C s( | j j | j j k o' | j | j k S( s� Comparison for equality (==).
Note: if the Variable's master matters to behavior
also compare self._master == other._master
( t __class__R7 RK ( RR t other( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt __eq__B s N( R7 R8 R9 RQ R RW RU RY RZ RN R] Rj R^ Rp Rl Rt ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRD � s t StringVarc B s/ e Z d Z d Z d d d d � Z d � Z RS( s# Value holder for strings variables.RE c C s t j | | | | � d S( s6 Construct a string variable.
MASTER can be given as master widget.
VALUE is an optional value (defaults to "")
NAME is an optional Tcl name (defaults to PY_VARnum).
If NAME matches an existing variable and VALUE is omitted
then the existing value is retained.
N( RD RU ( RR RS R RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU N s
c C s2 | j j | j � } t | t � r( | St | � S( s# Return value of variable as string.( RJ R\ RK R t
basestringR ( RR R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR] Z s N( R7 R8 R9 RQ R RU R] ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRu K s t IntVarc B s8 e Z d Z d Z d d d d � Z d � Z d � Z RS( s# Value holder for integer variables.i c C s t j | | | | � d S( s7 Construct an integer variable.
MASTER can be given as master widget.
VALUE is an optional value (defaults to 0)
NAME is an optional Tcl name (defaults to PY_VARnum).
If NAME matches an existing variable and VALUE is omitted
then the existing value is retained.
N( RD RU ( RR RS R RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU d s
c C s. t | t � r t | � } n t j | | � S( s; Set the variable to value, converting booleans to integers.( R t boolR? RD RN ( RR R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRN p s c C s t | j j | j � � S( s/ Return the value of the variable as an integer.( t getintRJ R\ RK ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR] v s N( R7 R8 R9 RQ R RU RN R] ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRw a s
t DoubleVarc B s/ e Z d Z d Z d d d d � Z d � Z RS( s! Value holder for float variables.g c C s t j | | | | � d S( s6 Construct a float variable.
MASTER can be given as master widget.
VALUE is an optional value (defaults to 0.0)
NAME is an optional Tcl name (defaults to PY_VARnum).
If NAME matches an existing variable and VALUE is omitted
then the existing value is retained.
N( RD RU ( RR RS R RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU } s
c C s t | j j | j � � S( s, Return the value of the variable as a float.( t getdoubleRJ R\ RK ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR] � s N( R7 R8 R9 RQ R RU R] ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRz z s t
BooleanVarc B s8 e Z d Z e Z d d d d � Z d � Z d � Z RS( s# Value holder for boolean variables.c C s t j | | | | � d S( s: Construct a boolean variable.
MASTER can be given as master widget.
VALUE is an optional value (defaults to False)
NAME is an optional Tcl name (defaults to PY_VARnum).
If NAME matches an existing variable and VALUE is omitted
then the existing value is retained.
N( RD RU ( RR RS R RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU � s
c C s" | j j | j | j j | � � S( s Set the variable to VALUE.( RJ R[ RK RO ( RR R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRN � s c C s | j j | j j | j � � S( s+ Return the value of the variable as a bool.( RJ RO R\ RK ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR] � s N( R7 R8 R9 t FalseRQ R RU RN R] ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR| � s
c C s t j j | � d S( s Run the main loop of Tcl.N( R; R. t mainloop( t n( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR~ � s c C s t j j | � S( s1 Convert true and false to integer values 1 and 0.( R; R. RO ( t s( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRO � s t Miscc B sD e Z d Z d� Z d � Z d � Z d� d � Z d � Z d � Z d � Z
d d � Z e Z d� d � Z
d� d
� Z d d d � Z d d
� Z e Z e Z d � Z d � Z e Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d� d � Z d � Z d � Z! d d � Z" d � Z# d � Z$ d � Z% d � Z& d � Z' d! � Z( d" � Z) d# � Z* d� d$ � Z+ d% � Z, d& � Z- d� d' � Z. d( � Z/ d) � Z0 d* � Z1 d+ � Z2 d, � Z3 d- � Z4 d� d. � Z5 d� d/ � Z6 e6 Z7 d� d0 � Z8 d d1 � Z9 d d2 � Z: d3 � Z; d4 � Z< d5 � Z= d6 � Z> d d7 � Z? d8 � Z@ d9 � ZA d: � ZB d; � ZC d< � ZD d= � ZE d d> � ZF d? � ZG d@ � ZH dA � ZI dB � ZJ d dC � ZK dD � ZL dE � ZM dF � ZN dG � ZO dH � ZP dI � ZQ dJ � ZR dK � ZS dL � ZT dM � ZU dN � ZV dO � ZW dP � ZX dQ � ZY dR � ZZ dS � Z[ dT � Z\ dU � Z] dV � Z^ dW � Z_ dX � Z` dY � Za d dZ � Zb d[ � Zc d\ � Zd d] � Ze d^ � Zf d_ � Zg d` � Zh da � Zi db � Zj dc � Zk dd � Zl de � Zm d� df � Zn dg dh � Zo d� d� d� di � Zp d� dj � Zq d� d� d� dk � Zr dl � Zs d� d� d� dm � Zt dn � Zu d do � Zv dp � Zw dq � Zx dr � Zy ds � Zz dt � Z{ e| du � � Z} d� dv � Z~ dw � Z e Z� d� dg dx � Z� e� Z� dy � Z� d� Z� d� j� e� � Z� d� � Z� d� � Z� d� � Z� d� � Z� d� � Z� d� d� � Z� e� Z� d� � Z� e� Z� d� � Z� d� � Z� d� � Z� d� � Z� d� g Z� e� d� � Z� e� Z� d� � Z� e� Z� d� � Z� d� d� d� d� d� � Z� e� Z� d� � Z� d� � Z� i d� � Z� e� Z� d� � Z� e� d� � Z� i d� � Z� e� Z� d� � Z� e� Z� d� d� d� � Z� d� � Z� d� � Z� d� � Z� d� d� � Z� d� � Z� d� � Z� RS(� sR Internal class.
Base class which defines methods common for interior widgets.c C sC | j d k r? x! | j D] } | j j | � q Wd | _ n d S( sk Internal function.
Delete all Tcl commands created for
this widget in the Tcl interpreter.N( RW R R. RX ( RR RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt destroy� s c C s< | j j | � y | j j | � Wn t k
r7 n Xd S( sD Internal function.
Delete the Tcl command provided in NAME.N( R. RX RW Rm R@ ( RR RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRX � s
c C s" | j j | j j d d | � � S( s� Set Tcl internal variable, whether the look and feel
should adhere to Motif.
A parameter of 1 means adhere to Motif (e.g. no color
change if mouse passes over slider).
Returns the set value.RN t tk_strictMotif( R. RO RP ( RR t boolean( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s | j j d � d S( sD Change the color scheme to light brown as used in Tk 3.6 and before.t tk_bisqueN( R. RP ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c O s. | j j d t | � t | j � � � d S( s Set a new color scheme for all widget elements.
A single color as argument will cause that all colors of Tk
widget elements are derived from this.
Alternatively several keyword parameters and its associated
colors can be given. The following keywords are valid:
activeBackground, foreground, selectColor,
activeForeground, highlightBackground, selectBackground,
background, highlightColor, selectForeground,
disabledForeground, insertBackground, troughColor.t
tk_setPaletteN( R� ( R. RP R R! ( RR t argst kw( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c G s& d d l } | j d t d d �d S( s) Do not use. Needed in Tk 3.6 and earlier.i����Ns4 tk_menuBar() does nothing and will be removed in 3.6t
stackleveli ( t warningst warnt DeprecationWarning( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
tk_menuBar� s RF c C s | j j d d | � d S( s� Wait until the variable is modified.
A parameter of type IntVar, StringVar, DoubleVar or
BooleanVar must be given.t tkwaitR_ N( R. RP ( RR RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
wait_variable� s c C s2 | d k r | } n | j j d d | j � d S( sQ Wait until a WIDGET is destroyed.
If no parameter is given self is used.R� t windowN( R R. RP t _w( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wait_window� s c C s2 | d k r | } n | j j d d | j � d S( sx Wait until the visibility of a WIDGET changes
(e.g. it appears).
If no parameter is given self is used.R� t
visibilityN( R R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wait_visibility� s t 1c C s | j j | | � d S( s Set Tcl variable NAME to VALUE.N( R. t setvar( RR RT R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� s c C s | j j | � S( s" Return value of Tcl variable NAME.( R. t getvar( RR RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� s c C s | j j | � S( sP Return a boolean value for Tcl boolean values true and false given as parameter.( R. RO ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRO s c C s | j j d | j � d S( s� Direct input focus to this widget.
If the application currently does not have the focus
this widget will get the focus if the application gets
the focus through the window manager.t focusN( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt focus_set s c C s | j j d d | j � d S( st Direct input focus to this widget even if the
application does not have the focus. Use with
caution!R� s -forceN( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt focus_force s c C s6 | j j d � } | d k s% | r) d S| j | � S( s� Return the widget which has currently the focus in the
application.
Use focus_displayof to allow working with several
displays. Return None if application does not have
the focus.R� t noneN( R. RP R t
_nametowidget( RR RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt focus_get s c C s? | j j d d | j � } | d k s. | r2 d S| j | � S( s� Return the widget which has currently the focus on the
display where this widget is located.
Return None if the application does not have the focus.R� s
-displayofR� N( R. RP R� R R� ( RR RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt focus_displayof# s c C s? | j j d d | j � } | d k s. | r2 d S| j | � S( sy Return the widget which would have the focus if top level
for this widget gets the focus from the window manager.R� s -lastforR� N( R. RP R� R R� ( RR RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
focus_lastfor+ s c C s | j j d � d S( sX The widget under mouse will get automatically focus. Can not
be disabled easily.t tk_focusFollowsMouseN( R. RP ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� 1 s c C s/ | j j d | j � } | s" d S| j | � S( sn Return the next widget in the focus order which follows
widget which has currently the focus.
The focus order first goes to the next child, then to
the children of the child recursively and then to the
next sibling which is higher in the stacking order. A
widget is omitted if it has the takefocus resource set
to 0.t tk_focusNextN( R. RP R� R R� ( RR RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� 5 s c C s/ | j j d | j � } | s" d S| j | � S( sH Return previous widget in the focus order. See tk_focusNext for details.t tk_focusPrevN( R. RP R� R R� ( RR RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� A s c sj � s � j j d | � d S� � � � f d � } � j | _ � j | � � � j j d | � � Sd S( s Call function once after given time.
MS specifies the time in milliseconds. FUNC gives the
function which shall be called. Additional parameters
are given as parameters to the function call. Return
identifier to cancel scheduling with after_cancel.t afterc s; z � � � Wd y � j � � Wn t k
r5 n XXd S( N( RX t TclError( ( R� t funcRT RR ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt callitR s
N( R. RP R R7 t _register( RR t msR� R� R� ( ( R� R� RT RR s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� F s c G s | j d | | � S( s� Call FUNC once if the Tcl main loop has no event to
process.
Return an identifier to cancel the scheduling with
after_cancel.t idle( R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
after_idle] s c C s� | s t d � � n y? | j j d d | � } | j j | � d } | j | � Wn t k
rg n X| j j d d | � d S( s� Cancel scheduling of function identified with ID.
Identifier returned by after or after_idle must be
given as first parameter.
s? id must be a valid identifier returned from after or after_idleR� RG i t cancelN( R@ R. RP R* RX R� ( RR Rb t datat script( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt after_canceld s
i c C s! | j j d | j | � � d S( s Ring a display's bell.t bellN( R� ( R. RP t
_displayof( RR t displayof( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� t s c K s� d | k rd | j d k rd y+ d | d <| j j d | j | � � SWqd t k
r` | d =qd Xn | j j d | j | � � S( s� Retrieve data from the clipboard on window's display.
The window keyword defaults to the root window of the Tkinter
application.
The type keyword specifies the form in which the data is
to be returned and should be an atom name such as STRING
or FILE_NAME. Type defaults to STRING, except on X11, where the default
is to try UTF8_STRING and fall back to STRING.
This command is equivalent to:
selection_get(CLIPBOARD)
R t x11t UTF8_STRINGt clipboardR] ( R� R] ( R� R] ( t _windowingsystemR. RP t _optionsR� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
clipboard_gety s
!
c K s= d | k r | j | d <n | j j d | j | � � d S( s� Clear the data in the Tk clipboard.
A widget specified for the optional displayof keyword
argument specifies the target display.R� R� t clearN( R� R� ( R� R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt clipboard_clear� s c K sG d | k r | j | d <n | j j d | j | � d | f � d S( s� Append STRING to the Tk clipboard.
A widget specified at the optional displayof keyword
argument specifies the target display. The clipboard
can be retrieved with selection_get.R� R� Re s --N( R� Re ( R� R. RP R� ( RR t stringR� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt clipboard_append� s c C s2 | j j d d | j � } | s% d S| j | � S( sO Return widget which has currently the grab in this application
or None.t grabt currentN( R. RP R� R R� ( RR RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grab_current� s c C s | j j d d | j � d S( s. Release grab for this widget if currently set.R� t releaseN( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grab_release� s c C s | j j d d | j � d S( sw Set grab for this widget.
A grab directs all events to this and descendant
widgets in the application.R� RN N( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grab_set� s c C s | j j d d d | j � d S( s� Set global grab for this widget.
A global grab directs all events to this and
descendant widgets on the display. Use with caution -
other applications do not get events anymore.R� RN s -globalN( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grab_set_global� s c C s4 | j j d d | j � } | d k r0 d } n | S( sY Return None, "local" or "global" if this widget has
no, a local or a global grab.R� t statusR� N( R. RP R� R ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grab_status� s c C s | j j d d | | | � d S( s� Set a VALUE (second parameter) for an option
PATTERN (first parameter).
An optional third parameter gives the numeric priority
(defaults to 80).t optiont addN( R. RP ( RR t patternR t priority( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
option_add� s c C s | j j d d � d S( sP Clear the option database.
It will be reloaded if option_add is called.R� R� N( R. RP ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt option_clear� s c C s | j j d d | j | | � S( s� Return the value for an option NAME for this widget
with CLASSNAME.
Values with higher priority override lower values.R� R] ( R. RP R� ( RR RT t className( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
option_get� s c C s | j j d d | | � d S( sv Read file FILENAME into the option database.
An optional second parameter gives the numeric
priority.R� t readfileN( R. RP ( RR t fileNameR� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt option_readfile� s c K s= d | k r | j | d <n | j j d | j | � � d S( s Clear the current X selection.R� t selectionR� N( R� R� ( R� R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt selection_clear� s c K s� d | k r | j | d <n d | k r� | j d k r� y+ d | d <| j j d | j | � � SWq� t k
r| | d =q� Xn | j j d | j | � � S( s� Return the contents of the current X selection.
A keyword parameter selection specifies the name of
the selection and defaults to PRIMARY. A keyword
parameter displayof specifies a widget on the display
to use. A keyword parameter type specifies the form of data to be
fetched, defaulting to STRING except on X11, where UTF8_STRING is tried
before STRING.R� R R� R� R� R] ( R� R] ( R� R] ( R� R� R. RP R� R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
selection_get� s
!
c K s= | j | � } | j j d | j | � | j | f � d S( s Specify a function COMMAND to call if the X
selection owned by this widget is queried by another
application.
This function must return the contents of the
selection. The function will be called with the
arguments OFFSET and LENGTH which allows the chunking
of very long selections. The following keyword
parameters can be provided:
selection - name of the selection (default PRIMARY),
type - type of the selection (e.g. STRING, FILE_NAME).R� t handleN( R� R� ( R� R. RP R� R� ( RR t commandR� RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt selection_handle� s c K s+ | j j d | j | � | j f � d S( s� Become owner of X selection.
A keyword parameter selection specifies the name of
the selection (default PRIMARY).R� t ownN( R� R� ( R. RP R� R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
selection_own� s c K sR d | k r | j | d <n | j j d | j | � � } | sE d S| j | � S( s� Return owner of X selection.
The following keyword parameter can
be provided:
selection - name of the selection (default PRIMARY),
type - type of the selection (e.g. STRING, FILE_NAME).R� R� R� ( R� R� N( R� R. RP R� R R� ( RR R� RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt selection_own_get s c G s | j j d | | f | � S( sD Send Tcl command CMD to different interpreter INTERP to be executed.t send( R. RP ( RR t interpt cmdR� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� s c C s | j j d | j | � d S( s( Lower this widget in the stacking order.t lowerN( R. RP R� ( RR t belowThis( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� s c C s | j j d | j | � d S( s( Raise this widget in the stacking order.t raiseN( R. RP R� ( RR t aboveThis( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt tkraise s c C s | j j d d | j | � S( s Useless. Not implemented in Tk.R. t
colormodel( R. RP R� ( RR R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� s c C s0 d | j | � | f } t | j j | � � S( s* Return integer which represents atom NAME.t winfot atom( R� R� ( R� Ry R. RP ( RR RT R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
winfo_atom s c C s* d | j | � | f } | j j | � S( s' Return name of atom with identifier ID.R� t atomname( R� R� ( R� R. RP ( RR Rb R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_atomname s c C s t | j j d d | j � � S( s7 Return number of cells in the colormap for this widget.R� t cells( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_cells! s c C sj g } x] | j j | j j d d | j � � D]4 } y | j | j | � � Wq. t k
ra q. Xq. W| S( s? Return a list of all widgets which are children of this widget.R� t children( R. R* RP R� Re R� t KeyError( RR t resultt child( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_children% s "
c C s | j j d d | j � S( s( Return window class name of this widget.R� t class( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_class2 s c C s% | j j | j j d d | j � � S( s? Return true if at the last color request the colormap was full.R� t colormapfull( R. RO RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_colormapfull5 s c C sF d | j | � | | f } | j j | � } | s9 d S| j | � S( s@ Return the widget which is at the root coordinates ROOTX, ROOTY.R� t
containing( R� R� N( R� R. RP R R� ( RR t rootXt rootYR� R� RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_containing9 s
c C s t | j j d d | j � � S( s$ Return the number of bits per pixel.R� t depth( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_depth@ s c C s t | j j d d | j � � S( s" Return true if this widget exists.R� RH ( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_existsC s c C s" t | j j d d | j | � � S( sW Return the number of pixels for the given distance NUMBER
(e.g. "3c") as float.R� t fpixels( R{ R. RP R� ( RR t number( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
winfo_fpixelsG s c C s | j j d d | j � S( sF Return geometry string for this widget in the form "widthxheight+X+Y".R� t geometry( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_geometryL s c C s t | j j d d | j � � S( s Return height of this widget.R� t height( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_heightO s c C s" t | j j d d | j � d � S( s% Return identifier ID for this widget.R� Rb i ( R? R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_idS s c C s/ d | j | � } | j j | j j | � � S( s9 Return the name of all Tcl interpreters for this display.R� t interps( R� R ( R� R. R* RP ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
winfo_interpsV s c C s t | j j d d | j � � S( s% Return true if this widget is mapped.R� t ismapped( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_ismappedZ s c C s | j j d d | j � S( s/ Return the window manager name for this widget.R� t manager( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
winfo_manager^ s c C s | j j d d | j � S( s Return the name of this widget.R� RT ( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
winfo_namea s c C s | j j d d | j � S( s- Return the name of the parent of this widget.R� t parent( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_parentd s c C s* d | j | � | f } | j j | � S( s. Return the pathname of the widget given by ID.R� t pathname( R� R
( R� R. RP ( RR Rb R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_pathnameg s c C s" t | j j d d | j | � � S( s' Rounded integer value of winfo_fpixels.R� t pixels( Ry R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_pixelsl s c C s t | j j d d | j � � S( s: Return the x coordinate of the pointer on the root window.R� t pointerx( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_pointerxp s c C s" | j | j j d d | j � � S( sH Return a tuple of x and y coordinates of the pointer on the root window.R� t pointerxy( t _getintsR. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_pointerxyt s c C s t | j j d d | j � � S( s: Return the y coordinate of the pointer on the root window.R� t pointery( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_pointeryx s c C s t | j j d d | j � � S( s' Return requested height of this widget.R� t reqheight( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_reqheight| s c C s t | j j d d | j � � S( s& Return requested width of this widget.R� t reqwidth( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_reqwidth� s c C s% | j | j j d d | j | � � S( sU Return tuple of decimal values for red, green, blue for
COLOR in this widget.R� t rgb( R R. RP R� ( RR t color( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_rgb� s c C s t | j j d d | j � � S( sS Return x coordinate of upper left corner of this widget on the
root window.R� t rootx( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_rootx� s c C s t | j j d d | j � � S( sS Return y coordinate of upper left corner of this widget on the
root window.R� t rooty( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_rooty� s c C s | j j d d | j � S( s& Return the screen name of this widget.R� t screen( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_screen� s c C s t | j j d d | j � � S( sT Return the number of the cells in the colormap of the screen
of this widget.R� t screencells( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_screencells� s c C s t | j j d d | j � � S( s\ Return the number of bits per pixel of the root window of the
screen of this widget.R� t screendepth( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_screendepth� s c C s t | j j d d | j � � S( sX Return the number of pixels of the height of the screen of this widget
in pixel.R� t screenheight( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_screenheight� s c C s t | j j d d | j � � S( sU Return the number of pixels of the height of the screen of
this widget in mm.R� t screenmmheight( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_screenmmheight� s c C s t | j j d d | j � � S( sT Return the number of pixels of the width of the screen of
this widget in mm.R� t
screenmmwidth( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_screenmmwidth� s c C s | j j d d | j � S( s� Return one of the strings directcolor, grayscale, pseudocolor,
staticcolor, staticgray, or truecolor for the default
colormodel of this screen.R� t screenvisual( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_screenvisual� s c C s t | j j d d | j � � S( sW Return the number of pixels of the width of the screen of
this widget in pixel.R� t screenwidth( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_screenwidth� s c C s | j j d d | j � S( sx Return information of the X-Server of the screen of this widget in
the form "XmajorRminor vendor vendorVersion".R� t server( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_server� s c C s" | j | j j d d | j � � S( s* Return the toplevel widget of this widget.R� t toplevel( R� R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_toplevel� s c C s t | j j d d | j � � S( sB Return true if the widget and all its higher ancestors are mapped.R� t viewable( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_viewable� s c C s | j j d d | j � S( s� Return one of the strings directcolor, grayscale, pseudocolor,
staticcolor, staticgray, or truecolor for the
colormodel of this widget.R� t visual( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_visual� s c C s | j j d d | j � S( s7 Return the X identifier for the visual for this widget.R� t visualid( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_visualid� s c C sp | j j | j j d d | j | r* d p- d � � } t | � t k r` | j j | � g } n t | j | � S( s� Return a list of all visuals available for the screen
of this widget.
Each item in the list consists of a visual name (see winfo_visual), a
depth and if INCLUDEIDS=1 is given also the X identifier.R� t visualsavailablet
includeidsN( R. t splitRP R� R R R R t _Misc__winfo_parseitem( RR R; R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_visualsavailable� s c C s" | d t t | j | d � � S( s Internal function.i ( R R t _Misc__winfo_getint( RR R1 ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt __winfo_parseitem� s c C s
t | d � S( s Internal function.i ( R? ( RR t x( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt __winfo_getint� s c C s t | j j d d | j � � S( s� Return the height of the virtual root window associated with this
widget in pixels. If there is no virtual root window return the
height of the screen.R� t vrootheight( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_vrootheight� s c C s t | j j d d | j � � S( s� Return the width of the virtual root window associated with this
widget in pixel. If there is no virtual root window return the
width of the screen.R� t
vrootwidth( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_vrootwidth� s c C s t | j j d d | j � � S( si Return the x offset of the virtual root relative to the root
window of the screen of this widget.R� t vrootx( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_vrootx� s c C s t | j j d d | j � � S( si Return the y offset of the virtual root relative to the root
window of the screen of this widget.R� t vrooty( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_vrooty� s c C s t | j j d d | j � � S( s Return the width of this widget.R� t width( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_width� s c C s t | j j d d | j � � S( sV Return the x coordinate of the upper left corner of this widget
in the parent.R� RA ( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_x� s c C s t | j j d d | j � � S( sV Return the y coordinate of the upper left corner of this widget
in the parent.R� t y( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt winfo_y� s c C s | j j d � d S( sE Enter event loop until all pending events have been processed by Tcl.R N( R. RP ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR s c C s | j j d d � d S( s� Enter event loop until all idle callbacks have been called. This
will update the display of windows but not process events caused by
the user.R t idletasksN( R. RP ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt update_idletasks s c C sK | d k r. | j j | j j d | j � � S| j j d | j | � d S( s, Set or get the list of bindtags for this widget.
With no argument return the list of all bindtags associated with
this widget. With a list of strings as argument the bindtags are
set to this list. The bindtags determine in which order events are
processed (see bind).t bindtagsN( R R. R* RP R� ( RR t tagList( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRR s i c C s� t | � t k r/ | j j | | | f � n� | r� | j | | j | � } d | r\ d p_ d | | j f } | j j | | | f � | S| r� | j j | | f � S| j j | j j | � � Sd S( s Internal function.s" %sif {"[%s %s]" == "break"} break
t +RE N( R R R. RP R� t _substitutet _subst_format_strR* ( RR t whatt sequenceR� R� t needcleanupt funcidR� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _bind s c C s | j d | j f | | | � S( sO Bind to this widget at event SEQUENCE a call to function FUNC.
SEQUENCE is a string of concatenated event
patterns. An event pattern is of the form
<MODIFIER-MODIFIER-TYPE-DETAIL> where MODIFIER is one
of Control, Mod2, M2, Shift, Mod3, M3, Lock, Mod4, M4,
Button1, B1, Mod5, M5 Button2, B2, Meta, M, Button3,
B3, Alt, Button4, B4, Double, Button5, B5 Triple,
Mod1, M1. TYPE is one of Activate, Enter, Map,
ButtonPress, Button, Expose, Motion, ButtonRelease
FocusIn, MouseWheel, Circulate, FocusOut, Property,
Colormap, Gravity Reparent, Configure, KeyPress, Key,
Unmap, Deactivate, KeyRelease Visibility, Destroy,
Leave and DETAIL is the button number for ButtonPress,
ButtonRelease and DETAIL is the Keysym for KeyPress and
KeyRelease. Examples are
<Control-Button-1> for pressing Control and mouse button 1 or
<Alt-A> for pressing A and the Alt key (KeyPress can be omitted).
An event pattern can also be a virtual event of the form
<<AString>> where AString can be arbitrary. This
event can be generated by event_generate.
If events are concatenated they must appear shortly
after each other.
FUNC will be called if the event sequence occurs with an
instance of Event as argument. If the return value of FUNC is
"break" no further bound function is invoked.
An additional boolean parameter ADD specifies whether FUNC will
be called additionally to the other bound function or whether
it will replace the previous function.
Bind will return an identifier to allow deletion of the bound function with
unbind without memory leak.
If FUNC or SEQUENCE is omitted the bound function or list
of bound events are returned.t bind( R[ R� ( RR RX R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR\ ( s 'c C s6 | j j d | j | d � | r2 | j | � n d S( sW Unbind for this widget for event SEQUENCE the
function identified with FUNCID.R\ RE N( R. RP R� RX ( RR RX RZ ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt unbindP s c C s | j d | | | d � S( s Bind to all widgets at an event SEQUENCE a call to function FUNC.
An additional boolean parameter ADD specifies whether FUNC will
be called additionally to the other bound function or whether
it will replace the previous function. See bind for the return value.R\ t alli ( R\ R^ ( R[ ( RR RX R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt bind_allV s c C s | j j d d | d � d S( s8 Unbind for all widgets for event SEQUENCE all functions.R\ R^ RE N( R. RP ( RR RX ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
unbind_all\ s c C s | j d | f | | | d � S( s= Bind to widgets with bindtag CLASSNAME at event
SEQUENCE a call of function FUNC. An additional
boolean parameter ADD specifies whether FUNC will be
called additionally to the other bound function or
whether it will replace the previous function. See bind for
the return value.R\ i ( R[ ( RR R� RX R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
bind_class_ s c C s | j j d | | d � d S( sW Unbind for all widgets with bindtag CLASSNAME for event SEQUENCE
all functions.R\ RE N( R. RP ( RR R� RX ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt unbind_classi s c C s | j j | � d S( s Call the mainloop of Tk.N( R. R~ ( RR R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR~ m s c C s | j j � d S( s8 Quit the Tcl interpreter. All widgets will be destroyed.N( R. t quit( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRc p s c C s) | r% t t t | j j | � � � Sd S( s Internal function.N( R R Ry R. R* ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR s s c C s) | r% t t t | j j | � � � Sd S( s Internal function.N( R R R{ R. R* ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _getdoublesw s c C s | r | j j | � Sd S( s Internal function.N( R. RO ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _getboolean{ s c C s- | r d | f S| d k r) d | j f Sd S( s Internal function.s
-displayofN( ( R R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� s
c C sL y | j � j SWn4 t k
rG | j j d d � } | j � _ | SXd S( s Internal function.R. t windowingsystemN( RI t _windowingsystem_cachedR R. RP ( RR t ws( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s
"c C sE | r t | | f � } n t | � } d } x| j � D]\ } } | d k r: | d d k ro | d } n t | d � r� | j | � } n� t | t t f � r&g } xx | D]^ } t | t t t
f � s� Pq� t | t t
f � r� | j d | � q� | j t | � � q� Wd j
| � } n | d | | f } q: q: W| S( s Internal function.i����t _Ra s %dR R) ( N( R( R! R t hasattrR� R R R
Rv R? t longRe R R ( RR R# R� R R& R' t nvR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s*
c C sj t | � j d � } | } | d s> | j � } | d } n x% | D] } | sU Pn | j | } qE W| S( sP Return the Tkinter instance of a widget identified by
its Tcl name NAME.t .i i ( R R< RI R� ( RR RT t wR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt nametowidget� s
c C s� t | | | � j } t t | � � } y
| j } Wn t k
rG n Xy | | j } Wn t k
rl n X| j j | | � | r� | j d k r� g | _ n | j j | � n | S( s� Return a newly created Tcl function. If this
function is called, the Python function FUNC will
be executed. An optional function SUBST can
be given which will be executed before FUNC.N( R` Ra RL Rb Rc R R7 R. Rd RW R Re ( RR R� t substRY Rh RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s
c C s# | } x | j r | j } q W| S( s Internal function.( RS ( RR Rn ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRI � s
s %#s %bs %fs %hs %ks %ss %ts %ws %xs %ys %As %Es %Ks %Ns %Ws %Ts %Xs %Ys %DR c G s t | � t | j � k r | S| j j } t } d � } | \ } } } } } }
} } }
} } } } } } } } } } t � } | | � | _ | | � | _ y | | � | _ Wn t k
r� n X| | � | _
| | � | _ | |
� | _ | | � | _
| | � | _ | |
� | _ | | � | _ | | _ y | | � | _ Wn t k
r_n X| | _ | | � | _ | | _ y | j | � | _ Wn t k
r�| | _ n X| | � | _ | | � | _ y | | � | _ Wn t k
rd | _ n X| f S( s Internal function.c S s' y t | � SWn t k
r" | SXd S( s? Tk changed behavior in 8.4.2, returning "??" rather more often.N( R? R@ ( R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt getint_event� s
i ( R t
_subst_formatR. RO R? R6 t serialt numR� R� R� t keycodet statet timeRK RA RN t chart
send_eventt keysymt
keysym_numR R� t widgetR� t x_roott y_roott deltaR@ ( RR R� RO Ry Rq t nsignt bRh t hR& R� R1 Rn RA RN t At Et Kt Nt Wt Tt Xt Yt Dt e( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU � sN ?
c C sL d d l } | j | j | j } } } | j � } | j | | | � d S( s Internal function.i����N( t syst exc_typet exc_valuet
exc_tracebackRI t report_callback_exception( RR R� t exct valt tbt root( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _report_exception s c G sj i } x] | j j | j j | � � D]= } | j j | � } | d d f | d | | d d <q% W| S( s; Call Tcl configure command and return the result as a dict.i i ( R. R* RP ( RR R� R# RA ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
_getconfigure s
%)c G s5 | j j | j j | � � } | d d f | d S( Ni i ( R. R* RP ( RR R� RA ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _getconfigure1! s c C s� | r t | | f � } n | r0 t | � } n | d k rX | j t | j | f � � St | � t k r� | j t | j | d | f � � S| j j t | j | f � | j
| � � d S( s Internal function.R) N( R( R R� R R� R R R� R. RP R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
_configure% s #c K s | j d | | � S( s� Configure resources of a widget.
The values for resources are specified as keyword
arguments. To get an overview about
the allowed keyword arguments call the method keys.
t configure( R� ( RR R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� 1 s c C s | j j | j d d | � S( s4 Return the resource value for a KEY given as string.t cgetR) ( R. RP R� ( RR R4 ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� : s c C s | j i | | 6� d S( N( R� ( RR R4 R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt __setitem__> s c C s t d � � d S( Ns) Tkinter objects don't support 'in' tests.( R ( RR R4 ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt __contains__@ s c C sI | j j } g | | j j | j d � � D] } | | � d d ^ q+ S( s3 Return a list of all resource names of this widget.R� i i ( R. R* RP R� ( RR R* RA ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt keysB s c C s | j S( s+ Return the window path name of this widget.( R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRZ G s t _noarg_c C sQ | t j k r1 | j | j j d d | j � � S| j j d d | j | � d S( s Set or get the status for propagation of geometry information.
A boolean argument specifies whether the geometry information
of the slaves will determine the size of this widget. If no argument
is given the current setting will be returned.
t packt propagateN( R� R� Re R. RP R� ( RR t flag( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt pack_propagateL s c C s1 t | j | j j | j j d d | j � � � S( sH Return a list of all slaves of this widget
in its packing order.R� t slaves( R R� R. R* RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt pack_slavesY s c C s1 t | j | j j | j j d d | j � � � S( sH Return a list of all slaves of this widget
in its packing order.t placeR� ( R R� R. R* RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt place_slavesa s c C s� d d | j f } | d k r= | d k r= | | | f } n | d k rh | d k rh | | | f } n | j | j j | � � p� d S( s� Return a tuple of integer coordinates for the bounding
box of this widget controlled by the geometry manager grid.
If COLUMN, ROW is given the bounding box applies from
the cell with row and column 0 to the specified
cell. If COL2 and ROW2 are given the bounding box
starts at that cell.
The returned integers specify the offset of the upper left
corner in the master widget and the width and height.
t gridt bboxN( R� R R R. RP ( RR t columnt rowt col2t row2R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grid_bboxi s c C sm t | t t j f � ri y: t | � } | s1 d Sd | k rG t | � St | � SWqi t k
re qi Xn | S( NRm ( R R t _tkintert Tcl_ObjR R{ Ry R@ ( RR R t svalue( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _gridconvvalue~ s
c C s� t | � t k r_ | r_ | d d k r6 | d } n | d d k rS d | } n | f } n | j | | � } | s� t | j | j j d | | j | � d | j �S| j j d | | j | f | � } t | � d k r� | j | � Sd S( s Internal function.i����Ri i R) R� R0 N( R R R� R5 R. RP R� R� R ( RR R� t indexR# R� t optionsR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _grid_configure� s"
c K s | j d | | | � S( s� Configure column INDEX of a grid.
Valid resources are minsize (minimum size of the column),
weight (how much does additional space propagate to this column)
and pad (how much space to let additionally).t columnconfigure( R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grid_columnconfigure� s c C s. | j | j j d d | j | | � � p- d S( s� Return a tuple of column and row which identify the cell
at which the pixel at position X and Y inside the master
widget is located.R� t locationN( R R. RP R� R ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
grid_location� s c C sQ | t j k r1 | j | j j d d | j � � S| j j d d | j | � d S( s Set or get the status for propagation of geometry information.
A boolean argument specifies whether the geometry information
of the slaves will determine the size of this widget. If no argument
is given, the current setting will be returned.
R� R� N( R� R� Re R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grid_propagate� s c K s | j d | | | � S( s� Configure row INDEX of a grid.
Valid resources are minsize (minimum size of the row),
weight (how much does additional space propagate to this row)
and pad (how much space to let additionally).t rowconfigure( R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grid_rowconfigure� s c C s( | j | j j d d | j � � p' d S( s< Return a tuple of the number of column and rows in the grid.R� t sizeN( R R. RP R� R ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grid_size� s c C s| d } | d k r% | d | f } n | d k rD | d | f } n t | j | j j | j j d d | j f | � � � S( sH Return a list of all slaves of this widget
in its packing order.s -rows -columnR� R� ( N( R R R� R. R* RP R� ( RR R� R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grid_slaves� s c G s' d d | f | } | j j | � d S( s� Bind a virtual event VIRTUAL (of the form <<Name>>)
to an event SEQUENCE such that the virtual event is triggered
whenever SEQUENCE occurs.t eventR� N( R. RP ( RR t virtualt sequencesR� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt event_add� s c G s' d d | f | } | j j | � d S( s- Unbind a virtual event VIRTUAL from SEQUENCE.R� t deleteN( R. RP ( RR R� R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt event_delete� s c K s` d d | j | f } x4 | j � D]& \ } } | d | t | � f } q" W| j j | � d S( s� Generate an event SEQUENCE. Additional
keyword arguments specify parameter of the event
(e.g. x, y, rootx, rooty).R� t generates -%sN( R� R! R R. RP ( RR RX R� R� R& R' ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt event_generate� s c C s" | j j | j j d d | � � S( su Return a list of all virtual events or the information
about the SEQUENCE bound to the virtual event VIRTUAL.R� RG ( R. R* RP ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
event_info� s c C s | j j | j j d d � � S( s* Return a list of all existing image names.t imaget names( R. R* RP ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt image_names� s c C s | j j | j j d d � � S( s? Return a list of all available image types (e.g. photo bitmap).R� t types( R. R* RP ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt image_types� s N( s %#s %bs %fs %hs %ks %ss %ts %ws %xs %ys %As %Es %Ks %Ns %Ws %Ts %Xs %Ys %D(� R7 R8 R9 R RW R� RX R� R� R� R� R� t waitvarR� R� R� R� R? Ry t floatR{ RO R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� t liftR� R� R� R� R� R� R� R� R� R� R� R� R� R R R R R R R R
R R R R R R R R R! R# R% R' R) R+ R- R/ R1 R3 R5 R7 R9 R> R= R? RD RF RH RJ RL RM RO R RQ RR R[ R\ R] R_ R` Ra Rb R~ Rc R Rd Re R� t propertyR� R� Ro R� R� t registerRI Rr R RV RU R� R� R� R� R� t configR� t __getitem__R� R� R� RZ R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � sP
(
9 R` c B s e Z d Z d � Z d � Z RS( sw Internal class. Stores function to call when some user
defined Tcl function is called e.g. after an event occurred.c C s | | _ | | _ | | _ d S( s( Store FUNC, SUBST and WIDGET as members.N( R� Rp R| ( RR R� Rp R| ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU s c G sb y, | j r | j | � } n | j | � SWn/ t k
rJ } t | � n | j j � n Xd S( s3 Apply first function SUBST to arguments, than FUNC.N( Rp R� RA R| R� ( RR R� R% ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRa s ( R7 R8 R9 RU Ra ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR` � s t XViewc B s) e Z d Z d � Z d � Z d � Z RS( sX Mix-in class for querying and changing the horizontal position
of a widget's window.c G s2 | j j | j d | � } | s. | j | � Sd S( s5 Query and change the horizontal position of the view.t xviewN( R. RP R� Rd ( RR R� R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� s c C s | j j | j d d | � d S( ss Adjusts the view in the window so that FRACTION of the
total width of the canvas is off-screen to the left.R� t movetoN( R. RP R� ( RR t fraction( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt xview_moveto s c C s# | j j | j d d | | � d S( s\ Shift the x-view according to NUMBER which is measured in "units"
or "pages" (WHAT).R� t scrollN( R. RP R� ( RR R� RW ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt xview_scroll! s ( R7 R8 R9 R� R� R� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� s t YViewc B s) e Z d Z d � Z d � Z d � Z RS( sV Mix-in class for querying and changing the vertical position
of a widget's window.c G s2 | j j | j d | � } | s. | j | � Sd S( s3 Query and change the vertical position of the view.t yviewN( R. RP R� Rd ( RR R� R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� + s c C s | j j | j d d | � d S( ss Adjusts the view in the window so that FRACTION of the
total height of the canvas is off-screen to the top.R� R� N( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt yview_moveto1 s c C s# | j j | j d d | | � d S( s\ Shift the y-view according to NUMBER which is measured in
"units" or "pages" (WHAT).R� R� N( R. RP R� ( RR R� RW ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt yview_scroll6 s ( R7 R8 R9 R� R� R� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� ' s t Wmc B s e Z d Z d d d d d � Z e Z d � Z e Z d d � Z e Z d � Z
e
Z d d � Z e Z
d � Z e Z d d � Z e Z d � Z e Z d d � Z e Z d d d d d
� Z e Z d d � Z e Z d d d � Z e Z d
� Z e Z d d � Z e Z d d � Z e Z! d d d � Z" e" Z# d d � Z$ e$ Z% d d d � Z& e& Z' d d d � Z( e( Z) d d � Z* e* Z+ d d � Z, e, Z- d d d � Z. e. Z/ d d d � Z0 e0 Z1 d d � Z2 e2 Z3 d d � Z4 e4 Z5 d d � Z6 e6 Z7 d d � Z8 e8 Z9 d � Z: e: Z; RS( sA Provides functions for the communication with the window manager.c C s. | j | j j d d | j | | | | � � S( s� Instruct the window manager to set the aspect ratio (width/height)
of this widget to be between MINNUMER/MINDENOM and MAXNUMER/MAXDENOM. Return a tuple
of the actual values if no argument is given.t wmt aspect( R R. RP R� ( RR t minNumert minDenomt maxNumert maxDenom( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_aspect? s c G s& d d | j f | } | j j | � S( s� This subcommand returns or sets platform specific attributes
The first form returns a list of the platform specific flags and
their values. The second form returns the value for the specific
option. The third form sets one or more of the values. The values
are as follows:
On Windows, -disabled gets or sets whether the window is in a
disabled state. -toolwindow gets or sets the style of the window
to toolwindow (as defined in the MSDN). -topmost gets or sets
whether this is a topmost window (displays above all other
windows).
On Macintosh, XXXXX
On Unix, there are currently no special attribute values.
R� t
attributes( R� R. RP ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
wm_attributesK s c C s | j j d d | j | � S( sV Store NAME in WM_CLIENT_MACHINE property of this widget. Return
current value.R� t client( R. RP R� ( RR RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_clienta s c G sy t | � d k r | f } n d d | j f | } | rM | j j | � n( t | j | j j | j j | � � � Sd S( s� Store list of window names (WLIST) into WM_COLORMAPWINDOWS property
of this widget. This list contains windows whose colormaps differ from their
parents. Return current list of widgets if WLIST is empty.i R� t colormapwindowsN( R R� R. RP R R� R* ( RR t wlistR� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_colormapwindowsf s c C s | j j d d | j | � S( s� Store VALUE in WM_COMMAND property. It is the command
which shall be used to invoke the application. Return current
command if VALUE is None.R� R� ( R. RP R� ( RR R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
wm_commandr s c C s | j j d d | j � S( s� Deiconify this widget. If it was never mapped it will not be mapped.
On Windows it will raise this widget and give it the focus.R� t deiconify( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_deiconifyx s c C s | j j d d | j | � S( s� Set focus model to MODEL. "active" means that this widget will claim
the focus itself, "passive" means that the window manager shall give
the focus. Return current focus model if MODEL is None.R� t
focusmodel( R. RP R� ( RR t model( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
wm_focusmodel} s c C s | j j d d | j � S( sA Return identifier for decorative frame of this widget if present.R� t frame( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_frame� s c C s | j j d d | j | � S( si Set geometry to NEWGEOMETRY of the form =widthxheight+x+y. Return
current value if None is given.R� R� ( R. RP R� ( RR t newGeometry( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_geometry� s c C s. | j | j j d d | j | | | | � � S( s Instruct the window manager that this widget shall only be
resized on grid boundaries. WIDTHINC and HEIGHTINC are the width and
height of a grid unit in pixels. BASEWIDTH and BASEHEIGHT are the
number of grid units requested in Tk_GeometryRequest.R� R� ( R R. RP R� ( RR t baseWidtht
baseHeightt widthInct heightInc( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_grid� s c C s | j j d d | j | � S( s~ Set the group leader widgets for related widgets to PATHNAME. Return
the group leader of this widget if None is given.R� t group( R. RP R� ( RR t pathName( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_group� s c C sE | r% | j j d d | j d | � S| j j d d | j | � Sd S( s� Set bitmap for the iconified widget to BITMAP. Return
the bitmap if None is given.
Under Windows, the DEFAULT parameter can be used to set the icon
for the widget and any descendents that don't have an icon set
explicitly. DEFAULT can be the relative path to a .ico file
(example: root.iconbitmap(default='myicon.ico') ). See Tk
documentation for more information.R� t
iconbitmaps -defaultN( R. RP R� ( RR t bitmapt default( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
wm_iconbitmap� s c C s | j j d d | j � S( s Display widget as icon.R� t iconify( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
wm_iconify� s c C s | j j d d | j | � S( sV Set mask for the icon bitmap of this widget. Return the
mask if None is given.R� t iconmask( R. RP R� ( RR R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_iconmask� s c C s | j j d d | j | � S( sS Set the name of the icon for this widget. Return the name if
None is given.R� t iconname( R. RP R� ( RR t newName( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_iconname� s c C s( | j | j j d d | j | | � � S( s� Set the position of the icon of this widget to X and Y. Return
a tuple of the current values of X and X if None is given.R� t iconposition( R R. RP R� ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_iconposition� s c C s | j j d d | j | � S( sg Set widget PATHNAME to be displayed instead of icon. Return the current
value if None is given.R� t
iconwindow( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
wm_iconwindow� s c C s( | j | j j d d | j | | � � S( s� Set max WIDTH and HEIGHT for this widget. If the window is gridded
the values are given in grid units. Return the current values if None
is given.R� t maxsize( R R. RP R� ( RR RK R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
wm_maxsize� s c C s( | j | j j d d | j | | � � S( s� Set min WIDTH and HEIGHT for this widget. If the window is gridded
the values are given in grid units. Return the current values if None
is given.R� t minsize( R R. RP R� ( RR RK R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
wm_minsize� s c C s% | j | j j d d | j | � � S( s� Instruct the window manager to ignore this widget
if BOOLEAN is given with 1. Return the current value if None
is given.R� t overrideredirect( Re R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_overrideredirect� s c C s | j j d d | j | � S( s� Instruct the window manager that the position of this widget shall
be defined by the user if WHO is "user", and by its own policy if WHO is
"program".R� t positionfrom( R. RP R� ( RR t who( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_positionfrom� s c C sF t | d � r! | j | � } n | } | j j d d | j | | � S( s� Bind function FUNC to command NAME for this widget.
Return the function bound to NAME if None is given. NAME could be
e.g. "WM_SAVE_YOURSELF" or "WM_DELETE_WINDOW".Ra R� t protocol( Rj R� R. RP R� ( RR RT R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_protocol� s
c C s | j j d d | j | | � S( sy Instruct the window manager whether this width can be resized
in WIDTH or HEIGHT. Both values are boolean values.R� t resizable( R. RP R� ( RR RK R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_resizable� s c C s | j j d d | j | � S( s� Instruct the window manager that the size of this widget shall
be defined by the user if WHO is "user", and by its own policy if WHO is
"program".R� t sizefrom( R. RP R� ( RR R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_sizefrom� s c C s | j j d d | j | � S( s� Query or set the state of this widget as one of normal, icon,
iconic (see wm_iconwindow), withdrawn, or zoomed (Windows only).R� Rv ( R. RP R� ( RR t newstate( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_state� s c C s | j j d d | j | � S( s Set the title of this widget.R� t title( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_title� s c C s | j j d d | j | � S( s_ Instruct the window manager that this widget is transient
with regard to widget MASTER.R� t transient( R. RP R� ( RR RS ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_transient� s c C s | j j d d | j � S( s� Withdraw this widget from the screen such that it is unmapped
and forgotten by the window manager. Re-draw it with wm_deiconify.R� t withdraw( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt wm_withdraw s N(< R7 R8 R9 R R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R R� R R R R R R R R R
R R R R R R R R R R R R R R R R R R Rv R" R! R$ R# R& R% ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� < sv
t Tkc B se e Z d Z d Z d d d d d d d � Z d � Z d � Z d � Z d � Z d
� Z
d � Z RS(
sz Toplevel widget of Tk which represents mostly the main window
of an application. It has an associated Tcl interpreter.Rm R' i i c
C s� d | _ i | _ d | _ d | _ | d k r� d d l } | j j t j d � } | j j
| � \ } } | d k r� | | } q� n d } t j | | | | t
| | | � | _ | r� | j � n t j j s� | j | | � n d S( s@ Return a new Toplevel widget on screen SCREENNAME. A new Tcl interpreter will
be created. BASENAME will be used for the identification of the profile file (see
readprofile).
It is constructed from sys.argv[0] without extensions if None is given. CLASSNAME
is the name of the widget class.i i����Ns .pys .pycs .pyo( s .pys .pycs .pyo( R RS R� t _tkloadedR. t ost patht basenameR� t argvt splitextR� t createt wantobjectst _loadtkt flagst ignore_environmentt readprofile(
RR t
screenNamet baseNameR� t useTkt synct useR) t extt interactive( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU
s '
c C s' | j s# | j j � | j � n d S( N( R( R. t loadtkR0 ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR; ' s
c C s3 d | _ | j j d � } | t j k rC t d t j | f � n t | j j d � � } | t j k r� t d t j | f � n t d k r� t d t t � � n | j d k r� g | _ n | j j d t � | j j d t
� | j j d � | j j d � t r t r | a n | j d
| j � d S( Ni t
tk_versions4 tk.h version (%s) doesn't match libtk.a version (%s)t tcl_versions6 tcl.h version (%s) doesn't match libtcl.a version (%s)g @s) Tk 4.0 or higher is required; found Tk %st tkerrort exitt WM_DELETE_WINDOW( R( R. R� R� t
TK_VERSIONR+ R t TCL_VERSIONt TkVersionRW R Rd R> RC Re R: R; R R� ( RR R< R= ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR0 + s0
c C sf x! | j j � D] } | j � q W| j j d | j � t j | � t rb t | k rb d a n d S( sh Destroy this and all descendants widgets. This will
end the application of this Tcl interpreter.R� N(
R� t valuesR� R. RP R� R� R: R; R ( RR R$ ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� J s
c
B sE d d l } d | j k r+ | j d } n | j } | j j | d | � } | j j | d | � } | j j | d | � } | j j | d | � } i | d 6} d | U| j j | � r� | j j d | � n | j j | � r� e | | � n | j j | � r | j j d | � n | j j | � rAe | | � n d S( s� Internal function. It reads BASENAME.tcl and CLASSNAME.tcl into
the Tcl Interpreter and calls execfile on BASENAME.py and CLASSNAME.py if
such a file exists in the home directory.i����Nt HOMEs .%s.tcls .%s.pyRR s from Tkinter import *t source( R) t environt curdirR* R t isfileR. RP t execfile(
RR R5 R� R) t homet class_tclt class_pyt base_tclt base_pyt dir( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR3 S s$
c C sW d d l } d d l } | j d IJ| | _ | | _ | | _ | j | | | � d S( s� Report callback exception on sys.stderr.
Applications may want to override this internal function, and
should when sys.stderr is None.i����Ns Exception in Tkinter callback( t tracebackR� t stderrt last_typet
last_valuet last_tracebackt print_exception( RR R� R� R� RQ R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� h s
c C s t | j | � S( s3 Delegate attribute access to the interpreter object( t getattrR. ( RR t attr( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt __getattr__s s N( R7 R8 R9 R� R RU R; R0 R� R3 R� RY ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR' s c C s t | | | | � S( N( R' ( R4 R5 R� R6 ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt Tcl� s t Packc B s` e Z d Z i d � Z e Z Z Z d � Z e Z d � Z e Z
e j Z
Z e j Z Z RS( sQ Geometry manager Pack.
Base class to use the methods pack_* in every widget.c K s0 | j j d d | j f | j | | � � d S( s( Pack a widget in the parent widget. Use as options:
after=widget - pack it after you have packed widget
anchor=NSEW (or subset) - position widget according to
given direction
before=widget - pack it before you will pack widget
expand=bool - expand widget if parent size grows
fill=NONE or X or Y or BOTH - fill widget if widget grows
in=master - use master to contain this widget
in_=master - see 'in' option description
ipadx=amount - add internal padding in x direction
ipady=amount - add internal padding in y direction
padx=amount - add padding in x direction
pady=amount - add padding in y direction
side=TOP or BOTTOM or LEFT or RIGHT - where to add this widget.
R� R� N( R. RP R� R� ( RR R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt pack_configure� s c C s | j j d d | j � d S( s: Unmap this widget and do not use it for the packing order.R� t forgetN( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt pack_forget� s c C sQ t | j | j j d d | j � � } d | k rM | j | d � | d <n | S( sE Return information about the packing options
for this widget.R� RG t in( R5 R. RP R� Ro ( RR t d( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt pack_info� s ' ( R7 R8 R9 R\ R� R� R� R^ R] Ra RG R� R� R� R� R� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR[ � s
t Placec B sS e Z d Z i d � Z e Z Z Z d � Z e Z d � Z e Z
e j Z
Z RS( sS Geometry manager Place.
Base class to use the methods place_* in every widget.c K s0 | j j d d | j f | j | | � � d S( s Place a widget in the parent widget. Use as options:
in=master - master relative to which the widget is placed
in_=master - see 'in' option description
x=amount - locate anchor of this widget at position x of master
y=amount - locate anchor of this widget at position y of master
relx=amount - locate anchor of this widget between 0.0 and 1.0
relative to width of master (1.0 is right edge)
rely=amount - locate anchor of this widget between 0.0 and 1.0
relative to height of master (1.0 is bottom edge)
anchor=NSEW (or subset) - position anchor according to given direction
width=amount - width of this widget in pixel
height=amount - height of this widget in pixel
relwidth=amount - width of this widget between 0.0 and 1.0
relative to width of master (1.0 is the same width
as the master)
relheight=amount - height of this widget between 0.0 and 1.0
relative to height of master (1.0 is the same
height as the master)
bordermode="inside" or "outside" - whether to take border width of
master widget into account
R� R� N( R. RP R� R� ( RR R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt place_configure� s c C s | j j d d | j � d S( s Unmap this widget.R� R] N( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt place_forget� s c C sQ t | j | j j d d | j � � } d | k rM | j | d � | d <n | S( sE Return information about the placing options
for this widget.R� RG R_ ( R5 R. RP R� Ro ( RR R` ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
place_info� s ' ( R7 R8 R9 Rc R� R� R� Rd R] Re RG R� R� R� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRb � s t Gridc B s� e Z d Z i d � Z e Z Z Z e j Z Z e j
Z Z
d � Z e Z
d � Z d � Z e Z e j Z Z e j Z Z e j Z Z e j Z Z e j Z Z RS( sQ Geometry manager Grid.
Base class to use the methods grid_* in every widget.c K s0 | j j d d | j f | j | | � � d S( s Position a widget in the parent widget in a grid. Use as options:
column=number - use cell identified with given column (starting with 0)
columnspan=number - this widget will span several columns
in=master - use master to contain this widget
in_=master - see 'in' option description
ipadx=amount - add internal padding in x direction
ipady=amount - add internal padding in y direction
padx=amount - add padding in x direction
pady=amount - add padding in y direction
row=number - use cell identified with given row (starting with 0)
rowspan=number - this widget will span several rows
sticky=NSEW - if cell is larger on which sides will this
widget stick to the cell boundary
R� R� N( R. RP R� R� ( RR R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grid_configure� s c C s | j j d d | j � d S( s Unmap this widget.R� R] N( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grid_forget� s c C s | j j d d | j � d S( s0 Unmap this widget but remember the grid options.R� Rm N( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grid_remove� s c C sQ t | j | j j d d | j � � } d | k rM | j | d � | d <n | S( sS Return information about the options
for positioning this widget in a grid.R� RG R_ ( R5 R. RP R� Ro ( RR R` ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt grid_info� s ' ( R7 R8 R9 Rg R� R� R� R� R� R� R� R� Rh R] Ri Rj RG R� R� R� R� R� R� R� R� R� R� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRf � s
t
BaseWidgetc B s> e Z d Z d � Z i i d d � Z d � Z d d � Z RS( s Internal class.c C s t r* | s* t s t � a n t } q* n | | _ | j | _ d } d | k re | d } | d =n | s� t t | � � } n | | _ | j d k r� d | | _ n | j d | | _ i | _
| j | j j
k r� | j j
| j j � n | | j j
| j <d S( s6 Internal function. Sets up information about children.RT Rm N( R: R; R' RS R. R RL Rb RK R� R� R� ( RR RS R# RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _setup
s*
c C s� | r t | | f � } n | | _ t j | | | � | j d k rR g | _ n g } xG | j � D]9 } t | � t k re | j | | | f � | | =qe qe W| j
j | | j f | | j
| � � x$ | D] \ } } | j | | � q� Wd S( sd Construct a widget with the parent widget MASTER, a name WIDGETNAME
and appropriate options.N( R( t
widgetNameRk Rl RW R R� R t ClassTypeRe R. RP R� R� R� ( RR RS Rm R# R� t extrat classesR& R' ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU & s !c C ss x! | j j � D] } | j � q W| j j d | j � | j | j j k rb | j j | j =n t j | � d S( s) Destroy this and all descendants widgets.R� N( R� RD R� R. RP R� RK RS R� ( RR R$ ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� 8 s c C s | j j | j | f | � S( N( R. RP R� ( RR RT R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _do? s ( ( ( R7 R8 R9 Rl RU R� Rq ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRk s
t Widgetc B s e Z d Z RS( sx Internal class.
Base class for a widget which can be positioned with the geometry managers
Pack, Place or Grid.( R7 R8 R9 ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRr C s t Toplevelc B s e Z d Z d i d � Z RS( s" Toplevel widget, e.g. for dialogs.c K s | r t | | f � } n d } xx d d d d d g D]a } | | k r7 | | } | d d k rt d | d } n
d | } | | | f } | | =q7 q7 Wt j | | d | i | � | j � } | j | j � � | j | j � � | j d
| j � d S(
s% Construct a toplevel widget with the parent MASTER.
Valid resource names: background, bd, bg, borderwidth, class,
colormap, container, cursor, height, highlightbackground,
highlightcolor, highlightthickness, menu, relief, screen, takefocus,
use, visual, width.R t class_R� R6 t colormapi����Ri R) R2 R@ N( ( R( Rk RU RI R R! R R� ( RR RS R# R� Ro t wmkeyR� t optR� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU L s"
N( R7 R8 R9 R RU ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRs J s t Buttonc B s\ e Z d Z d i d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z RS(
s Button widget.c K s t j | | d | | � d S( sU Construct a button widget with the parent MASTER.
STANDARD OPTIONS
activebackground, activeforeground, anchor,
background, bitmap, borderwidth, cursor,
disabledforeground, font, foreground
highlightbackground, highlightcolor,
highlightthickness, image, justify,
padx, pady, relief, repeatdelay,
repeatinterval, takefocus, text,
textvariable, underline, wraplength
WIDGET-SPECIFIC OPTIONS
command, compound, default, height,
overrelief, state, width
t buttonN( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU h s c G s | j j d | j � d S( Nt
tkButtonEnter( R. RP R� ( RR t dummy( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRz } s c G s | j j d | j � d S( Nt
tkButtonLeave( R. RP R� ( RR R{ ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR| � s c G s | j j d | j � d S( Nt tkButtonDown( R. RP R� ( RR R{ ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR} � s c G s | j j d | j � d S( Nt
tkButtonUp( R. RP R� ( RR R{ ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR~ � s c G s | j j d | j � d S( Nt tkButtonInvoke( R. RP R� ( RR R{ ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR � s c C s | j j | j d � d S( s_ Flash the button.
This is accomplished by redisplaying
the button several times, alternating between active and
normal colors. At the end of the flash the button is left
in the same normal/active state as when the command was
invoked. This command is ignored if the button's state is
disabled.
t flashN( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s
c C s | j j | j d � S( s Invoke the command associated with the button.
The return value is the return value from the command,
or an empty string if there is no command associated with
the button. This command is ignored if the button's state
is disabled.
t invoke( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s N( R7 R8 R9 R RU Rz R| R} R~ R R� R� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRx f s c C s d S( Nt end( ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt AtEnd� s c G s2 d } x% | D] } | r
| d | } q
q
W| S( Nt insertR ( ( R� R� t a( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt AtInsert� s
c C s d S( Ns sel.first( ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
AtSelFirst� s c C s d S( Ns sel.last( ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt AtSelLast� s c C s) | d k r d | f Sd | | f Sd S( Ns @%rs @%r,%r( R ( RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt At� s t Canvasc B sI e Z d Z d: i d � Z d � Z d � Z d � Z d � Z d: d: d � Z d � Z
d � Z d � Z d
� Z
d: d � Z d: d: d: d � Z d: d
� Z d: d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z! d � Z" d � Z# d: d: d! � Z$ d" � Z% d# � Z& d$ � Z' d% � Z( d& � Z) d' � Z* d( � Z+ d) � Z, d* � Z- d: d+ � Z. e. Z/ d, � Z0 e0 Z1 d- � Z2 i d. � Z3 d/ � Z4 e4 Z5 Z6 d0 � Z7 d1 � Z8 d2 d3 � Z9 d4 � Z: d5 � Z; d6 � Z< d7 � Z= d8 � Z> d9 � Z? RS(; s? Canvas widget to display graphical elements like lines or text.c K s t j | | d | | � d S( s Construct a canvas widget with the parent MASTER.
Valid resource names: background, bd, bg, borderwidth, closeenough,
confine, cursor, height, highlightbackground, highlightcolor,
highlightthickness, insertbackground, insertborderwidth,
insertofftime, insertontime, insertwidth, offset, relief,
scrollregion, selectbackground, selectborderwidth, selectforeground,
state, takefocus, width, xscrollcommand, xscrollincrement,
yscrollcommand, yscrollincrement.t canvasN( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU � s
c G s! | j j | j d f | � d S( s Internal function.t addtagN( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s | j | d | � d S( s* Add tag NEWTAG to all items above TAGORID.t aboveN( R� ( RR t newtagt tagOrId( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt addtag_above� s c C s | j | d � d S( s Add tag NEWTAG to all items.R^ N( R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
addtag_all� s c C s | j | d | � d S( s* Add tag NEWTAG to all items below TAGORID.t belowN( R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt addtag_below� s c C s | j | d | | | | � d S( s� Add tag NEWTAG to item which is closest to pixel at X, Y.
If several match take the top-most.
All items closer than HALO are considered overlapping (all are
closests). If START is specified the next below this tag is taken.t closestN( R� ( RR R� RA RN t halot start( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt addtag_closest� s c C s | j | d | | | | � d S( sL Add tag NEWTAG to all items in the rectangle defined
by X1,Y1,X2,Y2.t enclosedN( R� ( RR R� t x1t y1t x2t y2( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt addtag_enclosed� s c C s | j | d | | | | � d S( sW Add tag NEWTAG to all items which overlap the rectangle
defined by X1,Y1,X2,Y2.t overlappingN( R� ( RR R� R� R� R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt addtag_overlapping� s c C s | j | d | � d S( s) Add tag NEWTAG to all items with TAGORID.t withtagN( R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt addtag_withtag� s c G s, | j | j j | j d f | � � p+ d S( s| Return a tuple of X1,Y1,X2,Y2 coordinates for a rectangle
which encloses all items with tags specified as arguments.R� N( R R. RP R� R ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s9 | j j | j d | | d � | r5 | j | � n d S( sb Unbind for all items with TAGORID for event SEQUENCE the
function identified with FUNCID.R\ RE N( R. RP R� RX ( RR R� RX RZ ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
tag_unbind� s c C s" | j | j d | f | | | � S( s& Bind to all items with TAGORID at event SEQUENCE a call to function FUNC.
An additional boolean parameter ADD specifies whether FUNC will be
called additionally to the other bound function or whether it will
replace the previous function. See bind for the return value.R\ ( R[ R� ( RR R� RX R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt tag_bind� s c C s" t | j j | j d | | � � S( sr Return the canvas x coordinate of pixel position SCREENX rounded
to nearest multiple of GRIDSPACING units.t canvasx( R{ R. RP R� ( RR t screenxt gridspacing( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s" t | j j | j d | | � � S( sr Return the canvas y coordinate of pixel position SCREENY rounded
to nearest multiple of GRIDSPACING units.t canvasy( R{ R. RP R� ( RR t screenyR� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c G s2 t t | j j | j j | j d f | � � � S( s8 Return a list of coordinates for the item given in ARGS.t coords( R R{ R. R* RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C ss t | � } | d } t | � t t f k r; | d } n i } t | j j | j d | | | j | | � � � S( s Internal function.i����R. ( R R R R Ry R. RP R� R� ( RR t itemTypeR� R� R# ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _create s
c O s | j d | | � S( s6 Create arc shaped region with coordinates x1,y1,x2,y2.t arc( R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
create_arc
s c O s | j d | | � S( s% Create bitmap with coordinates x1,y1.R ( R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
create_bitmap s c O s | j d | | � S( s) Create image item with coordinates x1,y1.R� ( R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt create_image s c O s | j d | | � S( s- Create line with coordinates x1,y1,...,xn,yn.t line( R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt create_line s c O s | j d | | � S( s) Create oval with coordinates x1,y1,x2,y2.t oval( R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt create_oval s c O s | j d | | � S( s0 Create polygon with coordinates x1,y1,...,xn,yn.t polygon( R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt create_polygon s c O s | j d | | � S( s. Create rectangle with coordinates x1,y1,x2,y2.t rectangle( R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt create_rectangle s c O s | j d | | � S( s# Create text with coordinates x1,y1.t text( R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt create_text" s c O s | j d | | � S( s+ Create window with coordinates x1,y1,x2,y2.R� ( R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
create_window% s c G s! | j j | j d f | � d S( s� Delete characters of text items identified by tag or id in ARGS (possibly
several times) from FIRST to LAST character (including).t dcharsN( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� ( s c G s! | j j | j d f | � d S( s< Delete items identified by all tag or ids contained in ARGS.R� N( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� , s c G s! | j j | j d f | � d S( si Delete tag or id given as last arguments in ARGS from items
identified by first argument in ARGS.t dtagN( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� / s c G s, | j | j j | j d f | � � p+ d S( s Internal function.t find( ( R R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� 3 s c C s | j d | � S( s Return items above TAGORID.R� ( R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
find_above7 s c C s
| j d � S( s Return all items.R^ ( R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt find_all: s c C s | j d | � S( s Return all items below TAGORID.R� ( R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
find_below= s c C s | j d | | | | � S( s� Return item which is closest to pixel at X, Y.
If several match take the top-most.
All items closer than HALO are considered overlapping (all are
closest). If START is specified the next below this tag is taken.R� ( R� ( RR RA RN R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt find_closest@ s c C s | j d | | | | � S( s= Return all items in rectangle defined
by X1,Y1,X2,Y2.R� ( R� ( RR R� R� R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
find_enclosedF s c C s | j d | | | | � S( sL Return all items which overlap the rectangle
defined by X1,Y1,X2,Y2.R� ( R� ( RR R� R� R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt find_overlappingJ s c C s | j d | � S( s Return all items with TAGORID.R� ( R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt find_withtagN s c G s | j j | j d f | � S( s. Set focus to the first item specified in ARGS.R� ( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� Q s c G s) | j j | j j | j d f | � � S( s= Return tags associated with the first item specified in ARGS.t gettags( R. R* RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� T s c G s! | j j | j d f | � d S( sd Set cursor at position POS in the item identified by TAGORID.
In ARGS TAGORID must be first.t icursorN( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� X s c G s# t | j j | j d f | � � S( s? Return position of cursor as integer in item specified in ARGS.R� ( Ry R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� \ s c G s! | j j | j d f | � d S( sS Insert TEXT in item TAGORID at position POS. ARGS must
be TAGORID POS TEXT.R� N( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� _ s c C s' | j j | j d f | d | f � S( s9 Return the resource value for an OPTION for item TAGORID.t itemcgetR) ( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� c s c K s | j d | f | | � S( s� Configure resources of an item TAGORID.
The values for resources are specified as keyword
arguments. To get an overview about
the allowed keyword arguments call the method without arguments.
t
itemconfigure( R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� g s c G s! | j j | j d f | � d S( sJ Lower an item TAGORID given in ARGS
(optional below another item).R� N( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt tag_lowert s c G s! | j j | j d f | � d S( s# Move an item TAGORID given in ARGS.t moveN( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� y s c K s) | j j | j d f | j | | � � S( s� Print the contents of the canvas to a postscript
file. Valid options: colormap, colormode, file, fontmap,
height, pageanchor, pageheight, pagewidth, pagex, pagey,
rotate, width, x, y.t
postscript( R. RP R� R� ( RR R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� | s c G s! | j j | j d f | � d S( sJ Raise an item TAGORID given in ARGS
(optional above another item).R� N( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt tag_raise� s c G s! | j j | j d f | � d S( s9 Scale item TAGORID with XORIGIN, YORIGIN, XSCALE, YSCALE.t scaleN( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s# | j j | j d d | | � d S( s& Remember the current X, Y coordinates.t scant markN( R. RP R� ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt scan_mark� s i
c C s& | j j | j d d | | | � d S( s� Adjust the view of the canvas to GAIN times the
difference between X and Y and the coordinates given in
scan_mark.R� t dragtoN( R. RP R� ( RR RA RN t gain( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt scan_dragto� s c C s# | j j | j d d | | � d S( sL Adjust the end of the selection near the cursor of an item TAGORID to index.t selectt adjustN( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
select_adjust� s c C s | j j | j d d � d S( s, Clear the selection if it is in this widget.R� R� N( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt select_clear� s c C s# | j j | j d d | | � d S( s: Set the fixed end of a selection in item TAGORID to INDEX.R� t fromN( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt select_from� s c C s | j j | j d d � p d S( s( Return the item which has the selection.R� R N( R. RP R� R ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt select_item� s c C s# | j j | j d d | | � d S( s= Set the variable end of a selection in item TAGORID to INDEX.R� t toN( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt select_to� s c C s | j j | j d | � p d S( s$ Return the type of the item TAGORID.R N( R. RP R� R ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR � s N(@ R7 R8 R9 R RU R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� t
itemconfigR� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � sx
t Checkbuttonc B sJ e Z d Z d i d � Z d � Z d � Z d � Z d � Z d � Z RS( s7 Checkbutton widget which is either in on- or off-state.c K s t j | | d | | � d S( s Construct a checkbutton widget with the parent MASTER.
Valid resource names: activebackground, activeforeground, anchor,
background, bd, bg, bitmap, borderwidth, command, cursor,
disabledforeground, fg, font, foreground, height,
highlightbackground, highlightcolor, highlightthickness, image,
indicatoron, justify, offvalue, onvalue, padx, pady, relief,
selectcolor, selectimage, state, takefocus, text, textvariable,
underline, variable, width, wraplength.t checkbuttonN( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU � s
c C s | j j | j d � d S( s Put the button in off-state.t deselectN( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s | j j | j d � d S( s Flash the button.R� N( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s | j j | j d � S( s< Toggle the button and invoke a command if given as resource.R� ( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s | j j | j d � d S( s Put the button in on-state.R� N( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s | j j | j d � d S( s Toggle the button.t toggleN( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s N(
R7 R8 R9 R RU R� R� R� R� R� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s t Entryc B s� e Z d Z d i d � Z d d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d � Z e Z
d
� Z e Z d � Z e Z d � Z e Z d
� Z e Z d � Z e Z RS( s1 Entry widget which allows displaying simple text.c K s t j | | d | | � d S( s Construct an entry widget with the parent MASTER.
Valid resource names: background, bd, bg, borderwidth, cursor,
exportselection, fg, font, foreground, highlightbackground,
highlightcolor, highlightthickness, insertbackground,
insertborderwidth, insertofftime, insertontime, insertwidth,
invalidcommand, invcmd, justify, relief, selectbackground,
selectborderwidth, selectforeground, show, state, takefocus,
textvariable, validate, validatecommand, vcmd, width,
xscrollcommand.t entryN( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU � s c C s | j j | j d | | � d S( s. Delete text from FIRST to LAST (not included).R� N( R. RP R� ( RR t firstt last( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s | j j | j d � S( s Return the text.R] ( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR] � s c C s | j j | j d | � d S( s Insert cursor at INDEX.R� N( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s t | j j | j d | � � S( s Return position of cursor.R� ( Ry R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s | j j | j d | | � d S( s Insert STRING at INDEX.R� N( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s | j j | j d d | � d S( s& Remember the current X, Y coordinates.R� R� N( R. RP R� ( RR RA ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s | j j | j d d | � d S( s� Adjust the view of the canvas to 10 times the
difference between X and Y and the coordinates given in
scan_mark.R� R� N( R. RP R� ( RR RA ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s | j j | j d d | � d S( s9 Adjust the end of the selection near the cursor to INDEX.R� R� N( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt selection_adjust� s c C s | j j | j d d � d S( s, Clear the selection if it is in this widget.R� R� N( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s | j j | j d d | � d S( s* Set the fixed end of a selection to INDEX.R� R� N( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt selection_from� s c C s% | j j | j j | j d d � � S( sS Return True if there are characters selected in the entry, False
otherwise.R� t present( R. RO RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt selection_present� s c C s# | j j | j d d | | � d S( s3 Set the selection from START to END (not included).R� t rangeN( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt selection_range� s c C s | j j | j d d | � d S( s- Set the variable end of a selection to INDEX.R� R� N( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt selection_to� s N( R7 R8 R9 R RU R� R] R� R� R� R� R� R� R� R� R� R� R� R� t select_presentR� t select_rangeR� R� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s* t Framec B s e Z d Z d i d � Z RS( sF Frame widget which may contain other widgets and can have a 3D border.c K s� t | | f � } d } d | k r> d | d f } | d =n& d | k rd d | d f } | d =n t j | | d | i | � d S( s Construct a frame widget with the parent MASTER.
Valid resource names: background, bd, bg, borderwidth, class,
colormap, container, cursor, height, highlightbackground,
highlightcolor, highlightthickness, relief, takefocus, visual, width.Rt s -classR� R� N( ( R( Rr RU ( RR RS R# R� Ro ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU
s
N( R7 R8 R9 R RU ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR�
s t Labelc B s e Z d Z d i d � Z RS( s0 Label widget which can display text and bitmaps.c K s t j | | d | | � d S( s� Construct a label widget with the parent MASTER.
STANDARD OPTIONS
activebackground, activeforeground, anchor,
background, bitmap, borderwidth, cursor,
disabledforeground, font, foreground,
highlightbackground, highlightcolor,
highlightthickness, image, justify,
padx, pady, relief, takefocus, text,
textvariable, underline, wraplength
WIDGET-SPECIFIC OPTIONS
height, state, width
t labelN( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU
s N( R7 R8 R9 R RU ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR�
s t Listboxc B s� e Z d Z d i d � Z d � Z d � Z d � Z d d � Z d d � Z d � Z
d � Z d � Z d
� Z
d � Z d � Z d
� Z e Z d d � Z e Z d � Z e Z d d � Z e Z d � Z d � Z d d � Z e Z RS( s3 Listbox widget which can display a list of strings.c K s t j | | d | | � d S( s� Construct a listbox widget with the parent MASTER.
Valid resource names: background, bd, bg, borderwidth, cursor,
exportselection, fg, font, foreground, height, highlightbackground,
highlightcolor, highlightthickness, relief, selectbackground,
selectborderwidth, selectforeground, selectmode, setgrid, takefocus,
width, xscrollcommand, yscrollcommand, listvariable.t listboxN( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU .
s c C s | j j | j d | � d S( s" Activate item identified by INDEX.t activateN( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� 7
s c C s( | j | j j | j d | � � p' d S( sx Return a tuple of X1,Y1,X2,Y2 coordinates for a rectangle
which encloses the item identified by the given index.R� N( R R. RP R� R ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� :
s c C s% | j | j j | j d � � p$ d S( s. Return the indices of currently selected item.t curselection( ( R R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� >
s c C s | j j | j d | | � d S( s+ Delete items from FIRST to LAST (included).R� N( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� A
s c C sQ | d k r4 | j j | j j | j d | | � � S| j j | j d | � Sd S( s0 Get list of items from FIRST to LAST (included).R] N( R R. R* RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR] D
s c C s5 | j j | j d | � } | d k r+ d St | � S( s+ Return index of item identified with INDEX.R� R� N( R. RP R� R Ry ( RR R� t i( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� K
s c G s$ | j j | j d | f | � d S( s Insert ELEMENTS at INDEX.R� N( R. RP R� ( RR R� t elements( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� P
s c C s t | j j | j d | � � S( s5 Get index of item which is nearest to y coordinate Y.t nearest( Ry R. RP R� ( RR RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� S
s c C s# | j j | j d d | | � d S( s& Remember the current X, Y coordinates.R� R� N( R. RP R� ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� W
s c C s# | j j | j d d | | � d S( s� Adjust the view of the listbox to 10 times the
difference between X and Y and the coordinates given in
scan_mark.R� R� N( R. RP R� ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� Z
s c C s | j j | j d | � d S( s" Scroll such that INDEX is visible.t seeN( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� _
s c C s | j j | j d d | � d S( s- Set the fixed end oft the selection to INDEX.R� t anchorN( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt selection_anchorb
s c C s# | j j | j d d | | � d S( s2 Clear the selection from FIRST to LAST (included).R� R� N( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� f
s c C s( | j j | j j | j d d | � � S( s+ Return 1 if INDEX is part of the selection.R� t includes( R. RO RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt selection_includesk
s c C s# | j j | j d d | | � d S( si Set the selection from FIRST to LAST (included) without
changing the currently selected elements.R� RN N( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
selection_setp
s c C s t | j j | j d � � S( s- Return the number of elements in the listbox.R� ( Ry R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� u
s c C s' | j j | j d f | d | f � S( s4 Return the resource value for an ITEM and an OPTION.R� R) ( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� x
s c K s | j d | f | | � S( s9 Configure resources of an ITEM.
The values for resources are specified as keyword arguments.
To get an overview about the allowed keyword arguments
call the method without arguments.
Valid resource names: background, bg, foreground, fg,
selectbackground, selectforeground.R� ( R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� |
s N( R7 R8 R9 R RU R� R� R� R� R] R� R� R� R� R� R� R� t
select_anchorR� R� R� t select_includesR� t
select_setR� R� R� R� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� ,
s2 t Menuc B s� e Z d Z d% i d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d � Z d
� Z
d � Z d � Z d
d � Z d � Z i d � Z i d � Z i d � Z i d � Z i d � Z i d � Z i d � Z i d � Z i d � Z i d � Z i d � Z i d � Z d% d � Z d � Z d% d � Z e Z! d � Z" d � Z# d! � Z$ d" � Z% d# � Z& d$ � Z' RS(& sP Menu widget which allows displaying menu bars, pull-down menus and pop-up menus.c K s t j | | d | | � d S( sA Construct menu widget with the parent MASTER.
Valid resource names: activebackground, activeborderwidth,
activeforeground, background, bd, bg, borderwidth, cursor,
disabledforeground, fg, font, foreground, postcommand, relief,
selectcolor, takefocus, tearoff, tearoffcommand, title, type.t menuN( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU �
s c C s& d d l } | j d t d d �d S( Ni����s= tk_bindForTraversal() does nothing and will be removed in 3.6R� i ( R� R� R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt tk_bindForTraversal�
s c C s | j j d | j � d S( Nt tk_mbPost( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR �
s c C s | j j d � d S( Nt tk_mbUnpost( R. RP ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR �
s c C s | j j d | j | � d S( Nt tk_traverseToMenu( R. RP R� ( RR Rx ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR �
s c C s | j j d | j | � d S( Nt tk_traverseWithinMenu( R. RP R� ( RR Rx ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR �
s c C s | j j d | j � S( Nt tk_getMenuButtons( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR �
s c C s | j j d | � d S( Nt tk_nextMenu( R. RP ( RR t count( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR
�
s c C s | j j d | � d S( Nt tk_nextMenuEntry( R. RP ( RR R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR �
s c C s | j j d | j � d S( Nt
tk_invokeMenu( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR
�
s c C s | j j d | j � d S( Nt tk_firstMenu( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR �
s c C s | j j d | j � d S( Nt tk_mbButtonDown( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR �
s RE c C s# | j j d | j | | | � d S( s/ Post the menu at position X,Y with entry ENTRY.t tk_popupN( R. RP R� ( RR RA RN R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR �
s c C s | j j | j d | � d S( s Activate entry at INDEX.R� N( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c K s0 | j j | j d | f | j | | � � d S( s Internal function.R� N( R. RP R� R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c K s | j d | p | � d S( s Add hierarchical menu item.t cascadeN( R� ( RR R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt add_cascade�
s c K s | j d | p | � d S( s Add checkbutton menu item.R� N( R� ( RR R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt add_checkbutton�
s c K s | j d | p | � d S( s Add command menu item.R� N( R� ( RR R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt add_command�
s c K s | j d | p | � d S( s Addd radio menu item.t radiobuttonN( R� ( RR R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt add_radiobutton�
s c K s | j d | p | � d S( s Add separator.t separatorN( R� ( RR R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
add_separator�
s c K s3 | j j | j d | | f | j | | � � d S( s Internal function.R� N( R. RP R� R� ( RR R� R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c K s | j | d | p | � d S( s$ Add hierarchical menu item at INDEX.R N( R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt insert_cascade�
s c K s | j | d | p | � d S( s# Add checkbutton menu item at INDEX.R� N( R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt insert_checkbutton�
s c K s | j | d | p | � d S( s Add command menu item at INDEX.R� N( R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt insert_command�
s c K s | j | d | p | � d S( s Addd radio menu item at INDEX.R N( R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt insert_radiobutton�
s c K s | j | d | p | � d S( s Add separator at INDEX.R N( R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt insert_separator�
s c C s� | d k r | } n | j | � | j | � } } | d k sL | d k r[ d \ } } n xa t | | d � D]L } d | j | � k ro t | j | d � � } | r� | j | � q� qo qo W| j j | j d | | � d S( s7 Delete menu items between INDEX1 and INDEX2 (included).i i����i R� R� N( i i����(
R R� R� t entryconfigR t entrycgetRX R. RP R� ( RR t index1t index2t
num_index1t
num_index2R� R$ ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c C s | j j | j d | d | � S( s= Return the resource value of a menu item for OPTION at INDEX.R R) ( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR �
s c K s | j d | f | | � S( s Configure a menu item at INDEX.t entryconfigure( R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR$ �
s c C s5 | j j | j d | � } | d k r+ d St | � S( s4 Return the index of a menu item identified by INDEX.R� R� N( R. RP R� R Ry ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c C s | j j | j d | � S( sR Invoke a menu item identified by INDEX and execute
the associated command.R� ( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c C s | j j | j d | | � d S( s Display a menu at position X,Y.t postN( R. RP R� ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR% �
s c C s | j j | j d | � S( s* Return the type of the menu item at INDEX.R ( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR �
s c C s | j j | j d � d S( s
Unmap a menu.t unpostN( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR& �
s c C s t | j j | j d | � � S( sE Return the y-position of the topmost pixel of the menu item at INDEX.t yposition( Ry R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR' �
s N(( R7 R8 R9 R RU R R R R R R R
R R
R R R R� R� R R R R R R� R R R R R R� R R$ R R� R� R% R R& R' ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR �
sJ t
Menubuttonc B s e Z d Z d i d � Z RS( s( Menubutton widget, obsolete since Tk8.0.c K s t j | | d | | � d S( Nt
menubutton( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU s N( R7 R8 R9 R RU ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR( s t Messagec B s e Z d Z d i d � Z RS( sK Message widget to display multiline text. Obsolete since Label does it too.c K s t j | | d | | � d S( Nt message( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU s N( R7 R8 R9 R RU ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR* s t Radiobuttonc B sA e Z d Z d i d � Z d � Z d � Z d � Z d � Z RS( sG Radiobutton widget which shows only one of several buttons in on-state.c K s t j | | d | | � d S( s� Construct a radiobutton widget with the parent MASTER.
Valid resource names: activebackground, activeforeground, anchor,
background, bd, bg, bitmap, borderwidth, command, cursor,
disabledforeground, fg, font, foreground, height,
highlightbackground, highlightcolor, highlightthickness, image,
indicatoron, justify, padx, pady, relief, selectcolor, selectimage,
state, takefocus, text, textvariable, underline, value, variable,
width, wraplength.R N( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU s
c C s | j j | j d � d S( s Put the button in off-state.R� N( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� s c C s | j j | j d � d S( s Flash the button.R� N( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� s c C s | j j | j d � S( s< Toggle the button and invoke a command if given as resource.R� ( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� " s c C s | j j | j d � d S( s Put the button in on-state.R� N( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� % s N( R7 R8 R9 R RU R� R� R� R� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR, s t Scalec B sD e Z d Z d i d � Z d � Z d � Z d d � Z d � Z RS( s1 Scale widget which can display a numerical scale.c K s t j | | d | | � d S( s� Construct a scale widget with the parent MASTER.
Valid resource names: activebackground, background, bigincrement, bd,
bg, borderwidth, command, cursor, digits, fg, font, foreground, from,
highlightbackground, highlightcolor, highlightthickness, label,
length, orient, relief, repeatdelay, repeatinterval, resolution,
showvalue, sliderlength, sliderrelief, state, takefocus,
tickinterval, to, troughcolor, variable, width.R� N( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU + s c C sE | j j | j d � } y t | � SWn t k
r@ t | � SXd S( s* Get the current value as integer or float.R] N( R. RP R� Ry R@ R{ ( RR R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR] 5 s
c C s | j j | j d | � d S( s Set the value to VALUE.RN N( R. RP R� ( RR R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRN < s c C s" | j | j j | j d | � � S( s� Return a tuple (X,Y) of the point along the centerline of the
trough that corresponds to VALUE or the current value if None is
given.R� ( R R. RP R� ( RR R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� ? s c C s | j j | j d | | � S( sc Return where the point X,Y lies. Valid return values are "slider",
"though1" and "though2".t identify( R. RP R� ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR. E s N( R7 R8 R9 R RU R] RN R� R. ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR- ) s
t Scrollbarc B sS e Z d Z d i d � Z d � Z d � Z d � Z d � Z d � Z d � Z
RS( s? Scrollbar widget which displays a slider at a certain position.c K s t j | | d | | � d S( sl Construct a scrollbar widget with the parent MASTER.
Valid resource names: activebackground, activerelief,
background, bd, bg, borderwidth, command, cursor,
elementborderwidth, highlightbackground,
highlightcolor, highlightthickness, jump, orient,
relief, repeatdelay, repeatinterval, takefocus,
troughcolor, width.t scrollbarN( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU L s c C s | j j | j d | � d S( sx Display the element at INDEX with activebackground and activerelief.
INDEX can be "arrow1","slider" or "arrow2".R� N( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� V s c C s" t | j j | j d | | � � S( sn Return the fractional change of the scrollbar setting if it
would be moved by DELTAX or DELTAY pixels.R ( R{ R. RP R� ( RR t deltaxt deltay( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR Z s c C s" t | j j | j d | | � � S( sR Return the fractional value which corresponds to a slider
position of X,Y.R� ( R{ R. RP R� ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� _ s c C s | j j | j d | | � S( sY Return the element under position X,Y as one of
"arrow1","slider","arrow2" or "".R. ( R. RP R� ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR. c s c C s | j | j j | j d � � S( sZ Return the current fractional values (upper and lower end)
of the slider position.R] ( Rd R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR] g s c G s! | j j | j d f | � d S( si Set the fractional values of the slider position (upper and
lower ends as value between 0 and 1).RN N( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRN k s N( R7 R8 R9 R RU R� R R� R. R] RN ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR/ J s
t Textc B sH e Z d Z d5 i d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d5 d � Z d5 d � Z d
� Z
d5 d5 d � Z d � Z d5 d
� Z d � Z d � Z d � Z d � Z d5 d � Z d � Z d5 d � Z i d � Z d � Z d � Z d � Z d5 d � Z d � Z d � Z d � Z d � Z d � Z! d � Z" d � Z# d5 d5 d5 d5 d5 d5 d5 d5 d! � Z$ d" � Z% d# � Z& d5 d$ � Z' d5 d% � Z( d& � Z) d5 d' � Z* e* Z+ d( � Z, d5 d) � Z- d5 d* � Z. d5 d+ � Z/ d5 d, � Z0 d5 d- � Z1 d. � Z2 d5 d/ � Z3 d0 � Z4 d5 d1 � Z5 e5 Z6 i d2 � Z7 d3 � Z8 d4 � Z9 RS(6 s4 Text widget which can display text in various forms.c K s t j | | d | | � d S( s� Construct a text widget with the parent MASTER.
STANDARD OPTIONS
background, borderwidth, cursor,
exportselection, font, foreground,
highlightbackground, highlightcolor,
highlightthickness, insertbackground,
insertborderwidth, insertofftime,
insertontime, insertwidth, padx, pady,
relief, selectbackground,
selectborderwidth, selectforeground,
setgrid, takefocus,
xscrollcommand, yscrollcommand,
WIDGET-SPECIFIC OPTIONS
autoseparators, height, maxundo,
spacing1, spacing2, spacing3,
state, tabs, undo, width, wrap,
R� N( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU t s c G s, | j | j j | j d f | � � p+ d S( s� Return a tuple of (x,y,width,height) which gives the bounding
box of the visible part of the character at the index in ARGS.R� N( R R. RP R� R ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s | j j d | j | � d S( Nt tk_textSelectTo( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR4 � s c C s | j j d | j � d S( Nt tk_textBackspace( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR5 � s c C s# | j j d | j | | | � d S( Nt tk_textIndexCloser( R. RP R� ( RR R� R� R$ ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR6 � s c C s | j j d | j | � d S( Nt tk_textResetAnchor( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR7 � s c C s+ | j j | j j | j d | | | � � S( s� Return whether between index INDEX1 and index INDEX2 the
relation OP is satisfied. OP is one of <, <=, ==, >=, >, or !=.t compare( R. RO RP R� ( RR R t opR! ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR8 � s c C sK | d k r. | j j | j j | j d � � S| j j | j d | � d S( sj Turn on the internal consistency checks of the B-Tree inside the text
widget according to BOOLEAN.t debugN( R R. RO RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR: � s "c C s | j j | j d | | � d S( s? Delete the characters between INDEX1 and INDEX2 (not included).R� N( R. RP R� ( RR R R! ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s" | j | j j | j d | � � S( s� Return tuple (x,y,width,height,baseline) giving the bounding box
and baseline position of the visible part of the line containing
the character at INDEX.t dlineinfo( R R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR; � s c
K s� g } d } d } | s3 g } | d � } | } n z� t | t � s[ | j | � } } n | d | g 7} x, | D]$ } | | rr | j d | � qr qr W| j | � | r� | j | � n | j j | j d | � | SWd | r� | j | � n Xd S( s� Return the contents of the widget between index1 and index2.
The type of contents returned in filtered based on the keyword
parameters; if 'all', 'image', 'mark', 'tag', 'text', or 'window' are
given and true, then the corresponding items are returned. The result
is a list of triples of the form (key, value, index). If none of the
keywords are true then 'all' is used by default.
If the 'command' argument is given, it is called once for each element
of the list of triples, with the values of each triple serving as the
arguments to the function. In this case the list is not returned.c S s | j | | | f � d S( N( Re ( R4 R R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
append_triple� s s -commandR) t dumpN( R R R R� Re R. RP R� RX (
RR R R! R� R� R� t func_nameR� R< R4 ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR= � s*
c G s | j j | j d | � S( sr Internal method
This method controls the undo mechanism and
the modified flag. The exact behavior of the
command depends on the option argument that
follows the edit argument. The following forms
of the command are currently supported:
edit_modified, edit_redo, edit_reset, edit_separator
and edit_undo
t edit( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR? � s
c C s | j d | � S( s; Get or Set the modified flag
If arg is not specified, returns the modified
flag of the widget. The insert, delete, edit undo and
edit redo commands or the user can set or clear the
modified flag. If boolean is specified, sets the
modified flag of the widget to arg.
t modified( R? ( RR t arg( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
edit_modified� s c C s
| j d � S( s Redo the last undone edit
When the undo option is true, reapplies the last
undone edits provided no other edits were done since
then. Generates an error when the redo stack is empty.
Does nothing when the undo option is false.
t redo( R? ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt edit_redo� s c C s
| j d � S( s( Clears the undo and redo stacks
t reset( R? ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
edit_reset� s c C s
| j d � S( sn Inserts a separator (boundary) on the undo stack.
Does nothing when the undo option is false
R ( R? ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt edit_separator� s c C s
| j d � S( sD Undoes the last edit action
If the undo option is true. An edit action is defined
as all the insert and delete commands that are recorded
on the undo stack in between two separators. Generates
an error when the undo stack is empty. Does nothing
when the undo option is false
t undo( R? ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt edit_undo s c C s | j j | j d | | � S( s5 Return the text from INDEX1 to INDEX2 (not included).R] ( R. RP R� ( RR R R! ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR] s c C sY | d d k r d | } n | d d k r: | d } n | j j | j d d | | � S( s9 Return the value of OPTION of an embedded image at INDEX.i R) i����Ri R� R� ( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
image_cget s
c K s | j d d | f | | � S( s% Configure an embedded image at INDEX.R� R� ( R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt image_configure s c K s+ | j j | j d d | | j | | � � S( s" Create an embedded image at INDEX.R� R. ( R. RP R� R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt image_create s c C s | j j | j d d � S( s3 Return all names of embedded images in this widget.R� R� ( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� " s c C s t | j j | j d | � � S( s1 Return the index in the form line.char for INDEX.R� ( R R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� % s c G s' | j j | j d | | f | � d S( s� Insert CHARS before the characters at INDEX. An additional
tag can be given in ARGS. Additional CHARS and tags can follow in ARGS.R� N( R. RP R� ( RR R� t charsR� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� ( s c C s" | j j | j d d | | f � S( s� Change the gravity of a mark MARKNAME to DIRECTION (LEFT or RIGHT).
Return the current value if None is given for DIRECTION.R� t gravity( R. RP R� ( RR t markNamet direction( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt mark_gravity, s c C s% | j j | j j | j d d � � S( s Return all mark names.R� R� ( R. R* RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
mark_names1 s c C s# | j j | j d d | | � d S( s0 Set mark MARKNAME before the character at INDEX.R� RN N( R. RP R� ( RR RO R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt mark_set5 s c G s$ | j j | j d d f | � d S( s Delete all marks in MARKNAMES.R� t unsetN( R. RP R� ( RR t markNames( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
mark_unset8 s c C s" | j j | j d d | � p! d S( s- Return the name of the next mark after INDEX.R� t nextN( R. RP R� R ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt mark_next; s c C s" | j j | j d d | � p! d S( s2 Return the name of the previous mark before INDEX.R� t previousN( R. RP R� R ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
mark_previous> s c C s# | j j | j d d | | � d S( s& Remember the current X, Y coordinates.R� R� N( R. RP R� ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� A s c C s# | j j | j d d | | � d S( s~ Adjust the view of the text to 10 times the
difference between X and Y and the coordinates given in
scan_mark.R� R� N( R. RP R� ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� D s c C s( | j d g } | r% | j d � n | r; | j d � n | rQ | j d � n | rg | j d � n | r} | j d � n |
r� | j d � n | r� | j d � | j | � n | r� | d d
k r� | j d � n | j | � | j | � | r | j | � n t | j j t | � � � S( s� Search PATTERN beginning from INDEX until STOPINDEX.
Return the index of the first character of a match or an
empty string.R s -forwardss
-backwardss -exacts -regexps -nocases -elides -counti R) s --( R� Re R R. RP R ( RR R� R� t stopindext forwardst backwardst exactt regexpt nocaseR t elideR� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR I s.
c C s | j j | j d | � d S( s3 Scroll such that the character at INDEX is visible.R� N( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� \ s c G s* | j j | j d d | | f | � d S( s| Add tag TAGNAME to all characters between INDEX1 and index2 in ARGS.
Additional pairs of indices may follow in ARGS.t tagR� N( R. RP R� ( RR t tagNameR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt tag_add_ s c C s< | j j | j d d | | d � | r8 | j | � n d S( sg Unbind for all characters with TAGNAME for event SEQUENCE the
function identified with FUNCID.Rb R\ RE N( R. RP R� RX ( RR Rc RX RZ ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� d s "c C s% | j | j d d | f | | | � S( s+ Bind to all characters with TAGNAME at event SEQUENCE a call to function FUNC.
An additional boolean parameter ADD specifies whether FUNC will be
called additionally to the other bound function or whether it will
replace the previous function. See bind for the return value.Rb R\ ( R[ R� ( RR Rc RX R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� j s c C sY | d d k r d | } n | d d k r: | d } n | j j | j d d | | � S( s+ Return the value of OPTION for tag TAGNAME.i R) i����Ri Rb R� ( R. RP R� ( RR Rc R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt tag_cgetr s
c K s | j d d | f | | � S( s Configure a tag TAGNAME.Rb R� ( R� ( RR Rc R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
tag_configurey s c G s$ | j j | j d d f | � d S( s Delete all tags in TAGNAMES.Rb R� N( R. RP R� ( RR t tagNames( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
tag_delete} s c C s# | j j | j d d | | � d S( s` Change the priority of tag TAGNAME such that it is lower
than the priority of BELOWTHIS.Rb R� N( R. RP R� ( RR Rc R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s( | j j | j j | j d d | � � S( s Return a list of all tag names.Rb R� ( R. R* RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt tag_names� s c C s. | j j | j j | j d d | | | � � S( s� Return a list of start and end index for the first sequence of
characters between INDEX1 and INDEX2 which all have tag TAGNAME.
The text is searched forward from INDEX1.Rb t nextrange( R. R* RP R� ( RR Rc R R! ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
tag_nextrange� s c C s. | j j | j j | j d d | | | � � S( s� Return a list of start and end index for the first sequence of
characters between INDEX1 and INDEX2 which all have tag TAGNAME.
The text is searched backwards from INDEX1.Rb t prevrange( R. R* RP R� ( RR Rc R R! ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
tag_prevrange� s c C s# | j j | j d d | | � d S( sa Change the priority of tag TAGNAME such that it is higher
than the priority of ABOVETHIS.Rb R� N( R. RP R� ( RR Rc R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s( | j j | j j | j d d | � � S( s7 Return a list of ranges of text which have tag TAGNAME.Rb t ranges( R. R* RP R� ( RR Rc ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
tag_ranges� s c C s& | j j | j d d | | | � d S( sA Remove tag TAGNAME from all characters between INDEX1 and INDEX2.Rb Rm N( R. RP R� ( RR Rc R R! ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
tag_remove� s c C sY | d d k r d | } n | d d k r: | d } n | j j | j d d | | � S( s: Return the value of OPTION of an embedded window at INDEX.i R) i����Ri R� R� ( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt window_cget� s
c K s | j d d | f | | � S( s& Configure an embedded window at INDEX.R� R� ( R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt window_configure� s c K s3 | j j | j d d | f | j | | � � d S( s Create a window at INDEX.R� R. N( R. RP R� R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
window_create� s c C s% | j j | j j | j d d � � S( s4 Return all names of embedded windows in this widget.R� R� ( R. R* RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt window_names� s c G s$ | j j | j d d f | � d S( s Obsolete function, use see.R� s
-pickplaceN( R. RP R� ( RR RW ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt yview_pickplace� s N(: R7 R8 R9 R RU R� R4 R5 R6 R7 R8 R: R� R; R= R? RB RD RF RG RI R] RJ RK RL R� R� R� RQ RR RS RV RX RZ R� R� R R� Rd R� R� Re Rf t
tag_configRh R� Ri Rk Rm R� Ro Rp Rq Rr t
window_configRs Rt Ru ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR3 r sr (
t _setitc B s# e Z d Z d d � Z d � Z RS( s> Internal class. It wraps the command in the widget OptionMenu.c C s | | _ | | _ | | _ d S( N( t
_setit__valuet _setit__vart _setit__callback( RR t varR Rg ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU � s c G s6 | j j | j � | j r2 | j | j | � n d S( N( Rz RN Ry R{ ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRa � s N( R7 R8 R9 R RU Ra ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRx � s t
OptionMenuc B s) e Z d Z d � Z d � Z d � Z RS( s? OptionMenu which allows the user to select a value from a menu.c
O s" i d d 6| d 6d d 6t d 6d d 6d d 6} t j | | d
| � d | _ t | d d
d d �} | _ | j | _ | j d � } d | k r� | d =n | r� t d | j
� d � n | j d | d t | | | � � x0 | D]( } | j d | d t | | | � � q� W| | d
<d S( s� Construct an optionmenu widget with the parent MASTER, with
the resource textvariable set to VARIABLE, the initially selected
value VALUE, the other menu values VALUES and an additional
keyword argument command.i t borderwidtht textvariablei t indicatoront reliefR$ R� t highlightthicknessR) t
tk_optionMenuRT R t tearoffi R� s unknown option -R� N(
t RAISEDRr RU Rm R t _OptionMenu__menuR� t menunameR] R� R� R Rx (
RR RS R_ R RD t kwargsR� R Rg R' ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU � s$
c C s# | d k r | j St j | | � S( NR ( R� Rr R� ( RR RT ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s t j | � d | _ d S( s, Destroy this widget and the associated menu.N( R( R� R R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s
( R7 R8 R9 RU R� R� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR} � s t Imagec B st e Z d Z d Z d i d d � Z d � Z d � Z d � Z d � Z d � Z
e
Z d � Z d � Z
d
� Z RS( s Base class for images.i c K s^ d | _ | s* t } | s* t d � q* n t | d | � | _ | s� t j d 7_ d t j f } | d d k r� d | d } q� n | r� | r� t | | f � } n | r� | } n d
} xp | j � D]b \ } } t
| d � r� | j | � } n! | d k r| j j | � } n | d | | f } q� W| j j
d d | | f | � | | _ d S( Ns Too early to create imageR. i s pyimage%ri R) Ri Ra R� t maskdataR� R. ( ( R� R� ( R RT R; R+ RW R. R� t _last_idR( R! Rj R� t _createbytearrayRP ( RR t imgtypeRT R# RS R� R� R& R' ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU � s0 c C s | j S( N( RT ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRZ
RE c C sA | j r= y | j j d d | j � Wq= t k
r9 q= Xn d S( NR� R� ( RT R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRY
s
c C s$ | j j | j d d | | � d S( NR� R) ( R. RP RT ( RR R4 R ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR�
s c C s | j j | j d d | � S( NR� R) ( R. RP RT ( RR R4 ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR�
s c K s� d } x� t | � j � D]� \ } } | d k r | d d k rN | d } n t | d � ro | j | � } n! | d
k r� | j j | � } n | d | | f } q q W| j j | j d f | � d S( s Configure the image.i����Ri Ra R� R� R) R� N( ( R� R� ( R( R! R Rj R� R. R� RP RT ( RR R� R R& R' ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR�
s
c C s t | j j d d | j � � S( s Return the height of the image.R� R� ( Ry R. RP RT ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR�
s c C s | j j d d | j � S( s7 Return the type of the image, e.g. "photo" or "bitmap".R� R ( R. RP RT ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR "
s c C s t | j j d d | j � � S( s Return the width of the image.R� RK ( Ry R. RP RT ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRK %
s N( R7 R8 R9 R� R RU RZ RY R� R� R� R� R� R RK ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s t
PhotoImagec B s� e Z d Z d i d d � Z d � Z d � Z d � Z d � Z d d � Z d d � Z
d � Z d d
� Z d d d � Z
RS(
s= Widget which can display images in PGM, PPM, GIF, PNG format.c K s t j | d | | | | � d S( st Create an image with NAME.
Valid resource names: data, format, file, gamma, height, palette,
width.t photoN( R� RU ( RR RT R# RS R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU ,
s c C s | j j | j d � d S( s Display a transparent image.t blankN( R. RP RT ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� 2
s c C s | j j | j d d | � S( s Return the value of OPTION.R� R) ( R. RP RT ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� 5
s c C s | j j | j d d | � S( NR� R) ( R. RP RT ( RR R4 ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� 9
s c C s/ t d | j � } | j j | d | j � | S( s; Return a new PhotoImage with the same image as this widget.RS t copy( R� R. RP RT ( RR t destImage( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� <
s RE c C sM t d | j � } | d k r' | } n | j j | d | j d | | � | S( s� Return a new PhotoImage with the same image as this widget
but zoom it with a factor of x in the X direction and y in the Y
direction. If y is not given, the default value is the same as x.
RS RE R� s -zoom( R� R. RP RT ( RR RA RN R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt zoomA
s
"c C sM t d | j � } | d k r' | } n | j j | d | j d | | � | S( s� Return a new PhotoImage based on the same image as this widget
but use only every Xth or Yth pixel. If y is not given, the
default value is the same as x.
RS RE R� s
-subsample( R� R. RP RT ( RR RA RN R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt subsampleJ
s
"c C s | j j | j d | | � S( s8 Return the color (red, green, blue) of the pixel at X,Y.R] ( R. RP RT ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR] S
s c C s` | j d | f } | rL | d d k r5 | d } n | d t | � } n | j j | � d S( sz Put row formatted colors to image starting from
position TO, e.g. image.put("{red green} {blue yellow}", to=(4,6))t puti s -toi N( s -to( RT R R. RP ( RR R� R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� V
s
c C s\ | j d | f } | r+ | d | f } n | rH | d t | � } n | j j | � d S( sR Write image to file FILENAME in FORMAT starting from
position FROM_COORDS.t writes -formats -fromN( s -from( RT R R. RP ( RR t filenamet formatt from_coordsR� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� `
s N( R7 R8 R9 R RU R� R� R� R� R� R� R] R� R� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� *
s
t BitmapImagec B s e Z d Z d i d d � Z RS( s. Widget which can display images in XBM format.c K s t j | d | | | | � d S( sq Create a bitmap with NAME.
Valid resource names: background, data, file, foreground, maskdata, maskfile.R N( R� RU ( RR RT R# RS R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU l
s N( R7 R8 R9 R RU ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� j
s c C s t j j t j j d d � � S( NR� R� ( R; R. R* RP ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� r
s c C s t j j t j j d d � � S( NR� R� ( R; R. R* RP ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� u
s t Spinboxc B s� e Z d Z d i d � Z d � Z d d � Z d � Z d � Z d � Z d � Z
d � Z d � Z d
� Z
d � Z d � Z d
� Z d � Z d � Z d d � Z RS( s spinbox widget.c K s t j | | d | | � d S( s� Construct a spinbox widget with the parent MASTER.
STANDARD OPTIONS
activebackground, background, borderwidth,
cursor, exportselection, font, foreground,
highlightbackground, highlightcolor,
highlightthickness, insertbackground,
insertborderwidth, insertofftime,
insertontime, insertwidth, justify, relief,
repeatdelay, repeatinterval,
selectbackground, selectborderwidth
selectforeground, takefocus, textvariable
xscrollcommand.
WIDGET-SPECIFIC OPTIONS
buttonbackground, buttoncursor,
buttondownrelief, buttonuprelief,
command, disabledbackground,
disabledforeground, format, from,
invalidcommand, increment,
readonlybackground, state, to,
validate, validatecommand values,
width, wrap,
t spinboxN( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU {
s c C s( | j | j j | j d | � � p' d S( s� Return a tuple of X1,Y1,X2,Y2 coordinates for a
rectangle which encloses the character given by index.
The first two elements of the list give the x and y
coordinates of the upper-left corner of the screen
area covered by the character (in pixels relative
to the widget) and the last two elements give the
width and height of the character, in pixels. The
bounding box may refer to a region outside the
visible area of the window.
R� N( R R. RP R� R ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c C s | j j | j d | | � S( sW Delete one or more elements of the spinbox.
First is the index of the first character to delete,
and last is the index of the character just after
the last one to delete. If last isn't specified it
defaults to first+1, i.e. a single character is
deleted. This command returns an empty string.
R� ( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c C s | j j | j d � S( s Returns the spinbox's stringR] ( R. RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR] �
s c C s | j j | j d | � S( s� Alter the position of the insertion cursor.
The insertion cursor will be displayed just before
the character given by index. Returns an empty string
R� ( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c C s | j j | j d | | � S( s{ Returns the name of the widget at position x, y
Return value is one of: none, buttondown, buttonup, entry
R. ( R. RP R� ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR. �
s c C s | j j | j d | � S( s; Returns the numerical index corresponding to index
R� ( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c C s | j j | j d | | � S( sD Insert string s at index
Returns an empty string.
R� ( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c C s | j j | j d | � S( s� Causes the specified element to be invoked
The element could be buttondown or buttonup
triggering the action associated with it.
R� ( R. RP R� ( RR t element( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c G s, | j | j j | j d f | � � p+ d S( s Internal function.R� ( ( R R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c C s | j d | � S( s� Records x and the current view in the spinbox window;
used in conjunction with later scan dragto commands.
Typically this command is associated with a mouse button
press in the widget. It returns an empty string.
R� ( R� ( RR RA ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c C s | j d | � S( s� Compute the difference between the given x argument
and the x argument to the last scan mark command
It then adjusts the view left or right by 10 times the
difference in x-coordinates. This command is typically
associated with mouse motion events in the widget, to
produce the effect of dragging the spinbox at high speed
through the window. The return value is an empty string.
R� ( R� ( RR RA ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s
c G s, | j | j j | j d f | � � p+ d S( s Internal function.R� ( ( R R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c C s | j d | � S( s� Locate the end of the selection nearest to the character
given by index,
Then adjust that end of the selection to be at index
(i.e including but not going beyond index). The other
end of the selection is made the anchor point for future
select to commands. If the selection isn't currently in
the spinbox, then a new selection is created to include
the characters between index and the most recent selection
anchor point, inclusive.
R� ( R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� �
s c C s
| j d � S( ss Clear the selection
If the selection isn't in this widget then the
command has no effect.
R� ( R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� s c C s | j j | j d d | � S( s� Sets or gets the currently selected element.
If a spinbutton element is specified, it will be
displayed depressed.
R� R� ( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt selection_element
s N( R7 R8 R9 R RU R� R� R] R� R. R� R� R� R� R� R� R� R� R� R� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� y
s" t
LabelFramec B s e Z d Z d i d � Z RS( s labelframe widget.c K s t j | | d | | � d S( s� Construct a labelframe widget with the parent MASTER.
STANDARD OPTIONS
borderwidth, cursor, font, foreground,
highlightbackground, highlightcolor,
highlightthickness, padx, pady, relief,
takefocus, text
WIDGET-SPECIFIC OPTIONS
background, class, colormap, container,
height, labelanchor, labelwidget,
visual, width
t
labelframeN( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU s N( R7 R8 R9 R RU ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� s t PanedWindowc B s� e Z d Z d i d � Z d � Z d � Z e Z d � Z d � Z d � Z
d � Z d � Z d � Z
d
� Z d � Z d � Z d
� Z d d � Z e Z d � Z RS( s panedwindow widget.c K s t j | | d | | � d S( sT Construct a panedwindow widget with the parent MASTER.
STANDARD OPTIONS
background, borderwidth, cursor, height,
orient, relief, width
WIDGET-SPECIFIC OPTIONS
handlepad, handlesize, opaqueresize,
sashcursor, sashpad, sashrelief,
sashwidth, showhandle,
t panedwindowN( Rr RU ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU / s c K s- | j j | j d | f | j | � � d S( s+ Add a child widget to the panedwindow in a new pane.
The child argument is the name of the child widget
followed by pairs of arguments that specify how to
manage the windows. The possible options and values
are the ones accepted by the paneconfigure method.
R� N( R. RP R� R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� ? s c C s | j j | j d | � d S( s� Remove the pane containing child from the panedwindow
All geometry management options for child will be forgotten.
R] N( R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRm I s c C s | j j | j d | | � S( s� Identify the panedwindow component at point x, y
If the point is over a sash or a sash handle, the result
is a two element list containing the index of the sash or
handle, and a word indicating whether it is over a sash
or a handle, such as {0 sash} or {2 handle}. If the point
is over any other part of the panedwindow, the result is
an empty list.
R. ( R. RP R� ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR. Q s
c G s, | j | j j | j d f | � � p+ d S( s Internal function.t proxy( ( R R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� ] s c C s
| j d � S( sB Return the x and y pair of the most recent proxy location
t coord( R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt proxy_coordb s c C s
| j d � S( s+ Remove the proxy from the display.
R] ( R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt proxy_forgetg s c C s | j d | | � S( s: Place the proxy at the given x and y coordinates.
R� ( R� ( RR RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt proxy_placel s c G s, | j | j j | j d f | � � p+ d S( s Internal function.t sash( ( R R. RP R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� q s c C s | j d | � S( sA Return the current x and y pair for the sash given by index.
Index must be an integer between 0 and 1 less than the
number of panes in the panedwindow. The coordinates given are
those of the top left corner of the region containing the sash.
pathName sash dragto index x y This command computes the
difference between the given coordinates and the coordinates
given to the last sash coord command for the given sash. It then
moves that sash the computed difference. The return value is the
empty string.
R� ( R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
sash_coordv s c C s | j d | � S( s Records x and y for the sash given by index;
Used in conjunction with later dragto commands to move the sash.
R� ( R� ( RR R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt sash_mark� s c C s | j d | | | � S( s? Place the sash given by index at the given coordinates
R� ( R� ( RR R� RA RN ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt
sash_place� s c C s' | j j | j d f | d | f � S( sw Query a management option for window.
Option may be any value allowed by the paneconfigure subcommand
t panecgetR) ( R. RP R� ( RR R� R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c K s� | d k r) | r) | j | j d | � St | � t k r_ | r_ | j | j d | d | � S| j j | j d | f | j | | � � d S( s�
Query or modify the management options for window.
If no option is specified, returns a list describing all
of the available options for pathName. If option is
specified with no value, then the command returns a list
describing the one named option (this list will be identical
to the corresponding sublist of the value returned if no
option is specified). If one or more option-value pairs are
specified, then the command modifies the given widget
option(s) to have the given value(s); in this case the
command returns an empty string. The following options
are supported:
after window
Insert the window after the window specified. window
should be the name of a window already managed by pathName.
before window
Insert the window before the window specified. window
should be the name of a window already managed by pathName.
height size
Specify a height for the window. The height will be the
outer dimension of the window including its border, if
any. If size is an empty string, or if -height is not
specified, then the height requested internally by the
window will be used initially; the height may later be
adjusted by the movement of sashes in the panedwindow.
Size may be any value accepted by Tk_GetPixels.
minsize n
Specifies that the size of the window cannot be made
less than n. This constraint only affects the size of
the widget in the paned dimension -- the x dimension
for horizontal panedwindows, the y dimension for
vertical panedwindows. May be any value accepted by
Tk_GetPixels.
padx n
Specifies a non-negative value indicating how much
extra space to leave on each side of the window in
the X-direction. The value may have any of the forms
accepted by Tk_GetPixels.
pady n
Specifies a non-negative value indicating how much
extra space to leave on each side of the window in
the Y-direction. The value may have any of the forms
accepted by Tk_GetPixels.
sticky style
If a window's pane is larger than the requested
dimensions of the window, this option may be used
to position (or stretch) the window within its pane.
Style is a string that contains zero or more of the
characters n, s, e or w. The string can optionally
contains spaces or commas, but they are ignored. Each
letter refers to a side (north, south, east, or west)
that the window will "stick" to. If both n and s
(or e and w) are specified, the window will be
stretched to fill the entire height (or width) of
its cavity.
width size
Specify a width for the window. The width will be
the outer dimension of the window including its
border, if any. If size is an empty string, or
if -width is not specified, then the width requested
internally by the window will be used initially; the
width may later be adjusted by the movement of sashes
in the panedwindow. Size may be any value accepted by
Tk_GetPixels.
t
paneconfigureR) N( R R� R� R R R� R. RP R� ( RR R� R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s Dc C s" | j j | j j | j d � � S( s+ Returns an ordered list of the child panes.t panes( R. R* RP R� ( RR ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s N( R7 R8 R9 R RU R� Rm R] R. R� R� R� R� R� R� R� R� R� R� t
paneconfigR� ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� - s$
Kt
Studbuttonc B s e Z d i d � Z RS( c K si t j | | d | | � | j d | j � | j d | j � | j d | j � | j d | j � d S( Nt
studbuttons <Any-Enter>s <Any-Leave>s <1>s <ButtonRelease-1>( Rr RU R\ Rz R| R} R~ ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU � s
N( R7 R8 R RU ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s t Tributtonc B s e Z d i d � Z RS( c K s� t j | | d | | � | j d | j � | j d | j � | j d | j � | j d | j � | d | d <| d | d <d S( Nt tributtons <Any-Enter>s <Any-Leave>s <1>s <ButtonRelease-1>t bgt fgt activebackground( Rr RU R\ Rz R| R} R~ ( RR RS R# R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyRU � s N( R7 R8 R RU ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyR� � s c C s� t � } d t } t d k rM y | t d d � } WqM t k
rI qM Xn t | d | �} | j � t | d d d | d � �} | j � | | _ t | d d d | j �} | j � | j � | j
� | j � | j � d S(
Ns This is Tcl/Tk version %sg333333 @s
This should be a cedilla: �s
iso-8859-1R� s Click me!R� c S s | j j d d | j d � S( NR� s [%s]( t testR� ( R� ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt <lambda>
s t QUIT(
R' t
TclVersionR t NameErrorR� R� Rx R� R� R R R� R~ ( R� R� R� R� Rc ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt _test s(
t __main__(` R9 t __version__R� t platformt FixTkR� t tkinterR� R� t Tkconstantst reR/ R� RA RC RB R� t READABLEt WRITABLEt EXCEPTIONt createfilehandlerR R t deletefilehandlert compileR
R R R R R( t TrueR5 R6 R: R; R< R> RC RM RD Ru Rw Rz R| R~ R? Ry R{ RO R� R` R� R� R� R' RZ R[ Rb Rf Rk Rr Rs Rx R� R� R� R� R� R� R� R� R� R� R� R R( R* R, R- R/ R3 Rx R} R� R� R� R� R� R� R� R� R� R� R� R7 ( ( ( s& /usr/lib64/python2.7/lib-tk/Tkinter.pyt <module> s�
, k � � � � Q�}',/8 > � A [}!( � I %@@ ��
FileDialog.py 0000644 00000021177 15032720555 0007131 0 ustar 00 """File selection dialog classes.
Classes:
- FileDialog
- LoadFileDialog
- SaveFileDialog
"""
from Tkinter import *
from Dialog import Dialog
import os
import fnmatch
dialogstates = {}
class FileDialog:
"""Standard file selection dialog -- no checks on selected file.
Usage:
d = FileDialog(master)
fname = d.go(dir_or_file, pattern, default, key)
if fname is None: ...canceled...
else: ...open file...
All arguments to go() are optional.
The 'key' argument specifies a key in the global dictionary
'dialogstates', which keeps track of the values for the directory
and pattern arguments, overriding the values passed in (it does
not keep track of the default argument!). If no key is specified,
the dialog keeps no memory of previous state. Note that memory is
kept even when the dialog is canceled. (All this emulates the
behavior of the Macintosh file selection dialogs.)
"""
title = "File Selection Dialog"
def __init__(self, master, title=None):
if title is None: title = self.title
self.master = master
self.directory = None
self.top = Toplevel(master)
self.top.title(title)
self.top.iconname(title)
self.botframe = Frame(self.top)
self.botframe.pack(side=BOTTOM, fill=X)
self.selection = Entry(self.top)
self.selection.pack(side=BOTTOM, fill=X)
self.selection.bind('<Return>', self.ok_event)
self.filter = Entry(self.top)
self.filter.pack(side=TOP, fill=X)
self.filter.bind('<Return>', self.filter_command)
self.midframe = Frame(self.top)
self.midframe.pack(expand=YES, fill=BOTH)
self.filesbar = Scrollbar(self.midframe)
self.filesbar.pack(side=RIGHT, fill=Y)
self.files = Listbox(self.midframe, exportselection=0,
yscrollcommand=(self.filesbar, 'set'))
self.files.pack(side=RIGHT, expand=YES, fill=BOTH)
btags = self.files.bindtags()
self.files.bindtags(btags[1:] + btags[:1])
self.files.bind('<ButtonRelease-1>', self.files_select_event)
self.files.bind('<Double-ButtonRelease-1>', self.files_double_event)
self.filesbar.config(command=(self.files, 'yview'))
self.dirsbar = Scrollbar(self.midframe)
self.dirsbar.pack(side=LEFT, fill=Y)
self.dirs = Listbox(self.midframe, exportselection=0,
yscrollcommand=(self.dirsbar, 'set'))
self.dirs.pack(side=LEFT, expand=YES, fill=BOTH)
self.dirsbar.config(command=(self.dirs, 'yview'))
btags = self.dirs.bindtags()
self.dirs.bindtags(btags[1:] + btags[:1])
self.dirs.bind('<ButtonRelease-1>', self.dirs_select_event)
self.dirs.bind('<Double-ButtonRelease-1>', self.dirs_double_event)
self.ok_button = Button(self.botframe,
text="OK",
command=self.ok_command)
self.ok_button.pack(side=LEFT)
self.filter_button = Button(self.botframe,
text="Filter",
command=self.filter_command)
self.filter_button.pack(side=LEFT, expand=YES)
self.cancel_button = Button(self.botframe,
text="Cancel",
command=self.cancel_command)
self.cancel_button.pack(side=RIGHT)
self.top.protocol('WM_DELETE_WINDOW', self.cancel_command)
# XXX Are the following okay for a general audience?
self.top.bind('<Alt-w>', self.cancel_command)
self.top.bind('<Alt-W>', self.cancel_command)
def go(self, dir_or_file=os.curdir, pattern="*", default="", key=None):
if key and key in dialogstates:
self.directory, pattern = dialogstates[key]
else:
dir_or_file = os.path.expanduser(dir_or_file)
if os.path.isdir(dir_or_file):
self.directory = dir_or_file
else:
self.directory, default = os.path.split(dir_or_file)
self.set_filter(self.directory, pattern)
self.set_selection(default)
self.filter_command()
self.selection.focus_set()
self.top.wait_visibility() # window needs to be visible for the grab
self.top.grab_set()
self.how = None
self.master.mainloop() # Exited by self.quit(how)
if key:
directory, pattern = self.get_filter()
if self.how:
directory = os.path.dirname(self.how)
dialogstates[key] = directory, pattern
self.top.destroy()
return self.how
def quit(self, how=None):
self.how = how
self.master.quit() # Exit mainloop()
def dirs_double_event(self, event):
self.filter_command()
def dirs_select_event(self, event):
dir, pat = self.get_filter()
subdir = self.dirs.get('active')
dir = os.path.normpath(os.path.join(self.directory, subdir))
self.set_filter(dir, pat)
def files_double_event(self, event):
self.ok_command()
def files_select_event(self, event):
file = self.files.get('active')
self.set_selection(file)
def ok_event(self, event):
self.ok_command()
def ok_command(self):
self.quit(self.get_selection())
def filter_command(self, event=None):
dir, pat = self.get_filter()
try:
names = os.listdir(dir)
except os.error:
self.master.bell()
return
self.directory = dir
self.set_filter(dir, pat)
names.sort()
subdirs = [os.pardir]
matchingfiles = []
for name in names:
fullname = os.path.join(dir, name)
if os.path.isdir(fullname):
subdirs.append(name)
elif fnmatch.fnmatch(name, pat):
matchingfiles.append(name)
self.dirs.delete(0, END)
for name in subdirs:
self.dirs.insert(END, name)
self.files.delete(0, END)
for name in matchingfiles:
self.files.insert(END, name)
head, tail = os.path.split(self.get_selection())
if tail == os.curdir: tail = ''
self.set_selection(tail)
def get_filter(self):
filter = self.filter.get()
filter = os.path.expanduser(filter)
if filter[-1:] == os.sep or os.path.isdir(filter):
filter = os.path.join(filter, "*")
return os.path.split(filter)
def get_selection(self):
file = self.selection.get()
file = os.path.expanduser(file)
return file
def cancel_command(self, event=None):
self.quit()
def set_filter(self, dir, pat):
if not os.path.isabs(dir):
try:
pwd = os.getcwd()
except os.error:
pwd = None
if pwd:
dir = os.path.join(pwd, dir)
dir = os.path.normpath(dir)
self.filter.delete(0, END)
self.filter.insert(END, os.path.join(dir or os.curdir, pat or "*"))
def set_selection(self, file):
self.selection.delete(0, END)
self.selection.insert(END, os.path.join(self.directory, file))
class LoadFileDialog(FileDialog):
"""File selection dialog which checks that the file exists."""
title = "Load File Selection Dialog"
def ok_command(self):
file = self.get_selection()
if not os.path.isfile(file):
self.master.bell()
else:
self.quit(file)
class SaveFileDialog(FileDialog):
"""File selection dialog which checks that the file may be created."""
title = "Save File Selection Dialog"
def ok_command(self):
file = self.get_selection()
if os.path.exists(file):
if os.path.isdir(file):
self.master.bell()
return
d = Dialog(self.top,
title="Overwrite Existing File Question",
text="Overwrite existing file %r?" % (file,),
bitmap='questhead',
default=1,
strings=("Yes", "Cancel"))
if d.num != 0:
return
else:
head, tail = os.path.split(file)
if not os.path.isdir(head):
self.master.bell()
return
self.quit(file)
def test():
"""Simple test program."""
root = Tk()
root.withdraw()
fd = LoadFileDialog(root)
loadfile = fd.go(key="test")
fd = SaveFileDialog(root)
savefile = fd.go(key="test")
print loadfile, savefile
if __name__ == '__main__':
test()
Tkinter.py 0000644 00000471553 15032720555 0006561 0 ustar 00 """Wrapper functions for Tcl/Tk.
Tkinter provides classes which allow the display, positioning and
control of widgets. Toplevel widgets are Tk and Toplevel. Other
widgets are Frame, Label, Entry, Text, Canvas, Button, Radiobutton,
Checkbutton, Scale, Listbox, Scrollbar, OptionMenu, Spinbox
LabelFrame and PanedWindow.
Properties of the widgets are specified with keyword arguments.
Keyword arguments have the same name as the corresponding resource
under Tk.
Widgets are positioned with one of the geometry managers Place, Pack
or Grid. These managers can be called with methods place, pack, grid
available in every Widget.
Actions are bound to events by resources (e.g. keyword argument
command) or with the method bind.
Example (Hello, World):
import Tkinter
from Tkconstants import *
tk = Tkinter.Tk()
frame = Tkinter.Frame(tk, relief=RIDGE, borderwidth=2)
frame.pack(fill=BOTH,expand=1)
label = Tkinter.Label(frame, text="Hello, World")
label.pack(fill=X, expand=1)
button = Tkinter.Button(frame,text="Exit",command=tk.destroy)
button.pack(side=BOTTOM)
tk.mainloop()
"""
__version__ = "$Revision: 81008 $"
import sys
if sys.platform == "win32":
# Attempt to configure Tcl/Tk without requiring PATH
import FixTk
import _tkinter # If this fails your Python may not be configured for Tk
tkinter = _tkinter # b/w compat for export
TclError = _tkinter.TclError
from types import *
from Tkconstants import *
import re
wantobjects = 1
TkVersion = float(_tkinter.TK_VERSION)
TclVersion = float(_tkinter.TCL_VERSION)
READABLE = _tkinter.READABLE
WRITABLE = _tkinter.WRITABLE
EXCEPTION = _tkinter.EXCEPTION
# These are not always defined, e.g. not on Win32 with Tk 8.0 :-(
try: _tkinter.createfilehandler
except AttributeError: _tkinter.createfilehandler = None
try: _tkinter.deletefilehandler
except AttributeError: _tkinter.deletefilehandler = None
_magic_re = re.compile(r'([\\{}])')
_space_re = re.compile(r'([\s])')
def _join(value):
"""Internal function."""
return ' '.join(map(_stringify, value))
def _stringify(value):
"""Internal function."""
if isinstance(value, (list, tuple)):
if len(value) == 1:
value = _stringify(value[0])
if _magic_re.search(value):
value = '{%s}' % value
else:
value = '{%s}' % _join(value)
else:
if isinstance(value, str):
value = unicode(value, 'utf-8')
elif not isinstance(value, unicode):
value = str(value)
if not value:
value = '{}'
elif _magic_re.search(value):
# add '\' before special characters and spaces
value = _magic_re.sub(r'\\\1', value)
value = value.replace('\n', r'\n')
value = _space_re.sub(r'\\\1', value)
if value[0] == '"':
value = '\\' + value
elif value[0] == '"' or _space_re.search(value):
value = '{%s}' % value
return value
def _flatten(tuple):
"""Internal function."""
res = ()
for item in tuple:
if type(item) in (TupleType, ListType):
res = res + _flatten(item)
elif item is not None:
res = res + (item,)
return res
try: _flatten = _tkinter._flatten
except AttributeError: pass
def _cnfmerge(cnfs):
"""Internal function."""
if type(cnfs) is DictionaryType:
return cnfs
elif type(cnfs) in (NoneType, StringType):
return cnfs
else:
cnf = {}
for c in _flatten(cnfs):
try:
cnf.update(c)
except (AttributeError, TypeError), msg:
print "_cnfmerge: fallback due to:", msg
for k, v in c.items():
cnf[k] = v
return cnf
try: _cnfmerge = _tkinter._cnfmerge
except AttributeError: pass
def _splitdict(tk, v, cut_minus=True, conv=None):
"""Return a properly formatted dict built from Tcl list pairs.
If cut_minus is True, the supposed '-' prefix will be removed from
keys. If conv is specified, it is used to convert values.
Tcl list is expected to contain an even number of elements.
"""
t = tk.splitlist(v)
if len(t) % 2:
raise RuntimeError('Tcl list representing a dict is expected '
'to contain an even number of elements')
it = iter(t)
dict = {}
for key, value in zip(it, it):
key = str(key)
if cut_minus and key[0] == '-':
key = key[1:]
if conv:
value = conv(value)
dict[key] = value
return dict
class Event:
"""Container for the properties of an event.
Instances of this type are generated if one of the following events occurs:
KeyPress, KeyRelease - for keyboard events
ButtonPress, ButtonRelease, Motion, Enter, Leave, MouseWheel - for mouse events
Visibility, Unmap, Map, Expose, FocusIn, FocusOut, Circulate,
Colormap, Gravity, Reparent, Property, Destroy, Activate,
Deactivate - for window events.
If a callback function for one of these events is registered
using bind, bind_all, bind_class, or tag_bind, the callback is
called with an Event as first argument. It will have the
following attributes (in braces are the event types for which
the attribute is valid):
serial - serial number of event
num - mouse button pressed (ButtonPress, ButtonRelease)
focus - whether the window has the focus (Enter, Leave)
height - height of the exposed window (Configure, Expose)
width - width of the exposed window (Configure, Expose)
keycode - keycode of the pressed key (KeyPress, KeyRelease)
state - state of the event as a number (ButtonPress, ButtonRelease,
Enter, KeyPress, KeyRelease,
Leave, Motion)
state - state as a string (Visibility)
time - when the event occurred
x - x-position of the mouse
y - y-position of the mouse
x_root - x-position of the mouse on the screen
(ButtonPress, ButtonRelease, KeyPress, KeyRelease, Motion)
y_root - y-position of the mouse on the screen
(ButtonPress, ButtonRelease, KeyPress, KeyRelease, Motion)
char - pressed character (KeyPress, KeyRelease)
send_event - see X/Windows documentation
keysym - keysym of the event as a string (KeyPress, KeyRelease)
keysym_num - keysym of the event as a number (KeyPress, KeyRelease)
type - type of the event as a number
widget - widget in which the event occurred
delta - delta of wheel movement (MouseWheel)
"""
pass
_support_default_root = 1
_default_root = None
def NoDefaultRoot():
"""Inhibit setting of default root window.
Call this function to inhibit that the first instance of
Tk is used for windows without an explicit parent window.
"""
global _support_default_root
_support_default_root = 0
global _default_root
_default_root = None
del _default_root
def _tkerror(err):
"""Internal function."""
pass
def _exit(code=0):
"""Internal function. Calling it will raise the exception SystemExit."""
try:
code = int(code)
except ValueError:
pass
raise SystemExit, code
_varnum = 0
class Variable:
"""Class to define value holders for e.g. buttons.
Subclasses StringVar, IntVar, DoubleVar, BooleanVar are specializations
that constrain the type of the value returned from get()."""
_default = ""
_tclCommands = None
def __init__(self, master=None, value=None, name=None):
"""Construct a variable
MASTER can be given as master widget.
VALUE is an optional value (defaults to "")
NAME is an optional Tcl name (defaults to PY_VARnum).
If NAME matches an existing variable and VALUE is omitted
then the existing value is retained.
"""
global _varnum
if not master:
master = _default_root
self._root = master._root()
self._tk = master.tk
if name:
self._name = name
else:
self._name = 'PY_VAR' + repr(_varnum)
_varnum += 1
if value is not None:
self.set(value)
elif not self._tk.getboolean(self._tk.call("info", "exists", self._name)):
self.set(self._default)
def __del__(self):
"""Unset the variable in Tcl."""
if self._tk is None:
return
if self._tk.getboolean(self._tk.call("info", "exists", self._name)):
self._tk.globalunsetvar(self._name)
if self._tclCommands is not None:
for name in self._tclCommands:
#print '- Tkinter: deleted command', name
self._tk.deletecommand(name)
self._tclCommands = None
def __str__(self):
"""Return the name of the variable in Tcl."""
return self._name
def set(self, value):
"""Set the variable to VALUE."""
return self._tk.globalsetvar(self._name, value)
def get(self):
"""Return value of variable."""
return self._tk.globalgetvar(self._name)
def trace_variable(self, mode, callback):
"""Define a trace callback for the variable.
MODE is one of "r", "w", "u" for read, write, undefine.
CALLBACK must be a function which is called when
the variable is read, written or undefined.
Return the name of the callback.
"""
f = CallWrapper(callback, None, self._root).__call__
cbname = repr(id(f))
try:
callback = callback.im_func
except AttributeError:
pass
try:
cbname = cbname + callback.__name__
except AttributeError:
pass
self._tk.createcommand(cbname, f)
if self._tclCommands is None:
self._tclCommands = []
self._tclCommands.append(cbname)
self._tk.call("trace", "variable", self._name, mode, cbname)
return cbname
trace = trace_variable
def trace_vdelete(self, mode, cbname):
"""Delete the trace callback for a variable.
MODE is one of "r", "w", "u" for read, write, undefine.
CBNAME is the name of the callback returned from trace_variable or trace.
"""
self._tk.call("trace", "vdelete", self._name, mode, cbname)
cbname = self._tk.splitlist(cbname)[0]
for m, ca in self.trace_vinfo():
if self._tk.splitlist(ca)[0] == cbname:
break
else:
self._tk.deletecommand(cbname)
try:
self._tclCommands.remove(cbname)
except ValueError:
pass
def trace_vinfo(self):
"""Return all trace callback information."""
return map(self._tk.splitlist, self._tk.splitlist(
self._tk.call("trace", "vinfo", self._name)))
def __eq__(self, other):
"""Comparison for equality (==).
Note: if the Variable's master matters to behavior
also compare self._master == other._master
"""
return self.__class__.__name__ == other.__class__.__name__ \
and self._name == other._name
class StringVar(Variable):
"""Value holder for strings variables."""
_default = ""
def __init__(self, master=None, value=None, name=None):
"""Construct a string variable.
MASTER can be given as master widget.
VALUE is an optional value (defaults to "")
NAME is an optional Tcl name (defaults to PY_VARnum).
If NAME matches an existing variable and VALUE is omitted
then the existing value is retained.
"""
Variable.__init__(self, master, value, name)
def get(self):
"""Return value of variable as string."""
value = self._tk.globalgetvar(self._name)
if isinstance(value, basestring):
return value
return str(value)
class IntVar(Variable):
"""Value holder for integer variables."""
_default = 0
def __init__(self, master=None, value=None, name=None):
"""Construct an integer variable.
MASTER can be given as master widget.
VALUE is an optional value (defaults to 0)
NAME is an optional Tcl name (defaults to PY_VARnum).
If NAME matches an existing variable and VALUE is omitted
then the existing value is retained.
"""
Variable.__init__(self, master, value, name)
def set(self, value):
"""Set the variable to value, converting booleans to integers."""
if isinstance(value, bool):
value = int(value)
return Variable.set(self, value)
def get(self):
"""Return the value of the variable as an integer."""
return getint(self._tk.globalgetvar(self._name))
class DoubleVar(Variable):
"""Value holder for float variables."""
_default = 0.0
def __init__(self, master=None, value=None, name=None):
"""Construct a float variable.
MASTER can be given as master widget.
VALUE is an optional value (defaults to 0.0)
NAME is an optional Tcl name (defaults to PY_VARnum).
If NAME matches an existing variable and VALUE is omitted
then the existing value is retained.
"""
Variable.__init__(self, master, value, name)
def get(self):
"""Return the value of the variable as a float."""
return getdouble(self._tk.globalgetvar(self._name))
class BooleanVar(Variable):
"""Value holder for boolean variables."""
_default = False
def __init__(self, master=None, value=None, name=None):
"""Construct a boolean variable.
MASTER can be given as master widget.
VALUE is an optional value (defaults to False)
NAME is an optional Tcl name (defaults to PY_VARnum).
If NAME matches an existing variable and VALUE is omitted
then the existing value is retained.
"""
Variable.__init__(self, master, value, name)
def set(self, value):
"""Set the variable to VALUE."""
return self._tk.globalsetvar(self._name, self._tk.getboolean(value))
def get(self):
"""Return the value of the variable as a bool."""
return self._tk.getboolean(self._tk.globalgetvar(self._name))
def mainloop(n=0):
"""Run the main loop of Tcl."""
_default_root.tk.mainloop(n)
getint = int
getdouble = float
def getboolean(s):
"""Convert true and false to integer values 1 and 0."""
return _default_root.tk.getboolean(s)
# Methods defined on both toplevel and interior widgets
class Misc:
"""Internal class.
Base class which defines methods common for interior widgets."""
# XXX font command?
_tclCommands = None
def destroy(self):
"""Internal function.
Delete all Tcl commands created for
this widget in the Tcl interpreter."""
if self._tclCommands is not None:
for name in self._tclCommands:
#print '- Tkinter: deleted command', name
self.tk.deletecommand(name)
self._tclCommands = None
def deletecommand(self, name):
"""Internal function.
Delete the Tcl command provided in NAME."""
#print '- Tkinter: deleted command', name
self.tk.deletecommand(name)
try:
self._tclCommands.remove(name)
except ValueError:
pass
def tk_strictMotif(self, boolean=None):
"""Set Tcl internal variable, whether the look and feel
should adhere to Motif.
A parameter of 1 means adhere to Motif (e.g. no color
change if mouse passes over slider).
Returns the set value."""
return self.tk.getboolean(self.tk.call(
'set', 'tk_strictMotif', boolean))
def tk_bisque(self):
"""Change the color scheme to light brown as used in Tk 3.6 and before."""
self.tk.call('tk_bisque')
def tk_setPalette(self, *args, **kw):
"""Set a new color scheme for all widget elements.
A single color as argument will cause that all colors of Tk
widget elements are derived from this.
Alternatively several keyword parameters and its associated
colors can be given. The following keywords are valid:
activeBackground, foreground, selectColor,
activeForeground, highlightBackground, selectBackground,
background, highlightColor, selectForeground,
disabledForeground, insertBackground, troughColor."""
self.tk.call(('tk_setPalette',)
+ _flatten(args) + _flatten(kw.items()))
def tk_menuBar(self, *args):
"""Do not use. Needed in Tk 3.6 and earlier."""
# obsolete since Tk 4.0
import warnings
warnings.warn('tk_menuBar() does nothing and will be removed in 3.6',
DeprecationWarning, stacklevel=2)
def wait_variable(self, name='PY_VAR'):
"""Wait until the variable is modified.
A parameter of type IntVar, StringVar, DoubleVar or
BooleanVar must be given."""
self.tk.call('tkwait', 'variable', name)
waitvar = wait_variable # XXX b/w compat
def wait_window(self, window=None):
"""Wait until a WIDGET is destroyed.
If no parameter is given self is used."""
if window is None:
window = self
self.tk.call('tkwait', 'window', window._w)
def wait_visibility(self, window=None):
"""Wait until the visibility of a WIDGET changes
(e.g. it appears).
If no parameter is given self is used."""
if window is None:
window = self
self.tk.call('tkwait', 'visibility', window._w)
def setvar(self, name='PY_VAR', value='1'):
"""Set Tcl variable NAME to VALUE."""
self.tk.setvar(name, value)
def getvar(self, name='PY_VAR'):
"""Return value of Tcl variable NAME."""
return self.tk.getvar(name)
getint = int
getdouble = float
def getboolean(self, s):
"""Return a boolean value for Tcl boolean values true and false given as parameter."""
return self.tk.getboolean(s)
def focus_set(self):
"""Direct input focus to this widget.
If the application currently does not have the focus
this widget will get the focus if the application gets
the focus through the window manager."""
self.tk.call('focus', self._w)
focus = focus_set # XXX b/w compat?
def focus_force(self):
"""Direct input focus to this widget even if the
application does not have the focus. Use with
caution!"""
self.tk.call('focus', '-force', self._w)
def focus_get(self):
"""Return the widget which has currently the focus in the
application.
Use focus_displayof to allow working with several
displays. Return None if application does not have
the focus."""
name = self.tk.call('focus')
if name == 'none' or not name: return None
return self._nametowidget(name)
def focus_displayof(self):
"""Return the widget which has currently the focus on the
display where this widget is located.
Return None if the application does not have the focus."""
name = self.tk.call('focus', '-displayof', self._w)
if name == 'none' or not name: return None
return self._nametowidget(name)
def focus_lastfor(self):
"""Return the widget which would have the focus if top level
for this widget gets the focus from the window manager."""
name = self.tk.call('focus', '-lastfor', self._w)
if name == 'none' or not name: return None
return self._nametowidget(name)
def tk_focusFollowsMouse(self):
"""The widget under mouse will get automatically focus. Can not
be disabled easily."""
self.tk.call('tk_focusFollowsMouse')
def tk_focusNext(self):
"""Return the next widget in the focus order which follows
widget which has currently the focus.
The focus order first goes to the next child, then to
the children of the child recursively and then to the
next sibling which is higher in the stacking order. A
widget is omitted if it has the takefocus resource set
to 0."""
name = self.tk.call('tk_focusNext', self._w)
if not name: return None
return self._nametowidget(name)
def tk_focusPrev(self):
"""Return previous widget in the focus order. See tk_focusNext for details."""
name = self.tk.call('tk_focusPrev', self._w)
if not name: return None
return self._nametowidget(name)
def after(self, ms, func=None, *args):
"""Call function once after given time.
MS specifies the time in milliseconds. FUNC gives the
function which shall be called. Additional parameters
are given as parameters to the function call. Return
identifier to cancel scheduling with after_cancel."""
if not func:
# I'd rather use time.sleep(ms*0.001)
self.tk.call('after', ms)
return None
else:
def callit():
try:
func(*args)
finally:
try:
self.deletecommand(name)
except TclError:
pass
callit.__name__ = func.__name__
name = self._register(callit)
return self.tk.call('after', ms, name)
def after_idle(self, func, *args):
"""Call FUNC once if the Tcl main loop has no event to
process.
Return an identifier to cancel the scheduling with
after_cancel."""
return self.after('idle', func, *args)
def after_cancel(self, id):
"""Cancel scheduling of function identified with ID.
Identifier returned by after or after_idle must be
given as first parameter.
"""
if not id:
raise ValueError('id must be a valid identifier returned from '
'after or after_idle')
try:
data = self.tk.call('after', 'info', id)
script = self.tk.splitlist(data)[0]
self.deletecommand(script)
except TclError:
pass
self.tk.call('after', 'cancel', id)
def bell(self, displayof=0):
"""Ring a display's bell."""
self.tk.call(('bell',) + self._displayof(displayof))
# Clipboard handling:
def clipboard_get(self, **kw):
"""Retrieve data from the clipboard on window's display.
The window keyword defaults to the root window of the Tkinter
application.
The type keyword specifies the form in which the data is
to be returned and should be an atom name such as STRING
or FILE_NAME. Type defaults to STRING, except on X11, where the default
is to try UTF8_STRING and fall back to STRING.
This command is equivalent to:
selection_get(CLIPBOARD)
"""
if 'type' not in kw and self._windowingsystem == 'x11':
try:
kw['type'] = 'UTF8_STRING'
return self.tk.call(('clipboard', 'get') + self._options(kw))
except TclError:
del kw['type']
return self.tk.call(('clipboard', 'get') + self._options(kw))
def clipboard_clear(self, **kw):
"""Clear the data in the Tk clipboard.
A widget specified for the optional displayof keyword
argument specifies the target display."""
if 'displayof' not in kw: kw['displayof'] = self._w
self.tk.call(('clipboard', 'clear') + self._options(kw))
def clipboard_append(self, string, **kw):
"""Append STRING to the Tk clipboard.
A widget specified at the optional displayof keyword
argument specifies the target display. The clipboard
can be retrieved with selection_get."""
if 'displayof' not in kw: kw['displayof'] = self._w
self.tk.call(('clipboard', 'append') + self._options(kw)
+ ('--', string))
# XXX grab current w/o window argument
def grab_current(self):
"""Return widget which has currently the grab in this application
or None."""
name = self.tk.call('grab', 'current', self._w)
if not name: return None
return self._nametowidget(name)
def grab_release(self):
"""Release grab for this widget if currently set."""
self.tk.call('grab', 'release', self._w)
def grab_set(self):
"""Set grab for this widget.
A grab directs all events to this and descendant
widgets in the application."""
self.tk.call('grab', 'set', self._w)
def grab_set_global(self):
"""Set global grab for this widget.
A global grab directs all events to this and
descendant widgets on the display. Use with caution -
other applications do not get events anymore."""
self.tk.call('grab', 'set', '-global', self._w)
def grab_status(self):
"""Return None, "local" or "global" if this widget has
no, a local or a global grab."""
status = self.tk.call('grab', 'status', self._w)
if status == 'none': status = None
return status
def option_add(self, pattern, value, priority = None):
"""Set a VALUE (second parameter) for an option
PATTERN (first parameter).
An optional third parameter gives the numeric priority
(defaults to 80)."""
self.tk.call('option', 'add', pattern, value, priority)
def option_clear(self):
"""Clear the option database.
It will be reloaded if option_add is called."""
self.tk.call('option', 'clear')
def option_get(self, name, className):
"""Return the value for an option NAME for this widget
with CLASSNAME.
Values with higher priority override lower values."""
return self.tk.call('option', 'get', self._w, name, className)
def option_readfile(self, fileName, priority = None):
"""Read file FILENAME into the option database.
An optional second parameter gives the numeric
priority."""
self.tk.call('option', 'readfile', fileName, priority)
def selection_clear(self, **kw):
"""Clear the current X selection."""
if 'displayof' not in kw: kw['displayof'] = self._w
self.tk.call(('selection', 'clear') + self._options(kw))
def selection_get(self, **kw):
"""Return the contents of the current X selection.
A keyword parameter selection specifies the name of
the selection and defaults to PRIMARY. A keyword
parameter displayof specifies a widget on the display
to use. A keyword parameter type specifies the form of data to be
fetched, defaulting to STRING except on X11, where UTF8_STRING is tried
before STRING."""
if 'displayof' not in kw: kw['displayof'] = self._w
if 'type' not in kw and self._windowingsystem == 'x11':
try:
kw['type'] = 'UTF8_STRING'
return self.tk.call(('selection', 'get') + self._options(kw))
except TclError:
del kw['type']
return self.tk.call(('selection', 'get') + self._options(kw))
def selection_handle(self, command, **kw):
"""Specify a function COMMAND to call if the X
selection owned by this widget is queried by another
application.
This function must return the contents of the
selection. The function will be called with the
arguments OFFSET and LENGTH which allows the chunking
of very long selections. The following keyword
parameters can be provided:
selection - name of the selection (default PRIMARY),
type - type of the selection (e.g. STRING, FILE_NAME)."""
name = self._register(command)
self.tk.call(('selection', 'handle') + self._options(kw)
+ (self._w, name))
def selection_own(self, **kw):
"""Become owner of X selection.
A keyword parameter selection specifies the name of
the selection (default PRIMARY)."""
self.tk.call(('selection', 'own') +
self._options(kw) + (self._w,))
def selection_own_get(self, **kw):
"""Return owner of X selection.
The following keyword parameter can
be provided:
selection - name of the selection (default PRIMARY),
type - type of the selection (e.g. STRING, FILE_NAME)."""
if 'displayof' not in kw: kw['displayof'] = self._w
name = self.tk.call(('selection', 'own') + self._options(kw))
if not name: return None
return self._nametowidget(name)
def send(self, interp, cmd, *args):
"""Send Tcl command CMD to different interpreter INTERP to be executed."""
return self.tk.call(('send', interp, cmd) + args)
def lower(self, belowThis=None):
"""Lower this widget in the stacking order."""
self.tk.call('lower', self._w, belowThis)
def tkraise(self, aboveThis=None):
"""Raise this widget in the stacking order."""
self.tk.call('raise', self._w, aboveThis)
lift = tkraise
def colormodel(self, value=None):
"""Useless. Not implemented in Tk."""
return self.tk.call('tk', 'colormodel', self._w, value)
def winfo_atom(self, name, displayof=0):
"""Return integer which represents atom NAME."""
args = ('winfo', 'atom') + self._displayof(displayof) + (name,)
return getint(self.tk.call(args))
def winfo_atomname(self, id, displayof=0):
"""Return name of atom with identifier ID."""
args = ('winfo', 'atomname') \
+ self._displayof(displayof) + (id,)
return self.tk.call(args)
def winfo_cells(self):
"""Return number of cells in the colormap for this widget."""
return getint(
self.tk.call('winfo', 'cells', self._w))
def winfo_children(self):
"""Return a list of all widgets which are children of this widget."""
result = []
for child in self.tk.splitlist(
self.tk.call('winfo', 'children', self._w)):
try:
# Tcl sometimes returns extra windows, e.g. for
# menus; those need to be skipped
result.append(self._nametowidget(child))
except KeyError:
pass
return result
def winfo_class(self):
"""Return window class name of this widget."""
return self.tk.call('winfo', 'class', self._w)
def winfo_colormapfull(self):
"""Return true if at the last color request the colormap was full."""
return self.tk.getboolean(
self.tk.call('winfo', 'colormapfull', self._w))
def winfo_containing(self, rootX, rootY, displayof=0):
"""Return the widget which is at the root coordinates ROOTX, ROOTY."""
args = ('winfo', 'containing') \
+ self._displayof(displayof) + (rootX, rootY)
name = self.tk.call(args)
if not name: return None
return self._nametowidget(name)
def winfo_depth(self):
"""Return the number of bits per pixel."""
return getint(self.tk.call('winfo', 'depth', self._w))
def winfo_exists(self):
"""Return true if this widget exists."""
return getint(
self.tk.call('winfo', 'exists', self._w))
def winfo_fpixels(self, number):
"""Return the number of pixels for the given distance NUMBER
(e.g. "3c") as float."""
return getdouble(self.tk.call(
'winfo', 'fpixels', self._w, number))
def winfo_geometry(self):
"""Return geometry string for this widget in the form "widthxheight+X+Y"."""
return self.tk.call('winfo', 'geometry', self._w)
def winfo_height(self):
"""Return height of this widget."""
return getint(
self.tk.call('winfo', 'height', self._w))
def winfo_id(self):
"""Return identifier ID for this widget."""
return int(self.tk.call('winfo', 'id', self._w), 0)
def winfo_interps(self, displayof=0):
"""Return the name of all Tcl interpreters for this display."""
args = ('winfo', 'interps') + self._displayof(displayof)
return self.tk.splitlist(self.tk.call(args))
def winfo_ismapped(self):
"""Return true if this widget is mapped."""
return getint(
self.tk.call('winfo', 'ismapped', self._w))
def winfo_manager(self):
"""Return the window manager name for this widget."""
return self.tk.call('winfo', 'manager', self._w)
def winfo_name(self):
"""Return the name of this widget."""
return self.tk.call('winfo', 'name', self._w)
def winfo_parent(self):
"""Return the name of the parent of this widget."""
return self.tk.call('winfo', 'parent', self._w)
def winfo_pathname(self, id, displayof=0):
"""Return the pathname of the widget given by ID."""
args = ('winfo', 'pathname') \
+ self._displayof(displayof) + (id,)
return self.tk.call(args)
def winfo_pixels(self, number):
"""Rounded integer value of winfo_fpixels."""
return getint(
self.tk.call('winfo', 'pixels', self._w, number))
def winfo_pointerx(self):
"""Return the x coordinate of the pointer on the root window."""
return getint(
self.tk.call('winfo', 'pointerx', self._w))
def winfo_pointerxy(self):
"""Return a tuple of x and y coordinates of the pointer on the root window."""
return self._getints(
self.tk.call('winfo', 'pointerxy', self._w))
def winfo_pointery(self):
"""Return the y coordinate of the pointer on the root window."""
return getint(
self.tk.call('winfo', 'pointery', self._w))
def winfo_reqheight(self):
"""Return requested height of this widget."""
return getint(
self.tk.call('winfo', 'reqheight', self._w))
def winfo_reqwidth(self):
"""Return requested width of this widget."""
return getint(
self.tk.call('winfo', 'reqwidth', self._w))
def winfo_rgb(self, color):
"""Return tuple of decimal values for red, green, blue for
COLOR in this widget."""
return self._getints(
self.tk.call('winfo', 'rgb', self._w, color))
def winfo_rootx(self):
"""Return x coordinate of upper left corner of this widget on the
root window."""
return getint(
self.tk.call('winfo', 'rootx', self._w))
def winfo_rooty(self):
"""Return y coordinate of upper left corner of this widget on the
root window."""
return getint(
self.tk.call('winfo', 'rooty', self._w))
def winfo_screen(self):
"""Return the screen name of this widget."""
return self.tk.call('winfo', 'screen', self._w)
def winfo_screencells(self):
"""Return the number of the cells in the colormap of the screen
of this widget."""
return getint(
self.tk.call('winfo', 'screencells', self._w))
def winfo_screendepth(self):
"""Return the number of bits per pixel of the root window of the
screen of this widget."""
return getint(
self.tk.call('winfo', 'screendepth', self._w))
def winfo_screenheight(self):
"""Return the number of pixels of the height of the screen of this widget
in pixel."""
return getint(
self.tk.call('winfo', 'screenheight', self._w))
def winfo_screenmmheight(self):
"""Return the number of pixels of the height of the screen of
this widget in mm."""
return getint(
self.tk.call('winfo', 'screenmmheight', self._w))
def winfo_screenmmwidth(self):
"""Return the number of pixels of the width of the screen of
this widget in mm."""
return getint(
self.tk.call('winfo', 'screenmmwidth', self._w))
def winfo_screenvisual(self):
"""Return one of the strings directcolor, grayscale, pseudocolor,
staticcolor, staticgray, or truecolor for the default
colormodel of this screen."""
return self.tk.call('winfo', 'screenvisual', self._w)
def winfo_screenwidth(self):
"""Return the number of pixels of the width of the screen of
this widget in pixel."""
return getint(
self.tk.call('winfo', 'screenwidth', self._w))
def winfo_server(self):
"""Return information of the X-Server of the screen of this widget in
the form "XmajorRminor vendor vendorVersion"."""
return self.tk.call('winfo', 'server', self._w)
def winfo_toplevel(self):
"""Return the toplevel widget of this widget."""
return self._nametowidget(self.tk.call(
'winfo', 'toplevel', self._w))
def winfo_viewable(self):
"""Return true if the widget and all its higher ancestors are mapped."""
return getint(
self.tk.call('winfo', 'viewable', self._w))
def winfo_visual(self):
"""Return one of the strings directcolor, grayscale, pseudocolor,
staticcolor, staticgray, or truecolor for the
colormodel of this widget."""
return self.tk.call('winfo', 'visual', self._w)
def winfo_visualid(self):
"""Return the X identifier for the visual for this widget."""
return self.tk.call('winfo', 'visualid', self._w)
def winfo_visualsavailable(self, includeids=0):
"""Return a list of all visuals available for the screen
of this widget.
Each item in the list consists of a visual name (see winfo_visual), a
depth and if INCLUDEIDS=1 is given also the X identifier."""
data = self.tk.split(
self.tk.call('winfo', 'visualsavailable', self._w,
includeids and 'includeids' or None))
if type(data) is StringType:
data = [self.tk.split(data)]
return map(self.__winfo_parseitem, data)
def __winfo_parseitem(self, t):
"""Internal function."""
return t[:1] + tuple(map(self.__winfo_getint, t[1:]))
def __winfo_getint(self, x):
"""Internal function."""
return int(x, 0)
def winfo_vrootheight(self):
"""Return the height of the virtual root window associated with this
widget in pixels. If there is no virtual root window return the
height of the screen."""
return getint(
self.tk.call('winfo', 'vrootheight', self._w))
def winfo_vrootwidth(self):
"""Return the width of the virtual root window associated with this
widget in pixel. If there is no virtual root window return the
width of the screen."""
return getint(
self.tk.call('winfo', 'vrootwidth', self._w))
def winfo_vrootx(self):
"""Return the x offset of the virtual root relative to the root
window of the screen of this widget."""
return getint(
self.tk.call('winfo', 'vrootx', self._w))
def winfo_vrooty(self):
"""Return the y offset of the virtual root relative to the root
window of the screen of this widget."""
return getint(
self.tk.call('winfo', 'vrooty', self._w))
def winfo_width(self):
"""Return the width of this widget."""
return getint(
self.tk.call('winfo', 'width', self._w))
def winfo_x(self):
"""Return the x coordinate of the upper left corner of this widget
in the parent."""
return getint(
self.tk.call('winfo', 'x', self._w))
def winfo_y(self):
"""Return the y coordinate of the upper left corner of this widget
in the parent."""
return getint(
self.tk.call('winfo', 'y', self._w))
def update(self):
"""Enter event loop until all pending events have been processed by Tcl."""
self.tk.call('update')
def update_idletasks(self):
"""Enter event loop until all idle callbacks have been called. This
will update the display of windows but not process events caused by
the user."""
self.tk.call('update', 'idletasks')
def bindtags(self, tagList=None):
"""Set or get the list of bindtags for this widget.
With no argument return the list of all bindtags associated with
this widget. With a list of strings as argument the bindtags are
set to this list. The bindtags determine in which order events are
processed (see bind)."""
if tagList is None:
return self.tk.splitlist(
self.tk.call('bindtags', self._w))
else:
self.tk.call('bindtags', self._w, tagList)
def _bind(self, what, sequence, func, add, needcleanup=1):
"""Internal function."""
if type(func) is StringType:
self.tk.call(what + (sequence, func))
elif func:
funcid = self._register(func, self._substitute,
needcleanup)
cmd = ('%sif {"[%s %s]" == "break"} break\n'
%
(add and '+' or '',
funcid, self._subst_format_str))
self.tk.call(what + (sequence, cmd))
return funcid
elif sequence:
return self.tk.call(what + (sequence,))
else:
return self.tk.splitlist(self.tk.call(what))
def bind(self, sequence=None, func=None, add=None):
"""Bind to this widget at event SEQUENCE a call to function FUNC.
SEQUENCE is a string of concatenated event
patterns. An event pattern is of the form
<MODIFIER-MODIFIER-TYPE-DETAIL> where MODIFIER is one
of Control, Mod2, M2, Shift, Mod3, M3, Lock, Mod4, M4,
Button1, B1, Mod5, M5 Button2, B2, Meta, M, Button3,
B3, Alt, Button4, B4, Double, Button5, B5 Triple,
Mod1, M1. TYPE is one of Activate, Enter, Map,
ButtonPress, Button, Expose, Motion, ButtonRelease
FocusIn, MouseWheel, Circulate, FocusOut, Property,
Colormap, Gravity Reparent, Configure, KeyPress, Key,
Unmap, Deactivate, KeyRelease Visibility, Destroy,
Leave and DETAIL is the button number for ButtonPress,
ButtonRelease and DETAIL is the Keysym for KeyPress and
KeyRelease. Examples are
<Control-Button-1> for pressing Control and mouse button 1 or
<Alt-A> for pressing A and the Alt key (KeyPress can be omitted).
An event pattern can also be a virtual event of the form
<<AString>> where AString can be arbitrary. This
event can be generated by event_generate.
If events are concatenated they must appear shortly
after each other.
FUNC will be called if the event sequence occurs with an
instance of Event as argument. If the return value of FUNC is
"break" no further bound function is invoked.
An additional boolean parameter ADD specifies whether FUNC will
be called additionally to the other bound function or whether
it will replace the previous function.
Bind will return an identifier to allow deletion of the bound function with
unbind without memory leak.
If FUNC or SEQUENCE is omitted the bound function or list
of bound events are returned."""
return self._bind(('bind', self._w), sequence, func, add)
def unbind(self, sequence, funcid=None):
"""Unbind for this widget for event SEQUENCE the
function identified with FUNCID."""
self.tk.call('bind', self._w, sequence, '')
if funcid:
self.deletecommand(funcid)
def bind_all(self, sequence=None, func=None, add=None):
"""Bind to all widgets at an event SEQUENCE a call to function FUNC.
An additional boolean parameter ADD specifies whether FUNC will
be called additionally to the other bound function or whether
it will replace the previous function. See bind for the return value."""
return self._bind(('bind', 'all'), sequence, func, add, 0)
def unbind_all(self, sequence):
"""Unbind for all widgets for event SEQUENCE all functions."""
self.tk.call('bind', 'all' , sequence, '')
def bind_class(self, className, sequence=None, func=None, add=None):
"""Bind to widgets with bindtag CLASSNAME at event
SEQUENCE a call of function FUNC. An additional
boolean parameter ADD specifies whether FUNC will be
called additionally to the other bound function or
whether it will replace the previous function. See bind for
the return value."""
return self._bind(('bind', className), sequence, func, add, 0)
def unbind_class(self, className, sequence):
"""Unbind for all widgets with bindtag CLASSNAME for event SEQUENCE
all functions."""
self.tk.call('bind', className , sequence, '')
def mainloop(self, n=0):
"""Call the mainloop of Tk."""
self.tk.mainloop(n)
def quit(self):
"""Quit the Tcl interpreter. All widgets will be destroyed."""
self.tk.quit()
def _getints(self, string):
"""Internal function."""
if string:
return tuple(map(getint, self.tk.splitlist(string)))
def _getdoubles(self, string):
"""Internal function."""
if string:
return tuple(map(getdouble, self.tk.splitlist(string)))
def _getboolean(self, string):
"""Internal function."""
if string:
return self.tk.getboolean(string)
def _displayof(self, displayof):
"""Internal function."""
if displayof:
return ('-displayof', displayof)
if displayof is None:
return ('-displayof', self._w)
return ()
@property
def _windowingsystem(self):
"""Internal function."""
try:
return self._root()._windowingsystem_cached
except AttributeError:
ws = self._root()._windowingsystem_cached = \
self.tk.call('tk', 'windowingsystem')
return ws
def _options(self, cnf, kw = None):
"""Internal function."""
if kw:
cnf = _cnfmerge((cnf, kw))
else:
cnf = _cnfmerge(cnf)
res = ()
for k, v in cnf.items():
if v is not None:
if k[-1] == '_': k = k[:-1]
if hasattr(v, '__call__'):
v = self._register(v)
elif isinstance(v, (tuple, list)):
nv = []
for item in v:
if not isinstance(item, (basestring, int, long)):
break
elif isinstance(item, (int, long)):
nv.append('%d' % item)
else:
# format it to proper Tcl code if it contains space
nv.append(_stringify(item))
else:
v = ' '.join(nv)
res = res + ('-'+k, v)
return res
def nametowidget(self, name):
"""Return the Tkinter instance of a widget identified by
its Tcl name NAME."""
name = str(name).split('.')
w = self
if not name[0]:
w = w._root()
name = name[1:]
for n in name:
if not n:
break
w = w.children[n]
return w
_nametowidget = nametowidget
def _register(self, func, subst=None, needcleanup=1):
"""Return a newly created Tcl function. If this
function is called, the Python function FUNC will
be executed. An optional function SUBST can
be given which will be executed before FUNC."""
f = CallWrapper(func, subst, self).__call__
name = repr(id(f))
try:
func = func.im_func
except AttributeError:
pass
try:
name = name + func.__name__
except AttributeError:
pass
self.tk.createcommand(name, f)
if needcleanup:
if self._tclCommands is None:
self._tclCommands = []
self._tclCommands.append(name)
return name
register = _register
def _root(self):
"""Internal function."""
w = self
while w.master: w = w.master
return w
_subst_format = ('%#', '%b', '%f', '%h', '%k',
'%s', '%t', '%w', '%x', '%y',
'%A', '%E', '%K', '%N', '%W', '%T', '%X', '%Y', '%D')
_subst_format_str = " ".join(_subst_format)
def _substitute(self, *args):
"""Internal function."""
if len(args) != len(self._subst_format): return args
getboolean = self.tk.getboolean
getint = int
def getint_event(s):
"""Tk changed behavior in 8.4.2, returning "??" rather more often."""
try:
return int(s)
except ValueError:
return s
nsign, b, f, h, k, s, t, w, x, y, A, E, K, N, W, T, X, Y, D = args
# Missing: (a, c, d, m, o, v, B, R)
e = Event()
# serial field: valid for all events
# number of button: ButtonPress and ButtonRelease events only
# height field: Configure, ConfigureRequest, Create,
# ResizeRequest, and Expose events only
# keycode field: KeyPress and KeyRelease events only
# time field: "valid for events that contain a time field"
# width field: Configure, ConfigureRequest, Create, ResizeRequest,
# and Expose events only
# x field: "valid for events that contain an x field"
# y field: "valid for events that contain a y field"
# keysym as decimal: KeyPress and KeyRelease events only
# x_root, y_root fields: ButtonPress, ButtonRelease, KeyPress,
# KeyRelease, and Motion events
e.serial = getint(nsign)
e.num = getint_event(b)
try: e.focus = getboolean(f)
except TclError: pass
e.height = getint_event(h)
e.keycode = getint_event(k)
e.state = getint_event(s)
e.time = getint_event(t)
e.width = getint_event(w)
e.x = getint_event(x)
e.y = getint_event(y)
e.char = A
try: e.send_event = getboolean(E)
except TclError: pass
e.keysym = K
e.keysym_num = getint_event(N)
e.type = T
try:
e.widget = self._nametowidget(W)
except KeyError:
e.widget = W
e.x_root = getint_event(X)
e.y_root = getint_event(Y)
try:
e.delta = getint(D)
except ValueError:
e.delta = 0
return (e,)
def _report_exception(self):
"""Internal function."""
import sys
exc, val, tb = sys.exc_type, sys.exc_value, sys.exc_traceback
root = self._root()
root.report_callback_exception(exc, val, tb)
def _getconfigure(self, *args):
"""Call Tcl configure command and return the result as a dict."""
cnf = {}
for x in self.tk.splitlist(self.tk.call(*args)):
x = self.tk.splitlist(x)
cnf[x[0][1:]] = (x[0][1:],) + x[1:]
return cnf
def _getconfigure1(self, *args):
x = self.tk.splitlist(self.tk.call(*args))
return (x[0][1:],) + x[1:]
def _configure(self, cmd, cnf, kw):
"""Internal function."""
if kw:
cnf = _cnfmerge((cnf, kw))
elif cnf:
cnf = _cnfmerge(cnf)
if cnf is None:
return self._getconfigure(_flatten((self._w, cmd)))
if type(cnf) is StringType:
return self._getconfigure1(_flatten((self._w, cmd, '-'+cnf)))
self.tk.call(_flatten((self._w, cmd)) + self._options(cnf))
# These used to be defined in Widget:
def configure(self, cnf=None, **kw):
"""Configure resources of a widget.
The values for resources are specified as keyword
arguments. To get an overview about
the allowed keyword arguments call the method keys.
"""
return self._configure('configure', cnf, kw)
config = configure
def cget(self, key):
"""Return the resource value for a KEY given as string."""
return self.tk.call(self._w, 'cget', '-' + key)
__getitem__ = cget
def __setitem__(self, key, value):
self.configure({key: value})
def __contains__(self, key):
raise TypeError("Tkinter objects don't support 'in' tests.")
def keys(self):
"""Return a list of all resource names of this widget."""
splitlist = self.tk.splitlist
return [splitlist(x)[0][1:] for x in
splitlist(self.tk.call(self._w, 'configure'))]
def __str__(self):
"""Return the window path name of this widget."""
return self._w
# Pack methods that apply to the master
_noarg_ = ['_noarg_']
def pack_propagate(self, flag=_noarg_):
"""Set or get the status for propagation of geometry information.
A boolean argument specifies whether the geometry information
of the slaves will determine the size of this widget. If no argument
is given the current setting will be returned.
"""
if flag is Misc._noarg_:
return self._getboolean(self.tk.call(
'pack', 'propagate', self._w))
else:
self.tk.call('pack', 'propagate', self._w, flag)
propagate = pack_propagate
def pack_slaves(self):
"""Return a list of all slaves of this widget
in its packing order."""
return map(self._nametowidget,
self.tk.splitlist(
self.tk.call('pack', 'slaves', self._w)))
slaves = pack_slaves
# Place method that applies to the master
def place_slaves(self):
"""Return a list of all slaves of this widget
in its packing order."""
return map(self._nametowidget,
self.tk.splitlist(
self.tk.call(
'place', 'slaves', self._w)))
# Grid methods that apply to the master
def grid_bbox(self, column=None, row=None, col2=None, row2=None):
"""Return a tuple of integer coordinates for the bounding
box of this widget controlled by the geometry manager grid.
If COLUMN, ROW is given the bounding box applies from
the cell with row and column 0 to the specified
cell. If COL2 and ROW2 are given the bounding box
starts at that cell.
The returned integers specify the offset of the upper left
corner in the master widget and the width and height.
"""
args = ('grid', 'bbox', self._w)
if column is not None and row is not None:
args = args + (column, row)
if col2 is not None and row2 is not None:
args = args + (col2, row2)
return self._getints(self.tk.call(*args)) or None
bbox = grid_bbox
def _gridconvvalue(self, value):
if isinstance(value, (str, _tkinter.Tcl_Obj)):
try:
svalue = str(value)
if not svalue:
return None
elif '.' in svalue:
return getdouble(svalue)
else:
return getint(svalue)
except ValueError:
pass
return value
def _grid_configure(self, command, index, cnf, kw):
"""Internal function."""
if type(cnf) is StringType and not kw:
if cnf[-1:] == '_':
cnf = cnf[:-1]
if cnf[:1] != '-':
cnf = '-'+cnf
options = (cnf,)
else:
options = self._options(cnf, kw)
if not options:
return _splitdict(
self.tk,
self.tk.call('grid', command, self._w, index),
conv=self._gridconvvalue)
res = self.tk.call(
('grid', command, self._w, index)
+ options)
if len(options) == 1:
return self._gridconvvalue(res)
def grid_columnconfigure(self, index, cnf={}, **kw):
"""Configure column INDEX of a grid.
Valid resources are minsize (minimum size of the column),
weight (how much does additional space propagate to this column)
and pad (how much space to let additionally)."""
return self._grid_configure('columnconfigure', index, cnf, kw)
columnconfigure = grid_columnconfigure
def grid_location(self, x, y):
"""Return a tuple of column and row which identify the cell
at which the pixel at position X and Y inside the master
widget is located."""
return self._getints(
self.tk.call(
'grid', 'location', self._w, x, y)) or None
def grid_propagate(self, flag=_noarg_):
"""Set or get the status for propagation of geometry information.
A boolean argument specifies whether the geometry information
of the slaves will determine the size of this widget. If no argument
is given, the current setting will be returned.
"""
if flag is Misc._noarg_:
return self._getboolean(self.tk.call(
'grid', 'propagate', self._w))
else:
self.tk.call('grid', 'propagate', self._w, flag)
def grid_rowconfigure(self, index, cnf={}, **kw):
"""Configure row INDEX of a grid.
Valid resources are minsize (minimum size of the row),
weight (how much does additional space propagate to this row)
and pad (how much space to let additionally)."""
return self._grid_configure('rowconfigure', index, cnf, kw)
rowconfigure = grid_rowconfigure
def grid_size(self):
"""Return a tuple of the number of column and rows in the grid."""
return self._getints(
self.tk.call('grid', 'size', self._w)) or None
size = grid_size
def grid_slaves(self, row=None, column=None):
"""Return a list of all slaves of this widget
in its packing order."""
args = ()
if row is not None:
args = args + ('-row', row)
if column is not None:
args = args + ('-column', column)
return map(self._nametowidget,
self.tk.splitlist(self.tk.call(
('grid', 'slaves', self._w) + args)))
# Support for the "event" command, new in Tk 4.2.
# By Case Roole.
def event_add(self, virtual, *sequences):
"""Bind a virtual event VIRTUAL (of the form <<Name>>)
to an event SEQUENCE such that the virtual event is triggered
whenever SEQUENCE occurs."""
args = ('event', 'add', virtual) + sequences
self.tk.call(args)
def event_delete(self, virtual, *sequences):
"""Unbind a virtual event VIRTUAL from SEQUENCE."""
args = ('event', 'delete', virtual) + sequences
self.tk.call(args)
def event_generate(self, sequence, **kw):
"""Generate an event SEQUENCE. Additional
keyword arguments specify parameter of the event
(e.g. x, y, rootx, rooty)."""
args = ('event', 'generate', self._w, sequence)
for k, v in kw.items():
args = args + ('-%s' % k, str(v))
self.tk.call(args)
def event_info(self, virtual=None):
"""Return a list of all virtual events or the information
about the SEQUENCE bound to the virtual event VIRTUAL."""
return self.tk.splitlist(
self.tk.call('event', 'info', virtual))
# Image related commands
def image_names(self):
"""Return a list of all existing image names."""
return self.tk.splitlist(self.tk.call('image', 'names'))
def image_types(self):
"""Return a list of all available image types (e.g. photo bitmap)."""
return self.tk.splitlist(self.tk.call('image', 'types'))
class CallWrapper:
"""Internal class. Stores function to call when some user
defined Tcl function is called e.g. after an event occurred."""
def __init__(self, func, subst, widget):
"""Store FUNC, SUBST and WIDGET as members."""
self.func = func
self.subst = subst
self.widget = widget
def __call__(self, *args):
"""Apply first function SUBST to arguments, than FUNC."""
try:
if self.subst:
args = self.subst(*args)
return self.func(*args)
except SystemExit, msg:
raise SystemExit, msg
except:
self.widget._report_exception()
class XView:
"""Mix-in class for querying and changing the horizontal position
of a widget's window."""
def xview(self, *args):
"""Query and change the horizontal position of the view."""
res = self.tk.call(self._w, 'xview', *args)
if not args:
return self._getdoubles(res)
def xview_moveto(self, fraction):
"""Adjusts the view in the window so that FRACTION of the
total width of the canvas is off-screen to the left."""
self.tk.call(self._w, 'xview', 'moveto', fraction)
def xview_scroll(self, number, what):
"""Shift the x-view according to NUMBER which is measured in "units"
or "pages" (WHAT)."""
self.tk.call(self._w, 'xview', 'scroll', number, what)
class YView:
"""Mix-in class for querying and changing the vertical position
of a widget's window."""
def yview(self, *args):
"""Query and change the vertical position of the view."""
res = self.tk.call(self._w, 'yview', *args)
if not args:
return self._getdoubles(res)
def yview_moveto(self, fraction):
"""Adjusts the view in the window so that FRACTION of the
total height of the canvas is off-screen to the top."""
self.tk.call(self._w, 'yview', 'moveto', fraction)
def yview_scroll(self, number, what):
"""Shift the y-view according to NUMBER which is measured in
"units" or "pages" (WHAT)."""
self.tk.call(self._w, 'yview', 'scroll', number, what)
class Wm:
"""Provides functions for the communication with the window manager."""
def wm_aspect(self,
minNumer=None, minDenom=None,
maxNumer=None, maxDenom=None):
"""Instruct the window manager to set the aspect ratio (width/height)
of this widget to be between MINNUMER/MINDENOM and MAXNUMER/MAXDENOM. Return a tuple
of the actual values if no argument is given."""
return self._getints(
self.tk.call('wm', 'aspect', self._w,
minNumer, minDenom,
maxNumer, maxDenom))
aspect = wm_aspect
def wm_attributes(self, *args):
"""This subcommand returns or sets platform specific attributes
The first form returns a list of the platform specific flags and
their values. The second form returns the value for the specific
option. The third form sets one or more of the values. The values
are as follows:
On Windows, -disabled gets or sets whether the window is in a
disabled state. -toolwindow gets or sets the style of the window
to toolwindow (as defined in the MSDN). -topmost gets or sets
whether this is a topmost window (displays above all other
windows).
On Macintosh, XXXXX
On Unix, there are currently no special attribute values.
"""
args = ('wm', 'attributes', self._w) + args
return self.tk.call(args)
attributes=wm_attributes
def wm_client(self, name=None):
"""Store NAME in WM_CLIENT_MACHINE property of this widget. Return
current value."""
return self.tk.call('wm', 'client', self._w, name)
client = wm_client
def wm_colormapwindows(self, *wlist):
"""Store list of window names (WLIST) into WM_COLORMAPWINDOWS property
of this widget. This list contains windows whose colormaps differ from their
parents. Return current list of widgets if WLIST is empty."""
if len(wlist) > 1:
wlist = (wlist,) # Tk needs a list of windows here
args = ('wm', 'colormapwindows', self._w) + wlist
if wlist:
self.tk.call(args)
else:
return map(self._nametowidget, self.tk.splitlist(self.tk.call(args)))
colormapwindows = wm_colormapwindows
def wm_command(self, value=None):
"""Store VALUE in WM_COMMAND property. It is the command
which shall be used to invoke the application. Return current
command if VALUE is None."""
return self.tk.call('wm', 'command', self._w, value)
command = wm_command
def wm_deiconify(self):
"""Deiconify this widget. If it was never mapped it will not be mapped.
On Windows it will raise this widget and give it the focus."""
return self.tk.call('wm', 'deiconify', self._w)
deiconify = wm_deiconify
def wm_focusmodel(self, model=None):
"""Set focus model to MODEL. "active" means that this widget will claim
the focus itself, "passive" means that the window manager shall give
the focus. Return current focus model if MODEL is None."""
return self.tk.call('wm', 'focusmodel', self._w, model)
focusmodel = wm_focusmodel
def wm_frame(self):
"""Return identifier for decorative frame of this widget if present."""
return self.tk.call('wm', 'frame', self._w)
frame = wm_frame
def wm_geometry(self, newGeometry=None):
"""Set geometry to NEWGEOMETRY of the form =widthxheight+x+y. Return
current value if None is given."""
return self.tk.call('wm', 'geometry', self._w, newGeometry)
geometry = wm_geometry
def wm_grid(self,
baseWidth=None, baseHeight=None,
widthInc=None, heightInc=None):
"""Instruct the window manager that this widget shall only be
resized on grid boundaries. WIDTHINC and HEIGHTINC are the width and
height of a grid unit in pixels. BASEWIDTH and BASEHEIGHT are the
number of grid units requested in Tk_GeometryRequest."""
return self._getints(self.tk.call(
'wm', 'grid', self._w,
baseWidth, baseHeight, widthInc, heightInc))
grid = wm_grid
def wm_group(self, pathName=None):
"""Set the group leader widgets for related widgets to PATHNAME. Return
the group leader of this widget if None is given."""
return self.tk.call('wm', 'group', self._w, pathName)
group = wm_group
def wm_iconbitmap(self, bitmap=None, default=None):
"""Set bitmap for the iconified widget to BITMAP. Return
the bitmap if None is given.
Under Windows, the DEFAULT parameter can be used to set the icon
for the widget and any descendents that don't have an icon set
explicitly. DEFAULT can be the relative path to a .ico file
(example: root.iconbitmap(default='myicon.ico') ). See Tk
documentation for more information."""
if default:
return self.tk.call('wm', 'iconbitmap', self._w, '-default', default)
else:
return self.tk.call('wm', 'iconbitmap', self._w, bitmap)
iconbitmap = wm_iconbitmap
def wm_iconify(self):
"""Display widget as icon."""
return self.tk.call('wm', 'iconify', self._w)
iconify = wm_iconify
def wm_iconmask(self, bitmap=None):
"""Set mask for the icon bitmap of this widget. Return the
mask if None is given."""
return self.tk.call('wm', 'iconmask', self._w, bitmap)
iconmask = wm_iconmask
def wm_iconname(self, newName=None):
"""Set the name of the icon for this widget. Return the name if
None is given."""
return self.tk.call('wm', 'iconname', self._w, newName)
iconname = wm_iconname
def wm_iconposition(self, x=None, y=None):
"""Set the position of the icon of this widget to X and Y. Return
a tuple of the current values of X and X if None is given."""
return self._getints(self.tk.call(
'wm', 'iconposition', self._w, x, y))
iconposition = wm_iconposition
def wm_iconwindow(self, pathName=None):
"""Set widget PATHNAME to be displayed instead of icon. Return the current
value if None is given."""
return self.tk.call('wm', 'iconwindow', self._w, pathName)
iconwindow = wm_iconwindow
def wm_maxsize(self, width=None, height=None):
"""Set max WIDTH and HEIGHT for this widget. If the window is gridded
the values are given in grid units. Return the current values if None
is given."""
return self._getints(self.tk.call(
'wm', 'maxsize', self._w, width, height))
maxsize = wm_maxsize
def wm_minsize(self, width=None, height=None):
"""Set min WIDTH and HEIGHT for this widget. If the window is gridded
the values are given in grid units. Return the current values if None
is given."""
return self._getints(self.tk.call(
'wm', 'minsize', self._w, width, height))
minsize = wm_minsize
def wm_overrideredirect(self, boolean=None):
"""Instruct the window manager to ignore this widget
if BOOLEAN is given with 1. Return the current value if None
is given."""
return self._getboolean(self.tk.call(
'wm', 'overrideredirect', self._w, boolean))
overrideredirect = wm_overrideredirect
def wm_positionfrom(self, who=None):
"""Instruct the window manager that the position of this widget shall
be defined by the user if WHO is "user", and by its own policy if WHO is
"program"."""
return self.tk.call('wm', 'positionfrom', self._w, who)
positionfrom = wm_positionfrom
def wm_protocol(self, name=None, func=None):
"""Bind function FUNC to command NAME for this widget.
Return the function bound to NAME if None is given. NAME could be
e.g. "WM_SAVE_YOURSELF" or "WM_DELETE_WINDOW"."""
if hasattr(func, '__call__'):
command = self._register(func)
else:
command = func
return self.tk.call(
'wm', 'protocol', self._w, name, command)
protocol = wm_protocol
def wm_resizable(self, width=None, height=None):
"""Instruct the window manager whether this width can be resized
in WIDTH or HEIGHT. Both values are boolean values."""
return self.tk.call('wm', 'resizable', self._w, width, height)
resizable = wm_resizable
def wm_sizefrom(self, who=None):
"""Instruct the window manager that the size of this widget shall
be defined by the user if WHO is "user", and by its own policy if WHO is
"program"."""
return self.tk.call('wm', 'sizefrom', self._w, who)
sizefrom = wm_sizefrom
def wm_state(self, newstate=None):
"""Query or set the state of this widget as one of normal, icon,
iconic (see wm_iconwindow), withdrawn, or zoomed (Windows only)."""
return self.tk.call('wm', 'state', self._w, newstate)
state = wm_state
def wm_title(self, string=None):
"""Set the title of this widget."""
return self.tk.call('wm', 'title', self._w, string)
title = wm_title
def wm_transient(self, master=None):
"""Instruct the window manager that this widget is transient
with regard to widget MASTER."""
return self.tk.call('wm', 'transient', self._w, master)
transient = wm_transient
def wm_withdraw(self):
"""Withdraw this widget from the screen such that it is unmapped
and forgotten by the window manager. Re-draw it with wm_deiconify."""
return self.tk.call('wm', 'withdraw', self._w)
withdraw = wm_withdraw
class Tk(Misc, Wm):
"""Toplevel widget of Tk which represents mostly the main window
of an application. It has an associated Tcl interpreter."""
_w = '.'
def __init__(self, screenName=None, baseName=None, className='Tk',
useTk=1, sync=0, use=None):
"""Return a new Toplevel widget on screen SCREENNAME. A new Tcl interpreter will
be created. BASENAME will be used for the identification of the profile file (see
readprofile).
It is constructed from sys.argv[0] without extensions if None is given. CLASSNAME
is the name of the widget class."""
self.master = None
self.children = {}
self._tkloaded = 0
# to avoid recursions in the getattr code in case of failure, we
# ensure that self.tk is always _something_.
self.tk = None
if baseName is None:
import os
baseName = os.path.basename(sys.argv[0])
baseName, ext = os.path.splitext(baseName)
if ext not in ('.py', '.pyc', '.pyo'):
baseName = baseName + ext
interactive = 0
self.tk = _tkinter.create(screenName, baseName, className, interactive, wantobjects, useTk, sync, use)
if useTk:
self._loadtk()
if not sys.flags.ignore_environment:
# Issue #16248: Honor the -E flag to avoid code injection.
self.readprofile(baseName, className)
def loadtk(self):
if not self._tkloaded:
self.tk.loadtk()
self._loadtk()
def _loadtk(self):
self._tkloaded = 1
global _default_root
# Version sanity checks
tk_version = self.tk.getvar('tk_version')
if tk_version != _tkinter.TK_VERSION:
raise RuntimeError, \
"tk.h version (%s) doesn't match libtk.a version (%s)" \
% (_tkinter.TK_VERSION, tk_version)
# Under unknown circumstances, tcl_version gets coerced to float
tcl_version = str(self.tk.getvar('tcl_version'))
if tcl_version != _tkinter.TCL_VERSION:
raise RuntimeError, \
"tcl.h version (%s) doesn't match libtcl.a version (%s)" \
% (_tkinter.TCL_VERSION, tcl_version)
if TkVersion < 4.0:
raise RuntimeError, \
"Tk 4.0 or higher is required; found Tk %s" \
% str(TkVersion)
# Create and register the tkerror and exit commands
# We need to inline parts of _register here, _ register
# would register differently-named commands.
if self._tclCommands is None:
self._tclCommands = []
self.tk.createcommand('tkerror', _tkerror)
self.tk.createcommand('exit', _exit)
self._tclCommands.append('tkerror')
self._tclCommands.append('exit')
if _support_default_root and not _default_root:
_default_root = self
self.protocol("WM_DELETE_WINDOW", self.destroy)
def destroy(self):
"""Destroy this and all descendants widgets. This will
end the application of this Tcl interpreter."""
for c in self.children.values(): c.destroy()
self.tk.call('destroy', self._w)
Misc.destroy(self)
global _default_root
if _support_default_root and _default_root is self:
_default_root = None
def readprofile(self, baseName, className):
"""Internal function. It reads BASENAME.tcl and CLASSNAME.tcl into
the Tcl Interpreter and calls execfile on BASENAME.py and CLASSNAME.py if
such a file exists in the home directory."""
import os
if 'HOME' in os.environ: home = os.environ['HOME']
else: home = os.curdir
class_tcl = os.path.join(home, '.%s.tcl' % className)
class_py = os.path.join(home, '.%s.py' % className)
base_tcl = os.path.join(home, '.%s.tcl' % baseName)
base_py = os.path.join(home, '.%s.py' % baseName)
dir = {'self': self}
exec 'from Tkinter import *' in dir
if os.path.isfile(class_tcl):
self.tk.call('source', class_tcl)
if os.path.isfile(class_py):
execfile(class_py, dir)
if os.path.isfile(base_tcl):
self.tk.call('source', base_tcl)
if os.path.isfile(base_py):
execfile(base_py, dir)
def report_callback_exception(self, exc, val, tb):
"""Report callback exception on sys.stderr.
Applications may want to override this internal function, and
should when sys.stderr is None."""
import traceback, sys
print >>sys.stderr, "Exception in Tkinter callback"
sys.last_type = exc
sys.last_value = val
sys.last_traceback = tb
traceback.print_exception(exc, val, tb)
def __getattr__(self, attr):
"Delegate attribute access to the interpreter object"
return getattr(self.tk, attr)
# Ideally, the classes Pack, Place and Grid disappear, the
# pack/place/grid methods are defined on the Widget class, and
# everybody uses w.pack_whatever(...) instead of Pack.whatever(w,
# ...), with pack(), place() and grid() being short for
# pack_configure(), place_configure() and grid_columnconfigure(), and
# forget() being short for pack_forget(). As a practical matter, I'm
# afraid that there is too much code out there that may be using the
# Pack, Place or Grid class, so I leave them intact -- but only as
# backwards compatibility features. Also note that those methods that
# take a master as argument (e.g. pack_propagate) have been moved to
# the Misc class (which now incorporates all methods common between
# toplevel and interior widgets). Again, for compatibility, these are
# copied into the Pack, Place or Grid class.
def Tcl(screenName=None, baseName=None, className='Tk', useTk=0):
return Tk(screenName, baseName, className, useTk)
class Pack:
"""Geometry manager Pack.
Base class to use the methods pack_* in every widget."""
def pack_configure(self, cnf={}, **kw):
"""Pack a widget in the parent widget. Use as options:
after=widget - pack it after you have packed widget
anchor=NSEW (or subset) - position widget according to
given direction
before=widget - pack it before you will pack widget
expand=bool - expand widget if parent size grows
fill=NONE or X or Y or BOTH - fill widget if widget grows
in=master - use master to contain this widget
in_=master - see 'in' option description
ipadx=amount - add internal padding in x direction
ipady=amount - add internal padding in y direction
padx=amount - add padding in x direction
pady=amount - add padding in y direction
side=TOP or BOTTOM or LEFT or RIGHT - where to add this widget.
"""
self.tk.call(
('pack', 'configure', self._w)
+ self._options(cnf, kw))
pack = configure = config = pack_configure
def pack_forget(self):
"""Unmap this widget and do not use it for the packing order."""
self.tk.call('pack', 'forget', self._w)
forget = pack_forget
def pack_info(self):
"""Return information about the packing options
for this widget."""
d = _splitdict(self.tk, self.tk.call('pack', 'info', self._w))
if 'in' in d:
d['in'] = self.nametowidget(d['in'])
return d
info = pack_info
propagate = pack_propagate = Misc.pack_propagate
slaves = pack_slaves = Misc.pack_slaves
class Place:
"""Geometry manager Place.
Base class to use the methods place_* in every widget."""
def place_configure(self, cnf={}, **kw):
"""Place a widget in the parent widget. Use as options:
in=master - master relative to which the widget is placed
in_=master - see 'in' option description
x=amount - locate anchor of this widget at position x of master
y=amount - locate anchor of this widget at position y of master
relx=amount - locate anchor of this widget between 0.0 and 1.0
relative to width of master (1.0 is right edge)
rely=amount - locate anchor of this widget between 0.0 and 1.0
relative to height of master (1.0 is bottom edge)
anchor=NSEW (or subset) - position anchor according to given direction
width=amount - width of this widget in pixel
height=amount - height of this widget in pixel
relwidth=amount - width of this widget between 0.0 and 1.0
relative to width of master (1.0 is the same width
as the master)
relheight=amount - height of this widget between 0.0 and 1.0
relative to height of master (1.0 is the same
height as the master)
bordermode="inside" or "outside" - whether to take border width of
master widget into account
"""
self.tk.call(
('place', 'configure', self._w)
+ self._options(cnf, kw))
place = configure = config = place_configure
def place_forget(self):
"""Unmap this widget."""
self.tk.call('place', 'forget', self._w)
forget = place_forget
def place_info(self):
"""Return information about the placing options
for this widget."""
d = _splitdict(self.tk, self.tk.call('place', 'info', self._w))
if 'in' in d:
d['in'] = self.nametowidget(d['in'])
return d
info = place_info
slaves = place_slaves = Misc.place_slaves
class Grid:
"""Geometry manager Grid.
Base class to use the methods grid_* in every widget."""
# Thanks to Masazumi Yoshikawa (yosikawa@isi.edu)
def grid_configure(self, cnf={}, **kw):
"""Position a widget in the parent widget in a grid. Use as options:
column=number - use cell identified with given column (starting with 0)
columnspan=number - this widget will span several columns
in=master - use master to contain this widget
in_=master - see 'in' option description
ipadx=amount - add internal padding in x direction
ipady=amount - add internal padding in y direction
padx=amount - add padding in x direction
pady=amount - add padding in y direction
row=number - use cell identified with given row (starting with 0)
rowspan=number - this widget will span several rows
sticky=NSEW - if cell is larger on which sides will this
widget stick to the cell boundary
"""
self.tk.call(
('grid', 'configure', self._w)
+ self._options(cnf, kw))
grid = configure = config = grid_configure
bbox = grid_bbox = Misc.grid_bbox
columnconfigure = grid_columnconfigure = Misc.grid_columnconfigure
def grid_forget(self):
"""Unmap this widget."""
self.tk.call('grid', 'forget', self._w)
forget = grid_forget
def grid_remove(self):
"""Unmap this widget but remember the grid options."""
self.tk.call('grid', 'remove', self._w)
def grid_info(self):
"""Return information about the options
for positioning this widget in a grid."""
d = _splitdict(self.tk, self.tk.call('grid', 'info', self._w))
if 'in' in d:
d['in'] = self.nametowidget(d['in'])
return d
info = grid_info
location = grid_location = Misc.grid_location
propagate = grid_propagate = Misc.grid_propagate
rowconfigure = grid_rowconfigure = Misc.grid_rowconfigure
size = grid_size = Misc.grid_size
slaves = grid_slaves = Misc.grid_slaves
class BaseWidget(Misc):
"""Internal class."""
def _setup(self, master, cnf):
"""Internal function. Sets up information about children."""
if _support_default_root:
global _default_root
if not master:
if not _default_root:
_default_root = Tk()
master = _default_root
self.master = master
self.tk = master.tk
name = None
if 'name' in cnf:
name = cnf['name']
del cnf['name']
if not name:
name = repr(id(self))
self._name = name
if master._w=='.':
self._w = '.' + name
else:
self._w = master._w + '.' + name
self.children = {}
if self._name in self.master.children:
self.master.children[self._name].destroy()
self.master.children[self._name] = self
def __init__(self, master, widgetName, cnf={}, kw={}, extra=()):
"""Construct a widget with the parent widget MASTER, a name WIDGETNAME
and appropriate options."""
if kw:
cnf = _cnfmerge((cnf, kw))
self.widgetName = widgetName
BaseWidget._setup(self, master, cnf)
if self._tclCommands is None:
self._tclCommands = []
classes = []
for k in cnf.keys():
if type(k) is ClassType:
classes.append((k, cnf[k]))
del cnf[k]
self.tk.call(
(widgetName, self._w) + extra + self._options(cnf))
for k, v in classes:
k.configure(self, v)
def destroy(self):
"""Destroy this and all descendants widgets."""
for c in self.children.values(): c.destroy()
self.tk.call('destroy', self._w)
if self._name in self.master.children:
del self.master.children[self._name]
Misc.destroy(self)
def _do(self, name, args=()):
# XXX Obsolete -- better use self.tk.call directly!
return self.tk.call((self._w, name) + args)
class Widget(BaseWidget, Pack, Place, Grid):
"""Internal class.
Base class for a widget which can be positioned with the geometry managers
Pack, Place or Grid."""
pass
class Toplevel(BaseWidget, Wm):
"""Toplevel widget, e.g. for dialogs."""
def __init__(self, master=None, cnf={}, **kw):
"""Construct a toplevel widget with the parent MASTER.
Valid resource names: background, bd, bg, borderwidth, class,
colormap, container, cursor, height, highlightbackground,
highlightcolor, highlightthickness, menu, relief, screen, takefocus,
use, visual, width."""
if kw:
cnf = _cnfmerge((cnf, kw))
extra = ()
for wmkey in ['screen', 'class_', 'class', 'visual',
'colormap']:
if wmkey in cnf:
val = cnf[wmkey]
# TBD: a hack needed because some keys
# are not valid as keyword arguments
if wmkey[-1] == '_': opt = '-'+wmkey[:-1]
else: opt = '-'+wmkey
extra = extra + (opt, val)
del cnf[wmkey]
BaseWidget.__init__(self, master, 'toplevel', cnf, {}, extra)
root = self._root()
self.iconname(root.iconname())
self.title(root.title())
self.protocol("WM_DELETE_WINDOW", self.destroy)
class Button(Widget):
"""Button widget."""
def __init__(self, master=None, cnf={}, **kw):
"""Construct a button widget with the parent MASTER.
STANDARD OPTIONS
activebackground, activeforeground, anchor,
background, bitmap, borderwidth, cursor,
disabledforeground, font, foreground
highlightbackground, highlightcolor,
highlightthickness, image, justify,
padx, pady, relief, repeatdelay,
repeatinterval, takefocus, text,
textvariable, underline, wraplength
WIDGET-SPECIFIC OPTIONS
command, compound, default, height,
overrelief, state, width
"""
Widget.__init__(self, master, 'button', cnf, kw)
def tkButtonEnter(self, *dummy):
self.tk.call('tkButtonEnter', self._w)
def tkButtonLeave(self, *dummy):
self.tk.call('tkButtonLeave', self._w)
def tkButtonDown(self, *dummy):
self.tk.call('tkButtonDown', self._w)
def tkButtonUp(self, *dummy):
self.tk.call('tkButtonUp', self._w)
def tkButtonInvoke(self, *dummy):
self.tk.call('tkButtonInvoke', self._w)
def flash(self):
"""Flash the button.
This is accomplished by redisplaying
the button several times, alternating between active and
normal colors. At the end of the flash the button is left
in the same normal/active state as when the command was
invoked. This command is ignored if the button's state is
disabled.
"""
self.tk.call(self._w, 'flash')
def invoke(self):
"""Invoke the command associated with the button.
The return value is the return value from the command,
or an empty string if there is no command associated with
the button. This command is ignored if the button's state
is disabled.
"""
return self.tk.call(self._w, 'invoke')
# Indices:
# XXX I don't like these -- take them away
def AtEnd():
return 'end'
def AtInsert(*args):
s = 'insert'
for a in args:
if a: s = s + (' ' + a)
return s
def AtSelFirst():
return 'sel.first'
def AtSelLast():
return 'sel.last'
def At(x, y=None):
if y is None:
return '@%r' % (x,)
else:
return '@%r,%r' % (x, y)
class Canvas(Widget, XView, YView):
"""Canvas widget to display graphical elements like lines or text."""
def __init__(self, master=None, cnf={}, **kw):
"""Construct a canvas widget with the parent MASTER.
Valid resource names: background, bd, bg, borderwidth, closeenough,
confine, cursor, height, highlightbackground, highlightcolor,
highlightthickness, insertbackground, insertborderwidth,
insertofftime, insertontime, insertwidth, offset, relief,
scrollregion, selectbackground, selectborderwidth, selectforeground,
state, takefocus, width, xscrollcommand, xscrollincrement,
yscrollcommand, yscrollincrement."""
Widget.__init__(self, master, 'canvas', cnf, kw)
def addtag(self, *args):
"""Internal function."""
self.tk.call((self._w, 'addtag') + args)
def addtag_above(self, newtag, tagOrId):
"""Add tag NEWTAG to all items above TAGORID."""
self.addtag(newtag, 'above', tagOrId)
def addtag_all(self, newtag):
"""Add tag NEWTAG to all items."""
self.addtag(newtag, 'all')
def addtag_below(self, newtag, tagOrId):
"""Add tag NEWTAG to all items below TAGORID."""
self.addtag(newtag, 'below', tagOrId)
def addtag_closest(self, newtag, x, y, halo=None, start=None):
"""Add tag NEWTAG to item which is closest to pixel at X, Y.
If several match take the top-most.
All items closer than HALO are considered overlapping (all are
closests). If START is specified the next below this tag is taken."""
self.addtag(newtag, 'closest', x, y, halo, start)
def addtag_enclosed(self, newtag, x1, y1, x2, y2):
"""Add tag NEWTAG to all items in the rectangle defined
by X1,Y1,X2,Y2."""
self.addtag(newtag, 'enclosed', x1, y1, x2, y2)
def addtag_overlapping(self, newtag, x1, y1, x2, y2):
"""Add tag NEWTAG to all items which overlap the rectangle
defined by X1,Y1,X2,Y2."""
self.addtag(newtag, 'overlapping', x1, y1, x2, y2)
def addtag_withtag(self, newtag, tagOrId):
"""Add tag NEWTAG to all items with TAGORID."""
self.addtag(newtag, 'withtag', tagOrId)
def bbox(self, *args):
"""Return a tuple of X1,Y1,X2,Y2 coordinates for a rectangle
which encloses all items with tags specified as arguments."""
return self._getints(
self.tk.call((self._w, 'bbox') + args)) or None
def tag_unbind(self, tagOrId, sequence, funcid=None):
"""Unbind for all items with TAGORID for event SEQUENCE the
function identified with FUNCID."""
self.tk.call(self._w, 'bind', tagOrId, sequence, '')
if funcid:
self.deletecommand(funcid)
def tag_bind(self, tagOrId, sequence=None, func=None, add=None):
"""Bind to all items with TAGORID at event SEQUENCE a call to function FUNC.
An additional boolean parameter ADD specifies whether FUNC will be
called additionally to the other bound function or whether it will
replace the previous function. See bind for the return value."""
return self._bind((self._w, 'bind', tagOrId),
sequence, func, add)
def canvasx(self, screenx, gridspacing=None):
"""Return the canvas x coordinate of pixel position SCREENX rounded
to nearest multiple of GRIDSPACING units."""
return getdouble(self.tk.call(
self._w, 'canvasx', screenx, gridspacing))
def canvasy(self, screeny, gridspacing=None):
"""Return the canvas y coordinate of pixel position SCREENY rounded
to nearest multiple of GRIDSPACING units."""
return getdouble(self.tk.call(
self._w, 'canvasy', screeny, gridspacing))
def coords(self, *args):
"""Return a list of coordinates for the item given in ARGS."""
# XXX Should use _flatten on args
return map(getdouble,
self.tk.splitlist(
self.tk.call((self._w, 'coords') + args)))
def _create(self, itemType, args, kw): # Args: (val, val, ..., cnf={})
"""Internal function."""
args = _flatten(args)
cnf = args[-1]
if type(cnf) in (DictionaryType, TupleType):
args = args[:-1]
else:
cnf = {}
return getint(self.tk.call(
self._w, 'create', itemType,
*(args + self._options(cnf, kw))))
def create_arc(self, *args, **kw):
"""Create arc shaped region with coordinates x1,y1,x2,y2."""
return self._create('arc', args, kw)
def create_bitmap(self, *args, **kw):
"""Create bitmap with coordinates x1,y1."""
return self._create('bitmap', args, kw)
def create_image(self, *args, **kw):
"""Create image item with coordinates x1,y1."""
return self._create('image', args, kw)
def create_line(self, *args, **kw):
"""Create line with coordinates x1,y1,...,xn,yn."""
return self._create('line', args, kw)
def create_oval(self, *args, **kw):
"""Create oval with coordinates x1,y1,x2,y2."""
return self._create('oval', args, kw)
def create_polygon(self, *args, **kw):
"""Create polygon with coordinates x1,y1,...,xn,yn."""
return self._create('polygon', args, kw)
def create_rectangle(self, *args, **kw):
"""Create rectangle with coordinates x1,y1,x2,y2."""
return self._create('rectangle', args, kw)
def create_text(self, *args, **kw):
"""Create text with coordinates x1,y1."""
return self._create('text', args, kw)
def create_window(self, *args, **kw):
"""Create window with coordinates x1,y1,x2,y2."""
return self._create('window', args, kw)
def dchars(self, *args):
"""Delete characters of text items identified by tag or id in ARGS (possibly
several times) from FIRST to LAST character (including)."""
self.tk.call((self._w, 'dchars') + args)
def delete(self, *args):
"""Delete items identified by all tag or ids contained in ARGS."""
self.tk.call((self._w, 'delete') + args)
def dtag(self, *args):
"""Delete tag or id given as last arguments in ARGS from items
identified by first argument in ARGS."""
self.tk.call((self._w, 'dtag') + args)
def find(self, *args):
"""Internal function."""
return self._getints(
self.tk.call((self._w, 'find') + args)) or ()
def find_above(self, tagOrId):
"""Return items above TAGORID."""
return self.find('above', tagOrId)
def find_all(self):
"""Return all items."""
return self.find('all')
def find_below(self, tagOrId):
"""Return all items below TAGORID."""
return self.find('below', tagOrId)
def find_closest(self, x, y, halo=None, start=None):
"""Return item which is closest to pixel at X, Y.
If several match take the top-most.
All items closer than HALO are considered overlapping (all are
closest). If START is specified the next below this tag is taken."""
return self.find('closest', x, y, halo, start)
def find_enclosed(self, x1, y1, x2, y2):
"""Return all items in rectangle defined
by X1,Y1,X2,Y2."""
return self.find('enclosed', x1, y1, x2, y2)
def find_overlapping(self, x1, y1, x2, y2):
"""Return all items which overlap the rectangle
defined by X1,Y1,X2,Y2."""
return self.find('overlapping', x1, y1, x2, y2)
def find_withtag(self, tagOrId):
"""Return all items with TAGORID."""
return self.find('withtag', tagOrId)
def focus(self, *args):
"""Set focus to the first item specified in ARGS."""
return self.tk.call((self._w, 'focus') + args)
def gettags(self, *args):
"""Return tags associated with the first item specified in ARGS."""
return self.tk.splitlist(
self.tk.call((self._w, 'gettags') + args))
def icursor(self, *args):
"""Set cursor at position POS in the item identified by TAGORID.
In ARGS TAGORID must be first."""
self.tk.call((self._w, 'icursor') + args)
def index(self, *args):
"""Return position of cursor as integer in item specified in ARGS."""
return getint(self.tk.call((self._w, 'index') + args))
def insert(self, *args):
"""Insert TEXT in item TAGORID at position POS. ARGS must
be TAGORID POS TEXT."""
self.tk.call((self._w, 'insert') + args)
def itemcget(self, tagOrId, option):
"""Return the resource value for an OPTION for item TAGORID."""
return self.tk.call(
(self._w, 'itemcget') + (tagOrId, '-'+option))
def itemconfigure(self, tagOrId, cnf=None, **kw):
"""Configure resources of an item TAGORID.
The values for resources are specified as keyword
arguments. To get an overview about
the allowed keyword arguments call the method without arguments.
"""
return self._configure(('itemconfigure', tagOrId), cnf, kw)
itemconfig = itemconfigure
# lower, tkraise/lift hide Misc.lower, Misc.tkraise/lift,
# so the preferred name for them is tag_lower, tag_raise
# (similar to tag_bind, and similar to the Text widget);
# unfortunately can't delete the old ones yet (maybe in 1.6)
def tag_lower(self, *args):
"""Lower an item TAGORID given in ARGS
(optional below another item)."""
self.tk.call((self._w, 'lower') + args)
lower = tag_lower
def move(self, *args):
"""Move an item TAGORID given in ARGS."""
self.tk.call((self._w, 'move') + args)
def postscript(self, cnf={}, **kw):
"""Print the contents of the canvas to a postscript
file. Valid options: colormap, colormode, file, fontmap,
height, pageanchor, pageheight, pagewidth, pagex, pagey,
rotate, width, x, y."""
return self.tk.call((self._w, 'postscript') +
self._options(cnf, kw))
def tag_raise(self, *args):
"""Raise an item TAGORID given in ARGS
(optional above another item)."""
self.tk.call((self._w, 'raise') + args)
lift = tkraise = tag_raise
def scale(self, *args):
"""Scale item TAGORID with XORIGIN, YORIGIN, XSCALE, YSCALE."""
self.tk.call((self._w, 'scale') + args)
def scan_mark(self, x, y):
"""Remember the current X, Y coordinates."""
self.tk.call(self._w, 'scan', 'mark', x, y)
def scan_dragto(self, x, y, gain=10):
"""Adjust the view of the canvas to GAIN times the
difference between X and Y and the coordinates given in
scan_mark."""
self.tk.call(self._w, 'scan', 'dragto', x, y, gain)
def select_adjust(self, tagOrId, index):
"""Adjust the end of the selection near the cursor of an item TAGORID to index."""
self.tk.call(self._w, 'select', 'adjust', tagOrId, index)
def select_clear(self):
"""Clear the selection if it is in this widget."""
self.tk.call(self._w, 'select', 'clear')
def select_from(self, tagOrId, index):
"""Set the fixed end of a selection in item TAGORID to INDEX."""
self.tk.call(self._w, 'select', 'from', tagOrId, index)
def select_item(self):
"""Return the item which has the selection."""
return self.tk.call(self._w, 'select', 'item') or None
def select_to(self, tagOrId, index):
"""Set the variable end of a selection in item TAGORID to INDEX."""
self.tk.call(self._w, 'select', 'to', tagOrId, index)
def type(self, tagOrId):
"""Return the type of the item TAGORID."""
return self.tk.call(self._w, 'type', tagOrId) or None
class Checkbutton(Widget):
"""Checkbutton widget which is either in on- or off-state."""
def __init__(self, master=None, cnf={}, **kw):
"""Construct a checkbutton widget with the parent MASTER.
Valid resource names: activebackground, activeforeground, anchor,
background, bd, bg, bitmap, borderwidth, command, cursor,
disabledforeground, fg, font, foreground, height,
highlightbackground, highlightcolor, highlightthickness, image,
indicatoron, justify, offvalue, onvalue, padx, pady, relief,
selectcolor, selectimage, state, takefocus, text, textvariable,
underline, variable, width, wraplength."""
Widget.__init__(self, master, 'checkbutton', cnf, kw)
def deselect(self):
"""Put the button in off-state."""
self.tk.call(self._w, 'deselect')
def flash(self):
"""Flash the button."""
self.tk.call(self._w, 'flash')
def invoke(self):
"""Toggle the button and invoke a command if given as resource."""
return self.tk.call(self._w, 'invoke')
def select(self):
"""Put the button in on-state."""
self.tk.call(self._w, 'select')
def toggle(self):
"""Toggle the button."""
self.tk.call(self._w, 'toggle')
class Entry(Widget, XView):
"""Entry widget which allows displaying simple text."""
def __init__(self, master=None, cnf={}, **kw):
"""Construct an entry widget with the parent MASTER.
Valid resource names: background, bd, bg, borderwidth, cursor,
exportselection, fg, font, foreground, highlightbackground,
highlightcolor, highlightthickness, insertbackground,
insertborderwidth, insertofftime, insertontime, insertwidth,
invalidcommand, invcmd, justify, relief, selectbackground,
selectborderwidth, selectforeground, show, state, takefocus,
textvariable, validate, validatecommand, vcmd, width,
xscrollcommand."""
Widget.__init__(self, master, 'entry', cnf, kw)
def delete(self, first, last=None):
"""Delete text from FIRST to LAST (not included)."""
self.tk.call(self._w, 'delete', first, last)
def get(self):
"""Return the text."""
return self.tk.call(self._w, 'get')
def icursor(self, index):
"""Insert cursor at INDEX."""
self.tk.call(self._w, 'icursor', index)
def index(self, index):
"""Return position of cursor."""
return getint(self.tk.call(
self._w, 'index', index))
def insert(self, index, string):
"""Insert STRING at INDEX."""
self.tk.call(self._w, 'insert', index, string)
def scan_mark(self, x):
"""Remember the current X, Y coordinates."""
self.tk.call(self._w, 'scan', 'mark', x)
def scan_dragto(self, x):
"""Adjust the view of the canvas to 10 times the
difference between X and Y and the coordinates given in
scan_mark."""
self.tk.call(self._w, 'scan', 'dragto', x)
def selection_adjust(self, index):
"""Adjust the end of the selection near the cursor to INDEX."""
self.tk.call(self._w, 'selection', 'adjust', index)
select_adjust = selection_adjust
def selection_clear(self):
"""Clear the selection if it is in this widget."""
self.tk.call(self._w, 'selection', 'clear')
select_clear = selection_clear
def selection_from(self, index):
"""Set the fixed end of a selection to INDEX."""
self.tk.call(self._w, 'selection', 'from', index)
select_from = selection_from
def selection_present(self):
"""Return True if there are characters selected in the entry, False
otherwise."""
return self.tk.getboolean(
self.tk.call(self._w, 'selection', 'present'))
select_present = selection_present
def selection_range(self, start, end):
"""Set the selection from START to END (not included)."""
self.tk.call(self._w, 'selection', 'range', start, end)
select_range = selection_range
def selection_to(self, index):
"""Set the variable end of a selection to INDEX."""
self.tk.call(self._w, 'selection', 'to', index)
select_to = selection_to
class Frame(Widget):
"""Frame widget which may contain other widgets and can have a 3D border."""
def __init__(self, master=None, cnf={}, **kw):
"""Construct a frame widget with the parent MASTER.
Valid resource names: background, bd, bg, borderwidth, class,
colormap, container, cursor, height, highlightbackground,
highlightcolor, highlightthickness, relief, takefocus, visual, width."""
cnf = _cnfmerge((cnf, kw))
extra = ()
if 'class_' in cnf:
extra = ('-class', cnf['class_'])
del cnf['class_']
elif 'class' in cnf:
extra = ('-class', cnf['class'])
del cnf['class']
Widget.__init__(self, master, 'frame', cnf, {}, extra)
class Label(Widget):
"""Label widget which can display text and bitmaps."""
def __init__(self, master=None, cnf={}, **kw):
"""Construct a label widget with the parent MASTER.
STANDARD OPTIONS
activebackground, activeforeground, anchor,
background, bitmap, borderwidth, cursor,
disabledforeground, font, foreground,
highlightbackground, highlightcolor,
highlightthickness, image, justify,
padx, pady, relief, takefocus, text,
textvariable, underline, wraplength
WIDGET-SPECIFIC OPTIONS
height, state, width
"""
Widget.__init__(self, master, 'label', cnf, kw)
class Listbox(Widget, XView, YView):
"""Listbox widget which can display a list of strings."""
def __init__(self, master=None, cnf={}, **kw):
"""Construct a listbox widget with the parent MASTER.
Valid resource names: background, bd, bg, borderwidth, cursor,
exportselection, fg, font, foreground, height, highlightbackground,
highlightcolor, highlightthickness, relief, selectbackground,
selectborderwidth, selectforeground, selectmode, setgrid, takefocus,
width, xscrollcommand, yscrollcommand, listvariable."""
Widget.__init__(self, master, 'listbox', cnf, kw)
def activate(self, index):
"""Activate item identified by INDEX."""
self.tk.call(self._w, 'activate', index)
def bbox(self, index):
"""Return a tuple of X1,Y1,X2,Y2 coordinates for a rectangle
which encloses the item identified by the given index."""
return self._getints(self.tk.call(self._w, 'bbox', index)) or None
def curselection(self):
"""Return the indices of currently selected item."""
return self._getints(self.tk.call(self._w, 'curselection')) or ()
def delete(self, first, last=None):
"""Delete items from FIRST to LAST (included)."""
self.tk.call(self._w, 'delete', first, last)
def get(self, first, last=None):
"""Get list of items from FIRST to LAST (included)."""
if last is not None:
return self.tk.splitlist(self.tk.call(
self._w, 'get', first, last))
else:
return self.tk.call(self._w, 'get', first)
def index(self, index):
"""Return index of item identified with INDEX."""
i = self.tk.call(self._w, 'index', index)
if i == 'none': return None
return getint(i)
def insert(self, index, *elements):
"""Insert ELEMENTS at INDEX."""
self.tk.call((self._w, 'insert', index) + elements)
def nearest(self, y):
"""Get index of item which is nearest to y coordinate Y."""
return getint(self.tk.call(
self._w, 'nearest', y))
def scan_mark(self, x, y):
"""Remember the current X, Y coordinates."""
self.tk.call(self._w, 'scan', 'mark', x, y)
def scan_dragto(self, x, y):
"""Adjust the view of the listbox to 10 times the
difference between X and Y and the coordinates given in
scan_mark."""
self.tk.call(self._w, 'scan', 'dragto', x, y)
def see(self, index):
"""Scroll such that INDEX is visible."""
self.tk.call(self._w, 'see', index)
def selection_anchor(self, index):
"""Set the fixed end oft the selection to INDEX."""
self.tk.call(self._w, 'selection', 'anchor', index)
select_anchor = selection_anchor
def selection_clear(self, first, last=None):
"""Clear the selection from FIRST to LAST (included)."""
self.tk.call(self._w,
'selection', 'clear', first, last)
select_clear = selection_clear
def selection_includes(self, index):
"""Return 1 if INDEX is part of the selection."""
return self.tk.getboolean(self.tk.call(
self._w, 'selection', 'includes', index))
select_includes = selection_includes
def selection_set(self, first, last=None):
"""Set the selection from FIRST to LAST (included) without
changing the currently selected elements."""
self.tk.call(self._w, 'selection', 'set', first, last)
select_set = selection_set
def size(self):
"""Return the number of elements in the listbox."""
return getint(self.tk.call(self._w, 'size'))
def itemcget(self, index, option):
"""Return the resource value for an ITEM and an OPTION."""
return self.tk.call(
(self._w, 'itemcget') + (index, '-'+option))
def itemconfigure(self, index, cnf=None, **kw):
"""Configure resources of an ITEM.
The values for resources are specified as keyword arguments.
To get an overview about the allowed keyword arguments
call the method without arguments.
Valid resource names: background, bg, foreground, fg,
selectbackground, selectforeground."""
return self._configure(('itemconfigure', index), cnf, kw)
itemconfig = itemconfigure
class Menu(Widget):
"""Menu widget which allows displaying menu bars, pull-down menus and pop-up menus."""
def __init__(self, master=None, cnf={}, **kw):
"""Construct menu widget with the parent MASTER.
Valid resource names: activebackground, activeborderwidth,
activeforeground, background, bd, bg, borderwidth, cursor,
disabledforeground, fg, font, foreground, postcommand, relief,
selectcolor, takefocus, tearoff, tearoffcommand, title, type."""
Widget.__init__(self, master, 'menu', cnf, kw)
def tk_bindForTraversal(self):
# obsolete since Tk 4.0
import warnings
warnings.warn('tk_bindForTraversal() does nothing and '
'will be removed in 3.6',
DeprecationWarning, stacklevel=2)
def tk_mbPost(self):
self.tk.call('tk_mbPost', self._w)
def tk_mbUnpost(self):
self.tk.call('tk_mbUnpost')
def tk_traverseToMenu(self, char):
self.tk.call('tk_traverseToMenu', self._w, char)
def tk_traverseWithinMenu(self, char):
self.tk.call('tk_traverseWithinMenu', self._w, char)
def tk_getMenuButtons(self):
return self.tk.call('tk_getMenuButtons', self._w)
def tk_nextMenu(self, count):
self.tk.call('tk_nextMenu', count)
def tk_nextMenuEntry(self, count):
self.tk.call('tk_nextMenuEntry', count)
def tk_invokeMenu(self):
self.tk.call('tk_invokeMenu', self._w)
def tk_firstMenu(self):
self.tk.call('tk_firstMenu', self._w)
def tk_mbButtonDown(self):
self.tk.call('tk_mbButtonDown', self._w)
def tk_popup(self, x, y, entry=""):
"""Post the menu at position X,Y with entry ENTRY."""
self.tk.call('tk_popup', self._w, x, y, entry)
def activate(self, index):
"""Activate entry at INDEX."""
self.tk.call(self._w, 'activate', index)
def add(self, itemType, cnf={}, **kw):
"""Internal function."""
self.tk.call((self._w, 'add', itemType) +
self._options(cnf, kw))
def add_cascade(self, cnf={}, **kw):
"""Add hierarchical menu item."""
self.add('cascade', cnf or kw)
def add_checkbutton(self, cnf={}, **kw):
"""Add checkbutton menu item."""
self.add('checkbutton', cnf or kw)
def add_command(self, cnf={}, **kw):
"""Add command menu item."""
self.add('command', cnf or kw)
def add_radiobutton(self, cnf={}, **kw):
"""Addd radio menu item."""
self.add('radiobutton', cnf or kw)
def add_separator(self, cnf={}, **kw):
"""Add separator."""
self.add('separator', cnf or kw)
def insert(self, index, itemType, cnf={}, **kw):
"""Internal function."""
self.tk.call((self._w, 'insert', index, itemType) +
self._options(cnf, kw))
def insert_cascade(self, index, cnf={}, **kw):
"""Add hierarchical menu item at INDEX."""
self.insert(index, 'cascade', cnf or kw)
def insert_checkbutton(self, index, cnf={}, **kw):
"""Add checkbutton menu item at INDEX."""
self.insert(index, 'checkbutton', cnf or kw)
def insert_command(self, index, cnf={}, **kw):
"""Add command menu item at INDEX."""
self.insert(index, 'command', cnf or kw)
def insert_radiobutton(self, index, cnf={}, **kw):
"""Addd radio menu item at INDEX."""
self.insert(index, 'radiobutton', cnf or kw)
def insert_separator(self, index, cnf={}, **kw):
"""Add separator at INDEX."""
self.insert(index, 'separator', cnf or kw)
def delete(self, index1, index2=None):
"""Delete menu items between INDEX1 and INDEX2 (included)."""
if index2 is None:
index2 = index1
num_index1, num_index2 = self.index(index1), self.index(index2)
if (num_index1 is None) or (num_index2 is None):
num_index1, num_index2 = 0, -1
for i in range(num_index1, num_index2 + 1):
if 'command' in self.entryconfig(i):
c = str(self.entrycget(i, 'command'))
if c:
self.deletecommand(c)
self.tk.call(self._w, 'delete', index1, index2)
def entrycget(self, index, option):
"""Return the resource value of a menu item for OPTION at INDEX."""
return self.tk.call(self._w, 'entrycget', index, '-' + option)
def entryconfigure(self, index, cnf=None, **kw):
"""Configure a menu item at INDEX."""
return self._configure(('entryconfigure', index), cnf, kw)
entryconfig = entryconfigure
def index(self, index):
"""Return the index of a menu item identified by INDEX."""
i = self.tk.call(self._w, 'index', index)
if i == 'none': return None
return getint(i)
def invoke(self, index):
"""Invoke a menu item identified by INDEX and execute
the associated command."""
return self.tk.call(self._w, 'invoke', index)
def post(self, x, y):
"""Display a menu at position X,Y."""
self.tk.call(self._w, 'post', x, y)
def type(self, index):
"""Return the type of the menu item at INDEX."""
return self.tk.call(self._w, 'type', index)
def unpost(self):
"""Unmap a menu."""
self.tk.call(self._w, 'unpost')
def yposition(self, index):
"""Return the y-position of the topmost pixel of the menu item at INDEX."""
return getint(self.tk.call(
self._w, 'yposition', index))
class Menubutton(Widget):
"""Menubutton widget, obsolete since Tk8.0."""
def __init__(self, master=None, cnf={}, **kw):
Widget.__init__(self, master, 'menubutton', cnf, kw)
class Message(Widget):
"""Message widget to display multiline text. Obsolete since Label does it too."""
def __init__(self, master=None, cnf={}, **kw):
Widget.__init__(self, master, 'message', cnf, kw)
class Radiobutton(Widget):
"""Radiobutton widget which shows only one of several buttons in on-state."""
def __init__(self, master=None, cnf={}, **kw):
"""Construct a radiobutton widget with the parent MASTER.
Valid resource names: activebackground, activeforeground, anchor,
background, bd, bg, bitmap, borderwidth, command, cursor,
disabledforeground, fg, font, foreground, height,
highlightbackground, highlightcolor, highlightthickness, image,
indicatoron, justify, padx, pady, relief, selectcolor, selectimage,
state, takefocus, text, textvariable, underline, value, variable,
width, wraplength."""
Widget.__init__(self, master, 'radiobutton', cnf, kw)
def deselect(self):
"""Put the button in off-state."""
self.tk.call(self._w, 'deselect')
def flash(self):
"""Flash the button."""
self.tk.call(self._w, 'flash')
def invoke(self):
"""Toggle the button and invoke a command if given as resource."""
return self.tk.call(self._w, 'invoke')
def select(self):
"""Put the button in on-state."""
self.tk.call(self._w, 'select')
class Scale(Widget):
"""Scale widget which can display a numerical scale."""
def __init__(self, master=None, cnf={}, **kw):
"""Construct a scale widget with the parent MASTER.
Valid resource names: activebackground, background, bigincrement, bd,
bg, borderwidth, command, cursor, digits, fg, font, foreground, from,
highlightbackground, highlightcolor, highlightthickness, label,
length, orient, relief, repeatdelay, repeatinterval, resolution,
showvalue, sliderlength, sliderrelief, state, takefocus,
tickinterval, to, troughcolor, variable, width."""
Widget.__init__(self, master, 'scale', cnf, kw)
def get(self):
"""Get the current value as integer or float."""
value = self.tk.call(self._w, 'get')
try:
return getint(value)
except ValueError:
return getdouble(value)
def set(self, value):
"""Set the value to VALUE."""
self.tk.call(self._w, 'set', value)
def coords(self, value=None):
"""Return a tuple (X,Y) of the point along the centerline of the
trough that corresponds to VALUE or the current value if None is
given."""
return self._getints(self.tk.call(self._w, 'coords', value))
def identify(self, x, y):
"""Return where the point X,Y lies. Valid return values are "slider",
"though1" and "though2"."""
return self.tk.call(self._w, 'identify', x, y)
class Scrollbar(Widget):
"""Scrollbar widget which displays a slider at a certain position."""
def __init__(self, master=None, cnf={}, **kw):
"""Construct a scrollbar widget with the parent MASTER.
Valid resource names: activebackground, activerelief,
background, bd, bg, borderwidth, command, cursor,
elementborderwidth, highlightbackground,
highlightcolor, highlightthickness, jump, orient,
relief, repeatdelay, repeatinterval, takefocus,
troughcolor, width."""
Widget.__init__(self, master, 'scrollbar', cnf, kw)
def activate(self, index):
"""Display the element at INDEX with activebackground and activerelief.
INDEX can be "arrow1","slider" or "arrow2"."""
self.tk.call(self._w, 'activate', index)
def delta(self, deltax, deltay):
"""Return the fractional change of the scrollbar setting if it
would be moved by DELTAX or DELTAY pixels."""
return getdouble(
self.tk.call(self._w, 'delta', deltax, deltay))
def fraction(self, x, y):
"""Return the fractional value which corresponds to a slider
position of X,Y."""
return getdouble(self.tk.call(self._w, 'fraction', x, y))
def identify(self, x, y):
"""Return the element under position X,Y as one of
"arrow1","slider","arrow2" or ""."""
return self.tk.call(self._w, 'identify', x, y)
def get(self):
"""Return the current fractional values (upper and lower end)
of the slider position."""
return self._getdoubles(self.tk.call(self._w, 'get'))
def set(self, *args):
"""Set the fractional values of the slider position (upper and
lower ends as value between 0 and 1)."""
self.tk.call((self._w, 'set') + args)
class Text(Widget, XView, YView):
"""Text widget which can display text in various forms."""
def __init__(self, master=None, cnf={}, **kw):
"""Construct a text widget with the parent MASTER.
STANDARD OPTIONS
background, borderwidth, cursor,
exportselection, font, foreground,
highlightbackground, highlightcolor,
highlightthickness, insertbackground,
insertborderwidth, insertofftime,
insertontime, insertwidth, padx, pady,
relief, selectbackground,
selectborderwidth, selectforeground,
setgrid, takefocus,
xscrollcommand, yscrollcommand,
WIDGET-SPECIFIC OPTIONS
autoseparators, height, maxundo,
spacing1, spacing2, spacing3,
state, tabs, undo, width, wrap,
"""
Widget.__init__(self, master, 'text', cnf, kw)
def bbox(self, *args):
"""Return a tuple of (x,y,width,height) which gives the bounding
box of the visible part of the character at the index in ARGS."""
return self._getints(
self.tk.call((self._w, 'bbox') + args)) or None
def tk_textSelectTo(self, index):
self.tk.call('tk_textSelectTo', self._w, index)
def tk_textBackspace(self):
self.tk.call('tk_textBackspace', self._w)
def tk_textIndexCloser(self, a, b, c):
self.tk.call('tk_textIndexCloser', self._w, a, b, c)
def tk_textResetAnchor(self, index):
self.tk.call('tk_textResetAnchor', self._w, index)
def compare(self, index1, op, index2):
"""Return whether between index INDEX1 and index INDEX2 the
relation OP is satisfied. OP is one of <, <=, ==, >=, >, or !=."""
return self.tk.getboolean(self.tk.call(
self._w, 'compare', index1, op, index2))
def debug(self, boolean=None):
"""Turn on the internal consistency checks of the B-Tree inside the text
widget according to BOOLEAN."""
if boolean is None:
return self.tk.getboolean(self.tk.call(self._w, 'debug'))
self.tk.call(self._w, 'debug', boolean)
def delete(self, index1, index2=None):
"""Delete the characters between INDEX1 and INDEX2 (not included)."""
self.tk.call(self._w, 'delete', index1, index2)
def dlineinfo(self, index):
"""Return tuple (x,y,width,height,baseline) giving the bounding box
and baseline position of the visible part of the line containing
the character at INDEX."""
return self._getints(self.tk.call(self._w, 'dlineinfo', index))
def dump(self, index1, index2=None, command=None, **kw):
"""Return the contents of the widget between index1 and index2.
The type of contents returned in filtered based on the keyword
parameters; if 'all', 'image', 'mark', 'tag', 'text', or 'window' are
given and true, then the corresponding items are returned. The result
is a list of triples of the form (key, value, index). If none of the
keywords are true then 'all' is used by default.
If the 'command' argument is given, it is called once for each element
of the list of triples, with the values of each triple serving as the
arguments to the function. In this case the list is not returned."""
args = []
func_name = None
result = None
if not command:
# Never call the dump command without the -command flag, since the
# output could involve Tcl quoting and would be a pain to parse
# right. Instead just set the command to build a list of triples
# as if we had done the parsing.
result = []
def append_triple(key, value, index, result=result):
result.append((key, value, index))
command = append_triple
try:
if not isinstance(command, str):
func_name = command = self._register(command)
args += ["-command", command]
for key in kw:
if kw[key]: args.append("-" + key)
args.append(index1)
if index2:
args.append(index2)
self.tk.call(self._w, "dump", *args)
return result
finally:
if func_name:
self.deletecommand(func_name)
## new in tk8.4
def edit(self, *args):
"""Internal method
This method controls the undo mechanism and
the modified flag. The exact behavior of the
command depends on the option argument that
follows the edit argument. The following forms
of the command are currently supported:
edit_modified, edit_redo, edit_reset, edit_separator
and edit_undo
"""
return self.tk.call(self._w, 'edit', *args)
def edit_modified(self, arg=None):
"""Get or Set the modified flag
If arg is not specified, returns the modified
flag of the widget. The insert, delete, edit undo and
edit redo commands or the user can set or clear the
modified flag. If boolean is specified, sets the
modified flag of the widget to arg.
"""
return self.edit("modified", arg)
def edit_redo(self):
"""Redo the last undone edit
When the undo option is true, reapplies the last
undone edits provided no other edits were done since
then. Generates an error when the redo stack is empty.
Does nothing when the undo option is false.
"""
return self.edit("redo")
def edit_reset(self):
"""Clears the undo and redo stacks
"""
return self.edit("reset")
def edit_separator(self):
"""Inserts a separator (boundary) on the undo stack.
Does nothing when the undo option is false
"""
return self.edit("separator")
def edit_undo(self):
"""Undoes the last edit action
If the undo option is true. An edit action is defined
as all the insert and delete commands that are recorded
on the undo stack in between two separators. Generates
an error when the undo stack is empty. Does nothing
when the undo option is false
"""
return self.edit("undo")
def get(self, index1, index2=None):
"""Return the text from INDEX1 to INDEX2 (not included)."""
return self.tk.call(self._w, 'get', index1, index2)
# (Image commands are new in 8.0)
def image_cget(self, index, option):
"""Return the value of OPTION of an embedded image at INDEX."""
if option[:1] != "-":
option = "-" + option
if option[-1:] == "_":
option = option[:-1]
return self.tk.call(self._w, "image", "cget", index, option)
def image_configure(self, index, cnf=None, **kw):
"""Configure an embedded image at INDEX."""
return self._configure(('image', 'configure', index), cnf, kw)
def image_create(self, index, cnf={}, **kw):
"""Create an embedded image at INDEX."""
return self.tk.call(
self._w, "image", "create", index,
*self._options(cnf, kw))
def image_names(self):
"""Return all names of embedded images in this widget."""
return self.tk.call(self._w, "image", "names")
def index(self, index):
"""Return the index in the form line.char for INDEX."""
return str(self.tk.call(self._w, 'index', index))
def insert(self, index, chars, *args):
"""Insert CHARS before the characters at INDEX. An additional
tag can be given in ARGS. Additional CHARS and tags can follow in ARGS."""
self.tk.call((self._w, 'insert', index, chars) + args)
def mark_gravity(self, markName, direction=None):
"""Change the gravity of a mark MARKNAME to DIRECTION (LEFT or RIGHT).
Return the current value if None is given for DIRECTION."""
return self.tk.call(
(self._w, 'mark', 'gravity', markName, direction))
def mark_names(self):
"""Return all mark names."""
return self.tk.splitlist(self.tk.call(
self._w, 'mark', 'names'))
def mark_set(self, markName, index):
"""Set mark MARKNAME before the character at INDEX."""
self.tk.call(self._w, 'mark', 'set', markName, index)
def mark_unset(self, *markNames):
"""Delete all marks in MARKNAMES."""
self.tk.call((self._w, 'mark', 'unset') + markNames)
def mark_next(self, index):
"""Return the name of the next mark after INDEX."""
return self.tk.call(self._w, 'mark', 'next', index) or None
def mark_previous(self, index):
"""Return the name of the previous mark before INDEX."""
return self.tk.call(self._w, 'mark', 'previous', index) or None
def scan_mark(self, x, y):
"""Remember the current X, Y coordinates."""
self.tk.call(self._w, 'scan', 'mark', x, y)
def scan_dragto(self, x, y):
"""Adjust the view of the text to 10 times the
difference between X and Y and the coordinates given in
scan_mark."""
self.tk.call(self._w, 'scan', 'dragto', x, y)
def search(self, pattern, index, stopindex=None,
forwards=None, backwards=None, exact=None,
regexp=None, nocase=None, count=None, elide=None):
"""Search PATTERN beginning from INDEX until STOPINDEX.
Return the index of the first character of a match or an
empty string."""
args = [self._w, 'search']
if forwards: args.append('-forwards')
if backwards: args.append('-backwards')
if exact: args.append('-exact')
if regexp: args.append('-regexp')
if nocase: args.append('-nocase')
if elide: args.append('-elide')
if count: args.append('-count'); args.append(count)
if pattern and pattern[0] == '-': args.append('--')
args.append(pattern)
args.append(index)
if stopindex: args.append(stopindex)
return str(self.tk.call(tuple(args)))
def see(self, index):
"""Scroll such that the character at INDEX is visible."""
self.tk.call(self._w, 'see', index)
def tag_add(self, tagName, index1, *args):
"""Add tag TAGNAME to all characters between INDEX1 and index2 in ARGS.
Additional pairs of indices may follow in ARGS."""
self.tk.call(
(self._w, 'tag', 'add', tagName, index1) + args)
def tag_unbind(self, tagName, sequence, funcid=None):
"""Unbind for all characters with TAGNAME for event SEQUENCE the
function identified with FUNCID."""
self.tk.call(self._w, 'tag', 'bind', tagName, sequence, '')
if funcid:
self.deletecommand(funcid)
def tag_bind(self, tagName, sequence, func, add=None):
"""Bind to all characters with TAGNAME at event SEQUENCE a call to function FUNC.
An additional boolean parameter ADD specifies whether FUNC will be
called additionally to the other bound function or whether it will
replace the previous function. See bind for the return value."""
return self._bind((self._w, 'tag', 'bind', tagName),
sequence, func, add)
def tag_cget(self, tagName, option):
"""Return the value of OPTION for tag TAGNAME."""
if option[:1] != '-':
option = '-' + option
if option[-1:] == '_':
option = option[:-1]
return self.tk.call(self._w, 'tag', 'cget', tagName, option)
def tag_configure(self, tagName, cnf=None, **kw):
"""Configure a tag TAGNAME."""
return self._configure(('tag', 'configure', tagName), cnf, kw)
tag_config = tag_configure
def tag_delete(self, *tagNames):
"""Delete all tags in TAGNAMES."""
self.tk.call((self._w, 'tag', 'delete') + tagNames)
def tag_lower(self, tagName, belowThis=None):
"""Change the priority of tag TAGNAME such that it is lower
than the priority of BELOWTHIS."""
self.tk.call(self._w, 'tag', 'lower', tagName, belowThis)
def tag_names(self, index=None):
"""Return a list of all tag names."""
return self.tk.splitlist(
self.tk.call(self._w, 'tag', 'names', index))
def tag_nextrange(self, tagName, index1, index2=None):
"""Return a list of start and end index for the first sequence of
characters between INDEX1 and INDEX2 which all have tag TAGNAME.
The text is searched forward from INDEX1."""
return self.tk.splitlist(self.tk.call(
self._w, 'tag', 'nextrange', tagName, index1, index2))
def tag_prevrange(self, tagName, index1, index2=None):
"""Return a list of start and end index for the first sequence of
characters between INDEX1 and INDEX2 which all have tag TAGNAME.
The text is searched backwards from INDEX1."""
return self.tk.splitlist(self.tk.call(
self._w, 'tag', 'prevrange', tagName, index1, index2))
def tag_raise(self, tagName, aboveThis=None):
"""Change the priority of tag TAGNAME such that it is higher
than the priority of ABOVETHIS."""
self.tk.call(
self._w, 'tag', 'raise', tagName, aboveThis)
def tag_ranges(self, tagName):
"""Return a list of ranges of text which have tag TAGNAME."""
return self.tk.splitlist(self.tk.call(
self._w, 'tag', 'ranges', tagName))
def tag_remove(self, tagName, index1, index2=None):
"""Remove tag TAGNAME from all characters between INDEX1 and INDEX2."""
self.tk.call(
self._w, 'tag', 'remove', tagName, index1, index2)
def window_cget(self, index, option):
"""Return the value of OPTION of an embedded window at INDEX."""
if option[:1] != '-':
option = '-' + option
if option[-1:] == '_':
option = option[:-1]
return self.tk.call(self._w, 'window', 'cget', index, option)
def window_configure(self, index, cnf=None, **kw):
"""Configure an embedded window at INDEX."""
return self._configure(('window', 'configure', index), cnf, kw)
window_config = window_configure
def window_create(self, index, cnf={}, **kw):
"""Create a window at INDEX."""
self.tk.call(
(self._w, 'window', 'create', index)
+ self._options(cnf, kw))
def window_names(self):
"""Return all names of embedded windows in this widget."""
return self.tk.splitlist(
self.tk.call(self._w, 'window', 'names'))
def yview_pickplace(self, *what):
"""Obsolete function, use see."""
self.tk.call((self._w, 'yview', '-pickplace') + what)
class _setit:
"""Internal class. It wraps the command in the widget OptionMenu."""
def __init__(self, var, value, callback=None):
self.__value = value
self.__var = var
self.__callback = callback
def __call__(self, *args):
self.__var.set(self.__value)
if self.__callback:
self.__callback(self.__value, *args)
class OptionMenu(Menubutton):
"""OptionMenu which allows the user to select a value from a menu."""
def __init__(self, master, variable, value, *values, **kwargs):
"""Construct an optionmenu widget with the parent MASTER, with
the resource textvariable set to VARIABLE, the initially selected
value VALUE, the other menu values VALUES and an additional
keyword argument command."""
kw = {"borderwidth": 2, "textvariable": variable,
"indicatoron": 1, "relief": RAISED, "anchor": "c",
"highlightthickness": 2}
Widget.__init__(self, master, "menubutton", kw)
self.widgetName = 'tk_optionMenu'
menu = self.__menu = Menu(self, name="menu", tearoff=0)
self.menuname = menu._w
# 'command' is the only supported keyword
callback = kwargs.get('command')
if 'command' in kwargs:
del kwargs['command']
if kwargs:
raise TclError, 'unknown option -'+kwargs.keys()[0]
menu.add_command(label=value,
command=_setit(variable, value, callback))
for v in values:
menu.add_command(label=v,
command=_setit(variable, v, callback))
self["menu"] = menu
def __getitem__(self, name):
if name == 'menu':
return self.__menu
return Widget.__getitem__(self, name)
def destroy(self):
"""Destroy this widget and the associated menu."""
Menubutton.destroy(self)
self.__menu = None
class Image:
"""Base class for images."""
_last_id = 0
def __init__(self, imgtype, name=None, cnf={}, master=None, **kw):
self.name = None
if not master:
master = _default_root
if not master:
raise RuntimeError, 'Too early to create image'
self.tk = getattr(master, 'tk', master)
if not name:
Image._last_id += 1
name = "pyimage%r" % (Image._last_id,) # tk itself would use image<x>
# The following is needed for systems where id(x)
# can return a negative number, such as Linux/m68k:
if name[0] == '-': name = '_' + name[1:]
if kw and cnf: cnf = _cnfmerge((cnf, kw))
elif kw: cnf = kw
options = ()
for k, v in cnf.items():
if hasattr(v, '__call__'):
v = self._register(v)
elif k in ('data', 'maskdata'):
v = self.tk._createbytearray(v)
options = options + ('-'+k, v)
self.tk.call(('image', 'create', imgtype, name,) + options)
self.name = name
def __str__(self): return self.name
def __del__(self):
if self.name:
try:
self.tk.call('image', 'delete', self.name)
except TclError:
# May happen if the root was destroyed
pass
def __setitem__(self, key, value):
self.tk.call(self.name, 'configure', '-'+key, value)
def __getitem__(self, key):
return self.tk.call(self.name, 'configure', '-'+key)
def configure(self, **kw):
"""Configure the image."""
res = ()
for k, v in _cnfmerge(kw).items():
if v is not None:
if k[-1] == '_': k = k[:-1]
if hasattr(v, '__call__'):
v = self._register(v)
elif k in ('data', 'maskdata'):
v = self.tk._createbytearray(v)
res = res + ('-'+k, v)
self.tk.call((self.name, 'config') + res)
config = configure
def height(self):
"""Return the height of the image."""
return getint(
self.tk.call('image', 'height', self.name))
def type(self):
"""Return the type of the image, e.g. "photo" or "bitmap"."""
return self.tk.call('image', 'type', self.name)
def width(self):
"""Return the width of the image."""
return getint(
self.tk.call('image', 'width', self.name))
class PhotoImage(Image):
"""Widget which can display images in PGM, PPM, GIF, PNG format."""
def __init__(self, name=None, cnf={}, master=None, **kw):
"""Create an image with NAME.
Valid resource names: data, format, file, gamma, height, palette,
width."""
Image.__init__(self, 'photo', name, cnf, master, **kw)
def blank(self):
"""Display a transparent image."""
self.tk.call(self.name, 'blank')
def cget(self, option):
"""Return the value of OPTION."""
return self.tk.call(self.name, 'cget', '-' + option)
# XXX config
def __getitem__(self, key):
return self.tk.call(self.name, 'cget', '-' + key)
# XXX copy -from, -to, ...?
def copy(self):
"""Return a new PhotoImage with the same image as this widget."""
destImage = PhotoImage(master=self.tk)
self.tk.call(destImage, 'copy', self.name)
return destImage
def zoom(self, x, y=''):
"""Return a new PhotoImage with the same image as this widget
but zoom it with a factor of x in the X direction and y in the Y
direction. If y is not given, the default value is the same as x.
"""
destImage = PhotoImage(master=self.tk)
if y=='': y=x
self.tk.call(destImage, 'copy', self.name, '-zoom',x,y)
return destImage
def subsample(self, x, y=''):
"""Return a new PhotoImage based on the same image as this widget
but use only every Xth or Yth pixel. If y is not given, the
default value is the same as x.
"""
destImage = PhotoImage(master=self.tk)
if y=='': y=x
self.tk.call(destImage, 'copy', self.name, '-subsample',x,y)
return destImage
def get(self, x, y):
"""Return the color (red, green, blue) of the pixel at X,Y."""
return self.tk.call(self.name, 'get', x, y)
def put(self, data, to=None):
"""Put row formatted colors to image starting from
position TO, e.g. image.put("{red green} {blue yellow}", to=(4,6))"""
args = (self.name, 'put', data)
if to:
if to[0] == '-to':
to = to[1:]
args = args + ('-to',) + tuple(to)
self.tk.call(args)
# XXX read
def write(self, filename, format=None, from_coords=None):
"""Write image to file FILENAME in FORMAT starting from
position FROM_COORDS."""
args = (self.name, 'write', filename)
if format:
args = args + ('-format', format)
if from_coords:
args = args + ('-from',) + tuple(from_coords)
self.tk.call(args)
class BitmapImage(Image):
"""Widget which can display images in XBM format."""
def __init__(self, name=None, cnf={}, master=None, **kw):
"""Create a bitmap with NAME.
Valid resource names: background, data, file, foreground, maskdata, maskfile."""
Image.__init__(self, 'bitmap', name, cnf, master, **kw)
def image_names():
return _default_root.tk.splitlist(_default_root.tk.call('image', 'names'))
def image_types():
return _default_root.tk.splitlist(_default_root.tk.call('image', 'types'))
class Spinbox(Widget, XView):
"""spinbox widget."""
def __init__(self, master=None, cnf={}, **kw):
"""Construct a spinbox widget with the parent MASTER.
STANDARD OPTIONS
activebackground, background, borderwidth,
cursor, exportselection, font, foreground,
highlightbackground, highlightcolor,
highlightthickness, insertbackground,
insertborderwidth, insertofftime,
insertontime, insertwidth, justify, relief,
repeatdelay, repeatinterval,
selectbackground, selectborderwidth
selectforeground, takefocus, textvariable
xscrollcommand.
WIDGET-SPECIFIC OPTIONS
buttonbackground, buttoncursor,
buttondownrelief, buttonuprelief,
command, disabledbackground,
disabledforeground, format, from,
invalidcommand, increment,
readonlybackground, state, to,
validate, validatecommand values,
width, wrap,
"""
Widget.__init__(self, master, 'spinbox', cnf, kw)
def bbox(self, index):
"""Return a tuple of X1,Y1,X2,Y2 coordinates for a
rectangle which encloses the character given by index.
The first two elements of the list give the x and y
coordinates of the upper-left corner of the screen
area covered by the character (in pixels relative
to the widget) and the last two elements give the
width and height of the character, in pixels. The
bounding box may refer to a region outside the
visible area of the window.
"""
return self._getints(self.tk.call(self._w, 'bbox', index)) or None
def delete(self, first, last=None):
"""Delete one or more elements of the spinbox.
First is the index of the first character to delete,
and last is the index of the character just after
the last one to delete. If last isn't specified it
defaults to first+1, i.e. a single character is
deleted. This command returns an empty string.
"""
return self.tk.call(self._w, 'delete', first, last)
def get(self):
"""Returns the spinbox's string"""
return self.tk.call(self._w, 'get')
def icursor(self, index):
"""Alter the position of the insertion cursor.
The insertion cursor will be displayed just before
the character given by index. Returns an empty string
"""
return self.tk.call(self._w, 'icursor', index)
def identify(self, x, y):
"""Returns the name of the widget at position x, y
Return value is one of: none, buttondown, buttonup, entry
"""
return self.tk.call(self._w, 'identify', x, y)
def index(self, index):
"""Returns the numerical index corresponding to index
"""
return self.tk.call(self._w, 'index', index)
def insert(self, index, s):
"""Insert string s at index
Returns an empty string.
"""
return self.tk.call(self._w, 'insert', index, s)
def invoke(self, element):
"""Causes the specified element to be invoked
The element could be buttondown or buttonup
triggering the action associated with it.
"""
return self.tk.call(self._w, 'invoke', element)
def scan(self, *args):
"""Internal function."""
return self._getints(
self.tk.call((self._w, 'scan') + args)) or ()
def scan_mark(self, x):
"""Records x and the current view in the spinbox window;
used in conjunction with later scan dragto commands.
Typically this command is associated with a mouse button
press in the widget. It returns an empty string.
"""
return self.scan("mark", x)
def scan_dragto(self, x):
"""Compute the difference between the given x argument
and the x argument to the last scan mark command
It then adjusts the view left or right by 10 times the
difference in x-coordinates. This command is typically
associated with mouse motion events in the widget, to
produce the effect of dragging the spinbox at high speed
through the window. The return value is an empty string.
"""
return self.scan("dragto", x)
def selection(self, *args):
"""Internal function."""
return self._getints(
self.tk.call((self._w, 'selection') + args)) or ()
def selection_adjust(self, index):
"""Locate the end of the selection nearest to the character
given by index,
Then adjust that end of the selection to be at index
(i.e including but not going beyond index). The other
end of the selection is made the anchor point for future
select to commands. If the selection isn't currently in
the spinbox, then a new selection is created to include
the characters between index and the most recent selection
anchor point, inclusive.
"""
return self.selection("adjust", index)
def selection_clear(self):
"""Clear the selection
If the selection isn't in this widget then the
command has no effect.
"""
return self.selection("clear")
def selection_element(self, element=None):
"""Sets or gets the currently selected element.
If a spinbutton element is specified, it will be
displayed depressed.
"""
return self.tk.call(self._w, 'selection', 'element', element)
###########################################################################
class LabelFrame(Widget):
"""labelframe widget."""
def __init__(self, master=None, cnf={}, **kw):
"""Construct a labelframe widget with the parent MASTER.
STANDARD OPTIONS
borderwidth, cursor, font, foreground,
highlightbackground, highlightcolor,
highlightthickness, padx, pady, relief,
takefocus, text
WIDGET-SPECIFIC OPTIONS
background, class, colormap, container,
height, labelanchor, labelwidget,
visual, width
"""
Widget.__init__(self, master, 'labelframe', cnf, kw)
########################################################################
class PanedWindow(Widget):
"""panedwindow widget."""
def __init__(self, master=None, cnf={}, **kw):
"""Construct a panedwindow widget with the parent MASTER.
STANDARD OPTIONS
background, borderwidth, cursor, height,
orient, relief, width
WIDGET-SPECIFIC OPTIONS
handlepad, handlesize, opaqueresize,
sashcursor, sashpad, sashrelief,
sashwidth, showhandle,
"""
Widget.__init__(self, master, 'panedwindow', cnf, kw)
def add(self, child, **kw):
"""Add a child widget to the panedwindow in a new pane.
The child argument is the name of the child widget
followed by pairs of arguments that specify how to
manage the windows. The possible options and values
are the ones accepted by the paneconfigure method.
"""
self.tk.call((self._w, 'add', child) + self._options(kw))
def remove(self, child):
"""Remove the pane containing child from the panedwindow
All geometry management options for child will be forgotten.
"""
self.tk.call(self._w, 'forget', child)
forget=remove
def identify(self, x, y):
"""Identify the panedwindow component at point x, y
If the point is over a sash or a sash handle, the result
is a two element list containing the index of the sash or
handle, and a word indicating whether it is over a sash
or a handle, such as {0 sash} or {2 handle}. If the point
is over any other part of the panedwindow, the result is
an empty list.
"""
return self.tk.call(self._w, 'identify', x, y)
def proxy(self, *args):
"""Internal function."""
return self._getints(
self.tk.call((self._w, 'proxy') + args)) or ()
def proxy_coord(self):
"""Return the x and y pair of the most recent proxy location
"""
return self.proxy("coord")
def proxy_forget(self):
"""Remove the proxy from the display.
"""
return self.proxy("forget")
def proxy_place(self, x, y):
"""Place the proxy at the given x and y coordinates.
"""
return self.proxy("place", x, y)
def sash(self, *args):
"""Internal function."""
return self._getints(
self.tk.call((self._w, 'sash') + args)) or ()
def sash_coord(self, index):
"""Return the current x and y pair for the sash given by index.
Index must be an integer between 0 and 1 less than the
number of panes in the panedwindow. The coordinates given are
those of the top left corner of the region containing the sash.
pathName sash dragto index x y This command computes the
difference between the given coordinates and the coordinates
given to the last sash coord command for the given sash. It then
moves that sash the computed difference. The return value is the
empty string.
"""
return self.sash("coord", index)
def sash_mark(self, index):
"""Records x and y for the sash given by index;
Used in conjunction with later dragto commands to move the sash.
"""
return self.sash("mark", index)
def sash_place(self, index, x, y):
"""Place the sash given by index at the given coordinates
"""
return self.sash("place", index, x, y)
def panecget(self, child, option):
"""Query a management option for window.
Option may be any value allowed by the paneconfigure subcommand
"""
return self.tk.call(
(self._w, 'panecget') + (child, '-'+option))
def paneconfigure(self, tagOrId, cnf=None, **kw):
"""Query or modify the management options for window.
If no option is specified, returns a list describing all
of the available options for pathName. If option is
specified with no value, then the command returns a list
describing the one named option (this list will be identical
to the corresponding sublist of the value returned if no
option is specified). If one or more option-value pairs are
specified, then the command modifies the given widget
option(s) to have the given value(s); in this case the
command returns an empty string. The following options
are supported:
after window
Insert the window after the window specified. window
should be the name of a window already managed by pathName.
before window
Insert the window before the window specified. window
should be the name of a window already managed by pathName.
height size
Specify a height for the window. The height will be the
outer dimension of the window including its border, if
any. If size is an empty string, or if -height is not
specified, then the height requested internally by the
window will be used initially; the height may later be
adjusted by the movement of sashes in the panedwindow.
Size may be any value accepted by Tk_GetPixels.
minsize n
Specifies that the size of the window cannot be made
less than n. This constraint only affects the size of
the widget in the paned dimension -- the x dimension
for horizontal panedwindows, the y dimension for
vertical panedwindows. May be any value accepted by
Tk_GetPixels.
padx n
Specifies a non-negative value indicating how much
extra space to leave on each side of the window in
the X-direction. The value may have any of the forms
accepted by Tk_GetPixels.
pady n
Specifies a non-negative value indicating how much
extra space to leave on each side of the window in
the Y-direction. The value may have any of the forms
accepted by Tk_GetPixels.
sticky style
If a window's pane is larger than the requested
dimensions of the window, this option may be used
to position (or stretch) the window within its pane.
Style is a string that contains zero or more of the
characters n, s, e or w. The string can optionally
contains spaces or commas, but they are ignored. Each
letter refers to a side (north, south, east, or west)
that the window will "stick" to. If both n and s
(or e and w) are specified, the window will be
stretched to fill the entire height (or width) of
its cavity.
width size
Specify a width for the window. The width will be
the outer dimension of the window including its
border, if any. If size is an empty string, or
if -width is not specified, then the width requested
internally by the window will be used initially; the
width may later be adjusted by the movement of sashes
in the panedwindow. Size may be any value accepted by
Tk_GetPixels.
"""
if cnf is None and not kw:
return self._getconfigure(self._w, 'paneconfigure', tagOrId)
if type(cnf) == StringType and not kw:
return self._getconfigure1(
self._w, 'paneconfigure', tagOrId, '-'+cnf)
self.tk.call((self._w, 'paneconfigure', tagOrId) +
self._options(cnf, kw))
paneconfig = paneconfigure
def panes(self):
"""Returns an ordered list of the child panes."""
return self.tk.splitlist(self.tk.call(self._w, 'panes'))
######################################################################
# Extensions:
class Studbutton(Button):
def __init__(self, master=None, cnf={}, **kw):
Widget.__init__(self, master, 'studbutton', cnf, kw)
self.bind('<Any-Enter>', self.tkButtonEnter)
self.bind('<Any-Leave>', self.tkButtonLeave)
self.bind('<1>', self.tkButtonDown)
self.bind('<ButtonRelease-1>', self.tkButtonUp)
class Tributton(Button):
def __init__(self, master=None, cnf={}, **kw):
Widget.__init__(self, master, 'tributton', cnf, kw)
self.bind('<Any-Enter>', self.tkButtonEnter)
self.bind('<Any-Leave>', self.tkButtonLeave)
self.bind('<1>', self.tkButtonDown)
self.bind('<ButtonRelease-1>', self.tkButtonUp)
self['fg'] = self['bg']
self['activebackground'] = self['bg']
######################################################################
# Test:
def _test():
root = Tk()
text = "This is Tcl/Tk version %s" % TclVersion
if TclVersion >= 8.1:
try:
text = text + unicode("\nThis should be a cedilla: \347",
"iso-8859-1")
except NameError:
pass # no unicode support
label = Label(root, text=text)
label.pack()
test = Button(root, text="Click me!",
command=lambda root=root: root.test.configure(
text="[%s]" % root.test['text']))
test.pack()
root.test = test
quit = Button(root, text="QUIT", command=root.destroy)
quit.pack()
# The following three commands are needed so the window pops
# up on top on Windows...
root.iconify()
root.update()
root.deiconify()
root.mainloop()
if __name__ == '__main__':
_test()
Canvas.pyo 0000644 00000036314 15032720555 0006523 0 ustar 00 �
z fc @ s/ d d l m Z e d d d �[ d d l m Z m Z m Z d d d � � YZ d e f d � � YZ d
e f d � � YZ d e f d
� � YZ d e f d � � YZ
d e f d � � YZ d e f d � � YZ d e f d � � YZ
d e f d � � YZ d e f d � � YZ d d d � � YZ d S( i����( t warnpy3ks0 the Canvas module has been removed in Python 3.0t
stackleveli ( t Canvast _cnfmerget _flattent
CanvasItemc B s% e Z d � Z d � Z d � Z d � Z d � Z e Z d � Z d � Z d � Z
d � Z d d
� Z d � Z
d d d d � Z d d
� Z i d � Z d d � Z d d � Z d � Z d � Z d � Z d � Z d � Z d � Z d d � Z d � Z d d � Z e Z d � Z d � Z RS( c O sP | | _ | j | | | � | _ t | d � s< i | _ n | | j | j <d S( Nt items( t canvast _createt idt hasattrR ( t selfR t itemTypet argst kw( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt __init__ s
c C s
t | j � S( N( t strR ( R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt __str__ s c C s d | j j | j f S( Ns <%s, id=%d>( t __class__t __name__R ( R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt __repr__ s c C s' | j j | j =| j j | j � d S( N( R R R t delete( R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR s c C sB | j j j | j j j | j j d | j d | � � } | d S( Nt
itemconfiguret -i ( R t tkt splitt callt _wR ( R t keyt v( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt __getitem__ s c C s! | j j | j i | | 6� d S( N( R t
itemconfigR ( R R t value( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt __setitem__! s c C s[ t | d � sT t | j j d � | j j j | j j d | j f � � � | _ n | j S( Nt _keysc S s | j | � d d S( Ni i ( t splitlist( t xR ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt <lambda>% s R ( R
t mapR R R# t _doR R" ( R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt keys# s c C s | | j � k S( N( R( ( R R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt has_key, s c C s | | j � k S( N( R( ( R R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt __contains__. s t withtagc C s | j j | | | j � d S( N( R t addtagR ( R t tagt option( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR, 0 s c C s7 | j j | j � \ } } } } | | f | | f f S( N( R t bboxR ( R t x1t y1t x2t y2( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR/ 2 s !c C s | j j | j | | | � S( N( R t tag_bindR ( R t sequencet commandt add( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt bind5 s c C s | j j | j | | � d S( N( R t
tag_unbindR ( R R5 t funcid( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt unbind7 s c K s" | j j | j t | | f � � S( N( R R R R ( R t cnfR ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt config9 s c C sC d } x$ | D] \ } } | | | f } q
W| j j | j | � S( N( ( R t coordsR ( R t ptst flatR$ t y( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR> ; s c C s | j j | j | | � d S( N( R t dcharsR ( R t firstt last( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRB ? s c C s | j j | j | � d S( N( R t dtagR ( R t ttd( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRE A s c C s | j j | j � d S( N( R t focusR ( R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRG C s c C s | j j | j � S( N( R t gettagsR ( R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRH E s c C s | j j | j | � d S( N( R t icursorR ( R t index( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRI G s c C s | j j | j | � S( N( R RJ R ( R RJ ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRJ I s c C s | j j | j | | � d S( N( R t insertR ( R t
beforethist string( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRK K s c C s | j j | j | � d S( N( R t tag_lowerR ( R t belowthis( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt lowerM s c C s | j j | j | | � d S( N( R t moveR ( R t xamountt yamount( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRQ O s c C s | j j | j | � d S( N( R t tag_raiseR ( R t abovethis( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt tkraiseQ s c C s# | j j | j | | | | � d S( N( R t scaleR ( R t xorigint yorigint xscalet yscale( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRW T s c C s | j j | j � S( N( R t typeR ( R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR\ V s N( ( R t
__module__R R R R R t cgetR! R( R) R* R, R/ t NoneR8 R; R= R> RB RE RG RH RI RJ RK RP RQ RV t raise_RW R\ ( ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR
s: t Arcc B s e Z d � Z RS( c O s t j | | d | | � d S( Nt arc( R R ( R R R
R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR Z s ( R R] R ( ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRa Y s t Bitmapc B s e Z d � Z RS( c O s t j | | d | | � d S( Nt bitmap( R R ( R R R
R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR ^ s ( R R] R ( ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRc ] s t ImageItemc B s e Z d � Z RS( c O s t j | | d | | � d S( Nt image( R R ( R R R
R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR b s ( R R] R ( ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRe a s t Linec B s e Z d � Z RS( c O s t j | | d | | � d S( Nt line( R R ( R R R
R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR f s ( R R] R ( ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRg e s t Ovalc B s e Z d � Z RS( c O s t j | | d | | � d S( Nt oval( R R ( R R R
R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR j s ( R R] R ( ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRi i s t Polygonc B s e Z d � Z RS( c O s t j | | d | | � d S( Nt polygon( R R ( R R R
R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR n s ( R R] R ( ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRk m s t Rectanglec B s e Z d � Z RS( c O s t j | | d | | � d S( Nt rectangle( R R ( R R R
R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR r s ( R R] R ( ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRm q s t
CanvasTextc B s e Z d � Z RS( c O s t j | | d | | � d S( Nt text( R R ( R R R
R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR w s ( R R] R ( ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRo v s t Windowc B s e Z d � Z RS( c O s t j | | d | | � d S( Nt window( R R ( R R R
R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR { s ( R R] R ( ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRq z s t Groupc B sO e Z d d � Z d � Z e Z d � Z d � Z d � Z d � Z d d d � Z
d � Z d � Z d � Z
d
� Z d d d d � Z d d � Z d
� Z d d � Z d � Z d d � Z d � Z d � Z d � Z d � Z d � Z i d � Z d d � Z d � Z d d � Z e Z d � Z d � Z d � Z! d � Z" d � Z# RS( c C sI | s d t | � } n | | _ | _ | | _ | j j | j � d S( Ns Group%d( R R- R RE ( R R R- ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR s
c C s | j S( N( R- ( R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR � s c G s# | j j | | j f t | � � S( N( R R' R- R ( R t cmdR
( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR' � s c C s | j d d | � d S( NR, t above( R' ( R t tagOrId( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt addtag_above� s c C s | j d d � d S( NR, t all( R' ( R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt
addtag_all� s c C s | j d d | � d S( NR, t below( R' ( R Rv ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt addtag_below� s c C s | j d d | | | | � d S( NR, t closest( R' ( R R$ RA t halot start( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt addtag_closest� s c C s | j d d | | | | � d S( NR, t enclosed( R' ( R R0 R1 R2 R3 ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt addtag_enclosed� s c C s | j d d | | | | � d S( NR, t overlapping( R' ( R R0 R1 R2 R3 ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt addtag_overlapping� s c C s | j d d | � d S( NR, R+ ( R' ( R Rv ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt addtag_withtag� s c C s | j j | j d � � S( NR/ ( R t _getintsR' ( R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR/ � s c C s | j j | j | | | � S( N( R R4 R ( R R5 R6 R7 ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR8 � s c C s | j j | j | | � d S( N( R R9 R ( R R5 R: ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR; � s c G s | j d | � S( NR> ( R' ( R R? ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR> � s c C s | j d | | � d S( NRB ( R' ( R RC RD ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRB � s c C s | j d � d S( NR ( R' ( R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR � s c C s | j d | � d S( NRE ( R' ( R t tagToDelete( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRE � s c C s | j d � d S( NRG ( R' ( R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRG � s c C s" | j j j | j d | j � � S( NRH ( R R R# R' R- ( R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRH � s c C s | j d | � S( NRI ( R' ( R RJ ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRI � s c C s | j j j | j d | � � S( NRJ ( R R t getintR' ( R RJ ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRJ � s c C s | j d | | � d S( NRK ( R' ( R t
beforeThisRM ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRK � s c K s" | j j | j t | | f � � S( N( R R R- R ( R R< R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR= � s c C s | j d | � d S( NRP ( R' ( R t belowThis( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRP � s c C s | j d | | � d S( NRQ ( R' ( R t xAmountt yAmount( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRQ � s c C s | j d | � d S( Nt raise( R' ( R t aboveThis( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRV � s c C s | j d | | | | � d S( NRW ( R' ( R t xOrigint yOrigint xScalet yScale( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRW � s c C s# | j j d d | j | f � d S( Nt selectt adjust( R R' R- ( R RJ ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt
select_adjust� s c C s# | j j d d | j | f � d S( NR� t from( R R' R- ( R RJ ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt select_from� s c C s# | j j d d | j | f � d S( NR� t to( R R' R- ( R RJ ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt select_to� s c C s
| j d � S( NR\ ( R' ( R ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyR\ � s N($ R R] R_ R R R R' Rw Ry R{ R R� R� R� R/ R8 R; R> RB R RE RG RH RI RJ RK R= RP RQ RV t liftRW R� R� R� R\ ( ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyRs ~ sB N( ( ( t warningsR t TkinterR R R R Ra Rc Re Rg Ri Rk Rm Ro Rq Rs ( ( ( s% /usr/lib64/python2.7/lib-tk/Canvas.pyt <module> s L FixTk.pyo 0000644 00000003756 15032720555 0006341 0 ustar 00 �
z fc @ sb d d l Z d d l Z y d d l Z e j j j Wn e e f k
rW d � Z n
Xd � Z e j j
e j d � Z e j j e � s� d Z
e j d k r� d Z
n e j j
e j d
e
d � Z e j j e � Z n e j j e � r^e e � Z d e j k roxc e j e � D]O Z e j d � re j j
e e � Z e j j e � rhe e j d <qhqqWn d d l Z e e j � Z d
e j k r�e j j
e d e � Z e j j e j j
e d � � r�e e j d
<q�n d e j k r^xc e j e � D]O Z e j d � re j j
e e � Z e j j e � rTe e j d <qTqqWq^n d S( i����Nc C s | S( N( ( t s( ( s$ /usr/lib64/python2.7/lib-tk/FixTk.pyt convert_path s c C s� | j d � } t j j j | d d d d d d � } | d k rF | St j d d � } t j j j | | t | � d � } t j j j | � | d k r� | S| | j
d � } | j d
� r� | d } n | j d � r� d
| d } n | S( Nt mbcsi� i i i i����u i � i s \\?\i t UNCs \( t decodet ctypest windllt kernel32t CreateFileWt Nonet create_unicode_buffert GetFinalPathNameByHandleWt lent CloseHandlet encodet
startswith( R t udirt hdirt buft res( ( s$ /usr/lib64/python2.7/lib-tk/FixTk.pyR s,
t tclt tcltki i i t tcltk64t externalst libt TCL_LIBRARYt
TK_LIBRARYt tkt tclIndext TIX_LIBRARYt tixI � i���( t syst osR R R R t ImportErrort AttributeErrorR t patht joint prefixt existsR t maxsizet abspatht environt listdirt nameR t tcldirt isdirt _tkintert strt TCL_VERSIONt vert vt tixdir( ( ( s$ /usr/lib64/python2.7/lib-tk/FixTk.pyt <module> sB
! FileDialog.pyc 0000644 00000022766 15032720555 0007301 0 ustar 00 �
z fc @ s� d Z d d l Td d l m Z d d l Z d d l Z i Z d d
d � � YZ d e f d � � YZ d e f d
� � YZ d � Z e
d k r� e � n d S( sZ File selection dialog classes.
Classes:
- FileDialog
- LoadFileDialog
- SaveFileDialog
i����( t *( t DialogNt
FileDialogc B s� e Z d Z d Z d d � Z e j d d d d � Z d d � Z d � Z
d � Z d � Z d
� Z
d � Z d � Z d d
� Z d � Z d � Z d d � Z d � Z d � Z RS( s� Standard file selection dialog -- no checks on selected file.
Usage:
d = FileDialog(master)
fname = d.go(dir_or_file, pattern, default, key)
if fname is None: ...canceled...
else: ...open file...
All arguments to go() are optional.
The 'key' argument specifies a key in the global dictionary
'dialogstates', which keeps track of the values for the directory
and pattern arguments, overriding the values passed in (it does
not keep track of the default argument!). If no key is specified,
the dialog keeps no memory of previous state. Note that memory is
kept even when the dialog is canceled. (All this emulates the
behavior of the Macintosh file selection dialogs.)
s File Selection Dialogc C s� | d k r | j } n | | _ d | _ t | � | _ | j j | � | j j | � t | j � | _ | j j d t
d t � t | j � | _
| j
j d t
d t � | j
j d | j � t | j � | _ | j j d t d t � | j j d | j � t | j � | _ | j j d t d t � t | j � | _ | j j d t d t � t | j d d d | j d f �| _ | j j d t d t d t � | j j � } | j j | d | d � | j j d
| j � | j j d | j � | j j d | j d
f � t | j � | _ | j j d t! d t � t | j d d d | j d f �| _" | j" j d t! d t d t � | j j d | j" d
f � | j" j � } | j" j | d | d � | j" j d
| j# � | j" j d | j$ � t% | j d d d | j& �| _' | j' j d t! � t% | j d d d | j �| _( | j( j d t! d t � t% | j d d d | j) �| _* | j* j d t � | j j+ d | j) � | j j d | j) � | j j d | j) � d S( Nt sidet fills <Return>t expandt exportselectioni t yscrollcommandt seti s <ButtonRelease-1>s <Double-ButtonRelease-1>t commandt yviewt textt OKt Filtert Cancelt WM_DELETE_WINDOWs <Alt-w>s <Alt-W>(, t Nonet titlet mastert directoryt Toplevelt topt iconnamet Framet botframet packt BOTTOMt Xt Entryt selectiont bindt ok_eventt filtert TOPt filter_commandt midframet YESt BOTHt Scrollbart filesbart RIGHTt Yt Listboxt filest bindtagst files_select_eventt files_double_eventt configt dirsbart LEFTt dirst dirs_select_eventt dirs_double_eventt Buttont
ok_commandt ok_buttont
filter_buttont cancel_commandt
cancel_buttont protocol( t selfR R t btags( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyt __init__. sh R t c C s: | r( | t k r( t | \ | _ } nK t j j | � } t j j | � rX | | _ n t j j | � \ | _ } | j | j | � | j | � | j � | j
j � | j j
� | j j � d | _ | j j � | r&| j � \ } } | j rt j j | j � } n | | f t | <n | j j � | j S( N( t dialogstatesR t ost patht
expandusert isdirt splitt
set_filtert
set_selectionR" R t focus_setR t wait_visibilityt grab_setR t howR t mainloopt
get_filtert dirnamet destroy( R< t dir_or_filet patternt defaultt keyR ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyt gom s*
c C s | | _ | j j � d S( N( RK R t quit( R< RK ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyRU � s c C s | j � d S( N( R" ( R< t event( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyR4 � s c C s\ | j � \ } } | j j d � } t j j t j j | j | � � } | j | | � d S( Nt active( RM R2 t getRA RB t normpatht joinR RF ( R< RV t dirt patt subdir( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyR3 � s $c C s | j � d S( N( R6 ( R< RV ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyR. � s c C s# | j j d � } | j | � d S( NRW ( R+ RX RG ( R< RV t file( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyR- � s c C s | j � d S( N( R6 ( R< RV ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyR � s c C s | j | j � � d S( N( RU t
get_selection( R< ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyR6 � s c C s� | j � \ } } y t j | � } Wn" t j k
rI | j j � d SX| | _ | j | | � | j � t j g } g } xg | D]_ } t j
j | | � } t j
j | � r� | j
| � q� t j | | � r� | j
| � q� q� W| j j d t � x! | D] } | j j t | � qW| j j d t � x! | D] } | j j t | � q:Wt j
j | j � � \ } }
|
t j k r�d }
n | j |
� d S( Ni R? ( RM RA t listdirt errorR t bellR RF t sortt pardirRB RZ RD t appendt fnmatchR2 t deletet ENDt insertR+ RE R_ t curdirRG ( R< RV R[ R\ t namest subdirst
matchingfilest namet fullnamet headt tail( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyR" � s6
c C sn | j j � } t j j | � } | d t j k sF t j j | � r^ t j j | d � } n t j j | � S( Ni����R ( R RX RA RB RC t sepRD RZ RE ( R< R ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyRM � s
%c C s% | j j � } t j j | � } | S( N( R RX RA RB RC ( R< R^ ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyR_ � s c C s | j � d S( N( RU ( R< RV ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyR9 � s c C s� t j j | � sr y t j � } Wn t j k
r> d } n X| rr t j j | | � } t j j | � } qr n | j j d t
� | j j t
t j j | p� t j | p� d � � d S( Ni R (
RA RB t isabst getcwdRa R RZ RY R Rg Rh Ri Rj ( R< R[ R\ t pwd( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyRF � s
c C s< | j j d t � | j j t t j j | j | � � d S( Ni ( R Rg Rh Ri RA RB RZ R ( R< R^ ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyRG � s N( t __name__t
__module__t __doc__R R R> RA Rj RT RU R4 R3 R. R- R R6 R" RM R_ R9 RF RG ( ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyR s" ? t LoadFileDialogc B s e Z d Z d Z d � Z RS( s8 File selection dialog which checks that the file exists.s Load File Selection Dialogc C s? | j � } t j j | � s. | j j � n
| j | � d S( N( R_ RA RB t isfileR Rb RU ( R< R^ ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyR6 � s ( Rv Rw Rx R R6 ( ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyRy � s t SaveFileDialogc B s e Z d Z d Z d � Z RS( s@ File selection dialog which checks that the file may be created.s Save File Selection Dialogc
C s� | j � } t j j | � r� t j j | � rA | j j � d St | j d d d d | f d d d d d d
�} | j d k r� d Sn; t j j
| � \ } } t j j | � s� | j j � d S| j | � d S( NR s Overwrite Existing File QuestionR s Overwrite existing file %r?t bitmapt questheadRR i t stringst YesR i ( R R ( R_ RA RB t existsRD R Rb R R t numRE RU ( R< R^ t dRp Rq ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyR6 � s$
( Rv Rw Rx R R6 ( ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyR{ � s c C s\ t � } | j � t | � } | j d d � } t | � } | j d d � } | G| GHd S( s Simple test program.RS t testN( t Tkt withdrawRy RT R{ ( t roott fdt loadfilet savefile( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyR� s
t __main__( ( Rx t TkinterR RA Rf R@ R Ry R{ R� Rv ( ( ( s) /usr/lib64/python2.7/lib-tk/FileDialog.pyt <module> s
� tkColorChooser.py 0000644 00000003370 15032720555 0010065 0 ustar 00 # tk common color chooser dialogue
#
# this module provides an interface to the native color dialogue
# available in Tk 4.2 and newer.
#
# written by Fredrik Lundh, May 1997
#
# fixed initialcolor handling in August 1998
#
#
# options (all have default values):
#
# - initialcolor: color to mark as selected when dialog is displayed
# (given as an RGB triplet or a Tk color string)
#
# - parent: which window to place the dialog on top of
#
# - title: dialog title
#
from tkCommonDialog import Dialog
#
# color chooser class
class Chooser(Dialog):
"Ask for a color"
command = "tk_chooseColor"
def _fixoptions(self):
try:
# make sure initialcolor is a tk color string
color = self.options["initialcolor"]
if isinstance(color, tuple):
# assume an RGB triplet
self.options["initialcolor"] = "#%02x%02x%02x" % color
except KeyError:
pass
def _fixresult(self, widget, result):
# result can be somethings: an empty tuple, an empty string or
# a Tcl_Obj, so this somewhat weird check handles that
if not result or not str(result):
return None, None # canceled
# to simplify application code, the color chooser returns
# an RGB tuple together with the Tk color string
r, g, b = widget.winfo_rgb(result)
return (r/256, g/256, b/256), str(result)
#
# convenience stuff
def askcolor(color = None, **options):
"Ask for a color"
if color:
options = options.copy()
options["initialcolor"] = color
return Chooser(**options).show()
# --------------------------------------------------------------------
# test stuff
if __name__ == "__main__":
print "color", askcolor()
ScrolledText.pyo 0000644 00000005150 15032720555 0007716 0 ustar 00 �
z fc @ s� d Z d g Z d d l m Z m Z m Z m Z m Z m Z d d l m
Z
m Z m Z m
Z
d e f d � � YZ d � Z e d k r� e � n d S( s A ScrolledText widget feels like a text widget but also has a
vertical scroll bar on its right. (Later, options may be added to
add a horizontal bar as well, to make the bars disappear
automatically when not needed, to move them to the other side of the
window, etc.)
Configuration options are passed to the Text widget.
A Frame widget is inserted between the master and the text, to hold
the Scrollbar widget.
Most methods calls are inherited from the Text widget; Pack, Grid and
Place methods are redirected to the Frame widget however.
t ScrolledTexti����( t Framet Textt Scrollbart Packt Gridt Place( t RIGHTt LEFTt Yt BOTHc B s e Z d d � Z d � Z RS( c K sK t | � | _ t | j � | _ | j j d t d t � | j i | j j d 6� t j
| | j | � | j d t d t d t
� | j | j d <t t � j � } t t � j � t t � j � t t � j � } t | � j | � } xU | D]M } | d d k r� | d k r� | d k r� t | | t | j | � � q� q� Wd S(
Nt sidet fillt yscrollcommandt expandt commandi t _t configt configure( R t frameR t vbart packR R t updatet setR t __init__R R
t Truet yviewt varst keysR R R t
differencet setattrt getattr( t selft mastert kwt
text_methst methodst m( ( s+ /usr/lib64/python2.7/lib-tk/ScrolledText.pyR s 2
(c C s
t | j � S( N( t strR ( R ( ( s+ /usr/lib64/python2.7/lib-tk/ScrolledText.pyt __str__( s N( t __name__t
__module__t NoneR R' ( ( ( s+ /usr/lib64/python2.7/lib-tk/ScrolledText.pyR s c C sx d d l } d d l m } t d d d d � } | j | | j � | j d t d t d t � | j
� | j � d S(
Ni����( t ENDt bgt whitet heighti
R R R ( t __main__t TkconstantsR+ R t insertt __doc__R R
R R t focus_sett mainloop( R/ R+ t stext( ( s+ /usr/lib64/python2.7/lib-tk/ScrolledText.pyt example, s
R/ N( R2 t __all__t TkinterR R R R R R R0 R R R R
R R6 R( ( ( ( s+ /usr/lib64/python2.7/lib-tk/ScrolledText.pyt <module> s ."
SimpleDialog.pyo 0000644 00000010363 15032720555 0007655 0 ustar 00 �
z fc @ sF d Z d d l Td d d � � YZ e d k rB d � Z e � n d S( s' A simple but flexible modal dialog box.i����( t *t SimpleDialogc B sV e Z d g d d d d d � Z d d d � Z d � Z d � Z d � Z d � Z RS(
t c C s� | r t | d | �| _ n t | � | _ | rV | j j | � | j j | � n t | j d | d d �| _ | j j d d d t � t | j � | _ | j j � | | _
| | _ | | _ | j j
d | j � x� t t | � � D]u } | | } t | j d | d | | d
� �}
| | k rI|
j d t d d
� n |
j d t d t d d � q� W| j j d | j � | j | � d S( Nt class_t textt aspecti� t expandi t fills <Return>t commandc S s
| j | � S( N( t done( t selft num( ( s+ /usr/lib64/python2.7/lib-tk/SimpleDialog.pyt <lambda> R t relieft borderwidthi t sidet WM_DELETE_WINDOW( t Toplevelt roott titlet iconnamet Messaget messaget packt BOTHt Framet frameR t cancelt defaultt bindt return_eventt ranget lent Buttont configt RIDGEt LEFTt protocolt wm_delete_windowt _set_transient( R
t masterR t buttonsR R R R R t st b( ( s+ /usr/lib64/python2.7/lib-tk/SimpleDialog.pyt __init__ s.
g �?g333333�?c
C sh | j } | j � | j | � | j � | j � ri | j � } | j � } | j � } | j � } n" | j � } | j
� } d } } | j � } | j � }
| | | | } | | |
| } | | | j � k r� | j � | } n | d k rd } n | |
| j
� k r.| j
� |
} n | d k rCd } n | j
d | | f � | j � d S( Ni s +%d+%d( R t withdrawt transientt update_idletaskst winfo_ismappedt winfo_widtht winfo_heightt winfo_rootxt winfo_rootyt winfo_screenwidtht winfo_screenheightt winfo_reqwidtht winfo_reqheightt geometryt deiconify(
R
R( t relxt relyt widgett m_widtht m_heightt m_xt m_yt w_widtht w_heightt xt y( ( s+ /usr/lib64/python2.7/lib-tk/SimpleDialog.pyR' % s4
c C s; | j j � | j j � | j j � | j j � | j S( N( R t wait_visibilityt grab_sett mainloopt destroyR ( R
( ( s+ /usr/lib64/python2.7/lib-tk/SimpleDialog.pyt goB s
c C s3 | j d k r | j j � n | j | j � d S( N( R t NoneR t bellR ( R
t event( ( s+ /usr/lib64/python2.7/lib-tk/SimpleDialog.pyR I s c C s3 | j d k r | j j � n | j | j � d S( N( R RK R RL R ( R
( ( s+ /usr/lib64/python2.7/lib-tk/SimpleDialog.pyR& O s c C s | | _ | j j � d S( N( R R t quit( R
R ( ( s+ /usr/lib64/python2.7/lib-tk/SimpleDialog.pyR U s N( t __name__t
__module__RK R, R' RJ R R& R ( ( ( s+ /usr/lib64/python2.7/lib-tk/SimpleDialog.pyR s t __main__c C sj t � } | d � } t | d d d | �} | j � t | d d d | j �} | j � | j � d S( Nc S sB t | d d d d d d g d d d d
d d �} | j � GHd S(
NR s� This is a test dialog. Would this have been an actual dialog, the buttons below would have been glowing in soft pink light.
Do you believe this?R) t Yest Not CancelR i R i R s Test Dialog( R RJ ( R t d( ( s+ /usr/lib64/python2.7/lib-tk/SimpleDialog.pyt doit^ s R t TestR t Quit( t TkR! R RN RH ( R RV t tt q( ( s+ /usr/lib64/python2.7/lib-tk/SimpleDialog.pyt test\ s
N( ( t __doc__t TkinterR RO R\ ( ( ( s+ /usr/lib64/python2.7/lib-tk/SimpleDialog.pyt <module> s
S FixTk.pyc 0000644 00000004054 15032720555 0006315 0 ustar 00 �
z fc @ sb d d l Z d d l Z y d d l Z e j j j Wn e e f k
rW d � Z n
Xd � Z e j j
e j d � Z e j j e � s� d Z
e j d k r� d Z
n e j j
e j d
e
d � Z e j j e � Z n e j j e � r^e e � Z d e j k roxc e j e � D]O Z e j d � re j j
e e � Z e j j e � rhe e j d <qhqqWn d d l Z e e j � Z d
e j k r�e j j
e d e � Z e j j e j j
e d � � r�e e j d
<q�n d e j k r^xc e j e � D]O Z e j d � re j j
e e � Z e j j e � rTe e j d <qTqqWq^n d S( i����Nc C s | S( N( ( t s( ( s$ /usr/lib64/python2.7/lib-tk/FixTk.pyt convert_path s c C s t | t � s t � | j d � } t j j j | d d d d d d � } | d k r[ | St j d d � } t j j j
| | t | � d � } t j j j | � | d k r� | S| | j
d � } | j d
� r� | d } n | j d � rd
| d } n | S( Nt mbcsi� i i i i����u i � i s \\?\i t UNCs \( t
isinstancet strt AssertionErrort decodet ctypest windllt kernel32t CreateFileWt Nonet create_unicode_buffert GetFinalPathNameByHandleWt lent CloseHandlet encodet
startswith( R t udirt hdirt buft res( ( s$ /usr/lib64/python2.7/lib-tk/FixTk.pyR s.
t tclt tcltki i i t tcltk64t externalst libt TCL_LIBRARYt
TK_LIBRARYt tkt tclIndext TIX_LIBRARYt tixI � i���( t syst osR R R
R t ImportErrort AttributeErrorR t patht joint prefixt existsR t maxsizet abspatht environt listdirt nameR t tcldirt isdirt _tkinterR t TCL_VERSIONt vert vt tixdir( ( ( s$ /usr/lib64/python2.7/lib-tk/FixTk.pyt <module> sB
! tkMessageBox.py 0000644 00000007147 15032720555 0007527 0 ustar 00 # tk common message boxes
#
# this module provides an interface to the native message boxes
# available in Tk 4.2 and newer.
#
# written by Fredrik Lundh, May 1997
#
#
# options (all have default values):
#
# - default: which button to make default (one of the reply codes)
#
# - icon: which icon to display (see below)
#
# - message: the message to display
#
# - parent: which window to place the dialog on top of
#
# - title: dialog title
#
# - type: dialog type; that is, which buttons to display (see below)
#
from tkCommonDialog import Dialog
#
# constants
# icons
ERROR = "error"
INFO = "info"
QUESTION = "question"
WARNING = "warning"
# types
ABORTRETRYIGNORE = "abortretryignore"
OK = "ok"
OKCANCEL = "okcancel"
RETRYCANCEL = "retrycancel"
YESNO = "yesno"
YESNOCANCEL = "yesnocancel"
# replies
ABORT = "abort"
RETRY = "retry"
IGNORE = "ignore"
OK = "ok"
CANCEL = "cancel"
YES = "yes"
NO = "no"
#
# message dialog class
class Message(Dialog):
"A message box"
command = "tk_messageBox"
#
# convenience stuff
# Rename _icon and _type options to allow overriding them in options
def _show(title=None, message=None, _icon=None, _type=None, **options):
if _icon and "icon" not in options: options["icon"] = _icon
if _type and "type" not in options: options["type"] = _type
if title: options["title"] = title
if message: options["message"] = message
res = Message(**options).show()
# In some Tcl installations, yes/no is converted into a boolean.
if isinstance(res, bool):
if res:
return YES
return NO
# In others we get a Tcl_Obj.
return str(res)
def showinfo(title=None, message=None, **options):
"Show an info message"
return _show(title, message, INFO, OK, **options)
def showwarning(title=None, message=None, **options):
"Show a warning message"
return _show(title, message, WARNING, OK, **options)
def showerror(title=None, message=None, **options):
"Show an error message"
return _show(title, message, ERROR, OK, **options)
def askquestion(title=None, message=None, **options):
"Ask a question"
return _show(title, message, QUESTION, YESNO, **options)
def askokcancel(title=None, message=None, **options):
"Ask if operation should proceed; return true if the answer is ok"
s = _show(title, message, QUESTION, OKCANCEL, **options)
return s == OK
def askyesno(title=None, message=None, **options):
"Ask a question; return true if the answer is yes"
s = _show(title, message, QUESTION, YESNO, **options)
return s == YES
def askyesnocancel(title=None, message=None, **options):
"Ask a question; return true if the answer is yes, None if cancelled."
s = _show(title, message, QUESTION, YESNOCANCEL, **options)
# s might be a Tcl index object, so convert it to a string
s = str(s)
if s == CANCEL:
return None
return s == YES
def askretrycancel(title=None, message=None, **options):
"Ask if operation should be retried; return true if the answer is yes"
s = _show(title, message, WARNING, RETRYCANCEL, **options)
return s == RETRY
# --------------------------------------------------------------------
# test stuff
if __name__ == "__main__":
print "info", showinfo("Spam", "Egg Information")
print "warning", showwarning("Spam", "Egg Warning")
print "error", showerror("Spam", "Egg Alert")
print "question", askquestion("Spam", "Question?")
print "proceed", askokcancel("Spam", "Proceed?")
print "yes/no", askyesno("Spam", "Got it?")
print "yes/no/cancel", askyesnocancel("Spam", "Want it?")
print "try again", askretrycancel("Spam", "Try again?")
Tkconstants.py 0000644 00000002725 15032720555 0007443 0 ustar 00 # Symbolic constants for Tk
# Booleans
NO=FALSE=OFF=0
YES=TRUE=ON=1
# -anchor and -sticky
N='n'
S='s'
W='w'
E='e'
NW='nw'
SW='sw'
NE='ne'
SE='se'
NS='ns'
EW='ew'
NSEW='nsew'
CENTER='center'
# -fill
NONE='none'
X='x'
Y='y'
BOTH='both'
# -side
LEFT='left'
TOP='top'
RIGHT='right'
BOTTOM='bottom'
# -relief
RAISED='raised'
SUNKEN='sunken'
FLAT='flat'
RIDGE='ridge'
GROOVE='groove'
SOLID = 'solid'
# -orient
HORIZONTAL='horizontal'
VERTICAL='vertical'
# -tabs
NUMERIC='numeric'
# -wrap
CHAR='char'
WORD='word'
# -align
BASELINE='baseline'
# -bordermode
INSIDE='inside'
OUTSIDE='outside'
# Special tags, marks and insert positions
SEL='sel'
SEL_FIRST='sel.first'
SEL_LAST='sel.last'
END='end'
INSERT='insert'
CURRENT='current'
ANCHOR='anchor'
ALL='all' # e.g. Canvas.delete(ALL)
# Text widget and button states
NORMAL='normal'
DISABLED='disabled'
ACTIVE='active'
# Canvas state
HIDDEN='hidden'
# Menu item types
CASCADE='cascade'
CHECKBUTTON='checkbutton'
COMMAND='command'
RADIOBUTTON='radiobutton'
SEPARATOR='separator'
# Selection modes for list boxes
SINGLE='single'
BROWSE='browse'
MULTIPLE='multiple'
EXTENDED='extended'
# Activestyle for list boxes
# NONE='none' is also valid
DOTBOX='dotbox'
UNDERLINE='underline'
# Various canvas styles
PIESLICE='pieslice'
CHORD='chord'
ARC='arc'
FIRST='first'
LAST='last'
BUTT='butt'
PROJECTING='projecting'
ROUND='round'
BEVEL='bevel'
MITER='miter'
# Arguments to xview/yview
MOVETO='moveto'
SCROLL='scroll'
UNITS='units'
PAGES='pages'
Dialog.pyo 0000644 00000003600 15032720555 0006477 0 ustar 00 �
z fc @ s� d d l Td d l m Z e d k r/ d Z n d Z d e f d � � YZ d � Z e d k r� e d i d
d 6e d 6i e
6� Z e d i d
d 6e j d 6i e
6� Z
e j � n d S( i����( t *( t _cnfmergeg������ @t warningt questheadt Dialogc B s e Z d i d � Z d � Z RS( c
K s� t | | f � } d | _ t j | | | � | j j | j j d | j | d | d | d | d | d � � | _ y t j | � Wn t
k
r� n Xd S( Nt
__dialog__t tk_dialogt titlet textt bitmapt defaultt strings( R t
widgetNamet Widgett _setupt tkt getintt callt _wt numt destroyt TclError( t selft mastert cnft kw( ( s% /usr/lib64/python2.7/lib-tk/Dialog.pyt __init__
s
c C s d S( N( ( R ( ( s% /usr/lib64/python2.7/lib-tk/Dialog.pyR t N( t __name__t
__module__t NoneR R ( ( ( s% /usr/lib64/python2.7/lib-tk/Dialog.pyR s c C s> t d i d d 6d d 6t d 6d d 6d d 6� } | j GHd S(
Ns
File ModifiedR sz File "Python.h" has been modified since the last time it was saved. Do you want to save it before exiting the application.R R i R
s Save Files Discard Changess Return to EditorR ( s Save Files Discard Changess Return to Editor( R R t DIALOG_ICONR ( t d( ( s% /usr/lib64/python2.7/lib-tk/Dialog.pyt _test s
t __main__t TestR t commandt QuitN( t TkinterR t TkVersionR R
R R! R t ButtonR t Packt tt quitt qt mainloop( ( ( s% /usr/lib64/python2.7/lib-tk/Dialog.pyt <module> s
tkSimpleDialog.pyc 0000644 00000021631 15032720555 0010200 0 ustar 00 �
z fc @ s� d Z d d l Td e f d � � YZ d e f d � � YZ d e f d � � YZ d � Z d
e f d � � YZ d � Z d
e f d � � YZ d � Z
e d k r� e � Z
e
j � e d d d d �GHe d d d d d d �GHe
d d � GHn d S( s� Dialog boxes
This module handles dialog boxes. It contains the following
public symbols:
Dialog -- a base class for dialogs
askinteger -- get an integer from the user
askfloat -- get a float from the user
askstring -- get a string from the user
i����( t *t Dialogc B s_ e Z d Z d d � Z d � Z d � Z d � Z d d � Z d d � Z d � Z
d � Z RS(
sZ Class to open dialogs.
This class is intended as a base class for custom dialogs
c C s= t j | | � | j � | j � r6 | j | � n | rL | j | � n | | _ d | _ t | � } | j
| � | _ | j d d d d � | j
� | j s� | | _ n | j d | j � | j d k r| j d | j � d | j � d f � n | j � | j j � | j � | j � | j | � d S( s� Initialize a dialog.
Arguments:
parent -- a parent window (the application window)
title -- the dialog title
t padxi t padyt WM_DELETE_WINDOWs +%d+%di2 N( t Toplevelt __init__t withdrawt winfo_viewablet transientt titlet parentt Nonet resultt Framet bodyt
initial_focust packt buttonboxt protocolt cancelt geometryt winfo_rootxt winfo_rootyt deiconifyt focus_sett wait_visibilityt grab_sett wait_window( t selfR R
R ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR % s.
c C s d | _ t j | � d S( s Destroy the windowN( R R R t destroy( R ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR X s c C s d S( s� create dialog body.
return widget that should have initial focus.
This method should be overridden, and is called
by the __init__ method.
N( ( R t master( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR ` s c
C s� t | � } t | d d d d d | j d t �} | j d t d d d
d � t | d d d d d | j �} | j d t d d d
d � | j d | j � | j d
| j � | j � d S( s[ add standard button box.
override if you do not want the standard buttons
t textt OKt widthi
t commandt defaultt sideR i R t Cancels <Return>s <Escape>N( R t Buttont okt ACTIVER t LEFTR t bind( R t boxt w( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR i s ' ! c C sQ | j � s | j j � d S| j � | j � z | j � Wd | j � Xd S( N( t validateR R R t update_idletaskst applyR ( R t event( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR( ~ s
c C s- | j d k r | j j � n | j � d S( N( R R R R ( R R1 ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR � s c C s d S( s� validate the data
This method is called automatically to validate the data before the
dialog is destroyed. By default, it always validates OK.
i ( ( R ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR. � s c C s d S( s� process the data
This method is called automatically to process the data, *after*
the dialog is destroyed. By default, it does nothing.
N( ( R ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR0 � s N( t __name__t
__module__t __doc__R R R R R R( R R. R0 ( ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR s 3
t _QueryDialogc B s8 e Z d d d d d � Z d � Z d � Z d � Z RS( c C sY | s d d l } | j } n | | _ | | _ | | _ | | _ t j | | | � d S( Ni����( t Tkintert
_default_roott promptt minvaluet maxvaluet initialvalueR R ( R R
R8 R; R9 R: R R6 ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR � s c C s d | _ t j | � d S( N( R t entryR R ( R ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR � s c C s� t | d | j d t �} | j d d d d d t � t | d d �| _ | j j d d
d d d t t � | j d k r� | j j
d | j � | j j d t � n | j S( NR t justifyt rowi R i t stickyt nameR< i (
t LabelR8 R* t gridt Wt EntryR< t ER; R t insertt select_ranget END( R R R- ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR � s #c C s� d d l } y | j � } Wn/ t k
rM | j d | j d d | �d SX| j d k r� | | j k r� | j d d | j d | �d S| j d k r� | | j k r� | j d d | j d | �d S| | _ d
S( Ni����s
Illegal values
Please try againR i s Too smalls2 The allowed minimum value is %s. Please try again.s Too larges2 The allowed maximum value is %s. Please try again.i ( t tkMessageBoxt getresultt
ValueErrort showwarningt errormessageR9 R R: R
( R RI R
( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR. � s2
N( R2 R3 R R R R R. ( ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR5 � s t
_QueryIntegerc B s e Z d Z d � Z RS( s Not an integer.c C s t | j j � � S( N( t intR< t get( R ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyRJ � s ( R2 R3 RM RJ ( ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyRN � s c K s t | | | � } | j S( s� get an integer from the user
Arguments:
title -- the dialog title
prompt -- the label text
**kw -- see SimpleDialog class
Return value is an integer
( RN R
( R
R8 t kwt d( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyt
askinteger� s t _QueryFloatc B s e Z d Z d � Z RS( s Not a floating point value.c C s t | j j � � S( N( t floatR< RP ( R ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyRJ s ( R2 R3 RM RJ ( ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyRT s c K s t | | | � } | j S( s� get a float from the user
Arguments:
title -- the dialog title
prompt -- the label text
**kw -- see SimpleDialog class
Return value is a float
( RT R
( R
R8 RQ RR ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyt askfloat s t _QueryStringc B s# e Z d � Z d � Z d � Z RS( c O sC d | k r# | d | _ | d =n d | _ t j | | | � d S( Nt show( t _QueryString__showR R5 R ( R t argsRQ ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR s
c C s; t j | | � } | j d k r7 | j d | j � n | S( NRX ( R5 R RY R t configure( R R R< ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR % s c C s
| j j � S( N( R< RP ( R ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyRJ + s ( R2 R3 R R RJ ( ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyRW s c K s t | | | � } | j S( s� get a string from the user
Arguments:
title -- the dialog title
prompt -- the label text
**kw -- see SimpleDialog class
Return value is a string
( RW R
( R
R8 RQ RR ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyt askstring. s t __main__t Spams Egg countR; i s Egg weight
(in tons)R9 i R: id s Egg labelNi� ( R4 R6 R R R5 RN RS RT RV RW R\ R2 t Tkt roott update( ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyt <module> s
�J
Tkconstants.pyc 0000644 00000004306 15032720555 0007603 0 ustar 00 �
z fc @ s� d Z Z Z d Z Z Z d Z d Z d Z d Z d Z
d Z d Z d Z
d
Z d Z d Z d
Z d Z d Z d Z d Z d Z d Z d Z d Z d Z d Z d Z d Z d Z d Z d Z d Z! d Z" d Z# d Z$ d! Z% d" Z& d# Z' d$ Z( d% Z) d& Z* d' Z+ d( Z, d) Z- d* Z. d+ Z/ d, Z0 d- Z1 d. Z2 d/ Z3 d0 Z4 d1 Z5 d2 Z6 d3 Z7 d4 Z8 d5 Z9 d6 Z: d7 Z; d8 Z< d9 Z= d: Z> d; Z? d< Z@ d= ZA d> ZB d? ZC d@ ZD dA ZE dB ZF dC ZG dD ZH dE ZI dF ZJ dG ZK dH ZL dI S(J i i t nt st wt et nwt swt net set nst ewt nsewt centert nonet xt yt botht leftt topt rightt bottomt raisedt sunkent flatt ridget groovet solidt
horizontalt verticalt numerict chart wordt baselinet insidet outsidet sels sel.firsts sel.lastt endt insertt currentt anchort allt normalt disabledt activet hiddent cascadet checkbuttont commandt radiobuttont separatort singlet browset multiplet extendedt dotboxt underlinet pieslicet chordt arct firstt lastt buttt
projectingt roundt bevelt mitert movetot scrollt unitst pagesN(M t NOt FALSEt OFFt YESt TRUEt ONt Nt St Wt Et NWt SWt NEt SEt NSt EWt NSEWt CENTERt NONEt Xt Yt BOTHt LEFTt TOPt RIGHTt BOTTOMt RAISEDt SUNKENt FLATt RIDGEt GROOVEt SOLIDt
HORIZONTALt VERTICALt NUMERICt CHARt WORDt BASELINEt INSIDEt OUTSIDEt SELt SEL_FIRSTt SEL_LASTt ENDt INSERTt CURRENTt ANCHORt ALLt NORMALt DISABLEDt ACTIVEt HIDDENt CASCADEt CHECKBUTTONt COMMANDt RADIOBUTTONt SEPARATORt SINGLEt BROWSEt MULTIPLEt EXTENDEDt DOTBOXt UNDERLINEt PIESLICEt CHORDt ARCt FIRSTt LASTt BUTTt
PROJECTINGt ROUNDt BEVELt MITERt MOVETOt SCROLLt UNITSt PAGES( ( ( s* /usr/lib64/python2.7/lib-tk/Tkconstants.pyt <module> s� SimpleDialog.py 0000644 00000007220 15032720555 0007474 0 ustar 00 """A simple but flexible modal dialog box."""
from Tkinter import *
class SimpleDialog:
def __init__(self, master,
text='', buttons=[], default=None, cancel=None,
title=None, class_=None):
if class_:
self.root = Toplevel(master, class_=class_)
else:
self.root = Toplevel(master)
if title:
self.root.title(title)
self.root.iconname(title)
self.message = Message(self.root, text=text, aspect=400)
self.message.pack(expand=1, fill=BOTH)
self.frame = Frame(self.root)
self.frame.pack()
self.num = default
self.cancel = cancel
self.default = default
self.root.bind('<Return>', self.return_event)
for num in range(len(buttons)):
s = buttons[num]
b = Button(self.frame, text=s,
command=(lambda self=self, num=num: self.done(num)))
if num == default:
b.config(relief=RIDGE, borderwidth=8)
b.pack(side=LEFT, fill=BOTH, expand=1)
self.root.protocol('WM_DELETE_WINDOW', self.wm_delete_window)
self._set_transient(master)
def _set_transient(self, master, relx=0.5, rely=0.3):
widget = self.root
widget.withdraw() # Remain invisible while we figure out the geometry
widget.transient(master)
widget.update_idletasks() # Actualize geometry information
if master.winfo_ismapped():
m_width = master.winfo_width()
m_height = master.winfo_height()
m_x = master.winfo_rootx()
m_y = master.winfo_rooty()
else:
m_width = master.winfo_screenwidth()
m_height = master.winfo_screenheight()
m_x = m_y = 0
w_width = widget.winfo_reqwidth()
w_height = widget.winfo_reqheight()
x = m_x + (m_width - w_width) * relx
y = m_y + (m_height - w_height) * rely
if x+w_width > master.winfo_screenwidth():
x = master.winfo_screenwidth() - w_width
elif x < 0:
x = 0
if y+w_height > master.winfo_screenheight():
y = master.winfo_screenheight() - w_height
elif y < 0:
y = 0
widget.geometry("+%d+%d" % (x, y))
widget.deiconify() # Become visible at the desired location
def go(self):
self.root.wait_visibility()
self.root.grab_set()
self.root.mainloop()
self.root.destroy()
return self.num
def return_event(self, event):
if self.default is None:
self.root.bell()
else:
self.done(self.default)
def wm_delete_window(self):
if self.cancel is None:
self.root.bell()
else:
self.done(self.cancel)
def done(self, num):
self.num = num
self.root.quit()
if __name__ == '__main__':
def test():
root = Tk()
def doit(root=root):
d = SimpleDialog(root,
text="This is a test dialog. "
"Would this have been an actual dialog, "
"the buttons below would have been glowing "
"in soft pink light.\n"
"Do you believe this?",
buttons=["Yes", "No", "Cancel"],
default=0,
cancel=2,
title="Test Dialog")
print d.go()
t = Button(root, text='Test', command=doit)
t.pack()
q = Button(root, text='Quit', command=t.quit)
q.pack()
t.mainloop()
test()
Dialog.py 0000644 00000003037 15032720555 0006324 0 ustar 00 # dialog.py -- Tkinter interface to the tk_dialog script.
from Tkinter import *
from Tkinter import _cnfmerge
if TkVersion <= 3.6:
DIALOG_ICON = 'warning'
else:
DIALOG_ICON = 'questhead'
class Dialog(Widget):
def __init__(self, master=None, cnf={}, **kw):
cnf = _cnfmerge((cnf, kw))
self.widgetName = '__dialog__'
Widget._setup(self, master, cnf)
self.num = self.tk.getint(
self.tk.call(
'tk_dialog', self._w,
cnf['title'], cnf['text'],
cnf['bitmap'], cnf['default'],
*cnf['strings']))
try: Widget.destroy(self)
except TclError: pass
def destroy(self): pass
def _test():
d = Dialog(None, {'title': 'File Modified',
'text':
'File "Python.h" has been modified'
' since the last time it was saved.'
' Do you want to save it before'
' exiting the application.',
'bitmap': DIALOG_ICON,
'default': 0,
'strings': ('Save File',
'Discard Changes',
'Return to Editor')})
print d.num
if __name__ == '__main__':
t = Button(None, {'text': 'Test',
'command': _test,
Pack: {}})
q = Button(None, {'text': 'Quit',
'command': t.quit,
Pack: {}})
t.mainloop()
tkFont.pyc 0000644 00000016004 15032720555 0006533 0 ustar 00 �
z fc @ s� d Z d d l Z d Z d Z d Z d Z d � Z d d d � � YZ d d
� Z d d � Z
e d k r�e j � Z
e d
d d d d e � Z e j � GHe j d
� GHe j d � GHe j � GHe j d
� GHe j d � GHe
� GHe j d � Ge j d � GHe j � GHe d d � Z e j d � Ge j d � GHe j e
d d d e �Z e j � e j e
d d d e
j �Z e j � e d e d � j � Z e j d e � e j d e � e j � n d S( s 0.9i����Nt normalt romant boldt italicc C s t d | d t � S( sF Given the name of a tk named font, returns a Font representation.
t namet exists( t Fontt True( R ( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyt
nametofont s R c B s� e Z d Z d � Z d � Z d � Z d d d e d � Z d � Z d � Z
d � Z d � Z d � Z
d
� Z d d � Z d � Z d
� Z e Z d � Z d � Z RS( s� Represents a named font.
Constructor options are:
font -- font specifier (name, system font, or (family, size, style)-tuple)
name -- name to use for this font configuration (defaults to a unique name)
exists -- does a named font by this name already exist?
Creates a new named font if False, points to the existing font if True.
Raises _Tkinter.TclError if the assertion is false.
the following are ignored if font is specified:
family -- font 'family', e.g. Courier, Times, Helvetica
size -- font size in points
weight -- font thickness: NORMAL, BOLD
slant -- font slant: ROMAN, ITALIC
underline -- font underlining: false (0), true (1)
overstrike -- font strikeout: false (0), true (1)
c C si g } xV | j � D]H \ } } t | t � s= t | � } n | j d | � | j | � q Wt | � S( Nt -( t itemst
isinstancet
basestringt strt appendt tuple( t selft kwt optionst kt v( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyt _set/ s c C s2 g } x | D] } | j d | � q
Wt | � S( NR ( R R ( R t argsR R ( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyt _get8 s
c C sG i } x: t d t | � d � D] } | | d | | | d <q W| S( Ni i i ( t ranget len( R R R t i( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyt _mkdict> s c K s= | s t j } n t | d | � } | rK | j | j d d | � � } n | j | � } | sy d t t | � � } n | | _ | r� t | _
| j | j | j d d � � k r� t j j d | j f � n | r| j d d | j | � qn" | j d d | j | � t
| _
| | _ | j | _ | j | _ d S( Nt tkt fontt actualt namess$ named font %s does not already existt configuret create( t Tkintert
_default_roott getattrt splitlistt callR R
t idR t Falset delete_fontt _tkintert TclErrorR t _tkt _splitt _call( R t rootR R R R R ( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyt __init__D s( ! $ c C s | j S( N( R ( R ( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyt __str__a s c C s t | t � o | j | j k S( N( R R R ( R t other( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyt __eq__d s c C s
| j | � S( N( t cget( R t key( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyt __getitem__g s c C s | j i | | 6� d S( N( R ( R R5 t value( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyt __setitem__j s c C sW y& | j r% | j d d | j � n Wn* t t f k
rB � n t k
rR n Xd S( NR t delete( R) R. R t KeyboardInterruptt
SystemExitt Exception( R ( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyt __del__m s
c C s t | j | j � � S( s* Return a distinct copy of the current font( R R, R ( R ( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyt copyv s c C sO | r# | j d d | j d | � S| j | j | j d d | j � � � Sd S( s Return actual font attributesR R R N( R. R R R- ( R t option( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyR z s c C s | j d d | j d | � S( s Get font attributeR t configR ( R. R ( R R? ( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyR4 � s c K sW | r+ | j d d | j | j | � � n( | j | j | j d d | j � � � Sd S( s Modify font attributesR R@ N( R. R R R R- ( R R ( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyR@ � s
c C s t | j d d | j | � � S( s Return text widthR t measure( t intR. R ( R t text( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyRA � s c G s� | r. t | j d d | j | j | � � � S| j | j d d | j � � } i } x@ t d t | � d � D]& } t | | d � | | | d <qn W| Sd S( s} Return font metrics.
For best performance, create a dummy widget
using this font before calling this method.R t metricsi i i N( RB R. R R R- R R ( R R t resR ( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyRD � s %! $N( t __name__t
__module__t __doc__R R R t NoneR( R0 R1 R3 R6 R8 R= R> R R4 R@ R RA RD ( ( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyR s"
c C s1 | s t j } n | j j | j j d d � � S( s Get font families (as a tuple)R t families( R" R# R R% R& ( R/ ( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyRJ � s c C s1 | s t j } n | j j | j j d d � � S( s' Get names of defined fonts (as a tuple)R R ( R" R# R R% R& ( R/ ( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyR � s t __main__t familyt timest sizei t weightt hellot linespaceR t Courieri RC s Hello, worlds Quit!t command( ( RR i R ( t __version__R" t NORMALt ROMANt BOLDt ITALICR R RI RJ R RF t TkR/ t fR R@ R4 RA RD t Labelt wt packt Buttont destroyR> t fbt mainloop( ( ( s% /usr/lib64/python2.7/lib-tk/tkFont.pyt <module> s> �
turtle.py 0000644 00000417433 15032720555 0006455 0 ustar 00 #
# turtle.py: a Tkinter based turtle graphics module for Python
# Version 1.0.1 - 24. 9. 2009
#
# Copyright (C) 2006 - 2010 Gregor Lingl
# email: glingl@aon.at
#
# This software is provided 'as-is', without any express or implied
# warranty. In no event will the authors be held liable for any damages
# arising from the use of this software.
#
# Permission is granted to anyone to use this software for any purpose,
# including commercial applications, and to alter it and redistribute it
# freely, subject to the following restrictions:
#
# 1. The origin of this software must not be misrepresented; you must not
# claim that you wrote the original software. If you use this software
# in a product, an acknowledgment in the product documentation would be
# appreciated but is not required.
# 2. Altered source versions must be plainly marked as such, and must not be
# misrepresented as being the original software.
# 3. This notice may not be removed or altered from any source distribution.
"""
Turtle graphics is a popular way for introducing programming to
kids. It was part of the original Logo programming language developed
by Wally Feurzig and Seymour Papert in 1966.
Imagine a robotic turtle starting at (0, 0) in the x-y plane. After an ``import turtle``, give it
the command turtle.forward(15), and it moves (on-screen!) 15 pixels in
the direction it is facing, drawing a line as it moves. Give it the
command turtle.right(25), and it rotates in-place 25 degrees clockwise.
By combining together these and similar commands, intricate shapes and
pictures can easily be drawn.
----- turtle.py
This module is an extended reimplementation of turtle.py from the
Python standard distribution up to Python 2.5. (See: http://www.python.org)
It tries to keep the merits of turtle.py and to be (nearly) 100%
compatible with it. This means in the first place to enable the
learning programmer to use all the commands, classes and methods
interactively when using the module from within IDLE run with
the -n switch.
Roughly it has the following features added:
- Better animation of the turtle movements, especially of turning the
turtle. So the turtles can more easily be used as a visual feedback
instrument by the (beginning) programmer.
- Different turtle shapes, gif-images as turtle shapes, user defined
and user controllable turtle shapes, among them compound
(multicolored) shapes. Turtle shapes can be stretched and tilted, which
makes turtles very versatile geometrical objects.
- Fine control over turtle movement and screen updates via delay(),
and enhanced tracer() and speed() methods.
- Aliases for the most commonly used commands, like fd for forward etc.,
following the early Logo traditions. This reduces the boring work of
typing long sequences of commands, which often occur in a natural way
when kids try to program fancy pictures on their first encounter with
turtle graphics.
- Turtles now have an undo()-method with configurable undo-buffer.
- Some simple commands/methods for creating event driven programs
(mouse-, key-, timer-events). Especially useful for programming games.
- A scrollable Canvas class. The default scrollable Canvas can be
extended interactively as needed while playing around with the turtle(s).
- A TurtleScreen class with methods controlling background color or
background image, window and canvas size and other properties of the
TurtleScreen.
- There is a method, setworldcoordinates(), to install a user defined
coordinate-system for the TurtleScreen.
- The implementation uses a 2-vector class named Vec2D, derived from tuple.
This class is public, so it can be imported by the application programmer,
which makes certain types of computations very natural and compact.
- Appearance of the TurtleScreen and the Turtles at startup/import can be
configured by means of a turtle.cfg configuration file.
The default configuration mimics the appearance of the old turtle module.
- If configured appropriately the module reads in docstrings from a docstring
dictionary in some different language, supplied separately and replaces
the English ones by those read in. There is a utility function
write_docstringdict() to write a dictionary with the original (English)
docstrings to disc, so it can serve as a template for translations.
Behind the scenes there are some features included with possible
extensions in mind. These will be commented and documented elsewhere.
"""
_ver = "turtle 1.0b1 - for Python 2.6 - 30. 5. 2008, 18:08"
#print _ver
import Tkinter as TK
import types
import math
import time
import os
from os.path import isfile, split, join
from copy import deepcopy
from math import * ## for compatibility with old turtle module
_tg_classes = ['ScrolledCanvas', 'TurtleScreen', 'Screen',
'RawTurtle', 'Turtle', 'RawPen', 'Pen', 'Shape', 'Vec2D']
_tg_screen_functions = ['addshape', 'bgcolor', 'bgpic', 'bye',
'clearscreen', 'colormode', 'delay', 'exitonclick', 'getcanvas',
'getshapes', 'listen', 'mode', 'onkey', 'onscreenclick', 'ontimer',
'register_shape', 'resetscreen', 'screensize', 'setup',
'setworldcoordinates', 'title', 'tracer', 'turtles', 'update',
'window_height', 'window_width']
_tg_turtle_functions = ['back', 'backward', 'begin_fill', 'begin_poly', 'bk',
'circle', 'clear', 'clearstamp', 'clearstamps', 'clone', 'color',
'degrees', 'distance', 'dot', 'down', 'end_fill', 'end_poly', 'fd',
'fill', 'fillcolor', 'forward', 'get_poly', 'getpen', 'getscreen',
'getturtle', 'goto', 'heading', 'hideturtle', 'home', 'ht', 'isdown',
'isvisible', 'left', 'lt', 'onclick', 'ondrag', 'onrelease', 'pd',
'pen', 'pencolor', 'pendown', 'pensize', 'penup', 'pos', 'position',
'pu', 'radians', 'right', 'reset', 'resizemode', 'rt',
'seth', 'setheading', 'setpos', 'setposition', 'settiltangle',
'setundobuffer', 'setx', 'sety', 'shape', 'shapesize', 'showturtle',
'speed', 'st', 'stamp', 'tilt', 'tiltangle', 'towards', 'tracer',
'turtlesize', 'undo', 'undobufferentries', 'up', 'width',
'window_height', 'window_width', 'write', 'xcor', 'ycor']
_tg_utilities = ['write_docstringdict', 'done', 'mainloop']
_math_functions = ['acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'cosh',
'e', 'exp', 'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log',
'log10', 'modf', 'pi', 'pow', 'sin', 'sinh', 'sqrt', 'tan', 'tanh']
__all__ = (_tg_classes + _tg_screen_functions + _tg_turtle_functions +
_tg_utilities + ['Terminator'] + _math_functions)
_alias_list = ['addshape', 'backward', 'bk', 'fd', 'ht', 'lt', 'pd', 'pos',
'pu', 'rt', 'seth', 'setpos', 'setposition', 'st',
'turtlesize', 'up', 'width']
_CFG = {"width" : 0.5, # Screen
"height" : 0.75,
"canvwidth" : 400,
"canvheight": 300,
"leftright": None,
"topbottom": None,
"mode": "standard", # TurtleScreen
"colormode": 1.0,
"delay": 10,
"undobuffersize": 1000, # RawTurtle
"shape": "classic",
"pencolor" : "black",
"fillcolor" : "black",
"resizemode" : "noresize",
"visible" : True,
"language": "english", # docstrings
"exampleturtle": "turtle",
"examplescreen": "screen",
"title": "Python Turtle Graphics",
"using_IDLE": False
}
##print "cwd:", os.getcwd()
##print "__file__:", __file__
##
##def show(dictionary):
## print "=========================="
## for key in sorted(dictionary.keys()):
## print key, ":", dictionary[key]
## print "=========================="
## print
def config_dict(filename):
"""Convert content of config-file into dictionary."""
f = open(filename, "r")
cfglines = f.readlines()
f.close()
cfgdict = {}
for line in cfglines:
line = line.strip()
if not line or line.startswith("#"):
continue
try:
key, value = line.split("=")
except ValueError:
print "Bad line in config-file %s:\n%s" % (filename,line)
continue
key = key.strip()
value = value.strip()
if value in ["True", "False", "None", "''", '""']:
value = eval(value)
else:
try:
if "." in value:
value = float(value)
else:
value = int(value)
except ValueError:
pass # value need not be converted
cfgdict[key] = value
return cfgdict
def readconfig(cfgdict):
"""Read config-files, change configuration-dict accordingly.
If there is a turtle.cfg file in the current working directory,
read it from there. If this contains an importconfig-value,
say 'myway', construct filename turtle_mayway.cfg else use
turtle.cfg and read it from the import-directory, where
turtle.py is located.
Update configuration dictionary first according to config-file,
in the import directory, then according to config-file in the
current working directory.
If no config-file is found, the default configuration is used.
"""
default_cfg = "turtle.cfg"
cfgdict1 = {}
cfgdict2 = {}
if isfile(default_cfg):
cfgdict1 = config_dict(default_cfg)
#print "1. Loading config-file %s from: %s" % (default_cfg, os.getcwd())
if "importconfig" in cfgdict1:
default_cfg = "turtle_%s.cfg" % cfgdict1["importconfig"]
try:
head, tail = split(__file__)
cfg_file2 = join(head, default_cfg)
except BaseException:
cfg_file2 = ""
if isfile(cfg_file2):
#print "2. Loading config-file %s:" % cfg_file2
cfgdict2 = config_dict(cfg_file2)
## show(_CFG)
## show(cfgdict2)
_CFG.update(cfgdict2)
## show(_CFG)
## show(cfgdict1)
_CFG.update(cfgdict1)
## show(_CFG)
try:
readconfig(_CFG)
except BaseException:
print "No configfile read, reason unknown"
class Vec2D(tuple):
"""A 2 dimensional vector class, used as a helper class
for implementing turtle graphics.
May be useful for turtle graphics programs also.
Derived from tuple, so a vector is a tuple!
Provides (for a, b vectors, k number):
a+b vector addition
a-b vector subtraction
a*b inner product
k*a and a*k multiplication with scalar
|a| absolute value of a
a.rotate(angle) rotation
"""
def __new__(cls, x, y):
return tuple.__new__(cls, (x, y))
def __add__(self, other):
return Vec2D(self[0]+other[0], self[1]+other[1])
def __mul__(self, other):
if isinstance(other, Vec2D):
return self[0]*other[0]+self[1]*other[1]
return Vec2D(self[0]*other, self[1]*other)
def __rmul__(self, other):
if isinstance(other, (int, long, float)):
return Vec2D(self[0]*other, self[1]*other)
def __sub__(self, other):
return Vec2D(self[0]-other[0], self[1]-other[1])
def __neg__(self):
return Vec2D(-self[0], -self[1])
def __abs__(self):
return (self[0]**2 + self[1]**2)**0.5
def rotate(self, angle):
"""rotate self counterclockwise by angle
"""
perp = Vec2D(-self[1], self[0])
angle = angle * math.pi / 180.0
c, s = math.cos(angle), math.sin(angle)
return Vec2D(self[0]*c+perp[0]*s, self[1]*c+perp[1]*s)
def __getnewargs__(self):
return (self[0], self[1])
def __repr__(self):
return "(%.2f,%.2f)" % self
##############################################################################
### From here up to line : Tkinter - Interface for turtle.py ###
### May be replaced by an interface to some different graphics toolkit ###
##############################################################################
## helper functions for Scrolled Canvas, to forward Canvas-methods
## to ScrolledCanvas class
def __methodDict(cls, _dict):
"""helper function for Scrolled Canvas"""
baseList = list(cls.__bases__)
baseList.reverse()
for _super in baseList:
__methodDict(_super, _dict)
for key, value in cls.__dict__.items():
if type(value) == types.FunctionType:
_dict[key] = value
def __methods(cls):
"""helper function for Scrolled Canvas"""
_dict = {}
__methodDict(cls, _dict)
return _dict.keys()
__stringBody = (
'def %(method)s(self, *args, **kw): return ' +
'self.%(attribute)s.%(method)s(*args, **kw)')
def __forwardmethods(fromClass, toClass, toPart, exclude = ()):
"""Helper functions for Scrolled Canvas, used to forward
ScrolledCanvas-methods to Tkinter.Canvas class.
"""
_dict = {}
__methodDict(toClass, _dict)
for ex in _dict.keys():
if ex[:1] == '_' or ex[-1:] == '_':
del _dict[ex]
for ex in exclude:
if ex in _dict:
del _dict[ex]
for ex in __methods(fromClass):
if ex in _dict:
del _dict[ex]
for method, func in _dict.items():
d = {'method': method, 'func': func}
if type(toPart) == types.StringType:
execString = \
__stringBody % {'method' : method, 'attribute' : toPart}
exec execString in d
fromClass.__dict__[method] = d[method]
class ScrolledCanvas(TK.Frame):
"""Modeled after the scrolled canvas class from Grayons's Tkinter book.
Used as the default canvas, which pops up automatically when
using turtle graphics functions or the Turtle class.
"""
def __init__(self, master, width=500, height=350,
canvwidth=600, canvheight=500):
TK.Frame.__init__(self, master, width=width, height=height)
self._rootwindow = self.winfo_toplevel()
self.width, self.height = width, height
self.canvwidth, self.canvheight = canvwidth, canvheight
self.bg = "white"
self._canvas = TK.Canvas(master, width=width, height=height,
bg=self.bg, relief=TK.SUNKEN, borderwidth=2)
self.hscroll = TK.Scrollbar(master, command=self._canvas.xview,
orient=TK.HORIZONTAL)
self.vscroll = TK.Scrollbar(master, command=self._canvas.yview)
self._canvas.configure(xscrollcommand=self.hscroll.set,
yscrollcommand=self.vscroll.set)
self.rowconfigure(0, weight=1, minsize=0)
self.columnconfigure(0, weight=1, minsize=0)
self._canvas.grid(padx=1, in_ = self, pady=1, row=0,
column=0, rowspan=1, columnspan=1, sticky='news')
self.vscroll.grid(padx=1, in_ = self, pady=1, row=0,
column=1, rowspan=1, columnspan=1, sticky='news')
self.hscroll.grid(padx=1, in_ = self, pady=1, row=1,
column=0, rowspan=1, columnspan=1, sticky='news')
self.reset()
self._rootwindow.bind('<Configure>', self.onResize)
def reset(self, canvwidth=None, canvheight=None, bg = None):
"""Adjust canvas and scrollbars according to given canvas size."""
if canvwidth:
self.canvwidth = canvwidth
if canvheight:
self.canvheight = canvheight
if bg:
self.bg = bg
self._canvas.config(bg=bg,
scrollregion=(-self.canvwidth//2, -self.canvheight//2,
self.canvwidth//2, self.canvheight//2))
self._canvas.xview_moveto(0.5*(self.canvwidth - self.width + 30) /
self.canvwidth)
self._canvas.yview_moveto(0.5*(self.canvheight- self.height + 30) /
self.canvheight)
self.adjustScrolls()
def adjustScrolls(self):
""" Adjust scrollbars according to window- and canvas-size.
"""
cwidth = self._canvas.winfo_width()
cheight = self._canvas.winfo_height()
self._canvas.xview_moveto(0.5*(self.canvwidth-cwidth)/self.canvwidth)
self._canvas.yview_moveto(0.5*(self.canvheight-cheight)/self.canvheight)
if cwidth < self.canvwidth or cheight < self.canvheight:
self.hscroll.grid(padx=1, in_ = self, pady=1, row=1,
column=0, rowspan=1, columnspan=1, sticky='news')
self.vscroll.grid(padx=1, in_ = self, pady=1, row=0,
column=1, rowspan=1, columnspan=1, sticky='news')
else:
self.hscroll.grid_forget()
self.vscroll.grid_forget()
def onResize(self, event):
"""self-explanatory"""
self.adjustScrolls()
def bbox(self, *args):
""" 'forward' method, which canvas itself has inherited...
"""
return self._canvas.bbox(*args)
def cget(self, *args, **kwargs):
""" 'forward' method, which canvas itself has inherited...
"""
return self._canvas.cget(*args, **kwargs)
def config(self, *args, **kwargs):
""" 'forward' method, which canvas itself has inherited...
"""
self._canvas.config(*args, **kwargs)
def bind(self, *args, **kwargs):
""" 'forward' method, which canvas itself has inherited...
"""
self._canvas.bind(*args, **kwargs)
def unbind(self, *args, **kwargs):
""" 'forward' method, which canvas itself has inherited...
"""
self._canvas.unbind(*args, **kwargs)
def focus_force(self):
""" 'forward' method, which canvas itself has inherited...
"""
self._canvas.focus_force()
__forwardmethods(ScrolledCanvas, TK.Canvas, '_canvas')
class _Root(TK.Tk):
"""Root class for Screen based on Tkinter."""
def __init__(self):
TK.Tk.__init__(self)
def setupcanvas(self, width, height, cwidth, cheight):
self._canvas = ScrolledCanvas(self, width, height, cwidth, cheight)
self._canvas.pack(expand=1, fill="both")
def _getcanvas(self):
return self._canvas
def set_geometry(self, width, height, startx, starty):
self.geometry("%dx%d%+d%+d"%(width, height, startx, starty))
def ondestroy(self, destroy):
self.wm_protocol("WM_DELETE_WINDOW", destroy)
def win_width(self):
return self.winfo_screenwidth()
def win_height(self):
return self.winfo_screenheight()
Canvas = TK.Canvas
class TurtleScreenBase(object):
"""Provide the basic graphics functionality.
Interface between Tkinter and turtle.py.
To port turtle.py to some different graphics toolkit
a corresponding TurtleScreenBase class has to be implemented.
"""
@staticmethod
def _blankimage():
"""return a blank image object
"""
img = TK.PhotoImage(width=1, height=1)
img.blank()
return img
@staticmethod
def _image(filename):
"""return an image object containing the
imagedata from a gif-file named filename.
"""
return TK.PhotoImage(file=filename)
def __init__(self, cv):
self.cv = cv
if isinstance(cv, ScrolledCanvas):
w = self.cv.canvwidth
h = self.cv.canvheight
else: # expected: ordinary TK.Canvas
w = int(self.cv.cget("width"))
h = int(self.cv.cget("height"))
self.cv.config(scrollregion = (-w//2, -h//2, w//2, h//2 ))
self.canvwidth = w
self.canvheight = h
self.xscale = self.yscale = 1.0
def _createpoly(self):
"""Create an invisible polygon item on canvas self.cv)
"""
return self.cv.create_polygon((0, 0, 0, 0, 0, 0), fill="", outline="")
def _drawpoly(self, polyitem, coordlist, fill=None,
outline=None, width=None, top=False):
"""Configure polygonitem polyitem according to provided
arguments:
coordlist is sequence of coordinates
fill is filling color
outline is outline color
top is a boolean value, which specifies if polyitem
will be put on top of the canvas' displaylist so it
will not be covered by other items.
"""
cl = []
for x, y in coordlist:
cl.append(x * self.xscale)
cl.append(-y * self.yscale)
self.cv.coords(polyitem, *cl)
if fill is not None:
self.cv.itemconfigure(polyitem, fill=fill)
if outline is not None:
self.cv.itemconfigure(polyitem, outline=outline)
if width is not None:
self.cv.itemconfigure(polyitem, width=width)
if top:
self.cv.tag_raise(polyitem)
def _createline(self):
"""Create an invisible line item on canvas self.cv)
"""
return self.cv.create_line(0, 0, 0, 0, fill="", width=2,
capstyle = TK.ROUND)
def _drawline(self, lineitem, coordlist=None,
fill=None, width=None, top=False):
"""Configure lineitem according to provided arguments:
coordlist is sequence of coordinates
fill is drawing color
width is width of drawn line.
top is a boolean value, which specifies if polyitem
will be put on top of the canvas' displaylist so it
will not be covered by other items.
"""
if coordlist is not None:
cl = []
for x, y in coordlist:
cl.append(x * self.xscale)
cl.append(-y * self.yscale)
self.cv.coords(lineitem, *cl)
if fill is not None:
self.cv.itemconfigure(lineitem, fill=fill)
if width is not None:
self.cv.itemconfigure(lineitem, width=width)
if top:
self.cv.tag_raise(lineitem)
def _delete(self, item):
"""Delete graphics item from canvas.
If item is"all" delete all graphics items.
"""
self.cv.delete(item)
def _update(self):
"""Redraw graphics items on canvas
"""
self.cv.update()
def _delay(self, delay):
"""Delay subsequent canvas actions for delay ms."""
self.cv.after(delay)
def _iscolorstring(self, color):
"""Check if the string color is a legal Tkinter color string.
"""
try:
rgb = self.cv.winfo_rgb(color)
ok = True
except TK.TclError:
ok = False
return ok
def _bgcolor(self, color=None):
"""Set canvas' backgroundcolor if color is not None,
else return backgroundcolor."""
if color is not None:
self.cv.config(bg = color)
self._update()
else:
return self.cv.cget("bg")
def _write(self, pos, txt, align, font, pencolor):
"""Write txt at pos in canvas with specified font
and color.
Return text item and x-coord of right bottom corner
of text's bounding box."""
x, y = pos
x = x * self.xscale
y = y * self.yscale
anchor = {"left":"sw", "center":"s", "right":"se" }
item = self.cv.create_text(x-1, -y, text = txt, anchor = anchor[align],
fill = pencolor, font = font)
x0, y0, x1, y1 = self.cv.bbox(item)
self.cv.update()
return item, x1-1
## def _dot(self, pos, size, color):
## """may be implemented for some other graphics toolkit"""
def _onclick(self, item, fun, num=1, add=None):
"""Bind fun to mouse-click event on turtle.
fun must be a function with two arguments, the coordinates
of the clicked point on the canvas.
num, the number of the mouse-button defaults to 1
"""
if fun is None:
self.cv.tag_unbind(item, "<Button-%s>" % num)
else:
def eventfun(event):
x, y = (self.cv.canvasx(event.x)/self.xscale,
-self.cv.canvasy(event.y)/self.yscale)
fun(x, y)
self.cv.tag_bind(item, "<Button-%s>" % num, eventfun, add)
def _onrelease(self, item, fun, num=1, add=None):
"""Bind fun to mouse-button-release event on turtle.
fun must be a function with two arguments, the coordinates
of the point on the canvas where mouse button is released.
num, the number of the mouse-button defaults to 1
If a turtle is clicked, first _onclick-event will be performed,
then _onscreensclick-event.
"""
if fun is None:
self.cv.tag_unbind(item, "<Button%s-ButtonRelease>" % num)
else:
def eventfun(event):
x, y = (self.cv.canvasx(event.x)/self.xscale,
-self.cv.canvasy(event.y)/self.yscale)
fun(x, y)
self.cv.tag_bind(item, "<Button%s-ButtonRelease>" % num,
eventfun, add)
def _ondrag(self, item, fun, num=1, add=None):
"""Bind fun to mouse-move-event (with pressed mouse button) on turtle.
fun must be a function with two arguments, the coordinates of the
actual mouse position on the canvas.
num, the number of the mouse-button defaults to 1
Every sequence of mouse-move-events on a turtle is preceded by a
mouse-click event on that turtle.
"""
if fun is None:
self.cv.tag_unbind(item, "<Button%s-Motion>" % num)
else:
def eventfun(event):
try:
x, y = (self.cv.canvasx(event.x)/self.xscale,
-self.cv.canvasy(event.y)/self.yscale)
fun(x, y)
except BaseException:
pass
self.cv.tag_bind(item, "<Button%s-Motion>" % num, eventfun, add)
def _onscreenclick(self, fun, num=1, add=None):
"""Bind fun to mouse-click event on canvas.
fun must be a function with two arguments, the coordinates
of the clicked point on the canvas.
num, the number of the mouse-button defaults to 1
If a turtle is clicked, first _onclick-event will be performed,
then _onscreensclick-event.
"""
if fun is None:
self.cv.unbind("<Button-%s>" % num)
else:
def eventfun(event):
x, y = (self.cv.canvasx(event.x)/self.xscale,
-self.cv.canvasy(event.y)/self.yscale)
fun(x, y)
self.cv.bind("<Button-%s>" % num, eventfun, add)
def _onkey(self, fun, key):
"""Bind fun to key-release event of key.
Canvas must have focus. See method listen
"""
if fun is None:
self.cv.unbind("<KeyRelease-%s>" % key, None)
else:
def eventfun(event):
fun()
self.cv.bind("<KeyRelease-%s>" % key, eventfun)
def _listen(self):
"""Set focus on canvas (in order to collect key-events)
"""
self.cv.focus_force()
def _ontimer(self, fun, t):
"""Install a timer, which calls fun after t milliseconds.
"""
if t == 0:
self.cv.after_idle(fun)
else:
self.cv.after(t, fun)
def _createimage(self, image):
"""Create and return image item on canvas.
"""
return self.cv.create_image(0, 0, image=image)
def _drawimage(self, item, pos, image):
"""Configure image item as to draw image object
at position (x,y) on canvas)
"""
x, y = pos
self.cv.coords(item, (x * self.xscale, -y * self.yscale))
self.cv.itemconfig(item, image=image)
def _setbgpic(self, item, image):
"""Configure image item as to draw image object
at center of canvas. Set item to the first item
in the displaylist, so it will be drawn below
any other item ."""
self.cv.itemconfig(item, image=image)
self.cv.tag_lower(item)
def _type(self, item):
"""Return 'line' or 'polygon' or 'image' depending on
type of item.
"""
return self.cv.type(item)
def _pointlist(self, item):
"""returns list of coordinate-pairs of points of item
Example (for insiders):
>>> from turtle import *
>>> getscreen()._pointlist(getturtle().turtle._item)
[(0.0, 9.9999999999999982), (0.0, -9.9999999999999982),
(9.9999999999999982, 0.0)]
>>> """
cl = self.cv.coords(item)
pl = [(cl[i], -cl[i+1]) for i in range(0, len(cl), 2)]
return pl
def _setscrollregion(self, srx1, sry1, srx2, sry2):
self.cv.config(scrollregion=(srx1, sry1, srx2, sry2))
def _rescale(self, xscalefactor, yscalefactor):
items = self.cv.find_all()
for item in items:
coordinates = self.cv.coords(item)
newcoordlist = []
while coordinates:
x, y = coordinates[:2]
newcoordlist.append(x * xscalefactor)
newcoordlist.append(y * yscalefactor)
coordinates = coordinates[2:]
self.cv.coords(item, *newcoordlist)
def _resize(self, canvwidth=None, canvheight=None, bg=None):
"""Resize the canvas the turtles are drawing on. Does
not alter the drawing window.
"""
# needs amendment
if not isinstance(self.cv, ScrolledCanvas):
return self.canvwidth, self.canvheight
if canvwidth is canvheight is bg is None:
return self.cv.canvwidth, self.cv.canvheight
if canvwidth is not None:
self.canvwidth = canvwidth
if canvheight is not None:
self.canvheight = canvheight
self.cv.reset(canvwidth, canvheight, bg)
def _window_size(self):
""" Return the width and height of the turtle window.
"""
width = self.cv.winfo_width()
if width <= 1: # the window isn't managed by a geometry manager
width = self.cv['width']
height = self.cv.winfo_height()
if height <= 1: # the window isn't managed by a geometry manager
height = self.cv['height']
return width, height
##############################################################################
### End of Tkinter - interface ###
##############################################################################
class Terminator (Exception):
"""Will be raised in TurtleScreen.update, if _RUNNING becomes False.
This stops execution of a turtle graphics script.
Main purpose: use in the Demo-Viewer turtle.Demo.py.
"""
pass
class TurtleGraphicsError(Exception):
"""Some TurtleGraphics Error
"""
class Shape(object):
"""Data structure modeling shapes.
attribute _type is one of "polygon", "image", "compound"
attribute _data is - depending on _type a poygon-tuple,
an image or a list constructed using the addcomponent method.
"""
def __init__(self, type_, data=None):
self._type = type_
if type_ == "polygon":
if isinstance(data, list):
data = tuple(data)
elif type_ == "image":
if isinstance(data, basestring):
if data.lower().endswith(".gif") and isfile(data):
data = TurtleScreen._image(data)
# else data assumed to be Photoimage
elif type_ == "compound":
data = []
else:
raise TurtleGraphicsError("There is no shape type %s" % type_)
self._data = data
def addcomponent(self, poly, fill, outline=None):
"""Add component to a shape of type compound.
Arguments: poly is a polygon, i. e. a tuple of number pairs.
fill is the fillcolor of the component,
outline is the outline color of the component.
call (for a Shapeobject namend s):
-- s.addcomponent(((0,0), (10,10), (-10,10)), "red", "blue")
Example:
>>> poly = ((0,0),(10,-5),(0,10),(-10,-5))
>>> s = Shape("compound")
>>> s.addcomponent(poly, "red", "blue")
>>> # .. add more components and then use register_shape()
"""
if self._type != "compound":
raise TurtleGraphicsError("Cannot add component to %s Shape"
% self._type)
if outline is None:
outline = fill
self._data.append([poly, fill, outline])
class Tbuffer(object):
"""Ring buffer used as undobuffer for RawTurtle objects."""
def __init__(self, bufsize=10):
self.bufsize = bufsize
self.buffer = [[None]] * bufsize
self.ptr = -1
self.cumulate = False
def reset(self, bufsize=None):
if bufsize is None:
for i in range(self.bufsize):
self.buffer[i] = [None]
else:
self.bufsize = bufsize
self.buffer = [[None]] * bufsize
self.ptr = -1
def push(self, item):
if self.bufsize > 0:
if not self.cumulate:
self.ptr = (self.ptr + 1) % self.bufsize
self.buffer[self.ptr] = item
else:
self.buffer[self.ptr].append(item)
def pop(self):
if self.bufsize > 0:
item = self.buffer[self.ptr]
if item is None:
return None
else:
self.buffer[self.ptr] = [None]
self.ptr = (self.ptr - 1) % self.bufsize
return (item)
def nr_of_items(self):
return self.bufsize - self.buffer.count([None])
def __repr__(self):
return str(self.buffer) + " " + str(self.ptr)
class TurtleScreen(TurtleScreenBase):
"""Provides screen oriented methods like setbg etc.
Only relies upon the methods of TurtleScreenBase and NOT
upon components of the underlying graphics toolkit -
which is Tkinter in this case.
"""
# _STANDARD_DELAY = 5
_RUNNING = True
def __init__(self, cv, mode=_CFG["mode"],
colormode=_CFG["colormode"], delay=_CFG["delay"]):
self._shapes = {
"arrow" : Shape("polygon", ((-10,0), (10,0), (0,10))),
"turtle" : Shape("polygon", ((0,16), (-2,14), (-1,10), (-4,7),
(-7,9), (-9,8), (-6,5), (-7,1), (-5,-3), (-8,-6),
(-6,-8), (-4,-5), (0,-7), (4,-5), (6,-8), (8,-6),
(5,-3), (7,1), (6,5), (9,8), (7,9), (4,7), (1,10),
(2,14))),
"circle" : Shape("polygon", ((10,0), (9.51,3.09), (8.09,5.88),
(5.88,8.09), (3.09,9.51), (0,10), (-3.09,9.51),
(-5.88,8.09), (-8.09,5.88), (-9.51,3.09), (-10,0),
(-9.51,-3.09), (-8.09,-5.88), (-5.88,-8.09),
(-3.09,-9.51), (-0.00,-10.00), (3.09,-9.51),
(5.88,-8.09), (8.09,-5.88), (9.51,-3.09))),
"square" : Shape("polygon", ((10,-10), (10,10), (-10,10),
(-10,-10))),
"triangle" : Shape("polygon", ((10,-5.77), (0,11.55),
(-10,-5.77))),
"classic": Shape("polygon", ((0,0),(-5,-9),(0,-7),(5,-9))),
"blank" : Shape("image", self._blankimage())
}
self._bgpics = {"nopic" : ""}
TurtleScreenBase.__init__(self, cv)
self._mode = mode
self._delayvalue = delay
self._colormode = _CFG["colormode"]
self._keys = []
self.clear()
def clear(self):
"""Delete all drawings and all turtles from the TurtleScreen.
Reset empty TurtleScreen to its initial state: white background,
no backgroundimage, no eventbindings and tracing on.
No argument.
Example (for a TurtleScreen instance named screen):
>>> screen.clear()
Note: this method is not available as function.
"""
self._delayvalue = _CFG["delay"]
self._colormode = _CFG["colormode"]
self._delete("all")
self._bgpic = self._createimage("")
self._bgpicname = "nopic"
self._tracing = 1
self._updatecounter = 0
self._turtles = []
self.bgcolor("white")
for btn in 1, 2, 3:
self.onclick(None, btn)
for key in self._keys[:]:
self.onkey(None, key)
Turtle._pen = None
def mode(self, mode=None):
"""Set turtle-mode ('standard', 'logo' or 'world') and perform reset.
Optional argument:
mode -- one of the strings 'standard', 'logo' or 'world'
Mode 'standard' is compatible with turtle.py.
Mode 'logo' is compatible with most Logo-Turtle-Graphics.
Mode 'world' uses userdefined 'worldcoordinates'. *Attention*: in
this mode angles appear distorted if x/y unit-ratio doesn't equal 1.
If mode is not given, return the current mode.
Mode Initial turtle heading positive angles
------------|-------------------------|-------------------
'standard' to the right (east) counterclockwise
'logo' upward (north) clockwise
Examples:
>>> mode('logo') # resets turtle heading to north
>>> mode()
'logo'
"""
if mode is None:
return self._mode
mode = mode.lower()
if mode not in ["standard", "logo", "world"]:
raise TurtleGraphicsError("No turtle-graphics-mode %s" % mode)
self._mode = mode
if mode in ["standard", "logo"]:
self._setscrollregion(-self.canvwidth//2, -self.canvheight//2,
self.canvwidth//2, self.canvheight//2)
self.xscale = self.yscale = 1.0
self.reset()
def setworldcoordinates(self, llx, lly, urx, ury):
"""Set up a user defined coordinate-system.
Arguments:
llx -- a number, x-coordinate of lower left corner of canvas
lly -- a number, y-coordinate of lower left corner of canvas
urx -- a number, x-coordinate of upper right corner of canvas
ury -- a number, y-coordinate of upper right corner of canvas
Set up user coodinat-system and switch to mode 'world' if necessary.
This performs a screen.reset. If mode 'world' is already active,
all drawings are redrawn according to the new coordinates.
But ATTENTION: in user-defined coordinatesystems angles may appear
distorted. (see Screen.mode())
Example (for a TurtleScreen instance named screen):
>>> screen.setworldcoordinates(-10,-0.5,50,1.5)
>>> for _ in range(36):
... left(10)
... forward(0.5)
"""
if self.mode() != "world":
self.mode("world")
xspan = float(urx - llx)
yspan = float(ury - lly)
wx, wy = self._window_size()
self.screensize(wx-20, wy-20)
oldxscale, oldyscale = self.xscale, self.yscale
self.xscale = self.canvwidth / xspan
self.yscale = self.canvheight / yspan
srx1 = llx * self.xscale
sry1 = -ury * self.yscale
srx2 = self.canvwidth + srx1
sry2 = self.canvheight + sry1
self._setscrollregion(srx1, sry1, srx2, sry2)
self._rescale(self.xscale/oldxscale, self.yscale/oldyscale)
self.update()
def register_shape(self, name, shape=None):
"""Adds a turtle shape to TurtleScreen's shapelist.
Arguments:
(1) name is the name of a gif-file and shape is None.
Installs the corresponding image shape.
!! Image-shapes DO NOT rotate when turning the turtle,
!! so they do not display the heading of the turtle!
(2) name is an arbitrary string and shape is a tuple
of pairs of coordinates. Installs the corresponding
polygon shape
(3) name is an arbitrary string and shape is a
(compound) Shape object. Installs the corresponding
compound shape.
To use a shape, you have to issue the command shape(shapename).
call: register_shape("turtle.gif")
--or: register_shape("tri", ((0,0), (10,10), (-10,10)))
Example (for a TurtleScreen instance named screen):
>>> screen.register_shape("triangle", ((5,-3),(0,5),(-5,-3)))
"""
if shape is None:
# image
if name.lower().endswith(".gif"):
shape = Shape("image", self._image(name))
else:
raise TurtleGraphicsError("Bad arguments for register_shape.\n"
+ "Use help(register_shape)" )
elif isinstance(shape, tuple):
shape = Shape("polygon", shape)
## else shape assumed to be Shape-instance
self._shapes[name] = shape
# print "shape added:" , self._shapes
def _colorstr(self, color):
"""Return color string corresponding to args.
Argument may be a string or a tuple of three
numbers corresponding to actual colormode,
i.e. in the range 0<=n<=colormode.
If the argument doesn't represent a color,
an error is raised.
"""
if len(color) == 1:
color = color[0]
if isinstance(color, basestring):
if self._iscolorstring(color) or color == "":
return color
else:
raise TurtleGraphicsError("bad color string: %s" % str(color))
try:
r, g, b = color
except (TypeError, ValueError):
raise TurtleGraphicsError("bad color arguments: %s" % str(color))
if self._colormode == 1.0:
r, g, b = [round(255.0*x) for x in (r, g, b)]
if not ((0 <= r <= 255) and (0 <= g <= 255) and (0 <= b <= 255)):
raise TurtleGraphicsError("bad color sequence: %s" % str(color))
return "#%02x%02x%02x" % (r, g, b)
def _color(self, cstr):
if not cstr.startswith("#"):
return cstr
if len(cstr) == 7:
cl = [int(cstr[i:i+2], 16) for i in (1, 3, 5)]
elif len(cstr) == 4:
cl = [16*int(cstr[h], 16) for h in cstr[1:]]
else:
raise TurtleGraphicsError("bad colorstring: %s" % cstr)
return tuple([c * self._colormode/255 for c in cl])
def colormode(self, cmode=None):
"""Return the colormode or set it to 1.0 or 255.
Optional argument:
cmode -- one of the values 1.0 or 255
r, g, b values of colortriples have to be in range 0..cmode.
Example (for a TurtleScreen instance named screen):
>>> screen.colormode()
1.0
>>> screen.colormode(255)
>>> pencolor(240,160,80)
"""
if cmode is None:
return self._colormode
if cmode == 1.0:
self._colormode = float(cmode)
elif cmode == 255:
self._colormode = int(cmode)
def reset(self):
"""Reset all Turtles on the Screen to their initial state.
No argument.
Example (for a TurtleScreen instance named screen):
>>> screen.reset()
"""
for turtle in self._turtles:
turtle._setmode(self._mode)
turtle.reset()
def turtles(self):
"""Return the list of turtles on the screen.
Example (for a TurtleScreen instance named screen):
>>> screen.turtles()
[<turtle.Turtle object at 0x00E11FB0>]
"""
return self._turtles
def bgcolor(self, *args):
"""Set or return backgroundcolor of the TurtleScreen.
Arguments (if given): a color string or three numbers
in the range 0..colormode or a 3-tuple of such numbers.
Example (for a TurtleScreen instance named screen):
>>> screen.bgcolor("orange")
>>> screen.bgcolor()
'orange'
>>> screen.bgcolor(0.5,0,0.5)
>>> screen.bgcolor()
'#800080'
"""
if args:
color = self._colorstr(args)
else:
color = None
color = self._bgcolor(color)
if color is not None:
color = self._color(color)
return color
def tracer(self, n=None, delay=None):
"""Turns turtle animation on/off and set delay for update drawings.
Optional arguments:
n -- nonnegative integer
delay -- nonnegative integer
If n is given, only each n-th regular screen update is really performed.
(Can be used to accelerate the drawing of complex graphics.)
Second arguments sets delay value (see RawTurtle.delay())
Example (for a TurtleScreen instance named screen):
>>> screen.tracer(8, 25)
>>> dist = 2
>>> for i in range(200):
... fd(dist)
... rt(90)
... dist += 2
"""
if n is None:
return self._tracing
self._tracing = int(n)
self._updatecounter = 0
if delay is not None:
self._delayvalue = int(delay)
if self._tracing:
self.update()
def delay(self, delay=None):
""" Return or set the drawing delay in milliseconds.
Optional argument:
delay -- positive integer
Example (for a TurtleScreen instance named screen):
>>> screen.delay(15)
>>> screen.delay()
15
"""
if delay is None:
return self._delayvalue
self._delayvalue = int(delay)
def _incrementudc(self):
"""Increment update counter."""
if not TurtleScreen._RUNNING:
TurtleScreen._RUNNING = True
raise Terminator
if self._tracing > 0:
self._updatecounter += 1
self._updatecounter %= self._tracing
def update(self):
"""Perform a TurtleScreen update.
"""
tracing = self._tracing
self._tracing = True
for t in self.turtles():
t._update_data()
t._drawturtle()
self._tracing = tracing
self._update()
def window_width(self):
""" Return the width of the turtle window.
Example (for a TurtleScreen instance named screen):
>>> screen.window_width()
640
"""
return self._window_size()[0]
def window_height(self):
""" Return the height of the turtle window.
Example (for a TurtleScreen instance named screen):
>>> screen.window_height()
480
"""
return self._window_size()[1]
def getcanvas(self):
"""Return the Canvas of this TurtleScreen.
No argument.
Example (for a Screen instance named screen):
>>> cv = screen.getcanvas()
>>> cv
<turtle.ScrolledCanvas instance at 0x010742D8>
"""
return self.cv
def getshapes(self):
"""Return a list of names of all currently available turtle shapes.
No argument.
Example (for a TurtleScreen instance named screen):
>>> screen.getshapes()
['arrow', 'blank', 'circle', ... , 'turtle']
"""
return sorted(self._shapes.keys())
def onclick(self, fun, btn=1, add=None):
"""Bind fun to mouse-click event on canvas.
Arguments:
fun -- a function with two arguments, the coordinates of the
clicked point on the canvas.
btn -- the number of the mouse-button, defaults to 1
Example (for a TurtleScreen instance named screen
and a Turtle instance named turtle):
>>> screen.onclick(goto)
>>> # Subsequently clicking into the TurtleScreen will
>>> # make the turtle move to the clicked point.
>>> screen.onclick(None)
"""
self._onscreenclick(fun, btn, add)
def onkey(self, fun, key):
"""Bind fun to key-release event of key.
Arguments:
fun -- a function with no arguments
key -- a string: key (e.g. "a") or key-symbol (e.g. "space")
In order to be able to register key-events, TurtleScreen
must have focus. (See method listen.)
Example (for a TurtleScreen instance named screen):
>>> def f():
... fd(50)
... lt(60)
...
>>> screen.onkey(f, "Up")
>>> screen.listen()
Subsequently the turtle can be moved by repeatedly pressing
the up-arrow key, consequently drawing a hexagon
"""
if fun is None:
if key in self._keys:
self._keys.remove(key)
elif key not in self._keys:
self._keys.append(key)
self._onkey(fun, key)
def listen(self, xdummy=None, ydummy=None):
"""Set focus on TurtleScreen (in order to collect key-events)
No arguments.
Dummy arguments are provided in order
to be able to pass listen to the onclick method.
Example (for a TurtleScreen instance named screen):
>>> screen.listen()
"""
self._listen()
def ontimer(self, fun, t=0):
"""Install a timer, which calls fun after t milliseconds.
Arguments:
fun -- a function with no arguments.
t -- a number >= 0
Example (for a TurtleScreen instance named screen):
>>> running = True
>>> def f():
... if running:
... fd(50)
... lt(60)
... screen.ontimer(f, 250)
...
>>> f() # makes the turtle marching around
>>> running = False
"""
self._ontimer(fun, t)
def bgpic(self, picname=None):
"""Set background image or return name of current backgroundimage.
Optional argument:
picname -- a string, name of a gif-file or "nopic".
If picname is a filename, set the corresponding image as background.
If picname is "nopic", delete backgroundimage, if present.
If picname is None, return the filename of the current backgroundimage.
Example (for a TurtleScreen instance named screen):
>>> screen.bgpic()
'nopic'
>>> screen.bgpic("landscape.gif")
>>> screen.bgpic()
'landscape.gif'
"""
if picname is None:
return self._bgpicname
if picname not in self._bgpics:
self._bgpics[picname] = self._image(picname)
self._setbgpic(self._bgpic, self._bgpics[picname])
self._bgpicname = picname
def screensize(self, canvwidth=None, canvheight=None, bg=None):
"""Resize the canvas the turtles are drawing on.
Optional arguments:
canvwidth -- positive integer, new width of canvas in pixels
canvheight -- positive integer, new height of canvas in pixels
bg -- colorstring or color-tuple, new backgroundcolor
If no arguments are given, return current (canvaswidth, canvasheight)
Do not alter the drawing window. To observe hidden parts of
the canvas use the scrollbars. (Can make visible those parts
of a drawing, which were outside the canvas before!)
Example (for a Turtle instance named turtle):
>>> turtle.screensize(2000,1500)
>>> # e. g. to search for an erroneously escaped turtle ;-)
"""
return self._resize(canvwidth, canvheight, bg)
onscreenclick = onclick
resetscreen = reset
clearscreen = clear
addshape = register_shape
class TNavigator(object):
"""Navigation part of the RawTurtle.
Implements methods for turtle movement.
"""
START_ORIENTATION = {
"standard": Vec2D(1.0, 0.0),
"world" : Vec2D(1.0, 0.0),
"logo" : Vec2D(0.0, 1.0) }
DEFAULT_MODE = "standard"
DEFAULT_ANGLEOFFSET = 0
DEFAULT_ANGLEORIENT = 1
def __init__(self, mode=DEFAULT_MODE):
self._angleOffset = self.DEFAULT_ANGLEOFFSET
self._angleOrient = self.DEFAULT_ANGLEORIENT
self._mode = mode
self.undobuffer = None
self.degrees()
self._mode = None
self._setmode(mode)
TNavigator.reset(self)
def reset(self):
"""reset turtle to its initial values
Will be overwritten by parent class
"""
self._position = Vec2D(0.0, 0.0)
self._orient = TNavigator.START_ORIENTATION[self._mode]
def _setmode(self, mode=None):
"""Set turtle-mode to 'standard', 'world' or 'logo'.
"""
if mode is None:
return self._mode
if mode not in ["standard", "logo", "world"]:
return
self._mode = mode
if mode in ["standard", "world"]:
self._angleOffset = 0
self._angleOrient = 1
else: # mode == "logo":
self._angleOffset = self._fullcircle/4.
self._angleOrient = -1
def _setDegreesPerAU(self, fullcircle):
"""Helper function for degrees() and radians()"""
self._fullcircle = fullcircle
self._degreesPerAU = 360/fullcircle
if self._mode == "standard":
self._angleOffset = 0
else:
self._angleOffset = fullcircle/4.
def degrees(self, fullcircle=360.0):
""" Set angle measurement units to degrees.
Optional argument:
fullcircle - a number
Set angle measurement units, i. e. set number
of 'degrees' for a full circle. Dafault value is
360 degrees.
Example (for a Turtle instance named turtle):
>>> turtle.left(90)
>>> turtle.heading()
90
Change angle measurement unit to grad (also known as gon,
grade, or gradian and equals 1/100-th of the right angle.)
>>> turtle.degrees(400.0)
>>> turtle.heading()
100
"""
self._setDegreesPerAU(fullcircle)
def radians(self):
""" Set the angle measurement units to radians.
No arguments.
Example (for a Turtle instance named turtle):
>>> turtle.heading()
90
>>> turtle.radians()
>>> turtle.heading()
1.5707963267948966
"""
self._setDegreesPerAU(2*math.pi)
def _go(self, distance):
"""move turtle forward by specified distance"""
ende = self._position + self._orient * distance
self._goto(ende)
def _rotate(self, angle):
"""Turn turtle counterclockwise by specified angle if angle > 0."""
angle *= self._degreesPerAU
self._orient = self._orient.rotate(angle)
def _goto(self, end):
"""move turtle to position end."""
self._position = end
def forward(self, distance):
"""Move the turtle forward by the specified distance.
Aliases: forward | fd
Argument:
distance -- a number (integer or float)
Move the turtle forward by the specified distance, in the direction
the turtle is headed.
Example (for a Turtle instance named turtle):
>>> turtle.position()
(0.00, 0.00)
>>> turtle.forward(25)
>>> turtle.position()
(25.00,0.00)
>>> turtle.forward(-75)
>>> turtle.position()
(-50.00,0.00)
"""
self._go(distance)
def back(self, distance):
"""Move the turtle backward by distance.
Aliases: back | backward | bk
Argument:
distance -- a number
Move the turtle backward by distance ,opposite to the direction the
turtle is headed. Do not change the turtle's heading.
Example (for a Turtle instance named turtle):
>>> turtle.position()
(0.00, 0.00)
>>> turtle.backward(30)
>>> turtle.position()
(-30.00, 0.00)
"""
self._go(-distance)
def right(self, angle):
"""Turn turtle right by angle units.
Aliases: right | rt
Argument:
angle -- a number (integer or float)
Turn turtle right by angle units. (Units are by default degrees,
but can be set via the degrees() and radians() functions.)
Angle orientation depends on mode. (See this.)
Example (for a Turtle instance named turtle):
>>> turtle.heading()
22.0
>>> turtle.right(45)
>>> turtle.heading()
337.0
"""
self._rotate(-angle)
def left(self, angle):
"""Turn turtle left by angle units.
Aliases: left | lt
Argument:
angle -- a number (integer or float)
Turn turtle left by angle units. (Units are by default degrees,
but can be set via the degrees() and radians() functions.)
Angle orientation depends on mode. (See this.)
Example (for a Turtle instance named turtle):
>>> turtle.heading()
22.0
>>> turtle.left(45)
>>> turtle.heading()
67.0
"""
self._rotate(angle)
def pos(self):
"""Return the turtle's current location (x,y), as a Vec2D-vector.
Aliases: pos | position
No arguments.
Example (for a Turtle instance named turtle):
>>> turtle.pos()
(0.00, 240.00)
"""
return self._position
def xcor(self):
""" Return the turtle's x coordinate.
No arguments.
Example (for a Turtle instance named turtle):
>>> reset()
>>> turtle.left(60)
>>> turtle.forward(100)
>>> print turtle.xcor()
50.0
"""
return self._position[0]
def ycor(self):
""" Return the turtle's y coordinate
---
No arguments.
Example (for a Turtle instance named turtle):
>>> reset()
>>> turtle.left(60)
>>> turtle.forward(100)
>>> print turtle.ycor()
86.6025403784
"""
return self._position[1]
def goto(self, x, y=None):
"""Move turtle to an absolute position.
Aliases: setpos | setposition | goto:
Arguments:
x -- a number or a pair/vector of numbers
y -- a number None
call: goto(x, y) # two coordinates
--or: goto((x, y)) # a pair (tuple) of coordinates
--or: goto(vec) # e.g. as returned by pos()
Move turtle to an absolute position. If the pen is down,
a line will be drawn. The turtle's orientation does not change.
Example (for a Turtle instance named turtle):
>>> tp = turtle.pos()
>>> tp
(0.00, 0.00)
>>> turtle.setpos(60,30)
>>> turtle.pos()
(60.00,30.00)
>>> turtle.setpos((20,80))
>>> turtle.pos()
(20.00,80.00)
>>> turtle.setpos(tp)
>>> turtle.pos()
(0.00,0.00)
"""
if y is None:
self._goto(Vec2D(*x))
else:
self._goto(Vec2D(x, y))
def home(self):
"""Move turtle to the origin - coordinates (0,0).
No arguments.
Move turtle to the origin - coordinates (0,0) and set its
heading to its start-orientation (which depends on mode).
Example (for a Turtle instance named turtle):
>>> turtle.home()
"""
self.goto(0, 0)
self.setheading(0)
def setx(self, x):
"""Set the turtle's first coordinate to x
Argument:
x -- a number (integer or float)
Set the turtle's first coordinate to x, leave second coordinate
unchanged.
Example (for a Turtle instance named turtle):
>>> turtle.position()
(0.00, 240.00)
>>> turtle.setx(10)
>>> turtle.position()
(10.00, 240.00)
"""
self._goto(Vec2D(x, self._position[1]))
def sety(self, y):
"""Set the turtle's second coordinate to y
Argument:
y -- a number (integer or float)
Set the turtle's first coordinate to x, second coordinate remains
unchanged.
Example (for a Turtle instance named turtle):
>>> turtle.position()
(0.00, 40.00)
>>> turtle.sety(-10)
>>> turtle.position()
(0.00, -10.00)
"""
self._goto(Vec2D(self._position[0], y))
def distance(self, x, y=None):
"""Return the distance from the turtle to (x,y) in turtle step units.
Arguments:
x -- a number or a pair/vector of numbers or a turtle instance
y -- a number None None
call: distance(x, y) # two coordinates
--or: distance((x, y)) # a pair (tuple) of coordinates
--or: distance(vec) # e.g. as returned by pos()
--or: distance(mypen) # where mypen is another turtle
Example (for a Turtle instance named turtle):
>>> turtle.pos()
(0.00, 0.00)
>>> turtle.distance(30,40)
50.0
>>> pen = Turtle()
>>> pen.forward(77)
>>> turtle.distance(pen)
77.0
"""
if y is not None:
pos = Vec2D(x, y)
if isinstance(x, Vec2D):
pos = x
elif isinstance(x, tuple):
pos = Vec2D(*x)
elif isinstance(x, TNavigator):
pos = x._position
return abs(pos - self._position)
def towards(self, x, y=None):
"""Return the angle of the line from the turtle's position to (x, y).
Arguments:
x -- a number or a pair/vector of numbers or a turtle instance
y -- a number None None
call: distance(x, y) # two coordinates
--or: distance((x, y)) # a pair (tuple) of coordinates
--or: distance(vec) # e.g. as returned by pos()
--or: distance(mypen) # where mypen is another turtle
Return the angle, between the line from turtle-position to position
specified by x, y and the turtle's start orientation. (Depends on
modes - "standard" or "logo")
Example (for a Turtle instance named turtle):
>>> turtle.pos()
(10.00, 10.00)
>>> turtle.towards(0,0)
225.0
"""
if y is not None:
pos = Vec2D(x, y)
if isinstance(x, Vec2D):
pos = x
elif isinstance(x, tuple):
pos = Vec2D(*x)
elif isinstance(x, TNavigator):
pos = x._position
x, y = pos - self._position
result = round(math.atan2(y, x)*180.0/math.pi, 10) % 360.0
result /= self._degreesPerAU
return (self._angleOffset + self._angleOrient*result) % self._fullcircle
def heading(self):
""" Return the turtle's current heading.
No arguments.
Example (for a Turtle instance named turtle):
>>> turtle.left(67)
>>> turtle.heading()
67.0
"""
x, y = self._orient
result = round(math.atan2(y, x)*180.0/math.pi, 10) % 360.0
result /= self._degreesPerAU
return (self._angleOffset + self._angleOrient*result) % self._fullcircle
def setheading(self, to_angle):
"""Set the orientation of the turtle to to_angle.
Aliases: setheading | seth
Argument:
to_angle -- a number (integer or float)
Set the orientation of the turtle to to_angle.
Here are some common directions in degrees:
standard - mode: logo-mode:
-------------------|--------------------
0 - east 0 - north
90 - north 90 - east
180 - west 180 - south
270 - south 270 - west
Example (for a Turtle instance named turtle):
>>> turtle.setheading(90)
>>> turtle.heading()
90
"""
angle = (to_angle - self.heading())*self._angleOrient
full = self._fullcircle
angle = (angle+full/2.)%full - full/2.
self._rotate(angle)
def circle(self, radius, extent = None, steps = None):
""" Draw a circle with given radius.
Arguments:
radius -- a number
extent (optional) -- a number
steps (optional) -- an integer
Draw a circle with given radius. The center is radius units left
of the turtle; extent - an angle - determines which part of the
circle is drawn. If extent is not given, draw the entire circle.
If extent is not a full circle, one endpoint of the arc is the
current pen position. Draw the arc in counterclockwise direction
if radius is positive, otherwise in clockwise direction. Finally
the direction of the turtle is changed by the amount of extent.
As the circle is approximated by an inscribed regular polygon,
steps determines the number of steps to use. If not given,
it will be calculated automatically. Maybe used to draw regular
polygons.
call: circle(radius) # full circle
--or: circle(radius, extent) # arc
--or: circle(radius, extent, steps)
--or: circle(radius, steps=6) # 6-sided polygon
Example (for a Turtle instance named turtle):
>>> turtle.circle(50)
>>> turtle.circle(120, 180) # semicircle
"""
if self.undobuffer:
self.undobuffer.push(["seq"])
self.undobuffer.cumulate = True
speed = self.speed()
if extent is None:
extent = self._fullcircle
if steps is None:
frac = abs(extent)/self._fullcircle
steps = 1+int(min(11+abs(radius)/6.0, 59.0)*frac)
w = 1.0 * extent / steps
w2 = 0.5 * w
l = 2.0 * radius * math.sin(w2*math.pi/180.0*self._degreesPerAU)
if radius < 0:
l, w, w2 = -l, -w, -w2
tr = self.tracer()
dl = self._delay()
if speed == 0:
self.tracer(0, 0)
else:
self.speed(0)
self._rotate(w2)
for i in range(steps):
self.speed(speed)
self._go(l)
self.speed(0)
self._rotate(w)
self._rotate(-w2)
if speed == 0:
self.tracer(tr, dl)
self.speed(speed)
if self.undobuffer:
self.undobuffer.cumulate = False
## three dummy methods to be implemented by child class:
def speed(self, s=0):
"""dummy method - to be overwritten by child class"""
def tracer(self, a=None, b=None):
"""dummy method - to be overwritten by child class"""
def _delay(self, n=None):
"""dummy method - to be overwritten by child class"""
fd = forward
bk = back
backward = back
rt = right
lt = left
position = pos
setpos = goto
setposition = goto
seth = setheading
class TPen(object):
"""Drawing part of the RawTurtle.
Implements drawing properties.
"""
def __init__(self, resizemode=_CFG["resizemode"]):
self._resizemode = resizemode # or "user" or "noresize"
self.undobuffer = None
TPen._reset(self)
def _reset(self, pencolor=_CFG["pencolor"],
fillcolor=_CFG["fillcolor"]):
self._pensize = 1
self._shown = True
self._pencolor = pencolor
self._fillcolor = fillcolor
self._drawing = True
self._speed = 3
self._stretchfactor = (1, 1)
self._tilt = 0
self._outlinewidth = 1
### self.screen = None # to override by child class
def resizemode(self, rmode=None):
"""Set resizemode to one of the values: "auto", "user", "noresize".
(Optional) Argument:
rmode -- one of the strings "auto", "user", "noresize"
Different resizemodes have the following effects:
- "auto" adapts the appearance of the turtle
corresponding to the value of pensize.
- "user" adapts the appearance of the turtle according to the
values of stretchfactor and outlinewidth (outline),
which are set by shapesize()
- "noresize" no adaption of the turtle's appearance takes place.
If no argument is given, return current resizemode.
resizemode("user") is called by a call of shapesize with arguments.
Examples (for a Turtle instance named turtle):
>>> turtle.resizemode("noresize")
>>> turtle.resizemode()
'noresize'
"""
if rmode is None:
return self._resizemode
rmode = rmode.lower()
if rmode in ["auto", "user", "noresize"]:
self.pen(resizemode=rmode)
def pensize(self, width=None):
"""Set or return the line thickness.
Aliases: pensize | width
Argument:
width -- positive number
Set the line thickness to width or return it. If resizemode is set
to "auto" and turtleshape is a polygon, that polygon is drawn with
the same line thickness. If no argument is given, current pensize
is returned.
Example (for a Turtle instance named turtle):
>>> turtle.pensize()
1
>>> turtle.pensize(10) # from here on lines of width 10 are drawn
"""
if width is None:
return self._pensize
self.pen(pensize=width)
def penup(self):
"""Pull the pen up -- no drawing when moving.
Aliases: penup | pu | up
No argument
Example (for a Turtle instance named turtle):
>>> turtle.penup()
"""
if not self._drawing:
return
self.pen(pendown=False)
def pendown(self):
"""Pull the pen down -- drawing when moving.
Aliases: pendown | pd | down
No argument.
Example (for a Turtle instance named turtle):
>>> turtle.pendown()
"""
if self._drawing:
return
self.pen(pendown=True)
def isdown(self):
"""Return True if pen is down, False if it's up.
No argument.
Example (for a Turtle instance named turtle):
>>> turtle.penup()
>>> turtle.isdown()
False
>>> turtle.pendown()
>>> turtle.isdown()
True
"""
return self._drawing
def speed(self, speed=None):
""" Return or set the turtle's speed.
Optional argument:
speed -- an integer in the range 0..10 or a speedstring (see below)
Set the turtle's speed to an integer value in the range 0 .. 10.
If no argument is given: return current speed.
If input is a number greater than 10 or smaller than 0.5,
speed is set to 0.
Speedstrings are mapped to speedvalues in the following way:
'fastest' : 0
'fast' : 10
'normal' : 6
'slow' : 3
'slowest' : 1
speeds from 1 to 10 enforce increasingly faster animation of
line drawing and turtle turning.
Attention:
speed = 0 : *no* animation takes place. forward/back makes turtle jump
and likewise left/right make the turtle turn instantly.
Example (for a Turtle instance named turtle):
>>> turtle.speed(3)
"""
speeds = {'fastest':0, 'fast':10, 'normal':6, 'slow':3, 'slowest':1 }
if speed is None:
return self._speed
if speed in speeds:
speed = speeds[speed]
elif 0.5 < speed < 10.5:
speed = int(round(speed))
else:
speed = 0
self.pen(speed=speed)
def color(self, *args):
"""Return or set the pencolor and fillcolor.
Arguments:
Several input formats are allowed.
They use 0, 1, 2, or 3 arguments as follows:
color()
Return the current pencolor and the current fillcolor
as a pair of color specification strings as are returned
by pencolor and fillcolor.
color(colorstring), color((r,g,b)), color(r,g,b)
inputs as in pencolor, set both, fillcolor and pencolor,
to the given value.
color(colorstring1, colorstring2),
color((r1,g1,b1), (r2,g2,b2))
equivalent to pencolor(colorstring1) and fillcolor(colorstring2)
and analogously, if the other input format is used.
If turtleshape is a polygon, outline and interior of that polygon
is drawn with the newly set colors.
For mor info see: pencolor, fillcolor
Example (for a Turtle instance named turtle):
>>> turtle.color('red', 'green')
>>> turtle.color()
('red', 'green')
>>> colormode(255)
>>> color((40, 80, 120), (160, 200, 240))
>>> color()
('#285078', '#a0c8f0')
"""
if args:
l = len(args)
if l == 1:
pcolor = fcolor = args[0]
elif l == 2:
pcolor, fcolor = args
elif l == 3:
pcolor = fcolor = args
pcolor = self._colorstr(pcolor)
fcolor = self._colorstr(fcolor)
self.pen(pencolor=pcolor, fillcolor=fcolor)
else:
return self._color(self._pencolor), self._color(self._fillcolor)
def pencolor(self, *args):
""" Return or set the pencolor.
Arguments:
Four input formats are allowed:
- pencolor()
Return the current pencolor as color specification string,
possibly in hex-number format (see example).
May be used as input to another color/pencolor/fillcolor call.
- pencolor(colorstring)
s is a Tk color specification string, such as "red" or "yellow"
- pencolor((r, g, b))
*a tuple* of r, g, and b, which represent, an RGB color,
and each of r, g, and b are in the range 0..colormode,
where colormode is either 1.0 or 255
- pencolor(r, g, b)
r, g, and b represent an RGB color, and each of r, g, and b
are in the range 0..colormode
If turtleshape is a polygon, the outline of that polygon is drawn
with the newly set pencolor.
Example (for a Turtle instance named turtle):
>>> turtle.pencolor('brown')
>>> tup = (0.2, 0.8, 0.55)
>>> turtle.pencolor(tup)
>>> turtle.pencolor()
'#33cc8c'
"""
if args:
color = self._colorstr(args)
if color == self._pencolor:
return
self.pen(pencolor=color)
else:
return self._color(self._pencolor)
def fillcolor(self, *args):
""" Return or set the fillcolor.
Arguments:
Four input formats are allowed:
- fillcolor()
Return the current fillcolor as color specification string,
possibly in hex-number format (see example).
May be used as input to another color/pencolor/fillcolor call.
- fillcolor(colorstring)
s is a Tk color specification string, such as "red" or "yellow"
- fillcolor((r, g, b))
*a tuple* of r, g, and b, which represent, an RGB color,
and each of r, g, and b are in the range 0..colormode,
where colormode is either 1.0 or 255
- fillcolor(r, g, b)
r, g, and b represent an RGB color, and each of r, g, and b
are in the range 0..colormode
If turtleshape is a polygon, the interior of that polygon is drawn
with the newly set fillcolor.
Example (for a Turtle instance named turtle):
>>> turtle.fillcolor('violet')
>>> col = turtle.pencolor()
>>> turtle.fillcolor(col)
>>> turtle.fillcolor(0, .5, 0)
"""
if args:
color = self._colorstr(args)
if color == self._fillcolor:
return
self.pen(fillcolor=color)
else:
return self._color(self._fillcolor)
def showturtle(self):
"""Makes the turtle visible.
Aliases: showturtle | st
No argument.
Example (for a Turtle instance named turtle):
>>> turtle.hideturtle()
>>> turtle.showturtle()
"""
self.pen(shown=True)
def hideturtle(self):
"""Makes the turtle invisible.
Aliases: hideturtle | ht
No argument.
It's a good idea to do this while you're in the
middle of a complicated drawing, because hiding
the turtle speeds up the drawing observably.
Example (for a Turtle instance named turtle):
>>> turtle.hideturtle()
"""
self.pen(shown=False)
def isvisible(self):
"""Return True if the Turtle is shown, False if it's hidden.
No argument.
Example (for a Turtle instance named turtle):
>>> turtle.hideturtle()
>>> print turtle.isvisible():
False
"""
return self._shown
def pen(self, pen=None, **pendict):
"""Return or set the pen's attributes.
Arguments:
pen -- a dictionary with some or all of the below listed keys.
**pendict -- one or more keyword-arguments with the below
listed keys as keywords.
Return or set the pen's attributes in a 'pen-dictionary'
with the following key/value pairs:
"shown" : True/False
"pendown" : True/False
"pencolor" : color-string or color-tuple
"fillcolor" : color-string or color-tuple
"pensize" : positive number
"speed" : number in range 0..10
"resizemode" : "auto" or "user" or "noresize"
"stretchfactor": (positive number, positive number)
"outline" : positive number
"tilt" : number
This dictionary can be used as argument for a subsequent
pen()-call to restore the former pen-state. Moreover one
or more of these attributes can be provided as keyword-arguments.
This can be used to set several pen attributes in one statement.
Examples (for a Turtle instance named turtle):
>>> turtle.pen(fillcolor="black", pencolor="red", pensize=10)
>>> turtle.pen()
{'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,
'pencolor': 'red', 'pendown': True, 'fillcolor': 'black',
'stretchfactor': (1,1), 'speed': 3}
>>> penstate=turtle.pen()
>>> turtle.color("yellow","")
>>> turtle.penup()
>>> turtle.pen()
{'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,
'pencolor': 'yellow', 'pendown': False, 'fillcolor': '',
'stretchfactor': (1,1), 'speed': 3}
>>> p.pen(penstate, fillcolor="green")
>>> p.pen()
{'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,
'pencolor': 'red', 'pendown': True, 'fillcolor': 'green',
'stretchfactor': (1,1), 'speed': 3}
"""
_pd = {"shown" : self._shown,
"pendown" : self._drawing,
"pencolor" : self._pencolor,
"fillcolor" : self._fillcolor,
"pensize" : self._pensize,
"speed" : self._speed,
"resizemode" : self._resizemode,
"stretchfactor" : self._stretchfactor,
"outline" : self._outlinewidth,
"tilt" : self._tilt
}
if not (pen or pendict):
return _pd
if isinstance(pen, dict):
p = pen
else:
p = {}
p.update(pendict)
_p_buf = {}
for key in p:
_p_buf[key] = _pd[key]
if self.undobuffer:
self.undobuffer.push(("pen", _p_buf))
newLine = False
if "pendown" in p:
if self._drawing != p["pendown"]:
newLine = True
if "pencolor" in p:
if isinstance(p["pencolor"], tuple):
p["pencolor"] = self._colorstr((p["pencolor"],))
if self._pencolor != p["pencolor"]:
newLine = True
if "pensize" in p:
if self._pensize != p["pensize"]:
newLine = True
if newLine:
self._newLine()
if "pendown" in p:
self._drawing = p["pendown"]
if "pencolor" in p:
self._pencolor = p["pencolor"]
if "pensize" in p:
self._pensize = p["pensize"]
if "fillcolor" in p:
if isinstance(p["fillcolor"], tuple):
p["fillcolor"] = self._colorstr((p["fillcolor"],))
self._fillcolor = p["fillcolor"]
if "speed" in p:
self._speed = p["speed"]
if "resizemode" in p:
self._resizemode = p["resizemode"]
if "stretchfactor" in p:
sf = p["stretchfactor"]
if isinstance(sf, (int, long, float)):
sf = (sf, sf)
self._stretchfactor = sf
if "outline" in p:
self._outlinewidth = p["outline"]
if "shown" in p:
self._shown = p["shown"]
if "tilt" in p:
self._tilt = p["tilt"]
self._update()
## three dummy methods to be implemented by child class:
def _newLine(self, usePos = True):
"""dummy method - to be overwritten by child class"""
def _update(self, count=True, forced=False):
"""dummy method - to be overwritten by child class"""
def _color(self, args):
"""dummy method - to be overwritten by child class"""
def _colorstr(self, args):
"""dummy method - to be overwritten by child class"""
width = pensize
up = penup
pu = penup
pd = pendown
down = pendown
st = showturtle
ht = hideturtle
class _TurtleImage(object):
"""Helper class: Datatype to store Turtle attributes
"""
def __init__(self, screen, shapeIndex):
self.screen = screen
self._type = None
self._setshape(shapeIndex)
def _setshape(self, shapeIndex):
screen = self.screen # RawTurtle.screens[self.screenIndex]
self.shapeIndex = shapeIndex
if self._type == "polygon" == screen._shapes[shapeIndex]._type:
return
if self._type == "image" == screen._shapes[shapeIndex]._type:
return
if self._type in ["image", "polygon"]:
screen._delete(self._item)
elif self._type == "compound":
for item in self._item:
screen._delete(item)
self._type = screen._shapes[shapeIndex]._type
if self._type == "polygon":
self._item = screen._createpoly()
elif self._type == "image":
self._item = screen._createimage(screen._shapes["blank"]._data)
elif self._type == "compound":
self._item = [screen._createpoly() for item in
screen._shapes[shapeIndex]._data]
class RawTurtle(TPen, TNavigator):
"""Animation part of the RawTurtle.
Puts RawTurtle upon a TurtleScreen and provides tools for
its animation.
"""
screens = []
def __init__(self, canvas=None,
shape=_CFG["shape"],
undobuffersize=_CFG["undobuffersize"],
visible=_CFG["visible"]):
if isinstance(canvas, _Screen):
self.screen = canvas
elif isinstance(canvas, TurtleScreen):
if canvas not in RawTurtle.screens:
RawTurtle.screens.append(canvas)
self.screen = canvas
elif isinstance(canvas, (ScrolledCanvas, Canvas)):
for screen in RawTurtle.screens:
if screen.cv == canvas:
self.screen = screen
break
else:
self.screen = TurtleScreen(canvas)
RawTurtle.screens.append(self.screen)
else:
raise TurtleGraphicsError("bad canvas argument %s" % canvas)
screen = self.screen
TNavigator.__init__(self, screen.mode())
TPen.__init__(self)
screen._turtles.append(self)
self.drawingLineItem = screen._createline()
self.turtle = _TurtleImage(screen, shape)
self._poly = None
self._creatingPoly = False
self._fillitem = self._fillpath = None
self._shown = visible
self._hidden_from_screen = False
self.currentLineItem = screen._createline()
self.currentLine = [self._position]
self.items = [self.currentLineItem]
self.stampItems = []
self._undobuffersize = undobuffersize
self.undobuffer = Tbuffer(undobuffersize)
self._update()
def reset(self):
"""Delete the turtle's drawings and restore its default values.
No argument.
,
Delete the turtle's drawings from the screen, re-center the turtle
and set variables to the default values.
Example (for a Turtle instance named turtle):
>>> turtle.position()
(0.00,-22.00)
>>> turtle.heading()
100.0
>>> turtle.reset()
>>> turtle.position()
(0.00,0.00)
>>> turtle.heading()
0.0
"""
TNavigator.reset(self)
TPen._reset(self)
self._clear()
self._drawturtle()
self._update()
def setundobuffer(self, size):
"""Set or disable undobuffer.
Argument:
size -- an integer or None
If size is an integer an empty undobuffer of given size is installed.
Size gives the maximum number of turtle-actions that can be undone
by the undo() function.
If size is None, no undobuffer is present.
Example (for a Turtle instance named turtle):
>>> turtle.setundobuffer(42)
"""
if size is None or size <= 0:
self.undobuffer = None
else:
self.undobuffer = Tbuffer(size)
def undobufferentries(self):
"""Return count of entries in the undobuffer.
No argument.
Example (for a Turtle instance named turtle):
>>> while undobufferentries():
... undo()
"""
if self.undobuffer is None:
return 0
return self.undobuffer.nr_of_items()
def _clear(self):
"""Delete all of pen's drawings"""
self._fillitem = self._fillpath = None
for item in self.items:
self.screen._delete(item)
self.currentLineItem = self.screen._createline()
self.currentLine = []
if self._drawing:
self.currentLine.append(self._position)
self.items = [self.currentLineItem]
self.clearstamps()
self.setundobuffer(self._undobuffersize)
def clear(self):
"""Delete the turtle's drawings from the screen. Do not move turtle.
No arguments.
Delete the turtle's drawings from the screen. Do not move turtle.
State and position of the turtle as well as drawings of other
turtles are not affected.
Examples (for a Turtle instance named turtle):
>>> turtle.clear()
"""
self._clear()
self._update()
def _update_data(self):
self.screen._incrementudc()
if self.screen._updatecounter != 0:
return
if len(self.currentLine)>1:
self.screen._drawline(self.currentLineItem, self.currentLine,
self._pencolor, self._pensize)
def _update(self):
"""Perform a Turtle-data update.
"""
screen = self.screen
if screen._tracing == 0:
return
elif screen._tracing == 1:
self._update_data()
self._drawturtle()
screen._update() # TurtleScreenBase
screen._delay(screen._delayvalue) # TurtleScreenBase
else:
self._update_data()
if screen._updatecounter == 0:
for t in screen.turtles():
t._drawturtle()
screen._update()
def tracer(self, flag=None, delay=None):
"""Turns turtle animation on/off and set delay for update drawings.
Optional arguments:
n -- nonnegative integer
delay -- nonnegative integer
If n is given, only each n-th regular screen update is really performed.
(Can be used to accelerate the drawing of complex graphics.)
Second arguments sets delay value (see RawTurtle.delay())
Example (for a Turtle instance named turtle):
>>> turtle.tracer(8, 25)
>>> dist = 2
>>> for i in range(200):
... turtle.fd(dist)
... turtle.rt(90)
... dist += 2
"""
return self.screen.tracer(flag, delay)
def _color(self, args):
return self.screen._color(args)
def _colorstr(self, args):
return self.screen._colorstr(args)
def _cc(self, args):
"""Convert colortriples to hexstrings.
"""
if isinstance(args, basestring):
return args
try:
r, g, b = args
except (TypeError, ValueError):
raise TurtleGraphicsError("bad color arguments: %s" % str(args))
if self.screen._colormode == 1.0:
r, g, b = [round(255.0*x) for x in (r, g, b)]
if not ((0 <= r <= 255) and (0 <= g <= 255) and (0 <= b <= 255)):
raise TurtleGraphicsError("bad color sequence: %s" % str(args))
return "#%02x%02x%02x" % (r, g, b)
def clone(self):
"""Create and return a clone of the turtle.
No argument.
Create and return a clone of the turtle with same position, heading
and turtle properties.
Example (for a Turtle instance named mick):
mick = Turtle()
joe = mick.clone()
"""
screen = self.screen
self._newLine(self._drawing)
turtle = self.turtle
self.screen = None
self.turtle = None # too make self deepcopy-able
q = deepcopy(self)
self.screen = screen
self.turtle = turtle
q.screen = screen
q.turtle = _TurtleImage(screen, self.turtle.shapeIndex)
screen._turtles.append(q)
ttype = screen._shapes[self.turtle.shapeIndex]._type
if ttype == "polygon":
q.turtle._item = screen._createpoly()
elif ttype == "image":
q.turtle._item = screen._createimage(screen._shapes["blank"]._data)
elif ttype == "compound":
q.turtle._item = [screen._createpoly() for item in
screen._shapes[self.turtle.shapeIndex]._data]
q.currentLineItem = screen._createline()
q._update()
return q
def shape(self, name=None):
"""Set turtle shape to shape with given name / return current shapename.
Optional argument:
name -- a string, which is a valid shapename
Set turtle shape to shape with given name or, if name is not given,
return name of current shape.
Shape with name must exist in the TurtleScreen's shape dictionary.
Initially there are the following polygon shapes:
'arrow', 'turtle', 'circle', 'square', 'triangle', 'classic'.
To learn about how to deal with shapes see Screen-method register_shape.
Example (for a Turtle instance named turtle):
>>> turtle.shape()
'arrow'
>>> turtle.shape("turtle")
>>> turtle.shape()
'turtle'
"""
if name is None:
return self.turtle.shapeIndex
if not name in self.screen.getshapes():
raise TurtleGraphicsError("There is no shape named %s" % name)
self.turtle._setshape(name)
self._update()
def shapesize(self, stretch_wid=None, stretch_len=None, outline=None):
"""Set/return turtle's stretchfactors/outline. Set resizemode to "user".
Optional arguments:
stretch_wid : positive number
stretch_len : positive number
outline : positive number
Return or set the pen's attributes x/y-stretchfactors and/or outline.
Set resizemode to "user".
If and only if resizemode is set to "user", the turtle will be displayed
stretched according to its stretchfactors:
stretch_wid is stretchfactor perpendicular to orientation
stretch_len is stretchfactor in direction of turtles orientation.
outline determines the width of the shapes's outline.
Examples (for a Turtle instance named turtle):
>>> turtle.resizemode("user")
>>> turtle.shapesize(5, 5, 12)
>>> turtle.shapesize(outline=8)
"""
if stretch_wid is stretch_len is outline is None:
stretch_wid, stretch_len = self._stretchfactor
return stretch_wid, stretch_len, self._outlinewidth
if stretch_wid is not None:
if stretch_len is None:
stretchfactor = stretch_wid, stretch_wid
else:
stretchfactor = stretch_wid, stretch_len
elif stretch_len is not None:
stretchfactor = self._stretchfactor[0], stretch_len
else:
stretchfactor = self._stretchfactor
if outline is None:
outline = self._outlinewidth
self.pen(resizemode="user",
stretchfactor=stretchfactor, outline=outline)
def settiltangle(self, angle):
"""Rotate the turtleshape to point in the specified direction
Optional argument:
angle -- number
Rotate the turtleshape to point in the direction specified by angle,
regardless of its current tilt-angle. DO NOT change the turtle's
heading (direction of movement).
Examples (for a Turtle instance named turtle):
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.settiltangle(45)
>>> stamp()
>>> turtle.fd(50)
>>> turtle.settiltangle(-45)
>>> stamp()
>>> turtle.fd(50)
"""
tilt = -angle * self._degreesPerAU * self._angleOrient
tilt = (tilt * math.pi / 180.0) % (2*math.pi)
self.pen(resizemode="user", tilt=tilt)
def tiltangle(self):
"""Return the current tilt-angle.
No argument.
Return the current tilt-angle, i. e. the angle between the
orientation of the turtleshape and the heading of the turtle
(its direction of movement).
Examples (for a Turtle instance named turtle):
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.tilt(45)
>>> turtle.tiltangle()
"""
tilt = -self._tilt * (180.0/math.pi) * self._angleOrient
return (tilt / self._degreesPerAU) % self._fullcircle
def tilt(self, angle):
"""Rotate the turtleshape by angle.
Argument:
angle - a number
Rotate the turtleshape by angle from its current tilt-angle,
but do NOT change the turtle's heading (direction of movement).
Examples (for a Turtle instance named turtle):
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.tilt(30)
>>> turtle.fd(50)
>>> turtle.tilt(30)
>>> turtle.fd(50)
"""
self.settiltangle(angle + self.tiltangle())
def _polytrafo(self, poly):
"""Computes transformed polygon shapes from a shape
according to current position and heading.
"""
screen = self.screen
p0, p1 = self._position
e0, e1 = self._orient
e = Vec2D(e0, e1 * screen.yscale / screen.xscale)
e0, e1 = (1.0 / abs(e)) * e
return [(p0+(e1*x+e0*y)/screen.xscale, p1+(-e0*x+e1*y)/screen.yscale)
for (x, y) in poly]
def _drawturtle(self):
"""Manages the correct rendering of the turtle with respect to
its shape, resizemode, stretch and tilt etc."""
screen = self.screen
shape = screen._shapes[self.turtle.shapeIndex]
ttype = shape._type
titem = self.turtle._item
if self._shown and screen._updatecounter == 0 and screen._tracing > 0:
self._hidden_from_screen = False
tshape = shape._data
if ttype == "polygon":
if self._resizemode == "noresize":
w = 1
shape = tshape
else:
if self._resizemode == "auto":
lx = ly = max(1, self._pensize/5.0)
w = self._pensize
tiltangle = 0
elif self._resizemode == "user":
lx, ly = self._stretchfactor
w = self._outlinewidth
tiltangle = self._tilt
shape = [(lx*x, ly*y) for (x, y) in tshape]
t0, t1 = math.sin(tiltangle), math.cos(tiltangle)
shape = [(t1*x+t0*y, -t0*x+t1*y) for (x, y) in shape]
shape = self._polytrafo(shape)
fc, oc = self._fillcolor, self._pencolor
screen._drawpoly(titem, shape, fill=fc, outline=oc,
width=w, top=True)
elif ttype == "image":
screen._drawimage(titem, self._position, tshape)
elif ttype == "compound":
lx, ly = self._stretchfactor
w = self._outlinewidth
for item, (poly, fc, oc) in zip(titem, tshape):
poly = [(lx*x, ly*y) for (x, y) in poly]
poly = self._polytrafo(poly)
screen._drawpoly(item, poly, fill=self._cc(fc),
outline=self._cc(oc), width=w, top=True)
else:
if self._hidden_from_screen:
return
if ttype == "polygon":
screen._drawpoly(titem, ((0, 0), (0, 0), (0, 0)), "", "")
elif ttype == "image":
screen._drawimage(titem, self._position,
screen._shapes["blank"]._data)
elif ttype == "compound":
for item in titem:
screen._drawpoly(item, ((0, 0), (0, 0), (0, 0)), "", "")
self._hidden_from_screen = True
############################## stamp stuff ###############################
def stamp(self):
"""Stamp a copy of the turtleshape onto the canvas and return its id.
No argument.
Stamp a copy of the turtle shape onto the canvas at the current
turtle position. Return a stamp_id for that stamp, which can be
used to delete it by calling clearstamp(stamp_id).
Example (for a Turtle instance named turtle):
>>> turtle.color("blue")
>>> turtle.stamp()
13
>>> turtle.fd(50)
"""
screen = self.screen
shape = screen._shapes[self.turtle.shapeIndex]
ttype = shape._type
tshape = shape._data
if ttype == "polygon":
stitem = screen._createpoly()
if self._resizemode == "noresize":
w = 1
shape = tshape
else:
if self._resizemode == "auto":
lx = ly = max(1, self._pensize/5.0)
w = self._pensize
tiltangle = 0
elif self._resizemode == "user":
lx, ly = self._stretchfactor
w = self._outlinewidth
tiltangle = self._tilt
shape = [(lx*x, ly*y) for (x, y) in tshape]
t0, t1 = math.sin(tiltangle), math.cos(tiltangle)
shape = [(t1*x+t0*y, -t0*x+t1*y) for (x, y) in shape]
shape = self._polytrafo(shape)
fc, oc = self._fillcolor, self._pencolor
screen._drawpoly(stitem, shape, fill=fc, outline=oc,
width=w, top=True)
elif ttype == "image":
stitem = screen._createimage("")
screen._drawimage(stitem, self._position, tshape)
elif ttype == "compound":
stitem = []
for element in tshape:
item = screen._createpoly()
stitem.append(item)
stitem = tuple(stitem)
lx, ly = self._stretchfactor
w = self._outlinewidth
for item, (poly, fc, oc) in zip(stitem, tshape):
poly = [(lx*x, ly*y) for (x, y) in poly]
poly = self._polytrafo(poly)
screen._drawpoly(item, poly, fill=self._cc(fc),
outline=self._cc(oc), width=w, top=True)
self.stampItems.append(stitem)
self.undobuffer.push(("stamp", stitem))
return stitem
def _clearstamp(self, stampid):
"""does the work for clearstamp() and clearstamps()
"""
if stampid in self.stampItems:
if isinstance(stampid, tuple):
for subitem in stampid:
self.screen._delete(subitem)
else:
self.screen._delete(stampid)
self.stampItems.remove(stampid)
# Delete stampitem from undobuffer if necessary
# if clearstamp is called directly.
item = ("stamp", stampid)
buf = self.undobuffer
if item not in buf.buffer:
return
index = buf.buffer.index(item)
buf.buffer.remove(item)
if index <= buf.ptr:
buf.ptr = (buf.ptr - 1) % buf.bufsize
buf.buffer.insert((buf.ptr+1)%buf.bufsize, [None])
def clearstamp(self, stampid):
"""Delete stamp with given stampid
Argument:
stampid - an integer, must be return value of previous stamp() call.
Example (for a Turtle instance named turtle):
>>> turtle.color("blue")
>>> astamp = turtle.stamp()
>>> turtle.fd(50)
>>> turtle.clearstamp(astamp)
"""
self._clearstamp(stampid)
self._update()
def clearstamps(self, n=None):
"""Delete all or first/last n of turtle's stamps.
Optional argument:
n -- an integer
If n is None, delete all of pen's stamps,
else if n > 0 delete first n stamps
else if n < 0 delete last n stamps.
Example (for a Turtle instance named turtle):
>>> for i in range(8):
... turtle.stamp(); turtle.fd(30)
...
>>> turtle.clearstamps(2)
>>> turtle.clearstamps(-2)
>>> turtle.clearstamps()
"""
if n is None:
toDelete = self.stampItems[:]
elif n >= 0:
toDelete = self.stampItems[:n]
else:
toDelete = self.stampItems[n:]
for item in toDelete:
self._clearstamp(item)
self._update()
def _goto(self, end):
"""Move the pen to the point end, thereby drawing a line
if pen is down. All other methods for turtle movement depend
on this one.
"""
## Version mit undo-stuff
go_modes = ( self._drawing,
self._pencolor,
self._pensize,
isinstance(self._fillpath, list))
screen = self.screen
undo_entry = ("go", self._position, end, go_modes,
(self.currentLineItem,
self.currentLine[:],
screen._pointlist(self.currentLineItem),
self.items[:])
)
if self.undobuffer:
self.undobuffer.push(undo_entry)
start = self._position
if self._speed and screen._tracing == 1:
diff = (end-start)
diffsq = (diff[0]*screen.xscale)**2 + (diff[1]*screen.yscale)**2
nhops = 1+int((diffsq**0.5)/(3*(1.1**self._speed)*self._speed))
delta = diff * (1.0/nhops)
for n in range(1, nhops):
if n == 1:
top = True
else:
top = False
self._position = start + delta * n
if self._drawing:
screen._drawline(self.drawingLineItem,
(start, self._position),
self._pencolor, self._pensize, top)
self._update()
if self._drawing:
screen._drawline(self.drawingLineItem, ((0, 0), (0, 0)),
fill="", width=self._pensize)
# Turtle now at end,
if self._drawing: # now update currentLine
self.currentLine.append(end)
if isinstance(self._fillpath, list):
self._fillpath.append(end)
###### vererbung!!!!!!!!!!!!!!!!!!!!!!
self._position = end
if self._creatingPoly:
self._poly.append(end)
if len(self.currentLine) > 42: # 42! answer to the ultimate question
# of life, the universe and everything
self._newLine()
self._update() #count=True)
def _undogoto(self, entry):
"""Reverse a _goto. Used for undo()
"""
old, new, go_modes, coodata = entry
drawing, pc, ps, filling = go_modes
cLI, cL, pl, items = coodata
screen = self.screen
if abs(self._position - new) > 0.5:
print "undogoto: HALLO-DA-STIMMT-WAS-NICHT!"
# restore former situation
self.currentLineItem = cLI
self.currentLine = cL
if pl == [(0, 0), (0, 0)]:
usepc = ""
else:
usepc = pc
screen._drawline(cLI, pl, fill=usepc, width=ps)
todelete = [i for i in self.items if (i not in items) and
(screen._type(i) == "line")]
for i in todelete:
screen._delete(i)
self.items.remove(i)
start = old
if self._speed and screen._tracing == 1:
diff = old - new
diffsq = (diff[0]*screen.xscale)**2 + (diff[1]*screen.yscale)**2
nhops = 1+int((diffsq**0.5)/(3*(1.1**self._speed)*self._speed))
delta = diff * (1.0/nhops)
for n in range(1, nhops):
if n == 1:
top = True
else:
top = False
self._position = new + delta * n
if drawing:
screen._drawline(self.drawingLineItem,
(start, self._position),
pc, ps, top)
self._update()
if drawing:
screen._drawline(self.drawingLineItem, ((0, 0), (0, 0)),
fill="", width=ps)
# Turtle now at position old,
self._position = old
## if undo is done during creating a polygon, the last vertex
## will be deleted. if the polygon is entirely deleted,
## creatingPoly will be set to False.
## Polygons created before the last one will not be affected by undo()
if self._creatingPoly:
if len(self._poly) > 0:
self._poly.pop()
if self._poly == []:
self._creatingPoly = False
self._poly = None
if filling:
if self._fillpath == []:
self._fillpath = None
print "Unwahrscheinlich in _undogoto!"
elif self._fillpath is not None:
self._fillpath.pop()
self._update() #count=True)
def _rotate(self, angle):
"""Turns pen clockwise by angle.
"""
if self.undobuffer:
self.undobuffer.push(("rot", angle, self._degreesPerAU))
angle *= self._degreesPerAU
neworient = self._orient.rotate(angle)
tracing = self.screen._tracing
if tracing == 1 and self._speed > 0:
anglevel = 3.0 * self._speed
steps = 1 + int(abs(angle)/anglevel)
delta = 1.0*angle/steps
for _ in range(steps):
self._orient = self._orient.rotate(delta)
self._update()
self._orient = neworient
self._update()
def _newLine(self, usePos=True):
"""Closes current line item and starts a new one.
Remark: if current line became too long, animation
performance (via _drawline) slowed down considerably.
"""
if len(self.currentLine) > 1:
self.screen._drawline(self.currentLineItem, self.currentLine,
self._pencolor, self._pensize)
self.currentLineItem = self.screen._createline()
self.items.append(self.currentLineItem)
else:
self.screen._drawline(self.currentLineItem, top=True)
self.currentLine = []
if usePos:
self.currentLine = [self._position]
def fill(self, flag=None):
"""Call fill(True) before drawing a shape to fill, fill(False) when done.
Optional argument:
flag -- True/False (or 1/0 respectively)
Call fill(True) before drawing the shape you want to fill,
and fill(False) when done.
When used without argument: return fillstate (True if filling,
False else)
Example (for a Turtle instance named turtle):
>>> turtle.fill(True)
>>> turtle.forward(100)
>>> turtle.left(90)
>>> turtle.forward(100)
>>> turtle.left(90)
>>> turtle.forward(100)
>>> turtle.left(90)
>>> turtle.forward(100)
>>> turtle.fill(False)
"""
filling = isinstance(self._fillpath, list)
if flag is None:
return filling
screen = self.screen
entry1 = entry2 = ()
if filling:
if len(self._fillpath) > 2:
self.screen._drawpoly(self._fillitem, self._fillpath,
fill=self._fillcolor)
entry1 = ("dofill", self._fillitem)
if flag:
self._fillitem = self.screen._createpoly()
self.items.append(self._fillitem)
self._fillpath = [self._position]
entry2 = ("beginfill", self._fillitem) # , self._fillpath)
self._newLine()
else:
self._fillitem = self._fillpath = None
if self.undobuffer:
if entry1 == ():
if entry2 != ():
self.undobuffer.push(entry2)
else:
if entry2 == ():
self.undobuffer.push(entry1)
else:
self.undobuffer.push(["seq", entry1, entry2])
self._update()
def begin_fill(self):
"""Called just before drawing a shape to be filled.
No argument.
Example (for a Turtle instance named turtle):
>>> turtle.begin_fill()
>>> turtle.forward(100)
>>> turtle.left(90)
>>> turtle.forward(100)
>>> turtle.left(90)
>>> turtle.forward(100)
>>> turtle.left(90)
>>> turtle.forward(100)
>>> turtle.end_fill()
"""
self.fill(True)
def end_fill(self):
"""Fill the shape drawn after the call begin_fill().
No argument.
Example (for a Turtle instance named turtle):
>>> turtle.begin_fill()
>>> turtle.forward(100)
>>> turtle.left(90)
>>> turtle.forward(100)
>>> turtle.left(90)
>>> turtle.forward(100)
>>> turtle.left(90)
>>> turtle.forward(100)
>>> turtle.end_fill()
"""
self.fill(False)
def dot(self, size=None, *color):
"""Draw a dot with diameter size, using color.
Optional arguments:
size -- an integer >= 1 (if given)
color -- a colorstring or a numeric color tuple
Draw a circular dot with diameter size, using color.
If size is not given, the maximum of pensize+4 and 2*pensize is used.
Example (for a Turtle instance named turtle):
>>> turtle.dot()
>>> turtle.fd(50); turtle.dot(20, "blue"); turtle.fd(50)
"""
#print "dot-1:", size, color
if not color:
if isinstance(size, (basestring, tuple)):
color = self._colorstr(size)
size = self._pensize + max(self._pensize, 4)
else:
color = self._pencolor
if not size:
size = self._pensize + max(self._pensize, 4)
else:
if size is None:
size = self._pensize + max(self._pensize, 4)
color = self._colorstr(color)
#print "dot-2:", size, color
if hasattr(self.screen, "_dot"):
item = self.screen._dot(self._position, size, color)
#print "dot:", size, color, "item:", item
self.items.append(item)
if self.undobuffer:
self.undobuffer.push(("dot", item))
else:
pen = self.pen()
if self.undobuffer:
self.undobuffer.push(["seq"])
self.undobuffer.cumulate = True
try:
if self.resizemode() == 'auto':
self.ht()
self.pendown()
self.pensize(size)
self.pencolor(color)
self.forward(0)
finally:
self.pen(pen)
if self.undobuffer:
self.undobuffer.cumulate = False
def _write(self, txt, align, font):
"""Performs the writing for write()
"""
item, end = self.screen._write(self._position, txt, align, font,
self._pencolor)
self.items.append(item)
if self.undobuffer:
self.undobuffer.push(("wri", item))
return end
def write(self, arg, move=False, align="left", font=("Arial", 8, "normal")):
"""Write text at the current turtle position.
Arguments:
arg -- info, which is to be written to the TurtleScreen
move (optional) -- True/False
align (optional) -- one of the strings "left", "center" or right"
font (optional) -- a triple (fontname, fontsize, fonttype)
Write text - the string representation of arg - at the current
turtle position according to align ("left", "center" or right")
and with the given font.
If move is True, the pen is moved to the bottom-right corner
of the text. By default, move is False.
Example (for a Turtle instance named turtle):
>>> turtle.write('Home = ', True, align="center")
>>> turtle.write((0,0), True)
"""
if self.undobuffer:
self.undobuffer.push(["seq"])
self.undobuffer.cumulate = True
end = self._write(str(arg), align.lower(), font)
if move:
x, y = self.pos()
self.setpos(end, y)
if self.undobuffer:
self.undobuffer.cumulate = False
def begin_poly(self):
"""Start recording the vertices of a polygon.
No argument.
Start recording the vertices of a polygon. Current turtle position
is first point of polygon.
Example (for a Turtle instance named turtle):
>>> turtle.begin_poly()
"""
self._poly = [self._position]
self._creatingPoly = True
def end_poly(self):
"""Stop recording the vertices of a polygon.
No argument.
Stop recording the vertices of a polygon. Current turtle position is
last point of polygon. This will be connected with the first point.
Example (for a Turtle instance named turtle):
>>> turtle.end_poly()
"""
self._creatingPoly = False
def get_poly(self):
"""Return the lastly recorded polygon.
No argument.
Example (for a Turtle instance named turtle):
>>> p = turtle.get_poly()
>>> turtle.register_shape("myFavouriteShape", p)
"""
## check if there is any poly? -- 1st solution:
if self._poly is not None:
return tuple(self._poly)
def getscreen(self):
"""Return the TurtleScreen object, the turtle is drawing on.
No argument.
Return the TurtleScreen object, the turtle is drawing on.
So TurtleScreen-methods can be called for that object.
Example (for a Turtle instance named turtle):
>>> ts = turtle.getscreen()
>>> ts
<turtle.TurtleScreen object at 0x0106B770>
>>> ts.bgcolor("pink")
"""
return self.screen
def getturtle(self):
"""Return the Turtleobject itself.
No argument.
Only reasonable use: as a function to return the 'anonymous turtle':
Example:
>>> pet = getturtle()
>>> pet.fd(50)
>>> pet
<turtle.Turtle object at 0x0187D810>
>>> turtles()
[<turtle.Turtle object at 0x0187D810>]
"""
return self
getpen = getturtle
################################################################
### screen oriented methods recurring to methods of TurtleScreen
################################################################
def window_width(self):
""" Returns the width of the turtle window.
No argument.
Example (for a TurtleScreen instance named screen):
>>> screen.window_width()
640
"""
return self.screen._window_size()[0]
def window_height(self):
""" Return the height of the turtle window.
No argument.
Example (for a TurtleScreen instance named screen):
>>> screen.window_height()
480
"""
return self.screen._window_size()[1]
def _delay(self, delay=None):
"""Set delay value which determines speed of turtle animation.
"""
return self.screen.delay(delay)
##### event binding methods #####
def onclick(self, fun, btn=1, add=None):
"""Bind fun to mouse-click event on this turtle on canvas.
Arguments:
fun -- a function with two arguments, to which will be assigned
the coordinates of the clicked point on the canvas.
btn -- number of the mouse-button defaults to 1 (left mouse button).
add -- True or False. If True, new binding will be added, otherwise
it will replace a former binding.
Example for the anonymous turtle, i. e. the procedural way:
>>> def turn(x, y):
... left(360)
...
>>> onclick(turn) # Now clicking into the turtle will turn it.
>>> onclick(None) # event-binding will be removed
"""
self.screen._onclick(self.turtle._item, fun, btn, add)
self._update()
def onrelease(self, fun, btn=1, add=None):
"""Bind fun to mouse-button-release event on this turtle on canvas.
Arguments:
fun -- a function with two arguments, to which will be assigned
the coordinates of the clicked point on the canvas.
btn -- number of the mouse-button defaults to 1 (left mouse button).
Example (for a MyTurtle instance named joe):
>>> class MyTurtle(Turtle):
... def glow(self,x,y):
... self.fillcolor("red")
... def unglow(self,x,y):
... self.fillcolor("")
...
>>> joe = MyTurtle()
>>> joe.onclick(joe.glow)
>>> joe.onrelease(joe.unglow)
Clicking on joe turns fillcolor red, unclicking turns it to
transparent.
"""
self.screen._onrelease(self.turtle._item, fun, btn, add)
self._update()
def ondrag(self, fun, btn=1, add=None):
"""Bind fun to mouse-move event on this turtle on canvas.
Arguments:
fun -- a function with two arguments, to which will be assigned
the coordinates of the clicked point on the canvas.
btn -- number of the mouse-button defaults to 1 (left mouse button).
Every sequence of mouse-move-events on a turtle is preceded by a
mouse-click event on that turtle.
Example (for a Turtle instance named turtle):
>>> turtle.ondrag(turtle.goto)
Subsequently clicking and dragging a Turtle will move it
across the screen thereby producing handdrawings (if pen is
down).
"""
self.screen._ondrag(self.turtle._item, fun, btn, add)
def _undo(self, action, data):
"""Does the main part of the work for undo()
"""
if self.undobuffer is None:
return
if action == "rot":
angle, degPAU = data
self._rotate(-angle*degPAU/self._degreesPerAU)
dummy = self.undobuffer.pop()
elif action == "stamp":
stitem = data[0]
self.clearstamp(stitem)
elif action == "go":
self._undogoto(data)
elif action in ["wri", "dot"]:
item = data[0]
self.screen._delete(item)
self.items.remove(item)
elif action == "dofill":
item = data[0]
self.screen._drawpoly(item, ((0, 0),(0, 0),(0, 0)),
fill="", outline="")
elif action == "beginfill":
item = data[0]
self._fillitem = self._fillpath = None
self.screen._delete(item)
self.items.remove(item)
elif action == "pen":
TPen.pen(self, data[0])
self.undobuffer.pop()
def undo(self):
"""undo (repeatedly) the last turtle action.
No argument.
undo (repeatedly) the last turtle action.
Number of available undo actions is determined by the size of
the undobuffer.
Example (for a Turtle instance named turtle):
>>> for i in range(4):
... turtle.fd(50); turtle.lt(80)
...
>>> for i in range(8):
... turtle.undo()
...
"""
if self.undobuffer is None:
return
item = self.undobuffer.pop()
action = item[0]
data = item[1:]
if action == "seq":
while data:
item = data.pop()
self._undo(item[0], item[1:])
else:
self._undo(action, data)
turtlesize = shapesize
RawPen = RawTurtle
### Screen - Singleton ########################
def Screen():
"""Return the singleton screen object.
If none exists at the moment, create a new one and return it,
else return the existing one."""
if Turtle._screen is None:
Turtle._screen = _Screen()
return Turtle._screen
class _Screen(TurtleScreen):
_root = None
_canvas = None
_title = _CFG["title"]
def __init__(self):
# XXX there is no need for this code to be conditional,
# as there will be only a single _Screen instance, anyway
# XXX actually, the turtle demo is injecting root window,
# so perhaps the conditional creation of a root should be
# preserved (perhaps by passing it as an optional parameter)
if _Screen._root is None:
_Screen._root = self._root = _Root()
self._root.title(_Screen._title)
self._root.ondestroy(self._destroy)
if _Screen._canvas is None:
width = _CFG["width"]
height = _CFG["height"]
canvwidth = _CFG["canvwidth"]
canvheight = _CFG["canvheight"]
leftright = _CFG["leftright"]
topbottom = _CFG["topbottom"]
self._root.setupcanvas(width, height, canvwidth, canvheight)
_Screen._canvas = self._root._getcanvas()
TurtleScreen.__init__(self, _Screen._canvas)
self.setup(width, height, leftright, topbottom)
def setup(self, width=_CFG["width"], height=_CFG["height"],
startx=_CFG["leftright"], starty=_CFG["topbottom"]):
""" Set the size and position of the main window.
Arguments:
width: as integer a size in pixels, as float a fraction of the screen.
Default is 50% of screen.
height: as integer the height in pixels, as float a fraction of the
screen. Default is 75% of screen.
startx: if positive, starting position in pixels from the left
edge of the screen, if negative from the right edge
Default, startx=None is to center window horizontally.
starty: if positive, starting position in pixels from the top
edge of the screen, if negative from the bottom edge
Default, starty=None is to center window vertically.
Examples (for a Screen instance named screen):
>>> screen.setup (width=200, height=200, startx=0, starty=0)
sets window to 200x200 pixels, in upper left of screen
>>> screen.setup(width=.75, height=0.5, startx=None, starty=None)
sets window to 75% of screen by 50% of screen and centers
"""
if not hasattr(self._root, "set_geometry"):
return
sw = self._root.win_width()
sh = self._root.win_height()
if isinstance(width, float) and 0 <= width <= 1:
width = sw*width
if startx is None:
startx = (sw - width) / 2
if isinstance(height, float) and 0 <= height <= 1:
height = sh*height
if starty is None:
starty = (sh - height) / 2
self._root.set_geometry(width, height, startx, starty)
self.update()
def title(self, titlestring):
"""Set title of turtle-window
Argument:
titlestring -- a string, to appear in the titlebar of the
turtle graphics window.
This is a method of Screen-class. Not available for TurtleScreen-
objects.
Example (for a Screen instance named screen):
>>> screen.title("Welcome to the turtle-zoo!")
"""
if _Screen._root is not None:
_Screen._root.title(titlestring)
_Screen._title = titlestring
def _destroy(self):
root = self._root
if root is _Screen._root:
Turtle._pen = None
Turtle._screen = None
_Screen._root = None
_Screen._canvas = None
TurtleScreen._RUNNING = False
root.destroy()
def bye(self):
"""Shut the turtlegraphics window.
Example (for a TurtleScreen instance named screen):
>>> screen.bye()
"""
self._destroy()
def exitonclick(self):
"""Go into mainloop until the mouse is clicked.
No arguments.
Bind bye() method to mouseclick on TurtleScreen.
If "using_IDLE" - value in configuration dictionary is False
(default value), enter mainloop.
If IDLE with -n switch (no subprocess) is used, this value should be
set to True in turtle.cfg. In this case IDLE's mainloop
is active also for the client script.
This is a method of the Screen-class and not available for
TurtleScreen instances.
Example (for a Screen instance named screen):
>>> screen.exitonclick()
"""
def exitGracefully(x, y):
"""Screen.bye() with two dummy-parameters"""
self.bye()
self.onclick(exitGracefully)
if _CFG["using_IDLE"]:
return
try:
mainloop()
except AttributeError:
exit(0)
class Turtle(RawTurtle):
"""RawTurtle auto-creating (scrolled) canvas.
When a Turtle object is created or a function derived from some
Turtle method is called a TurtleScreen object is automatically created.
"""
_pen = None
_screen = None
def __init__(self,
shape=_CFG["shape"],
undobuffersize=_CFG["undobuffersize"],
visible=_CFG["visible"]):
if Turtle._screen is None:
Turtle._screen = Screen()
RawTurtle.__init__(self, Turtle._screen,
shape=shape,
undobuffersize=undobuffersize,
visible=visible)
Pen = Turtle
def write_docstringdict(filename="turtle_docstringdict"):
"""Create and write docstring-dictionary to file.
Optional argument:
filename -- a string, used as filename
default value is turtle_docstringdict
Has to be called explicitly, (not used by the turtle-graphics classes)
The docstring dictionary will be written to the Python script <filname>.py
It is intended to serve as a template for translation of the docstrings
into different languages.
"""
docsdict = {}
for methodname in _tg_screen_functions:
key = "_Screen."+methodname
docsdict[key] = eval(key).__doc__
for methodname in _tg_turtle_functions:
key = "Turtle."+methodname
docsdict[key] = eval(key).__doc__
f = open("%s.py" % filename,"w")
keys = sorted([x for x in docsdict.keys()
if x.split('.')[1] not in _alias_list])
f.write('docsdict = {\n\n')
for key in keys[:-1]:
f.write('%s :\n' % repr(key))
f.write(' """%s\n""",\n\n' % docsdict[key])
key = keys[-1]
f.write('%s :\n' % repr(key))
f.write(' """%s\n"""\n\n' % docsdict[key])
f.write("}\n")
f.close()
def read_docstrings(lang):
"""Read in docstrings from lang-specific docstring dictionary.
Transfer docstrings, translated to lang, from a dictionary-file
to the methods of classes Screen and Turtle and - in revised form -
to the corresponding functions.
"""
modname = "turtle_docstringdict_%(language)s" % {'language':lang.lower()}
module = __import__(modname)
docsdict = module.docsdict
for key in docsdict:
#print key
try:
eval(key).im_func.__doc__ = docsdict[key]
except BaseException:
print "Bad docstring-entry: %s" % key
_LANGUAGE = _CFG["language"]
try:
if _LANGUAGE != "english":
read_docstrings(_LANGUAGE)
except ImportError:
print "Cannot find docsdict for", _LANGUAGE
except BaseException:
print ("Unknown Error when trying to import %s-docstring-dictionary" %
_LANGUAGE)
def getmethparlist(ob):
"Get strings describing the arguments for the given object"
argText1 = argText2 = ""
# bit of a hack for methods - turn it into a function
# but we drop the "self" param.
if type(ob)==types.MethodType:
fob = ob.im_func
argOffset = 1
else:
fob = ob
argOffset = 0
# Try and build one for Python defined functions
if type(fob) in [types.FunctionType, types.LambdaType]:
try:
counter = fob.func_code.co_argcount
items2 = list(fob.func_code.co_varnames[argOffset:counter])
realArgs = fob.func_code.co_varnames[argOffset:counter]
defaults = fob.func_defaults or []
defaults = list(map(lambda name: "=%s" % repr(name), defaults))
defaults = [""] * (len(realArgs)-len(defaults)) + defaults
items1 = map(lambda arg, dflt: arg+dflt, realArgs, defaults)
if fob.func_code.co_flags & 0x4:
items1.append("*"+fob.func_code.co_varnames[counter])
items2.append("*"+fob.func_code.co_varnames[counter])
counter += 1
if fob.func_code.co_flags & 0x8:
items1.append("**"+fob.func_code.co_varnames[counter])
items2.append("**"+fob.func_code.co_varnames[counter])
argText1 = ", ".join(items1)
argText1 = "(%s)" % argText1
argText2 = ", ".join(items2)
argText2 = "(%s)" % argText2
except:
pass
return argText1, argText2
def _turtle_docrevise(docstr):
"""To reduce docstrings from RawTurtle class for functions
"""
import re
if docstr is None:
return None
turtlename = _CFG["exampleturtle"]
newdocstr = docstr.replace("%s." % turtlename,"")
parexp = re.compile(r' \(.+ %s\):' % turtlename)
newdocstr = parexp.sub(":", newdocstr)
return newdocstr
def _screen_docrevise(docstr):
"""To reduce docstrings from TurtleScreen class for functions
"""
import re
if docstr is None:
return None
screenname = _CFG["examplescreen"]
newdocstr = docstr.replace("%s." % screenname,"")
parexp = re.compile(r' \(.+ %s\):' % screenname)
newdocstr = parexp.sub(":", newdocstr)
return newdocstr
## The following mechanism makes all methods of RawTurtle and Turtle available
## as functions. So we can enhance, change, add, delete methods to these
## classes and do not need to change anything here.
__func_body = """\
def {name}{paramslist}:
if {obj} is None:
if not TurtleScreen._RUNNING:
TurtleScreen._RUNNING = True
raise Terminator
{obj} = {init}
try:
return {obj}.{name}{argslist}
except TK.TclError:
if not TurtleScreen._RUNNING:
TurtleScreen._RUNNING = True
raise Terminator
raise
"""
def _make_global_funcs(functions, cls, obj, init, docrevise):
for methodname in functions:
method = getattr(cls, methodname)
pl1, pl2 = getmethparlist(method)
if pl1 == "":
print ">>>>>>", pl1, pl2
continue
defstr = __func_body.format(obj=obj, init=init, name=methodname,
paramslist=pl1, argslist=pl2)
exec defstr in globals()
globals()[methodname].__doc__ = docrevise(method.__doc__)
_make_global_funcs(_tg_screen_functions, _Screen,
'Turtle._screen', 'Screen()', _screen_docrevise)
_make_global_funcs(_tg_turtle_functions, Turtle,
'Turtle._pen', 'Turtle()', _turtle_docrevise)
done = mainloop = TK.mainloop
if __name__ == "__main__":
def switchpen():
if isdown():
pu()
else:
pd()
def demo1():
"""Demo of old turtle.py - module"""
reset()
tracer(True)
up()
backward(100)
down()
# draw 3 squares; the last filled
width(3)
for i in range(3):
if i == 2:
fill(1)
for _ in range(4):
forward(20)
left(90)
if i == 2:
color("maroon")
fill(0)
up()
forward(30)
down()
width(1)
color("black")
# move out of the way
tracer(False)
up()
right(90)
forward(100)
right(90)
forward(100)
right(180)
down()
# some text
write("startstart", 1)
write(u"start", 1)
color("red")
# staircase
for i in range(5):
forward(20)
left(90)
forward(20)
right(90)
# filled staircase
tracer(True)
fill(1)
for i in range(5):
forward(20)
left(90)
forward(20)
right(90)
fill(0)
# more text
def demo2():
"""Demo of some new features."""
speed(1)
st()
pensize(3)
setheading(towards(0, 0))
radius = distance(0, 0)/2.0
rt(90)
for _ in range(18):
switchpen()
circle(radius, 10)
write("wait a moment...")
while undobufferentries():
undo()
reset()
lt(90)
colormode(255)
laenge = 10
pencolor("green")
pensize(3)
lt(180)
for i in range(-2, 16):
if i > 0:
begin_fill()
fillcolor(255-15*i, 0, 15*i)
for _ in range(3):
fd(laenge)
lt(120)
laenge += 10
lt(15)
speed((speed()+1)%12)
end_fill()
lt(120)
pu()
fd(70)
rt(30)
pd()
color("red","yellow")
speed(0)
fill(1)
for _ in range(4):
circle(50, 90)
rt(90)
fd(30)
rt(90)
fill(0)
lt(90)
pu()
fd(30)
pd()
shape("turtle")
tri = getturtle()
tri.resizemode("auto")
turtle = Turtle()
turtle.resizemode(u"auto")
turtle.shape("turtle")
turtle.reset()
turtle.left(90)
turtle.speed(0)
turtle.up()
turtle.goto(280, 40)
turtle.lt(30)
turtle.down()
turtle.speed(6)
turtle.color("blue",u"orange")
turtle.pensize(2)
tri.speed(6)
setheading(towards(turtle))
count = 1
while tri.distance(turtle) > 4:
turtle.fd(3.5)
turtle.lt(0.6)
tri.setheading(tri.towards(turtle))
tri.fd(4)
if count % 20 == 0:
turtle.stamp()
tri.stamp()
switchpen()
count += 1
tri.write("CAUGHT! ", font=("Arial", 16, "bold"), align=u"right")
tri.pencolor("black")
tri.pencolor(u"red")
def baba(xdummy, ydummy):
clearscreen()
bye()
time.sleep(2)
while undobufferentries():
tri.undo()
turtle.undo()
tri.fd(50)
tri.write(" Click me!", font = ("Courier", 12, "bold") )
tri.onclick(baba, 1)
demo1()
demo2()
exitonclick()
ScrolledText.py 0000644 00000003454 15032720555 0007544 0 ustar 00 """A ScrolledText widget feels like a text widget but also has a
vertical scroll bar on its right. (Later, options may be added to
add a horizontal bar as well, to make the bars disappear
automatically when not needed, to move them to the other side of the
window, etc.)
Configuration options are passed to the Text widget.
A Frame widget is inserted between the master and the text, to hold
the Scrollbar widget.
Most methods calls are inherited from the Text widget; Pack, Grid and
Place methods are redirected to the Frame widget however.
"""
__all__ = ['ScrolledText']
from Tkinter import Frame, Text, Scrollbar, Pack, Grid, Place
from Tkconstants import RIGHT, LEFT, Y, BOTH
class ScrolledText(Text):
def __init__(self, master=None, **kw):
self.frame = Frame(master)
self.vbar = Scrollbar(self.frame)
self.vbar.pack(side=RIGHT, fill=Y)
kw.update({'yscrollcommand': self.vbar.set})
Text.__init__(self, self.frame, **kw)
self.pack(side=LEFT, fill=BOTH, expand=True)
self.vbar['command'] = self.yview
# Copy geometry methods of self.frame without overriding Text
# methods -- hack!
text_meths = vars(Text).keys()
methods = vars(Pack).keys() + vars(Grid).keys() + vars(Place).keys()
methods = set(methods).difference(text_meths)
for m in methods:
if m[0] != '_' and m != 'config' and m != 'configure':
setattr(self, m, getattr(self.frame, m))
def __str__(self):
return str(self.frame)
def example():
import __main__
from Tkconstants import END
stext = ScrolledText(bg='white', height=10)
stext.insert(END, __main__.__doc__)
stext.pack(fill=BOTH, side=LEFT, expand=True)
stext.focus_set()
stext.mainloop()
if __name__ == "__main__":
example()
tkFileDialog.pyo 0000644 00000012051 15032720555 0007636 0 ustar 00 �
z fc @ s� d d l m Z d e f d � � YZ d e f d � � YZ d e f d � � YZ d e f d � � YZ d
� Z d � Z d � Z d
d � Z d
d � Z
d d � Z d � Z e
d k r�d Z d d l Z y5 d d l Z e j e j d � e j e j � Z Wn e e f k
r n Xe d d g � Z y e e d
� Z e j � Wn d GHe j � d GHn Xd Ge j e � GHe � Z d Ge j e � GHn d S( i����( t Dialogt _Dialogc B s e Z d � Z d � Z RS( c C s6 y t | j d � | j d <Wn t k
r1 n Xd S( Nt filetypes( t tuplet optionst KeyError( t self( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyt _fixoptions/ s
c C su | rh d d l } y
| j } Wn t k
r2 n X| j j | � \ } } | | j d <| | j d <n | | _ | S( Ni����t
initialdirt initialfile( t ost stringt AttributeErrort patht splitR t filename( R t widgett resultR
R
t file( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyt
_fixresult6 s
( t __name__t
__module__R R ( ( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyR - s t Openc B s e Z d Z d Z d � Z RS( s Ask for a filename to opent tk_getOpenFilec C s� t | t � r| t g | D] } t | d | � ^ q � } | rx d d l } | j j | d � \ } } | | j d <n | S| j j � r� d | j k r� | j | | j j
| � � St j | | | � S( NR i����i R t multiple( t
isinstanceR t getattrR
R
R R t tkt wantobjectsR t splitlistR ( R R R t rR
R
R ( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyR O s + ( R R t __doc__t commandR ( ( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyR J s t SaveAsc B s e Z d Z d Z RS( s Ask for a filename to save ast tk_getSaveFile( R R R R ( ( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyR! ^ s t Directoryc B s e Z d Z d Z d � Z RS( s Ask for a directoryt tk_chooseDirectoryc C sD | r7 y
| j } Wn t k
r& n X| | j d <n | | _ | S( NR ( R R R t directory( R R R ( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyR j s
( R R R R R ( ( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyR# e s c K s t | � j � S( s Ask for a filename to open( R t show( R ( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyt askopenfilenamez s c K s t | � j � S( s Ask for a filename to save as( R! R& ( R ( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyt asksaveasfilename s c K s d | d <t | � j � S( st Ask for multiple filenames to open
Returns a list of filenames or empty list if
cancel button selected
i R ( R R& ( R ( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyt askopenfilenames� s
R c K s) t | � j � } | r% t | | � Sd S( s8 Ask for a filename to open, and returned the opened fileN( R R& t opent None( t modeR R ( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyt askopenfile� s
c K sL t | � } | rH g } x$ | D] } | j t | | � � q W| } n | S( s� Ask for multiple filenames and return the open file
objects
returns a list of open file objects or an empty list if
cancel selected
( R) t appendR* ( R, R t filest ofilesR ( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyt askopenfiles� s
t wc K s) t | � j � } | r% t | | � Sd S( s; Ask for a filename to save as, and returned the opened fileN( R! R& R* R+ ( R, R R ( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyt
asksaveasfile� s
c K s t | � j � S( s- Ask for a directory, and return the file name( R# R& ( R ( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyt askdirectory� s t __main__s utf-8Nt R s all filest *s Could not open File: i R* t saveas( s all filesR7 ( t tkCommonDialogR R R R! R# R' R( R) R- R1 R3 R4 R t enct syst localet setlocalet LC_ALLt nl_langinfot CODESETt ImportErrorR t openfilenameR* t fpt closet exc_infot encodet saveasfilename( ( ( s+ /usr/lib64/python2.7/lib-tk/tkFileDialog.pyt <module>+ s< tkMessageBox.pyo 0000644 00000007466 15032720555 0007712 0 ustar 00 �
z fc @ s� d d l m Z d Z d Z d Z d Z d Z d Z d Z d Z d
Z
d Z d Z d
Z
d Z d Z d Z d Z d Z d e f d � � YZ d+ d+ d+ d+ d � Z d+ d+ d � Z d+ d+ d � Z d+ d+ d � Z d+ d+ d � Z d+ d+ d � Z d+ d+ d � Z d+ d+ d � Z d+ d+ d � Z e d k r�d Ge d d � GHd Ge d d � GHd Ge d d! � GHd Ge d d" � GHd# Ge d d$ � GHd% Ge d d& � GHd' Ge d d( � GHd) Ge d d* � GHn d+ S(, i����( t Dialogt errort infot questiont warningt abortretryignoret okt okcancelt retrycancelt yesnot yesnocancelt abortt retryt ignoret cancelt yest not Messagec B s e Z d Z d Z RS( s
A message boxt
tk_messageBox( t __name__t
__module__t __doc__t command( ( ( s+ /usr/lib64/python2.7/lib-tk/tkMessageBox.pyR 9 s c K s� | r d | k r | | d <n | r> d | k r> | | d <n | rQ | | d <n | rd | | d <n t | � j � } t | t � r� | r� t St St | � S( Nt icont typet titlet message( R t showt
isinstancet boolt YESt NOt str( R R t _icont _typet optionst res( ( s+ /usr/lib64/python2.7/lib-tk/tkMessageBox.pyt _showC s
c K s t | | t t | � S( s Show an info message( R% t INFOt OK( R R R# ( ( s+ /usr/lib64/python2.7/lib-tk/tkMessageBox.pyt showinfoQ s c K s t | | t t | � S( s Show a warning message( R% t WARNINGR' ( R R R# ( ( s+ /usr/lib64/python2.7/lib-tk/tkMessageBox.pyt showwarningU s c K s t | | t t | � S( s Show an error message( R% t ERRORR' ( R R R# ( ( s+ /usr/lib64/python2.7/lib-tk/tkMessageBox.pyt showerrorY s c K s t | | t t | � S( s Ask a question( R% t QUESTIONt YESNO( R R R# ( ( s+ /usr/lib64/python2.7/lib-tk/tkMessageBox.pyt askquestion] s c K s" t | | t t | � } | t k S( s@ Ask if operation should proceed; return true if the answer is ok( R% R- t OKCANCELR' ( R R R# t s( ( s+ /usr/lib64/python2.7/lib-tk/tkMessageBox.pyt askokcancela s c K s" t | | t t | � } | t k S( s0 Ask a question; return true if the answer is yes( R% R- R. R ( R R R# R1 ( ( s+ /usr/lib64/python2.7/lib-tk/tkMessageBox.pyt askyesnof s c K s> t | | t t | � } t | � } | t k r4 d S| t k S( sD Ask a question; return true if the answer is yes, None if cancelled.N( R% R- t YESNOCANCELR t CANCELt NoneR ( R R R# R1 ( ( s+ /usr/lib64/python2.7/lib-tk/tkMessageBox.pyt askyesnocancelk s
c K s" t | | t t | � } | t k S( sD Ask if operation should be retried; return true if the answer is yes( R% R) t RETRYCANCELt RETRY( R R R# R1 ( ( s+ /usr/lib64/python2.7/lib-tk/tkMessageBox.pyt askretrycancelt s t __main__t Spams Egg Informations Egg Warnings Egg Alerts Question?t proceeds Proceed?s yes/nos Got it?s
yes/no/cancels Want it?s try agains
Try again?N( t tkCommonDialogR R+ R& R- R) t ABORTRETRYIGNORER' R0 R8 R. R4 t ABORTR9 t IGNORER5 R R R R6 R% R( R* R, R/ R2 R3 R7 R: R ( ( ( s+ /usr/lib64/python2.7/lib-tk/tkMessageBox.pyt <module> sH
Tix.py 0000644 00000226637 15032720555 0005706 0 ustar 00 # Tix.py -- Tix widget wrappers.
#
# For Tix, see http://tix.sourceforge.net
#
# - Sudhir Shenoy (sshenoy@gol.com), Dec. 1995.
# based on an idea of Jean-Marc Lugrin (lugrin@ms.com)
#
# NOTE: In order to minimize changes to Tkinter.py, some of the code here
# (TixWidget.__init__) has been taken from Tkinter (Widget.__init__)
# and will break if there are major changes in Tkinter.
#
# The Tix widgets are represented by a class hierarchy in python with proper
# inheritance of base classes.
#
# As a result after creating a 'w = StdButtonBox', I can write
# w.ok['text'] = 'Who Cares'
# or w.ok['bg'] = w['bg']
# or even w.ok.invoke()
# etc.
#
# Compare the demo tixwidgets.py to the original Tcl program and you will
# appreciate the advantages.
#
import os
import Tkinter
from Tkinter import *
from Tkinter import _flatten, _cnfmerge
# WARNING - TkVersion is a limited precision floating point number
if TkVersion < 3.999:
raise ImportError, "This version of Tix.py requires Tk 4.0 or higher"
import _tkinter # If this fails your Python may not be configured for Tk
# Some more constants (for consistency with Tkinter)
WINDOW = 'window'
TEXT = 'text'
STATUS = 'status'
IMMEDIATE = 'immediate'
IMAGE = 'image'
IMAGETEXT = 'imagetext'
BALLOON = 'balloon'
AUTO = 'auto'
ACROSSTOP = 'acrosstop'
# A few useful constants for the Grid widget
ASCII = 'ascii'
CELL = 'cell'
COLUMN = 'column'
DECREASING = 'decreasing'
INCREASING = 'increasing'
INTEGER = 'integer'
MAIN = 'main'
MAX = 'max'
REAL = 'real'
ROW = 'row'
S_REGION = 's-region'
X_REGION = 'x-region'
Y_REGION = 'y-region'
# Some constants used by Tkinter dooneevent()
TCL_DONT_WAIT = 1 << 1
TCL_WINDOW_EVENTS = 1 << 2
TCL_FILE_EVENTS = 1 << 3
TCL_TIMER_EVENTS = 1 << 4
TCL_IDLE_EVENTS = 1 << 5
TCL_ALL_EVENTS = 0
# BEWARE - this is implemented by copying some code from the Widget class
# in Tkinter (to override Widget initialization) and is therefore
# liable to break.
# Could probably add this to Tkinter.Misc
class tixCommand:
"""The tix commands provide access to miscellaneous elements
of Tix's internal state and the Tix application context.
Most of the information manipulated by these commands pertains
to the application as a whole, or to a screen or
display, rather than to a particular window.
This is a mixin class, assumed to be mixed to Tkinter.Tk
that supports the self.tk.call method.
"""
def tix_addbitmapdir(self, directory):
"""Tix maintains a list of directories under which
the tix_getimage and tix_getbitmap commands will
search for image files. The standard bitmap directory
is $TIX_LIBRARY/bitmaps. The addbitmapdir command
adds directory into this list. By using this
command, the image files of an applications can
also be located using the tix_getimage or tix_getbitmap
command.
"""
return self.tk.call('tix', 'addbitmapdir', directory)
def tix_cget(self, option):
"""Returns the current value of the configuration
option given by option. Option may be any of the
options described in the CONFIGURATION OPTIONS section.
"""
return self.tk.call('tix', 'cget', option)
def tix_configure(self, cnf=None, **kw):
"""Query or modify the configuration options of the Tix application
context. If no option is specified, returns a dictionary all of the
available options. If option is specified with no value, then the
command returns a list describing the one named option (this list
will be identical to the corresponding sublist of the value
returned if no option is specified). If one or more option-value
pairs are specified, then the command modifies the given option(s)
to have the given value(s); in this case the command returns an
empty string. Option may be any of the configuration options.
"""
# Copied from Tkinter.py
if kw:
cnf = _cnfmerge((cnf, kw))
elif cnf:
cnf = _cnfmerge(cnf)
if cnf is None:
return self._getconfigure('tix', 'configure')
if isinstance(cnf, StringType):
return self._getconfigure1('tix', 'configure', '-'+cnf)
return self.tk.call(('tix', 'configure') + self._options(cnf))
def tix_filedialog(self, dlgclass=None):
"""Returns the file selection dialog that may be shared among
different calls from this application. This command will create a
file selection dialog widget when it is called the first time. This
dialog will be returned by all subsequent calls to tix_filedialog.
An optional dlgclass parameter can be passed to specified what type
of file selection dialog widget is desired. Possible options are
tix FileSelectDialog or tixExFileSelectDialog.
"""
if dlgclass is not None:
return self.tk.call('tix', 'filedialog', dlgclass)
else:
return self.tk.call('tix', 'filedialog')
def tix_getbitmap(self, name):
"""Locates a bitmap file of the name name.xpm or name in one of the
bitmap directories (see the tix_addbitmapdir command above). By
using tix_getbitmap, you can avoid hard coding the pathnames of the
bitmap files in your application. When successful, it returns the
complete pathname of the bitmap file, prefixed with the character
'@'. The returned value can be used to configure the -bitmap
option of the TK and Tix widgets.
"""
return self.tk.call('tix', 'getbitmap', name)
def tix_getimage(self, name):
"""Locates an image file of the name name.xpm, name.xbm or name.ppm
in one of the bitmap directories (see the addbitmapdir command
above). If more than one file with the same name (but different
extensions) exist, then the image type is chosen according to the
depth of the X display: xbm images are chosen on monochrome
displays and color images are chosen on color displays. By using
tix_ getimage, you can avoid hard coding the pathnames of the
image files in your application. When successful, this command
returns the name of the newly created image, which can be used to
configure the -image option of the Tk and Tix widgets.
"""
return self.tk.call('tix', 'getimage', name)
def tix_option_get(self, name):
"""Gets the options maintained by the Tix
scheme mechanism. Available options include:
active_bg active_fg bg
bold_font dark1_bg dark1_fg
dark2_bg dark2_fg disabled_fg
fg fixed_font font
inactive_bg inactive_fg input1_bg
input2_bg italic_font light1_bg
light1_fg light2_bg light2_fg
menu_font output1_bg output2_bg
select_bg select_fg selector
"""
# could use self.tk.globalgetvar('tixOption', name)
return self.tk.call('tix', 'option', 'get', name)
def tix_resetoptions(self, newScheme, newFontSet, newScmPrio=None):
"""Resets the scheme and fontset of the Tix application to
newScheme and newFontSet, respectively. This affects only those
widgets created after this call. Therefore, it is best to call the
resetoptions command before the creation of any widgets in a Tix
application.
The optional parameter newScmPrio can be given to reset the
priority level of the Tk options set by the Tix schemes.
Because of the way Tk handles the X option database, after Tix has
been has imported and inited, it is not possible to reset the color
schemes and font sets using the tix config command. Instead, the
tix_resetoptions command must be used.
"""
if newScmPrio is not None:
return self.tk.call('tix', 'resetoptions', newScheme, newFontSet, newScmPrio)
else:
return self.tk.call('tix', 'resetoptions', newScheme, newFontSet)
class Tk(Tkinter.Tk, tixCommand):
"""Toplevel widget of Tix which represents mostly the main window
of an application. It has an associated Tcl interpreter."""
def __init__(self, screenName=None, baseName=None, className='Tix'):
Tkinter.Tk.__init__(self, screenName, baseName, className)
tixlib = os.environ.get('TIX_LIBRARY')
self.tk.eval('global auto_path; lappend auto_path [file dir [info nameof]]')
if tixlib is not None:
self.tk.eval('global auto_path; lappend auto_path {%s}' % tixlib)
self.tk.eval('global tcl_pkgPath; lappend tcl_pkgPath {%s}' % tixlib)
# Load Tix - this should work dynamically or statically
# If it's static, tcl/tix8.1/pkgIndex.tcl should have
# 'load {} Tix'
# If it's dynamic under Unix, tcl/tix8.1/pkgIndex.tcl should have
# 'load libtix8.1.8.3.so Tix'
self.tk.eval('package require Tix')
def destroy(self):
# For safety, remove the delete_window binding before destroy
self.protocol("WM_DELETE_WINDOW", "")
Tkinter.Tk.destroy(self)
# The Tix 'tixForm' geometry manager
class Form:
"""The Tix Form geometry manager
Widgets can be arranged by specifying attachments to other widgets.
See Tix documentation for complete details"""
def config(self, cnf={}, **kw):
self.tk.call('tixForm', self._w, *self._options(cnf, kw))
form = config
def __setitem__(self, key, value):
Form.form(self, {key: value})
def check(self):
return self.tk.call('tixForm', 'check', self._w)
def forget(self):
self.tk.call('tixForm', 'forget', self._w)
def grid(self, xsize=0, ysize=0):
if (not xsize) and (not ysize):
x = self.tk.call('tixForm', 'grid', self._w)
y = self.tk.splitlist(x)
z = ()
for x in y:
z = z + (self.tk.getint(x),)
return z
return self.tk.call('tixForm', 'grid', self._w, xsize, ysize)
def info(self, option=None):
if not option:
return self.tk.call('tixForm', 'info', self._w)
if option[0] != '-':
option = '-' + option
return self.tk.call('tixForm', 'info', self._w, option)
def slaves(self):
return map(self._nametowidget,
self.tk.splitlist(
self.tk.call(
'tixForm', 'slaves', self._w)))
Tkinter.Widget.__bases__ = Tkinter.Widget.__bases__ + (Form,)
class TixWidget(Tkinter.Widget):
"""A TixWidget class is used to package all (or most) Tix widgets.
Widget initialization is extended in two ways:
1) It is possible to give a list of options which must be part of
the creation command (so called Tix 'static' options). These cannot be
given as a 'config' command later.
2) It is possible to give the name of an existing TK widget. These are
child widgets created automatically by a Tix mega-widget. The Tk call
to create these widgets is therefore bypassed in TixWidget.__init__
Both options are for use by subclasses only.
"""
def __init__ (self, master=None, widgetName=None,
static_options=None, cnf={}, kw={}):
# Merge keywords and dictionary arguments
if kw:
cnf = _cnfmerge((cnf, kw))
else:
cnf = _cnfmerge(cnf)
# Move static options into extra. static_options must be
# a list of keywords (or None).
extra=()
# 'options' is always a static option
if static_options:
static_options.append('options')
else:
static_options = ['options']
for k,v in cnf.items()[:]:
if k in static_options:
extra = extra + ('-' + k, v)
del cnf[k]
self.widgetName = widgetName
Widget._setup(self, master, cnf)
# If widgetName is None, this is a dummy creation call where the
# corresponding Tk widget has already been created by Tix
if widgetName:
self.tk.call(widgetName, self._w, *extra)
# Non-static options - to be done via a 'config' command
if cnf:
Widget.config(self, cnf)
# Dictionary to hold subwidget names for easier access. We can't
# use the children list because the public Tix names may not be the
# same as the pathname component
self.subwidget_list = {}
# We set up an attribute access function so that it is possible to
# do w.ok['text'] = 'Hello' rather than w.subwidget('ok')['text'] = 'Hello'
# when w is a StdButtonBox.
# We can even do w.ok.invoke() because w.ok is subclassed from the
# Button class if you go through the proper constructors
def __getattr__(self, name):
if name in self.subwidget_list:
return self.subwidget_list[name]
raise AttributeError, name
def set_silent(self, value):
"""Set a variable without calling its action routine"""
self.tk.call('tixSetSilent', self._w, value)
def subwidget(self, name):
"""Return the named subwidget (which must have been created by
the sub-class)."""
n = self._subwidget_name(name)
if not n:
raise TclError, "Subwidget " + name + " not child of " + self._name
# Remove header of name and leading dot
n = n[len(self._w)+1:]
return self._nametowidget(n)
def subwidgets_all(self):
"""Return all subwidgets."""
names = self._subwidget_names()
if not names:
return []
retlist = []
for name in names:
name = name[len(self._w)+1:]
try:
retlist.append(self._nametowidget(name))
except:
# some of the widgets are unknown e.g. border in LabelFrame
pass
return retlist
def _subwidget_name(self,name):
"""Get a subwidget name (returns a String, not a Widget !)"""
try:
return self.tk.call(self._w, 'subwidget', name)
except TclError:
return None
def _subwidget_names(self):
"""Return the name of all subwidgets."""
try:
x = self.tk.call(self._w, 'subwidgets', '-all')
return self.tk.splitlist(x)
except TclError:
return None
def config_all(self, option, value):
"""Set configuration options for all subwidgets (and self)."""
if option == '':
return
elif not isinstance(option, StringType):
option = repr(option)
if not isinstance(value, StringType):
value = repr(value)
names = self._subwidget_names()
for name in names:
self.tk.call(name, 'configure', '-' + option, value)
# These are missing from Tkinter
def image_create(self, imgtype, cnf={}, master=None, **kw):
if not master:
master = Tkinter._default_root
if not master:
raise RuntimeError, 'Too early to create image'
if kw and cnf: cnf = _cnfmerge((cnf, kw))
elif kw: cnf = kw
options = ()
for k, v in cnf.items():
if hasattr(v, '__call__'):
v = self._register(v)
options = options + ('-'+k, v)
return master.tk.call(('image', 'create', imgtype,) + options)
def image_delete(self, imgname):
try:
self.tk.call('image', 'delete', imgname)
except TclError:
# May happen if the root was destroyed
pass
# Subwidgets are child widgets created automatically by mega-widgets.
# In python, we have to create these subwidgets manually to mirror their
# existence in Tk/Tix.
class TixSubWidget(TixWidget):
"""Subwidget class.
This is used to mirror child widgets automatically created
by Tix/Tk as part of a mega-widget in Python (which is not informed
of this)"""
def __init__(self, master, name,
destroy_physically=1, check_intermediate=1):
if check_intermediate:
path = master._subwidget_name(name)
try:
path = path[len(master._w)+1:]
plist = path.split('.')
except:
plist = []
if not check_intermediate:
# immediate descendant
TixWidget.__init__(self, master, None, None, {'name' : name})
else:
# Ensure that the intermediate widgets exist
parent = master
for i in range(len(plist) - 1):
n = '.'.join(plist[:i+1])
try:
w = master._nametowidget(n)
parent = w
except KeyError:
# Create the intermediate widget
parent = TixSubWidget(parent, plist[i],
destroy_physically=0,
check_intermediate=0)
# The Tk widget name is in plist, not in name
if plist:
name = plist[-1]
TixWidget.__init__(self, parent, None, None, {'name' : name})
self.destroy_physically = destroy_physically
def destroy(self):
# For some widgets e.g., a NoteBook, when we call destructors,
# we must be careful not to destroy the frame widget since this
# also destroys the parent NoteBook thus leading to an exception
# in Tkinter when it finally calls Tcl to destroy the NoteBook
for c in self.children.values(): c.destroy()
if self._name in self.master.children:
del self.master.children[self._name]
if self._name in self.master.subwidget_list:
del self.master.subwidget_list[self._name]
if self.destroy_physically:
# This is bypassed only for a few widgets
self.tk.call('destroy', self._w)
# Useful class to create a display style - later shared by many items.
# Contributed by Steffen Kremser
class DisplayStyle:
"""DisplayStyle - handle configuration options shared by
(multiple) Display Items"""
def __init__(self, itemtype, cnf={}, **kw):
if 'refwindow' in kw:
master = kw['refwindow']
elif 'refwindow' in cnf:
master = cnf['refwindow']
else:
master = Tkinter._default_root
if not master:
raise RuntimeError("Too early to create display style: no root window")
self.tk = master.tk
self.stylename = self.tk.call('tixDisplayStyle', itemtype,
*self._options(cnf,kw) )
def __str__(self):
return self.stylename
def _options(self, cnf, kw):
if kw and cnf:
cnf = _cnfmerge((cnf, kw))
elif kw:
cnf = kw
opts = ()
for k, v in cnf.items():
opts = opts + ('-'+k, v)
return opts
def delete(self):
self.tk.call(self.stylename, 'delete')
def __setitem__(self,key,value):
self.tk.call(self.stylename, 'configure', '-%s'%key, value)
def config(self, cnf={}, **kw):
return self._getconfigure(
self.stylename, 'configure', *self._options(cnf,kw))
def __getitem__(self,key):
return self.tk.call(self.stylename, 'cget', '-%s'%key)
######################################################
### The Tix Widget classes - in alphabetical order ###
######################################################
class Balloon(TixWidget):
"""Balloon help widget.
Subwidget Class
--------- -----
label Label
message Message"""
# FIXME: It should inherit -superclass tixShell
def __init__(self, master=None, cnf={}, **kw):
# static seem to be -installcolormap -initwait -statusbar -cursor
static = ['options', 'installcolormap', 'initwait', 'statusbar',
'cursor']
TixWidget.__init__(self, master, 'tixBalloon', static, cnf, kw)
self.subwidget_list['label'] = _dummyLabel(self, 'label',
destroy_physically=0)
self.subwidget_list['message'] = _dummyLabel(self, 'message',
destroy_physically=0)
def bind_widget(self, widget, cnf={}, **kw):
"""Bind balloon widget to another.
One balloon widget may be bound to several widgets at the same time"""
self.tk.call(self._w, 'bind', widget._w, *self._options(cnf, kw))
def unbind_widget(self, widget):
self.tk.call(self._w, 'unbind', widget._w)
class ButtonBox(TixWidget):
"""ButtonBox - A container for pushbuttons.
Subwidgets are the buttons added with the add method.
"""
def __init__(self, master=None, cnf={}, **kw):
TixWidget.__init__(self, master, 'tixButtonBox',
['orientation', 'options'], cnf, kw)
def add(self, name, cnf={}, **kw):
"""Add a button with given name to box."""
btn = self.tk.call(self._w, 'add', name, *self._options(cnf, kw))
self.subwidget_list[name] = _dummyButton(self, name)
return btn
def invoke(self, name):
if name in self.subwidget_list:
self.tk.call(self._w, 'invoke', name)
class ComboBox(TixWidget):
"""ComboBox - an Entry field with a dropdown menu. The user can select a
choice by either typing in the entry subwidget or selecting from the
listbox subwidget.
Subwidget Class
--------- -----
entry Entry
arrow Button
slistbox ScrolledListBox
tick Button
cross Button : present if created with the fancy option"""
# FIXME: It should inherit -superclass tixLabelWidget
def __init__ (self, master=None, cnf={}, **kw):
TixWidget.__init__(self, master, 'tixComboBox',
['editable', 'dropdown', 'fancy', 'options'],
cnf, kw)
self.subwidget_list['label'] = _dummyLabel(self, 'label')
self.subwidget_list['entry'] = _dummyEntry(self, 'entry')
self.subwidget_list['arrow'] = _dummyButton(self, 'arrow')
self.subwidget_list['slistbox'] = _dummyScrolledListBox(self,
'slistbox')
try:
self.subwidget_list['tick'] = _dummyButton(self, 'tick')
self.subwidget_list['cross'] = _dummyButton(self, 'cross')
except TypeError:
# unavailable when -fancy not specified
pass
# align
def add_history(self, str):
self.tk.call(self._w, 'addhistory', str)
def append_history(self, str):
self.tk.call(self._w, 'appendhistory', str)
def insert(self, index, str):
self.tk.call(self._w, 'insert', index, str)
def pick(self, index):
self.tk.call(self._w, 'pick', index)
class Control(TixWidget):
"""Control - An entry field with value change arrows. The user can
adjust the value by pressing the two arrow buttons or by entering
the value directly into the entry. The new value will be checked
against the user-defined upper and lower limits.
Subwidget Class
--------- -----
incr Button
decr Button
entry Entry
label Label"""
# FIXME: It should inherit -superclass tixLabelWidget
def __init__ (self, master=None, cnf={}, **kw):
TixWidget.__init__(self, master, 'tixControl', ['options'], cnf, kw)
self.subwidget_list['incr'] = _dummyButton(self, 'incr')
self.subwidget_list['decr'] = _dummyButton(self, 'decr')
self.subwidget_list['label'] = _dummyLabel(self, 'label')
self.subwidget_list['entry'] = _dummyEntry(self, 'entry')
def decrement(self):
self.tk.call(self._w, 'decr')
def increment(self):
self.tk.call(self._w, 'incr')
def invoke(self):
self.tk.call(self._w, 'invoke')
def update(self):
self.tk.call(self._w, 'update')
class DirList(TixWidget):
"""DirList - displays a list view of a directory, its previous
directories and its sub-directories. The user can choose one of
the directories displayed in the list or change to another directory.
Subwidget Class
--------- -----
hlist HList
hsb Scrollbar
vsb Scrollbar"""
# FIXME: It should inherit -superclass tixScrolledHList
def __init__(self, master, cnf={}, **kw):
TixWidget.__init__(self, master, 'tixDirList', ['options'], cnf, kw)
self.subwidget_list['hlist'] = _dummyHList(self, 'hlist')
self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb')
self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb')
def chdir(self, dir):
self.tk.call(self._w, 'chdir', dir)
class DirTree(TixWidget):
"""DirTree - Directory Listing in a hierarchical view.
Displays a tree view of a directory, its previous directories and its
sub-directories. The user can choose one of the directories displayed
in the list or change to another directory.
Subwidget Class
--------- -----
hlist HList
hsb Scrollbar
vsb Scrollbar"""
# FIXME: It should inherit -superclass tixScrolledHList
def __init__(self, master, cnf={}, **kw):
TixWidget.__init__(self, master, 'tixDirTree', ['options'], cnf, kw)
self.subwidget_list['hlist'] = _dummyHList(self, 'hlist')
self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb')
self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb')
def chdir(self, dir):
self.tk.call(self._w, 'chdir', dir)
class DirSelectBox(TixWidget):
"""DirSelectBox - Motif style file select box.
It is generally used for
the user to choose a file. FileSelectBox stores the files mostly
recently selected into a ComboBox widget so that they can be quickly
selected again.
Subwidget Class
--------- -----
selection ComboBox
filter ComboBox
dirlist ScrolledListBox
filelist ScrolledListBox"""
def __init__(self, master, cnf={}, **kw):
TixWidget.__init__(self, master, 'tixDirSelectBox', ['options'], cnf, kw)
self.subwidget_list['dirlist'] = _dummyDirList(self, 'dirlist')
self.subwidget_list['dircbx'] = _dummyFileComboBox(self, 'dircbx')
class ExFileSelectBox(TixWidget):
"""ExFileSelectBox - MS Windows style file select box.
It provides a convenient method for the user to select files.
Subwidget Class
--------- -----
cancel Button
ok Button
hidden Checkbutton
types ComboBox
dir ComboBox
file ComboBox
dirlist ScrolledListBox
filelist ScrolledListBox"""
def __init__(self, master, cnf={}, **kw):
TixWidget.__init__(self, master, 'tixExFileSelectBox', ['options'], cnf, kw)
self.subwidget_list['cancel'] = _dummyButton(self, 'cancel')
self.subwidget_list['ok'] = _dummyButton(self, 'ok')
self.subwidget_list['hidden'] = _dummyCheckbutton(self, 'hidden')
self.subwidget_list['types'] = _dummyComboBox(self, 'types')
self.subwidget_list['dir'] = _dummyComboBox(self, 'dir')
self.subwidget_list['dirlist'] = _dummyDirList(self, 'dirlist')
self.subwidget_list['file'] = _dummyComboBox(self, 'file')
self.subwidget_list['filelist'] = _dummyScrolledListBox(self, 'filelist')
def filter(self):
self.tk.call(self._w, 'filter')
def invoke(self):
self.tk.call(self._w, 'invoke')
# Should inherit from a Dialog class
class DirSelectDialog(TixWidget):
"""The DirSelectDialog widget presents the directories in the file
system in a dialog window. The user can use this dialog window to
navigate through the file system to select the desired directory.
Subwidgets Class
---------- -----
dirbox DirSelectDialog"""
# FIXME: It should inherit -superclass tixDialogShell
def __init__(self, master, cnf={}, **kw):
TixWidget.__init__(self, master, 'tixDirSelectDialog',
['options'], cnf, kw)
self.subwidget_list['dirbox'] = _dummyDirSelectBox(self, 'dirbox')
# cancel and ok buttons are missing
def popup(self):
self.tk.call(self._w, 'popup')
def popdown(self):
self.tk.call(self._w, 'popdown')
# Should inherit from a Dialog class
class ExFileSelectDialog(TixWidget):
"""ExFileSelectDialog - MS Windows style file select dialog.
It provides a convenient method for the user to select files.
Subwidgets Class
---------- -----
fsbox ExFileSelectBox"""
# FIXME: It should inherit -superclass tixDialogShell
def __init__(self, master, cnf={}, **kw):
TixWidget.__init__(self, master, 'tixExFileSelectDialog',
['options'], cnf, kw)
self.subwidget_list['fsbox'] = _dummyExFileSelectBox(self, 'fsbox')
def popup(self):
self.tk.call(self._w, 'popup')
def popdown(self):
self.tk.call(self._w, 'popdown')
class FileSelectBox(TixWidget):
"""ExFileSelectBox - Motif style file select box.
It is generally used for
the user to choose a file. FileSelectBox stores the files mostly
recently selected into a ComboBox widget so that they can be quickly
selected again.
Subwidget Class
--------- -----
selection ComboBox
filter ComboBox
dirlist ScrolledListBox
filelist ScrolledListBox"""
def __init__(self, master, cnf={}, **kw):
TixWidget.__init__(self, master, 'tixFileSelectBox', ['options'], cnf, kw)
self.subwidget_list['dirlist'] = _dummyScrolledListBox(self, 'dirlist')
self.subwidget_list['filelist'] = _dummyScrolledListBox(self, 'filelist')
self.subwidget_list['filter'] = _dummyComboBox(self, 'filter')
self.subwidget_list['selection'] = _dummyComboBox(self, 'selection')
def apply_filter(self): # name of subwidget is same as command
self.tk.call(self._w, 'filter')
def invoke(self):
self.tk.call(self._w, 'invoke')
# Should inherit from a Dialog class
class FileSelectDialog(TixWidget):
"""FileSelectDialog - Motif style file select dialog.
Subwidgets Class
---------- -----
btns StdButtonBox
fsbox FileSelectBox"""
# FIXME: It should inherit -superclass tixStdDialogShell
def __init__(self, master, cnf={}, **kw):
TixWidget.__init__(self, master, 'tixFileSelectDialog',
['options'], cnf, kw)
self.subwidget_list['btns'] = _dummyStdButtonBox(self, 'btns')
self.subwidget_list['fsbox'] = _dummyFileSelectBox(self, 'fsbox')
def popup(self):
self.tk.call(self._w, 'popup')
def popdown(self):
self.tk.call(self._w, 'popdown')
class FileEntry(TixWidget):
"""FileEntry - Entry field with button that invokes a FileSelectDialog.
The user can type in the filename manually. Alternatively, the user can
press the button widget that sits next to the entry, which will bring
up a file selection dialog.
Subwidgets Class
---------- -----
button Button
entry Entry"""
# FIXME: It should inherit -superclass tixLabelWidget
def __init__(self, master, cnf={}, **kw):
TixWidget.__init__(self, master, 'tixFileEntry',
['dialogtype', 'options'], cnf, kw)
self.subwidget_list['button'] = _dummyButton(self, 'button')
self.subwidget_list['entry'] = _dummyEntry(self, 'entry')
def invoke(self):
self.tk.call(self._w, 'invoke')
def file_dialog(self):
# FIXME: return python object
pass
class HList(TixWidget, XView, YView):
"""HList - Hierarchy display widget can be used to display any data
that have a hierarchical structure, for example, file system directory
trees. The list entries are indented and connected by branch lines
according to their places in the hierarchy.
Subwidgets - None"""
def __init__ (self,master=None,cnf={}, **kw):
TixWidget.__init__(self, master, 'tixHList',
['columns', 'options'], cnf, kw)
def add(self, entry, cnf={}, **kw):
return self.tk.call(self._w, 'add', entry, *self._options(cnf, kw))
def add_child(self, parent=None, cnf={}, **kw):
if not parent:
parent = ''
return self.tk.call(
self._w, 'addchild', parent, *self._options(cnf, kw))
def anchor_set(self, entry):
self.tk.call(self._w, 'anchor', 'set', entry)
def anchor_clear(self):
self.tk.call(self._w, 'anchor', 'clear')
def column_width(self, col=0, width=None, chars=None):
if not chars:
return self.tk.call(self._w, 'column', 'width', col, width)
else:
return self.tk.call(self._w, 'column', 'width', col,
'-char', chars)
def delete_all(self):
self.tk.call(self._w, 'delete', 'all')
def delete_entry(self, entry):
self.tk.call(self._w, 'delete', 'entry', entry)
def delete_offsprings(self, entry):
self.tk.call(self._w, 'delete', 'offsprings', entry)
def delete_siblings(self, entry):
self.tk.call(self._w, 'delete', 'siblings', entry)
def dragsite_set(self, index):
self.tk.call(self._w, 'dragsite', 'set', index)
def dragsite_clear(self):
self.tk.call(self._w, 'dragsite', 'clear')
def dropsite_set(self, index):
self.tk.call(self._w, 'dropsite', 'set', index)
def dropsite_clear(self):
self.tk.call(self._w, 'dropsite', 'clear')
def header_create(self, col, cnf={}, **kw):
self.tk.call(self._w, 'header', 'create', col, *self._options(cnf, kw))
def header_configure(self, col, cnf={}, **kw):
if cnf is None:
return self._getconfigure(self._w, 'header', 'configure', col)
self.tk.call(self._w, 'header', 'configure', col,
*self._options(cnf, kw))
def header_cget(self, col, opt):
return self.tk.call(self._w, 'header', 'cget', col, opt)
def header_exists(self, col):
# A workaround to Tix library bug (issue #25464).
# The documented command is "exists", but only erroneous "exist" is
# accepted.
return self.tk.getboolean(self.tk.call(self._w, 'header', 'exist', col))
header_exist = header_exists
def header_delete(self, col):
self.tk.call(self._w, 'header', 'delete', col)
def header_size(self, col):
return self.tk.call(self._w, 'header', 'size', col)
def hide_entry(self, entry):
self.tk.call(self._w, 'hide', 'entry', entry)
def indicator_create(self, entry, cnf={}, **kw):
self.tk.call(
self._w, 'indicator', 'create', entry, *self._options(cnf, kw))
def indicator_configure(self, entry, cnf={}, **kw):
if cnf is None:
return self._getconfigure(
self._w, 'indicator', 'configure', entry)
self.tk.call(
self._w, 'indicator', 'configure', entry, *self._options(cnf, kw))
def indicator_cget(self, entry, opt):
return self.tk.call(self._w, 'indicator', 'cget', entry, opt)
def indicator_exists(self, entry):
return self.tk.call (self._w, 'indicator', 'exists', entry)
def indicator_delete(self, entry):
self.tk.call(self._w, 'indicator', 'delete', entry)
def indicator_size(self, entry):
return self.tk.call(self._w, 'indicator', 'size', entry)
def info_anchor(self):
return self.tk.call(self._w, 'info', 'anchor')
def info_bbox(self, entry):
return self._getints(
self.tk.call(self._w, 'info', 'bbox', entry)) or None
def info_children(self, entry=None):
c = self.tk.call(self._w, 'info', 'children', entry)
return self.tk.splitlist(c)
def info_data(self, entry):
return self.tk.call(self._w, 'info', 'data', entry)
def info_dragsite(self):
return self.tk.call(self._w, 'info', 'dragsite')
def info_dropsite(self):
return self.tk.call(self._w, 'info', 'dropsite')
def info_exists(self, entry):
return self.tk.call(self._w, 'info', 'exists', entry)
def info_hidden(self, entry):
return self.tk.call(self._w, 'info', 'hidden', entry)
def info_next(self, entry):
return self.tk.call(self._w, 'info', 'next', entry)
def info_parent(self, entry):
return self.tk.call(self._w, 'info', 'parent', entry)
def info_prev(self, entry):
return self.tk.call(self._w, 'info', 'prev', entry)
def info_selection(self):
c = self.tk.call(self._w, 'info', 'selection')
return self.tk.splitlist(c)
def item_cget(self, entry, col, opt):
return self.tk.call(self._w, 'item', 'cget', entry, col, opt)
def item_configure(self, entry, col, cnf={}, **kw):
if cnf is None:
return self._getconfigure(self._w, 'item', 'configure', entry, col)
self.tk.call(self._w, 'item', 'configure', entry, col,
*self._options(cnf, kw))
def item_create(self, entry, col, cnf={}, **kw):
self.tk.call(
self._w, 'item', 'create', entry, col, *self._options(cnf, kw))
def item_exists(self, entry, col):
return self.tk.call(self._w, 'item', 'exists', entry, col)
def item_delete(self, entry, col):
self.tk.call(self._w, 'item', 'delete', entry, col)
def entrycget(self, entry, opt):
return self.tk.call(self._w, 'entrycget', entry, opt)
def entryconfigure(self, entry, cnf={}, **kw):
if cnf is None:
return self._getconfigure(self._w, 'entryconfigure', entry)
self.tk.call(self._w, 'entryconfigure', entry,
*self._options(cnf, kw))
def nearest(self, y):
return self.tk.call(self._w, 'nearest', y)
def see(self, entry):
self.tk.call(self._w, 'see', entry)
def selection_clear(self, cnf={}, **kw):
self.tk.call(self._w, 'selection', 'clear', *self._options(cnf, kw))
def selection_includes(self, entry):
return self.tk.call(self._w, 'selection', 'includes', entry)
def selection_set(self, first, last=None):
self.tk.call(self._w, 'selection', 'set', first, last)
def show_entry(self, entry):
return self.tk.call(self._w, 'show', 'entry', entry)
class InputOnly(TixWidget):
"""InputOnly - Invisible widget. Unix only.
Subwidgets - None"""
def __init__ (self,master=None,cnf={}, **kw):
TixWidget.__init__(self, master, 'tixInputOnly', None, cnf, kw)
class LabelEntry(TixWidget):
"""LabelEntry - Entry field with label. Packages an entry widget
and a label into one mega widget. It can be used to simplify the creation
of ``entry-form'' type of interface.
Subwidgets Class
---------- -----
label Label
entry Entry"""
def __init__ (self,master=None,cnf={}, **kw):
TixWidget.__init__(self, master, 'tixLabelEntry',
['labelside','options'], cnf, kw)
self.subwidget_list['label'] = _dummyLabel(self, 'label')
self.subwidget_list['entry'] = _dummyEntry(self, 'entry')
class LabelFrame(TixWidget):
"""LabelFrame - Labelled Frame container. Packages a frame widget
and a label into one mega widget. To create widgets inside a
LabelFrame widget, one creates the new widgets relative to the
frame subwidget and manage them inside the frame subwidget.
Subwidgets Class
---------- -----
label Label
frame Frame"""
def __init__ (self,master=None,cnf={}, **kw):
TixWidget.__init__(self, master, 'tixLabelFrame',
['labelside','options'], cnf, kw)
self.subwidget_list['label'] = _dummyLabel(self, 'label')
self.subwidget_list['frame'] = _dummyFrame(self, 'frame')
class ListNoteBook(TixWidget):
"""A ListNoteBook widget is very similar to the TixNoteBook widget:
it can be used to display many windows in a limited space using a
notebook metaphor. The notebook is divided into a stack of pages
(windows). At one time only one of these pages can be shown.
The user can navigate through these pages by
choosing the name of the desired page in the hlist subwidget."""
def __init__(self, master, cnf={}, **kw):
TixWidget.__init__(self, master, 'tixListNoteBook', ['options'], cnf, kw)
# Is this necessary? It's not an exposed subwidget in Tix.
self.subwidget_list['pane'] = _dummyPanedWindow(self, 'pane',
destroy_physically=0)
self.subwidget_list['hlist'] = _dummyHList(self, 'hlist')
self.subwidget_list['shlist'] = _dummyScrolledHList(self, 'shlist')
def add(self, name, cnf={}, **kw):
self.tk.call(self._w, 'add', name, *self._options(cnf, kw))
self.subwidget_list[name] = TixSubWidget(self, name)
return self.subwidget_list[name]
def page(self, name):
return self.subwidget(name)
def pages(self):
# Can't call subwidgets_all directly because we don't want .nbframe
names = self.tk.split(self.tk.call(self._w, 'pages'))
ret = []
for x in names:
ret.append(self.subwidget(x))
return ret
def raise_page(self, name): # raise is a python keyword
self.tk.call(self._w, 'raise', name)
class Meter(TixWidget):
"""The Meter widget can be used to show the progress of a background
job which may take a long time to execute.
"""
def __init__(self, master=None, cnf={}, **kw):
TixWidget.__init__(self, master, 'tixMeter',
['options'], cnf, kw)
class NoteBook(TixWidget):
"""NoteBook - Multi-page container widget (tabbed notebook metaphor).
Subwidgets Class
---------- -----
nbframe NoteBookFrame
<pages> page widgets added dynamically with the add method"""
def __init__ (self,master=None,cnf={}, **kw):
TixWidget.__init__(self,master,'tixNoteBook', ['options'], cnf, kw)
self.subwidget_list['nbframe'] = TixSubWidget(self, 'nbframe',
destroy_physically=0)
def add(self, name, cnf={}, **kw):
self.tk.call(self._w, 'add', name, *self._options(cnf, kw))
self.subwidget_list[name] = TixSubWidget(self, name)
return self.subwidget_list[name]
def delete(self, name):
self.tk.call(self._w, 'delete', name)
self.subwidget_list[name].destroy()
del self.subwidget_list[name]
def page(self, name):
return self.subwidget(name)
def pages(self):
# Can't call subwidgets_all directly because we don't want .nbframe
names = self.tk.split(self.tk.call(self._w, 'pages'))
ret = []
for x in names:
ret.append(self.subwidget(x))
return ret
def raise_page(self, name): # raise is a python keyword
self.tk.call(self._w, 'raise', name)
def raised(self):
return self.tk.call(self._w, 'raised')
class NoteBookFrame(TixWidget):
# FIXME: This is dangerous to expose to be called on its own.
pass
class OptionMenu(TixWidget):
"""OptionMenu - creates a menu button of options.
Subwidget Class
--------- -----
menubutton Menubutton
menu Menu"""
def __init__(self, master, cnf={}, **kw):
TixWidget.__init__(self, master, 'tixOptionMenu',
['labelside', 'options'], cnf, kw)
self.subwidget_list['menubutton'] = _dummyMenubutton(self, 'menubutton')
self.subwidget_list['menu'] = _dummyMenu(self, 'menu')
def add_command(self, name, cnf={}, **kw):
self.tk.call(self._w, 'add', 'command', name, *self._options(cnf, kw))
def add_separator(self, name, cnf={}, **kw):
self.tk.call(self._w, 'add', 'separator', name, *self._options(cnf, kw))
def delete(self, name):
self.tk.call(self._w, 'delete', name)
def disable(self, name):
self.tk.call(self._w, 'disable', name)
def enable(self, name):
self.tk.call(self._w, 'enable', name)
class PanedWindow(TixWidget):
"""PanedWindow - Multi-pane container widget
allows the user to interactively manipulate the sizes of several
panes. The panes can be arranged either vertically or horizontally.The
user changes the sizes of the panes by dragging the resize handle
between two panes.
Subwidgets Class
---------- -----
<panes> g/p widgets added dynamically with the add method."""
def __init__(self, master, cnf={}, **kw):
TixWidget.__init__(self, master, 'tixPanedWindow', ['orientation', 'options'], cnf, kw)
# add delete forget panecget paneconfigure panes setsize
def add(self, name, cnf={}, **kw):
self.tk.call(self._w, 'add', name, *self._options(cnf, kw))
self.subwidget_list[name] = TixSubWidget(self, name,
check_intermediate=0)
return self.subwidget_list[name]
def delete(self, name):
self.tk.call(self._w, 'delete', name)
self.subwidget_list[name].destroy()
del self.subwidget_list[name]
def forget(self, name):
self.tk.call(self._w, 'forget', name)
def panecget(self, entry, opt):
return self.tk.call(self._w, 'panecget', entry, opt)
def paneconfigure(self, entry, cnf={}, **kw):
if cnf is None:
return self._getconfigure(self._w, 'paneconfigure', entry)
self.tk.call(self._w, 'paneconfigure', entry, *self._options(cnf, kw))
def panes(self):
names = self.tk.splitlist(self.tk.call(self._w, 'panes'))
return [self.subwidget(x) for x in names]
class PopupMenu(TixWidget):
"""PopupMenu widget can be used as a replacement of the tk_popup command.
The advantage of the Tix PopupMenu widget is it requires less application
code to manipulate.
Subwidgets Class
---------- -----
menubutton Menubutton
menu Menu"""
# FIXME: It should inherit -superclass tixShell
def __init__(self, master, cnf={}, **kw):
TixWidget.__init__(self, master, 'tixPopupMenu', ['options'], cnf, kw)
self.subwidget_list['menubutton'] = _dummyMenubutton(self, 'menubutton')
self.subwidget_list['menu'] = _dummyMenu(self, 'menu')
def bind_widget(self, widget):
self.tk.call(self._w, 'bind', widget._w)
def unbind_widget(self, widget):
self.tk.call(self._w, 'unbind', widget._w)
def post_widget(self, widget, x, y):
self.tk.call(self._w, 'post', widget._w, x, y)
class ResizeHandle(TixWidget):
"""Internal widget to draw resize handles on Scrolled widgets."""
def __init__(self, master, cnf={}, **kw):
# There seems to be a Tix bug rejecting the configure method
# Let's try making the flags -static
flags = ['options', 'command', 'cursorfg', 'cursorbg',
'handlesize', 'hintcolor', 'hintwidth',
'x', 'y']
# In fact, x y height width are configurable
TixWidget.__init__(self, master, 'tixResizeHandle',
flags, cnf, kw)
def attach_widget(self, widget):
self.tk.call(self._w, 'attachwidget', widget._w)
def detach_widget(self, widget):
self.tk.call(self._w, 'detachwidget', widget._w)
def hide(self, widget):
self.tk.call(self._w, 'hide', widget._w)
def show(self, widget):
self.tk.call(self._w, 'show', widget._w)
class ScrolledHList(TixWidget):
"""ScrolledHList - HList with automatic scrollbars."""
# FIXME: It should inherit -superclass tixScrolledWidget
def __init__(self, master, cnf={}, **kw):
TixWidget.__init__(self, master, 'tixScrolledHList', ['options'],
cnf, kw)
self.subwidget_list['hlist'] = _dummyHList(self, 'hlist')
self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb')
self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb')
class ScrolledListBox(TixWidget):
"""ScrolledListBox - Listbox with automatic scrollbars."""
# FIXME: It should inherit -superclass tixScrolledWidget
def __init__(self, master, cnf={}, **kw):
TixWidget.__init__(self, master, 'tixScrolledListBox', ['options'], cnf, kw)
self.subwidget_list['listbox'] = _dummyListbox(self, 'listbox')
self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb')
self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb')
class ScrolledText(TixWidget):
"""ScrolledText - Text with automatic scrollbars."""
# FIXME: It should inherit -superclass tixScrolledWidget
def __init__(self, master, cnf={}, **kw):
TixWidget.__init__(self, master, 'tixScrolledText', ['options'], cnf, kw)
self.subwidget_list['text'] = _dummyText(self, 'text')
self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb')
self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb')
class ScrolledTList(TixWidget):
"""ScrolledTList - TList with automatic scrollbars."""
# FIXME: It should inherit -superclass tixScrolledWidget
def __init__(self, master, cnf={}, **kw):
TixWidget.__init__(self, master, 'tixScrolledTList', ['options'],
cnf, kw)
self.subwidget_list['tlist'] = _dummyTList(self, 'tlist')
self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb')
self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb')
class ScrolledWindow(TixWidget):
"""ScrolledWindow - Window with automatic scrollbars."""
# FIXME: It should inherit -superclass tixScrolledWidget
def __init__(self, master, cnf={}, **kw):
TixWidget.__init__(self, master, 'tixScrolledWindow', ['options'], cnf, kw)
self.subwidget_list['window'] = _dummyFrame(self, 'window')
self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb')
self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb')
class Select(TixWidget):
"""Select - Container of button subwidgets. It can be used to provide
radio-box or check-box style of selection options for the user.
Subwidgets are buttons added dynamically using the add method."""
# FIXME: It should inherit -superclass tixLabelWidget
def __init__(self, master, cnf={}, **kw):
TixWidget.__init__(self, master, 'tixSelect',
['allowzero', 'radio', 'orientation', 'labelside',
'options'],
cnf, kw)
self.subwidget_list['label'] = _dummyLabel(self, 'label')
def add(self, name, cnf={}, **kw):
self.tk.call(self._w, 'add', name, *self._options(cnf, kw))
self.subwidget_list[name] = _dummyButton(self, name)
return self.subwidget_list[name]
def invoke(self, name):
self.tk.call(self._w, 'invoke', name)
class Shell(TixWidget):
"""Toplevel window.
Subwidgets - None"""
def __init__ (self,master=None,cnf={}, **kw):
TixWidget.__init__(self, master, 'tixShell', ['options', 'title'], cnf, kw)
class DialogShell(TixWidget):
"""Toplevel window, with popup popdown and center methods.
It tells the window manager that it is a dialog window and should be
treated specially. The exact treatment depends on the treatment of
the window manager.
Subwidgets - None"""
# FIXME: It should inherit from Shell
def __init__ (self,master=None,cnf={}, **kw):
TixWidget.__init__(self, master,
'tixDialogShell',
['options', 'title', 'mapped',
'minheight', 'minwidth',
'parent', 'transient'], cnf, kw)
def popdown(self):
self.tk.call(self._w, 'popdown')
def popup(self):
self.tk.call(self._w, 'popup')
def center(self):
self.tk.call(self._w, 'center')
class StdButtonBox(TixWidget):
"""StdButtonBox - Standard Button Box (OK, Apply, Cancel and Help) """
def __init__(self, master=None, cnf={}, **kw):
TixWidget.__init__(self, master, 'tixStdButtonBox',
['orientation', 'options'], cnf, kw)
self.subwidget_list['ok'] = _dummyButton(self, 'ok')
self.subwidget_list['apply'] = _dummyButton(self, 'apply')
self.subwidget_list['cancel'] = _dummyButton(self, 'cancel')
self.subwidget_list['help'] = _dummyButton(self, 'help')
def invoke(self, name):
if name in self.subwidget_list:
self.tk.call(self._w, 'invoke', name)
class TList(TixWidget, XView, YView):
"""TList - Hierarchy display widget which can be
used to display data in a tabular format. The list entries of a TList
widget are similar to the entries in the Tk listbox widget. The main
differences are (1) the TList widget can display the list entries in a
two dimensional format and (2) you can use graphical images as well as
multiple colors and fonts for the list entries.
Subwidgets - None"""
def __init__ (self,master=None,cnf={}, **kw):
TixWidget.__init__(self, master, 'tixTList', ['options'], cnf, kw)
def active_set(self, index):
self.tk.call(self._w, 'active', 'set', index)
def active_clear(self):
self.tk.call(self._w, 'active', 'clear')
def anchor_set(self, index):
self.tk.call(self._w, 'anchor', 'set', index)
def anchor_clear(self):
self.tk.call(self._w, 'anchor', 'clear')
def delete(self, from_, to=None):
self.tk.call(self._w, 'delete', from_, to)
def dragsite_set(self, index):
self.tk.call(self._w, 'dragsite', 'set', index)
def dragsite_clear(self):
self.tk.call(self._w, 'dragsite', 'clear')
def dropsite_set(self, index):
self.tk.call(self._w, 'dropsite', 'set', index)
def dropsite_clear(self):
self.tk.call(self._w, 'dropsite', 'clear')
def insert(self, index, cnf={}, **kw):
self.tk.call(self._w, 'insert', index, *self._options(cnf, kw))
def info_active(self):
return self.tk.call(self._w, 'info', 'active')
def info_anchor(self):
return self.tk.call(self._w, 'info', 'anchor')
def info_down(self, index):
return self.tk.call(self._w, 'info', 'down', index)
def info_left(self, index):
return self.tk.call(self._w, 'info', 'left', index)
def info_right(self, index):
return self.tk.call(self._w, 'info', 'right', index)
def info_selection(self):
c = self.tk.call(self._w, 'info', 'selection')
return self.tk.splitlist(c)
def info_size(self):
return self.tk.call(self._w, 'info', 'size')
def info_up(self, index):
return self.tk.call(self._w, 'info', 'up', index)
def nearest(self, x, y):
return self.tk.call(self._w, 'nearest', x, y)
def see(self, index):
self.tk.call(self._w, 'see', index)
def selection_clear(self, cnf={}, **kw):
self.tk.call(self._w, 'selection', 'clear', *self._options(cnf, kw))
def selection_includes(self, index):
return self.tk.call(self._w, 'selection', 'includes', index)
def selection_set(self, first, last=None):
self.tk.call(self._w, 'selection', 'set', first, last)
class Tree(TixWidget):
"""Tree - The tixTree widget can be used to display hierarchical
data in a tree form. The user can adjust
the view of the tree by opening or closing parts of the tree."""
# FIXME: It should inherit -superclass tixScrolledWidget
def __init__(self, master=None, cnf={}, **kw):
TixWidget.__init__(self, master, 'tixTree',
['options'], cnf, kw)
self.subwidget_list['hlist'] = _dummyHList(self, 'hlist')
self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb')
self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb')
def autosetmode(self):
'''This command calls the setmode method for all the entries in this
Tree widget: if an entry has no child entries, its mode is set to
none. Otherwise, if the entry has any hidden child entries, its mode is
set to open; otherwise its mode is set to close.'''
self.tk.call(self._w, 'autosetmode')
def close(self, entrypath):
'''Close the entry given by entryPath if its mode is close.'''
self.tk.call(self._w, 'close', entrypath)
def getmode(self, entrypath):
'''Returns the current mode of the entry given by entryPath.'''
return self.tk.call(self._w, 'getmode', entrypath)
def open(self, entrypath):
'''Open the entry given by entryPath if its mode is open.'''
self.tk.call(self._w, 'open', entrypath)
def setmode(self, entrypath, mode='none'):
'''This command is used to indicate whether the entry given by
entryPath has children entries and whether the children are visible. mode
must be one of open, close or none. If mode is set to open, a (+)
indicator is drawn next to the entry. If mode is set to close, a (-)
indicator is drawn next to the entry. If mode is set to none, no
indicators will be drawn for this entry. The default mode is none. The
open mode indicates the entry has hidden children and this entry can be
opened by the user. The close mode indicates that all the children of the
entry are now visible and the entry can be closed by the user.'''
self.tk.call(self._w, 'setmode', entrypath, mode)
# Could try subclassing Tree for CheckList - would need another arg to init
class CheckList(TixWidget):
"""The CheckList widget
displays a list of items to be selected by the user. CheckList acts
similarly to the Tk checkbutton or radiobutton widgets, except it is
capable of handling many more items than checkbuttons or radiobuttons.
"""
# FIXME: It should inherit -superclass tixTree
def __init__(self, master=None, cnf={}, **kw):
TixWidget.__init__(self, master, 'tixCheckList',
['options', 'radio'], cnf, kw)
self.subwidget_list['hlist'] = _dummyHList(self, 'hlist')
self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb')
self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb')
def autosetmode(self):
'''This command calls the setmode method for all the entries in this
Tree widget: if an entry has no child entries, its mode is set to
none. Otherwise, if the entry has any hidden child entries, its mode is
set to open; otherwise its mode is set to close.'''
self.tk.call(self._w, 'autosetmode')
def close(self, entrypath):
'''Close the entry given by entryPath if its mode is close.'''
self.tk.call(self._w, 'close', entrypath)
def getmode(self, entrypath):
'''Returns the current mode of the entry given by entryPath.'''
return self.tk.call(self._w, 'getmode', entrypath)
def open(self, entrypath):
'''Open the entry given by entryPath if its mode is open.'''
self.tk.call(self._w, 'open', entrypath)
def getselection(self, mode='on'):
'''Returns a list of items whose status matches status. If status is
not specified, the list of items in the "on" status will be returned.
Mode can be on, off, default'''
c = self.tk.split(self.tk.call(self._w, 'getselection', mode))
return self.tk.splitlist(c)
def getstatus(self, entrypath):
'''Returns the current status of entryPath.'''
return self.tk.call(self._w, 'getstatus', entrypath)
def setstatus(self, entrypath, mode='on'):
'''Sets the status of entryPath to be status. A bitmap will be
displayed next to the entry its status is on, off or default.'''
self.tk.call(self._w, 'setstatus', entrypath, mode)
###########################################################################
### The subclassing below is used to instantiate the subwidgets in each ###
### mega widget. This allows us to access their methods directly. ###
###########################################################################
class _dummyButton(Button, TixSubWidget):
def __init__(self, master, name, destroy_physically=1):
TixSubWidget.__init__(self, master, name, destroy_physically)
class _dummyCheckbutton(Checkbutton, TixSubWidget):
def __init__(self, master, name, destroy_physically=1):
TixSubWidget.__init__(self, master, name, destroy_physically)
class _dummyEntry(Entry, TixSubWidget):
def __init__(self, master, name, destroy_physically=1):
TixSubWidget.__init__(self, master, name, destroy_physically)
class _dummyFrame(Frame, TixSubWidget):
def __init__(self, master, name, destroy_physically=1):
TixSubWidget.__init__(self, master, name, destroy_physically)
class _dummyLabel(Label, TixSubWidget):
def __init__(self, master, name, destroy_physically=1):
TixSubWidget.__init__(self, master, name, destroy_physically)
class _dummyListbox(Listbox, TixSubWidget):
def __init__(self, master, name, destroy_physically=1):
TixSubWidget.__init__(self, master, name, destroy_physically)
class _dummyMenu(Menu, TixSubWidget):
def __init__(self, master, name, destroy_physically=1):
TixSubWidget.__init__(self, master, name, destroy_physically)
class _dummyMenubutton(Menubutton, TixSubWidget):
def __init__(self, master, name, destroy_physically=1):
TixSubWidget.__init__(self, master, name, destroy_physically)
class _dummyScrollbar(Scrollbar, TixSubWidget):
def __init__(self, master, name, destroy_physically=1):
TixSubWidget.__init__(self, master, name, destroy_physically)
class _dummyText(Text, TixSubWidget):
def __init__(self, master, name, destroy_physically=1):
TixSubWidget.__init__(self, master, name, destroy_physically)
class _dummyScrolledListBox(ScrolledListBox, TixSubWidget):
def __init__(self, master, name, destroy_physically=1):
TixSubWidget.__init__(self, master, name, destroy_physically)
self.subwidget_list['listbox'] = _dummyListbox(self, 'listbox')
self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb')
self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb')
class _dummyHList(HList, TixSubWidget):
def __init__(self, master, name, destroy_physically=1):
TixSubWidget.__init__(self, master, name, destroy_physically)
class _dummyScrolledHList(ScrolledHList, TixSubWidget):
def __init__(self, master, name, destroy_physically=1):
TixSubWidget.__init__(self, master, name, destroy_physically)
self.subwidget_list['hlist'] = _dummyHList(self, 'hlist')
self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb')
self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb')
class _dummyTList(TList, TixSubWidget):
def __init__(self, master, name, destroy_physically=1):
TixSubWidget.__init__(self, master, name, destroy_physically)
class _dummyComboBox(ComboBox, TixSubWidget):
def __init__(self, master, name, destroy_physically=1):
TixSubWidget.__init__(self, master, name, ['fancy',destroy_physically])
self.subwidget_list['label'] = _dummyLabel(self, 'label')
self.subwidget_list['entry'] = _dummyEntry(self, 'entry')
self.subwidget_list['arrow'] = _dummyButton(self, 'arrow')
self.subwidget_list['slistbox'] = _dummyScrolledListBox(self,
'slistbox')
try:
self.subwidget_list['tick'] = _dummyButton(self, 'tick')
#cross Button : present if created with the fancy option
self.subwidget_list['cross'] = _dummyButton(self, 'cross')
except TypeError:
# unavailable when -fancy not specified
pass
class _dummyDirList(DirList, TixSubWidget):
def __init__(self, master, name, destroy_physically=1):
TixSubWidget.__init__(self, master, name, destroy_physically)
self.subwidget_list['hlist'] = _dummyHList(self, 'hlist')
self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb')
self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb')
class _dummyDirSelectBox(DirSelectBox, TixSubWidget):
def __init__(self, master, name, destroy_physically=1):
TixSubWidget.__init__(self, master, name, destroy_physically)
self.subwidget_list['dirlist'] = _dummyDirList(self, 'dirlist')
self.subwidget_list['dircbx'] = _dummyFileComboBox(self, 'dircbx')
class _dummyExFileSelectBox(ExFileSelectBox, TixSubWidget):
def __init__(self, master, name, destroy_physically=1):
TixSubWidget.__init__(self, master, name, destroy_physically)
self.subwidget_list['cancel'] = _dummyButton(self, 'cancel')
self.subwidget_list['ok'] = _dummyButton(self, 'ok')
self.subwidget_list['hidden'] = _dummyCheckbutton(self, 'hidden')
self.subwidget_list['types'] = _dummyComboBox(self, 'types')
self.subwidget_list['dir'] = _dummyComboBox(self, 'dir')
self.subwidget_list['dirlist'] = _dummyScrolledListBox(self, 'dirlist')
self.subwidget_list['file'] = _dummyComboBox(self, 'file')
self.subwidget_list['filelist'] = _dummyScrolledListBox(self, 'filelist')
class _dummyFileSelectBox(FileSelectBox, TixSubWidget):
def __init__(self, master, name, destroy_physically=1):
TixSubWidget.__init__(self, master, name, destroy_physically)
self.subwidget_list['dirlist'] = _dummyScrolledListBox(self, 'dirlist')
self.subwidget_list['filelist'] = _dummyScrolledListBox(self, 'filelist')
self.subwidget_list['filter'] = _dummyComboBox(self, 'filter')
self.subwidget_list['selection'] = _dummyComboBox(self, 'selection')
class _dummyFileComboBox(ComboBox, TixSubWidget):
def __init__(self, master, name, destroy_physically=1):
TixSubWidget.__init__(self, master, name, destroy_physically)
self.subwidget_list['dircbx'] = _dummyComboBox(self, 'dircbx')
class _dummyStdButtonBox(StdButtonBox, TixSubWidget):
def __init__(self, master, name, destroy_physically=1):
TixSubWidget.__init__(self, master, name, destroy_physically)
self.subwidget_list['ok'] = _dummyButton(self, 'ok')
self.subwidget_list['apply'] = _dummyButton(self, 'apply')
self.subwidget_list['cancel'] = _dummyButton(self, 'cancel')
self.subwidget_list['help'] = _dummyButton(self, 'help')
class _dummyNoteBookFrame(NoteBookFrame, TixSubWidget):
def __init__(self, master, name, destroy_physically=0):
TixSubWidget.__init__(self, master, name, destroy_physically)
class _dummyPanedWindow(PanedWindow, TixSubWidget):
def __init__(self, master, name, destroy_physically=1):
TixSubWidget.__init__(self, master, name, destroy_physically)
########################
### Utility Routines ###
########################
#mike Should tixDestroy be exposed as a wrapper? - but not for widgets.
def OptionName(widget):
'''Returns the qualified path name for the widget. Normally used to set
default options for subwidgets. See tixwidgets.py'''
return widget.tk.call('tixOptionName', widget._w)
# Called with a dictionary argument of the form
# {'*.c':'C source files', '*.txt':'Text Files', '*':'All files'}
# returns a string which can be used to configure the fsbox file types
# in an ExFileSelectBox. i.e.,
# '{{*} {* - All files}} {{*.c} {*.c - C source files}} {{*.txt} {*.txt - Text Files}}'
def FileTypeList(dict):
s = ''
for type in dict.keys():
s = s + '{{' + type + '} {' + type + ' - ' + dict[type] + '}} '
return s
# Still to be done:
# tixIconView
class CObjView(TixWidget):
"""This file implements the Canvas Object View widget. This is a base
class of IconView. It implements automatic placement/adjustment of the
scrollbars according to the canvas objects inside the canvas subwidget.
The scrollbars are adjusted so that the canvas is just large enough
to see all the objects.
"""
# FIXME: It should inherit -superclass tixScrolledWidget
pass
class Grid(TixWidget, XView, YView):
'''The Tix Grid command creates a new window and makes it into a
tixGrid widget. Additional options, may be specified on the command
line or in the option database to configure aspects such as its cursor
and relief.
A Grid widget displays its contents in a two dimensional grid of cells.
Each cell may contain one Tix display item, which may be in text,
graphics or other formats. See the DisplayStyle class for more information
about Tix display items. Individual cells, or groups of cells, can be
formatted with a wide range of attributes, such as its color, relief and
border.
Subwidgets - None'''
# valid specific resources as of Tk 8.4
# editdonecmd, editnotifycmd, floatingcols, floatingrows, formatcmd,
# highlightbackground, highlightcolor, leftmargin, itemtype, selectmode,
# selectunit, topmargin,
def __init__(self, master=None, cnf={}, **kw):
static= []
self.cnf= cnf
TixWidget.__init__(self, master, 'tixGrid', static, cnf, kw)
# valid options as of Tk 8.4
# anchor, bdtype, cget, configure, delete, dragsite, dropsite, entrycget,
# edit, entryconfigure, format, geometryinfo, info, index, move, nearest,
# selection, set, size, unset, xview, yview
def anchor_clear(self):
"""Removes the selection anchor."""
self.tk.call(self, 'anchor', 'clear')
def anchor_get(self):
"Get the (x,y) coordinate of the current anchor cell"
return self._getints(self.tk.call(self, 'anchor', 'get'))
def anchor_set(self, x, y):
"""Set the selection anchor to the cell at (x, y)."""
self.tk.call(self, 'anchor', 'set', x, y)
def delete_row(self, from_, to=None):
"""Delete rows between from_ and to inclusive.
If to is not provided, delete only row at from_"""
if to is None:
self.tk.call(self, 'delete', 'row', from_)
else:
self.tk.call(self, 'delete', 'row', from_, to)
def delete_column(self, from_, to=None):
"""Delete columns between from_ and to inclusive.
If to is not provided, delete only column at from_"""
if to is None:
self.tk.call(self, 'delete', 'column', from_)
else:
self.tk.call(self, 'delete', 'column', from_, to)
def edit_apply(self):
"""If any cell is being edited, de-highlight the cell and applies
the changes."""
self.tk.call(self, 'edit', 'apply')
def edit_set(self, x, y):
"""Highlights the cell at (x, y) for editing, if the -editnotify
command returns True for this cell."""
self.tk.call(self, 'edit', 'set', x, y)
def entrycget(self, x, y, option):
"Get the option value for cell at (x,y)"
if option and option[0] != '-':
option = '-' + option
return self.tk.call(self, 'entrycget', x, y, option)
def entryconfigure(self, x, y, cnf=None, **kw):
return self._configure(('entryconfigure', x, y), cnf, kw)
# def format
# def index
def info_exists(self, x, y):
"Return True if display item exists at (x,y)"
return self._getboolean(self.tk.call(self, 'info', 'exists', x, y))
def info_bbox(self, x, y):
# This seems to always return '', at least for 'text' displayitems
return self.tk.call(self, 'info', 'bbox', x, y)
def move_column(self, from_, to, offset):
"""Moves the range of columns from position FROM through TO by
the distance indicated by OFFSET. For example, move_column(2, 4, 1)
moves the columns 2,3,4 to columns 3,4,5."""
self.tk.call(self, 'move', 'column', from_, to, offset)
def move_row(self, from_, to, offset):
"""Moves the range of rows from position FROM through TO by
the distance indicated by OFFSET.
For example, move_row(2, 4, 1) moves the rows 2,3,4 to rows 3,4,5."""
self.tk.call(self, 'move', 'row', from_, to, offset)
def nearest(self, x, y):
"Return coordinate of cell nearest pixel coordinate (x,y)"
return self._getints(self.tk.call(self, 'nearest', x, y))
# def selection adjust
# def selection clear
# def selection includes
# def selection set
# def selection toggle
def set(self, x, y, itemtype=None, **kw):
args= self._options(self.cnf, kw)
if itemtype is not None:
args= ('-itemtype', itemtype) + args
self.tk.call(self, 'set', x, y, *args)
def size_column(self, index, **kw):
"""Queries or sets the size of the column given by
INDEX. INDEX may be any non-negative
integer that gives the position of a given column.
INDEX can also be the string "default"; in this case, this command
queries or sets the default size of all columns.
When no option-value pair is given, this command returns a tuple
containing the current size setting of the given column. When
option-value pairs are given, the corresponding options of the
size setting of the given column are changed. Options may be one
of the follwing:
pad0 pixels
Specifies the paddings to the left of a column.
pad1 pixels
Specifies the paddings to the right of a column.
size val
Specifies the width of a column. Val may be:
"auto" -- the width of the column is set to the
width of the widest cell in the column;
a valid Tk screen distance unit;
or a real number following by the word chars
(e.g. 3.4chars) that sets the width of the column to the
given number of characters."""
return self.tk.split(self.tk.call(self._w, 'size', 'column', index,
*self._options({}, kw)))
def size_row(self, index, **kw):
"""Queries or sets the size of the row given by
INDEX. INDEX may be any non-negative
integer that gives the position of a given row .
INDEX can also be the string "default"; in this case, this command
queries or sets the default size of all rows.
When no option-value pair is given, this command returns a list con-
taining the current size setting of the given row . When option-value
pairs are given, the corresponding options of the size setting of the
given row are changed. Options may be one of the follwing:
pad0 pixels
Specifies the paddings to the top of a row.
pad1 pixels
Specifies the paddings to the bottom of a row.
size val
Specifies the height of a row. Val may be:
"auto" -- the height of the row is set to the
height of the highest cell in the row;
a valid Tk screen distance unit;
or a real number following by the word chars
(e.g. 3.4chars) that sets the height of the row to the
given number of characters."""
return self.tk.split(self.tk.call(
self, 'size', 'row', index, *self._options({}, kw)))
def unset(self, x, y):
"""Clears the cell at (x, y) by removing its display item."""
self.tk.call(self._w, 'unset', x, y)
class ScrolledGrid(Grid):
'''Scrolled Grid widgets'''
# FIXME: It should inherit -superclass tixScrolledWidget
def __init__(self, master=None, cnf={}, **kw):
static= []
self.cnf= cnf
TixWidget.__init__(self, master, 'tixScrolledGrid', static, cnf, kw)
Tix.pyo 0000644 00000273532 15032720555 0006061 0 ustar 00 �
z fc @ sx d d l Z d d l Z d d l Td d l m Z m Z e d k rP e d � n d d l Z d Z d Z d Z d Z
d
Z d Z d Z
d
Z d Z d Z d Z d Z d Z d Z d Z d Z d Z d Z d Z d Z d Z d Z d� Z d� Z d� Z d� Z d� Z! d! Z" d" d� d# � � YZ# d$ e j$ e# f d% � � YZ$ d& d� d' � � YZ% e j& j' e% f e j& _' d( e j& f d) � � YZ( d* e( f d+ � � YZ) d, d� d- � � YZ* d. e( f d/ � � YZ+ d0 e( f d1 � � YZ, d2 e( f d3 � � YZ- d4 e( f d5 � � YZ. d6 e( f d7 � � YZ/ d8 e( f d9 � � YZ0 d: e( f d; � � YZ1 d< e( f d= � � YZ2 d> e( f d? � � YZ3 d@ e( f dA � � YZ4 dB e( f dC � � YZ5 dD e( f dE � � YZ6 dF e( f dG � � YZ7 dH e( e8 e9 f dI � � YZ: dJ e( f dK � � YZ; dL e( f dM � � YZ< dN e( f dO � � YZ= dP e( f dQ � � YZ> dR e( f dS � � YZ? dT e( f dU � � YZ@ dV e( f dW � � YZA dX e( f dY � � YZB dZ e( f d[ � � YZC d\ e( f d] � � YZD d^ e( f d_ � � YZE d` e( f da � � YZF db e( f dc � � YZG dd e( f de � � YZH df e( f dg � � YZI dh e( f di � � YZJ dj e( f dk � � YZK dl e( f dm � � YZL dn e( f do � � YZM dp e( f dq � � YZN dr e( e8 e9 f ds � � YZO dt e( f du � � YZP dv e( f dw � � YZQ dx eR e) f dy � � YZS dz eT e) f d{ � � YZU d| eV e) f d} � � YZW d~ eX e) f d � � YZY d� eZ e) f d� � � YZ[ d� e\ e) f d� � � YZ] d� e^ e) f d� � � YZ_ d� e` e) f d� � � YZa d� eb e) f d� � � YZc d� ed e) f d� � � YZe d� eG e) f d� � � YZf d� e: e) f d� � � YZg d� eF e) f d� � � YZh d� eO e) f d� � � YZi d� e- e) f d� � � YZj d� e/ e) f d� � � YZk d� e1 e) f d� � � YZl d� e2 e) f d� � � YZm d� e5 e) f d� � � YZn d� e- e) f d� � � YZo d� eN e) f d� � � YZp d� eA e) f d� � � YZq d� eC e) f d� � � YZr d� � Zs d� � Zt d� e( f d� � � YZu d� e( e8 e9 f d� � � YZv d� ev f d� � � YZw d S(� i����N( t *( t _flattent _cnfmergegˡE��@s0 This version of Tix.py requires Tk 4.0 or highert windowt textt statust immediatet imaget imagetextt balloont autot acrosstopt asciit cellt columnt
decreasingt
increasingt integert maint maxt realt rows s-regions x-regions y-regioni i i i i i t
tixCommandc B s_ e Z d Z d � Z d � Z d d � Z d d � Z d � Z d � Z d � Z
d d � Z RS(
s� The tix commands provide access to miscellaneous elements
of Tix's internal state and the Tix application context.
Most of the information manipulated by these commands pertains
to the application as a whole, or to a screen or
display, rather than to a particular window.
This is a mixin class, assumed to be mixed to Tkinter.Tk
that supports the self.tk.call method.
c C s | j j d d | � S( s� Tix maintains a list of directories under which
the tix_getimage and tix_getbitmap commands will
search for image files. The standard bitmap directory
is $TIX_LIBRARY/bitmaps. The addbitmapdir command
adds directory into this list. By using this
command, the image files of an applications can
also be located using the tix_getimage or tix_getbitmap
command.
t tixt addbitmapdir( t tkt call( t selft directory( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt tix_addbitmapdirV s
c C s | j j d d | � S( s� Returns the current value of the configuration
option given by option. Option may be any of the
options described in the CONFIGURATION OPTIONS section.
R t cget( R R ( R t option( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt tix_cgetb s c K s� | r t | | f � } n | r0 t | � } n | d k rL | j d d � St | t � rr | j d d d | � S| j j d | j | � � S( s� Query or modify the configuration options of the Tix application
context. If no option is specified, returns a dictionary all of the
available options. If option is specified with no value, then the
command returns a list describing the one named option (this list
will be identical to the corresponding sublist of the value
returned if no option is specified). If one or more option-value
pairs are specified, then the command modifies the given option(s)
to have the given value(s); in this case the command returns an
empty string. Option may be any of the configuration options.
R t configuret -N( R R! ( R t Nonet
_getconfiguret
isinstancet
StringTypet _getconfigure1R R t _options( R t cnft kw( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
tix_configurei s c C s9 | d k r" | j j d d | � S| j j d d � Sd S( s� Returns the file selection dialog that may be shared among
different calls from this application. This command will create a
file selection dialog widget when it is called the first time. This
dialog will be returned by all subsequent calls to tix_filedialog.
An optional dlgclass parameter can be passed to specified what type
of file selection dialog widget is desired. Possible options are
tix FileSelectDialog or tixExFileSelectDialog.
R t
filedialogN( R# R R ( R t dlgclass( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt tix_filedialog s c C s | j j d d | � S( s� Locates a bitmap file of the name name.xpm or name in one of the
bitmap directories (see the tix_addbitmapdir command above). By
using tix_getbitmap, you can avoid hard coding the pathnames of the
bitmap files in your application. When successful, it returns the
complete pathname of the bitmap file, prefixed with the character
'@'. The returned value can be used to configure the -bitmap
option of the TK and Tix widgets.
R t getbitmap( R R ( R t name( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
tix_getbitmap� s c C s | j j d d | � S( s� Locates an image file of the name name.xpm, name.xbm or name.ppm
in one of the bitmap directories (see the addbitmapdir command
above). If more than one file with the same name (but different
extensions) exist, then the image type is chosen according to the
depth of the X display: xbm images are chosen on monochrome
displays and color images are chosen on color displays. By using
tix_ getimage, you can avoid hard coding the pathnames of the
image files in your application. When successful, this command
returns the name of the newly created image, which can be used to
configure the -image option of the Tk and Tix widgets.
R t getimage( R R ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt tix_getimage� s c C s | j j d d d | � S( s@ Gets the options maintained by the Tix
scheme mechanism. Available options include:
active_bg active_fg bg
bold_font dark1_bg dark1_fg
dark2_bg dark2_fg disabled_fg
fg fixed_font font
inactive_bg inactive_fg input1_bg
input2_bg italic_font light1_bg
light1_fg light2_bg light2_fg
menu_font output1_bg output2_bg
select_bg select_fg selector
R R t get( R R ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt tix_option_get� s c C sE | d k r( | j j d d | | | � S| j j d d | | � Sd S( s� Resets the scheme and fontset of the Tix application to
newScheme and newFontSet, respectively. This affects only those
widgets created after this call. Therefore, it is best to call the
resetoptions command before the creation of any widgets in a Tix
application.
The optional parameter newScmPrio can be given to reset the
priority level of the Tk options set by the Tix schemes.
Because of the way Tk handles the X option database, after Tix has
been has imported and inited, it is not possible to reset the color
schemes and font sets using the tix config command. Instead, the
tix_resetoptions command must be used.
R t resetoptionsN( R# R R ( R t newSchemet
newFontSett
newScmPrio( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt tix_resetoptions� s N( t __name__t
__module__t __doc__R R R# R+ R. R1 R3 R5 R: ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR K s t Tkc B s) e Z d Z d d d d � Z d � Z RS( s{ Toplevel widget of Tix which represents mostly the main window
of an application. It has an associated Tcl interpreter.t Tixc C s� t j j | | | | � t j j d � } | j j d � | d k rr | j j d | � | j j d | � n | j j d � d S( Nt TIX_LIBRARYs< global auto_path; lappend auto_path [file dir [info nameof]]s( global auto_path; lappend auto_path {%s}s, global tcl_pkgPath; lappend tcl_pkgPath {%s}s package require Tix( t TkinterR> t __init__t ost environR4 R t evalR# ( R t
screenNamet baseNamet classNamet tixlib( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s c C s$ | j d d � t j j | � d S( Nt WM_DELETE_WINDOWt ( t protocolRA R> t destroy( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRM � s N( R; R< R= R# RB RM ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR> � s t Formc B s_ e Z d Z i d � Z e Z d � Z d � Z d � Z d d d � Z d d � Z
d � Z RS(
s� The Tix Form geometry manager
Widgets can be arranged by specifying attachments to other widgets.
See Tix documentation for complete detailsc K s) | j j d | j | j | | � � d S( Nt tixForm( R R t _wR( ( R R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt config� s c C s t j | i | | 6� d S( N( RN t form( R t keyt value( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt __setitem__� s c C s | j j d d | j � S( NRO t check( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRV � s c C s | j j d d | j � d S( NRO t forget( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRW � s i c C s� | ro | ro | j j d d | j � } | j j | � } d } x' | D] } | | j j | � f } qH W| S| j j d d | j | | � S( NRO t grid( ( R R RP t splitlistt getint( R t xsizet ysizet xt yt z( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRX � s
c C sX | s | j j d d | j � S| d d k r< d | } n | j j d d | j | � S( NRO t infoi R" ( R R RP ( R R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR` s
c C s1 t | j | j j | j j d d | j � � � S( NRO t slaves( t mapt
_nametowidgetR RY R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRa s N( R; R< R= RQ RR RU RV RW RX R# R` Ra ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRN � s
t TixWidgetc B s} e Z d Z d d d i i d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z i d d � Z d
� Z
RS( sQ A TixWidget class is used to package all (or most) Tix widgets.
Widget initialization is extended in two ways:
1) It is possible to give a list of options which must be part of
the creation command (so called Tix 'static' options). These cannot be
given as a 'config' command later.
2) It is possible to give the name of an existing TK widget. These are
child widgets created automatically by a Tix mega-widget. The Tk call
to create these widgets is therefore bypassed in TixWidget.__init__
Both options are for use by subclasses only.
c C s� | r t | | f � } n t | � } d } | rC | j d � n d g } xE | j � D]6 \ } } | | k rZ | d | | f } | | =qZ qZ W| | _ t j | | | � | r� | j j | | j | � n | r� t j | | � n i | _
d S( Nt optionsR" ( ( R t appendt itemst
widgetNamet Widgett _setupR R RP RQ t subwidget_list( R t masterRh t static_optionsR) R* t extrat kt v( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB s$ c C s' | | j k r | j | St | � d S( N( Rk t AttributeError( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt __getattr__K s c C s | j j d | j | � d S( s1 Set a variable without calling its action routinet tixSetSilentN( R R RP ( R RT ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
set_silentP s c C sT | j | � } | s0 t d | d | j � n | t | j � d } | j | � S( sS Return the named subwidget (which must have been created by
the sub-class).s
Subwidget s not child of i ( t _subwidget_namet TclErrort _namet lenRP Rc ( R R0 t n( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt subwidgetT s
c C sl | j � } | s g Sg } xI | D]A } | t | j � d } y | j | j | � � Wq# q# Xq# W| S( s Return all subwidgets.i ( t _subwidget_namesRx RP Rf Rc ( R t namest retlistR0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt subwidgets_all^ s
c C s6 y | j j | j d | � SWn t k
r1 d SXd S( s7 Get a subwidget name (returns a String, not a Widget !)Rz N( R R RP Rv R# ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRu m s
c C sH y/ | j j | j d d � } | j j | � SWn t k
rC d SXd S( s" Return the name of all subwidgets.t
subwidgetss -allN( R R RP RY Rv R# ( R R] ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR{ t s
c C s� | d k r d St | t � s. t | � } n t | t � sL t | � } n | j � } x+ | D]# } | j j | d d | | � q_ Wd S( s8 Set configuration options for all subwidgets (and self).RK NR! R" ( R% R& t reprR{ R R ( R R RT R| R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
config_all| s
c K s� | s$ t j } | s$ t d � q$ n | rE | rE t | | f � } n | rT | } n d } xO | j � D]A \ } } t | d � r� | j | � } n | d | | f } qg W| j j d d | f | � S( Ns Too early to create imaget __call__R" R t create( ( RA t
_default_roott RuntimeErrorR Rg t hasattrt _registerR R ( R t imgtypeR) Rl R* Re Ro Rp ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt image_create� s c C s2 y | j j d d | � Wn t k
r- n Xd S( NR t delete( R R Rv ( R t imgname( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt image_delete� s
N( R; R< R= R# RB Rr Rt Rz R~ Ru R{ R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRd s ,
t TixSubWidgetc B s& e Z d Z d d d � Z d � Z RS( s� Subwidget class.
This is used to mirror child widgets automatically created
by Tix/Tk as part of a mega-widget in Python (which is not informed
of this)i c C sE | rR | j | � } y* | t | j � d } | j d � } WqR g } qR Xn | s{ t j | | d d i | d 6� n� | } x� t t | � d � D]i } d j | | d � } y | j | � }
|
} Wq� t
k
r t | | | d d d d �} q� Xq� W| r| d } n t j | | d d i | d 6� | | _ d S( Ni t .R0 t destroy_physicallyi t check_intermediatei����(
Ru Rx RP t splitRd RB R# t ranget joinRc t KeyErrorR� R� ( R Rl R0 R� R� t patht plistt parentt iRy t w( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s.
#
c C s� x! | j j � D] } | j � q W| j | j j k rL | j j | j =n | j | j j k rt | j j | j =n | j r� | j j d | j � n d S( NRM (
t childrent valuesRM Rw Rl Rk R� R R RP ( R t c( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRM � s ( R; R< R= RB RM ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s t DisplayStylec B sS e Z d Z i d � Z d � Z d � Z d � Z d � Z i d � Z d � Z RS( sR DisplayStyle - handle configuration options shared by
(multiple) Display Itemsc K s� d | k r | d } n7 d | k r2 | d } n t j } | sP t d � � n | j | _ | j j d | | j | | � � | _ d S( Nt refwindows1 Too early to create display style: no root windowt tixDisplayStyle( RA R� R� R R R( t stylename( R t itemtypeR) R* Rl ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s
c C s | j S( N( R� ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt __str__� s c C sk | r! | r! t | | f � } n | r0 | } n d } x. | j � D] \ } } | d | | f } qC W| S( NR" ( ( R Rg ( R R) R* t optsRo Rp ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR( � s c C s | j j | j d � d S( NR� ( R R R� ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C s$ | j j | j d d | | � d S( NR! s -%s( R R R� ( R RS RT ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRU � s c K s" | j | j d | j | | � � S( NR! ( R$ R� R( ( R R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRQ � s c C s | j j | j d d | � S( NR s -%s( R R R� ( R RS ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt __getitem__� s (
R; R< R= RB R� R( R� RU RQ R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s
t Balloonc B s2 e Z d Z d i d � Z i d � Z d � Z RS( s Balloon help widget.
Subwidget Class
--------- -----
label Label
message Messagec K sm d d d d d g } t j | | d | | | � t | d d d �| j d <t | d
d d �| j d
<d S( NRe t installcolormapt initwaitt statusbart cursort
tixBalloont labelR� i t message( Rd RB t _dummyLabelRk ( R Rl R) R* t static( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB s c K s/ | j j | j d | j | j | | � � d S( sk Bind balloon widget to another.
One balloon widget may be bound to several widgets at the same timet bindN( R R RP R( ( R t widgetR) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt bind_widget s c C s | j j | j d | j � d S( Nt unbind( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
unbind_widget s N( R; R< R= R# RB R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� s
t ButtonBoxc B s2 e Z d Z d i d � Z i d � Z d � Z RS( sg ButtonBox - A container for pushbuttons.
Subwidgets are the buttons added with the add method.
c K s& t j | | d d d g | | � d S( Nt tixButtonBoxt orientationRe ( Rd RB ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB & s c K sD | j j | j d | | j | | � � } t | | � | j | <| S( s$ Add a button with given name to box.t add( R R RP R( t _dummyButtonRk ( R R0 R) R* t btn( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� * s *c C s/ | | j k r+ | j j | j d | � n d S( Nt invoke( Rk R R RP ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� 1 s N( R; R< R= R# RB R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� " s t ComboBoxc B sA e Z d Z d i d � Z d � Z d � Z d � Z d � Z RS( s� ComboBox - an Entry field with a dropdown menu. The user can select a
choice by either typing in the entry subwidget or selecting from the
listbox subwidget.
Subwidget Class
--------- -----
entry Entry
arrow Button
slistbox ScrolledListBox
tick Button
cross Button : present if created with the fancy optionc K s� t j | | d d d d d g | | � t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <y0 t | d
� | j d
<t | d � | j d <Wn t k
r� n Xd S( Nt tixComboBoxt editablet dropdownt fancyRe R� t entryt arrowt slistboxt tickt cross( Rd RB R� Rk t _dummyEntryR� t _dummyScrolledListBoxt TypeError( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB C s
c C s | j j | j d | � d S( Nt
addhistory( R R RP ( R t str( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt add_historyU s c C s | j j | j d | � d S( Nt
appendhistory( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt append_historyX s c C s | j j | j d | | � d S( Nt insert( R R RP ( R t indexR� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� [ s c C s | j j | j d | � d S( Nt pick( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� ^ s N( R; R< R= R# RB R� R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� 5 s t Controlc B sA e Z d Z d i d � Z d � Z d � Z d � Z d � Z RS( s� Control - An entry field with value change arrows. The user can
adjust the value by pressing the two arrow buttons or by entering
the value directly into the entry. The new value will be checked
against the user-defined upper and lower limits.
Subwidget Class
--------- -----
incr Button
decr Button
entry Entry
label Labelc K s{ t j | | d d g | | � t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <d S( Nt
tixControlRe t incrt decrR� R� ( Rd RB R� Rk R� R� ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB o s
c C s | j j | j d � d S( NR� ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt decrementv s c C s | j j | j d � d S( NR� ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt incrementy s c C s | j j | j d � d S( NR� ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� | s c C s | j j | j d � d S( Nt update( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� s N( R; R< R= R# RB R� R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� a s t DirListc B s# e Z d Z i d � Z d � Z RS( sR DirList - displays a list view of a directory, its previous
directories and its sub-directories. The user can choose one of
the directories displayed in the list or change to another directory.
Subwidget Class
--------- -----
hlist HList
hsb Scrollbar
vsb Scrollbarc K se t j | | d d g | | � t | d � | j d <t | d � | j d <t | d � | j d <d S( Nt
tixDirListRe t hlistt vsbt hsb( Rd RB t _dummyHListRk t _dummyScrollbar( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s c C s | j j | j d | � d S( Nt chdir( R R RP ( R t dir( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s ( R; R< R= RB R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s t DirTreec B s# e Z d Z i d � Z d � Z RS( s� DirTree - Directory Listing in a hierarchical view.
Displays a tree view of a directory, its previous directories and its
sub-directories. The user can choose one of the directories displayed
in the list or change to another directory.
Subwidget Class
--------- -----
hlist HList
hsb Scrollbar
vsb Scrollbarc K se t j | | d d g | | � t | d � | j d <t | d � | j d <t | d � | j d <d S( Nt
tixDirTreeRe R� R� R� ( Rd RB R� Rk R� ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s c C s | j j | j d | � d S( NR� ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s ( R; R< R= RB R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s
t DirSelectBoxc B s e Z d Z i d � Z RS( s� DirSelectBox - Motif style file select box.
It is generally used for
the user to choose a file. FileSelectBox stores the files mostly
recently selected into a ComboBox widget so that they can be quickly
selected again.
Subwidget Class
--------- -----
selection ComboBox
filter ComboBox
dirlist ScrolledListBox
filelist ScrolledListBoxc K sO t j | | d d g | | � t | d � | j d <t | d � | j d <d S( Nt tixDirSelectBoxRe t dirlistt dircbx( Rd RB t
_dummyDirListRk t _dummyFileComboBox( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s ( R; R< R= RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s t ExFileSelectBoxc B s, e Z d Z i d � Z d � Z d � Z RS( s� ExFileSelectBox - MS Windows style file select box.
It provides a convenient method for the user to select files.
Subwidget Class
--------- -----
cancel Button
ok Button
hidden Checkbutton
types ComboBox
dir ComboBox
file ComboBox
dirlist ScrolledListBox
filelist ScrolledListBoxc K s� t j | | d d g | | � t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <t | d
� | j d
<d S( Nt tixExFileSelectBoxRe t cancelt okt hiddent typesR� R� t filet filelist( Rd RB R� Rk t _dummyCheckbuttont _dummyComboBoxR� R� ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s c C s | j j | j d � d S( Nt filter( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C s | j j | j d � d S( NR� ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s ( R; R< R= RB R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s
t DirSelectDialogc B s, e Z d Z i d � Z d � Z d � Z RS( s# The DirSelectDialog widget presents the directories in the file
system in a dialog window. The user can use this dialog window to
navigate through the file system to select the desired directory.
Subwidgets Class
---------- -----
dirbox DirSelectDialogc K s9 t j | | d d g | | � t | d � | j d <d S( Nt tixDirSelectDialogRe t dirbox( Rd RB t _dummyDirSelectBoxRk ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s c C s | j j | j d � d S( Nt popup( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C s | j j | j d � d S( Nt popdown( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s ( R; R< R= RB R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s t ExFileSelectDialogc B s, e Z d Z i d � Z d � Z d � Z RS( s� ExFileSelectDialog - MS Windows style file select dialog.
It provides a convenient method for the user to select files.
Subwidgets Class
---------- -----
fsbox ExFileSelectBoxc K s9 t j | | d d g | | � t | d � | j d <d S( Nt tixExFileSelectDialogRe t fsbox( Rd RB t _dummyExFileSelectBoxRk ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB s c C s | j j | j d � d S( NR� ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� s c C s | j j | j d � d S( NR� ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� s ( R; R< R= RB R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s t
FileSelectBoxc B s, e Z d Z i d � Z d � Z d � Z RS( s� ExFileSelectBox - Motif style file select box.
It is generally used for
the user to choose a file. FileSelectBox stores the files mostly
recently selected into a ComboBox widget so that they can be quickly
selected again.
Subwidget Class
--------- -----
selection ComboBox
filter ComboBox
dirlist ScrolledListBox
filelist ScrolledListBoxc K s{ t j | | d d g | | � t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <d S( Nt tixFileSelectBoxRe R� R� R� t selection( Rd RB R� Rk R� ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB s
c C s | j j | j d � d S( NR� ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt apply_filter# s c C s | j j | j d � d S( NR� ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� & s ( R; R< R= RB R R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� s t FileSelectDialogc B s, e Z d Z i d � Z d � Z d � Z RS( s� FileSelectDialog - Motif style file select dialog.
Subwidgets Class
---------- -----
btns StdButtonBox
fsbox FileSelectBoxc K sO t j | | d d g | | � t | d � | j d <t | d � | j d <d S( Nt tixFileSelectDialogRe t btnsR� ( Rd RB t _dummyStdButtonBoxRk t _dummyFileSelectBox( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB 3 s c C s | j j | j d � d S( NR� ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� 9 s c C s | j j | j d � d S( NR� ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� < s ( R; R< R= RB R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR * s t FileEntryc B s, e Z d Z i d � Z d � Z d � Z RS( s_ FileEntry - Entry field with button that invokes a FileSelectDialog.
The user can type in the filename manually. Alternatively, the user can
press the button widget that sits next to the entry, which will bring
up a file selection dialog.
Subwidgets Class
---------- -----
button Button
entry Entryc K sR t j | | d d d g | | � t | d � | j d <t | d � | j d <d S( Nt tixFileEntryt
dialogtypeRe t buttonR� ( Rd RB R� Rk R� ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB K s c C s | j j | j d � d S( NR� ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� Q s c C s d S( N( ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt file_dialogT s ( R; R< R= RB R� R
( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR ? s t HListc B s e Z d Z d6 i d � Z i d � Z d6 i d � Z d � Z d � Z d d6 d6 d � Z d � Z
d � Z d
� Z d � Z
d � Z d
� Z d � Z d � Z i d � Z i d � Z d � Z d � Z e Z d � Z d � Z d � Z i d � Z i d � Z d � Z d � Z d � Z d � Z d � Z d � Z! d6 d � Z" d � Z# d! � Z$ d" � Z% d# � Z& d$ � Z' d% � Z( d& � Z) d' � Z* d( � Z+ d) � Z, i d* � Z- i d+ � Z. d, � Z/ d- � Z0 d. � Z1 i d/ � Z2 d0 � Z3 d1 � Z4 i d2 � Z5 d3 � Z6 d6 d4 � Z7 d5 � Z8 RS(7 s HList - Hierarchy display widget can be used to display any data
that have a hierarchical structure, for example, file system directory
trees. The list entries are indented and connected by branch lines
according to their places in the hierarchy.
Subwidgets - Nonec K s& t j | | d d d g | | � d S( Nt tixHListt columnsRe ( Rd RB ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB ` s c K s( | j j | j d | | j | | � � S( NR� ( R R RP R( ( R R� R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� d s c K s7 | s d } n | j j | j d | | j | | � � S( NRK t addchild( R R RP R( ( R R� R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt add_childg s c C s | j j | j d d | � d S( Nt anchort set( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
anchor_setm s c C s | j j | j d d � d S( NR t clear( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt anchor_clearp s i c C sK | s% | j j | j d d | | � S| j j | j d d | d | � Sd S( NR t widths -char( R R RP ( R t colR t chars( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt column_widths s c C s | j j | j d d � d S( NR� t all( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
delete_allz s c C s | j j | j d d | � d S( NR� R� ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt delete_entry} s c C s | j j | j d d | � d S( NR� t
offsprings( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt delete_offsprings� s c C s | j j | j d d | � d S( NR� t siblings( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt delete_siblings� s c C s | j j | j d d | � d S( Nt dragsiteR ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt dragsite_set� s c C s | j j | j d d � d S( NR R ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt dragsite_clear� s c C s | j j | j d d | � d S( Nt dropsiteR ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt dropsite_set� s c C s | j j | j d d � d S( NR# R ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt dropsite_clear� s c K s/ | j j | j d d | | j | | � � d S( Nt headerR� ( R R RP R( ( R R R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
header_create� s c K sT | d k r% | j | j d d | � S| j j | j d d | | j | | � � d S( NR& R! ( R# R$ RP R R R( ( R R R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt header_configure� s c C s | j j | j d d | | � S( NR& R ( R R RP ( R R t opt( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt header_cget� s c C s( | j j | j j | j d d | � � S( NR& t exist( R t
getbooleanR RP ( R R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
header_exists� s c C s | j j | j d d | � d S( NR& R� ( R R RP ( R R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
header_delete� s c C s | j j | j d d | � S( NR& t size( R R RP ( R R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt header_size� s c C s | j j | j d d | � d S( Nt hideR� ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
hide_entry� s c K s/ | j j | j d d | | j | | � � d S( Nt indicatorR� ( R R RP R( ( R R� R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt indicator_create� s c K sT | d k r% | j | j d d | � S| j j | j d d | | j | | � � d S( NR3 R! ( R# R$ RP R R R( ( R R� R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt indicator_configure� s
c C s | j j | j d d | | � S( NR3 R ( R R RP ( R R� R) ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt indicator_cget� s c C s | j j | j d d | � S( NR3 t exists( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt indicator_exists� s c C s | j j | j d d | � d S( NR3 R� ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt indicator_delete� s c C s | j j | j d d | � S( NR3 R/ ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt indicator_size� s c C s | j j | j d d � S( NR` R ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt info_anchor� s c C s+ | j | j j | j d d | � � p* d S( NR` t bbox( t _getintsR R RP R# ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt info_bbox� s c C s. | j j | j d d | � } | j j | � S( NR` R� ( R R RP RY ( R R� R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
info_children� s c C s | j j | j d d | � S( NR` t data( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt info_data� s c C s | j j | j d d � S( NR` R ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
info_dragsite� s c C s | j j | j d d � S( NR` R# ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
info_dropsite� s c C s | j j | j d d | � S( NR` R7 ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt info_exists� s c C s | j j | j d d | � S( NR` R� ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt info_hidden� s c C s | j j | j d d | � S( NR` t next( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt info_next� s c C s | j j | j d d | � S( NR` R� ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt info_parent� s c C s | j j | j d d | � S( NR` t prev( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt info_prev� s c C s+ | j j | j d d � } | j j | � S( NR` R� ( R R RP RY ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt info_selection� s c C s" | j j | j d d | | | � S( Nt itemR ( R R RP ( R R� R R) ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt item_cget� s c K sZ | d k r( | j | j d d | | � S| j j | j d d | | | j | | � � d S( NRL R! ( R# R$ RP R R R( ( R R� R R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt item_configure� s c K s2 | j j | j d d | | | j | | � � d S( NRL R� ( R R RP R( ( R R� R R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt item_create� s c C s | j j | j d d | | � S( NRL R7 ( R R RP ( R R� R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt item_exists� s c C s# | j j | j d d | | � d S( NRL R� ( R R RP ( R R� R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt item_delete� s c C s | j j | j d | | � S( Nt entrycget( R R RP ( R R� R) ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRR � s c K sN | d k r" | j | j d | � S| j j | j d | | j | | � � d S( Nt entryconfigure( R# R$ RP R R R( ( R R� R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRS s c C s | j j | j d | � S( Nt nearest( R R RP ( R R^ ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRT s c C s | j j | j d | � d S( Nt see( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRU s c K s, | j j | j d d | j | | � � d S( NR� R ( R R RP R( ( R R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt selection_clear s c C s | j j | j d d | � S( NR� t includes( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt selection_includes s c C s# | j j | j d d | | � d S( NR� R ( R R RP ( R t firstt last( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
selection_set s c C s | j j | j d d | � S( Nt showR� ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
show_entry s N(9 R; R< R= R# RB R� R R R R R R R R R! R" R$ R% R' R( R* R- t header_existR. R0 R2 R4 R5 R6 R8 R9 R: R; R> R? RA RB RC RD RE RG RH RJ RK RM RN RO RP RQ RR RS RT RU RV RX R[ R] ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR X sl t InputOnlyc B s e Z d Z d i d � Z RS( s? InputOnly - Invisible widget. Unix only.
Subwidgets - Nonec K s t j | | d d | | � d S( Nt tixInputOnly( Rd RB R# ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB s N( R; R< R= R# RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR_ s t
LabelEntryc B s e Z d Z d i d � Z RS( s LabelEntry - Entry field with label. Packages an entry widget
and a label into one mega widget. It can be used to simplify the creation
of ``entry-form'' type of interface.
Subwidgets Class
---------- -----
label Label
entry Entryc K sR t j | | d d d g | | � t | d � | j d <t | d � | j d <d S( Nt
tixLabelEntryt labelsideRe R� R� ( Rd RB R� Rk R� ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB , s N( R; R< R= R# RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRa " s t
LabelFramec B s e Z d Z d i d � Z RS( se LabelFrame - Labelled Frame container. Packages a frame widget
and a label into one mega widget. To create widgets inside a
LabelFrame widget, one creates the new widgets relative to the
frame subwidget and manage them inside the frame subwidget.
Subwidgets Class
---------- -----
label Label
frame Framec K sR t j | | d d d g | | � t | d � | j d <t | d � | j d <d S( Nt
tixLabelFrameRc Re R� t frame( Rd RB R� Rk t _dummyFrame( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB = s N( R; R< R= R# RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRd 2 s t ListNoteBookc B sA e Z d Z i d � Z i d � Z d � Z d � Z d � Z RS( s A ListNoteBook widget is very similar to the TixNoteBook widget:
it can be used to display many windows in a limited space using a
notebook metaphor. The notebook is divided into a stack of pages
(windows). At one time only one of these pages can be shown.
The user can navigate through these pages by
choosing the name of the desired page in the hlist subwidget.c K sk t j | | d d g | | � t | d d d �| j d <t | d � | j d <t | d � | j d <d S( Nt tixListNoteBookRe t paneR� i R� t shlist( Rd RB t _dummyPanedWindowRk R� t _dummyScrolledHList( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB L s
c K sI | j j | j d | | j | | � � t | | � | j | <| j | S( NR� ( R R RP R( R� Rk ( R R0 R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� T s (c C s
| j | � S( N( Rz ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt pageY s c C sU | j j | j j | j d � � } g } x$ | D] } | j | j | � � q1 W| S( Nt pages( R R� R RP Rf Rz ( R R| t retR] ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRo \ s
$
c C s | j j | j d | � d S( Nt raise( R R RP ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
raise_paged s ( R; R< R= RB R� Rn Ro Rr ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRh D s t Meterc B s e Z d Z d i d � Z RS( su The Meter widget can be used to show the progress of a background
job which may take a long time to execute.
c K s# t j | | d d g | | � d S( Nt tixMeterRe ( Rd RB ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB l s N( R; R< R= R# RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRs g s t NoteBookc B sV e Z d Z d i d � Z i d � Z d � Z d � Z d � Z d � Z d � Z
RS( s� NoteBook - Multi-page container widget (tabbed notebook metaphor).
Subwidgets Class
---------- -----
nbframe NoteBookFrame
<pages> page widgets added dynamically with the add methodc K s? t j | | d d g | | � t | d d d �| j d <d S( Nt tixNoteBookRe t nbframeR� i ( Rd RB R� Rk ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB x s c K sI | j j | j d | | j | | � � t | | � | j | <| j | S( NR� ( R R RP R( R� Rk ( R R0 R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� } s (c C s8 | j j | j d | � | j | j � | j | =d S( NR� ( R R RP Rk RM ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C s
| j | � S( N( Rz ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRn � s c C sU | j j | j j | j d � � } g } x$ | D] } | j | j | � � q1 W| S( NRo ( R R� R RP Rf Rz ( R R| Rp R] ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRo � s
$
c C s | j j | j d | � d S( NRq ( R R RP ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRr � s c C s | j j | j d � S( Nt raised( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRx � s N( R; R< R= R# RB R� R� Rn Ro Rr Rx ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRu p s t
NoteBookFramec B s e Z RS( ( R; R< ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRy � s t
OptionMenuc B sM e Z d Z i d � Z i d � Z i d � Z d � Z d � Z d � Z RS( s� OptionMenu - creates a menu button of options.
Subwidget Class
--------- -----
menubutton Menubutton
menu Menuc K sR t j | | d d d g | | � t | d � | j d <t | d � | j d <d S( Nt
tixOptionMenuRc Re t
menubuttont menu( Rd RB t _dummyMenubuttonRk t
_dummyMenu( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s c K s/ | j j | j d d | | j | | � � d S( NR� t command( R R RP R( ( R R0 R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt add_command� s c K s/ | j j | j d d | | j | | � � d S( NR� t separator( R R RP R( ( R R0 R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
add_separator� s c C s | j j | j d | � d S( NR� ( R R RP ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C s | j j | j d | � d S( Nt disable( R R RP ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C s | j j | j d | � d S( Nt enable( R R RP ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s ( R; R< R= RB R� R� R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRz � s t PanedWindowc B sV e Z d Z i d � Z i d � Z d � Z d � Z d � Z i d � Z d � Z RS( s� PanedWindow - Multi-pane container widget
allows the user to interactively manipulate the sizes of several
panes. The panes can be arranged either vertically or horizontally.The
user changes the sizes of the panes by dragging the resize handle
between two panes.
Subwidgets Class
---------- -----
<panes> g/p widgets added dynamically with the add method.c K s& t j | | d d d g | | � d S( Nt tixPanedWindowR� Re ( Rd RB ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s c K sO | j j | j d | | j | | � � t | | d d �| j | <| j | S( NR� R� i ( R R RP R( R� Rk ( R R0 R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s ( c C s8 | j j | j d | � | j | j � | j | =d S( NR� ( R R RP Rk RM ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C s | j j | j d | � d S( NRW ( R R RP ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRW � s c C s | j j | j d | | � S( Nt panecget( R R RP ( R R� R) ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c K sN | d k r" | j | j d | � S| j j | j d | | j | | � � d S( Nt
paneconfigure( R# R$ RP R R R( ( R R� R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C sD | j j | j j | j d � � } g | D] } | j | � ^ q+ S( Nt panes( R RY R RP Rz ( R R| R] ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s $(
R; R< R= RB R� R� RW R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s t PopupMenuc B s5 e Z d Z i d � Z d � Z d � Z d � Z RS( s PopupMenu widget can be used as a replacement of the tk_popup command.
The advantage of the Tix PopupMenu widget is it requires less application
code to manipulate.
Subwidgets Class
---------- -----
menubutton Menubutton
menu Menuc K sO t j | | d d g | | � t | d � | j d <t | d � | j d <d S( Nt tixPopupMenuRe R| R} ( Rd RB R~ Rk R ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s c C s | j j | j d | j � d S( NR� ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C s | j j | j d | j � d S( NR� ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C s& | j j | j d | j | | � d S( Nt post( R R RP ( R R� R] R^ ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt post_widget� s ( R; R< R= RB R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s
t ResizeHandlec B s> e Z d Z i d � Z d � Z d � Z d � Z d � Z RS( s; Internal widget to draw resize handles on Scrolled widgets.c K sA d d d d d d d d d g } t j | | d
| | | � d S( NRe R� t cursorfgt cursorbgt
handlesizet hintcolort hintwidthR] R^ t tixResizeHandle( Rd RB ( R Rl R) R* t flags( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s
c C s | j j | j d | j � d S( Nt attachwidget( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
attach_widget s c C s | j j | j d | j � d S( Nt detachwidget( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
detach_widget s c C s | j j | j d | j � d S( NR1 ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR1 s c C s | j j | j d | j � d S( NR\ ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR\ s ( R; R< R= RB R� R� R1 R\ ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s
t
ScrolledHListc B s e Z d Z i d � Z RS( s0 ScrolledHList - HList with automatic scrollbars.c K se t j | | d d g | | � t | d � | j d <t | d � | j d <t | d � | j d <d S( Nt tixScrolledHListRe R� R� R� ( Rd RB R� Rk R� ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB s
( R; R< R= RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� s t ScrolledListBoxc B s e Z d Z i d � Z RS( s4 ScrolledListBox - Listbox with automatic scrollbars.c K se t j | | d d g | | � t | d � | j d <t | d � | j d <t | d � | j d <d S( Nt tixScrolledListBoxRe t listboxR� R� ( Rd RB t
_dummyListboxRk R� ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB # s ( R; R< R= RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� s t ScrolledTextc B s e Z d Z i d � Z RS( s. ScrolledText - Text with automatic scrollbars.c K se t j | | d d g | | � t | d � | j d <t | d � | j d <t | d � | j d <d S( Nt tixScrolledTextRe R R� R� ( Rd RB t
_dummyTextRk R� ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB - s ( R; R< R= RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� ) s t
ScrolledTListc B s e Z d Z i d � Z RS( s0 ScrolledTList - TList with automatic scrollbars.c K se t j | | d d g | | � t | d � | j d <t | d � | j d <t | d � | j d <d S( Nt tixScrolledTListRe t tlistR� R� ( Rd RB t _dummyTListRk R� ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB 7 s
( R; R< R= RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� 3 s t ScrolledWindowc B s e Z d Z i d � Z RS( s2 ScrolledWindow - Window with automatic scrollbars.c K se t j | | d d g | | � t | d � | j d <t | d � | j d <t | d � | j d <d S( Nt tixScrolledWindowRe R R� R� ( Rd RB Rg Rk R� ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB B s ( R; R< R= RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� > s t Selectc B s/ e Z d Z i d � Z i d � Z d � Z RS( s� Select - Container of button subwidgets. It can be used to provide
radio-box or check-box style of selection options for the user.
Subwidgets are buttons added dynamically using the add method.c K sE t j | | d d d d d d g | | � t | d � | j d <d S( Nt tixSelectt allowzerot radioR� Rc Re R� ( Rd RB R� Rk ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB O s
c K sI | j j | j d | | j | | � � t | | � | j | <| j | S( NR� ( R R RP R( R� Rk ( R R0 R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� V s (c C s | j j | j d | � d S( NR� ( R R RP ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� [ s ( R; R< R= RB R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� H s t Shellc B s e Z d Z d i d � Z RS( s' Toplevel window.
Subwidgets - Nonec K s& t j | | d d d g | | � d S( Nt tixShellRe t title( Rd RB ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB c s N( R; R< R= R# RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� ^ s t DialogShellc B s8 e Z d Z d i d � Z d � Z d � Z d � Z RS( s� Toplevel window, with popup popdown and center methods.
It tells the window manager that it is a dialog window and should be
treated specially. The exact treatment depends on the treatment of
the window manager.
Subwidgets - Nonec K s5 t j | | d d d d d d d d g | | � d S( Nt tixDialogShellRe R� t mappedt minheightt minwidthR� t transient( Rd RB ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB o s
c C s | j j | j d � d S( NR� ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� v s c C s | j j | j d � d S( NR� ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� y s c C s | j j | j d � d S( Nt center( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� | s N( R; R< R= R# RB R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� f s
t StdButtonBoxc B s& e Z d Z d i d � Z d � Z RS( s@ StdButtonBox - Standard Button Box (OK, Apply, Cancel and Help) c K s~ t j | | d d d g | | � t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <d S( Nt tixStdButtonBoxR� Re R� t applyR� t help( Rd RB R� Rk ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s c C s/ | | j k r+ | j j | j d | � n d S( NR� ( Rk R R RP ( R R0 ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s N( R; R< R= R# RB R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� s t TListc B s� e Z d Z d i d � Z d � Z d � Z d � Z d � Z d d � Z d � Z
d � Z d � Z d
� Z
i d � Z d � Z d
� Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z i d � Z d � Z d d � Z RS( s� TList - Hierarchy display widget which can be
used to display data in a tabular format. The list entries of a TList
widget are similar to the entries in the Tk listbox widget. The main
differences are (1) the TList widget can display the list entries in a
two dimensional format and (2) you can use graphical images as well as
multiple colors and fonts for the list entries.
Subwidgets - Nonec K s# t j | | d d g | | � d S( Nt tixTListRe ( Rd RB ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s c C s | j j | j d d | � d S( Nt activeR ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
active_set� s c C s | j j | j d d � d S( NR� R ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt active_clear� s c C s | j j | j d d | � d S( NR R ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR � s c C s | j j | j d d � d S( NR R ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR � s c C s | j j | j d | | � d S( NR� ( R R RP ( R t from_t to( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C s | j j | j d d | � d S( NR R ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR! � s c C s | j j | j d d � d S( NR R ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR" � s c C s | j j | j d d | � d S( NR# R ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR$ � s c C s | j j | j d d � d S( NR# R ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR% � s c K s, | j j | j d | | j | | � � d S( NR� ( R R RP R( ( R R� R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C s | j j | j d d � S( NR` R� ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt info_active� s c C s | j j | j d d � S( NR` R ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR; � s c C s | j j | j d d | � S( NR` t down( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt info_down� s c C s | j j | j d d | � S( NR` t left( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt info_left� s c C s | j j | j d d | � S( NR` t right( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
info_right� s c C s+ | j j | j d d � } | j j | � S( NR` R� ( R R RP RY ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRK � s c C s | j j | j d d � S( NR` R/ ( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt info_size� s c C s | j j | j d d | � S( NR` t up( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt info_up� s c C s | j j | j d | | � S( NRT ( R R RP ( R R] R^ ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRT � s c C s | j j | j d | � d S( NRU ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRU � s c K s, | j j | j d d | j | | � � d S( NR� R ( R R RP R( ( R R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRV � s c C s | j j | j d d | � S( NR� RW ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRX � s c C s# | j j | j d d | | � d S( NR� R ( R R RP ( R RY RZ ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR[ � s N( R; R< R= R# RB R� R� R R R� R! R" R$ R% R� R� R; R� R� R� RK R� R� RT RU RV RX R[ ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s2 t Treec B sM e Z d Z d i d � Z d � Z d � Z d � Z d � Z d d � Z RS( s� Tree - The tixTree widget can be used to display hierarchical
data in a tree form. The user can adjust
the view of the tree by opening or closing parts of the tree.c K se t j | | d d g | | � t | d � | j d <t | d � | j d <t | d � | j d <d S( Nt tixTreeRe R� R� R� ( Rd RB R� Rk R� ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s
c C s | j j | j d � d S( s This command calls the setmode method for all the entries in this
Tree widget: if an entry has no child entries, its mode is set to
none. Otherwise, if the entry has any hidden child entries, its mode is
set to open; otherwise its mode is set to close.t autosetmodeN( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C s | j j | j d | � d S( s8 Close the entry given by entryPath if its mode is close.t closeN( R R RP ( R t entrypath( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C s | j j | j d | � S( s9 Returns the current mode of the entry given by entryPath.t getmode( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s c C s | j j | j d | � d S( s6 Open the entry given by entryPath if its mode is open.t openN( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s t nonec C s | j j | j d | | � d S( s� This command is used to indicate whether the entry given by
entryPath has children entries and whether the children are visible. mode
must be one of open, close or none. If mode is set to open, a (+)
indicator is drawn next to the entry. If mode is set to close, a (-)
indicator is drawn next to the entry. If mode is set to none, no
indicators will be drawn for this entry. The default mode is none. The
open mode indicates the entry has hidden children and this entry can be
opened by the user. The close mode indicates that all the children of the
entry are now visible and the entry can be closed by the user.t setmodeN( R R RP ( R R� t mode( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� s
N(
R; R< R= R# RB R� R� R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s t CheckListc B sb e Z d Z d
i d � Z d � Z d � Z d � Z d � Z d d � Z d � Z
d d � Z RS( s� The CheckList widget
displays a list of items to be selected by the user. CheckList acts
similarly to the Tk checkbutton or radiobutton widgets, except it is
capable of handling many more items than checkbuttons or radiobuttons.
c K sh t j | | d d d g | | � t | d � | j d <t | d � | j d <t | d � | j d <d S( Nt tixCheckListRe R� R� R� R� ( Rd RB R� Rk R� ( R Rl R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB s
c C s | j j | j d � d S( s This command calls the setmode method for all the entries in this
Tree widget: if an entry has no child entries, its mode is set to
none. Otherwise, if the entry has any hidden child entries, its mode is
set to open; otherwise its mode is set to close.R� N( R R RP ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� s c C s | j j | j d | � d S( s8 Close the entry given by entryPath if its mode is close.R� N( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� $ s c C s | j j | j d | � S( s9 Returns the current mode of the entry given by entryPath.R� ( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� ( s c C s | j j | j d | � d S( s6 Open the entry given by entryPath if its mode is open.R� N( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� , s t onc C s7 | j j | j j | j d | � � } | j j | � S( s� Returns a list of items whose status matches status. If status is
not specified, the list of items in the "on" status will be returned.
Mode can be on, off, defaultt getselection( R R� R RP RY ( R R� R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� 0 s 'c C s | j j | j d | � S( s( Returns the current status of entryPath.t getstatus( R R RP ( R R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� 7 s c C s | j j | j d | | � d S( s~ Sets the status of entryPath to be status. A bitmap will be
displayed next to the entry its status is on, off or default.t setstatusN( R R RP ( R R� R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� ; s N( R; R< R= R# RB R� R� R� R� R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� s R� c B s e Z d d � Z RS( i c C s t j | | | | � d S( N( R� RB ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB G s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� F s R� c B s e Z d d � Z RS( i c C s t j | | | | � d S( N( R� RB ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB K s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� J s R� c B s e Z d d � Z RS( i c C s t j | | | | � d S( N( R� RB ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB O s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� N s Rg c B s e Z d d � Z RS( i c C s t j | | | | � d S( N( R� RB ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB S s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRg R s R� c B s e Z d d � Z RS( i c C s t j | | | | � d S( N( R� RB ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB W s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� V s R� c B s e Z d d � Z RS( i c C s t j | | | | � d S( N( R� RB ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB [ s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� Z s R c B s e Z d d � Z RS( i c C s t j | | | | � d S( N( R� RB ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB _ s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR ^ s R~ c B s e Z d d � Z RS( i c C s t j | | | | � d S( N( R� RB ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB c s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR~ b s R� c B s e Z d d � Z RS( i c C s t j | | | | � d S( N( R� RB ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB g s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� f s R� c B s e Z d d � Z RS( i c C s t j | | | | � d S( N( R� RB ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB k s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� j s R� c B s e Z d d � Z RS( i c C s\ t j | | | | � t | d � | j d <t | d � | j d <t | d � | j d <d S( NR� R� R� ( R� RB R� Rk R� ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB o s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� n s R� c B s e Z d d � Z RS( i c C s t j | | | | � d S( N( R� RB ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB v s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� u s Rm c B s e Z d d � Z RS( i c C s\ t j | | | | � t | d � | j d <t | d � | j d <t | d � | j d <d S( NR� R� R� ( R� RB R� Rk R� ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB z s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRm y s R� c B s e Z d d � Z RS( i c C s t j | | | | � d S( N( R� RB ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s R� c B s e Z d d � Z RS( i c C s� t j | | | d | g � t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <y0 t | d � | j d <t | d � | j d <Wn t k
r� n Xd S( NR� R� R� R� R� R� R� ( R� RB R� Rk R� R� R� R� ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s
( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s R� c B s e Z d d � Z RS( i c C s\ t j | | | | � t | d � | j d <t | d � | j d <t | d � | j d <d S( NR� R� R� ( R� RB R� Rk R� ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s R� c B s e Z d d � Z RS( i c C sF t j | | | | � t | d � | j d <t | d � | j d <d S( NR� R� ( R� RB R� Rk R� ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s R� c B s e Z d d � Z RS( i c C s� t j | | | | � t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <d S( NR� R� R� R� R� R� R� R� ( R� RB R� Rk R� R� R� ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s R c B s e Z d d � Z RS( i c C sr t j | | | | � t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <d S( NR� R� R� R� ( R� RB R� Rk R� ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s
( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR � s R� c B s e Z d d � Z RS( i c C s0 t j | | | | � t | d � | j d <d S( NR� ( R� RB R� Rk ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s R c B s e Z d d � Z RS( i c C sr t j | | | | � t | d � | j d <t | d � | j d <t | d � | j d <t | d � | j d <d S( NR� R� R� R� ( R� RB R� Rk ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s
( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR � s t _dummyNoteBookFramec B s e Z d d � Z RS( i c C s t j | | | | � d S( N( R� RB ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s Rl c B s e Z d d � Z RS( i c C s t j | | | | � d S( N( R� RB ( R Rl R0 R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s ( R; R< RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRl � s c C s | j j d | j � S( sz Returns the qualified path name for the widget. Normally used to set
default options for subwidgets. See tixwidgets.pyt
tixOptionName( R R RP ( R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
OptionName� s c C sG d } x: | j � D], } | d | d | d | | d } q W| S( NRK s {{s } {s - s }} ( t keys( t dictt st type( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt FileTypeList� s *t CObjViewc B s e Z d Z RS( sB This file implements the Canvas Object View widget. This is a base
class of IconView. It implements automatic placement/adjustment of the
scrollbars according to the canvas objects inside the canvas subwidget.
The scrollbars are adjusted so that the canvas is just large enough
to see all the objects.
( R; R< R= ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s t Gridc B s� e Z d Z d i d � Z d � Z d � Z d � Z d d � Z d d � Z d � Z
d � Z d � Z d d
� Z
d � Z d � Z d
� Z d � Z d � Z d d � Z d � Z d � Z d � Z RS( s} The Tix Grid command creates a new window and makes it into a
tixGrid widget. Additional options, may be specified on the command
line or in the option database to configure aspects such as its cursor
and relief.
A Grid widget displays its contents in a two dimensional grid of cells.
Each cell may contain one Tix display item, which may be in text,
graphics or other formats. See the DisplayStyle class for more information
about Tix display items. Individual cells, or groups of cells, can be
formatted with a wide range of attributes, such as its color, relief and
border.
Subwidgets - Nonec K s/ g } | | _ t j | | d | | | � d S( Nt tixGrid( R) Rd RB ( R Rl R) R* R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB s c C s | j j | d d � d S( s Removes the selection anchor.R R N( R R ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR s c C s | j | j j | d d � � S( s3 Get the (x,y) coordinate of the current anchor cellR R4 ( R= R R ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
anchor_get
s c C s | j j | d d | | � d S( s/ Set the selection anchor to the cell at (x, y).R R N( R R ( R R] R^ ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR s c C sH | d k r( | j j | d d | � n | j j | d d | | � d S( sd Delete rows between from_ and to inclusive.
If to is not provided, delete only row at from_R� R N( R# R R ( R R� R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
delete_row s c C sH | d k r( | j j | d d | � n | j j | d d | | � d S( sj Delete columns between from_ and to inclusive.
If to is not provided, delete only column at from_R� R N( R# R R ( R R� R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
delete_column s c C s | j j | d d � d S( sU If any cell is being edited, de-highlight the cell and applies
the changes.t editR� N( R R ( R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt
edit_apply% s c C s | j j | d d | | � d S( sm Highlights the cell at (x, y) for editing, if the -editnotify
command returns True for this cell.R� R N( R R ( R R] R^ ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt edit_set* s c C s? | r# | d d k r# d | } n | j j | d | | | � S( s& Get the option value for cell at (x,y)i R" RR ( R R ( R R] R^ R ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRR / s
c K s | j d | | f | | � S( NRS ( t
_configure( R R] R^ R) R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRS 5 s c C s% | j | j j | d d | | � � S( s+ Return True if display item exists at (x,y)R` R7 ( t _getbooleanR R ( R R] R^ ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRD ; s c C s | j j | d d | | � S( NR` R< ( R R ( R R] R^ ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR> ? s c C s# | j j | d d | | | � d S( s� Moves the range of columns from position FROM through TO by
the distance indicated by OFFSET. For example, move_column(2, 4, 1)
moves the columns 2,3,4 to columns 3,4,5.t moveR N( R R ( R R� R� t offset( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt move_columnC s c C s# | j j | d d | | | � d S( s� Moves the range of rows from position FROM through TO by
the distance indicated by OFFSET.
For example, move_row(2, 4, 1) moves the rows 2,3,4 to rows 3,4,5.R� R N( R R ( R R� R� R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt move_rowI s c C s" | j | j j | d | | � � S( s8 Return coordinate of cell nearest pixel coordinate (x,y)RT ( R= R R ( R R] R^ ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRT O s c K sT | j | j | � } | d k r4 d | f | } n | j j | d | | | � d S( Ns -itemtypeR ( R( R) R# R R ( R R] R^ R� R* t args( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR Y s c K s7 | j j | j j | j d d | | j i | � � � S( s� Queries or sets the size of the column given by
INDEX. INDEX may be any non-negative
integer that gives the position of a given column.
INDEX can also be the string "default"; in this case, this command
queries or sets the default size of all columns.
When no option-value pair is given, this command returns a tuple
containing the current size setting of the given column. When
option-value pairs are given, the corresponding options of the
size setting of the given column are changed. Options may be one
of the follwing:
pad0 pixels
Specifies the paddings to the left of a column.
pad1 pixels
Specifies the paddings to the right of a column.
size val
Specifies the width of a column. Val may be:
"auto" -- the width of the column is set to the
width of the widest cell in the column;
a valid Tk screen distance unit;
or a real number following by the word chars
(e.g. 3.4chars) that sets the width of the column to the
given number of characters.R/ R ( R R� R RP R( ( R R� R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt size_column_ s !c K s4 | j j | j j | d d | | j i | � � � S( s� Queries or sets the size of the row given by
INDEX. INDEX may be any non-negative
integer that gives the position of a given row .
INDEX can also be the string "default"; in this case, this command
queries or sets the default size of all rows.
When no option-value pair is given, this command returns a list con-
taining the current size setting of the given row . When option-value
pairs are given, the corresponding options of the size setting of the
given row are changed. Options may be one of the follwing:
pad0 pixels
Specifies the paddings to the top of a row.
pad1 pixels
Specifies the paddings to the bottom of a row.
size val
Specifies the height of a row. Val may be:
"auto" -- the height of the row is set to the
height of the highest cell in the row;
a valid Tk screen distance unit;
or a real number following by the word chars
(e.g. 3.4chars) that sets the height of the row to the
given number of characters.R/ R ( R R� R R( ( R R� R* ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt size_rowy s c C s | j j | j d | | � d S( s7 Clears the cell at (x, y) by removing its display item.t unsetN( R R RP ( R R] R^ ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s N( R; R< R= R# RB R R� R R� R� R� R� RR RS RD R> R� R� RT R R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s(
t ScrolledGridc B s e Z d Z d i d � Z RS( s Scrolled Grid widgetsc K s/ g } | | _ t j | | d | | | � d S( Nt tixScrolledGrid( R) Rd RB ( R Rl R) R* R� ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyRB � s N( R; R< R= R# RB ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyR� � s i i i i i ( ( ( (x RC RA R R t TkVersiont ImportErrort _tkintert WINDOWt TEXTt STATUSt IMMEDIATEt IMAGEt IMAGETEXTt BALLOONt AUTOt ACROSSTOPt ASCIIt CELLt COLUMNt
DECREASINGt
INCREASINGt INTEGERt MAINt MAXt REALt ROWt S_REGIONt X_REGIONt Y_REGIONt
TCL_DONT_WAITt TCL_WINDOW_EVENTSt TCL_FILE_EVENTSt TCL_TIMER_EVENTSt TCL_IDLE_EVENTSt TCL_ALL_EVENTSR R> RN Ri t __bases__Rd R� R� R� R� R� R� R� R� R� R� R� R� R� R R t XViewt YViewR R_ Ra Rd Rh Rs Ru Ry Rz R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� t ButtonR� t CheckbuttonR� t EntryR� t FrameRg t LabelR� t ListboxR� t MenuR t
MenubuttonR~ t ScrollbarR� t TextR� R� R� Rm R� R� R� R� R� R R� R R� Rl R� R� R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/Tix.pyt <module> s�
� -�80,!" �# ( )
S.7
� tkCommonDialog.py 0000644 00000002612 15032720555 0010032 0 ustar 00 # base class for tk common dialogues
#
# this module provides a base class for accessing the common
# dialogues available in Tk 4.2 and newer. use tkFileDialog,
# tkColorChooser, and tkMessageBox to access the individual
# dialogs.
#
# written by Fredrik Lundh, May 1997
#
from Tkinter import *
class Dialog:
command = None
def __init__(self, master=None, **options):
# FIXME: should this be placed on the module level instead?
if TkVersion < 4.2:
raise TclError, "this module requires Tk 4.2 or newer"
self.master = master
self.options = options
if not master and options.get('parent'):
self.master = options['parent']
def _fixoptions(self):
pass # hook
def _fixresult(self, widget, result):
return result # hook
def show(self, **options):
# update instance options
for k, v in options.items():
self.options[k] = v
self._fixoptions()
# we need a dummy widget to properly process the options
# (at least as long as we use Tkinter 1.63)
w = Frame(self.master)
try:
s = w.tk.call(self.command, *w._options(self.options))
s = self._fixresult(w, s)
finally:
try:
# get rid of the widget
w.destroy()
except:
pass
return s
ttk.pyc 0000644 00000172244 15032720555 0006101 0 ustar 00 �
z fc @ sY d Z d Z d Z d d d d d d d d
d d d
d d d d d d d d d d d d d g Z d d l Z d d l m Z m Z m Z m Z e j d k r� e
n e Z d � Z
e d � Z e e d! � Z d" � Z e d# � Z e d$ � Z d% d& d' � Z d( � Z d) � Z d* � Z d+ � Z d, � Z d- � Z d. � Z d/ � Z e d0 � Z d e f d1 � � YZ d2 e j f d3 � � YZ d e f d4 � � YZ! d e f d5 � � YZ" d e e j# f d6 � � YZ# d e# f d7 � � YZ$ d e f d8 � � YZ% d e f d9 � � YZ& d e f d: � � YZ' e' Z( d e f d; � � YZ) d e f d< � � YZ* d
e e j+ f d= � � YZ, e, Z+ d e f d> � � YZ- d e f d? � � YZ. d e e j/ f d@ � � YZ/ d e e j0 f dA � � YZ0 d e f dB � � YZ1 d e f dC � � YZ2 d e e j3 e j4 f dD � � YZ5 d e% e f dE � � YZ6 d e) f dF � � YZ7 d S(G s� Ttk wrapper.
This module provides classes to allow using Tk themed widget set.
Ttk is based on a revised and enhanced version of
TIP #48 (http://tip.tcl.tk/48) specified style engine.
Its basic idea is to separate, to the extent possible, the code
implementing a widget's behavior from the code implementing its
appearance. Widget class bindings are primarily responsible for
maintaining the widget state and invoking callbacks, all aspects
of the widgets appearance lies at Themes.
s 0.3.1s! Guilherme Polo <ggpolo@gmail.com>t Buttont Checkbuttont Comboboxt Entryt Framet Labelt
Labelframet
LabelFramet
Menubuttont Notebookt Panedwindowt PanedWindowt Progressbart Radiobuttont Scalet Scrollbart Separatort Sizegript Stylet Treeviewt LabeledScalet
OptionMenut
tclobjs_to_pyt setup_masteri����N( t _flattent _joint
_stringifyt
_splitdictg !@c C sa t r] d d l } | j j d � } | rA | j j d | � n | j j d � t | _ n d S( Ni����t TILE_LIBRARYs( global auto_path; lappend auto_path {%s}s package require tile( t
_REQUIRE_TILEt ost environt gett tkt evalt Truet _tile_loaded( t masterR t tilelib( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt
_load_tile" s c C s= | r t | � } n$ t | t t f � r9 t | � } n | S( s Internal function.( R t
isinstancet listt tupleR ( t valuet script( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt _format_optvalue1 s
c C sy g } xf | j � D]X \ } } | s2 | | k r | j d | � | d k rk | j t | | � � qk q q Wt | � S( s� Formats optdict to a tuple to pass it to tk.call.
E.g. (script=False):
{'foreground': 'blue', 'padding': [1, 2, 3, 4]} returns:
('-foreground', 'blue', '-padding', '1 2 3 4')s -%sN( t iteritemst appendt NoneR- R ( t optdictR, t ignoret optst optR+ ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt _format_optdict; s c C s� g } x� | D] } | d } | d } | d t | � d k rT | d pN d } n d j | � } | j | � | d k r
| j | � q
q
W| S( Ni����i i t t ( t lent joinR/ R0 ( t itemst opt_valt itemt statet val( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt _mapdict_valuesK s
c C sS g } x@ | j � D]2 \ } } | j d | t t | � | � f � q Wt | � S( s� Formats mapdict to pass it to tk.call.
E.g. (script=False):
{'expand': [('active', 'selected', 'grey'), ('focus', [1, 2, 3, 4])]}
returns:
('-expand', '{active selected} grey focus {1, 2, 3, 4}')s -%s( R. t extendR- R? R ( t mapdictR, R3 R4 R+ ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt _format_mapdictd s
c O s d } d } | d
k r� | d k rW | d } t t | d � � } d | | f } n9 | d \ } } t t | d � � }
d | | |
f } t | | � } nD | d k r� | d } t | � d k r� t | d | � f } q� n | rd | } d
j | � } n | | f S( sA Formats args and kw according to the given element factory etype.t imaget vsapii i s %s %si s %s %s %st froms {%s}R7 N( ( RC RD ( R0 R R? R5 R8 R- R9 ( t etypeR, t argst kwt specR3 t inamet imagespect
class_namet part_idt statemap( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt _format_elemcreateu s&
i i c
C s g } x� | D]� } | \ } } | p( i } d j t | t d � � } d d | | | rc d | n d f } d | k r� | j | d � | | 7} t | d | | � \ } } | j | � | | 8} | j d d | � q
| j | � q
Wd j | � | f S(
s$ Formats a layout list so we can pass the result to ttk::style
layout and ttk::style settings. Note that the layout doesn't have to
be a list necessarily.
E.g.:
[("Menubutton.background", None),
("Menubutton.button", {"children":
[("Menubutton.focus", {"children":
[("Menubutton.padding", {"children":
[("Menubutton.label", {"side": "left", "expand": 1})]
})]
})]
}),
("Menubutton.indicator", {"side": "right"})
]
returns:
Menubutton.background
Menubutton.button -children {
Menubutton.focus -children {
Menubutton.padding -children {
Menubutton.label -side left -expand 1
}
}
}
Menubutton.indicator -side rightR7 t childrens %s%s%ss %sR6 s -children {s %s}s
( RP ( R9 R5 R# R/ t _format_layoutlist(
t layoutt indentt indent_sizeR, t layout_elemt elemR3 t foptst headt newscript( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyRQ � s
'
c C s� g } x�| j � D]�\ } } | j d � rd d j t | d t � � } | j d | | f � n | j d � r� d j t | d t � � } | j d | | f � n d | k r� | d s� d } n t | d � \ } } | j d | | f � n | j d � r | d } | d
} d } x4 | t | � k rWt | | d � rW| d 7} q$W| d | !} | t | � k r�| | r�| | n i }
t
| t | |
� \ } } | j d
| | | | f � q q Wd j | � S( s� Returns an appropriate script, based on settings, according to
theme_settings definition to be used by theme_settings and
theme_create.t configureR7 s ttk::style configure %s %s;t maps ttk::style map %s %s;RR t nulls ttk::style layout %s {
%s
}s element createi i R. s% ttk::style element create %s %s %s %ss
( R. R R9 R5 R# R/ RB RQ R8 t hasattrRO ( t settingsR, t nameR3 t st _t eoptsRF t argct elemargst elemkwRI ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt _script_from_settings� s2
)
, c C s� g } xp | D]h } t | d d � } | d k rA | j | � q
t | � } | d k rh | j � } n | j | � q
Wt | � } g t | | � D] } t | � ^ q� S( st Construct a list from the given statespec tuple according to the
accepted statespec accepted by _format_mapdict.t typenamet StateSpecN( t getattrR0 R/ t strt splitt itert zipR ( t stuplet nvalR> Rg t itRI ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt _list_from_statespec� s
c C s� | j | � } g } d } x� | t | � k r� | | } i } | j | | f � | d 7} x| | t | � k r� | | | d !\ } } | j d � s� Pn | d } | d 7} | d k r� t | | � } n | | | <q` Wq W| S( sp Construct a list from the tuple returned by ttk::layout, this is
somewhat the reverse of _format_layoutlist.i i i t -RP ( t splitlistR8 R/ t
startswitht _list_from_layouttuple( R! t ltuplet rest indxR_ R3 R4 R> ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyRu s$
c G sF t | � } | j | | � } t | � d r3 | St | | d t �S( sh Format options then call Tk command with args and options and return
the appropriate result.
If no option is specified, a dict is returned. If an option is
specified with the None value, the value for that option is returned.
Otherwise, the function just sets the passed options and the caller
shouldn't be expecting a return value anyway.i t conv( R5 t callR8 R t
_tclobj_to_py( R! t optionsRG Rw ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt _val_or_dict" s
c C s: t | � } y t | � } Wn t t f k
r5 n X| S( sA Converts a value to, hopefully, a more appropriate Python object.( t unicodet intt
ValueErrort TypeError( R+ ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt _convert_stringval2 s c C s= t | t � r9 d | k r* t | � } q9 t | � } n | S( Nt .( R( Rj t floatR ( t x( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt
_to_number< s
c C s� | rb t | d � rb t | t � rb t | d d d � d k rP t | � } q� t t | � } n t | d � r� t | � } n | S( s8 Return value converted from Tcl object to Python object.t __len__i Rg Rh N( R] R( t
basestringRi R0 Rq R[ R� ( R> ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR{ D s % c C s1 x* | j � D] \ } } t | � | | <q
W| S( sO Returns adict with its values converted from Tcl objects to Python
objects.( R: R{ ( t adictR4 R> ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR Q s c C s@ | d k r< t j r- t j p' t j � } q< t d � � n | S( s If master is not None, itself is returned. If master is None,
the default master is returned if there is one, otherwise a new
master is created and returned.
If it is not allowed to use the default root and master is None,
RuntimeError is raised.sI No master specified and Tkinter is configured to not support default rootN( R0 t Tkintert _support_default_roott
_default_roott Tkt RuntimeError( R% ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR Y s c B s� e Z d Z d Z d d � Z d d � Z d d � Z d d d � Z d d � Z d � Z
d � Z d � Z d d d
� Z
d � Z d � Z d d
� Z RS( s Manipulate style database.s
ttk::stylec C sG t | � } t | d t � s+ t | � n | | _ | j j | _ d S( NR$ ( R Ri t FalseR' R% R! ( t selfR% ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt __init__o s
c K s5 | d k r d | | <n t | j | | j d | � S( s� Query or sets the default value of the specified option(s) in
style.
Each key in kw is an option and each value is either a string or
a sequence identifying the value for that option.RZ N( R0 R} R! t _name( R� t stylet query_optRH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyRZ z s
c K sr | d k r> t | j j | j j | j d | d | � � � St | j | j j | j d | t | � � d t �S( sS Query or sets dynamic values of the specified option(s) in
style.
Each key in kw is an option and each value should be a list or a
tuple (usually) containing statespecs grouped in tuples, or list,
or something else of your preference. A statespec is compound of
one or more states and then a value.R[ s -%sRy N( R0 Rq R! Rs Rz R� R RB R{ ( R� R� R� RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR[ � s &$c C sA | r d j | � n d } | j j | j d | d | | | � S( s Returns the value specified for option in style.
If state is specified it is expected to be a sequence of one
or more states. If the default argument is set, it is used as
a fallback value in case no specification for option is found.R7 R6 t lookups -%s( R9 R! Rz R� ( R� R� t optionR= t default( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c C s\ d } | r t | � d } n | d k r4 d } n t | j | j j | j d | | � � S( s� Define the widget layout for given style. If layoutspec is
omitted, return the layout specification for given style.
layoutspec is expected to be a list or an object different than
None that evaluates to False if you want to "turn off" that style.
If it is a list (or tuple, or something else), each item should be
a tuple where the first item is the layout name and the second item
should have the format described below:
LAYOUTS
A layout can contain the value None, if takes no options, or
a dict of options specifying how to arrange the element.
The layout mechanism uses a simplified version of the pack
geometry manager: given an initial cavity, each element is
allocated a parcel. Valid options/values are:
side: whichside
Specifies which side of the cavity to place the
element; one of top, right, bottom or left. If
omitted, the element occupies the entire cavity.
sticky: nswe
Specifies where the element is placed inside its
allocated parcel.
children: [sublayout... ]
Specifies a list of elements to place inside the
element. Each element is a tuple (or other sequence)
where the first item is the layout name, and the other
is a LAYOUT.i R\ RR N( R0 RQ Ru R! Rz R� ( R� R� t
layoutspect lspec( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyRR � s c O sD t | t | | � \ } } | j j | j d d | | | | � d S( s9 Create a new element in the current theme of given etype.t elementt createN( RO R� R! Rz R� ( R� t elementnameRF RG RH RI R3 ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt element_create� s c C s% | j j | j j | j d d � � S( s: Returns the list of elements defined in the current theme.R� t names( R! Rs Rz R� ( R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt
element_names� s c C s( | j j | j j | j d d | � � S( s) Return the list of elementname's options.R� R| ( R! Rs Rz R� ( R� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt element_options� s c C so | r t | � n d } | rI | j j | j d d | d | d | � n" | j j | j d d | d | � d S( s. Creates a new theme.
It is an error if themename already exists. If parent is
specified, the new theme will inherit styles, elements and
layouts from the specified parent theme. If settings are present,
they are expected to have the same syntax used for theme_settings.R6 t themeR� s -parents -settingsN( Rf R! Rz R� ( R� t themenamet parentR^ R, ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt theme_create� s c C s/ t | � } | j j | j d d | | � d S( s� Temporarily sets the current theme to themename, apply specified
settings and then restore the previous theme.
Each key in settings is a style and each value may contain the
keys 'configure', 'map', 'layout' and 'element create' and they
are expected to have the same format as specified by the methods
configure, map, layout and element_create respectively.R� R^ N( Rf R! Rz R� ( R� R� R^ R, ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt theme_settings� s c C s% | j j | j j | j d d � � S( s# Returns a list of all known themes.R� R� ( R! Rs Rz R� ( R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt theme_names� s c C s3 | d k r | j j d � S| j j d | � d S( s� If themename is None, returns the theme in use, otherwise, set
the current theme to themename, refreshes all widgets and emits
a <<ThemeChanged>> event.s return $ttk::currentThemes
ttk::setThemeN( R0 R! R" Rz ( R� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt theme_use s N( t __name__t
__module__t __doc__R� R0 R� RZ R[ R� RR R� R� R� R� R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR j s + t Widgetc B s; e Z d Z d d � Z d � Z d d � Z d d � Z RS( s! Base class for Tk themed widgets.c C sK t | � } t | d t � s+ t | � n t j j | | | d | �d S( s� Constructs a Ttk Widget with the parent master.
STANDARD OPTIONS
class, cursor, takefocus, style
SCROLLABLE WIDGET OPTIONS
xscrollcommand, yscrollcommand
LABEL WIDGET OPTIONS
text, textvariable, underline, image, compound, width
WIDGET STATES
active, disabled, focus, pressed, selected, background,
readonly, alternate, invalid
R$ RH N( R Ri R� R' R� R� R� ( R� R% t
widgetnameRH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� s
c C s | j j | j d | | � S( s� Returns the name of the element at position x, y, or the empty
string if the point does not lie within any element.
x and y are pixel coordinates relative to the widget.t identify( R! Rz t _w( R� R� t y( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� . s c O sM | j j | j j | j d d j | � � � } | rI | rI | | | � S| S( s1 Test the widget's state.
If callback is not specified, returns True if the widget state
matches statespec and False otherwise. If callback is specified,
then it will be invoked with *args, **kw if the widget state
matches statespec. statespec is expected to be a sequence.t instateR7 ( R! t
getbooleanRz R� R9 ( R� t statespect callbackRG RH t ret( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� 6 s
'
c C sI | d k r d j | � } n | j j t | j j | j d | � � � S( s Modify or inquire widget state.
Widget state is returned if statespec is None, otherwise it is
set according to the statespec flags and then a new state spec
is returned indicating which flags were changed. statespec is
expected to be a sequence.R7 R= N( R0 R9 R! Rs Rj Rz R� ( R� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR= E s N( R� R� R� R0 R� R� R� R= ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� s
c B s# e Z d Z d d � Z d � Z RS( sc Ttk Button widget, displays a textual label and/or image, and
evaluates a command when pressed.c K s t j | | d | � d S( s Construct a Ttk Button widget with the parent master.
STANDARD OPTIONS
class, compound, cursor, image, state, style, takefocus,
text, textvariable, underline, width
WIDGET-SPECIFIC OPTIONS
command, default, width
s ttk::buttonN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� V s c C s | j j | j d � S( s/ Invokes the command associated with the button.t invoke( R! Rz R� ( R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� e s N( R� R� R� R0 R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR R s c B s# e Z d Z d d � Z d � Z RS( s; Ttk Checkbutton widget which is either in on- or off-state.c K s t j | | d | � d S( s' Construct a Ttk Checkbutton widget with the parent master.
STANDARD OPTIONS
class, compound, cursor, image, state, style, takefocus,
text, textvariable, underline, width
WIDGET-SPECIFIC OPTIONS
command, offvalue, onvalue, variable
s ttk::checkbuttonN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� m s c C s | j j | j d � S( sW Toggles between the selected and deselected states and
invokes the associated command. If the widget is currently
selected, sets the option variable to the offvalue option
and deselects the widget; otherwise, sets the option variable
to the option onvalue.
Returns the result of the associated command.R� ( R! Rz R� ( R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� | s N( R� R� R� R0 R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR j s c B s8 e Z d Z d d d � Z d � Z d � Z d � Z RS( se Ttk Entry widget displays a one-line text string and allows that
string to be edited by the user.c K s t j | | | p d | � d S( s� Constructs a Ttk Entry widget with the parent master.
STANDARD OPTIONS
class, cursor, style, takefocus, xscrollcommand
WIDGET-SPECIFIC OPTIONS
exportselection, invalidcommand, justify, show, state,
textvariable, validate, validatecommand, width
VALIDATION MODES
none, key, focus, focusin, focusout, all
s
ttk::entryN( R� R� ( R� R% t widgetRH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c C s" | j | j j | j d | � � S( sq Return a tuple of (x, y, width, height) which describes the
bounding box of the character given by index.t bbox( t _getintsR! Rz R� ( R� t index( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c C s | j j | j d | | � S( sx Returns the name of the element at position x, y, or the
empty string if the coordinates are outside the window.R� ( R! Rz R� ( R� R� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c C s" | j j | j j | j d � � S( s� Force revalidation, independent of the conditions specified
by the validate option. Returns False if validation fails, True
if it succeeds. Sets or clears the invalid state accordingly.t validate( R! R� Rz R� ( R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s N( R� R� R� R0 R� R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR � s
c B s/ e Z d Z d d � Z d d � Z d � Z RS( sM Ttk Combobox widget combines a text field with a pop-down list of
values.c K s t j | | d | � d S( s Construct a Ttk Combobox widget with the parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
exportselection, justify, height, postcommand, state,
textvariable, values, width
s
ttk::comboboxN( R R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c C sG | d k r. | j j | j j | j d � � S| j j | j d | � S( s If newindex is supplied, sets the combobox value to the
element at position newindex in the list of values. Otherwise,
returns the index of the current value in the list of values
or -1 if the current value does not appear in the list.t currentN( R0 R! t getintRz R� ( R� t newindex( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s "c C s | j j | j d | � d S( s( Sets the value of the combobox to value.t setN( R! Rz R� ( R� R+ ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s N( R� R� R� R0 R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR � s
c B s e Z d Z d d � Z RS( sJ Ttk Frame widget is a container, used to group other widgets
together.c K s t j | | d | � d S( s� Construct a Ttk Frame with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
borderwidth, relief, padding, width, height
s
ttk::frameN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s N( R� R� R� R0 R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR � s c B s e Z d Z d d � Z RS( s7 Ttk Label widget displays a textual label and/or image.c K s t j | | d | � d S( sG Construct a Ttk Label with parent master.
STANDARD OPTIONS
class, compound, cursor, image, style, takefocus, text,
textvariable, underline, width
WIDGET-SPECIFIC OPTIONS
anchor, background, font, foreground, justify, padding,
relief, text, wraplength
s
ttk::labelN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s
N( R� R� R� R0 R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR � s c B s e Z d Z d d � Z RS( s� Ttk Labelframe widget is a container used to group other widgets
together. It has an optional label, which may be a plain text string
or another widget.c K s t j | | d | � d S( s� Construct a Ttk Labelframe with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
labelanchor, text, underline, padding, labelwidget, width,
height
s ttk::labelframeN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s N( R� R� R� R0 R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR � s c B s e Z d Z d d � Z RS( sb Ttk Menubutton widget displays a textual label and/or image, and
displays a menu when pressed.c K s t j | | d | � d S( s Construct a Ttk Menubutton with parent master.
STANDARD OPTIONS
class, compound, cursor, image, state, style, takefocus,
text, textvariable, underline, width
WIDGET-SPECIFIC OPTIONS
direction, menu
s ttk::menubuttonN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� s N( R� R� R� R0 R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR
s c B sz e Z d Z d d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d d � Z d d � Z d
� Z
d � Z RS(
s� Ttk Notebook widget manages a collection of windows and displays
a single one at a time. Each child window is associated with a tab,
which the user may select to change the currently-displayed window.c K s t j | | d | � d S( s\ Construct a Ttk Notebook with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
height, padding, width
TAB OPTIONS
state, sticky, padding, text, image, compound, underline
TAB IDENTIFIERS (tab_id)
The tab_id argument found in several methods may take any of
the following forms:
* An integer between zero and the number of tabs
* The name of a child window
* A positional specification of the form "@x,y", which
defines the tab
* The string "current", which identifies the
currently-selected tab
* The string "end", which returns the number of tabs (only
valid for method index)
s
ttk::notebookN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� % s c K s& | j j | j d | t | � � d S( s� Adds a new tab to the notebook.
If window is currently managed by the notebook but hidden, it is
restored to its previous position.t addN( R! Rz R� R5 ( R� t childRH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� E s c C s | j j | j d | � d S( sX Removes the tab specified by tab_id, unmaps and unmanages the
associated window.t forgetN( R! Rz R� ( R� t tab_id( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� M s c C s | j j | j d | � d S( s� Hides the tab specified by tab_id.
The tab will not be displayed, but the associated window remains
managed by the notebook and its configuration remembered. Hidden
tabs may be restored with the add command.t hideN( R! Rz R� ( R� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� S s c C s | j j | j d | | � S( sZ Returns the name of the tab element at position x, y, or the
empty string if none.R� ( R! Rz R� ( R� R� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� \ s c C s% | j j | j j | j d | � � S( s| Returns the numeric index of the tab specified by tab_id, or
the total number of tabs if tab_id is the string "end".R� ( R! R� Rz R� ( R� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� b s c K s) | j j | j d | | t | � � d S( s� Inserts a pane at the specified position.
pos is either the string end, an integer index, or the name of
a managed child. If child is already managed by the notebook,
moves it to the specified position.t insertN( R! Rz R� R5 ( R� t posR� RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� h s c C s | j j | j d | � S( s� Selects the specified tab.
The associated child window will be displayed, and the
previously-selected window (if different) is unmapped. If tab_id
is omitted, returns the widget name of the currently selected
pane.t select( R! Rz R� ( R� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� q s c K s5 | d k r d | | <n t | j | | j d | � S( s� Query or modify the options of the specific tab_id.
If kw is not given, returns a dict of the tab option values. If option
is specified, returns the value of that option. Otherwise, sets the
options to the corresponding values.t tabN( R0 R} R! R� ( R� R� R� RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� { s
c C s( | j j | j j | j d � p$ d � S( s2 Returns a list of windows managed by the notebook.t tabs( ( R! Rs Rz R� ( R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c C s | j j d | j � d S( s� Enable keyboard traversal for a toplevel window containing
this notebook.
This will extend the bindings for the toplevel window containing
this notebook as follows:
Control-Tab: selects the tab following the currently selected
one
Shift-Control-Tab: selects the tab preceding the currently
selected one
Alt-K: where K is the mnemonic (underlined) character of any
tab, will select that tab.
Multiple notebooks in a single toplevel may be enabled for
traversal, including nested notebooks. However, notebook traversal
only works properly if all panes are direct children of the
notebook.s ttk::notebook::enableTraversalN( R! Rz R� ( R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt enable_traversal� s N( R� R� R� R0 R� R� R� R� R� R� R� R� R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR s
c B sG e Z d Z d d � Z e j j Z d � Z d d � Z d d � Z
RS( sf Ttk Panedwindow widget displays a number of subwindows, stacked
either vertically or horizontally.c K s t j | | d | � d S( s� Construct a Ttk Panedwindow with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
orient, width, height
PANE OPTIONS
weight
s ttk::panedwindowN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c K s) | j j | j d | | t | � � d S( s� Inserts a pane at the specified positions.
pos is either the string end, and integer index, or the name
of a child. If child is already managed by the paned window,
moves it to the specified position.R� N( R! Rz R� R5 ( R� R� R� RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c K s5 | d k r d | | <n t | j | | j d | � S( sQ Query or modify the options of the specified pane.
pane is either an integer index or the name of a managed subwindow.
If kw is not given, returns a dict of the pane option values. If
option is specified then the value for that option is returned.
Otherwise, sets the options to the corresponding values.t paneN( R0 R} R! R� ( R� R� R� RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s
c C s( | j j | j j | j d | | � � S( sL If newpos is specified, sets the position of sash number index.
May adjust the positions of adjacent sashes to ensure that
positions are monotonically increasing. Sash positions are further
constrained to be between 0 and the total size of the widget.
Returns the new position of sash number index.t sashpos( R! R� Rz R� ( R� R� t newpos( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s N( R� R� R� R0 R� R� R R� R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR
� s c B s; e Z d Z d d � Z d d � Z d d � Z d � Z RS( s6 Ttk Progressbar widget shows the status of a long-running
operation. They can operate in two modes: determinate mode shows the
amount completed relative to the total amount of work to be done, and
indeterminate mode provides an animated display to let the user know
that something is happening.c K s t j | | d | � d S( s� Construct a Ttk Progressbar with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
orient, length, mode, maximum, value, variable, phase
s ttk::progressbarN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c C s | j j | j d | � d S( s� Begin autoincrement mode: schedules a recurring timer event
that calls method step every interval milliseconds.
interval defaults to 50 milliseconds (20 steps/second) if omitted.t startN( R! Rz R� ( R� t interval( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c C s | j j | j d | � d S( sR Increments the value option by amount.
amount defaults to 1.0 if omitted.t stepN( R! Rz R� ( R� t amount( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c C s | j j | j d � d S( sV Stop autoincrement mode: cancels any recurring timer event
initiated by start.t stopN( R! Rz R� ( R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� s N( R� R� R� R0 R� R� R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR � s
c B s# e Z d Z d d � Z d � Z RS( se Ttk Radiobutton widgets are used in groups to show or change a
set of mutually-exclusive options.c K s t j | | d | � d S( s Construct a Ttk Radiobutton with parent master.
STANDARD OPTIONS
class, compound, cursor, image, state, style, takefocus,
text, textvariable, underline, width
WIDGET-SPECIFIC OPTIONS
command, value, variable
s ttk::radiobuttonN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� s c C s | j j | j d � S( s� Sets the option variable to the option value, selects the
widget, and invokes the associated command.
Returns the result of the command, or an empty string if
no command is specified.R� ( R! Rz R� ( R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� s N( R� R� R� R0 R� R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR
s c B s5 e Z d Z d d � Z d d � Z d d d � Z RS( s Ttk Scale widget is typically used to control the numeric value of
a linked variable that varies uniformly over some range.c K s t j | | d | � d S( s� Construct a Ttk Scale with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
command, from, length, orient, to, value, variable
s
ttk::scaleN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� * s c K sa | r | j | � n t j | | � t d | k d | k d | k g � r] | j d � n d S( s� Modify or query scale options.
Setting a value for any of the "from", "from_" or "to" options
generates a <<RangeChanged>> event.RE t from_t tos <<RangeChanged>>N( t updateR� RZ t anyt event_generate( R� t cnfRH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyRZ 8 s
'c C s | j j | j d | | � S( s� Get the current value of the value option, or the value
corresponding to the coordinates x, y if they are specified.
x and y are pixel coordinates relative to the scale widget
origin.R ( R! Rz R� ( R� R� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR D s N( R� R� R� R0 R� RZ R ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR & s c B s e Z d Z d d � Z RS( s; Ttk Scrollbar controls the viewport of a scrollable widget.c K s t j | | d | � d S( s� Construct a Ttk Scrollbar with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
command, orient
s ttk::scrollbarN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� P s N( R� R� R� R0 R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR M s c B s e Z d Z d d � Z RS( sI Ttk Separator widget displays a horizontal or vertical separator
bar.c K s t j | | d | � d S( s� Construct a Ttk Separator with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
orient
s ttk::separatorN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� b s N( R� R� R� R0 R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR ^ s c B s e Z d Z d d � Z RS( sl Ttk Sizegrip allows the user to resize the containing toplevel
window by pressing and dragging the grip.c K s t j | | d | � d S( s� Construct a Ttk Sizegrip with parent master.
STANDARD OPTIONS
class, cursor, state, style, takefocus
s
ttk::sizegripN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� t s N( R� R� R� R0 R� ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR p s c B sd e Z d Z d! d � Z d! d � Z d! d � Z d � Z d! d � Z d � Z d � Z
d � Z d! d � Z d! d
� Z
d � Z d � Z d
� Z d � Z d � Z d � Z d! d � Z d! d � Z d � Z e Z d � Z d � Z d � Z d � Z d! d! d � Z d � Z d � Z d � Z d � Z d! d! d � Z! d! d! d � Z" d! d � Z# d! d � Z$ RS(" s� Ttk Treeview widget displays a hierarchical collection of items.
Each item has a textual label, an optional image, and an optional list
of data values. The data values are displayed in successive columns
after the tree label.c K s t j | | d | � d S( s� Construct a Ttk Treeview with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus, xscrollcommand,
yscrollcommand
WIDGET-SPECIFIC OPTIONS
columns, displaycolumns, height, padding, selectmode, show
ITEM OPTIONS
text, image, values, open, tags
TAG OPTIONS
foreground, background, font, image
s
ttk::treeviewN( R� R� ( R� R% RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c C s+ | j | j j | j d | | � � p* d S( sT Returns the bounding box (relative to the treeview widget's
window) of the specified item in the form x y width height.
If column is specified, returns the bounding box of that cell.
If the item is not visible (i.e., if it is a descendant of a
closed item or is scrolled offscreen), returns an empty string.R� R6 ( R� R! Rz R� ( R� R< t column( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c C s1 | j j | j j | j d | p$ d � p- d � S( sh Returns a tuple of children belonging to item.
If item is not specified, returns root children.RP R6 ( ( R! Rs Rz R� ( R� R< ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt get_children� s c G s | j j | j d | | � d S( s� Replaces item's child with newchildren.
Children present in item that are not present in newchildren
are detached from tree. No items in newchildren may be an
ancestor of item.RP N( R! Rz R� ( R� R< t newchildren( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt set_children� s c K s5 | d k r d | | <n t | j | | j d | � S( s
Query or modify the options for the specified column.
If kw is not given, returns a dict of the column option values. If
option is specified then the value for that option is returned.
Otherwise, sets the options to the corresponding values.R� N( R0 R} R! R� ( R� R� R� RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s
c G s | j j | j d | � d S( s_ Delete all specified items and all their descendants. The root
item may not be deleted.t deleteN( R! Rz R� ( R� R: ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c G s | j j | j d | � d S( s� Unlinks all of the specified items from the tree.
The items and all of their descendants are still present, and may
be reinserted at another point in the tree, but will not be
displayed. The root item may not be detached.t detachN( R! Rz R� ( R� R: ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c C s% | j j | j j | j d | � � S( sS Returns True if the specified item is present in the tree,
False otherwise.t exists( R! R� Rz R� ( R� R< ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c C s | j j | j d | � S( s} If item is specified, sets the focus item to item. Otherwise,
returns the current focus item, or '' if there is none.t focus( R! Rz R� ( R� R< ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c K sy | j d � } | rD t | t � rD | j j | | j � | d <n | d k r] d | | <n t | j | | j d | � S( s_ Query or modify the heading options for the specified column.
If kw is not given, returns a dict of the heading option values. If
option is specified then the value for that option is returned.
Otherwise, sets the options to the corresponding values.
Valid options/values are:
text: text
The text to display in the column heading
image: image_name
Specifies an image to display to the right of the column
heading
anchor: anchor
Specifies how the heading text should be aligned. One of
the standard Tk anchor values
command: callback
A callback to be invoked when the heading label is
pressed.
To configure the tree column heading, call this with column = "#0" t commandt headingN(
R R( R� R% t registert _substituteR0 R} R! R� ( R� R� R� RH t cmd( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s
c C s | j j | j d | | | � S( s� Returns a description of the specified component under the
point given by x and y, or the empty string if no such component
is present at that position.R� ( R! Rz R� ( R� t componentR� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s c C s | j d d | � S( s. Returns the item ID of the item at position y.t rowi ( R� ( R� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt identify_row s c C s | j d | d � S( sa Returns the data column identifier of the cell at position x.
The tree column has ID #0.R� i ( R� ( R� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt identify_column s c C s | j d | | � S( s� Returns one of:
heading: Tree heading area.
separator: Space between two columns headings;
tree: The tree area.
cell: A data cell.
* Availability: Tk 8.6t region( R� ( R� R� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt identify_region s c C s | j d | | � S( sE Returns the element at position x, y.
* Availability: Tk 8.6R� ( R� ( R� R� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt identify_element s c C s% | j j | j j | j d | � � S( sO Returns the integer index of item within its parent's list
of children.R� ( R! R� Rz R� ( R� R< ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� # s c K sg t | � } | d k rB | j j | j d | | d | | � } n! | j j | j d | | | � } | S( s� Creates a new item and return the item identifier of the newly
created item.
parent is the item ID of the parent item, or the empty string
to create a new top-level item. index is an integer, or the value
end, specifying where in the list of parent's children to insert
the new item. If index is less than or equal to zero, the new node
is inserted at the beginning, if index is greater than or equal to
the current number of children, it is inserted at the end. If iid
is specified, it is used as the item identifier, iid must not
already exist in the tree. Otherwise, a new unique identifier
is generated.R� s -idN( R5 R0 R! Rz R� ( R� R� R� t iidRH R3 Rw ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� ) s
!c K s5 | d k r d | | <n t | j | | j d | � S( s- Query or modify the options for the specified item.
If no options are given, a dict with options/values for the item
is returned. If option is specified then the value for that option
is returned. Otherwise, sets the options to the corresponding
values as given by kw.R< N( R0 R} R! R� ( R� R< R� RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR< @ s
c C s# | j j | j d | | | � d S( sR Moves item to position index in parent's list of children.
It is illegal to move an item under one of its descendants. If
index is less than or equal to zero, item is moved to the
beginning, if greater than or equal to the number of children,
it is moved to the end. If item was detached it is reattached.t moveN( R! Rz R� ( R� R< R� R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� L s c C s | j j | j d | � S( se Returns the identifier of item's next sibling, or '' if item
is the last child of its parent.t next( R! Rz R� ( R� R< ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� X s c C s | j j | j d | � S( sa Returns the ID of the parent of item, or '' if item is at the
top level of the hierarchy.R� ( R! Rz R� ( R� R< ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� ^ s c C s | j j | j d | � S( sj Returns the identifier of item's previous sibling, or '' if
item is the first child of its parent.t prev( R! Rz R� ( R� R< ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� d s c C s | j j | j d | � d S( s� Ensure that item is visible.
Sets all of item's ancestors open option to True, and scrolls
the widget if necessary so that item is within the visible
portion of the tree.t seeN( R! Rz R� ( R� R< ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� j s c C sC t | t � r | f } n | j j | j j | j d | | � � S( s2 If selop is not specified, returns selected items.t selection( R( R� R! Rs Rz R� ( R� t selopR: ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� s s c C s | j d | � d S( s items becomes the new selection.R� N( R� ( R� R: ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt
selection_setz s c C s | j d | � d S( s Add items to the selection.R� N( R� ( R� R: ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt
selection_add s c C s | j d | � d S( s Remove items from the selection.t removeN( R� ( R� R: ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt selection_remove� s c C s | j d | � d S( s1 Toggle the selection state of each item in items.t toggleN( R� ( R� R: ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt selection_toggle� s c C s] | j j | j d | | | � } | d k rU | d k rU t | j | d t d t �S| Sd S( s; Query or set the value of given item.
With one argument, return a dictionary of column/value pairs
for the specified item. With two arguments, return the current
value of the specified column. With three arguments, set the
value of given column in given item to the specified value.R� t cut_minusRy N( R! Rz R� R0 R R� R{ ( R� R< R� R+ Rw ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s
!
c C s, | j | j d d | f | | d d �d S( s� Bind a callback for the given event sequence to the tag tagname.
When an event is delivered to an item, the callbacks for each
of the item's tags option are called.t tagt bindR� i N( t _bindR� ( R� t tagnamet sequenceR� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt tag_bind� s c K s8 | d k r d | | <n t | j | | j d d | � S( sB Query or modify the options for the specified tagname.
If kw is not given, returns a dict of the option settings for tagname.
If option is specified, returns the value for that option for the
specified tagname. Otherwise, sets the options to the corresponding
values for the given tagname.R� RZ N( R0 R} R! R� ( R� R� R� RH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt
tag_configure� s
c C sc | d k r4 | j j | j j | j d d | � � S| j j | j j | j d d | | � � Sd S( s� If item is specified, returns 1 or 0 depending on whether the
specified item has the given tagname. Otherwise, returns a list of
all items which have the specified tag.
* Availability: Tk 8.6R� t hasN( R0 R! Rs Rz R� R� ( R� R� R< ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt tag_has� s
N(% R� R� R� R0 R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R< R� t reattachR� R� R� R� R� R� R� R� R� R� R� R R ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR ~ sD
c B sV e Z d Z d d d d d � Z d � Z d � Z d � Z d � Z e e e � Z
RS( s� A Ttk Scale widget with a Ttk Label widget indicating its
current value.
The Ttk Scale can be accessed through instance.scale, and Ttk Label
can be accessed through instance.labeli i
c K sp | j d d � d k | _ t j | | | � | p@ t j | � | _ | j j | � | | _ t | � | _
t | d | j d | d | �| _ | j j
d | j � | j r� d n d } | d k r� d n d } | j j d | d d
� t | � j d | � } | j
j d | d k r$d n d
� | j j d | j � | _ | j
d | j � | j
d | j � d S( s� Construct a horizontal LabeledScale with parent master, a
variable to be associated with the Ttk Scale widget and its range.
If variable is not specified, a Tkinter.IntVar is created.
WIDGET-SPECIFIC OPTIONS
compound: 'top' or 'bottom'
Specifies how to display the label relative to the scale.
Defaults to 'top'.
t compoundt topt variableR� R� s <<RangeChanged>>t bottomt sidet fillR� t anchort nR` t ws <Configure>s <Map>N( t popt
_label_topR R� R� t IntVart _variableR� t _last_validR t labelR t scaleR� t _adjustt packt placet trace_variablet _LabeledScale__tracecb( R� R% R R� R� RH t
scale_sidet
label_sidet tmp( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� � s $%c C sW y | j j d | j � Wn t k
r- n X| ` t j | � d | _ d | _ d S( s9 Destroy this widget and possibly its associated variable.R N( R t
trace_vdeleteR t AttributeErrorR t destroyR0 R R ( R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR � s
c s� � f d � } t � j d � } t � j d � } | | k rQ | | } } n � j j � } | | k ow | k n s� � j � _ d S| � _ | � j d <� j | � d S( s1 Adjust the label position according to the scale.c s� � j � � j j � \ } } � j rG � j j � � j j � } n � j j � � j j � } � j j d | d | � d S( NR� R� ( t update_idletasksR t coordsR t winfo_yR t winfo_reqheightt place_configure( R� R� ( R� ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt adjust_label� s
RE R� Nt text( R� R R R R R+ R t
after_idle( R� RG R$ R� R� t newval( ( R� s" /usr/lib64/python2.7/lib-tk/ttk.pyR � s
c C s
| j j � S( s Return current scale value.( R R ( R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt
_get_value s c C s | j j | � d S( s Set new scale value.N( R R� ( R� R> ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt
_set_value s N( R� R� R� R0 R� R R R( R) t propertyR+ ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR � s # c B s8 e Z d Z d d � Z d � Z d d � Z d � Z RS( sm Themed OptionMenu, based after Tkinter's OptionMenu, which allows
the user to select a value from a menu.c O s� i | d 6| j d d � d 6| j d d � d 6} t j | | | � t j | d t �| d <| | _ | j d d � | _ | r� t j d | j
� j � � � n | j | | � d S( s9 Construct a themed OptionMenu widget with master as the parent,
the resource textvariable set to variable, the initially selected
value specified by the default parameter, the menu values given by
*values and additional keywords.
WIDGET-SPECIFIC OPTIONS
style: stylename
Menubutton style.
direction: 'above', 'below', 'left', 'right', or 'flush'
Menubutton direction.
command: callback
A callback that will be invoked after selecting an item.
t textvariableR� t directiont tearofft menuR� s unknown option -%sN(
R
R0 R R� R� t MenuR� R t _callbackt TclErrort iterkeysR� t set_menu( R� R% R R� t valuest kwargsRH ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR� & s c C s5 | d k r% | j t j | | � � St j | | � S( NR. ( t nametowidgetR t __getitem__( R� R< ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR7 C s c G s| | d } | j d d � xB | D]: } | j d | d t j | j | | j � d | j � q! W| rx | j j | � n d S( sU Build a new menu of radiobuttons with *values and optionally
a default value.R. i t endR R� R N( R� t add_radiobuttonR� t _setitR R0 R� ( R� R� R4 R. R> ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR3 J s
c C s/ y
| ` Wn t k
r n Xt j | � d S( s0 Destroy this widget and its associated variable.N( R R R R ( R� ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR X s
N( R� R� R� R0 R� R7 R3 R ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyR " s
(8 R� t __version__t
__author__t __all__R� R R R R t TkVersionR# R� R R' R- R0 R5 R? RB RO RQ Rf Rq Ru R} R� R� R{ R R t objectR R� R R R R R R R R R R R R
R R
R R R R t XViewt YViewR R R ( ( ( s" /usr/lib64/python2.7/lib-tk/ttk.pyt <module>
sf "
%1 *
�B *"� 8* ' "� Da Tkdnd.pyc 0000644 00000031031 15032720555 0006327 0 ustar 00 �
z fc @ sw d Z d d l Z d � Z d d d � � YZ d d
d � � YZ d d d � � YZ d
� Z e d k rs e � n d S( sF Drag-and-drop support for Tkinter.
This is very preliminary. I currently only support dnd *within* one
application, between different windows (or within the same window).
I am trying to make this as generic as possible -- not dependent on
the use of a particular widget or icon type, etc. I also hope that
this will work with Pmw.
To enable an object to be dragged, you must create an event binding
for it that starts the drag-and-drop process. Typically, you should
bind <ButtonPress> to a callback function that you write. The function
should call Tkdnd.dnd_start(source, event), where 'source' is the
object to be dragged, and 'event' is the event that invoked the call
(the argument to your callback function). Even though this is a class
instantiation, the returned instance should not be stored -- it will
be kept alive automatically for the duration of the drag-and-drop.
When a drag-and-drop is already in process for the Tk interpreter, the
call is *ignored*; this normally averts starting multiple simultaneous
dnd processes, e.g. because different button callbacks all
dnd_start().
The object is *not* necessarily a widget -- it can be any
application-specific object that is meaningful to potential
drag-and-drop targets.
Potential drag-and-drop targets are discovered as follows. Whenever
the mouse moves, and at the start and end of a drag-and-drop move, the
Tk widget directly under the mouse is inspected. This is the target
widget (not to be confused with the target object, yet to be
determined). If there is no target widget, there is no dnd target
object. If there is a target widget, and it has an attribute
dnd_accept, this should be a function (or any callable object). The
function is called as dnd_accept(source, event), where 'source' is the
object being dragged (the object passed to dnd_start() above), and
'event' is the most recent event object (generally a <Motion> event;
it can also be <ButtonPress> or <ButtonRelease>). If the dnd_accept()
function returns something other than None, this is the new dnd target
object. If dnd_accept() returns None, or if the target widget has no
dnd_accept attribute, the target widget's parent is considered as the
target widget, and the search for a target object is repeated from
there. If necessary, the search is repeated all the way up to the
root widget. If none of the target widgets can produce a target
object, there is no target object (the target object is None).
The target object thus produced, if any, is called the new target
object. It is compared with the old target object (or None, if there
was no old target widget). There are several cases ('source' is the
source object, and 'event' is the most recent event object):
- Both the old and new target objects are None. Nothing happens.
- The old and new target objects are the same object. Its method
dnd_motion(source, event) is called.
- The old target object was None, and the new target object is not
None. The new target object's method dnd_enter(source, event) is
called.
- The new target object is None, and the old target object is not
None. The old target object's method dnd_leave(source, event) is
called.
- The old and new target objects differ and neither is None. The old
target object's method dnd_leave(source, event), and then the new
target object's method dnd_enter(source, event) is called.
Once this is done, the new target object replaces the old one, and the
Tk mainloop proceeds. The return value of the methods mentioned above
is ignored; if they raise an exception, the normal exception handling
mechanisms take over.
The drag-and-drop processes can end in two ways: a final target object
is selected, or no final target object is selected. When a final
target object is selected, it will always have been notified of the
potential drop by a call to its dnd_enter() method, as described
above, and possibly one or more calls to its dnd_motion() method; its
dnd_leave() method has not been called since the last call to
dnd_enter(). The target is notified of the drop by a call to its
method dnd_commit(source, event).
If no final target object is selected, and there was an old target
object, its dnd_leave(source, event) method is called to complete the
dnd sequence.
Finally, the source object is notified that the drag-and-drop process
is over, by a call to source.dnd_end(target, event), specifying either
the selected target object, or None if no target object was selected.
The source object can use this to implement the commit action; this is
sometimes simpler than to do it in the target's dnd_commit(). The
target's dnd_commit() method could then simply be aliased to
dnd_leave().
At any time during a dnd sequence, the application can cancel the
sequence by calling the cancel() method on the object returned by
dnd_start(). This will call dnd_leave() if a target is currently
active; it will never call dnd_commit().
i����Nc C s$ t | | � } | j r | Sd Sd S( N( t
DndHandlert roott None( t sourcet eventt h( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyt dnd_startl s R c B sJ e Z d Z d � Z d � Z d � Z d � Z d d � Z d d � Z RS( c C s� | j d k r d S| j j � } y | j d SWn# t k
rV | | _ | | _ n X| | _ d | _ | j | _ } | j | _
} d | | f | _ | d p� d | _ | j
| j | j � | j
d | j � d | d <d S( Ni s <B%d-ButtonRelease-%d>t cursort s <Motion>t hand2( t numt widgett _roott _DndHandler__dndt AttributeErrorR R R t targett initial_buttont initial_widgett release_patternt save_cursort bindt
on_releaset on_motion( t selfR R R t buttonR ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyt __init__z s$
c C s= | j } d | _ | r9 y
| ` Wq9 t k
r5 q9 Xn d S( N( R R R
R ( R R ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyt __del__� s
c C s | j | j } } | j j | | � } | j } d } xM | r� y
| j } Wn t k
r` n X| | | � } | rz Pn | j } q: W| j } | | k r� | r� | j
| | � q� nD | r� d | _ | j | | � n | r� | j | | � | | _ n d S( N(
t x_roott y_rootR t winfo_containingR R t
dnd_acceptR t masterR t
dnd_motiont dnd_leavet dnd_enter( R R t xt yt
target_widgetR t
new_targett attrt
old_target( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyR � s.
c C s | j | d � d S( Ni ( t finish( R R ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyR � s c C s | j | d � d S( Ni ( R) ( R R ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyt cancel� s i c C s� | j } | j } | j } | j } z� | ` | j j | j � | j j d � | j | d <d | _ | _ | _ | _ | r� | r� | j | | � q� | j
| | � n Wd | j | | � Xd S( Ns <Motion>R ( R R R R R
t unbindR R R t
dnd_commitR! t dnd_end( R R t commitR R R R ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyR) � s
N(
t __name__t
__module__R R R R R R R* R) ( ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyR v s t Iconc B sV e Z d � Z d d d � Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c C s$ | | _ d | _ | _ | _ d S( N( t nameR t canvast labelt id( R R2 ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyR � s i
c C s� | | j k r, | j j | j | | � d S| j rB | j � n | sL d St j | d | j d d d d �} | j | | d | d d �} | | _ | | _ | | _ | j d | j
� d S(
Nt textt borderwidthi t relieft raisedt windowt anchort nws
<ButtonPress>( R3 t coordsR5 t detacht Tkintert LabelR2 t
create_windowR4 R t press( R R3 R# R$ R4 R5 ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyt attach� s
c C sW | j } | s d S| j } | j } d | _ | _ | _ | j | � | j � d S( N( R3 R5 R4 R t deletet destroy( R R3 R5 R4 ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyR> � s
c C sO t | | � rK | j | _ | j | _ | j j | j � \ | _ | _ n d S( N(
R R# t x_offR$ t y_offR3 R= R5 t x_origt y_orig( R R ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyRB � s c C s8 | j | j | � \ } } | j j | j | | � d S( N( t whereR3 R= R5 ( R R R# R$ ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyt move� s c C s# | j j | j | j | j � d S( N( R3 R= R5 RH RI ( R ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyt putback� s c C sJ | j � } | j � } | j | } | j | } | | j | | j f S( N( t winfo_rootxt winfo_rootyR R RF RG ( R R3 R t x_orgt y_orgR# R$ ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyRJ � s
c C s d S( N( ( R R R ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyR- s (
R/ R0 R RC R> RB RK RL RJ R- ( ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyR1 � s
t Testerc B s> e Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c C s_ t j | � | _ t j | j d d d d �| _ | j j d d d d � | j | j _ d S( Nt widthid t heightt fillt botht expandi ( R? t Toplevelt topt CanvasR3 t packR ( R R ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyR s !c C s | S( N( ( R R R ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyR s c C s� | j j � | j | j | � \ } } | j j | j � \ } } } } | | | | } }
| j j | | | | | |
� | _ | j | | � d S( N( R3 t focus_setRJ t bboxR5 t create_rectanglet dndidR ( R R R R# R$ t x1t y1t x2t y2t dxt dy( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyR" s
!&c C sa | j | j | � \ } } | j j | j � \ } } } } | j j | j | | | | � d S( N( RJ R3 R\ R^ RK ( R R R R# R$ R_ R` Ra Rb ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyR s !c C s- | j j � | j j | j � d | _ d S( N( RX R[ R3 RD R^ R ( R R R ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyR! $ s
c C sE | j | | � | j | j | � \ } } | j | j | | � d S( N( R! RJ R3 RC ( R R R R# R$ ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyR, ) s ( R/ R0 R R R" R R! R, ( ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyRQ s c C s� t j � } | j d � t j d | j d d � j � t | � } | j j d � t | � } | j j d � t | � } | j j d � t d � } t d � } t d
� } | j | j
� | j | j
� | j | j
� | j � d S( Ns +1+1t commandR6 t Quits +1+60s +120+60s +240+60t ICON1t ICON2t ICON3( R? t Tkt geometryt Buttont quitRZ RQ RX R1 RC R3 t mainloop( R t t1t t2t t3t i1t i2t i3( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyt test. s
t __main__( ( ( ( t __doc__R? R R R1 RQ Ru R/ ( ( ( s$ /usr/lib64/python2.7/lib-tk/Tkdnd.pyt <module>d s
Z<" tkSimpleDialog.pyo 0000644 00000021631 15032720555 0010214 0 ustar 00 �
z fc @ s� d Z d d l Td e f d � � YZ d e f d � � YZ d e f d � � YZ d � Z d
e f d � � YZ d � Z d
e f d � � YZ d � Z
e d k r� e � Z
e
j � e d d d d �GHe d d d d d d �GHe
d d � GHn d S( s� Dialog boxes
This module handles dialog boxes. It contains the following
public symbols:
Dialog -- a base class for dialogs
askinteger -- get an integer from the user
askfloat -- get a float from the user
askstring -- get a string from the user
i����( t *t Dialogc B s_ e Z d Z d d � Z d � Z d � Z d � Z d d � Z d d � Z d � Z
d � Z RS(
sZ Class to open dialogs.
This class is intended as a base class for custom dialogs
c C s= t j | | � | j � | j � r6 | j | � n | rL | j | � n | | _ d | _ t | � } | j
| � | _ | j d d d d � | j
� | j s� | | _ n | j d | j � | j d k r| j d | j � d | j � d f � n | j � | j j � | j � | j � | j | � d S( s� Initialize a dialog.
Arguments:
parent -- a parent window (the application window)
title -- the dialog title
t padxi t padyt WM_DELETE_WINDOWs +%d+%di2 N( t Toplevelt __init__t withdrawt winfo_viewablet transientt titlet parentt Nonet resultt Framet bodyt
initial_focust packt buttonboxt protocolt cancelt geometryt winfo_rootxt winfo_rootyt deiconifyt focus_sett wait_visibilityt grab_sett wait_window( t selfR R
R ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR % s.
c C s d | _ t j | � d S( s Destroy the windowN( R R R t destroy( R ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR X s c C s d S( s� create dialog body.
return widget that should have initial focus.
This method should be overridden, and is called
by the __init__ method.
N( ( R t master( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR ` s c
C s� t | � } t | d d d d d | j d t �} | j d t d d d
d � t | d d d d d | j �} | j d t d d d
d � | j d | j � | j d
| j � | j � d S( s[ add standard button box.
override if you do not want the standard buttons
t textt OKt widthi
t commandt defaultt sideR i R t Cancels <Return>s <Escape>N( R t Buttont okt ACTIVER t LEFTR t bind( R t boxt w( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR i s ' ! c C sQ | j � s | j j � d S| j � | j � z | j � Wd | j � Xd S( N( t validateR R R t update_idletaskst applyR ( R t event( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR( ~ s
c C s- | j d k r | j j � n | j � d S( N( R R R R ( R R1 ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR � s c C s d S( s� validate the data
This method is called automatically to validate the data before the
dialog is destroyed. By default, it always validates OK.
i ( ( R ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR. � s c C s d S( s� process the data
This method is called automatically to process the data, *after*
the dialog is destroyed. By default, it does nothing.
N( ( R ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR0 � s N( t __name__t
__module__t __doc__R R R R R R( R R. R0 ( ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR s 3
t _QueryDialogc B s8 e Z d d d d d � Z d � Z d � Z d � Z RS( c C sY | s d d l } | j } n | | _ | | _ | | _ | | _ t j | | | � d S( Ni����( t Tkintert
_default_roott promptt minvaluet maxvaluet initialvalueR R ( R R
R8 R; R9 R: R R6 ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR � s c C s d | _ t j | � d S( N( R t entryR R ( R ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR � s c C s� t | d | j d t �} | j d d d d d t � t | d d �| _ | j j d d
d d d t t � | j d k r� | j j
d | j � | j j d t � n | j S( NR t justifyt rowi R i t stickyt nameR< i (
t LabelR8 R* t gridt Wt EntryR< t ER; R t insertt select_ranget END( R R R- ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR � s #c C s� d d l } y | j � } Wn/ t k
rM | j d | j d d | �d SX| j d k r� | | j k r� | j d d | j d | �d S| j d k r� | | j k r� | j d d | j d | �d S| | _ d
S( Ni����s
Illegal values
Please try againR i s Too smalls2 The allowed minimum value is %s. Please try again.s Too larges2 The allowed maximum value is %s. Please try again.i ( t tkMessageBoxt getresultt
ValueErrort showwarningt errormessageR9 R R: R
( R RI R
( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR. � s2
N( R2 R3 R R R R R. ( ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR5 � s t
_QueryIntegerc B s e Z d Z d � Z RS( s Not an integer.c C s t | j j � � S( N( t intR< t get( R ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyRJ � s ( R2 R3 RM RJ ( ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyRN � s c K s t | | | � } | j S( s� get an integer from the user
Arguments:
title -- the dialog title
prompt -- the label text
**kw -- see SimpleDialog class
Return value is an integer
( RN R
( R
R8 t kwt d( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyt
askinteger� s t _QueryFloatc B s e Z d Z d � Z RS( s Not a floating point value.c C s t | j j � � S( N( t floatR< RP ( R ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyRJ s ( R2 R3 RM RJ ( ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyRT s c K s t | | | � } | j S( s� get a float from the user
Arguments:
title -- the dialog title
prompt -- the label text
**kw -- see SimpleDialog class
Return value is a float
( RT R
( R
R8 RQ RR ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyt askfloat s t _QueryStringc B s# e Z d � Z d � Z d � Z RS( c O sC d | k r# | d | _ | d =n d | _ t j | | | � d S( Nt show( t _QueryString__showR R5 R ( R t argsRQ ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR s
c C s; t j | | � } | j d k r7 | j d | j � n | S( NRX ( R5 R RY R t configure( R R R< ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyR % s c C s
| j j � S( N( R< RP ( R ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyRJ + s ( R2 R3 R R RJ ( ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyRW s c K s t | | | � } | j S( s� get a string from the user
Arguments:
title -- the dialog title
prompt -- the label text
**kw -- see SimpleDialog class
Return value is a string
( RW R
( R
R8 RQ RR ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyt askstring. s t __main__t Spams Egg countR; i s Egg weight
(in tons)R9 i R: id s Egg labelNi� ( R4 R6 R R R5 RN RS RT RV RW R\ R2 t Tkt roott update( ( ( s- /usr/lib64/python2.7/lib-tk/tkSimpleDialog.pyt <module> s
�J