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)
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()
def paint(self, canvas, is_secondary_color=False, additional_flag=False): pen = QPen() pen.setWidth(self.data_singleton.pen_size) pen.setStyle(Qt.SolidLine) pen.setCapStyle(Qt.RoundCap) pen.setJoinStyle(Qt.RoundJoin) if is_secondary_color: pen.setBrush(self.data_singleton.secondary_color) else: pen.setBrush(self.data_singleton.primary_color) painter = QPainter(canvas.image) painter.setPen(pen) if self._start_point != self._end_point: painter.drawLine(self._start_point, self._end_point) if self._start_point == self._end_point: painter.drawPoint(self._start_point) painter.end() canvas.edited = True canvas.update()
def default_roi_pen(dashed=True,color=Qt.green): pen = QPen() if dashed: pen.setStyle(Qt.DashLine) pen.setBrush(color) pen.setCapStyle(Qt.RoundCap) pen.setJoinStyle(Qt.RoundJoin) return pen
def draw(self, painter, offset, draw_mode=DRAW_MODE_NORMAL): if draw_mode != Bin.DRAW_MODE_RELEASE: # Рисуем контур контейнера pen = QPen() pen.setStyle(Qt.DashLine) painter.setPen(pen) # painter.drawRect(self.origin.x, self.origin.y, self.size.width, self.size.height) painter.drawRect(offset.x, offset.y, self.size.width, self.size.height) for image in self.images: # Rect(rect.origin + self.origin, rect.size, rect.pen).draw(painter=painter) # image.draw(painter=painter, offset=self.origin) image.draw(painter=painter, offset=offset)
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)])
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
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)
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)
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()