def paintEvent( self, event ): """ Das automatisch ausgelöste paintEvent, das das Widget bei jeder Fensterveränderung neu zeichnet. """ if self.__maximum > 0: frameWidth = 1 separatorWidth = 1 # Damit der Rahmen nicht irgendwie abgeschnitten wird, muß das Quadrat entsprechend kleiner sein. squareSideLength = 10 framePen = QPen( frameWidth ) framePen.setColor( self.__colorFrame ) squareSideLengthPlus = squareSideLength + 2 * frameWidth painter = QPainter( self ) windowWidth = self.width() / min( self.__maximum, self.__columnMax ) windowHeight = self.__maximum / self.__columnMax windowHeight = math.ceil( windowHeight ) windowHeight = self.height() / windowHeight side = min( windowWidth, windowHeight ) painter.setRenderHint( QPainter.Antialiasing ) # Wenn das Widget disabled ist, muß ich den Alphakanal meiner Farben verändern. if ( not self.isEnabled() ): painter.setOpacity( .5 ) #painter.translate( float( windowWidth ), float( windowHeight ) ) painter.scale( side / squareSideLengthPlus, side / squareSideLengthPlus ) painter.setPen( framePen ) painter.setBrush( self.__colorEmpty ) painter.save() squareColumnIter = 0 squareLineIter = 0 squareCount = 0 for squareCount in range(self.__maximum): square = QRect( ( squareSideLength + separatorWidth ) * squareColumnIter + frameWidth * ( squareColumnIter + 1 ), ( squareSideLength + separatorWidth ) * squareLineIter + frameWidth * ( squareLineIter + 1 ), squareSideLength, squareSideLength ) painter.drawRect( square ) # Wir zeichnen die ausgekreuzten Quadrate if (self.__value > (self.__columnMax * squareLineIter + squareColumnIter)): painter.drawLine(square.bottomLeft(), square.topRight()) painter.drawLine(square.topLeft(), square.bottomRight()) squareColumnIter += 1 if ( squareColumnIter >= self.__columnMax ): squareColumnIter = 0 squareLineIter += 1 painter.restore()
def paintEvent(self, event):
"""
Overloads the paint event to handle painting pointers for the popup \
mode.
:param event | <QPaintEvent>
"""
# use the base technique for the dialog mode
if self.currentMode() == XPopupWidget.Mode.Dialog:
super(XPopupWidget, self).paintEvent(event)
return
# setup the coloring options
palette = self.palette()
painter = QPainter()
painter.begin(self)
pen = QPen(palette.color(palette.Window).darker(130))
pen.setWidthF(1.75)
painter.setPen(pen)
painter.setRenderHint(painter.Antialiasing)
painter.setBrush(palette.color(palette.Window))
painter.drawPath(self.borderPath())
painter.end()
def __init__(self, radiusOut, raiusIn, angle, arcLen, parent=None):
QGraphicsPathItem.__init__(self, parent=parent)
self._radiusOut = radiusOut
self._raiusIn = raiusIn
self._angle = angle
self._arcLen = arcLen
self._pen = QPen(QColor('#000000'))
self._pen.setWidth(1)
self.setPen(self._pen)
self._hoverPen = QPen(QColor('#000000'))
self._hoverPen.setWidth(2)
brush = QBrush(QColor('#FF9966'))
self.setBrush(brush)
rectOut = QRectF(-radiusOut, -radiusOut, radiusOut*2.0, radiusOut*2.0)
rectIn = QRectF(-raiusIn, -raiusIn, raiusIn*2.0, raiusIn*2.0)
startAngle = angle - arcLen/2.0
endAngle = angle + arcLen/2.0
path = QPainterPath()
path.arcMoveTo(rectIn, startAngle)
path.arcTo(rectOut, startAngle, arcLen)
path.arcTo(rectIn, endAngle, 0)
path.arcTo(rectIn, endAngle, -arcLen)
self.setPath(path)
self._isHover = False
self._ioDragFirstPos = None
def create_multicut_edge_layer(self):
ActionInfo = ShortcutManager.ActionInfo
op = self.__topLevelOperatorView
if not op.Output.ready():
return None
# Final segmentation -- Edges
default_pen = QPen(SegmentationEdgesLayer.DEFAULT_PEN)
default_pen.setColor(Qt.blue)
layer = SegmentationEdgesLayer(LazyflowSource(op.Output), default_pen)
layer.name = "Multicut Edges"
layer.visible = False # Off by default...
layer.opacity = 1.0
layer.shortcutRegistration = (
"m",
ActionInfo(
"Multicut",
"MulticutEdgesVisibility",
"Show/Hide Multicut Edges",
layer.toggleVisible,
self.viewerControlWidget(),
layer,
),
)
return layer
def __init__(self, scene, axis, posModel):
QGraphicsItem.__init__(self, scene=scene)
self.setFlag(QGraphicsItem.ItemHasNoContents);
self.axis = axis
self.posModel = posModel
self._width = 0
self._height = 0
self.thick_penX = QPen(Qt.red, self.thick_width)
self.thick_penX.setCosmetic(True)
self.thick_penY = QPen(Qt.green, self.thick_width)
self.thick_penY.setCosmetic(True)
self.thin_penX = QPen(Qt.red, self.thin_width)
self.thin_penX.setCosmetic(True)
self.thin_penY = QPen(Qt.green, self.thin_width)
self.thin_penY.setCosmetic(True)
self.x = 0
self.y = 0
# These child items do most of the work.
self._horizontal_marker = SliceMarkerLine(self, 'horizontal')
self._vertical_marker = SliceMarkerLine(self, 'vertical')
# We
self._horizontal_marker = SliceMarkerLine(self, 'horizontal')
self._vertical_marker = SliceMarkerLine(self, 'vertical')
def __init__(self, scene, axis, posModel):
"""
scene: Must be an ImageScene2D instance. We manipulate the scene.allow_brushing flag.
"""
QGraphicsItem.__init__(self, scene=scene)
self.setFlag(QGraphicsItem.ItemHasNoContents);
self.axis = axis
self.posModel = posModel
self._width = 0
self._height = 0
self.thick_penX = QPen(Qt.red, self.thick_width)
self.thick_penX.setCosmetic(True)
self.thick_penY = QPen(Qt.green, self.thick_width)
self.thick_penY.setCosmetic(True)
self.thin_penX = QPen(Qt.red, self.thin_width)
self.thin_penX.setCosmetic(True)
self.thin_penY = QPen(Qt.green, self.thin_width)
self.thin_penY.setCosmetic(True)
self.x = 0
self.y = 0
# These child items do most of the work.
self._horizontal_marker = SliceMarkerLine(self, 'horizontal')
self._vertical_marker = SliceMarkerLine(self, 'vertical')
def mouseMoveEvent(self, event):
if event.buttons() & Qt.LeftButton:
downPos = event.buttonDownPos(Qt.LeftButton)
if not self.__tmpLine and self.__dragStartItem and \
(downPos - event.pos()).manhattanLength() > \
QApplication.instance().startDragDistance():
# Start a line drag
line = QGraphicsLineItem(self)
start = self.__dragStartItem.boundingRect().center()
start = self.mapFromItem(self.__dragStartItem, start)
line.setLine(start.x(), start.y(),
event.pos().x(), event.pos().y())
pen = QPen(Qt.black, 4)
pen.setCapStyle(Qt.RoundCap)
line.setPen(pen)
line.show()
self.__tmpLine = line
if self.__tmpLine:
# Update the temp line
line = self.__tmpLine.line()
line.setP2(event.pos())
self.__tmpLine.setLine(line)
QGraphicsWidget.mouseMoveEvent(self, event)
def draw_image(name, q): image = QSvgGenerator() image.setSize(QSize(IMAGE_SIZE, IMAGE_SIZE)) image.setFileName(name + ".svg") painter = QPainter() painter.begin(image) painter.setBrush(Qt.white) painter.setPen(Qt.NoPen) painter.drawEllipse(QPointF(IMAGE_SIZE/2, IMAGE_SIZE/2), IMAGE_SIZE/2, IMAGE_SIZE/2) painter.setBrush(QBrush()) painter.setPen(QPen()) draw_defect(painter, q) draw_circle(painter, q) pen = QPen() pen.setWidth(7) pen.setColor(Qt.red) painter.setPen(pen) painter.drawLine(IMAGE_SIZE/2 - ARROW_SIZE, IMAGE_SIZE/2, IMAGE_SIZE/2 + ARROW_SIZE, IMAGE_SIZE/2) painter.drawLine(IMAGE_SIZE/2 + ARROW_SIZE, IMAGE_SIZE/2, IMAGE_SIZE/2 + ARROW_SIZE - 30, IMAGE_SIZE/2 + 20) painter.drawLine(IMAGE_SIZE/2 + ARROW_SIZE, IMAGE_SIZE/2, IMAGE_SIZE/2 + ARROW_SIZE - 30, IMAGE_SIZE/2 - 20) font = painter.font() font.setPixelSize(40) font.setBold(True) painter.setFont(font) painter.drawText(QPointF(IMAGE_SIZE/2 + ARROW_SIZE - 30, IMAGE_SIZE/2 - 30), "E") painter.end()
def drawForeground(self, painter, rect):
QGraphicsView.drawForeground(self, painter, rect)
if self._sel_accepted:
painter.save()
painter.resetTransform()
rect = self._sel_rect
viewport = self.viewport()
option = QStyleOptionRubberBand()
option.initFrom(viewport)
option.rect = self._sel_rect
option.shape = QRubberBand.Rectangle
mask = QStyleHintReturnMask()
self.style().drawControl(QStyle.CE_RubberBand, option, painter, viewport);
painter.restore()
elif self._div_accepted:
painter.save()
painter.resetTransform()
line = self._div_line
viewport = self.viewport()
palette = viewport.palette()
pen = QPen(Qt.DashDotLine)
pen.setWidth(2)
pen.setColor(Qt.red)
painter.setPen(pen)
painter.drawLine(self._div_line)
painter.restore()
def drawForeground(self, painter, rect):
if self._tiling is None:
return
tile_nos = self._tiling.intersected(rect)
for tileId in tile_nos:
p = self._brushingLayer[tileId]
if p.dataVer == p.imgVer:
continue
p.paint(painter) #access to the underlying image patch is serialized
## draw tile outlines
if self._showTileOutlines:
# Dashed black line
pen = QPen()
pen.setDashPattern([5,5])
painter.setPen(pen)
painter.drawRect(self._tiling.imageRects[tileId])
# Dashed white line
# (offset to occupy the spaces in the dashed black line)
pen = QPen()
pen.setDashPattern([5,5])
pen.setDashOffset(5)
pen.setColor(QColor(Qt.white))
painter.setPen(pen)
painter.drawRect(self._tiling.imageRects[tileId])
def updateFilledCircle(self, s):
size = s * self.zoom
pixmap = QPixmap(self.width(), self.height())
pixmap.fill(Qt.transparent)
#painter filled ellipse
p = QPalette()
painter = QPainter()
painter.begin(pixmap)
painter.setRenderHint(QPainter.Antialiasing)
brush = QBrush(p.link().color())
painter.setBrush(brush)
painter.setOpacity(0.4)
painter.drawEllipse(QRect(self.width()/2 - size/2, self.height()/2 - size/2, size, size))
painter.end()
#painter ellipse 2
painter2 = QPainter()
painter2.begin(pixmap)
painter2.setRenderHint(QPainter.Antialiasing)
pen2 = QPen(Qt.green)
pen2.setWidth(1)
painter2.setPen(pen2)
painter2.drawEllipse(QRect(self.width()/2 - size/2, self.height()/2 - size/2, size, size))
painter2.end()
self.ellipseLabel.setPixmap(QPixmap(pixmap))
self.lastSize = s
def paintEvent(self, e):
super().paintEvent(e)
painter = QPainter()
painter.begin(self)
pen = QPen()
pen.setWidth(2)
painter.setPen(pen)
right_as_line = False
ral_place = []
if self.previous_commit != None and '\\' in self.previous_commit[-1]:
right_as_line = True
for f in range(len(self.previous_commit[-1])):
if self.previous_commit[-1][f] == '\\':
ral_place.append(f)
i = 0
for j in range(len(self.commit[0])):
if self.commit[0][j] == '*':
painter.drawImage(QPoint(i,0), self.commit_image())
elif self.commit[0][j] == '|':
x = 30/len(self.commit)
if len(self.commit) > 1 and len(self.commit[1]) > j+1 and self.commit[1][j+1] == '\\':
x = 15
painter.drawLine(i+15, 0, i+15, x)
elif self.commit[0][j] == '\\':
if right_as_line == True and j-1 in ral_place:
painter.drawLine(i+15, 0, i+15, 15)
else:
painter.drawLine(i+15, 15, i+30, 15+(15/len(self.commit)))
elif self.commit[0][j] == '/':
painter.drawImage(QPoint(i,0), QImage(dirname(__file__)+'/icons/right.png'))
elif self.commit[0][j] == '_':
painter.drawImage(QPoint(i,0), QImage(dirname(__file__)+'/icons/line-flipped.png'))
i += self.char_size
down = 0
up = 0
left = False
for j in range(1, len(self.commit)):
i = 0
for k in range(len(self.commit[j])):
if self.commit[j][k] == '|':
x = (30/len(self.commit))*j
if len(self.commit[0]) > k and self.commit[0][k] == '*':
x += 15
if len(self.commit[j-1]) > k and self.commit[j-1][k-1] == '\\':
x += (30/len(self.commit))/2
painter.drawLine(i+15, x, i+15, (30/len(self.commit))*(j+1))
elif self.commit[j][k] == '\\':
painter.drawLine(i+1, 15, i+29, 15+(15/len(self.commit))*(j+1))
down = 5
up = 2
left = True
elif self.commit[j][k] == '/':
if left == True:
painter.drawLine(i+2, 15+(13/len(self.commit))*(j+1), i+29, 15+(15/len(self.commit))*j)
else:
painter.drawLine(i+1, (30/len(self.commit))*(j+1)-up, i+27, down+(30/len(self.commit))*j)
elif self.commit[j][k] == '_':
painter.drawLine(i, 15+(15/len(self.commit))*j, i+30, 15+(15/len(self.commit))*j)
i += self.char_size
painter.end()
def setRectanglePen( self ):
" Sets the diagram pen "
pen = QPen( QColor( 0, 0, 0) )
pen.setWidth( 2 )
pen.setJoinStyle( Qt.RoundJoin )
self.setPen( pen )
return
class CoreItem(QGraphicsEllipseItem):
def __init__(self, radius, parent=None):
QGraphicsEllipseItem.__init__(self, QRectF(-radius, -radius, radius*2.0, radius*2.0), parent=parent)
self._pen = QPen(QColor('#000000'))
self._pen.setWidth(1)
self.setPen(self._pen)
self._hoverPen = QPen(QColor('#000000'))
self._hoverPen.setWidth(2)
brush = QBrush(QColor('#FF9966'))
self.setBrush(brush)
self._isSelected = False
self._isHover = False
self.setAcceptHoverEvents(True)
def setIsHover(self, isHover):
self._isHover = isHover
pen = self._hoverPen if isHover else self._pen
self.setPen(pen)
self.update()
def hoverEnterEvent(self, event):
QGraphicsEllipseItem.hoverEnterEvent(self, event)
event.accept()
self.setIsHover(True)
def hoverLeaveEvent(self, event):
QGraphicsEllipseItem.hoverLeaveEvent(self, event)
event.accept()
self.setIsHover(False)
def __init__(self, source, dest):
super().__init__()
self.setAcceptedMouseButtons(Qt.LeftButton)
self.setCacheMode(self.DeviceCoordinateCache) # Without this, burn thy CPU
self.setZValue(1)
pen = QPen(Edge.Color.DEFAULT[0], 1)
pen.setJoinStyle(Qt.MiterJoin)
self.setPen(pen)
self.arrowHead = QtGui.QPolygonF()
self._selected = False
self._weights = []
self._labels = []
self.squares = GroupOfSquares(self)
self.source = source
self.dest = dest
if source is dest:
source.edges.append(self)
else:
source.edges.insert(0, self)
dest.edges.insert(0, self)
# Add text labels
label = self.label = TextItem('', self)
label.setFont(Edge.Font.DEFAULT)
label.setZValue(3)
self.adjust()
def paintEvent(self, event):
""" custom paint event to draw vertical text """
painter = QPainter(self)
# draw box around
arc_size, line_width=10, 1
pen = QPen(QtCore.Qt.gray)
pen.setWidth(line_width)
painter.setPen(pen)
painter.drawLine(arc_size,0, self.width(), 0)
painter.drawLine(0, arc_size,0, self.height()-arc_size)
painter.drawLine(arc_size-5,self.height()-1,self.width(), self.height()-1)
painter.drawArc(0,0, arc_size*2, arc_size*2, 180*16, -90*16)
painter.drawArc(0,self.height()-arc_size*2, arc_size*2, arc_size*2, 180*16, 90*16)
# draw box around
#if (self.isEnabled()):
if self.selected:
painter.setPen(QtCore.Qt.black)
else:
painter.setPen(QtCore.Qt.gray)
painter.translate(self.width(), self.height())
painter.rotate(270)
painter.drawText(QtCore.QPointF(10,- self.width()/3), self.text())
# destroy
del painter
def paintEvent(self, ev):
color = self.palette().color(QPalette.Highlight)
painter = QPainter(self)
# Filled rectangle.
painter.setClipRect(self.rect())
color.setAlpha(50)
painter.fillRect(self.rect().adjusted(2,2,-2,-2), color)
# Thin rectangle outside.
color.setAlpha(150)
painter.setPen(color)
painter.drawRect(self.rect().adjusted(0,0,-1,-1))
# Pseudo-handles at the corners and sides
color.setAlpha(100)
pen = QPen(color)
pen.setWidth(8)
painter.setPen(pen)
painter.setBackgroundMode(Qt.OpaqueMode)
# Clip at 4 corners
region = QRegion(QRect(0,0,20,20))
region += QRect(self.rect().width()-20, 0, 20, 20)
region += QRect(self.rect().width()-20, self.rect().height()-20, 20, 20)
region += QRect(0, self.rect().height()-20, 20, 20)
# Clip middles
region += QRect(0, self.rect().height()/2-10, self.rect().width(), 20)
region += QRect(self.rect().width()/2-10, 0, 20, self.rect().height())
# Draw thicker rectangles, clipped at corners and sides.
painter.setClipRegion(region)
painter.drawRect(self.rect())
def draw(self):
""" Draws connection.
"""
self.calculateRoute()
if not self.routeIsValid():
return
painter = QPainter(self)
#logging.debug(self.__class__.__name__ +": draw()")
if self._selectedFlag:
# Selected
framePen = QPen(self.SELECT_COLOR)
framePen.setWidth(self.SELECTED_FRAME_WIDTH)
else:
#self.select(False)
framePen = QPen(Qt.NoPen)
#if hasattr(QPainter, 'Antialiasing'):
if self.zoom() > 30:
painter.setRenderHint(QPainter.Antialiasing)
# painter.setPen(Qt.black)
# for thisP in self._route:
# painter.drawEllipse(self.mapFromParent(thisP), self.CONNECTION_THICKNESS * self.zoomFactor(), self.CONNECTION_THICKNESS* self.zoomFactor())
painter.setPen(framePen)
for i in range(0, len(self._route) -1):
#self.drawLineSection(painter, route[i], route[i + 1], self._cornerTypes[i], self._cornerTypes[i + 1])
self.drawSection(painter, i)
def draw_arrow(self, line, width, color):
(x1, y1), (x2, y2) = line
# compute points
line = QLineF(x1, y1, x2, y2)
# If the line is very small, we make our arrowhead smaller
arrowsize = min(14, line.length())
lineangle = radians(line.angle())
arrowpt1 = line.p2() + QPointF(sin(lineangle - (pi/3)) * arrowsize, cos(lineangle - (pi/3)) * arrowsize)
arrowpt2 = line.p2() + QPointF(sin(lineangle - pi + (pi/3)) * arrowsize, cos(lineangle - pi + (pi/3)) * arrowsize)
head = QPolygonF([line.p2(), arrowpt1, arrowpt2])
# We have to draw the actual line a little short for the tip of the arrowhead not to be too wide
adjustedLine = QLineF(line)
adjustedLine.setLength(line.length() - arrowsize/2)
# draw line
painter = self.current_painter
color = COLORS[color]
painter.save()
pen = QPen(painter.pen())
pen.setColor(color)
pen.setWidthF(width)
painter.setPen(pen)
painter.drawLine(adjustedLine)
# draw arrowhead
painter.setPen(Qt.NoPen)
brush = painter.brush()
brush.setColor(color)
brush.setStyle(Qt.SolidPattern)
painter.setBrush(brush)
painter.drawPolygon(head)
painter.restore()
def addRectIndependencePearson(self, rect, x, y, w, h, xAttr_xVal, yAttr_yVal, actual, sum, width):
xAttr, xVal = xAttr_xVal
yAttr, yVal = yAttr_yVal
expected = float(xVal*yVal)/float(sum)
pearson = (actual - expected) / sqrt(expected)
if pearson > 0: # if there are more examples that we would expect under the null hypothesis
intPearson = floor(pearson)
pen = QPen(QColor(0,0,255), width); rect.setPen(pen)
b = 255
r = g = 255 - intPearson*20
r = g = max(r, 55) #
elif pearson < 0:
intPearson = ceil(pearson)
pen = QPen(QColor(255,0,0), width)
rect.setPen(pen)
r = 255
b = g = 255 + intPearson*20
b = g = max(b, 55)
else:
pen = QPen(QColor(255,255,255), width)
r = g = b = 255 # white
color = QColor(r,g,b)
brush = QBrush(color)
rect.setBrush(brush)
if pearson > 0:
pearson = min(pearson, 10)
kvoc = 1 - 0.08 * pearson # if pearson in [0..10] --> kvoc in [1..0.2]
else:
pearson = max(pearson, -10)
kvoc = 1 - 0.4*pearson
pen.setWidth(1)
self.addLines(x,y,w,h, kvoc, pen)
def paintEvent( self, event ):
"""
Overloads the paint event to draw rounded edges on this widget.
:param event | <QPaintEvent>
"""
super(XRolloutItem, self).paintEvent(event)
painter = QPainter()
painter.begin(self)
w = self.width() - 3
h = self.height() - 3
color = self.palette().color(QPalette.Midlight)
color = color.darker(180)
pen = QPen(color)
pen.setWidthF(0.5)
painter.setPen(pen)
painter.setBrush(self.palette().color(QPalette.Midlight))
painter.setRenderHint(QPainter.Antialiasing)
painter.drawRoundedRect(1, 1, w, h, 10, 10)
painter.end()
def paintEvent(self, event): """ Reimplements the :meth:`QWidget.paintEvent` method. :param event: Event. :type event: QEvent """ def __setBold(state): """ Sets the current painter font bold state. :return: Definiton success. :rtype: bool """ font = painter.font() font.setBold(state) painter.setFont(font) return True painter = QPainter(self) painter.fillRect(event.rect(), self.__backgroundColor) pen = QPen(QBrush(), self.__separatorWidth) pen.setColor(self.__separatorColor) painter.setPen(pen) topRightCorner = event.rect().topRight() bottomRightCorner = event.rect().bottomRight() painter.drawLine(topRightCorner.x(), topRightCorner.y(), bottomRightCorner.x(), bottomRightCorner.y()) painter.setPen(self.__color) viewportHeight = self.__editor.viewport().height() metrics = QFontMetrics(self.__editor.document().defaultFont()) currentBlock = self.__editor.document().findBlock( self.__editor.textCursor().position()) block = self.__editor.firstVisibleBlock() blockNumber = block.blockNumber() painter.setFont(self.__editor.document().defaultFont()) while block.isValid(): blockNumber += 1 position = self.__editor.blockBoundingGeometry(block).topLeft() + self.__editor.contentOffset() if position.y() > viewportHeight: break if not block.isVisible(): continue block == currentBlock and __setBold(True) or __setBold(False) painter.drawText(self.width() - metrics.width(foundations.strings.toString(blockNumber)) - self.__margin / 3, round(position.y() + metrics.ascent() + metrics.descent() - \ (self.__editor.blockBoundingRect(block).height() * 8.0 / 100)), foundations.strings.toString(blockNumber)) block = block.next() painter.end() QWidget.paintEvent(self, event)
def minorGridPen():
""" Reasonable default for minor grid pen.
@return QPen instance
"""
pen = QPen(QColor(210, 210, 210))
pen.setStyle(Qt.DotLine)
return pen
def paint(self, painter, option, widget):
params = parameters.instance
col = QColor(params.arrow_color)
pen = QPen(col)
pen.setWidth(params.arrow_line_size)
painter.setPen(pen)
painter.setBrush(col)
painter.drawPath(self.path)
def paint(self, painter, option, widget=None):
with painter_context(painter):
pen = QPen(painter.pen())
pen.setWidth(10.0)
pen.setColor( QColor(255,0,0) )
painter.setPen(pen)
shrunken_rectf = self.rectf.adjusted(10,10,-10,-10)
painter.drawRoundedRect(shrunken_rectf, 50, 50, Qt.RelativeSize)
def majorGridPen():
""" Reasonable default for major grid pen.
@return QPen instance
"""
pen = QPen(QColor(170, 170, 170))
pen.setStyle(Qt.DashLine)
return pen
class BaseConnectorItem(QGraphicsPathItem):
IOTypeIn = 1
IOTypeOut = 1 << 1
def __init__(self, radiusOut, raiusIn, angle, arcLen, parent=None):
QGraphicsPathItem.__init__(self, parent=parent)
self._radiusOut = radiusOut
self._raiusIn = raiusIn
self._angle = angle
self._arcLen = arcLen
self._pen = QPen(QColor('#000000'))
self._pen.setWidth(1)
self.setPen(self._pen)
self._hoverPen = QPen(QColor('#000000'))
self._hoverPen.setWidth(2)
brush = QBrush(QColor('#FF9966'))
self.setBrush(brush)
rectOut = QRectF(-radiusOut, -radiusOut, radiusOut*2.0, radiusOut*2.0)
rectIn = QRectF(-raiusIn, -raiusIn, raiusIn*2.0, raiusIn*2.0)
startAngle = angle - arcLen/2.0
endAngle = angle + arcLen/2.0
path = QPainterPath()
path.arcMoveTo(rectIn, startAngle)
path.arcTo(rectOut, startAngle, arcLen)
path.arcTo(rectIn, endAngle, 0)
path.arcTo(rectIn, endAngle, -arcLen)
self.setPath(path)
self._isHover = False
self._ioDragFirstPos = None
def ioType(self):
return self._ioType
def setIsHover(self, isHover):
self._isHover = isHover
pen = self._hoverPen if isHover else self._pen
self.setPen(pen)
self.update()
def hoverEnterEvent(self, event):
event.accept()
self.setIsHover(True)
QGraphicsPathItem.hoverEnterEvent(self, event)
def hoverLeaveEvent(self, event):
event.accept()
self.setIsHover(False)
QGraphicsPathItem.hoverLeaveEvent(self, event)
def __gradient(self):
left = QPointF(self.contentsRect().topLeft())
right = QPointF(self.contentsRect().topRight())
gradient = QLinearGradient(left, right)
gradient.setColorAt(0.9, self.palette().color(QPalette.WindowText))
gradient.setColorAt(1.0, self.palette().color(QPalette.Window))
pen = QPen()
pen.setBrush(QBrush(gradient))
return pen
def paint(self, QPainter, QStyleOptionGraphicsItem, QWidget_widget=None):
# setPen
pen = QPen()
pen.setWidth(5)
pen.setJoinStyle(Qt.MiterJoin) #让箭头变尖
QPainter.setPen(pen)
# draw line
QPainter.drawLine(self.line)
def penForID(self, penId):
if penId == PenID.Bar:
return self.linePen
elif penId == PenID.TodayLine:
pen = QPen(self.linePen)
pen.setColor(Qt.red)
return pen
else:
return GraphView.penForID(self, penId)
def imprimer(self):
self.liste_action()
printer = QtGui.QPrinter()
printer.setOutputFileName("listingAction.pdf")
painter = QtGui.QPainter()
painter.begin(printer)
pen = QPen(Qt.black, 1, Qt.SolidLine)
painter.setPen(pen)
marge = 20
col1 = 100
posCol2 = marge + col1
col2 = 250
posCol3 = posCol2 + col2
col3 = 250
posCol4 = posCol3 + col3
col4 = 100
fin = posCol4 + col4
pasY = 20
line = 0
posY = line * pasY
painter.drawLine(marge, posY,fin, posY)
painter.setFont(QtGui.QFont('Decorative', 10))
painter.drawText(marge + 5, posY + 15, 'Num semaine')
painter.drawText(posCol2 + 5, posY + 15, 'Planche')
painter.drawText(posCol3 + 5, posY + 15, 'Action')
painter.drawText(posCol4 + 5, posY + 15, 'Retrait')
for id in self.tableAction:
posY = (line + 1) * pasY
painter.drawLine(marge, posY,fin, posY)
painter.setFont(QtGui.QFont('Decorative', 10))
painter.drawText(marge + 5, posY + 15, str(self.tableAction[line][0]))
painter.drawText(posCol2 + 5, posY + 15, str(self.tableAction[line][1]))
painter.drawText(posCol3 + 5, posY + 15, str(self.tableAction[line][2]))
painter.drawText(posCol4 + 5, posY + 15, str(self.tableAction[line][3]))
line = line + 1
painter.drawLine(marge, 0,marge, (line + 1) * pasY)
painter.drawLine(posCol2, 0,posCol2, (line + 1) * pasY)
painter.drawLine(posCol3, 0,posCol3, (line + 1) * pasY)
painter.drawLine(posCol4, 0,posCol4, (line + 1) * pasY)
painter.drawLine(fin, 0,fin, (line + 1) * pasY)
painter.drawLine(marge, (line + 1) * pasY,fin, (line + 1) * pasY)
painter.end()
def draw_big_scaled_markter(self):
my_painter = QPainter(self)
my_painter.setRenderHint(QPainter.Antialiasing)
# Koordinatenursprung in die Mitte der Flaeche legen
my_painter.translate(self.width() / 2, self.height() / 2)
# my_painter.setPen(Qt.NoPen)
self.pen = QPen(QColor(0, 0, 0, 255))
self.pen.setWidth(2)
# # if outline_pen_with > 0:
my_painter.setPen(self.pen)
my_painter.rotate(self.scale_angle_start_value - self.angle_offset)
steps_size = (float(self.scale_angle_size) / float(self.scala_main_count))
scale_line_outer_start = self.widget_diameter/2
scale_line_lenght = (self.widget_diameter / 2) - (self.widget_diameter / 20)
# print(stepszize)
for i in range(self.scala_main_count+1):
my_painter.drawLine(scale_line_lenght, 0, scale_line_outer_start, 0)
my_painter.rotate(steps_size)
def __init__(self, canvas, parent=None):
super(ScaleBarItem, self).__init__(parent)
self.canvas = canvas
self.realsize = 100
black = QColor(Qt.black)
black.setAlpha(150)
white = QColor(Qt.white)
white.setAlpha(150)
blackpen = QPen(black, 4)
whitepen = QPen(white, 8)
self.pens = [whitepen, blackpen]
self.whitepen = QPen(white, 1)
self.blackbrush = QBrush(black)
self.ticksize = 10
self.fontsize = 15
self.font = QFont()
self.font.setPointSize(self.fontsize)
self.font.setStyleHint(QFont.Times, QFont.PreferAntialias)
self.font.setBold(True)
self.metrics = QFontMetrics(self.font)
def paint(self, painter, option, widget):
gradient = QRadialGradient(-3, -3, 10)
if option.state & QStyle.State_Sunken:
gradient.setCenter(3, 3)
gradient.setFocalPoint(3, 3)
gradient.setColorAt(0, QColor(Qt.yellow).light(120))
else:
gradient.setColorAt(0, QColor(Qt.yellow).light(120))
painter.setBrush(gradient)
painter.setPen(QPen(Qt.black, 0))
painter.drawRoundedRect(self.boundingRect(), 3, 3)
def __init__(self, parent=None, text=""):
super(QGraphicsPathItem, self).__init__(parent)
self.setAcceptHoverEvents(True)
self.setPen(QPen(Qt.NoPen))
self.text = QGraphicsTextItem(self)
layout = self.text.document().documentLayout()
layout.documentSizeChanged.connect(self._onLayoutChanged)
self._text = ""
self._anchor = QPointF()
def __init__(self,
pen=QPen(Qt.black),
brush=QBrush(Qt.white),
xData=[],
yData=[],
tooltip=None):
OWCurve.__init__(self, xData, yData, tooltip=tooltip)
self._data_polygon = self.polygon_from_data(xData, yData)
self._polygon_item = QGraphicsPolygonItem(self)
self.set_pen(pen)
self.set_brush(brush)
def drawAsciiDump(self, painter, offset, row, size, row_data) :
ascii_dump_left = self.asciiDumpLeft()
#// i is the byte index
chars_per_row = self.bytesPerRow()
for i in range(0,chars_per_row) :
index = offset + i
if(index < size) :
ch = row_data[i]
drawLeft = ascii_dump_left + i * self.font_width
printable = self.is_printable(ch)
#// drawing a selected character
if(self.isSelected(index)) :
painter.fillRect(
drawLeft,
row,
self.font_width,
self.font_height,
self.palette().highlight()
)
painter.setPen(QPen(self.palette().highlightedText().color()))
else :
if printable:
painter.setPen(QPen(self.palette().text().color()))
else:
painter.setPen(QPen(self.non_printable_text))
if printable:
byteBuffer = str(ch)
else:
byteBuffer = str(self.unprintable_char)
painter.drawText(
drawLeft,
row,
self.font_width,
self.font_height,
Qt.AlignTop,
byteBuffer
)
else :
break
return
def paint(self, painter, option, index):
filePath = self.model.filePath(index)
fileName = self.model.fileName(index)
r = option.rect
img = QPixmap(filePath)
if img.isNull():
# If not image file, try to load icon with QFileIconProvider
# according to file type (extension name).
# Currently not work as intended.
fileInfo = self.model.fileInfo(index)
icon = QFileIconProvider().icon(fileInfo)
img = icon.pixmap(QSize(32, 32))
# Scale to height, align center horizontally, align bottom vertically.
if img.height() > self.thumbHeight:
img = img.scaledToHeight(self.thumbHeight, Qt.SmoothTransformation)
if img.width() > self.thumbHeight:
img = img.scaledToWidth(self.thumbHeight, Qt.SmoothTransformation)
imgLeft = (self.width - img.width()) / 2
imgTop = self.thumbHeight - img.height()
painter.drawPixmap(r.left() + imgLeft, r.top() + imgTop, img)
rect = QRect(r.left(),
r.top() + self.thumbHeight, self.width, self.nameHeight)
flag = Qt.AlignHCenter | Qt.TextWrapAnywhere
# get the bounding rectangle of the fileName
bdRect = painter.boundingRect(rect, flag, fileName)
if bdRect.height() < rect.height():
rect = bdRect
if option.state & QStyle.State_Selected:
painter.setBrush(self.parent().palette().highlight())
painter.drawRoundedRect(rect, 5, 5)
pen = QPen(self.parent().palette().highlightedText(), 1,
Qt.SolidLine)
else:
pen = QPen(self.parent().palette().text(), 1, Qt.SolidLine)
painter.setPen(pen)
painter.drawText(rect, flag, fileName)
def __updateStyleState(self):
"""
Update the arrows' brush, pen, ... based on it's state
"""
if self.isSelected():
color = self.__color.darker(150)
pen = QPen(QColor(96, 158, 215), Qt.DashDotLine)
pen.setWidthF(1.25)
pen.setCosmetic(True)
self.__shadow.setColor(pen.color().darker(150))
else:
color = self.__color
pen = QPen(Qt.NoPen)
self.__shadow.setColor(QColor(63, 63, 63, 180))
self.__arrowItem.setBrush(color)
self.__arrowItem.setPen(pen)
def addRectIndependencePearson(self, rect, x, y, w, h, xAttr_xVal, yAttr_yVal, actual, sum):
xAttr, xVal = xAttr_xVal
yAttr, yVal = yAttr_yVal
expected = float(xVal*yVal)/float(sum)
pearson = (actual - expected) / sqrt(expected)
if pearson > 0: # if there are more examples that we would expect under the null hypothesis
intPearson = floor(pearson)
pen = QPen(QColor(0,0,255), 1); rect.setPen(pen)
b = 255
r = g = 255 - intPearson*20
r = g = max(r, 55) #
elif pearson < 0:
intPearson = ceil(pearson)
pen = QPen(QColor(255,0,0), 1)
rect.setPen(pen)
r = 255
b = g = 255 + intPearson*20
b = g = max(b, 55)
else:
pen = QPen(QColor(255,255,255), 1)
r = g = b = 255 # white
color = QColor(r,g,b)
brush = QBrush(color); rect.setBrush(brush)
if self.showCases and w > 6 and h > 6:
if self.showInColor:
if pearson > 0: c = QColor(0,0,255)
else: c = QColor(255, 0,0)
else: c = Qt.black
for i in range(int(actual)):
OWCanvasEllipse(self.canvas, random.randint(x+1, x + w-4), random.randint(y+1, y + h-4), 3, 3, penColor = c, brushColor = c, z = 100)
if pearson > 0:
pearson = min(pearson, 10)
kvoc = 1 - 0.08 * pearson # if pearson in [0..10] --> kvoc in [1..0.2]
else:
pearson = max(pearson, -10)
kvoc = 1 - 0.4*pearson
self.addLines(x,y,w,h, kvoc, pen)
def updateColor(self):
iconSize = self.iconSize()
width = iconSize.width()
height = iconSize.height()
pixmap = QPixmap(iconSize)
pixmap.fill(self._color)
painter = QPainter()
painter.begin(pixmap)
painter.setPen(QPen(QColor("#777777")))
painter.drawRect(QRect(0, 0, width - 1, height - 1))
painter.end()
self.setIcon(QIcon(pixmap))
def addCurve(self, curveId, curveName):
curveId = str(curveId)
if self.curves.get(curveId):
return
curveObject = Qwt.QwtPlotCurve(curveName)
curveObject.attach(self)
curveObject.setPen(QPen(self.colors[len(self.curves.keys()) % len(self.colors)]))
self.curves[curveId] = {
'name': curveName,
'data': zeros(self.dataNumValuesSaved),
'object': curveObject,
}
def paintEvent(self, event):
"""Paint over the widget to overlay its content."""
if not ACTIVATE_OPACITY:
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.TextAntialiasing, True)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.fillRect(event.rect(), QBrush(QColor(226, 0, 0, 80)))
painter.setPen(QPen(Qt.NoPen))
painter.end()
super(SliderArea, self).paintEvent(event)
def __init__(self, edge_count=3, radius=20):
super(PolygonItem, self).__init__()
# edge_count çokgenin kaç kenarı olduğunu
# radius ise çokgenin herhangi bir köşesinin
# merkeze olan mesafesini belirliyor.
# bir önceki görseldeki 'r' değeri
self.edge_count = edge_count
self.radius = radius
self.polygon = self.calculate_polygon_points()
self._pen = QPen(Qt.black)
self._brush = QBrush(Qt.NoBrush)
def paintEvent(self, e):
super(QFrame, self).paintEvent(e)
p = QPainter(self)
p.fillRect(self.contentsRect(), self.palette().button())
r = self.rect()
offset = 1 if self.frameShadow() == self.Sunken else 0
pen = QPen(self.palette().buttonText(), 1)
p.setPen(pen)
p.drawRect(r.center().x() + offset - 4, r.center().y() + offset, 1, 1)
p.drawRect(r.center().x() + offset, r.center().y() + offset, 1, 1)
p.drawRect(r.center().x() + offset + 4, r.center().y() + offset, 1, 1)
if self.hasFocus():
p.setPen(QPen(Qt.black, 0, Qt.SolidLine))
p.drawRect(0, 0, self.width() - 1, self.height() - 1)
p.end()
def draw_needle(self):
painter = QPainter(self)
# painter.setRenderHint(QtGui.QPainter.HighQualityAntialiasing)
painter.setRenderHint(QPainter.Antialiasing)
# Koordinatenursprung in die Mitte der Flaeche legen
painter.translate(self.width() / 2, self.height() / 2)
painter.setPen(QPen(Qt.black, 2, Qt.SolidLine))
painter.setBrush(self.NeedleColor)
painter.rotate(((self.value - self.value_offset - self.value_min) * self.scale_angle_size /
(self.value_max - self.value_min)) + 90 + self.scale_angle_start_value)
painter.drawConvexPolygon(self.value_needle[0])
def paint(self, p: QPainter):
if not self.n1.parent.isVisible() or (self.n2 is not None and not self.n2.parent.isVisible()):
return
if self.__path is None:
self.compute_path()
c = Block.border_color
if self.selected:
c = c.lighter().lighter()
if not self.__status:
c = QColor(255, 100, 100, 180)
p.setPen(QPen(c, 4))
p.drawPath(self.__path)
def __init__(self, start, end, pen=QPen(QColor(0, 0, 0, 255))):
self.pen = pen
QGraphicsItem.__init__(self)
self.starting_line = QLineF(start, end)
self.bounds = QRectF(start - (end - start), end + (end - start))
self.steps = 4
self.smooth = 50
self.dampen = 100
self.update_lines()
def __init__(self, x1, y1, x2, y2, parent=None, scene=None):
QGraphicsItem.__init__(self,
x1,
y1,
x2,
y2,
parent=parent,
scene=scene)
self.selec = False
self.ctrlPressed = False
self.selectWidth = 2.5
self.id = None
self.parentSelected = False
self.parentList = []
self.allItems = []
self.backupPen = self.pen()
self.select_pen = QPen(QtCore.Qt.gray)
self.select_pen.setStyle(QtCore.Qt.DotLine)
self.select_pen.setWidthF(self.selectWidth)
def chart(self, v1, v2):
self.data1.pop(0)
self.data2.pop(0)
self.data1.append(v1)
self.data2.append(v2)
self.scene1 = QGraphicsScene()
self.scene2 = QGraphicsScene()
self.setup_scene(self.scene1)
self.setup_scene(self.scene2)
path = QPainterPath()
path.moveTo(0, -self.data1[0] / 6)
for i in xrange(1, 100):
path.lineTo(2 * (i + 1), -self.data1[i] / 6)
self.scene1.addPath(path, QPen(QColor(0, 0, 255), 3))
path = QPainterPath()
path.moveTo(0, -self.data2[0] / 6)
for i in xrange(1, 100):
path.lineTo(2 * (i + 1), -self.data2[i] / 6)
self.scene2.addPath(path, QPen(QColor(0, 0, 255), 3))
self.ui.chart1.setScene(self.scene1)
self.ui.chart2.setScene(self.scene2)
def __highlight(self, positions, color=None, cancel=False):
cursor = QTextCursor(self.document())
modified = self.document().isModified()
for position in positions:
if position > self.get_position('eof'):
return
cursor.setPosition(position)
cursor.movePosition(QTextCursor.NextCharacter,
QTextCursor.KeepAnchor)
charformat = cursor.charFormat()
pen = QPen(Qt.NoPen) if cancel else QPen(color)
charformat.setTextOutline(pen)
cursor.setCharFormat(charformat)
if cancel:
charformat = QTextCharFormat()
cursor.movePosition(QTextCursor.NextCharacter,
QTextCursor.KeepAnchor)
cursor.setCharFormat(charformat)
cursor.clearSelection()
self.setCurrentCharFormat(charformat)
self.document().setModified(modified)
def paint(self, painter, option, index):
painter.setFont(option.font)
painter.setBrush(QBrush(Qt.black))
if option.state & QStyle.State_Selected:
painter.setPen(QPen(Qt.white))
rect = QRect(option.rect)
rect.setLeft(rect.left() + 4)
rect.setTop(rect.top() + 4)
rect.setWidth(rect.width() - 8)
rect.setHeight(rect.height() - 8)
painter.drawText(rect, Qt.Horizontal | Qt.TextWordWrap,
forceString(index.data()))
def __init__(self):
super().__init__()
self.results = None
self.classifier_names = []
self.colors = []
self._curve_data = {}
box = gui.widgetBox(self.controlArea, "Plot")
tbox = gui.widgetBox(box, "Target Class")
tbox.setFlat(True)
self.target_cb = gui.comboBox(
tbox, self, "target_index", callback=self._on_target_changed,
contentsLength=8)
cbox = gui.widgetBox(box, "Classifiers")
cbox.setFlat(True)
self.classifiers_list_box = gui.listBox(
cbox, self, "selected_classifiers", "classifier_names",
selectionMode=QtGui.QListView.MultiSelection,
callback=self._on_classifiers_changed)
gui.checkBox(box, self, "display_convex_hull",
"Show lift convex hull", callback=self._replot)
self.plotview = pg.GraphicsView(background="w")
self.plotview.setFrameStyle(QtGui.QFrame.StyledPanel)
self.plot = pg.PlotItem()
self.plot.getViewBox().setMenuEnabled(False)
pen = QPen(self.palette().color(QtGui.QPalette.Text))
tickfont = QtGui.QFont(self.font())
tickfont.setPixelSize(max(int(tickfont.pixelSize() * 2 // 3), 11))
axis = self.plot.getAxis("bottom")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("P Rate")
axis = self.plot.getAxis("left")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("TP Rate")
self.plot.showGrid(True, True, alpha=0.1)
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0))
self.plotview.setCentralItem(self.plot)
self.mainArea.layout().addWidget(self.plotview)
self.graphButton.clicked.connect(self.save_graph)
def loadItemPen(self, item):
""" Creates a pen from saved settings.
@param item ControlTreeItem instance
@return QPen instance
"""
pen = self.settings.value('%s/pen' % self.itemName(item))
if pen.isValid():
pen = QPen(pen)
else:
pen = defaults.itemPen(item.name())
return pen
def __init__(self, parent):
QGraphicsPathItem.__init__(self, parent)
if not isinstance(parent, LinkItem):
raise TypeError("'LinkItem' expected")
self.setAcceptedMouseButtons(Qt.NoButton)
self.__canvasLink = parent
self.setAcceptHoverEvents(True)
self.shadow = QGraphicsDropShadowEffect(
blurRadius=5, color=QColor(SHADOW_COLOR),
offset=QPointF(0, 0)
)
self.normalPen = QPen(QBrush(QColor("#9CACB4")), 2.0)
self.hoverPen = QPen(QBrush(QColor("#7D7D7D")), 2.1)
self.setPen(self.normalPen)
self.setGraphicsEffect(self.shadow)
self.shadow.setEnabled(False)
self.__hover = False
def _drawIcon(self, color=Qt.black):
self.setForeground(QBrush(color))
if self.isRootNode:
pixmap = QPixmap(20, 20)
pixmap.fill(Qt.transparent)
painter = QPainter()
painter.begin(pixmap)
pen = QPen(color)
pen.setWidth(1)
painter.setPen(pen)
painter.setBrush(color)
painter.setRenderHint(QPainter.Antialiasing)
if not self.isExpanded:
arrowRightPolygon = [QPoint(6,6), QPoint(6,14), QPoint(14, 10)]
painter.drawPolygon(QPolygon(arrowRightPolygon))
else:
arrowDownPolygon = [QPoint(6,6), QPoint(15,6), QPoint(10, 14)]
painter.drawPolygon(QPolygon(arrowDownPolygon))
painter.end()
self.setIcon(QIcon(pixmap))
def addLink(self, output, input):
"""
Add a link between `output` (:class:`OutputSignal`) and `input`
(:class:`InputSignal`).
"""
if not compatible_channels(output, input):
return
if output not in self.source.output_channels():
raise ValueError("%r is not an output channel of %r" % \
(output, self.source))
if input not in self.sink.input_channels():
raise ValueError("%r is not an input channel of %r" % \
(input, self.sink))
if input.single:
# Remove existing link if it exists.
for s1, s2, _ in self.__links:
if s2 == input:
self.removeLink(s1, s2)
line = QGraphicsLineItem(self)
source_anchor = self.sourceNodeWidget.anchor(output)
sink_anchor = self.sinkNodeWidget.anchor(input)
source_pos = source_anchor.boundingRect().center()
source_pos = self.mapFromItem(source_anchor, source_pos)
sink_pos = sink_anchor.boundingRect().center()
sink_pos = self.mapFromItem(sink_anchor, sink_pos)
line.setLine(source_pos.x(), source_pos.y(), sink_pos.x(),
sink_pos.y())
pen = QPen(Qt.black, 4)
pen.setCapStyle(Qt.RoundCap)
line.setPen(pen)
self.__links.append(_Link(output, input, line))
def paintEvent(self, event):
"""
Draw the QImage on screen.
"""
textPosX,textPosY = 10,200
painter = QPainter(self)
painter.drawImage(painter.viewport(), self._image)
innerFont = QFont()
innerFont.setPointSize(12)
painter.setFont(innerFont)
painter.setPen(QColor(QtCore.Qt.white))
painter.drawText(10,180,'Current Action:')
painter.drawText(10,200,self._currentMovement)
self.drawMoreText(painter,10,300,['Control Buttons:',
'w,s - Walking Forwards/Backwards',
'q,e - Walking Left/Right',
'a,d - Turning Left/Right',
'x - stopping',
'Space - standing up',
'Ctrl - crouch',
'Escape,Enter - restMode, wakeUp',
'1 - Grabbing small',
'2 - Grabbing large',
'3 - Grabbing Kuscheltier',
'4 - Grabbing bottle'])
self.drawMoreText(painter,self.width()-300-25,300,['Dialog Control:({})'.format(self._attitude),
'u - Introduction',
'i - Ask for object',
'h - Object is Somat',
'j - Object is Muesli',
'k - Object is Bottle',
'l - Object is Kuscheltier',
'n - Wertstoff',
'm - Altpapier',
'o - Ask for help',
'z - Ask proband to repeat sentence',
'p - Repeat task',
'0(Null) - construct initial state',
't - Goodbye',
'b - thanks',
'# - Start free Speech(PopUp)'])
self.drawMoreText(painter,100,50,['Movement Speeds','Forward: {}'.format(self._currentSpeeds['Forward']),'Leftward: {}'.format(self._currentSpeeds['Leftward']),'CounterClockwise: {}'.format(self._currentSpeeds['CounterClockwise'])])
pen = QPen()
pen.setColor(QColor(QtCore.Qt.red))
pen.setWidth(5)
painter.setPen(pen)
painter.drawEllipse(20,15,60,30)
pen.setColor(QColor(QtCore.Qt.blue))
painter.setPen(pen)
painter.drawPolygon(self.rotatePolygon(arrowPolygon,math.degrees(self._motionProxy.getAngles('HeadYaw',True)[0]),[30,20]))
def draw(self):
""" Draws connection.
"""
self.calculateRoute()
if not self.routeIsValid():
return
painter = QPainter(self)
#logging.debug(self.__class__.__name__ +": draw()")
if self._selectedFlag:
# Selected
framePen = QPen(self.SELECT_COLOR)
framePen.setWidth(self.SELECTED_FRAME_WIDTH)
else:
#self.select(False)
framePen = QPen(Qt.NoPen)
#if hasattr(QPainter, 'Antialiasing'):
if self.zoom() > 30:
painter.setRenderHint(QPainter.Antialiasing)
# painter.setPen(Qt.black)
# for thisP in self._route:
# painter.drawEllipse(self.mapFromParent(thisP), self.CONNECTION_THICKNESS * self.zoomFactor(), self.CONNECTION_THICKNESS* self.zoomFactor())
painter.setPen(framePen)
for i in range(0, len(self._route) - 1):
#self.drawLineSection(painter, route[i], route[i + 1], self._cornerTypes[i], self._cornerTypes[i + 1])
self.drawSection(painter, i)
def drawForeground(self, painter, rect):
QGraphicsView.drawForeground(self, painter, rect)
if self._sel_accepted:
painter.save()
painter.resetTransform()
rect = self._sel_rect
viewport = self.viewport()
option = QStyleOptionRubberBand()
option.initFrom(viewport)
option.rect = self._sel_rect
option.shape = QRubberBand.Rectangle
mask = QStyleHintReturnMask()
self.style().drawControl(QStyle.CE_RubberBand, option, painter,
viewport)
painter.restore()
elif self._div_accepted:
painter.save()
painter.resetTransform()
line = self._div_line
viewport = self.viewport()
palette = viewport.palette()
pen = QPen(Qt.DashDotLine)
pen.setWidth(2)
pen.setColor(Qt.red)
painter.setPen(pen)
painter.drawLine(self._div_line)
painter.restore()
