Python QtGui.QGraphicsLineItem类代码示例

    def __init__(self, parent, fromView, toView, distributedObjects):
        """ Constructor
        @param parent                parent for the QGraphicsPolygonItem-Constructor
        @param fromView              datagraph.htmlvariableview.HtmlVariableView, starting point of the Pointer
        @param toView                datagraph.htmlvariableview.HtmlVariableView, end point of the Pointer
        @param distributedObjects    distributedobjects.DistributedObjects, the DistributedObjects-Instance
        fromView and toView are QGraphicsWebViews
        """
        QGraphicsLineItem.__init__(self, parent)
        self.fromView = fromView
        fromView.addOutgoingPointer(self)
        self.toView = toView
        toView.addIncomingPointer(self)
        #self.setBrush( QBrush( self.bgcolor  ) )
        self.setPen(QPen(self.fgcolor, 1))

        self.distributedObjects = distributedObjects

        QObject.connect(self.fromView, SIGNAL('geometryChanged()'), self.updatePosition)
        QObject.connect(self.toView, SIGNAL('geometryChanged()'), self.updatePosition)
        QObject.connect(self.fromView, SIGNAL('xChanged()'), self.updatePosition)
        QObject.connect(self.fromView, SIGNAL('yChanged()'), self.updatePosition)
        QObject.connect(self.toView, SIGNAL('xChanged()'), self.updatePosition)
        QObject.connect(self.toView, SIGNAL('yChanged()'), self.updatePosition)
        QObject.connect(self.fromView, SIGNAL('removing()'), self.delete)
        QObject.connect(self.toView, SIGNAL('removing()'), self.delete)

        self.arrowhead = QPolygonF()
        self.arrowSize = 20
        self.setZValue(-1)  # paint the arrows behind (lower z-value) everything else

 def __init__(self, w, h, fgcolor):
     QGraphicsLineItem.__init__(self)
     self.setLine(w / 2., 0, w / 2., h)
     if fgcolor:
         self.setPen(QPen(QColor(fgcolor)))
     else:
         self.setPen(QPen(QColor('#000000')))

 def draw_y_axis(self):
     lineItem = QGraphicsLineItem(0, self.coordY(self.ylim[0]),
                                  0, self.coordY(self.ylim[1]),
                                  parent=self.item)
     lineItem.setPen(QPen(QColor('black')))
     lineItem.setZValue(10)
     max_w = 0
     for y in set(self.hlines + list(self.ylim)):
         lineItem = QGraphicsLineItem(0, self.coordY(y),
                                            -5, self.coordY(y),
                                            parent=self.item)
         lineItem.setPen(QPen(QColor('black')))
         lineItem.setZValue(10)
         text = QGraphicsSimpleTextItem(str(y))
         text.setFont(QFont("Arial", self.fsize-2))
         text.setParentItem(self.item)
         tw = text.boundingRect().width()
         max_w = tw if tw > max_w else max_w
         th = text.boundingRect().height()
         # Center text according to masterItem size
         text.setPos(-tw - 5, self.coordY(y)-th/2)
     if self.ylabel:
         text = QGraphicsSimpleTextItem(self.ylabel)
         text.setFont(QFont("Arial", self.fsize-1))
         text.setParentItem(self.item)
         text.rotate(-90)
         tw = text.boundingRect().width()
         th = text.boundingRect().height()
         # Center text according to masterItem size
         text.setPos(-th -5-max_w, tw/2+self.coordY(sum(self.ylim)/2))

class GPendulum(Graphics.Items.ItemGroupBase):
    def _setup(self):
        self.rod = QGraphicsLineItem(QLineF(0, 0, 0, 100))
        p = QPen(QColor(100, 100, 100))
        p.setWidth(5)
        self.rod.setPen(p)
        self.rod.setToolTip('This is the rod of the pendulum')
        self.ball = QGraphicsEllipseItem(QRectF(-20, 80, 40, 40))
        b = QBrush(Qt.SolidPattern)
        b.setColor(QColor(0, 255, 0))
        self.ball.setBrush(b)
        self.ball.setToolTip('This is the ball of the pendulum where the mass is concentrated')
        self.addToGroup(self.rod)
        self.addToGroup(self.ball)
        self.setFlags(QGraphicsItem.ItemIsSelectable)

    def setProperties(self, q):
        self.properties = q

    def contextMenuEvent(self, e):
        e.accept()
        m = QMenu()
        p = m.addAction("Properties")
        a = m.exec_(e.screenPos())
        if a == p:
            dlg = SimTools.RichTypes.Qt4Widgets.SimpleRichTypesDialog(mainWin, 'Pendulum properties',
                text='Change physical properties', scrolling=False)
            dlg.addRichTypes(self.properties)
            dlg.exec_()

 def __init__ (self, s_in, s_out ,parent=None, scene=None):
     
     QGraphicsLineItem.__init__ (self)
     
     self.s_in  = s_in
     self.s_out = s_out
     
     self.comm = c0.Comm0 ()
     
     self.xo = self.s_in.getAbsPos().x()
     self.yo = self.s_in.getAbsPos().y()
     self.xf = self.s_out.getAbsPos().x()
     self.yf = self.s_out.getAbsPos().y()
     
     self.color  = QColor (Qt.green).dark(120)
     
     #self.setFlags (QGraphicsItem.ItemIsSelectable | QGraphicsItem.ItemIsMovable)
     #self.setAcceptsHoverEvents (True)
     
     self.setZValue (-1)
     
     self.arrowSize = 5
     self.arrowHead = QPolygonF()
     
     self.setFlags (QGraphicsItem.ItemIsSelectable)
     self.setAcceptHoverEvents (True)
     self.setActive(True)
     
     self.wire_pen = QPen (Qt.white, 3, Qt.DotLine) # Qt.SolidLine
     
     self.const = 3

 def draw_errors(self, x, i):
     lower = self.values[i]+self._dw_err[i]
     upper = self.values[i]+self._up_err[i]
     lineItem = QGraphicsLineItem(0, self.coordY(lower), 0,
                                        self.coordY(upper), parent=self.item)
     lineItem.setX(x)
     lineItem.setPen(QPen(QColor('black'),1))

 def _setup(self, x=0, y=0, size=10, pen=QPen(QColor(0,0, 255))):
     a = 0.5*size
     self.p1 = QGraphicsLineItem(QLineF(x-a, y-a, x+a, y+a))
     self.p2 = QGraphicsLineItem(QLineF(x-a, y+a, x+a, y-a))
     self.p1.setPen(pen)
     self.p2.setPen(pen)
     self.addToGroup(self.p1)
     self.addToGroup(self.p2)

    def __init__(self, lon0, lat0, lon1, lat1, scene, parent=None):
        QGraphicsLineItem.__init__(self, parent=parent, scene=scene)

        self._lon0 = lon0
        self._lat0 = lat0
        self._lon1 = lon1
        self._lat1 = lat1

        self.updatePosition(scene)

class CrossX(ItemGroupBase):
    """a cross (x) made of two lines"""
    def _setup(self, x=0, y=0, size=10, pen=QPen(QColor(0,0, 255))):
        a = 0.5*size
        self.p1 = QGraphicsLineItem(QLineF(x-a, y-a, x+a, y+a))
        self.p2 = QGraphicsLineItem(QLineF(x-a, y+a, x+a, y-a))
        self.p1.setPen(pen)
        self.p2.setPen(pen)
        self.addToGroup(self.p1)
        self.addToGroup(self.p2)

    def mouseMoveEvent(self, event):
        if event.buttons() & Qt.LeftButton:

            downPos = event.buttonDownPos(Qt.LeftButton)
            if not self.__tmpLine and self.__dragStartItem and \
                    (downPos - event.pos()).manhattanLength() > \
                        QApplication.instance().startDragDistance():
                # Start a line drag
                line = QGraphicsLineItem(self)
                start = self.__dragStartItem.boundingRect().center()
                start = self.mapFromItem(self.__dragStartItem, start)
                line.setLine(start.x(), start.y(),
                             event.pos().x(), event.pos().y())

                pen = QPen(Qt.black, 4)
                pen.setCapStyle(Qt.RoundCap)
                line.setPen(pen)
                line.show()

                self.__tmpLine = line

            if self.__tmpLine:
                # Update the temp line
                line = self.__tmpLine.line()
                line.setP2(event.pos())
                self.__tmpLine.setLine(line)

        QGraphicsWidget.mouseMoveEvent(self, event)

class Axes(ItemGroupBase):
    """two rectangular lines as axes"""
    def _setup(self, x=[0, -100, 100], y=[0, -100, 100], pen=QPen(QColor(255,0,0))):
        if x:
            self.xAxis = QGraphicsLineItem(QLineF(x[1], x[0], x[2], x[0]))
            self.xAxis.setPen(pen)
            self.addToGroup(self.xAxis)
        if y:
            self.yAxis = QGraphicsLineItem(QLineF(y[0], y[1], y[0], y[2]))
            self.yAxis.setPen(pen)
            self.addToGroup(self.yAxis)

        def __init__(self, scene, *args, **kwords):
            comp.__init__(self, *args, **kwords)
            QGraphicsLineItem.__init__(self,QLineF(), scene = scene)

            pen = QtGui.QPen()
            pen.setWidth(1)
            pen.setBrush(Qt.black)
            pen.setStyle(Qt.NoPen)

            self.setPen(pen)
            self.nextPoint = 1

 def onEdgeAdd(start,end):
   '''
   Whenever a new edge is added to model, this method is to be notified.
   '''
   p1 = nodeToScene[start].rect().center()
   p2 = nodeToScene[end]  .rect().center()
   line = QGraphicsLineItem( QLineF(p1,p2) )
   line.setPen( QPen( QColor(32,32,32), 1 ) )
   groupEdges.addToGroup(line)
   nodeToLineP1[start].add(line)
   nodeToLineP2  [end].add(line)

 def draw_curve(self, x, y, i):
     # top line
     lineItem = QGraphicsLineItem(0, self.coordY(y), 4,
                                        self.coordY(y), parent=self.item)
     lineItem.setX(x-2)
     lineItem.setPen(QPen(QColor(self.colors[i]),2))
     if i > 0:
         prev = self.values[i-1] if i>0 else self.values[i]
         lineItem = QGraphicsLineItem(0, self.coordY(prev), self.col_w-4,
                                            self.coordY(y), parent=self.item)
         lineItem.setX(x - self.col_w+2)
         lineItem.setPen(QPen(QColor(self.colors[i]),2))

    def update(self):
        x1 = self.node1.centerX()
        y1 = self.node1.centerY()
        x2 = self.node2.centerX()
        y2 = self.node2.centerY()

        point1 = QPointF(x1,y1)
        point2 = QPointF(x2,y2)

        line = QLineF(point1, point2)

        QGraphicsLineItem.setLine(self,line)