diff options
author | William Joye <wjoye@cfa.harvard.edu> | 2019-01-07 21:33:12 (GMT) |
---|---|---|
committer | William Joye <wjoye@cfa.harvard.edu> | 2019-01-07 21:33:12 (GMT) |
commit | add018f8b224a906e0c85e0740919e68d15f6854 (patch) | |
tree | 94c9d70d4441d9aa26a358b56bd6de92b1d3c331 /library/tktable.py | |
download | blt-add018f8b224a906e0c85e0740919e68d15f6854.zip blt-add018f8b224a906e0c85e0740919e68d15f6854.tar.gz blt-add018f8b224a906e0c85e0740919e68d15f6854.tar.bz2 |
Squashed 'tktable/' content from commit 998144f5
git-subtree-dir: tktable
git-subtree-split: 998144f5af780966e6e92249bfe0b3dea919d2a1
Diffstat (limited to 'library/tktable.py')
-rwxr-xr-x | library/tktable.py | 651 |
1 files changed, 651 insertions, 0 deletions
diff --git a/library/tktable.py b/library/tktable.py new file mode 100755 index 0000000..d293f9f --- /dev/null +++ b/library/tktable.py @@ -0,0 +1,651 @@ +# Updated tktable.py wrapper for Python 2.x with Tkinter. +# Improvements over previous version can be seen at: +# https://sf.net/tracker2/?func=detail&aid=2244167&group_id=11464&atid=311464 +# +# Copyright (c) 2008, Guilherme Polo +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# * Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. + +""" +This contains a wrapper class for the tktable widget as well a class for using +tcl arrays that are, in some instances, required by tktable. +""" + +__author__ = "Guilherme Polo <ggpolo@gmail.com>" + +__all__ = ["ArrayVar", "Table"] + +import Tkinter + +def _setup_master(master): + if master is None: + if Tkinter._support_default_root: + master = Tkinter._default_root or Tkinter.Tk() + else: + raise RuntimeError("No master specified and Tkinter is " + "configured to not support default master") + return master + +class ArrayVar(Tkinter.Variable): + def __init__(self, master=None, name=None): + # Tkinter.Variable.__init__ is not called on purpose! I don't wanna + # see an ugly _default value in the pretty array. + self._master = _setup_master(master) + self._tk = self._master.tk + if name: + self._name = name + else: + self._name = 'PY_VAR%s' % id(self) + + def get(self, index=None): + if index is None: + res = {} + for key in self.names(): + res[key] = self._tk.globalgetvar(str(self), key) + return res + + return self._tk.globalgetvar(str(self), str(index)) + + def names(self): + return self._tk.call('array', 'names', self._name) + + def set(self, key, value): + self._tk.globalsetvar(str(self), str(key), value) + + +class Table(Tkinter.Widget): + """Create and manipulate tables.""" + + _switches = ('holddimensions', 'holdselection', 'holdtags', 'holdwindows', + 'keeptitles', '-') + _tabsubst_format = ('%c', '%C', '%i', '%r', '%s', '%S', '%W') + _tabsubst_commands = ('browsecommand', 'browsecmd', 'command', + 'selectioncommand', 'selcmd', + 'validatecommand', 'valcmd') + + def __init__(self, master=None, **kw): + master = _setup_master(master) + try: + master.tk.call('package', 'require', 'Tktable') + except Tkinter.TclError: + try: + master.tk.call('load', 'Tktable.dll', 'Tktable') + except Tkinter.TclError: + master.tk.call('load', '', 'Tktable') + + Tkinter.Widget.__init__(self, master, 'table', kw) + + + def _options(self, cnf, kw=None): + if kw: + cnf = Tkinter._cnfmerge((cnf, kw)) + else: + cnf = Tkinter._cnfmerge(cnf) + + res = () + for k, v in cnf.iteritems(): + if callable(v): + if k in self._tabsubst_commands: + v = "%s %s" % (self._register(v, self._tabsubst), + ' '.join(self._tabsubst_format)) + else: + v = self._register(v) + res += ('-%s' % k, v) + + return res + + + def _tabsubst(self, *args): + if len(args) != len(self._tabsubst_format): + return args + + tk = self.tk + c, C, i, r, s, S, W = args + e = Tkinter.Event() + + e.widget = self + e.c = tk.getint(c) + e.i = tk.getint(i) + e.r = tk.getint(r) + e.C = (e.r, e.c) + try: + e.s = tk.getint(s) + except Tkinter.TclError: + e.s = s + try: + e.S = tk.getint(S) + except Tkinter.TclError: + e.S = S + e.W = W + + return (e,) + + + def _handle_switches(self, args): + args = args or () + return tuple(('-%s' % x) for x in args if x in self._switches) + + + def activate(self, index): + """Set the active cell to the one indicated by index.""" + self.tk.call(self._w, 'activate', index) + + + def bbox(self, first, last=None): + """Return the bounding box for the specified cell (range) as a + 4-tuple of x, y, width and height in pixels. It clips the box to + the visible portion, if any, otherwise an empty tuple is returned.""" + return self._getints(self.tk.call(self._w, 'bbox', first, last)) or () + + + def clear(self, option, first=None, last=None): + """This is a convenience routine to clear certain state information + managed by the table. first and last represent valid table indices. + If neither are specified, then the command operates on the whole + table.""" + self.tk.call(self._w, 'clear', option, first, last) + + + def clear_cache(self, first=None, last=None): + """Clear the specified section of the cache, if the table has been + keeping one.""" + self.clear('cache', first, last) + + + def clear_sizes(self, first=None, last=None): + """Clear the specified row and column areas of specific height/width + dimensions. When just one index is specified, for example 2,0, that + is interpreted as row 2 and column 0.""" + self.clear('sizes', first, last) + + + def clear_tags(self, first=None, last=None): + """Clear the specified area of tags (all row, column and cell tags).""" + self.clear('tags', first, last) + + + def clear_all(self, first=None, last=None): + """Perform all of the above clear functions on the specified area.""" + self.clear('all', first, last) + + + def curselection(self, value=None): + """With no arguments, it returns the sorted indices of the currently + selected cells. Otherwise it sets all the selected cells to the given + value if there is an associated ArrayVar and the state is not + disabled.""" + result = self.tk.call(self._w, 'curselection', value) + if value is None: + return result + + + def curvalue(self, value=None): + """If no value is given, the value of the cell being edited (indexed + by active) is returned, else it is set to the given value. """ + return self.tk.call(self._w, 'curvalue', value) + + + def delete_active(self, index1, index2=None): + """Deletes text from the active cell. If only one index is given, + it deletes the character after that index, otherwise it deletes from + the first index to the second. index can be a number, insert or end.""" + self.tk.call(self._w, 'delete', 'active', index1, index2) + + + def delete_cols(self, index, count=None, switches=None): + args = self._handle_switches(switches) + (index, count) + self.tk.call(self._w, 'delete', 'cols', *args) + + + def delete_rows(self, index, count=None, switches=None): + args = self._handle_switches(switches) + (index, count) + self.tk.call(self._w, 'delete', 'rows', *args) + + + def get(self, first, last=None): + """Returns the value of the cells specified by the table indices + first and (optionally) last.""" + return self.tk.call(self._w, 'get', first, last) + + + def height(self, row=None, **kwargs): + """If row and kwargs are not given, a list describing all rows for + which a width has been set is returned. + If row is given, the height of that row is returnd. + If kwargs is given, then it sets the key/value pairs, where key is a + row and value represents the height for the row.""" + if row is None and not kwargs: + pairs = self.tk.splitlist(self.tk.call(self._w, 'height')) + return dict(pair.split() for pair in pairs) + elif row: + return int(self.tk.call(self._w, 'height', str(row))) + + args = Tkinter._flatten(kwargs.items()) + self.tk.call(self._w, 'height', *args) + + + def hidden(self, *args): + """When called without args, it returns all the hidden cells (those + cells covered by a spanning cell). If one index is specified, it + returns the spanning cell covering that index, if any. If multiple + indices are specified, it returns 1 if all indices are hidden cells, + 0 otherwise.""" + return self.tk.call(self._w, 'hidden', *args) + + + def icursor(self, arg=None): + """If arg is not specified, return the location of the insertion + cursor in the active cell. Otherwise, set the cursor to that point in + the string. + + 0 is before the first character, you can also use insert or end for + the current insertion point or the end of the text. If there is no + active cell, or the cell or table is disabled, this will return -1.""" + return self.tk.call(self._w, 'icursor', arg) + + + def index(self, index, rc=None): + """Return the integer cell coordinate that corresponds to index in the + form row, col. If rc is specified, it must be either 'row' or 'col' so + only the row or column index is returned.""" + res = self.tk.call(self._w, 'index', index, rc) + if rc is None: + return res + else: + return int(res) + + + def insert_active(self, index, value): + """The value is a text string which is inserted at the index postion + of the active cell. The cursor is then positioned after the new text. + index can be a number, insert or end. """ + self.tk.call(self._w, 'insert', 'active', index, value) + + + def insert_cols(self, index, count=None, switches=None): + args = self._handle_switches(switches) + (index, count) + self.tk.call(self._w, 'insert', 'cols', *args) + + + def insert_rows(self, index, count=None, switches=None): + args = self._handle_switches(switches) + (index, count) + self.tk.call(self._w, 'insert', 'rows', *args) + + + #def postscript(self, **kwargs): + # """Skip this command if you are under Windows. + # + # Accepted options: + # colormap, colormode, file, channel, first, fontmap, height, + # last, pageanchor, pageheight, pagewidth, pagex, pagey, rotate, + # width, x, y + # """ + # args = () + # for key, val in kwargs.iteritems(): + # args += ('-%s' % key, val) + # + # return self.tk.call(self._w, 'postscript', *args) + + + def reread(self): + """Rereads the old contents of the cell back into the editing buffer. + Useful for a key binding when <Escape> is pressed to abort the edit + (a default binding).""" + self.tk.call(self._w, 'reread') + + + def scan_mark(self, x, y): + self.tk.call(self._w, 'scan', 'mark', x, y) + + + def scan_dragto(self, x, y): + self.tk.call(self._w, 'scan', 'dragto', x, y) + + + def see(self, index): + self.tk.call(self._w, 'see', index) + + + def selection_anchor(self, index): + self.tk.call(self._w, 'selection', 'anchor', index) + + + def selection_clear(self, first, last=None): + self.tk.call(self._w, 'selection', 'clear', first, last) + + + def selection_includes(self, index): + return self.getboolean(self.tk.call(self._w, 'selection', 'includes', + index)) + + + def selection_set(self, first, last=None): + self.tk.call(self._w, 'selection', 'set', first, last) + + + def set(self, rc=None, index=None, *args, **kwargs): + """If rc is specified (either 'row' or 'col') then it is assumes that + args (if given) represents values which will be set into the + subsequent columns (if row is specified) or rows (for col). + If index is not None and args is not given, then it will return the + value(s) for the cell(s) specified. + + If kwargs is given, assumes that each key in kwargs is a index in this + table and sets the specified index to the associated value. Table + validation will not be triggered via this method. + + Note that the table must have an associated array (defined through the + variable option) in order to this work.""" + if not args and index is not None: + if rc: + args = (rc, index) + else: + args = (index, ) + return self.tk.call(self._w, 'set', *args) + + if rc is None: + args = Tkinter._flatten(kwargs.items()) + self.tk.call(self._w, 'set', *args) + else: + self.tk.call(self._w, 'set', rc, index, args) + + + def spans(self, index=None, **kwargs): + """Manipulate row/col spans. + + When called with no arguments, all known spans are returned as a dict. + When called with only the index, the span for that index only is + returned, if any. Otherwise kwargs is assumed to contain keys/values + pairs used to set spans. A span starts at the row,col defined by a key + and continues for the specified number of rows,cols specified by + its value. A span of 0,0 unsets any span on that cell.""" + if kwargs: + args = Tkinter._flatten(kwargs.items()) + self.tk.call(self._w, 'spans', *args) + else: + return self.tk.call(self._w, 'spans', index) + + + def tag_cell(self, tagname, *args): + return self.tk.call(self._w, 'tag', 'cell', tagname, *args) + + + def tag_cget(self, tagname, option): + return self.tk.call(self._w, 'tag', 'cget', tagname, '-%s' % option) + + + def tag_col(self, tagname, *args): + return self.tk.call(self._w, 'tag', 'col', tagname, *args) + + + def tag_configure(self, tagname, option=None, **kwargs): + """Query or modify options associated with the tag given by tagname. + + If no option is specified, a dict describing all of the available + options for tagname is returned. If option is specified, then the + command returns a list describing the one named option. Lastly, if + kwargs is given then it corresponds to option-value pairs that should + be modified.""" + if option is None and not kwargs: + split1 = self.tk.splitlist( + self.tk.call(self._w, 'tag', 'configure', tagname)) + + result = {} + for item in split1: + res = self.tk.splitlist(item) + result[res[0]] = res[1:] + + return result + + elif option: + return self.tk.call(self._w, 'tag', 'configure', tagname, + '-%s' % option) + + else: + args = () + for key, val in kwargs.iteritems(): + args += ('-%s' % key, val) + + self.tk.call(self._w, 'tag', 'configure', tagname, *args) + + + def tag_delete(self, tagname): + self.tk.call(self._w, 'tag', 'delete', tagname) + + + def tag_exists(self, tagname): + return self.getboolean(self.tk.call(self._w, 'tag', 'exists', tagname)) + + + def tag_includes(self, tagname, index): + return self.getboolean(self.tk.call(self._w, 'tag', 'includes', + tagname, index)) + + + def tag_lower(self, tagname, belowthis=None): + self.tk.call(self._w, 'tag', 'lower', belowthis) + + + def tag_names(self, pattern=None): + return self.tk.call(self._w, 'tag', 'names', pattern) + + + def tag_raise(self, tagname, abovethis=None): + self.tk.call(self._w, 'tag', 'raise', tagname, abovethis) + + + def tag_row(self, tagname, *args): + return self.tk.call(self._w, 'tag', 'row', tagname, *args) + + + def validate(self, index): + """Explicitly validates the specified index based on the current + callback set for the validatecommand option. Return 0 or 1 based on + whether the cell was validated.""" + return self.tk.call(self._w, 'validate', index) + + + @property + def version(self): + """Return tktable's package version.""" + return self.tk.call(self._w, 'version') + + + def width(self, column=None, **kwargs): + """If column and kwargs are not given, a dict describing all columns + for which a width has been set is returned. + If column is given, the width of that column is returnd. + If kwargs is given, then it sets the key/value pairs, where key is a + column and value represents the width for the column.""" + if column is None and not kwargs: + pairs = self.tk.splitlist(self.tk.call(self._w, 'width')) + return dict(pair.split() for pair in pairs) + elif column: + return int(self.tk.call(self._w, 'width', str(column))) + + args = Tkinter._flatten(kwargs.items()) + self.tk.call(self._w, 'width', *args) + + + def window_cget(self, index, option): + return self.tk.call(self._w, 'window', 'cget', index, option) + + + def window_configure(self, index, option=None, **kwargs): + """Query or modify options associated with the embedded window given + by index. This should also be used to add a new embedded window into + the table. + + If no option is specified, a dict describing all of the available + options for index is returned. If option is specified, then the + command returns a list describing the one named option. Lastly, if + kwargs is given then it corresponds to option-value pairs that should + be modified.""" + if option is None and not kwargs: + return self.tk.call(self._w, 'window', 'configure', index) + elif option: + return self.tk.call(self._w, 'window', 'configure', index, + '-%s' % option) + else: + args = () + for key, val in kwargs.iteritems(): + args += ('-%s' % key, val) + + self.tk.call(self._w, 'window', 'configure', index, *args) + + + def window_delete(self, *indexes): + self.tk.call(self._w, 'window', 'delete', *indexes) + + + def window_move(self, index_from, index_to): + self.tk.call(self._w, 'window', 'move', index_from, index_to) + + + def window_names(self, pattern=None): + return self.tk.call(self._w, 'window', 'names', pattern) + + + def xview(self, index=None): + """If index is not given a tuple containing two fractions is returned, + each fraction is between 0 and 1. Together they describe the + horizontal span that is visible in the window. + + If index is given the view in the window is adjusted so that the + column given by index is displayed at the left edge of the window.""" + res = self.tk.call(self._w, 'xview', index) + if index is None: + return self._getdoubles(res) + + + def xview_moveto(self, fraction): + """Adjusts the view in the window so that fraction of the total width + of the table text is off-screen to the left. The fraction parameter + must be a fraction between 0 and 1.""" + self.tk.call(self._w, 'xview', 'moveto', fraction) + + + def xview_scroll(self, number, what): + """Shift the view in the window left or right according to number and + what. The 'number' parameter must be an integer. The 'what' parameter + must be either units or pages or an abbreviation of one of these. + + If 'what' is units, the view adjusts left or right by number cells on + the display; if it is pages then the view adjusts by number screenfuls. + If 'number' is negative then cells farther to the left become visible; + if it is positive then cells farther to the right become visible. """ + self.tk.call(self._w, 'xview', 'scroll', number, what) + + + def yview(self, index=None): + """If index is not given a tuple containing two fractions is returned, + each fraction is between 0 and 1. The first element gives the position + of the table element at the top of the window, relative to the table + as a whole. The second element gives the position of the table element + just after the last one in the window, relative to the table as a + whole. + + If index is given the view in the window is adjusted so that the + row given by index is displayed at the top of the window.""" + res = self.tk.call(self._w, 'yview', index) + if index is None: + return self._getdoubles(res) + + + def yview_moveto(self, fraction): + """Adjusts the view in the window so that the element given by + fraction appears at the top of the window. The fraction parameter + must be a fraction between 0 and 1.""" + self.tk.call(self._w, 'yview', 'moveto', fraction) + + + def yview_scroll(self, number, what): + """Adjust the view in the window up or down according to number and + what. The 'number' parameter must be an integer. The 'what' parameter + must be either units or pages or an abbreviation of one of these. + + If 'what' is units, the view adjusts up or down by number cells; if it + is pages then the view adjusts by number screenfuls. + If 'number' is negative then earlier elements become visible; if it + is positive then later elements become visible. """ + self.tk.call(self._w, 'yview', 'scroll', number, what) + + +# Sample test taken from tktable cvs, original tktable python wrapper +def sample_test(): + from Tkinter import Tk, Label, Button + + def test_cmd(event): + if event.i == 0: + return '%i, %i' % (event.r, event.c) + else: + return 'set' + + def browsecmd(event): + print "event:", event.__dict__ + print "curselection:", test.curselection() + print "active cell index:", test.index('active') + print "active:", test.index('active', 'row') + print "anchor:", test.index('anchor', 'row') + + root = Tk() + + var = ArrayVar(root) + for y in range(-1, 4): + for x in range(-1, 5): + index = "%i,%i" % (y, x) + var.set(index, index) + + label = Label(root, text="Proof-of-existence test for Tktable") + label.pack(side = 'top', fill = 'x') + + quit = Button(root, text="QUIT", command=root.destroy) + quit.pack(side = 'bottom', fill = 'x') + + test = Table(root, + rows=10, + cols=5, + state='disabled', + width=6, + height=6, + titlerows=1, + titlecols=1, + roworigin=-1, + colorigin=-1, + selectmode='browse', + selecttype='row', + rowstretch='unset', + colstretch='last', + browsecmd=browsecmd, + flashmode='on', + variable=var, + usecommand=0, + command=test_cmd) + test.pack(expand=1, fill='both') + test.tag_configure('sel', background = 'yellow') + test.tag_configure('active', background = 'blue') + test.tag_configure('title', anchor='w', bg='red', relief='sunken') + root.mainloop() + +if __name__ == '__main__': + sample_test() |