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... | 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 t... | 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 valu... | 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', ta... |
'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 u... | 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... | 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.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 ... | 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... | 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
d... | 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 light... | 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 res... | 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 s... | 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 return... | 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 co... | 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 tu... | 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
configur... | 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,... | 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:
* ... | 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 i... | 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.