desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'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.'
| def add(self, child, **kw):
| self.tk.call(((self._w, 'add', child) + self._options(kw)))
|
'Remove the pane containing child from the panedwindow
All geometry management options for child will be forgotten.'
| def remove(self, child):
| self.tk.call(self._w, 'forget', child)
|
'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.'
| def identify(self, x, y):
| return self.tk.call(self._w, 'identify', x, y)
|
'Internal function.'
| def proxy(self, *args):
| return (self._getints(self.tk.call(((self._w, 'proxy') + args))) or ())
|
'Return the x and y pair of the most recent proxy location'
| def proxy_coord(self):
| return self.proxy('coord')
|
'Remove the proxy from the display.'
| def proxy_forget(self):
| return self.proxy('forget')
|
'Place the proxy at the given x and y coordinates.'
| def proxy_place(self, x, y):
| return self.proxy('place', x, y)
|
'Internal function.'
| def sash(self, *args):
| return (self._getints(self.tk.call(((self._w, 'sash') + args))) or ())
|
'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.'
| def sash_coord(self, index):
| return self.sash('coord', index)
|
'Records x and y for the sash given by index;
Used in conjunction with later dragto commands to move the sash.'
| def sash_mark(self, index):
| return self.sash('mark', index)
|
'Place the sash given by index at the given coordinates'
| def sash_place(self, index, x, y):
| return self.sash('place', index, x, y)
|
'Query a management option for window.
Option may be any value allowed by the paneconfigure subcommand'
| def panecget(self, child, option):
| return self.tk.call(((self._w, 'panecget') + (child, ('-' + option))))
|
'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.'
| def paneconfigure(self, tagOrId, cnf=None, **kw):
| if ((cnf is None) and (not kw)):
cnf = {}
for x in self.tk.split(self.tk.call(self._w, 'paneconfigure', tagOrId)):
cnf[x[0][1:]] = ((x[0][1:],) + x[1:])
return cnf
if ((type(cnf) == StringType) and (not kw)):
x = self.tk.split(self.tk.call(self._w, 'paneconfigure', tagOrId, ('-' + cnf)))
return ((x[0][1:],) + x[1:])
self.tk.call(((self._w, 'paneconfigure', tagOrId) + self._options(cnf, kw)))
|
'Returns an ordered list of the child panes.'
| def panes(self):
| return self.tk.call(self._w, 'panes')
|
'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.'
| def tix_addbitmapdir(self, directory):
| return self.tk.call('tix', 'addbitmapdir', directory)
|
'Returns the current value of the configuration
option given by option. Option may be any of the
options described in the CONFIGURATION OPTIONS section.'
| def tix_cget(self, option):
| return self.tk.call('tix', 'cget', option)
|
'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.'
| def tix_configure(self, cnf=None, **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('tix', 'configure')):
cnf[x[0][1:]] = ((x[0][1:],) + x[1:])
return cnf
if isinstance(cnf, StringType):
x = self.tk.split(self.tk.call('tix', 'configure', ('-' + cnf)))
return ((x[0][1:],) + x[1:])
return self.tk.call((('tix', 'configure') + self._options(cnf)))
|
'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.'
| def tix_filedialog(self, dlgclass=None):
| if (dlgclass is not None):
return self.tk.call('tix', 'filedialog', dlgclass)
else:
return self.tk.call('tix', 'filedialog')
|
'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.'
| def tix_getbitmap(self, name):
| return self.tk.call('tix', 'getbitmap', 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.'
| def tix_getimage(self, name):
| return self.tk.call('tix', 'getimage', 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'
| def tix_option_get(self, name):
| return self.tk.call('tix', 'option', 'get', name)
|
'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.'
| def tix_resetoptions(self, newScheme, newFontSet, newScmPrio=None):
| if (newScmPrio is not None):
return self.tk.call('tix', 'resetoptions', newScheme, newFontSet, newScmPrio)
else:
return self.tk.call('tix', 'resetoptions', newScheme, newFontSet)
|
'Set a variable without calling its action routine'
| def set_silent(self, value):
| self.tk.call('tixSetSilent', self._w, value)
|
'Return the named subwidget (which must have been created by
the sub-class).'
| def subwidget(self, name):
| n = self._subwidget_name(name)
if (not n):
raise TclError, ((('Subwidget ' + name) + ' not child of ') + self._name)
n = n[(len(self._w) + 1):]
return self._nametowidget(n)
|
'Return all subwidgets.'
| def subwidgets_all(self):
| 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:
pass
return retlist
|
'Get a subwidget name (returns a String, not a Widget !)'
| def _subwidget_name(self, name):
| try:
return self.tk.call(self._w, 'subwidget', name)
except TclError:
return None
|
'Return the name of all subwidgets.'
| def _subwidget_names(self):
| try:
x = self.tk.call(self._w, 'subwidgets', '-all')
return self.tk.split(x)
except TclError:
return None
|
'Set configuration options for all subwidgets (and self).'
| def config_all(self, option, value):
| 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)
|
'Bind balloon widget to another.
One balloon widget may be bound to several widgets at the same time'
| def bind_widget(self, widget, cnf={}, **kw):
| self.tk.call(self._w, 'bind', widget._w, *self._options(cnf, kw))
|
'Add a button with given name to box.'
| def add(self, name, cnf={}, **kw):
| btn = self.tk.call(self._w, 'add', name, *self._options(cnf, kw))
self.subwidget_list[name] = _dummyButton(self, name)
return btn
|
'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.'
| def autosetmode(self):
| self.tk.call(self._w, 'autosetmode')
|
'Close the entry given by entryPath if its mode is close.'
| def close(self, entrypath):
| self.tk.call(self._w, 'close', entrypath)
|
'Returns the current mode of the entry given by entryPath.'
| def getmode(self, entrypath):
| return self.tk.call(self._w, 'getmode', entrypath)
|
'Open the entry given by entryPath if its mode is open.'
| def open(self, entrypath):
| self.tk.call(self._w, 'open', entrypath)
|
'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.'
| def setmode(self, entrypath, mode='none'):
| self.tk.call(self._w, 'setmode', entrypath, mode)
|
'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.'
| def autosetmode(self):
| self.tk.call(self._w, 'autosetmode')
|
'Close the entry given by entryPath if its mode is close.'
| def close(self, entrypath):
| self.tk.call(self._w, 'close', entrypath)
|
'Returns the current mode of the entry given by entryPath.'
| def getmode(self, entrypath):
| return self.tk.call(self._w, 'getmode', entrypath)
|
'Open the entry given by entryPath if its mode is open.'
| def open(self, entrypath):
| self.tk.call(self._w, 'open', entrypath)
|
'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'
| def getselection(self, mode='on'):
| c = self.tk.split(self.tk.call(self._w, 'getselection', mode))
return self.tk.splitlist(c)
|
'Returns the current status of entryPath.'
| def getstatus(self, entrypath):
| return self.tk.call(self._w, 'getstatus', entrypath)
|
'Sets the status of entryPath to be status. A bitmap will be
displayed next to the entry its status is on, off or default.'
| def setstatus(self, entrypath, mode='on'):
| self.tk.call(self._w, 'setstatus', entrypath, mode)
|
'Removes the selection anchor.'
| def anchor_clear(self):
| self.tk.call(self, 'anchor', 'clear')
|
'Get the (x,y) coordinate of the current anchor cell'
| def anchor_get(self):
| return self._getints(self.tk.call(self, 'anchor', 'get'))
|
'Set the selection anchor to the cell at (x, y).'
| def anchor_set(self, x, y):
| self.tk.call(self, 'anchor', 'set', x, y)
|
'Delete rows between from_ and to inclusive.
If to is not provided, delete only row at from_'
| def delete_row(self, from_, to=None):
| if (to is None):
self.tk.call(self, 'delete', 'row', from_)
else:
self.tk.call(self, 'delete', 'row', from_, to)
|
'Delete columns between from_ and to inclusive.
If to is not provided, delete only column at from_'
| def delete_column(self, from_, to=None):
| if (to is None):
self.tk.call(self, 'delete', 'column', from_)
else:
self.tk.call(self, 'delete', 'column', from_, to)
|
'If any cell is being edited, de-highlight the cell and applies
the changes.'
| def edit_apply(self):
| self.tk.call(self, 'edit', 'apply')
|
'Highlights the cell at (x, y) for editing, if the -editnotify
command returns True for this cell.'
| def edit_set(self, x, y):
| self.tk.call(self, 'edit', 'set', x, y)
|
'Get the option value for cell at (x,y)'
| def entrycget(self, x, y, option):
| if (option and (option[0] != '-')):
option = ('-' + option)
return self.tk.call(self, 'entrycget', x, y, option)
|
'Return True if display item exists at (x,y)'
| def info_exists(self, x, y):
| return self._getboolean(self.tk.call(self, 'info', 'exists', x, y))
|
'Moves the 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.'
| def move_column(self, from_, to, offset):
| self.tk.call(self, 'move', 'column', from_, to, offset)
|
'Moves the 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.'
| def move_row(self, from_, to, offset):
| self.tk.call(self, 'move', 'row', from_, to, offset)
|
'Return coordinate of cell nearest pixel coordinate (x,y)'
| def nearest(self, x, y):
| return self._getints(self.tk.call(self, 'nearest', x, y))
|
'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 the
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.'
| def size_column(self, index, **kw):
| return self.tk.split(self.tk.call(self._w, 'size', 'column', index, *self._options({}, 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 the bottom of a row.
size val
Specifies the height of a row.
Val may be: "auto" -- the height of the row is set the
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.'
| def size_row(self, index, **kw):
| return self.tk.split(self.tk.call(self, 'size', 'row', index, *self._options({}, kw)))
|
'Clears the cell at (x, y) by removing its display item.'
| def unset(self, x, y):
| self.tk.call(self._w, 'unset', x, y)
|
'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.'
| def configure(self, style, query_opt=None, **kw):
| if (query_opt is not None):
kw[query_opt] = None
return _val_or_dict(kw, self.tk.call, self._name, 'configure', style)
|
'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.'
| def map(self, style, query_opt=None, **kw):
| if (query_opt is not None):
return _list_from_statespec(self.tk.call(self._name, 'map', style, ('-%s' % query_opt)))
return _dict_from_tcltuple(self.tk.call(self._name, 'map', style, *_format_mapdict(kw)))
|
'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.'
| def lookup(self, style, option, state=None, default=None):
| state = (' '.join(state) if state else '')
return self.tk.call(self._name, 'lookup', style, ('-%s' % option), state, default)
|
'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.'
| def layout(self, style, layoutspec=None):
| lspec = None
if layoutspec:
lspec = _format_layoutlist(layoutspec)[0]
elif (layoutspec is not None):
lspec = 'null'
return _list_from_layouttuple(self.tk.call(self._name, 'layout', style, lspec))
|
'Create a new element in the current theme of given etype.'
| def element_create(self, elementname, etype, *args, **kw):
| (spec, opts) = _format_elemcreate(etype, False, *args, **kw)
self.tk.call(self._name, 'element', 'create', elementname, etype, spec, *opts)
|
'Returns the list of elements defined in the current theme.'
| def element_names(self):
| return self.tk.call(self._name, 'element', 'names')
|
'Return the list of elementname\'s options.'
| def element_options(self, elementname):
| return self.tk.call(self._name, 'element', 'options', elementname)
|
'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.'
| def theme_create(self, themename, parent=None, settings=None):
| 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)
|
'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.'
| def theme_settings(self, themename, settings):
| script = _script_from_settings(settings)
self.tk.call(self._name, 'theme', 'settings', themename, script)
|
'Returns a list of all known themes.'
| def theme_names(self):
| return self.tk.call(self._name, 'theme', 'names')
|
'If themename is None, returns the theme in use, otherwise, set
the current theme to themename, refreshes all widgets and emits
a <<ThemeChanged>> event.'
| def theme_use(self, themename=None):
| if (themename is None):
return self.tk.eval('return $ttk::currentTheme')
self.tk.call('ttk::setTheme', themename)
|
'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'
| def __init__(self, master, widgetname, kw=None):
| master = setup_master(master)
if (not getattr(master, '_tile_loaded', False)):
_load_tile(master)
Tkinter.Widget.__init__(self, master, widgetname, kw=kw)
|
'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.'
| def identify(self, x, y):
| return self.tk.call(self._w, 'identify', x, y)
|
'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.'
| def instate(self, statespec, callback=None, *args, **kw):
| ret = self.tk.call(self._w, 'instate', ' '.join(statespec))
if (ret and callback):
return callback(*args, **kw)
return bool(ret)
|
'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.'
| def state(self, statespec=None):
| if (statespec is not None):
statespec = ' '.join(statespec)
return self.tk.splitlist(str(self.tk.call(self._w, 'state', statespec)))
|
'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'
| def __init__(self, master=None, **kw):
| Widget.__init__(self, master, 'ttk::button', kw)
|
'Invokes the command associated with the button.'
| def invoke(self):
| return self.tk.call(self._w, 'invoke')
|
'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'
| def __init__(self, master=None, **kw):
| Widget.__init__(self, master, 'ttk::checkbutton', kw)
|
'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.'
| def invoke(self):
| return self.tk.call(self._w, 'invoke')
|
'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'
| def __init__(self, master=None, widget=None, **kw):
| Widget.__init__(self, master, (widget or 'ttk::entry'), kw)
|
'Return a tuple of (x, y, width, height) which describes the
bounding box of the character given by index.'
| def bbox(self, index):
| return self.tk.call(self._w, 'bbox', index)
|
'Returns the name of the element at position x, y, or the
empty string if the coordinates are outside the window.'
| def identify(self, x, y):
| return self.tk.call(self._w, 'identify', x, y)
|
'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.'
| def validate(self):
| return bool(self.tk.call(self._w, 'validate'))
|
'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'
| def __init__(self, master=None, **kw):
| if ('values' in kw):
kw['values'] = _format_optdict({'v': kw['values']})[1]
Entry.__init__(self, master, 'ttk::combobox', **kw)
|
'Custom Combobox configure, created to properly format the values
option.'
| def configure(self, cnf=None, **kw):
| if ('values' in kw):
kw['values'] = _format_optdict({'v': kw['values']})[1]
return Entry.configure(self, cnf, **kw)
|
'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.'
| def current(self, newindex=None):
| return self.tk.call(self._w, 'current', newindex)
|
'Sets the value of the combobox to value.'
| def set(self, value):
| self.tk.call(self._w, 'set', value)
|
'Construct a Ttk Frame with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
borderwidth, relief, padding, width, height'
| def __init__(self, master=None, **kw):
| Widget.__init__(self, master, 'ttk::frame', 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'
| def __init__(self, master=None, **kw):
| Widget.__init__(self, master, 'ttk::label', kw)
|
'Construct a Ttk Labelframe with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
labelanchor, text, underline, padding, labelwidget, width,
height'
| def __init__(self, master=None, **kw):
| Widget.__init__(self, master, 'ttk::labelframe', 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'
| def __init__(self, master=None, **kw):
| Widget.__init__(self, master, 'ttk::menubutton', 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)'
| def __init__(self, master=None, **kw):
| Widget.__init__(self, master, 'ttk::notebook', 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.'
| def add(self, child, **kw):
| self.tk.call(self._w, 'add', child, *_format_optdict(kw))
|
'Removes the tab specified by tab_id, unmaps and unmanages the
associated window.'
| def forget(self, tab_id):
| self.tk.call(self._w, 'forget', 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.'
| def hide(self, tab_id):
| self.tk.call(self._w, 'hide', tab_id)
|
'Returns the name of the tab element at position x, y, or the
empty string if none.'
| def identify(self, x, y):
| return self.tk.call(self._w, 'identify', x, y)
|
'Returns the numeric index of the tab specified by tab_id, or
the total number of tabs if tab_id is the string "end".'
| def index(self, tab_id):
| return self.tk.call(self._w, 'index', tab_id)
|
'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.'
| def insert(self, pos, child, **kw):
| self.tk.call(self._w, 'insert', pos, child, *_format_optdict(kw))
|
'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.'
| def select(self, tab_id=None):
| return self.tk.call(self._w, 'select', tab_id)
|
'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.'
| def tab(self, tab_id, option=None, **kw):
| if (option is not None):
kw[option] = None
return _val_or_dict(kw, self.tk.call, self._w, 'tab', tab_id)
|
'Returns a list of windows managed by the notebook.'
| def tabs(self):
| return (self.tk.call(self._w, 'tabs') or ())
|
'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.'
| def enable_traversal(self):
| self.tk.call('ttk::notebook::enableTraversal', self._w)
|
'Construct a Ttk Panedwindow with parent master.
STANDARD OPTIONS
class, cursor, style, takefocus
WIDGET-SPECIFIC OPTIONS
orient, width, height
PANE OPTIONS
weight'
| def __init__(self, master=None, **kw):
| Widget.__init__(self, master, 'ttk::panedwindow', kw)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.