#------------------------------------------------------------------------------- # Name: BaseCompanions.py # Purpose: Classes that 'shadow' controls. They implement design time # behaviour and interfaces # # Author: Riaan Booysen # # Created: 1999 # RCS-ID: $Id: BaseCompanions.py,v 1.39 2005/07/11 11:34:25 riaan Exp $ # Copyright: (c) 1999 - 2005 Riaan Booysen # Licence: GPL #------------------------------------------------------------------------------- """ Classes that 'shadow' controls. They implement design time behaviour and interfaces. Also used for inspectable objects """ print 'importing Companions' import copy import wx import Preferences, Utils from PropEdit.PropertyEditors import * from Constructors import WindowConstr import RTTI, EventCollections import methodparse, sourceconst """ Design time classes These are companion classes to wxPython classes that capture design-time behaviour like * Constructor parameters * Events * Property editors XXX Todo XXX * write/wrap many more classes * streaming of properties * xml option * handling of default values * define event and name for popup menu on component * overrideable method or new multi inheritance class for palette creation in container companions, """ class Companion: """ Default companion, entity with a name and default documentation """ def __init__(self, name): self.name = name def getPropertyHelp(self, propName): return propName class CodeCompanion(Companion): pass class DesignTimeCompanion(Companion): """ Base class for all companions participating in the design-time process. """ handledConstrParams = () suppressWindowId = False def __init__(self, name, designer): Companion.__init__(self, name) self.parentCompanion = None self.designer = designer # Design time window id self.dId = wx.NewId() self.id = None # Property editors for properties whose types cannot be deduced self.editors = {'Class': ClassConstrPropEdit} # Enumerated values for the options of a property editor self.options = {} # Enumerated display values for the options of a property editor # XXX Change to something less generic self.names = {} # Companion methods that must be called when a property changes self.triggers = {'Name': self.SetName} # Companions for properties for which a companion can not be deduced self.subCompanions = {} # Parsers for special properties, given string value should # return valid wxPython object # The property evaluator should return a tuple of arguments # as customPropEvaluators are also used to initialise multi parameter # properties self.customPropEvaluators = {} # Properties that should be initialised thru the companion instead of # directly on the control. Usually this applies to 'write-only' # properties whose values cannot otherwise be determined # It's keyed on the property name and if the setter does not start # with Set*, it's keyed on the setter name self.initPropsThruCompanion = [] # Run time dict of created collection companions self.collections = {} # Can't work, remove self.letClickThru = False # Mutualy depentent props # These props will all be refeshed in the inspector when any one of # them is updated self.mutualDepProps = [] # Flag for controls which do not process mouse events correctly self.ctrlDisabled = False self.compositeCtrl = False # self.resourceImports = [] # Parse objects for reading in and writing out source self.textConstr = None self.textPropList = [] self.textEventList = [] self.textCollInitList = [] def destroy(self): del self.triggers def constructor(self): """ This method must be overriden by defining it in in another class and multiply inheriting from this new class and a DesignTimeCompanion derivative. This allows groups of components having the same constructor to be created.""" return {} def extraConstrProps(self): return {} # def defaults(self): # return {} def getPropList(self): propList = RTTI.getPropList(self.control, self) pw = RTTI.PropertyWrapper('Class', 'CompnRoute', self.GetClass, self.SetClass) propList['constructor'].append(pw) return propList def GetClass(self, dummy=None): """ Used by the Inspector to display the type of the selected object """ return self.textConstr.class_name def SetClass(self, value): """ Used by the Inspector to display the type of the selected object """ self.textConstr.class_name = value def properties(self): """ Properties additional to those gleened thru reflection. Dictionary key=propname : type, val=getter, setter tuple. type = 'CtrlRoute' : Routed to get/setters on the control 'CompnRoute': Routed to get/setters on the companion """ return {} def setConstr(self, constr): """ Define a new constructor for source code, called when a component is parsed from source See also: persistConstr """ self.textConstr = constr def setProps(self, propList): # XXX Should companion initialise comp props instead of Designer? self.textPropList = propList def setCollInits(self, collInitList): self.textCollInitList = collInitList def setEvents(self, eventList): self.textEventList = eventList def getEvents(self): return self.textEventList def getWinId(self): return self.id def hideDesignTime(self): """ Property names of automatically picked up properties that should not be shown in the Inspector. """ return [] def dontPersistProps(self): """ Properties are live (i.e. read/write) at design time but whose changes won't be applied to source. This is for cascading type properties like Size vs ClientSize. Updating one will automatically update the other so only one of them has to be stored.""" return ['Class'] def onlyPersistProps(self): """ Properties that should not be applied at design-time and should only be applied to the source """ return [] def events(self): return [] def editor(self): pass def vetoedMethods(self): return [] ## def links(self): ## return [] # Rename to links def dependentProps(self): """ These are properties that depend on other controls already being created. They will be initialised right at the end of the definition block """ return [] def applyRunTime(self): """ Properties whose value will be modifyable at design-time and whose changes will be applied to the source but will not be applied to the controls at design time e.g. Show/Enable. """ pass def getPropEditor(self, prop): if self.editors.has_key(prop): return self.editors[prop] else: return None def getPropOptions(self, prop): if self.options.has_key(prop): return self.options[prop] else: return None def getPropNames(self, prop): if self.names.has_key(prop): return self.names[prop] else: return None def evtGetter(self, name): for evt in self.textEventList: if evt.event_name == name: return evt.trigger_meth return None def evtSetter(self, name, value): for evt in self.textEventList: if evt.event_name == name: evt.trigger_meth = value return def persistConstr(self, className, params): """ Define a new constructor for source code, called when creating a new component from the palette See also: setConstr """ paramStrs = [] for param in params.keys(): paramStrs.append('%s = %s'%(param, params[param])) # XXX Is frame name initialised ??? self.textConstr = methodparse.ConstructorParse('self.%s = %s(%s)' %( self.name, className, ', '.join(paramStrs))) self.designer.addCtrlToObjectCollection(self.textConstr) def persistCollInit(self, method, ctrlName, propName, params = {}): """ Define a new collection init method for source code, called when creating a new item in CollectionEditor """ collInitParse = methodparse.CollectionInitParse(None, ctrlName, method, [], propName) self.parentCompanion.textCollInitList.append(collInitParse) self.designer.addCollToObjectCollection(collInitParse) def checkTriggers(self, name, oldValue, newValue): #trigger specially handled callbacks for property changes with consequences if self.triggers.has_key(name): self.triggers[name](oldValue, newValue) def getCompName(self): if id(self.control) == id(self.designer): return '' else: return self.name def persistProp(self, name, setterName, value): c = self.constructor() #constructor if c.has_key(name): self.textConstr.params[c[name]] = value #property elif name not in self.dontPersistProps(): for prop in self.textPropList: if prop.prop_setter == setterName: prop.params = [value] return self.textPropList.append(methodparse.PropertyParse( \ None, self.getCompName(), setterName, [value], name)) def persistedPropVal(self, name, setterName): c = self.constructor() #constructor if c.has_key(name): return self.textConstr.params[c[name]] #property elif name not in self.dontPersistProps(): for prop in self.textPropList: try: if prop.prop_setter == setterName: return prop.params except: print 'except in persistprop' raise return None def propRevertToDefault(self, name, setterName): """ Removes property methods from source and revert constructor parameters to default values """ c = self.constructor() #constructor if c.has_key(name): defVal = self.designTimeSource()[c[name]] self.textConstr.params[c[name]] = defVal #property elif name not in self.dontPersistProps(): idx = 0 while idx < len(self.textPropList): prop = self.textPropList[idx] if prop.prop_setter == setterName: del self.textPropList[idx] else: idx = idx + 1 def propIsDefault(self, name, setterName): """ Returns True if no modification has been made to the property or constructor parameter """ c = self.constructor() #constructor if c.has_key(name): try: dts = self.designTimeSource() except TypeError: return True else: if dts.has_key(c[name]): defVal = self.designTimeSource()[c[name]] return self.textConstr.params[c[name]] == defVal else: return True #property elif name not in self.dontPersistProps(): for prop in self.textPropList: if prop.prop_setter == setterName: return False return True def persistEvt(self, name, value, wId = None): """ Add a source entry for an event or update the trigger method of am existing event. """ for evt in self.textEventList: if evt.event_name == name: evt.trigger_meth = value return if self.control == self.designer or \ not isinstance(self.control, wx.EvtHandler) or \ isinstance(self.control, wx.Timer): comp_name = '' else: comp_name = self.name self.textEventList.append(methodparse.EventParse(None, comp_name, name, value, wId)) def evtName(self): return self.name def addIds(self, lst): if self.id is not None: # generate default win id for list when reserved one is used by control if self.id in EventCollections.reservedWxIds: wId = Utils.windowIdentifier(self.designer.GetName(), self.name) else: wId = self.id lst.append(wId) def renameEventListIds(self, wId): for evt in self.textEventList: if evt.windowid and evt.windowid not in EventCollections.reservedWxIds: evt.windowid = wId def setProp(self, name, value): """ Optional callback companions can override for extra functionality after updating a property e.g. refreshing """ pass def SetName(self, oldValue, newValue): """ Triggered when the 'Name' property is changed """ if self.designer.objects.has_key(newValue): wx.LogError('There is already an object named '+newValue) else: self.name = newValue self.designer.model.renameCtrl(oldValue, newValue) self.designer.renameCtrl(oldValue, newValue) def renameCtrl(self, oldName, newName): self.textConstr.comp_name = newName for prop in self.textPropList: prop.comp_name = newName for collInit in self.textCollInitList: collInit.renameCompName2(oldName, newName) for evt in self.textEventList: if evt.comp_name: evt.comp_name = newName def renameCtrlRefs(self, oldName, newName): """ Notification of a the rename of another control, used to fix up references """ if self.textConstr: self.textConstr.renameCompName2(oldName, newName) for prop in self.textPropList: prop.renameCompName2(oldName, newName) def getPropNameFromSetter(self, setter): props = self.properties() for prop in props.keys(): if props[prop][1] and props[prop][1].__name__ == setter: return prop if setter[:3] == 'Set': return setter[3:] else: return setter def eval(self, expr): import PaletteMapping try: return PaletteMapping.evalCtrl(expr, self.designer.model.specialAttrs) except Exception, err: print 'Illegal expression: %s'%expr raise def defaultAction(self): """ Invoke the default property editor for this component, This can be anything from a custom editor to an event. """ pass def notification(self, compn, action): """ Called after components are added and before they are removed. Used for initialisation or finalisation hooks in other components. """ pass def registerResourceModule(self, name): """ Resource Module name that should be added to the import list """ if name not in self.resourceImports: self.resourceImports.append(name) def writeResourceImports(self): """ Return import line that will be added to module """ if not self.resourceImports: return '' else: return '\n'.join(['import %s'%mod for mod in self.resourceImports]) def writeImports(self): """ Return import line that will be added to module """ return '' #---Source writing methods------------------------------------------------------ def addContinuedLine(self, line, output, indent): if Preferences.cgWrapLines: if len(line) > Preferences.cgLineWrapWidth: segs = methodparse.safesplitfields(line, ',', True, (), ()) line = sourceconst.bodyIndent+segs[0].lstrip() for seg in segs[1:]: newLine = line +', '+ seg if len(newLine) >= Preferences.cgLineWrapWidth: output.append(line+',') line = indent+' '*Preferences.cgContinuedLineIndent+seg else: line = newLine output.append(line) def writeConstructor(self, output, collectionMethod, stripFrmId=''): """ Writes out constructor and parameters for control """ # Add constructor if self.textConstr: self.addContinuedLine( sourceconst.bodyIndent+self.textConstr.asText(stripFrmId), output, sourceconst.bodyIndent) nullProps = ('None', 'wx.NullBitmap', 'wx.NullIcon') def writeProperties(self, output, ctrlName, definedCtrls, deps, depLinks, stripFrmId=''): """ Write out property setters but postpone dependent properties. """ # Add properties for prop in self.textPropList: # Skip blanked out props if len(prop.params) == 1 and prop.params[0] in self.nullProps: continue # Postpone dependent props if self.designer.checkAndAddDepLink(ctrlName, prop, self.dependentProps(), deps, depLinks, definedCtrls): continue self.addContinuedLine(sourceconst.bodyIndent+prop.asText(stripFrmId), output, sourceconst.bodyIndent) def writeEvents(self, output, module=None, stripFrmId=''): """ Write out EVT_* calls for all events. Optionally For every event definition not defined in source add an empty method declaration to the bottom of the class """ for evt in self.textEventList: if evt.trigger_meth != '(delete)': self.addContinuedLine( sourceconst.bodyIndent + evt.asText(stripFrmId), output, sourceconst.bodyIndent) model = self.designer.model # Either rename the event or add if a new one # The first streamed occurrence will do the rename or add if evt.prev_trigger_meth and module and module.classes[ model.main].methods.has_key(evt.prev_trigger_meth): module.renameMethod(model.main, evt.prev_trigger_meth, evt.trigger_meth) elif module and not module.classes[ model.main].methods.has_key(evt.trigger_meth): module.addMethod(model.main, evt.trigger_meth, 'self, event', [sourceconst.bodyIndent + 'event.Skip()']) def writeCollections(self, output, collDeps, stripFrmId=''): """ Write out collection initialiser methods. """ for collInit in self.textCollInitList: if collInit.getPropName() in self.dependentProps(): self.addContinuedLine( sourceconst.bodyIndent + collInit.asText(stripFrmId), collDeps, sourceconst.bodyIndent) else: self.addContinuedLine( sourceconst.bodyIndent + collInit.asText(stripFrmId), output, sourceconst.bodyIndent) def writeDependencies(self, output, ctrlName, depLinks, definedCtrls, stripFrmId=''): """ Write out dependent properties if all the ctrls they reference have been created. """ if depLinks.has_key(ctrlName): for prop, otherRefs in depLinks[ctrlName]: for oRf in otherRefs: if oRf not in definedCtrls: # special attrs are not 'reference dependencies' if not hasattr( self.designer.model.specialAttrs['self'], oRf): break else: self.addContinuedLine( sourceconst.bodyIndent + prop.asText(stripFrmId), output, sourceconst.bodyIndent) class NYIDTC(DesignTimeCompanion): """ Blank holder for companions which have not been implemented.""" host = 'Not Implemented' def __init__(self, name, designer, parent, ctrlClass): raise 'Not Implemented' class ControlDTC(DesignTimeCompanion): """ Visible controls created on a Frame and defined from _init_ctrls. """ handledConstrParams = ('id', 'parent') windowIdName = 'id' windowParentName = 'parent' host = 'Designer' def __init__(self, name, designer, parent, ctrlClass): DesignTimeCompanion.__init__(self, name, designer) self.parent = parent self.ctrlClass = ctrlClass self.generateWindowId() self.container = False def designTimeControl(self, position, size, args = None): """ Create and initialise a design-time control """ if args: self.control = self.ctrlClass(**args) else: self.control = self.ctrlClass(**self.designTimeDefaults(position, size)) self.initDesignTimeControl() return self.control def designTimeDefaults(self, position = wx.DefaultPosition, size = wx.DefaultSize): """ Return a dictionary of parameters for the constructor of a wxPython control. e.g. {'name': 'Frame1', etc) """ if not position: position = wx.DefaultPosition if not size: size = wx.DefaultSize dts = self.designTimeSource('wx.Point(%s, %s)'%(position.x, position.y), 'wx.Size(%s, %s)'%(size.x, size.y)) for param in dts.keys(): dts[param] = self.eval(dts[param]) dts[self.windowParentName] = self.parent if not self.suppressWindowId: dts[self.windowIdName] = self.dId return dts def designTimeSource(self, position = 'wx.DefaultPosition', size = 'wx.DefaultSize'): """ Return a dictionary of parameters for the constructor of a wxPython control's source. 'parent' and 'id' handled automatically """ return {} def generateWindowId(self): if self.designer: self.id = Utils.windowIdentifier(self.designer.GetName(), self.name) else: self.id = `wx.NewId()` def SetName(self, oldValue, newValue): DesignTimeCompanion.SetName(self, oldValue, newValue) self.updateWindowIds() if self.compositeCtrl: for ctrl in self.control.GetChildren(): ctrl.SetName(newValue) def extraConstrProps(self): return {'Class': 'class'} ## def GetClass(self, dummy): ## return self.control.__class__.__name__ ## ## def SetClass(self, value): ## raise 'Cannot change' def updateWindowIds(self): self.generateWindowId() if not self.suppressWindowId: EventCollections.renameCmdIdInDict(self.textConstr.params, self.windowIdName, self.id) self.renameEventListIds(self.id) def initDesignTimeEvents(self, ctrl): # XXX Uncommenting this causes a crash after the first # XXX OnMouseOver event # By pushing the eventhandler, even ctrls # that hook to the Mouse events will still cause # mouse event to fire (theoretically) # ctrl.PushEventHandler(self.designer.ctrlEvtHandler) self.designer.ctrlEvtHandler.connectEvts(ctrl, self.compositeCtrl) def initDesignTimeControl(self): #try to set the name try: self.control.SetName(self.name) if self.compositeCtrl: for ctrl in self.control.GetChildren(): ctrl.SetName(self.name) ctrl._composite_child = 1 self.control.SetToolTipString(self.name) # Disabled controls do not pass thru mouse clicks to their parents on GTK :( if wx.Platform != '__WXGTK__' and self.ctrlDisabled: self.control.Enable(False) except: pass self.initDesignTimeEvents(self.control) self.popx = self.popy = 0 self.control.Bind(wx.EVT_RIGHT_DOWN, self.designer.OnRightDown) # for wxMSW # EVT_COMMAND_RIGHT_CLICK(self.control, -1, self.designer.OnRightClick) # for wxGTK self.control.Bind(wx.EVT_RIGHT_UP, self.designer.OnRightClick) def beforeResize(self): pass #print 'beforeResize' def afterResize(self): pass #print 'afterResize' def updatePosAndSize(self): if self.textConstr and self.textConstr.params.has_key('pos') \ and self.textConstr.params.has_key('size'): pos = self.control.GetPosition() size = self.control.GetSize() self.textConstr.params['pos'] = 'wx.Point(%d, %d)' % (pos.x, pos.y) self.textConstr.params['size'] = 'wx.Size(%d, %d)' % (size.x, size.y) def getDefCtrlSize(self): return 'wx.Size(%d, %d)'%(Preferences.dsDefaultControlSize.x, Preferences.dsDefaultControlSize.y) def getPositionDependentProps(self): return [('constr', 'Position'), ('prop', 'Position')] def getSizeDependentProps(self): return [('constr', 'Size'), ('prop', 'Size'), ('prop', 'ClientSize')] class MultipleSelectionDTC(DesignTimeCompanion): """ Semi mythical class at the moment that will represent a group of selected objects. It's properties should represent the common subset of properties of the selection. Currently only used so the inspector has something to hold on to during multiple selection """ # sub properties (Font etc) class HelperDTC(DesignTimeCompanion): """ Helpers are subobjects or enumerations of properties. """ def __init__(self, name, designer, ownerCompanion, obj, ownerPropWrap): DesignTimeCompanion.__init__(self, name, designer) self.control = obj # self.obj = obj self.ownerCompn = ownerCompanion self.owner = ownerCompanion.control self.ownerPW = ownerPropWrap self.updateObjFromOwner() def updateObjFromOwner(self): """ The object to which a sub object is connected may change this method reconnects the property to the current object. """ self.obj = self.ownerPW.getValue(self) self.ctrl = self.obj self.control = self.obj def updateOwnerFromObj(self): """ Changes to subobjects do not reflect in their owners automatically they have to be reassigned to their property """ self.ownerPW.setValue(self.obj) def persistProp(self, name, setterName, value): """ When a subobject's property is told to persist, it should persist it's owner This is currently managed by the property editor """ pass # non-visual classes (Imagelists, etc) class UtilityDTC(DesignTimeCompanion): """ Utility companions are 'invisible' components that are not owned by the Frame. Utilities are created before the frame and controls and defined in the _init_utils method. """ host = 'Data' def __init__(self, name, designer, objClass): DesignTimeCompanion.__init__(self, name, designer) self.objClass = objClass self.editors['Name'] = NameConstrPropEdit def properties(self): props = DesignTimeCompanion.properties(self) props['Name'] = ('NoneRoute', None, None) return props def designTimeObject(self, args = None): if args: self.control = self.objClass(**args) else: self.control = self.objClass(**self.designTimeDefaults()) return self.control def designTimeDefaults(self): """ Return a dictionary of parameters for the constructor of a wxPython control. e.g. {'name': 'Frame1', etc) """ dts = self.designTimeSource() for param in dts.keys(): dts[param] = self.eval(dts[param]) return dts def extraConstrProps(self): return {'Class': 'class'} def updateWindowIds(self): pass def updatePosAndSize(self): pass # XXX Parents, from constructor or current selected container in designer class WindowDTC(WindowConstr, ControlDTC): """ Defines the wxWindow interface overloading/defining specialised property editors. """ def __init__(self, name, designer, parent, ctrlClass): ControlDTC.__init__(self, name, designer, parent, ctrlClass) self.editors.update({'AutoLayout': BoolPropEdit, 'Shown': BoolPropEdit, 'Enabled': BoolPropEdit, #'EvtHandlerEnabled': BoolPropEdit, 'Style': StyleConstrPropEdit, #'Constraints': CollectionPropEdit, 'Name': NamePropEdit, 'Anchors': AnchorPropEdit, 'Sizer': SizerClassLinkPropEdit, 'SizeHints': TuplePropEdit, 'Cursor': CursorClassLinkPropEdit, 'Centered': EnumPropEdit, 'ThemeEnabled': BoolPropEdit, 'WindowVariant': EnumPropEdit, 'BackgroundStyle': EnumPropEdit, }) self.options['Centered'] = [None, wx.HORIZONTAL, wx.VERTICAL, wx.BOTH] self.names['Centered'] = {'None': None, 'wx.HORIZONTAL': wx.HORIZONTAL, 'wx.VERTICAL': wx.VERTICAL, 'wx.BOTH': wx.BOTH} self.options['WindowVariant'] = [wx.WINDOW_VARIANT_NORMAL, wx.WINDOW_VARIANT_SMALL, wx.WINDOW_VARIANT_MINI, wx.WINDOW_VARIANT_LARGE] self.names['WindowVariant'] = { 'wx.WINDOW_VARIANT_NORMAL': wx.WINDOW_VARIANT_NORMAL, 'wx.WINDOW_VARIANT_SMALL': wx.WINDOW_VARIANT_SMALL, 'wx.WINDOW_VARIANT_MINI': wx.WINDOW_VARIANT_MINI, 'wx.WINDOW_VARIANT_LARGE': wx.WINDOW_VARIANT_LARGE} self.options['BackgroundStyle'] = [wx.BG_STYLE_SYSTEM, wx.BG_STYLE_COLOUR, wx.BG_STYLE_CUSTOM] self.names['BackgroundStyle'] = { 'wx.BG_STYLE_SYSTEM': wx.BG_STYLE_SYSTEM, 'wx.BG_STYLE_COLOUR': wx.BG_STYLE_COLOUR, 'wx.BG_STYLE_CUSTOM': wx.BG_STYLE_CUSTOM} self.triggers.update({'Size' : self.SizeUpdate, 'Position' : self.PositionUpdate}) self.customPropEvaluators.update({'Constraints': self.EvalConstraints, 'SizeHints': self.EvalSizeHints,}) self.windowStyles = ['wx.CAPTION', 'wx.MINIMIZE_BOX', 'wx.MAXIMIZE_BOX', 'wx.THICK_FRAME', 'wx.SIMPLE_BORDER', 'wx.DOUBLE_BORDER', 'wx.SUNKEN_BORDER', 'wx.RAISED_BORDER', 'wx.STATIC_BORDER', 'wx.TRANSPARENT_WINDOW', 'wx.NO_3D', 'wx.TAB_TRAVERSAL', 'wx.WANTS_CHARS', 'wx.NO_FULL_REPAINT_ON_RESIZE', 'wx.VSCROLL', 'wx.HSCROLL', 'wx.CLIP_CHILDREN', 'wx.NO_BORDER', 'wx.ALWAYS_SHOW_SB'] self.mutualDepProps = ['Value', 'Title', 'Label'] #import UtilCompanions #self.subCompanions['Constraints'] = UtilCompanions.IndividualLayoutConstraintOCDTC #self.subCompanions['SizeHints'] = UtilCompanions.SizeHintsDTC self.anchorSettings = [] self._applyConstraints = False self.initPropsThruCompanion = ['SizeHints', 'Cursor', 'Center', 'Sizer'] self._sizeHints = (-1, -1, -1, -1) self._cursor = wx.NullCursor self._centered = None def properties(self): return {'Shown': ('CompnRoute', self.GetShown, self.Show), 'Enabled': ('CompnRoute', self.GetEnabled, self.Enable), 'ToolTipString': ('CompnRoute', self.GetToolTipString, self.SetToolTipString), 'Anchors': ('CompnRoute', self.GetAnchors, self.SetConstraints), 'SizeHints': ('CompnRoute', self.GetSizeHints, self.SetSizeHints), 'Cursor': ('CompnRoute', self.GetCursor, self.SetCursor), 'Centered': ('CompnRoute', self.GetCentered, self.Center), 'Sizer': ('CompnRoute', self.GetSizer, self.SetSizer), } def designTimeSource(self, position = 'wx.DefaultPosition', size = 'wx.DefaultSize'): return {'pos': position, 'size': self.getDefCtrlSize(), 'name': `self.name`, 'style': '0'} def dependentProps(self): return ['Cursor'] def onlyPersistProps(self): return ['Show', 'Enable'] def hideDesignTime(self): return ['NextHandler', 'PreviousHandler', 'EventHandler', 'EvtHandlerEnabled', 'Id', 'Caret', 'WindowStyleFlag', 'ToolTip', 'Title', 'Rect', 'DragTarget', 'DropTarget', 'Cursor', 'VirtualSize', 'Sizer', 'ContainingSizer', 'Constraints', 'DefaultItem', 'Validator', 'WindowStyle', 'AcceleratorTable', 'ClientRect'] def dontPersistProps(self): return ControlDTC.dontPersistProps(self) + ['ClientSize'] def applyRunTime(self): return ['Shown', 'Enabled', 'EvtHandlerEnabled'] def events(self): return ['MiscEvent', 'MouseEvent', 'FocusEvent', 'KeyEvent', 'HelpEvent'] def notification(self, compn, action): if action == 'delete': if self._cursor and `self._cursor` == `compn.control`: self.propRevertToDefault('Cursor', 'SetCursor') self.SetCursor(wx.NullCursor) # XXX sizer def persistProp(self, name, setterName, value): if setterName == 'SetSizeHints': minW, minH, maxW, maxH = self.eval(value) newParams = [`minW`, `minH`, `maxW`, `maxH`] # edit if exists for prop in self.textPropList: if prop.prop_setter == setterName: prop.params = newParams return # add if not defined self.textPropList.append(methodparse.PropertyParse( None, self.getCompName(), setterName, newParams, 'SetSizeHints')) elif setterName == 'SetSizer': sizerList = self.designer.getSizerConnectList() if sizerList is not None: for prop in sizerList: if prop.prop_setter == setterName and \ prop.comp_name == self.getCompName(): if value == 'None': sizerList.remove(prop) else: prop.params = [value] return if value != 'None': sizerList.append(methodparse.PropertyParse( None, self.getCompName(), setterName, [value], name)) else: ControlDTC.persistProp(self, name, setterName, value) def propIsDefault(self, propName, setterName): if setterName == 'SetSizer': scl = self.designer.getSizerConnectList() if scl: for connProp in self.designer.getSizerConnectList(): if connProp.comp_name == self.getCompName(): return False return True else: return ControlDTC.propIsDefault(self, propName, setterName) #---ToolTips-------------------------------------------------------------------- def GetToolTipString(self, blah): return self.control.GetToolTip().GetTip() def SetToolTipString(self, value): self.control.SetToolTipString(value) #---Anchors--------------------------------------------------------------------- from wx.lib.anchors import LayoutAnchors def writeImports(self): imports = ControlDTC.writeImports(self) if self.anchorSettings: return '\n'.join( (imports, 'from wx.lib.anchors import LayoutAnchors') ) else: return imports def GetAnchors(self, compn): if self.anchorSettings: return self.LayoutAnchors(*([self.control] + self.anchorSettings)) else: return None # Named like the wxWindow method to override it when generating code def SetConstraints(self, value): curVal = self.control.GetConstraints() if curVal != value: self.control.SetConstraints(value) if self.designer.selection: self.designer.selection.updateAnchors() elif self.designer.multiSelection: for selection in self.designer.multiSelection: selection.updateAnchors() self.designer.inspector.propertyUpdate('Anchors') def EvalConstraints(self, exprs, objects): if exprs[0].startswith('LayoutAnchors'): ctrl, left, top, right, bottom = \ methodparse.safesplitfields(exprs[0][len('LayoutAnchors')+1:-1], ',') ctrl, left, top, right, bottom = (objects[ctrl], self.eval(left), self.eval(top), self.eval(right), self.eval(bottom)) self.anchorSettings = [left, top, right, bottom] return (self.LayoutAnchors(ctrl, left, top, right, bottom), ) return (None,) def updateAnchors(self, flagset, value): if not self.anchorSettings: self.defaultAnchors() for idx in range(4): if flagset[idx]: self.anchorSettings[idx] = value def removeAnchors(self): self.anchorSettings = [] idx = 0 while idx < len(self.textPropList): prop = self.textPropList[idx] if prop.prop_setter == 'SetConstraints' and \ prop.params[0].startswith('LayoutAnchors'): del self.textPropList[idx] break else: idx = idx + 1 def defaultAnchors(self): self.anchorSettings = [True, True, False, False] def applyConstraints(self): left, top, right, bottom = self.anchorSettings self.control.SetConstraints( self.LayoutAnchors(self.control, left, top, right, bottom)) def beforeResize(self): lc = self.control.GetConstraints() self._applyConstraints = lc != None and self.anchorSettings if self._applyConstraints: self.SetConstraints(None) def afterResize(self): if self._applyConstraints and self.anchorSettings: self.applyConstraints() elif self.designer.sizersView and hasattr(self.control, '_in_sizer'): szr = self.control._in_sizer if szr: for si in szr.GetChildren(): if si.IsWindow(): if si.GetWindow() == self.control: p = self.control.GetPosition() s = self.control.GetSize() #si.SetDimension(p, s) si.SetInitSize(s.width, s.height) #szr.Layout() #self.designer.sizersView.layoutSizers() parent = self.control.GetParent() if parent: wx.PostEvent(parent, wx.SizeEvent( parent.GetSize(), parent.GetId())) wx.CallAfter(parent.Refresh)#relayoutCtrl(self.designer) #self.designer.model.editor.setStatus('Sizer item update %s, %s'%(p, s)) break #---Designer updaters----------------------------------------------------------- def SizeUpdate(self, oldValue, newValue): if self.designer.selection: self.designer.selection.selectCtrl(self.control, self) self.designer.selection.moveCapture(self.control, self, wx.Point(0, 0)) def PositionUpdate(self, oldValue, newValue): if self.designer.selection: self.designer.selection.selectCtrl(self.control, self) self.designer.selection.moveCapture(self.control, self, wx.Point(0, 0)) #---Size hints------------------------------------------------------------------ def GetSizeHints(self, dummy): return self._sizeHints def SetSizeHints(self, value): self._sizeHints = value self.control.SetSizeHints(value[0], value[1], value[2], value[3]) def EvalSizeHints(self, exprs, objects): res = [] for expr in exprs: res.append(self.eval(expr)) return tuple(res) #---Cursors--------------------------------------------------------------------- def GetCursor(self, x): return self._cursor def SetCursor(self, value): self._cursor = value self.control.SetCursor(value) #---Sizers---------------------------------------------------------------------- def GetSizer(self, x): return self.control.GetSizer() def SetSizer(self, value): if value is not None: self.control._has_sizer = value value._has_control = self.control else: if hasattr(self.control, '_has_sizer'): szr = self.control._has_sizer if szr: if hasattr(szr, '_has_control'): del szr._has_control del self.control._has_sizer self.control.SetSizer(value) if value is not None: value.Layout() self.designer.relayoutCtrl(self.control) #------------------------------------------------------------------------------- def GetCentered(self, dummy): return self._centered def Center(self, value): self._centered = value if value: self.control.Center(value) def GetShown(self, x): for prop in self.textPropList: if prop.prop_setter == 'Show': return int(prop.params[0].lower() == 'true') return 1 def Show(self, value): pass def GetEnabled(self, x): for prop in self.textPropList: if prop.prop_setter == 'Enable': return int(prop.params[0].lower() == 'true') return 1 def Enable(self, value): pass class ChoicedDTC(WindowDTC): def __init__(self, name, designer, parent, ctrlClass): WindowDTC.__init__(self, name, designer, parent, ctrlClass) self.editors['Choices'] = ChoicesConstrPropEdit class ContainerDTC(WindowDTC): """ Parent for controls that contain/own other controls """ def __init__(self, name, designer, parent, ctrlClass): WindowDTC.__init__(self, name, designer, parent, ctrlClass) self.container = True class CollectionDTC(DesignTimeCompanion): """ Companions encapsulating list maintaining behaviour into a single property Maintains an index which points to the currently active item in the collection """ propName = 'undefined' insertionMethod = 'undefined' deletionMethod = 'undefined' displayProp = 'undefined' indexProp = 'undefined' sourceObjName = 'parent' additionalMethods = {} def __init__(self, name, designer, parentCompanion, ctrl): DesignTimeCompanion.__init__(self, name, designer) from Views.CollectionEdit import CollectionEditor self.CollEditorFrame = CollectionEditor self.control = ctrl self.setCollectionMethod() self.index = 0 self.parentCompanion = parentCompanion def setCollectionMethod(self): self.collectionMethod = '_init_coll_%s_%s' %(self.name, self.propName) def setIndex(self, index): self.index = index self.setConstr(self.textConstrLst[index]) def setConstrs(self, constrLst, inits, fins): self.initialisers = inits self.finalisers = fins self.textConstrLst = constrLst def renameCtrl(self, oldName, newName): DesignTimeCompanion.renameCtrl(self, oldName, newName) self.setCollectionMethod() def renameCtrlRefs(self, oldName, newName): # textConstr and textPropList not used in collections # DesignTimeCompanion.renameCtrlRefs(self, oldName, newName) for constr in self.textConstrLst: constr.renameCompName2(oldName, newName) def getCount(self): return len(self.textConstrLst) def getDisplayProp(self): tcl = self.textConstrLst[self.index] if tcl.method != self.insertionMethod: if self.additionalMethods.has_key(tcl.method): displayProp = self.additionalMethods[tcl.method][1] else: return '-' else: displayProp = self.displayProp if tcl.params.has_key(displayProp): propSrc = tcl.params[displayProp] if propSrc and (propSrc[0] in ("'", '"') or propSrc[:2] in ('u"', "u'")): return self.eval(propSrc) else: return propSrc else: return '-' def initialiser(self): """ When overriding, append this after derived initialiser """ return [''] def finaliser(self): """ When overriding, append this before derived finaliser """ return [] def appendItem(self, method=None): self.index = self.getCount() if method is None: method = self.insertionMethod collItemInit = methodparse.CollectionItemInitParse(None, self.sourceObjName, method, self.designTimeSource(self.index, method)) self.textConstrLst.append(collItemInit) self.setConstr(collItemInit) self.applyDesignTimeDefaults(collItemInit.params, method) return collItemInit def deleteItem(self, idx): # remove from ctrl if self.deletionMethod != '(None)': getattr(self.control, self.deletionMethod)(idx) # renumber items following deleted one if self.indexProp != '(None)': for constr in self.textConstrLst[idx:]: constr.params[self.indexProp] = `int(constr.params[self.indexProp]) -1` def moveItem(self, idx, dir): tc = self.textConstrLst[idx] newIdx = min(max(idx + dir, 0), len(self.textConstrLst)-1) if newIdx != idx: del self.textConstrLst[idx] self.textConstrLst.insert(newIdx, tc) if self.indexProp != '(None)': # swap index property values (self.textConstrLst[idx].params[self.indexProp], self.textConstrLst[newIdx].params[self.indexProp]) = \ (self.textConstrLst[newIdx].params[self.indexProp], self.textConstrLst[idx].params[self.indexProp]) return newIdx def applyDesignTimeDefaults(self, params, method=None): if method is None: method = self.insertionMethod args = [] kwargs = {} paramItems = self.designTimeDefaults(params, method).items() paramItems.sort() for k, v in paramItems: if type(k) is type(0): args.append(v) else: kwargs[k] = v getattr(self.control, method)(*args, **kwargs) def SetName(self, oldValue, newValue): self.name = newValue self.setCollectionMethod() def GetClass(self, dummy=None): return self.propName def SetClass(self, value): pass def updateWindowIds(self): pass ## def addIds(self, lst): ## """ Iterate over items and extend lst for collections with ids """ ## pass def designTimeDefaults(self, vals, method=None): """ Return a dictionary of parameters for adding an item to the collection """ dtd = {} for param in vals.keys(): dtd[param] = self.eval(vals[param]) return dtd def initCollection(self): pass def writeCollectionInitialiser(self, output, stripFrmId=''): output.extend(self.initialiser()) def writeCollectionItems(self, output, stripFrmId=''): for creator in self.textConstrLst: self.addContinuedLine( sourceconst.bodyIndent + creator.asText(stripFrmId), output, sourceconst.bodyIndent) def writeCollectionFinaliser(self, output, stripFrmId=''): output.extend(self.finaliser()) def getPropList(self): """ Returns a dictionary of methods suported by the control The dict has 'properties' and 'methods' keys which contain the getters/setters and undefined methods. """ # XXX should use sub objects if available, but properties on collection # XXX items aren't supported yet return RTTI.getPropList(None, self) def defaultAction(self): """ Called when a component is double clicked in a designer """ pass ## print 'CDTC', self.textConstrLst[self.index] def notification(self, compn, action): """ Called when other components are deleted. Use it to clear references to components which are being deleted. """ # XXX Should use this mechanism to trap renames as well pass ## print 'CollectionDTC.notification', compn, action class CollectionIddDTC(CollectionDTC): """ Collections which have window ids and events """ windowIdName = 'id' idProp = '(undefined)' idPropNameFrom = '(undefined)' def __init__(self, name, designer, parentCompanion, ctrl): CollectionDTC.__init__(self, name, designer, parentCompanion, ctrl) self.editors = {'ItemId': ItemIdConstrPropEdit} def properties(self): props = CollectionDTC.properties(self) props['ItemId'] = ('CompnRoute', self.GetItemId, self.SetItemId) return props def evtName(self): # return '%s%s%d' % (self.name, self.propName, self.index) base = self.newWinId('') itemId = self.GetItemId(None)[len(base):].capitalize() return '%s%s' % (self.name, itemId) ## def setIndex(self, idx): ## CollectionDCT.setIndex(idx) ## self.setEvents( def getEvents(self): evts = [] idxWId = self.getWinId() for evt in self.textEventList: if evt.windowid == idxWId: evts.append(evt) return evts def getWinId(self): tcl = self.textConstrLst[self.index] if tcl.params.has_key(self.idProp): return tcl.params[self.idProp] else: return -1 def getDesignTimeWinId(self): return self.control.GetMenuItems()[self.index].GetId() def addIds(self, lst): for constr in self.textConstrLst: if constr.params.has_key(self.idProp): wId = constr.params[self.idProp] if wId in EventCollections.reservedWxIds: name, wId = self.newUnusedItemNames(0) lst.append(wId) def appendItem(self, method=None): CollectionDTC.appendItem(self, method) #1 self.generateWindowId(self.index) self.updateWindowIds() def deleteItemEvents(self, idx): constr = self.textConstrLst[idx] if constr.params.has_key(self.idProp): wIdStr = constr.params[self.idProp] for evt in self.textEventList[:]: if evt.windowid == wIdStr: self.textEventList.remove(evt) def deleteItem(self, idx): self.deleteItemEvents(idx) CollectionDTC.deleteItem(self, idx) self.updateWindowIds() def newUnusedItemNames(self, wId): while 1: newItemName = '%s%d'%(self.propName, wId) winId = self.newWinId(newItemName) if self.isIdUsed(winId): wId = wId + 1 else: break return newItemName, winId def isIdUsed(self, wId): for tc in self.textConstrLst: if tc.params.has_key(self.idProp) and tc.params[self.idProp] == wId: return True return False def newWinId(self, itemName): return Utils.windowIdentifier(self.designer.controllerView.GetName(), self.name + itemName) def generateWindowId(self, idx): return def SetName(self, oldValue, newValue): CollectionDTC.SetName(self, oldValue, newValue) self.updateWindowIds() def evtGetter(self, name): wId = self.getWinId() for evt in self.textEventList: if evt.event_name == name and evt.windowid == wId: return evt.trigger_meth return None def evtSetter(self, name, value): wId = self.getWinId() for evt in self.textEventList: if evt.event_name == name and evt.windowid == wId: evt.trigger_meth = value return def persistEvt(self, name, value, wId = None): """ Add a source entry for an event or update the trigger method of am existing event. """ if wId is None: wId = self.getWinId() for evt in self.textEventList: if evt.event_name == name and evt.windowid == wId: evt.trigger_meth = value return if self.control == self.designer or wId is not None: comp_name = '' else: comp_name = self.name self.textEventList.append(methodparse.EventParse(None, comp_name, name, value, wId)) def updateWindowIds(self): for idx in range(len(self.textConstrLst)): # XXX no op? self.generateWindowId(idx) def designTimeDefaults(self, vals, method=None): """ Return a dictionary of parameters for the constructor of a wxPython control. e.g. {'name': 'button1', etc) Derived classes should only call this base method if method requires an id parameter. This is usually the case.""" values = copy.copy(vals) values[self.idProp] = `wx.NewId()` dts = CollectionDTC.designTimeDefaults(self, values) dts[self.idProp] = wx.NewId() return dts def GetItemId(self, x): return self.textConstrLst[self.index].params[self.idProp] def SetItemId(self, value): oldValue = self.textConstrLst[self.index].params[self.idProp] self.textConstrLst[self.index].params[self.idProp] = value for evt in self.textEventList: if evt.windowid == oldValue: evt.windowid = value