######################################################################## # # Date: Nov. 2001 Author: Michel Sanner, Daniel Stoffler # # sanner@scripps.edu # stoffler@scripps.edu # # The Scripps Research Institute (TSRI) # Molecular Graphics Lab # La Jolla, CA 92037, USA # # Copyright: Michel Sanner, Daniel Stoffler and TSRI # # revision: Guillaume Vareille # ######################################################################### # # $Header: /opt/cvs/python/packages/share1.5/NetworkEditor/items.py,v 1.423.2.2 2016/02/11 23:41:06 annao Exp $ # # $Id: items.py,v 1.423.2.2 2016/02/11 23:41:06 annao Exp $ # import warnings, re, sys, os, user, inspect, copy, cmath, math, types, weakref import copy, random import string, threading, traceback import Tkinter, Pmw, tkFileDialog, Image, ImageTk import numpy from tkSimpleDialog import askstring from mglutil.util.packageFilePath import getResourceFolderWithVersion from NetworkEditor.ports import InputPort, OutputPort, RunNodeInputPort, \ TriggerOutputPort, SpecialOutputPort from mglutil.util.callback import CallBackFunction from mglutil.util.uniq import uniq from mglutil.util.misc import ensureFontCase from mglutil.util.misc import suppressMultipleQuotes from NetworkEditor.widgets import widgetsTable from NetworkEditor.Editor import NodeEditor from NetworkEditor.ports import InputPortsDescr, OutputPortsDescr, Port # FIXME .. dependency on Vision is bad here from mglutil.util.packageFilePath import findFilePath ICONPATH = findFilePath('Icons', 'Vision') # namespace note: node's compute function get compiled using their origin # module's __dict__ as global name space from itemBase import NetworkItems class NetworkNodeBase(NetworkItems): """Base class for a network editor Node """ def __init__(self, name='NoName', sourceCode=None, originalClass=None, constrkw=None, library=None, progbar=0, **kw): NetworkItems.__init__(self, name) self.objEditor = None # will be an instance of an Editor object self.network = None # VPE network self.originalClass = originalClass if originalClass is None: self.originalClass = self.__class__ if library is not None: assert library.modName is not None, "ERROR: node %s create with library %s that has no modname"%(name, library.name) assert library.varName is not None, "ERROR: node %s create with library %s that has no varName"%(name, library.name) self.library = library self.options = kw if constrkw is None: constrkw = {} self.constrkw = constrkw # dictionary of name:values to be added to # the call of the constructor when node # is instanciated from a saved network # used in getNodeSourceCode and # getNodesCreationSourceCode if not sourceCode: sourceCode = """def doit(self):\n\tpass\n""" self.setFunction(sourceCode) self.readOnly = False #self.mtstate = 0 # used by MTScheduler to schedule nodes in sub-tree #self.thread = None # will hold a ThreadNode object self.newData = 0 # set to 1 by outputData of parent node self.widthFirstTag = 0 # tag used by widthFirstTraversal self.isRootNode = 1 # when a node is created it isnot yet a child self.forceExecution = 0 # if the forceExecution flag is set # we will always run, else we check if new data is available self.expandedIcon = False # True when widgets in node are shown self.widgetsHiddenForScale = False # will be set to true if node scales # below 1.0 while widget are seen # does the node have a progrs bar ? self.hasProgBar = progbar if self.hasProgBar: self.progBarH = 3 # Progress bar width else: self.progBarH = 0 self.scaleSum = 1.0 # scale factor for this node's icon self.highlightOptions = {'highlightbackground':'red'} self.unhighlightOptions = {'highlightbackground':'gray50'} self.selectOptions = {'background':'yellow'} self.deselectOptions = {'background':'gray85'} self.posx = 0 # position where node will be placed on canvas self.posy = 0 # these vales are set in the addNode method of # the canvas to which this node is added # the are the upper left corner if self.innerBox self.center = [0,0] # center of innerBox self.inputPorts = [] # will hold a list of InputPort objects self.outputPorts = [] # will hold a list of OutputPort objects self._inputPortsID = 0 # used to assign InputPorts a unique number self._outputPortsID = 0 # used to assign OutputPorts a unique number self._id = None # a unique node number, which is assigned in # network.addNodes() #self.widgets = {} # {widgetName: PortWidget object } # # Used to save the widget when it is unbound self.specialInputPorts = [] self.specialOutputPorts = [] self.specialPortsVisible = False self.children = [] # list of children nodes self.parents = [] # list of parent nodes self.nodesToRunCache = [] # list of nodes to be run when this node # triggers self.condition = None self.funcEditorDialog = None # ports description, these dictionaries are used to create ports # at node's instanciation self.inputPortsDescr = InputPortsDescr(self) # [{optionName:optionValue}] self.outputPortsDescr = OutputPortsDescr(self) # [{optionName:optionValue}] self.widgetDescr = {} # {widgetName: {optionName:optionValue}} self.mouseAction[''] = self.showParams_cb self.mouseAction[''] = self.toggleNodeExpand_cb self.mouseAction[''] = self.startMoveOneNode self.hasMoved = False # set to True in net.moveSubGraph() def customizeConnectionCode(self, conn, name, indent=''): return [] def showParams_cb(self, event=None): ed = self.getEditor() ed.libTree.showNodeParameters(self.paramPanel.mainFrame) def resize(self, event): return def onStoppingExecution(self): pass def beforeAddingToNetwork(self, network): NetworkItems.beforeAddingToNetwork(self, network) def safeName(self, name): """remove all weird symbols from node name so that it becomes a regular string usabel as a Python variable in a saved network """ name = name.replace(' ', '_') # name cannot contain spaces if name[0].isdigit(): # first letter cannot be a number name = '_'+name if name.isalnum(): return name if name.isdigit(): return name # replace weird characters by '_' newname = '' for c in name: if c.isalnum(): newname += c else:# if c in ['/', '\\', '~', '$', '!']: newname+= '_' return newname def getUniqueNodeName(self): return '%s_%d'%(self.safeName(self.name), self._id) def configure(self, **kw): """Configure a NetworkNode object. Going through this framework tags the node modified. Supports the following keywords: name: node name (string) position: node position on canvas. Must be a tuple of (x,y) coords function: the computational method of this node expanded: True or False. If True: expand the node specialPortsVisible: True or False. If True: show the special ports paramPanelImmediate: True or False. This sets the node's paramPanel immediate state """ ed = self.getEditor() for k,v in kw.items(): if k == 'function': #solves some \n issues when loading saved networks v = v.replace('\'\'\'', '\'') v = v.replace('\"\"\"', '\'') v = v.replace('\'', '\'\'\'') #v = v.replace('\"', '\'\'\'') kw[k] = v self.setFunction(v, tagModified=True) elif ed is not None and ed.hasGUI: if k == 'name': self.rename(v, tagModified=True) elif k == 'position': self.move(v[0], v[1], absolute=True, tagModified=True) elif k == 'expanded': if self.isExpanded() and v is False: self.toggleNodeExpand_cb() elif not self.isExpanded() and v is True: self.toggleNodeExpand_cb() elif k == 'specialPortsVisible': if self.specialPortsVisible and v is False: self.hideSpecialPorts(tagModified=True) elif not self.specialPortsVisible and v is True: self.showSpecialPorts(tagModified=True) elif k == 'paramPanelImmediate': self.paramPanel.setImmediate(immediate=v, tagModified=True) elif k == 'frozen': if self.frozen is True and v is False: self.toggleFrozen_cb() elif self.frozen is False and v is True: self.toggleFrozen_cb() def getDescr(self): """returns a dict with the current configuration of this node""" cfg = {} cfg['name'] = self.name cfg['position'] = (self.posx, self.posy) cfg['function'] = self.sourceCode cfg['expanded'] = self.isExpanded() cfg['specialPortsVisible'] = self.specialPortsVisible cfg['paramPanelImmediate'] = self.paramPanel.immediateTk.get() cfg['frozen'] = self.frozen return cfg def rename(self, name, tagModified=True): """Rename a node. remember the name has changed, resize the node if necessary""" if name == self.name or name is None or len(name)==0: return # if name contains ' " remove them name = name.replace("'", "") name = name.replace('"', "") self.name=name if self.iconMaster is None: return canvas = self.iconMaster canvas.itemconfigure(self.textId, text=self.name) self.autoResizeX() if tagModified is True: self._setModified(True) def displayName(self, displayedName, tagModified=True): """display the displyed node name. remember the name has changed, resize the node if necessary""" if displayedName is None or len(displayedName)==0: return # if name contains ' " remove them displayedName = displayedName.replace("'", "") displayedName = displayedName.replace('"', "") if self.iconMaster is None: return canvas = self.iconMaster canvas.itemconfigure(self.textId, text=displayedName) self.autoResizeX() if tagModified is True: self._setModified(True) def ischild(self, node): """returns True is self is a child node of node """ conn = self.getInConnections() for c in conn: if c.blocking is True: node2 = c.port1.node if node2 == node: return True else: return node2.ischild(node) return False def isMacro(self): """Returns False if this node is not a MacroNode, returns True if MacroNode""" return False def startMoveOneNode(self, event): # get a handle to the network of this node net = self.network # save the current selection if len(net.selectedNodes): self.tempo_curSel = net.selectedNodes[:] # clear the current selection net.clearSelection() # select this node so we can move it net.selectNodes([self], undo=0) # call the function to register functions for moving selected nodes net.moveSelectedNodesStart(event) # register an additional function to deselect this node # and restore the original selection num = event.num # FIXME looks like I am binding this many times ! net.canvas.bind(""%num, self.moveSelectedNodeEnd,'+') def moveSelectedNodeEnd(self, event): # get a handle to the network of this node net = self.network # clear the selection (made of this node) net.clearSelection() # if we saved a selection when we started moving this node, restore it if hasattr(self, 'tempo_curSel'): net.selectNodes(self.tempo_curSel, undo=0) del self.tempo_curSel net.canvas.unbind(""%event.num) self.updateCenter() def updateCenter(self): canvas = self.network.canvas if canvas is None: return bb = canvas.bbox(self.innerBox) cx = self.posx + (bb[2]-bb[0])/2 cy = self.posy + (bb[3]-bb[1])/2 self.center = [cx,cy] def isModified(self): # loop over all input ports, all widgets, all outputports, and report # if anything has been modified modified = False if self._modified: return True # input ports and widgets for p in self.inputPorts: if p._modified: modified = True break if p.widget: if p.widget._modified: modified = True break if modified is True: return modified # output ports for p in self.outputPorts: if p._modified: modified = True break return modified def resetModifiedTag(self): """set _modified attribute to False in node, ports, widgets.""" self._modified = False for p in self.inputPorts: p._modified = False if p.widget: p.widget._modified = False for p in self.outputPorts: p._modified = False def resetTags(self): """set _modified attribute to False in node, ports, widgets. Also, sets _original attribute to True in node, ports, widgets And we also reset the two flags in all connections from and to ports""" self._modified = False self._original = True for p in self.inputPorts: p._modified = False p._original = True if p.widget: p.widget._modified = False p.widget._original = True for c in p.connections: c._modified = False c._original = True for p in self.outputPorts: p._modified = False p._original = True for c in p.connections: c._modified = False c._original = True def getInputPortByName(self, name): # return the an input port given its name for p in self.inputPorts: if p.name==name: return p warnings.warn( 'WARNING: input port "%s" not found in node %s'%(name, self.name)) def getOutputPortByName(self, name): # return the an output port given its name for p in self.outputPorts: if p.name==name: return p warnings.warn( 'WARNING: output port "%s" not found in node %s'%(name, self.name)) def getOutputPortByType(self, type, name=None): # return the matching or first output port given its type if len(self.outputPorts) == 0: return None lDatatypeObject = \ self.outputPorts[0].getDatatypeObjectFromDatatype(type) lPort = None for p in self.outputPorts: if p.datatypeObject == lDatatypeObject: if p.name == name: return p elif p is None: return p elif lPort is None: lPort = p if lPort is not None: return lPort return None def getSpecialInputPortByName(self, name): # return the an input port given its name for p in self.specialInputPorts: if p.name==name: return p warnings.warn( 'WARNING: special input port "%s" not found in node %s'%(name, self.name)) def getSpecialOutputPortByName(self, name): # return the an output port given its name for p in self.specialOutputPorts: if p.name==name: return p warnings.warn( 'WARNING: special output port "%s" not found in node %s'%(name, self.name)) def getInConnections(self): l = [] for p in self.inputPorts: l.extend(p.connections) for p in self.specialInputPorts: l.extend(p.connections) return l def getOutConnections(self): l = [] for p in self.outputPorts: l.extend(p.connections) for p in self.specialOutputPorts: l.extend(p.connections) return l def getConnections(self): return self.getInConnections()+self.getOutConnections() def getWidgetByName(self, name): port = self.inputPortByName[name] if port: if port.widget: return port.widget ############################################################################## # The following methods are needed to save a network # getNodeDefinitionSourceCode() is called by net.getNodesCreationSourceCode() ############################################################################## def getNodeDefinitionSourceCode(self, networkName, indent="", ignoreOriginal=False): """This method builds the text-string to describe a network node in a saved file. networkName: string holding the networkName indent: string of whitespaces for code indentation. Default: '' ignoreOriginal: True/False. Default: False. If set to True, the node's attr _original is ignored (used in cut/copy/paste nodes inside a macro that came from a node library where nodes are marked original This method is called by net.getNodesCreationSourceCode() NOTE: macros.py MacroNode re-implements this method!""" lines = [] nodeName = self.getUniqueNodeName() self.nameInSavedFile = nodeName ################################################################## # add lines to import node from library, instanciate node, and # add node to network ################################################################## indent, l = self.getNodeSourceCodeForInstanciation( networkName, indent=indent, ignoreOriginal=ignoreOriginal) lines.extend(l) ################################################################## # fetch code that desccribes the changes done to this node compared # to the base class node ################################################################## txt = self.getNodeSourceCodeForModifications( networkName, indent=indent, ignoreOriginal=ignoreOriginal) lines.extend(txt) txt = self.getStateDefinitionCode(nodeName=nodeName,indent=indent) lines.extend(txt) return lines def getStateDefinitionCode(self, nodeName, indent=''): #print "getStateDefinitionCode" return '' def getNodeSourceCodeForModifications(self, networkName, indent="", ignoreOriginal=False): """Return the code that describes node modifications compared to the original node (as described in a node library)""" lines = [] ################################################################## # add lines for ports if they changed compared to the base class ################################################################## indent, l = self.getNodeSourceCodeForPorts(networkName, indent , ignoreOriginal) lines.extend(l) ################################################################## # add lines for widgets: add/delete/configure/unbind, and set value ################################################################## indent, l = self.getNodeSourceCodeForWidgets(networkName, indent, ignoreOriginal) lines.extend(l) ################################################################## # add lines for node changes (name, expanded, etc) ################################################################## indent, l = self.getNodeSourceCodeForNode(networkName, indent, ignoreOriginal) lines.extend(l) return lines def getNodeSourceCodeForInstanciation(self, networkName="masterNet", indent="", ignoreOriginal=False, full=0): """This method is called when saving a network. Here, code is generated to import a node from a library, instanciate the node, and adding it to the network.""" lines = [] ed = self.getEditor() nodeName = self.getUniqueNodeName() ################################################################## # Abort if this node is original (for example, inside a macro node) ################################################################## if self._original is True and not full and not ignoreOriginal: return indent, lines ed._tmpListOfSavedNodes[nodeName] = self k = self.__class__ ################################################################## # add line to import node from the library ################################################################## if self.library is not None: libName = self.library.varName lines.append(indent + "klass = %s.nodeClassFromName['%s']\n"%(libName, k.__name__)) else: pathStr = str(k)[8:-2] # i.e. 'NetworkEditor.Tests.nodes.PassNode' klass = pathStr.split('.')[-1] # i.e. PassNode path = pathStr[:-len(klass)-1] # i.e. NetworkEditor.Tests.nodes libName = None lines.append(indent + "from %s import %s\n"%(path, klass)) lines.append(indent + "klass = %s\n"%klass) #if self.library.file is not None: # user defined library ## if False: # skip this test!! ## l = "from mglutil.util.packageFilePath import "+\ ## "getObjectFromFile\n" ## lines.append(indent+l) ## lines.append(indent+"%s = getObjectFromFile( '%s', '%s')\n"%( ## k.__name__, self.library.file, k.__name__)) ## else: ## line = "from "+k.__module__+" import "+k.__name__+"\n" ## lines.append(indent+line) ## else: # generate from EwSignal import EwSignalCollector #line = "from "+k.__module__+" import "+k.__name__+"\n" #lines.append(indent+line) # generate klass = EwSignal.nodeClassFromName['EwSignalCollector'] #line = "klass = %s.nodeClassFromName['%s']\n"%(self.library.varName, # k.__name__) #lines.append(indent+line) ################################################################## # add line with constructor keywords if needed ################################################################## constrkw = '' for name, value in self.constrkw.items(): constrkw = constrkw + name+'='+str(value)+', ' # this line seems redondant, # but is usefull when the network is saved and resaved # especially with pmv nodes constrkw = constrkw + "constrkw="+str(self.constrkw)+', ' ################################################################## # add line to instanciate the node ################################################################## #line=nodeName+" = "+k.__name__+"("+constrkw+"name='"+\ # self.name+"'" line=nodeName+" = klass("+constrkw+"name='"+\ self.name+"'" if libName is not None: line = line + ", library="+libName line = line + ")\n" lines.append(indent+line) ################################################################## # add line to add the node to the network ################################################################## txt = networkName+".addNode("+nodeName+","+str(self.posx)+","+\ str(self.posy)+")\n" lines.append(indent+txt) return indent, lines def getNodeSourceCodeForPorts(self, networkName, indent="", ignoreOriginal=False,full=0, dummyNode=None, nodeName=None): """Create code used to save a network which reflects changes of ports compared to the port definitions in a given network node of a node library. We create text to configure a port with changes, adding a port or deleting a port. If optional keyword 'full' is set to 1, we will append text to configure unchanged ports""" lines = [] ed = self.getEditor() if dummyNode is None: # we need the base class node if issubclass(self.__class__, FunctionNode): lKw = {'masternet':self.network} lKw.update(self.constrkw) dummyNode = apply(self.__class__,(), lKw) else: dummyNode = self.__class__() if nodeName is None: nodeName = self.getUniqueNodeName() ############################################################### # created save strings for inputPorts ############################################################### i = 0 lDeleted = 0 for index in range(len(dummyNode.inputPortsDescr)): # Delete remaining input ports if necessary if i >= len(self.inputPorts): if nodeName != 'self': lines = self.checkIfNodeForSavingIsDefined( lines, networkName, indent) txt = "%s.deletePort(%s.inputPortByName['%s'])\n"%( #txt = "%s.deletePort(%s.getInputPortByName('%s'))\n"%( nodeName, nodeName, dummyNode.inputPortsDescr[index]['name']) lines.append(indent+txt) continue ip = self.inputPorts[i] # delete input port if ip._id != index: if nodeName != 'self': lines = self.checkIfNodeForSavingIsDefined( lines, networkName, indent) txt = "%s.deletePort(%s.inputPortByName['%s'])\n"%( #txt = "%s.deletePort(%s.getInputPortByName('%s'))\n"%( nodeName, nodeName, dummyNode.inputPortsDescr[index]['name']) lines.append(indent+txt) lDeleted += 1 continue # modify input port else: if ip._modified is True or ignoreOriginal is True: if full: changes = ip.getDescr() else: changes = ip.compareToOrigPortDescr() if len(changes): if nodeName != 'self': lines = self.checkIfNodeForSavingIsDefined( lines, networkName, indent) txt = "apply(%s.inputPortByName['%s'].configure, (), %s)\n"%( nodeName, dummyNode.inputPortsDescr[ip._id]['name'], str(changes) ) #txt = "apply(%s.inputPorts[%s].configure, (), %s)\n"%( # nodeName, ip.number, str(changes) ) lines.append(indent+txt) i = i + 1 continue # check if we have to add additional input ports for p in self.inputPorts[len(dummyNode.inputPortsDescr) - lDeleted:]: if p._modified is True or ignoreOriginal is True: descr = p.getDescr() if nodeName != 'self': lines = self.checkIfNodeForSavingIsDefined( lines, networkName, indent) txt = "apply(%s.addInputPort, (), %s)\n"%( nodeName, str(descr) ) lines.append(indent+txt) ############################################################### # created save strings for outputPorts ############################################################### i = 0 for index in range(len(dummyNode.outputPortsDescr)): # Delete remaining output ports if necessary if i >= len(self.outputPorts): if nodeName != 'self': lines = self.checkIfNodeForSavingIsDefined( lines, networkName, indent) txt = "%s.deletePort(%s.outputPortByName['%s'])\n"%( nodeName, nodeName, dummyNode.outputPortsDescr[index]['name']) lines.append(indent+txt) continue op = self.outputPorts[i] # delete output port if not op._id == index: if nodeName != 'self': lines = self.checkIfNodeForSavingIsDefined( lines, networkName, indent) txt = "%s.deletePort(%s.outputPortByName['%s'])\n"%( nodeName, nodeName, dummyNode.outputPortsDescr[index]['name']) lines.append(indent+txt) continue # modify output port else: if op._modified is True or ignoreOriginal is True: if full: changes = op.getDescr() else: changes = op.compareToOrigPortDescr() if len(changes): if nodeName != 'self': lines = self.checkIfNodeForSavingIsDefined( lines, networkName, indent) txt = "apply(%s.outputPortByName['%s'].configure, (), %s)\n"%( nodeName, dummyNode.outputPortsDescr[op._id]['name'], str(changes) ) #txt = "apply(%s.outputPorts[%s].configure, (), %s)\n"%( # nodeName, op.number, str(changes) ) lines.append(indent+txt) i = i + 1 continue # check if we have to add additional output ports for p in self.outputPorts[len(dummyNode.outputPortsDescr):]: if p._modified is True or ignoreOriginal is True: descr = p.getDescr() if nodeName != 'self': lines = self.checkIfNodeForSavingIsDefined( lines, networkName, indent) txt = "apply(%s.addOutputPort, (), %s)\n"%( nodeName, str(descr) ) lines.append(indent+txt) # makes the specials ports visible if necessary if self.specialPortsVisible: if nodeName != 'self': lines = self.checkIfNodeForSavingIsDefined( lines, networkName, indent) txt = "apply(%s.configure, (), {'specialPortsVisible': True})\n"%(nodeName) lines.append(indent+txt) return indent, lines def getNodeSourceCodeForWidgets(self, networkName, indent="", ignoreOriginal=False, full=0, dummyNode=None, nodeName=None): """Create code used to save a network which reflects changes of widgets compared to the widget definitions in a given network node of a node library. We create text to configure a widget with changes, adding a widget or deleting a widget. If optional keyword 'full' is set to 1, we will append text to configure unchanged widgets.""" lines = [] ed = self.getEditor() if dummyNode is None: # we need the base class node if issubclass(self.__class__, FunctionNode): lKw = {'masternet':self.network} lKw.update(self.constrkw) dummyNode = apply(self.__class__,(), lKw) else: dummyNode = self.__class__() if nodeName is None: nodeName = self.getUniqueNodeName() for i in range(len(self.inputPorts)): p = self.inputPorts[i] if p._id >= len(dummyNode.inputPortsDescr): origDescr = None elif p.name != dummyNode.inputPortsDescr[p._id]['name']: origDescr = None else: try: origDescr = dummyNode.widgetDescr[p.name] except: origDescr = None w = p.widget try: ownDescr = w.getDescr() except: ownDescr = None ############################################################# # if current port has no widget and orig port had no widget: # continue ############################################################# if ownDescr is None and origDescr is None: pass ############################################################# # if current port has no widget and orig port had a widget: # unbind the widget. Also, check if the port was modified: # unbinding and deleting a widget sets the port._modifed=True ############################################################# elif ownDescr is None and origDescr is not None: if (p._modified is True) or (ignoreOriginal is True): if nodeName != 'self': lines = self.checkIfNodeForSavingIsDefined( lines, networkName, indent) ## distinguish between "delete" and "unbind": # 1) Delete event (we don't have _previousWidgetDescr) if p._previousWidgetDescr is None: txt = "%s.inputPortByName['%s'].deleteWidget()\n"%( nodeName, self.inputPortsDescr[i]['name']) #txt = "%s.inputPorts[%d].deleteWidget()\n"%( # nodeName, i) lines.append(indent+txt) # 2) unbind event (we have _previousWidgetDescr) else: # first, set widget to current value txt1 = self.getNodeSourceCodeForWidgetValue( networkName, i, indent, ignoreOriginal, full) lines.extend(txt1) # then unbind widget txt2 = "%s.inputPortByName['%s'].unbindWidget()\n"%( nodeName, self.inputPortsDescr[i]['name']) #txt2 = "%s.inputPorts[%d].unbindWidget()\n"%( # nodeName, i) lines.append(indent+txt2) ############################################################# # if current port has widget and orig port had no widget: # create the widget ############################################################# elif ownDescr is not None and origDescr is None: if nodeName != 'self': lines = self.checkIfNodeForSavingIsDefined( lines, networkName, indent) # create widget txt = \ "apply(%s.inputPortByName['%s'].createWidget, (), {'descr':%s})\n"%( nodeName, self.inputPortsDescr[i]['name'], str(ownDescr ) ) #txt = \ # "apply(%s.inputPorts[%d].createWidget, (), {'descr':%s})\n"%( # nodeName, i, str(ownDescr ) ) lines.append(indent+txt) # Hack to set widget. This fixes the ill sized nodes # when new widgets have been added to a node (MS) wmaster = ownDescr.get('master', None) if wmaster=='node': txt = "%s.inputPortByName['%s'].widget.configure(master='node')\n"%(nodeName, self.inputPortsDescr[i]['name']) lines.append(indent+txt) # set widget value txt = self.getNodeSourceCodeForWidgetValue( networkName, i, indent, ignoreOriginal, full, nodeName) lines.extend(txt) ############################################################# # if current port has widget and orig port has widget: # check if both widgets are the same, then check if changes # occured. # If widgets are not the same, delete old widget, create new ############################################################# elif ownDescr is not None and origDescr is not None: if ownDescr['class'] == origDescr['class']: if p.widget._modified is True or ignoreOriginal is True: if full: changes = ownDescr else: changes = w.compareToOrigWidgetDescr() if len(changes): if nodeName != 'self': lines = self.checkIfNodeForSavingIsDefined( lines, networkName, indent) if changes.has_key('command'): # extract and build the correct CB function name lCommand = changes['command'] lCommandStr = str(lCommand) lCbIndex = lCommandStr.find('.') lCbFuncName = nodeName + lCommandStr[lCbIndex:] lCbIndex = lCbFuncName.find(' ') lCbFuncName = lCbFuncName[:lCbIndex] changes['command'] = lCbFuncName # the changes['command'] is now a string # so, we need to get rid of the quote # that comes with the output lChangesStr = str(changes) lQuoteIndex = lChangesStr.find(lCbFuncName) lChanges = lChangesStr[:lQuoteIndex-1] + \ lCbFuncName + \ lChangesStr[lQuoteIndex+len(lCbFuncName)+1:] else: lChanges = str(changes) txt = \ "apply(%s.inputPortByName['%s'].widget.configure, (), %s)\n"%( nodeName, self.inputPortsDescr[i]['name'], lChanges) #txt = \ #"apply(%s.inputPorts[%d].widget.configure, (), %s)\n"%( # nodeName, i, str(changes)) lines.append(indent+txt) else: if nodeName != 'self': lines = self.checkIfNodeForSavingIsDefined( lines, networkName, indent) txt1 = "%s.inputPortByName['%s'].deleteWidget()\n"%( nodeName, self.inputPortsDescr[i]['name']) #txt1 = "%s.inputPorts[%d].deleteWidget()\n"%( # nodeName,i) txt2 = \ "apply(%s.inputPortByName['%s'].createWidget, (), {'descr':%s})\n"%( nodeName, self.inputPortsDescr[i]['name'], str(ownDescr) ) #txt2 = \ #"apply(%s.inputPorts[%d].createWidget, (), {'descr':%s})\n"%( # nodeName, i, str(ownDescr) ) lines.append(indent+txt1) lines.append(indent+txt2) # and set widget value txt = self.getNodeSourceCodeForWidgetValue( networkName, i, indent, ignoreOriginal, full, nodeName) lines.extend(txt) return indent, lines def getNodeSourceCodeForWidgetValue(self, networkName, portIndex, indent="", ignoreOriginal=False, full=0, nodeName=None): """Returns code to set the widget value. Note: here we have to take unbound widgets into account.""" ############################################################# # Setting widget value sets widget _modified=True ############################################################# lines = [] returnPattern = re.compile('\n') # used when data is type(string) p = self.inputPorts[portIndex] # we need the base class node if issubclass(self.__class__, FunctionNode): lKw = {'masternet':self.network} lKw.update(self.constrkw) dummyNode = apply(self.__class__,(), lKw) else: dummyNode = self.__class__() if nodeName is None: nodeName = self.getUniqueNodeName() ############################################################# # Get data and original widget description to check if value # changed ############################################################# ## do we have a widget ? if p.widget: ## is it an original widget? try: origDescr = dummyNode.widgetDescr[p.name] except: ## or a new widget origDescr = {} val = p.widget.getDataForSaving() ## do we have an unbound widget ? elif p.widget is None and p._previousWidgetDescr is not None: origDescr = p._previousWidgetDescr val = p._previousWidgetDescr['initialValue'] ## no widget ? else: return lines ############################################################# # Compare data to default value, return if values are the same ############################################################# ## ## CASE 1: BOUND WIDGET: ## if p.widget: ## # MS WHY ignor original when cut and copy??? ## # ignoreOriginal is set True when cut|copy ## #if not p.widget._modified and not ignoreOriginal: ## # return lines ## # 1) compare value to initial value of widget descr ## wdescr = p.widget.getDescr() ## if wdescr.has_key('initialValue'): ## if val==wdescr['initialValue']: # value is initial value ## return lines ## # 2) else: compare to initialValue in node base class definition ## else: ## # 3) if the widget's original description has an initialValue ## if origDescr.has_key('initialValue'): ## if val == origDescr['initialValue']: ## return lines ## # 4) else, compare to widget base class defined initialValue ## else: ## origWidgetDescr = p.widget.__class__.configOpts ## if val == origWidgetDescr['initialValue']['defaultValue']: ## return lines ## ## CASE 2: UNBOUND WIDGET: ## else: ## descr = dummyNode.widgetDescr[p.name] ## #if descr.has_key('initialValue') and val == descr['initialValue']: ## # return lines ############################################################# # Create text to save widget value ############################################################# if nodeName != 'self': lines = self.checkIfNodeForSavingIsDefined( lines, networkName, indent) if p.widget is None: #widget has been unbinded in the before or after adding to network #as it will be unbinded later we can safely rebind it to set the widget datatxt = '%s.inputPortByName[\'%s\'].rebindWidget()\n'%( nodeName, self.inputPortsDescr[portIndex]['name']) lines.append(indent+datatxt) if type(val)==types.StringType: if returnPattern.search(val): #multi - line data datatxt = \ '%s.inputPortByName[\'%s\'].widget.set(r"""%s""", run=False)\n'%( nodeName, self.inputPortsDescr[portIndex]['name'], val) else: datatxt = '%s.inputPortByName[\'%s\'].widget.set(r"%s", run=False)\n'%( nodeName, self.inputPortsDescr[portIndex]['name'], val) else: if hasattr(val, 'getDescr'): datatxt = '%s.inputPortByName[\'%s\'].widget.set(%s, run=False)\n'%( nodeName, self.inputPortsDescr[portIndex]['name'], val.getDescr() ) else: datatxt = '%s.inputPortByName[\'%s\'].widget.set(%s, run=False)\n'%( nodeName, self.inputPortsDescr[portIndex]['name'], val) lines.append(indent+datatxt) return lines def getNodeSourceCodeForNode(self, networkName, indent="", ignoreOriginal=False, full=0, nodeName=None): """return code to configure a node with modifications compared to the node definition in a node library. Note: """ lines = [] if (self._modified is False) and (ignoreOriginal is False): return indent, lines if full: changes = self.getDescr().copy() else: changes = self.compareToOrigNodeDescr() if changes.has_key('name'): changes.pop('name') # name is passed to constructor if changes.has_key('position'): changes.pop('position') # position is set in addNode if nodeName is None: nodeName = self.getUniqueNodeName() if changes.has_key('function'): changes.pop('function') # function has to be set separately: code, i = self.getNodeSourceCodeForDoit( networkName=networkName, nodeName=nodeName, indent=indent, ignoreOriginal=ignoreOriginal) if code: # Note: the line to add the code to the node is returned # within 'code' lines.extend(code) if len(changes): txt = "apply(%s.configure, (), %s)\n"%( nodeName, str(changes)) lines.append(indent+txt) return indent, lines def getNodeSourceCodeForDoit(self, networkName, nodeName,indent="", ignoreOriginal=False, full=0): lines = [] ed = self.getEditor() if (self._modified is True) or (ignoreOriginal is True): if nodeName != 'self': lines = self.checkIfNodeForSavingIsDefined( lines, networkName, indent) lines.append(indent+"code = \"\"\"%s\"\"\"\n"%self.sourceCode) lines.append(indent+"%s.configure(function=code)\n"% nodeName) return lines, indent def getAfterConnectionsSourceCode(self, networkName, indent="", ignoreOriginal=False): """Here, we provide a hook for users to generate source code which might be needed to adress certain events after connections were formed: for example, connections might generate new ports.""" # The MacroOutputNode subclasses this method and returns real data lines = [] return lines def compareToOrigNodeDescr(self): """compare this node to the original node as defined in a given node library, such as StandardNodes. Return a dictionary containing the differences.""" ownDescr = self.getDescr().copy() dummy = self.__class__() # we need to create a base class node # we dont need to add the self generated port # as we only look here for the node modifications for k,v in ownDescr.items(): if k == 'name': if v == dummy.name: ownDescr.pop(k) elif k == 'position': # this is a bit tricky: the dummy node # has not been added to a net yet, thus we assume a new position continue elif k == 'function': #we don't compare the prototype as it is automatically generated #the code itself is what may have be changed if v[v.find(':'):] == dummy.sourceCode[dummy.sourceCode.find(':'):]: ownDescr.pop(k) elif k == 'expanded': if v == dummy.inNodeWidgetsVisibleByDefault: ownDescr.pop(k) elif k == 'specialPortsVisible': if v == dummy.specialPortsVisible: ownDescr.pop(k) elif k == 'paramPanelImmediate': # default value is 0 if v == 0 or v is False: ownDescr.pop(k) elif k == 'frozen': # default is False if v == dummy.frozen: ownDescr.pop(k) return ownDescr def checkIfNodeForSavingIsDefined(self, lines, networkName, indent): """This method fixes a problem with saving macros that come from a node library. If only a widget value has changed, we do not have a handle to the node. Thus, we need to create this additional line to get a handle """ ed = self.getEditor() nodeName = self.getUniqueNodeName() if ed._tmpListOfSavedNodes.has_key(nodeName) is False: # This part is a bit complicated: we need to define the various # macro nodes if we have nested macros and they are not explicitly # created (e.g. a macro from a node library) from macros import MacroNetwork if isinstance(self.network, MacroNetwork): roots = self.network.macroNode.getRootMacro() for macro in roots[1:]: # skip root, because this is always defined!? nn = macro.getUniqueNodeName() # was nn = 'node%d'%macro._id if ed._tmpListOfSavedNodes.has_key(nn) is False: txt = "%s = %s.macroNetwork.nodes[%d]\n"%( nn, macro.network.macroNode.getUniqueNodeName(), macro.network.nodeIdToNumber(macro._id)) lines.append(indent+txt) ed._tmpListOfSavedNodes[nn] = macro # now process the 'regular' nodes #import pdb;pdb.set_trace() txt = "%s = %s.nodes[%d]\n"%(nodeName, networkName, self.network.nodeIdToNumber(self._id)) lines.append(indent+txt) ed._tmpListOfSavedNodes[nodeName] = self return lines ############################################################################# #### The following methods are needed to generate source code (not for saving #### networks) ############################################################################# def saveSource_cb(self, dependencies=False): """ the classname is extracted from the given filename """ lPossibleFileName = "New" + self.name + ".py" lPossibleFileNameSplit = lPossibleFileName.split(' ') initialfile = '' for lSmallString in lPossibleFileNameSplit: initialfile += lSmallString userResourceFolder = self.getEditor().resourceFolderWithVersion if userResourceFolder is None: return userVisionDir = userResourceFolder + os.sep + 'Vision' + os.sep userLibsDir = userVisionDir + 'UserLibs' + os.sep defaultLibDir = userLibsDir + 'MyDefaultLib' file = tkFileDialog.asksaveasfilename( initialdir = defaultLibDir , filetypes=[('python source', '*.py'), ('all', '*')], title='Save source code in a category folder', initialfile=initialfile ) if file: # get rid of the extension and of the path lFileSplit = file.split('/') name = lFileSplit[-1].split('.')[0] self.saveSource(file, name, dependencies) # reload the modified library self.getEditor().loadLibModule(str(lFileSplit[-3])) def saveSource(self, filename, classname, dependencies=False): f = open(filename, "w") map( lambda x, f=f: f.write(x), self.getNodeSourceCode(classname, networkName='self.masterNetwork', dependencies=dependencies) ) f.close() def getNodeSourceCode(self, className, networkName='self.network', indent="", dependencies=False): """This method is called through the 'save source code' mechanism. Generate source code describing a node. This code can be put into a node library. This is not for saving networks. dependencies: True/False False: the node is fully independent from his original node. True : the node is saved as a subclass of the original node, and only modifications from the original are saved. """ lines = [] kw = {} # keywords dict kw['dependencies'] = dependencies indent0 = indent txt, indent = apply(self.getHeaderBlock, (className, indent), kw) lines.extend(txt) # this make sure the port types will be avalaible when saved code will run lTypes = {} lSynonyms = {} lPorts = self.inputPorts + self.outputPorts for p in lPorts: lName = p.datatypeObject.__class__.__name__ if (lTypes.has_key(lName) is False) and \ (p.datatypeObject.__module__ != 'NetworkEditor.datatypes'): lTypes[lName] = p.datatypeObject.__module__ lName = p.datatypeObject['name'] if lSynonyms.has_key(lName) is False: lSplitName = lName.split('(') lBaseName = lSplitName[0] if (len(lSplitName) == 2) and (lSynonyms.has_key(lBaseName) is False): lDict = self.network.getTypeManager().getSynonymDict(lBaseName) if lDict is not None: lSynonyms[lBaseName] = lDict lDict = self.network.getTypeManager().getSynonymDict(lName) if lDict is not None: lSynonyms[lName] = lDict kw['types'] = lTypes kw['synonyms'] = lSynonyms txt, indent = apply(self.getInitBlock, (className, indent), kw) kw.pop('types') kw.pop('synonyms') lines.extend(txt) if dependencies is True: nodeName = 'self' indent, txt = self.getNodeSourceCodeForNode(self.network, indent=indent, full=0, nodeName=nodeName) lines.extend(txt) lines.extend("\n\n" + indent0 + " " + \ "def afterAddingToNetwork(self):\n" + \ indent + "pass\n") constrkw = {} constrkw.update( self.constrkw ) constrkw['name'] = className dummyNode = apply( self.originalClass,(),constrkw) indent, txt = self.getNodeSourceCodeForPorts( self.network, indent=indent, ignoreOriginal=False, full=0, dummyNode=dummyNode, nodeName=nodeName) lines.extend(txt) indent, txt = self.getNodeSourceCodeForWidgets( self.network, indent=indent, ignoreOriginal=False, full=0, dummyNode=dummyNode, nodeName=nodeName) lines.extend(txt) elif dependencies is False: txt = self.getComputeFunctionSourceCode(indent=indent) lines.extend(txt) txt, indent = apply(self.getPortsCreationSourceCode, (self.inputPorts, 'input', indent), kw) lines.extend(txt) txt, indent = apply(self.getPortsCreationSourceCode, (self.outputPorts, 'output', indent), kw) lines.extend(txt) txt, indent = self.getWidgetsCreationSourceCode(indent) lines.extend(txt) else: assert(False) indent1 = indent + ' '*4 lines.extend("\n\n" + indent0 + " " + \ "def beforeAddingToNetwork(self, net):\n") # this make sure the host web service is loaded if self.constrkw.has_key('host'): lines.extend( indent + "try:\n" ) ## get library import cache ## then write libray import code cache = self.network.buildLibraryImportCache( {'files':[]}, self.network, selectedOnly=False) li = self.network.getLibraryImportCode( cache, indent1, editor="self.editor", networkName="net", importOnly=True, loadHost=True) lines.extend(li) lines.extend( indent + "except:\n" + \ indent1 + "print 'Warning! Could not load web services'\n\n") # this make sure the port widgets will be avalaible when saved code will run lines.extend(indent + "try:\n" ) lWidgetsClass = [] for p in self.inputPorts: lClass = p.widget.__class__ lModule = lClass.__module__ if ( lModule != 'NetworkEditor.widgets') \ and (lModule != '__builtin__') \ and (lModule not in lWidgetsClass): lWidgetsClass.append(lClass) lines.append(indent1 + "ed = net.getEditor()\n") for w in lWidgetsClass: lWidgetsClassName = w.__name__ lines.append(indent1 + "from %s import %s\n" % (w.__module__, lWidgetsClassName) ) lines.extend(indent1 + "if %s not in ed.widgetsTable.keys():\n" % lWidgetsClassName ) lines.extend(indent1 + 4*' ' + \ "ed.widgetsTable['%s'] = %s\n" % (lWidgetsClassName, lWidgetsClassName) ) lines.extend(indent + "except:\n" + \ indent1 + "import traceback; traceback.print_exc()\n" + \ indent1 + "print 'Warning! Could not import widgets'\n") lines.extend("\n") return lines #################################################### #### Helper Methods follow to generate save file ### #################################################### def getHeaderBlock(self, className, indent="", **kw): """Generate source code to import a node from a library or file.""" lines = [] dependencies = kw['dependencies'] import datetime lNow = datetime.datetime.now().strftime("%A %d %B %Y %H:%M:%S") lCopyright = \ """######################################################################## # # Vision Node - Python source code - file generated by vision # %s # # The Scripps Research Institute (TSRI) # Molecular Graphics Lab # La Jolla, CA 92037, USA # # Copyright: Daniel Stoffler, Michel Sanner and TSRI # # revision: Guillaume Vareille # ######################################################################### # # $%s$ # # $%s$ # """%(lNow, "Header:", "Id:") # if directly in the txt, CVS fills these fields lines.append(lCopyright) return lines, indent def getInitBlock(self, className, indent="", **kw): """Generate source code to define the __init__() method of the node, building the correct constrkw dict, etc.""" lines = [] dependencies = kw['dependencies'] lines.append(indent+"# import node's base class node\n") # if dependencies is True: # mod = self.originalClass.__module__ # klass = self.originalClass.__name__ # txt1 = "from %s import %s\n"%(mod,klass) # lines.append(indent+txt1) # txt2 = "class %s(%s):\n"%(className,klass) # lines.append(indent+txt2) # else: # txt1 = "from NetworkEditor.items import NetworkNode\n" # lines.append(indent+txt1) # txt2 = "class %s(NetworkNode):\n"%className # lines.append(indent+txt2) txt1 = "from NetworkEditor.items import NetworkNode\n" lines.append(indent+txt1) mod = self.originalClass.__module__ klass = self.originalClass.__name__ txt1 = "from %s import %s\n"%(mod,klass) lines.append(indent+txt1) txt2 = "class %s(%s):\n"%(className,klass) lines.append(indent+txt2) if self.originalClass.__doc__ is not None: lines.append(indent+' \"\"\"'+self.originalClass.__doc__) lines.append('\"\"\"\n') indent1 = indent + 4*" " indent2 = indent1 + 4*" " if kw.has_key('types'): lines.append(indent1 + "mRequiredTypes = " + kw['types'].__str__() + '\n') if kw.has_key('synonyms'): lines.append(indent1 + "mRequiredSynonyms = [\n") for lkey, lSynonym in kw['synonyms'].items(): lines.extend(indent2 + lSynonym.__str__() + ',\n') lines.append(indent1 + ']\n') # build constructor keyword from original class # constrkw is not used by the original class but only by NetworkNode constrkw = '' for name, value in self.constrkw.items(): constrkw = constrkw + name+'='+str(value)+', ' constrkw = constrkw + "constrkw = " + str(self.constrkw)+', ' indent += 4*" " lines.append(indent+\ "def __init__(self, %s name='%s', **kw):\n" % ( constrkw, className)) indent += 4*" " lines.append(indent+"kw['constrkw'] = constrkw\n") lines.append(indent+"kw['name'] = name\n") if dependencies is True: klass = self.originalClass.__name__ lines.append(indent+"apply(%s.__init__, (self,), kw)\n"%klass) # we just fully blank everything an recreate them # we will need to save only the differences and not everything #lines.append(indent+"self.inputPortsDescr = []\n") #lines.append(indent+"self.outputPortsDescr = []\n") #lines.append(indent+"self.widgetDescr = {}\n") if self._modified is True: lines.append(indent+"self.inNodeWidgetsVisibleByDefault = %s\n"%self.inNodeWidgetsVisibleByDefault) else: lines.append(indent+"apply( NetworkNode.__init__, (self,), kw)\n") if self.inNodeWidgetsVisibleByDefault: lines.append(indent+"self.inNodeWidgetsVisibleByDefault = True\n") return lines, indent def getPortsCreationSourceCode(self, ports, ptype='input', indent="",**kw): """generates code to create ports using the inputportsDescr and outputPortsDescr""" lines = [] dependencies = kw['dependencies'] assert ptype in ['input', 'output'] for p in ports: d = p.getDescr() if d is None: d = {} lines.append(indent+"self.%sPortsDescr.append(\n"%ptype) lines.append(indent+ 4*" " + "%s)\n"%str(d) ) return lines, indent def getWidgetsCreationSourceCode(self, indent="",**kw): """generating code to create widgets using the widgetDescr""" lines = [] for p in self.inputPorts: if p.widget is None: continue d = p.widget.getDescr() # save current widget value d['initialValue'] = p.widget.getDataForSaving() if d is None: d = {} lines.append(indent+"self.widgetDescr['%s'] = {\n"%p.name) lines.append(indent+ 4*" " + "%s\n"%str(d)[1:] ) #ommit first { return lines, indent def getComputeFunctionSourceCode(self, indent="", **kw): lines = [] nodeName = 'self' lines.append(indent+"code = \"\"\"%s\"\"\"\n"%self.sourceCode) lines.append(indent+"%s.configure(function=code)\n"% nodeName) return lines ###################### END of methods generating source code ################ ############################################################################# def outputData(self, **kw): for p in self.outputPorts: if kw.has_key(p.name): data = kw[p.name] kw.pop(p.name) p.outputData(data) else: ed = self.getEditor() if ed.hasGUI: ed.balloons.tagbind( self.network.canvas, p.id, p.balloonBase) if len(kw): for k in kw.keys(): warnings.warn( "WARNING: port %s not found in node %s"%(k, self.name) ) def setFunction(self, source, tagModified=True): """Set the node's compute function. If tagModified is True, we set _modified=True""" self.sourceCode = source self.dynamicComputeFunction = self.evalString(source) if tagModified: self._setModified(True) # update the source code editor if available if self.objEditor is not None: if self.objEditor.funcEditorDialog is not None: self.objEditor.funcEditorDialog.settext(source) def scheduleChildren(self, portList=None): """run the children of this node in the same thread as the parent if portList is None all children are scheduled, else only children of the specified ports are scheduled """ #print "NetworkNodeBase.scheduleChildren" net = self.network # get the list of nodes to run if portList is None: allNodes = net.getAllNodes(self.children) for n in self.children: n.forceExecution = 1 else: children = [] for p in portList: children.extend(map (lambda x: x.node, p.children) ) for n in children: n.forceExecution = 1 # since a node can be a child through multiple ports we have to # make the list of children unique allNodes = net.getAllNodes(uniq(children)) if len(allNodes): #self.forceExecution = 1 #print "SCHEDULE CHILDREN", allNodes net.runNodes(allNodes) def schedule_cb(self, event=None): self.forceExecution = 1 self.schedule() def schedule(self): """start an execution thread for the subtree under that node """ #print "NetworkNodeBase.schedule", self.network.runOnNewData net = self.network ed = net.getEditor() if ed.hasGUI: if hasattr(ed, 'buttonBar'): bl = ed.buttonBar.toolbarButtonDict if bl.has_key('softrun'): bl['softrun'].disable() bl['run'].disable() #bl['runWithoutGui'].disable() #if ed.withThreads is True: bl['pause'].enable() bl['stop'].enable() net.run([self]) def computeFunction(self): # make sure all required input ports present data # make sure data is valid and available # call self.dynamicComputeFunction # Return 'Go' after successful execution or 'Stop' otherwise for p in self.outputPorts: if p.dataView: p.clearDataView() if not self.dynamicComputeFunction: return 'Stop' lArgs = [self,] ed = self.getEditor() # for each input port of this node newData = 0 for port in self.inputPorts: # this make sure the text entries are used even if the user hasn't pressed return if ed.hasGUI and port.widget is not None: w = port.widget.widget if isinstance(w, Tkinter.Entry) \ or isinstance(w, Pmw.ComboBox): before = port.widget.lastUsedValue after = port.widget.widget.get() if before != after: port.widget._newdata = True if port.hasNewData(): newData = 1 data = port.getData() # returns 'Stop' if bad or missing data if type(data) is types.StringType: if data.lower()=='stop': # turn node outline to missing data color if ed.hasGUI and ed.flashNodesWhenRun: c = self.iconMaster c.tk.call((c._w, 'itemconfigure', self.innerBox, '-outline', '#ff6b00', '-width', 4)) return 'Stop' if port.dataView: port.updateDataView() # update Data Browser GUI (only if window is not deiconified) if port.objectBrowser and \ port.objectBrowser.root.state()=='normal': port.objectBrowser.root.after( 100, port.objectBrowser.refresh_cb ) lArgs.append(data) stat = 'Stop' if newData \ or self.forceExecution \ or (self.network and self.network.forceExecution): #print "running %s with:"%self.name, args lCurrentDir = os.getcwd() if self.network: if self.network.filename is not None: lNetworkDir = os.path.dirname(self.network.filename) elif hasattr(self.network, 'macroNode') \ and self.network.macroNode.network.filename is not None: lNetworkDir = os.path.dirname(self.network.macroNode.network.filename) else: import Vision if hasattr(Vision, 'networkDefaultDirectory'): lNetworkDir = Vision.networkDefaultDirectory else: lNetworkDir = '.' # MS WHY do we have to go there ? Oct 2010 # removed it because this prevented networks from .psf file # wfrom working as the tmp dir was deleted #if os.path.exists(lNetworkDir): os.chdir(lNetworkDir) try: stat = apply( self.dynamicComputeFunction, tuple(lArgs) ) finally: os.chdir(lCurrentDir) if stat is None: stat = 'Go' for p in self.outputPorts: # update Data Viewer GUI if p.dataView: p.updateDataView() # update Data Browser GUI (only if window is not deiconified) if p.objectBrowser and p.objectBrowser.root.state() =='normal': p.objectBrowser.root.after( 100, p.objectBrowser.refresh_cb ) for p in self.inputPorts: p.releaseData() return stat def growRight(self, id, dx): """Expand (and shrink) the x-dimension of the node icon to (and from) the right.""" # we get the coords coords = self.iconMaster.coords(id) # compute the middle point using the bounding box of this object bbox = self.iconMaster.bbox(id) xmid = (bbox[0] + bbox[2]) * 0.5 # add dx for every x coord right of the middle point for i in range(0,len(coords),2): if coords[i]>xmid: coords[i]=coords[i]+dx apply( self.iconMaster.coords, (id,)+tuple(coords) ) def growDown(self, id, dy): """Expand (and shrink) the y-dimension of the node icon to (and from) the top.""" # we get the coords coords = self.iconMaster.coords(id) # compute the middle point using the bounding box of this object bbox = self.iconMaster.bbox(id) ymid = (bbox[1] + bbox[3]) * 0.5 # add dy for every y coord below of the middle point for i in range(1,len(coords),2): if coords[i]>ymid: coords[i]=coords[i]+dy apply( self.iconMaster.coords, (id,)+tuple(coords) ) def updateCode(self, port='ip', action=None, tagModified=True, **kw): """update signature of compute function in source code. We re-write the first line with all port names as arguments. **kw are not used but allow to match updateCode signature of output ports """ code = self.sourceCode # handle input port if port == 'ip': if action=='add' or action=='remove' or action=='create': ## This was bas: 13 assumed that was no space between doit( and ## self. If there is a space we lost the f at the end of self #signatureBegin = code.index('def doit(')+13 signatureBegin = code.index('self')+4 signatureEnd = code[signatureBegin:].index('):') signatureEnd = signatureBegin+signatureEnd newCode = code[:signatureBegin] if action=='create': for p in self.inputPortsDescr: newCode += ', ' + p['name'] #if p['required'] is True: # newCode += "='NA' " #else: # newCode += '=None ' else: for p in self.inputPorts: newCode += ', ' + p.name #if p.required is True: # newCode += "='NA' " #else: # newCode += '=None ' newCode = newCode + code[signatureEnd:] elif action=='rename': newname = kw['newname'] oldname = kw['oldname'] newCode = code.replace(oldname, newname) # handle output port elif port == 'op': newname = kw['newname'] if action==None: return if action=='add': # add comment on how to output data olds = "## to ouput data on port %s use\n"%newname olds += "## self.outputData(%s=data)\n"%newname code += olds elif action=='remove': oldname = kw['oldname'] # remove comment on how to output data olds = "## to ouput data on port %s use\n"%oldname olds += "## self.outputData(%s=data)\n"%oldname code = code.replace(olds, '') elif action=='rename': oldname = kw['oldname'] olds = "## to ouput data on port %s use\n"%oldname olds += "## self.outputData(%s=data)\n"%oldname news = "## to ouput data on port %s use\n"%newname news += "## self.outputData(%s=data)\n"%newname code = code.replace(olds, news) else: raise ValueError ( "action should be either 'add', 'remove', 'rename', got ", action) newCode = code else: warnings.warn("Wrong port type specified!", stacklevel=2) return # finally, set the new code self.setFunction(newCode, tagModified=tagModified) def toggleNodeExpand_cb(self, event=None): widgetsInNode = self.getWidgetsForMaster('Node') if len(widgetsInNode)==0: widgetsInParamPanel = self.getWidgetsForMaster('ParamPanel') if len(widgetsInParamPanel): if self.paramPanel.master.winfo_ismapped() == 1: self.paramPanel.hide() self.paramPanelTk.set(0) else: self.paramPanel.show() self.paramPanelTk.set(1) else: if self.isExpanded(): self.expandedIcon = False self.hideInNodeWidgets() else: self.expandedIcon = True self.showInNodeWidgets() self._setModified(True) def getWidthForPorts(self, maxi=None): # compute the width in the icon required for input and output ports # if maxw is not none, the maximum is return if maxi is None: maxi = maxwidth = 0 # find last visible inputport if len(self.inputPorts): for p in self.inputPorts[::-1]: # going backwards if p.visible: break maxwidth = p.relposx+2*p.halfPortWidth if len(self.outputPorts): for p in self.outputPorts[::-1]: # going backwards if p.visible: break if p.relposx+2*p.halfPortWidth > maxwidth: maxwidth = p.relposx+2*p.halfPortWidth return max(maxi, int(round(maxwidth*self.scaleSum))) def getHeightForPorts(self, maxi=None): # compute the height in the icon required for input and output ports # if maxw is not none, the maximum is return maxheight = 0 if maxi is None: maxi = 0 # find last visible inputport if len(self.inputPorts): for p in self.inputPorts[::-1]: # going backwards if p.visible: break maxheight = p.relposy+2*p.halfPortHeight if len(self.outputPorts): for p in self.outputPorts[::-1]: # going backwards if p.visible: break if p.relposy+2*p.halfPortHeight > maxheight: maxheight = p.relposy+2*p.halfPortHeight return max(maxi, int(round(maxheight*self.scaleSum))) def getWidthForLabel(self, maxi=None): # compute the width in the icon required for the label # if maxis is not not, the maximum is return if maxi is None: maxi = 0 bb = self.iconMaster.bbox(self.textId) return max(maxi, 10+(bb[2]-bb[0]) ) # label has 2*5 padding def getWidthForNodeWidgets(self, maxi=None): # compute the width in the icon required for node widgets # if maxis is not not, the maximum is return if maxi is None: maxi = 0 if self.isExpanded(): return max(maxi, self.nodeWidgetMaster.winfo_reqwidth()+10) else: return maxi def autoResizeX(self): # we find how wide the innerBox has to be canvas = self.iconMaster neededWidth = self.getWidthForPorts() neededWidth = self.getWidthForLabel(neededWidth) neededWidth = self.getWidthForNodeWidgets(neededWidth) # get width of current innerbox bb = canvas.bbox(self.innerBox) w = bb[2]-bb[0] self.resizeIcon(dx=neededWidth-w) def autoResizeY(self): canvas = self.iconMaster bb = canvas.bbox(self.textId) labelH = 12+self.progBarH+(bb[3]-bb[1]) # label has 2*5 padding if self.isExpanded(): widgetH = self.nodeWidgetMaster.winfo_reqheight() if len(self.getWidgetsForMaster('Node')): labelH += 6 else: widgetH = 0 bb = canvas.bbox(self.innerBox) curh = bb[3]-bb[1] self.resizeIcon(dy=labelH+widgetH-curh) def autoResize(self): self.autoResizeX() self.autoResizeY() if len(self.getWidgetsForMaster('node')): # resize gets the right size but always grows to the right # by hiding and showing the widgets in node we fix this self.toggleNodeExpand_cb() self.toggleNodeExpand_cb() def getSize(self): """returns size of this node as a tuple of (width, height) in pixels""" bbox = self.iconMaster.bbox(self.outerBox) w = bbox[2] - bbox[0] h = bbox[3] - bbox[1] return (w, h) def hideInNodeWidgets(self, rescale=1): # hide widgets in node by destroying canvas object holding them # the NE widget is not destroyed canvas = self.iconMaster if rescale: self.autoResizeX() h = self.nodeWidgetMaster.winfo_reqheight() self.resizeIcon(dy=-h-6) #bb = canvas.bbox(self.nodeWidgetTkId) #self.resizeIcon(dy=bb[1]-bb[3]) canvas.delete(self.nodeWidgetTkId) def showInNodeWidgets(self, rescale=1): canvas = self.iconMaster widgetFrame = self.nodeWidgetMaster oldbb = canvas.bbox(self.innerBox)# find current bbox #if len(self.nodeWidgetsID): # bb = canvas.bbox(self.nodeWidgetsID[-1]) # find bbox of last widget #else: # bb = canvas.bbox(self.textId) # find bbox of text bb = canvas.bbox(self.textId) # find bbox of text # pack the frame containg the widgets so we can measure it's size widgetFrame.pack() canvas.update_idletasks() h = widgetFrame.winfo_reqheight() # before asking for its size w = widgetFrame.winfo_reqwidth() ## FIXME the frame is created with a given size. Since it is on a canvas ## it does not resize when widgets are added or removed ## newh =0 ## for p in self.inputPorts: ## if p.widget and p.widget.inNode: ## newh += p.widget.widgetFrame.winfo_reqheight() ## h = newh-h tags = (self.iconTag, 'node') # compute center (x,y) of canvas window # add a window below text for widgets self.nodeWidgetTkId = widgetWin = canvas.create_window( bb[0]+(w/2), bb[3]+ self.progBarH +(h/2), tags=tags, window=widgetFrame ) if self.selected: canvas.addtag_withtag('selected', widgetWin) if rescale: self.autoResizeX() self.resizeIcon(dy=h+6) def getWidgetsForMaster(self, masterName): """Return a dict of all widgets bound for a given master in a given node (self). Masters can be 'Node' or 'ParamPanel'. key is an instance of the port, value is an instance of the widget""" widgets = {} for k, v in self.widgetDescr.items(): master = v.get('master', 'ParamPanel') if master.lower()==masterName.lower(): # find corresponding widget to this port for port in self.inputPorts: if port.name == k: widget = port.widget break widgets[port] = widget return widgets def drawMapIcon(self, naviMap): canvas = naviMap.mapCanvas x0, y0 = naviMap.upperLeft scaleFactor = naviMap.scaleFactor c = self.network.canvas.bbox(self.iconTag) cid = canvas.create_rectangle( [x0+c[0]*scaleFactor, y0+c[1]*scaleFactor, x0+c[2]*scaleFactor, y0+c[3]*scaleFactor], fill='grey50', outline='black', tag=('navimap',)) self.naviMapID = cid return cid def buildIcons(self, canvas, posx, posy, small=False): """Build NODE icon with ports etc """ NetworkItems.buildIcons(self, canvas) network = self.network self.paramPanelTk = Tkinter.IntVar() # to toggle Param. Panel self.paramPanelTk.set(0) # build node's Icon ed = self.getEditor() if ed.hasGUI: self.buildNodeIcon(canvas, posx, posy, small=small) # instanciate output ports for p in self.outputPorts: p.buildIcons(resize=False) # instanciate input ports inNode = 0 for p in self.inputPorts: # this loop first so all port have halfPortWidth p.buildIcons( resize=False ) for p in self.inputPorts: p.createWidget() if p.widget is not None: inNode = max(inNode, p.widget.inNode) if ed.hasGUI: self.autoResizeX() # in case we added too many ports # at least one widget is in the node. We show it if visible by default if inNode: if self.inNodeWidgetsVisibleByDefault: self.expandedIcon = True self.showInNodeWidgets( rescale=1 ) # instanciate special input ports for ip in self.specialInputPorts: ip.buildIcons(resize=False) if not self.specialPortsVisible: ip.deleteIcon() # instanciate special output ports for op in self.specialOutputPorts: op.buildIcons(resize=False) if not self.specialPortsVisible: op.deleteIcon() # this is needed because only now do we know the true relposx of ports # if we do not do this here, some port icons might be outside the node # but we do not want to autoResize() because that would rebuild widgets if ed.hasGUI: self.autoResizeX() # add command entries to node's pull down self.menu.add_command(label='Run', command=self.schedule_cb, underline=0) self.menu.add_checkbutton(label="Frozen", variable = self.frozenTk, command=self.toggleFrozen_cb, underline=0) # self.menu.add_command(label='Freeze', command=self.toggleFreeze) self.menu.add_separator() self.menu.add_command(label='Edit', command=self.edit, underline=0) self.menu.add_command(label='Edit compute function', command=self.editComputeFunction_cb, underline=14) self.menu.add_command(label='Introspect', command=self.introspect, underline=0) self.menu.add_checkbutton(label="Parameter Panel", variable = self.paramPanelTk, command=self.toggleParamPanel_cb, underline=0) self.menu.add_separator() self.menu.add_command(label='Copy', command=self.copy_cb, underline=0) self.menu.add_command(label='Cut', command=self.cut_cb, underline=0) self.menu.add_command(label='Delete', command=self.delete_cb, underline=0) self.menu.add_command(label='Reset', command=self.replaceWith, underline=0) if self.__class__ is FunctionNode and hasattr(self.function, 'serviceName'): def buildhostCascadeMenu(): self.menu.cascadeMenu.delete(0, 'end') for lKey in self.library.libraryDescr.keys(): if lKey.startswith('http://') and lKey != suppressMultipleQuotes(self.constrkw['host']): cb = CallBackFunction( self.replaceWithHost, host=lKey) self.menu.cascadeMenu.add_command(label=lKey, command=cb) self.menu.cascadeMenu = Tkinter.Menu(self.menu, tearoff=0, postcommand=buildhostCascadeMenu) self.menu.add_cascade(label='Replace with node from', menu=self.menu.cascadeMenu) if self.specialPortsVisible: self.menu.add_command(label='Hide special ports', command=self.hideSpecialPorts, underline=5) else: self.menu.add_command(label='Show special ports', command=self.showSpecialPorts, underline=5) def delete(self): # remove all connections to this node inConnections = self.getInConnections() self.network.deleteConnections(inConnections, 0, schedule=False) outConnections = self.getOutConnections() self.network.deleteConnections(outConnections, 0) self.beforeRemovingFromNetwork() # delete this node's ports inNode = 0 for p in self.inputPorts[:]: # IMPORTANT NOTE: since we will delete # the port from self.inputPorts while we are looping over this # list, we need to loop over a copy to avoid unpredictable # results! if p.dataView is not None: # kill data viewer window p.dataView.destroy() if p.widget: # close widget editor if p.widget.objEditor: p.widget.objEditor.Cancel_cb() inNode = max(0, p.widget.inNode) # close port editor if p.objEditor: p.objEditor.Cancel() self.deletePort(p, resize=False, updateSignature=False) for p in self.outputPorts[:]: if p.dataView is not None: # kill data viewer window p.dataView.destroy() if p.objEditor: p.objEditor.Cancel() self.deletePort(p, resize=False, updateSignature=False) for p in self.specialInputPorts[:]: self.deletePort(p, resize=False, updateSignature=False) for p in self.specialOutputPorts[:]: self.deletePort(p, resize=False, updateSignature=False) # delete the node's param. panel self.paramPanel.destroy() if self.objEditor: self.objEditor.Dismiss() if self.isExpanded() and inNode: self.hideInNodeWidgets( ) self.deleteIcon() self.afterRemovingFromNetwork() def addSaveNodeMenuEntries(self): """add 'save source code' and 'add to library' entries to node menu'""" if self.readOnly: return try: self.menu.index('Save as customized node') except: self.menu.add_separator() funcDependent = CallBackFunction(self.saveSource_cb, True) funcIndependent = CallBackFunction(self.saveSource_cb, False) if hasattr(self, 'geoms') is False: if issubclass(self.__class__, FunctionNode): pass # still in devellopment: #self.menu.add_command( # label='Save as customized node inheriting', # command=funcDependent) else: self.menu.add_command( label='Save as customized node', command=funcIndependent) ## PLEASE NOTE: This will be enabled in a future release of Vision ## ed = self.network.getEditor() ## if hasattr(ed, 'addNodeToLibrary'): ## fun = CallBackFunction( ed.addNodeToLibrary, self) ## self.menu.add_command(label='add to library', command=fun) def copy_cb(self, event=None): ed = self.network.getEditor() self.network.selectNodes([self]) ed.copyNetwork_cb(event) def cut_cb(self, event=None): ed = self.network.getEditor() self.network.selectNodes([self]) ed.cutNetwork_cb(event) def delete_cb(self, event=None): self.network.selectNodes([self]) nodeList = self.network.selectedNodes[:] self.network.deleteNodes(nodeList) def edit(self, event=None): if self.objEditor: self.objEditor.top.master.lift() return self.objEditor = NodeEditor(self) def editComputeFunction_cb(self, event=None): if not self.objEditor: self.objEditor = NodeEditor(self) self.objEditor.editButton.invoke() def evalString(self, str): if not str: return try: function = eval("%s"%str) except: #try: obj = compile(str, '', 'exec') if self.__module__ == '__main__': d = globals() else: # import the module from which this node comes mn = self.__module__ m = __import__(mn) # get the global dictionary of this module ind = string.find(mn, '.') if ind==-1: # not '.' was found d = eval('m'+'.__dict__') else: d = eval('m'+mn[ind:]+'.__dict__') # use the module's dictionary as global scope exec(obj, d) # when a function has names arguments it seems that the # co_names is (None, 'functionName') if len(obj.co_names)==0: function = None else: function = eval(obj.co_names[-1], d) #except: # raise ValueError return function def move(self, dx, dy, absolute=True, tagModified=True): """if absolute is set to False, the node moves about the increment dx,dy. If absolute is True, the node moves to the position dx,dy Connections are updated automatically.""" if self.editor.hasGUI: self.network.moveSubGraph([self], dx, dy, absolute=absolute, tagModified=tagModified) def getSourceCode(self): # this method is implemented in subclasses # create the source code to rebuild this object # used for saving or copying pass def toggleParamPanel_cb(self, event=None): if self.paramPanel.master.winfo_ismapped() == 0: self.paramPanel.show() self.showParams_cb() else: self.paramPanel.hide() def ensureRootNode(self): # count parent to decide whether or not second node is a root lInConnections = self.getInConnections() if len(lInConnections) == 0: self.isRootNode = 1 if self not in self.network.rootNodes: self.network.rootNodes.append(self) else: for lConn in lInConnections: if lConn.blocking is True: if self in self.network.rootNodes: self.network.rootNodes.remove(self) break; else: # we didn't break # all the connections are not blocking self.isRootNode = 1 if self not in self.network.rootNodes: self.network.rootNodes.append(self) class NetworkNode(NetworkNodeBase): """This class implements a node that is represented using a Polygon """ def __init__(self, name='NoName', sourceCode=None, originalClass=None, constrkw=None, library=None, progbar=0, **kw): apply( NetworkNodeBase.__init__, (self, name, sourceCode, originalClass, constrkw, library, progbar), kw) self.highlightOptions = {'highlightbackground':'red'} self.unhighlightOptions = {'highlightbackground':'gray50'} self.selectOptions = {'fill':'yellow'} self.deselectOptions = {'fill':'gray85'} self.inNodeWidgetsVisibleByDefault = True self.inputPortByName = {} self.outputPortByName = {} def replaceWithHost(self, klass=None, library=None, host='http://krusty.ucsd.edu:8081/opal2'): """a function to replace a node with another node. the connections are recreated. the connected ports must have the same name in the new node and in the original node. """ #print "replaceWithHost", self, host constrkw = copy.deepcopy(self.constrkw) if library is None: library = self.library if library is not None: constrkw['library'] = library if klass is None: klass = self.__class__ constrkw['klass'] = klass if klass is FunctionNode \ and hasattr(self.function, 'serviceName') \ and host is not None: constrkw['host'] = suppressMultipleQuotes(host) serverName = host.split('http://')[-1] serverName = serverName.split('/')[0] serverName = serverName.split(':')[0] serverName = serverName.replace('.','_') # to replace exactly with the same one #constrkw['functionOrString'] = \ # self.function.serviceOriginalName.lower() + '_' + serverName # to pick any better version if self.library.libraryDescr.has_key(host): lversion = 0 # replace with the highest version available on the host #lversion = self.function.version # replace only if version is at least equal to current # to eval we need to bring the main scope into this local scope from mglutil.util.misc import importMainOrIPythonMain lMainDict = importMainOrIPythonMain() for modItemName in set(lMainDict).difference(dir()): locals()[modItemName] = lMainDict[modItemName] del constrkw['functionOrString'] for node in self.library.libraryDescr[host]['nodes']: try: lFunction = eval(node.kw['functionOrString']) if lFunction.serviceName == self.function.serviceName \ and lFunction.version >= lversion: constrkw['functionOrString'] = lFunction.serviceOriginalName + '_' + serverName except: pass if constrkw.has_key('functionOrString'): return apply(self.replaceWith, (), constrkw) else: return False def replaceWith(self, klass=None, **kw): """a function to replace a node with another node. the connections are recreated. the connected ports must have the same name in the new node and in the original node. """ if len(kw) == 0: kw = copy.deepcopy(self.constrkw) if kw.has_key('library') is False: kw['library'] = self.library if klass is None: klass = self.__class__ try: lNewNode = apply(klass,(),kw) lNewNode.inNodeWidgetsVisibleByDefault = self.expandedIcon #by default we want the new node to be in the same state as the curren one self.network.addNode(lNewNode, posx=self.posx, posy=self.posy) if self.specialPortsVisible is True: self.showSpecialPorts() lFailure = False for port in self.inputPorts: if lFailure is False: for connection in port.connections: if lFailure is False: try: self.network.connectNodes( connection.port1.node, lNewNode, connection.port1.name, port.name, blocking=connection.blocking ) except: lFailure = True for port in self.inputPorts: if port.widget is not None: try: lNewNode.inputPortByName[port.name].widget.set(port.widget.get()) except: pass lDownstreamNodeInputPortSingleConnection = {} if lFailure is False: for port in self.outputPorts: if lFailure is False: # input ports downstream have to accept multiple connections otherwise they can't be connected for connection in port.connections: lDownstreamNodeInputPortSingleConnection[connection.port2.node] = \ (connection.port2.name, connection.port2.singleConnection) connection.port2.singleConnection = 'multiple' try: self.network.connectNodes( lNewNode, connection.port2.node, port.name, connection.port2.name, blocking=connection.blocking ) except: lFailure = True # input ports downstream are set back to what they were for lNode, portNameSingleConnection in lDownstreamNodeInputPortSingleConnection.items(): lNode.inputPortByName[portNameSingleConnection[0]].singleConnection = portNameSingleConnection[1] if lFailure is False: self.network.deleteNodes([self]) #print "replaced" return True else: self.network.deleteNodes([lNewNode]) except Exception, e: print e #warnings.warn( str(e) ) return False def createPorts(self): for kw in self.outputPortsDescr: kw['updateSignature'] = False # prevent recreating source code sig. op = self.addOutputPort(**kw) # create all inputPorts from description for kw in self.inputPortsDescr: kw['updateSignature'] = False # prevent recreating source code sig. ip = self.addInputPort(**kw) # create widgets ip.createWidget() # create all specialPorts self.addSpecialPorts() def isExpanded(self): """returns True if widgets inside the node as displayed""" return self.expandedIcon def editorVisible(self): """returns True if the node Editor is visible""" return self.objEditor is not None def getColor(self): if self.iconMaster is None: return return self.iconMaster.itemconfigure(self.innerBox)['fill'][-1] def setColor(self, color): ## FOR unknown reasons c.tk.call((c._w, 'itemcget', self.innerBox, '-fill') can return 'None' sometimes on SGI when using threads c = self.iconMaster if c is None: print 'Canvas is None' return oldCol = c.tk.call((c._w, 'itemcget', self.innerBox, '-fill') ) while oldCol=='None': print "//////////////////////////", oldCol,self.innerBox, c oldCol = c.tk.call((c._w, 'itemcget', self.innerBox, '-fill') ) print "\\\\\\\\\\\\\\\\\\\\\\",oldCol,self.innerBox, c #oldCol = c.itemconfigure(self.innerBox)['fill'][-1] c.tk.call((c._w, 'itemconfigure', self.innerBox, '-fill', color)) #c.itemconfigure(self.innerBox, fill=color) return oldCol ## OBSOLETE was used for nodes that were widgets ## ## def highlight(self, event=None): ## if self.iconMaster is None: return ## apply( self.iconMaster.itemconfigure, (self.innerBox,), ## self.highlightOptions ) ## def unhighlight(self, event=None): ## if self.iconMaster is None: return ## apply( self.iconMaster.itemconfigure, (self.innerBox,), ## self.unhighlightOptions ) def getFont(self): if self.iconMaster is None: return return self.iconMaster.itemconfigure(self.textId)['font'][-1] def setFont(self, font): # has to be a tuple like this: (ensureFontCase('helvetica'),'-12','bold') if self.iconMaster is None: return assert font is not None and len(font) font = tuple(font) self.iconMaster.itemconfig(self.textId, font=font) def select(self): NetworkItems.select(self) if self.iconMaster is None: return apply( self.iconMaster.itemconfigure, (self.innerBox,), self.selectOptions ) def deselect(self): NetworkItems.deselect(self) if self.iconMaster is None: return apply( self.iconMaster.itemconfigure, (self.innerBox,), self.deselectOptions ) def resizeIcon(self, dx=0, dy=0): if dx: self.growRight(self.innerBox, dx) self.growRight(self.outerBox, dx) self.growRight(self.lowerLine, dx) self.growRight(self.upperLine, dx) # move the special outputPort icons if visible if self.specialPortsVisible: for p in self.specialOutputPorts: p.deleteIcon() p.createIcon() if dy: self.growDown(self.innerBox, dy) self.growDown(self.outerBox, dy) self.growDown(self.lowerLine, dy) self.growDown(self.upperLine, dy) for p in self.outputPorts: p.relposy = p.relposy + dy p.deleteIcon() p.createIcon() for c in p.connections: if c.id: c.updatePosition() def addInputPort(self, name=None, updateSignature=True, _previousWidgetDescr=None, **kw): # ): defaults = { 'balloon':None, '_previousWidgetDescr':None, 'required':True, 'datatype':'None', 'width':None, 'height':None, 'singleConnection':True, 'beforeConnect':None, 'afterConnect':None, 'beforeDisconnect':None, 'afterDisconnect':None, 'shape':None, 'color':None, 'cast':True, 'originalDatatype':None, 'defaultValue':None, 'inputPortClass':InputPort, } defaults.update(kw) kw = defaults """Create input port and creates icon NOTE: this method does not update the description""" number = len(self.inputPorts) if name is None: name = 'in'+str(number) # create unique name portNames = [] for p in self.inputPorts: portNames.append(p.name) if name in portNames: i = number while (True): newname = name+str(i) if newname not in portNames: break i = i+1 name = newname # create port inputPortClass = kw.pop('inputPortClass', InputPort) #print 'ADD INPUT PORT', self.name, inputPortClass, kw ip = inputPortClass( name, self, **kw) # name, self, datatype, required, balloon, width, height, # singleConnection, beforeConnect, afterConnect, beforeDisconnect, # afterDisconnect, shape, color, cast=cast, # originalDatatype=originalDatatype, # defaultValue=defaultValue, **kw # ) self.inputPorts.append(ip) if self.iconMaster: ip.buildIcons() if not self.getEditor().hasGUI: ip.createWidget() # create NGWidget # and add descr to node.inputPortsDescr if it does not exist pdescr = self.inputPortsDescr found = False for d in pdescr: if d['name'] == name: found = True break if not found: descr = {'name':name, 'datatype':kw['datatype'], 'required':kw['required'], 'balloon':kw['balloon'], 'singleConnection':kw['singleConnection']} self.inputPortsDescr.append(descr) if _previousWidgetDescr is not None: ip.previousWidgetDescr = _previousWidgetDescr # generate unique number, which is used for saving/restoring ip._id = self._inputPortsID self._inputPortsID += 1 ip._setModified(True) ip._setOriginal(False) # change signature of compute function if updateSignature is True: self.updateCode(port='ip', action='add', tagModified=False) self.inputPortByName[name] = ip return ip def refreshInputPortData(self): d = {} for p in self.inputPorts: d[p.name] = p.getData() return d def addOutputPort(self, name=None, updateSignature=True, **kw): defaults = {'datatype':'None', 'width':None, 'height':None, 'balloon':None, 'beforeConnect':None, 'afterConnect':None, 'beforeDisconnect':None, 'afterDisconnect':None, 'shape':None, 'color':None} defaults.update(kw) kw = defaults """Create output port and creates icon NOTE: this method does not update the description nor the function's signature""" number = len(self.outputPorts) if name is None: name = 'out'+str(number) # create unique name portNames = [] for p in self.outputPorts: portNames.append(p.name) if name in portNames: i = number while (True): newname = name+str(i) if newname not in portNames: break i = i+1 name = newname # create port outputPortClass = kw.pop('outputPortClass', OutputPort) op = outputPortClass(name, self, **kw) #datatype, balloon, width, height, #beforeConnect, afterConnect, beforeDisconnect, #afterDisconnect) self.outputPorts.append(op) if self.iconMaster: op.buildIcons() # and add descr to node.outputPortsDescr if it does not exist pdescr = self.outputPortsDescr found = False for d in pdescr: if d['name'] == name: found = True break if not found: descr = {'name':name, 'datatype':kw['datatype'], 'balloon':kw['balloon']} self.outputPortsDescr.append(descr) # generate unique number, which is used for saving/restoring op._id = self._outputPortsID self._outputPortsID += 1 op._setModified(True) op._setOriginal(False) # add comment to code on how to output data on that port if updateSignature is True: self.updateCode(port='op', action='add', newname=op.name, tagModified=False) self.outputPortByName[name] = op return op def deletePort(self, p, resize=True, updateSignature=True): NetworkItems.deletePort(self, p, resize) # update code first, then delete if updateSignature and isinstance(p, InputPort): self.updateCode(port='ip', action='remove', tagModified=False) self.inputPortByName.pop(p.name) elif updateSignature and isinstance(p, OutputPort): self.updateCode(port='op', action='remove', newname='', oldname=p.name, tagModified=False) self.outputPortByName.pop(p.name) def deletePortByName(self, portName, resize=True, updateSignature=True): """delete a port by specifying a port name (port names are unique within a given node).""" port = self.findPortByName() self.deletePort(port, resize=resize, updateSignature=updateSignature) def showSpecialPorts(self, tagModified=True, event=None): self.specialPortsVisible = True self._setModified(tagModified) for p in self.specialOutputPorts: p.createIcon() for p in self.specialInputPorts: p.createIcon() self.menu.entryconfigure('Show special ports', label='Hide special ports', command=self.hideSpecialPorts) def hideSpecialPorts(self, tagModified=True, event=None): self.specialPortsVisible = False self._setModified(tagModified) for p in self.specialOutputPorts: p.node.network.deleteConnections(p.connections, undo=1) p.deleteIcon() for p in self.specialInputPorts: p.node.network.deleteConnections(p.connections, undo=1) p.deleteIcon() self.menu.entryconfigure('Hide special ports', label='Show special ports', command=self.showSpecialPorts) def addSpecialPorts(self): """add special ports to special ports list. But do not build icons""" # port to receive an impulse that will trigger the execution of the # node ip = RunNodeInputPort(self) ip.network = self.network self.specialInputPorts.append( ip ) # port that always output an impulse upon successful completion # of the node's function op = TriggerOutputPort(self) op.network = self.network self.specialOutputPorts.append( op ) ed = self.getEditor() ip.vEditor = weakref.ref( ed ) op.vEditor = weakref.ref( ed ) def buildSmallIcon(self, canvas, posx, posy, font=None): """build node proxy icon (icons in library categories""" if font is None: font = self.ed.font['LibNodes'] font = tuple(font) self.textId = canvas.create_text( posx, posy, text=self.name, justify=Tkinter.CENTER, anchor='w', tags='node', font=font) self.iconTag = 'node'+str(self.textId) bb = canvas.bbox(self.textId) # adding the self.id as a unique tag for this node canvas.addtag_closest(self.iconTag, posx, posy, start=self.textId) bdx1 = 2 # x padding around label bdy1 = 0 # y padding around label bdx2 = bdx1+3 # label padding + relief width bdy2 = bdy1+3 # label padding + relief width self.innerBox = canvas.create_rectangle( bb[0]-bdx1, bb[1]-bdy1, bb[2]+bdx1, bb[3]+bdy1, tags=(self.iconTag,'node'), fill='gray85') # the innerBox is the canvas item used to designate this node self.id = self.innerBox # add a shadow below if self.library is not None: color1 = self.library.color else: color1 = 'gray95' # upper right triangle self.upperLine = canvas.create_polygon( bb[0]-bdx2, bb[1]-bdy2, bb[0]-bdx1, bb[1]-bdy1, bb[2]+bdx1, bb[3]+bdy1, bb[2]+bdx2, bb[3]+bdy2, bb[2]+bdx2, bb[1]-bdy2, width=4, tags=(self.iconTag,'node'), fill=color1 ) # lower left triangle self.lowerLine = canvas.create_polygon( bb[0]-bdx2, bb[1]-bdy2, bb[0]-bdx1, bb[1]-bdy1, bb[2]+bdx1, bb[3]+bdy1, bb[2]+bdx2, bb[3]+bdy2, bb[0]-bdx2, bb[3]+bdy2, width=4, tags=(self.iconTag,'node'), fill='gray45' ) self.outerBox = canvas.create_rectangle( bb[0]-bdx2, bb[1]-bdy2, bb[2]+bdx2, bb[3]+bdy2, width=1, tags=(self.iconTag,'node')) canvas.tag_raise(self.innerBox, self.outerBox) canvas.tag_raise(self.textId, self.innerBox) return bb def deleteSmallIcon(self, canvas, item): # Experimental! node = item.dummyNode canvas.delete(node.textId) canvas.delete(node.innerBox) canvas.delete(node.outerBox) canvas.delete(node.iconTag) def buildNodeIcon(self, canvas, posx, posy, small=False): # build a frame that will hold all widgets in node if hasattr(self.iconMaster,'tk'): self.nodeWidgetMaster = Tkinter.Frame( self.iconMaster, borderwidth=3, relief='sunken' , bg='#c3d0a6') ed = self.getEditor() if small is True: font = tuple(ed.font['LibNodes']) lInner = 2 lOuter = 4 else: font = tuple(ed.font['Nodes']) lInner = 5 lOuter = 8 self.textId = canvas.create_text( posx, posy, text=self.name, justify=Tkinter.CENTER, anchor='w', tags='node', font=font) canvas.tag_bind(self.textId, "", self.setLabel_cb) self.iconTag = 'node'+str(self.textId) # add self.iconTag tag to self.textId canvas.itemconfig(self.textId, tags=(self.iconTag,'node')) bb = canvas.bbox(self.textId) ## # NOTE: THIS LINE ADDS RANDOMLY WRONG TAGS TO NODES >>>> COPY/PASTE ## # WON'T WORK CORRECTLY!!! WITHOUT THIS LINE, EVERYTHING SEEMS TO ## # WORK FINE. ## #adding the self.id as a unique tag for this node ## canvas.addtag_closest(self.iconTag, posx, posy, start=self.textId) progBarH = self.progBarH # this method is also called by a network refresh, thus we need to # get the description of the node and color it accordingly (frozen # or colored by node library) color = "gray85" # default color is gray if self.editor.colorNodeByLibraryTk.get() == 1: if self.library is not None: color = self.library.color # color by node library color # if node is frozen, this overwrites everything if self.frozen: color = '#b6d3f6' # color light blue self.innerBox = canvas.create_rectangle( bb[0]-lInner, bb[1]-lInner, bb[2]+lInner, bb[3]+lInner+progBarH, tags=(self.iconTag,'node'), fill=color)#, width=2 ) # the innerBox is the canvas item used to designate this node self.id = self.innerBox # add a shadow below (color by Library) if self.library is not None: color1 = self.library.color else: color1 = 'gray95' self.outerBox = canvas.create_rectangle( bb[0]-lOuter, bb[1]-lOuter, bb[2]+lOuter, bb[3]+lOuter+progBarH, width=1, tags=(self.iconTag,'node')) # get a shortcut to the bounding boxes used later on ibb = canvas.bbox(self.innerBox) obb = canvas.bbox(self.outerBox) # upper right polygon (this is used to color the node icons upper # and right side with the corresponding node library color) self.upperLine = canvas.create_polygon( # note: we have to compensate +1 and -1 because of '1'-based # coord system obb[0]+1, obb[1]+1, ibb[0]+1, ibb[1]+1, ibb[2]-1, ibb[3]-1, obb[2]-1, obb[3]-1, obb[2]-1, obb[1]+1, width=4, tags=(self.iconTag,'node'), fill=color1 ) # lower left polygon (this is used to 'shade' the node icons lower # and right side with a dark grey color to give it a 3-D impression self.lowerLine = canvas.create_polygon( # note: we have to compensate +1 and -1 because of '1'-based # coord system obb[0]+1, obb[1]+1, ibb[0]+1, ibb[1]+1, ibb[2]-1, ibb[3]-1, obb[2]-1, obb[3]-1, obb[0]+1, obb[3]-1, width=4, tags=(self.iconTag,'node'), fill='gray45' ) canvas.tag_raise(self.outerBox) canvas.tag_raise(self.innerBox, self.outerBox) canvas.tag_raise(self.textId, self.innerBox) # add the progress bar if self.hasProgBar: pbid1 = canvas.create_rectangle( bb[0]-3, bb[3]-2, bb[2]+3, bb[3]+1+progBarH, tags=(self.iconTag,'node'), fill='green') self.pbid1 = pbid1 pbid2 = canvas.create_rectangle( bb[2]+3, bb[3]-2, bb[2]+3, bb[3]+1+progBarH, {'tags':(self.iconTag,'node'), 'fill':'red'} ) self.pbid2 = pbid2 # and set posx, posy self.updatePosXPosY(posx, posy) if self.network is not None: self.move(posx, posy) self.hasMoved = False # reset this attribute because the current # position is now the original position def setLabel_cb(self, event): self._tmproot = root = Tkinter.Toplevel() root.transient() root.geometry("+%d+%d"%root.winfo_pointerxy()) root.overrideredirect(True) self._tmpEntry = Tkinter.Entry(root) self._tmpEntry.pack() self._tmpEntry.bind("", self.setNewLabel_cb) def setNewLabel_cb(self, event): name = self._tmpEntry.get() self.rename(name) self._tmpEntry.destroy() self._tmproot.destroy() def setProgressBar(self, percent): """update node's progress bar. percent should be between 0.0 and 1.0""" if not self.hasProgBar: return canvas = self.iconMaster c = canvas.coords(self.pbid1) c[0] = c[0] + (c[2]-c[0])*percent canvas.coords(self.pbid2, c[0], c[1], c[2], c[3]) def updatePosXPosY(self, dx=None, dy=None): """set node.posx and node.posy after node has been moved""" bbox = self.iconMaster.bbox(self.outerBox) self.posx = bbox[0] self.posy = bbox[1] def setModifiedTag(self): """THIS METHOD REMAINS FOR BACKWARDS COMPATIBILITY WITH OLD NETWORKS! Sets self._modified=True""" self._setModified(True) class NetworkConnection(NetworkItems): """This class implements a connection between nodes, drawing lines between the centers of 2 ports. The mode can be set to 'straight' or 'angles' to have a straight line or lines using only right angles. smooth=1 option can be used for splines joinstyle = 'bevel', 'miter' and 'round' """ arcNum = 0 def __init__(self, port1, port2, mode='straight', name=None, blocking=None, smooth=False, splitratio=None, hidden=False, **kw): if name is None: name = port1.node.name+'('+port1.name+')'+'_'+port2.node.name+'('+port2.name+')' if splitratio is None: splitratio=[random.uniform(.2,.75), random.uniform(.2,.75)] # was [.5, .5] NetworkItems.__init__(self, name) self.hidden = hidden self.id2 = None self.iconTag2 = None self.port1 = port1 self.port2 = port2 port1.children.append(port2) #assert self not in port1.connections port1.connections.append(self) port1.node.children.append(port2.node) port2.parents.append(port1) #assert self not in port2.connections port2.connections.append(self) port2.node.parents.append(port1.node) leditor = self.port1.editor if blocking is None: blocking = leditor.createBlockingConnections self.blocking = blocking # when true a child node can not run before # the parent node has run self.mode = mode if leditor is not None and hasattr(leditor, 'splineConnections'): self.smooth = leditor.splineConnections else: self.smooth = smooth self.splitratio = copy.deepcopy(splitratio) w = self.connectionWidth = 3 if port1.node.getEditor().hasGUI: col = port1.datatypeObject['color'] if not kw.has_key('arrow'): kw['arrow']='last' if not kw.has_key('fill'): kw['fill']=col if not kw.has_key('width'): kw['width']=w if not kw.has_key('width'): kw['width']=w if not kw.has_key('activefill'): kw['activefill']='pink' kw['smooth'] = self.smooth self.lineOptions = kw self.highlightOptions = {'fill':'red', 'width':w, 'arrow':'last'} self.unhighlightOptions = {'width':w, 'arrow':'last'} self.unhighlightOptions['fill'] = col self.selectOptions = { 'connection0': {'fill':'blue', 'width':w, 'arrow':'last'}, 'connection1': {'fill':'pink', 'width':w, 'arrow':'last'}, 'connection2': {'fill':'purple', 'width':w, 'arrow':'last'}, } self.deselectOptions = {'width':w, 'arrow':'last'} self.deselectOptions['fill'] = col self.mouseAction[''] = self.reshapeConnection self.parentMenu = None self.isBlockingTk = Tkinter.IntVar() self.isBlockingTk.set(self.blocking) if isinstance(port1.node, NetworkNode) and isinstance(port2.node, NetworkNode): self._mode = 1 else: self._mode = 2 def reshapeConnection(self, event): # get a handle to the network of this node c = self.iconMaster # register an additional function to reshape connection num = event.num # FIXME looks like I am binding this many times ! c.bind(""%num, self.moveReshape,'+') c.bind(""%num, self.moveEndReshape, '+') ## def moveReshape(self, event): ## c = self.iconMaster ## y = c.canvasy(event.y) ## dy = y - self.network.lasty ## self.network.lasty = y ## coords = c.coords(self.iconTag) ## coords[3] = coords[3]+dy ## coords[5] = coords[5]+dy ## apply( c.coords, (self.iconTag,)+tuple(coords) ) ## def moveEndReshape(self, event): ## c = self.iconMaster ## num = event.num ## c.unbind(""%num) ## c.bind(""%num, self.moveEndReshape, '+') # patch from Karl Gutwin 2003-03-27 16:05 def moveReshape(self, event): #print "moveReshape" c = self.iconMaster y = c.canvasy(event.y) x = c.canvasx(event.x) dy = y - self.network.lasty dx = x - self.network.lastx self.network.lasty = y self.network.lastx = x coords = c.coords(self.iconTag) if len(coords)==12: coords[4] = coords[4]+dx coords[6] = coords[6]+dx if y > ((coords[5]+coords[7])/2): coords[3] = coords[3]+dy coords[5] = coords[5]+dy else: coords[7] = coords[7]+dy coords[9] = coords[9]+dy else: coords[3] = coords[3]+dy coords[5] = coords[5]+dy self.calculateNewSplitratio(coords) apply( c.coords, (self.iconTag,)+tuple(coords) ) def calculateNewSplitratio(self, coords): self.splitratio[0] = coords[0]-coords[4] lDistance = coords[0]-coords[-2] if lDistance != 0: self.splitratio[0] /= float(lDistance) if self.splitratio[0] > 2: self.splitratio[0] = 2 elif self.splitratio[0] < -2: self.splitratio[0] = -2 self.splitratio[1] = coords[1]-coords[5] lDistance = coords[1]-coords[-1] if lDistance != 0: self.splitratio[1] /= float(lDistance) if self.splitratio[1] > 2: self.splitratio[1] = 2 elif self.splitratio[1] < -2: self.splitratio[1] = -2 def moveEndReshape(self, event): c = self.iconMaster num = event.num c.unbind(""%num) c.unbind(""%num) def highlight(self, event=None): if self.iconMaster is None: return c = self.iconMaster apply( c.itemconfigure, (self.iconTag,), self.highlightOptions ) def unhighlight(self, event=None): if self.iconMaster is None: return c = self.iconMaster apply( c.itemconfigure, (self.iconTag,), self.unhighlightOptions) def setColor(self, color): if self.iconMaster is None: return c = self.iconMaster apply( c.itemconfigure, (self.iconTag,), {'fill':color} ) self.unhighlightOptions['fill'] = color self.deselectOptions['fill'] = color def getColor(self): return self.deselectOptions['fill'] def select(self): self.selected = 1 if self.iconMaster is None: return sum = self.port1.node.selected + self.port2.node.selected if sum==2: self.iconMaster.addtag('selected', 'withtag', self.iconTag) apply( self.iconMaster.itemconfigure, (self.iconTag,), self.selectOptions['connection%d'%sum] ) def deselect(self): NetworkItems.deselect(self) if self.iconMaster is None: return sum = self.port1.node.selected + self.port2.node.selected if sum<2: self.iconMaster.dtag(self.iconTag, 'selected') if sum==0: opt = self.deselectOptions else: opt = self.selectOptions['connection%d'%sum] apply( self.iconMaster.itemconfigure, (self.iconTag,), opt ) def shadowColors(self, colorTk): # for a given Tkcolor return a dark tone 40% and light tone 80% c = self.iconMaster maxi = float(c.winfo_rgb('white')[0]) rgb = c.winfo_rgb(colorTk) base = ( rgb[0]/maxi*255, rgb[1]/maxi*255, rgb[2]/maxi*255 ) dark = "#%02x%02x%02x"%(base[0]*0.6,base[1]*0.6,base[2]*0.6) light = "#%02x%02x%02x"%(base[0]*0.8,base[1]*0.8,base[2]*0.8) return dark, light def toggleBlocking_cb(self, event=None): self.blocking = not self.blocking self.isBlockingTk.set(self.blocking) if not self.blocking: self.port2.node.ensureRootNode() def toggleVisibility_cb(self, event=None): self.setVisibility(not self.hidden) def setVisibility(self, hidden): self.hidden = hidden del self.network.connById[self.id] if self.id2 is not None: del self.network.connById[self.id2] self.deleteIcon() self.buildIcons(self.network.canvas) self.network.connById[self.id] = self if self.id2 is not None: self.network.connById[self.id2] = self def reparent_cb(self, type): node = self.port2.node self.network.deleteConnections([self]) node.reparentGeomType(type, reparentCurrent=False) def drawMapIcon(self, naviMap): if self.id is None: # geom nodes with aprentNode2 seen to create return # conenctions with no id mapCanvas = naviMap.mapCanvas x0, y0 = naviMap.upperLeft scaleFactor = naviMap.scaleFactor canvas = self.iconMaster cc = self.network.canvas.coords(self.id) nc = [] for i in range(0, len(cc), 2): nc.append( x0+cc[i]*scaleFactor ) nc.append( y0+cc[i+1]*scaleFactor ) if self.naviMapID is None: cid = mapCanvas.create_line( *nc, tag=('navimap',)) self.naviMapID = cid return cid else: mapCanvas.coords(self.naviMapID, *nc) def updatePosition(self): if self.iconMaster is None: return # spoted by guillaume, I am not sure what it means if self.port1 is None or self.port2 is None: import traceback traceback.print_stack() print c, id(id) print 'IT HAPPENED AGAIN: a conection is missing ports' return if self.port1.id is None or self.port2.id is None: return # one the ports is not visible c = self.iconMaster coords = self.getLineCoords() if self.hidden is False: apply( c.coords, (self.id,)+tuple(coords) ) else: if isinstance(self.port1, SpecialOutputPort): lcoords1 = (coords[0],coords[1],coords[0]+20,coords[1]) lcoords2 = (coords[-2]-16,coords[-1],coords[-2],coords[-1]) else: lcoords1 = (coords[0],coords[1],coords[0],coords[1]+20) lcoords2 = (coords[-2],coords[-1]-16,coords[-2],coords[-1]) apply( c.coords, (self.id,)+tuple(lcoords1) ) apply( c.coords, (self.id2,)+tuple(lcoords2) ) naviMap = self.port1.node.network.naviMap self.drawMapIcon(naviMap) def getLineCoords(self): canvas = self.iconMaster c1 = self.port1.getCenterCoords() c2 = self.port2.getCenterCoords() n1 = self.port1.node n2 = self.port2.node if self._mode==1: if self.mode == 'straight': outOffy = c1[1]+15 inOffy = c2[1]-15 return [ c1[0], c1[1], c1[0], outOffy, c2[0], inOffy, c2[0], c2[1] ] else: # if self.mode == 'angles': dy = c2[1]-c1[1] if dy > 30: # draw just 1 segment down, 1 horizontal and 1 down again dy2 = dy * self.splitratio[1] outOffy = c1[1]+dy2 return [ c1[0], c1[1], c1[0], outOffy, c2[0], outOffy, c2[0], c2[1] ] else: outOffy = c1[1]+15 # go down 15 pixels from output inOffy = c2[1]-15 # go up 15 pixel from input dx = c2[0]-c1[0] dx2 = dx * self.splitratio[0] mid = [ c1[0]+dx2, outOffy, c2[0]-(dx-dx2), inOffy ] return [ c1[0], c1[1], c1[0], outOffy ] + mid + \ [ c2[0], inOffy, c2[0], c2[1] ] else: vx1, vy1 = self.port1.vectorRotated vy1 = -vy1 vx2, vy2 = self.port2.vectorRotated vy2 = -vy2 if self.mode == 'straight': outOffy = c1[0]+15*vx1 inOffy = c2[0]-15*vy1 return [ c1[0], c1[1], c1[0], outOffy, c2[0], inOffy, c2[0], c2[1] ] else: # if self.mode == 'angles': dx = c2[0]-c1[0] # check if port vectors are opposite dot = vx1*vx2 + vy1*vy2 if dot < 0.0: # 3 segments, 2 projecting out of node and 1 joining them # draw 1 segment along p1.vector # 1 segment along -p2.vector and a segement joing them proj = 20 p1x = c1[0]+proj*vx1 p1y = c1[1]+proj*vy1 p2x = c2[0]+proj*vx2 p2y = c2[1]+proj*vy2 #print 'getLineCoords A',c1[0], c1[1], p1x, p1y, p2x, p2y, c2[0], c2[1] #print 'A', c1, c2, vx1, vy1, vx2, vy2 return [ c1[0], c1[1], p1x, p1y, p2x, p2y, c2[0], c2[1] ] else: proj = 20 p1x = c1[0]+proj*vx1 # move up p1y = c1[1]+proj*vy1 perp = -vy1, vx1 # check that perpendicular vector point from on port to the other ppvx = c2[0]-c1[0] # vector form port1 to port2 ppvy = c2[1]-c1[1] dot = ppvx*perp[0] + ppvy*perp[1] if dot>0.0: sign = 1.0 else: sign = -1.0 p2x = p1x+proj*sign*perp[0] # move side ways a bit p2y = p1y+proj*sign*perp[1] p3x = c2[0]+proj*vx2 p3y = c2[1]+proj*vy2 #print 'B', c1, c2, vx1, vy1, vx2, vy2, perp #print 'getLineCoords B', c1[0], c1[1], p1x, p1y, p2x, p2y, p3x, p3y,c2[0], c2[1] return [ c1[0], c1[1], p1x, p1y, p2x, p2y, p3x, p3y, c2[0], c2[1] ] ## def getLineCoords(self): ## if isinstance(self.port1, SpecialOutputPort): ## return self.getLineCoordsLeftRightPorts() ## elif isinstance(self.port1, ImageOutputPort): ## return self.getLineCoordsLeftRightPorts() ## else: ## return self.getLineCoordsTopBottomPorts() ## def getLineCoordsLeftRightPorts(self): ## canvas = self.iconMaster ## c1 = self.port1.getCenterCoords() ## c2 = self.port2.getCenterCoords() ## if self.mode == 'straight': ## outOffy = c1[0]+15 ## inOffy = c2[0]-15 ## return [ c1[0], c1[1], c1[0], outOffy, ## c2[0], inOffy, c2[0], c2[1] ] ## else: # if self.mode == 'angles': ## dx = c2[0]-c1[0] ## if dx > 30: # draw just 1 segment down, 1 horizontal and 1 down again ## dx2 = dx * self.splitratio[0] ## outOffx = c1[0]+dx2 ## inOffx = c2[0]-(dx-dx2) ## return [ c1[0], c1[1], outOffx, c1[1], inOffx, c2[1], ## c2[0], c2[1] ] ## else: ## outOffx = c1[0]+15 # go right 15 pixels from output ## inOffx = c2[0]-15 # go left 15 pixel from input ## dy = c2[1]-c1[1] ## dy2 = dy * self.splitratio[1] ## mid = [ outOffx, c1[1]+dy2, inOffx, c2[1]-(dy-dy2) ] ## return [ c1[0], c1[1], outOffx, c1[1] ] + mid + \ ## [ inOffx, c2[1], c2[0], c2[1] ] ## def getLineCoordsTopBottomPorts(self): ## # implements straight and angle connections between nodes ## canvas = self.iconMaster ## c1 = self.port1.getCenterCoords() ## c2 = self.port2.getCenterCoords() ## if self.mode == 'straight': ## outOffy = c1[1]+15 ## inOffy = c2[1]-15 ## return [ c1[0], c1[1], c1[0], outOffy, ## c2[0], inOffy, c2[0], c2[1] ] ## else: # if self.mode == 'angles': ## dy = c2[1]-c1[1] ## if dy > 30: # draw just 1 segment down, 1 horizontal and 1 down again ## dy2 = dy * self.splitratio[1] ## outOffy = c1[1]+dy2 ## return [ c1[0], c1[1], c1[0], outOffy, c2[0], ## outOffy, c2[0], c2[1] ] ## else: ## outOffy = c1[1]+15 # go down 15 pixels from output ## inOffy = c2[1]-15 # go up 15 pixel from input ## dx = c2[0]-c1[0] ## dx2 = dx * self.splitratio[0] ## mid = [ c1[0]+dx2, outOffy, c2[0]-(dx-dx2), inOffy ] ## return [ c1[0], c1[1], c1[0], outOffy ] + mid + \ ## [ c2[0], inOffy, c2[0], c2[1] ] def buildIcons(self, canvas): """Build CONNECTION icon """ NetworkItems.buildIcons(self, canvas) kw = self.lineOptions arcTag = '__arc'+str(self.arcNum) self.arcNum = self.arcNum + 1 kw['tags'] = ('connection', arcTag) coords = self.getLineCoords() if self.hidden is False: g = apply( canvas.create_line, tuple(coords), kw ) else: #print "coords", coords if isinstance(self.port1, SpecialOutputPort): lcoords1 = (coords[0],coords[1],coords[0]+20,coords[1]) lcoords2 = (coords[-2]-16,coords[-1],coords[-2],coords[-1]) else: lcoords1 = (coords[0],coords[1],coords[0],coords[1]+20) lcoords2 = (coords[-2],coords[-1]-16,coords[-2],coords[-1]) g = apply( canvas.create_line, tuple(lcoords1), kw ) g2 = apply( canvas.create_line, tuple(lcoords2), kw ) self.iconTag2 = 'conn'+str(g2) self.id2 = g2 self.iconTag = 'conn'+str(g) self.id = g cb = CallBackFunction(self.network.deleteConnections, ([self])) if self.port2.name == 'parent' and hasattr(self.port2.node,'selectedGeomIndex'): # i.e. it's a geometry node cbSiblings = CallBackFunction(self.reparent_cb, ('siblings')) cbAll = CallBackFunction(self.reparent_cb, ('all')) self.menu.add_command(label='delete / reparent to root', command=cb) self.menu.add_command(label='reparent pointed siblings to root', command=cbSiblings) self.menu.add_command(label='reparent all pointed geoms to root', command=cbAll) else: self.menu.add_command(label='delete', command=cb) if self.hidden is False: self.menu.add_command(label='hide', command=self.toggleVisibility_cb) else: self.menu.add_command(label='show', command=self.toggleVisibility_cb) self.menu.add_checkbutton(label='blocking', variable = self.isBlockingTk, command=self.toggleBlocking_cb) # adding the self.id as a unique tag for this node canvas.addtag_withtag(self.iconTag, arcTag ) if self.hidden is True: canvas.addtag_withtag(self.iconTag2, arcTag ) canvas.dtag( arcTag ) canvas.lower(g, 'node') def getSourceCode(self, networkName, selectedOnly=0, indent="", ignoreOriginal=False, connName='conn'): # build and return connection creation source code from NetworkEditor.ports import TriggerOutputPort lines = [] conn = self if conn._original is True and ignoreOriginal is False: return lines if selectedOnly and \ conn.port1.node.selected+conn.port2.node.selected < 2: return lines node1 = conn.port1.node node2 = conn.port2.node n1Name = node1.getUniqueNodeName() n2Name = node2.getUniqueNodeName() lines = node1.checkIfNodeForSavingIsDefined(lines, networkName, indent) lines = node2.checkIfNodeForSavingIsDefined(lines, networkName, indent) lines.append(indent+'if %s is not None and %s is not None:\n'%( n1Name, n2Name)) if isinstance(conn.port1, TriggerOutputPort): line1 = networkName+".specialConnectNodes(\n" else: line1 = '%s = '%connName +networkName+".connectNodes(\n" ## line = line + "%s, %s, %d, %d)\n"%(n1Name, n2Name, ## conn.port1.number, conn.port2.number) port1Name = conn.port1.name port2Name = conn.port2.name from macros import MacroInputNode, MacroOutputNode # treat connections to MacroInputNode separately if isinstance(conn.port1.node, MacroInputNode): if len(conn.port1.connections) > 1: i = 0 for c in conn.port1.connections: if c == conn: break else: i = i + 1 if i == 0: port1Name = 'new' else: port1Name = 'new' # treat connections to MacroOutpuNode separately if isinstance(conn.port2.node, MacroOutputNode): if len(conn.port2.connections) > 1: i = 0 for c in conn.port2.connections: if c == conn: break else: i = i + 1 if i == 0: port2Name = 'new' else: port2Name = 'new' line2 = '%s, %s, "%s", "%s", blocking=%s\n'%( n1Name, n2Name, port1Name, port2Name, conn.blocking) line3 = '' if conn.splitratio != [.5,.5]: line3 = ', splitratio=%s'%(conn.splitratio) if self.hidden is True: line3 += ', hidden=True' line3 += ')\n' lines.append(indent + ' '*4 + 'try:\n') lines.append(indent + ' '*8 + line1) lines.append(indent + ' '*12 + line2) lines.append(indent + ' '*12 + line3) lines.append(indent + ' '*4 + 'except:\n') lines.append(indent + ' '*8 + \ 'print "WARNING: failed to restore connection between %s and %s in network %s"\n'%(n1Name,n2Name,networkName)) lines.extend(node1.customizeConnectionCode(self, connName, indent + ' '*4)) lines.extend(node2.customizeConnectionCode(self, connName, indent + ' '*4)) return lines def destroyIcon(self): self.deleteIcon() self.id = None self.iconMaster = None self.id2 = None self.network.canvas.delete(self.iconTag2) self.iconTag2 = None self.naviMapID = None class FunctionNode(NetworkNode): """ Base node for Vsiion nodes exposing a function or callable object The RunFunction node is an example of subclassing this node. Opal web services nodes are instance of this node exposing the opal web service python wrapper callable object This object support creating input ports for all parameters to the function. Positional (i.e. without default value) arguments always generate an input port visible on the node. For named arguments arguments a widget is created base on the type of the default value (e.g. entry for string, dial for int and float etc.) If the function or callable object has a .params attribute this attribute is expected to be a dictionary where the key is the name of the argument and the\ value is dictionary providing additional info about this parameter. the folloing keys are recognized in this dictionary: {'default': 'False', # default value (not used as it is taken from the function signature) 'type': 'boolean', 'description': 'string' #use to create tooltip 'ioType': 'INPUT', # can be INPUT, INOUT, } if type is FILE a a file browser will be generated if type is selection a values keywords should be present and provide a list of possible values that will be made available in a combobox widget """ codeBeforeDisconnect = """def beforeDisconnect(self, c): # upon disconnecting we want to set the attribute function to None c.port2.node.function = None # remove all ports beyond the 'function' and 'importString' input ports for p in c.port2.node.inputPorts[2:]: c.port2.node.deletePort(p) """ def passFunction(): pass passFunc = passFunction def __init__(self, functionOrString=None, importString=None, posArgsNames=[], namedArgs={}, **kw): if functionOrString is not None or kw.has_key('functionOrString') is False: kw['functionOrString'] = functionOrString elif kw.has_key('functionOrString') is True: functionOrString = kw['functionOrString'] if importString is not None or kw.has_key('importString') is False: kw['importString'] = importString elif kw.has_key('importString') is True: importString = kw['importString'] if len(posArgsNames)>0 or kw.has_key('posArgsNames') is False: kw['posArgsNames'] = posArgsNames elif kw.has_key('posArgsNames') is True: posArgsNames = kw['posArgsNames'] if len(namedArgs)>0 or kw.has_key('namedArgs') is False: kw['namedArgs'] = namedArgs elif kw.has_key('namedArgs') is True: namedArgs = kw['namedArgs'] if type(functionOrString) == types.StringType: # we add __main__ to the scope of the local function # the folowing code is similar to: "from __main__ import *" # but it doesn't raise any warning, and its probably more local # and self and in1 are still known in the scope of the eval function from mglutil.util.misc import importMainOrIPythonMain lMainDict = importMainOrIPythonMain() for modItemName in set(lMainDict).difference(dir()): locals()[modItemName] = lMainDict[modItemName] if importString is not None: try: lImport = eval(importString) if lImport == types.StringType: importString = lImport except: pass exec(importString) if kw.has_key('masternet') is True: masterNet = kw['masternet'] lfunctionOrString = functionOrString while type(lfunctionOrString) == types.StringType: try: function = eval(lfunctionOrString) except NameError: function = None lfunctionOrString = function else: function = functionOrString if function is not None and kw.has_key('library'): # so we know where to find the current editor function._vpe = kw['library'].ed function._node = self # so we can find the vision node if hasattr(function, 'params') and type(function.params) == types.DictType: argsDescription = function.params else: argsDescription = {} if inspect.isclass(function) is True: try: function = function() except: function = None if function is None: #def testFunction(a, b=1): # print 'testFunction', a, b # return a, b function = self.passFunc if hasattr(function, 'name'): name = function.name elif hasattr(function, '__name__'): name = function.__name__ else: name = function.__class__.__name__ kw['name'] = name apply( NetworkNode.__init__, (self,), kw ) self.function = function # function or command to be called self.posArgsNames = posArgsNames self.namedArgs = namedArgs # dict: key: arg name, value: arg default self.outputPortsDescr.append(datatype='None', name='result') #for key, value in outputDescr: # self.outputPortsDescr.append(datatype=value, name=key) # get arguments description from inspect import getargspec if hasattr(function, '__call__') and hasattr(function.__call__, 'im_func'): args = getargspec(function.__call__.im_func) else: args = getargspec(function) if len(args[0])>0 and args[0][0] == 'self': args[0].pop(0) # get rid of self allNames = args[0] defaultValues = args[3] if defaultValues is None: defaultValues = [] nbNamesArgs = len(defaultValues) if nbNamesArgs > 0: self.posArgsNames = args[0][:-nbNamesArgs] else: self.posArgsNames = args[0] d = {} for name, val in zip(args[0][-nbNamesArgs:], defaultValues): d[name] = val self.namedArgs = d # create widgets and ports for named arguments self.buildPortsForPositionalAndNamedArgs(self.posArgsNames, self.namedArgs, argsDescription=argsDescription) # create the constructor arguments such that when the node is restored # from file it will have all the info it needs if functionOrString is not None \ and type(functionOrString) == types.StringType: self.constrkw['functionOrString'] = "\'"+suppressMultipleQuotes(functionOrString)+"\'" if importString is not None: self.constrkw['importString'] = "\'"+suppressMultipleQuotes(importString)+"\'" elif hasattr(function, 'name'): # case of a Pmv command self.constrkw['command'] = 'masterNet.editor.vf.%s'%function.name elif hasattr(function, '__name__'): # a function is not savable, so we are trying to save something self.constrkw['functionOrString'] = "\'"+function.__name__+"\'" else: # a function is not savable, so we are trying to save something self.constrkw['functionOrString'] = "\'"+function.__class__.__name__+"\'" if (importString is None or importString == '') \ and self.constrkw.has_key('importString') is True: del self.constrkw['importString'] if len(self.posArgsNames) > 0: self.constrkw['posArgsNames'] = self.posArgsNames elif self.constrkw.has_key('posArgsNames') is True: del self.constrkw['posArgsNames'] if len(self.namedArgs) > 0: self.constrkw['namedArgs'] = self.namedArgs elif self.constrkw.has_key('namedArgs') is True: del self.constrkw['namedArgs'] if kw.has_key('host') is True: self.constrkw['host'] = '\"'+suppressMultipleQuotes(kw['host'])+'\"' elif self.constrkw.has_key('host') is True: del self.constrkw['host'] code = """def doit(self, *args): # get all positional arguments posargs = [] for pn in self.posArgsNames: posargs.append(locals()[pn]) # build named arguments kw = {} for arg in self.namedArgs.keys(): kw[arg] = locals()[arg] # call function try: if hasattr(self.function,'__call__') and hasattr(self.function.__call__, 'im_func'): result = apply( self.function.__call__, posargs, kw ) else: result = apply( self.function, posargs, kw ) except Exception, e: from warnings import warn warn(str(e)) result = None self.outputData(result=result) """ if code: self.setFunction(code) # change signature of compute function self.updateCode(port='ip', action='create', tagModified=False) def buildPortsForPositionalAndNamedArgs(self, args, namedArgs, argsDescription={}, createPortNow=False): lAllPortNames = args + namedArgs.keys() for name in lAllPortNames: if name in args: ipdescr = {'name':name, 'required':True} if argsDescription.get(name): lHasDefaultValue = True val = argsDescription[name]['default'] else: lHasDefaultValue = False else: ipdescr = {'name':name, 'required':False} lHasDefaultValue = True val = namedArgs[name] dtype = 'None' if lHasDefaultValue is True: if argsDescription.get(name) and argsDescription[name]['type']=='selection': dtype = 'string' self.widgetDescr[name] = { 'class': 'NEComboBox', 'initialValue':val, 'choices':argsDescription[name]['values'], 'labelGridCfg':{'sticky':'w'}, 'labelCfg':{'text':name}, } elif argsDescription.get(name) \ and argsDescription[name]['type']=='FILE' \ and ( argsDescription[name]['ioType']=='INPUT' \ or argsDescription[name]['ioType']=='INOUT'): dtype = 'string' self.widgetDescr[name] = { 'class': 'NEEntryWithFileBrowser', 'initialValue':val, 'labelGridCfg':{'sticky':'w'}, 'labelCfg':{'text':name}, } elif type(val) is types.BooleanType: dtype = 'boolean' self.widgetDescr[name] = { 'class': 'NECheckButton', 'initialValue':val==True, 'labelGridCfg':{'sticky':'w'}, 'labelCfg':{'text':name}, } elif type(val) in [ types.IntType, types.LongType]: dtype = 'int' self.widgetDescr[name] = { 'class': 'NEDial', 'size':50, 'showLabel':1, 'oneTurn':1, 'type':'int', 'initialValue':val, 'labelGridCfg':{'sticky':'w'}, 'labelCfg':{'text':name}, } elif type(val) in [types.FloatType, types.FloatType]: dtype = 'float' self.widgetDescr[name] = { 'class': 'NEDial', 'size':50, 'showLabel':1, 'oneTurn':1, 'type':'float', 'initialValue':val, 'labelGridCfg':{'sticky':'w'}, 'labelCfg':{'text':name}, } elif type(val) is types.StringType: dtype = 'string' self.widgetDescr[name] = { 'class': 'NEEntry', 'width':10, 'initialValue':val, 'labelGridCfg':{'sticky':'w'}, 'labelCfg':{'text':name}, } if argsDescription.get(name): self.widgetDescr[name]['labelBalloon'] = argsDescription[name]['description'] ipdescr.update({'datatype':dtype, 'balloon':'Defaults to '+str(val), 'singleConnection':True}) self.inputPortsDescr.append( ipdescr ) if createPortNow is True: # create port ip = apply( self.addInputPort, (), ipdescr ) # create widget if necessary if dtype != 'None': ip.createWidget(descr=self.widgetDescr[name]) def inSegment( p, s1, s2): ## inSegment(): determine if a point is inside a segment ## Input: a point p, and a collinear segment [s1,s2] ## Return: 1 = P is inside S ## 0 = P is not inside S if s1[0] != s2[0]: # [s1,s2] is not vertical if s1[0]<=p[0] and p[0]<=s2[0]: return True if s1[0]>=p[0] and p[0]>=s2[0]: return True else: # S is vertical, so test y coordinate if s1[1]<=p[1] and p[1]<=s2[1]: return True if s1[1]>=p[1] and p[1]>=s2[1]: return True return False def perp( a ): # return 2D vector orthogonal to a b = [0,0] b[0] = -a[1] b[1] = a[0] return b def seg_intersect(a1, a2, b1, b2) : # line segment a given by endpoints a1, a2 # line segment b given by endpoints b1, b2 # return x,y of intersection of 2 segments or None, None da = (a2[0]-a1[0], a2[1]-a1[1]) db = (b2[0]-b1[0], b2[1]-b1[1]) dp = (a1[0]-b1[0], a1[1]-b1[1]) dap = perp(da) denom = numpy.dot( dap, db) if denom==0.0: return None, None num = numpy.dot( dap, dp ) l = (num / denom) return l*db[0]+b1[0], l*db[1]+b1[1] ## ## Image nodes are node for which the node is represented by an image rendered ## using pycairo and added to the canvas rather than using Tkinter.Canvas ## primitives ## def rotateCoords(center, coords, angle): """ Rotate a list of 2D coords around the center by an angle given in degrees """ cangle = cmath.exp(angle*1j*math.pi/180) offset = complex(center[0], center[1]) rotatedxy = [] for i in range(0, len(coords), 2): v = cangle * (complex(coords[i], coords[i+1]) - offset) + offset rotatedxy.append(v.real) rotatedxy.append(v.imag) return rotatedxy class NodeStyle: """ Class to define the rendering style of a node. Every node has a NodeStyle instance that is used to render the node's image. The VPE has a NodeStylesManager that stores alternate styles for each node """ def __init__(self, **kw): #flowDirection='leftRight' self.rotAngle = 0.0 self.width = None self.height = None self.fillColor = [0.82, 0.88, 0.95, 0.5] self.outlineColor = [0.28, 0.45, 0.6, 1.] self.inputPorts = {} self.iportNumToName = [] # list of names of input ports self.outputPorts = {} self.oportNumToName = [] # list of names of output ports self.configure(**kw) #if flowDirection=='leftRight': # sideIn = 'left' # sideOut = 'right' #elif flowDirection=='topBottom': # sideIn = 'top' # sideOut = 'bottom' #else: # raise RuntimeError, "bad flowDirection" #self.flowDirection = flowDirection def getPortXY(self, descr, node): ulx, uly = node.UL width = node.activeWidth height = node.activeHeight dx, dy = descr.get('ulrpos', (None, None)) if dx is not None: if abs(dx) < 1.0: dx *= width if abs(dy) < 1.0: dy *= height return ulx+dx, uly+dy dx, dy = descr.get('urrpos', (None, None)) if dx is not None: if abs(dx) < 1.0: dx *= width if abs(dy) < 1.0: dy *= height return ulx+width+dx, uly+dy dx, dy = descr.get('llrpos', (None, None)) if dx is not None: if abs(dx) < 1.0: dx *= width if abs(dy) < 1.0: dy *= height return ulx+dx, uly+height+dy dx, dy = descr.get('lrrpos',(None, None)) if dx is not None: if abs(dx) < 1.0: dx *= width if abs(dy) < 1.0: dy *= height return ulx+width+dx, uly+height+dy # fixme .. find a good location for this port return ulx+10, uly def getEdge(self, styleDict): for k,v in styleDict.items(): if k[-4:]=='rpos': found = True break if not found: print 'PORT EDGE NOT FOUND %rpos key missing using "top"', portNum, descr return 'top' if k=='ulrpos': if v[0]==0: return 'left' else: return 'top' elif k=='urrpos': if v[0]==0: return 'right' else: return 'top' elif k=='llrpos': if v[0]==0: return 'left' else: return 'bottom' elif k=='lrrpos': if v[0]==0: return 'right' else: return 'bottom' def setInputPortStyles(self, ipStyles): for name, styleDict in ipStyles: self.iportNumToName.append(name) styleDict['edge'] = self.getEdge(styleDict) self.inputPorts[name] = styleDict def setOutputPortStyles(self, opStyles): for name, styleDict in opStyles: self.oportNumToName.append(name) styleDict['edge'] = self.getEdge(styleDict) self.outputPorts[name] = styleDict def configure(self, **kw): width = kw.get('width', None) if width: if width > 0 and isinstance(width, (int, float)): self.width = width else: print 'WARNING bad width', width, type(width) height = kw.get('height', None) if height: if height > 0 and isinstance(height, (int, float)): self.height = height else: print 'WARNING bad height', height, type(height) rotAngle = kw.get('rotAngle', None) if rotAngle is not None: if isinstance(rotAngle, (int, float)): self.rotAngle = rotAngle else: print 'WARNING bad rotAngle', rotAngle, type(rotAngle) fillColor = kw.get('fillColor', None) if fillColor: if len(fillColor)==3 and isinstance(fillColor[0], float): self.fillColor[:3] = fillColor elif len(fillColor)==4 and isinstance(fillColor[0], float): self.fillColor = fillColor[:] else: print 'WARNING bad fillColor', fillColor, type(fillColor) outlineColor = kw.get('outlineColor', None) if outlineColor: if len(outlineColor)==3 and isinstance(outlineColor[0], float): self.outlineColor[:3] = outlineColor elif len(outlineColor)==4 and isinstance(outlineColor[0], float): self.outlineColor = outlineColor[:] else: print 'WARNING bad outlineColor', outlineColor, type(outlineColor) inputPorts = kw.get('inputPorts', None) if inputPorts: assert isinstance(inputPorts, dict) self.inputPorts = inputPorts.copy() outputPorts = kw.get('outputPorts', None) if outputPorts: assert isinstance(outputPorts, dict) self.outputPorts = outputPorts.copy() iportNumToName = kw.get('iportNumToName', None) if iportNumToName: assert isinstance(iportNumToName, list) self.iportNumToName = iportNumToName[:] oportNumToName = kw.get('oportNumToName', None) if oportNumToName: assert isinstance(oportNumToName, list) self.oportNumToName = oportNumToName[:] def getStyle(self): style = {'width':self.width, 'height':self.height, 'fillColor': self.fillColor, 'outlineColor': self.outlineColor, 'rotAngle': self.rotAngle, 'inputPorts': self.inputPorts, 'iportNumToName' : self.iportNumToName, 'outputPorts': self.outputPorts, 'oportNumToName' : self.oportNumToName, } return style def copy(self): return self.__class__( width = self.width, height = self.height, rotAngle = self.rotAngle, fillColor = self.fillColor[:], outlineColor = self.outlineColor[:], inputPorts = self.inputPorts.copy(), iportNumToName = self.iportNumToName[:], outputPorts = self.outputPorts.copy(), oportNumToName = self.oportNumToName[:] ) def getSize(self): return self.width, self.height def getFillColor(self): return self.fillColor def getOutlineColor(self): return self.outlineColor def getAngle(self): return self.rotAngle class ImageNode(NetworkNode): #def edit(self, event=None): #if self.objEditor: # self.objEditor.top.master.lift() # return #from ImageNodeEditor import ImageNodeEditor #self.objEditor = ImageNodeEditor(self) def saveStylesDefinition(self): # now save style in styles folder from mglutil.util.packageFilePath import getResourceFolderWithVersion sm = self.editor.nodeStylesManager styles = sm.getStylesForNode(self) visionrcDir = getResourceFolderWithVersion() folder = os.path.join(visionrcDir, 'Vision', 'nodeStyles') filename = os.path.join(folder, "%s__%s.py"%( self.library.name.replace('.', '___'), self.__class__.__name__)) f = open(filename, 'w') f.write("styles = {\n") default = styles.get('default', styles.keys()[0]) f.write(" 'default' : '%s',\n"%default) for name, style in styles.items(): if name=='default': continue f.write(" '%s' : %s,\n"%(name, str(style.getStyle()))) f.write(" }\n") f.close() ## def getStylesDefinitionSourceCode(self, indent): ## #'EwSignals_v0.1|EwAmpDelaySignal' : { ## # 'default' : 'square80' ## # 'square80' : {'width':80, 'height':80}, ## # 'small rectangle' : {'width':200, 'height':120}, ## # 'large rectangle' : {'width':300, 'height':240}, ## # }, ## lines = [] ## lines.append(indent+"'%s|%s' : {\n"%(self.library.name, self.__class__.__name__)) ## indent1 = indent + ' ' ## for name, style in self.styles.items(): ## lines.append(indent1+"'%s' : %s,\n"%(name, str(style))) ## lines.append(indent+"},\n") ## return lines def __init__(self, name='NoName', library=None, iconFileName=None, iconPath='', **kw): """ This class implements a NetworkNode that is rendered using a single image generated using pycairo """ constrkw = kw.pop('constrkw', None) NetworkNode.__init__(*(self, name, None, constrkw, None, library, 0), **kw) # posx and posy are upper left corner of BoundingBox(self.innerBox) self.center= [0,0] # coords of node's center in canvas self.rotAngle = 0.0 # keep track of rotation angle self.selectOptions = {} self.deselectOptions = {} self.iconPath = iconPath self.iconFileName = iconFileName # create the node renderer from NetworkEditor.drawNode import CairoNodeRenderer self.renderer = CairoNodeRenderer() self.posx = None # x coord of upper left corner of the node's image self.posy = None # y coord of upper left corner of the node's image self.activeWidth = None # length of not node's box self.activeheight = None # height of not node's box self.UL = (None, None) # offset of upper left corner of box in image # node styles self.nodeStyle = None self.currentNodeStyle = None # None means no predefined style is applied # else it is the name of the style def resize(self, event): self.startDrawingResizeBox(event) def startDrawingResizeBox(self, event): num = event.num self.mouseButtonFlag = self.mouseButtonFlag & ~num canvas = self.network.canvas canvas.configure(cursor="bottom_right_corner") x1, y1, x2, y2 = self.getBoxCorners() self.origx = x1 self.origy = y1 x = canvas.canvasx(event.x) y = canvas.canvasy(event.y) self.hasMoved = 0 canvas.bind(""%num, self.endResizeBox) canvas.bind(""%num, self.resizeBox) self.resizeBoxID = canvas.create_rectangle(x1, y1, x2, y2, outline='green') # function to draw the box def selectionBoxMotion(self, event): self.ResizeBox(event) # call back for motion events def resizeBox(self, event): canvas = self.network.canvas #if self.resizeBoIDx: canvas.delete(self.resizeBoxID) x = canvas.canvasx(event.x) y = canvas.canvasy(event.y) # check if the mouse moved only a few pixels. If we are below a # threshold we assume we did not move. This is usefull for deselecting # nodes for people who don't have a steady hand (who move the mouse # when releasing the mouse button, or when the mouse pad is very soft # and the mouse moves because it is pressed in the pad...) if abs(self.origx-x) < 10 or abs(self.origy-y) < 10: self.hasMoved = 0 else: self.hasMoved = 1 canvas.coords(self.resizeBoxID, self.origx, self.origy, x, y) x1, y1, x2, y2 = canvas.bbox(self.resizeBoxID) self.nodeStyle.configure(width=x2-x1, height=y2-y1) self.boxCorners = self.getBoxCorners() self.redrawNode() #print 'ORIG2', self.origx, self.origy, x, y, canvas.bbox(self.resizeBoxID) # callback for ending command def endResizeBox(self, event): canvas = self.network.canvas canvas.configure(cursor="") x1, y1, x2, y2 = canvas.bbox(self.resizeBoxID) width = self.activeWidth = x2-x1 height = self.activeHeight = y2-y1 self.nodeStyle.configure(width=width, height=y2-y1) self.redrawNode() canvas.delete(self.resizeBoxID) num = event.num self.mouseButtonFlag = self.mouseButtonFlag & ~num canvas.unbind(""%num) canvas.unbind(""%num) del self.origx del self.origy del self.resizeBoxID self.currentNodeStyle = None # set the a style name that is a key in # ed.nodeStylesManager.styles OR set to None when the style is modified # but not saved as a style def getNodeDefinitionSourceCode(self, networkName, indent="", ignoreOriginal=False): self.nameInSavedFile = self.getUniqueNodeName() # specialize this method to save the the system configuration lines = NetworkNode.getNodeDefinitionSourceCode( self, networkName, indent=indent, ignoreOriginal=ignoreOriginal) # save node rotation if self.rotAngle !=0.0: lines.append( indent + '%s.rotate(%f)\n'%( self.nameInSavedFile, self.rotAngle)) from NetworkEditor.macros import MacroNetwork if isinstance(self.network, MacroNetwork): if hasattr(self.network.macroNode, 'nameInSavedFile') and \ self.network.macroNode.nameInSavedFile: # we are saving the macro name = "%s.macroNetwork.nodes[%d]"%( self.network.macroNode.nameInSavedFile, # <- this break copy of network in macro self.network.nodeIdToNumber(self._id)) else: # we are copying the network in a macro name = self.nameInSavedFile else: name = self.nameInSavedFile if self.currentNodeStyle: # we have a predefined style lines.append( indent + '%s.setStyle("%s")\n'%( name, self.currentNodeStyle)) else: # the style is modified but not saved as a template lines.append( indent + 'nodeStyle = %s\n'%self.nodeStyle.getStyle()) lines.append( indent + '%s.nodeStyle.configure(**nodeStyle)\n'%( name)) return lines def autoResizeX(self): return def drawMapIcon(self, naviMap): canvas = naviMap.mapCanvas x0, y0 = naviMap.upperLeft scaleFactor = naviMap.scaleFactor c = self.getBoxCorners() cid = canvas.create_rectangle( [x0+c[0]*scaleFactor, y0+c[1]*scaleFactor, x0+c[2]*scaleFactor, y0+c[3]*scaleFactor], fill='grey50', outline='black', tag=('navimap',)) ## import Image ## im = self.imShadow1 ## self.scaledImage = im.resize((int(im.size[0]*scaleFactor), ## int(im.size[1]*scaleFactor)), Image.ANTIALIAS) ## self.mapImagetk = ImageTk.PhotoImage(image=self.scaledImage) ## cid = canvas.create_image( x0+self.posx*scaleFactor, y0+self.posy*scaleFactor, ## image=self.mapImagetk) self.naviMapID = cid return cid def deleteIcon(self): NetworkNode.deleteIcon(self) if hasattr(self, 'imagetk'): del self.imagetk # else the selected rendered node remains if hasattr(self, 'imagetkRot'): del self.imagetkRot # else the selected rendered node remains if hasattr(self, 'imagetkSel'): del self.imagetkSel # else the selected rendered node remains if hasattr(self, 'imagetkSelRot'): del self.imagetkSelRot # else the selected rendered node remains def select(self): canvas = self.iconMaster tags = canvas.itemcget(self.id, 'tags').split() NetworkNode.select(self) canvas.itemconfigure(self.innerBox, tags=tags+['selected'], image = self.imagetkSelRot) def deselect(self): canvas = self.iconMaster tags = canvas.itemcget(self.id, 'tags').split() NetworkNode.deselect(self) canvas.itemconfigure(self.innerBox, tags=tags, image = self.imagetkRot) canvas.dtag(self.innerBox,'selected') def getColor(self): return (0.82, 0.88, 0.95, 0.5) def setColor(self, color): return def pickedComponent(self, x, y): xr = x - self.posx-self.shadowOffset[0] # x relative to image upper left corner yr = y - self.posy-self.shadowOffset[1] # y relative to image upper left corner # check if the (x,y) is the position of an input port for p in self.inputPorts: px, py = p.posRotated dx = abs(xr-px) dy = abs(yr-py) if dx<10 and dy<10: return p, 'input' # check if the (x,y) is the position of an output port for p in self.outputPorts: px, py = p.posRotated dx = abs(xr-px) dy = abs(yr-py) if dx<10 and dy<10: return p, 'output' # check if we clicked inside the node p1x, p1y, p2x, p2y = self.boxCorners #self.network.canvas.create_rectangle(p1x, p1y, p2x, p2y, outline='blue') angle = self.rotAngle if angle !=0.0: # unrotate the (x,y) point cx, cy = self.nodeCenter[0]+self.posx, self.nodeCenter[1]+self.posy x, y = rotateCoords((cx,cy), [x, y], angle) #self.network.canvas.create_rectangle(x-2, y-2, x+2, y+2, outline='red') if (x>=p1x and x<=p2x) and (y>=p1y and y<=p2y): # check if we picked resize handle #if (x-p1x<10 and y-p1y<10): # print 'UL resize' # return self, 'resize UL' if (p2x-x<10 and p2y-y<10): return self, 'resize' return self, 'node' return None, None def buildIcons(self, canvas, posx, posy, small=False): """Build NODE icon with ports etc""" NetworkNode.buildIcons(self, canvas, posx, posy, small) # add node editing menu entries self.menu.add_separator() self.menu.add_command(label='Rotate', command=self.rotate_cb) #self.menu.add_command(label='Resize', command=self.resize) self.stylesMenuTK = Tkinter.StringVar() self.stylesMenu = Tkinter.Menu(self.menu, tearoff=0, postcommand=self.fillStyleMenu) self.menu.add_cascade(label="styles", menu=self.stylesMenu) def fillStyleMenu(self, event=None): self.stylesMenu.delete(0, 'end') self.stylesMenu.add_command(label="Save As ...", command=self.saveStyle) self.stylesMenu.add_command(label="Set as Default", command=self.setDefaultStyle, state='disabled') self.stylesMenu.add_separator() self.stylesMenu.add_radiobutton( label='auto', variable=self.stylesMenuTK, command=self.setStyle_cb, value='auto') sm = self.editor.nodeStylesManager styles = sm.getStylesForNode(self) if styles: for name, style in styles.items(): if name=='default': continue self.stylesMenu.add_radiobutton( label=name, variable=self.stylesMenuTK, command=self.setStyle_cb, value=name) if self.currentNodeStyle: self.stylesMenuTK.set(self.currentNodeStyle) if self.currentNodeStyle: # enable Set as Default menu entry self.stylesMenu.entryconfigure(1, state='normal') else: self.stylesMenuTK.set('') def setDefaultStyle(self): name = self.stylesMenuTK.get() self.editor.nodeStylesManager.setDefault(self, name) self.saveStylesDefinition() def setStyle_cb(self): name = self.stylesMenuTK.get() self.setStyle(name) def setStyle(self, name): if name == 'auto': self.currentNodeStyle = 'auto' else: sm = self.editor.nodeStylesManager styles = sm.getStylesForNode(self) self.nodeStyle.configure( **styles[name].getStyle() ) self.currentNodeStyle = name self.redrawNode() def _saveStyle(self, result): #self.askNameWidget.withdraw() self.askNameWidget.deactivate() if result == 'OK':# or hasattr(result, "widget"): name = self.askNameWidget.get() style = self.nodeStyle.getStyle() sm = self.editor.nodeStylesManager sm.addStyle(self, name, NodeStyle(**style)) self.currentNodeStyle = name self.saveStylesDefinition() def saveStyle(self): master = self.editor.root w = Pmw.PromptDialog( master, title = 'style name', label_text = "Enter the name for this style", entryfield_labelpos = 'n', buttons = ('OK', 'Cancel'), command=self._saveStyle) sm = self.editor.nodeStylesManager styles = sm.getStylesForNode(self) if styles: nb = len(styles)+1 else: nb = 1 w.insertentry(0, "custom%d"%nb) w.component('entry').selection_range(0, Tkinter.END) w.component('entry').focus_set() w.component('entry').bind('', self._saveStyle) w.geometry( '+%d+%d' % (master.winfo_x()+200, master.winfo_y()+200)) self.askNameWidget = w w.activate() def drawNode(self, sx, sy, line, fill, macro, padding): renderer = self.renderer # render the node shape renderer.makeNodeImage(sx, sy, line, fill, macro) self.UL = list(renderer.ul) # add ports #ip = self.inputPortsDescr #for pn in range(len(ip)): # # find the position in image # x, y , size, vector, line, fill, outline, label = ip.getDrawingParams( # pn, self) #print 'ZZZZZZZZZZ', self.nodeStyle.iportNumToName ## def drawInputPort(port, portStyle): ## port.vector = portStyle['vector'] ## port.vectorRotated = portStyle['vector'] ## x, y = self.nodeStyle.getPortXY(portStyle, self) ## renderer.drawPort('in', x, y, portStyle) ## port.posRotated = [x,y] ## port.pos = (x,y) ## if macro: ## pn = 0 ## for op in self.macroNetwork.ipNode.outputPorts[1:]: ## ip = op.connections[0].port2 ## node = ip.node ## portStyle = node.nodeStyle.inputPorts[ip.name] ## print 'Drawing macro input', ip.name, portStyle ## drawInputPort(ip, portStyle) ## else: ## for pn, portName in enumerate(self.nodeStyle.iportNumToName): ## if not self.widgetDescr.has_key(portName): ## portStyle = self.nodeStyle.inputPorts[portName] ## port = self.inputPorts[pn] ## drawInputPort(port, portStyle) for pn, portName in enumerate(self.nodeStyle.iportNumToName): portStyle = self.nodeStyle.inputPorts[portName] port = self.inputPorts[pn] port.vector = portStyle['vector'] port.vectorRotated = portStyle['vector'] x, y = self.nodeStyle.getPortXY(portStyle, self) #edge = op[pn]['edge'] #renderer.drawPort('out', x, y, size, vector, line, fill, outline, label, edge) renderer.drawPort('in', x, y, portStyle) port.posRotated = [x,y] port.pos = (x,y) #op = self.outputPortsDescr #for pn in range(len(op)): # # find the position # x, y, size, vector, line, fill, outline, label = op.getDrawingParams( # pn, self) # #print 'DRAWNODE1', self.name, pn, vector for pn, portName in enumerate(self.nodeStyle.oportNumToName): portStyle = self.nodeStyle.outputPorts[portName] port = self.outputPorts[pn] port.vector = portStyle['vector'] port.vectorRotated = portStyle['vector'] x, y = self.nodeStyle.getPortXY(portStyle, self) #edge = op[pn]['edge'] #renderer.drawPort('out', x, y, size, vector, line, fill, outline, label, edge) renderer.drawPort('out', x, y, portStyle) port.posRotated = [x,y] port.pos = (x,y) renderer.drawLabel(self.name, padding) if self.iconFileName: filename = os.path.join(self.iconPath, self.iconFileName) renderer.drawIcon(filename) def getDefaultPortsStyleDict(self): ipStyles = [] # count visible ports ct = 0 for p in self.inputPortsDescr: if not self.widgetDescr.has_key(p['name']): ct += 1 incr = 1.0/(ct+1) for n, pd in enumerate(self.inputPortsDescr): ipStyles.append( (pd['name'], { 'ulrpos':((n+1)*incr,0), 'vector':(0,1), 'size':15, 'fill':(1,1,1,1), 'line':(0.28, 0.45, 0.6, 1.), 'edge':'top', 'outline':(0.28, 0.45, 0.6, 1.), 'label':pd['name'], })) opStyles = [] incr = 1.0/(len(self.outputPortsDescr)+1) for n, pd in enumerate(self.outputPortsDescr): opStyles.append( (pd['name'], { 'llrpos':((n+1)*incr,0), 'vector':(0,-1), 'size':15, 'fill': (1,1,1,1), 'line':(0.28, 0.45, 0.6, 1.), 'edge':'bottom', 'outline':(0.28, 0.45, 0.6, 1.), 'label':pd['name'], })) return ipStyles, opStyles def computeDefaultNodeSize(self): renderer = self.renderer ## compute the size needed for the node # get size of label x_bearing, y_bearing, width, height = renderer.getLabelSize(self.name) iconwidth = iconheight = 0 if self.iconFileName: iconwidth = 20 iconheight = 20 - 10 # -10 is minus the port label height width += iconwidth height += iconheight # here we compute how much space we need around the label for port icons and labels # port label are written using "Sans', size 10 which is 8 pixels heigh # for now we add 10 above the label and 10 below for the label # then we add maxPortSize / 2 above and below for the ports glyph # on the sides we will all the max of the port label length + 4 + max port glyph / 2 maxPortSize = 0 if self.iconFileName: maxPortLabLen = {'left':10, 'right':0, 'top':0, 'bottom':0} maxPortLabHeight = {'left':0, 'right':0, 'top':10, 'bottom':0} else: maxPortLabLen = {'left':0, 'right':0, 'top':0, 'bottom':0} maxPortLabHeight = {'left':0, 'right':0, 'top':0, 'bottom':0} sumPortLabLenTop = 0.0 sumPortLabLenBottom = 0.0 for pn, port in enumerate(self.inputPorts): if self.widgetDescr.has_key(port.name): continue pd = self.nodeStyle.inputPorts[port.name] edge = pd['edge'] size = pd['size'] label = pd['label'] if size > maxPortSize: maxPortSize=size if label: x_b, y_b, w, h = renderer.getLabelSize(label, 'Sans', size=10) if edge=='top': sumPortLabLenTop += w+10 elif edge=='bottom': sumPortLabLenBottom += w+10 if w > maxPortLabLen[edge]: maxPortLabLen[edge] = w if h > maxPortLabHeight[edge]: maxPortLabHeight[edge] = h for pn, port in enumerate(self.outputPorts): pd = self.nodeStyle.outputPorts[port.name] edge = pd['edge'] size = pd['size'] label = pd['label'] if size > maxPortSize: maxPortSize=size if label: x_b, y_b, w, h = renderer.getLabelSize(label, 'Sans', size=10) if edge=='top': sumPortLabLenTop += w+10 elif edge=='bottom': sumPortLabLenBottom += w+10 if w > maxPortLabLen[edge]: maxPortLabLen[edge] = w if h > maxPortLabHeight[edge]: maxPortLabHeight[edge] = h pady = maxPortLabHeight['top'] + maxPortLabHeight['bottom'] + maxPortSize + 2*8 padx = maxPortLabLen['left'] + maxPortLabLen['right'] + maxPortSize + 2*8 padding = { 'left': max(5, maxPortLabLen['left']), 'right': max(5, maxPortLabLen['right']), 'top': max(5, maxPortLabHeight['top']), 'bottom': max(5, maxPortLabHeight['bottom']) } sx = max( max(width, sumPortLabLenTop, sumPortLabLenBottom) + iconwidth + 2*8, max(maxPortLabLen['bottom'], maxPortLabLen['top'], )) sy = height+pady #print 'GGGGG', maxPortSize, maxPortLabLen, maxPortLabHeight, width, height, padx, pady, sx, sy return sx, sy, padding def makeNodeImage(self, canvas, posx, posy): renderer = self.renderer if self.nodeStyle is None: # no styles defined. Happens when we first # click on a node in the tree #print 'NO NodeStyle', self.library if self.library is not None: color1 = self.library.fillColor color2 = self.library.outlineColor else: color1 = '#FFFFFF' color2 = '#AAAAAA' fillColor = [float(x)/256**2 for x in self.iconMaster.winfo_rgb(color1)] outlineColor = [float(x)/256**2 for x in self.iconMaster.winfo_rgb(color2)] sm = self.editor.nodeStylesManager stylesDict = sm.getStylesForNode(self) if stylesDict is None or stylesDict['default']=='auto': # no style available for this class #print ' no style dict' # create node Style because it will be used in computeDefaultNodeSize self.nodeStyle = style = NodeStyle( width=200, height=200, fillColor=fillColor, outlineColor=outlineColor) ipStyles, opStyles = self.getDefaultPortsStyleDict() style.setInputPortStyles(ipStyles) style.setOutputPortStyles(opStyles) sx, sy, padding = self.computeDefaultNodeSize() style.configure(width=sx, height=sy) #self.currentNodeStyle = None #'auto' self.currentNodeStyle = 'auto' else: #print ' with style dict' default = stylesDict['default'] style = stylesDict[default].copy() self.currentNodeStyle = default self.nodeStyle = style sx, sy, padding = self.computeDefaultNodeSize() elif self.currentNodeStyle == 'auto': #print 'Auto NodeStyle' # call to compute padding sx, sy, padding = self.computeDefaultNodeSize() style = self.nodeStyle = NodeStyle(width=sx, height=sy) ipStyles, opStyles = self.getDefaultPortsStyleDict() style.setInputPortStyles(ipStyles) style.setOutputPortStyles(opStyles) else: #print 'WITH NodeStyle' # call to compute padding sx, sy, padding = self.computeDefaultNodeSize() sx, sy = self.nodeStyle.getSize() self.activeWidth = sx self.activeHeight = sy # render the node shape fill = self.nodeStyle.getFillColor() line = self.nodeStyle.getOutlineColor() rotAngle = self.nodeStyle.getAngle() #print 'ANGLE', self.nodeStyle.getAngle() from NetworkEditor.macros import MacroImageNode macro = isinstance(self, MacroImageNode) # draw the node self.drawNode(sx, sy, line, fill, macro, padding) image = renderer.getPilImage() self.imShadow1, offset = renderer.addDropShadow() self.shadowOffset = offset #self.imShadow1 = image self.imagetk = ImageTk.PhotoImage(image=self.imShadow1) self.imagetkRot = self.imagetk self.imwidth = self.imagetk.width() self.imheight = self.imagetk.height() self.boxCorners = self.getBoxCorners() # assign ports posx and posy for port in self.inputPorts+self.outputPorts: x,y = port.pos port.posx = posx + self.shadowOffset[0] + x port.posy = posy + self.shadowOffset[0] + y canvas.itemconfigure(self.innerBox, image=self.imagetk) # draw image outline #bb = canvas.bbox(self.innerBox) #canvas.create_rectangle(*bb, outline='black') ## this could be used to render selected nodes # draw rectangle around node image bbox ## x1, y1, x2, y2 = renderer.bbox ## self.nodeOutline = canvas.create_rectangle( ## x1+posx, y1+posy, x2+posx, y2+posy, fill='yellow', ## outline='yellow', tags=(self.iconTag,'node')) ## build an image with yellow background for selected state fill = (1., 1, 0., 0.5) line = (0.28, 0.45, 0.6, 1.) self.drawNode(sx, sy, line, fill, macro, padding) self.imShadow2, offset = renderer.addDropShadow() #self.imShadow2 = image self.imagetkSel = ImageTk.PhotoImage(image=self.imShadow2) self.imagetkSelRot = self.imagetkSel bb = canvas.bbox(self.innerBox) self.nodeCenter = (bb[2]-bb[0])*.5, (bb[3]-bb[1])*.5 #self.nodeCenter = (sx*.5, sy*.5) #print 'ROTATE', rotAngle, self.rotAngle self.rotate(rotAngle) def buildNodeIcon(self, canvas, posx, posy, small=False): renderer = self.renderer self.iconMaster = canvas # set posx, posy self.posx = posx self.posy = posy self.innerBox = canvas.create_image( posx, posy, anchor=Tkinter.NW, # image=self.imagetk, tags=(self.iconTag,'node')) self.makeNodeImage(canvas, posx, posy) self.outerBox = self.innerBox bb = canvas.bbox(self.innerBox) #print 'NODE IMAGE BBOX', bb, posx, posy, self.UL, self.activeWidth, self.activeHeight, self.shadowOffset # draw node's image bounding box #canvas.create_rectangle( # *bb, fill='', outline='yellow', tags=(self.iconTag,'node')) # draw node's box bounding box #canvas.create_rectangle( # bb[0]+self.UL[0]+self.shadowOffset[0], # bb[1]+self.UL[1]+self.shadowOffset[1], # bb[0]+self.UL[0]+self.shadowOffset[0]+self.activeWidth, # bb[1]+self.UL[1]+self.shadowOffset[1]+self.activeHeight, # fill='', outline='green', tags=(self.iconTag,'node')) #self.nodeCenter = (bb[2]-bb[0])*.5, (bb[3]-bb[1])*.5 self.textId = self.innerBox self.id = self.innerBox # used to build network.nodesById used for picking self.iconTag = 'node'+str(self.textId) # used in node.select #if self.network is not None: # self.move(posx, posy) self.hasMoved = False # reset this attribute because the current # position is now the original position ## ## functions used to rotate Nodes ## def rotateRelative(self, angle): canvas = self.iconMaster self.rotAngle = (self.rotAngle + angle)%360 # center of unrotated image cx, cy = self.nodeCenter # rotate node images imShadowRotated = self.imShadow1.rotate( self.rotAngle, Image.BICUBIC, expand=1) self.imagetkRot = ImageTk.PhotoImage(image=imShadowRotated) imShadowRotated = self.imShadow2.rotate( self.rotAngle, Image.BICUBIC, expand=1) self.imagetkSelRot = ImageTk.PhotoImage(image=imShadowRotated) canvas.itemconfigure(self.innerBox, image=self.imagetkRot) bb = canvas.bbox(self.innerBox) #bb = self.boxCorners rcx, rcy = (bb[2]-bb[0])*.5, (bb[3]-bb[1])*.5 canvas.coords(self.innerBox, self.posx+cx-rcx, self.posy+cy-rcy) # rotate input ports # node center in canvas coordinate system cx = self.posx + self.nodeCenter[0] cy = self.posy + self.nodeCenter[1] # node uper left corner in canvas coordinate system offx = self.posx+self.shadowOffset[0] offy = self.posy+self.shadowOffset[1] for p in self.inputPorts: hpx = p.pos[0]+offx hpy = p.pos[1]+offy hpxr, hpyr = rotateCoords( (cx, cy), (hpx, hpy), -self.rotAngle) p.posRotated = (hpxr-offx, hpyr-offy) # display hotspots #canvas.create_rectangle(hpxr-5, hpyr-5, hpxr+5, hpyr+5) a,b,c,d = rotateCoords( (cx, cy), (0, 0, p.vector[0], p.vector[1]), self.rotAngle) p.vectorRotated = [c-a, d-b] # rotate output ports for p in self.outputPorts: hpx = p.pos[0]+offx hpy = p.pos[1]+offy hpxr, hpyr = rotateCoords( (cx, cy), (hpx, hpy), -self.rotAngle) p.posRotated = (hpxr-offx, hpyr-offy) # draw rectangel on hotspot for debuging #canvas.create_rectangle(hpxr-5, hpyr-5, hpxr+5, hpyr+5) a,b,c,d = rotateCoords( (cx, cy), (0, 0, p.vector[0], p.vector[1]), self.rotAngle) p.vectorRotated = [c-a, d-b] #print p.vector, a,b,c,d, p.vectorRotated def rotate(self, absoluteAngle): angle = absoluteAngle-self.rotAngle self.rotateRelative(angle) def rotate_cb(self): canvas = self.iconMaster bb = canvas.bbox(self.innerBox) # posx and pos y are upper left corner # self.nodeCenter is center of node relative to posx, posy cx = self.posx+self.nodeCenter[0] cy = self.posy+self.nodeCenter[1] rad = 0.5*max(bb[2]-bb[0], bb[1]-bb[0])+10 #draw a circle with an arrow to indicate node rotation mode arcid = canvas.create_oval( cx-rad, cy-rad, cx+rad, cy+rad, outline='green', width=2.0, tags=('arc',)) self._arcid = arcid canvas.tag_bind(arcid, "", self.startRotate_cb) def startRotate_cb(self, event=None): canvas = self.iconMaster self._x0 = canvas.canvasx(event.x) - self.posx - self.nodeCenter[0] self._y0 = canvas.canvasy(event.y) - self.posy - self.nodeCenter[1] #self._deltaAngle = 0 canvas.itemconfigure(self._arcid, outline='red') canvas.tag_bind(self._arcid, "", self.moveToRotate_cb) canvas.tag_bind(self._arcid, "", self.endRotate_cb) #self._lineid = canvas.create_line( # self.posx + self.nodeCenter[0], self.posy + self.nodeCenter[1], # canvas.canvasx(event.x), canvas.canvasy(event.y), # fill='green', width=2.0, tags=('arc',)) self._textid = canvas.create_text( canvas.canvasx(event.x)+10, canvas.canvasy(event.y)-10, text='%d'%self.rotAngle, fill='black', tags=('arc',)) def fullAngle(self, x0, y0, x1, y1): n0 = math.sqrt(x0*x0 + y0*y0) n1 = math.sqrt(x1*x1 + y1*y1) x0 = x0/n0 y0 = y0/n0 x1 = x1/n1 y1 = y1/n1 tetha = math.acos( (x0*x1 + y0*y1)) if x0*y1-y0*x1 > 0: return math.degrees(tetha) else: return math.degrees(2*math.pi-tetha) def moveToRotate_cb(self, event=None): canvas = self.iconMaster x1 = canvas.canvasx(event.x) - self.posx - self.nodeCenter[0] y1 = canvas.canvasy(event.y) - self.posy - self.nodeCenter[1] #canvas.coords( # self._lineid, self.posx + self.nodeCenter[0], # self.posy + self.nodeCenter[1], # canvas.canvasx(event.x), canvas.canvasx(event.y)) angle = self.fullAngle(self._x0, -self._y0, x1, -y1) self.rotate(15*int(angle/15)) canvas.itemconfigure(self._textid, text='%d'%self.rotAngle) canvas.coords(self._textid, canvas.canvasx(event.x)+10, canvas.canvasx(event.y)-10) for p in self.inputPorts: for c in p.connections: c.updatePosition() for p in self.outputPorts: for c in p.connections: c.updatePosition() def endRotate_cb(self, event=None): canvas = self.iconMaster self.iconMaster.delete('arc') self.nodeStyle.configure(rotAngle=self.rotAngle) self.currentNodeStyle = None # set the a style name that is a key in del self._arcid del self._x0 del self._y0 def updatePosXPosY(self, dx, dy): """set node.posx and node.posy after node has been moved""" self.posx += dx self.posy += dy self.boxCorners = self.getBoxCorners() def getBoxCorners(self): dx, dy = self.UL sx, sy = self.shadowOffset p1x, p1y = self.posx + dx + sx, self.posy + dy + sy, p2x = self.posx + dx + sx + self.activeWidth p2y = self.posy + dy + sy + self.activeHeight return p1x, p1y, p2x, p2y ## ## functions used to move ports ## def segmentIntersection(self, p0, p1): canvas = self.iconMaster # center of unrotated image cx, cy = self.nodeCenter[0]+self.posx, self.nodeCenter[1]+self.posy p1x, p1y, p2x,p2y = self.boxCorners coords = (p1x, p1y, p2x, p1y, p2x, p2y, p1x, p2y, p1x, p1y) # rotate coords of the box box coords = rotateCoords((cx,cy), coords, -self.rotAngle) l = len(coords) for i in range(0, l, 2): p2 = (coords[i], coords[i+1]) p3 = (coords[(i+2)%l], coords[(i+3)%l]) xi, yi = seg_intersect(p0, p1, p2, p3) inSegment( (xi, yi), p2, p3) if inSegment( (xi, yi), p0, p1) and inSegment( (xi, yi), p2, p3): #print 'intersection with edge', i, p0, p1, p2, p3, xi, yi return xi,yi return None, None def movePortTo(self, port, x, y): # x.y are absolute coordinates on the canvas and are expected to be # on the node's box outline # # x and y are potentially on the rotated shape of the box # we undo the rotation to set the port description, re-create the image # and rotate the node #print 'MOVE PORT TO', x, y angle = self.rotAngle if angle !=0.0: # unrotate the (x,y) point cx, cy = self.nodeCenter[0]+self.posx, self.nodeCenter[1]+self.posy x, y = rotateCoords((cx,cy), [x,y], self.rotAngle) # find the port's style description from ports import ImageInputPort, ImageOutputPort if isinstance(port, ImageInputPort): name = self.nodeStyle.iportNumToName[port.number] pd = self.nodeStyle.inputPorts[name] else: name = self.nodeStyle.oportNumToName[port.number] pd = self.nodeStyle.outputPorts[name] #print 'BEFORE', pd # now remove the **rpos entry for k,v in pd.items(): if k[-4:]=='rpos': print k, pd[k] del pd[k] width = float(self.activeWidth) height = float(self.activeHeight) p1x, p1y, p2x, p2y = self.getBoxCorners() #print p1x, p1y, p2x, p2y if abs(x-p1x)<2: # left edge pd['ulrpos'] = (0, (y-p1y)/height) pd['vector'] = (-1, 0) #print 'ulrpos1', (x-p1x, y-p1y) elif abs(x-p2x)<2: # right edge pd['lrrpos'] = (0, (y-p2y)/height) pd['vector'] = (1, 0) #print 'lrrpos2', (x-p2x, y-p2y) elif abs(y-p1y)<2: # top edge pd['ulrpos'] = ((x-p1x)/width, 0) pd['vector'] = (0, 1) #print 'ulrpos1', (x-p1x, y-p1y), vector elif abs(y-p2y)<2: # bottom edge pd['lrrpos'] = ((x-p2x)/width, 0) pd['vector'] = (0, -1) #print 'lrrpos2', (x-p2x, y-p2y) else: print "ERROR: edge not found", x, y, p1x, p1y, p2x, p2y pd['edge'] = self.nodeStyle.getEdge(pd) #print 'AFTER', id(pd), pd self.rotate(angle) self.redrawNode() port._hasMoved = True def rename(self, name, tagModified=True): """Rename a node. remember the name has changed, resize the node if necessary""" if name == self.name or name is None or len(name)==0: return # if name contains ' " remove them name = name.replace("'", "") name = name.replace('"', "") self.name=name self.redrawNode() if tagModified is True: self._setModified(True) def redrawNode(self): self.makeNodeImage(self.iconMaster, self.posx, self.posy) # update all connections for port in self.inputPorts+self.outputPorts: for c in port.connections: if c.id: c.updatePosition() def movePortToRelativeLocation(self, port, corner, dx, dy): # move a port to a position relative to one of its corners # corner can be ul, ll, ur, or lr string # dx, dy are relative displacements from the corner point p1x, p1y, p2x,p2y = self.boxCorners if corner=='ul': cornerx, cornery = p1x, p1y elif corner=='ll': cornerx, cornery = p1x, p2y elif corner=='ur': cornerx, cornery = p2x, p1y elif corner=='lr': cornerx, cornery = p2x, p2y self.movePortTo(port, cornerx+dx, cornery+dy) def movePortToRelativePos(self, port, corner, edge, percentx, percenty): # move a port to a position specified by a corner and a percent of edge length angle = self.rotAngle if angle !=0.0: # unrotate the (x,y) point cx, cy = self.nodeCenter[0]+self.posx, self.nodeCenter[1]+self.posy x, y = rotateCoords((cx,cy), [x,y], self.rotAngle) # find the port's style description from ports import ImageInputPort, ImageOutputPort if isinstance(port, ImageInputPort): name = self.nodeStyle.iportNumToName[port.number] pd = self.nodeStyle.inputPorts[name] else: name = self.nodeStyle.oportNumToName[port.number] pd = self.nodeStyle.outputPorts[name] ## # find the port's description ## found = False ## for p, pd in zip(self.inputPorts, self.inputPortsDescr): ## if p==port: ## found = True ## break ## if not found: ## for p, pd in zip(self.outputPorts, self.outputPortsDescr): ## if p==port: ## found = True ## break # now remove the **rpos entry for k,v in pd.items(): if k[-4:]=='rpos': del pd[k] p1x, p1y, p2x,p2y = self.boxCorners width = p2x-p1x height = p2y-p1y if corner=='ul': pd['ulrpos'] = (percentx, percenty) elif corner=='ll': pd['llrpos'] = (percentx, percenty) elif corner=='ur': pd['urrpos'] = (percentx, percenty) elif corner=='lr': pd['lrrpos'] = (percentx, percenty) if edge=='left': pd['vector'] = (-1, 0) elif edge=='right': pd['vector'] = (1, 0) elif edge=='top': pd['vector'] = (0, 1) elif edge=='bottom': pd['vector'] = (0, -1) self.makeNodeImage(self.iconMaster, self.posx, self.posy) self.rotate(angle) # update all connections for p in self.inputPorts+self.outputPorts: for c in p.connections: if c.id: c.updatePosition() port._hasMoved = True #n = WarpIV.ed.currentNetwork.nodes[0] class ImageDataNode(ImageNode): """ Subclass ImageNode to render a node as a circle with an input at the top and an output at the bottom (use for WarpIV data """ def drawMapIcon(self, naviMap): canvas = naviMap.mapCanvas x0, y0 = naviMap.upperLeft scaleFactor = naviMap.scaleFactor c = self.getBoxCorners() cid = canvas.create_rectangle( [x0+c[0]*scaleFactor, y0+c[1]*scaleFactor, x0+c[2]*scaleFactor, y0+c[3]*scaleFactor], fill='grey50', outline='black', tag=('navimap',)) ## import Image ## im = self.imShadow1 ## self.scaledImage = im.resize((int(im.size[0]*scaleFactor), ## int(im.size[1]*scaleFactor)), Image.ANTIALIAS) ## self.mapImagetk = ImageTk.PhotoImage(image=self.scaledImage) ## cid = canvas.create_image( x0+self.posx*scaleFactor, y0+self.posy*scaleFactor, ## image=self.mapImagetk) self.naviMapID = cid return cid def getDefaultPortsStyleDict(self): ipStyles = [] ipStyles.append( ('name', { 'ulrpos':(0.1,0), 'vector':(0,1), 'size':15, 'fill':(1,1,1,1), 'line':(0.28, 0.45, 0.6, 1.), 'edge':'top', 'outline':(0.28, 0.45, 0.6, 1.), 'label':'name', })) ipStyles.append( ('value', { 'ulrpos':(0.5,0), 'vector':(0,1), 'size':15, 'fill':(1,1,1,1), 'line':(0.28, 0.45, 0.6, 1.), 'edge':'top', 'outline':(0.28, 0.45, 0.6, 1.), 'label':'value', })) opStyles = [] opStyles.append( ('output1', { 'llrpos':(0.5,0), 'vector':(0,-1), 'size':15, 'fill': (1,1,1,1), 'line':(0.28, 0.45, 0.6, 1.), 'edge':'bottom', 'outline':(0.28, 0.45, 0.6, 1.), 'label':'output1', })) return ipStyles, opStyles def drawNode(self, sx, sy, line, fill, macro, padding): renderer = self.renderer self.activeWidth = sx self.activeHeight = sy border = renderer.border renderer.makeCircleNodeImage(sx, sy, line, fill, macro) self.UL = list(renderer.ul) port = self.inputPorts[1] # only draw second port for value portStyle = self.nodeStyle.inputPorts[port.name] port.vector = portStyle['vector'] port.vectorRotated = portStyle['vector'] x, y = self.nodeStyle.getPortXY(portStyle, self) #print 'ZZZZZZZ', x, y, border+sx*.5 #x, y = border+sx*.5, border+portStyle.get('size', 10)*.5 portStyle['label'] = None renderer.drawPort('in', x, y, portStyle) port.posRotated = [x,y] port.pos = (x,y) port = self.outputPorts[0] portStyle = self.nodeStyle.outputPorts[self.outputPorts[0].name] port.vector = portStyle['vector'] port.vectorRotated = portStyle['vector'] x, y = self.nodeStyle.getPortXY(portStyle, self) #x, y = border+sx*.5, border+sy-portStyle.get('size', 10)*.5 portStyle['label'] = None renderer.drawPort('out', x, y, portStyle) port.posRotated = [x,y] port.pos = (x,y) padding = {'left':5, 'top':0, 'right':5, 'bottom':5} renderer.drawLabel(self.name, padding)