w4kek/WSJT-X
1
0
Fork 0
mirror of https://github.com/saitohirga/WSJT-X.git synced 2025-10-31 04:50:34 -04:00
Code Issues Packages Projects Releases Wiki Activity
WSJT-X/Pmw.py
Joe Taylor 2c17544f3f initial import 
git-svn-id: svn+ssh://svn.code.sf.net/p/wsjt/wsjt/WSJT/trunk@1 ab8295b8-cf94-4d9e-aec4-7959e3be5d79
2005-12-22 16:40:53 +00:00

9234 lines
294 KiB
Python
Raw Blame History

import PmwColor
Color = PmwColor
del PmwColor
import PmwBlt
Blt = PmwBlt
del PmwBlt
### Loader functions:
_VERSION = '1.2'
def setversion(version):
if version != _VERSION:
raise ValueError, 'Dynamic versioning not available'
def setalphaversions(*alpha_versions):
if alpha_versions != ():
raise ValueError, 'Dynamic versioning not available'
def version(alpha = 0):
if alpha:
return ()
else:
return _VERSION
def installedversions(alpha = 0):
if alpha:
return ()
else:
return (_VERSION,)
######################################################################
### File: PmwBase.py
# Pmw megawidget base classes.
# This module provides a foundation for building megawidgets. It
# contains the MegaArchetype class which manages component widgets and
# configuration options. Also provided are the MegaToplevel and
# MegaWidget classes, derived from the MegaArchetype class. The
# MegaToplevel class contains a Tkinter Toplevel widget to act as the
# container of the megawidget. This is used as the base class of all
# megawidgets that are contained in their own top level window, such
# as a Dialog window. The MegaWidget class contains a Tkinter Frame
# to act as the container of the megawidget. This is used as the base
# class of all other megawidgets, such as a ComboBox or ButtonBox.
#
# Megawidgets are built by creating a class that inherits from either
# the MegaToplevel or MegaWidget class.
import os
import string
import sys
import traceback
import types
import Tkinter
# Special values used in index() methods of several megawidgets.
END = ['end']
SELECT = ['select']
DEFAULT = ['default']
# Constant used to indicate that an option can only be set by a call
# to the constructor.
INITOPT = ['initopt']
_DEFAULT_OPTION_VALUE = ['default_option_value']
_useTkOptionDb = 0
# Symbolic constants for the indexes into an optionInfo list.
_OPT_DEFAULT = 0
_OPT_VALUE = 1
_OPT_FUNCTION = 2
# Stacks
_busyStack = []
# Stack which tracks nested calls to show/hidebusycursor (called
# either directly or from activate()/deactivate()). Each element
# is a dictionary containing:
# 'newBusyWindows' : List of windows which had busy_hold called
# on them during a call to showbusycursor().
# The corresponding call to hidebusycursor()
# will call busy_release on these windows.
# 'busyFocus' : The blt _Busy window which showbusycursor()
# set the focus to.
# 'previousFocus' : The focus as it was when showbusycursor()
# was called. The corresponding call to
# hidebusycursor() will restore this focus if
# the focus has not been changed from busyFocus.
_grabStack = []
# Stack of grabbed windows. It tracks calls to push/popgrab()
# (called either directly or from activate()/deactivate()). The
# window on the top of the stack is the window currently with the
# grab. Each element is a dictionary containing:
# 'grabWindow' : The window grabbed by pushgrab(). The
# corresponding call to popgrab() will release
# the grab on this window and restore the grab
# on the next window in the stack (if there is one).
# 'globalMode' : True if the grabWindow was grabbed with a
# global grab, false if the grab was local
# and 'nograb' if no grab was performed.
# 'previousFocus' : The focus as it was when pushgrab()
# was called. The corresponding call to
# popgrab() will restore this focus.
# 'deactivateFunction' :
# The function to call (usually grabWindow.deactivate) if
# popgrab() is called (usually from a deactivate() method)
# on a window which is not at the top of the stack (that is,
# does not have the grab or focus). For example, if a modal
# dialog is deleted by the window manager or deactivated by
# a timer. In this case, all dialogs above and including
# this one are deactivated, starting at the top of the
# stack.
# Note that when dealing with focus windows, the name of the Tk
# widget is used, since it may be the '_Busy' window, which has no
# python instance associated with it.
#=============================================================================
# Functions used to forward methods from a class to a component.
# Fill in a flattened method resolution dictionary for a class (attributes are
# filtered out). Flattening honours the MI method resolution rules
# (depth-first search of bases in order). The dictionary has method names
# for keys and functions for values.
def __methodDict(cls, dict):
# the strategy is to traverse the class in the _reverse_ of the normal
# order, and overwrite any duplicates.
baseList = list(cls.__bases__)
baseList.reverse()
# do bases in reverse order, so first base overrides last base
for super in baseList:
__methodDict(super, dict)
# do my methods last to override base classes
for key, value in cls.__dict__.items():
# ignore class attributes
if type(value) == types.FunctionType:
dict[key] = value
def __methods(cls):
# Return all method names for a class.
# Return all method names for a class (attributes are filtered
# out). Base classes are searched recursively.
dict = {}
__methodDict(cls, dict)
return dict.keys()
# Function body to resolve a forwarding given the target method name and the
# attribute name. The resulting lambda requires only self, but will forward
# any other parameters.
__stringBody = (
'def %(method)s(this, *args, **kw): return ' +
'apply(this.%(attribute)s.%(method)s, args, kw)')
# Get a unique id
__counter = 0
def __unique():
global __counter
__counter = __counter + 1
return str(__counter)
# Function body to resolve a forwarding given the target method name and the
# index of the resolution function. The resulting lambda requires only self,
# but will forward any other parameters. The target instance is identified
# by invoking the resolution function.
__funcBody = (
'def %(method)s(this, *args, **kw): return ' +
'apply(this.%(forwardFunc)s().%(method)s, args, kw)')
def forwardmethods(fromClass, toClass, toPart, exclude = ()):
# Forward all methods from one class to another.
# Forwarders will be created in fromClass to forward method
# invocations to toClass. The methods to be forwarded are
# identified by flattening the interface of toClass, and excluding
# methods identified in the exclude list. Methods already defined
# in fromClass, or special methods with one or more leading or
# trailing underscores will not be forwarded.
# For a given object of class fromClass, the corresponding toClass
# object is identified using toPart. This can either be a String
# denoting an attribute of fromClass objects, or a function taking
# a fromClass object and returning a toClass object.
# Example:
# class MyClass:
# ...
# def __init__(self):
# ...
# self.__target = TargetClass()
# ...
# def findtarget(self):
# return self.__target
# forwardmethods(MyClass, TargetClass, '__target', ['dangerous1', 'dangerous2'])
# # ...or...
# forwardmethods(MyClass, TargetClass, MyClass.findtarget,
# ['dangerous1', 'dangerous2'])
# In both cases, all TargetClass methods will be forwarded from
# MyClass except for dangerous1, dangerous2, special methods like
# __str__, and pre-existing methods like findtarget.
# Allow an attribute name (String) or a function to determine the instance
if type(toPart) != types.StringType:
# check that it is something like a function
if callable(toPart):
# If a method is passed, use the function within it
if hasattr(toPart, 'im_func'):
toPart = toPart.im_func
# After this is set up, forwarders in this class will use
# the forwarding function. The forwarding function name is
# guaranteed to be unique, so that it can't be hidden by subclasses
forwardName = '__fwdfunc__' + __unique()
fromClass.__dict__[forwardName] = toPart
# It's not a valid type
else:
raise TypeError, 'toPart must be attribute name, function or method'
# get the full set of candidate methods
dict = {}
__methodDict(toClass, dict)
# discard special methods
for ex in dict.keys():
if ex[:1] == '_' or ex[-1:] == '_':
del dict[ex]
# discard dangerous methods supplied by the caller
for ex in exclude:
if dict.has_key(ex):
del dict[ex]
# discard methods already defined in fromClass
for ex in __methods(fromClass):
if dict.has_key(ex):
del dict[ex]
for method, func in dict.items():
d = {'method': method, 'func': func}
if type(toPart) == types.StringType:
execString = \
__stringBody % {'method' : method, 'attribute' : toPart}
else:
execString = \
__funcBody % {'forwardFunc' : forwardName, 'method' : method}
exec execString in d
# this creates a method
fromClass.__dict__[method] = d[method]
#=============================================================================
def setgeometryanddeiconify(window, geom):
# To avoid flashes on X and to position the window correctly on NT
# (caused by Tk bugs).
if os.name == 'nt' or \
(os.name == 'posix' and sys.platform[:6] == 'cygwin'):
# Require overrideredirect trick to stop window frame
# appearing momentarily.
redirect = window.overrideredirect()
if not redirect:
window.overrideredirect(1)
window.deiconify()
if geom is not None:
window.geometry(geom)
# Call update_idletasks to ensure NT moves the window to the
# correct position it is raised.
window.update_idletasks()
window.tkraise()
if not redirect:
window.overrideredirect(0)
else:
if geom is not None:
window.geometry(geom)
# Problem!? Which way around should the following two calls
# go? If deiconify() is called first then I get complaints
# from people using the enlightenment or sawfish window
# managers that when a dialog is activated it takes about 2
# seconds for the contents of the window to appear. But if
# tkraise() is called first then I get complaints from people
# using the twm window manager that when a dialog is activated
# it appears in the top right corner of the screen and also
# takes about 2 seconds to appear.
#window.tkraise()
# Call update_idletasks to ensure certain window managers (eg:
# enlightenment and sawfish) do not cause Tk to delay for
# about two seconds before displaying window.
#window.update_idletasks()
#window.deiconify()
window.deiconify()
if window.overrideredirect():
# The window is not under the control of the window manager
# and so we need to raise it ourselves.
window.tkraise()
#=============================================================================
class MegaArchetype:
# Megawidget abstract root class.
# This class provides methods which are inherited by classes
# implementing useful bases (this class doesn't provide a
# container widget inside which the megawidget can be built).
def __init__(self, parent = None, hullClass = None):
# Mapping from each megawidget option to a list of information
# about the option
# - default value
# - current value
# - function to call when the option is initialised in the
# call to initialiseoptions() in the constructor or
# modified via configure(). If this is INITOPT, the
# option is an initialisation option (an option that can
# be set by the call to the constructor but can not be
# used with configure).
# This mapping is not initialised here, but in the call to
# defineoptions() which precedes construction of this base class.
#
# self._optionInfo = {}
# Mapping from each component name to a tuple of information
# about the component.
# - component widget instance
# - configure function of widget instance
# - the class of the widget (Frame, EntryField, etc)
# - cget function of widget instance
# - the name of the component group of this component, if any
self.__componentInfo = {}
# Mapping from alias names to the names of components or
# sub-components.
self.__componentAliases = {}
# Contains information about the keywords provided to the
# constructor. It is a mapping from the keyword to a tuple
# containing:
# - value of keyword
# - a boolean indicating if the keyword has been used.
# A keyword is used if, during the construction of a megawidget,
# - it is defined in a call to defineoptions() or addoptions(), or
# - it references, by name, a component of the megawidget, or
# - it references, by group, at least one component
# At the end of megawidget construction, a call is made to
# initialiseoptions() which reports an error if there are
# unused options given to the constructor.
#
# After megawidget construction, the dictionary contains
# keywords which refer to a dynamic component group, so that
# these components can be created after megawidget
# construction and still use the group options given to the
# constructor.
#
# self._constructorKeywords = {}
# List of dynamic component groups. If a group is included in
# this list, then it not an error if a keyword argument for
# the group is given to the constructor or to configure(), but
# no components with this group have been created.
# self._dynamicGroups = ()
if hullClass is None:
self._hull = None
else:
if parent is None:
parent = Tkinter._default_root
# Create the hull.
self._hull = self.createcomponent('hull',
(), None,
hullClass, (parent,))
_hullToMegaWidget[self._hull] = self
if _useTkOptionDb:
# Now that a widget has been created, query the Tk
# option database to get the default values for the
# options which have not been set in the call to the
# constructor. This assumes that defineoptions() is
# called before the __init__().
option_get = self.option_get
_VALUE = _OPT_VALUE
_DEFAULT = _OPT_DEFAULT
for name, info in self._optionInfo.items():
value = info[_VALUE]
if value is _DEFAULT_OPTION_VALUE:
resourceClass = string.upper(name[0]) + name[1:]
value = option_get(name, resourceClass)
if value != '':
try:
# Convert the string to int/float/tuple, etc
value = eval(value, {'__builtins__': {}})
except:
pass
info[_VALUE] = value
else:
info[_VALUE] = info[_DEFAULT]
def destroy(self):
# Clean up optionInfo in case it contains circular references
# in the function field, such as self._settitle in class
# MegaToplevel.
self._optionInfo = {}
if self._hull is not None:
del _hullToMegaWidget[self._hull]
self._hull.destroy()
#======================================================================
# Methods used (mainly) during the construction of the megawidget.
def defineoptions(self, keywords, optionDefs, dynamicGroups = ()):
# Create options, providing the default value and the method
# to call when the value is changed. If any option created by
# base classes has the same name as one in <optionDefs>, the
# base class's value and function will be overriden.
# This should be called before the constructor of the base
# class, so that default values defined in the derived class
# override those in the base class.
if not hasattr(self, '_constructorKeywords'):
# First time defineoptions has been called.
tmp = {}
for option, value in keywords.items():
tmp[option] = [value, 0]
self._constructorKeywords = tmp
self._optionInfo = {}
self._initialiseoptions_counter = 0
self._initialiseoptions_counter = self._initialiseoptions_counter + 1
if not hasattr(self, '_dynamicGroups'):
self._dynamicGroups = ()
self._dynamicGroups = self._dynamicGroups + tuple(dynamicGroups)
self.addoptions(optionDefs)
def addoptions(self, optionDefs):
# Add additional options, providing the default value and the
# method to call when the value is changed. See
# "defineoptions" for more details
# optimisations:
optionInfo = self._optionInfo
optionInfo_has_key = optionInfo.has_key
keywords = self._constructorKeywords
keywords_has_key = keywords.has_key
FUNCTION = _OPT_FUNCTION
for name, default, function in optionDefs:
if '_' not in name:
# The option will already exist if it has been defined
# in a derived class. In this case, do not override the
# default value of the option or the callback function
# if it is not None.
if not optionInfo_has_key(name):
if keywords_has_key(name):
value = keywords[name][0]
optionInfo[name] = [default, value, function]
del keywords[name]
else:
if _useTkOptionDb:
optionInfo[name] = \
[default, _DEFAULT_OPTION_VALUE, function]
else:
optionInfo[name] = [default, default, function]
elif optionInfo[name][FUNCTION] is None:
optionInfo[name][FUNCTION] = function
else:
# This option is of the form "component_option". If this is
# not already defined in self._constructorKeywords add it.
# This allows a derived class to override the default value
# of an option of a component of a base class.
if not keywords_has_key(name):
keywords[name] = [default, 0]
def createcomponent(self, componentName, componentAliases,
componentGroup, widgetClass, *widgetArgs, **kw):
# Create a component (during construction or later).
if self.__componentInfo.has_key(componentName):
raise ValueError, 'Component "%s" already exists' % componentName
if '_' in componentName:
raise ValueError, \
'Component name "%s" must not contain "_"' % componentName
if hasattr(self, '_constructorKeywords'):
keywords = self._constructorKeywords
else:
keywords = {}
for alias, component in componentAliases:
# Create aliases to the component and its sub-components.
index = string.find(component, '_')
if index < 0:
self.__componentAliases[alias] = (component, None)
else:
mainComponent = component[:index]
subComponent = component[(index + 1):]
self.__componentAliases[alias] = (mainComponent, subComponent)
# Remove aliases from the constructor keyword arguments by
# replacing any keyword arguments that begin with *alias*
# with corresponding keys beginning with *component*.
alias = alias + '_'
aliasLen = len(alias)
for option in keywords.keys():
if len(option) > aliasLen and option[:aliasLen] == alias:
newkey = component + '_' + option[aliasLen:]
keywords[newkey] = keywords[option]
del keywords[option]
componentPrefix = componentName + '_'
nameLen = len(componentPrefix)
for option in keywords.keys():
if len(option) > nameLen and option[:nameLen] == componentPrefix:
# The keyword argument refers to this component, so add
# this to the options to use when constructing the widget.
kw[option[nameLen:]] = keywords[option][0]
del keywords[option]
else:
# Check if this keyword argument refers to the group
# of this component. If so, add this to the options
# to use when constructing the widget. Mark the
# keyword argument as being used, but do not remove it
# since it may be required when creating another
# component.
index = string.find(option, '_')
if index >= 0 and componentGroup == option[:index]:
rest = option[(index + 1):]
kw[rest] = keywords[option][0]
keywords[option][1] = 1
if kw.has_key('pyclass'):
widgetClass = kw['pyclass']
del kw['pyclass']
if widgetClass is None:
return None
if len(widgetArgs) == 1 and type(widgetArgs[0]) == types.TupleType:
# Arguments to the constructor can be specified as either
# multiple trailing arguments to createcomponent() or as a
# single tuple argument.
widgetArgs = widgetArgs[0]
widget = apply(widgetClass, widgetArgs, kw)
componentClass = widget.__class__.__name__
self.__componentInfo[componentName] = (widget, widget.configure,
componentClass, widget.cget, componentGroup)
return widget
def destroycomponent(self, name):
# Remove a megawidget component.
# This command is for use by megawidget designers to destroy a
# megawidget component.
self.__componentInfo[name][0].destroy()
del self.__componentInfo[name]
def createlabel(self, parent, childCols = 1, childRows = 1):
labelpos = self['labelpos']
labelmargin = self['labelmargin']
if labelpos is None:
return
label = self.createcomponent('label',
(), None,
Tkinter.Label, (parent,))
if labelpos[0] in 'ns':
# vertical layout
if labelpos[0] == 'n':
row = 0
margin = 1
else:
row = childRows + 3
margin = row - 1
label.grid(column=2, row=row, columnspan=childCols, sticky=labelpos)
parent.grid_rowconfigure(margin, minsize=labelmargin)
else:
# horizontal layout
if labelpos[0] == 'w':
col = 0
margin = 1
else:
col = childCols + 3
margin = col - 1
label.grid(column=col, row=2, rowspan=childRows, sticky=labelpos)
parent.grid_columnconfigure(margin, minsize=labelmargin)
def initialiseoptions(self, dummy = None):
self._initialiseoptions_counter = self._initialiseoptions_counter - 1
if self._initialiseoptions_counter == 0:
unusedOptions = []
keywords = self._constructorKeywords
for name in keywords.keys():
used = keywords[name][1]
if not used:
# This keyword argument has not been used. If it
# does not refer to a dynamic group, mark it as
# unused.
index = string.find(name, '_')
if index < 0 or name[:index] not in self._dynamicGroups:
unusedOptions.append(name)
if len(unusedOptions) > 0:
if len(unusedOptions) == 1:
text = 'Unknown option "'
else:
text = 'Unknown options "'
raise KeyError, text + string.join(unusedOptions, ', ') + \
'" for ' + self.__class__.__name__
# Call the configuration callback function for every option.
FUNCTION = _OPT_FUNCTION
for info in self._optionInfo.values():
func = info[FUNCTION]
if func is not None and func is not INITOPT:
func()
#======================================================================
# Method used to configure the megawidget.
def configure(self, option=None, **kw):
# Query or configure the megawidget options.
#
# If not empty, *kw* is a dictionary giving new
# values for some of the options of this megawidget or its
# components. For options defined for this megawidget, set
# the value of the option to the new value and call the
# configuration callback function, if any. For options of the
# form <component>_<option>, where <component> is a component
# of this megawidget, call the configure method of the
# component giving it the new value of the option. The
# <component> part may be an alias or a component group name.
#
# If *option* is None, return all megawidget configuration
# options and settings. Options are returned as standard 5
# element tuples
#
# If *option* is a string, return the 5 element tuple for the
# given configuration option.
# First, deal with the option queries.
if len(kw) == 0:
# This configure call is querying the values of one or all options.
# Return 5-tuples:
# (optionName, resourceName, resourceClass, default, value)
if option is None:
rtn = {}
for option, config in self._optionInfo.items():
resourceClass = string.upper(option[0]) + option[1:]
rtn[option] = (option, option, resourceClass,
config[_OPT_DEFAULT], config[_OPT_VALUE])
return rtn
else:
config = self._optionInfo[option]
resourceClass = string.upper(option[0]) + option[1:]
return (option, option, resourceClass, config[_OPT_DEFAULT],
config[_OPT_VALUE])
# optimisations:
optionInfo = self._optionInfo
optionInfo_has_key = optionInfo.has_key
componentInfo = self.__componentInfo
componentInfo_has_key = componentInfo.has_key
componentAliases = self.__componentAliases
componentAliases_has_key = componentAliases.has_key
VALUE = _OPT_VALUE
FUNCTION = _OPT_FUNCTION
# This will contain a list of options in *kw* which
# are known to this megawidget.
directOptions = []
# This will contain information about the options in
# *kw* of the form <component>_<option>, where
# <component> is a component of this megawidget. It is a
# dictionary whose keys are the configure method of each
# component and whose values are a dictionary of options and
# values for the component.
indirectOptions = {}
indirectOptions_has_key = indirectOptions.has_key
for option, value in kw.items():
if optionInfo_has_key(option):
# This is one of the options of this megawidget.
# Make sure it is not an initialisation option.
if optionInfo[option][FUNCTION] is INITOPT:
raise KeyError, \
'Cannot configure initialisation option "' \
+ option + '" for ' + self.__class__.__name__
optionInfo[option][VALUE] = value
directOptions.append(option)
else:
index = string.find(option, '_')
if index >= 0:
# This option may be of the form <component>_<option>.
component = option[:index]
componentOption = option[(index + 1):]
# Expand component alias
if componentAliases_has_key(component):
component, subComponent = componentAliases[component]
if subComponent is not None:
componentOption = subComponent + '_' \
+ componentOption
# Expand option string to write on error
option = component + '_' + componentOption
if componentInfo_has_key(component):
# Configure the named component
componentConfigFuncs = [componentInfo[component][1]]
else:
# Check if this is a group name and configure all
# components in the group.
componentConfigFuncs = []
for info in componentInfo.values():
if info[4] == component:
componentConfigFuncs.append(info[1])
if len(componentConfigFuncs) == 0 and \
component not in self._dynamicGroups:
raise KeyError, 'Unknown option "' + option + \
'" for ' + self.__class__.__name__
# Add the configure method(s) (may be more than
# one if this is configuring a component group)
# and option/value to dictionary.
for componentConfigFunc in componentConfigFuncs:
if not indirectOptions_has_key(componentConfigFunc):
indirectOptions[componentConfigFunc] = {}
indirectOptions[componentConfigFunc][componentOption] \
= value
else:
raise KeyError, 'Unknown option "' + option + \
'" for ' + self.__class__.__name__
# Call the configure methods for any components.
map(apply, indirectOptions.keys(),
((),) * len(indirectOptions), indirectOptions.values())
# Call the configuration callback function for each option.
for option in directOptions:
info = optionInfo[option]
func = info[_OPT_FUNCTION]
if func is not None:
func()
def __setitem__(self, key, value):
apply(self.configure, (), {key: value})
#======================================================================
# Methods used to query the megawidget.
def component(self, name):
# Return a component widget of the megawidget given the
# component's name
# This allows the user of a megawidget to access and configure
# widget components directly.
# Find the main component and any subcomponents
index = string.find(name, '_')
if index < 0:
component = name
remainingComponents = None
else:
component = name[:index]
remainingComponents = name[(index + 1):]
# Expand component alias
if self.__componentAliases.has_key(component):
component, subComponent = self.__componentAliases[component]
if subComponent is not None:
if remainingComponents is None:
remainingComponents = subComponent
else:
remainingComponents = subComponent + '_' \
+ remainingComponents
widget = self.__componentInfo[component][0]
if remainingComponents is None:
return widget
else:
return widget.component(remainingComponents)
def interior(self):
return self._hull
def hulldestroyed(self):
return not _hullToMegaWidget.has_key(self._hull)
def __str__(self):
return str(self._hull)
def cget(self, option):
# Get current configuration setting.
# Return the value of an option, for example myWidget['font'].
if self._optionInfo.has_key(option):
return self._optionInfo[option][_OPT_VALUE]
else:
index = string.find(option, '_')
if index >= 0:
component = option[:index]
componentOption = option[(index + 1):]
# Expand component alias
if self.__componentAliases.has_key(component):
component, subComponent = self.__componentAliases[component]
if subComponent is not None:
componentOption = subComponent + '_' + componentOption
# Expand option string to write on error
option = component + '_' + componentOption
if self.__componentInfo.has_key(component):
# Call cget on the component.
componentCget = self.__componentInfo[component][3]
return componentCget(componentOption)
else:
# If this is a group name, call cget for one of
# the components in the group.
for info in self.__componentInfo.values():
if info[4] == component:
componentCget = info[3]
return componentCget(componentOption)
raise KeyError, 'Unknown option "' + option + \
'" for ' + self.__class__.__name__
__getitem__ = cget
def isinitoption(self, option):
return self._optionInfo[option][_OPT_FUNCTION] is INITOPT
def options(self):
options = []
if hasattr(self, '_optionInfo'):
for option, info in self._optionInfo.items():
isinit = info[_OPT_FUNCTION] is INITOPT
default = info[_OPT_DEFAULT]
options.append((option, default, isinit))
options.sort()
return options
def components(self):
# Return a list of all components.
# This list includes the 'hull' component and all widget subcomponents
names = self.__componentInfo.keys()
names.sort()
return names
def componentaliases(self):
# Return a list of all component aliases.
componentAliases = self.__componentAliases
names = componentAliases.keys()
names.sort()
rtn = []
for alias in names:
(mainComponent, subComponent) = componentAliases[alias]
if subComponent is None:
rtn.append((alias, mainComponent))
else:
rtn.append((alias, mainComponent + '_' + subComponent))
return rtn
def componentgroup(self, name):
return self.__componentInfo[name][4]
#=============================================================================
# The grab functions are mainly called by the activate() and
# deactivate() methods.
#
# Use pushgrab() to add a new window to the grab stack. This
# releases the grab by the window currently on top of the stack (if
# there is one) and gives the grab and focus to the new widget.
#
# To remove the grab from the window on top of the grab stack, call
# popgrab().
#
# Use releasegrabs() to release the grab and clear the grab stack.
def pushgrab(grabWindow, globalMode, deactivateFunction):
prevFocus = grabWindow.tk.call('focus')
grabInfo = {
'grabWindow' : grabWindow,
'globalMode' : globalMode,
'previousFocus' : prevFocus,
'deactivateFunction' : deactivateFunction,
}
_grabStack.append(grabInfo)
_grabtop()
grabWindow.focus_set()
def popgrab(window):
# Return the grab to the next window in the grab stack, if any.
# If this window is not at the top of the grab stack, then it has
# just been deleted by the window manager or deactivated by a
# timer. Call the deactivate method for the modal dialog above
# this one on the stack.
if _grabStack[-1]['grabWindow'] != window:
for index in range(len(_grabStack)):
if _grabStack[index]['grabWindow'] == window:
_grabStack[index + 1]['deactivateFunction']()
break
grabInfo = _grabStack[-1]
del _grabStack[-1]
topWidget = grabInfo['grabWindow']
prevFocus = grabInfo['previousFocus']
globalMode = grabInfo['globalMode']
if globalMode != 'nograb':
topWidget.grab_release()
if len(_grabStack) > 0:
_grabtop()
if prevFocus != '':
try:
topWidget.tk.call('focus', prevFocus)
except Tkinter.TclError:
# Previous focus widget has been deleted. Set focus
# to root window.
Tkinter._default_root.focus_set()
else:
# Make sure that focus does not remain on the released widget.
if len(_grabStack) > 0:
topWidget = _grabStack[-1]['grabWindow']
topWidget.focus_set()
else:
Tkinter._default_root.focus_set()
def grabstacktopwindow():
if len(_grabStack) == 0:
return None
else:
return _grabStack[-1]['grabWindow']
def releasegrabs():
# Release grab and clear the grab stack.
current = Tkinter._default_root.grab_current()
if current is not None:
current.grab_release()
_grabStack[:] = []
def _grabtop():
grabInfo = _grabStack[-1]
topWidget = grabInfo['grabWindow']
globalMode = grabInfo['globalMode']
if globalMode == 'nograb':
return
while 1:
try:
if globalMode:
topWidget.grab_set_global()
else:
topWidget.grab_set()
break
except Tkinter.TclError:
# Another application has grab. Keep trying until
# grab can succeed.
topWidget.after(100)
#=============================================================================
class MegaToplevel(MegaArchetype):
def __init__(self, parent = None, **kw):
# Define the options for this megawidget.
optiondefs = (
('activatecommand', None, None),
('deactivatecommand', None, None),
('master', None, None),
('title', None, self._settitle),
('hull_class', self.__class__.__name__, None),
)
self.defineoptions(kw, optiondefs)
# Initialise the base class (after defining the options).
MegaArchetype.__init__(self, parent, Tkinter.Toplevel)
# Initialise instance.
# Set WM_DELETE_WINDOW protocol, deleting any old callback, so
# memory does not leak.
if hasattr(self._hull, '_Pmw_WM_DELETE_name'):
self._hull.tk.deletecommand(self._hull._Pmw_WM_DELETE_name)
self._hull._Pmw_WM_DELETE_name = \
self.register(self._userDeleteWindow, needcleanup = 0)
self.protocol('WM_DELETE_WINDOW', self._hull._Pmw_WM_DELETE_name)
# Initialise instance variables.
self._firstShowing = 1
# Used by show() to ensure window retains previous position on screen.
# The IntVar() variable to wait on during a modal dialog.
self._wait = None
self._active = 0
self._userDeleteFunc = self.destroy
self._userModalDeleteFunc = self.deactivate
# Check keywords and initialise options.
self.initialiseoptions()
def _settitle(self):
title = self['title']
if title is not None:
self.title(title)
def userdeletefunc(self, func=None):
if func:
self._userDeleteFunc = func
else:
return self._userDeleteFunc
def usermodaldeletefunc(self, func=None):
if func:
self._userModalDeleteFunc = func
else:
return self._userModalDeleteFunc
def _userDeleteWindow(self):
if self.active():
self._userModalDeleteFunc()
else:
self._userDeleteFunc()
def destroy(self):
# Allow this to be called more than once.
if _hullToMegaWidget.has_key(self._hull):
self.deactivate()
# Remove circular references, so that object can get cleaned up.
del self._userDeleteFunc
del self._userModalDeleteFunc
MegaArchetype.destroy(self)
def show(self, master = None):
if self.state() != 'normal':
if self._firstShowing:
# Just let the window manager determine the window
# position for the first time.
geom = None
else:
# Position the window at the same place it was last time.
geom = self._sameposition()
setgeometryanddeiconify(self, geom)
if self._firstShowing:
self._firstShowing = 0
else:
if self.transient() == '':
self.tkraise()
# Do this last, otherwise get flashing on NT:
if master is not None:
if master == 'parent':
parent = self.winfo_parent()
# winfo_parent() should return the parent widget, but the
# the current version of Tkinter returns a string.
if type(parent) == types.StringType:
parent = self._hull._nametowidget(parent)
master = parent.winfo_toplevel()
self.transient(master)
self.focus()
def _centreonscreen(self):
# Centre the window on the screen. (Actually halfway across
# and one third down.)
parent = self.winfo_parent()
if type(parent) == types.StringType:
parent = self._hull._nametowidget(parent)
# Find size of window.
self.update_idletasks()
width = self.winfo_width()
height = self.winfo_height()
if width == 1 and height == 1:
# If the window has not yet been displayed, its size is
# reported as 1x1, so use requested size.
width = self.winfo_reqwidth()
height = self.winfo_reqheight()
# Place in centre of screen:
x = (self.winfo_screenwidth() - width) / 2 - parent.winfo_vrootx()
y = (self.winfo_screenheight() - height) / 3 - parent.winfo_vrooty()
if x < 0:
x = 0
if y < 0:
y = 0
return '+%d+%d' % (x, y)
def _sameposition(self):
# Position the window at the same place it was last time.
geometry = self.geometry()
index = string.find(geometry, '+')
if index >= 0:
return geometry[index:]
else:
return None
def activate(self, globalMode = 0, geometry = 'centerscreenfirst'):
if self._active:
raise ValueError, 'Window is already active'
if self.state() == 'normal':
self.withdraw()
self._active = 1
showbusycursor()
if self._wait is None:
self._wait = Tkinter.IntVar()
self._wait.set(0)
if geometry == 'centerscreenalways':
geom = self._centreonscreen()
elif geometry == 'centerscreenfirst':
if self._firstShowing:
# Centre the window the first time it is displayed.
geom = self._centreonscreen()
else:
# Position the window at the same place it was last time.
geom = self._sameposition()
elif geometry[:5] == 'first':
if self._firstShowing:
geom = geometry[5:]
else:
# Position the window at the same place it was last time.
geom = self._sameposition()
else:
geom = geometry
self._firstShowing = 0
setgeometryanddeiconify(self, geom)
# Do this last, otherwise get flashing on NT:
master = self['master']
if master is not None:
if master == 'parent':
parent = self.winfo_parent()
# winfo_parent() should return the parent widget, but the
# the current version of Tkinter returns a string.
if type(parent) == types.StringType:
parent = self._hull._nametowidget(parent)
master = parent.winfo_toplevel()
self.transient(master)
pushgrab(self._hull, globalMode, self.deactivate)
command = self['activatecommand']
if callable(command):
command()
self.wait_variable(self._wait)
return self._result
def deactivate(self, result=None):
if not self._active:
return
self._active = 0
# Restore the focus before withdrawing the window, since
# otherwise the window manager may take the focus away so we
# can't redirect it. Also, return the grab to the next active
# window in the stack, if any.
popgrab(self._hull)
command = self['deactivatecommand']
if callable(command):
command()
self.withdraw()
hidebusycursor(forceFocusRestore = 1)
self._result = result
self._wait.set(1)
def active(self):
return self._active
forwardmethods(MegaToplevel, Tkinter.Toplevel, '_hull')
#=============================================================================
class MegaWidget(MegaArchetype):
def __init__(self, parent = None, **kw):
# Define the options for this megawidget.
optiondefs = (
('hull_class', self.__class__.__name__, None),
)
self.defineoptions(kw, optiondefs)
# Initialise the base class (after defining the options).
MegaArchetype.__init__(self, parent, Tkinter.Frame)
# Check keywords and initialise options.
self.initialiseoptions()
forwardmethods(MegaWidget, Tkinter.Frame, '_hull')
#=============================================================================
# Public functions
#-----------------
_traceTk = 0
def tracetk(root = None, on = 1, withStackTrace = 0, file=None):
global _withStackTrace
global _traceTkFile
global _traceTk
if root is None:
root = Tkinter._default_root
_withStackTrace = withStackTrace
_traceTk = on
if on:
if hasattr(root.tk, '__class__'):
# Tracing already on
return
if file is None:
_traceTkFile = sys.stderr
else:
_traceTkFile = file
tk = _TraceTk(root.tk)
else:
if not hasattr(root.tk, '__class__'):
# Tracing already off
return
tk = root.tk.getTclInterp()
_setTkInterps(root, tk)
def showbusycursor():
_addRootToToplevelBusyInfo()
root = Tkinter._default_root
busyInfo = {
'newBusyWindows' : [],
'previousFocus' : None,
'busyFocus' : None,
}
_busyStack.append(busyInfo)
if _disableKeyboardWhileBusy:
# Remember the focus as it is now, before it is changed.
busyInfo['previousFocus'] = root.tk.call('focus')
if not _havebltbusy(root):
# No busy command, so don't call busy hold on any windows.
return
for (window, winInfo) in _toplevelBusyInfo.items():
if (window.state() != 'withdrawn' and not winInfo['isBusy']
and not winInfo['excludeFromBusy']):
busyInfo['newBusyWindows'].append(window)
winInfo['isBusy'] = 1
_busy_hold(window, winInfo['busyCursorName'])
# Make sure that no events for the busy window get
# through to Tkinter, otherwise it will crash in
# _nametowidget with a 'KeyError: _Busy' if there is
# a binding on the toplevel window.
window.tk.call('bindtags', winInfo['busyWindow'], 'Pmw_Dummy_Tag')
if _disableKeyboardWhileBusy:
# Remember previous focus widget for this toplevel window
# and set focus to the busy window, which will ignore all
# keyboard events.
winInfo['windowFocus'] = \
window.tk.call('focus', '-lastfor', window._w)
window.tk.call('focus', winInfo['busyWindow'])
busyInfo['busyFocus'] = winInfo['busyWindow']
if len(busyInfo['newBusyWindows']) > 0:
if os.name == 'nt':
# NT needs an "update" before it will change the cursor.
window.update()
else:
window.update_idletasks()
def hidebusycursor(forceFocusRestore = 0):
# Remember the focus as it is now, before it is changed.
root = Tkinter._default_root
if _disableKeyboardWhileBusy:
currentFocus = root.tk.call('focus')
# Pop the busy info off the stack.
busyInfo = _busyStack[-1]
del _busyStack[-1]
for window in busyInfo['newBusyWindows']:
# If this window has not been deleted, release the busy cursor.
if _toplevelBusyInfo.has_key(window):
winInfo = _toplevelBusyInfo[window]
winInfo['isBusy'] = 0
_busy_release(window)
if _disableKeyboardWhileBusy:
# Restore previous focus window for this toplevel window,
# but only if is still set to the busy window (it may have
# been changed).
windowFocusNow = window.tk.call('focus', '-lastfor', window._w)
if windowFocusNow == winInfo['busyWindow']:
try:
window.tk.call('focus', winInfo['windowFocus'])
except Tkinter.TclError:
# Previous focus widget has been deleted. Set focus
# to toplevel window instead (can't leave focus on
# busy window).
window.focus_set()
if _disableKeyboardWhileBusy:
# Restore the focus, depending on whether the focus had changed
# between the calls to showbusycursor and hidebusycursor.
if forceFocusRestore or busyInfo['busyFocus'] == currentFocus:
# The focus had not changed, so restore it to as it was before
# the call to showbusycursor,
previousFocus = busyInfo['previousFocus']
if previousFocus is not None:
try:
root.tk.call('focus', previousFocus)
except Tkinter.TclError:
# Previous focus widget has been deleted; forget it.
pass
else:
# The focus had changed, so restore it to what it had been
# changed to before the call to hidebusycursor.
root.tk.call('focus', currentFocus)
def clearbusycursor():
while len(_busyStack) > 0:
hidebusycursor()
def setbusycursorattributes(window, **kw):
_addRootToToplevelBusyInfo()
for name, value in kw.items():
if name == 'exclude':
_toplevelBusyInfo[window]['excludeFromBusy'] = value
elif name == 'cursorName':
_toplevelBusyInfo[window]['busyCursorName'] = value
else:
raise KeyError, 'Unknown busycursor attribute "' + name + '"'
def _addRootToToplevelBusyInfo():
# Include the Tk root window in the list of toplevels. This must
# not be called before Tkinter has had a chance to be initialised by
# the application.
root = Tkinter._default_root
if root == None:
root = Tkinter.Tk()
if not _toplevelBusyInfo.has_key(root):
_addToplevelBusyInfo(root)
def busycallback(command, updateFunction = None):
if not callable(command):
raise ValueError, \
'cannot register non-command busy callback %s %s' % \
(repr(command), type(command))
wrapper = _BusyWrapper(command, updateFunction)
return wrapper.callback
_errorReportFile = None
_errorWindow = None
def reporterrorstofile(file = None):
global _errorReportFile
_errorReportFile = file
def displayerror(text):
global _errorWindow
if _errorReportFile is not None:
_errorReportFile.write(text + '\n')
else:
# Print error on standard error as well as to error window.
# Useful if error window fails to be displayed, for example
# when exception is triggered in a <Destroy> binding for root
# window.
sys.stderr.write(text + '\n')
if _errorWindow is None:
# The error window has not yet been created.
_errorWindow = _ErrorWindow()
_errorWindow.showerror(text)
_root = None
_disableKeyboardWhileBusy = 1
def initialise(
root = None,
size = None,
fontScheme = None,
useTkOptionDb = 0,
noBltBusy = 0,
disableKeyboardWhileBusy = None,
):
# Remember if show/hidebusycursor should ignore keyboard events.
global _disableKeyboardWhileBusy
if disableKeyboardWhileBusy is not None:
_disableKeyboardWhileBusy = disableKeyboardWhileBusy
# Do not use blt busy command if noBltBusy is set. Otherwise,
# use blt busy if it is available.
global _haveBltBusy
if noBltBusy:
_haveBltBusy = 0
# Save flag specifying whether the Tk option database should be
# queried when setting megawidget option default values.
global _useTkOptionDb
_useTkOptionDb = useTkOptionDb
# If we haven't been given a root window, use the default or
# create one.
if root is None:
if Tkinter._default_root is None:
root = Tkinter.Tk()
else:
root = Tkinter._default_root
# If this call is initialising a different Tk interpreter than the
# last call, then re-initialise all global variables. Assume the
# last interpreter has been destroyed - ie: Pmw does not (yet)
# support multiple simultaneous interpreters.
global _root
if _root is not None and _root != root:
global _busyStack
global _errorWindow
global _grabStack
global _hullToMegaWidget
global _toplevelBusyInfo
_busyStack = []
_errorWindow = None
_grabStack = []
_hullToMegaWidget = {}
_toplevelBusyInfo = {}
_root = root
# Trap Tkinter Toplevel constructors so that a list of Toplevels
# can be maintained.
Tkinter.Toplevel.title = __TkinterToplevelTitle
# Trap Tkinter widget destruction so that megawidgets can be
# destroyed when their hull widget is destoyed and the list of
# Toplevels can be pruned.
Tkinter.Toplevel.destroy = __TkinterToplevelDestroy
Tkinter.Widget.destroy = __TkinterWidgetDestroy
# Modify Tkinter's CallWrapper class to improve the display of
# errors which occur in callbacks.
Tkinter.CallWrapper = __TkinterCallWrapper
# Make sure we get to know when the window manager deletes the
# root window. Only do this if the protocol has not yet been set.
# This is required if there is a modal dialog displayed and the
# window manager deletes the root window. Otherwise the
# application will not exit, even though there are no windows.
if root.protocol('WM_DELETE_WINDOW') == '':
root.protocol('WM_DELETE_WINDOW', root.destroy)
# Set the base font size for the application and set the
# Tk option database font resources.
_font_initialise(root, size, fontScheme)
return root
def alignlabels(widgets, sticky = None):
if len(widgets) == 0:
return
widgets[0].update_idletasks()
# Determine the size of the maximum length label string.
maxLabelWidth = 0
for iwid in widgets:
labelWidth = iwid.grid_bbox(0, 1)[2]
if labelWidth > maxLabelWidth:
maxLabelWidth = labelWidth
# Adjust the margins for the labels such that the child sites and
# labels line up.
for iwid in widgets:
if sticky is not None:
iwid.component('label').grid(sticky=sticky)
iwid.grid_columnconfigure(0, minsize = maxLabelWidth)
#=============================================================================
# Private routines
#-----------------
_callToTkReturned = 1
_recursionCounter = 1
class _TraceTk:
def __init__(self, tclInterp):
self.tclInterp = tclInterp
def getTclInterp(self):
return self.tclInterp
# Calling from python into Tk.
def call(self, *args, **kw):
global _callToTkReturned
global _recursionCounter
_callToTkReturned = 0
if len(args) == 1 and type(args[0]) == types.TupleType:
argStr = str(args[0])
else:
argStr = str(args)
_traceTkFile.write('CALL TK> %d:%s%s' %
(_recursionCounter, ' ' * _recursionCounter, argStr))
_recursionCounter = _recursionCounter + 1
try:
result = apply(self.tclInterp.call, args, kw)
except Tkinter.TclError, errorString:
_callToTkReturned = 1
_recursionCounter = _recursionCounter - 1
_traceTkFile.write('\nTK ERROR> %d:%s-> %s\n' %
(_recursionCounter, ' ' * _recursionCounter,
repr(errorString)))
if _withStackTrace:
_traceTkFile.write('CALL TK> stack:\n')
traceback.print_stack()
raise Tkinter.TclError, errorString
_recursionCounter = _recursionCounter - 1
if _callToTkReturned:
_traceTkFile.write('CALL RTN> %d:%s-> %s' %
(_recursionCounter, ' ' * _recursionCounter, repr(result)))
else:
_callToTkReturned = 1
if result:
_traceTkFile.write(' -> %s' % repr(result))
_traceTkFile.write('\n')
if _withStackTrace:
_traceTkFile.write('CALL TK> stack:\n')
traceback.print_stack()
_traceTkFile.flush()
return result
def __getattr__(self, key):
return getattr(self.tclInterp, key)
def _setTkInterps(window, tk):
window.tk = tk
for child in window.children.values():
_setTkInterps(child, tk)
#=============================================================================
# Functions to display a busy cursor. Keep a list of all toplevels
# and display the busy cursor over them. The list will contain the Tk
# root toplevel window as well as all other toplevel windows.
# Also keep a list of the widget which last had focus for each
# toplevel.
# Map from toplevel windows to
# {'isBusy', 'windowFocus', 'busyWindow',
# 'excludeFromBusy', 'busyCursorName'}
_toplevelBusyInfo = {}
# Pmw needs to know all toplevel windows, so that it can call blt busy
# on them. This is a hack so we get notified when a Tk topevel is
# created. Ideally, the __init__ 'method' should be overridden, but
# it is a 'read-only special attribute'. Luckily, title() is always
# called from the Tkinter Toplevel constructor.
def _addToplevelBusyInfo(window):
if window._w == '.':
busyWindow = '._Busy'
else:
busyWindow = window._w + '._Busy'
_toplevelBusyInfo[window] = {
'isBusy' : 0,
'windowFocus' : None,
'busyWindow' : busyWindow,
'excludeFromBusy' : 0,
'busyCursorName' : None,
}
def __TkinterToplevelTitle(self, *args):
# If this is being called from the constructor, include this
# Toplevel in the list of toplevels and set the initial
# WM_DELETE_WINDOW protocol to destroy() so that we get to know
# about it.
if not _toplevelBusyInfo.has_key(self):
_addToplevelBusyInfo(self)
self._Pmw_WM_DELETE_name = self.register(self.destroy, None, 0)
self.protocol('WM_DELETE_WINDOW', self._Pmw_WM_DELETE_name)
return apply(Tkinter.Wm.title, (self,) + args)
_haveBltBusy = None
def _havebltbusy(window):
global _busy_hold, _busy_release, _haveBltBusy
if _haveBltBusy is None:
import PmwBlt
_haveBltBusy = PmwBlt.havebltbusy(window)
_busy_hold = PmwBlt.busy_hold
if os.name == 'nt':
# There is a bug in Blt 2.4i on NT where the busy window
# does not follow changes in the children of a window.
# Using forget works around the problem.
_busy_release = PmwBlt.busy_forget
else:
_busy_release = PmwBlt.busy_release
return _haveBltBusy
class _BusyWrapper:
def __init__(self, command, updateFunction):
self._command = command
self._updateFunction = updateFunction
def callback(self, *args):
showbusycursor()
rtn = apply(self._command, args)
# Call update before hiding the busy windows to clear any
# events that may have occurred over the busy windows.
if callable(self._updateFunction):
self._updateFunction()
hidebusycursor()
return rtn
#=============================================================================
def drawarrow(canvas, color, direction, tag, baseOffset = 0.25, edgeOffset = 0.15):
canvas.delete(tag)
bw = (string.atoi(canvas['borderwidth']) +
string.atoi(canvas['highlightthickness']))
width = string.atoi(canvas['width'])
height = string.atoi(canvas['height'])
if direction in ('up', 'down'):
majorDimension = height
minorDimension = width
else:
majorDimension = width
minorDimension = height
offset = round(baseOffset * majorDimension)
if direction in ('down', 'right'):
base = bw + offset
apex = bw + majorDimension - offset
else:
base = bw + majorDimension - offset
apex = bw + offset
if minorDimension > 3 and minorDimension % 2 == 0:
minorDimension = minorDimension - 1
half = int(minorDimension * (1 - 2 * edgeOffset)) / 2
low = round(bw + edgeOffset * minorDimension)
middle = low + half
high = low + 2 * half
if direction in ('up', 'down'):
coords = (low, base, high, base, middle, apex)
else:
coords = (base, low, base, high, apex, middle)
kw = {'fill' : color, 'outline' : color, 'tag' : tag}
apply(canvas.create_polygon, coords, kw)
#=============================================================================
# Modify the Tkinter destroy methods so that it notifies us when a Tk
# toplevel or frame is destroyed.
# A map from the 'hull' component of a megawidget to the megawidget.
# This is used to clean up a megawidget when its hull is destroyed.
_hullToMegaWidget = {}
def __TkinterToplevelDestroy(tkWidget):
if _hullToMegaWidget.has_key(tkWidget):
mega = _hullToMegaWidget[tkWidget]
try:
mega.destroy()
except:
_reporterror(mega.destroy, ())
else:
# Delete the busy info structure for this toplevel (if the
# window was created before initialise() was called, it
# will not have any.
if _toplevelBusyInfo.has_key(tkWidget):
del _toplevelBusyInfo[tkWidget]
if hasattr(tkWidget, '_Pmw_WM_DELETE_name'):
tkWidget.tk.deletecommand(tkWidget._Pmw_WM_DELETE_name)
del tkWidget._Pmw_WM_DELETE_name
Tkinter.BaseWidget.destroy(tkWidget)
def __TkinterWidgetDestroy(tkWidget):
if _hullToMegaWidget.has_key(tkWidget):
mega = _hullToMegaWidget[tkWidget]
try:
mega.destroy()
except:
_reporterror(mega.destroy, ())
else:
Tkinter.BaseWidget.destroy(tkWidget)
#=============================================================================
# Add code to Tkinter to improve the display of errors which occur in
# callbacks.
class __TkinterCallWrapper:
def __init__(self, func, subst, widget):
self.func = func
self.subst = subst
self.widget = widget
# Calling back from Tk into python.
def __call__(self, *args):
try:
if self.subst:
args = apply(self.subst, args)
if _traceTk:
if not _callToTkReturned:
_traceTkFile.write('\n')
if hasattr(self.func, 'im_class'):
name = self.func.im_class.__name__ + '.' + \
self.func.__name__
else:
name = self.func.__name__
if len(args) == 1 and hasattr(args[0], 'type'):
# The argument to the callback is an event.
eventName = _eventTypeToName[string.atoi(args[0].type)]
if eventName in ('KeyPress', 'KeyRelease',):
argStr = '(%s %s Event: %s)' % \
(eventName, args[0].keysym, args[0].widget)
else:
argStr = '(%s Event, %s)' % (eventName, args[0].widget)
else:
argStr = str(args)
_traceTkFile.write('CALLBACK> %d:%s%s%s\n' %
(_recursionCounter, ' ' * _recursionCounter, name, argStr))
_traceTkFile.flush()
return apply(self.func, args)
except SystemExit, msg:
raise SystemExit, msg
except:
_reporterror(self.func, args)
_eventTypeToName = {
2 : 'KeyPress', 15 : 'VisibilityNotify', 28 : 'PropertyNotify',
3 : 'KeyRelease', 16 : 'CreateNotify', 29 : 'SelectionClear',
4 : 'ButtonPress', 17 : 'DestroyNotify', 30 : 'SelectionRequest',
5 : 'ButtonRelease', 18 : 'UnmapNotify', 31 : 'SelectionNotify',
6 : 'MotionNotify', 19 : 'MapNotify', 32 : 'ColormapNotify',
7 : 'EnterNotify', 20 : 'MapRequest', 33 : 'ClientMessage',
8 : 'LeaveNotify', 21 : 'ReparentNotify', 34 : 'MappingNotify',
9 : 'FocusIn', 22 : 'ConfigureNotify', 35 : 'VirtualEvents',
10 : 'FocusOut', 23 : 'ConfigureRequest', 36 : 'ActivateNotify',
11 : 'KeymapNotify', 24 : 'GravityNotify', 37 : 'DeactivateNotify',
12 : 'Expose', 25 : 'ResizeRequest', 38 : 'MouseWheelEvent',
13 : 'GraphicsExpose', 26 : 'CirculateNotify',
14 : 'NoExpose', 27 : 'CirculateRequest',
}
def _reporterror(func, args):
# Fetch current exception values.
exc_type, exc_value, exc_traceback = sys.exc_info()
# Give basic information about the callback exception.
if type(exc_type) == types.ClassType:
# Handle python 1.5 class exceptions.
exc_type = exc_type.__name__
msg = exc_type + ' Exception in Tk callback\n'
msg = msg + ' Function: %s (type: %s)\n' % (repr(func), type(func))
msg = msg + ' Args: %s\n' % str(args)
if type(args) == types.TupleType and len(args) > 0 and \
hasattr(args[0], 'type'):
eventArg = 1
else:
eventArg = 0
# If the argument to the callback is an event, add the event type.
if eventArg:
eventNum = string.atoi(args[0].type)
if eventNum in _eventTypeToName.keys():
msg = msg + ' Event type: %s (type num: %d)\n' % \
(_eventTypeToName[eventNum], eventNum)
else:
msg = msg + ' Unknown event type (type num: %d)\n' % eventNum
# Add the traceback.
msg = msg + 'Traceback (innermost last):\n'
for tr in traceback.extract_tb(exc_traceback):
msg = msg + ' File "%s", line %s, in %s\n' % (tr[0], tr[1], tr[2])
msg = msg + ' %s\n' % tr[3]
msg = msg + '%s: %s\n' % (exc_type, exc_value)
# If the argument to the callback is an event, add the event contents.
if eventArg:
msg = msg + '\n================================================\n'
msg = msg + ' Event contents:\n'
keys = args[0].__dict__.keys()
keys.sort()
for key in keys:
msg = msg + ' %s: %s\n' % (key, args[0].__dict__[key])
clearbusycursor()
try:
displayerror(msg)
except:
pass
class _ErrorWindow:
def __init__(self):
self._errorQueue = []
self._errorCount = 0
self._open = 0
self._firstShowing = 1
# Create the toplevel window
self._top = Tkinter.Toplevel()
self._top.protocol('WM_DELETE_WINDOW', self._hide)
self._top.title('Error in background function')
self._top.iconname('Background error')
# Create the text widget and scrollbar in a frame
upperframe = Tkinter.Frame(self._top)
scrollbar = Tkinter.Scrollbar(upperframe, orient='vertical')
scrollbar.pack(side = 'right', fill = 'y')
self._text = Tkinter.Text(upperframe, yscrollcommand=scrollbar.set)
self._text.pack(fill = 'both', expand = 1)
scrollbar.configure(command=self._text.yview)
# Create the buttons and label in a frame
lowerframe = Tkinter.Frame(self._top)
ignore = Tkinter.Button(lowerframe,
text = 'Ignore remaining errors', command = self._hide)
ignore.pack(side='left')
self._nextError = Tkinter.Button(lowerframe,
text = 'Show next error', command = self._next)
self._nextError.pack(side='left')
self._label = Tkinter.Label(lowerframe, relief='ridge')
self._label.pack(side='left', fill='x', expand=1)
# Pack the lower frame first so that it does not disappear
# when the window is resized.
lowerframe.pack(side = 'bottom', fill = 'x')
upperframe.pack(side = 'bottom', fill = 'both', expand = 1)
def showerror(self, text):
if self._open:
self._errorQueue.append(text)
else:
self._display(text)
self._open = 1
# Display the error window in the same place it was before.
if self._top.state() == 'normal':
# If update_idletasks is not called here, the window may
# be placed partially off the screen. Also, if it is not
# called and many errors are generated quickly in
# succession, the error window may not display errors
# until the last one is generated and the interpreter
# becomes idle.
# XXX: remove this, since it causes omppython to go into an
# infinite loop if an error occurs in an omp callback.
# self._top.update_idletasks()
pass
else:
if self._firstShowing:
geom = None
else:
geometry = self._top.geometry()
index = string.find(geometry, '+')
if index >= 0:
geom = geometry[index:]
else:
geom = None
setgeometryanddeiconify(self._top, geom)
if self._firstShowing:
self._firstShowing = 0
else:
self._top.tkraise()
self._top.focus()
self._updateButtons()
# Release any grab, so that buttons in the error window work.
releasegrabs()
def _hide(self):
self._errorCount = self._errorCount + len(self._errorQueue)
self._errorQueue = []
self._top.withdraw()
self._open = 0
def _next(self):
# Display the next error in the queue.
text = self._errorQueue[0]
del self._errorQueue[0]
self._display(text)
self._updateButtons()
def _display(self, text):
self._errorCount = self._errorCount + 1
text = 'Error: %d\n%s' % (self._errorCount, text)
self._text.delete('1.0', 'end')
self._text.insert('end', text)
def _updateButtons(self):
numQueued = len(self._errorQueue)
if numQueued > 0:
self._label.configure(text='%d more errors' % numQueued)
self._nextError.configure(state='normal')
else:
self._label.configure(text='No more errors')
self._nextError.configure(state='disabled')
######################################################################
### File: PmwDialog.py
# Based on iwidgets2.2.0/dialog.itk and iwidgets2.2.0/dialogshell.itk code.
# Convention:
# Each dialog window should have one of these as the rightmost button:
# Close Close a window which only displays information.
# Cancel Close a window which may be used to change the state of
# the application.
import sys
import types
import Tkinter
# A Toplevel with a ButtonBox and child site.
class Dialog(MegaToplevel):
def __init__(self, parent = None, **kw):
# Define the megawidget options.
optiondefs = (
('buttonbox_hull_borderwidth', 1, None),
('buttonbox_hull_relief', 'raised', None),
('buttonboxpos', 's', INITOPT),
('buttons', ('OK',), self._buttons),
('command', None, None),
('dialogchildsite_borderwidth', 1, None),
('dialogchildsite_relief', 'raised', None),
('defaultbutton', None, self._defaultButton),
('master', 'parent', None),
('separatorwidth', 0, INITOPT),
)
self.defineoptions(kw, optiondefs)
# Initialise the base class (after defining the options).
MegaToplevel.__init__(self, parent)
# Create the components.
oldInterior = MegaToplevel.interior(self)
# Set up pack options according to the position of the button box.
pos = self['buttonboxpos']
if pos not in 'nsew':
raise ValueError, \
'bad buttonboxpos option "%s": should be n, s, e, or w' \
% pos
if pos in 'ns':
orient = 'horizontal'
fill = 'x'
if pos == 'n':
side = 'top'
else:
side = 'bottom'
else:
orient = 'vertical'
fill = 'y'
if pos == 'w':
side = 'left'
else:
side = 'right'
# Create the button box.
self._buttonBox = self.createcomponent('buttonbox',
(), None,
ButtonBox, (oldInterior,), orient = orient)
self._buttonBox.pack(side = side, fill = fill)
# Create the separating line.
width = self['separatorwidth']
if width > 0:
self._separator = self.createcomponent('separator',
(), None,
Tkinter.Frame, (oldInterior,), relief = 'sunken',
height = width, width = width, borderwidth = width / 2)
self._separator.pack(side = side, fill = fill)
# Create the child site.
self.__dialogChildSite = self.createcomponent('dialogchildsite',
(), None,
Tkinter.Frame, (oldInterior,))
self.__dialogChildSite.pack(side=side, fill='both', expand=1)
self.oldButtons = ()
self.oldDefault = None
self.bind('<Return>', self._invokeDefault)
self.userdeletefunc(self._doCommand)
self.usermodaldeletefunc(self._doCommand)
# Check keywords and initialise options.
self.initialiseoptions()
def interior(self):
return self.__dialogChildSite
def invoke(self, index = DEFAULT):
return self._buttonBox.invoke(index)
def _invokeDefault(self, event):
try:
self._buttonBox.index(DEFAULT)
except ValueError:
return
self._buttonBox.invoke()
def _doCommand(self, name = None):
if name is not None and self.active() and \
grabstacktopwindow() != self.component('hull'):
# This is a modal dialog but is not on the top of the grab
# stack (ie: should not have the grab), so ignore this
# event. This seems to be a bug in Tk and may occur in
# nested modal dialogs.
#
# An example is the PromptDialog demonstration. To
# trigger the problem, start the demo, then move the mouse
# to the main window, hit <TAB> and then <TAB> again. The
# highlight border of the "Show prompt dialog" button
# should now be displayed. Now hit <SPACE>, <RETURN>,
# <RETURN> rapidly several times. Eventually, hitting the
# return key invokes the password dialog "OK" button even
# though the confirm dialog is active (and therefore
# should have the keyboard focus). Observed under Solaris
# 2.5.1, python 1.5.2 and Tk8.0.
# TODO: Give focus to the window on top of the grabstack.
return
command = self['command']
if callable(command):
return command(name)
else:
if self.active():
self.deactivate(name)
else:
self.withdraw()
def _buttons(self):
buttons = self['buttons']
if type(buttons) != types.TupleType and type(buttons) != types.ListType:
raise ValueError, \
'bad buttons option "%s": should be a tuple' % str(buttons)
if self.oldButtons == buttons:
return
self.oldButtons = buttons
for index in range(self._buttonBox.numbuttons()):
self._buttonBox.delete(0)
for name in buttons:
self._buttonBox.add(name,
command=lambda self=self, name=name: self._doCommand(name))
if len(buttons) > 0:
defaultbutton = self['defaultbutton']
if defaultbutton is None:
self._buttonBox.setdefault(None)
else:
try:
self._buttonBox.index(defaultbutton)
except ValueError:
pass
else:
self._buttonBox.setdefault(defaultbutton)
self._buttonBox.alignbuttons()
def _defaultButton(self):
defaultbutton = self['defaultbutton']
if self.oldDefault == defaultbutton:
return
self.oldDefault = defaultbutton
if len(self['buttons']) > 0:
if defaultbutton is None:
self._buttonBox.setdefault(None)
else:
try:
self._buttonBox.index(defaultbutton)
except ValueError:
pass
else:
self._buttonBox.setdefault(defaultbutton)
######################################################################
### File: PmwTimeFuncs.py
# Functions for dealing with dates and times.
import re
import string
def timestringtoseconds(text, separator = ':'):
inputList = string.split(string.strip(text), separator)
if len(inputList) != 3:
raise ValueError, 'invalid value: ' + text
sign = 1
if len(inputList[0]) > 0 and inputList[0][0] in ('+', '-'):
if inputList[0][0] == '-':
sign = -1
inputList[0] = inputList[0][1:]
if re.search('[^0-9]', string.join(inputList, '')) is not None:
raise ValueError, 'invalid value: ' + text
hour = string.atoi(inputList[0])
minute = string.atoi(inputList[1])
second = string.atoi(inputList[2])
if minute >= 60 or second >= 60:
raise ValueError, 'invalid value: ' + text
return sign * (hour * 60 * 60 + minute * 60 + second)
_year_pivot = 50
_century = 2000
def setyearpivot(pivot, century = None):
global _year_pivot
global _century
oldvalues = (_year_pivot, _century)
_year_pivot = pivot
if century is not None:
_century = century
return oldvalues
def datestringtojdn(text, format = 'ymd', separator = '/'):
inputList = string.split(string.strip(text), separator)
if len(inputList) != 3:
raise ValueError, 'invalid value: ' + text
if re.search('[^0-9]', string.join(inputList, '')) is not None:
raise ValueError, 'invalid value: ' + text
formatList = list(format)
day = string.atoi(inputList[formatList.index('d')])
month = string.atoi(inputList[formatList.index('m')])
year = string.atoi(inputList[formatList.index('y')])
if _year_pivot is not None:
if year >= 0 and year < 100:
if year <= _year_pivot:
year = year + _century
else:
year = year + _century - 100
jdn = ymdtojdn(year, month, day)
if jdntoymd(jdn) != (year, month, day):
raise ValueError, 'invalid value: ' + text
return jdn
def _cdiv(a, b):
# Return a / b as calculated by most C language implementations,
# assuming both a and b are integers.
if a * b > 0:
return a / b
else:
return -(abs(a) / abs(b))
def ymdtojdn(year, month, day, julian = -1, papal = 1):
# set Julian flag if auto set
if julian < 0:
if papal: # Pope Gregory XIII's decree
lastJulianDate = 15821004L # last day to use Julian calendar
else: # British-American usage
lastJulianDate = 17520902L # last day to use Julian calendar
julian = ((year * 100L) + month) * 100 + day <= lastJulianDate
if year < 0:
# Adjust BC year
year = year + 1
if julian:
return 367L * year - _cdiv(7 * (year + 5001L + _cdiv((month - 9), 7)), 4) + \
_cdiv(275 * month, 9) + day + 1729777L
else:
return (day - 32076L) + \
_cdiv(1461L * (year + 4800L + _cdiv((month - 14), 12)), 4) + \
_cdiv(367 * (month - 2 - _cdiv((month - 14), 12) * 12), 12) - \
_cdiv((3 * _cdiv((year + 4900L + _cdiv((month - 14), 12)), 100)), 4) + \
1 # correction by rdg
def jdntoymd(jdn, julian = -1, papal = 1):
# set Julian flag if auto set
if julian < 0:
if papal: # Pope Gregory XIII's decree
lastJulianJdn = 2299160L # last jdn to use Julian calendar
else: # British-American usage
lastJulianJdn = 2361221L # last jdn to use Julian calendar
julian = (jdn <= lastJulianJdn);
x = jdn + 68569L
if julian:
x = x + 38
daysPer400Years = 146100L
fudgedDaysPer4000Years = 1461000L + 1
else:
daysPer400Years = 146097L
fudgedDaysPer4000Years = 1460970L + 31
z = _cdiv(4 * x, daysPer400Years)
x = x - _cdiv((daysPer400Years * z + 3), 4)
y = _cdiv(4000 * (x + 1), fudgedDaysPer4000Years)
x = x - _cdiv(1461 * y, 4) + 31
m = _cdiv(80 * x, 2447)
d = x - _cdiv(2447 * m, 80)
x = _cdiv(m, 11)
m = m + 2 - 12 * x
y = 100 * (z - 49) + y + x
# Convert from longs to integers.
yy = int(y)
mm = int(m)
dd = int(d)
if yy <= 0:
# Adjust BC years.
yy = yy - 1
return (yy, mm, dd)
def stringtoreal(text, separator = '.'):
if separator != '.':
if string.find(text, '.') >= 0:
raise ValueError, 'invalid value: ' + text
index = string.find(text, separator)
if index >= 0:
text = text[:index] + '.' + text[index + 1:]
return string.atof(text)
######################################################################
### File: PmwBalloon.py
import os
import string
import Tkinter
class Balloon(MegaToplevel):
def __init__(self, parent = None, **kw):
# Define the megawidget options.
optiondefs = (
('initwait', 500, None), # milliseconds
('label_background', 'lightyellow', None),
('label_foreground', 'black', None),
('label_justify', 'left', None),
('master', 'parent', None),
('relmouse', 'none', self._relmouse),
('state', 'both', self._state),
('statuscommand', None, None),
('xoffset', 20, None), # pixels
('yoffset', 1, None), # pixels
('hull_highlightthickness', 1, None),
('hull_highlightbackground', 'black', None),
)
self.defineoptions(kw, optiondefs)
# Initialise the base class (after defining the options).
MegaToplevel.__init__(self, parent)
self.withdraw()
self.overrideredirect(1)
# Create the components.
interior = self.interior()
self._label = self.createcomponent('label',
(), None,
Tkinter.Label, (interior,))
self._label.pack()
# The default hull configuration options give a black border
# around the balloon, but avoids a black 'flash' when the
# balloon is deiconified, before the text appears.
if not kw.has_key('hull_background'):
self.configure(hull_background = \
str(self._label.cget('background')))
# Initialise instance variables.
self._timer = None
# The widget or item that is currently triggering the balloon.
# It is None if the balloon is not being displayed. It is a
# one-tuple if the balloon is being displayed in response to a
# widget binding (value is the widget). It is a two-tuple if
# the balloon is being displayed in response to a canvas or
# text item binding (value is the widget and the item).
self._currentTrigger = None
# Check keywords and initialise options.
self.initialiseoptions()
def destroy(self):
if self._timer is not None:
self.after_cancel(self._timer)
self._timer = None
MegaToplevel.destroy(self)
def bind(self, widget, balloonHelp, statusHelp = None):
# If a previous bind for this widget exists, remove it.
self.unbind(widget)
if balloonHelp is None and statusHelp is None:
return
if statusHelp is None:
statusHelp = balloonHelp
enterId = widget.bind('<Enter>',
lambda event, self = self, w = widget,
sHelp = statusHelp, bHelp = balloonHelp:
self._enter(event, w, sHelp, bHelp, 0))
# Set Motion binding so that if the pointer remains at rest
# within the widget until the status line removes the help and
# then the pointer moves again, then redisplay the help in the
# status line.
# Note: The Motion binding only works for basic widgets, and
# the hull of megawidgets but not for other megawidget components.
motionId = widget.bind('<Motion>',
lambda event = None, self = self, statusHelp = statusHelp:
self.showstatus(statusHelp))
leaveId = widget.bind('<Leave>', self._leave)
buttonId = widget.bind('<ButtonPress>', self._buttonpress)
# Set Destroy binding so that the balloon can be withdrawn and
# the timer can be cancelled if the widget is destroyed.
destroyId = widget.bind('<Destroy>', self._destroy)
# Use the None item in the widget's private Pmw dictionary to
# store the widget's bind callbacks, for later clean up.
if not hasattr(widget, '_Pmw_BalloonBindIds'):
widget._Pmw_BalloonBindIds = {}
widget._Pmw_BalloonBindIds[None] = \
(enterId, motionId, leaveId, buttonId, destroyId)
def unbind(self, widget):
if hasattr(widget, '_Pmw_BalloonBindIds'):
if widget._Pmw_BalloonBindIds.has_key(None):
(enterId, motionId, leaveId, buttonId, destroyId) = \
widget._Pmw_BalloonBindIds[None]
# Need to pass in old bindings, so that Tkinter can
# delete the commands. Otherwise, memory is leaked.
widget.unbind('<Enter>', enterId)
widget.unbind('<Motion>', motionId)
widget.unbind('<Leave>', leaveId)
widget.unbind('<ButtonPress>', buttonId)
widget.unbind('<Destroy>', destroyId)
del widget._Pmw_BalloonBindIds[None]
if self._currentTrigger is not None and len(self._currentTrigger) == 1:
# The balloon is currently being displayed and the current
# trigger is a widget.
triggerWidget = self._currentTrigger[0]
if triggerWidget == widget:
if self._timer is not None:
self.after_cancel(self._timer)
self._timer = None
self.withdraw()
self.clearstatus()
self._currentTrigger = None
def tagbind(self, widget, tagOrItem, balloonHelp, statusHelp = None):
# If a previous bind for this widget's tagOrItem exists, remove it.
self.tagunbind(widget, tagOrItem)
if balloonHelp is None and statusHelp is None:
return
if statusHelp is None:
statusHelp = balloonHelp
enterId = widget.tag_bind(tagOrItem, '<Enter>',
lambda event, self = self, w = widget,
sHelp = statusHelp, bHelp = balloonHelp:
self._enter(event, w, sHelp, bHelp, 1))
motionId = widget.tag_bind(tagOrItem, '<Motion>',
lambda event = None, self = self, statusHelp = statusHelp:
self.showstatus(statusHelp))
leaveId = widget.tag_bind(tagOrItem, '<Leave>', self._leave)
buttonId = widget.tag_bind(tagOrItem, '<ButtonPress>', self._buttonpress)
# Use the tagOrItem item in the widget's private Pmw dictionary to
# store the tagOrItem's bind callbacks, for later clean up.
if not hasattr(widget, '_Pmw_BalloonBindIds'):
widget._Pmw_BalloonBindIds = {}
widget._Pmw_BalloonBindIds[tagOrItem] = \
(enterId, motionId, leaveId, buttonId)
def tagunbind(self, widget, tagOrItem):
if hasattr(widget, '_Pmw_BalloonBindIds'):
if widget._Pmw_BalloonBindIds.has_key(tagOrItem):
(enterId, motionId, leaveId, buttonId) = \
widget._Pmw_BalloonBindIds[tagOrItem]
widget.tag_unbind(tagOrItem, '<Enter>', enterId)
widget.tag_unbind(tagOrItem, '<Motion>', motionId)
widget.tag_unbind(tagOrItem, '<Leave>', leaveId)
widget.tag_unbind(tagOrItem, '<ButtonPress>', buttonId)
del widget._Pmw_BalloonBindIds[tagOrItem]
if self._currentTrigger is None:
# The balloon is not currently being displayed.
return
if len(self._currentTrigger) == 1:
# The current trigger is a widget.
return
if len(self._currentTrigger) == 2:
# The current trigger is a canvas item.
(triggerWidget, triggerItem) = self._currentTrigger
if triggerWidget == widget and triggerItem == tagOrItem:
if self._timer is not None:
self.after_cancel(self._timer)
self._timer = None
self.withdraw()
self.clearstatus()
self._currentTrigger = None
else: # The current trigger is a text item.
(triggerWidget, x, y) = self._currentTrigger
if triggerWidget == widget:
currentPos = widget.index('@%d,%d' % (x, y))
currentTags = widget.tag_names(currentPos)
if tagOrItem in currentTags:
if self._timer is not None:
self.after_cancel(self._timer)
self._timer = None
self.withdraw()
self.clearstatus()
self._currentTrigger = None
def showstatus(self, statusHelp):
if self['state'] in ('status', 'both'):
cmd = self['statuscommand']
if callable(cmd):
cmd(statusHelp)
def clearstatus(self):
self.showstatus(None)
def _state(self):
if self['state'] not in ('both', 'balloon', 'status', 'none'):
raise ValueError, 'bad state option ' + repr(self['state']) + \
': should be one of \'both\', \'balloon\', ' + \
'\'status\' or \'none\''
def _relmouse(self):
if self['relmouse'] not in ('both', 'x', 'y', 'none'):
raise ValueError, 'bad relmouse option ' + repr(self['relmouse'])+ \
': should be one of \'both\', \'x\', ' + '\'y\' or \'none\''
def _enter(self, event, widget, statusHelp, balloonHelp, isItem):
# Do not display balloon if mouse button is pressed. This
# will only occur if the button was pressed inside a widget,
# then the mouse moved out of and then back into the widget,
# with the button still held down. The number 0x1f00 is the
# button mask for the 5 possible buttons in X.
buttonPressed = (event.state & 0x1f00) != 0
if not buttonPressed and balloonHelp is not None and \
self['state'] in ('balloon', 'both'):
if self._timer is not None:
self.after_cancel(self._timer)
self._timer = None
self._timer = self.after(self['initwait'],
lambda self = self, widget = widget, help = balloonHelp,
isItem = isItem:
self._showBalloon(widget, help, isItem))
if isItem:
if hasattr(widget, 'canvasx'):
# The widget is a canvas.
item = widget.find_withtag('current')
if len(item) > 0:
item = item[0]
else:
item = None
self._currentTrigger = (widget, item)
else:
# The widget is a text widget.
self._currentTrigger = (widget, event.x, event.y)
else:
self._currentTrigger = (widget,)
self.showstatus(statusHelp)
def _leave(self, event):
if self._timer is not None:
self.after_cancel(self._timer)
self._timer = None
self.withdraw()
self.clearstatus()
self._currentTrigger = None
def _destroy(self, event):
# Only withdraw the balloon and cancel the timer if the widget
# being destroyed is the widget that triggered the balloon.
# Note that in a Tkinter Destroy event, the widget field is a
# string and not a widget as usual.
if self._currentTrigger is None:
# The balloon is not currently being displayed
return
if len(self._currentTrigger) == 1:
# The current trigger is a widget (not an item)
triggerWidget = self._currentTrigger[0]
if str(triggerWidget) == event.widget:
if self._timer is not None:
self.after_cancel(self._timer)
self._timer = None
self.withdraw()
self.clearstatus()
self._currentTrigger = None
def _buttonpress(self, event):
if self._timer is not None:
self.after_cancel(self._timer)
self._timer = None
self.withdraw()
self._currentTrigger = None
def _showBalloon(self, widget, balloonHelp, isItem):
self._label.configure(text = balloonHelp)
# First, display the balloon offscreen to get dimensions.
screenWidth = self.winfo_screenwidth()
screenHeight = self.winfo_screenheight()
self.geometry('+%d+0' % (screenWidth + 1))
self.update_idletasks()
if isItem:
# Get the bounding box of the current item.
bbox = widget.bbox('current')
if bbox is None:
# The item that triggered the balloon has disappeared,
# perhaps by a user's timer event that occured between
# the <Enter> event and the 'initwait' timer calling
# this method.
return
# The widget is either a text or canvas. The meaning of
# the values returned by the bbox method is different for
# each, so use the existence of the 'canvasx' method to
# distinguish between them.
if hasattr(widget, 'canvasx'):
# The widget is a canvas. Place balloon under canvas
# item. The positions returned by bbox are relative
# to the entire canvas, not just the visible part, so
# need to convert to window coordinates.
leftrel = bbox[0] - widget.canvasx(0)
toprel = bbox[1] - widget.canvasy(0)
bottomrel = bbox[3] - widget.canvasy(0)
else:
# The widget is a text widget. Place balloon under
# the character closest to the mouse. The positions
# returned by bbox are relative to the text widget
# window (ie the visible part of the text only).
leftrel = bbox[0]
toprel = bbox[1]
bottomrel = bbox[1] + bbox[3]
else:
leftrel = 0
toprel = 0
bottomrel = widget.winfo_height()
xpointer, ypointer = widget.winfo_pointerxy() # -1 if off screen
if xpointer >= 0 and self['relmouse'] in ('both', 'x'):
x = xpointer
else:
x = leftrel + widget.winfo_rootx()
x = x + self['xoffset']
if ypointer >= 0 and self['relmouse'] in ('both', 'y'):
y = ypointer
else:
y = bottomrel + widget.winfo_rooty()
y = y + self['yoffset']
edges = (string.atoi(str(self.cget('hull_highlightthickness'))) +
string.atoi(str(self.cget('hull_borderwidth')))) * 2
if x + self._label.winfo_reqwidth() + edges > screenWidth:
x = screenWidth - self._label.winfo_reqwidth() - edges
if y + self._label.winfo_reqheight() + edges > screenHeight:
if ypointer >= 0 and self['relmouse'] in ('both', 'y'):
y = ypointer
else:
y = toprel + widget.winfo_rooty()
y = y - self._label.winfo_reqheight() - self['yoffset'] - edges
setgeometryanddeiconify(self, '+%d+%d' % (x, y))
######################################################################
### File: PmwButtonBox.py
# Based on iwidgets2.2.0/buttonbox.itk code.
import types
import Tkinter
class ButtonBox(MegaWidget):
def __init__(self, parent = None, **kw):
# Define the megawidget options.
optiondefs = (
('labelmargin', 0, INITOPT),
('labelpos', None, INITOPT),
('orient', 'horizontal', INITOPT),
('padx', 3, INITOPT),
('pady', 3, INITOPT),
)
self.defineoptions(kw, optiondefs, dynamicGroups = ('Button',))
# Initialise the base class (after defining the options).
MegaWidget.__init__(self, parent)
# Create the components.
interior = self.interior()
if self['labelpos'] is None:
self._buttonBoxFrame = self._hull
columnOrRow = 0
else:
self._buttonBoxFrame = self.createcomponent('frame',
(), None,
Tkinter.Frame, (interior,))
self._buttonBoxFrame.grid(column=2, row=2, sticky='nsew')
columnOrRow = 2
self.createlabel(interior)
orient = self['orient']
if orient == 'horizontal':
interior.grid_columnconfigure(columnOrRow, weight = 1)
elif orient == 'vertical':
interior.grid_rowconfigure(columnOrRow, weight = 1)
else:
raise ValueError, 'bad orient option ' + repr(orient) + \
': must be either \'horizontal\' or \'vertical\''
# Initialise instance variables.
# List of tuples describing the buttons:
# - name
# - button widget
self._buttonList = []
# The index of the default button.
self._defaultButton = None
self._timerId = None
# Check keywords and initialise options.
self.initialiseoptions()
def destroy(self):
if self._timerId:
self.after_cancel(self._timerId)
self._timerId = None
MegaWidget.destroy(self)
def numbuttons(self):
return len(self._buttonList)
def index(self, index, forInsert = 0):
listLength = len(self._buttonList)
if type(index) == types.IntType:
if forInsert and index <= listLength:
return index
elif not forInsert and index < listLength:
return index
else:
raise ValueError, 'index "%s" is out of range' % index
elif index is END:
if forInsert:
return listLength
elif listLength > 0:
return listLength - 1
else:
raise ValueError, 'ButtonBox has no buttons'
elif index is DEFAULT:
if self._defaultButton is not None:
return self._defaultButton
raise ValueError, 'ButtonBox has no default'
else:
names = map(lambda t: t[0], self._buttonList)
if index in names:
return names.index(index)
validValues = 'a name, a number, END or DEFAULT'
raise ValueError, \
'bad index "%s": must be %s' % (index, validValues)
def insert(self, componentName, beforeComponent = 0, **kw):
if componentName in self.components():
raise ValueError, 'button "%s" already exists' % componentName
if not kw.has_key('text'):
kw['text'] = componentName
kw['default'] = 'normal'
button = apply(self.createcomponent, (componentName,
(), 'Button',
Tkinter.Button, (self._buttonBoxFrame,)), kw)
index = self.index(beforeComponent, 1)
horizontal = self['orient'] == 'horizontal'
numButtons = len(self._buttonList)
# Shift buttons up one position.
for i in range(numButtons - 1, index - 1, -1):
widget = self._buttonList[i][1]
pos = i * 2 + 3
if horizontal:
widget.grid(column = pos, row = 0)
else:
widget.grid(column = 0, row = pos)
# Display the new button.
if horizontal:
button.grid(column = index * 2 + 1, row = 0, sticky = 'ew',
padx = self['padx'], pady = self['pady'])
self._buttonBoxFrame.grid_columnconfigure(
numButtons * 2 + 2, weight = 1)
else:
button.grid(column = 0, row = index * 2 + 1, sticky = 'ew',
padx = self['padx'], pady = self['pady'])
self._buttonBoxFrame.grid_rowconfigure(
numButtons * 2 + 2, weight = 1)
self._buttonList.insert(index, (componentName, button))
return button
def add(self, componentName, **kw):
return apply(self.insert, (componentName, len(self._buttonList)), kw)
def delete(self, index):
index = self.index(index)
(name, widget) = self._buttonList[index]
widget.grid_forget()
self.destroycomponent(name)
numButtons = len(self._buttonList)
# Shift buttons down one position.
horizontal = self['orient'] == 'horizontal'
for i in range(index + 1, numButtons):
widget = self._buttonList[i][1]
pos = i * 2 - 1
if horizontal:
widget.grid(column = pos, row = 0)
else:
widget.grid(column = 0, row = pos)
if horizontal:
self._buttonBoxFrame.grid_columnconfigure(numButtons * 2 - 1,
minsize = 0)
self._buttonBoxFrame.grid_columnconfigure(numButtons * 2, weight = 0)
else:
self._buttonBoxFrame.grid_rowconfigure(numButtons * 2, weight = 0)
del self._buttonList[index]
def setdefault(self, index):
# Turn off the default ring around the current default button.
if self._defaultButton is not None:
button = self._buttonList[self._defaultButton][1]
button.configure(default = 'normal')
self._defaultButton = None
# Turn on the default ring around the new default button.
if index is not None:
index = self.index(index)
self._defaultButton = index
button = self._buttonList[index][1]
button.configure(default = 'active')
def invoke(self, index = DEFAULT, noFlash = 0):
# Invoke the callback associated with the *index* button. If
# *noFlash* is not set, flash the button to indicate to the
# user that something happened.
button = self._buttonList[self.index(index)][1]
if not noFlash:
state = button.cget('state')
relief = button.cget('relief')
button.configure(state = 'active', relief = 'sunken')
self.update_idletasks()
self.after(100)
button.configure(state = state, relief = relief)
return button.invoke()
def button(self, buttonIndex):
return self._buttonList[self.index(buttonIndex)][1]
def alignbuttons(self, when = 'later'):
if when == 'later':
if not self._timerId:
self._timerId = self.after_idle(self.alignbuttons, 'now')
return
self.update_idletasks()
self._timerId = None
# Determine the width of the maximum length button.
max = 0
horizontal = (self['orient'] == 'horizontal')
for index in range(len(self._buttonList)):
gridIndex = index * 2 + 1
if horizontal:
width = self._buttonBoxFrame.grid_bbox(gridIndex, 0)[2]
else:
width = self._buttonBoxFrame.grid_bbox(0, gridIndex)[2]
if width > max:
max = width
# Set the width of all the buttons to be the same.
if horizontal:
for index in range(len(self._buttonList)):
self._buttonBoxFrame.grid_columnconfigure(index * 2 + 1,
minsize = max)
else:
self._buttonBoxFrame.grid_columnconfigure(0, minsize = max)
######################################################################
### File: PmwEntryField.py
# Based on iwidgets2.2.0/entryfield.itk code.
import re
import string
import types
import Tkinter
# Possible return values of validation functions.
OK = 1
ERROR = 0
PARTIAL = -1
class EntryField(MegaWidget):
_classBindingsDefinedFor = 0
def __init__(self, parent = None, **kw):
# Define the megawidget options.
optiondefs = (
('command', None, None),
('errorbackground', 'pink', None),
('invalidcommand', self.bell, None),
('labelmargin', 0, INITOPT),
('labelpos', None, INITOPT),
('modifiedcommand', None, None),
('sticky', 'ew', INITOPT),
('validate', None, self._validate),
('extravalidators', {}, None),
('value', '', INITOPT),
)
self.defineoptions(kw, optiondefs)
# Initialise the base class (after defining the options).
MegaWidget.__init__(self, parent)
# Create the components.
interior = self.interior()
self._entryFieldEntry = self.createcomponent('entry',
(), None,
Tkinter.Entry, (interior,))
self._entryFieldEntry.grid(column=2, row=2, sticky=self['sticky'])
if self['value'] != '':
self.__setEntry(self['value'])
interior.grid_columnconfigure(2, weight=1)
interior.grid_rowconfigure(2, weight=1)
self.createlabel(interior)
# Initialise instance variables.
self.normalBackground = None
self._previousText = None
# Initialise instance.
_registerEntryField(self._entryFieldEntry, self)
# Establish the special class bindings if not already done.
# Also create bindings if the Tkinter default interpreter has
# changed. Use Tkinter._default_root to create class
# bindings, so that a reference to root is created by
# bind_class rather than a reference to self, which would
# prevent object cleanup.
if EntryField._classBindingsDefinedFor != Tkinter._default_root:
tagList = self._entryFieldEntry.bindtags()
root = Tkinter._default_root
allSequences = {}
for tag in tagList:
sequences = root.bind_class(tag)
if type(sequences) is types.StringType:
# In old versions of Tkinter, bind_class returns a string
sequences = root.tk.splitlist(sequences)
for sequence in sequences:
allSequences[sequence] = None
for sequence in allSequences.keys():
root.bind_class('EntryFieldPre', sequence, _preProcess)
root.bind_class('EntryFieldPost', sequence, _postProcess)
EntryField._classBindingsDefinedFor = root
self._entryFieldEntry.bindtags(('EntryFieldPre',) +
self._entryFieldEntry.bindtags() + ('EntryFieldPost',))
self._entryFieldEntry.bind('<Return>', self._executeCommand)
# Check keywords and initialise options.
self.initialiseoptions()
def destroy(self):
_deregisterEntryField(self._entryFieldEntry)
MegaWidget.destroy(self)
def _getValidatorFunc(self, validator, index):
# Search the extra and standard validator lists for the
# given 'validator'. If 'validator' is an alias, then
# continue the search using the alias. Make sure that
# self-referencial aliases do not cause infinite loops.
extraValidators = self['extravalidators']
traversedValidators = []
while 1:
traversedValidators.append(validator)
if extraValidators.has_key(validator):
validator = extraValidators[validator][index]
elif _standardValidators.has_key(validator):
validator = _standardValidators[validator][index]
else:
return validator
if validator in traversedValidators:
return validator
def _validate(self):
dict = {
'validator' : None,
'min' : None,
'max' : None,
'minstrict' : 1,
'maxstrict' : 1,
}
opt = self['validate']
if type(opt) is types.DictionaryType:
dict.update(opt)
else:
dict['validator'] = opt
# Look up validator maps and replace 'validator' field with
# the corresponding function.
validator = dict['validator']
valFunction = self._getValidatorFunc(validator, 0)
self._checkValidateFunction(valFunction, 'validate', validator)
dict['validator'] = valFunction
# Look up validator maps and replace 'stringtovalue' field
# with the corresponding function.
if dict.has_key('stringtovalue'):
stringtovalue = dict['stringtovalue']
strFunction = self._getValidatorFunc(stringtovalue, 1)
self._checkValidateFunction(
strFunction, 'stringtovalue', stringtovalue)
else:
strFunction = self._getValidatorFunc(validator, 1)
if strFunction == validator:
strFunction = len
dict['stringtovalue'] = strFunction
self._validationInfo = dict
args = dict.copy()
del args['validator']
del args['min']
del args['max']
del args['minstrict']
del args['maxstrict']
del args['stringtovalue']
self._validationArgs = args
self._previousText = None
if type(dict['min']) == types.StringType and strFunction is not None:
dict['min'] = apply(strFunction, (dict['min'],), args)
if type(dict['max']) == types.StringType and strFunction is not None:
dict['max'] = apply(strFunction, (dict['max'],), args)
self._checkValidity()
def _checkValidateFunction(self, function, option, validator):
# Raise an error if 'function' is not a function or None.
if function is not None and not callable(function):
extraValidators = self['extravalidators']
extra = extraValidators.keys()
extra.sort()
extra = tuple(extra)
standard = _standardValidators.keys()
standard.sort()
standard = tuple(standard)
msg = 'bad %s value "%s": must be a function or one of ' \
'the standard validators %s or extra validators %s'
raise ValueError, msg % (option, validator, standard, extra)
def _executeCommand(self, event = None):
cmd = self['command']
if callable(cmd):
if event is None:
# Return result of command for invoke() method.
return cmd()
else:
cmd()
def _preProcess(self):
self._previousText = self._entryFieldEntry.get()
self._previousICursor = self._entryFieldEntry.index('insert')
self._previousXview = self._entryFieldEntry.index('@0')
if self._entryFieldEntry.selection_present():
self._previousSel= (self._entryFieldEntry.index('sel.first'),
self._entryFieldEntry.index('sel.last'))
else:
self._previousSel = None
def _postProcess(self):
# No need to check if text has not changed.
previousText = self._previousText
if previousText == self._entryFieldEntry.get():
return self.valid()
valid = self._checkValidity()
if self.hulldestroyed():
# The invalidcommand called by _checkValidity() destroyed us.
return valid
cmd = self['modifiedcommand']
if callable(cmd) and previousText != self._entryFieldEntry.get():
cmd()
return valid
def checkentry(self):
# If there is a variable specified by the entry_textvariable
# option, checkentry() should be called after the set() method
# of the variable is called.
self._previousText = None
return self._postProcess()
def _getValidity(self):
text = self._entryFieldEntry.get()
dict = self._validationInfo
args = self._validationArgs
if dict['validator'] is not None:
status = apply(dict['validator'], (text,), args)
if status != OK:
return status
# Check for out of (min, max) range.
if dict['stringtovalue'] is not None:
min = dict['min']
max = dict['max']
if min is None and max is None:
return OK
val = apply(dict['stringtovalue'], (text,), args)
if min is not None and val < min:
if dict['minstrict']:
return ERROR
else:
return PARTIAL
if max is not None and val > max:
if dict['maxstrict']:
return ERROR
else:
return PARTIAL
return OK
def _checkValidity(self):
valid = self._getValidity()
oldValidity = valid
if valid == ERROR:
# The entry is invalid.
cmd = self['invalidcommand']
if callable(cmd):
cmd()
if self.hulldestroyed():
# The invalidcommand destroyed us.
return oldValidity
# Restore the entry to its previous value.
if self._previousText is not None:
self.__setEntry(self._previousText)
self._entryFieldEntry.icursor(self._previousICursor)
self._entryFieldEntry.xview(self._previousXview)
if self._previousSel is not None:
self._entryFieldEntry.selection_range(self._previousSel[0],
self._previousSel[1])
# Check if the saved text is valid as well.
valid = self._getValidity()
self._valid = valid
if self.hulldestroyed():
# The validator or stringtovalue commands called by
# _checkValidity() destroyed us.
return oldValidity
if valid == OK:
if self.normalBackground is not None:
self._entryFieldEntry.configure(
background = self.normalBackground)
self.normalBackground = None
else:
if self.normalBackground is None:
self.normalBackground = self._entryFieldEntry.cget('background')
self._entryFieldEntry.configure(
background = self['errorbackground'])
return oldValidity
def invoke(self):
return self._executeCommand()
def valid(self):
return self._valid == OK
def clear(self):
self.setentry('')
def __setEntry(self, text):
oldState = str(self._entryFieldEntry.cget('state'))
if oldState != 'normal':
self._entryFieldEntry.configure(state='normal')
self._entryFieldEntry.delete(0, 'end')
self._entryFieldEntry.insert(0, text)
if oldState != 'normal':
self._entryFieldEntry.configure(state=oldState)
def setentry(self, text):
self._preProcess()
self.__setEntry(text)
return self._postProcess()
def getvalue(self):
return self._entryFieldEntry.get()
def setvalue(self, text):
return self.setentry(text)
forwardmethods(EntryField, Tkinter.Entry, '_entryFieldEntry')
# ======================================================================
# Entry field validation functions
_numericregex = re.compile('^[0-9]*$')
_alphabeticregex = re.compile('^[a-z]*$', re.IGNORECASE)
_alphanumericregex = re.compile('^[0-9a-z]*$', re.IGNORECASE)
def numericvalidator(text):
if text == '':
return PARTIAL
else:
if _numericregex.match(text) is None:
return ERROR
else:
return OK
def integervalidator(text):
if text in ('', '-', '+'):
return PARTIAL
try:
string.atol(text)
return OK
except ValueError:
return ERROR
def alphabeticvalidator(text):
if _alphabeticregex.match(text) is None:
return ERROR
else:
return OK
def alphanumericvalidator(text):
if _alphanumericregex.match(text) is None:
return ERROR
else:
return OK
def hexadecimalvalidator(text):
if text in ('', '0x', '0X', '+', '+0x', '+0X', '-', '-0x', '-0X'):
return PARTIAL
try:
string.atol(text, 16)
return OK
except ValueError:
return ERROR
def realvalidator(text, separator = '.'):
if separator != '.':
if string.find(text, '.') >= 0:
return ERROR
index = string.find(text, separator)
if index >= 0:
text = text[:index] + '.' + text[index + 1:]
try:
string.atof(text)
return OK
except ValueError:
# Check if the string could be made valid by appending a digit
# eg ('-', '+', '.', '-.', '+.', '1.23e', '1E-').
if len(text) == 0:
return PARTIAL
if text[-1] in string.digits:
return ERROR
try:
string.atof(text + '0')
return PARTIAL
except ValueError:
return ERROR
def timevalidator(text, separator = ':'):
try:
timestringtoseconds(text, separator)
return OK
except ValueError:
if len(text) > 0 and text[0] in ('+', '-'):
text = text[1:]
if re.search('[^0-9' + separator + ']', text) is not None:
return ERROR
return PARTIAL
def datevalidator(text, format = 'ymd', separator = '/'):
try:
datestringtojdn(text, format, separator)
return OK
except ValueError:
if re.search('[^0-9' + separator + ']', text) is not None:
return ERROR
return PARTIAL
_standardValidators = {
'numeric' : (numericvalidator, string.atol),
'integer' : (integervalidator, string.atol),
'hexadecimal' : (hexadecimalvalidator, lambda s: string.atol(s, 16)),
'real' : (realvalidator, stringtoreal),
'alphabetic' : (alphabeticvalidator, len),
'alphanumeric' : (alphanumericvalidator, len),
'time' : (timevalidator, timestringtoseconds),
'date' : (datevalidator, datestringtojdn),
}
_entryCache = {}
def _registerEntryField(entry, entryField):
# Register an EntryField widget for an Entry widget
_entryCache[entry] = entryField
def _deregisterEntryField(entry):
# Deregister an Entry widget
del _entryCache[entry]
def _preProcess(event):
# Forward preprocess events for an Entry to it's EntryField
_entryCache[event.widget]._preProcess()
def _postProcess(event):
# Forward postprocess events for an Entry to it's EntryField
# The function specified by the 'command' option may have destroyed
# the megawidget in a binding earlier in bindtags, so need to check.
if _entryCache.has_key(event.widget):
_entryCache[event.widget]._postProcess()
######################################################################
### File: PmwGroup.py
import string
import Tkinter
def aligngrouptags(groups):
# Adjust the y position of the tags in /groups/ so that they all
# have the height of the highest tag.
maxTagHeight = 0
for group in groups:
if group._tag is None:
height = (string.atoi(str(group._ring.cget('borderwidth'))) +
string.atoi(str(group._ring.cget('highlightthickness'))))
else:
height = group._tag.winfo_reqheight()
if maxTagHeight < height:
maxTagHeight = height
for group in groups:
ringBorder = (string.atoi(str(group._ring.cget('borderwidth'))) +
string.atoi(str(group._ring.cget('highlightthickness'))))
topBorder = maxTagHeight / 2 - ringBorder / 2
group._hull.grid_rowconfigure(0, minsize = topBorder)
group._ring.grid_rowconfigure(0,
minsize = maxTagHeight - topBorder - ringBorder)
if group._tag is not None:
group._tag.place(y = maxTagHeight / 2)
class Group( MegaWidget ):
def __init__(self, parent = None, **kw):
# Define the megawidget options.
optiondefs = (
('collapsedsize', 6, INITOPT),
('ring_borderwidth', 2, None),
('ring_relief', 'groove', None),
('tagindent', 10, INITOPT),
)
self.defineoptions(kw, optiondefs)
# Initialise the base class (after defining the options).
MegaWidget.__init__(self, parent)
# Create the components.
interior = MegaWidget.interior(self)
self._ring = self.createcomponent(
'ring',
(), None,
Tkinter.Frame, (interior,),
)
self._groupChildSite = self.createcomponent(
'groupchildsite',
(), None,
Tkinter.Frame, (self._ring,)
)
self._tag = self.createcomponent(
'tag',
(), None,
Tkinter.Label, (interior,),
)
ringBorder = (string.atoi(str(self._ring.cget('borderwidth'))) +
string.atoi(str(self._ring.cget('highlightthickness'))))
if self._tag is None:
tagHeight = ringBorder
else:
tagHeight = self._tag.winfo_reqheight()
self._tag.place(
x = ringBorder + self['tagindent'],
y = tagHeight / 2,
anchor = 'w')
topBorder = tagHeight / 2 - ringBorder / 2
self._ring.grid(column = 0, row = 1, sticky = 'nsew')
interior.grid_columnconfigure(0, weight = 1)
interior.grid_rowconfigure(1, weight = 1)
interior.grid_rowconfigure(0, minsize = topBorder)
self._groupChildSite.grid(column = 0, row = 1, sticky = 'nsew')
self._ring.grid_columnconfigure(0, weight = 1)
self._ring.grid_rowconfigure(1, weight = 1)
self._ring.grid_rowconfigure(0,
minsize = tagHeight - topBorder - ringBorder)
self.showing = 1
# Check keywords and initialise options.
self.initialiseoptions()
def toggle(self):
if self.showing:
self.collapse()
else:
self.expand()
self.showing = not self.showing
def expand(self):
self._groupChildSite.grid(column = 0, row = 1, sticky = 'nsew')
def collapse(self):
self._groupChildSite.grid_forget()
if self._tag is None:
tagHeight = 0
else:
tagHeight = self._tag.winfo_reqheight()
self._ring.configure(height=(tagHeight / 2) + self['collapsedsize'])
def interior(self):
return self._groupChildSite
######################################################################
### File: PmwLabeledWidget.py
import Tkinter
class LabeledWidget(MegaWidget):
def __init__(self, parent = None, **kw):
# Define the megawidget options.
optiondefs = (
('labelmargin', 0, INITOPT),
('labelpos', None, INITOPT),
('sticky', 'nsew', INITOPT),
)
self.defineoptions(kw, optiondefs)
# Initialise the base class (after defining the options).
MegaWidget.__init__(self, parent)
# Create the components.
interior = MegaWidget.interior(self)
self._labelChildSite = self.createcomponent('labelchildsite',
(), None,
Tkinter.Frame, (interior,))
self._labelChildSite.grid(column=2, row=2, sticky=self['sticky'])
interior.grid_columnconfigure(2, weight=1)
interior.grid_rowconfigure(2, weight=1)
self.createlabel(interior)
# Check keywords and initialise options.
self.initialiseoptions()
def interior(self):
return self._labelChildSite
######################################################################
### File: PmwMainMenuBar.py
# Main menubar
import string
import types
import Tkinter
class MainMenuBar(MegaArchetype):
def __init__(self, parent = None, **kw):
# Define the megawidget options.
optiondefs = (
('balloon', None, None),
('hotkeys', 1, INITOPT),
('hull_tearoff', 0, None),
)
self.defineoptions(kw, optiondefs, dynamicGroups = ('Menu',))
# Initialise the base class (after defining the options).
MegaArchetype.__init__(self, parent, Tkinter.Menu)
self._menuInfo = {}
self._menuInfo[None] = (None, [])
# Map from a menu name to a tuple of information about the menu.
# The first item in the tuple is the name of the parent menu (for
# toplevel menus this is None). The second item in the tuple is
# a list of status help messages for each item in the menu.
# The key for the information for the main menubar is None.
self._menu = self.interior()
self._menu.bind('<Leave>', self._resetHelpmessage)
self._menu.bind('<Motion>',
lambda event=None, self=self: self._menuHelp(event, None))
# Check keywords and initialise options.
self.initialiseoptions()
def deletemenuitems(self, menuName, start, end = None):
self.component(menuName).delete(start, end)
if end is None:
del self._menuInfo[menuName][1][start]
else:
self._menuInfo[menuName][1][start:end+1] = []
def deletemenu(self, menuName):
"""Delete should be called for cascaded menus before main menus.
"""
parentName = self._menuInfo[menuName][0]
del self._menuInfo[menuName]
if parentName is None:
parentMenu = self._menu
else:
parentMenu = self.component(parentName)
menu = self.component(menuName)
menuId = str(menu)
for item in range(parentMenu.index('end') + 1):
if parentMenu.type(item) == 'cascade':
itemMenu = str(parentMenu.entrycget(item, 'menu'))
if itemMenu == menuId:
parentMenu.delete(item)
del self._menuInfo[parentName][1][item]
break
self.destroycomponent(menuName)
def disableall(self):
for index in range(len(self._menuInfo[None][1])):
self.entryconfigure(index, state = 'disabled')
def enableall(self):
for index in range(len(self._menuInfo[None][1])):
self.entryconfigure(index, state = 'normal')
def addmenu(self, menuName, balloonHelp, statusHelp = None,
traverseSpec = None, **kw):
if statusHelp is None:
statusHelp = balloonHelp
self._addmenu(None, menuName, balloonHelp, statusHelp,
traverseSpec, kw)
def addcascademenu(self, parentMenuName, menuName, statusHelp='',
traverseSpec = None, **kw):
self._addmenu(parentMenuName, menuName, None, statusHelp,
traverseSpec, kw)
def _addmenu(self, parentMenuName, menuName, balloonHelp, statusHelp,
traverseSpec, kw):
if (menuName) in self.components():
raise ValueError, 'menu "%s" already exists' % menuName
menukw = {}
if kw.has_key('tearoff'):
menukw['tearoff'] = kw['tearoff']
del kw['tearoff']
else:
menukw['tearoff'] = 0
if kw.has_key('name'):
menukw['name'] = kw['name']
del kw['name']
if not kw.has_key('label'):
kw['label'] = menuName
self._addHotkeyToOptions(parentMenuName, kw, traverseSpec)
if parentMenuName is None:
parentMenu = self._menu
balloon = self['balloon']
# Bug in Tk: balloon help not implemented
# if balloon is not None:
# balloon.mainmenubind(parentMenu, balloonHelp, statusHelp)
else:
parentMenu = self.component(parentMenuName)
apply(parentMenu.add_cascade, (), kw)
menu = apply(self.createcomponent, (menuName,
(), 'Menu',
Tkinter.Menu, (parentMenu,)), menukw)
parentMenu.entryconfigure('end', menu = menu)
self._menuInfo[parentMenuName][1].append(statusHelp)
self._menuInfo[menuName] = (parentMenuName, [])
menu.bind('<Leave>', self._resetHelpmessage)
menu.bind('<Motion>',
lambda event=None, self=self, menuName=menuName:
self._menuHelp(event, menuName))
def addmenuitem(self, menuName, itemType, statusHelp = '',
traverseSpec = None, **kw):
menu = self.component(menuName)
if itemType != 'separator':
self._addHotkeyToOptions(menuName, kw, traverseSpec)
if itemType == 'command':
command = menu.add_command
elif itemType == 'separator':
command = menu.add_separator
elif itemType == 'checkbutton':
command = menu.add_checkbutton
elif itemType == 'radiobutton':
command = menu.add_radiobutton
elif itemType == 'cascade':
command = menu.add_cascade
else:
raise ValueError, 'unknown menuitem type "%s"' % itemType
self._menuInfo[menuName][1].append(statusHelp)
apply(command, (), kw)
def _addHotkeyToOptions(self, menuName, kw, traverseSpec):
if (not self['hotkeys'] or kw.has_key('underline') or
not kw.has_key('label')):
return
if type(traverseSpec) == types.IntType:
kw['underline'] = traverseSpec
return
if menuName is None:
menu = self._menu
else:
menu = self.component(menuName)
hotkeyList = []
end = menu.index('end')
if end is not None:
for item in range(end + 1):
if menu.type(item) not in ('separator', 'tearoff'):
underline = \
string.atoi(str(menu.entrycget(item, 'underline')))
if underline != -1:
label = str(menu.entrycget(item, 'label'))
if underline < len(label):
hotkey = string.lower(label[underline])
if hotkey not in hotkeyList:
hotkeyList.append(hotkey)
name = kw['label']
if type(traverseSpec) == types.StringType:
lowerLetter = string.lower(traverseSpec)
if traverseSpec in name and lowerLetter not in hotkeyList:
kw['underline'] = string.index(name, traverseSpec)
else:
targets = string.digits + string.letters
lowerName = string.lower(name)
for letter_index in range(len(name)):
letter = lowerName[letter_index]
if letter in targets and letter not in hotkeyList:
kw['underline'] = letter_index
break
def _menuHelp(self, event, menuName):
if menuName is None:
menu = self._menu
index = menu.index('@%d'% event.x)
else:
menu = self.component(menuName)
index = menu.index('@%d'% event.y)
balloon = self['balloon']
if balloon is not None:
if index is None:
balloon.showstatus('')
else:
if str(menu.cget('tearoff')) == '1':
index = index - 1
if index >= 0:
help = self._menuInfo[menuName][1][index]
balloon.showstatus(help)
def _resetHelpmessage(self, event=None):
balloon = self['balloon']
if balloon is not None:
balloon.clearstatus()
forwardmethods(MainMenuBar, Tkinter.Menu, '_hull')
######################################################################
### File: PmwMenuBar.py
# Manager widget for menus.
import string
import types
import Tkinter
class MenuBar(MegaWidget):
def __init__(self, parent = None, **kw):
# Define the megawidget options.
optiondefs = (
('balloon', None, None),
('hotkeys', 1, INITOPT),
('padx', 0, INITOPT),
)
self.defineoptions(kw, optiondefs, dynamicGroups = ('Menu', 'Button'))
# Initialise the base class (after defining the options).
MegaWidget.__init__(self, parent)
self._menuInfo = {}
# Map from a menu name to a tuple of information about the menu.
# The first item in the tuple is the name of the parent menu (for
# toplevel menus this is None). The second item in the tuple is
# a list of status help messages for each item in the menu.
# The third item in the tuple is the id of the binding used
# to detect mouse motion to display status help.
# Information for the toplevel menubuttons is not stored here.
self._mydeletecommand = self.component('hull').tk.deletecommand
# Cache this method for use later.
# Check keywords and initialise options.
self.initialiseoptions()
def deletemenuitems(self, menuName, start, end = None):
self.component(menuName + '-menu').delete(start, end)
if end is None:
del self._menuInfo[menuName][1][start]
else:
self._menuInfo[menuName][1][start:end+1] = []
def deletemenu(self, menuName):
"""Delete should be called for cascaded menus before main menus.
"""
# Clean up binding for this menu.
parentName = self._menuInfo[menuName][0]
bindId = self._menuInfo[menuName][2]
_bindtag = 'PmwMenuBar' + str(self) + menuName
self.unbind_class(_bindtag, '<Motion>')
self._mydeletecommand(bindId) # unbind_class does not clean up
del self._menuInfo[menuName]
if parentName is None:
self.destroycomponent(menuName + '-button')
else:
parentMenu = self.component(parentName + '-menu')
menu = self.component(menuName + '-menu')
menuId = str(menu)
for item in range(parentMenu.index('end') + 1):
if parentMenu.type(item) == 'cascade':
itemMenu = str(parentMenu.entrycget(item, 'menu'))
if itemMenu == menuId:
parentMenu.delete(item)
del self._menuInfo[parentName][1][item]
break
self.destroycomponent(menuName + '-menu')
def disableall(self):
for menuName in self._menuInfo.keys():
if self._menuInfo[menuName][0] is None:
menubutton = self.component(menuName + '-button')
menubutton.configure(state = 'disabled')
def enableall(self):
for menuName in self._menuInfo.keys():
if self._menuInfo[menuName][0] is None:
menubutton = self.component(menuName + '-button')
menubutton.configure(state = 'normal')
def addmenu(self, menuName, balloonHelp, statusHelp = None,
side = 'left', traverseSpec = None, **kw):
self._addmenu(None, menuName, balloonHelp, statusHelp,
traverseSpec, side, 'text', kw)
def addcascademenu(self, parentMenuName, menuName, statusHelp = '',
traverseSpec = None, **kw):
self._addmenu(parentMenuName, menuName, None, statusHelp,
traverseSpec, None, 'label', kw)
def _addmenu(self, parentMenuName, menuName, balloonHelp, statusHelp,
traverseSpec, side, textKey, kw):
if (menuName + '-menu') in self.components():
raise ValueError, 'menu "%s" already exists' % menuName
menukw = {}
if kw.has_key('tearoff'):
menukw['tearoff'] = kw['tearoff']
del kw['tearoff']
else:
menukw['tearoff'] = 0
if not kw.has_key(textKey):
kw[textKey] = menuName
self._addHotkeyToOptions(parentMenuName, kw, textKey, traverseSpec)
if parentMenuName is None:
button = apply(self.createcomponent, (menuName + '-button',
(), 'Button',
Tkinter.Menubutton, (self.interior(),)), kw)
button.pack(side=side, padx = self['padx'])
balloon = self['balloon']
if balloon is not None:
balloon.bind(button, balloonHelp, statusHelp)
parentMenu = button
else:
parentMenu = self.component(parentMenuName + '-menu')
apply(parentMenu.add_cascade, (), kw)
self._menuInfo[parentMenuName][1].append(statusHelp)
menu = apply(self.createcomponent, (menuName + '-menu',
(), 'Menu',
Tkinter.Menu, (parentMenu,)), menukw)
if parentMenuName is None:
button.configure(menu = menu)
else:
parentMenu.entryconfigure('end', menu = menu)
# Need to put this binding after the class bindings so that
# menu.index() does not lag behind.
_bindtag = 'PmwMenuBar' + str(self) + menuName
bindId = self.bind_class(_bindtag, '<Motion>',
lambda event=None, self=self, menuName=menuName:
self._menuHelp(menuName))
menu.bindtags(menu.bindtags() + (_bindtag,))
menu.bind('<Leave>', self._resetHelpmessage)
self._menuInfo[menuName] = (parentMenuName, [], bindId)
def addmenuitem(self, menuName, itemType, statusHelp = '',
traverseSpec = None, **kw):
menu = self.component(menuName + '-menu')
if itemType != 'separator':
self._addHotkeyToOptions(menuName, kw, 'label', traverseSpec)
if itemType == 'command':
command = menu.add_command
elif itemType == 'separator':
command = menu.add_separator
elif itemType == 'checkbutton':
command = menu.add_checkbutton
elif itemType == 'radiobutton':
command = menu.add_radiobutton
elif itemType == 'cascade':
command = menu.add_cascade
else:
raise ValueError, 'unknown menuitem type "%s"' % itemType
self._menuInfo[menuName][1].append(statusHelp)
apply(command, (), kw)
def _addHotkeyToOptions(self, menuName, kw, textKey, traverseSpec):
if (not self['hotkeys'] or kw.has_key('underline') or
not kw.has_key(textKey)):
return
if type(traverseSpec) == types.IntType:
kw['underline'] = traverseSpec
return
hotkeyList = []
if menuName is None:
for menuName in self._menuInfo.keys():
if self._menuInfo[menuName][0] is None:
menubutton = self.component(menuName + '-button')
underline = string.atoi(str(menubutton.cget('underline')))
if underline != -1:
label = str(menubutton.cget(textKey))
if underline < len(label):
hotkey = string.lower(label[underline])
if hotkey not in hotkeyList:
hotkeyList.append(hotkey)
else:
menu = self.component(menuName + '-menu')
end = menu.index('end')
if end is not None:
for item in range(end + 1):
if menu.type(item) not in ('separator', 'tearoff'):
underline = string.atoi(
str(menu.entrycget(item, 'underline')))
if underline != -1:
label = str(menu.entrycget(item, textKey))
if underline < len(label):
hotkey = string.lower(label[underline])
if hotkey not in hotkeyList:
hotkeyList.append(hotkey)
name = kw[textKey]
if type(traverseSpec) == types.StringType:
lowerLetter = string.lower(traverseSpec)
if traverseSpec in name and lowerLetter not in hotkeyList:
kw['underline'] = string.index(name, traverseSpec)
else:
targets = string.digits + string.letters
lowerName = string.lower(name)
for letter_index in range(len(name)):
letter = lowerName[letter_index]
if letter in targets and letter not in hotkeyList:
kw['underline'] = letter_index
break
def _menuHelp(self, menuName):
menu = self.component(menuName + '-menu')
index = menu.index('active')
balloon = self['balloon']
if balloon is not None:
if index is None:
balloon.showstatus('')
else:
if str(menu.cget('tearoff')) == '1':
index = index - 1
if index >= 0:
help = self._menuInfo[menuName][1][index]
balloon.showstatus(help)
def _resetHelpmessage(self, event=None):
balloon = self['balloon']
if balloon is not None:
balloon.clearstatus()
######################################################################
### File: PmwMessageBar.py
# Class to display messages in an information line.
import string
import Tkinter
class MessageBar(MegaWidget):
def __init__(self, parent = None, **kw):
# Define the megawidget options.
defaultMessageTypes = {
# (priority, showtime, bells, logmessage)
'systemerror' : (5, 10, 2, 1),
'usererror' : (4, 5, 1, 0),
'busy' : (3, 0, 0, 0),
'systemevent' : (2, 5, 0, 0),
'userevent' : (2, 5, 0, 0),
'help' : (1, 5, 0, 0),
'state' : (0, 0, 0, 0),
}
optiondefs = (
('labelmargin', 0, INITOPT),
('labelpos', None, INITOPT),
('messagetypes', defaultMessageTypes, INITOPT),
('silent', 0, None),
('sticky', 'ew', INITOPT),
)
self.defineoptions(kw, optiondefs)
# Initialise the base class (after defining the options).
MegaWidget.__init__(self, parent)
# Create the components.
interior = self.interior()
self._messageBarEntry = self.createcomponent('entry',
(), None,
Tkinter.Entry, (interior,))
# Can't always use 'disabled', since this greys out text in Tk 8.4.2
try:
self._messageBarEntry.configure(state = 'readonly')
except Tkinter.TclError:
self._messageBarEntry.configure(state = 'disabled')
self._messageBarEntry.grid(column=2, row=2, sticky=self['sticky'])
interior.grid_columnconfigure(2, weight=1)
interior.grid_rowconfigure(2, weight=1)
self.createlabel(interior)
# Initialise instance variables.
self._numPriorities = 0
for info in self['messagetypes'].values():
if self._numPriorities < info[0]:
self._numPriorities = info[0]
self._numPriorities = self._numPriorities + 1
self._timer = [None] * self._numPriorities
self._messagetext = [''] * self._numPriorities
self._activemessage = [0] * self._numPriorities
# Check keywords and initialise options.
self.initialiseoptions()
def destroy(self):
for timerId in self._timer:
if timerId is not None:
self.after_cancel(timerId)
self._timer = [None] * self._numPriorities
MegaWidget.destroy(self)
def message(self, type, text):
# Display a message in the message bar.
(priority, showtime, bells, logmessage) = self['messagetypes'][type]
if not self['silent']:
for i in range(bells):
if i != 0:
self.after(100)
self.bell()
self._activemessage[priority] = 1
if text is None:
text = ''
self._messagetext[priority] = string.replace(text, '\n', ' ')
self._redisplayInfoMessage()
if logmessage:
# Should log this text to a text widget.
pass
if showtime > 0:
if self._timer[priority] is not None:
self.after_cancel(self._timer[priority])
# Define a callback to clear this message after a time.
def _clearmessage(self=self, priority=priority):
self._clearActivemessage(priority)
mseconds = int(showtime * 1000)
self._timer[priority] = self.after(mseconds, _clearmessage)
def helpmessage(self, text):
if text is None:
self.resetmessages('help')
else:
self.message('help', text)
def resetmessages(self, type):
priority = self['messagetypes'][type][0]
self._clearActivemessage(priority)
for messagetype, info in self['messagetypes'].items():
thisPriority = info[0]
showtime = info[1]
if thisPriority < priority and showtime != 0:
self._clearActivemessage(thisPriority)
def _clearActivemessage(self, priority):
self._activemessage[priority] = 0
if self._timer[priority] is not None:
self.after_cancel(self._timer[priority])
self._timer[priority] = None
self._redisplayInfoMessage()
def _redisplayInfoMessage(self):
text = ''
for priority in range(self._numPriorities - 1, -1, -1):
if self._activemessage[priority]:
text = self._messagetext[priority]
break
self._messageBarEntry.configure(state = 'normal')
self._messageBarEntry.delete(0, 'end')
self._messageBarEntry.insert('end', text)
# Can't always use 'disabled', since this greys out text in Tk 8.4.2
try:
self._messageBarEntry.configure(state = 'readonly')
except Tkinter.TclError:
self._messageBarEntry.configure(state = 'disabled')
forwardmethods(MessageBar, Tkinter.Entry, '_messageBarEntry')
######################################################################
### File: PmwMessageDialog.py
# Based on iwidgets2.2.0/messagedialog.itk code.
import Tkinter
class MessageDialog(Dialog):
def __init__(self, parent = None, **kw):
# Define the megawidget options.
optiondefs = (
('borderx', 20, INITOPT),
('bordery', 20, INITOPT),
('iconmargin', 20, INITOPT),
('iconpos', None, INITOPT),
)
self.defineoptions(kw, optiondefs)
# Initialise the base class (after defining the options).
Dialog.__init__(self, parent)
# Create the components.
interior = self.interior()
self._message = self.createcomponent('message',
(), None,
Tkinter.Label, (interior,))
iconpos = self['iconpos']
iconmargin = self['iconmargin']
borderx = self['borderx']
bordery = self['bordery']
border_right = 2
border_bottom = 2
if iconpos is None:
self._message.grid(column = 1, row = 1)
else:
self._icon = self.createcomponent('icon',
(), None,
Tkinter.Label, (interior,))
if iconpos not in 'nsew':
raise ValueError, \
'bad iconpos option "%s": should be n, s, e, or w' \
% iconpos
if iconpos in 'nw':
icon = 1
message = 3
else:
icon = 3
message = 1
if iconpos in 'ns':
# vertical layout
self._icon.grid(column = 1, row = icon)
self._message.grid(column = 1, row = message)
interior.grid_rowconfigure(2, minsize = iconmargin)
border_bottom = 4
else:
# horizontal layout
self._icon.grid(column = icon, row = 1)
self._message.grid(column = message, row = 1)
interior.grid_columnconfigure(2, minsize = iconmargin)
border_right = 4
interior.grid_columnconfigure(0, minsize = borderx)
interior.grid_rowconfigure(0, minsize = bordery)
interior.grid_columnconfigure(border_right, minsize = borderx)
interior.grid_rowconfigure(border_bottom, minsize = bordery)
# Check keywords and initialise options.
self.initialiseoptions()
######################################################################
### File: PmwNoteBook.py
import string
import types
import Tkinter
class NoteBook(MegaArchetype):
def __init__(self, parent = None, **kw):
# Define the megawidget options.
optiondefs = (
('hull_highlightthickness', 0, None),
('hull_borderwidth', 0, None),
('arrownavigation', 1, INITOPT),
('borderwidth', 2, INITOPT),
('createcommand', None, None),
('lowercommand', None, None),
('pagemargin', 4, INITOPT),
('raisecommand', None, None),
('tabpos', 'n', INITOPT),
)
self.defineoptions(kw, optiondefs, dynamicGroups = ('Page', 'Tab'))
# Initialise the base class (after defining the options).
MegaArchetype.__init__(self, parent, Tkinter.Canvas)
self.bind('<Map>', self._handleMap)
self.bind('<Configure>', self._handleConfigure)
tabpos = self['tabpos']
if tabpos is not None and tabpos != 'n':
raise ValueError, \
'bad tabpos option %s: should be n or None' % repr(tabpos)
self._withTabs = (tabpos is not None)
self._pageMargin = self['pagemargin']
self._borderWidth = self['borderwidth']
# Use a dictionary as a set of bits indicating what needs to
# be redisplayed the next time _layout() is called. If
# dictionary contains 'topPage' key, the value is the new top
# page to be displayed. None indicates that all pages have
# been deleted and that _layout() should draw a border under where
# the tabs should be.
self._pending = {}
self._pending['size'] = 1
self._pending['borderColor'] = 1
self._pending['topPage'] = None
if self._withTabs:
self._pending['tabs'] = 1
self._canvasSize = None # This gets set by <Configure> events
# Set initial height of space for tabs
if self._withTabs:
self.tabBottom = 35
else:
self.tabBottom = 0
self._lightBorderColor, self._darkBorderColor = \
Color.bordercolors(self, self['hull_background'])
self._pageNames = [] # List of page names
# Map from page name to page info. Each item is itself a
# dictionary containing the following items:
# page the Tkinter.Frame widget for the page
# created set to true the first time the page is raised
# tabbutton the Tkinter.Button widget for the button (if any)
# tabreqwidth requested width of the tab
# tabreqheight requested height of the tab
# tabitems the canvas items for the button: the button
# window item, the lightshadow and the darkshadow
# left the left and right canvas coordinates of the tab
# right
self._pageAttrs = {}
# Name of page currently on top (actually displayed, using
# create_window, not pending). Ignored if current top page
# has been deleted or new top page is pending. None indicates
# no pages in notebook.
self._topPageName = None
# Canvas items used:
# Per tab:
# top and left shadow
# right shadow
# button
# Per notebook:
# page
# top page
# left shadow
# bottom and right shadow
# top (one or two items)
# Canvas tags used:
# lighttag - top and left shadows of tabs and page
# darktag - bottom and right shadows of tabs and page
# (if no tabs then these are reversed)
# (used to color the borders by recolorborders)
# Create page border shadows.
if self._withTabs:
self._pageLeftBorder = self.create_polygon(0, 0, 0, 0, 0, 0,
fill = self._lightBorderColor, tags = 'lighttag')
self._pageBottomRightBorder = self.create_polygon(0, 0, 0, 0, 0, 0,
fill = self._darkBorderColor, tags = 'darktag')
self._pageTop1Border = self.create_polygon(0, 0, 0, 0, 0, 0,
fill = self._darkBorderColor, tags = 'lighttag')
self._pageTop2Border = self.create_polygon(0, 0, 0, 0, 0, 0,
fill = self._darkBorderColor, tags = 'lighttag')
else:
self._pageLeftBorder = self.create_polygon(0, 0, 0, 0, 0, 0,
fill = self._darkBorderColor, tags = 'darktag')
self._pageBottomRightBorder = self.create_polygon(0, 0, 0, 0, 0, 0,
fill = self._lightBorderColor, tags = 'lighttag')
self._pageTopBorder = self.create_polygon(0, 0, 0, 0, 0, 0,
fill = self._darkBorderColor, tags = 'darktag')
# Check keywords and initialise options.
self.initialiseoptions()
def insert(self, pageName, before = 0, **kw):
if self._pageAttrs.has_key(pageName):
msg = 'Page "%s" already exists.' % pageName
raise ValueError, msg
# Do this early to catch bad <before> spec before creating any items.
beforeIndex = self.index(before, 1)
pageOptions = {}
if self._withTabs:
# Default tab button options.
tabOptions = {
'text' : pageName,
'borderwidth' : 0,
}
# Divide the keyword options into the 'page_' and 'tab_' options.
for key in kw.keys():
if key[:5] == 'page_':
pageOptions[key[5:]] = kw[key]
del kw[key]
elif self._withTabs and key[:4] == 'tab_':
tabOptions[key[4:]] = kw[key]
del kw[key]
else:
raise KeyError, 'Unknown option "' + key + '"'
# Create the frame to contain the page.
page = apply(self.createcomponent, (pageName,
(), 'Page',
Tkinter.Frame, self._hull), pageOptions)
attributes = {}
attributes['page'] = page
attributes['created'] = 0
if self._withTabs:
# Create the button for the tab.
def raiseThisPage(self = self, pageName = pageName):
self.selectpage(pageName)
tabOptions['command'] = raiseThisPage
tab = apply(self.createcomponent, (pageName + '-tab',
(), 'Tab',
Tkinter.Button, self._hull), tabOptions)
if self['arrownavigation']:
# Allow the use of the arrow keys for Tab navigation:
def next(event, self = self, pageName = pageName):
self.nextpage(pageName)
def prev(event, self = self, pageName = pageName):
self.previouspage(pageName)
tab.bind('<Left>', prev)
tab.bind('<Right>', next)
attributes['tabbutton'] = tab
attributes['tabreqwidth'] = tab.winfo_reqwidth()
attributes['tabreqheight'] = tab.winfo_reqheight()
# Create the canvas item to manage the tab's button and the items
# for the tab's shadow.
windowitem = self.create_window(0, 0, window = tab, anchor = 'nw')
lightshadow = self.create_polygon(0, 0, 0, 0, 0, 0,
tags = 'lighttag', fill = self._lightBorderColor)
darkshadow = self.create_polygon(0, 0, 0, 0, 0, 0,
tags = 'darktag', fill = self._darkBorderColor)
attributes['tabitems'] = (windowitem, lightshadow, darkshadow)
self._pending['tabs'] = 1
self._pageAttrs[pageName] = attributes
self._pageNames.insert(beforeIndex, pageName)
# If this is the first page added, make it the new top page
# and call the create and raise callbacks.
if self.getcurselection() is None:
self._pending['topPage'] = pageName
self._raiseNewTop(pageName)
self._layout()
return page
def add(self, pageName, **kw):
return apply(self.insert, (pageName, len(self._pageNames)), kw)
def delete(self, *pageNames):
newTopPage = 0
for page in pageNames:
pageIndex = self.index(page)
pageName = self._pageNames[pageIndex]
pageInfo = self._pageAttrs[pageName]
if self.getcurselection() == pageName:
if len(self._pageNames) == 1:
newTopPage = 0
self._pending['topPage'] = None
elif pageIndex == len(self._pageNames) - 1:
newTopPage = 1
self._pending['topPage'] = self._pageNames[pageIndex - 1]
else:
newTopPage = 1
self._pending['topPage'] = self._pageNames[pageIndex + 1]
if self._topPageName == pageName:
self._hull.delete(self._topPageItem)
self._topPageName = None
if self._withTabs:
self.destroycomponent(pageName + '-tab')
apply(self._hull.delete, pageInfo['tabitems'])
self.destroycomponent(pageName)
del self._pageAttrs[pageName]
del self._pageNames[pageIndex]
# If the old top page was deleted and there are still pages
# left in the notebook, call the create and raise callbacks.
if newTopPage:
pageName = self._pending['topPage']
self._raiseNewTop(pageName)
if self._withTabs:
self._pending['tabs'] = 1
self._layout()
def page(self, pageIndex):
pageName = self._pageNames[self.index(pageIndex)]
return self._pageAttrs[pageName]['page']
def pagenames(self):
return list(self._pageNames)
def getcurselection(self):
if self._pending.has_key('topPage'):
return self._pending['topPage']
else:
return self._topPageName
def tab(self, pageIndex):
if self._withTabs:
pageName = self._pageNames[self.index(pageIndex)]
return self._pageAttrs[pageName]['tabbutton']
else:
return None
def index(self, index, forInsert = 0):
listLength = len(self._pageNames)
if type(index) == types.IntType:
if forInsert and index <= listLength:
return index
elif not forInsert and index < listLength:
return index
else:
raise ValueError, 'index "%s" is out of range' % index
elif index is END:
if forInsert:
return listLength
elif listLength > 0:
return listLength - 1
else:
raise ValueError, 'NoteBook has no pages'
elif index is SELECT:
if listLength == 0:
raise ValueError, 'NoteBook has no pages'
return self._pageNames.index(self.getcurselection())
else:
if index in self._pageNames:
return self._pageNames.index(index)
validValues = 'a name, a number, END or SELECT'
raise ValueError, \
'bad index "%s": must be %s' % (index, validValues)
def selectpage(self, page):
pageName = self._pageNames[self.index(page)]
oldTopPage = self.getcurselection()
if pageName != oldTopPage:
self._pending['topPage'] = pageName
if oldTopPage == self._topPageName:
self._hull.delete(self._topPageItem)
cmd = self['lowercommand']
if cmd is not None:
cmd(oldTopPage)
self._raiseNewTop(pageName)
self._layout()
# Set focus to the tab of new top page:
if self._withTabs and self['arrownavigation']:
self._pageAttrs[pageName]['tabbutton'].focus_set()
def previouspage(self, pageIndex = None):
if pageIndex is None:
curpage = self.index(SELECT)
else:
curpage = self.index(pageIndex)
if curpage > 0:
self.selectpage(curpage - 1)
def nextpage(self, pageIndex = None):
if pageIndex is None:
curpage = self.index(SELECT)
else:
curpage = self.index(pageIndex)
if curpage < len(self._pageNames) - 1:
self.selectpage(curpage + 1)
def setnaturalsize(self, pageNames = None):
self.update_idletasks()
maxPageWidth = 1
maxPageHeight = 1
if pageNames is None:
pageNames = self.pagenames()
for pageName in pageNames:
pageInfo = self._pageAttrs[pageName]
page = pageInfo['page']
w = page.winfo_reqwidth()
h = page.winfo_reqheight()
if maxPageWidth < w:
maxPageWidth = w
if maxPageHeight < h:
maxPageHeight = h
pageBorder = self._borderWidth + self._pageMargin
width = maxPageWidth + pageBorder * 2
height = maxPageHeight + pageBorder * 2
if self._withTabs:
maxTabHeight = 0
for pageInfo in self._pageAttrs.values():
if maxTabHeight < pageInfo['tabreqheight']:
maxTabHeight = pageInfo['tabreqheight']
height = height + maxTabHeight + self._borderWidth * 1.5
# Note that, since the hull is a canvas, the width and height
# options specify the geometry *inside* the borderwidth and
# highlightthickness.
self.configure(hull_width = width, hull_height = height)
def recolorborders(self):
self._pending['borderColor'] = 1
self._layout()
def _handleMap(self, event):
self._layout()
def _handleConfigure(self, event):
self._canvasSize = (event.width, event.height)
self._pending['size'] = 1
self._layout()
def _raiseNewTop(self, pageName):
if not self._pageAttrs[pageName]['created']:
self._pageAttrs[pageName]['created'] = 1
cmd = self['createcommand']
if cmd is not None:
cmd(pageName)
cmd = self['raisecommand']
if cmd is not None:
cmd(pageName)
# This is the vertical layout of the notebook, from top (assuming
# tabpos is 'n'):
# hull highlightthickness (top)
# hull borderwidth (top)
# borderwidth (top border of tabs)
# borderwidth * 0.5 (space for bevel)
# tab button (maximum of requested height of all tab buttons)
# borderwidth (border between tabs and page)
# pagemargin (top)
# the page itself
# pagemargin (bottom)
# borderwidth (border below page)
# hull borderwidth (bottom)
# hull highlightthickness (bottom)
#
# canvasBorder is sum of top two elements.
# tabBottom is sum of top five elements.
#
# Horizontal layout (and also vertical layout when tabpos is None):
# hull highlightthickness
# hull borderwidth
# borderwidth
# pagemargin
# the page itself
# pagemargin
# borderwidth
# hull borderwidth
# hull highlightthickness
#
def _layout(self):
if not self.winfo_ismapped() or self._canvasSize is None:
# Don't layout if the window is not displayed, or we
# haven't yet received a <Configure> event.
return
hullWidth, hullHeight = self._canvasSize
borderWidth = self._borderWidth
canvasBorder = string.atoi(self._hull['borderwidth']) + \
string.atoi(self._hull['highlightthickness'])
if not self._withTabs:
self.tabBottom = canvasBorder
oldTabBottom = self.tabBottom
if self._pending.has_key('borderColor'):
self._lightBorderColor, self._darkBorderColor = \
Color.bordercolors(self, self['hull_background'])
# Draw all the tabs.
if self._withTabs and (self._pending.has_key('tabs') or
self._pending.has_key('size')):
# Find total requested width and maximum requested height
# of tabs.
sumTabReqWidth = 0
maxTabHeight = 0
for pageInfo in self._pageAttrs.values():
sumTabReqWidth = sumTabReqWidth + pageInfo['tabreqwidth']
if maxTabHeight < pageInfo['tabreqheight']:
maxTabHeight = pageInfo['tabreqheight']
if maxTabHeight != 0:
# Add the top tab border plus a bit for the angled corners
self.tabBottom = canvasBorder + maxTabHeight + borderWidth * 1.5
# Prepare for drawing the border around each tab button.
tabTop = canvasBorder
tabTop2 = tabTop + borderWidth
tabTop3 = tabTop + borderWidth * 1.5
tabBottom2 = self.tabBottom
tabBottom = self.tabBottom + borderWidth
numTabs = len(self._pageNames)
availableWidth = hullWidth - 2 * canvasBorder - \
numTabs * 2 * borderWidth
x = canvasBorder
cumTabReqWidth = 0
cumTabWidth = 0
# Position all the tabs.
for pageName in self._pageNames:
pageInfo = self._pageAttrs[pageName]
(windowitem, lightshadow, darkshadow) = pageInfo['tabitems']
if sumTabReqWidth <= availableWidth:
tabwidth = pageInfo['tabreqwidth']
else:
# This ugly calculation ensures that, when the
# notebook is not wide enough for the requested
# widths of the tabs, the total width given to
# the tabs exactly equals the available width,
# without rounding errors.
cumTabReqWidth = cumTabReqWidth + pageInfo['tabreqwidth']
tmp = (2*cumTabReqWidth*availableWidth + sumTabReqWidth) \
/ (2 * sumTabReqWidth)
tabwidth = tmp - cumTabWidth
cumTabWidth = tmp
# Position the tab's button canvas item.
self.coords(windowitem, x + borderWidth, tabTop3)
self.itemconfigure(windowitem,
width = tabwidth, height = maxTabHeight)
# Make a beautiful border around the tab.
left = x
left2 = left + borderWidth
left3 = left + borderWidth * 1.5
right = left + tabwidth + 2 * borderWidth
right2 = left + tabwidth + borderWidth
right3 = left + tabwidth + borderWidth * 0.5
self.coords(lightshadow,
left, tabBottom2, left, tabTop2, left2, tabTop,
right2, tabTop, right3, tabTop2, left3, tabTop2,
left2, tabTop3, left2, tabBottom,
)
self.coords(darkshadow,
right2, tabTop, right, tabTop2, right, tabBottom2,
right2, tabBottom, right2, tabTop3, right3, tabTop2,
)
pageInfo['left'] = left
pageInfo['right'] = right
x = x + tabwidth + 2 * borderWidth
# Redraw shadow under tabs so that it appears that tab for old
# top page is lowered and that tab for new top page is raised.
if self._withTabs and (self._pending.has_key('topPage') or
self._pending.has_key('tabs') or self._pending.has_key('size')):
if self.getcurselection() is None:
# No pages, so draw line across top of page area.
self.coords(self._pageTop1Border,
canvasBorder, self.tabBottom,
hullWidth - canvasBorder, self.tabBottom,
hullWidth - canvasBorder - borderWidth,
self.tabBottom + borderWidth,
borderWidth + canvasBorder, self.tabBottom + borderWidth,
)
# Ignore second top border.
self.coords(self._pageTop2Border, 0, 0, 0, 0, 0, 0)
else:
# Draw two lines, one on each side of the tab for the
# top page, so that the tab appears to be raised.
pageInfo = self._pageAttrs[self.getcurselection()]
left = pageInfo['left']
right = pageInfo['right']
self.coords(self._pageTop1Border,
canvasBorder, self.tabBottom,
left, self.tabBottom,
left + borderWidth, self.tabBottom + borderWidth,
canvasBorder + borderWidth, self.tabBottom + borderWidth,
)
self.coords(self._pageTop2Border,
right, self.tabBottom,
hullWidth - canvasBorder, self.tabBottom,
hullWidth - canvasBorder - borderWidth,
self.tabBottom + borderWidth,
right - borderWidth, self.tabBottom + borderWidth,
)
# Prevent bottom of dark border of tabs appearing over
# page top border.
self.tag_raise(self._pageTop1Border)
self.tag_raise(self._pageTop2Border)
# Position the page border shadows.
if self._pending.has_key('size') or oldTabBottom != self.tabBottom:
self.coords(self._pageLeftBorder,
canvasBorder, self.tabBottom,
borderWidth + canvasBorder,
self.tabBottom + borderWidth,
borderWidth + canvasBorder,
hullHeight - canvasBorder - borderWidth,
canvasBorder, hullHeight - canvasBorder,
)
self.coords(self._pageBottomRightBorder,
hullWidth - canvasBorder, self.tabBottom,
hullWidth - canvasBorder, hullHeight - canvasBorder,
canvasBorder, hullHeight - canvasBorder,
borderWidth + canvasBorder,
hullHeight - canvasBorder - borderWidth,
hullWidth - canvasBorder - borderWidth,
hullHeight - canvasBorder - borderWidth,
hullWidth - canvasBorder - borderWidth,
self.tabBottom + borderWidth,
)
if not self._withTabs:
self.coords(self._pageTopBorder,
canvasBorder, self.tabBottom,
hullWidth - canvasBorder, self.tabBottom,
hullWidth - canvasBorder - borderWidth,
self.tabBottom + borderWidth,
borderWidth + canvasBorder, self.tabBottom + borderWidth,
)
# Color borders.
if self._pending.has_key('borderColor'):
self.itemconfigure('lighttag', fill = self._lightBorderColor)
self.itemconfigure('darktag', fill = self._darkBorderColor)
newTopPage = self._pending.get('topPage')
pageBorder = borderWidth + self._pageMargin
# Raise new top page.
if newTopPage is not None:
self._topPageName = newTopPage
self._topPageItem = self.create_window(
pageBorder + canvasBorder, self.tabBottom + pageBorder,
window = self._pageAttrs[newTopPage]['page'],
anchor = 'nw',
)
# Change position of top page if tab height has changed.
if self._topPageName is not None and oldTabBottom != self.tabBottom:
self.coords(self._topPageItem,
pageBorder + canvasBorder, self.tabBottom + pageBorder)
# Change size of top page if,
# 1) there is a new top page.
# 2) canvas size has changed, but not if there is no top
# page (eg: initially or when all pages deleted).
# 3) tab height has changed, due to difference in the height of a tab
if (newTopPage is not None or \
self._pending.has_key('size') and self._topPageName is not None
or oldTabBottom != self.tabBottom):
self.itemconfigure(self._topPageItem,
width = hullWidth - 2 * canvasBorder - pageBorder * 2,
height = hullHeight - 2 * canvasBorder - pageBorder * 2 -
(self.tabBottom - canvasBorder),
)
self._pending = {}
# Need to do forwarding to get the pack, grid, etc methods.
# Unfortunately this means that all the other canvas methods are also
# forwarded.
forwardmethods(NoteBook, Tkinter.Canvas, '_hull')
######################################################################
### File: PmwOptionMenu.py
import types
import Tkinter
class OptionMenu(MegaWidget):
def __init__(self, parent = None, **kw):
# Define the megawidget options.
optiondefs = (
('command', None, None),
('items', (), INITOPT),
('initialitem', None, INITOPT),
('labelmargin', 0, INITOPT),
('labelpos', None, INITOPT),
('sticky', 'ew', INITOPT),
)
self.defineoptions(kw, optiondefs)
# Initialise the base class (after defining the options).
MegaWidget.__init__(self, parent)
# Create the components.
interior = self.interior()
self._menubutton = self.createcomponent('menubutton',
(), None,
Tkinter.Menubutton, (interior,),
borderwidth = 2,
indicatoron = 1,
relief = 'raised',
anchor = 'c',
highlightthickness = 2,
direction = 'flush',
takefocus = 1,
)
self._menubutton.grid(column = 2, row = 2, sticky = self['sticky'])
self._menu = self.createcomponent('menu',
(), None,
Tkinter.Menu, (self._menubutton,),
tearoff=0
)
self._menubutton.configure(menu = self._menu)
interior.grid_columnconfigure(2, weight = 1)
interior.grid_rowconfigure(2, weight = 1)
# Create the label.
self.createlabel(interior)
# Add the items specified by the initialisation option.
self._itemList = []
self.setitems(self['items'], self['initialitem'])
# Check keywords and initialise options.
self.initialiseoptions()
def setitems(self, items, index = None):
# Clean up old items and callback commands.
for oldIndex in range(len(self._itemList)):
tclCommandName = str(self._menu.entrycget(oldIndex, 'command'))
if tclCommandName != '':
self._menu.deletecommand(tclCommandName)
self._menu.delete(0, 'end')
self._itemList = list(items)
# Set the items in the menu component.
for item in items:
self._menu.add_command(label = item,
command = lambda self = self, item = item: self._invoke(item))
# Set the currently selected value.
if index is None:
var = str(self._menubutton.cget('textvariable'))
if var != '':
# None means do not change text variable.
return
if len(items) == 0:
text = ''
elif str(self._menubutton.cget('text')) in items:
# Do not change selection if it is still valid
return
else:
text = items[0]
else:
index = self.index(index)
text = self._itemList[index]
self.setvalue(text)
def getcurselection(self):
var = str(self._menubutton.cget('textvariable'))
if var == '':
return str(self._menubutton.cget('text'))
else:
return self._menu.tk.globalgetvar(var)
def getvalue(self):
return self.getcurselection()
def setvalue(self, text):
var = str(self._menubutton.cget('textvariable'))
if var == '':
self._menubutton.configure(text = text)
else:
self._menu.tk.globalsetvar(var, text)
def index(self, index):
listLength = len(self._itemList)
if type(index) == types.IntType:
if index < listLength:
return index
else:
raise ValueError, 'index "%s" is out of range' % index
elif index is END:
if listLength > 0:
return listLength - 1
else:
raise ValueError, 'OptionMenu has no items'
else:
if index is SELECT:
if listLength > 0:
index = self.getcurselection()
else:
raise ValueError, 'OptionMenu has no items'
if index in self._itemList:
return self._itemList.index(index)
raise ValueError, \
'bad index "%s": must be a ' \
'name, a number, END or SELECT' % (index,)
def invoke(self, index = SELECT):
index = self.index(index)
text = self._itemList[index]
return self._invoke(text)
def _invoke(self, text):
self.setvalue(text)
command = self['command']
if callable(command):
return command(text)
######################################################################
### File: PmwPanedWidget.py
# PanedWidget
# a frame which may contain several resizable sub-frames
import string
import sys
import types
import Tkinter
class PanedWidget(MegaWidget):
def __init__(self, parent = None, **kw):
# Define the megawidget options.
optiondefs = (
('command', None, None),
('orient', 'vertical', INITOPT),
('separatorrelief', 'sunken', INITOPT),
('separatorthickness', 2, INITOPT),
('handlesize', 8, INITOPT),
('hull_width', 400, None),
('hull_height', 400, None),
)
self.defineoptions(kw, optiondefs,
dynamicGroups = ('Frame', 'Separator', 'Handle'))
# Initialise the base class (after defining the options).
MegaWidget.__init__(self, parent)
self.bind('<Configure>', self._handleConfigure)
if self['orient'] not in ('horizontal', 'vertical'):
raise ValueError, 'bad orient option ' + repr(self['orient']) + \
': must be either \'horizontal\' or \'vertical\''
self._separatorThickness = self['separatorthickness']
self._handleSize = self['handlesize']
self._paneNames = [] # List of pane names
self._paneAttrs = {} # Map from pane name to pane info
self._timerId = None
self._frame = {}
self._separator = []
self._button = []
self._totalSize = 0
self._movePending = 0
self._relsize = {}
self._relmin = {}
self._relmax = {}
self._size = {}
self._min = {}
self._max = {}
self._rootp = None
self._curSize = None
self._beforeLimit = None
self._afterLimit = None
self._buttonIsDown = 0
self._majorSize = 100
self._minorSize = 100
# Check keywords and initialise options.
self.initialiseoptions()
def insert(self, name, before = 0, **kw):
# Parse <kw> for options.
self._initPaneOptions(name)
self._parsePaneOptions(name, kw)
insertPos = self._nameToIndex(before)
atEnd = (insertPos == len(self._paneNames))
# Add the frame.
self._paneNames[insertPos:insertPos] = [name]
self._frame[name] = self.createcomponent(name,
(), 'Frame',
Tkinter.Frame, (self.interior(),))
# Add separator, if necessary.
if len(self._paneNames) > 1:
self._addSeparator()
else:
self._separator.append(None)
self._button.append(None)
# Add the new frame and adjust the PanedWidget
if atEnd:
size = self._size[name]
if size > 0 or self._relsize[name] is not None:
if self['orient'] == 'vertical':
self._frame[name].place(x=0, relwidth=1,
height=size, y=self._totalSize)
else:
self._frame[name].place(y=0, relheight=1,
width=size, x=self._totalSize)
else:
if self['orient'] == 'vertical':
self._frame[name].place(x=0, relwidth=1,
y=self._totalSize)
else:
self._frame[name].place(y=0, relheight=1,
x=self._totalSize)
else:
self._updateSizes()
self._totalSize = self._totalSize + self._size[name]
return self._frame[name]
def add(self, name, **kw):
return apply(self.insert, (name, len(self._paneNames)), kw)
def delete(self, name):
deletePos = self._nameToIndex(name)
name = self._paneNames[deletePos]
self.destroycomponent(name)
del self._paneNames[deletePos]
del self._frame[name]
del self._size[name]
del self._min[name]
del self._max[name]
del self._relsize[name]
del self._relmin[name]
del self._relmax[name]
last = len(self._paneNames)
del self._separator[last]
del self._button[last]
if last > 0:
self.destroycomponent(self._sepName(last))
self.destroycomponent(self._buttonName(last))
self._plotHandles()
def setnaturalsize(self):
self.update_idletasks()
totalWidth = 0
totalHeight = 0
maxWidth = 0
maxHeight = 0
for name in self._paneNames:
frame = self._frame[name]
w = frame.winfo_reqwidth()
h = frame.winfo_reqheight()
totalWidth = totalWidth + w
totalHeight = totalHeight + h
if maxWidth < w:
maxWidth = w
if maxHeight < h:
maxHeight = h
# Note that, since the hull is a frame, the width and height
# options specify the geometry *outside* the borderwidth and
# highlightthickness.
bw = string.atoi(str(self.cget('hull_borderwidth')))
hl = string.atoi(str(self.cget('hull_highlightthickness')))
extra = (bw + hl) * 2
if str(self.cget('orient')) == 'horizontal':
totalWidth = totalWidth + extra
maxHeight = maxHeight + extra
self.configure(hull_width = totalWidth, hull_height = maxHeight)
else:
totalHeight = (totalHeight + extra +
(len(self._paneNames) - 1) * self._separatorThickness)
maxWidth = maxWidth + extra
self.configure(hull_width = maxWidth, hull_height = totalHeight)
def move(self, name, newPos, newPosOffset = 0):
# see if we can spare ourselves some work
numPanes = len(self._paneNames)
if numPanes < 2:
return
newPos = self._nameToIndex(newPos) + newPosOffset
if newPos < 0 or newPos >=numPanes:
return
deletePos = self._nameToIndex(name)
if deletePos == newPos:
# inserting over ourself is a no-op
return
# delete name from old position in list
name = self._paneNames[deletePos]
del self._paneNames[deletePos]
# place in new position
self._paneNames[newPos:newPos] = [name]
# force everything to redraw
self._plotHandles()
self._updateSizes()
def _nameToIndex(self, nameOrIndex):
try:
pos = self._paneNames.index(nameOrIndex)
except ValueError:
pos = nameOrIndex
return pos
def _initPaneOptions(self, name):
# Set defaults.
self._size[name] = 0
self._relsize[name] = None
self._min[name] = 0
self._relmin[name] = None
self._max[name] = 100000
self._relmax[name] = None
def _parsePaneOptions(self, name, args):
# Parse <args> for options.
for arg, value in args.items():
if type(value) == types.FloatType:
relvalue = value
value = self._absSize(relvalue)
else:
relvalue = None
if arg == 'size':
self._size[name], self._relsize[name] = value, relvalue
elif arg == 'min':
self._min[name], self._relmin[name] = value, relvalue
elif arg == 'max':
self._max[name], self._relmax[name] = value, relvalue
else:
raise ValueError, 'keyword must be "size", "min", or "max"'
def _absSize(self, relvalue):
return int(round(relvalue * self._majorSize))
def _sepName(self, n):
return 'separator-%d' % n
def _buttonName(self, n):
return 'handle-%d' % n
def _addSeparator(self):
n = len(self._paneNames) - 1
downFunc = lambda event, s = self, num=n: s._btnDown(event, num)
upFunc = lambda event, s = self, num=n: s._btnUp(event, num)
moveFunc = lambda event, s = self, num=n: s._btnMove(event, num)
# Create the line dividing the panes.
sep = self.createcomponent(self._sepName(n),
(), 'Separator',
Tkinter.Frame, (self.interior(),),
borderwidth = 1,
relief = self['separatorrelief'])
self._separator.append(sep)
sep.bind('<ButtonPress-1>', downFunc)
sep.bind('<Any-ButtonRelease-1>', upFunc)
sep.bind('<B1-Motion>', moveFunc)
if self['orient'] == 'vertical':
cursor = 'sb_v_double_arrow'
sep.configure(height = self._separatorThickness,
width = 10000, cursor = cursor)
else:
cursor = 'sb_h_double_arrow'
sep.configure(width = self._separatorThickness,
height = 10000, cursor = cursor)
self._totalSize = self._totalSize + self._separatorThickness
# Create the handle on the dividing line.
handle = self.createcomponent(self._buttonName(n),
(), 'Handle',
Tkinter.Frame, (self.interior(),),
relief = 'raised',
borderwidth = 1,
width = self._handleSize,
height = self._handleSize,
cursor = cursor,
)
self._button.append(handle)
handle.bind('<ButtonPress-1>', downFunc)
handle.bind('<Any-ButtonRelease-1>', upFunc)
handle.bind('<B1-Motion>', moveFunc)
self._plotHandles()
for i in range(1, len(self._paneNames)):
self._separator[i].tkraise()
for i in range(1, len(self._paneNames)):
self._button[i].tkraise()
def _btnUp(self, event, item):
self._buttonIsDown = 0
self._updateSizes()
try:
self._button[item].configure(relief='raised')
except:
pass
def _btnDown(self, event, item):
self._button[item].configure(relief='sunken')
self._getMotionLimit(item)
self._buttonIsDown = 1
self._movePending = 0
def _handleConfigure(self, event = None):
self._getNaturalSizes()
if self._totalSize == 0:
return
iterRange = list(self._paneNames)
iterRange.reverse()
if self._majorSize > self._totalSize:
n = self._majorSize - self._totalSize
self._iterate(iterRange, self._grow, n)
elif self._majorSize < self._totalSize:
n = self._totalSize - self._majorSize
self._iterate(iterRange, self._shrink, n)
self._plotHandles()
self._updateSizes()
def _getNaturalSizes(self):
# Must call this in order to get correct winfo_width, winfo_height
self.update_idletasks()
self._totalSize = 0
if self['orient'] == 'vertical':
self._majorSize = self.winfo_height()
self._minorSize = self.winfo_width()
majorspec = Tkinter.Frame.winfo_reqheight
else:
self._majorSize = self.winfo_width()
self._minorSize = self.winfo_height()
majorspec = Tkinter.Frame.winfo_reqwidth
bw = string.atoi(str(self.cget('hull_borderwidth')))
hl = string.atoi(str(self.cget('hull_highlightthickness')))
extra = (bw + hl) * 2
self._majorSize = self._majorSize - extra
self._minorSize = self._minorSize - extra
if self._majorSize < 0:
self._majorSize = 0
if self._minorSize < 0:
self._minorSize = 0
for name in self._paneNames:
# adjust the absolute sizes first...
if self._relsize[name] is None:
#special case
if self._size[name] == 0:
self._size[name] = apply(majorspec, (self._frame[name],))
self._setrel(name)
else:
self._size[name] = self._absSize(self._relsize[name])
if self._relmin[name] is not None:
self._min[name] = self._absSize(self._relmin[name])
if self._relmax[name] is not None:
self._max[name] = self._absSize(self._relmax[name])
# now adjust sizes
if self._size[name] < self._min[name]:
self._size[name] = self._min[name]
self._setrel(name)
if self._size[name] > self._max[name]:
self._size[name] = self._max[name]
self._setrel(name)
self._totalSize = self._totalSize + self._size[name]
# adjust for separators
self._totalSize = (self._totalSize +
(len(self._paneNames) - 1) * self._separatorThickness)
def _setrel(self, name):
if self._relsize[name] is not None:
if self._majorSize != 0:
self._relsize[name] = round(self._size[name]) / self._majorSize
def _iterate(self, names, proc, n):
for i in names:
n = apply(proc, (i, n))
if n == 0:
break
def _grow(self, name, n):
canGrow = self._max[name] - self._size[name]
if canGrow > n:
self._size[name] = self._size[name] + n
self._setrel(name)
return 0
elif canGrow > 0:
self._size[name] = self._max[name]
self._setrel(name)
n = n - canGrow
return n
def _shrink(self, name, n):
canShrink = self._size[name] - self._min[name]
if canShrink > n:
self._size[name] = self._size[name] - n
self._setrel(name)
return 0
elif canShrink > 0:
self._size[name] = self._min[name]
self._setrel(name)
n = n - canShrink
return n
def _updateSizes(self):
totalSize = 0
for name in self._paneNames:
size = self._size[name]
if self['orient'] == 'vertical':
self._frame[name].place(x = 0, relwidth = 1,
y = totalSize,
height = size)
else:
self._frame[name].place(y = 0, relheight = 1,
x = totalSize,
width = size)
totalSize = totalSize + size + self._separatorThickness
# Invoke the callback command
cmd = self['command']
if callable(cmd):
cmd(map(lambda x, s = self: s._size[x], self._paneNames))
def _plotHandles(self):
if len(self._paneNames) == 0:
return
if self['orient'] == 'vertical':
btnp = self._minorSize - 13
else:
h = self._minorSize
if h > 18:
btnp = 9
else:
btnp = h - 9
firstPane = self._paneNames[0]
totalSize = self._size[firstPane]
first = 1
last = len(self._paneNames) - 1
# loop from first to last, inclusive
for i in range(1, last + 1):
handlepos = totalSize - 3
prevSize = self._size[self._paneNames[i - 1]]
nextSize = self._size[self._paneNames[i]]
offset1 = 0
if i == first:
if prevSize < 4:
offset1 = 4 - prevSize
else:
if prevSize < 8:
offset1 = (8 - prevSize) / 2
offset2 = 0
if i == last:
if nextSize < 4:
offset2 = nextSize - 4
else:
if nextSize < 8:
offset2 = (nextSize - 8) / 2
handlepos = handlepos + offset1
if self['orient'] == 'vertical':
height = 8 - offset1 + offset2
if height > 1:
self._button[i].configure(height = height)
self._button[i].place(x = btnp, y = handlepos)
else:
self._button[i].place_forget()
self._separator[i].place(x = 0, y = totalSize,
relwidth = 1)
else:
width = 8 - offset1 + offset2
if width > 1:
self._button[i].configure(width = width)
self._button[i].place(y = btnp, x = handlepos)
else:
self._button[i].place_forget()
self._separator[i].place(y = 0, x = totalSize,
relheight = 1)
totalSize = totalSize + nextSize + self._separatorThickness
def pane(self, name):
return self._frame[self._paneNames[self._nameToIndex(name)]]
# Return the name of all panes
def panes(self):
return list(self._paneNames)
def configurepane(self, name, **kw):
name = self._paneNames[self._nameToIndex(name)]
self._parsePaneOptions(name, kw)
self._handleConfigure()
def updatelayout(self):
self._handleConfigure()
def _getMotionLimit(self, item):
curBefore = (item - 1) * self._separatorThickness
minBefore, maxBefore = curBefore, curBefore
for name in self._paneNames[:item]:
curBefore = curBefore + self._size[name]
minBefore = minBefore + self._min[name]
maxBefore = maxBefore + self._max[name]
curAfter = (len(self._paneNames) - item) * self._separatorThickness
minAfter, maxAfter = curAfter, curAfter
for name in self._paneNames[item:]:
curAfter = curAfter + self._size[name]
minAfter = minAfter + self._min[name]
maxAfter = maxAfter + self._max[name]
beforeToGo = min(curBefore - minBefore, maxAfter - curAfter)
afterToGo = min(curAfter - minAfter, maxBefore - curBefore)
self._beforeLimit = curBefore - beforeToGo
self._afterLimit = curBefore + afterToGo
self._curSize = curBefore
self._plotHandles()
# Compress the motion so that update is quick even on slow machines
#
# theRootp = root position (either rootx or rooty)
def _btnMove(self, event, item):
self._rootp = event
if self._movePending == 0:
self._timerId = self.after_idle(
lambda s = self, i = item: s._btnMoveCompressed(i))
self._movePending = 1
def destroy(self):
if self._timerId is not None:
self.after_cancel(self._timerId)
self._timerId = None
MegaWidget.destroy(self)
def _btnMoveCompressed(self, item):
if not self._buttonIsDown:
return
if self['orient'] == 'vertical':
p = self._rootp.y_root - self.winfo_rooty()
else:
p = self._rootp.x_root - self.winfo_rootx()
if p == self._curSize:
self._movePending = 0
return
if p < self._beforeLimit:
p = self._beforeLimit
if p >= self._afterLimit:
p = self._afterLimit
self._calculateChange(item, p)
self.update_idletasks()
self._movePending = 0
# Calculate the change in response to mouse motions
def _calculateChange(self, item, p):
if p < self._curSize:
self._moveBefore(item, p)
elif p > self._curSize:
self._moveAfter(item, p)
self._plotHandles()
def _moveBefore(self, item, p):
n = self._curSize - p
# Shrink the frames before
iterRange = list(self._paneNames[:item])
iterRange.reverse()
self._iterate(iterRange, self._shrink, n)
# Adjust the frames after
iterRange = self._paneNames[item:]
self._iterate(iterRange, self._grow, n)
self._curSize = p
def _moveAfter(self, item, p):
n = p - self._curSize
# Shrink the frames after
iterRange = self._paneNames[item:]
self._iterate(iterRange, self._shrink, n)
# Adjust the frames before
iterRange = list(self._paneNames[:item])
iterRange.reverse()
self._iterate(iterRange, self._grow, n)
self._curSize = p
######################################################################
### File: PmwPromptDialog.py
# Based on iwidgets2.2.0/promptdialog.itk code.
# A Dialog with an entryfield
class PromptDialog(Dialog):
def __init__(self, parent = None, **kw):
# Define the megawidget options.
optiondefs = (
('borderx', 20, INITOPT),
('bordery', 20, INITOPT),
)
self.defineoptions(kw, optiondefs)
# Initialise the base class (after defining the options).
Dialog.__init__(self, parent)
# Create the components.
interior = self.interior()
aliases = (
('entry', 'entryfield_entry'),
('label', 'entryfield_label'),
)
self._promptDialogEntry = self.createcomponent('entryfield',
aliases, None,
EntryField, (interior,))
self._promptDialogEntry.pack(fill='x', expand=1,
padx = self['borderx'], pady = self['bordery'])
if not kw.has_key('activatecommand'):
# Whenever this dialog is activated, set the focus to the
# EntryField's entry widget.
tkentry = self.component('entry')
self.configure(activatecommand = tkentry.focus_set)
# Check keywords and initialise options.
self.initialiseoptions()
# Supply aliases to some of the entry component methods.
def insertentry(self, index, text):
self._promptDialogEntry.insert(index, text)
def deleteentry(self, first, last=None):
self._promptDialogEntry.delete(first, last)
def indexentry(self, index):
return self._promptDialogEntry.index(index)
forwardmethods(PromptDialog, EntryField, '_promptDialogEntry')
######################################################################
### File: PmwRadioSelect.py
import types
import Tkinter
class RadioSelect(MegaWidget):
# A collection of several buttons. In single mode, only one
# button may be selected. In multiple mode, any number of buttons
# may be selected.
def __init__(self, parent = None, **kw):
# Define the megawidget options.
optiondefs = (
('buttontype', 'button', INITOPT),
('command', None, None),
('labelmargin', 0, INITOPT),
('labelpos', None, INITOPT),
('orient', 'horizontal', INITOPT),
('padx', 5, INITOPT),
('pady', 5, INITOPT),
('selectmode', 'single', INITOPT),
)
self.defineoptions(kw, optiondefs, dynamicGroups = ('Button',))
# Initialise the base class (after defining the options).
MegaWidget.__init__(self, parent)
# Create the components.
interior = self.interior()
if self['labelpos'] is None:
self._radioSelectFrame = self._hull
else:
self._radioSelectFrame = self.createcomponent('frame',
(), None,
Tkinter.Frame, (interior,))
self._radioSelectFrame.grid(column=2, row=2, sticky='nsew')
interior.grid_columnconfigure(2, weight=1)
interior.grid_rowconfigure(2, weight=1)
self.createlabel(interior)
# Initialise instance variables.
self._buttonList = []
if self['selectmode'] == 'single':
self._singleSelect = 1
elif self['selectmode'] == 'multiple':
self._singleSelect = 0
else:
raise ValueError, 'bad selectmode option "' + \
self['selectmode'] + '": should be single or multiple'
if self['buttontype'] == 'button':
self.buttonClass = Tkinter.Button
elif self['buttontype'] == 'radiobutton':
self._singleSelect = 1
self.var = Tkinter.StringVar()
self.buttonClass = Tkinter.Radiobutton
elif self['buttontype'] == 'checkbutton':
self._singleSelect = 0
self.buttonClass = Tkinter.Checkbutton
else:
raise ValueError, 'bad buttontype option "' + \
self['buttontype'] + \
'": should be button, radiobutton or checkbutton'
if self._singleSelect:
self.selection = None
else:
self.selection = []
if self['orient'] not in ('horizontal', 'vertical'):
raise ValueError, 'bad orient option ' + repr(self['orient']) + \
': must be either \'horizontal\' or \'vertical\''
# Check keywords and initialise options.
self.initialiseoptions()
def getcurselection(self):
if self._singleSelect:
return self.selection
else:
return tuple(self.selection)
def getvalue(self):
return self.getcurselection()
def setvalue(self, textOrList):
if self._singleSelect:
self.__setSingleValue(textOrList)
else:
# Multiple selections
oldselection = self.selection
self.selection = textOrList
for button in self._buttonList:
if button in oldselection:
if button not in self.selection:
# button is currently selected but should not be
widget = self.component(button)
if self['buttontype'] == 'checkbutton':
widget.deselect()
else: # Button
widget.configure(relief='raised')
else:
if button in self.selection:
# button is not currently selected but should be
widget = self.component(button)
if self['buttontype'] == 'checkbutton':
widget.select()
else: # Button
widget.configure(relief='sunken')
def numbuttons(self):
return len(self._buttonList)
def index(self, index):
# Return the integer index of the button with the given index.
listLength = len(self._buttonList)
if type(index) == types.IntType:
if index < listLength:
return index
else:
raise ValueError, 'index "%s" is out of range' % index
elif index is END:
if listLength > 0:
return listLength - 1
else:
raise ValueError, 'RadioSelect has no buttons'
else:
for count in range(listLength):
name = self._buttonList[count]
if index == name:
return count
validValues = 'a name, a number or END'
raise ValueError, \
'bad index "%s": must be %s' % (index, validValues)
def button(self, buttonIndex):
name = self._buttonList[self.index(buttonIndex)]
return self.component(name)
def add(self, componentName, **kw):
if componentName in self._buttonList:
raise ValueError, 'button "%s" already exists' % componentName
kw['command'] = \
lambda self=self, name=componentName: self.invoke(name)
if not kw.has_key('text'):
kw['text'] = componentName
if self['buttontype'] == 'radiobutton':
if not kw.has_key('anchor'):
kw['anchor'] = 'w'
if not kw.has_key('variable'):
kw['variable'] = self.var
if not kw.has_key('value'):
kw['value'] = kw['text']
elif self['buttontype'] == 'checkbutton':
if not kw.has_key('anchor'):
kw['anchor'] = 'w'
button = apply(self.createcomponent, (componentName,
(), 'Button',
self.buttonClass, (self._radioSelectFrame,)), kw)
if self['orient'] == 'horizontal':
self._radioSelectFrame.grid_rowconfigure(0, weight=1)
col = len(self._buttonList)
button.grid(column=col, row=0, padx = self['padx'],
pady = self['pady'], sticky='nsew')
self._radioSelectFrame.grid_columnconfigure(col, weight=1)
else:
self._radioSelectFrame.grid_columnconfigure(0, weight=1)
row = len(self._buttonList)
button.grid(column=0, row=row, padx = self['padx'],
pady = self['pady'], sticky='ew')
self._radioSelectFrame.grid_rowconfigure(row, weight=1)
self._buttonList.append(componentName)
return button
def deleteall(self):
for name in self._buttonList:
self.destroycomponent(name)
self._buttonList = []
if self._singleSelect:
self.selection = None
else:
self.selection = []
def __setSingleValue(self, value):
self.selection = value
if self['buttontype'] == 'radiobutton':
widget = self.component(value)
widget.select()
else: # Button
for button in self._buttonList:
widget = self.component(button)
if button == value:
widget.configure(relief='sunken')
else:
widget.configure(relief='raised')
def invoke(self, index):
index = self.index(index)
name = self._buttonList[index]
if self._singleSelect:
self.__setSingleValue(name)
command = self['command']
if callable(command):
return command(name)
else:
# Multiple selections
widget = self.component(name)
if name in self.selection:
if self['buttontype'] == 'checkbutton':
widget.deselect()
else:
widget.configure(relief='raised')
self.selection.remove(name)
state = 0
else:
if self['buttontype'] == 'checkbutton':
widget.select()
else:
widget.configure(relief='sunken')
self.selection.append(name)
state = 1
command = self['command']
if callable(command):
return command(name, state)
######################################################################
### File: PmwScrolledCanvas.py
import Tkinter
class ScrolledCanvas(MegaWidget):
def __init__(self, parent = None, **kw):
# Define the megawidget options.
optiondefs = (
('borderframe', 0, INITOPT),
('canvasmargin', 0, INITOPT),
('hscrollmode', 'dynamic', self._hscrollMode),
('labelmargin', 0, INITOPT),
('labelpos', None, INITOPT),
('scrollmargin', 2, INITOPT),
('usehullsize', 0, INITOPT),
('vscrollmode', 'dynamic', self._vscrollMode),
)
self.defineoptions(kw, optiondefs)
# Initialise the base class (after defining the options).
MegaWidget.__init__(self, parent)
# Create the components.
self.origInterior = MegaWidget.interior(self)
if self['usehullsize']:
self.origInterior.grid_propagate(0)
if self['borderframe']:
# Create a frame widget to act as the border of the canvas.
self._borderframe = self.createcomponent('borderframe',
(), None,
Tkinter.Frame, (self.origInterior,),
relief = 'sunken',
borderwidth = 2,
)
self._borderframe.grid(row = 2, column = 2, sticky = 'news')
# Create the canvas widget.
self._canvas = self.createcomponent('canvas',
(), None,
Tkinter.Canvas, (self._borderframe,),
highlightthickness = 0,
borderwidth = 0,
)
self._canvas.pack(fill = 'both', expand = 1)
else:
# Create the canvas widget.
self._canvas = self.createcomponent('canvas',
(), None,
Tkinter.Canvas, (self.origInterior,),
relief = 'sunken',
borderwidth = 2,
)
self._canvas.grid(row = 2, column = 2, sticky = 'news')
self.origInterior.grid_rowconfigure(2, weight = 1, minsize = 0)
self.origInterior.grid_columnconfigure(2, weight = 1, minsize = 0)
# Create the horizontal scrollbar
self._horizScrollbar = self.createcomponent('horizscrollbar',
(), 'Scrollbar',
Tkinter.Scrollbar, (self.origInterior,),
orient='horizontal',
command=self._canvas.xview
)
# Create the vertical scrollbar
self._vertScrollbar = self.createcomponent('vertscrollbar',
(), 'Scrollbar',
Tkinter.Scrollbar, (self.origInterior,),
orient='vertical',
command=self._canvas.yview
)
self.createlabel(self.origInterior, childCols = 3, childRows = 3)
# Initialise instance variables.
self._horizScrollbarOn = 0
self._vertScrollbarOn = 0
self.scrollTimer = None
self._scrollRecurse = 0
self._horizScrollbarNeeded = 0
self._vertScrollbarNeeded = 0
self.setregionTimer = None
# Check keywords and initialise options.
self.initialiseoptions()
def destroy(self):
if self.scrollTimer is not None:
self.after_cancel(self.scrollTimer)
self.scrollTimer = None
if self.setregionTimer is not None:
self.after_cancel(self.setregionTimer)
self.setregionTimer = None
MegaWidget.destroy(self)
# ======================================================================
# Public methods.
def interior(self):
return self._canvas
def resizescrollregion(self):
if self.setregionTimer is None:
self.setregionTimer = self.after_idle(self._setRegion)
# ======================================================================
# Configuration methods.
def _hscrollMode(self):
# The horizontal scroll mode has been configured.
mode = self['hscrollmode']
if mode == 'static':
if not self._horizScrollbarOn:
self._toggleHorizScrollbar()
elif mode == 'dynamic':
if self._horizScrollbarNeeded != self._horizScrollbarOn:
self._toggleHorizScrollbar()
elif mode == 'none':
if self._horizScrollbarOn:
self._toggleHorizScrollbar()
else:
message = 'bad hscrollmode option "%s": should be static, dynamic, or none' % mode
raise ValueError, message
self._configureScrollCommands()
def _vscrollMode(self):
# The vertical scroll mode has been configured.
mode = self['vscrollmode']
if mode == 'static':
if not self._vertScrollbarOn:
self._toggleVertScrollbar()
elif mode == 'dynamic':
if self._vertScrollbarNeeded != self._vertScrollbarOn:
self._toggleVertScrollbar()
elif mode == 'none':
if self._vertScrollbarOn:
self._toggleVertScrollbar()
else:
message = 'bad vscrollmode option "%s": should be static, dynamic, or none' % mode
raise ValueError, message
self._configureScrollCommands()
# ======================================================================
# Private methods.
def _configureScrollCommands(self):
# If both scrollmodes are not dynamic we can save a lot of
# time by not having to create an idle job to handle the
# scroll commands.
# Clean up previous scroll commands to prevent memory leak.
tclCommandName = str(self._canvas.cget('xscrollcommand'))
if tclCommandName != '':
self._canvas.deletecommand(tclCommandName)
tclCommandName = str(self._canvas.cget('yscrollcommand'))
if tclCommandName != '':
self._canvas.deletecommand(tclCommandName)
if self['hscrollmode'] == self['vscrollmode'] == 'dynamic':
self._canvas.configure(
xscrollcommand=self._scrollBothLater,
yscrollcommand=self._scrollBothLater
)
else:
self._canvas.configure(
xscrollcommand=self._scrollXNow,
yscrollcommand=self._scrollYNow
)
def _scrollXNow(self, first, last):
self._horizScrollbar.set(first, last)
self._horizScrollbarNeeded = ((first, last) != ('0', '1'))
if self['hscrollmode'] == 'dynamic':
if self._horizScrollbarNeeded != self._horizScrollbarOn:
self._toggleHorizScrollbar()
def _scrollYNow(self, first, last):
self._vertScrollbar.set(first, last)
self._vertScrollbarNeeded = ((first, last) != ('0', '1'))
if self['vscrollmode'] == 'dynamic':
if self._vertScrollbarNeeded != self._vertScrollbarOn:
self._toggleVertScrollbar()
def _scrollBothLater(self, first, last):
# Called by the canvas to set the horizontal or vertical
# scrollbar when it has scrolled or changed scrollregion.
if self.scrollTimer is None:
self.scrollTimer = self.after_idle(self._scrollBothNow)
def _scrollBothNow(self):
# This performs the function of _scrollXNow and _scrollYNow.
# If one is changed, the other should be updated to match.
self.scrollTimer = None
# Call update_idletasks to make sure that the containing frame
# has been resized before we attempt to set the scrollbars.
# Otherwise the scrollbars may be mapped/unmapped continuously.
self._scrollRecurse = self._scrollRecurse + 1
self.update_idletasks()
self._scrollRecurse = self._scrollRecurse - 1
if self._scrollRecurse != 0:
return
xview = self._canvas.xview()
yview = self._canvas.yview()
self._horizScrollbar.set(xview[0], xview[1])
self._vertScrollbar.set(yview[0], yview[1])
self._horizScrollbarNeeded = (xview != (0.0, 1.0))
self._vertScrollbarNeeded = (yview != (0.0, 1.0))
# If both horizontal and vertical scrollmodes are dynamic and
# currently only one scrollbar is mapped and both should be
# toggled, then unmap the mapped scrollbar. This prevents a
# continuous mapping and unmapping of the scrollbars.
if (self['hscrollmode'] == self['vscrollmode'] == 'dynamic' and
self._horizScrollbarNeeded != self._horizScrollbarOn and
self._vertScrollbarNeeded != self._vertScrollbarOn and
self._vertScrollbarOn != self._horizScrollbarOn):
if self._horizScrollbarOn:
self._toggleHorizScrollbar()
else:
self._toggleVertScrollbar()
return
if self['hscrollmode'] == 'dynamic':
if self._horizScrollbarNeeded != self._horizScrollbarOn:
self._toggleHorizScrollbar()
if self['vscrollmode'] == 'dynamic':
if self._vertScrollbarNeeded != self._vertScrollbarOn:
self._toggleVertScrollbar()
def _toggleHorizScrollbar(self):
self._horizScrollbarOn = not self._horizScrollbarOn
interior = self.origInterior
if self._horizScrollbarOn:
self._horizScrollbar.grid(row = 4, column = 2, sticky = 'news')
interior.grid_rowconfigure(3, minsize = self['scrollmargin'])
else:
self._horizScrollbar.grid_forget()
interior.grid_rowconfigure(3, minsize = 0)
def _toggleVertScrollbar(self):
self._vertScrollbarOn = not self._vertScrollbarOn
interior = self.origInterior
if self._vertScrollbarOn:
self._vertScrollbar.grid(row = 2, column = 4, sticky = 'news')
interior.grid_columnconfigure(3, minsize = self['scrollmargin'])
else:
self._vertScrollbar.grid_forget()
interior.grid_columnconfigure(3, minsize = 0)
def _setRegion(self):
self.setregionTimer = None
region = self._canvas.bbox('all')
if region is not None:
canvasmargin = self['canvasmargin']
region = (region[0] - canvasmargin, region[1] - canvasmargin,
region[2] + canvasmargin, region[3] + canvasmargin)
self._canvas.configure(scrollregion = region)
# Need to explicitly forward this to override the stupid
# (grid_)bbox method inherited from Tkinter.Frame.Grid.
def bbox(self, *args):
return apply(self._canvas.bbox, args)
forwardmethods(ScrolledCanvas, Tkinter.Canvas, '_canvas')
######################################################################
### File: PmwScrolledField.py
import Tkinter
class ScrolledField(MegaWidget):
def __init__(self, parent = None, **kw):
# Define the megawidget options.
optiondefs = (
('labelmargin', 0, INITOPT),
('labelpos', None, INITOPT),
('sticky', 'ew', INITOPT),
('text', '', self._text),
)
self.defineoptions(kw, optiondefs)
# Initialise the base class (after defining the options).
MegaWidget.__init__(self, parent)
# Create the components.
interior = self.interior()
self._scrolledFieldEntry = self.createcomponent('entry',
(), None,
Tkinter.Entry, (interior,))
# Can't always use 'disabled', since this greys out text in Tk 8.4.2
try:
self._scrolledFieldEntry.configure(state = 'readonly')
except Tkinter.TclError:
self._scrolledFieldEntry.configure(state = 'disabled')
self._scrolledFieldEntry.grid(column=2, row=2, sticky=self['sticky'])
interior.grid_columnconfigure(2, weight=1)
interior.grid_rowconfigure(2, weight=1)
self.createlabel(interior)
# Check keywords and initialise options.
self.initialiseoptions()
def _text(self):
text = self['text']
self._scrolledFieldEntry.configure(state = 'normal')
self._scrolledFieldEntry.delete(0, 'end')
self._scrolledFieldEntry.insert('end', text)
# Can't always use 'disabled', since this greys out text in Tk 8.4.2
try:
self._scrolledFieldEntry.configure(state = 'readonly')
except Tkinter.TclError:
self._scrolledFieldEntry.configure(state = 'disabled')
forwardmethods(ScrolledField, Tkinter.Entry, '_scrolledFieldEntry')
######################################################################
### File: PmwScrolledFrame.py
import string
import types
import Tkinter
class ScrolledFrame(MegaWidget):
def __init__(self, parent = None, **kw):
# Define the megawidget options.
optiondefs = (
('borderframe', 1, INITOPT),
('horizflex', 'fixed', self._horizflex),
('horizfraction', 0.05, INITOPT),
('hscrollmode', 'dynamic', self._hscrollMode),
('labelmargin', 0, INITOPT),
('labelpos', None, INITOPT),
('scrollmargin', 2, INITOPT),
('usehullsize', 0, INITOPT),
('vertflex', 'fixed', self._vertflex),
('vertfraction', 0.05, INITOPT),
('vscrollmode', 'dynamic', self._vscrollMode),
)
self.defineoptions(kw, optiondefs)
# Initialise the base class (after defining the options).
MegaWidget.__init__(self, parent)
# Create the components.
self.origInterior = MegaWidget.interior(self)
if self['usehullsize']:
self.origInterior.grid_propagate(0)
if self['borderframe']:
# Create a frame widget to act as the border of the clipper.
self._borderframe = self.createcomponent('borderframe',
(), None,
Tkinter.Frame, (self.origInterior,),
relief = 'sunken',
borderwidth = 2,
)
self._borderframe.grid(row = 2, column = 2, sticky = 'news')
# Create the clipping window.
self._clipper = self.createcomponent('clipper',
(), None,
Tkinter.Frame, (self._borderframe,),
width = 400,
height = 300,
highlightthickness = 0,
borderwidth = 0,
)
self._clipper.pack(fill = 'both', expand = 1)
else:
# Create the clipping window.
self._clipper = self.createcomponent('clipper',
(), None,
Tkinter.Frame, (self.origInterior,),
width = 400,
height = 300,
relief = 'sunken',
borderwidth = 2,
)
self._clipper.grid(row = 2, column = 2, sticky = 'news')
self.origInterior.grid_rowconfigure(2, weight = 1, minsize = 0)
self.origInterior.grid_columnconfigure(2, weight = 1, minsize = 0)
# Create the horizontal scrollbar
self._horizScrollbar = self.createcomponent('horizscrollbar',
(), 'Scrollbar',
Tkinter.Scrollbar, (self.origInterior,),
orient='horizontal',
command=self.xview
)
# Create the vertical scrollbar
self._vertScrollbar = self.createcomponent('vertscrollbar',
(), 'Scrollbar',
Tkinter.Scrollbar, (self.origInterior,),
orient='vertical',
command=self.yview
)
self.createlabel(self.origInterior, childCols = 3, childRows = 3)
# Initialise instance variables.
self._horizScrollbarOn = 0
self._vertScrollbarOn = 0
self.scrollTimer = None
self._scrollRecurse = 0
self._horizScrollbarNeeded = 0
self._vertScrollbarNeeded = 0
self.startX = 0
self.startY = 0
self._flexoptions = ('fixed', 'expand', 'shrink', 'elastic')
# Create a frame in the clipper to contain the widgets to be
# scrolled.
self._frame = self.createcomponent('frame',
(), None,
Tkinter.Frame, (self._clipper,)
)
# Whenever the clipping window or scrolled frame change size,
# update the scrollbars.
self._frame.bind('<Configure>', self._reposition)
self._clipper.bind('<Configure>', self._reposition)
# Work around a bug in Tk where the value returned by the
# scrollbar get() method is (0.0, 0.0, 0.0, 0.0) rather than
# the expected 2-tuple. This occurs if xview() is called soon
# after the ScrolledFrame has been created.
self._horizScrollbar.set(0.0, 1.0)
self._vertScrollbar.set(0.0, 1.0)
# Check keywords and initialise options.
self.initialiseoptions()
def destroy(self):
if self.scrollTimer is not None:
self.after_cancel(self.scrollTimer)
self.scrollTimer = None
MegaWidget.destroy(self)
# ======================================================================
# Public methods.
def interior(self):
return self._frame
# Set timer to call real reposition method, so that it is not
# called multiple times when many things are reconfigured at the
# same time.
def reposition(self):
if self.scrollTimer is None:
self.scrollTimer = self.after_idle(self._scrollBothNow)
# Called when the user clicks in the horizontal scrollbar.
# Calculates new position of frame then calls reposition() to
# update the frame and the scrollbar.
def xview(self, mode = None, value = None, units = None):
if type(value) == types.StringType:
value = string.atof(value)
if mode is None:
return self._horizScrollbar.get()
elif mode == 'moveto':
frameWidth = self._frame.winfo_reqwidth()
self.startX = value * float(frameWidth)
else: # mode == 'scroll'
clipperWidth = self._clipper.winfo_width()
if units == 'units':
jump = int(clipperWidth * self['horizfraction'])
else:
jump = clipperWidth
self.startX = self.startX + value * jump
self.reposition()
# Called when the user clicks in the vertical scrollbar.
# Calculates new position of frame then calls reposition() to
# update the frame and the scrollbar.
def yview(self, mode = None, value = None, units = None):
if type(value) == types.StringType:
value = string.atof(value)
if mode is None:
return self._vertScrollbar.get()
elif mode == 'moveto':
frameHeight = self._frame.winfo_reqheight()
self.startY = value * float(frameHeight)
else: # mode == 'scroll'
clipperHeight = self._clipper.winfo_height()
if units == 'units':
jump = int(clipperHeight * self['vertfraction'])
else:
jump = clipperHeight
self.startY = self.startY + value * jump
self.reposition()
# ======================================================================
# Configuration methods.
def _hscrollMode(self):
# The horizontal scroll mode has been configured.
mode = self['hscrollmode']
if mode == 'static':
if not self._horizScrollbarOn:
self._toggleHorizScrollbar()
elif mode == 'dynamic':
if self._horizScrollbarNeeded != self._horizScrollbarOn:
self._toggleHorizScrollbar()
elif mode == 'none':
if self._horizScrollbarOn:
self._toggleHorizScrollbar()
else:
message = 'bad hscrollmode option "%s": should be static, dynamic, or none' % mode
raise ValueError, message
def _vscrollMode(self):
# The vertical scroll mode has been configured.
mode = self['vscrollmode']
if mode == 'static':
if not self._vertScrollbarOn:
self._toggleVertScrollbar()
elif mode == 'dynamic':
if self._vertScrollbarNeeded != self._vertScrollbarOn:
self._toggleVertScrollbar()
elif mode == 'none':
if self._vertScrollbarOn:
self._toggleVertScrollbar()
else:
message = 'bad vscrollmode option "%s": should be static, dynamic, or none' % mode
raise ValueError, message
def _horizflex(self):
# The horizontal flex mode has been configured.
flex = self['horizflex']
if flex not in self._flexoptions:
message = 'bad horizflex option "%s": should be one of %s' % \
(flex, str(self._flexoptions))
raise ValueError, message
self.reposition()
def _vertflex(self):
# The vertical flex mode has been configured.
flex = self['vertflex']
if flex not in self._flexoptions:
message = 'bad vertflex option "%s": should be one of %s' % \
(flex, str(self._flexoptions))
raise ValueError, message
self.reposition()
# ======================================================================
# Private methods.
def _reposition(self, event):
self.reposition()
def _getxview(self):
# Horizontal dimension.
clipperWidth = self._clipper.winfo_width()
frameWidth = self._frame.winfo_reqwidth()
if frameWidth <= clipperWidth:
# The scrolled frame is smaller than the clipping window.
self.startX = 0
endScrollX = 1.0
if self['horizflex'] in ('expand', 'elastic'):
relwidth = 1
else:
relwidth = ''
else:
# The scrolled frame is larger than the clipping window.
if self['horizflex'] in ('shrink', 'elastic'):
self.startX = 0
endScrollX = 1.0
relwidth = 1
else:
if self.startX + clipperWidth > frameWidth:
self.startX = frameWidth - clipperWidth
endScrollX = 1.0
else:
if self.startX < 0:
self.startX = 0
endScrollX = (self.startX + clipperWidth) / float(frameWidth)
relwidth = ''
# Position frame relative to clipper.
self._frame.place(x = -self.startX, relwidth = relwidth)
return (self.startX / float(frameWidth), endScrollX)
def _getyview(self):
# Vertical dimension.
clipperHeight = self._clipper.winfo_height()
frameHeight = self._frame.winfo_reqheight()
if frameHeight <= clipperHeight:
# The scrolled frame is smaller than the clipping window.
self.startY = 0
endScrollY = 1.0
if self['vertflex'] in ('expand', 'elastic'):
relheight = 1
else:
relheight = ''
else:
# The scrolled frame is larger than the clipping window.
if self['vertflex'] in ('shrink', 'elastic'):
self.startY = 0
endScrollY = 1.0
relheight = 1
else:
if self.startY + clipperHeight > frameHeight:
self.startY = frameHeight - clipperHeight
endScrollY = 1.0
else:
if self.startY < 0:
self.startY = 0
endScrollY = (self.startY + clipperHeight) / float(frameHeight)
relheight = ''
# Position frame relative to clipper.
self._frame.place(y = -self.startY, relheight = relheight)
return (self.startY / float(frameHeight), endScrollY)
# According to the relative geometries of the frame and the
# clipper, reposition the frame within the clipper and reset the
# scrollbars.
def _scrollBothNow(self):
self.scrollTimer = None
# Call update_idletasks to make sure that the containing frame
# has been resized before we attempt to set the scrollbars.
# Otherwise the scrollbars may be mapped/unmapped continuously.
self._scrollRecurse = self._scrollRecurse + 1
self.update_idletasks()
self._scrollRecurse = self._scrollRecurse - 1
if self._scrollRecurse != 0:
return
xview = self._getxview()
yview = self._getyview()
self._horizScrollbar.set(xview[0], xview[1])
self._vertScrollbar.set(yview[0], yview[1])
self._horizScrollbarNeeded = (xview != (0.0, 1.0))
self._vertScrollbarNeeded = (yview != (0.0, 1.0))
# If both horizontal and vertical scrollmodes are dynamic and
# currently only one scrollbar is mapped and both should be
# toggled, then unmap the mapped scrollbar. This prevents a
# continuous mapping and unmapping of the scrollbars.
if (self['hscrollmode'] == self['vscrollmode'] == 'dynamic' and
self._horizScrollbarNeeded != self._horizScrollbarOn and
self._vertScrollbarNeeded != self._vertScrollbarOn and
self._vertScrollbarOn != self._horizScrollbarOn):
if self._horizScrollbarOn:
self._toggleHorizScrollbar()
else:
self._toggleVertScrollbar()
return
if self['hscrollmode'] == 'dynamic':
if self._horizScrollbarNeeded != self._horizScrollbarOn:
self._toggleHorizScrollbar()
if self['vscrollmode'] == 'dynamic':
if self._vertScrollbarNeeded != self._vertScrollbarOn:
self._toggleVertScrollbar()
def _toggleHorizScrollbar(self):
self._horizScrollbarOn = not self._horizScrollbarOn
interior = self.origInterior
if self._horizScrollbarOn:
self._horizScrollbar.grid(row = 4, column = 2, sticky = 'news')
interior.grid_rowconfigure(3, minsize = self['scrollmargin'])
else:
self._horizScrollbar.grid_forget()
interior.grid_rowconfigure(3, minsize = 0)
def _toggleVertScrollbar(self):
self._vertScrollbarOn = not self._vertScrollbarOn
interior = self.origInterior
if self._vertScrollbarOn:
self._vertScrollbar.grid(row = 2, column = 4, sticky = 'news')
interior.grid_columnconfigure(3, minsize = self['scrollmargin'])
else:
self._vertScrollbar.grid_forget()
interior.grid_columnconfigure(3, minsize = 0)
######################################################################
### File: PmwScrolledListBox.py
# Based on iwidgets2.2.0/scrolledlistbox.itk code.
import types
import Tkinter
class ScrolledListBox(MegaWidget):
_classBindingsDefinedFor = 0
def __init__(self, parent = None, **kw):
# Define the megawidget options.
optiondefs = (
('dblclickcommand', None, None),
('hscrollmode', 'dynamic', self._hscrollMode),
('items', (), INITOPT),
('labelmargin', 0, INITOPT),
('labelpos', None, INITOPT),
('scrollmargin', 2, INITOPT),
('selectioncommand', None, None),
('usehullsize', 0, INITOPT),
('vscrollmode', 'dynamic', self._vscrollMode),
)
self.defineoptions(kw, optiondefs)
# Initialise the base class (after defining the options).
MegaWidget.__init__(self, parent)
# Create the components.
interior = self.interior()
if self['usehullsize']:
interior.grid_propagate(0)
# Create the listbox widget.
self._listbox = self.createcomponent('listbox',
(), None,
Tkinter.Listbox, (interior,))
self._listbox.grid(row = 2, column = 2, sticky = 'news')
interior.grid_rowconfigure(2, weight = 1, minsize = 0)
interior.grid_columnconfigure(2, weight = 1, minsize = 0)
# Create the horizontal scrollbar
self._horizScrollbar = self.createcomponent('horizscrollbar',
(), 'Scrollbar',
Tkinter.Scrollbar, (interior,),
orient='horizontal',
command=self._listbox.xview
)
# Create the vertical scrollbar
self._vertScrollbar = self.createcomponent('vertscrollbar',
(), 'Scrollbar',
Tkinter.Scrollbar, (interior,),
orient='vertical',
command=self._listbox.yview
)
self.createlabel(interior, childCols = 3, childRows = 3)
# Add the items specified by the initialisation option.
items = self['items']
if type(items) != types.TupleType:
items = tuple(items)
if len(items) > 0:
apply(self._listbox.insert, ('end',) + items)
_registerScrolledList(self._listbox, self)
# Establish the special class bindings if not already done.
# Also create bindings if the Tkinter default interpreter has
# changed. Use Tkinter._default_root to create class
# bindings, so that a reference to root is created by
# bind_class rather than a reference to self, which would
# prevent object cleanup.
theTag = 'ScrolledListBoxTag'
if ScrolledListBox._classBindingsDefinedFor != Tkinter._default_root:
root = Tkinter._default_root
def doubleEvent(event):
_handleEvent(event, 'double')
def keyEvent(event):
_handleEvent(event, 'key')
def releaseEvent(event):
_handleEvent(event, 'release')
# Bind space and return keys and button 1 to the selectioncommand.
root.bind_class(theTag, '<Key-space>', keyEvent)
root.bind_class(theTag, '<Key-Return>', keyEvent)
root.bind_class(theTag, '<ButtonRelease-1>', releaseEvent)
# Bind double button 1 click to the dblclickcommand.
root.bind_class(theTag, '<Double-ButtonRelease-1>', doubleEvent)
ScrolledListBox._classBindingsDefinedFor = root
bindtags = self._listbox.bindtags()
self._listbox.bindtags(bindtags + (theTag,))
# Initialise instance variables.
self._horizScrollbarOn = 0
self._vertScrollbarOn = 0
self.scrollTimer = None
self._scrollRecurse = 0
self._horizScrollbarNeeded = 0
self._vertScrollbarNeeded = 0
# Check keywords and initialise options.
self.initialiseoptions()
def destroy(self):
if self.scrollTimer is not None:
self.after_cancel(self.scrollTimer)
self.scrollTimer = None
_deregisterScrolledList(self._listbox)
MegaWidget.destroy(self)
# ======================================================================
# Public methods.
def clear(self):
self.setlist(())
def getcurselection(self):
rtn = []
for sel in self.curselection():
rtn.append(self._listbox.get(sel))
return tuple(rtn)
def getvalue(self):
return self.getcurselection()
def setvalue(self, textOrList):
self._listbox.selection_clear(0, 'end')
listitems = list(self._listbox.get(0, 'end'))
if type(textOrList) == types.StringType:
if textOrList in listitems:
self._listbox.selection_set(listitems.index(textOrList))
else:
raise ValueError, 'no such item "%s"' % textOrList
else:
for item in textOrList:
if item in listitems:
self._listbox.selection_set(listitems.index(item))
else:
raise ValueError, 'no such item "%s"' % item
def setlist(self, items):
self._listbox.delete(0, 'end')
if len(items) > 0:
if type(items) != types.TupleType:
items = tuple(items)
apply(self._listbox.insert, (0,) + items)
# Override Tkinter.Listbox get method, so that if it is called with
# no arguments, return all list elements (consistent with other widgets).
def get(self, first=None, last=None):
if first is None:
return self._listbox.get(0, 'end')
else:
return self._listbox.get(first, last)
# ======================================================================
# Configuration methods.
def _hscrollMode(self):
# The horizontal scroll mode has been configured.
mode = self['hscrollmode']
if mode == 'static':
if not self._horizScrollbarOn:
self._toggleHorizScrollbar()
elif mode == 'dynamic':
if self._horizScrollbarNeeded != self._horizScrollbarOn:
self._toggleHorizScrollbar()
elif mode == 'none':
if self._horizScrollbarOn:
self._toggleHorizScrollbar()
else:
message = 'bad hscrollmode option "%s": should be static, dynamic, or none' % mode
raise ValueError, message
self._configureScrollCommands()
def _vscrollMode(self):
# The vertical scroll mode has been configured.
mode = self['vscrollmode']
if mode == 'static':
if not self._vertScrollbarOn:
self._toggleVertScrollbar()
elif mode == 'dynamic':
if self._vertScrollbarNeeded != self._vertScrollbarOn:
self._toggleVertScrollbar()
elif mode == 'none':
if self._vertScrollbarOn:
self._toggleVertScrollbar()
else:
message = 'bad vscrollmode option "%s": should be static, dynamic, or none' % mode
raise ValueError, message
self._configureScrollCommands()
# ======================================================================
# Private methods.
def _configureScrollCommands(self):
# If both scrollmodes are not dynamic we can save a lot of
# time by not having to create an idle job to handle the
# scroll commands.
# Clean up previous scroll commands to prevent memory leak.
tclCommandName = str(self._listbox.cget('xscrollcommand'))
if tclCommandName != '':
self._listbox.deletecommand(tclCommandName)
tclCommandName = str(self._listbox.cget('yscrollcommand'))
if tclCommandName != '':
self._listbox.deletecommand(tclCommandName)
if self['hscrollmode'] == self['vscrollmode'] == 'dynamic':
self._listbox.configure(
xscrollcommand=self._scrollBothLater,
yscrollcommand=self._scrollBothLater
)
else:
self._listbox.configure(
xscrollcommand=self._scrollXNow,
yscrollcommand=self._scrollYNow
)
def _scrollXNow(self, first, last):
self._horizScrollbar.set(first, last)
self._horizScrollbarNeeded = ((first, last) != ('0', '1'))
if self['hscrollmode'] == 'dynamic':
if self._horizScrollbarNeeded != self._horizScrollbarOn:
self._toggleHorizScrollbar()
def _scrollYNow(self, first, last):
self._vertScrollbar.set(first, last)
self._vertScrollbarNeeded = ((first, last) != ('0', '1'))
if self['vscrollmode'] == 'dynamic':
if self._vertScrollbarNeeded != self._vertScrollbarOn:
self._toggleVertScrollbar()
def _scrollBothLater(self, first, last):
# Called by the listbox to set the horizontal or vertical
# scrollbar when it has scrolled or changed size or contents.
if self.scrollTimer is None:
self.scrollTimer = self.after_idle(self._scrollBothNow)
def _scrollBothNow(self):
# This performs the function of _scrollXNow and _scrollYNow.
# If one is changed, the other should be updated to match.
self.scrollTimer = None
# Call update_idletasks to make sure that the containing frame
# has been resized before we attempt to set the scrollbars.
# Otherwise the scrollbars may be mapped/unmapped continuously.
self._scrollRecurse = self._scrollRecurse + 1
self.update_idletasks()
self._scrollRecurse = self._scrollRecurse - 1
if self._scrollRecurse != 0:
return
xview = self._listbox.xview()
yview = self._listbox.yview()
self._horizScrollbar.set(xview[0], xview[1])
self._vertScrollbar.set(yview[0], yview[1])
self._horizScrollbarNeeded = (xview != (0.0, 1.0))
self._vertScrollbarNeeded = (yview != (0.0, 1.0))
# If both horizontal and vertical scrollmodes are dynamic and
# currently only one scrollbar is mapped and both should be
# toggled, then unmap the mapped scrollbar. This prevents a
# continuous mapping and unmapping of the scrollbars.
if (self['hscrollmode'] == self['vscrollmode'] == 'dynamic' and
self._horizScrollbarNeeded != self._horizScrollbarOn and
self._vertScrollbarNeeded != self._vertScrollbarOn and
self._vertScrollbarOn != self._horizScrollbarOn):
if self._horizScrollbarOn:
self._toggleHorizScrollbar()
else:
self._toggleVertScrollbar()
return
if self['hscrollmode'] == 'dynamic':
if self._horizScrollbarNeeded != self._horizScrollbarOn:
self._toggleHorizScrollbar()
if self['vscrollmode'] == 'dynamic':
if self._vertScrollbarNeeded != self._vertScrollbarOn:
self._toggleVertScrollbar()
def _toggleHorizScrollbar(self):
self._horizScrollbarOn = not self._horizScrollbarOn
interior = self.interior()
if self._horizScrollbarOn:
self._horizScrollbar.grid(row = 4, column = 2, sticky = 'news')
interior.grid_rowconfigure(3, minsize = self['scrollmargin'])
else:
self._horizScrollbar.grid_forget()
interior.grid_rowconfigure(3, minsize = 0)
def _toggleVertScrollbar(self):
self._vertScrollbarOn = not self._vertScrollbarOn
interior = self.interior()
if self._vertScrollbarOn:
self._vertScrollbar.grid(row = 2, column = 4, sticky = 'news')
interior.grid_columnconfigure(3, minsize = self['scrollmargin'])
else:
self._vertScrollbar.grid_forget()
interior.grid_columnconfigure(3, minsize = 0)
def _handleEvent(self, event, eventType):
if eventType == 'double':
command = self['dblclickcommand']
elif eventType == 'key':
command = self['selectioncommand']
else: #eventType == 'release'
# Do not execute the command if the mouse was released
# outside the listbox.
if (event.x < 0 or self._listbox.winfo_width() <= event.x or
event.y < 0 or self._listbox.winfo_height() <= event.y):
return
command = self['selectioncommand']
if callable(command):
command()
# Need to explicitly forward this to override the stupid
# (grid_)size method inherited from Tkinter.Frame.Grid.
def size(self):
return self._listbox.size()
# Need to explicitly forward this to override the stupid
# (grid_)bbox method inherited from Tkinter.Frame.Grid.
def bbox(self, index):
return self._listbox.bbox(index)
forwardmethods(ScrolledListBox, Tkinter.Listbox, '_listbox')
# ======================================================================
_listboxCache = {}
def _registerScrolledList(listbox, scrolledList):
# Register an ScrolledList widget for a Listbox widget
_listboxCache[listbox] = scrolledList
def _deregisterScrolledList(listbox):
# Deregister a Listbox widget
del _listboxCache[listbox]
def _handleEvent(event, eventType):
# Forward events for a Listbox to it's ScrolledListBox
# A binding earlier in the bindtags list may have destroyed the
# megawidget, so need to check.
if _listboxCache.has_key(event.widget):
_listboxCache[event.widget]._handleEvent(event, eventType)
######################################################################
### File: PmwScrolledText.py
# Based on iwidgets2.2.0/scrolledtext.itk code.
import Tkinter
class ScrolledText(MegaWidget):
def __init__(self, parent = None, **kw):
# Define the megawidget options.
optiondefs = (
('borderframe', 0, INITOPT),
('columnheader', 0, INITOPT),
('hscrollmode', 'dynamic', self._hscrollMode),
('labelmargin', 0, INITOPT),
('labelpos', None, INITOPT),
('rowcolumnheader',0, INITOPT),
('rowheader', 0, INITOPT),
('scrollmargin', 2, INITOPT),
('usehullsize', 0, INITOPT),
('vscrollmode', 'dynamic', self._vscrollMode),
)
self.defineoptions(kw, optiondefs)
# Initialise the base class (after defining the options).
MegaWidget.__init__(self, parent)
# Create the components.
interior = self.interior()
if self['usehullsize']:
interior.grid_propagate(0)
if self['borderframe']:
# Create a frame widget to act as the border of the text
# widget. Later, pack the text widget so that it fills
# the frame. This avoids a problem in Tk, where window
# items in a text widget may overlap the border of the
# text widget.
self._borderframe = self.createcomponent('borderframe',
(), None,
Tkinter.Frame, (interior,),
relief = 'sunken',
borderwidth = 2,
)
self._borderframe.grid(row = 4, column = 4, sticky = 'news')
# Create the text widget.
self._textbox = self.createcomponent('text',
(), None,
Tkinter.Text, (self._borderframe,),
highlightthickness = 0,
borderwidth = 0,
)
self._textbox.pack(fill = 'both', expand = 1)
bw = self._borderframe.cget('borderwidth'),
ht = self._borderframe.cget('highlightthickness'),
else:
# Create the text widget.
self._textbox = self.createcomponent('text',
(), None,
Tkinter.Text, (interior,),
)
self._textbox.grid(row = 4, column = 4, sticky = 'news')
bw = self._textbox.cget('borderwidth'),
ht = self._textbox.cget('highlightthickness'),
# Create the header text widgets
if self['columnheader']:
self._columnheader = self.createcomponent('columnheader',
(), 'Header',
Tkinter.Text, (interior,),
height=1,
wrap='none',
borderwidth = bw,
highlightthickness = ht,
)
self._columnheader.grid(row = 2, column = 4, sticky = 'ew')
self._columnheader.configure(
xscrollcommand = self._columnheaderscrolled)
if self['rowheader']:
self._rowheader = self.createcomponent('rowheader',
(), 'Header',
Tkinter.Text, (interior,),
wrap='none',
borderwidth = bw,
highlightthickness = ht,
)
self._rowheader.grid(row = 4, column = 2, sticky = 'ns')
self._rowheader.configure(
yscrollcommand = self._rowheaderscrolled)
if self['rowcolumnheader']:
self._rowcolumnheader = self.createcomponent('rowcolumnheader',
(), 'Header',
Tkinter.Text, (interior,),
height=1,
wrap='none',
borderwidth = bw,
highlightthickness = ht,
)
self._rowcolumnheader.grid(row = 2, column = 2, sticky = 'nsew')
interior.grid_rowconfigure(4, weight = 1, minsize = 0)
interior.grid_columnconfigure(4, weight = 1, minsize = 0)
# Create the horizontal scrollbar
self._horizScrollbar = self.createcomponent('horizscrollbar',
(), 'Scrollbar',
Tkinter.Scrollbar, (interior,),
orient='horizontal',
command=self._textbox.xview
)
# Create the vertical scrollbar
self._vertScrollbar = self.createcomponent('vertscrollbar',
(), 'Scrollbar',
Tkinter.Scrollbar, (interior,),
orient='vertical',
command=self._textbox.yview
)
self.createlabel(interior, childCols = 5, childRows = 5)
# Initialise instance variables.
self._horizScrollbarOn = 0
self._vertScrollbarOn = 0
self.scrollTimer = None
self._scrollRecurse = 0
self._horizScrollbarNeeded = 0
self._vertScrollbarNeeded = 0
self._textWidth = None
# These four variables avoid an infinite loop caused by the
# row or column header's scrollcommand causing the main text
# widget's scrollcommand to be called and vice versa.
self._textboxLastX = None
self._textboxLastY = None
self._columnheaderLastX = None
self._rowheaderLastY = None
# Check keywords and initialise options.
self.initialiseoptions()
def destroy(self):
if self.scrollTimer is not None:
self.after_cancel(self.scrollTimer)
self.scrollTimer = None
MegaWidget.destroy(self)
# ======================================================================
# Public methods.
def clear(self):
self.settext('')
def importfile(self, fileName, where = 'end'):
file = open(fileName, 'r')
self._textbox.insert(where, file.read())
file.close()
def exportfile(self, fileName):
file = open(fileName, 'w')
file.write(self._textbox.get('1.0', 'end'))
file.close()
def settext(self, text):
disabled = (str(self._textbox.cget('state')) == 'disabled')
if disabled:
self._textbox.configure(state='normal')
self._textbox.delete('0.0', 'end')
self._textbox.insert('end', text)
if disabled:
self._textbox.configure(state='disabled')
# Override Tkinter.Text get method, so that if it is called with
# no arguments, return all text (consistent with other widgets).
def get(self, first=None, last=None):
if first is None:
return self._textbox.get('1.0', 'end')
else:
return self._textbox.get(first, last)
def getvalue(self):
return self.get()
def setvalue(self, text):
return self.settext(text)
def appendtext(self, text):
oldTop, oldBottom = self._textbox.yview()
disabled = (str(self._textbox.cget('state')) == 'disabled')
if disabled:
self._textbox.configure(state='normal')
self._textbox.insert('end', text)
if disabled:
self._textbox.configure(state='disabled')
if oldBottom == 1.0:
self._textbox.yview('moveto', 1.0)
# ======================================================================
# Configuration methods.
def _hscrollMode(self):
# The horizontal scroll mode has been configured.
mode = self['hscrollmode']
if mode == 'static':
if not self._horizScrollbarOn:
self._toggleHorizScrollbar()
elif mode == 'dynamic':
if self._horizScrollbarNeeded != self._horizScrollbarOn:
self._toggleHorizScrollbar()
elif mode == 'none':
if self._horizScrollbarOn:
self._toggleHorizScrollbar()
else:
message = 'bad hscrollmode option "%s": should be static, dynamic, or none' % mode
raise ValueError, message
self._configureScrollCommands()
def _vscrollMode(self):
# The vertical scroll mode has been configured.
mode = self['vscrollmode']
if mode == 'static':
if not self._vertScrollbarOn:
self._toggleVertScrollbar()
elif mode == 'dynamic':
if self._vertScrollbarNeeded != self._vertScrollbarOn:
self._toggleVertScrollbar()
elif mode == 'none':
if self._vertScrollbarOn:
self._toggleVertScrollbar()
else:
message = 'bad vscrollmode option "%s": should be static, dynamic, or none' % mode
raise ValueError, message
self._configureScrollCommands()
# ======================================================================
# Private methods.
def _configureScrollCommands(self):
# If both scrollmodes are not dynamic we can save a lot of
# time by not having to create an idle job to handle the
# scroll commands.
# Clean up previous scroll commands to prevent memory leak.
tclCommandName = str(self._textbox.cget('xscrollcommand'))
if tclCommandName != '':
self._textbox.deletecommand(tclCommandName)
tclCommandName = str(self._textbox.cget('yscrollcommand'))
if tclCommandName != '':
self._textbox.deletecommand(tclCommandName)
if self['hscrollmode'] == self['vscrollmode'] == 'dynamic':
self._textbox.configure(
xscrollcommand=self._scrollBothLater,
yscrollcommand=self._scrollBothLater
)
else:
self._textbox.configure(
xscrollcommand=self._scrollXNow,
yscrollcommand=self._scrollYNow
)
def _scrollXNow(self, first, last):
self._horizScrollbar.set(first, last)
self._horizScrollbarNeeded = ((first, last) != ('0', '1'))
# This code is the same as in _scrollBothNow. Keep it that way.
if self['hscrollmode'] == 'dynamic':
currentWidth = self._textbox.winfo_width()
if self._horizScrollbarNeeded != self._horizScrollbarOn:
if self._horizScrollbarNeeded or \
self._textWidth != currentWidth:
self._toggleHorizScrollbar()
self._textWidth = currentWidth
if self['columnheader']:
if self._columnheaderLastX != first:
self._columnheaderLastX = first
self._columnheader.xview('moveto', first)
def _scrollYNow(self, first, last):
if first == '0' and last == '0':
return
self._vertScrollbar.set(first, last)
self._vertScrollbarNeeded = ((first, last) != ('0', '1'))
if self['vscrollmode'] == 'dynamic':
if self._vertScrollbarNeeded != self._vertScrollbarOn:
self._toggleVertScrollbar()
if self['rowheader']:
if self._rowheaderLastY != first:
self._rowheaderLastY = first
self._rowheader.yview('moveto', first)
def _scrollBothLater(self, first, last):
# Called by the text widget to set the horizontal or vertical
# scrollbar when it has scrolled or changed size or contents.
if self.scrollTimer is None:
self.scrollTimer = self.after_idle(self._scrollBothNow)
def _scrollBothNow(self):
# This performs the function of _scrollXNow and _scrollYNow.
# If one is changed, the other should be updated to match.
self.scrollTimer = None
# Call update_idletasks to make sure that the containing frame
# has been resized before we attempt to set the scrollbars.
# Otherwise the scrollbars may be mapped/unmapped continuously.
self._scrollRecurse = self._scrollRecurse + 1
self.update_idletasks()
self._scrollRecurse = self._scrollRecurse - 1
if self._scrollRecurse != 0:
return
xview = self._textbox.xview()
yview = self._textbox.yview()
# The text widget returns a yview of (0.0, 0.0) just after it
# has been created. Ignore this.
if yview == (0.0, 0.0):
return
if self['columnheader']:
if self._columnheaderLastX != xview[0]:
self._columnheaderLastX = xview[0]
self._columnheader.xview('moveto', xview[0])
if self['rowheader']:
if self._rowheaderLastY != yview[0]:
self._rowheaderLastY = yview[0]
self._rowheader.yview('moveto', yview[0])
self._horizScrollbar.set(xview[0], xview[1])
self._vertScrollbar.set(yview[0], yview[1])
self._horizScrollbarNeeded = (xview != (0.0, 1.0))
self._vertScrollbarNeeded = (yview != (0.0, 1.0))
# If both horizontal and vertical scrollmodes are dynamic and
# currently only one scrollbar is mapped and both should be
# toggled, then unmap the mapped scrollbar. This prevents a
# continuous mapping and unmapping of the scrollbars.
if (self['hscrollmode'] == self['vscrollmode'] == 'dynamic' and
self._horizScrollbarNeeded != self._horizScrollbarOn and
self._vertScrollbarNeeded != self._vertScrollbarOn and
self._vertScrollbarOn != self._horizScrollbarOn):
if self._horizScrollbarOn:
self._toggleHorizScrollbar()
else:
self._toggleVertScrollbar()
return
if self['hscrollmode'] == 'dynamic':
# The following test is done to prevent continuous
# mapping and unmapping of the horizontal scrollbar.
# This may occur when some event (scrolling, resizing
# or text changes) modifies the displayed text such
# that the bottom line in the window is the longest
# line displayed. If this causes the horizontal
# scrollbar to be mapped, the scrollbar may "cover up"
# the bottom line, which would mean that the scrollbar
# is no longer required. If the scrollbar is then
# unmapped, the bottom line will then become visible
# again, which would cause the scrollbar to be mapped
# again, and so on...
#
# The idea is that, if the width of the text widget
# has not changed and the scrollbar is currently
# mapped, then do not unmap the scrollbar even if it
# is no longer required. This means that, during
# normal scrolling of the text, once the horizontal
# scrollbar has been mapped it will not be unmapped
# (until the width of the text widget changes).
currentWidth = self._textbox.winfo_width()
if self._horizScrollbarNeeded != self._horizScrollbarOn:
if self._horizScrollbarNeeded or \
self._textWidth != currentWidth:
self._toggleHorizScrollbar()
self._textWidth = currentWidth
if self['vscrollmode'] == 'dynamic':
if self._vertScrollbarNeeded != self._vertScrollbarOn:
self._toggleVertScrollbar()
def _columnheaderscrolled(self, first, last):
if self._textboxLastX != first:
self._textboxLastX = first
self._textbox.xview('moveto', first)
def _rowheaderscrolled(self, first, last):
if self._textboxLastY != first:
self._textboxLastY = first
self._textbox.yview('moveto', first)
def _toggleHorizScrollbar(self):
self._horizScrollbarOn = not self._horizScrollbarOn
interior = self.interior()
if self._horizScrollbarOn:
self._horizScrollbar.grid(row = 6, column = 4, sticky = 'news')
interior.grid_rowconfigure(5, minsize = self['scrollmargin'])
else:
self._horizScrollbar.grid_forget()
interior.grid_rowconfigure(5, minsize = 0)
def _toggleVertScrollbar(self):
self._vertScrollbarOn = not self._vertScrollbarOn
interior = self.interior()
if self._vertScrollbarOn:
self._vertScrollbar.grid(row = 4, column = 6, sticky = 'news')
interior.grid_columnconfigure(5, minsize = self['scrollmargin'])
else:
self._vertScrollbar.grid_forget()
interior.grid_columnconfigure(5, minsize = 0)
# Need to explicitly forward this to override the stupid
# (grid_)bbox method inherited from Tkinter.Frame.Grid.
def bbox(self, index):
return self._textbox.bbox(index)
forwardmethods(ScrolledText, Tkinter.Text, '_textbox')
######################################################################
### File: PmwHistoryText.py
_ORIGINAL = 0
_MODIFIED = 1
_DISPLAY = 2
class HistoryText(ScrolledText):
def __init__(self, parent = None, **kw):
# Define the megawidget options.
optiondefs = (
('compressany', 1, None),
('compresstail', 1, None),
('historycommand', None, None),
)
self.defineoptions(kw, optiondefs)
# Initialise the base class (after defining the options).
ScrolledText.__init__(self, parent)
# Initialise instance variables.
self._list = []
self._currIndex = 0
self._pastIndex = None
self._lastIndex = 0 # pointer to end of history list
# Check keywords and initialise options.
self.initialiseoptions()
def addhistory(self):
text = self.get()
if text[-1] == '\n':
text = text[:-1]
if len(self._list) == 0:
# This is the first history entry. Add it.
self._list.append([text, text, _MODIFIED])
return
currentEntry = self._list[self._currIndex]
if text == currentEntry[_ORIGINAL]:
# The current history entry has not been modified. Check if
# we need to add it again.
if self['compresstail'] and self._currIndex == self._lastIndex:
return
if self['compressany']:
return
# Undo any changes for the current history entry, since they
# will now be available in the new entry.
currentEntry[_MODIFIED] = currentEntry[_ORIGINAL]
historycommand = self['historycommand']
if self._currIndex == self._lastIndex:
# The last history entry is currently being displayed,
# so disable the special meaning of the 'Next' button.
self._pastIndex = None
nextState = 'disabled'
else:
# A previous history entry is currently being displayed,
# so allow the 'Next' button to go to the entry after this one.
self._pastIndex = self._currIndex
nextState = 'normal'
if callable(historycommand):
historycommand('normal', nextState)
# Create the new history entry.
self._list.append([text, text, _MODIFIED])
# Move the pointer into the history entry list to the end.
self._lastIndex = self._lastIndex + 1
self._currIndex = self._lastIndex
def next(self):
if self._currIndex == self._lastIndex and self._pastIndex is None:
self.bell()
else:
self._modifyDisplay('next')
def prev(self):
self._pastIndex = None
if self._currIndex == 0:
self.bell()
else:
self._modifyDisplay('prev')
def undo(self):
if len(self._list) != 0:
self._modifyDisplay('undo')
def redo(self):
if len(self._list) != 0:
self._modifyDisplay('redo')
def gethistory(self):
return self._list
def _modifyDisplay(self, command):
# Modify the display to show either the next or previous
# history entry (next, prev) or the original or modified
# version of the current history entry (undo, redo).
# Save the currently displayed text.
currentText = self.get()
if currentText[-1] == '\n':
currentText = currentText[:-1]
currentEntry = self._list[self._currIndex]
if currentEntry[_DISPLAY] == _MODIFIED:
currentEntry[_MODIFIED] = currentText
elif currentEntry[_ORIGINAL] != currentText:
currentEntry[_MODIFIED] = currentText
if command in ('next', 'prev'):
currentEntry[_DISPLAY] = _MODIFIED
if command in ('next', 'prev'):
prevstate = 'normal'
nextstate = 'normal'
if command == 'next':
if self._pastIndex is not None:
self._currIndex = self._pastIndex
self._pastIndex = None
self._currIndex = self._currIndex + 1
if self._currIndex == self._lastIndex:
nextstate = 'disabled'
elif command == 'prev':
self._currIndex = self._currIndex - 1
if self._currIndex == 0:
prevstate = 'disabled'
historycommand = self['historycommand']
if callable(historycommand):
historycommand(prevstate, nextstate)
currentEntry = self._list[self._currIndex]
else:
if command == 'undo':
currentEntry[_DISPLAY] = _ORIGINAL
elif command == 'redo':
currentEntry[_DISPLAY] = _MODIFIED
# Display the new text.
self.delete('1.0', 'end')
self.insert('end', currentEntry[currentEntry[_DISPLAY]])
######################################################################
### File: PmwSelectionDialog.py
# Not Based on iwidgets version.
class SelectionDialog(Dialog):
# Dialog window with selection list.
# Dialog window displaying a list and requesting the user to
# select one.
def __init__(self, parent = None, **kw):
# Define the megawidget options.
optiondefs = (
('borderx', 10, INITOPT),
('bordery', 10, INITOPT),
)
self.defineoptions(kw, optiondefs)
# Initialise the base class (after defining the options).
Dialog.__init__(self, parent)
# Create the components.
interior = self.interior()
aliases = (
('listbox', 'scrolledlist_listbox'),
('label', 'scrolledlist_label'),
)
self._list = self.createcomponent('scrolledlist',
aliases, None,
ScrolledListBox, (interior,),
dblclickcommand = self.invoke)
self._list.pack(side='top', expand='true', fill='both',
padx = self['borderx'], pady = self['bordery'])
if not kw.has_key('activatecommand'):
# Whenever this dialog is activated, set the focus to the
# ScrolledListBox's listbox widget.
listbox = self.component('listbox')
self.configure(activatecommand = listbox.focus_set)
# Check keywords and initialise options.
self.initialiseoptions()
# Need to explicitly forward this to override the stupid
# (grid_)size method inherited from Tkinter.Toplevel.Grid.
def size(self):
return self.component('listbox').size()
# Need to explicitly forward this to override the stupid
# (grid_)bbox method inherited from Tkinter.Toplevel.Grid.
def bbox(self, index):
return self.component('listbox').size(index)
forwardmethods(SelectionDialog, ScrolledListBox, '_list')
######################################################################
### File: PmwTextDialog.py
# A Dialog with a ScrolledText widget.
class TextDialog(Dialog):
def __init__(self, parent = None, **kw):
# Define the megawidget options.
optiondefs = (
('borderx', 10, INITOPT),
('bordery', 10, INITOPT),
)
self.defineoptions(kw, optiondefs)
# Initialise the base class (after defining the options).
Dialog.__init__(self, parent)
# Create the components.
interior = self.interior()
aliases = (
('text', 'scrolledtext_text'),
('label', 'scrolledtext_label'),
)
self._text = self.createcomponent('scrolledtext',
aliases, None,
ScrolledText, (interior,))
self._text.pack(side='top', expand=1, fill='both',
padx = self['borderx'], pady = self['bordery'])
# Check keywords and initialise options.
self.initialiseoptions()
# Need to explicitly forward this to override the stupid
# (grid_)bbox method inherited from Tkinter.Toplevel.Grid.
def bbox(self, index):
return self._text.bbox(index)
forwardmethods(TextDialog, ScrolledText, '_text')
######################################################################
### File: PmwTimeCounter.py
# Authors: Joe VanAndel and Greg McFarlane
import string
import sys
import time
import Tkinter
class TimeCounter(MegaWidget):
"""Up-down counter
A TimeCounter is a single-line entry widget with Up and Down arrows
which increment and decrement the Time value in the entry.
"""
def __init__(self, parent = None, **kw):
# Define the megawidget options.
optiondefs = (
('autorepeat', 1, None),
('buttonaspect', 1.0, INITOPT),
('command', None, None),
('initwait', 300, None),
('labelmargin', 0, INITOPT),
('labelpos', None, INITOPT),
('max', None, self._max),
('min', None, self._min),
('padx', 0, INITOPT),
('pady', 0, INITOPT),
('repeatrate', 50, None),
('value', None, INITOPT),
)
self.defineoptions(kw, optiondefs)
# Initialise the base class (after defining the options).
MegaWidget.__init__(self, parent)
self.arrowDirection = {}
self._flag = 'stopped'
self._timerId = None
self._createComponents(kw)
value = self['value']
if value is None:
now = time.time()
value = time.strftime('%H:%M:%S', time.localtime(now))
self.setvalue(value)
# Check keywords and initialise options.
self.initialiseoptions()
def _createComponents(self, kw):
# Create the components.
interior = self.interior()
# If there is no label, put the arrows and the entry directly
# into the interior, otherwise create a frame for them. In
# either case the border around the arrows and the entry will
# be raised (but not around the label).
if self['labelpos'] is None:
frame = interior
if not kw.has_key('hull_relief'):
frame.configure(relief = 'raised')
if not kw.has_key('hull_borderwidth'):
frame.configure(borderwidth = 1)
else:
frame = self.createcomponent('frame',
(), None,
Tkinter.Frame, (interior,),
relief = 'raised', borderwidth = 1)
frame.grid(column=2, row=2, sticky='nsew')
interior.grid_columnconfigure(2, weight=1)
interior.grid_rowconfigure(2, weight=1)
# Create the down arrow buttons.
# Create the hour down arrow.
self._downHourArrowBtn = self.createcomponent('downhourarrow',
(), 'Arrow',
Tkinter.Canvas, (frame,),
width = 16, height = 16, relief = 'raised', borderwidth = 2)
self.arrowDirection[self._downHourArrowBtn] = 'down'
self._downHourArrowBtn.grid(column = 0, row = 2)
# Create the minute down arrow.
self._downMinuteArrowBtn = self.createcomponent('downminutearrow',
(), 'Arrow',
Tkinter.Canvas, (frame,),
width = 16, height = 16, relief = 'raised', borderwidth = 2)
self.arrowDirection[self._downMinuteArrowBtn] = 'down'
self._downMinuteArrowBtn.grid(column = 1, row = 2)
# Create the second down arrow.
self._downSecondArrowBtn = self.createcomponent('downsecondarrow',
(), 'Arrow',
Tkinter.Canvas, (frame,),
width = 16, height = 16, relief = 'raised', borderwidth = 2)
self.arrowDirection[self._downSecondArrowBtn] = 'down'
self._downSecondArrowBtn.grid(column = 2, row = 2)
# Create the entry fields.
# Create the hour entry field.
self._hourCounterEntry = self.createcomponent('hourentryfield',
(('hourentry', 'hourentryfield_entry'),), None,
EntryField, (frame,), validate='integer', entry_width = 2)
self._hourCounterEntry.grid(column = 0, row = 1, sticky = 'news')
# Create the minute entry field.
self._minuteCounterEntry = self.createcomponent('minuteentryfield',
(('minuteentry', 'minuteentryfield_entry'),), None,
EntryField, (frame,), validate='integer', entry_width = 2)
self._minuteCounterEntry.grid(column = 1, row = 1, sticky = 'news')
# Create the second entry field.
self._secondCounterEntry = self.createcomponent('secondentryfield',
(('secondentry', 'secondentryfield_entry'),), None,
EntryField, (frame,), validate='integer', entry_width = 2)
self._secondCounterEntry.grid(column = 2, row = 1, sticky = 'news')
# Create the up arrow buttons.
# Create the hour up arrow.
self._upHourArrowBtn = self.createcomponent('uphourarrow',
(), 'Arrow',
Tkinter.Canvas, (frame,),
width = 16, height = 16, relief = 'raised', borderwidth = 2)
self.arrowDirection[self._upHourArrowBtn] = 'up'
self._upHourArrowBtn.grid(column = 0, row = 0)
# Create the minute up arrow.
self._upMinuteArrowBtn = self.createcomponent('upminutearrow',
(), 'Arrow',
Tkinter.Canvas, (frame,),
width = 16, height = 16, relief = 'raised', borderwidth = 2)
self.arrowDirection[self._upMinuteArrowBtn] = 'up'
self._upMinuteArrowBtn.grid(column = 1, row = 0)
# Create the second up arrow.
self._upSecondArrowBtn = self.createcomponent('upsecondarrow',
(), 'Arrow',
Tkinter.Canvas, (frame,),
width = 16, height = 16, relief = 'raised', borderwidth = 2)
self.arrowDirection[self._upSecondArrowBtn] = 'up'
self._upSecondArrowBtn.grid(column = 2, row = 0)
# Make it resize nicely.
padx = self['padx']
pady = self['pady']
for col in range(3):
frame.grid_columnconfigure(col, weight = 1, pad = padx)
frame.grid_rowconfigure(0, pad = pady)
frame.grid_rowconfigure(2, pad = pady)
frame.grid_rowconfigure(1, weight = 1)
# Create the label.
self.createlabel(interior)
# Set bindings.
# Up hour
self._upHourArrowBtn.bind('<Configure>',
lambda event, s=self,button=self._upHourArrowBtn:
s._drawArrow(button, 'up'))
self._upHourArrowBtn.bind('<1>',
lambda event, s=self,button=self._upHourArrowBtn:
s._countUp(button, 3600))
self._upHourArrowBtn.bind('<Any-ButtonRelease-1>',
lambda event, s=self, button=self._upHourArrowBtn:
s._stopUpDown(button))
# Up minute
self._upMinuteArrowBtn.bind('<Configure>',
lambda event, s=self,button=self._upMinuteArrowBtn:
s._drawArrow(button, 'up'))
self._upMinuteArrowBtn.bind('<1>',
lambda event, s=self,button=self._upMinuteArrowBtn:
s._countUp(button, 60))
self._upMinuteArrowBtn.bind('<Any-ButtonRelease-1>',
lambda event, s=self, button=self._upMinuteArrowBtn:
s._stopUpDown(button))
# Up second
self._upSecondArrowBtn.bind('<Configure>',
lambda event, s=self,button=self._upSecondArrowBtn:
s._drawArrow(button, 'up'))
self._upSecondArrowBtn.bind('<1>',
lambda event, s=self,button=self._upSecondArrowBtn:
s._countUp(button, 1))
self._upSecondArrowBtn.bind('<Any-ButtonRelease-1>',
lambda event, s=self, button=self._upSecondArrowBtn:
s._stopUpDown(button))
# Down hour
self._downHourArrowBtn.bind('<Configure>',
lambda event, s=self,button=self._downHourArrowBtn:
s._drawArrow(button, 'down'))
self._downHourArrowBtn.bind('<1>',
lambda event, s=self,button=self._downHourArrowBtn:
s._countDown(button, 3600))
self._downHourArrowBtn.bind('<Any-ButtonRelease-1>',
lambda event, s=self, button=self._downHourArrowBtn:
s._stopUpDown(button))
# Down minute
self._downMinuteArrowBtn.bind('<Configure>',
lambda event, s=self,button=self._downMinuteArrowBtn:
s._drawArrow(button, 'down'))
self._downMinuteArrowBtn.bind('<1>',
lambda event, s=self,button=self._downMinuteArrowBtn:
s._countDown(button, 60))
self._downMinuteArrowBtn.bind('<Any-ButtonRelease-1>',
lambda event, s=self, button=self._downMinuteArrowBtn:
s._stopUpDown(button))
# Down second
self._downSecondArrowBtn.bind('<Configure>',
lambda event, s=self,button=self._downSecondArrowBtn:
s._drawArrow(button, 'down'))
self._downSecondArrowBtn.bind('<1>',
lambda event, s=self, button=self._downSecondArrowBtn:
s._countDown(button,1))
self._downSecondArrowBtn.bind('<Any-ButtonRelease-1>',
lambda event, s=self, button=self._downSecondArrowBtn:
s._stopUpDown(button))
self._hourCounterEntry.component('entry').bind(
'<Return>', self._invoke)
self._minuteCounterEntry.component('entry').bind(
'<Return>', self._invoke)
self._secondCounterEntry.component('entry').bind(
'<Return>', self._invoke)
self._hourCounterEntry.bind('<Configure>', self._resizeArrow)
self._minuteCounterEntry.bind('<Configure>', self._resizeArrow)
self._secondCounterEntry.bind('<Configure>', self._resizeArrow)
def _drawArrow(self, arrow, direction):
drawarrow(arrow, self['hourentry_foreground'], direction, 'arrow')
def _resizeArrow(self, event = None):
for btn in (self._upHourArrowBtn, self._upMinuteArrowBtn,
self._upSecondArrowBtn,
self._downHourArrowBtn,
self._downMinuteArrowBtn, self._downSecondArrowBtn):
bw = (string.atoi(btn['borderwidth']) +
string.atoi(btn['highlightthickness']))
newHeight = self._hourCounterEntry.winfo_reqheight() - 2 * bw
newWidth = int(newHeight * self['buttonaspect'])
btn.configure(width=newWidth, height=newHeight)
self._drawArrow(btn, self.arrowDirection[btn])
def _min(self):
min = self['min']
if min is None:
self._minVal = 0
else:
self._minVal = timestringtoseconds(min)
def _max(self):
max = self['max']
if max is None:
self._maxVal = None
else:
self._maxVal = timestringtoseconds(max)
def getvalue(self):
return self.getstring()
def setvalue(self, text):
list = string.split(text, ':')
if len(list) != 3:
raise ValueError, 'invalid value: ' + text
self._hour = string.atoi(list[0])
self._minute = string.atoi(list[1])
self._second = string.atoi(list[2])
self._setHMS()
def getstring(self):
return '%02d:%02d:%02d' % (self._hour, self._minute, self._second)
def getint(self):
return self._hour * 3600 + self._minute * 60 + self._second
def _countUp(self, button, increment):
self._relief = self._upHourArrowBtn.cget('relief')
button.configure(relief='sunken')
self._count(1, 'start', increment)
def _countDown(self, button, increment):
self._relief = self._downHourArrowBtn.cget('relief')
button.configure(relief='sunken')
self._count(-1, 'start', increment)
def increment(self, seconds = 1):
self._count(1, 'force', seconds)
def decrement(self, seconds = 1):
self._count(-1, 'force', seconds)
def _count(self, factor, newFlag = None, increment = 1):
if newFlag != 'force':
if newFlag is not None:
self._flag = newFlag
if self._flag == 'stopped':
return
value = (string.atoi(self._hourCounterEntry.get()) *3600) + \
(string.atoi(self._minuteCounterEntry.get()) *60) + \
string.atoi(self._secondCounterEntry.get()) + \
factor * increment
min = self._minVal
max = self._maxVal
if value < min:
value = min
if max is not None and value > max:
value = max
self._hour = value /3600
self._minute = (value - (self._hour*3600)) / 60
self._second = value - (self._hour*3600) - (self._minute*60)
self._setHMS()
if newFlag != 'force':
if self['autorepeat']:
if self._flag == 'start':
delay = self['initwait']
self._flag = 'running'
else:
delay = self['repeatrate']
self._timerId = self.after(
delay, lambda self=self, factor=factor,increment=increment:
self._count(factor,'running', increment))
def _setHMS(self):
self._hourCounterEntry.setentry('%02d' % self._hour)
self._minuteCounterEntry.setentry('%02d' % self._minute)
self._secondCounterEntry.setentry('%02d' % self._second)
def _stopUpDown(self, button):
if self._timerId is not None:
self.after_cancel(self._timerId)
self._timerId = None
button.configure(relief=self._relief)
self._flag = 'stopped'
def _invoke(self, event):
cmd = self['command']
if callable(cmd):
cmd()
def invoke(self):
cmd = self['command']
if callable(cmd):
return cmd()
def destroy(self):
if self._timerId is not None:
self.after_cancel(self._timerId)
self._timerId = None
MegaWidget.destroy(self)
######################################################################
### File: PmwAboutDialog.py
class AboutDialog(MessageDialog):
# Window to display version and contact information.
# Class members containing resettable 'default' values:
_version = ''
_copyright = ''
_contact = ''
def __init__(self, parent = None, **kw):
# Define the megawidget options.
optiondefs = (
('applicationname', '', INITOPT),
('iconpos', 'w', None),
('icon_bitmap', 'info', None),
('buttons', ('Close',), None),
('defaultbutton', 0, None),
)
self.defineoptions(kw, optiondefs)
# Initialise the base class (after defining the options).
MessageDialog.__init__(self, parent)
applicationname = self['applicationname']
if not kw.has_key('title'):
self.configure(title = 'About ' + applicationname)
if not kw.has_key('message_text'):
text = applicationname + '\n\n'
if AboutDialog._version != '':
text = text + 'Version ' + AboutDialog._version + '\n'
if AboutDialog._copyright != '':
text = text + AboutDialog._copyright + '\n\n'
if AboutDialog._contact != '':
text = text + AboutDialog._contact
self.configure(message_text=text)
# Check keywords and initialise options.
self.initialiseoptions()
def aboutversion(value):
AboutDialog._version = value
def aboutcopyright(value):
AboutDialog._copyright = value
def aboutcontact(value):
AboutDialog._contact = value
######################################################################
### File: PmwComboBox.py
# Based on iwidgets2.2.0/combobox.itk code.
import os
import string
import types
import Tkinter
class ComboBox(MegaWidget):
def __init__(self, parent = None, **kw):
# Define the megawidget options.
optiondefs = (
('autoclear', 0, INITOPT),
('buttonaspect', 1.0, INITOPT),
('dropdown', 1, INITOPT),
('fliparrow', 0, INITOPT),
('history', 1, INITOPT),
('labelmargin', 0, INITOPT),
('labelpos', None, INITOPT),
('listheight', 200, INITOPT),
('selectioncommand', None, None),
('sticky', 'ew', INITOPT),
('unique', 1, INITOPT),
)
self.defineoptions(kw, optiondefs)
# Initialise the base class (after defining the options).
MegaWidget.__init__(self, parent)
# Create the components.
interior = self.interior()
self._entryfield = self.createcomponent('entryfield',
(('entry', 'entryfield_entry'),), None,
EntryField, (interior,))
self._entryfield.grid(column=2, row=2, sticky=self['sticky'])
interior.grid_columnconfigure(2, weight = 1)
self._entryWidget = self._entryfield.component('entry')
if self['dropdown']:
self._isPosted = 0
interior.grid_rowconfigure(2, weight = 1)
# Create the arrow button.
self._arrowBtn = self.createcomponent('arrowbutton',
(), None,
Tkinter.Canvas, (interior,), borderwidth = 2,
relief = 'raised',
width = 16, height = 16)
if 'n' in self['sticky']:
sticky = 'n'
else:
sticky = ''
if 's' in self['sticky']:
sticky = sticky + 's'
self._arrowBtn.grid(column=3, row=2, sticky = sticky)
self._arrowRelief = self._arrowBtn.cget('relief')
# Create the label.
self.createlabel(interior, childCols=2)
# Create the dropdown window.
self._popup = self.createcomponent('popup',
(), None,
Tkinter.Toplevel, (interior,))
self._popup.withdraw()
self._popup.overrideredirect(1)
# Create the scrolled listbox inside the dropdown window.
self._list = self.createcomponent('scrolledlist',
(('listbox', 'scrolledlist_listbox'),), None,
ScrolledListBox, (self._popup,),
hull_borderwidth = 2,
hull_relief = 'raised',
hull_height = self['listheight'],
usehullsize = 1,
listbox_exportselection = 0)
self._list.pack(expand=1, fill='both')
self.__listbox = self._list.component('listbox')
# Bind events to the arrow button.
self._arrowBtn.bind('<1>', self._postList)
self._arrowBtn.bind('<Configure>', self._drawArrow)
self._arrowBtn.bind('<3>', self._next)
self._arrowBtn.bind('<Shift-3>', self._previous)
self._arrowBtn.bind('<Down>', self._next)
self._arrowBtn.bind('<Up>', self._previous)
self._arrowBtn.bind('<Control-n>', self._next)
self._arrowBtn.bind('<Control-p>', self._previous)
self._arrowBtn.bind('<Shift-Down>', self._postList)
self._arrowBtn.bind('<Shift-Up>', self._postList)
self._arrowBtn.bind('<F34>', self._postList)
self._arrowBtn.bind('<F28>', self._postList)
self._arrowBtn.bind('<space>', self._postList)
# Bind events to the dropdown window.
self._popup.bind('<Escape>', self._unpostList)
self._popup.bind('<space>', self._selectUnpost)
self._popup.bind('<Return>', self._selectUnpost)
self._popup.bind('<ButtonRelease-1>', self._dropdownBtnRelease)
self._popup.bind('<ButtonPress-1>', self._unpostOnNextRelease)
# Bind events to the Tk listbox.
self.__listbox.bind('<Enter>', self._unpostOnNextRelease)
# Bind events to the Tk entry widget.
self._entryWidget.bind('<Configure>', self._resizeArrow)
self._entryWidget.bind('<Shift-Down>', self._postList)
self._entryWidget.bind('<Shift-Up>', self._postList)
self._entryWidget.bind('<F34>', self._postList)
self._entryWidget.bind('<F28>', self._postList)
# Need to unpost the popup if the entryfield is unmapped (eg:
# its toplevel window is withdrawn) while the popup list is
# displayed.
self._entryWidget.bind('<Unmap>', self._unpostList)
else:
# Create the scrolled listbox below the entry field.
self._list = self.createcomponent('scrolledlist',
(('listbox', 'scrolledlist_listbox'),), None,
ScrolledListBox, (interior,),
selectioncommand = self._selectCmd)
self._list.grid(column=2, row=3, sticky='nsew')
self.__listbox = self._list.component('listbox')
# The scrolled listbox should expand vertically.
interior.grid_rowconfigure(3, weight = 1)
# Create the label.
self.createlabel(interior, childRows=2)
self._entryWidget.bind('<Down>', self._next)
self._entryWidget.bind('<Up>', self._previous)
self._entryWidget.bind('<Control-n>', self._next)
self._entryWidget.bind('<Control-p>', self._previous)
self.__listbox.bind('<Control-n>', self._next)
self.__listbox.bind('<Control-p>', self._previous)
if self['history']:
self._entryfield.configure(command=self._addHistory)
# Check keywords and initialise options.
self.initialiseoptions()
def destroy(self):
if self['dropdown'] and self._isPosted:
popgrab(self._popup)
MegaWidget.destroy(self)
#======================================================================
# Public methods
def get(self, first = None, last=None):
if first is None:
return self._entryWidget.get()
else:
return self._list.get(first, last)
def invoke(self):
if self['dropdown']:
self._postList()
else:
return self._selectCmd()
def selectitem(self, index, setentry=1):
if type(index) == types.StringType:
text = index
items = self._list.get(0, 'end')
if text in items:
index = list(items).index(text)
else:
raise IndexError, 'index "%s" not found' % text
elif setentry:
text = self._list.get(0, 'end')[index]
self._list.select_clear(0, 'end')
self._list.select_set(index, index)
self._list.activate(index)
self.see(index)
if setentry:
self._entryfield.setentry(text)
# Need to explicitly forward this to override the stupid
# (grid_)size method inherited from Tkinter.Frame.Grid.
def size(self):
return self._list.size()
# Need to explicitly forward this to override the stupid
# (grid_)bbox method inherited from Tkinter.Frame.Grid.
def bbox(self, index):
return self._list.bbox(index)
def clear(self):
self._entryfield.clear()
self._list.clear()
#======================================================================
# Private methods for both dropdown and simple comboboxes.
def _addHistory(self):
input = self._entryWidget.get()
if input != '':
index = None
if self['unique']:
# If item is already in list, select it and return.
items = self._list.get(0, 'end')
if input in items:
index = list(items).index(input)
if index is None:
index = self._list.index('end')
self._list.insert('end', input)
self.selectitem(index)
if self['autoclear']:
self._entryWidget.delete(0, 'end')
# Execute the selectioncommand on the new entry.
self._selectCmd()
def _next(self, event):
size = self.size()
if size <= 1:
return
cursels = self.curselection()
if len(cursels) == 0:
index = 0
else:
index = string.atoi(cursels[0])
if index == size - 1:
index = 0
else:
index = index + 1
self.selectitem(index)
def _previous(self, event):
size = self.size()
if size <= 1:
return
cursels = self.curselection()
if len(cursels) == 0:
index = size - 1
else:
index = string.atoi(cursels[0])
if index == 0:
index = size - 1
else:
index = index - 1
self.selectitem(index)
def _selectCmd(self, event=None):
sels = self.getcurselection()
if len(sels) == 0:
item = None
else:
item = sels[0]
self._entryfield.setentry(item)
cmd = self['selectioncommand']
if callable(cmd):
if event is None:
# Return result of selectioncommand for invoke() method.
return cmd(item)
else:
cmd(item)
#======================================================================
# Private methods for dropdown combobox.
def _drawArrow(self, event=None, sunken=0):
arrow = self._arrowBtn
if sunken:
self._arrowRelief = arrow.cget('relief')
arrow.configure(relief = 'sunken')
else:
arrow.configure(relief = self._arrowRelief)
if self._isPosted and self['fliparrow']:
direction = 'up'
else:
direction = 'down'
drawarrow(arrow, self['entry_foreground'], direction, 'arrow')
def _postList(self, event = None):
self._isPosted = 1
self._drawArrow(sunken=1)
# Make sure that the arrow is displayed sunken.
self.update_idletasks()
x = self._entryfield.winfo_rootx()
y = self._entryfield.winfo_rooty() + \
self._entryfield.winfo_height()
w = self._entryfield.winfo_width() + self._arrowBtn.winfo_width()
h = self.__listbox.winfo_height()
sh = self.winfo_screenheight()
if y + h > sh and y > sh / 2:
y = self._entryfield.winfo_rooty() - h
self._list.configure(hull_width=w)
setgeometryanddeiconify(self._popup, '+%d+%d' % (x, y))
# Grab the popup, so that all events are delivered to it, and
# set focus to the listbox, to make keyboard navigation
# easier.
pushgrab(self._popup, 1, self._unpostList)
self.__listbox.focus_set()
self._drawArrow()
# Ignore the first release of the mouse button after posting the
# dropdown list, unless the mouse enters the dropdown list.
self._ignoreRelease = 1
def _dropdownBtnRelease(self, event):
if (event.widget == self._list.component('vertscrollbar') or
event.widget == self._list.component('horizscrollbar')):
return
if self._ignoreRelease:
self._unpostOnNextRelease()
return
self._unpostList()
if (event.x >= 0 and event.x < self.__listbox.winfo_width() and
event.y >= 0 and event.y < self.__listbox.winfo_height()):
self._selectCmd()
def _unpostOnNextRelease(self, event = None):
self._ignoreRelease = 0
def _resizeArrow(self, event):
bw = (string.atoi(self._arrowBtn['borderwidth']) +
string.atoi(self._arrowBtn['highlightthickness']))
newHeight = self._entryfield.winfo_reqheight() - 2 * bw
newWidth = int(newHeight * self['buttonaspect'])
self._arrowBtn.configure(width=newWidth, height=newHeight)
self._drawArrow()
def _unpostList(self, event=None):
if not self._isPosted:
# It is possible to get events on an unposted popup. For
# example, by repeatedly pressing the space key to post
# and unpost the popup. The <space> event may be
# delivered to the popup window even though
# popgrab() has set the focus away from the
# popup window. (Bug in Tk?)
return
# Restore the focus before withdrawing the window, since
# otherwise the window manager may take the focus away so we
# can't redirect it. Also, return the grab to the next active
# window in the stack, if any.
popgrab(self._popup)
self._popup.withdraw()
self._isPosted = 0
self._drawArrow()
def _selectUnpost(self, event):
self._unpostList()
self._selectCmd()
forwardmethods(ComboBox, ScrolledListBox, '_list')
forwardmethods(ComboBox, EntryField, '_entryfield')
######################################################################
### File: PmwComboBoxDialog.py
# Not Based on iwidgets version.
class ComboBoxDialog(Dialog):
# Dialog window with simple combobox.
# Dialog window displaying a list and entry field and requesting
# the user to make a selection or enter a value
def __init__(self, parent = None, **kw):
# Define the megawidget options.
optiondefs = (
('borderx', 10, INITOPT),
('bordery', 10, INITOPT),
)
self.defineoptions(kw, optiondefs)
# Initialise the base class (after defining the options).
Dialog.__init__(self, parent)
# Create the components.
interior = self.interior()
aliases = (
('listbox', 'combobox_listbox'),
('scrolledlist', 'combobox_scrolledlist'),
('entry', 'combobox_entry'),
('label', 'combobox_label'),
)
self._combobox = self.createcomponent('combobox',
aliases, None,
ComboBox, (interior,),
scrolledlist_dblclickcommand = self.invoke,
dropdown = 0,
)
self._combobox.pack(side='top', expand='true', fill='both',
padx = self['borderx'], pady = self['bordery'])
if not kw.has_key('activatecommand'):
# Whenever this dialog is activated, set the focus to the
# ComboBox's listbox widget.
listbox = self.component('listbox')
self.configure(activatecommand = listbox.focus_set)
# Check keywords and initialise options.
self.initialiseoptions()
# Need to explicitly forward this to override the stupid
# (grid_)size method inherited from Tkinter.Toplevel.Grid.
def size(self):
return self._combobox.size()
# Need to explicitly forward this to override the stupid
# (grid_)bbox method inherited from Tkinter.Toplevel.Grid.
def bbox(self, index):
return self._combobox.bbox(index)
forwardmethods(ComboBoxDialog, ComboBox, '_combobox')
######################################################################
### File: PmwCounter.py
import string
import sys
import types
import Tkinter
class Counter(MegaWidget):
def __init__(self, parent = None, **kw):
# Define the megawidget options.
optiondefs = (
('autorepeat', 1, None),
('buttonaspect', 1.0, INITOPT),
('datatype', 'numeric', self._datatype),
('increment', 1, None),
('initwait', 300, None),
('labelmargin', 0, INITOPT),
('labelpos', None, INITOPT),
('orient', 'horizontal', INITOPT),
('padx', 0, INITOPT),
('pady', 0, INITOPT),
('repeatrate', 50, None),
('sticky', 'ew', INITOPT),
)
self.defineoptions(kw, optiondefs)
# Initialise the base class (after defining the options).
MegaWidget.__init__(self, parent)
# Initialise instance variables.
self._timerId = None
self._normalRelief = None
# Create the components.
interior = self.interior()
# If there is no label, put the arrows and the entry directly
# into the interior, otherwise create a frame for them. In
# either case the border around the arrows and the entry will
# be raised (but not around the label).
if self['labelpos'] is None:
frame = interior
if not kw.has_key('hull_relief'):
frame.configure(relief = 'raised')
if not kw.has_key('hull_borderwidth'):
frame.configure(borderwidth = 1)
else:
frame = self.createcomponent('frame',
(), None,
Tkinter.Frame, (interior,),
relief = 'raised', borderwidth = 1)
frame.grid(column=2, row=2, sticky=self['sticky'])
interior.grid_columnconfigure(2, weight=1)
interior.grid_rowconfigure(2, weight=1)
# Create the down arrow.
self._downArrowBtn = self.createcomponent('downarrow',
(), 'Arrow',
Tkinter.Canvas, (frame,),
width = 16, height = 16, relief = 'raised', borderwidth = 2)
# Create the entry field.
self._counterEntry = self.createcomponent('entryfield',
(('entry', 'entryfield_entry'),), None,
EntryField, (frame,))
# Create the up arrow.
self._upArrowBtn = self.createcomponent('uparrow',
(), 'Arrow',
Tkinter.Canvas, (frame,),
width = 16, height = 16, relief = 'raised', borderwidth = 2)
padx = self['padx']
pady = self['pady']
orient = self['orient']
if orient == 'horizontal':
self._downArrowBtn.grid(column = 0, row = 0)
self._counterEntry.grid(column = 1, row = 0,
sticky = self['sticky'])
self._upArrowBtn.grid(column = 2, row = 0)
frame.grid_columnconfigure(1, weight = 1)
frame.grid_rowconfigure(0, weight = 1)
if Tkinter.TkVersion >= 4.2:
frame.grid_columnconfigure(0, pad = padx)
frame.grid_columnconfigure(2, pad = padx)
frame.grid_rowconfigure(0, pad = pady)
elif orient == 'vertical':
self._upArrowBtn.grid(column = 0, row = 0, sticky = 's')
self._counterEntry.grid(column = 0, row = 1,
sticky = self['sticky'])
self._downArrowBtn.grid(column = 0, row = 2, sticky = 'n')
frame.grid_columnconfigure(0, weight = 1)
frame.grid_rowconfigure(0, weight = 1)
frame.grid_rowconfigure(2, weight = 1)
if Tkinter.TkVersion >= 4.2:
frame.grid_rowconfigure(0, pad = pady)
frame.grid_rowconfigure(2, pad = pady)
frame.grid_columnconfigure(0, pad = padx)
else:
raise ValueError, 'bad orient option ' + repr(orient) + \
': must be either \'horizontal\' or \'vertical\''
self.createlabel(interior)
self._upArrowBtn.bind('<Configure>', self._drawUpArrow)
self._upArrowBtn.bind('<1>', self._countUp)
self._upArrowBtn.bind('<Any-ButtonRelease-1>', self._stopCounting)
self._downArrowBtn.bind('<Configure>', self._drawDownArrow)
self._downArrowBtn.bind('<1>', self._countDown)
self._downArrowBtn.bind('<Any-ButtonRelease-1>', self._stopCounting)
self._counterEntry.bind('<Configure>', self._resizeArrow)
entry = self._counterEntry.component('entry')
entry.bind('<Down>', lambda event, s = self: s._key_decrement(event))
entry.bind('<Up>', lambda event, s = self: s._key_increment(event))
# Need to cancel the timer if an arrow button is unmapped (eg:
# its toplevel window is withdrawn) while the mouse button is
# held down. The canvas will not get the ButtonRelease event
# if it is not mapped, since the implicit grab is cancelled.
self._upArrowBtn.bind('<Unmap>', self._stopCounting)
self._downArrowBtn.bind('<Unmap>', self._stopCounting)
# Check keywords and initialise options.
self.initialiseoptions()
def _resizeArrow(self, event):
for btn in (self._upArrowBtn, self._downArrowBtn):
bw = (string.atoi(btn['borderwidth']) +
string.atoi(btn['highlightthickness']))
newHeight = self._counterEntry.winfo_reqheight() - 2 * bw
newWidth = int(newHeight * self['buttonaspect'])
btn.configure(width=newWidth, height=newHeight)
self._drawArrow(btn)
def _drawUpArrow(self, event):
self._drawArrow(self._upArrowBtn)
def _drawDownArrow(self, event):
self._drawArrow(self._downArrowBtn)
def _drawArrow(self, arrow):
if self['orient'] == 'vertical':
if arrow == self._upArrowBtn:
direction = 'up'
else:
direction = 'down'
else:
if arrow == self._upArrowBtn:
direction = 'right'
else:
direction = 'left'
drawarrow(arrow, self['entry_foreground'], direction, 'arrow')
def _stopCounting(self, event = None):
if self._timerId is not None:
self.after_cancel(self._timerId)
self._timerId = None
if self._normalRelief is not None:
button, relief = self._normalRelief
button.configure(relief=relief)
self._normalRelief = None
def _countUp(self, event):
self._normalRelief = (self._upArrowBtn, self._upArrowBtn.cget('relief'))
self._upArrowBtn.configure(relief='sunken')
# Force arrow down (it may come up immediately, if increment fails).
self._upArrowBtn.update_idletasks()
self._count(1, 1)
def _countDown(self, event):
self._normalRelief = (self._downArrowBtn, self._downArrowBtn.cget('relief'))
self._downArrowBtn.configure(relief='sunken')
# Force arrow down (it may come up immediately, if increment fails).
self._downArrowBtn.update_idletasks()
self._count(-1, 1)
def increment(self):
self._forceCount(1)
def decrement(self):
self._forceCount(-1)
def _key_increment(self, event):
self._forceCount(1)
self.update_idletasks()
def _key_decrement(self, event):
self._forceCount(-1)
self.update_idletasks()
def _datatype(self):
datatype = self['datatype']
if type(datatype) is types.DictionaryType:
self._counterArgs = datatype.copy()
if self._counterArgs.has_key('counter'):
datatype = self._counterArgs['counter']
del self._counterArgs['counter']
else:
datatype = 'numeric'
else:
self._counterArgs = {}
if _counterCommands.has_key(datatype):
self._counterCommand = _counterCommands[datatype]
elif callable(datatype):
self._counterCommand = datatype
else:
validValues = _counterCommands.keys()
validValues.sort()
raise ValueError, ('bad datatype value "%s": must be a' +
' function or one of %s') % (datatype, validValues)
def _forceCount(self, factor):
if not self.valid():
self.bell()
return
text = self._counterEntry.get()
try:
value = apply(self._counterCommand,
(text, factor, self['increment']), self._counterArgs)
except ValueError:
self.bell()
return
previousICursor = self._counterEntry.index('insert')
if self._counterEntry.setentry(value) == OK:
self._counterEntry.xview('end')
self._counterEntry.icursor(previousICursor)
def _count(self, factor, first):
if not self.valid():
self.bell()
return
self._timerId = None
origtext = self._counterEntry.get()
try:
value = apply(self._counterCommand,
(origtext, factor, self['increment']), self._counterArgs)
except ValueError:
# If text is invalid, stop counting.
self._stopCounting()
self.bell()
return
# If incrementing produces an invalid value, restore previous
# text and stop counting.
previousICursor = self._counterEntry.index('insert')
valid = self._counterEntry.setentry(value)
if valid != OK:
self._stopCounting()
self._counterEntry.setentry(origtext)
if valid == PARTIAL:
self.bell()
return
self._counterEntry.xview('end')
self._counterEntry.icursor(previousICursor)
if self['autorepeat']:
if first:
delay = self['initwait']
else:
delay = self['repeatrate']
self._timerId = self.after(delay,
lambda self=self, factor=factor: self._count(factor, 0))
def destroy(self):
self._stopCounting()
MegaWidget.destroy(self)
forwardmethods(Counter, EntryField, '_counterEntry')
def _changeNumber(text, factor, increment):
value = string.atol(text)
if factor > 0:
value = (value / increment) * increment + increment
else:
value = ((value - 1) / increment) * increment
# Get rid of the 'L' at the end of longs (in python up to 1.5.2).
rtn = str(value)
if rtn[-1] == 'L':
return rtn[:-1]
else:
return rtn
def _changeReal(text, factor, increment, separator = '.'):
value = stringtoreal(text, separator)
div = value / increment
# Compare reals using str() to avoid problems caused by binary
# numbers being only approximations to decimal numbers.
# For example, if value is -0.3 and increment is 0.1, then
# int(value/increment) = -2, not -3 as one would expect.
if str(div)[-2:] == '.0':
# value is an even multiple of increment.
div = round(div) + factor
else:
# value is not an even multiple of increment.
div = int(div) * 1.0
if value < 0:
div = div - 1
if factor > 0:
div = (div + 1)
value = div * increment
text = str(value)
if separator != '.':
index = string.find(text, '.')
if index >= 0:
text = text[:index] + separator + text[index + 1:]
return text
def _changeDate(value, factor, increment, format = 'ymd',
separator = '/', yyyy = 0):
jdn = datestringtojdn(value, format, separator) + factor * increment
y, m, d = jdntoymd(jdn)
result = ''
for index in range(3):
if index > 0:
result = result + separator
f = format[index]
if f == 'y':
if yyyy:
result = result + '%02d' % y
else:
result = result + '%02d' % (y % 100)
elif f == 'm':
result = result + '%02d' % m
elif f == 'd':
result = result + '%02d' % d
return result
_SECSPERDAY = 24 * 60 * 60
def _changeTime(value, factor, increment, separator = ':', time24 = 0):
unixTime = timestringtoseconds(value, separator)
if factor > 0:
chunks = unixTime / increment + 1
else:
chunks = (unixTime - 1) / increment
unixTime = chunks * increment
if time24:
while unixTime < 0:
unixTime = unixTime + _SECSPERDAY
while unixTime >= _SECSPERDAY:
unixTime = unixTime - _SECSPERDAY
if unixTime < 0:
unixTime = -unixTime
sign = '-'
else:
sign = ''
secs = unixTime % 60
unixTime = unixTime / 60
mins = unixTime % 60
hours = unixTime / 60
return '%s%02d%s%02d%s%02d' % (sign, hours, separator, mins, separator, secs)
# hexadecimal, alphabetic, alphanumeric not implemented
_counterCommands = {
'numeric' : _changeNumber, # } integer
'integer' : _changeNumber, # } these two use the same function
'real' : _changeReal, # real number
'time' : _changeTime,
'date' : _changeDate,
}
######################################################################
### File: PmwCounterDialog.py
# A Dialog with a counter
class CounterDialog(Dialog):
def __init__(self, parent = None, **kw):
# Define the megawidget options.
optiondefs = (
('borderx', 20, INITOPT),
('bordery', 20, INITOPT),
)
self.defineoptions(kw, optiondefs)
# Initialise the base class (after defining the options).
Dialog.__init__(self, parent)
# Create the components.
interior = self.interior()
# Create the counter.
aliases = (
('entryfield', 'counter_entryfield'),
('entry', 'counter_entryfield_entry'),
('label', 'counter_label')
)
self._cdCounter = self.createcomponent('counter',
aliases, None,
Counter, (interior,))
self._cdCounter.pack(fill='x', expand=1,
padx = self['borderx'], pady = self['bordery'])
if not kw.has_key('activatecommand'):
# Whenever this dialog is activated, set the focus to the
# Counter's entry widget.
tkentry = self.component('entry')
self.configure(activatecommand = tkentry.focus_set)
# Check keywords and initialise options.
self.initialiseoptions()
# Supply aliases to some of the entry component methods.
def insertentry(self, index, text):
self._cdCounter.insert(index, text)
def deleteentry(self, first, last=None):
self._cdCounter.delete(first, last)
def indexentry(self, index):
return self._cdCounter.index(index)
forwardmethods(CounterDialog, Counter, '_cdCounter')
######################################################################
### File: PmwLogicalFont.py
import os
import string
def _font_initialise(root, size=None, fontScheme = None):
global _fontSize
if size is not None:
_fontSize = size
if fontScheme in ('pmw1', 'pmw2'):
if os.name == 'posix':
defaultFont = logicalfont('Helvetica')
menuFont = logicalfont('Helvetica', weight='bold', slant='italic')
scaleFont = logicalfont('Helvetica', slant='italic')
root.option_add('*Font', defaultFont, 'userDefault')
root.option_add('*Menu*Font', menuFont, 'userDefault')
root.option_add('*Menubutton*Font', menuFont, 'userDefault')
root.option_add('*Scale.*Font', scaleFont, 'userDefault')
if fontScheme == 'pmw1':
balloonFont = logicalfont('Helvetica', -6, pixel = '12')
else: # fontScheme == 'pmw2'
balloonFont = logicalfont('Helvetica', -2)
root.option_add('*Balloon.*Font', balloonFont, 'userDefault')
else:
defaultFont = logicalfont('Helvetica')
root.option_add('*Font', defaultFont, 'userDefault')
elif fontScheme == 'default':
defaultFont = ('Helvetica', '-%d' % (_fontSize,), 'bold')
entryFont = ('Helvetica', '-%d' % (_fontSize,))
textFont = ('Courier', '-%d' % (_fontSize,))
root.option_add('*Font', defaultFont, 'userDefault')
root.option_add('*Entry*Font', entryFont, 'userDefault')
root.option_add('*Text*Font', textFont, 'userDefault')
def logicalfont(name='Helvetica', sizeIncr = 0, **kw):
if not _fontInfo.has_key(name):
raise ValueError, 'font %s does not exist' % name
rtn = []
for field in _fontFields:
if kw.has_key(field):
logicalValue = kw[field]
elif _fontInfo[name].has_key(field):
logicalValue = _fontInfo[name][field]
else:
logicalValue = '*'
if _propertyAliases[name].has_key((field, logicalValue)):
realValue = _propertyAliases[name][(field, logicalValue)]
elif _propertyAliases[name].has_key((field, None)):
realValue = _propertyAliases[name][(field, None)]
elif _propertyAliases[None].has_key((field, logicalValue)):
realValue = _propertyAliases[None][(field, logicalValue)]
elif _propertyAliases[None].has_key((field, None)):
realValue = _propertyAliases[None][(field, None)]
else:
realValue = logicalValue
if field == 'size':
if realValue == '*':
realValue = _fontSize
realValue = str((realValue + sizeIncr) * 10)
rtn.append(realValue)
return string.join(rtn, '-')
def logicalfontnames():
return _fontInfo.keys()
if os.name == 'nt':
_fontSize = 16
else:
_fontSize = 14
_fontFields = (
'registry', 'foundry', 'family', 'weight', 'slant', 'width', 'style',
'pixel', 'size', 'xres', 'yres', 'spacing', 'avgwidth', 'charset', 'encoding')
# <_propertyAliases> defines other names for which property values may
# be known by. This is required because italics in adobe-helvetica
# are specified by 'o', while other fonts use 'i'.
_propertyAliases = {}
_propertyAliases[None] = {
('slant', 'italic') : 'i',
('slant', 'normal') : 'r',
('weight', 'light') : 'normal',
('width', 'wide') : 'normal',
('width', 'condensed') : 'normal',
}
# <_fontInfo> describes a 'logical' font, giving the default values of
# some of its properties.
_fontInfo = {}
_fontInfo['Helvetica'] = {
'foundry' : 'adobe',
'family' : 'helvetica',
'registry' : '',
'charset' : 'iso8859',
'encoding' : '1',
'spacing' : 'p',
'slant' : 'normal',
'width' : 'normal',
'weight' : 'normal',
}
_propertyAliases['Helvetica'] = {
('slant', 'italic') : 'o',
('weight', 'normal') : 'medium',
('weight', 'light') : 'medium',
}
_fontInfo['Times'] = {
'foundry' : 'adobe',
'family' : 'times',
'registry' : '',
'charset' : 'iso8859',
'encoding' : '1',
'spacing' : 'p',
'slant' : 'normal',
'width' : 'normal',
'weight' : 'normal',
}
_propertyAliases['Times'] = {
('weight', 'normal') : 'medium',
('weight', 'light') : 'medium',
}
_fontInfo['Fixed'] = {
'foundry' : 'misc',
'family' : 'fixed',
'registry' : '',
'charset' : 'iso8859',
'encoding' : '1',
'spacing' : 'c',
'slant' : 'normal',
'width' : 'normal',
'weight' : 'normal',
}
_propertyAliases['Fixed'] = {
('weight', 'normal') : 'medium',
('weight', 'light') : 'medium',
('style', None) : '',
('width', 'condensed') : 'semicondensed',
}
_fontInfo['Courier'] = {
'foundry' : 'adobe',
'family' : 'courier',
'registry' : '',
'charset' : 'iso8859',
'encoding' : '1',
'spacing' : 'm',
'slant' : 'normal',
'width' : 'normal',
'weight' : 'normal',
}
_propertyAliases['Courier'] = {
('weight', 'normal') : 'medium',
('weight', 'light') : 'medium',
('style', None) : '',
}
_fontInfo['Typewriter'] = {
'foundry' : 'b&h',
'family' : 'lucidatypewriter',
'registry' : '',
'charset' : 'iso8859',
'encoding' : '1',
'spacing' : 'm',
'slant' : 'normal',
'width' : 'normal',
'weight' : 'normal',
}
_propertyAliases['Typewriter'] = {
('weight', 'normal') : 'medium',
('weight', 'light') : 'medium',
}
if os.name == 'nt':
# For some reason 'fixed' fonts on NT aren't.
_fontInfo['Fixed'] = _fontInfo['Courier']
_propertyAliases['Fixed'] = _propertyAliases['Courier']
Reference in New Issue View Git Blame Copy Permalink