desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'Return true if the widget and all its higher ancestors are mapped.'
| def winfo_viewable(self):
| return getint(self.tk.call('winfo', 'viewable', self._w))
|
'Return one of the strings directcolor, grayscale, pseudocolor,
staticcolor, staticgray, or truecolor for the
colormodel of this widget.'
| def winfo_visual(self):
| return self.tk.call('winfo', 'visual', self._w)
|
'Return the X identifier for the visual for this widget.'
| def winfo_visualid(self):
| return self.tk.call('winfo', 'visualid', self._w)
|
'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.'
| def winfo_visualsavailable(self, includeids=0):
| 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)
|
'Internal function.'
| def __winfo_parseitem(self, t):
| return (t[:1] + tuple(map(self.__winfo_getint, t[1:])))
|
'Internal function.'
| def __winfo_getint(self, x):
| return int(x, 0)
|
'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.'
| def winfo_vrootheight(self):
| return getint(self.tk.call('winfo', 'vrootheight', self._w))
|
'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.'
| def winfo_vrootwidth(self):
| return getint(self.tk.call('winfo', 'vrootwidth', self._w))
|
'Return the x offset of the virtual root relative to the root
window of the screen of this widget.'
| def winfo_vrootx(self):
| return getint(self.tk.call('winfo', 'vrootx', self._w))
|
'Return the y offset of the virtual root relative to the root
window of the screen of this widget.'
| def winfo_vrooty(self):
| return getint(self.tk.call('winfo', 'vrooty', self._w))
|
'Return the width of this widget.'
| def winfo_width(self):
| return getint(self.tk.call('winfo', 'width', self._w))
|
'Return the x coordinate of the upper left corner of this widget
in the parent.'
| def winfo_x(self):
| return getint(self.tk.call('winfo', 'x', self._w))
|
'Return the y coordinate of the upper left corner of this widget
in the parent.'
| def winfo_y(self):
| return getint(self.tk.call('winfo', 'y', self._w))
|
'Enter event loop until all pending events have been processed by Tcl.'
| def update(self):
| self.tk.call('update')
|
'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.'
| def update_idletasks(self):
| self.tk.call('update', 'idletasks')
|
'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).'
| def bindtags(self, tagList=None):
| if (tagList is None):
return self.tk.splitlist(self.tk.call('bindtags', self._w))
else:
self.tk.call('bindtags', self._w, tagList)
return
|
'Internal function.'
| def _bind(self, what, sequence, func, add, needcleanup=1):
| if (type(func) is StringType):
self.tk.call((what + (sequence, func)))
else:
if func:
funcid = self._register(func, self._substitute, needcleanup)
cmd = ('%sif {"[%s %s]" == "break"} break\n' % (((add and '+') or ''), funcid, self._subst_format_str))
... |
'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, ... | def bind(self, sequence=None, func=None, add=None):
| return self._bind(('bind', self._w), sequence, func, add)
|
'Unbind for this widget for event SEQUENCE the
function identified with FUNCID.'
| def unbind(self, sequence, funcid=None):
| self.tk.call('bind', self._w, sequence, '')
if funcid:
self.deletecommand(funcid)
|
'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.'
| def bind_all(self, sequence=None, func=None, add=None):
| return self._bind(('bind', 'all'), sequence, func, add, 0)
|
'Unbind for all widgets for event SEQUENCE all functions.'
| def unbind_all(self, sequence):
| self.tk.call('bind', 'all', sequence, '')
|
'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.'
| def bind_class(self, className, sequence=None, func=None, add=None):
| return self._bind(('bind', className), sequence, func, add, 0)
|
'Unbind for a all widgets with bindtag CLASSNAME for event SEQUENCE
all functions.'
| def unbind_class(self, className, sequence):
| self.tk.call('bind', className, sequence, '')
|
'Call the mainloop of Tk.'
| def mainloop(self, n=0):
| self.tk.mainloop(n)
|
'Quit the Tcl interpreter. All widgets will be destroyed.'
| def quit(self):
| self.tk.quit()
|
'Internal function.'
| def _getints(self, string):
| if string:
return tuple(map(getint, self.tk.splitlist(string)))
|
'Internal function.'
| def _getdoubles(self, string):
| if string:
return tuple(map(getdouble, self.tk.splitlist(string)))
|
'Internal function.'
| def _getboolean(self, string):
| if string:
return self.tk.getboolean(string)
|
'Internal function.'
| def _displayof(self, displayof):
| if displayof:
return ('-displayof', displayof)
else:
if (displayof is None):
return ('-displayof', self._w)
return ()
|
'Internal function.'
| def _options(self, cnf, kw=None):
| 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 isinsta... |
'Return the Tkinter instance of a widget identified by
its Tcl name NAME.'
| def nametowidget(self, 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
|
'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.'
| def _register(self, func, subst=None, needcleanup=1):
| 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 ... |
'Internal function.'
| def _root(self):
| w = self
while w.master:
w = w.master
return w
|
'Internal function.'
| def _substitute(self, *args):
| 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:
... |
'Internal function.'
| def _report_exception(self):
| import sys
(exc, val, tb) = (sys.exc_type, sys.exc_value, sys.exc_traceback)
root = self._root()
root.report_callback_exception(exc, val, tb)
|
'Internal function.'
| def _configure(self, cmd, cnf, kw):
| if kw:
cnf = _cnfmerge((cnf, kw))
elif cnf:
cnf = _cnfmerge(cnf)
if (cnf is None):
cnf = {}
for x in self.tk.split(self.tk.call(_flatten((self._w, cmd)))):
cnf[x[0][1:]] = ((x[0][1:],) + x[1:])
return cnf
else:
if (type(cnf) is StringType):
... |
'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.'
| def configure(self, cnf=None, **kw):
| return self._configure('configure', cnf, kw)
|
'Return the resource value for a KEY given as string.'
| def cget(self, key):
| return self.tk.call(self._w, 'cget', ('-' + key))
|
'Return a list of all resource names of this widget.'
| def keys(self):
| return map((lambda x: x[0][1:]), self.tk.split(self.tk.call(self._w, 'configure')))
|
'Return the window path name of this widget.'
| def __str__(self):
| return self._w
|
'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.'
| def pack_propagate(self, flag=_noarg_):
| if (flag is Misc._noarg_):
return self._getboolean(self.tk.call('pack', 'propagate', self._w))
self.tk.call('pack', 'propagate', self._w, flag)
|
'Return a list of all slaves of this widget
in its packing order.'
| def pack_slaves(self):
| return map(self._nametowidget, self.tk.splitlist(self.tk.call('pack', 'slaves', self._w)))
|
'Return a list of all slaves of this widget
in its packing order.'
| def place_slaves(self):
| return map(self._nametowidget, self.tk.splitlist(self.tk.call('place', 'slaves', self._w)))
|
'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 t... | def grid_bbox(self, column=None, row=None, col2=None, row2=None):
| 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)
|
'Internal function.'
| def _grid_configure(self, command, index, cnf, kw):
| 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):
res = self.tk.call('grid', command, self._w, ... |
'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).'
| def grid_columnconfigure(self, index, cnf={}, **kw):
| return self._grid_configure('columnconfigure', index, cnf, kw)
|
'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.'
| def grid_location(self, x, y):
| return (self._getints(self.tk.call('grid', 'location', self._w, x, y)) or None)
|
'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.'
| def grid_propagate(self, flag=_noarg_):
| if (flag is Misc._noarg_):
return self._getboolean(self.tk.call('grid', 'propagate', self._w))
self.tk.call('grid', 'propagate', self._w, flag)
|
'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).'
| def grid_rowconfigure(self, index, cnf={}, **kw):
| return self._grid_configure('rowconfigure', index, cnf, kw)
|
'Return a tuple of the number of column and rows in the grid.'
| def grid_size(self):
| return (self._getints(self.tk.call('grid', 'size', self._w)) or None)
|
'Return a list of all slaves of this widget
in its packing order.'
| def grid_slaves(self, row=None, column=None):
| 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))))
|
'Bind a virtual event VIRTUAL (of the form <<Name>>)
to an event SEQUENCE such that the virtual event is triggered
whenever SEQUENCE occurs.'
| def event_add(self, virtual, *sequences):
| args = (('event', 'add', virtual) + sequences)
self.tk.call(args)
|
'Unbind a virtual event VIRTUAL from SEQUENCE.'
| def event_delete(self, virtual, *sequences):
| args = (('event', 'delete', virtual) + sequences)
self.tk.call(args)
|
'Generate an event SEQUENCE. Additional
keyword arguments specify parameter of the event
(e.g. x, y, rootx, rooty).'
| def event_generate(self, sequence, **kw):
| args = ('event', 'generate', self._w, sequence)
for (k, v) in kw.items():
args = (args + (('-%s' % k), str(v)))
self.tk.call(args)
|
'Return a list of all virtual events or the information
about the SEQUENCE bound to the virtual event VIRTUAL.'
| def event_info(self, virtual=None):
| return self.tk.splitlist(self.tk.call('event', 'info', virtual))
|
'Return a list of all existing image names.'
| def image_names(self):
| return self.tk.call('image', 'names')
|
'Return a list of all available image types (e.g. phote bitmap).'
| def image_types(self):
| return self.tk.call('image', 'types')
|
'Store FUNC, SUBST and WIDGET as members.'
| def __init__(self, func, subst, widget):
| self.func = func
self.subst = subst
self.widget = widget
|
'Apply first function SUBST to arguments, than FUNC.'
| def __call__(self, *args):
| try:
if self.subst:
args = self.subst(*args)
return self.func(*args)
except SystemExit as msg:
raise SystemExit, msg
except:
self.widget._report_exception()
|
'Query and change the horizontal position of the view.'
| def xview(self, *args):
| res = self.tk.call(self._w, 'xview', *args)
if (not args):
return self._getdoubles(res)
|
'Adjusts the view in the window so that FRACTION of the
total width of the canvas is off-screen to the left.'
| def xview_moveto(self, fraction):
| self.tk.call(self._w, 'xview', 'moveto', fraction)
|
'Shift the x-view according to NUMBER which is measured in "units"
or "pages" (WHAT).'
| def xview_scroll(self, number, what):
| self.tk.call(self._w, 'xview', 'scroll', number, what)
|
'Query and change the vertical position of the view.'
| def yview(self, *args):
| res = self.tk.call(self._w, 'yview', *args)
if (not args):
return self._getdoubles(res)
|
'Adjusts the view in the window so that FRACTION of the
total height of the canvas is off-screen to the top.'
| def yview_moveto(self, fraction):
| self.tk.call(self._w, 'yview', 'moveto', fraction)
|
'Shift the y-view according to NUMBER which is measured in
"units" or "pages" (WHAT).'
| def yview_scroll(self, number, what):
| self.tk.call(self._w, 'yview', 'scroll', number, what)
|
'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.'
| def wm_aspect(self, minNumer=None, minDenom=None, maxNumer=None, maxDenom=None):
| return self._getints(self.tk.call('wm', 'aspect', self._w, minNumer, minDenom, maxNumer, maxDenom))
|
'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... | def wm_attributes(self, *args):
| args = (('wm', 'attributes', self._w) + args)
return self.tk.call(args)
|
'Store NAME in WM_CLIENT_MACHINE property of this widget. Return
current value.'
| def wm_client(self, name=None):
| return self.tk.call('wm', 'client', self._w, name)
|
'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.'
| def wm_colormapwindows(self, *wlist):
| if (len(wlist) > 1):
wlist = (wlist,)
args = (('wm', 'colormapwindows', self._w) + wlist)
return map(self._nametowidget, self.tk.call(args))
|
'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.'
| def wm_command(self, value=None):
| return self.tk.call('wm', 'command', self._w, value)
|
'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.'
| def wm_deiconify(self):
| return self.tk.call('wm', 'deiconify', self._w)
|
'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.'
| def wm_focusmodel(self, model=None):
| return self.tk.call('wm', 'focusmodel', self._w, model)
|
'Return identifier for decorative frame of this widget if present.'
| def wm_frame(self):
| return self.tk.call('wm', 'frame', self._w)
|
'Set geometry to NEWGEOMETRY of the form =widthxheight+x+y. Return
current value if None is given.'
| def wm_geometry(self, newGeometry=None):
| return self.tk.call('wm', 'geometry', self._w, newGeometry)
|
'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.'
| def wm_grid(self, baseWidth=None, baseHeight=None, widthInc=None, heightInc=None):
| return self._getints(self.tk.call('wm', 'grid', self._w, baseWidth, baseHeight, widthInc, heightInc))
|
'Set the group leader widgets for related widgets to PATHNAME. Return
the group leader of this widget if None is given.'
| def wm_group(self, pathName=None):
| return self.tk.call('wm', 'group', self._w, pathName)
|
'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... | def wm_iconbitmap(self, bitmap=None, default=None):
| if default:
return self.tk.call('wm', 'iconbitmap', self._w, '-default', default)
else:
return self.tk.call('wm', 'iconbitmap', self._w, bitmap)
|
'Display widget as icon.'
| def wm_iconify(self):
| return self.tk.call('wm', 'iconify', self._w)
|
'Set mask for the icon bitmap of this widget. Return the
mask if None is given.'
| def wm_iconmask(self, bitmap=None):
| return self.tk.call('wm', 'iconmask', self._w, bitmap)
|
'Set the name of the icon for this widget. Return the name if
None is given.'
| def wm_iconname(self, newName=None):
| return self.tk.call('wm', 'iconname', self._w, newName)
|
'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.'
| def wm_iconposition(self, x=None, y=None):
| return self._getints(self.tk.call('wm', 'iconposition', self._w, x, y))
|
'Set widget PATHNAME to be displayed instead of icon. Return the current
value if None is given.'
| def wm_iconwindow(self, pathName=None):
| return self.tk.call('wm', 'iconwindow', self._w, pathName)
|
'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.'
| def wm_maxsize(self, width=None, height=None):
| return self._getints(self.tk.call('wm', 'maxsize', self._w, width, height))
|
'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.'
| def wm_minsize(self, width=None, height=None):
| return self._getints(self.tk.call('wm', 'minsize', self._w, width, height))
|
'Instruct the window manager to ignore this widget
if BOOLEAN is given with 1. Return the current value if None
is given.'
| def wm_overrideredirect(self, boolean=None):
| return self._getboolean(self.tk.call('wm', 'overrideredirect', self._w, boolean))
|
'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".'
| def wm_positionfrom(self, who=None):
| return self.tk.call('wm', 'positionfrom', self._w, who)
|
'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".'
| def wm_protocol(self, name=None, func=None):
| if hasattr(func, '__call__'):
command = self._register(func)
else:
command = func
return self.tk.call('wm', 'protocol', self._w, name, command)
|
'Instruct the window manager whether this width can be resized
in WIDTH or HEIGHT. Both values are boolean values.'
| def wm_resizable(self, width=None, height=None):
| return self.tk.call('wm', 'resizable', self._w, width, height)
|
'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".'
| def wm_sizefrom(self, who=None):
| return self.tk.call('wm', 'sizefrom', self._w, who)
|
'Query or set the state of this widget as one of normal, icon,
iconic (see wm_iconwindow), withdrawn, or zoomed (Windows only).'
| def wm_state(self, newstate=None):
| return self.tk.call('wm', 'state', self._w, newstate)
|
'Set the title of this widget.'
| def wm_title(self, string=None):
| return self.tk.call('wm', 'title', self._w, string)
|
'Instruct the window manager that this widget is transient
with regard to widget MASTER.'
| def wm_transient(self, master=None):
| return self.tk.call('wm', 'transient', self._w, master)
|
'Withdraw this widget from the screen such that it is unmapped
and forgotten by the window manager. Re-draw it with wm_deiconify.'
| def wm_withdraw(self):
| return self.tk.call('wm', 'withdraw', self._w)
|
'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.'
| def __init__(self, screenName=None, baseName=None, className='Tk', useTk=1, sync=0, use=None):
| self.master = None
self.children = {}
self._tkloaded = 0
self.tk = None
if (baseName is None):
import sys
import os
baseName = os.path.basename(sys.argv[0])
(baseName, ext) = os.path.splitext(baseName)
if (ext not in ('.py', '.pyc', '.pyo')):
baseN... |
'Destroy this and all descendants widgets. This will
end the application of this Tcl interpreter.'
| def destroy(self):
| global _default_root
for c in self.children.values():
c.destroy()
self.tk.call('destroy', self._w)
Misc.destroy(self)
if (_support_default_root and (_default_root is self)):
_default_root = None
return
|
'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.'
| def readprofile(self, baseName, className):
| 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(hom... |
'Internal function. It reports exception on sys.stderr.'
| def report_callback_exception(self, exc, val, tb):
| import traceback
import sys
sys.stderr.write('Exception in Tkinter callback\n')
sys.last_type = exc
sys.last_value = val
sys.last_traceback = tb
traceback.print_exception(exc, val, tb)
|
'Delegate attribute access to the interpreter object'
| def __getattr__(self, attr):
| return getattr(self.tk, attr)
|
'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 i... | def pack_configure(self, cnf={}, **kw):
| self.tk.call((('pack', 'configure', self._w) + self._options(cnf, kw)))
|
'Unmap this widget and do not use it for the packing order.'
| def pack_forget(self):
| self.tk.call('pack', 'forget', self._w)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.