def paint(self, canvas, is_secondary_color=False, additional_flag=False):
        pen = QPen()

        if is_secondary_color:
            pen.setColor(self.data_singleton.secondary_color)
        else:
            pen.setColor(self.data_singleton.primary_color)

        painter = QPainter(canvas.image)
        painter.setRenderHint(QPainter.Antialiasing)
        pen.setWidth(self.data_singleton.pen_size)
        pen.setStyle(Qt.SolidLine)
        pen.setCapStyle(Qt.RoundCap)
        pen.setJoinStyle(Qt.RoundJoin)

        painter.setPen(pen)

        if is_secondary_color:
            painter.setBrush(self.data_singleton.primary_color)
        else:
            painter.setBrush(self.data_singleton.secondary_color)

        if self._start_point != self._end_point:
            painter.drawRect(QRect(self._start_point, self._end_point))

        painter.end()

        canvas.edited = True
        canvas.update()
Example #2
0
    def _draw_serie(self, painter, ndx_serie, color):

        serie = self.data[ndx_serie]

        #mainlog.debug(serie)

        fill_color = QColor(color)
        fill_color.setAlpha(64)
        brush = QBrush(fill_color)
        pen = QPen()
        pen.setCapStyle(Qt.SquareCap)
        pen.setColor(color)

        qp = QPainterPath()
        painter.setPen(pen)

        for i in range(len(serie)):
            x, y_top, y_below = self._item_coordinates(i)

            h = max(1, float(y_top - y_below - 1))
            qp.addRect( x,
                        float(self.y_base-y_top),
                        float(self.bar_width),
                        h)

        painter.fillPath(qp,brush)
        painter.drawPath(qp)

        #mainlog.debug("Drawing peak values, juste before {}".format(self._peak_values))
        if self._peak_values:
            #mainlog.debug("Drawing peak values")
            self._draw_peak_values(painter, self._peak_values )
Example #3
0
 def paintEvent(self, pe):
   # make an arrow polygon right in the middle
   painter = QPainter(self)
   painter.setPen(Qt.NoPen)
   # draw the background transparent rect
   painter.save()
   painter.setOpacity(self.BACKGROUND_OPACITY)
   # get the rectangle coordinates it should extend over the whole width with only a portion at the center
   painter.setBrush(Qt.black)
   empty_space_percent = 1 - self.BACKROUND_HEIGHT_PERCENT
   rect_top = empty_space_percent / 2 * self.height()
   rect_height = self.BACKROUND_HEIGHT_PERCENT * self.height()
   painter.drawRect(0, rect_top, self.width(), rect_height)
   painter.restore()
   painter.setRenderHint(QPainter.Antialiasing)
   pen = QPen()
   pen.setWidth(self.ARROW_LINE_WIDTH)
   pen.setCapStyle(Qt.RoundCap)
   if self._mouse_inside:
     pen.setColor(self._hover_color)
   else:
     pen.setColor(self._normal_color)
   # get the arrow coords
   painter.setPen(pen)
   self_center = QPointF(self.width() / 2, self.height() / 2) # use this as the arrow tip for now
   if self._direction == self.LEFT:
     h_shift = self._arrow_width
   elif self._direction == self.RIGHT:
     h_shift = - self._arrow_width
   v_shift = self._arrow_height / 2
   top_point = self_center + QPointF(h_shift, - v_shift)
   bottom_point = self_center + QPointF(h_shift, v_shift)
   painter.drawLine(top_point, self_center)
   painter.drawLine(self_center, bottom_point)
Example #4
0
 def paintEvent(self, pe):
   if not self._hover_rect:
     super(TrackerWebView, self).paintEvent(pe)
   else:
     super(TrackerWebView, self).paintEvent(pe)
     hover_rect = self._hover_rect
     self._fixRectForScroll(hover_rect)
     painter = QPainter(self)
     painter.save()
     pen = QPen(Qt.red)
     pen.setWidth(2)
     painter.setPen(pen)
     painter.drawRect(hover_rect)
     painter.restore()
     # draw green rects around the similar elements
     pen = QPen()
     pen.setWidth(2)
     for field_info in self._fields_info:
       painter.save()
       web_elements = field_info.web_elements
       color = field_info.color
       pen.setColor(color)
       painter.setPen(pen)
       for elem in web_elements:
         elem_rect = elem.absoluteGeometry()
         painter.drawRoundedRect(self._fixRectForScroll(elem_rect), 2, 2)
       painter.restore()
Example #5
0
 def draw(self, painter, scale):
     if self.point:
         pen = QPen()
         pen.setColor(QColor(255, 0, 0))
         painter.setPen(pen)
         painter.drawEllipse(self.point, Figure.CTRL_RADIUS + 4,
                             Figure.CTRL_RADIUS + 4)
Example #6
0
    def _draw_serie(self, painter, ndx_serie, color):

        serie = self.data[ndx_serie]

        if not serie:
            return

        qp = QPainterPath()
        # qp.addRect(2,2,total_width-4,total_height-4)

        x = float(0) * self.x_factor
        y = serie[0] * self.y_factor
        qp.moveTo(self.x_centers[0],self.y_base - y)
        # print y_base

        for i in range(1,len(serie)):
            x = float(i) * self.x_factor
            y = float(serie[i]) * self.y_factor

            qp.lineTo(self.x_centers[i], self.y_base-y)

        pen = QPen()
        pen.setColor(color)

        if ndx_serie == self.ndx_best_serie:
            pen.setWidth(6)
        else:
            pen.setWidth(2)

        painter.setPen(pen)
        painter.drawPath(qp)
Example #7
0
    def _draw_horizontal_ruler(self, painter, text, y_value, color):

        y = y_value * self.y_factor

        pen = QPen()
        pen.setCapStyle(Qt.SquareCap)
        pen.setColor(color)

        qp = QPainterPath()

        r = QRect(1,1,1000,1000)
        bb = painter.boundingRect(r,Qt.AlignLeft,text)
        bb = QRect(self.x_base,self.y_base - y - bb.height(), bb.width() + 2, bb.height())

        # print("{} {} {} {}".format(bb.x(),bb.y(),bb.width(),bb.height()))

        fill_color = QColor(0,0,0)
        fill_color.setAlpha(128)
        brush = QBrush(fill_color)

        painter.fillRect(bb,brush)

        qp.moveTo(self.x_base,self.y_base - y)
        qp.lineTo(self.total_width + self.x_base, self.y_base - y)

        painter.setPen(pen)
        painter.drawPath(qp)

        text_pen = QPen()
        text_pen.setCapStyle(Qt.RoundCap)
        text_pen.setColor(color) # alpha=255=fully opaque
        text_pen.setWidth(1)

        painter.setPen(text_pen)
        painter.drawText(self.x_base,self.y_base - y - 5,text)
Example #8
0
    def paintEvent(self, pe):
        p = QPainter(self)
        p.setRenderHint(QPainter.Antialiasing)

        pen = QPen()
        pen.setColor(Qt.GlobalColor.black)
        pen.setWidth(2)
        pen.setJoinStyle(Qt.MiterJoin)
        p.setPen(pen)

        h = self.associated_label.sizeHint().height()
        w = h
        pw = pen.width()

        b = self.italic_block(pw+0,w,h)
        p.translate(self.shadow_size,self.shadow_size)
        p.fillPath(b, QBrush(Qt.gray))
        p.translate(-self.shadow_size,-self.shadow_size)
        p.fillPath(b, QBrush(self.Colors[self.step]))
        p.drawPath(b)
        b = self.italic_block(pw+w*1.25,w*0.75,h)
        p.translate(self.shadow_size,self.shadow_size)
        p.fillPath(b, QBrush(Qt.gray))
        p.translate(-self.shadow_size,-self.shadow_size)
        p.fillPath(b, QBrush(self.Colors[self.step+1]))
        p.drawPath(b)
        b = self.italic_block(pw+w*2.25,w*0.4,h)
        p.translate(self.shadow_size,self.shadow_size)
        p.fillPath(b, QBrush(Qt.gray))
        p.translate(-self.shadow_size,-self.shadow_size)
        p.fillPath(b, QBrush(self.Colors[self.step+2]))
        p.drawPath(b)
Example #9
0
    def paintEvent(self, pe):

        if self._drop_zones_shown:
            painter = QPainter(self.viewport(
            ))  # See documentation to know why I draw on the viewport
            painter.setFont(self._titles_font)
            vr = self.rect()

            nb_drop_zones = len(self._drop_zones_titles)

            subr = QRect(vr)
            subr.setHeight(vr.height() / nb_drop_zones)

            for i in range(nb_drop_zones):
                c = self._drop_zones_colors[i]

                text_pen = QPen()
                text_pen.setColor(inverse_colors(c))
                painter.setPen(text_pen)

                if i == self._selected_drop_zone:
                    # mainlog.debug("selected drop zone is {}".format(i))
                    c = c.lighter(200)
                painter.setBrush(c)

                subr.moveTop(int(i * vr.height() / nb_drop_zones))
                painter.drawRect(subr)
                painter.drawText(
                    QPoint(10, int((i + 0.5) * vr.height() / nb_drop_zones)),
                    self._drop_zones_titles[i])
            return None
        else:
            return super(AnimatedTableView, self).paintEvent(pe)
Example #10
0
    def _draw_selected_items_in_series(self, painter):
        fm = painter.fontMetrics()

        pen = QPen()
        pen.setWidth(1)
        pen.setColor(Qt.GlobalColor.white)
        painter.setPen(pen)

        # We assume all series have the very same number of values
        # and all values on the same index are drawn on the same X
        # coordinate

        ndx_serie = self.best_serie_intra_ndx

        aesthetic_shift = 5

        if ndx_serie is not None:

            to_draw = []
            for i in range(len(self.data)):
                x, y = self._item_coordinates_lines(i, ndx_serie)
                #mainlog.debug("{} {}".format(ndx_serie,i))
                v = self.data[i][ndx_serie]

                text = str(int(v))

                to_draw.append( (self.y_base - y, text) )

            last_y = 100000
            for y, text in sorted( to_draw, key=lambda z : z[0], reverse=True):
                r = QRect(x + aesthetic_shift,0,1000,1000)
                bb = painter.boundingRect(r,Qt.AlignLeft,text)
                if bb.right() > self.width():
                    x = x - bb.width() - 2*aesthetic_shift# left align

                if y + bb.height() > last_y:
                    y = last_y - bb.height()

                fill_color = QColor(16, 16, 48)
                fill_color.setAlpha(196)
                brush = QBrush(fill_color)
                margin = 2
                r = QRect(x + aesthetic_shift - margin,
                          y - aesthetic_shift - bb.height() - margin,
                          bb.width() + 2*margin,
                          bb.height() + 2*margin)
                painter.fillRect(r, brush)

                painter.drawText(x + aesthetic_shift,
                                 y - aesthetic_shift,
                                 text)

                last_y = y

            x, y = self._item_coordinates_lines(0, ndx_serie)
            qp = QPainterPath()
            qp.moveTo(x, self.y_base)
            qp.lineTo(x, self.y_base - self.total_height)
            painter.drawPath(qp)
Example #11
0
    def draw_no_data(self, painter):
        text_pen = QPen()
        text_pen.setCapStyle(Qt.RoundCap)
        text_pen.setColor(QColor(128, 128, 128)) # alpha=255=fully opaque
        text_pen.setWidth(1)
        painter.setPen(text_pen)

        painter.setFont(self.title_font)
        r = QRect( self.margin, 0, self.width() - 2*self.margin, self.height())
        painter.drawText(r, (Qt.AlignCenter | Qt.AlignLeft) + Qt.TextWordWrap, _("No data"))
Example #12
0
    def _draw_serie(self, painter, ndx_serie, color):

        last_item = len(self.data) - 1

        serie = self.data[ndx_serie]

        serie_below = [0] * len(self.data[last_item])
        if ndx_serie < len(self.data) - 1:
            serie_below = self.data[ ndx_serie + 1 ]

        qlp = QPainterPath() # The top line path
        qfp = QPainterPath() # the filled region path


        x = float(0) * self.x_factor
        y = serie[0] * self.y_factor
        qlp.moveTo(self.x_base + x,self.y_base - y)
        qfp.moveTo(self.x_base + x,self.y_base - y)

        for i in range(1,len(serie)):
            x = float(i) * self.x_factor
            y = float(serie[i]) * self.y_factor

            #print i,y

            qlp.lineTo(self.x_base + x, self.y_base-y)
            qfp.lineTo(self.x_base + x, self.y_base-y)



        for i in reversed(range(0,len(serie_below))):
            x = float(i) * self.x_factor
            y = float(serie_below[i]) * self.y_factor

            qfp.lineTo(self.x_base + x, self.y_base-y)

        qfp.closeSubpath()


        fill_color = QColor(color)
        fill_color.setAlpha(64)
        brush = QBrush(fill_color)
        painter.fillPath(qfp,brush)

        pen = QPen()
        pen.setColor(color)
        if ndx_serie == self.ndx_best_serie:
            pen.setWidth(6)
        else:
            pen.setWidth(2)

        painter.setPen(pen)

        painter.drawPath(qlp)
Example #13
0
    def draw_title(self, painter):
        text_pen = QPen()
        text_pen.setCapStyle(Qt.RoundCap)
        text_pen.setColor(QColor(255, 255, 255)) # alpha=255=fully opaque
        text_pen.setWidth(1)
        painter.setPen(text_pen)

        painter.setFont(self.title_font)

        r = QRect(self.margin,0,self.width() - 2*self.margin,self.height())
        painter.drawText(r, Qt.AlignLeft + Qt.TextWordWrap, self.title)
Example #14
0
    def _draw_legend2(self, painter, labels):
        text_pen = QPen()
        text_pen.setCapStyle(Qt.RoundCap)
        text_pen.setColor(QColor(200, 200, 200)) # alpha=255=fully opaque
        text_pen.setWidth(1)

        highlighted_text_pen = QPen()
        highlighted_text_pen.setColor(QColor(255, 255, 255)) # alpha=255=fully opaque
        highlighted_text_pen.setWidth(1)

        line_pen = QPen()
        line_pen.setCapStyle(Qt.RoundCap)
        line_pen.setColor(QColor(200, 200, 200)) # alpha=255=fully opaque
        line_pen.setWidth(2)


        row = col = 0

        self.legend_labels_bounding_boxes = []

        for data_ndx, label in sorted( zip(range(len(labels)),labels), key=lambda a:a[1]):

            if label:
                # One can hide a series' legend by using a blank label

                x = self.margin + col * self.max_legend_label_width + 3
                y = self.legend_y_start + row * self.text_height

                # Draw coloured line

                line_pen.setColor(self.graph_colors[data_ndx % len(self.graph_colors)]) # alpha=255=fully opaque
                painter.setPen(line_pen)

                if data_ndx == self.ndx_best_serie:
                    r = QRect(x-3, y-self.text_height+3, self.max_legend_label_width, self.text_height)
                    painter.drawRect(r)
                    painter.setPen(highlighted_text_pen)
                else:
                    painter.drawLine(x,y+3,x+self.max_legend_label_width - 6,y + 3)
                    painter.setPen(text_pen)

                painter.drawText(x,y, label)

                # Remember text bounding box
                r = QRect(x,y - self.text_height, self.max_legend_label_width, self.text_height)
                bb = painter.boundingRect(r,Qt.AlignLeft,label)

                # if label == 'TV':
                #     painter.drawRect(r)

                self.legend_labels_bounding_boxes.append( (data_ndx,r) )


                if not (col < self.legend_labels_per_line - 1):
                    col = 0
                    row += 1
                else:
                    col += 1
Example #15
0
 def paint(self, painter, _, ___):
     ''' Draw the comment symbol '''
     rect = self.boundingRect()
     pen = QPen()
     pen.setStyle(Qt.DashLine)
     pen.setColor(Qt.darkGray)
     painter.setPen(pen)
     x, y, w, h = rect.x(), rect.y(), rect.width(), rect.height()
     if self.on_the_right:
         painter.drawLines([QPoint(w, y), QPoint(x, y),
                            QPoint(x, y), QPoint(x, h),
                            QPoint(x, h), QPoint(w, h)])
     else:
         painter.drawLines([QPoint(x, y), QPoint(w, y),
                            QPoint(w, y), QPoint(w, h),
                            QPoint(w, h), QPoint(x, h)])
Example #16
0
 def __init__(self, parent, child):
     ''' Create a new connection between a parent and a child item '''
     super(Connection, self).__init__(parent)
     self.parent = parent
     self.child = child
     self._start_point = None
     self._end_point = None
     self._middle_points = []
     pen = QPen()
     pen.setColor(Qt.blue)
     pen.setCosmetic(False)
     self.setPen(pen)
     self.parent_rect = parent.sceneBoundingRect()
     self.childRect = child.sceneBoundingRect()
     # Activate cache mode to boost rendering by calling paint less often
     self.setCacheMode(QGraphicsItem.DeviceCoordinateCache)
Example #17
0
 def __init__(self, parent, child):
     ''' Create a new connection between a parent and a child item '''
     super(Connection, self).__init__(parent)
     self.parent = parent
     self.child = child
     self._start_point = None
     self._end_point = None
     self._middle_points = []
     pen = QPen()
     pen.setColor(Qt.blue)
     pen.setCosmetic(False)
     self.setPen(pen)
     self.parent_rect = parent.sceneBoundingRect()
     self.childRect = child.sceneBoundingRect()
     # Activate cache mode to boost rendering by calling paint less often
     self.setCacheMode(QGraphicsItem.DeviceCoordinateCache)
 def draw_uvs(self):
     self.img = QPixmap(QSize(self.w, self.h))
     pen = QPen()
     pen.setWidth(int(self.pen_w.text()))
     pen.setBrush(QBrush(Qt.white))
     pen.setColor(QColor('white'))
     painter = QPainter()
     painter.begin(self.img)
     painter.setPen(pen)
     coords = self.get_coords()
     for face in coords:
         for n in xrange(len(face) - 1):
             print face[n][0], face[n][1], face[n + 1][0], face[n + 1][1]
             painter.drawLine(face[n][0], face[n][1], face[n + 1][0], face[n + 1][1])
     painter.end()
     self.view.scene().addPixmap(self.img)
Example #19
0
    def paintEvent(self, pe):

        # Those lines are from
        # http://stackoverflow.com/questions/18344135/why-do-stylesheets-not-work-when-subclassing-qwidget-and-using-q-object
        # the big idea is : According to the Qt help files, "Every widget displaying custom content must implement the paintEvent".

        o = QStyleOption()
        o.initFrom(self)
        p = QPainter(self)
        self.style().drawPrimitive(QStyle.PE_Widget, o, p, self)

        w = self.minimumWidth()

        pen = QPen()
        pen.setColor(QColor(128, 128, 192))
        # pen.setWidth(1)
        p.setPen(pen)
        p.drawLine(0, 0, max(0, self.width() - 1), self.height() - 1)
Example #20
0
    def paintEvent(self, event):
        painter = QtGui.QPainter(self)
        painter.setFont(self.font)

        # painter.setPen(QColor(200, 0, 100))#light grey
        painter.fillRect(event.rect(), self.background_color)

        p = QPen()
        p.setColor(QColor(100, 100, 100))
        painter.setPen(p)

        rect = event.rect()
        rect.adjust(0, -1, self.adjust_width, 1)
        painter.drawRect(rect)

        cw = self.parent()
        block = cw.firstVisibleBlock()
        blocknum = block.blockNumber()
        top = cw.blockBoundingGeometry(block).translated(
            cw.contentOffset()).top()
        bottom = top + int(cw.blockBoundingRect(block).height())

        lineno = self.start
        while block.isValid() and top <= event.rect().bottom():
            if block.isVisible() and bottom >= event.rect().top():
                if blocknum > 0:
                    text = block.text()
                    if not text.startswith(self.anti_tag):
                        painter.drawText(0, top,
                                         self.width() - 2,
                                         self.fontMetrics().height(),
                                         QtCore.Qt.AlignRight, str(lineno))
                        lineno += 1
                else:
                    painter.drawText(0, top,
                                     self.width() - 2,
                                     self.fontMetrics().height(),
                                     QtCore.Qt.AlignRight, '...')

            block = block.next()
            top = bottom
            bottom = top + int(cw.blockBoundingRect(block).height())
            blocknum += 1
Example #21
0
    def _draw_y_axis(self,painter, y_base, width, height, steps):

        text_pen = QPen()
        text_pen.setCapStyle(Qt.RoundCap)
        text_pen.setColor(QColor(200, 200, 200)) # alpha=255=fully opaque
        text_pen.setWidth(1)
        painter.setPen(text_pen)


        if self.rounded_step_size < 1:
            fmt = "{:.1f}"
        else:
            fmt = "{:.0f}"

        if self.rounded_step_size > 0:
            for i in range(int(self.maxi / self.rounded_step_size) + 1):

                y = y_base - self.rounded_step_size * i * self.y_factor
                painter.drawText(self.margin,y, fmt.format(self.rounded_step_size * i))
Example #22
0
    def paintEvent(self, event):
        painter = QtGui.QPainter(self)
        painter.setFont(self.font)

        # painter.setPen(QColor(200, 0, 100))#light grey
        painter.fillRect(event.rect(), self.background_color)

        p=QPen()
        p.setColor(QColor(100,100,100))
        painter.setPen(p)

        rect=event.rect()
        rect.adjust(0,-1, self.adjust_width,1)
        painter.drawRect(rect)

        cw = self.parent()
        block = cw.firstVisibleBlock()
        blocknum = block.blockNumber()
        top = cw.blockBoundingGeometry(block).translated(
            cw.contentOffset()).top()
        bottom = top + int(cw.blockBoundingRect(block).height())

        lineno=self.start
        while block.isValid() and top <= event.rect().bottom():
            if block.isVisible() and bottom >= event.rect().top():
                if blocknum>0:
                    text=block.text()
                    if not text.startswith(self.anti_tag):
                        painter.drawText(0, top, self.width() - 2,
                                         self.fontMetrics().height(),
                                         QtCore.Qt.AlignRight, str(lineno))
                        lineno+=1
                else:
                    painter.drawText(0, top, self.width() - 2,
                                     self.fontMetrics().height(),
                                     QtCore.Qt.AlignRight, '...')

            block = block.next()
            top = bottom
            bottom = top + int(cw.blockBoundingRect(block).height())
            blocknum += 1
Example #23
0
    def paintEvent(self, pe):
        if self.left_view and self.right_view and self.right_view.model():
            vr = self.left_view.visualRect(self.left_view.currentIndex())

            self.left_top = self.mapFromGlobal(
                self.left_view.viewport().mapToGlobal(vr.topRight())).y()
            self.left_bottom = self.mapFromGlobal(
                self.left_view.viewport().mapToGlobal(vr.bottomRight())).y()

            vr_top = self.right_view.visualRect(self.right_view.model().index(
                0, 0))
            vr = self.right_view.visualRect(self.right_view.model().index(
                self.right_view.model().rowCount() - 1, 0))

            self.right_top = self.mapFromGlobal(
                self.left_view.viewport().mapToGlobal(vr_top.topLeft())).y()
            self.right_bottom = self.mapFromGlobal(
                self.left_view.viewport().mapToGlobal(vr.bottomLeft())).y()

            w = self.minimumWidth() - 1

            p = QPainter(self)
            p.setBrush(QBrush(QColor(210, 255, 210)))

            pen = QPen()
            pen.setColor(Qt.transparent)
            p.setPen(pen)

            poly = QPolygon()
            poly.append(QPoint(0, self.left_top))
            poly.append(QPoint(w, self.right_top))
            poly.append(QPoint(w, self.right_bottom))
            poly.append(QPoint(0, self.left_bottom))
            p.drawConvexPolygon(poly)

            p.setRenderHint(QPainter.Antialiasing)
            pen.setColor(Qt.GlobalColor.black)
            pen.setWidth(2)
            p.setPen(pen)
            p.drawLine(0, self.left_top, w, self.right_top)
            p.drawLine(0, self.left_bottom, w, self.right_bottom)
Example #24
0
    def drawLines(self, qp):
        pen = QPen(Qt.black, 2, Qt.SolidLine)
        qp.setPen(pen)

        qp.drawRect(self.rect().left(),
                    self.rect().top(),
                    self.rect().width(),
                    self.rect().height())

        qp.drawLine(self.dd.x() + 155,
                    self.dd.y() + 5,
                    self.dd.x() + 250,
                    self.dd.y() + 5)
        pen.setStyle(Qt.DashLine)
        qp.setPen(pen)
        qp.drawLine(self.ud.x() + 155,
                    self.ud.y() + 5,
                    self.ud.x() + 250,
                    self.ud.y() + 5)
        pen.setStyle(Qt.SolidLine)
        pen.setColor(Qt.red)
        qp.setPen(pen)
        qp.drawLine(self.unid.x() + 155,
                    self.unid.y() + 5,
                    self.unid.x() + 250,
                    self.unid.y() + 5)
        pen.setColor(Qt.yellow)
        qp.setPen(pen)
        qp.drawRect(self.sel.x() + 155, self.sel.y(), 95, 20)
        pen.setColor(Qt.green)
        qp.setPen(pen)
        qp.drawRect(self.leaf.x() + 155, self.leaf.y(), 95, 20)
Example #25
0
    def _draw_peak_values(self, painter, labels):
        #mainlog.debug('_draw_peak_values : {}'.format(labels))
        text_pen = QPen()
        text_pen.setCapStyle(Qt.RoundCap)
        text_pen.setColor(Qt.GlobalColor.white) # alpha=255=fully opaque
        text_pen.setWidth(1)
        fm = painter.fontMetrics()

        rects = []

        painter.setPen(text_pen)

        # The sort allow to draw the peak values which are lower first.
        # We do that to visually connect a peak value to its bar in a
        # (hopefully) better way

        for i in sorted( range(len(labels)), key=lambda i:self._item_coordinates(i)[1]):
            x, y_top, y_below = self._item_coordinates(i)

            label = labels[i]

            w = fm.boundingRect(label).width()
            h = fm.boundingRect(label).height()

            r = QRect(self.x_centers[i] - int(w/2), self.y_base-y_top - 5 - h, w, h)

            i = 0
            while i < len(rects):
                old_r = rects[i]
                if r.intersect(old_r):
                    i = 0
                    # Move r atop old_r
                    r.translate(0, -(r.bottom() - old_r.y()) - 2)
                else:
                    i += 1
            rects.append(r)

            self._draw_box_under_text(painter, r.x(), r.y() + h,label)
            painter.drawText( r.x(), r.y() + h,label)
Example #26
0
    def paintEvent(self, pe):

        if not self.enlightened.isVisible() or not self.enabled:
            return

        g = self.enlightened.mapToGlobal(QPoint(0, 0))
        pos = self.parent().mapFromGlobal(g)
        self.setGeometry(
            QRect(pos.x(), pos.y(), self.minimumWidth(), self.minimumHeight()))

        p = QPainter(self)
        p.setRenderHint(QPainter.Antialiasing)

        pen = QPen()
        pen.setColor(QColor(128, 128, 255))
        pen.setWidth(2)

        p.setBrush(QBrush(QColor(225 + math.sin(self.progress) * 30, 225,
                                 255)))
        self.progress += 0.09 * 2
        self.progress2 += 0.109 * 2

        p.setPen(pen)

        s = 10
        sz = 7
        w = s * 1.1 + sz
        p.drawEllipse(0 + s * math.sin(self.progress + 0.5) + w,
                      s * math.cos(self.progress) + w, sz, sz)

        p.drawEllipse(s * 1.1 * math.sin(self.progress2) + w,
                      s * math.cos(self.progress + 0.5) + w, sz - 2, sz - 2)

        p.drawEllipse(
            s * math.sin(self.progress + 1) + w,
            s * 1.1 * math.cos(self.progress2 / 2 + self.progress / 2) + w,
            sz - 4, sz - 4)
Example #27
0
    def _draw_grid(self,painter, y_base, width, height, steps):

        m = int(self.maxi / self.rounded_step_size)

        if self.timer.isActive():
            self.gride_lines_number = self.timer_ticks

            if self.gride_lines_number >= m:
                self.timer.stop()
        else:
            self.gride_lines_number = m


        for i in range( self.gride_lines_number + 2):
            qp = QPainterPath()
            #mainlog.debug("self.rounded_step_size = {}, self.maxi={}".format(self.rounded_step_size, self.maxi))
            y = y_base - self.rounded_step_size * i * self.y_factor
            qp.moveTo(0,y)

            # A bit of shuffle on y for visual effect
            qp.lineTo(width,y + (i % 3) - 1)

            pen = QPen()
            pen.setCapStyle(Qt.RoundCap)
            pen.setColor(QColor(0, 0, 25)) # alpha=255=fully opaque
            pen.setWidth(5)
            painter.setPen(pen)

            painter.drawPath(qp)

            pen = QPen()
            pen.setCapStyle(Qt.RoundCap)
            pen.setColor(QColor(30, 30, 30)) # alpha=255=fully opaque
            pen.setWidth(1)
            painter.setPen(pen)

            painter.drawPath(qp)
Example #28
0
    def paintEvent(self, event):
        painter = QPainter(self)

        # Фон
        painter_path = QPainterPath()
        painter_path.addRect(0, 0, self.width() - 1, self.height() - 1)
        painter.fillPath(painter_path, QBrush(QImage(':/main/background.png')))

        if self.image:
            painter.drawText(10, 20, str(self.image.draw_scale))

            painter.setTransform(QTransform().scale(
                self.image.draw_scale,
                self.image.draw_scale).translate(self.image.draw_offset.x(),
                                                 self.image.draw_offset.y()))
            old_pen = painter.pen()

            new_pen = QPen()
            new_pen.setColor(QColor(0, 150, 0))
            painter.setPen(new_pen)

            self.image.draw(painter)

            painter.setPen(old_pen)
    def paintEvent(self, event):
        painter = QPainter(self)

        # Фон
        painter_path = QPainterPath()
        painter_path.addRect(0, 0, self.width() - 1, self.height() - 1)
        painter.fillPath(painter_path,
                         QBrush(QImage(':/main/background.png')))

        if self.image:
            painter.drawText(10, 20, str(self.image.draw_scale))

            painter.setTransform(QTransform().
                                 scale(self.image.draw_scale, self.image.draw_scale).
                                 translate(self.image.draw_offset.x(), self.image.draw_offset.y()))
            old_pen = painter.pen()

            new_pen = QPen()
            new_pen.setColor(QColor(0, 150, 0))
            painter.setPen(new_pen)

            self.image.draw(painter)

            painter.setPen(old_pen)
Example #30
0
class LinesChart(QFrame):

    graph_colors = [Qt.GlobalColor.white, Qt.GlobalColor.blue, Qt.GlobalColor.red, Qt.GlobalColor.darkRed, Qt.GlobalColor.green, Qt.GlobalColor.darkGreen, Qt.GlobalColor.yellow]


    def __init__(self,parent=None):
        super(LinesChart,self).__init__(parent)

        self.timer = QTimer(self)
        self.timer.timeout.connect(self.timer_tick) # timerUpdate)
        self.timer.start(400)
        self.timer_ticks = 0

        self.gride_lines_number = 0
        self._create_pens()
        self.stacked = False
        self.title = "Sic transit gloria mundi"
        self.title_font = self.thinfont = QFont("Arial",10,QFont.Bold)

        self.margin = 10
        self.total_width = 0
        self.legend_labels_bounding_boxes = []

        self.ndx_best_serie = -1
        self.best_serie_intra_ndx = None
        self.no_draw = True # Set to True if we can't draw (because of numerical problems or non initialized data for example)
        self.data = None

        # When set to true, if the x axis values are dates
        # then, they'll be shown as month (so intead of 31/12/2014,
        # you'll get something like 12/14)
        self.x_axis_as_months = False
        self.set_mini_maxi(None, None)
        self.set_horizontal_ruler(None,None)

        self.forced_maxi = None
        self.forced_mini = None

    def set_title(self,t):
        self.title = t

    def timer_tick(self):
        self.timer_ticks += 1
        self.update()

    def set_data(self,x_legends, legends,data):
        """ Sets the data to draw.

        :param x_legends: Labels to write on the X axis
        :param series_legends: Name of the various series.
        :param data: a list of series; each serie is a list of tuples : (x_coordinate, value).
        :return:
        """

        mainlog.debug("({}) line_chart : set_data".format(self.title))
        mainlog.debug(data)
        if len(legends) != len(data):
            raise Exception("The number of legends for data series ({}) is different than the number of series ({})".format(len(legends),len(data)))

        self.legends = legends
        self.x_legends = x_legends
        self.original_data = self.data = data

        # Compute the smallest and greatest value of the dataset

        # if self.forced_maxi == None and self.forced_mini == None:
        self.mini = 9999999999
        self.maxi = 0

        for l in self.data:
            if l:
                # There can be some None in the list, or the list might
                # even by made only of None's !
                filtered = [x or 0 for x in l]
                if filtered:
                    self.mini = min(min( filtered),self.mini)
                    self.maxi = max(max( filtered),self.maxi)

        self.mini, self.maxi = self.clip_mini_maxi( self.mini, self.maxi)
        # if self.mini == self.maxi and self.forced_mini != None and self.forced_maxi != None:
        #     self.mini, self.maxi = self.forced_mini, self.forced_maxi

        # Compute the sum of each "column" of data

        summed = [0] * len( data[0] )
        for l in data:
            if l:
                summed = [(x or 0) + (y or 0) for x,y in zip(summed,l)]
        self.summed = summed

        self.highlighted_serie = None


    def clip_mini_maxi(self, mini, maxi):
        mainlog.debug("({}) Clipping {} {}, forced:{} {}".format( self.title, type(mini), type(maxi), type(self.forced_mini), type(self.forced_maxi)))
        if self.forced_mini != None and self.forced_maxi != None:
            mainlog.debug("Clipping to forced values {} {}".format( self.forced_mini, self.forced_maxi))
            mini, maxi = min( mini, self.forced_mini), max( maxi, self.forced_maxi)
            return mini, maxi
        else:
            mainlog.debug("Clipping no clipping :{} {}".format(mini, maxi))
            return mini, maxi

    def sizeHint(self):
        # QSizePolicy.expanding doesn't exapand as much as I want,
        # so I push myself :-)
        return QSize(4000,300)

    def _compute_legend_lengths(self, painter, legends):

        self.max_legend_label_width = 0
        fm = painter.fontMetrics()
        for label in legends:
            self.max_legend_label_width = max(fm.boundingRect(label).width(),
                                              self.max_legend_label_width)

        self.space_between_legend_labels = 10
        self.max_legend_label_width += self.space_between_legend_labels # a bit of room

        self.legend_labels_per_line = int(self.total_width / self.max_legend_label_width)
        if self.total_width % self.max_legend_label_width > 0:
            self.legend_labels_per_line += 1

        self.legend_lines = len(legends) / self.legend_labels_per_line
        if len(legends) % self.legend_labels_per_line > 0:
            self.legend_lines += 1

        self.legend_height = self.text_height * self.legend_lines


    def _compute_x_centers(self, nb_x, available_width):

        #  ----------------------------- 29
        #  __1__ __2__ __3__ __4__ __5__
        # 29/5 = 5.8
        #   2.9,  8.7, 14.5, 20.3, 26.1

        # mainlog.debug("_compute_x_centers({}, {})".format(nb_x, available_width))

        if nb_x == 0:
            return []

        step_width = float(available_width) / float(nb_x)

        all_x = []
        for i in range(nb_x):
            all_x.append( self.x_base + step_width/2 + i * step_width )

        return all_x

    def _compute_screen_lengths(self,painter,mini,maxi,x_steps):
        """

        :param painter: QPainter
        :param mini: Minimum value that will be displayed on the Y axis
        :param maxi: Maximum value that will be displayed on the Y axis
        :param x_steps: Number of steps on the X axis
        :return:
        """

        if x_steps > 0:
            assert 0 <= mini <= maxi, "We should have 0 <= {} <= {}".format(mini, maxi)


        # Measure regular font height
        fm = painter.fontMetrics()
        h = fm.boundingRect("A9j").height()
        self.text_height = h

        # Measure y_axis labels max width
        self.y_axis_label_width = fm.boundingRect(str(int(self.maxi))+"M").width()

        # Measure title font height
        base_font = painter.font()
        painter.setFont(self.title_font)
        r = QRect(self.margin,0,self.width() - 2*self.margin,self.height())
        bb = painter.boundingRect(r,Qt.AlignLeft+Qt.TextWordWrap,self.title)
        painter.setFont(base_font)


        self.total_width = self.width() - 2*self.margin - self.y_axis_label_width

        # Lengths of the legend
        self._compute_legend_lengths(painter, self.legends)
        self.legend_y_start = self.margin + bb.height()

        # Distance between top of widget and top of chart
        self.yoffset = self.margin + bb.height() + self.legend_height

        self.total_height = self.height() - self.yoffset - self.margin - self.text_height

        # print total_width,total_height

        # Go from actual value to a screen position (without offset, see x/y_base)
        d = max(maxi,maxi - mini)
        self.no_draw = self.total_width < 1 or self.total_height < 1 or d <= 0
        if self.no_draw:
            mainlog.debug("No draw because d:{} (mini {}, maxi {}) total_width:{} total_height:{}".format(d, mini, maxi, self.total_width, self.total_height ))
            return

        self.y_factor = float(min(self.total_height,self.total_width)) / d
        self.y_factor = float(self.total_height) / d

        if x_steps <= 3:
            self.x_factor = float(self.total_width) / float(3-1)

        elif x_steps > 1:
            self.x_factor = float(self.total_width) / float(x_steps - 1)

        else:
            self.x_factor = 0

        # self.x_axis_offset = max(0, (self.total_width -  x_steps * self.x_factor)/2)
        self.x_axis_offset = 0

        # print self.maxi,self.mini,self.y_factor

        # The axis positions
        self.y_base = float(maxi) * self.y_factor + self.yoffset
        self.x_base = self.margin + self.y_axis_label_width + self.x_axis_offset



        # Now we compute the vertical axis step size.
        # Remember the graph is fit in the window

        # First we want each step to display a human firendly
        # value (so, no 12.3462, 24.68... but 10, 20, 30...)
        # And we start with an arbitrary number of steps

        # if self.mini == self.maxi:
        #     steps = 6
        #     self.rounded_step_size = int(10 ** round(math.log10(self.maxi / steps))) or 1
        # else:
        #     steps = min(6, self.maxi - self.mini) or 1
        #     self.rounded_step_size = int(10 ** round(math.log10( (self.maxi - self.mini) / steps))) or 1
        #
        #
        # if self.rounded_step_size > 1:
        #
        #     # MAke sure the step size is small enough to have "steps" steps.
        #
        #     while int(self.maxi / self.rounded_step_size) < steps:
        #         self.rounded_step_size = int(self.rounded_step_size / 2)
        #
        #     # Second, make sure the step is tall enough to let the text in
        #
        #     while h > self.rounded_step_size * self.y_factor:
        #         # mainlog.debug("{} > {} * {}".format(h, self.rounded_step_size, self.y_factor))
        #         self.rounded_step_size = self.rounded_step_size * 2
        #
        # if self.maxi > 0:
        #     step_size = (10 ** int(math.log10(self.maxi - 0.00001))) or 1
        #     mainlog.debug("Maxi={} Actual {}, new {}".format(self.maxi,self.rounded_step_size,step_size))
        #     self.rounded_step_size = step_size
        # else:
        #     mainlog.debug("zero")

        log10 = math.log10( self.maxi)

        # This fix to make sure there is more than one step
        # in case the maxi is aligned on a power of 10.
        # In this case there will be 10 steps.

        if log10 - int(log10) == 0:
            fix = -1
        else:
            fix = 0

        step_size = 10 ** int(math.floor(log10) + fix)

        # If we rely only on power of 10, we might end up
        # with a small number of steps (e.g. 2). That is
        # correct but unpleasant to look at. To avoid
        # this, I increase the size of steps to reach
        # a minimum number of steps.
        # Dividing by two a power of 10 make sure we'll keep
        # "human readable" steps (1/2, 1/4, 1/8,...)

        MINIMUM_NUMBER_OF_STEPS = 4

        while self.maxi / step_size < MINIMUM_NUMBER_OF_STEPS:  # number of steps < MINIMUM_NUMBER_OF_STEPS
            step_size = step_size / 2

        # Second, make sure the step is tall enough to let the text in

        while h > step_size * self.y_factor:
            # mainlog.debug("{} > {} * {}".format(h, self.rounded_step_size, self.y_factor))
            step_size = step_size * 2

        self.rounded_step_size = step_size

        self.x_centers = self._compute_x_centers(len(self.data[0]), self.total_width)

    def _compute_lengths(self,painter):
        self._compute_screen_lengths(painter,self.mini,self.maxi,len(self.data[0]))


    def leaveEvent( self, q_leave_event):
        if self.ndx_best_serie:
            self.ndx_best_serie = -1
            self.update()


    def leaveEvent(self, event):
        self.ndx_best_serie = None
        self.best_serie_intra_ndx = None
        self.update()

    def mouseMoveEvent ( self, q_mouse_event):
        if not self.data or self.no_draw:
            return

        p = q_mouse_event.pos()

        # No need to highlight a serie if there's only one
        # in the graph.

        self.ndx_best_serie = -1
        self.best_serie_intra_ndx = None

        if len(self.data) >= 1:

            ndx,serie = self._locate_legend(p.x(), p.y())
            if not serie:
                # mainlog.debug("Trying to locate on graph")
                serie,self.best_serie_intra_ndx = self.locate_serie(None, p.x(), p.y())
                if serie:
                    #mainlog.debug("Located serie : {}".format(serie))
                    ndx = self.data.index(serie)

                # 2014/04/14 13:45:43 [DEBUG]   Locate legend data_ndx:2 TO 77481144 - 20
                # 2014/04/14 13:45:43 [DEBUG]   mouseMove : Highlighting another serie found ndx:1 locate_ndx:2 77481144
                # 2014/04/14 13:45:43 [DEBUG]   _draw_legend: Highlighting serie ndx=1 77481144

            if serie and self.ndx_best_serie != ndx:
                self.ndx_best_serie = ndx # self.data.index(serie)
                # mainlog.debug("mouseMove : Highlighting another serie found ndx:{} locate_ndx:{} {} loacte:{}".format(self.ndx_best_serie, ndx, id(serie), id(self.data[ndx])))
                self.update()


    def _locate_legend(self, x, y):

        for i in range(len(self.legend_labels_bounding_boxes)):
            data_ndx,bb = self.legend_labels_bounding_boxes[i]
            if bb.contains(x,y):
                # mainlog.debug(u"Locate legend data_ndx:{} {} {} - {}".format( data_ndx,self.legends[data_ndx], id(self.data[data_ndx]),i))
                return data_ndx, self.data[data_ndx]

        return None,None


    def locate_serie(self, painter, x, y):
        """ Find the serie which is closes to the x,y point
        """

        if len(self.x_legends) <= 1:
            return None, None

        # y = self.height() - y

        screen_x_step = float(self.total_width) / len(self.x_legends)

        # The x corrdinates can be outside the graph area.
        # So I use som min and max to have an index in the serie's range
        x_ndx = min(len(self.data[0])-1,
                    int(max(0, (x - self.margin - self.y_axis_label_width) / screen_x_step)))
        x_ndx1 = min( len(self.data[0])-1,
                      x_ndx+1)


        delta_x = x - self.margin - self.y_axis_label_width - (x_ndx * screen_x_step )

        # print "{}-{} -> {} - {} d={}".format(x,y,x_ndx,x_ndx1,delta_x)

        best_d = 999999999
        best_serie = None

        for serie in self.data:
            if serie[x_ndx] is not None and serie[x_ndx1] is not None:
                y0 = serie[x_ndx] * self.y_factor
                y1 = serie[x_ndx1] * self.y_factor

                # Screen slope
                slope = (y1 - y0)  / screen_x_step
                sy =  self.y_base - ( y0 + slope * delta_x)

                d = (sy - y ) ** 2
                # print d

                if d < best_d:
                    best_d = d
                    best_serie = serie

        return best_serie,x_ndx



    def _item_coordinates_lines(self, ndx_serie, ndx_in_serie):

        assert ndx_serie >= 0 and ndx_serie < len(self.data), "Incorrect ndx_serie ({})".format(ndx_serie)
        serie = self.data[ndx_serie]

        x = self.x_centers[ndx_in_serie]
        y_top = float(serie[ndx_in_serie]) * self.y_factor

        return x, y_top


    def _draw_selected_items_in_series(self, painter):
        fm = painter.fontMetrics()

        pen = QPen()
        pen.setWidth(1)
        pen.setColor(Qt.GlobalColor.white)
        painter.setPen(pen)

        # We assume all series have the very same number of values
        # and all values on the same index are drawn on the same X
        # coordinate

        ndx_serie = self.best_serie_intra_ndx

        aesthetic_shift = 5

        if ndx_serie is not None:

            to_draw = []
            for i in range(len(self.data)):
                x, y = self._item_coordinates_lines(i, ndx_serie)
                #mainlog.debug("{} {}".format(ndx_serie,i))
                v = self.data[i][ndx_serie]

                text = str(int(v))

                to_draw.append( (self.y_base - y, text) )

            last_y = 100000
            for y, text in sorted( to_draw, key=lambda z : z[0], reverse=True):
                r = QRect(x + aesthetic_shift,0,1000,1000)
                bb = painter.boundingRect(r,Qt.AlignLeft,text)
                if bb.right() > self.width():
                    x = x - bb.width() - 2*aesthetic_shift# left align

                if y + bb.height() > last_y:
                    y = last_y - bb.height()

                fill_color = QColor(16, 16, 48)
                fill_color.setAlpha(196)
                brush = QBrush(fill_color)
                margin = 2
                r = QRect(x + aesthetic_shift - margin,
                          y - aesthetic_shift - bb.height() - margin,
                          bb.width() + 2*margin,
                          bb.height() + 2*margin)
                painter.fillRect(r, brush)

                painter.drawText(x + aesthetic_shift,
                                 y - aesthetic_shift,
                                 text)

                last_y = y

            x, y = self._item_coordinates_lines(0, ndx_serie)
            qp = QPainterPath()
            qp.moveTo(x, self.y_base)
            qp.lineTo(x, self.y_base - self.total_height)
            painter.drawPath(qp)


    def _draw_serie(self, painter, ndx_serie, color):

        serie = self.data[ndx_serie]

        if not serie:
            return

        qp = QPainterPath()
        # qp.addRect(2,2,total_width-4,total_height-4)

        x = float(0) * self.x_factor
        y = serie[0] * self.y_factor
        qp.moveTo(self.x_centers[0],self.y_base - y)
        # print y_base

        for i in range(1,len(serie)):
            x = float(i) * self.x_factor
            y = float(serie[i]) * self.y_factor

            qp.lineTo(self.x_centers[i], self.y_base-y)

        pen = QPen()
        pen.setColor(color)

        if ndx_serie == self.ndx_best_serie:
            pen.setWidth(6)
        else:
            pen.setWidth(2)

        painter.setPen(pen)
        painter.drawPath(qp)



        # self.max_legend_label_width = 0
        # fm = painter.fontMetrics()
        # for label in legends:
        #     self.max_legend_label_width = max(fm.boundingRect(label).width(),
        #                                       self.max_legend_label_width)

        # self.max_legend_label_width += 10 # a bit of room

        # self.legend_labels_per_line = int(self.total_width / self.max_legend_label_width)
        # self.legend_lines = len(legends) / self.legend_labels_per_line
        # if len(legends) % self.legend_labels_per_line > 0:
        #     self.legend_lines += 1

        # self.legend_height = self.text_height * self.legend_lines

    def _draw_legend2(self, painter, labels):
        text_pen = QPen()
        text_pen.setCapStyle(Qt.RoundCap)
        text_pen.setColor(QColor(200, 200, 200)) # alpha=255=fully opaque
        text_pen.setWidth(1)

        highlighted_text_pen = QPen()
        highlighted_text_pen.setColor(QColor(255, 255, 255)) # alpha=255=fully opaque
        highlighted_text_pen.setWidth(1)

        line_pen = QPen()
        line_pen.setCapStyle(Qt.RoundCap)
        line_pen.setColor(QColor(200, 200, 200)) # alpha=255=fully opaque
        line_pen.setWidth(2)


        row = col = 0

        self.legend_labels_bounding_boxes = []

        for data_ndx, label in sorted( zip(range(len(labels)),labels), key=lambda a:a[1]):

            if label:
                # One can hide a series' legend by using a blank label

                x = self.margin + col * self.max_legend_label_width + 3
                y = self.legend_y_start + row * self.text_height

                # Draw coloured line

                line_pen.setColor(self.graph_colors[data_ndx % len(self.graph_colors)]) # alpha=255=fully opaque
                painter.setPen(line_pen)

                if data_ndx == self.ndx_best_serie:
                    r = QRect(x-3, y-self.text_height+3, self.max_legend_label_width, self.text_height)
                    painter.drawRect(r)
                    painter.setPen(highlighted_text_pen)
                else:
                    painter.drawLine(x,y+3,x+self.max_legend_label_width - 6,y + 3)
                    painter.setPen(text_pen)

                painter.drawText(x,y, label)

                # Remember text bounding box
                r = QRect(x,y - self.text_height, self.max_legend_label_width, self.text_height)
                bb = painter.boundingRect(r,Qt.AlignLeft,label)

                # if label == 'TV':
                #     painter.drawRect(r)

                self.legend_labels_bounding_boxes.append( (data_ndx,r) )


                if not (col < self.legend_labels_per_line - 1):
                    col = 0
                    row += 1
                else:
                    col += 1



    def _draw_legend(self, painter, labels):
        text_pen = QPen()
        text_pen.setCapStyle(Qt.RoundCap)
        text_pen.setColor(QColor(200, 200, 200)) # alpha=255=fully opaque
        text_pen.setWidth(1)

        highlighted_text_pen = QPen()
        highlighted_text_pen.setColor(QColor(255, 255, 255)) # alpha=255=fully opaque
        highlighted_text_pen.setWidth(1)

        line_pen = QPen()
        line_pen.setCapStyle(Qt.RoundCap)
        line_pen.setColor(QColor(200, 200, 200)) # alpha=255=fully opaque
        line_pen.setWidth(2)

        max_width = 0
        fm = painter.fontMetrics()
        for label in labels:
            max_width = max(fm.boundingRect(label).width(), max_width)

        y_room = int(self.height() * 0.5 / self.text_height)

        nb_columns = int( len(labels)  / y_room)
        if len(labels) % y_room > 0:
            nb_columns += 1

        y_room = y_room * self.text_height

        x = self.margin + self.total_width - nb_columns * (max_width + 10)



        # 100 / 20 = 5 entry per column
        # 17 / 5 = 3 => 4 columns
        # print self.height() * 0.5, "  ", len(labels), "   ", nb_columns, " y_room:", y_room

        y = 0
        i = 0
        y_offset = self.yoffset
        self.legend_labels_bounding_boxes = []

        # Draw a background rectanlge behin the legend

        fill_color = QColor(16,16,48)
        fill_color.setAlpha(196)
        brush = QBrush(fill_color)

        h = y_room
        w = nb_columns * (max_width + 10)
        if nb_columns == 1:
            h = len(labels) * self.text_height

        r = QRect(x-3, y_offset - self.text_height , w, h + 6)
        painter.fillRect(r,brush)

        sorted_labels = sorted( zip( range(len(labels)), labels, map(id,self.data)),
                                lambda a,b:cmp(a[1],b[1]))

        # mainlog.debug( sorted_labels)

        # We sort labels on their names (but keep the indices right)
        for data_ndx, label in sorted( zip(range(len(labels)),labels), lambda a,b:cmp(a[1],b[1])):

            # Draw coloured line

            line_pen.setColor(self.graph_colors[data_ndx % len(self.graph_colors)]) # alpha=255=fully opaque
            painter.setPen(line_pen)

            if data_ndx == self.ndx_best_serie:
                r = QRect(x-3, y_offset+ y-self.text_height+3, max_width + 6, self.text_height)
                painter.drawRect(r)
                painter.setPen(highlighted_text_pen)
            else:
                painter.drawLine(x,y_offset+y+3,x+max_width,y_offset+y + 3)
                painter.setPen(text_pen)

            painter.drawText(x,y_offset+y,label)

            # Remember text bounding box
            r = QRect(x,y_offset+y - self.text_height,max_width,self.text_height)

            # if label == "TO":
            #    painter.drawRect(r)

            bb = painter.boundingRect(r,Qt.AlignLeft,label)
            # bb.adjust(-5,-5,+5,+5)
            # print label,label_ndx,r.x(), r.y(), r.width(), r.height()

            self.legend_labels_bounding_boxes.append( (data_ndx,bb) )


            if y >= y_room - self.text_height:
                y = 0
                x += max_width + 10
            else:
                y += self.text_height


            i += 1





    def _create_pens(self):
        self.axis_text_pen = QPen()
        self.axis_text_pen.setCapStyle(Qt.RoundCap)
        self.axis_text_pen.setColor(QColor(200, 200, 200)) # alpha=255=fully opaque
        self.axis_text_pen.setWidth(1)


    def _draw_x_axis_dates(self, painter, l):

        def months_between(a,b):
            """ Nb of months, inclusive.
            """

            if a > b:
                a,b = b,a

            if a.year == b.year:
                return b.month - a.month + 1
            else:
                m = (12 - a.month + 1) + (b.month + 1)
                my = (b.year - a.year - 1) * 12

                return m + my


        if not l or len(l) <= 2:
            return l

        fm = painter.fontMetrics()
        char_width = fm.boundingRect("9").width()
        nbchars = self.total_width / char_width

        nb_days = (l[-1] - l[0]).days
        if nb_days <= 10 and not self.x_axis_as_months:
            return l

        # mainlog.debug("Too many days")

        nb_months = months_between(l[0], l[-1])
        if nb_months < (nbchars / len("MM/YY")):

            old_d = l[0]
            nl = [short_my(old_d)] # Will have the same length as l

            # print l[1:-1]

            for d in l[1:len(l)]:
                if d.month != old_d.month:
                    if d.year != old_d.year:
                        nl.append(short_my(d))
                    else:
                        nl.append(str(d.month))
                    old_d = d
                else:
                    nl.append("")

            if len(l) != len(nl):
                mainlog.error("something is wrong")

            return nl

        mainlog.debug("Too many months")

        nb_years = l[-1].year - l[0].year + 1

        old_d = l[0]
        nl = [short_my(old_d)] # Will have the same length as l

        for d in l[1:len(l)]:
            if d.year != old_d.year:
                nl.append(short_my(d))
                old_d = d
            else:
                nl.append("")

        return nl


    def _draw_x_axis(self, painter, labels):

        if not labels:
            return

        if isinstance(labels[0],date):

            # In this case we expect to have, for example, a label per day
            # Of course that's too many to draw, hence this "dithering"

            dithered_labels = []

            # 12 expresses a "density" which allows us to switch between days and month
            # steps. Ideally we should generalize that to weeks, years...

            if len(labels) > 12:
                dithered_labels.append(labels[0])

                for i in range(1,len(labels)):
                    if labels[i].month != labels[i-1].month:
                        dithered_labels.append(labels[i])
                    else:
                        dithered_labels.append(None)
                labels = dithered_labels

                # mainlog.debug(labels)

            def short_my(d):
                if d:
                    return u"{}/{:0>02}".format(d.month,d.year % 100)
                else:
                    return ""

            # labels = self._draw_x_axis_dates(painter, labels)
            # labels = [short_my(l) for l in labels]

            old_d = labels[0]
            nl = [short_my(old_d)] # Will have the same length as l

            for d in labels[1:len(labels)]:
                if d and d.month != old_d.month:
                    if d.year != old_d.year:
                        nl.append(short_my(d))
                    else:
                        nl.append(str(d.month))
                    old_d = d
                else:
                    nl.append("") # Dithering == cleraing unwanted values

            labels = nl

        max_height = 0
        total_label_width = 0

        fm = painter.fontMetrics()
        for label in labels:
            br = fm.boundingRect(str(label))
            max_height = max(br.height(), max_height)
            total_label_width += br.width()

        painter.setPen(self.axis_text_pen)

        last_x = -1
        last_label = None

        for i in range(len(labels)):
            label = str(labels[i])
            w = fm.boundingRect(label).width()
            x = self.x_centers[i] - w / 2

            # Somehow, the width of an empty string is not 0 :-)
            if label and last_label != label and x > last_x:
                # Avoid that this label overlaps the previous one
                painter.drawText(x, self.y_base + max_height, label)
                last_x = x + w - 1
                last_label = label

            if label:
                painter.drawLine(self.x_centers[i], self.y_base + 2, self.x_centers[i], self.y_base - 2)
            # else:
            #     mainlog.debug("Skipping label={} x={} last_x={}".format(label, x, last_x))

    def _draw_over_grid(self,painter):
        # painter.setRenderHint(QPainter.Antialiasing, False)

        line_color = QColor(60, 20, 200, 255)
        flat_structure = QColor(20,20,255,128)
        line_color = flat_structure

        w = min(self.height(), self.width()) / 20
        m = self.margin / 2

        x0 = m
        x1 = m + w
        x15 = m + 9*w
        x2 = self.width() - m - w
        x3 = self.width() - m

        y0 = m
        y1 = m + w
        y15 = m + 5*w
        y2 = self.height() - m - w
        y3 = self.height() - m


        # ----------------------------------------------------------------------

        d = w / 4
        p = [ (x0,y15+d),
              (x0,y1),
              (x1,y0),

              (x15+2*d,y0),     #         /
              (x15+d,y0+d),     #    ____/
              (x1,y0+d),    #   /
              (x0+d,y1),        #  |
              (x0+d,y15),       #  |
              (x0,y15+d)        # _|
        ]

        qp = QPainterPath()
        qp.moveTo( p[0][0], p[0][1],)
        for i in range(1,len(p)):
            qp.lineTo( p[i][0], p[i][1],)
        qp.closeSubpath()


        painter.fillPath(qp,QBrush(QColor(20,20,255,128)))

        pen = QPen()
        pen.setCapStyle(Qt.RoundCap)

        pen.setColor(line_color) # alpha=255=fully opaque
        pen.setWidth(1)
        painter.setPen(pen)
        painter.drawPath(qp)

        # ---------------------------------------------------------

        qp = QPainterPath()


        p = [ (x0,y1), (x1,y0),
              (x2,y0), (x3,y1),
              (x3,y2), (x2,y3),
              (x1,y3), (x0,y2),
              (x0,y1)]

        qp.moveTo( p[0][0], p[0][1],)
        for i in range(1,len(p)):
            qp.lineTo( p[i][0], p[i][1],)

        pen = QPen()
        pen.setCapStyle(Qt.RoundCap)
        pen.setColor(QColor(0, 0, 80, 196)) # alpha=255=fully opaque
        pen.setWidth(5)
        painter.setPen(pen)

        painter.drawPath(qp)

        pen = QPen()
        pen.setCapStyle(Qt.RoundCap)
        pen.setColor(line_color) # alpha=255=fully opaque
        pen.setWidth(1)
        painter.setPen(pen)

        painter.drawPath(qp)





    def _draw_grid(self,painter, y_base, width, height, steps):

        m = int(self.maxi / self.rounded_step_size)

        if self.timer.isActive():
            self.gride_lines_number = self.timer_ticks

            if self.gride_lines_number >= m:
                self.timer.stop()
        else:
            self.gride_lines_number = m


        for i in range( self.gride_lines_number + 2):
            qp = QPainterPath()
            #mainlog.debug("self.rounded_step_size = {}, self.maxi={}".format(self.rounded_step_size, self.maxi))
            y = y_base - self.rounded_step_size * i * self.y_factor
            qp.moveTo(0,y)

            # A bit of shuffle on y for visual effect
            qp.lineTo(width,y + (i % 3) - 1)

            pen = QPen()
            pen.setCapStyle(Qt.RoundCap)
            pen.setColor(QColor(0, 0, 25)) # alpha=255=fully opaque
            pen.setWidth(5)
            painter.setPen(pen)

            painter.drawPath(qp)

            pen = QPen()
            pen.setCapStyle(Qt.RoundCap)
            pen.setColor(QColor(30, 30, 30)) # alpha=255=fully opaque
            pen.setWidth(1)
            painter.setPen(pen)

            painter.drawPath(qp)




    def _draw_y_axis(self,painter, y_base, width, height, steps):

        text_pen = QPen()
        text_pen.setCapStyle(Qt.RoundCap)
        text_pen.setColor(QColor(200, 200, 200)) # alpha=255=fully opaque
        text_pen.setWidth(1)
        painter.setPen(text_pen)


        if self.rounded_step_size < 1:
            fmt = "{:.1f}"
        else:
            fmt = "{:.0f}"

        if self.rounded_step_size > 0:
            for i in range(int(self.maxi / self.rounded_step_size) + 1):

                y = y_base - self.rounded_step_size * i * self.y_factor
                painter.drawText(self.margin,y, fmt.format(self.rounded_step_size * i))


    def draw_title(self, painter):
        text_pen = QPen()
        text_pen.setCapStyle(Qt.RoundCap)
        text_pen.setColor(QColor(255, 255, 255)) # alpha=255=fully opaque
        text_pen.setWidth(1)
        painter.setPen(text_pen)

        painter.setFont(self.title_font)

        r = QRect(self.margin,0,self.width() - 2*self.margin,self.height())
        painter.drawText(r, Qt.AlignLeft + Qt.TextWordWrap, self.title)


    def draw_no_data(self, painter):
        text_pen = QPen()
        text_pen.setCapStyle(Qt.RoundCap)
        text_pen.setColor(QColor(128, 128, 128)) # alpha=255=fully opaque
        text_pen.setWidth(1)
        painter.setPen(text_pen)

        painter.setFont(self.title_font)
        r = QRect( self.margin, 0, self.width() - 2*self.margin, self.height())
        painter.drawText(r, (Qt.AlignCenter | Qt.AlignLeft) + Qt.TextWordWrap, _("No data"))

    def paintEvent(self,event):


        painter = QPainter(self)
        painter.setRenderHint(QPainter.Antialiasing)
        base_font = painter.font()

        self._compute_lengths(painter)

        if self.no_draw:
            self.draw_title(painter)
            self.draw_no_data(painter)
            return

        self._draw_grid(painter, self.y_base, self.width(), self.total_height, 6)
        # self._draw_over_grid(painter)

        self._draw_legend2(painter, self.legends)
        self._draw_x_axis(painter, self.x_legends)
        self._draw_y_axis(painter, self.y_base, self.width(), self.total_height, 6)
        self.draw_title(painter)
        painter.setFont(base_font)
        if self.data:
            for i in range(len(self.data)):
                self._draw_serie(painter, i, self.graph_colors[i % len(self.graph_colors)])

        if self._horizontal_ruler_y_value != None:
            self._draw_horizontal_ruler(painter,
                                        self._horizontal_ruler_text,
                                        self._horizontal_ruler_y_value,
                                        self._horizontal_ruler_color)

        self._draw_selected_items_in_series(painter)

    # def compute_mini_maxi(self, delta_min):
    #     if self.data:
    #         mini = 99999999999
    #         maxi = 0
    #         for l in self.data:
    #             if l:
    #                 mini = min(min(l),mini)
    #                 maxi = max(max(l),maxi)
    #
    #         if maxi - mini < delta_min:
    #             # mainlog.debug("* "*20 + str(delta_min) )
    #             maxi = mini + delta_min
    #
    #         self.mini, self.maxi = mini, maxi
    #
    #         assert 0 <= self.mini <= self.maxi, "0 <= {} <= {}".format(self.mini, self.maxi)

    def set_mini_maxi(self,mini,maxi):
        """ Set mini/maxi Y values. That's useful to have, for example,
        the 0 value on the graph.

        If mini and maxi are None, the their value will be guessed
        from the data drawn.

        :param mini: Minimum value that will be displayed on the Y axis
        :param maxi: Maximum value that will be displayed on the Y axis
        :return:
        """

        assert (mini == None and maxi == None) or (0 <= mini <= maxi), "0 <= {} <= {}".format( mini, maxi)

        self.forced_maxi = maxi
        self.forced_mini = mini

    def set_horizontal_ruler(self, text, y_value, color = Qt.GlobalColor.green):

        self._horizontal_ruler_text = text
        self._horizontal_ruler_y_value = y_value
        self._horizontal_ruler_color = color

    def _draw_box_under_text(self,painter,x,y,text):
        r = QRect(1,1,1000,1000)
        bb = painter.boundingRect(r,Qt.AlignLeft,text)
        bb = QRect(x,y - bb.height() +2 , bb.width() + 2, bb.height())

        # print("{} {} {} {}".format(bb.x(),bb.y(),bb.width(),bb.height()))

        fill_color = QColor(0,0,0)
        fill_color.setAlpha(170)
        brush = QBrush(fill_color)

        painter.fillRect(bb,brush)


    def _draw_horizontal_ruler(self, painter, text, y_value, color):

        y = y_value * self.y_factor

        pen = QPen()
        pen.setCapStyle(Qt.SquareCap)
        pen.setColor(color)

        qp = QPainterPath()

        r = QRect(1,1,1000,1000)
        bb = painter.boundingRect(r,Qt.AlignLeft,text)
        bb = QRect(self.x_base,self.y_base - y - bb.height(), bb.width() + 2, bb.height())

        # print("{} {} {} {}".format(bb.x(),bb.y(),bb.width(),bb.height()))

        fill_color = QColor(0,0,0)
        fill_color.setAlpha(128)
        brush = QBrush(fill_color)

        painter.fillRect(bb,brush)

        qp.moveTo(self.x_base,self.y_base - y)
        qp.lineTo(self.total_width + self.x_base, self.y_base - y)

        painter.setPen(pen)
        painter.drawPath(qp)

        text_pen = QPen()
        text_pen.setCapStyle(Qt.RoundCap)
        text_pen.setColor(color) # alpha=255=fully opaque
        text_pen.setWidth(1)

        painter.setPen(text_pen)
        painter.drawText(self.x_base,self.y_base - y - 5,text)
Example #31
0
class BaseObject(QGraphicsPathItem):
    """
    Subclass of `QGraphicsPathItem`_

    TOWRITE

    """

    Type = OBJ_TYPE_BASE

    def __init__(self, parent=None):
        """
        Default class constructor.

        :param `parent`: Pointer to a parent widget instance.
        :type `parent`: `QGraphicsItem`_
        """
        super(BaseObject, self).__init__(parent)

        qDebug("BaseObject Constructor()")

        self.objPen = QPen()        # QPen objPen;
        self.lwtPen = QPen()        # QPen lwtPen;
        self.objLine = QLineF()     # QLineF objLine;
        self.objRubberMode = int()  # int objRubberMode;
        self.objRubberPoints = {}   # QHash<QString, QPointF> objRubberPoints;
        self.objRubberTexts = {}    # QHash<QString, QString> objRubberTexts;
        self.objID = int()          # qint64 objID;

        self.objPen.setCapStyle(Qt.RoundCap)
        self.objPen.setJoinStyle(Qt.RoundJoin)
        self.lwtPen.setCapStyle(Qt.RoundCap)
        self.lwtPen.setJoinStyle(Qt.RoundJoin)

        self.objID = QDateTime.currentMSecsSinceEpoch()


    def __del__(self):
        """Class destructor."""
        qDebug("BaseObject Destructor()")

    def type(self):
        """
        TOWRITE

        :return: TOWRITE
        :rtype: int
        """
        return self.Type

    def setObjectColor(self, color):
        """
        TOWRITE

        :param `color`: TOWRITE
        :type `color`: `QColor`_
        """
        self.objPen.setColor(color)
        self.lwtPen.setColor(color)

    def setObjectColorRGB(self, rgb):
        """
        TOWRITE

        :param `rgb`: TOWRITE
        :type `rgb`: `QRgb`_
        """
        self.objPen.setColor(QColor(rgb))
        self.lwtPen.setColor(QColor(rgb))

    def setObjectLineType(self, lineType):
        """
        TOWRITE

        :param `rgb`: TOWRITE
        :type `rgb`: Qt.PenStyle
        """
        self.objPen.setStyle(lineType)
        self.lwtPen.setStyle(lineType)

    def setObjectLineWeight(self, lineWeight):
        """
        TOWRITE

        :param `lineWeight`: TOWRITE
        :type `lineWeight`: qreal
        """
        self.objPen.setWidthF(0)  # NOTE: The objPen will always be cosmetic

        if lineWeight < 0:
            if lineWeight == OBJ_LWT_BYLAYER:
                self.lwtPen.setWidthF(0.35)  # TODO: getLayerLineWeight
            elif lineWeight == OBJ_LWT_BYBLOCK:
                self.lwtPen.setWidthF(0.35)  # TODO: getBlockLineWeight
            else:
                QMessageBox.warning(0, QObject.tr("Error - Negative Lineweight"),
                                       QObject.tr("Lineweight: %f" % lineWeight))
                qDebug("Lineweight cannot be negative! Inverting sign.")
                self.lwtPen.setWidthF(-lineWeight)
        else:
            self.lwtPen.setWidthF(lineWeight)

    def objectRubberPoint(self, key):
        """
        TOWRITE

        :param `key`: TOWRITE
        :type `key`: QString
        :rtype: `QPointF`_
        """
        if key in self.objRubberPoints:       # if(objRubberTexts.contains(key))
            return self.objRubberPoints[key]  #     return objRubberTexts.value(key);

        gscene = self.scene()  # QGraphicsScene* gscene = scene()
        if gscene:
            return self.scene().property("SCENE_QSNAP_POINT")  # .toPointF()
        return QPointF()

    def objectRubberText(self, key):
        """
        TOWRITE

        :param `key`: TOWRITE
        :type `key`: QString
        :rtype: QString
        """
        if key in self.objRubberTexts:       # if(objRubberTexts.contains(key))
            return self.objRubberTexts[key]  #     return objRubberTexts.value(key);
        return ""  # QString()

    def boundingRect(self):
        """
        TOWRITE

        :rtype: `QRectF`_
        """
        # If gripped, force this object to be drawn even if it is offscreen
        if self.objectRubberMode() == OBJ_RUBBER_GRIP:
            return self.scene().sceneRect()
        return self.path().boundingRect()

    def drawRubberLine(self, rubLine, painter=None, colorFromScene=''):
        """
        TOWRITE

        :param `rubLine`: TOWRITE
        :type `rubLine`: `QLineF`_
        :param `painter`: TOWRITE
        :type `painter`: `QPainter`_
        :param `colorFromScene`: TOWRITE
        :type `colorFromScene`: str
        """
        if painter:
            objScene = self.scene()  # QGraphicsScene* objScene = scene();
            if not objScene:
                return
            colorPen = self.objPen  # QPen colorPen = objPen
            colorPen.setColor(QColor(objScene.property(colorFromScene)))  # .toUInt()))
            painter.setPen(colorPen)
            painter.drawLine(rubLine)
            painter.setPen(self.objPen)

    def realRender(self, painter, renderPath):  # TODO/PORT: Still needs work.
        """
        TOWRITE

        :param `painter`: TOWRITE
        :type `painter`: `QPainter`_
        :param `renderPath`: TOWRITE
        :type `renderPath`: `QPainterPath`_
        """
        color1 = self.objectColor()  #QColor  # lighter color
        color2 = color1.darker(150)  #QColor  # darker color

        # If we have a dark color, lighten it
        darkness = color1.lightness() #int
        threshold = 32 #int   #TODO: This number may need adjusted or maybe just add it to settings.
        if darkness < threshold:
            color2 = color1
            if not darkness:
                color1 = QColor(threshold, threshold, threshold)  # lighter() does not affect pure black
            else :
                color1 = color2.lighter(100 + threshold)

        count = renderPath.elementCount()  # int
        for i in range(0, count - 1):  # for(int i = 0; i < count-1; ++i);

            elem = renderPath.elementAt(i)      # QPainterPath::Element
            next = renderPath.elementAt(i + 1)  # QPainterPath::Element

            if next.isMoveTo():
                continue

            elemPath = QPainterPath()
            elemPath.moveTo(elem.x, elem.y)
            elemPath.lineTo(next.x, next.y)

            renderPen = QPen(QColor(0, 0, 0, 0))
            renderPen.setWidthF(0)
            painter.setPen(renderPen)
            stroker = QPainterPathStroker()
            stroker.setWidth(0.35)
            stroker.setCapStyle(Qt.RoundCap)
            stroker.setJoinStyle(Qt.RoundJoin)
            realPath = stroker.createStroke(elemPath)  # QPainterPath
            painter.drawPath(realPath)

            grad = QLinearGradient(elemPath.pointAtPercent(0.5), elemPath.pointAtPercent(0.0))
            grad.setColorAt(0, color1)
            grad.setColorAt(1, color2)
            grad.setSpread(QGradient.ReflectSpread)

            painter.fillPath(realPath, QBrush(grad))

    def objectID(self):
        """
        TOWRITE

        :return: TOWRITE
        :rtype: int
        """
        return self.objID

    def objectPen(self):
        """
        TOWRITE

        :return: TOWRITE
        :rtype: `QPen`_
        """
        return self.objPen

    def objectColor(self):
        """
        TOWRITE

        :return: TOWRITE
        :rtype: `QColor`_
        """
        return self.objPen.color()

    def objectColorRGB(self):
        """
        TOWRITE

        :return: TOWRITE
        :rtype: int
        """
        return self.objPen.color().rgb()

    def objectLineType(self):
        """
        TOWRITE

        :return: TOWRITE
        :rtype: Qt.PenStyle
        """
        return self.objPen.style()

    def objectLineWeight(self):
        """
        TOWRITE

        :return: TOWRITE
        :rtype: float
        """
        return self.lwtPen.widthF()

    def objectPath(self):
        """
        TOWRITE

        :return: TOWRITE
        :rtype: `QPainterPath`_
        """
        return self.path()

    def objectRubberMode(self):
        """
        TOWRITE

        :return: TOWRITE
        :rtype: int
        """
        return self.objRubberMode

    def rect(self):
        """
        TOWRITE

        :return: TOWRITE
        :rtype: `QRectF`_
        """
        return self.path().boundingRect()

    # pythonic setRect overload
    @signature(QPointF)
    def setRectFromRect(self, r):
        """
        TOWRITE

        :param `r`: TOWRITE
        :type `r`: QPointF
        """
        p = QPainterPath()
        p.addRect(r)
        self.setPath(p)

    # pythonic setRect overload
    @signature(float, float, float, float)
    def setRectFromXYWH(self, x, y, w, h):
        """
        TOWRITE

        :param `x`: TOWRITE
        :type `x`: qreal
        :param `y`: TOWRITE
        :type `y`: qreal
        :param `w`: TOWRITE
        :type `w`: qreal
        :param `h`: TOWRITE
        :type `h`: qreal
        """
        p = QPainterPath()
        p.addRect(x, y, w, h)
        self.setPath(p)

    @overloaded(setRectFromRect, setRectFromXYWH)
    def setRect(self, *args):
        """ TOWRITE """
        pass

    def line(self):
        """
        TOWRITE

        :return: TOWRITE
        :rtype: `QLineF`_
        """
        return self.objLine

    # pythonic setLine overload
    @signature(QPointF)
    def setLineFromLine(self, li):
        """
        TOWRITE

        :param `li`: TOWRITE
        :type `li`: QPointF
        """
        p = QPainterPath()
        p.moveTo(li.p1())
        p.lineTo(li.p2())
        self.setPath(p)
        self.objLine = li

    # pythonic setLine overload
    @signature(float, float, float, float)
    def setLineFromXXYY(self, x1, y1, x2, y2):
        """
        TOWRITE

        :param `x1`: TOWRITE
        :type `x1`: qreal
        :param `y1`: TOWRITE
        :type `y1`: qreal
        :param `x2`: TOWRITE
        :type `x2`: qreal
        :param `y2`: TOWRITE
        :type `y2`: qreal
        """
        p = QPainterPath()
        p.moveTo(x1, y1)
        p.lineTo(x2, y2)
        self.setPath(p)
        self.objLine.setLine(x1, y1, x2, y2)

    @overloaded(setLineFromLine, setLineFromXXYY)
    def setLine(self, *args):
        """ TOWRITE """
        pass

    def setObjectPath(self, p):
        """
        TOWRITE

        :param `p`: TOWRITE
        :type `p`: `QPainterPath`_
        """
        self.setPath(p)

    def setObjectRubberMode(self, mode):
        """
        TOWRITE

        :param `mode`: TOWRITE
        :type `mode`: int
        """
        self.objRubberMode = mode

    def setObjectRubberPoint(self, key, point):
        """
        TOWRITE

        :param `key`: TOWRITE
        :type `key`: str
        :param `point`: TOWRITE
        :type `point`: `QPointF`_
        """
        self.objRubberPoints[key] = point  # .insert(key, point)

    def setObjectRubberText(self, key, txt):
        """
        TOWRITE

        :param `key`: TOWRITE
        :type `key`: str
        :param `txt`: TOWRITE
        :type `txt`: str
        """
        self.objRubberTexts[key] = txt  # .insert(key, txt)

    def shape(self):
        """
        TOWRITE

        :return: TOWRITE
        :rtype: `QPainterPath`_
        """
        return self.path()

    def vulcanize(self):
        """ TOWRITE """
        raise NotImplementedError

    def mouseSnapPoint(self, mousePoint):
        """
        TOWRITE

        :param `mousePoint`: TOWRITE
        :type `mousePoint`: `QPointF`_
        :return: TOWRITE
        :rtype: `QPointF`_
        """
        raise NotImplementedError

    def allGripPoints(self):
        """
        TOWRITE

        :return: TOWRITE
        :rtype: list[`QPointF`_]
        """
        raise NotImplementedError

    def gripEdit(self, before, after):
        """
        TOWRITE

        :param `before`: TOWRITE
        :type `before`: `QPointF`_
        :param `after`: TOWRITE
        :type `after`: `QPointF`_
        """
        raise NotImplementedError

    def lineWeightPen(self):
        """
        TOWRITE

        :return: TOWRITE
        :rtype: `QPen`_
        """
        return self.lwtPen
Example #32
0
    def paintEvent(self, event):
        cX = self.parent.lytLeftMargin + self.scaleMarkLen
        cY = self.parent.lytTopMargin + self.scaleMarkLen
        worldX = self.parent.presenter.showChunkX*16
        worldZ = self.parent.presenter.showChunkZ*16
        painter = QPainter()
        path = QPainterPath()
        painter.begin(self)
        painter.save()
        #painter.setFont(QFont('Arial Narrow', 8)) #QFont.Bold
        # draw scale
        x = cX
        y = cY
        painter.rotate(-90)
        for i in range(16):
            fr = QRectF(-y, x, self.scaleMarkLen, self.edgeLen)
            painter.drawText(fr, Qt.AlignHCenter | Qt.AlignVCenter, str(worldX))
            #painter.drawRect(fr)
            #fr = QRectF(-y - 16*self.edgeLen - self.scaleMarkLen, x, self.scaleMarkLen, self.edgeLen)
            #painter.drawText(fr, Qt.AlignHCenter | Qt.AlignVCenter, '-5555')
            #painter.drawRect(fr)
            x += self.edgeLen
            worldX += 1
        painter.rotate(90)

        x = self.parent.lytLeftMargin
        y = cY
        for i in range(16):
            fr = QRectF(x, y, self.scaleMarkLen, self.edgeLen)
            painter.drawText(fr, Qt.AlignHCenter | Qt.AlignVCenter, str(worldZ))
            #painter.drawRect(fr)
            #fr = QRectF(x + self.scaleMarkLen + 16*self.edgeLen, y, self.scaleMarkLen, self.edgeLen)
            #painter.drawText(fr, Qt.AlignHCenter | Qt.AlignVCenter, '-5555')
            #painter.drawRect(fr)
            y += self.edgeLen
            worldZ += 1

        x = cX
        y = cY
        for i in range(16):
            for j in range(16):
                path.addRect(x, y, self.edgeLen, self.edgeLen)
                #fr = QRectF(x, y, self.edgeLen, self.edgeLen)
                #painter.drawText(fr, Qt.AlignHCenter | Qt.AlignVCenter, '-5555')
                x += self.edgeLen
            x = cX
            y += self.edgeLen
            
        painter.drawPath(path)

        slice_ = self.parent.presenter.getSlice(self.parent.presenter.elevation)
        x = cX
        y = cY
        bru = QBrush()
        #path1 = QPainterPath()
        for i in range(16):
            for j in range(16):
                if slice_[i][j] in self.parent.selectedMinerals.list_:
                    lePen = painter.pen()
                    
                    newPen = QPen(bru, 3)
                    newPen.setColor(self.parent.selectedMinerals.getColor(slice_[i][j]))
                    painter.setPen(newPen)
                    painter.drawRect(x, y, self.edgeLen, self.edgeLen)
                    painter.setPen(lePen)
                x += self.edgeLen
            x = cX
            y += self.edgeLen

        

        painter.restore()
        painter.end()
        del painter
Example #33
0
 def drawLines(self, qp):
     pen = QPen(Qt.black, 2, Qt.SolidLine)
     qp.setPen(pen)
     # Can be used to test drawing lines between specific actions. Keep for now.
     #ifrom = self.mapToTree(self.needsLine[0][0])
     #ito = self.mapToTree(self.needsLine[0][1])
     #qp.drawLine(ifrom.x(), ifrom.y(), ito.x(), ito.y())
     alternate = True
     #print self.op.lastButtonPressed
     if self.op.lastButtonPressed is not None:
         pen.setColor(Qt.yellow)
         qp.setPen(pen)
         qp.drawRect(
             self.mapToTree(self.op.lastButtonPressed).x(),
             self.mapToTree(self.op.lastButtonPressed).y(),
             self.buttons[self.op.lastButtonPressed].rect().width(),
             self.buttons[self.op.lastButtonPressed].rect().height())
         pen.setColor(Qt.black)
         qp.setPen(pen)
     for line in self.needsLine:
         width0 = self.buttons[line[0]].rect().width()
         height0 = self.buttons[line[0]].rect().height()
         width1 = self.buttons[line[1]].rect().width()
         height1 = self.buttons[line[1]].rect().height()
         ifrom = self.mapToTree(line[0])
         ito = self.mapToTree(line[1])
         if len(self.table[line[0]]) == 1 or len(self.table[line[1]]) == 1:
             pen.setColor(Qt.green)
             qp.setPen(pen)
             if len(self.table[line[0]]) == 1:
                 if line[0] in self.op.subtree or line[
                         0] == self.op.lastButtonPressed:
                     qp.drawRect(ifrom.x() - 2,
                                 ifrom.y() - 2, width0 + 4, height0 + 4)
                 else:
                     qp.drawRect(ifrom.x(), ifrom.y(), width0, height0)
             if len(self.table[line[1]]) == 1:
                 if line[1] in self.op.subtree:
                     qp.drawRect(ito.x() - 2,
                                 ito.y() - 2, width1 + 4, height1 + 4)
                 else:
                     qp.drawRect(ito.x(), ito.y(), width1, height1)
             pen.setColor(Qt.black)
             qp.setPen(pen)
         if line[0] in self.op.subtree or line[1] in self.op.subtree:
             pen.setColor(Qt.red)
             qp.setPen(pen)
             if line[0] in self.op.subtree and line[
                     0] != self.op.lastButtonPressed:  # and len(self.table[line[0]])>1:
                 qp.drawRect(ifrom.x(), ifrom.y(), width0, height0)
             if line[1] in self.op.subtree and line[
                     1] != self.op.lastButtonPressed:  # and len(self.table[line[1]])>1:
                 qp.drawRect(ito.x(), ito.y(), width1, height1)
         if self.op.needsRefresh:
             self.update()
             self.op.needsRefresh = False
         if self.mapped[line[0]] <= self.mapped[line[1]]:
             qp.drawLine(ifrom.x() + (width0 / 2),
                         ifrom.y() + (height0 / 2),
                         ito.x() + (width1 / 2),
                         ito.y() + (height1 / 2))
         else:
             pen.setStyle(Qt.DashLine)
             qp.setPen(pen)
             qp.drawLine(ifrom.x() + (width0 / 2),
                         ifrom.y() + (height0 / 2),
                         ito.x() + (width1 / 2),
                         ito.y() + (height1 / 2))
             #if alternate:
             #	qp.drawArc(QRectF(ito.x(), ito.y()+1, width0, ifrom.y()-ito.y()), 90*16, 180*16)
             #	alternate=False
             #else:
             #	qp.drawArc(QRectF(ito.x(), ito.y()+1, width0, ifrom.y()-ito.y()), 270*16, 180*16)
             #	alternate=True
             pen.setStyle(Qt.SolidLine)
         pen.setColor(Qt.black)
         qp.setPen(pen)
Example #34
0
class SelectBox(QRubberBand):
    """
    Subclass of `QRubberBand`_

    TOWRITE

    """
    def __init__(self, s, parent=None):
        """
        Default class constructor.

        :param `s`: TOWRITE
        :type `s`: QRubberBand.Shape
        :param `parent`: Pointer to a parent widget instance.
        :type `parent`: `QWidget`_
        """
        super(SelectBox, self).__init__(parent)

        # private
        self._leftBrushColor = QColor()
        self._rightBrushColor = QColor()
        self._leftPenColor = QColor()
        self._rightPenColor = QColor()
        self._alpha = 255  # quint8  #: TODO: what is the initial int?

        self._dirBrush = QBrush()
        self._leftBrush = QBrush()
        self._rightBrush = QBrush()

        self._dirPen = QPen()
        self._leftPen = QPen()
        self._rightPen = QPen()

        self._boxDir = False  #: TODO: is this initial bool value right?

        # Default values
        self.setColors(QColor(Qt.darkGreen), QColor(Qt.green),
                       QColor(Qt.darkBlue), QColor(Qt.blue), 32)

    def setDirection(self, dir):
        """
        TOWRITE

        :param `dir`: TOWRITE
        :type `dir`: int
        """
        if not dir:
            self._dirPen = self._leftPen
            self._dirBrush = self._leftBrush
        else:
            self._dirPen = self._rightPen
            self._dirBrush = self._rightBrush
        self._boxDir = dir

    def setColors(self, colorL, fillL, colorR, fillR, newAlpha):
        """
        TOWRITE

        :param `colorL`: TOWRITE
        :type `colorL`: `QColor`_
        :param `fillL`: TOWRITE
        :type `fillL`: `QColor`_
        :param `colorR`: TOWRITE
        :type `colorR`: `QColor`_
        :param `fillR`: TOWRITE
        :type `fillR`: `QColor`_
        :param `newAlpha`: TOWRITE
        :type `newAlpha`: int
        """
        qDebug("SelectBox setColors()")
        self._alpha = newAlpha

        self._leftPenColor = colorL  # TODO: allow customization
        self._leftBrushColor = QColor(fillL.red(), fillL.green(), fillL.blue(),
                                      alpha)
        self._rightPenColor = colorR  # TODO: allow customization
        self._rightBrushColor = QColor(fillR.red(), fillR.green(),
                                       fillR.blue(), alpha)

        self._leftPen.setColor(self._leftPenColor)
        self._leftPen.setStyle(Qt.DashLine)
        self._leftBrush.setStyle(Qt.SolidPattern)
        self._leftBrush.setColor(self._leftBrushColor)

        self._rightPen.setColor(self._rightPenColor)
        self._rightPen.setStyle(Qt.SolidLine)
        self._rightBrush.setStyle(Qt.SolidPattern)
        self._rightBrush.setColor(self._rightBrushColor)

        if not self._boxDir:
            self._dirPen = self._leftPen
            self._dirBrush = self._leftBrush
        else:
            self._dirPen = self._rightPen
            self._dirBrush = self._rightBrush

        self.forceRepaint()

    def paintEvent(self, event):
        """
        Handles the ``paintEvent`` event for :class:`SelectBox`.

        :param `event`: A `QPaintEvent`_ to be processed.
        """
        painter = QPainter(self)
        painter.setPen(self._dirPen)
        width, height = self.width(), self.height()
        painter.fillRect(0, 0, width - 1, height - 1, self._dirBrush)
        painter.drawRect(0, 0, width - 1, height - 1)

    def forceRepaint(self):
        """
        Force repaint the rubberband.

        .. NOTE:: HACK: Take that QRubberBand!
        """
        # HACK: Take that QRubberBand!
        hack = self.size()  # QSize
        self.resize(hack + QSize(1, 1))
        self.resize(hack)
Example #35
0
class SelectBox(QRubberBand):
    """
    Subclass of `QRubberBand`_

    TOWRITE

    """
    def __init__(self, s, parent=None):
        """
        Default class constructor.

        :param `s`: TOWRITE
        :type `s`: QRubberBand.Shape
        :param `parent`: Pointer to a parent widget instance.
        :type `parent`: `QWidget`_
        """
        super(SelectBox, self).__init__(s, parent)

        # private
        self._leftBrushColor = QColor()
        self._rightBrushColor = QColor()
        self._leftPenColor = QColor()
        self._rightPenColor = QColor()
        self._alpha = 255  # quint8  #: TODO: what is the initial int?

        self._dirBrush = QBrush()
        self._leftBrush = QBrush()
        self._rightBrush = QBrush()

        self._dirPen = QPen()
        self._leftPen = QPen()
        self._rightPen = QPen()

        self._boxDir = False  #: TODO: is this initial bool value right?

        # Default values
        self.setColors(QColor(Qt.darkGreen), QColor(Qt.green), QColor(Qt.darkBlue), QColor(Qt.blue), 32)

    def paintEvent(self, event):
        """
        Handles the ``paintEvent`` event for :class:`SelectBox`.

        :param `event`: A `QPaintEvent`_ to be processed.
        """
        painter = QPainter(self)
        painter.setPen(self._dirPen)
        width, height = self.width(), self.height()
        painter.fillRect(0, 0, width - 1, height - 1, self._dirBrush)
        painter.drawRect(0, 0, width - 1, height - 1)

    def forceRepaint(self):
        """
        Force repaint the rubberband.

        .. NOTE:: HACK: Take that QRubberBand!
        """
        # HACK: Take that QRubberBand!
        hack = self.size()  # QSize
        self.resize(hack + QSize(1, 1))
        self.resize(hack)

    # Slots ------------------------------------------------------------------

    @Slot(int)
    def setDirection(self, dir):
        """
        TOWRITE

        :param `dir`: TOWRITE
        :type `dir`: int
        """
        if not dir:
            self._dirPen = self._leftPen
            self._dirBrush = self._leftBrush
        else:
            self._dirPen = self._rightPen
            self._dirBrush = self._rightBrush
        self._boxDir = dir

    @Slot(QColor, QColor, QColor, QColor, int)
    def setColors(self, colorL, fillL, colorR, fillR, newAlpha):
        """
        TOWRITE

        :param `colorL`: TOWRITE
        :type `colorL`: `QColor`_
        :param `fillL`: TOWRITE
        :type `fillL`: `QColor`_
        :param `colorR`: TOWRITE
        :type `colorR`: `QColor`_
        :param `fillR`: TOWRITE
        :type `fillR`: `QColor`_
        :param `newAlpha`: TOWRITE
        :type `newAlpha`: int
        """
        qDebug("SelectBox setColors()")
        self._alpha = newAlpha

        self._leftPenColor = colorL  # TODO: allow customization
        self._leftBrushColor = QColor(fillL.red(), fillL.green(), fillL.blue(), self._alpha)
        self._rightPenColor = colorR  # TODO: allow customization
        self._rightBrushColor = QColor(fillR.red(), fillR.green(), fillR.blue(), self._alpha)

        self._leftPen.setColor(self._leftPenColor)
        self._leftPen.setStyle(Qt.DashLine)
        self._leftBrush.setStyle(Qt.SolidPattern)
        self._leftBrush.setColor(self._leftBrushColor)

        self._rightPen.setColor(self._rightPenColor)
        self._rightPen.setStyle(Qt.SolidLine)
        self._rightBrush.setStyle(Qt.SolidPattern)
        self._rightBrush.setColor(self._rightBrushColor)

        if not self._boxDir:
            self._dirPen = self._leftPen
            self._dirBrush = self._leftBrush
        else:
            self._dirPen = self._rightPen
            self._dirBrush = self._rightBrush

        self.forceRepaint()
Example #36
0
File: accd.py Project: Sugz/Python
    def paintEvent( self, event ):
        painter = QPainter()
        painter.begin(self)
        painter.setRenderHint(painter.Antialiasing)
        font = painter.font()
        font.setBold(True)
        painter.setFont(font)

        x = self.rect().x()
        y = self.rect().y()
        w = self.rect().width() - 1
        h = self.rect().height() - 1
        r = 8

        # draw a rounded style
        if self._rolloutStyle == 2:
            # draw the text
            painter.drawText(x + 33, y + 3, w, 16, Qt.AlignLeft | Qt.AlignTop, self.title())

            # draw the triangle
            self.__drawTriangle(painter, x, y)

            # draw the borders
            pen = QPen(self.palette().color(QPalette.Light))
            pen.setWidthF(0.6)
            painter.setPen(pen)

            painter.drawRoundedRect(x + 1, y + 1, w - 1, h - 1, r, r)

            pen.setColor(self.palette().color(QPalette.Shadow))
            painter.setPen(pen)

            painter.drawRoundedRect(x, y, w - 1, h - 1, r, r)

        # draw a square style
        if self._rolloutStyle == 3:
            # draw the text
            painter.drawText(x + 33, y + 3, w, 16, Qt.AlignLeft | Qt.AlignTop, self.title())

            self.__drawTriangle(painter, x, y)

            # draw the borders
            pen = QPen(self.palette().color(QPalette.Light))
            pen.setWidthF(0.6)
            painter.setPen(pen)

            painter.drawRect(x + 1, y + 1, w - 1, h - 1)

            pen.setColor(self.palette().color(QPalette.Shadow))
            painter.setPen(pen)

            painter.drawRect(x, y, w - 1, h - 1)

        # draw a Maya style
        if self._rolloutStyle == 4:
            # draw the text
            painter.drawText(x + 33, y + 3, w, 16, Qt.AlignLeft | Qt.AlignTop, self.title())

            painter.setRenderHint(QPainter.Antialiasing, False)

            self.__drawTriangle(painter, x, y)

            # draw the borders - top
            headerHeight = 20

            headerRect = QRect(x + 1, y + 1, w - 1, headerHeight)
            headerRectShadow = QRect(x - 1, y - 1, w + 1, headerHeight + 2)

            # Highlight
            pen = QPen(self.palette().color(QPalette.Light))
            pen.setWidthF(0.4)
            painter.setPen(pen)

            painter.drawRect(headerRect)
            painter.fillRect(headerRect, QColor(255, 255, 255, 18))

            # Shadow
            pen.setColor(self.palette().color(QPalette.Dark))
            painter.setPen(pen)
            painter.drawRect(headerRectShadow)

            if not self.isCollapsed():
                # draw the lover border
                pen = QPen(self.palette().color(QPalette.Dark))
                pen.setWidthF(0.8)
                painter.setPen(pen)

                offSet = headerHeight + 3
                bodyRect = QRect(x, y + offSet, w, h - offSet)
                bodyRectShadow = QRect(x + 1, y + offSet, w + 1, h - offSet + 1)
                painter.drawRect(bodyRect)

                pen.setColor(self.palette().color(QPalette.Light))
                pen.setWidthF(0.4)
                painter.setPen(pen)

                painter.drawRect(bodyRectShadow)

        # draw a boxed style
        elif self._rolloutStyle == 1:
            if self.isCollapsed():
                arect = QRect(x + 1, y + 9, w - 1, 4)
                brect = QRect(x, y + 8, w - 1, 4)
                text = '+'
            else:
                arect = QRect(x + 1, y + 9, w - 1, h - 9)
                brect = QRect(x, y + 8, w - 1, h - 9)
                text = '-'

            # draw the borders
            pen = QPen(self.palette().color(QPalette.Light))
            pen.setWidthF(0.6)
            painter.setPen(pen)

            painter.drawRect(arect)

            pen.setColor(self.palette().color(QPalette.Shadow))
            painter.setPen(pen)

            painter.drawRect(brect)

            painter.setRenderHint(painter.Antialiasing, False)
            painter.setBrush(self.palette().color(QPalette.Window).darker(120))
            painter.drawRect(x + 10, y + 1, w - 20, 16)
            painter.drawText(x + 16, y + 1, w - 32, 16, Qt.AlignLeft | Qt.AlignVCenter, text)
            painter.drawText(x + 10, y + 1, w - 20, 16, Qt.AlignCenter, self.title())

        if self.dragDropMode():
            rect = self.dragDropRect()

            # draw the lines
            l = rect.left()
            r = rect.right()
            cy = rect.center().y()

            for y in (cy - 3, cy, cy + 3):
                painter.drawLine(l, y, r, y)

        painter.end()
Example #37
0
    def paintEvent(self, event):
        # print self.height()

        s = (self.target_angle - self.angle) * 0.09

        self.angle += s
        if math.fabs(self.angle - self.target_angle) < 0.001:
            self.angle = self.target_angle
            self.timer.stop()

        painter = QPainter(self)
        painter.setRenderHint(QPainter.Antialiasing)

        qp = QPainterPath()

        width = min(self.height(), (self.width() / 2))
        height = self.height()

        # center
        x = self.width() / 2

        big_radius = 1000
        y = big_radius + 10
        small_radius = big_radius - 15

        ac = math.atan(float(self.width()) / 2.0 /
                       float(big_radius)) / math.pi * 180.0 * 0.95

        qp.arcMoveTo(x - big_radius, y - big_radius, 2 * big_radius,
                     2 * big_radius, 90 - ac)
        qp.arcTo(x - big_radius, y - big_radius, 2 * big_radius,
                 2 * big_radius, 90 - ac, 2 * ac)
        qp.arcTo(x - small_radius, y - small_radius, 2 * small_radius,
                 2 * small_radius, 90 + ac, -2 * ac)
        qp.arcTo(x - big_radius, y - big_radius, 2 * big_radius,
                 2 * big_radius, 90 - ac, 0)
        # qp.lineTo(x+big_radius,y)

        grange = ac * 2.0 / 360.0

        # Centered on 0, starting at angle 90-ac, counterclockwise
        self.gradient = QConicalGradient(0, 0, 90 - ac - 1)

        if self.gradient_type == 1:
            self.gradient.setColorAt(0, Qt.GlobalColor.red)
            self.gradient.setColorAt(0.1, Qt.GlobalColor.yellow)
            self.gradient.setColorAt(0.2, Qt.GlobalColor.green)
            self.gradient.setColorAt(0.5, Qt.GlobalColor.green)
            self.gradient.setColorAt(0.5, Qt.GlobalColor.green)
        elif self.gradient_type == 2:
            self.gradient.setColorAt(0, Qt.GlobalColor.green)
            self.gradient.setColorAt(0.6 * grange, Qt.GlobalColor.yellow)
            self.gradient.setColorAt(1 * grange, Qt.GlobalColor.red)
        elif self.gradient_type == 3:
            self.gradient.setColorAt(0 * grange, Qt.GlobalColor.red)
            self.gradient.setColorAt(0.05 * grange, Qt.GlobalColor.yellow)
            self.gradient.setColorAt(0.1 * grange, Qt.GlobalColor.green)
            self.gradient.setColorAt(0.4 * grange, Qt.GlobalColor.green)
            self.gradient.setColorAt(0.45 * grange, Qt.GlobalColor.yellow)
            self.gradient.setColorAt(0.5 * grange, Qt.GlobalColor.red)

        self.gradient.setCenter(x, y)
        painter.fillPath(qp, QBrush(self.gradient))

        pen = QPen()
        pen.setColor(Qt.GlobalColor.black)
        pen.setWidth(max(1, int(1 * self.width() / 300)))
        painter.setPen(pen)
        painter.drawPath(qp)

        qp = QPainterPath()
        #qp.moveTo(0,0)
        #qp.lineTo(x,y)
        #qp.lineTo(self.width(),0)

        angle = 0
        ac = math.atan(float(self.width()) / 2.0 / float(big_radius)) * 0.95

        if self.direction == self.UNIDIRECTIONAL:
            angle = math.pi / 2 + ac * (1 - 2 * self.angle)

        elif self.direction == self.BIDIRECTIONAL:
            angle = math.pi / 2 - self.angle * ac

        length = big_radius + 10
        short_length = small_radius - 10

        qp.moveTo(x + math.cos(angle) * short_length,
                  y - math.sin(angle) * short_length)
        qp.lineTo(x + math.cos(angle) * length, y - math.sin(angle) * length)
        pen = QPen()
        pen.setCapStyle(Qt.RoundCap)
        pen.setColor(Qt.GlobalColor.black)
        pen.setWidth(max(3, int(3 * width / 300)))
        painter.setPen(pen)
        painter.drawPath(qp)

        qp = QPainterPath()
        delta = self.width() * 0.025

        # print "{}-{} {} c:{}".format(x,y,delta,math.cos(angle))
        qp.moveTo(x + delta + math.cos(angle) * short_length,
                  y + delta - math.sin(angle) * short_length)
        qp.lineTo(x + delta + math.cos(angle) * length,
                  y + delta - math.sin(angle) * length)
        pen = QPen()
        pen.setCapStyle(Qt.RoundCap)
        pen.setColor(QColor.fromRgbF(0, 0, 0, 0.3))
        pen.setWidth(max(3, int(3 * width / 300)))
        painter.setPen(pen)
        painter.drawPath(qp)

        qp = QPainterPath()
        qp.addRect(0, 0, self.width(), self.height())
        painter.drawPath(qp)
Example #38
0
 def random():
     pen = QPen()
     pen.setColor(QColor(random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)))
     point = Point(100. * random.random(), 100. * random.random())
     size = Size(5 + 100. * random.random(), 5 + 100. * random.random())
     return Rect(point, size, pen)
Example #39
0
 def draw(self, painter, scale):
     if self.point:
         pen = QPen()
         pen.setColor(QColor(255, 0, 0))
         painter.setPen(pen)
         painter.drawEllipse(self.point, Figure.CTRL_RADIUS + 4, Figure.CTRL_RADIUS + 4)
Example #40
0
    def _draw_over_grid(self,painter):
        # painter.setRenderHint(QPainter.Antialiasing, False)

        line_color = QColor(60, 20, 200, 255)
        flat_structure = QColor(20,20,255,128)
        line_color = flat_structure

        w = min(self.height(), self.width()) / 20
        m = self.margin / 2

        x0 = m
        x1 = m + w
        x15 = m + 9*w
        x2 = self.width() - m - w
        x3 = self.width() - m

        y0 = m
        y1 = m + w
        y15 = m + 5*w
        y2 = self.height() - m - w
        y3 = self.height() - m


        # ----------------------------------------------------------------------

        d = w / 4
        p = [ (x0,y15+d),
              (x0,y1),
              (x1,y0),

              (x15+2*d,y0),     #         /
              (x15+d,y0+d),     #    ____/
              (x1,y0+d),    #   /
              (x0+d,y1),        #  |
              (x0+d,y15),       #  |
              (x0,y15+d)        # _|
        ]

        qp = QPainterPath()
        qp.moveTo( p[0][0], p[0][1],)
        for i in range(1,len(p)):
            qp.lineTo( p[i][0], p[i][1],)
        qp.closeSubpath()


        painter.fillPath(qp,QBrush(QColor(20,20,255,128)))

        pen = QPen()
        pen.setCapStyle(Qt.RoundCap)

        pen.setColor(line_color) # alpha=255=fully opaque
        pen.setWidth(1)
        painter.setPen(pen)
        painter.drawPath(qp)

        # ---------------------------------------------------------

        qp = QPainterPath()


        p = [ (x0,y1), (x1,y0),
              (x2,y0), (x3,y1),
              (x3,y2), (x2,y3),
              (x1,y3), (x0,y2),
              (x0,y1)]

        qp.moveTo( p[0][0], p[0][1],)
        for i in range(1,len(p)):
            qp.lineTo( p[i][0], p[i][1],)

        pen = QPen()
        pen.setCapStyle(Qt.RoundCap)
        pen.setColor(QColor(0, 0, 80, 196)) # alpha=255=fully opaque
        pen.setWidth(5)
        painter.setPen(pen)

        painter.drawPath(qp)

        pen = QPen()
        pen.setCapStyle(Qt.RoundCap)
        pen.setColor(line_color) # alpha=255=fully opaque
        pen.setWidth(1)
        painter.setPen(pen)

        painter.drawPath(qp)
Example #41
0
    def _draw_serie(self, painter, ndx_serie, color):

        last_item = len(self.data) - 1

        serie = self.data[ndx_serie]

        serie_below = [0] * len(self.data[last_item])
        if ndx_serie < len(self.data) - 1:
            serie_below = self.data[ndx_serie + 1]

        fill_color = QColor(color)
        fill_color.setAlpha(64)
        brush = QBrush(fill_color)
        pen = QPen()
        pen.setCapStyle(Qt.SquareCap)
        pen.setColor(color)

        for i in range(len(serie)):
            x, y_top, y_below = self._item_coordinates(ndx_serie, i)

            qp = QPainterPath()

            h = float(y_top - y_below - 1)
            if h > 0:
                qp.addRect(x, float(self.y_base - y_top),
                           float(self.bar_width), h)

                painter.fillPath(qp, brush)

                if self.ndx_best_serie == ndx_serie and (
                        self.best_serie_intra_ndx is None or
                    (self.best_serie_intra_ndx >= 0
                     and self.best_serie_intra_ndx == i)):
                    pen.setWidth(3)
                else:
                    pen.setWidth(1)

                painter.setPen(pen)
                painter.drawPath(qp)

        if ndx_serie == self.ndx_best_serie:
            fm = painter.fontMetrics()
            pen.setWidth(1)
            painter.setPen(pen)

            serie_below = None
            if ndx_serie < len(self.data) - 1:
                serie_below = self.data[ndx_serie + 1]

            for i in range(len(serie)):
                if (self.best_serie_intra_ndx
                        == i) or self.best_serie_intra_ndx is None:
                    x, y_top, y_below = self._item_coordinates(ndx_serie, i)
                    l_len = 15

                    v = serie[i]
                    if serie_below:
                        v = v - serie_below[i]
                    v = str(int(v))
                    bb = fm.boundingRect(v)

                    pen.setColor(color)
                    y = 0
                    if i < len(serie) - 1:
                        # small diagonal going top, right
                        painter.drawLine(x + self.bar_width,
                                         self.y_base - y_top,
                                         x + self.bar_width + l_len,
                                         self.y_base - (y_top + l_len))

                        x = x + self.bar_width + l_len
                        y = y_top + l_len
                    else:
                        # small diagonal going top, left
                        painter.drawLine(x, self.y_base - y_top, x - l_len,
                                         self.y_base - (y_top - l_len))

                        x = x - l_len - bb.width()
                        y = y_top - l_len

                    bb.moveTo(int(x), int(self.y_base - y - bb.height()))

                    brush = QBrush(Qt.GlobalColor.red)
                    bb.adjust(-2, +2, +4, +4)

                    bb.adjust(-2, -2, +2, +2)
                    painter.fillRect(bb, brush)

                    bb.adjust(+2, +2, -2, -2)
                    painter.drawRect(bb)

                    pen.setColor(Qt.GlobalColor.white)
                    painter.setPen(pen)
                    painter.drawText(x, self.y_base - y, str(int(v)))