gui.graph.Graph Class Reference

Public Member Functions
def	__init__ (self, item, parent)
def	createGraph (self)
def	addLink (self, link)
def	addItem (self, item)
def	selectItem (self, item)
def	layout (self, rankdir)
def	clearLinks (self)
def	orthoLinks (self)

Public Attributes
	parent
	item
	node
	canvas
	editor
	citems

Detailed Description

Definition at line 40 of file graph.py.

Constructor & Destructor Documentation

__init__()

def gui.graph.Graph.__init__	(		self,
			item,
			parent
	)

Definition at line 41 of file graph.py.

  def __init__(self,item,parent):
    self.parent=parent
    self.item=item
    self.node=item.node
    #initial canvas size : 1000x1000
    self.canvas=MyCanvas(1000,1000)
    self.editor=GraphViewer(self.canvas,parent,"example",0)
    self.createGraph()
    root=self.node.getRootNode()
    rootItem=Item.adapt(root)
    CONNECTOR.Connect(rootItem,"selected",self.selectItem,())
    CONNECTOR.Connect(self.item,"add",self.addItem,())
    CONNECTOR.Connect(self.item.datalinks,"add",self.addLink,())
 

Member Function Documentation

addItem()

def gui.graph.Graph.addItem	(		self,
			item
	)

Definition at line 112 of file graph.py.

  def addItem(self,item):
    #print "graph.addItem",item
    node=CItems.Cell(item.node,self.canvas)
    self.citems[item.node.ptr()]=node
    node.show()
    self.canvas.update()
 

References gui.CItems.LinkItem.canvas, gui.graph.Graph.canvas, and gui.graph.Graph.citems.

addLink()

def gui.graph.Graph.addLink	(		self,
			link
	)

Definition at line 93 of file graph.py.

  def addLink(self,link):
    print("graph.addLink",link)
    #CItem for outport
    nodeS=self.citems[link.pout.getNode().ptr()]
    nodeE=self.citems[link.pin.getNode().ptr()]
    po=pi=None
    for p in nodeS.outports:
      if p.port == link.pout:
        po=p
        break
    for p in nodeE.inports:
      if p.port == link.pin:
        pi=p
        break
 
    if pi and po:
      l=CItems.LinkItem(po,pi,self.canvas)
      self.canvas.update()
 

References gui.CItems.LinkItem.canvas, gui.graph.Graph.canvas, and gui.graph.Graph.citems.

clearLinks()

def gui.graph.Graph.clearLinks

(

self

)

Definition at line 185 of file graph.py.

  def clearLinks(self):
    items=list(self.citems.values())
    for node in items:
      for port in node.outports:
        if not hasattr(port,"links"):
          continue
        for link in port.links():
          link.clearPoints()
    self.canvas.update()
 

References gui.CItems.LinkItem.canvas, gui.graph.Graph.canvas, and gui.graph.Graph.citems.

createGraph()

def gui.graph.Graph.createGraph

(

self

)

Definition at line 55 of file graph.py.

  def createGraph(self):
    #citems dict helps finding items in canvas from swig proxy
    #To find an item node make : citems[node.ptr()]
    citems={}
    self.citems=citems
    #pitems dict helps finding items in canvas from swig proxy
    #To find an item port make : pitems[port.ptr()]
    pitems={}
 
    y=0
    lnode=self.node.edGetDirectDescendants()
    for n in lnode:
      c=CItems.Cell(n,self.canvas)
      citems[n.ptr()]=c
      c.show()
 
    for k,n in list(citems.items()):
      for p in n.inports:
        pitems[p.port.ptr()]=p
      for p in n.outports:
        pitems[p.port.ptr()]=p
 
    for pout,pin in self.node.getSetOfInternalLinks():
      if pout.getNode().getFather() != self.node and pin.getNode().getFather() != self.node:
        continue
      po=pitems.get(pout.ptr())
      pi=pitems.get(pin.ptr())
      if pi and po:
        CItems.LinkItem(po,pi,self.canvas)
 
    for n in lnode:
      itemup=citems[n.ptr()]
      for ndown in n.getOutNodes():
        itemdown=citems[ndown.ptr()]
        CItems.ControlLinkItem(itemup.outgate,itemdown.ingate,self.canvas)
 
    self.layout("LR")
 

layout()

def gui.graph.Graph.layout	(		self,
			rankdir
	)

Compute graph layout with graphviz package

Definition at line 123 of file graph.py.

  def layout(self,rankdir):
    """Compute graph layout with graphviz package"""
    G=pygraphviz.AGraph(strict=False,directed=True)
    G.graph_attr["rankdir"]=rankdir
    G.graph_attr["dpi"]="72"
    dpi=72.
    aspect=dpi/72
    for k,n in list(self.citems.items()):
      #k is node address (YACS)
      #n is item in canvas
      G.add_node(k)
 
    for pout,pin in self.node.getSetOfInternalLinks():
      if pout.getNode().ptr() not in self.citems :
        continue
      if pin.getNode().ptr() not in self.citems:
        continue
      G.add_edge(pout.getNode().ptr(),pin.getNode().ptr())
 
    for k,n in list(self.citems.items()):
      for ndown in n.node.getOutNodes():
        G.add_edge(n.node.ptr(),ndown.ptr())
 
    #By default graphviz uses 96.0 pixel per inch (dpi=96.0)
    for n in G.nodes():
      item=self.citems[int(n)]
      h=item.height()/dpi #height in inch
      w=item.width()/dpi  #width in inch
      n.attr['height']=str(h)
      n.attr['width']=str(w)
      n.attr['fixedsize']="true"
      n.attr['shape']="box"
      #n.attr['label']=item.node.getName()
 
    G.layout(prog='dot') # use dot
    #G.write("layout.dot")
    #G.draw("layout.png")
 
    graph_attr=dict(attrs(G))
    bbox=graph_attr["bb"]
    x1,y1,x2,y2=eval(bbox)
    h=self.canvas.height()
    w=self.canvas.width()
    h2=max(h,y2-y1+100)
    w2=max(w,x2-x1+100)
    if h2 > h or w2 > w:
      self.canvas.resize(w2,h2)
 
    for n in G:
      pos=n.attr['pos'] #position is given in points (72 points par inch, so 1 point = dpi/72=1.34)
      x,y=eval(pos)
      x=aspect*x
      y=aspect*y
      item=self.citems[int(n)]
      x0=item.x()
      y0=item.y()
      x=x-x0
      y=y-y0
      item.moveBy(x,y)
 
    self.canvas.update()
 

References gui.graph.attrs(), gui.CItems.LinkItem.canvas, gui.graph.Graph.canvas, gui.graph.Graph.citems, gui.cataitems.ItemNode.node, gui.cataitems.ItemComposedNode.node, gui.CItems.ControlItem.node, gui.CItems.PortItem.node, gui.CItems.Cell.node, gui.graph.Graph.node, gui.GraphViewer.PortItem.node, gui.Items.ItemComposedNode.node, gui.Items.ItemNode.node, YACS::servertypeParser< T >.node(), YACS::servicetypeParser< T >.node(), YACS::looptypeParser< ENGINE::WhileLoop * >.node(), YACS::looptypeParser< PseudoComposedNode * >.node(), YACS::looptypeParser< ENGINE::DynParaLoop * >.node(), YACS::looptypeParser< ENGINE::ForLoop * >.node(), YACS::looptypeParser< T >.node(), YACS::casetypeParser.node(), YACS::bloctypeParser< YACS::ENGINE::Proc * >.node(), and YACS::bloctypeParser< T >.node().

orthoLinks()

def gui.graph.Graph.orthoLinks

(

self

)

Definition at line 195 of file graph.py.

  def orthoLinks(self):
    items=list(self.citems.values())
    g=grid(items)
    for node in items:
      for port in node.outports:
        if not hasattr(port,"links"):
          continue
        for link in port.links():
          #clear all intermediate points of the link
          link.clearPoints()
          #if isinstance(link,CItems.ControlLinkItem):
          #  print port.port.getNode().getName() +"->"+link.toPort.port.getNode().getName()
          #else:
          #  print port.port.getNode().getName() +":"+port.port.getName()+"->"+link.toPort.port.getNode().getName()+":"+link.toPort.port.getName()
          #print (port.x(),port.y()),(link.toPort.x(),link.toPort.y())
          x0,y0=port.x()+5,port.y()
          while g.get((x0,y0)).blocked:
            x0=x0+1
          x1,y1=link.toPort.x()-5,link.toPort.y()
          while g.get((x1,y1)).blocked:
            x1=x1-1
          path=g.findPath((x0,y0),(x1,y1))
          #print path
          if len(path)==1:
            if port.y() == link.toPort.y():
              #near ports face to face
              continue
            else:
              x,y=path[0]
              path=[(x,port.y()),(x,link.toPort.y())]
          elif len(path)==2:
            x1,y1=path[0]
            x2,y2=path[1]
            if x1 == x2:
              #vertical line
              path=[(x1,port.y()),(x1,link.toPort.y())]
            else:
              #horizontal line
              if port.y() == link.toPort.y():
                #near ports face to face
                continue
              else:
                #transform it into a vertical line
                x=(x1+x2)/2
                path=[(x,port.y()),(x,link.toPort.y())]
 
          #adjust the first point to the same y as port
          x0,y0=path[0]
          x1,y1=path[1]
          if y0==y1:
            #remove first point and adjust second one
            del path[0]
            x0=x1
          path[0]=x0,port.y()
          #adjust the last point to the same y as link.toPort
          x0,y0=path[-1]
          x1,y1=path[-2]
          if y0==y1:
            #remove last point and adjust new last one
            del path[-1]
            x0=x1
          path[-1]=x0,link.toPort.y()
          #print path
 
          #add intermediate points
          for x,y in path:
            line=link.lines[-1]
            link.splitLine(line,x,y)
    self.canvas.update()
 

References gui.CItems.LinkItem.canvas, gui.graph.Graph.canvas, and gui.graph.Graph.citems.

selectItem()

def gui.graph.Graph.selectItem	(		self,
			item
	)

Definition at line 119 of file graph.py.

  def selectItem(self,item):
    #print "graph.selectItem",item
    self.editor.selectItem(item)
 

References gui.graph.Graph.editor.

Referenced by gui.Tree.Tree.additem().

Member Data Documentation

canvas

gui.graph.Graph.canvas

Definition at line 46 of file graph.py.

Referenced by gui.graph.Graph.addItem(), gui.graph.Graph.addLink(), gui.GraphViewer.GraphViewer.clear(), gui.graph.Graph.clearLinks(), gui.GraphViewer.GraphViewer.contentsMouseDoubleClickEvent(), gui.GraphViewer.GraphViewer.contentsMouseMoveEvent(), gui.GraphViewer.GraphViewer.contentsMousePressEvent(), gui.graph.Graph.layout(), gui.CItems.InControlItem.link(), gui.CItems.OutControlItem.link(), gui.CItems.InPortItem.link(), gui.CItems.OutPortItem.link(), gui.GraphViewer.InPortItem.link(), gui.GraphViewer.OutPortItem.link(), gui.graph.Graph.orthoLinks(), gui.CItems.Cell.pynotify(), gui.GraphViewer.GraphViewer.selectItem(), and gui.CItems.LinkItem.splitLine().

citems

gui.graph.Graph.citems

Definition at line 59 of file graph.py.

Referenced by gui.graph.Graph.addItem(), gui.graph.Graph.addLink(), gui.graph.Graph.clearLinks(), gui.graph.Graph.layout(), and gui.graph.Graph.orthoLinks().

editor

gui.graph.Graph.editor

Definition at line 47 of file graph.py.

Referenced by gui.graph.Graph.selectItem().

item

gui.graph.Graph.item

Definition at line 43 of file graph.py.

Referenced by gui.Items.ControlLinksItem.getChildren(), gui.Items.DataLinksItem.getChildren(), gui.panels.PanelScript.handleCancel(), gui.panels.PanelFunc.handleCancel(), gui.panels.PanelInPort.handleRestore(), gui.panels.PanelOutPort.handleRestore(), gui.panels.PanelScript.handleSave(), gui.panels.PanelFunc.handleSave(), gui.panels.PanelInPort.handleSave(), gui.Tree.Node.setOpen(), and gui.Tree.Node.setOpen_old().

node

gui.graph.Graph.node

Definition at line 44 of file graph.py.

Referenced by gui.cataitems.ItemNode.addNode(), gui.cataitems.ItemComposedNode.addNode(), gui.Items.ItemComposedNode.addNode(), gui.Items.ItemForLoop.addNode(), gui.CItems.Cell.customEvent(), gui.Items.ItemComposedNode.dblselected(), gui.Items.ItemComposedNode.getChildren(), gui.Items.ItemNode.getChildren(), gui.Items.ItemService.handleCancel(), gui.Items.ItemService.handleSave(), gui.graph.Graph.layout(), gui.CItems.ControlItem.moveBy(), gui.CItems.PortItem.moveBy(), gui.GraphViewer.PortItem.moveBy(), gui.CItems.Cell.selected(), gui.Items.ItemComposedNode.selected(), gui.Items.ItemNode.selected(), and gui.CItems.Cell.tooltip().

parent

gui.graph.Graph.parent

Definition at line 42 of file graph.py.

Referenced by gui.Appli.Runner.run().

---

The documentation for this class was generated from the following file:

• src/pyqt/gui/graph.py