GraphViewer.py

Go to the documentation of this file.

# Copyright (C) 2006-2025  CEA, EDF
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
 
import sys
from qt import *
from qtcanvas import *
import math
 
class DynamicTip( QToolTip ):
  def __init__( self, parent ):
    QToolTip.__init__( self, parent )
 
  def maybeTip( self, pos ):
    pos2=self.parentWidget().viewportToContents(pos)
    point = self.parentWidget().inverseWorldMatrix().map(pos2)
    ilist = self.parentWidget().canvas().collisions(point) #QCanvasItemList ilist
    for each_item in ilist:
      if hasattr(each_item,"tooltip"):
        each_item.tooltip(self,pos)
        return
      elif hasattr(each_item,"getObj"):
        each_item.getObj().tooltip(self,pos)
        return
 
class GraphViewer(QCanvasView):
  def __init__(self,c,parent,name,f):
    QCanvasView.__init__(self,c,parent,name,f)
    self.__moving__moving=0
    self.__connecting__connecting=0
    self.__moving_start__moving_start= 0
    # for highlighting selections
    self.selectPenselectPen=QPen(QColor(255,255,0),2,Qt.DashLine)
    self.selectBrushselectBrush=QBrush(Qt.red)
    self.selectStyleselectStyle = Qt.Dense5Pattern
    self.selectedselected=None
    self.tooltiptooltip = DynamicTip( self )
 
  def contentsMouseDoubleClickEvent(self,e): # QMouseEvent e
    point = self.inverseWorldMatrix().map(e.pos())
    ilist = self.canvas().collisions(point) #QCanvasItemList ilist
    for each_item in ilist:
      if each_item.rtti()==984376:
        if not each_item.hit(point):
          continue
      if e.button()== Qt.LeftButton:
        if hasattr(each_item,"handleDoubleClick"):
          each_item.handleDoubleClick(point)
          self.canvas().update()
          return
 
 
  def contentsMousePressEvent(self,e): # QMouseEvent e
    p=e.globalPos()
    point = self.inverseWorldMatrix().map(e.pos())
    ilist = self.canvas().collisions(point) #QCanvasItemList ilist
    for each_item in ilist:
      if each_item.rtti()==984376:
        if not each_item.hit(point):
          continue
      if e.button()== Qt.RightButton:
        #Right button click
        self.__moving__moving=0
        self.__connecting__connecting=0
        if hasattr(each_item,"popup"):
          menu=each_item.popup(self)
          if menu:
            menu.exec_loop( QCursor.pos() )
            self.canvas().update()
        elif hasattr(each_item,"getObj"):
          menu=each_item.getObj().popup(self)
          if menu:
            menu.exec_loop( QCursor.pos() )
            self.canvas().update()
 
      elif e.button()== Qt.LeftButton:
        #Left button click
        if self.__connecting__connecting:
          #We are linking objects
          if hasattr(each_item,"getObj"):
            #a connection is ending
            self.__connecting__connecting.link(each_item.getObj().item)
            #self.__connecting.link(each_item.getObj())
            self.canvas().update()
          self.__connecting__connecting=0
        else:
          #We are moving or selecting a composite object
          each_item.selected()
          self.__moving__moving=each_item
          self.__moving_start__moving_start=point
          self.canvas().update()
      return
    if e.button()== Qt.RightButton:
      menu=self.popuppopup()
      if menu:
        menu.exec_loop( QCursor.pos() )
        self.canvas().update()
    self.__moving__moving=0
    self.__connecting__connecting=0
    QCanvasView.contentsMousePressEvent(self,e)
 
  def selectItem(self,item):
    #print "selectItem",item
    if self.selectedselected:
      try:
        self.deselectObjdeselectObj(self.selectedselected)
      except:
        pass
      self.selectedselected=None
    #need to find equivalent canvas item 
    for citem in self.canvas().allItems():
      if hasattr(citem,"item") and citem.item is item:
        self.selectedselected=citem
        self.selectObjselectObj(self.selectedselected)
        break
    self.canvas().update()
 
  def selectObj(self,obj):
    if obj:
      obj._origPen = obj.pen()
      obj._origBrush = obj.brush()
      obj._origStyle = obj.brush().style()
      obj.setPen(self.selectPenselectPen)
      #obj.setBrush(self.selectBrush)
 
  def deselectObj(self,obj):
    if obj:
      obj.setPen(obj._origPen)
      #obj.setBrush(obj._origBrush)
 
  def popup(self):
    menu=QPopupMenu()
    caption = QLabel( "<font color=darkblue><u><b>View Menu</b></u></font>", self )
    caption.setAlignment( Qt.AlignCenter )
    menu.insertItem( caption )
    menu.insertItem("add Node", self.addNodeaddNode)
    return menu
 
  #def layout(self,rankdir):
  #  print rankdir
 
  def updateCanvas(self):
    #Par defaut, Qt n'efface pas le background. Seul repaintContents
    #semble le faire. Utile apres un popup ou un resize avec scrollbars
    #Peut-on l'utiliser partout ? Pb de performance ?
    self.repaintContents(True)
    #self.canvas().update()
 
  def addNode(self):
    print("addNode")    
 
  def zoomIn(self):
    m = self.worldMatrix()
    m.scale( 2.0, 2.0 )
    self.setWorldMatrix( m )
 
  def zoomOut(self):
    m = self.worldMatrix()
    m.scale( 0.5, 0.5 )
    self.setWorldMatrix( m )
 
  def clear(self):
    ilist = self.canvas().allItems()
    for each_item in ilist:
      if each_item:
        each_item.setCanvas(None)
        del each_item
    self.canvas().update()
 
  def connecting(self,obj):
    """Method called by an item to notify canvasView a connection has begun"""
    print("connecting",obj)
    self.__connecting__connecting=obj
 
  def contentsMouseMoveEvent(self,e):
    if  self.__moving__moving :
      point = self.inverseWorldMatrix().map(e.pos())
      self.__moving__moving.moveBy(point.x()-self.__moving_start__moving_start.x(),point.y()-self.__moving_start__moving_start.y())
      self.__moving_start__moving_start = point
      self.canvas().update()
    else:
      #self.tooltip.maybeTip(point)
      QCanvasView.contentsMouseMoveEvent(self,e)
 
class ImageItem(QCanvasRectangle):
    def __init__(self,img,canvas):
      QCanvasRectangle.__init__(self,canvas)
 
      self.imageRTTIimageRTTI=984376
      self.imageimage=img
      self.pixmappixmap=QPixmap()
      self.setSize(self.imageimage.width(), self.imageimage.height())
      self.pixmappixmap.convertFromImage(self.imageimage, Qt.OrderedAlphaDither);
 
    def rtti(self):
      return self.imageRTTIimageRTTI
 
    def hit(self,p):
      ix = p.x()-self.x()
      iy = p.y()-self.y()
      if not self.imageimage.valid( ix , iy ):
        return False
      self.pixelpixel = self.imageimage.pixel( ix, iy )
      return  (qAlpha( self.pixelpixel ) != 0)
 
    def drawShape(self,p):
      p.drawPixmap( self.x(), self.y(), self.pixmappixmap )
 
class LinkItem(QCanvasLine):
  def __init__(self,fromPort, toPort,canvas):
    QCanvasLine.__init__(self,canvas)
    self.setPen(QPen(Qt.black))
    self.setBrush(QBrush(Qt.red))
    fromPort.addOutLink(self)
    toPort.addInLink(self)
    self.setPoints(int(fromPort.x()),int(fromPort.y()), int(toPort.x()), int(toPort.y()))
    self.setZ(min(fromPort.z(),toPort.z())-1)
    self.setVisible(True)
    self.arrowarrow = QCanvasPolygon(self.canvas())
    self.arrowarrow.setBrush(QBrush(Qt.black))
    self.setArrowsetArrow()
    self.arrowarrow.show()
 
  def setFromPoint(self,x,y):
    self.setPoints(x,y,self.endPoint().x(),self.endPoint().y())
    self.setArrowsetArrow()
 
  def setToPoint(self,x,y):
    self.setPoints(self.startPoint().x(), self.startPoint().y(),x,y)
    self.setArrowsetArrow()
 
  def moveBy(self,dx,dy):
    pass
 
  def setArrow(self):
    x1,y1=self.startPoint().x(),self.startPoint().y()
    x2,y2=self.endPoint().x(),self.endPoint().y()
    d=math.hypot(x2-x1,y2-y1)
    sina=(y2-y1)/d
    cosa=(x2-x1)/d
    x=(x1+x2)/2.
    y=(y1+y2)/2.
    pa=QPointArray(3)
    pa.setPoint(0, QPoint(x+10*cosa,y+10*sina))
    pa.setPoint(1, QPoint(x-5*sina,y+5*cosa))
    pa.setPoint(2, QPoint(x+5*sina,y-5*cosa))
    self.arrow.setPoints(pa)
 
  def popup(self,canvasView):
    menu=QPopupMenu()
    caption = QLabel( "<font color=darkblue><u><b>Node Menu</b></u></font>",menu )
    caption.setAlignment( Qt.AlignCenter )
    menu.insertItem( caption )
    menu.insertItem("Delete", self.deletedelete)
    return menu
 
  def delete(self):
    print("delete link")
 
  def tooltip(self,view,pos):
    r = QRect(pos.x(), pos.y(), pos.x()+10, pos.y()+10)
    s = QString( "link: %d,%d" % (r.center().x(), r.center().y()) )
    view.tip( r, s )
 
class PortItem(QCanvasEllipse):
  def __init__(self,node,canvas):
    QCanvasEllipse.__init__(self,6,6,canvas)
    self.setPen(QPen(Qt.black))
    self.setBrush(QBrush(Qt.red))
    self.setZ(node.z()+1)
    self.nodenode=node
 
  def moveBy(self,dx,dy):
    self.nodenode.moveBy(dx,dy)
 
  def myMove(self,dx,dy):
    QCanvasEllipse.moveBy(self,dx,dy)
 
  def getObj(self):
    return self
 
  def popup(self,canvasView):
    self.contextcontext=canvasView
    menu=QPopupMenu()
    caption = QLabel( "<font color=darkblue><u><b>Port Menu</b></u></font>",menu )
    caption.setAlignment( Qt.AlignCenter )
    menu.insertItem( caption )
    menu.insertItem("Connect", self.connectconnect)
    return menu
 
  def connect(self):
    print("connect",self.contextcontext)
    self.contextcontext.connecting(self)
 
  def link(self,obj):
    print("link:",obj)
 
  def tooltip(self,view,pos):
    r = QRect(self.x(), self.y(), self.width(), self.height())
    s = QString( "port: %d,%d" % (r.center().x(), r.center().y()) )
    view.tip( r, s )
 
class InPortItem(PortItem):
  def __init__(self,node,canvas):
    PortItem.__init__(self,node,canvas)
    self.__inList__inList=[]
 
  def myMove(self,dx,dy):
    PortItem.myMove(self,dx,dy)
    for link in self.__inList__inList:
      link.setToPoint( int(self.x()), int(self.y()) )
 
  def link(self,obj):
    print("link:",obj)
    if isinstance(obj,OutPortItem):
      #Connection possible
      l=LinkItem(obj,self,self.canvas())
 
  def addInLink(self,link):
    self.__inList__inList.append(link)
 
class OutPortItem(PortItem):
  def __init__(self,node,canvas):
    PortItem.__init__(self,node,canvas)
    self.__outList__outList=[]
 
  def myMove(self,dx,dy):
    PortItem.myMove(self,dx,dy)
    for link in self.__outList__outList:
      link.setFromPoint( int(self.x()), int(self.y()) )
 
  def link(self,obj):
    print("link:",obj)
    if isinstance(obj,InPortItem):
      #Connection possible
      l=LinkItem(self,obj,self.canvas())
 
  def addOutLink(self,link):
    self.__outList__outList.append(link)
 
class Cell(QCanvasRectangle):
  def __init__(self,canvas):
    QCanvasRectangle.__init__(self,canvas)
    self.setSize(50,50)
 
    self.inportsinports=[]
    self.outportsoutports=[]
 
    p=InPortItem(self,canvas)
    p.myMove(0,25)
    self.inportsinports.append(p)
    p=OutPortItem(self,canvas)
    p.myMove(50,25)
    self.outportsoutports.append(p)
 
  def moveBy(self,dx,dy):
    QCanvasRectangle.moveBy(self,dx,dy)
    for p in self.inportsinports:
      p.myMove(dx,dy)
    for p in self.outportsoutports:
      p.myMove(dx,dy)
 
  def show(self):
    QCanvasRectangle.show(self)
    for p in self.inportsinports:
      p.show()
    for p in self.outportsoutports:
      p.show()
 
  def getObj(self):
    return self
 
  def popup(self,canvasView):
    menu=QPopupMenu()
    caption = QLabel( "<font color=darkblue><u><b>Node Menu</b></u></font>",menu )
    caption.setAlignment( Qt.AlignCenter )
    menu.insertItem( caption )
    menu.insertItem("Browse", self.browsebrowse)
    return menu
 
  def tooltip(self,view,pos):
    r = QRect(self.x(), self.y(), self.width(), self.height())
    s = QString( "node: %d,%d" % (r.center().x(), r.center().y()) )
    view.tip( r, s )
 
  def browse(self):
    print("browse")
 
  def selected(self):
    print("selected")
 
if __name__=='__main__':
  app=QApplication(sys.argv)
  box=QMainWindow()
  QToolBar(box,"toolbar")
  canvas=QCanvas(800,600)
  canvas.setAdvancePeriod(30)
  m=GraphViewer(canvas,box,"example",0)
  box.setCentralWidget(m)
  c1=Cell(canvas)
  c1.moveBy(150,150)
  c1.show()
  c2=Cell(canvas)
  c2.moveBy(250,150)
  c2.show()
  c1.outports[0].link(c2.inports[0])
 
  qApp.setMainWidget(box)
  box.show()
  app.exec_loop()