Exemple #1
0
    def _draw_grid(self, painter, rect, pen, grid_size):
        """
        draws the grid lines in the scene.

        Args:
            painter (QtGui.QPainter): painter object.
            rect (QtCore.QRectF): rect object.
            pen (QtGui.QPen): pen object.
            grid_size (int): grid size.
        """
        left = int(rect.left())
        right = int(rect.right())
        top = int(rect.top())
        bottom = int(rect.bottom())

        first_left = left - (left % grid_size)
        first_top = top - (top % grid_size)

        lines = []
        lines.extend([
            QtCore.QLineF(x, top, x, bottom)
            for x in range(first_left, right, grid_size)
        ])
        lines.extend([
            QtCore.QLineF(left, y, right, y)
            for y in range(first_top, bottom, grid_size)
        ])

        painter.setPen(pen)
        painter.drawLines(lines)
Exemple #2
0
 def graphicsMouseMoveEvent(self, event, itemId=0):
     """This function is called by the owned
     :class:`~ts2.scenery.helper.TrackGraphicsItem` to handle
     its :meth:`~ts2.scenery.helper.TrackGraphicsItem.mouseMoveEvent`.
     Reimplemented in the ResizableItem class to begin a drag operation on
     corners."""
     if event.buttons() == Qt.LeftButton and \
        self.simulation.context == utils.Context.EDITOR_SCENERY:
         if QtCore.QLineF(event.scenePos(),
                          event.buttonDownScenePos(
                              Qt.LeftButton)).length() < 3.0:
             return
         drag = QtGui.QDrag(event.widget())
         mime = QtCore.QMimeData()
         pos = event.buttonDownScenePos(Qt.LeftButton) - self.origin
         if QtCore.QRectF(-5, -5, 9, 9).contains(pos):
             movedEnd = "start"
         elif QtCore.QRectF(self.end.x() - self.origin.x() - 5,
                            self.end.y() - self.origin.y() - 5, 9,
                            9).contains(pos):
             movedEnd = "end"
             pos -= self.end - self.origin
         # elif self._gi[itemId].shape().contains(pos):
         else:
             movedEnd = "origin"
         if movedEnd is not None:
             mime.setText(
                 type(self).__name__ + "#" + str(self.tiId) + "#" +
                 str(pos.x()) + "#" + str(pos.y()) + "#" + movedEnd)
             drag.setMimeData(mime)
             drag.exec_()
Exemple #3
0
    def _update_line(self):
        """Resolve start and end point from current source and target position

        :returns: A Qt line object
        :rtype: :class:`QtCore.QLineF`

        """
        start = QtCore.QPointF(0, 0)
        end = self._target_slot.center - self._source_slot.center

        self._line = QtCore.QLineF(start, end)
Exemple #4
0
    def _update_line(self):
        """Re-implement function that updates edge line definition

        """
        start = QtCore.QPoint(0, 0)
        if self._source_slot.family & NodeSlot.OUTPUT:
            end = self._mouse_pos - self._source_slot.center
        else:
            end = self._source_slot.center - self._mouse_pos

        self._line = QtCore.QLineF(start, end)
Exemple #5
0
 def __init__(self, parameters):
     """Constructor for the LineItem class"""
     self._placeCode = ""
     self._trackCode = ""
     self._realLength = ""
     super().__init__(parameters)
     self.defaultZValue = 1
     self._line = QtCore.QLineF()
     self._boundingRect = QtCore.QRectF()
     self.updateGeometry()
     gli = helper.TrackGraphicsItem(self)
     gli.setPos(self._origin)
     gli.setZValue(self.defaultZValue)
     self._gi[0] = gli
     self._tli = []
Exemple #6
0
 def drawTrain(self):
     """Draws the train(s) on the line, if any"""
     tlines = []
     if self.simulation.context == utils.Context.GAME:
         for i in range(len(self._trainHeads)):
             tlines.append(
                 QtCore.QLineF(
                     self.sceneLine.pointAt(self._trainHeads[i] /
                                            self._realLength),
                     self.sceneLine.pointAt(self._trainTails[i] /
                                            self._realLength)))
             if tlines[i].length() < 5.0 and self._trainTails[i] != 0:
                 # Make sure that the train representation is always
                 # at least 5 pixel long.
                 tlines[i].setLength(
                     min(5.0, (1 - self._trainTails[i] / self._realLength) *
                         self.sceneLine.length()))
     self.showTrainLineItem(tlines)
Exemple #7
0
 def graphicsMouseMoveEvent(self, event, itemId=0):
     """This function is called by the owned TrackGraphicsItem to handle
     its mouseMoveEvent. The implementation in the base class TrackItem
     begins a drag operation."""
     if itemId == 0:
         if (event.buttons() == Qt.LeftButton and self.simulation.context
                 == utils.Context.EDITOR_SCENERY):
             if QtCore.QLineF(event.scenePos(),
                              event.buttonDownScenePos(
                                  Qt.LeftButton)).length() < 3.0:
                 return
             drag = QtGui.QDrag(event.widget())
             mime = QtCore.QMimeData()
             pos = event.buttonDownScenePos(Qt.LeftButton) - self.origin
             mime.setText(
                 type(self).__name__ + "#" + str(self.tiId) + "#" +
                 str(pos.x()) + "#" + str(pos.y()) + "#" + "origin")
             drag.setMimeData(mime)
             drag.exec_()
Exemple #8
0
 def updateGeometry(self):
     """Updates the internal representation of the line and boundingRect
     when it has been modified"""
     orig = QtCore.QPointF(0, 0)
     end = orig + self.end - self.origin
     self._line = QtCore.QLineF(orig, end)
     x1 = self._line.p1().x()
     x2 = self._line.p2().x()
     y1 = self._line.p1().y()
     y2 = self._line.p2().y()
     lx = min(x1, x2) - 5.0
     rx = max(x1, x2) + 5.0
     ty = min(y1, y2) - 5.0
     by = max(y1, y2) + 5.0
     if self.tiId.startswith("__EDITOR__"):
         # Library item in editor
         lx -= 15
         rx += 15
         ty -= 20
         by += 20
     self._boundingRect = QtCore.QRectF(lx, ty, rx - lx, by - ty)
Exemple #9
0
 def rebuild_line(self):
     src_node = self.view.get_node_graphic(self.src_node_path)
     tgt_node = self.view.get_node_graphic(self.tgt_node_path)
     if src_node:
         self.src_pos = src_node.get_attr_out_pos(self.src_attr_name,
                                                  scene=True)
         if not self.src_pos:
             exec_attr = nxt_node.INTERNAL_ATTRS.EXECUTE_IN
             self.src_pos = src_node.get_attr_out_pos(exec_attr, scene=True)
     else:
         self.src_pos = self.view.mouse_scene_pos
     if tgt_node:
         self.tgt_pos = tgt_node.get_attr_in_pos(self.tgt_attr_name,
                                                 scene=True)
         if not self.tgt_pos:
             exec_attr = nxt_node.INTERNAL_ATTRS.EXECUTE_IN
             self.tgt_pos = tgt_node.get_attr_in_pos(exec_attr, scene=True)
     else:
         self.tgt_pos = self.view.mouse_scene_pos
     self.setLine(QtCore.QLineF(self.src_pos, self.tgt_pos))
     # I don't want this
     self.update()
Exemple #10
0
    def draw_path(self, start_port, end_port=None, cursor_pos=None):
        """
        Draws the path between ports.

        Args:
            start_port (PortItem): port used to draw the starting point.
            end_port (PortItem): port used to draw the end point.
            cursor_pos (QtCore.QPointF): cursor position if specified this
                will be the draw end point.
        """
        if not start_port:
            return
        pos1 = start_port.scenePos()
        pos1.setX(pos1.x() + (start_port.boundingRect().width() / 2))
        pos1.setY(pos1.y() + (start_port.boundingRect().height() / 2))
        if cursor_pos:
            pos2 = cursor_pos
        elif end_port:
            pos2 = end_port.scenePos()
            pos2.setX(pos2.x() + (start_port.boundingRect().width() / 2))
            pos2.setY(pos2.y() + (start_port.boundingRect().height() / 2))
        else:
            return

        line = QtCore.QLineF(pos1, pos2)
        path = QtGui.QPainterPath()
        path.moveTo(line.x1(), line.y1())

        if self.viewer_pipe_layout() == PIPE_LAYOUT_STRAIGHT:
            path.lineTo(pos2)
            self.setPath(path)
            return
        else:
            if NODE_LAYOUT_DIRECTION is NODE_LAYOUT_VERTICAL:
                self.__draw_path_vertical(start_port, pos1, pos2, path)
            elif NODE_LAYOUT_DIRECTION is NODE_LAYOUT_HORIZONTAL:
                self.__draw_path_horizontal(start_port, pos1, pos2, path)
Exemple #11
0
 def sceneLine(self):
     """Returns the line as a QLineF in the scene's coordinates."""
     return QtCore.QLineF(self.origin, self.end)
    def drawBackground(self, painter, rect):
        super(CanvasBase, self).drawBackground(painter, rect)
        lod = self.getCanvasLodValueFromCurrentScale()
        self.boundingRect = rect

        polygon = self.mapToScene(self.viewport().rect())

        painter.fillRect(rect,
                         QtGui.QBrush(editableStyleSheet().CanvasBgColor))

        left = int(rect.left()) - (int(rect.left()) %
                                   editableStyleSheet().GridSizeFine[0])
        top = int(rect.top()) - (int(rect.top()) %
                                 editableStyleSheet().GridSizeFine[0])

        if editableStyleSheet().DrawGrid[0] >= 1:
            if lod < editableStyleSheet().CanvasSwitch[0]:
                # Draw horizontal fine lines
                gridLines = []
                y = float(top)
                while y < float(rect.bottom()):
                    gridLines.append(
                        QtCore.QLineF(rect.left(), y, rect.right(), y))
                    y += editableStyleSheet().GridSizeFine[0]
                painter.setPen(
                    QtGui.QPen(editableStyleSheet().CanvasGridColor, 1))
                painter.drawLines(gridLines)

                # Draw vertical fine lines
                gridLines = []
                x = float(left)
                while x < float(rect.right()):
                    gridLines.append(
                        QtCore.QLineF(x, rect.top(), x, rect.bottom()))
                    x += editableStyleSheet().GridSizeFine[0]
                painter.setPen(
                    QtGui.QPen(editableStyleSheet().CanvasGridColor, 1))
                painter.drawLines(gridLines)

            # Draw thick grid
            left = int(rect.left()) - (int(rect.left()) %
                                       editableStyleSheet().GridSizeHuge[0])
            top = int(rect.top()) - (int(rect.top()) %
                                     editableStyleSheet().GridSizeHuge[0])

            # Draw vertical thick lines
            gridLines = []
            painter.setPen(
                QtGui.QPen(editableStyleSheet().CanvasGridColorDarker, 1.5))
            x = left
            while x < rect.right():
                gridLines.append(QtCore.QLineF(x, rect.top(), x,
                                               rect.bottom()))
                x += editableStyleSheet().GridSizeHuge[0]
            painter.drawLines(gridLines)

            # Draw horizontal thick lines
            gridLines = []
            painter.setPen(
                QtGui.QPen(editableStyleSheet().CanvasGridColorDarker, 1.5))
            y = top
            while y < rect.bottom():
                gridLines.append(QtCore.QLineF(rect.left(), y, rect.right(),
                                               y))
                y += editableStyleSheet().GridSizeHuge[0]
            painter.drawLines(gridLines)

        if editableStyleSheet().DrawNumbers[0] >= 1:
            # draw numbers
            scale = self.currentViewScale()
            f = painter.font()
            f.setPointSize(6 / min(scale, 1))
            f.setFamily("Consolas")
            painter.setFont(f)
            y = float(top)

            while y < float(rect.bottom()):
                y += editableStyleSheet().GridSizeHuge[0]
                inty = int(y)
                if y > top + 30:
                    painter.setPen(
                        QtGui.QPen(
                            editableStyleSheet().CanvasGridColorDarker.lighter(
                                300)))
                    painter.drawText(rect.left(), y - 1.0, str(inty))

            x = float(left)
            while x < rect.right():
                x += editableStyleSheet().GridSizeHuge[0]
                intx = int(x)
                if x > left + 30:
                    painter.setPen(
                        QtGui.QPen(
                            editableStyleSheet().CanvasGridColorDarker.lighter(
                                300)))
                    painter.drawText(x,
                                     rect.top() + painter.font().pointSize(),
                                     str(intx))
Exemple #13
0
    def paint(self, p: QtGui.QPainter, option: QtWidgets.QGraphicsItem.ItemIsSelectable,
              widget: QtWidgets.QWidget): # pylint: disable=unused-argument

        # Set color when selected
        if option.state & QtWidgets.QStyle.State_Selected:
            fillColor = self.color.darker(150)
        else:
            fillColor = self.color

        # Lighten if mouse over
        if option.state & QtWidgets.QStyle.State_MouseOver:
            fillColor = fillColor.lighter(125)

        # Calculate level of detail
        lod = option.levelOfDetailFromTransform(p.worldTransform())
        if lod < 0.125:
            p.fillRect(QtCore.QRectF(0, 0, 110, 70), fillColor)
            return
        if lod < 0.2:
            oldBrush = p.brush()
            p.setBrush(fillColor)
            p.drawRect(13, 13, 97, 57)
            p.setBrush(oldBrush)
            return

        oldPen = p.pen()
        oldBrush = p.brush()

        # Use a copy of the old pen
        pen = QtGui.QPen(oldPen)
        if option.state & QtWidgets.QStyle.State_Selected:
            pen.setWidth(2)
        else:
            pen.setWidth(0)
        p.setPen(pen)

        # Draw the inside of the chip
        if option.state & QtWidgets.QStyle.State_Sunken:
            p.setBrush(QtGui.QBrush(fillColor.darker(120)))
        else:
            p.setBrush(QtGui.QBrush(fillColor.darker(100)))
        p.drawRect(QtCore.QRect(14, 14, 79, 39))
        p.setBrush(oldBrush)

        if lod >= 1:
            p.setPen(QtGui.QPen(QtCore.Qt.gray, 1))
            p.drawLine(15, 54, 94, 54)
            p.drawLine(94, 53, 94, 15)
            p.setPen(QtGui.QPen(QtCore.Qt.black, 0))

        if lod >= 2:
            font = QtGui.QFont("Times", 10)
            font.setStyleStrategy(QtGui.QFont.ForceOutline)
            p.setFont(font)
            p.save()
            p.scale(0.1, 0.1)
            p.drawText(170, 180, f"Model: VSC-2000 (Very Small Chip) at {self.x}x{self.y}")
            p.drawText(170, 200, "Serial number: DLWR-WEER-123L-ZZ33-SDSJ")
            p.drawText(170, 220, "Manufacturer: Chip Manufacturer")
            p.restore()

        lines = []
        if lod >= 0.5:
            for i in range(0, 11, 1 if lod > 0.5 else 2):
                lines.append(QtCore.QLineF(18 + 7*i, 13, 18 + 7*i, 5))
                lines.append(QtCore.QLineF(18 + 7*i, 54, 18 + 7*i, 62))
            for i in range(0, 7, 1 if lod > 0.5 else 2):
                lines.append(QtCore.QLineF(5, 18 + i*5, 13, 18 + i*5))
                lines.append(QtCore.QLineF(94, 18 + i*5, 102, 18 + i*5))
        if lod >= 0.4:
            lines.append(QtCore.QLineF(25, 35, 35, 35))
            lines.append(QtCore.QLineF(35, 30, 35, 40))
            lines.append(QtCore.QLineF(35, 30, 45, 35))
            lines.append(QtCore.QLineF(35, 40, 45, 35))
            lines.append(QtCore.QLineF(45, 30, 45, 40))
            lines.append(QtCore.QLineF(45, 35, 55, 35))
        p.drawLines(lines)

        # Draw red ink
        if self.stuff:
            p.setPen(QtGui.QPen(QtCore.Qt.red, 1, QtCore.Qt.SolidLine,
                                QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin))
            p.setBrush(QtCore.Qt.NoBrush)
            path = QtGui.QPainterPath()
            path.moveTo(self.stuff[0])
            for point in self.stuff[1:]:
                path.lineTo(point)
            p.drawPath(path)

        p.setPen(oldPen)
        p.setBrush(oldBrush)