Esempio n. 1
0
 def set_color(self, step):
     if self.basset_name == 'cc_bundle':
         self.normal_color = QtGui.QLinearGradient(
             QtCore.QPointF(0, 0), QtCore.QPointF(self.w, 0))
         color1 = SPECIAL_COLOR['cc_bundle'][0]
         color2 = SPECIAL_COLOR['cc_bundle'][1]
         self.normal_color.setColorAt(
             0, QtGui.QColor(color1[0], color1[1], color1[2]))
         self.normal_color.setColorAt(
             1, QtGui.QColor(color2[0], color2[1], color2[2]))
         self.fill_color = self.normal_color
     else:
         super(PlaVersionItem, self).set_color(step)
Esempio n. 2
0
    def fit_to(self, items=[]):
        if len(items) == 0:
            for item in self.scene().items():
                if isinstance(item, VersionItem):
                    items.append(item)

        max_x = items[0].pos().x()
        min_x = items[0].pos().x()
        max_y = items[0].pos().y()
        min_y = items[0].pos().y()
        for item in items:
            max_x = max(item.pos().x(), max_x)
            min_x = min(item.pos().x(), min_x)
            max_y = max(item.pos().y(), max_y)
            min_y = min(item.pos().y(), min_y)
        center_x = (max_x + min_x) / 2 + 100
        center_y = (max_y + min_y) / 2 + 40
        width = max_x - min_x
        height = max_y - min_y

        zoom_x = 1 / max(
            1,
            float(width + 1000) / self.viewport().width()) / self.current_zoom
        zoom_y = 1 / max(1,
                         float(height + 1000) /
                         self.viewport().height()) / self.current_zoom
        zoom = min(zoom_x, zoom_y)
        self.scale(zoom, zoom)
        self.current_zoom = self.transform().m11()
        self.resize_scene()

        self.centerOn(QtCore.QPointF(center_x, center_y))
Esempio n. 3
0
    def mouseMoveEvent(self, event):
        if self.panning:
            mouse_move = event.pos() - self.prevPos
            newCenter = QtCore.QPointF(
                self.prev_center.x() - mouse_move.x() / self.current_zoom,
                self.prev_center.y() - mouse_move.y() / self.current_zoom)
            self.centerOn(newCenter)

            show_detail = True if self.current_zoom >= 0.5 else False
            if show_detail:
                point1 = self.mapToScene(QtCore.QPoint(0, 0))
                point2 = self.mapToScene(
                    QtCore.QPoint(self.viewport().width(),
                                  self.viewport().height()))
                rect = QtCore.QRectF(point1, point2)
                for version_node in self.nodes():
                    if rect.contains(version_node.pos()) and not hasattr(
                            version_node, 'version_widget'):
                        version_node.start_show_version_widget()
                        # print version_node.pos(), point1, point2

            return
        super(GraphicsView, self).mouseMoveEvent(event)
Esempio n. 4
0
def get_shapes_of_triangle(a, roundness=0, direction=0):
    points = [
        QtCore.QPointF(1.732 * roundness, a),
        QtCore.QPointF(1.732 / 2 * roundness, a - 1.5 * roundness),
        QtCore.QPointF(0.5 * a - 1.732 / 2 * roundness, 1.5 * roundness),
        QtCore.QPointF(0.5 * a + 1.732 / 2 * roundness, 1.5 * roundness),
        QtCore.QPointF(a - 1.732 / 2 * roundness, a - 1.5 * roundness),
        QtCore.QPointF(a - 1.732 * roundness, a),
    ]
    centers = [
        QtCore.QPointF(0.5 * a, 2.0 * roundness),
        QtCore.QPointF(1.732 * roundness, a - roundness),
        QtCore.QPointF(a - 1.732 * roundness, a - roundness),
    ]
    if direction == 0:
        points = [
            point - QtCore.QPointF(0, 1.732 / 4 * roundness)
            for point in points
        ]
        centers = [
            point - QtCore.QPointF(0, 1.732 / 4 * roundness)
            for point in centers
        ]
    elif direction == 2:
        points = [
            QtCore.QPointF(point.x(),
                           -1 * point.y() + a + 1.732 / 4 * roundness)
            for point in points
        ]
        centers = [
            QtCore.QPointF(point.x(),
                           -1 * point.y() + a + 1.732 / 4 * roundness)
            for point in centers
        ]
    rects = [
        get_rect_of_ellipse(center.x(), center.y(), roundness)
        for center in centers
    ]
    return points, rects