Lines Matching refs:self
149 def __str__(self):
150 if self.releaselevel == 'final':
151 return f'{self.major}.{self.minor}.{self.micro}'
153 return f'{self.major}.{self.minor}{self.releaselevel[0]}{self.serial}'
256 def __repr__(self):
257 attrs = {k: v for k, v in self.__dict__.items() if v != '??'}
258 if not self.char:
260 elif self.char != '??':
261 attrs['char'] = repr(self.char)
262 if not getattr(self, 'send_event', True):
264 if self.state == 0:
266 elif isinstance(self.state, int):
267 state = self.state
279 if self.delta == 0:
290 getattr(self.type, 'name', self.type),
376 def __init__(self, master=None, value=None, name=None):
394 self._root = master._root()
395 self._tk = master.tk
397 self._name = name
399 self._name = 'PY_VAR' + repr(_varnum)
402 self.initialize(value)
403 elif not self._tk.getboolean(self._tk.call("info", "exists", self._name)):
404 self.initialize(self._default)
406 def __del__(self):
408 if self._tk is None:
410 if self._tk.getboolean(self._tk.call("info", "exists", self._name)):
411 self._tk.globalunsetvar(self._name)
412 if self._tclCommands is not None:
413 for name in self._tclCommands:
415 self._tk.deletecommand(name)
416 self._tclCommands = None
418 def __str__(self):
420 return self._name
422 def set(self, value):
424 return self._tk.globalsetvar(self._name, value)
428 def get(self):
430 return self._tk.globalgetvar(self._name)
432 def _register(self, callback):
433 f = CallWrapper(callback, None, self._root).__call__
443 self._tk.createcommand(cbname, f)
444 if self._tclCommands is None:
445 self._tclCommands = []
446 self._tclCommands.append(cbname)
449 def trace_add(self, mode, callback):
459 cbname = self._register(callback)
460 self._tk.call('trace', 'add', 'variable',
461 self._name, mode, (cbname,))
464 def trace_remove(self, mode, cbname):
471 self._tk.call('trace', 'remove', 'variable',
472 self._name, mode, cbname)
473 for m, ca in self.trace_info():
474 if self._tk.splitlist(ca)[0] == cbname:
477 self._tk.deletecommand(cbname)
479 self._tclCommands.remove(cbname)
483 def trace_info(self):
485 splitlist = self._tk.splitlist
487 splitlist(self._tk.call('trace', 'info', 'variable', self._name)))]
489 def trace_variable(self, mode, callback):
502 cbname = self._register(callback)
503 self._tk.call("trace", "variable", self._name, mode, cbname)
508 def trace_vdelete(self, mode, cbname):
518 self._tk.call("trace", "vdelete", self._name, mode, cbname)
519 cbname = self._tk.splitlist(cbname)[0]
520 for m, ca in self.trace_info():
521 if self._tk.splitlist(ca)[0] == cbname:
524 self._tk.deletecommand(cbname)
526 self._tclCommands.remove(cbname)
530 def trace_vinfo(self):
537 return [self._tk.splitlist(x) for x in self._tk.splitlist(
538 self._tk.call("trace", "vinfo", self._name))]
540 def __eq__(self, other):
543 return (self._name == other._name
544 and self.__class__.__name__ == other.__class__.__name__
545 and self._tk == other._tk)
552 def __init__(self, master=None, value=None, name=None):
562 Variable.__init__(self, master, value, name)
564 def get(self):
566 value = self._tk.globalgetvar(self._name)
576 def __init__(self, master=None, value=None, name=None):
586 Variable.__init__(self, master, value, name)
588 def get(self):
590 value = self._tk.globalgetvar(self._name)
592 return self._tk.getint(value)
594 return int(self._tk.getdouble(value))
601 def __init__(self, master=None, value=None, name=None):
611 Variable.__init__(self, master, value, name)
613 def get(self):
615 return self._tk.getdouble(self._tk.globalgetvar(self._name))
622 def __init__(self, master=None, value=None, name=None):
632 Variable.__init__(self, master, value, name)
634 def set(self, value):
636 return self._tk.globalsetvar(self._name, self._tk.getboolean(value))
640 def get(self):
643 return self._tk.getboolean(self._tk.globalgetvar(self._name))
679 def destroy(self):
684 if self._tclCommands is not None:
685 for name in self._tclCommands:
687 self.tk.deletecommand(name)
688 self._tclCommands = None
690 def deletecommand(self, name):
695 self.tk.deletecommand(name)
697 self._tclCommands.remove(name)
701 def tk_strictMotif(self, boolean=None):
708 return self.tk.getboolean(self.tk.call(
711 def tk_bisque(self):
713 self.tk.call('tk_bisque')
715 def tk_setPalette(self, *args, **kw):
726 self.tk.call(('tk_setPalette',)
729 def wait_variable(self, name='PY_VAR'):
734 self.tk.call('tkwait', 'variable', name)
737 def wait_window(self, window=None):
740 If no parameter is given self is used."""
742 window = self
743 self.tk.call('tkwait', 'window', window._w)
745 def wait_visibility(self, window=None):
749 If no parameter is given self is used."""
751 window = self
752 self.tk.call('tkwait', 'visibility', window._w)
754 def setvar(self, name='PY_VAR', value='1'):
756 self.tk.setvar(name, value)
758 def getvar(self, name='PY_VAR'):
760 return self.tk.getvar(name)
762 def getint(self, s):
764 return self.tk.getint(s)
768 def getdouble(self, s):
770 return self.tk.getdouble(s)
774 def getboolean(self, s):
777 return self.tk.getboolean(s)
781 def focus_set(self):
787 self.tk.call('focus', self._w)
790 def focus_force(self):
794 self.tk.call('focus', '-force', self._w)
796 def focus_get(self):
803 name = self.tk.call('focus')
805 return self._nametowidget(name)
807 def focus_displayof(self):
812 name = self.tk.call('focus', '-displayof', self._w)
814 return self._nametowidget(name)
816 def focus_lastfor(self):
819 name = self.tk.call('focus', '-lastfor', self._w)
821 return self._nametowidget(name)
823 def tk_focusFollowsMouse(self):
826 self.tk.call('tk_focusFollowsMouse')
828 def tk_focusNext(self):
837 name = self.tk.call('tk_focusNext', self._w)
839 return self._nametowidget(name)
841 def tk_focusPrev(self):
843 name = self.tk.call('tk_focusPrev', self._w)
845 return self._nametowidget(name)
847 def after(self, ms, func=None, *args):
856 self.tk.call('after', ms)
864 self.deletecommand(name)
872 name = self._register(callit)
873 return self.tk.call('after', ms, name)
875 def after_idle(self, func, *args):
881 return self.after('idle', func, *args)
883 def after_cancel(self, id):
893 data = self.tk.call('after', 'info', id)
894 script = self.tk.splitlist(data)[0]
895 self.deletecommand(script)
898 self.tk.call('after', 'cancel', id)
900 def bell(self, displayof=0):
902 self.tk.call(('bell',) + self._displayof(displayof))
905 def clipboard_get(self, **kw):
920 if 'type' not in kw and self._windowingsystem == 'x11':
923 return self.tk.call(('clipboard', 'get') + self._options(kw))
926 return self.tk.call(('clipboard', 'get') + self._options(kw))
928 def clipboard_clear(self, **kw):
933 if 'displayof' not in kw: kw['displayof'] = self._w
934 self.tk.call(('clipboard', 'clear') + self._options(kw))
936 def clipboard_append(self, string, **kw):
942 if 'displayof' not in kw: kw['displayof'] = self._w
943 self.tk.call(('clipboard', 'append') + self._options(kw)
947 def grab_current(self):
950 name = self.tk.call('grab', 'current', self._w)
952 return self._nametowidget(name)
954 def grab_release(self):
956 self.tk.call('grab', 'release', self._w)
958 def grab_set(self):
963 self.tk.call('grab', 'set', self._w)
965 def grab_set_global(self):
971 self.tk.call('grab', 'set', '-global', self._w)
973 def grab_status(self):
976 status = self.tk.call('grab', 'status', self._w)
980 def option_add(self, pattern, value, priority = None):
986 self.tk.call('option', 'add', pattern, value, priority)
988 def option_clear(self):
992 self.tk.call('option', 'clear')
994 def option_get(self, name, className):
999 return self.tk.call('option', 'get', self._w, name, className)
1001 def option_readfile(self, fileName, priority = None):
1006 self.tk.call('option', 'readfile', fileName, priority)
1008 def selection_clear(self, **kw):
1010 if 'displayof' not in kw: kw['displayof'] = self._w
1011 self.tk.call(('selection', 'clear') + self._options(kw))
1013 def selection_get(self, **kw):
1022 if 'displayof' not in kw: kw['displayof'] = self._w
1023 if 'type' not in kw and self._windowingsystem == 'x11':
1026 return self.tk.call(('selection', 'get') + self._options(kw))
1029 return self.tk.call(('selection', 'get') + self._options(kw))
1031 def selection_handle(self, command, **kw):
1043 name = self._register(command)
1044 self.tk.call(('selection', 'handle') + self._options(kw)
1045 + (self._w, name))
1047 def selection_own(self, **kw):
1052 self.tk.call(('selection', 'own') +
1053 self._options(kw) + (self._w,))
1055 def selection_own_get(self, **kw):
1062 if 'displayof' not in kw: kw['displayof'] = self._w
1063 name = self.tk.call(('selection', 'own') + self._options(kw))
1065 return self._nametowidget(name)
1067 def send(self, interp, cmd, *args):
1069 return self.tk.call(('send', interp, cmd) + args)
1071 def lower(self, belowThis=None):
1073 self.tk.call('lower', self._w, belowThis)
1075 def tkraise(self, aboveThis=None):
1077 self.tk.call('raise', self._w, aboveThis)
1081 def info_patchlevel(self):
1083 patchlevel = self.tk.call('info', 'patchlevel')
1086 def winfo_atom(self, name, displayof=0):
1088 args = ('winfo', 'atom') + self._displayof(displayof) + (name,)
1089 return self.tk.getint(self.tk.call(args))
1091 def winfo_atomname(self, id, displayof=0):
1094 + self._displayof(displayof) + (id,)
1095 return self.tk.call(args)
1097 def winfo_cells(self):
1099 return self.tk.getint(
1100 self.tk.call('winfo', 'cells', self._w))
1102 def winfo_children(self):
1105 for child in self.tk.splitlist(
1106 self.tk.call('winfo', 'children', self._w)):
1110 result.append(self._nametowidget(child))
1115 def winfo_class(self):
1117 return self.tk.call('winfo', 'class', self._w)
1119 def winfo_colormapfull(self):
1121 return self.tk.getboolean(
1122 self.tk.call('winfo', 'colormapfull', self._w))
1124 def winfo_containing(self, rootX, rootY, displayof=0):
1127 + self._displayof(displayof) + (rootX, rootY)
1128 name = self.tk.call(args)
1130 return self._nametowidget(name)
1132 def winfo_depth(self):
1134 return self.tk.getint(self.tk.call('winfo', 'depth', self._w))
1136 def winfo_exists(self):
1138 return self.tk.getint(
1139 self.tk.call('winfo', 'exists', self._w))
1141 def winfo_fpixels(self, number):
1144 return self.tk.getdouble(self.tk.call(
1145 'winfo', 'fpixels', self._w, number))
1147 def winfo_geometry(self):
1149 return self.tk.call('winfo', 'geometry', self._w)
1151 def winfo_height(self):
1153 return self.tk.getint(
1154 self.tk.call('winfo', 'height', self._w))
1156 def winfo_id(self):
1158 return int(self.tk.call('winfo', 'id', self._w), 0)
1160 def winfo_interps(self, displayof=0):
1162 args = ('winfo', 'interps') + self._displayof(displayof)
1163 return self.tk.splitlist(self.tk.call(args))
1165 def winfo_ismapped(self):
1167 return self.tk.getint(
1168 self.tk.call('winfo', 'ismapped', self._w))
1170 def winfo_manager(self):
1172 return self.tk.call('winfo', 'manager', self._w)
1174 def winfo_name(self):
1176 return self.tk.call('winfo', 'name', self._w)
1178 def winfo_parent(self):
1180 return self.tk.call('winfo', 'parent', self._w)
1182 def winfo_pathname(self, id, displayof=0):
1185 + self._displayof(displayof) + (id,)
1186 return self.tk.call(args)
1188 def winfo_pixels(self, number):
1190 return self.tk.getint(
1191 self.tk.call('winfo', 'pixels', self._w, number))
1193 def winfo_pointerx(self):
1195 return self.tk.getint(
1196 self.tk.call('winfo', 'pointerx', self._w))
1198 def winfo_pointerxy(self):
1200 return self._getints(
1201 self.tk.call('winfo', 'pointerxy', self._w))
1203 def winfo_pointery(self):
1205 return self.tk.getint(
1206 self.tk.call('winfo', 'pointery', self._w))
1208 def winfo_reqheight(self):
1210 return self.tk.getint(
1211 self.tk.call('winfo', 'reqheight', self._w))
1213 def winfo_reqwidth(self):
1215 return self.tk.getint(
1216 self.tk.call('winfo', 'reqwidth', self._w))
1218 def winfo_rgb(self, color):
1220 return self._getints(
1221 self.tk.call('winfo', 'rgb', self._w, color))
1223 def winfo_rootx(self):
1226 return self.tk.getint(
1227 self.tk.call('winfo', 'rootx', self._w))
1229 def winfo_rooty(self):
1232 return self.tk.getint(
1233 self.tk.call('winfo', 'rooty', self._w))
1235 def winfo_screen(self):
1237 return self.tk.call('winfo', 'screen', self._w)
1239 def winfo_screencells(self):
1242 return self.tk.getint(
1243 self.tk.call('winfo', 'screencells', self._w))
1245 def winfo_screendepth(self):
1248 return self.tk.getint(
1249 self.tk.call('winfo', 'screendepth', self._w))
1251 def winfo_screenheight(self):
1254 return self.tk.getint(
1255 self.tk.call('winfo', 'screenheight', self._w))
1257 def winfo_screenmmheight(self):
1260 return self.tk.getint(
1261 self.tk.call('winfo', 'screenmmheight', self._w))
1263 def winfo_screenmmwidth(self):
1266 return self.tk.getint(
1267 self.tk.call('winfo', 'screenmmwidth', self._w))
1269 def winfo_screenvisual(self):
1273 return self.tk.call('winfo', 'screenvisual', self._w)
1275 def winfo_screenwidth(self):
1278 return self.tk.getint(
1279 self.tk.call('winfo', 'screenwidth', self._w))
1281 def winfo_server(self):
1284 return self.tk.call('winfo', 'server', self._w)
1286 def winfo_toplevel(self):
1288 return self._nametowidget(self.tk.call(
1289 'winfo', 'toplevel', self._w))
1291 def winfo_viewable(self):
1293 return self.tk.getint(
1294 self.tk.call('winfo', 'viewable', self._w))
1296 def winfo_visual(self):
1300 return self.tk.call('winfo', 'visual', self._w)
1302 def winfo_visualid(self):
1304 return self.tk.call('winfo', 'visualid', self._w)
1306 def winfo_visualsavailable(self, includeids=False):
1312 data = self.tk.call('winfo', 'visualsavailable', self._w,
1314 data = [self.tk.splitlist(x) for x in self.tk.splitlist(data)]
1315 return [self.__winfo_parseitem(x) for x in data]
1317 def __winfo_parseitem(self, t):
1319 return t[:1] + tuple(map(self.__winfo_getint, t[1:]))
1321 def __winfo_getint(self, x):
1325 def winfo_vrootheight(self):
1329 return self.tk.getint(
1330 self.tk.call('winfo', 'vrootheight', self._w))
1332 def winfo_vrootwidth(self):
1336 return self.tk.getint(
1337 self.tk.call('winfo', 'vrootwidth', self._w))
1339 def winfo_vrootx(self):
1342 return self.tk.getint(
1343 self.tk.call('winfo', 'vrootx', self._w))
1345 def winfo_vrooty(self):
1348 return self.tk.getint(
1349 self.tk.call('winfo', 'vrooty', self._w))
1351 def winfo_width(self):
1353 return self.tk.getint(
1354 self.tk.call('winfo', 'width', self._w))
1356 def winfo_x(self):
1359 return self.tk.getint(
1360 self.tk.call('winfo', 'x', self._w))
1362 def winfo_y(self):
1365 return self.tk.getint(
1366 self.tk.call('winfo', 'y', self._w))
1368 def update(self):
1370 self.tk.call('update')
1372 def update_idletasks(self):
1376 self.tk.call('update', 'idletasks')
1378 def bindtags(self, tagList=None):
1386 return self.tk.splitlist(
1387 self.tk.call('bindtags', self._w))
1389 self.tk.call('bindtags', self._w, tagList)
1391 def _bind(self, what, sequence, func, add, needcleanup=1):
1394 self.tk.call(what + (sequence, func))
1396 funcid = self._register(func, self._substitute,
1401 funcid, self._subst_format_str))
1402 self.tk.call(what + (sequence, cmd))
1405 return self.tk.call(what + (sequence,))
1407 return self.tk.splitlist(self.tk.call(what))
1409 def bind(self, sequence=None, func=None, add=None):
1448 return self._bind(('bind', self._w), sequence, func, add)
1450 def unbind(self, sequence, funcid=None):
1453 self.tk.call('bind', self._w, sequence, '')
1455 self.deletecommand(funcid)
1457 def bind_all(self, sequence=None, func=None, add=None):
1462 return self._bind(('bind', 'all'), sequence, func, add, 0)
1464 def unbind_all(self, sequence):
1466 self.tk.call('bind', 'all' , sequence, '')
1468 def bind_class(self, className, sequence=None, func=None, add=None):
1476 return self._bind(('bind', className), sequence, func, add, 0)
1478 def unbind_class(self, className, sequence):
1481 self.tk.call('bind', className , sequence, '')
1483 def mainloop(self, n=0):
1485 self.tk.mainloop(n)
1487 def quit(self):
1489 self.tk.quit()
1491 def _getints(self, string):
1494 return tuple(map(self.tk.getint, self.tk.splitlist(string)))
1496 def _getdoubles(self, string):
1499 return tuple(map(self.tk.getdouble, self.tk.splitlist(string)))
1501 def _getboolean(self, string):
1504 return self.tk.getboolean(string)
1506 def _displayof(self, displayof):
1511 return ('-displayof', self._w)
1515 def _windowingsystem(self):
1518 return self._root()._windowingsystem_cached
1520 ws = self._root()._windowingsystem_cached = \
1521 self.tk.call('tk', 'windowingsystem')
1524 def _options(self, cnf, kw = None):
1535 v = self._register(v)
1550 def nametowidget(self, name):
1554 w = self
1569 def _register(self, func, subst=None, needcleanup=1):
1574 f = CallWrapper(func, subst, self).__call__
1584 self.tk.createcommand(name, f)
1586 if self._tclCommands is None:
1587 self._tclCommands = []
1588 self._tclCommands.append(name)
1593 def _root(self):
1595 w = self
1603 def _substitute(self, *args):
1605 if len(args) != len(self._subst_format): return args
1606 getboolean = self.tk.getboolean
1608 getint = self.tk.getint
1653 e.widget = self._nametowidget(W)
1664 def _report_exception(self):
1667 root = self._root()
1670 def _getconfigure(self, *args):
1673 for x in self.tk.splitlist(self.tk.call(*args)):
1674 x = self.tk.splitlist(x)
1678 def _getconfigure1(self, *args):
1679 x = self.tk.splitlist(self.tk.call(*args))
1682 def _configure(self, cmd, cnf, kw):
1689 return self._getconfigure(_flatten((self._w, cmd)))
1691 return self._getconfigure1(_flatten((self._w, cmd, '-'+cnf)))
1692 self.tk.call(_flatten((self._w, cmd)) + self._options(cnf))
1695 def configure(self, cnf=None, **kw):
1702 return self._configure('configure', cnf, kw)
1706 def cget(self, key):
1708 return self.tk.call(self._w, 'cget', '-' + key)
1712 def __setitem__(self, key, value):
1713 self.configure({key: value})
1715 def keys(self):
1717 splitlist = self.tk.splitlist
1719 splitlist(self.tk.call(self._w, 'configure'))]
1721 def __str__(self):
1723 return self._w
1725 def __repr__(self):
1727 self.__class__.__module__, self.__class__.__qualname__, self._w)
1732 def pack_propagate(self, flag=_noarg_):
1740 return self._getboolean(self.tk.call(
1741 'pack', 'propagate', self._w))
1743 self.tk.call('pack', 'propagate', self._w, flag)
1747 def pack_slaves(self):
1750 return [self._nametowidget(x) for x in
1751 self.tk.splitlist(
1752 self.tk.call('pack', 'slaves', self._w))]
1757 def place_slaves(self):
1760 return [self._nametowidget(x) for x in
1761 self.tk.splitlist(
1762 self.tk.call(
1763 'place', 'slaves', self._w))]
1767 def grid_anchor(self, anchor=None): # new in Tk 8.5
1772 self.tk.call('grid', 'anchor', self._w, anchor)
1776 def grid_bbox(self, column=None, row=None, col2=None, row2=None):
1788 args = ('grid', 'bbox', self._w)
1793 return self._getints(self.tk.call(*args)) or None
1797 def _gridconvvalue(self, value):
1804 return self.tk.getdouble(svalue)
1806 return self.tk.getint(svalue)
1811 def _grid_configure(self, command, index, cnf, kw):
1820 options = self._options(cnf, kw)
1823 self.tk,
1824 self.tk.call('grid', command, self._w, index),
1825 conv=self._gridconvvalue)
1826 res = self.tk.call(
1827 ('grid', command, self._w, index)
1830 return self._gridconvvalue(res)
1832 def grid_columnconfigure(self, index, cnf={}, **kw):
1838 return self._grid_configure('columnconfigure', index, cnf, kw)
1842 def grid_location(self, x, y):
1846 return self._getints(
1847 self.tk.call(
1848 'grid', 'location', self._w, x, y)) or None
1850 def grid_propagate(self, flag=_noarg_):
1858 return self._getboolean(self.tk.call(
1859 'grid', 'propagate', self._w))
1861 self.tk.call('grid', 'propagate', self._w, flag)
1863 def grid_rowconfigure(self, index, cnf={}, **kw):
1869 return self._grid_configure('rowconfigure', index, cnf, kw)
1873 def grid_size(self):
1875 return self._getints(
1876 self.tk.call('grid', 'size', self._w)) or None
1880 def grid_slaves(self, row=None, column=None):
1888 return [self._nametowidget(x) for x in
1889 self.tk.splitlist(self.tk.call(
1890 ('grid', 'slaves', self._w) + args))]
1895 def event_add(self, virtual, *sequences):
1900 self.tk.call(args)
1902 def event_delete(self, virtual, *sequences):
1905 self.tk.call(args)
1907 def event_generate(self, sequence, **kw):
1911 args = ('event', 'generate', self._w, sequence)
1914 self.tk.call(args)
1916 def event_info(self, virtual=None):
1919 return self.tk.splitlist(
1920 self.tk.call('event', 'info', virtual))
1924 def image_names(self):
1926 return self.tk.splitlist(self.tk.call('image', 'names'))
1928 def image_types(self):
1930 return self.tk.splitlist(self.tk.call('image', 'types'))
1937 def __init__(self, func, subst, widget):
1939 self.func = func
1940 self.subst = subst
1941 self.widget = widget
1943 def __call__(self, *args):
1946 if self.subst:
1947 args = self.subst(*args)
1948 return self.func(*args)
1952 self.widget._report_exception()
1959 def xview(self, *args):
1961 res = self.tk.call(self._w, 'xview', *args)
1963 return self._getdoubles(res)
1965 def xview_moveto(self, fraction):
1968 self.tk.call(self._w, 'xview', 'moveto', fraction)
1970 def xview_scroll(self, number, what):
1973 self.tk.call(self._w, 'xview', 'scroll', number, what)
1980 def yview(self, *args):
1982 res = self.tk.call(self._w, 'yview', *args)
1984 return self._getdoubles(res)
1986 def yview_moveto(self, fraction):
1989 self.tk.call(self._w, 'yview', 'moveto', fraction)
1991 def yview_scroll(self, number, what):
1994 self.tk.call(self._w, 'yview', 'scroll', number, what)
2000 def wm_aspect(self,
2006 return self._getints(
2007 self.tk.call('wm', 'aspect', self._w,
2013 def wm_attributes(self, *args):
2031 args = ('wm', 'attributes', self._w) + args
2032 return self.tk.call(args)
2036 def wm_client(self, name=None):
2039 return self.tk.call('wm', 'client', self._w, name)
2043 def wm_colormapwindows(self, *wlist):
2049 args = ('wm', 'colormapwindows', self._w) + wlist
2051 self.tk.call(args)
2053 return [self._nametowidget(x)
2054 for x in self.tk.splitlist(self.tk.call(args))]
2058 def wm_command(self, value=None):
2062 return self.tk.call('wm', 'command', self._w, value)
2066 def wm_deiconify(self):
2069 return self.tk.call('wm', 'deiconify', self._w)
2073 def wm_focusmodel(self, model=None):
2077 return self.tk.call('wm', 'focusmodel', self._w, model)
2081 def wm_forget(self, window): # new in Tk 8.5
2087 self.tk.call('wm', 'forget', window)
2091 def wm_frame(self):
2093 return self.tk.call('wm', 'frame', self._w)
2097 def wm_geometry(self, newGeometry=None):
2100 return self.tk.call('wm', 'geometry', self._w, newGeometry)
2104 def wm_grid(self,
2111 return self._getints(self.tk.call(
2112 'wm', 'grid', self._w,
2117 def wm_group(self, pathName=None):
2120 return self.tk.call('wm', 'group', self._w, pathName)
2124 def wm_iconbitmap(self, bitmap=None, default=None):
2134 return self.tk.call('wm', 'iconbitmap', self._w, '-default', default)
2136 return self.tk.call('wm', 'iconbitmap', self._w, bitmap)
2140 def wm_iconify(self):
2142 return self.tk.call('wm', 'iconify', self._w)
2146 def wm_iconmask(self, bitmap=None):
2149 return self.tk.call('wm', 'iconmask', self._w, bitmap)
2153 def wm_iconname(self, newName=None):
2156 return self.tk.call('wm', 'iconname', self._w, newName)
2160 def wm_iconphoto(self, default=False, *args): # new in Tk 8.5
2181 self.tk.call('wm', 'iconphoto', self._w, "-default", *args)
2183 self.tk.call('wm', 'iconphoto', self._w, *args)
2187 def wm_iconposition(self, x=None, y=None):
2190 return self._getints(self.tk.call(
2191 'wm', 'iconposition', self._w, x, y))
2195 def wm_iconwindow(self, pathName=None):
2198 return self.tk.call('wm', 'iconwindow', self._w, pathName)
2202 def wm_manage(self, widget): # new in Tk 8.5
2206 self.tk.call('wm', 'manage', widget)
2210 def wm_maxsize(self, width=None, height=None):
2214 return self._getints(self.tk.call(
2215 'wm', 'maxsize', self._w, width, height))
2219 def wm_minsize(self, width=None, height=None):
2223 return self._getints(self.tk.call(
2224 'wm', 'minsize', self._w, width, height))
2228 def wm_overrideredirect(self, boolean=None):
2232 return self._getboolean(self.tk.call(
2233 'wm', 'overrideredirect', self._w, boolean))
2237 def wm_positionfrom(self, who=None):
2241 return self.tk.call('wm', 'positionfrom', self._w, who)
2245 def wm_protocol(self, name=None, func=None):
2250 command = self._register(func)
2253 return self.tk.call(
2254 'wm', 'protocol', self._w, name, command)
2258 def wm_resizable(self, width=None, height=None):
2261 return self.tk.call('wm', 'resizable', self._w, width, height)
2265 def wm_sizefrom(self, who=None):
2269 return self.tk.call('wm', 'sizefrom', self._w, who)
2273 def wm_state(self, newstate=None):
2276 return self.tk.call('wm', 'state', self._w, newstate)
2280 def wm_title(self, string=None):
2282 return self.tk.call('wm', 'title', self._w, string)
2286 def wm_transient(self, master=None):
2289 return self.tk.call('wm', 'transient', self._w, master)
2293 def wm_withdraw(self):
2296 return self.tk.call('wm', 'withdraw', self._w)
2306 def __init__(self, screenName=None, baseName=None, className='Tk',
2313 self.master = None
2314 self.children = {}
2315 self._tkloaded = False
2317 # ensure that self.tk is always _something_.
2318 self.tk = None
2326 self.tk = _tkinter.create(screenName, baseName, className, interactive, wantobjects, useTk, sync, use)
2328 self._loadtk()
2331 self.readprofile(baseName, className)
2333 def loadtk(self):
2334 if not self._tkloaded:
2335 self.tk.loadtk()
2336 self._loadtk()
2338 def _loadtk(self):
2339 self._tkloaded = True
2342 tk_version = self.tk.getvar('tk_version')
2347 tcl_version = str(self.tk.getvar('tcl_version'))
2354 if self._tclCommands is None:
2355 self._tclCommands = []
2356 self.tk.createcommand('tkerror', _tkerror)
2357 self.tk.createcommand('exit', _exit)
2358 self._tclCommands.append('tkerror')
2359 self._tclCommands.append('exit')
2361 _default_root = self
2362 self.protocol("WM_DELETE_WINDOW", self.destroy)
2364 def destroy(self):
2367 for c in list(self.children.values()): c.destroy()
2368 self.tk.call('destroy', self._w)
2369 Misc.destroy(self)
2371 if _support_default_root and _default_root is self:
2374 def readprofile(self, baseName, className):
2385 dir = {'self': self}
2388 self.tk.call('source', class_tcl)
2392 self.tk.call('source', base_tcl)
2396 def report_callback_exception(self, exc, val, tb):
2408 def __getattr__(self, attr):
2410 return getattr(self.tk, attr)
2436 def pack_configure(self, cnf={}, **kw):
2452 self.tk.call(
2453 ('pack', 'configure', self._w)
2454 + self._options(cnf, kw))
2458 def pack_forget(self):
2460 self.tk.call('pack', 'forget', self._w)
2464 def pack_info(self):
2467 d = _splitdict(self.tk, self.tk.call('pack', 'info', self._w))
2469 d['in'] = self.nametowidget(d['in'])
2482 def place_configure(self, cnf={}, **kw):
2504 self.tk.call(
2505 ('place', 'configure', self._w)
2506 + self._options(cnf, kw))
2510 def place_forget(self):
2512 self.tk.call('place', 'forget', self._w)
2516 def place_info(self):
2519 d = _splitdict(self.tk, self.tk.call('place', 'info', self._w))
2521 d['in'] = self.nametowidget(d['in'])
2534 def grid_configure(self, cnf={}, **kw):
2549 self.tk.call(
2550 ('grid', 'configure', self._w)
2551 + self._options(cnf, kw))
2557 def grid_forget(self):
2559 self.tk.call('grid', 'forget', self._w)
2563 def grid_remove(self):
2565 self.tk.call('grid', 'remove', self._w)
2567 def grid_info(self):
2570 d = _splitdict(self.tk, self.tk.call('grid', 'info', self._w))
2572 d['in'] = self.nametowidget(d['in'])
2586 def _setup(self, master, cnf):
2590 self.master = master
2591 self.tk = master.tk
2597 name = self.__class__.__name__.lower()
2606 self._name = name
2608 self._w = '.' + name
2610 self._w = master._w + '.' + name
2611 self.children = {}
2612 if self._name in self.master.children:
2613 self.master.children[self._name].destroy()
2614 self.master.children[self._name] = self
2616 def __init__(self, master, widgetName, cnf={}, kw={}, extra=()):
2621 self.widgetName = widgetName
2622 self._setup(master, cnf)
2623 if self._tclCommands is None:
2624 self._tclCommands = []
2628 self.tk.call(
2629 (widgetName, self._w) + extra + self._options(cnf))
2631 k.configure(self, v)
2633 def destroy(self):
2635 for c in list(self.children.values()): c.destroy()
2636 self.tk.call('destroy', self._w)
2637 if self._name in self.master.children:
2638 del self.master.children[self._name]
2639 Misc.destroy(self)
2641 def _do(self, name, args=()):
2642 # XXX Obsolete -- better use self.tk.call directly!
2643 return self.tk.call((self._w, name) + args)
2657 def __init__(self, master=None, cnf={}, **kw):
2677 BaseWidget.__init__(self, master, 'toplevel', cnf, {}, extra)
2678 root = self._root()
2679 self.iconname(root.iconname())
2680 self.title(root.title())
2681 self.protocol("WM_DELETE_WINDOW", self.destroy)
2687 def __init__(self, master=None, cnf={}, **kw):
2706 Widget.__init__(self, master, 'button', cnf, kw)
2708 def flash(self):
2718 self.tk.call(self._w, 'flash')
2720 def invoke(self):
2728 return self.tk.call(self._w, 'invoke')
2734 def __init__(self, master=None, cnf={}, **kw):
2744 Widget.__init__(self, master, 'canvas', cnf, kw)
2746 def addtag(self, *args):
2748 self.tk.call((self._w, 'addtag') + args)
2750 def addtag_above(self, newtag, tagOrId):
2752 self.addtag(newtag, 'above', tagOrId)
2754 def addtag_all(self, newtag):
2756 self.addtag(newtag, 'all')
2758 def addtag_below(self, newtag, tagOrId):
2760 self.addtag(newtag, 'below', tagOrId)
2762 def addtag_closest(self, newtag, x, y, halo=None, start=None):
2767 self.addtag(newtag, 'closest', x, y, halo, start)
2769 def addtag_enclosed(self, newtag, x1, y1, x2, y2):
2772 self.addtag(newtag, 'enclosed', x1, y1, x2, y2)
2774 def addtag_overlapping(self, newtag, x1, y1, x2, y2):
2777 self.addtag(newtag, 'overlapping', x1, y1, x2, y2)
2779 def addtag_withtag(self, newtag, tagOrId):
2781 self.addtag(newtag, 'withtag', tagOrId)
2783 def bbox(self, *args):
2786 return self._getints(
2787 self.tk.call((self._w, 'bbox') + args)) or None
2789 def tag_unbind(self, tagOrId, sequence, funcid=None):
2792 self.tk.call(self._w, 'bind', tagOrId, sequence, '')
2794 self.deletecommand(funcid)
2796 def tag_bind(self, tagOrId, sequence=None, func=None, add=None):
2802 return self._bind((self._w, 'bind', tagOrId),
2805 def canvasx(self, screenx, gridspacing=None):
2808 return self.tk.getdouble(self.tk.call(
2809 self._w, 'canvasx', screenx, gridspacing))
2811 def canvasy(self, screeny, gridspacing=None):
2814 return self.tk.getdouble(self.tk.call(
2815 self._w, 'canvasy', screeny, gridspacing))
2817 def coords(self, *args):
2820 return [self.tk.getdouble(x) for x in
2821 self.tk.splitlist(
2822 self.tk.call((self._w, 'coords') + args))]
2824 def _create(self, itemType, args, kw): # Args: (val, val, ..., cnf={})
2832 return self.tk.getint(self.tk.call(
2833 self._w, 'create', itemType,
2834 *(args + self._options(cnf, kw))))
2836 def create_arc(self, *args, **kw):
2838 return self._create('arc', args, kw)
2840 def create_bitmap(self, *args, **kw):
2842 return self._create('bitmap', args, kw)
2844 def create_image(self, *args, **kw):
2846 return self._create('image', args, kw)
2848 def create_line(self, *args, **kw):
2850 return self._create('line', args, kw)
2852 def create_oval(self, *args, **kw):
2854 return self._create('oval', args, kw)
2856 def create_polygon(self, *args, **kw):
2858 return self._create('polygon', args, kw)
2860 def create_rectangle(self, *args, **kw):
2862 return self._create('rectangle', args, kw)
2864 def create_text(self, *args, **kw):
2866 return self._create('text', args, kw)
2868 def create_window(self, *args, **kw):
2870 return self._create('window', args, kw)
2872 def dchars(self, *args):
2875 self.tk.call((self._w, 'dchars') + args)
2877 def delete(self, *args):
2879 self.tk.call((self._w, 'delete') + args)
2881 def dtag(self, *args):
2884 self.tk.call((self._w, 'dtag') + args)
2886 def find(self, *args):
2888 return self._getints(
2889 self.tk.call((self._w, 'find') + args)) or ()
2891 def find_above(self, tagOrId):
2893 return self.find('above', tagOrId)
2895 def find_all(self):
2897 return self.find('all')
2899 def find_below(self, tagOrId):
2901 return self.find('below', tagOrId)
2903 def find_closest(self, x, y, halo=None, start=None):
2908 return self.find('closest', x, y, halo, start)
2910 def find_enclosed(self, x1, y1, x2, y2):
2913 return self.find('enclosed', x1, y1, x2, y2)
2915 def find_overlapping(self, x1, y1, x2, y2):
2918 return self.find('overlapping', x1, y1, x2, y2)
2920 def find_withtag(self, tagOrId):
2922 return self.find('withtag', tagOrId)
2924 def focus(self, *args):
2926 return self.tk.call((self._w, 'focus') + args)
2928 def gettags(self, *args):
2930 return self.tk.splitlist(
2931 self.tk.call((self._w, 'gettags') + args))
2933 def icursor(self, *args):
2936 self.tk.call((self._w, 'icursor') + args)
2938 def index(self, *args):
2940 return self.tk.getint(self.tk.call((self._w, 'index') + args))
2942 def insert(self, *args):
2945 self.tk.call((self._w, 'insert') + args)
2947 def itemcget(self, tagOrId, option):
2949 return self.tk.call(
2950 (self._w, 'itemcget') + (tagOrId, '-'+option))
2952 def itemconfigure(self, tagOrId, cnf=None, **kw):
2959 return self._configure(('itemconfigure', tagOrId), cnf, kw)
2967 def tag_lower(self, *args):
2970 self.tk.call((self._w, 'lower') + args)
2974 def move(self, *args):
2976 self.tk.call((self._w, 'move') + args)
2978 def moveto(self, tagOrId, x='', y=''):
2985 self.tk.call(self._w, 'moveto', tagOrId, x, y)
2987 def postscript(self, cnf={}, **kw):
2992 return self.tk.call((self._w, 'postscript') +
2993 self._options(cnf, kw))
2995 def tag_raise(self, *args):
2998 self.tk.call((self._w, 'raise') + args)
3002 def scale(self, *args):
3004 self.tk.call((self._w, 'scale') + args)
3006 def scan_mark(self, x, y):
3008 self.tk.call(self._w, 'scan', 'mark', x, y)
3010 def scan_dragto(self, x, y, gain=10):
3014 self.tk.call(self._w, 'scan', 'dragto', x, y, gain)
3016 def select_adjust(self, tagOrId, index):
3018 self.tk.call(self._w, 'select', 'adjust', tagOrId, index)
3020 def select_clear(self):
3022 self.tk.call(self._w, 'select', 'clear')
3024 def select_from(self, tagOrId, index):
3026 self.tk.call(self._w, 'select', 'from', tagOrId, index)
3028 def select_item(self):
3030 return self.tk.call(self._w, 'select', 'item') or None
3032 def select_to(self, tagOrId, index):
3034 self.tk.call(self._w, 'select', 'to', tagOrId, index)
3036 def type(self, tagOrId):
3038 return self.tk.call(self._w, 'type', tagOrId) or None
3046 def __init__(self, master=None, cnf={}, **kw):
3056 Widget.__init__(self, master, 'checkbutton', cnf, kw)
3058 def _setup(self, master, cnf):
3061 name = self.__class__.__name__.lower()
3066 def deselect(self):
3068 self.tk.call(self._w, 'deselect')
3070 def flash(self):
3072 self.tk.call(self._w, 'flash')
3074 def invoke(self):
3076 return self.tk.call(self._w, 'invoke')
3078 def select(self):
3080 self.tk.call(self._w, 'select')
3082 def toggle(self):
3084 self.tk.call(self._w, 'toggle')
3090 def __init__(self, master=None, cnf={}, **kw):
3101 Widget.__init__(self, master, 'entry', cnf, kw)
3103 def delete(self, first, last=None):
3105 self.tk.call(self._w, 'delete', first, last)
3107 def get(self):
3109 return self.tk.call(self._w, 'get')
3111 def icursor(self, index):
3113 self.tk.call(self._w, 'icursor', index)
3115 def index(self, index):
3117 return self.tk.getint(self.tk.call(
3118 self._w, 'index', index))
3120 def insert(self, index, string):
3122 self.tk.call(self._w, 'insert', index, string)
3124 def scan_mark(self, x):
3126 self.tk.call(self._w, 'scan', 'mark', x)
3128 def scan_dragto(self, x):
3132 self.tk.call(self._w, 'scan', 'dragto', x)
3134 def selection_adjust(self, index):
3136 self.tk.call(self._w, 'selection', 'adjust', index)
3140 def selection_clear(self):
3142 self.tk.call(self._w, 'selection', 'clear')
3146 def selection_from(self, index):
3148 self.tk.call(self._w, 'selection', 'from', index)
3152 def selection_present(self):
3155 return self.tk.getboolean(
3156 self.tk.call(self._w, 'selection', 'present'))
3160 def selection_range(self, start, end):
3162 self.tk.call(self._w, 'selection', 'range', start, end)
3166 def selection_to(self, index):
3168 self.tk.call(self._w, 'selection', 'to', index)
3176 def __init__(self, master=None, cnf={}, **kw):
3190 Widget.__init__(self, master, 'frame', cnf, {}, extra)
3196 def __init__(self, master=None, cnf={}, **kw):
3214 Widget.__init__(self, master, 'label', cnf, kw)
3220 def __init__(self, master=None, cnf={}, **kw):
3228 Widget.__init__(self, master, 'listbox', cnf, kw)
3230 def activate(self, index):
3232 self.tk.call(self._w, 'activate', index)
3234 def bbox(self, index):
3237 return self._getints(self.tk.call(self._w, 'bbox', index)) or None
3239 def curselection(self):
3241 return self._getints(self.tk.call(self._w, 'curselection')) or ()
3243 def delete(self, first, last=None):
3245 self.tk.call(self._w, 'delete', first, last)
3247 def get(self, first, last=None):
3250 return self.tk.splitlist(self.tk.call(
3251 self._w, 'get', first, last))
3253 return self.tk.call(self._w, 'get', first)
3255 def index(self, index):
3257 i = self.tk.call(self._w, 'index', index)
3259 return self.tk.getint(i)
3261 def insert(self, index, *elements):
3263 self.tk.call((self._w, 'insert', index) + elements)
3265 def nearest(self, y):
3267 return self.tk.getint(self.tk.call(
3268 self._w, 'nearest', y))
3270 def scan_mark(self, x, y):
3272 self.tk.call(self._w, 'scan', 'mark', x, y)
3274 def scan_dragto(self, x, y):
3278 self.tk.call(self._w, 'scan', 'dragto', x, y)
3280 def see(self, index):
3282 self.tk.call(self._w, 'see', index)
3284 def selection_anchor(self, index):
3286 self.tk.call(self._w, 'selection', 'anchor', index)
3290 def selection_clear(self, first, last=None):
3292 self.tk.call(self._w,
3297 def selection_includes(self, index):
3299 return self.tk.getboolean(self.tk.call(
3300 self._w, 'selection', 'includes', index))
3304 def selection_set(self, first, last=None):
3307 self.tk.call(self._w, 'selection', 'set', first, last)
3311 def size(self):
3313 return self.tk.getint(self.tk.call(self._w, 'size'))
3315 def itemcget(self, index, option):
3317 return self.tk.call(
3318 (self._w, 'itemcget') + (index, '-'+option))
3320 def itemconfigure(self, index, cnf=None, **kw):
3328 return self._configure(('itemconfigure', index), cnf, kw)
3336 def __init__(self, master=None, cnf={}, **kw):
3343 Widget.__init__(self, master, 'menu', cnf, kw)
3345 def tk_popup(self, x, y, entry=""):
3347 self.tk.call('tk_popup', self._w, x, y, entry)
3349 def activate(self, index):
3351 self.tk.call(self._w, 'activate', index)
3353 def add(self, itemType, cnf={}, **kw):
3355 self.tk.call((self._w, 'add', itemType) +
3356 self._options(cnf, kw))
3358 def add_cascade(self, cnf={}, **kw):
3360 self.add('cascade', cnf or kw)
3362 def add_checkbutton(self, cnf={}, **kw):
3364 self.add('checkbutton', cnf or kw)
3366 def add_command(self, cnf={}, **kw):
3368 self.add('command', cnf or kw)
3370 def add_radiobutton(self, cnf={}, **kw):
3372 self.add('radiobutton', cnf or kw)
3374 def add_separator(self, cnf={}, **kw):
3376 self.add('separator', cnf or kw)
3378 def insert(self, index, itemType, cnf={}, **kw):
3380 self.tk.call((self._w, 'insert', index, itemType) +
3381 self._options(cnf, kw))
3383 def insert_cascade(self, index, cnf={}, **kw):
3385 self.insert(index, 'cascade', cnf or kw)
3387 def insert_checkbutton(self, index, cnf={}, **kw):
3389 self.insert(index, 'checkbutton', cnf or kw)
3391 def insert_command(self, index, cnf={}, **kw):
3393 self.insert(index, 'command', cnf or kw)
3395 def insert_radiobutton(self, index, cnf={}, **kw):
3397 self.insert(index, 'radiobutton', cnf or kw)
3399 def insert_separator(self, index, cnf={}, **kw):
3401 self.insert(index, 'separator', cnf or kw)
3403 def delete(self, index1, index2=None):
3408 num_index1, num_index2 = self.index(index1), self.index(index2)
3413 if 'command' in self.entryconfig(i):
3414 c = str(self.entrycget(i, 'command'))
3416 self.deletecommand(c)
3417 self.tk.call(self._w, 'delete', index1, index2)
3419 def entrycget(self, index, option):
3421 return self.tk.call(self._w, 'entrycget', index, '-' + option)
3423 def entryconfigure(self, index, cnf=None, **kw):
3425 return self._configure(('entryconfigure', index), cnf, kw)
3429 def index(self, index):
3431 i = self.tk.call(self._w, 'index', index)
3432 return None if i in ('', 'none') else self.tk.getint(i) # GH-103685.
3434 def invoke(self, index):
3437 return self.tk.call(self._w, 'invoke', index)
3439 def post(self, x, y):
3441 self.tk.call(self._w, 'post', x, y)
3443 def type(self, index):
3445 return self.tk.call(self._w, 'type', index)
3447 def unpost(self):
3449 self.tk.call(self._w, 'unpost')
3451 def xposition(self, index): # new in Tk 8.5
3454 return self.tk.getint(self.tk.call(self._w, 'xposition', index))
3456 def yposition(self, index):
3458 return self.tk.getint(self.tk.call(
3459 self._w, 'yposition', index))
3465 def __init__(self, master=None, cnf={}, **kw):
3466 Widget.__init__(self, master, 'menubutton', cnf, kw)
3472 def __init__(self, master=None, cnf={}, **kw):
3473 Widget.__init__(self, master, 'message', cnf, kw)
3479 def __init__(self, master=None, cnf={}, **kw):
3489 Widget.__init__(self, master, 'radiobutton', cnf, kw)
3491 def deselect(self):
3494 self.tk.call(self._w, 'deselect')
3496 def flash(self):
3498 self.tk.call(self._w, 'flash')
3500 def invoke(self):
3502 return self.tk.call(self._w, 'invoke')
3504 def select(self):
3506 self.tk.call(self._w, 'select')
3512 def __init__(self, master=None, cnf={}, **kw):
3521 Widget.__init__(self, master, 'scale', cnf, kw)
3523 def get(self):
3525 value = self.tk.call(self._w, 'get')
3527 return self.tk.getint(value)
3529 return self.tk.getdouble(value)
3531 def set(self, value):
3533 self.tk.call(self._w, 'set', value)
3535 def coords(self, value=None):
3540 return self._getints(self.tk.call(self._w, 'coords', value))
3542 def identify(self, x, y):
3545 return self.tk.call(self._w, 'identify', x, y)
3551 def __init__(self, master=None, cnf={}, **kw):
3560 Widget.__init__(self, master, 'scrollbar', cnf, kw)
3562 def activate(self, index=None):
3569 return self.tk.call(self._w, 'activate', index) or None
3571 def delta(self, deltax, deltay):
3574 return self.tk.getdouble(
3575 self.tk.call(self._w, 'delta', deltax, deltay))
3577 def fraction(self, x, y):
3580 return self.tk.getdouble(self.tk.call(self._w, 'fraction', x, y))
3582 def identify(self, x, y):
3585 return self.tk.call(self._w, 'identify', x, y)
3587 def get(self):
3590 return self._getdoubles(self.tk.call(self._w, 'get'))
3592 def set(self, first, last):
3595 self.tk.call(self._w, 'set', first, last)
3601 def __init__(self, master=None, cnf={}, **kw):
3624 Widget.__init__(self, master, 'text', cnf, kw)
3626 def bbox(self, index):
3629 return self._getints(
3630 self.tk.call(self._w, 'bbox', index)) or None
3632 def compare(self, index1, op, index2):
3635 return self.tk.getboolean(self.tk.call(
3636 self._w, 'compare', index1, op, index2))
3638 def count(self, index1, index2, *args): # new in Tk 8.5
3652 res = self.tk.call(self._w, 'count', *args) or None
3658 def debug(self, boolean=None):
3662 return self.tk.getboolean(self.tk.call(self._w, 'debug'))
3663 self.tk.call(self._w, 'debug', boolean)
3665 def delete(self, index1, index2=None):
3667 self.tk.call(self._w, 'delete', index1, index2)
3669 def dlineinfo(self, index):
3673 return self._getints(self.tk.call(self._w, 'dlineinfo', index))
3675 def dump(self, index1, index2=None, command=None, **kw):
3701 func_name = command = self._register(command)
3708 self.tk.call(self._w, "dump", *args)
3712 self.deletecommand(func_name)
3715 def edit(self, *args):
3728 return self.tk.call(self._w, 'edit', *args)
3730 def edit_modified(self, arg=None):
3739 return self.edit("modified", arg)
3741 def edit_redo(self):
3749 return self.edit("redo")
3751 def edit_reset(self):
3754 return self.edit("reset")
3756 def edit_separator(self):
3761 return self.edit("separator")
3763 def edit_undo(self):
3772 return self.edit("undo")
3774 def get(self, index1, index2=None):
3776 return self.tk.call(self._w, 'get', index1, index2)
3779 def image_cget(self, index, option):
3785 return self.tk.call(self._w, "image", "cget", index, option)
3787 def image_configure(self, index, cnf=None, **kw):
3789 return self._configure(('image', 'configure', index), cnf, kw)
3791 def image_create(self, index, cnf={}, **kw):
3793 return self.tk.call(
3794 self._w, "image", "create", index,
3795 *self._options(cnf, kw))
3797 def image_names(self):
3799 return self.tk.call(self._w, "image", "names")
3801 def index(self, index):
3803 return str(self.tk.call(self._w, 'index', index))
3805 def insert(self, index, chars, *args):
3808 self.tk.call((self._w, 'insert', index, chars) + args)
3810 def mark_gravity(self, markName, direction=None):
3813 return self.tk.call(
3814 (self._w, 'mark', 'gravity', markName, direction))
3816 def mark_names(self):
3818 return self.tk.splitlist(self.tk.call(
3819 self._w, 'mark', 'names'))
3821 def mark_set(self, markName, index):
3823 self.tk.call(self._w, 'mark', 'set', markName, index)
3825 def mark_unset(self, *markNames):
3827 self.tk.call((self._w, 'mark', 'unset') + markNames)
3829 def mark_next(self, index):
3831 return self.tk.call(self._w, 'mark', 'next', index) or None
3833 def mark_previous(self, index):
3835 return self.tk.call(self._w, 'mark', 'previous', index) or None
3837 def peer_create(self, newPathName, cnf={}, **kw): # new in Tk 8.5
3842 self.tk.call(self._w, 'peer', 'create', newPathName,
3843 *self._options(cnf, kw))
3845 def peer_names(self): # new in Tk 8.5
3848 return self.tk.splitlist(self.tk.call(self._w, 'peer', 'names'))
3850 def replace(self, index1, index2, chars, *args): # new in Tk 8.5
3856 self.tk.call(self._w, 'replace', index1, index2, chars, *args)
3858 def scan_mark(self, x, y):
3860 self.tk.call(self._w, 'scan', 'mark', x, y)
3862 def scan_dragto(self, x, y):
3866 self.tk.call(self._w, 'scan', 'dragto', x, y)
3868 def search(self, pattern, index, stopindex=None,
3874 args = [self._w, 'search']
3886 return str(self.tk.call(tuple(args)))
3888 def see(self, index):
3890 self.tk.call(self._w, 'see', index)
3892 def tag_add(self, tagName, index1, *args):
3895 self.tk.call(
3896 (self._w, 'tag', 'add', tagName, index1) + args)
3898 def tag_unbind(self, tagName, sequence, funcid=None):
3901 self.tk.call(self._w, 'tag', 'bind', tagName, sequence, '')
3903 self.deletecommand(funcid)
3905 def tag_bind(self, tagName, sequence, func, add=None):
3911 return self._bind((self._w, 'tag', 'bind', tagName),
3914 def tag_cget(self, tagName, option):
3920 return self.tk.call(self._w, 'tag', 'cget', tagName, option)
3922 def tag_configure(self, tagName, cnf=None, **kw):
3924 return self._configure(('tag', 'configure', tagName), cnf, kw)
3928 def tag_delete(self, *tagNames):
3930 self.tk.call((self._w, 'tag', 'delete') + tagNames)
3932 def tag_lower(self, tagName, belowThis=None):
3935 self.tk.call(self._w, 'tag', 'lower', tagName, belowThis)
3937 def tag_names(self, index=None):
3939 return self.tk.splitlist(
3940 self.tk.call(self._w, 'tag', 'names', index))
3942 def tag_nextrange(self, tagName, index1, index2=None):
3946 return self.tk.splitlist(self.tk.call(
3947 self._w, 'tag', 'nextrange', tagName, index1, index2))
3949 def tag_prevrange(self, tagName, index1, index2=None):
3953 return self.tk.splitlist(self.tk.call(
3954 self._w, 'tag', 'prevrange', tagName, index1, index2))
3956 def tag_raise(self, tagName, aboveThis=None):
3959 self.tk.call(
3960 self._w, 'tag', 'raise', tagName, aboveThis)
3962 def tag_ranges(self, tagName):
3964 return self.tk.splitlist(self.tk.call(
3965 self._w, 'tag', 'ranges', tagName))
3967 def tag_remove(self, tagName, index1, index2=None):
3969 self.tk.call(
3970 self._w, 'tag', 'remove', tagName, index1, index2)
3972 def window_cget(self, index, option):
3978 return self.tk.call(self._w, 'window', 'cget', index, option)
3980 def window_configure(self, index, cnf=None, **kw):
3982 return self._configure(('window', 'configure', index), cnf, kw)
3986 def window_create(self, index, cnf={}, **kw):
3988 self.tk.call(
3989 (self._w, 'window', 'create', index)
3990 + self._options(cnf, kw))
3992 def window_names(self):
3994 return self.tk.splitlist(
3995 self.tk.call(self._w, 'window', 'names'))
3997 def yview_pickplace(self, *what):
3999 self.tk.call((self._w, 'yview', '-pickplace') + what)
4005 def __init__(self, var, value, callback=None):
4006 self.__value = value
4007 self.__var = var
4008 self.__callback = callback
4010 def __call__(self, *args):
4011 self.__var.set(self.__value)
4012 if self.__callback is not None:
4013 self.__callback(self.__value, *args)
4019 def __init__(self, master, variable, value, *values, **kwargs):
4027 Widget.__init__(self, master, "menubutton", kw)
4028 self.widgetName = 'tk_optionMenu'
4029 menu = self.__menu = Menu(self, name="menu", tearoff=0)
4030 self.menuname = menu._w
4042 self["menu"] = menu
4044 def __getitem__(self, name):
4046 return self.__menu
4047 return Widget.__getitem__(self, name)
4049 def destroy(self):
4051 Menubutton.destroy(self)
4052 self.__menu = None
4059 def __init__(self, imgtype, name=None, cnf={}, master=None, **kw):
4060 self.name = None
4063 self.tk = getattr(master, 'tk', master)
4072 v = self._register(v)
4074 self.tk.call(('image', 'create', imgtype, name,) + options)
4075 self.name = name
4077 def __str__(self): return self.name
4079 def __del__(self):
4080 if self.name:
4082 self.tk.call('image', 'delete', self.name)
4087 def __setitem__(self, key, value):
4088 self.tk.call(self.name, 'configure', '-'+key, value)
4090 def __getitem__(self, key):
4091 return self.tk.call(self.name, 'configure', '-'+key)
4093 def configure(self, **kw):
4100 v = self._register(v)
4102 self.tk.call((self.name, 'config') + res)
4106 def height(self):
4108 return self.tk.getint(
4109 self.tk.call('image', 'height', self.name))
4111 def type(self):
4113 return self.tk.call('image', 'type', self.name)
4115 def width(self):
4117 return self.tk.getint(
4118 self.tk.call('image', 'width', self.name))
4124 def __init__(self, name=None, cnf={}, master=None, **kw):
4129 Image.__init__(self, 'photo', name, cnf, master, **kw)
4131 def blank(self):
4133 self.tk.call(self.name, 'blank')
4135 def cget(self, option):
4137 return self.tk.call(self.name, 'cget', '-' + option)
4140 def __getitem__(self, key):
4141 return self.tk.call(self.name, 'cget', '-' + key)
4144 def copy(self):
4146 destImage = PhotoImage(master=self.tk)
4147 self.tk.call(destImage, 'copy', self.name)
4150 def zoom(self, x, y=''):
4155 destImage = PhotoImage(master=self.tk)
4157 self.tk.call(destImage, 'copy', self.name, '-zoom',x,y)
4160 def subsample(self, x, y=''):
4165 destImage = PhotoImage(master=self.tk)
4167 self.tk.call(destImage, 'copy', self.name, '-subsample',x,y)
4170 def get(self, x, y):
4172 return self.tk.call(self.name, 'get', x, y)
4174 def put(self, data, to=None):
4177 args = (self.name, 'put', data)
4182 self.tk.call(args)
4185 def write(self, filename, format=None, from_coords=None):
4188 args = (self.name, 'write', filename)
4193 self.tk.call(args)
4195 def transparency_get(self, x, y):
4197 return self.tk.getboolean(self.tk.call(
4198 self.name, 'transparency', 'get', x, y))
4200 def transparency_set(self, x, y, boolean):
4202 self.tk.call(self.name, 'transparency', 'set', x, y, boolean)
4208 def __init__(self, name=None, cnf={}, master=None, **kw):
4212 Image.__init__(self, 'bitmap', name, cnf, master, **kw)
4228 def __init__(self, master=None, cnf={}, **kw):
4255 Widget.__init__(self, master, 'spinbox', cnf, kw)
4257 def bbox(self, index):
4269 return self._getints(self.tk.call(self._w, 'bbox', index)) or None
4271 def delete(self, first, last=None):
4280 return self.tk.call(self._w, 'delete', first, last)
4282 def get(self):
4284 return self.tk.call(self._w, 'get')
4286 def icursor(self, index):
4292 return self.tk.call(self._w, 'icursor', index)
4294 def identify(self, x, y):
4299 return self.tk.call(self._w, 'identify', x, y)
4301 def index(self, index):
4304 return self.tk.call(self._w, 'index', index)
4306 def insert(self, index, s):
4311 return self.tk.call(self._w, 'insert', index, s)
4313 def invoke(self, element):
4319 return self.tk.call(self._w, 'invoke', element)
4321 def scan(self, *args):
4323 return self._getints(
4324 self.tk.call((self._w, 'scan') + args)) or ()
4326 def scan_mark(self, x):
4333 return self.scan("mark", x)
4335 def scan_dragto(self, x):
4345 return self.scan("dragto", x)
4347 def selection(self, *args):
4349 return self._getints(
4350 self.tk.call((self._w, 'selection') + args)) or ()
4352 def selection_adjust(self, index):
4364 return self.selection("adjust", index)
4366 def selection_clear(self):
4372 return self.selection("clear")
4374 def selection_element(self, element=None):
4380 return self.tk.call(self._w, 'selection', 'element', element)
4382 def selection_from(self, index):
4384 self.selection('from', index)
4386 def selection_present(self):
4389 return self.tk.getboolean(
4390 self.tk.call(self._w, 'selection', 'present'))
4392 def selection_range(self, start, end):
4394 self.selection('range', start, end)
4396 def selection_to(self, index):
4398 self.selection('to', index)
4406 def __init__(self, master=None, cnf={}, **kw):
4422 Widget.__init__(self, master, 'labelframe', cnf, kw)
4430 def __init__(self, master=None, cnf={}, **kw):
4444 Widget.__init__(self, master, 'panedwindow', cnf, kw)
4446 def add(self, child, **kw):
4454 self.tk.call((self._w, 'add', child) + self._options(kw))
4456 def remove(self, child):
4461 self.tk.call(self._w, 'forget', child)
4465 def identify(self, x, y):
4475 return self.tk.call(self._w, 'identify', x, y)
4477 def proxy(self, *args):
4479 return self._getints(
4480 self.tk.call((self._w, 'proxy') + args)) or ()
4482 def proxy_coord(self):
4485 return self.proxy("coord")
4487 def proxy_forget(self):
4490 return self.proxy("forget")
4492 def proxy_place(self, x, y):
4495 return self.proxy("place", x, y)
4497 def sash(self, *args):
4499 return self._getints(
4500 self.tk.call((self._w, 'sash') + args)) or ()
4502 def sash_coord(self, index):
4514 return self.sash("coord", index)
4516 def sash_mark(self, index):
4521 return self.sash("mark", index)
4523 def sash_place(self, index, x, y):
4526 return self.sash("place", index, x, y)
4528 def panecget(self, child, option):
4533 return self.tk.call(
4534 (self._w, 'panecget') + (child, '-'+option))
4536 def paneconfigure(self, tagOrId, cnf=None, **kw):
4605 return self._getconfigure(self._w, 'paneconfigure', tagOrId)
4607 return self._getconfigure1(
4608 self._w, 'paneconfigure', tagOrId, '-'+cnf)
4609 self.tk.call((self._w, 'paneconfigure', tagOrId) +
4610 self._options(cnf, kw))
4614 def panes(self):
4616 return self.tk.splitlist(self.tk.call(self._w, 'panes'))