def paintEvent(self, event):
painter = QPainter(self)
minSize = min(self.rect().width(), self.rect().height())
myRect = QRect(self.rect().x(), self.rect().y(), minSize, minSize)
painter.drawPixmap(myRect, self.backgroundPic,
self.backgroundPic.rect())
pen = QPen()
pen.setCapStyle(Qt.RoundCap)
pen.setWidthF(4.0)
pen.setColor(Qt.red)
pen.setJoinStyle(Qt.RoundJoin)
painter.setPen(pen)
spacing = 40
contentRect = myRect.adjusted(spacing, spacing, -spacing, -spacing)
valueInPercent = (self.m_value - self.m_minimum) / (self.m_maximum -
self.m_minimum)
math_pi = 3.14159265358979323846
degree = (self.m_startAngle +
90) - valueInPercent * 2.0 * self.m_startAngle
degree = degree * math_pi / 180.0
radius = (contentRect.width() - spacing * 0.5) * 0.5
vec = QPoint(radius * math.cos(degree), radius * -math.sin(degree))
painter.drawLine(contentRect.center(), contentRect.center() + vec)
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 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 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 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 draw_into(self, scene, incremental=False):
for subbranch in self.branches:
subbranch.draw_into(scene, incremental)
start = self.already_drawn if incremental else None
points = [QPointF(np.real(x), -np.imag(x)) for x in self.history[start:]]
gens = float(self.params["painter_generations"])
scale_factor = (self.params["scale"] - 1) * 3 + 1
pen_width = max(0, gens-self.generation) / gens * self.params["painter_thickness"] * scale_factor
if self.generation == 0 and len(self.history) < 30:
intensity = 126/30.0 * len(self.history)
else:
intensity = 17 + 99 * max(0, gens-self.generation) / gens
color = self.params["color"].darker(85 + (127 - intensity) * 4)
outline = color.darker(500)
pen = QPen(color)
pen.setWidthF(pen_width)
darkPen = QPen(outline)
darkPen.setWidthF(pen_width)
depth = self.params["depth"]
path = QPainterPath()
path.moveTo(points[0])
for index in range(1, len(points) - 1):
path.lineTo(points[index])
scene.addPath(path, pen)
if incremental:
self.already_drawn = max(0, len(self.history) - 1)
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 shape(self):
if self.__shape is None:
path = self.path()
pen = QPen(self.pen())
pen.setWidthF(max(pen.widthF(), 7.0))
pen.setStyle(Qt.SolidLine)
self.__shape = stroke_path(path, pen)
return self.__shape
def shape(self):
if self.__shape is None:
path = self.path()
pen = QPen(self.pen())
pen.setWidthF(max(pen.widthF(), 7.0))
pen.setStyle(Qt.SolidLine)
self.__shape = stroke_path(path, pen)
return self.__shape
def penForID(self, penId):
pen = QPen()
if penId == PenID.Axis:
pen.setColor(Qt.darkGray)
pen.setWidthF(self.LINE_WIDTH)
elif penId == PenID.AxisOverlay:
pen.setColor(Qt.darkGray)
pen.setWidthF(self.OVERLAY_AXIS_WIDTH)
return pen
def paint( self, painter, option, widget ):
"""
Overloads the paint method from QGraphicsPathItem to \
handle custom drawing of the path using this items \
pens and polygons.
:param painter <QPainter>
:param option <QGraphicsItemStyleOption>
:param widget <QWidget>
"""
# following the arguments required by Qt
# pylint: disable-msg=W0613
painter.setOpacity(self.opacity())
# show the connection selected
if ( not self.isEnabled() ):
pen = QPen(self.disabledPen())
elif ( self.isSelected() ):
pen = QPen(self.highlightPen())
else:
pen = QPen(self.pen())
if ( self._textItem ):
self._textItem.setOpacity(self.opacity())
self._textItem.setDefaultTextColor(pen.color().darker(110))
# rebuild first if necessary
if ( self.isDirty() ):
self.setPath(self.rebuild())
# store the initial hint
hint = painter.renderHints()
painter.setRenderHint( painter.Antialiasing )
pen.setWidthF(1.25)
painter.setPen(pen)
painter.drawPath(self.path())
# redraw the polys to force-fill them
for poly in self._polygons:
if ( not poly.isClosed() ):
continue
painter.setBrush(pen.color())
painter.drawPolygon(poly)
# restore the render hints
painter.setRenderHints(hint)
def paint(self, painter):
pen = QPen(Qt.black)
pen.setWidthF(2.5)
painter.setPen(pen)
line = QLineF(self.startPoint, self.pos)
painter.drawLine(line)
if self.pos != self.startPoint:
#draw arrowhead
a = line.angle()
l1 = QLineF.fromPolar(25, a - 155)
l1.translate(self.pos)
l2 = QLineF.fromPolar(25, a + 155)
l2.translate(self.pos)
painter.drawLine(l1)
painter.drawLine(l2)
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 __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 __init__(self, parent=None):
ChartView.__init__(self, parent)
self.dataSource = None
pen = QPen()
pen.setColor(QColor(20, 158, 11))
pen.setWidthF(self.LINE_WIDTH)
self.linePen = pen
gradient = QLinearGradient(0, 0, 0, 1)
gradient.setCoordinateMode(QLinearGradient.ObjectBoundingMode)
gradient.setColorAt(0, QColor(93, 188, 86)) # dark green
gradient.setColorAt(1, QColor(164, 216, 158)) # light green
self.graphBrush = QBrush(gradient)
gradient = QLinearGradient(0, 0, 0, 1)
gradient.setCoordinateMode(QLinearGradient.ObjectBoundingMode)
gradient.setColorAt(0, Qt.darkGray)
gradient.setColorAt(1, Qt.lightGray)
self.graphFutureBrush = QBrush(gradient)
def __init__(self):
super(QFramesInTracksScene, self).__init__()
self._coords = CoordTransform()
self._track_items = {}
self._frame_items = {}
pen = QPen()
pen.setWidthF(1.25)
pen.setColor(Qt.black)
# pen.setCapStyle(Qt.RoundCap)
pen.setJoinStyle(Qt.RoundJoin)
brush = QBrush()
brush.setColor(Qt.blue)
brush.setStyle(Qt.SolidPattern)
self._frame_pen_brush = pen, brush
pen = QPen(pen)
pen.setWidthF(3.5)
pen.setJoinStyle(Qt.RoundJoin)
pen.setColor(Qt.blue)
brush = QBrush(brush)
brush.setColor(Qt.gray)
self._track_pen_brush = pen, brush
def paint(self, painter, style, widget):
painter.setRenderHint(QPainter.Antialiasing, True)
rect = self.boundingRect()
pen = QPen(self.borderColor)
pen.setWidthF(10)
pen.setJoinStyle(Qt.RoundJoin)
path = QPainterPath()
if (self.parentItem().property('direction') == 1):
path.moveTo(5, rect.height() - 5)
path.lineTo(rect.width() / 2, 5)
path.lineTo(rect.width() - 5, rect.height() - 5)
path.lineTo(5, rect.height() - 5)
else:
path.moveTo(5, 5)
path.lineTo(rect.width() / 2, rect.height() - 5)
path.lineTo(rect.width() - 5, 5)
path.lineTo(5, 5)
painter.fillPath(path, self.color)
painter.strokePath(path, pen)
def __call__(self, painter, imageid, cid, pts, image_scale):
center = gravityCenter(pts)
(kmaj, kmin, theta, _) = self.result.cells[imageid][cid]
scaling = image_scale * self.scaling
if abs(1 - kmin / kmaj) < self.min_anisotropy:
return # Don't draw the ellipsis
elif self.scale_axis:
kmaj *= scaling
kmin *= scaling
else:
kmaj = scaling
kmin = -scaling / 2
painter.save()
pen = QPen()
pen.setWidthF(self.thickness * image_scale)
pen.setColor(self.color)
pen_positive = QPen(pen)
pen_positive.setColor(self.positive_color)
pen_negative = QPen(pen)
pen_negative.setColor(self.negative_color)
painter.setPen(pen)
painter.setBrush(Qt.NoBrush)
painter.translate(center)
painter.rotate(theta * 180 / pi)
if self.major_axis:
if kmaj >= 0:
painter.setPen(pen_positive)
else:
painter.setPen(pen_negative)
painter.drawLine(QPointF(-kmaj, 0), QPointF(kmaj, 0))
if self.minor_axis:
if kmin >= 0:
painter.setPen(pen_positive)
else:
painter.setPen(pen_negative)
painter.drawLine(QPointF(0, -kmin), QPointF(0, kmin))
painter.setPen(pen)
painter.drawEllipse(QPointF(0, 0), kmaj, kmin)
painter.restore()
def paint(self, painter, style, widget):
painter.setRenderHint(QPainter.Antialiasing, True)
rect = self.boundingRect()
pen = QPen(self.borderColor)
pen.setWidthF(10)
pen.setJoinStyle(Qt.RoundJoin)
path = QPainterPath()
if(self.parentItem().property('direction') == 1):
path.moveTo(5, rect.height() - 5)
path.lineTo(rect.width() / 2, 5)
path.lineTo(rect.width() - 5, rect.height() - 5)
path.lineTo(5, rect.height() - 5)
else:
path.moveTo(5, 5)
path.lineTo(rect.width() / 2, rect.height() - 5)
path.lineTo(rect.width() - 5, 5)
path.lineTo(5, 5)
painter.fillPath(path, self.color)
painter.strokePath(path, pen)
def __call__(self, painter, imageid, cid, pts, image_scale):
center = gravityCenter(pts)
(kmaj, kmin, theta, _) = self.result.cells[imageid][cid]
scaling = image_scale*self.scaling
if abs(1-kmin/kmaj) < self.min_anisotropy:
return # Don't draw the ellipsis
elif self.scale_axis:
kmaj *= scaling
kmin *= scaling
else:
kmaj = scaling
kmin = -scaling/2
painter.save()
pen = QPen()
pen.setWidthF(self.thickness*image_scale)
pen.setColor(self.color)
pen_positive = QPen(pen)
pen_positive.setColor(self.positive_color)
pen_negative = QPen(pen)
pen_negative.setColor(self.negative_color)
painter.setPen(pen)
painter.setBrush(Qt.NoBrush)
painter.translate(center)
painter.rotate(theta*180/pi)
if self.major_axis:
if kmaj >= 0:
painter.setPen(pen_positive)
else:
painter.setPen(pen_negative)
painter.drawLine(QPointF(-kmaj, 0), QPointF(kmaj, 0))
if self.minor_axis:
if kmin >= 0:
painter.setPen(pen_positive)
else:
painter.setPen(pen_negative)
painter.drawLine(QPointF(0, -kmin), QPointF(0, kmin))
painter.setPen(pen)
painter.drawEllipse(QPointF(0, 0), kmaj, kmin)
painter.restore()
def adjustMask(self):
"""
Updates the alpha mask for this popup widget.
"""
if self.currentMode() == XPopupWidget.Mode.Dialog:
self.clearMask()
return
path = self.borderPath()
bitmap = QBitmap(self.width(), self.height())
bitmap.fill(QColor('white'))
painter = QPainter()
painter.begin(bitmap)
painter.setRenderHint(QPainter.Antialiasing)
pen = QPen(QColor('black'))
pen.setWidthF(0.75)
painter.setPen(pen)
painter.setBrush(QColor('black'))
painter.drawPath(path)
painter.end()
self.setMask(bitmap)
def adjustMask(self):
"""
Updates the alpha mask for this popup widget.
"""
if self.currentMode() == XPopupWidget.Mode.Dialog:
self.clearMask()
return
path = self.borderPath()
bitmap = QBitmap(self.width(), self.height())
bitmap.fill(QColor('white'))
painter = QPainter()
painter.begin(bitmap)
painter.setRenderHint(QPainter.Antialiasing)
pen = QPen(QColor('black'))
pen.setWidthF(0.75)
painter.setPen(pen)
painter.setBrush(QColor('black'))
painter.drawPath(path)
painter.end()
self.setMask(bitmap)
def __call__(self, painter, imageid):
if imageid == len(self.images):
return
head_size = self.head_size
color = self.color
line_width = self.line_width
max_velocity = self.max_velocity
img1 = self.image_list[imageid]
img2 = self.image_list[imageid+1]
d1 = self.data[img1]
d2 = self.data[img2]
dt = d2.time - d1.time
pen = QPen(color)
pen.setWidthF(line_width)
brush = QBrush(color)
painter.setPen(pen)
painter.setBrush(brush)
for pt_id in d1:
if pt_id in d2:
p = d1[pt_id] if self.forward else d2[pt_id]
v = (d2[pt_id] - d1[pt_id]) / dt * self.factor
vl = length(v)
if abs(vl / max_velocity) > 1e-3:
self.drawArrow(painter, p, v, head_size)
def __call__(self, painter, imageid):
if imageid == len(self.images):
return
head_size = self.head_size
color = self.color
line_width = self.line_width
max_velocity = self.max_velocity
img1 = self.image_list[imageid]
img2 = self.image_list[imageid + 1]
d1 = self.data[img1]
d2 = self.data[img2]
dt = d2.time - d1.time
pen = QPen(color)
pen.setWidthF(line_width)
brush = QBrush(color)
painter.setPen(pen)
painter.setBrush(brush)
for pt_id in d1:
if pt_id in d2:
p = d1[pt_id] if self.forward else d2[pt_id]
v = (d2[pt_id] - d1[pt_id]) / dt * self.factor
vl = length(v)
if abs(vl / max_velocity) > 1e-3:
self.drawArrow(painter, p, v, head_size)
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 paintEvent(self, event):
spacing = 15
contentRect = self.rect().adjusted(spacing, spacing, -spacing,
-spacing)
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
pen = QPen()
pen.setCapStyle(Qt.RoundCap)
pen.setWidthF(1.0 + self.width() / 15.0)
pen.setColor(Qt.white)
pen.setJoinStyle(Qt.RoundJoin)
painter.setPen(pen)
painter.drawArc(contentRect, (-45) * 16, (2 * 135) * 16)
valueInPercent = (self.m_value - self.m_minimum) / (self.m_maximum -
self.m_minimum)
math_pi = 3.14159265358979323846
degree = (135 + 90) - valueInPercent * 2.0 * 135.0
degree = degree * math_pi / 180.0
radius = (contentRect.width() - spacing * 0.5) * 0.5
vec = QPoint(radius * math.cos(degree), radius * -math.sin(degree))
painter.drawLine(contentRect.center(), contentRect.center() + vec)
def addLines(self, show_max, axislimits=None):
self.backupRows = []
self.backupRows.append([])
#print str(axislimits)
parentcontainer = []
linecounter = self.axes_number - 1
plotnb = -1
parentDict = {}
row = self.ui.tableWidget.rowCount()
self.ui.tableWidget.insertRow(row)
hidden = []
for line in self.image['lines']:
plotnb = plotnb + 1
linecounter = linecounter + 1
qtcolor = self.QTColorGet(line['color'])
currentLine = lineItem(plotnb * defaults.axiswidth,
self.image['height'] - line['y1'],
(plotnb + 1) * defaults.axiswidth,
self.image['height'] - line['y2']
)
# Setting the pen
pen = QPen()
pen.setColor(qtcolor)
pen.setWidthF(line['penwidth'])
currentLine.setPen(pen)
currentLine.setToolTip("%s -> %s" % (line['x1_strval'],
line['x2_strval'])
)
currentLine.setCursor(QtCore.Qt.OpenHandCursor)
currentLine.setLayer(line['layer'])
self.scene.createLayer(line['layer'], linecounter, currentLine)
self.scene.addItem(currentLine)
self.ui.tableWidget.setItem(row, plotnb,
QTableWidgetItem(line['x1_strval'])
)
self.backupRows[row].append(line['x1_strval'])
currentLine.setOneRow(self.ui.tableWidget.item(row, plotnb))
parentcontainer.append(linecounter)
if line['hidden']:
hidden.append(currentLine)
if plotnb == self.axes_number - 2:
self.ui.tableWidget.setItem(row, plotnb + 1,
QTableWidgetItem(line['x2_strval'])
)
currentLine.setTwoRow(
self.ui.tableWidget.item(row, plotnb),
self.ui.tableWidget.item(row, plotnb + 1)
)
self.backupRows[row].append(line['x2_strval'])
row = self.ui.tableWidget.rowCount()
self.backupRows.append([])
self.ui.tableWidget.insertRow(row)
for each in parentcontainer:
parentDict[each] = parentcontainer
parentcontainer = []
plotnb = -1
# Set the headers of tableWidget
count = 0
for each in self.comboList:
self.ui.tableWidget.horizontalHeaderItem(count).setText(
each.currentText().__str__()
)
count = count + 1
#remove a unused row
self.ui.tableWidget.removeRow(row)
# Sets a backup control value, to slider hide/show correctly and
# efficiently
self.hideValue = linecounter - \
(self.axes_number - 1) / (self.axes_number - 1)
#Gets items of scene only 1 time
self.graph_item = self.scene.items()
self.scene.getItems(self.graph_item, self.axes_number)
self.graph_size = len(self.graph_item)
for each in parentDict:
count = 0
parentList = []
for i in parentDict[each]:
variant = QtCore.QVariant(i)
self.graph_item[each].setData(count, variant)
parentList.append(self.graph_item[i])
count = count + 1
if isinstance(self.graph_item[each], lineItem):
self.graph_item[each].setParents(parentList,
self.graph_item, each)
del parentList
self.doSelectable()
self.scene.hideList(hidden)
class lineItem(QGraphicsLineItem):
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 setParents(self, parentList, allItems, id):
self.parentList = [item for item in parentList
if not item == self]
self.parentSelected = False
self.id = id
self.allItems = allItems
def getLayer(self):
return self.layer
def setLayer(self, name):
self.layer = name
def setOneRow(self, row1):
self.tableItem1 = row1
self.haveTwoItems = False
def setTwoRow(self, row1, row2):
self.tableItem1 = row1
self.tableItem2 = row2
self.haveTwoItems = True
def testprint(self):
print "I'm printable!"
def dragEnterEvent(self, event):
print event
def setPressed(self, key):
if(key == QtCore.Qt.Key_Control):
self.ctrlPressed = True
def setUnPressed(self, key):
if(key == QtCore.Qt.Key_Control):
self.ctrlPressed = False
def myIsSelected(self):
return self.selec
def isPressed(self):
return self.ctrlPressed
def setBackupPen(self, pen):
self.backupPen = pen
def getBackupPen(self):
return self.backupPen
def decreaseWidth(self):
pen = self.pen()
if(self.myIsSelected()):
pen.setWidthF(pen.widthF() * 1 / 1.05)
self.selectWidth = pen.widthF()
self.backupPen.setWidthF(self.backupPen.widthF() * 1 / 1.05)
else:
pen.setWidthF(pen.widthF() * 1 / 1.05)
self.selectWidth = self.selectWidth * 1 / 1.05
self.backupPen = pen
self.setPen(pen)
def increaseWidth(self):
pen = self.pen()
if(self.myIsSelected()):
pen.setWidthF(pen.widthF() * 1.05)
self.selectWidth = pen.widthF()
self.backupPen.setWidthF(self.backupPen.widthF() * 1.05)
else:
pen.setWidthF(pen.widthF() * 1.05)
self.selectWidth = self.selectWidth * 1.05
self.backupPen = pen
self.setPen(pen)
def setWidth(self, width):
self.backupPen.setWidthF(width)
self.setPen(self.backupPen)
def selectParents(self, selection):
for each in self.parentList:
#each.setParentSelected(selection)
each.setSelected(selection)
def setParentSelected(self, value):
self.parentSelected = value
def mySetSelected(self, selection, first):
if (selection):
self.setPen(self.pen)
self.setSelected(selection)
if (first):
self.selectParents(True)
else:
self.setPen(self.backupPen)
self.setSelected(selection)
if (first):
self.selectParents(False)
self.selec = selection
def deselectRow(self):
if(self.haveTwoItems):
self.tableItem2.setSelected(False)
self.tableItem1.setSelected(False)
def selectRow(self):
if(self.haveTwoItems):
self.tableItem2.setSelected(self.selec)
self.tableItem1.setSelected(self.selec)
def getId(self):
return self.id
def hoverEnterEvent(self, event):
print event
def itemChange(self, event, value):
if event == QGraphicsItem.ItemSelectedHasChanged:
if self.isSelected():
self.setPen(self.select_pen)
self.selec = True
else:
self.setPen(self.backupPen)
self.selec = False
return value
def drawImage(self, imageid):
cache = image_cache.cache
cellColoring = self.cellColoring
wallColoring = self.wallColoring
pointColoring = self.pointColoring
ellipsisDraw = self.ellipsisDraw
overSampling = self.overSampling
extraDrawing = self.extraDrawing
bgColor = self.bgColor.rgb()
result = self.result
if self.result_type == "Data":
data = result
img_name = result.images_name[imageid]
else:
data = result.data
img_name = result.images[imageid]
#scale = data.images_scale[img_name]
min_scale = data.minScale()
img = cache.image(data.image_path(img_name))
img_data = data[img_name]
size = self._crop.size()
pix = QImage(size*overSampling, QImage.Format_ARGB32)
pix.fill(bgColor)
painter = QPainter()
if not painter.begin(pix):
self.abort("Cannot create painter on QImage")
return None, None, None
painter.setRenderHints(QPainter.SmoothPixmapTransform, True)
painter.setRenderHints(QPainter.Antialiasing, True)
if overSampling > 1:
painter.scale(overSampling, overSampling)
painter.translate(-self._crop.topLeft())
painter.save()
painter.translate(self.translate)
log_debug("Translating: %gx%g" % (self.translate.x(), self.translate.y()) )
painter.scale(1/min_scale, 1/min_scale)
painter.save()
matrix = img_data.matrix()
painter.setWorldTransform(matrix, True)
painter.drawImage(QPoint(0,0), img)
painter.restore()
#pt_matrix = QTransform()
#pt_matrix.scale(1/min_scale, 1/min_scale)
#painter.setTransform(pt_matrix, True)
cellColoring.startImage(painter, imageid)
wallColoring.startImage(painter, imageid)
for ed in extraDrawing:
ed.startImage(painter, imageid)
if self.result_type == "Growth":
cells = result.cells[imageid]
walls = result.walls[imageid]
else:
cells = img_data.cells
walls = set()
for cid in img_data.cells:
pts = [ pt for pt in data.cells[cid] if pt in img_data ]
if len(pts) > 1:
for i in range(len(pts)):
walls.add(data.wallId(pts[i-1], pts[i]))
# Now, draw the cells and the ellipsis
for cid in cells:
painter.setPen(Qt.NoPen)
color = cellColoring(imageid, cid)
painter.setBrush(color)
pts = data.cellAtTime(cid, img_data.index)
if pts:
pts.append(pts[0])
ppts = []
for p1,p2 in zip(pts[:-1], pts[1:]):
ppts.append(img_data[p1])
ppts.extend(img_data.walls[p1,p2])
ppts.append(ppts[0])
poly = QPolygonF(ppts)
painter.drawPolygon(poly)
# And draw the walls
wallThickness = self.wallThickness*min_scale
for wid in walls:
color = wallColoring(imageid, wid)
if color.alpha() > 0:
pen = QPen(color)
pen.setWidthF(wallThickness)
painter.setPen(pen)
pts = [img_data[wid[0]]] + img_data.walls[wid[0], wid[1]] + [img_data[wid[1]]]
#painter.drawLine(img_data[wid[0]], img_data[wid[1]])
painter.drawPolyline(*pts)
# Then, draw the points
pointSize = self.pointSize*min_scale
pointLineColor = self.pointLineColor
pointLineThickness = self.pointLineThickness*min_scale
log_debug("pointSize = %g" % pointSize)
for pid in img_data:
color = pointColoring(imageid, pid)
if color.alpha() > 0:
pen = QPen(pointLineColor)
pen.setWidthF(pointLineThickness)
brush = QBrush(color)
painter.setPen(pen)
painter.setBrush(brush)
pos = img_data[pid]
rect = QRectF(pos.x()-pointSize, pos.y()-pointSize, 2*pointSize, 2*pointSize)
painter.drawEllipse(rect)
if ellipsisDraw.plot:
for cid in cells:
pts = data.cellAtTime(cid, img_data.index)
if pts:
pts.append(pts[0])
ppts = []
for p1,p2 in zip(pts[:-1], pts[1:]):
ppts.append(img_data[p1])
ppts.extend(img_data.walls[p1,p2])
ppts.append(ppts[0])
#poly = QPolygonF(ppts)
#painter.drawPolygon(poly)
ellipsisDraw(painter, imageid, cid, ppts, min_scale)
# At last, draw the extra data
for ed in extraDrawing:
ed(painter, imageid)
tr = painter.worldTransform()
painter.restore()
pic_w = wallColoring.finalizeImage(painter, imageid, tr, self.crop)
pic_c = cellColoring.finalizeImage(painter, imageid, tr, self.crop)
for ed in extraDrawing:
ed.finalizeImage(painter, imageid, tr, self.crop)
painter.end()
return pix, pic_w, pic_c
def drawImage(self, imageid):
cache = image_cache.cache
cellColoring = self.cellColoring
wallColoring = self.wallColoring
pointColoring = self.pointColoring
ellipsisDraw = self.ellipsisDraw
overSampling = self.overSampling
extraDrawing = self.extraDrawing
bgColor = self.bgColor.rgb()
result = self.result
if self.result_type == "Data":
data = result
img_name = result.images_name[imageid]
else:
data = result.data
img_name = result.images[imageid]
#scale = data.images_scale[img_name]
min_scale = data.minScale()
img = cache.image(data.image_path(img_name))
img_data = data[img_name]
size = self._crop.size()
pix = QImage(size * overSampling, QImage.Format_ARGB32)
pix.fill(bgColor)
painter = QPainter()
if not painter.begin(pix):
self.abort("Cannot create painter on QImage")
return None, None, None
painter.setRenderHints(QPainter.SmoothPixmapTransform, True)
painter.setRenderHints(QPainter.Antialiasing, True)
if overSampling > 1:
painter.scale(overSampling, overSampling)
painter.translate(-self._crop.topLeft())
painter.save()
painter.translate(self.translate)
log_debug("Translating: %gx%g" %
(self.translate.x(), self.translate.y()))
painter.scale(1 / min_scale, 1 / min_scale)
painter.save()
matrix = img_data.matrix()
painter.setWorldTransform(matrix, True)
painter.drawImage(QPoint(0, 0), img)
painter.restore()
#pt_matrix = QTransform()
#pt_matrix.scale(1/min_scale, 1/min_scale)
#painter.setTransform(pt_matrix, True)
cellColoring.startImage(painter, imageid)
wallColoring.startImage(painter, imageid)
for ed in extraDrawing:
ed.startImage(painter, imageid)
if self.result_type == "Growth":
cells = result.cells[imageid]
walls = result.walls[imageid]
else:
cells = img_data.cells
walls = set()
for cid in img_data.cells:
pts = [pt for pt in data.cells[cid] if pt in img_data]
if len(pts) > 1:
for i in range(len(pts)):
walls.add(data.wallId(pts[i - 1], pts[i]))
# Now, draw the cells and the ellipsis
for cid in cells:
painter.setPen(Qt.NoPen)
color = cellColoring(imageid, cid)
painter.setBrush(color)
pts = data.cellAtTime(cid, img_data.index)
if pts:
pts.append(pts[0])
ppts = []
for p1, p2 in zip(pts[:-1], pts[1:]):
ppts.append(img_data[p1])
ppts.extend(img_data.walls[p1, p2])
ppts.append(ppts[0])
poly = QPolygonF(ppts)
painter.drawPolygon(poly)
# And draw the walls
wallThickness = self.wallThickness * min_scale
for wid in walls:
color = wallColoring(imageid, wid)
if color.alpha() > 0:
pen = QPen(color)
pen.setWidthF(wallThickness)
painter.setPen(pen)
pts = [img_data[wid[0]]
] + img_data.walls[wid[0], wid[1]] + [img_data[wid[1]]]
#painter.drawLine(img_data[wid[0]], img_data[wid[1]])
painter.drawPolyline(*pts)
# Then, draw the points
pointSize = self.pointSize * min_scale
pointLineColor = self.pointLineColor
pointLineThickness = self.pointLineThickness * min_scale
log_debug("pointSize = %g" % pointSize)
for pid in img_data:
color = pointColoring(imageid, pid)
if color.alpha() > 0:
pen = QPen(pointLineColor)
pen.setWidthF(pointLineThickness)
brush = QBrush(color)
painter.setPen(pen)
painter.setBrush(brush)
pos = img_data[pid]
rect = QRectF(pos.x() - pointSize,
pos.y() - pointSize, 2 * pointSize,
2 * pointSize)
painter.drawEllipse(rect)
if ellipsisDraw.plot:
for cid in cells:
pts = data.cellAtTime(cid, img_data.index)
if pts:
pts.append(pts[0])
ppts = []
for p1, p2 in zip(pts[:-1], pts[1:]):
ppts.append(img_data[p1])
ppts.extend(img_data.walls[p1, p2])
ppts.append(ppts[0])
#poly = QPolygonF(ppts)
#painter.drawPolygon(poly)
ellipsisDraw(painter, imageid, cid, ppts, min_scale)
# At last, draw the extra data
for ed in extraDrawing:
ed(painter, imageid)
tr = painter.worldTransform()
painter.restore()
pic_w = wallColoring.finalizeImage(painter, imageid, tr, self.crop)
pic_c = cellColoring.finalizeImage(painter, imageid, tr, self.crop)
for ed in extraDrawing:
ed.finalizeImage(painter, imageid, tr, self.crop)
painter.end()
return pix, pic_w, pic_c
class PatternLegendItem(QGraphicsSvgItem):
Type = 70000 + 2
def __init__(self,
unitDim,
width,
height,
defaultSymbol,
itemID=0,
defaultColor=QColor(Qt.white),
zValue=1,
parent=None):
super(PatternLegendItem, self).__init__(parent)
# NOTE: need this distinction for cache mode based on
# the Qt version otherwise rendering is broken
if NO_ITEM_CACHING:
self.setCacheMode(QGraphicsItem.NoCache)
else:
self.setCacheMode(QGraphicsItem.DeviceCoordinateCache)
self.itemID = itemID
self.setZValue(zValue)
self.setFlag(QGraphicsItem.ItemIsMovable, True)
self.origin = QPointF(0.0, 0.0)
self.unitDim = unitDim
self.width = width
self.height = height
self.size = QSizeF(self.unitDim.width() * width,
self.unitDim.height() * height)
self.color = defaultColor
self.symbol = None
self._set_symbol(defaultSymbol)
self._penSize = 1.0
self._pen = QPen()
self._pen.setWidthF(self._penSize)
self._pen.setJoinStyle(Qt.MiterJoin)
self._pen.setColor(Qt.black)
self.setAcceptsHoverEvents(True)
self._outline = None
def hoverEnterEvent(self, event):
""" Stuff related to hover enter events.
For now we just show a rectangular outline.
"""
if not self._outline:
self._outline = QGraphicsRectItem(\
self.boundingRect().adjusted(-1,-1,1,1), self)
highlightColor = QColor(Qt.blue)
highlightColor.setAlpha(30)
self._outline.setBrush(highlightColor)
highlightPen = QPen(Qt.blue)
highlightPen.setWidth(2)
self._outline.setPen(highlightPen)
else:
self._outline.show()
def hoverLeaveEvent(self, event):
""" Stuff related to hover leave events.
For now we just show a rectangular outline.
"""
self._outline.hide()
def mousePressEvent(self, event):
""" We reimplement this function to store the position of
the item when a user issues a mouse press.
"""
self._position = self.pos()
if (event.modifiers() & Qt.ControlModifier):
QApplication.setOverrideCursor(QCursor(Qt.SizeAllCursor))
else:
event.ignore()
return QGraphicsSvgItem.mousePressEvent(self, event)
def mouseReleaseEvent(self, event):
""" We reimplement this function to check if its position
has changed since the last mouse click. If yes we
let the canvas know so it can store the action as
a Redo/Undo event.
"""
QApplication.restoreOverrideCursor()
# this is needed for redo/undo
if self._position != self.pos():
self.scene().canvas_item_position_changed(self, self._position,
self.pos())
return QGraphicsSvgItem.mouseReleaseEvent(self, event)
def change_geometry(self, newDim):
""" This slot changes the unit dimensions of the item. """
self.unitDim = newDim
self.size = QSizeF(self.unitDim.width() * self.width,
self.unitDim.height() * self.height)
@property
def name(self):
""" Return the name of the knitting symbol we contain. """
return self.symbol["name"]
def _set_symbol(self, newSymbol):
""" Adds a new svg image of a knitting symbol to the scene. """
self.symbol = newSymbol
svgPath = newSymbol["svgPath"]
if not self.renderer().load(svgPath):
errorMessage = ("PatternLegendItem._set_symbol: failed to load "
"symbol %s" % svgPath)
logger.error(errorMessage)
return
# apply color if present
if "backgroundColor" in newSymbol:
self.color = QColor(newSymbol["backgroundColor"])
def boundingRect(self):
""" Return the bounding rectangle of the item. """
halfPen = self._penSize * 0.5
return QRectF(self.origin, self.size).adjusted(halfPen, halfPen,
halfPen, halfPen)
def paint(self, painter, option, widget):
""" Paint ourselves. """
painter.setPen(self._pen)
brush = QBrush(self.color)
painter.setBrush(brush)
halfPen = self._penSize * 0.5
painter.drawRect(\
QRectF(self.origin, self.size).adjusted(halfPen, halfPen,
halfPen, halfPen))
self.renderer().render(painter, QRectF(self.origin, self.size))
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()
def paintEvent( self, event ): from PyQt4.QtCore import Qt from PyQt4.QtGui import QPainter, QPainterPath, QPalette, QPixmap, QPen painter = QPainter() painter.begin( self ) painter.setRenderHint( painter.Antialiasing ) 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 + 22, y + 3, w, 16, Qt.AlignLeft | Qt.AlignTop, self.title() ) # draw the triangle pixmap = self._pixmap if ( not self.isCollapsed() ): from PyQt4.QtGui import QMatrix pixmap = pixmap.transformed( QMatrix().rotate(90) ) painter.drawPixmap( x + 7, y + 4, pixmap ) # 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 boxed style elif ( self._rolloutStyle == 1 ): from PyQt4.QtCore import QRect 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()
class PatternGridItem(QGraphicsSvgItem):
Type = 70000 + 1
def __init__(self,
unitDim,
col,
row,
width,
height,
defaultSymbol,
defaultColor=QColor(Qt.white),
parent=None):
super(PatternGridItem, self).__init__(parent)
# NOTE: need this distinction for cache mode based on
# the Qt version otherwise rendering is broken
if NO_ITEM_CACHING:
self.setCacheMode(QGraphicsItem.NoCache)
else:
self.setCacheMode(QGraphicsItem.DeviceCoordinateCache)
self.origin = QPointF(0.0, 0.0)
self.unitDim = unitDim
self.row = row
self.column = col
self.width = width
self.height = height
self.size = QSizeF(self.unitDim.width() * width,
self.unitDim.height() * height)
self._penSize = 1.0
self._pen = QPen()
self._pen.setWidthF(self._penSize)
self._pen.setJoinStyle(Qt.MiterJoin)
self._pen.setColor(Qt.black)
self.isHidden = False
self._selected = False
self.color = defaultColor
self._backBrush = QBrush(self.color)
self._highlightBrush = QBrush(QColor(Qt.lightGray), Qt.SolidPattern)
self.symbol = None
self._set_symbol(defaultSymbol)
def mousePressEvent(self, event):
""" Handle user press events on the item.
NOTE: We ignore all events with shift or control clicked.
"""
if (event.modifiers() & Qt.ControlModifier) or \
(event.modifiers() & Qt.ShiftModifier):
event.ignore()
return
mode = self.scene().selectionMode
if mode == HIDE_MODE:
self.emit(SIGNAL("cell_hidden"), [self])
elif mode == UNHIDE_MODE:
self.emit(SIGNAL("cell_visible"), [self])
elif not self.isHidden:
if not self._selected:
self.emit(SIGNAL("cell_selected"), self)
else:
self.emit(SIGNAL("cell_unselected"), self)
def hide_cell(self):
""" Hides the cell by setting the opacity to a low value.
NOTE: This is different from Qt's hide function since it
is not meant to disable the item completely.
"""
self.isHidden = True
self.setOpacity(HIDE_OPACITY)
def unhide_cell(self):
""" Unhides the cell by setting the opacity back to 1.0.
NOTE: This is the reverse of hide_cell().
"""
self.isHidden = False
self.setOpacity(1.0)
def change_geometry(self, newDim):
""" This slot changes the unit dimensions of the item. """
self.unitDim = newDim
self.size = QSizeF(self.unitDim.width() * self.width,
self.unitDim.height() * self.height)
def change_color(self, newColor):
""" This slot changes the color of the items. """
self.color = newColor
self._backBrush = QBrush(self.color)
@property
def name(self):
""" Return the name of the symbol we contain """
return self.symbol["name"]
def _unselect(self):
""" Unselects a given selected cell. """
self._selected = False
self._backBrush = QBrush(self.color)
self.update()
def _select(self):
""" Selects a given unselected cell. """
self._selected = True
self._backBrush = self._highlightBrush
self.update()
def _set_symbol(self, newSymbol):
""" Adds a new svg image of a knitting symbol to the scene. """
self.symbol = newSymbol
svgPath = newSymbol["svgPath"]
if not self.renderer().load(svgPath):
errorMessage = ("PatternGridItem._set_symbol: failed to load "
"symbol %s" % svgPath)
logger.error(errorMessage)
return
# apply color if present
if "backgroundColor" in newSymbol:
self._backColor = QColor(newSymbol["backgroundColor"])
self._backBrush = QBrush(QColor(newSymbol["backgroundColor"]))
self.update()
def boundingRect(self):
""" Return the bounding rectangle of the item. """
halfPen = self._penSize * 0.5
return QRectF(self.origin, self.size).adjusted(halfPen, halfPen,
halfPen, halfPen)
def paint(self, painter, option, widget):
""" Paint ourselves. """
painter.setPen(self._pen)
painter.setBrush(self._backBrush)
halfPen = self._penSize * 0.5
scaledRect = \
QRectF(self.origin, self.size).adjusted(halfPen, halfPen,
halfPen, halfPen)
painter.drawRect(scaledRect)
self.renderer().render(painter, scaledRect)
class RepeatLegendItem(QGraphicsRectItem):
Type = 70000 + 7
def __init__(self, color, parent=None):
super(RepeatLegendItem, self).__init__(parent)
# NOTE: need this distinction for cache mode based on
# the Qt version otherwise rendering is broken
if NO_ITEM_CACHING:
self.setCacheMode(QGraphicsItem.NoCache)
else:
self.setCacheMode(QGraphicsItem.DeviceCoordinateCache)
self.setZValue(1)
self.setFlag(QGraphicsItem.ItemIsMovable)
self._position = self.pos()
self.penColor = color
self.itemHeight = 20
self.itemWidth = 40
self._pen = QPen()
self._pen.setWidthF(3.0)
self._pen.setColor(self.penColor)
self.setPen(self._pen)
self.setRect(0, 0, self.itemWidth, self.itemHeight)
self.setAcceptsHoverEvents(True)
self._outline = None
@property
def height(self):
return self.itemHeight
@property
def width(self):
return self.itemWidth
@property
def color(self):
return self.penColor
@color.setter
def color(self, newColor):
self.penColor = newColor
self._pen.setColor(self.penColor)
self.setPen(self._pen)
def hoverEnterEvent(self, event):
""" Stuff related to hover enter events.
For now we just show a rectangular outline.
"""
if not self._outline:
self._outline = QGraphicsRectItem(\
self.boundingRect().adjusted(-1,-1,1,1), self)
highlightColor = QColor(Qt.blue)
highlightColor.setAlpha(30)
self._outline.setBrush(highlightColor)
highlightPen = QPen(Qt.blue)
highlightPen.setWidth(2)
self._outline.setPen(highlightPen)
else:
self._outline.show()
def hoverLeaveEvent(self, event):
""" Stuff related to hover leave events.
For now we just show a rectangular outline.
"""
self._outline.hide()
def mousePressEvent(self, event):
""" We reimplement this function to store the position of
the item when a user issues a mouse press.
"""
self._position = self.pos()
if (event.modifiers() & Qt.ControlModifier):
QApplication.setOverrideCursor(QCursor(Qt.SizeAllCursor))
else:
event.ignore()
return QGraphicsRectItem.mousePressEvent(self, event)
def mouseReleaseEvent(self, event):
""" We reimplement this function to check if its position
has changed since the last mouse click. If yes we
let the canvas know so it can store the action as
a Redo/Undo event.
"""
QApplication.restoreOverrideCursor()
# this is needed for undo/redo
if self._position != self.pos():
self.scene().canvas_item_position_changed(self, self._position,
self.pos())
return QGraphicsRectItem.mouseReleaseEvent(self, event)
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()
def getPenFromCmnd(self, peninfo):
'''
Returns a QPen based on the information in the dictionary
peninfo. A ValueError is raised if the value for the
"style", "capstyle", or "joinstyle" key, if given, is not
recognized.
Recognized keys in the outline dictionary are:
"color": color name or 24-bit RGB integer value
(eg, 0xFF0088)
"alpha": alpha value from 0 (transparent) to 255 (opaque)
"width": pen width in points (1/72 inches); possibly
further scaled by the width scaling factor
"style": pen style name ("solid", "dash", "dot", "dashdot",
"dashdotdot")
"capstyle": pen cap style name ("square", "flat", "round")
"joinstyle": pen join style name ("bevel", "miter", "round")
'''
try:
mycolor = self.getColorFromCmnd(peninfo)
mypen = QPen(mycolor)
except KeyError:
mypen = QPen()
try:
penwidth = float(peninfo["width"])
penwidth *= self.__viewer.widthScalingFactor()
mypen.setWidthF(penwidth)
except KeyError:
pass
try:
mystyle = peninfo["style"]
if mystyle == "solid":
mystyle = Qt.SolidLine
elif mystyle == "dash":
mystyle = Qt.DashLine
elif mystyle == "dot":
mystyle = Qt.DotLine
elif mystyle == "dashdot":
mystyle = Qt.DashDotLine
elif mystyle == "dashdotdot":
mystyle = Qt.DashDotDotLine
else:
raise ValueError( self.__viewer.tr( \
"Unknown pen style %1").arg(str(mystyle)) )
mypen.setStyle(mystyle)
except KeyError:
pass
try:
mystyle = peninfo["capstyle"]
if mystyle == "square":
mystyle = Qt.SquareCap
elif mystyle == "flat":
mystyle = Qt.FlatCap
elif mystyle == "round":
mystyle = Qt.RoundCap
else:
raise ValueError( self.__viewer.tr( \
"Unknown pen cap style %1").arg(str(mystyle)) )
mypen.setCapStyle(mystyle)
except KeyError:
pass
try:
mystyle = peninfo["joinstyle"]
if mystyle == "bevel":
mystyle = Qt.BevelJoin
elif mystyle == "miter":
mystyle = Qt.MiterJoin
elif mystyle == "round":
mystyle = Qt.RoundJoin
else:
raise ValueError( self.__viewer.tr( \
"Unknown pen join style %1").arg(str(mystyle)) )
mypen.setJoinStyle(mystyle)
except KeyError:
pass
return mypen
class PatternGridItem(QGraphicsSvgItem):
Type = 70000 + 1
def __init__(self, unitDim, col, row, width, height,
defaultSymbol, defaultColor = QColor(Qt.white),
parent = None):
super(PatternGridItem, self).__init__(parent)
# NOTE: need this distinction for cache mode based on
# the Qt version otherwise rendering is broken
if NO_ITEM_CACHING:
self.setCacheMode(QGraphicsItem.NoCache)
else:
self.setCacheMode(QGraphicsItem.DeviceCoordinateCache)
self.origin = QPointF(0.0, 0.0)
self.unitDim = unitDim
self.row = row
self.column = col
self.width = width
self.height = height
self.size = QSizeF(self.unitDim.width() * width,
self.unitDim.height() * height)
self._penSize = 1.0
self._pen = QPen()
self._pen.setWidthF(self._penSize)
self._pen.setJoinStyle(Qt.MiterJoin)
self._pen.setColor(Qt.black)
self.isHidden = False
self._selected = False
self.color = defaultColor
self._backBrush = QBrush(self.color)
self._highlightBrush = QBrush(QColor(Qt.lightGray), Qt.SolidPattern)
self.symbol = None
self._set_symbol(defaultSymbol)
def mousePressEvent(self, event):
""" Handle user press events on the item.
NOTE: We ignore all events with shift or control clicked.
"""
if (event.modifiers() & Qt.ControlModifier) or \
(event.modifiers() & Qt.ShiftModifier):
event.ignore()
return
mode = self.scene().selectionMode
if mode == HIDE_MODE:
self.emit(SIGNAL("cell_hidden"), [self])
elif mode == UNHIDE_MODE:
self.emit(SIGNAL("cell_visible"), [self])
elif not self.isHidden:
if not self._selected:
self.emit(SIGNAL("cell_selected"), self)
else:
self.emit(SIGNAL("cell_unselected"), self)
def hide_cell(self):
""" Hides the cell by setting the opacity to a low value.
NOTE: This is different from Qt's hide function since it
is not meant to disable the item completely.
"""
self.isHidden = True
self.setOpacity(HIDE_OPACITY)
def unhide_cell(self):
""" Unhides the cell by setting the opacity back to 1.0.
NOTE: This is the reverse of hide_cell().
"""
self.isHidden = False
self.setOpacity(1.0)
def change_geometry(self, newDim):
""" This slot changes the unit dimensions of the item. """
self.unitDim = newDim
self.size = QSizeF(self.unitDim.width() * self.width,
self.unitDim.height() * self.height)
def change_color(self, newColor):
""" This slot changes the color of the items. """
self.color = newColor
self._backBrush = QBrush(self.color)
@property
def name(self):
""" Return the name of the symbol we contain """
return self.symbol["name"]
def _unselect(self):
""" Unselects a given selected cell. """
self._selected = False
self._backBrush = QBrush(self.color)
self.update()
def _select(self):
""" Selects a given unselected cell. """
self._selected = True
self._backBrush = self._highlightBrush
self.update()
def _set_symbol(self, newSymbol):
""" Adds a new svg image of a knitting symbol to the scene. """
self.symbol = newSymbol
svgPath = newSymbol["svgPath"]
if not self.renderer().load(svgPath):
errorMessage = ("PatternGridItem._set_symbol: failed to load "
"symbol %s" % svgPath)
logger.error(errorMessage)
return
# apply color if present
if "backgroundColor" in newSymbol:
self._backColor = QColor(newSymbol["backgroundColor"])
self._backBrush = QBrush(QColor(newSymbol["backgroundColor"]))
self.update()
def boundingRect(self):
""" Return the bounding rectangle of the item. """
halfPen = self._penSize * 0.5
return QRectF(self.origin, self.size).adjusted(halfPen, halfPen,
halfPen, halfPen)
def paint(self, painter, option, widget):
""" Paint ourselves. """
painter.setPen(self._pen)
painter.setBrush(self._backBrush)
halfPen = self._penSize * 0.5
scaledRect = \
QRectF(self.origin, self.size).adjusted(halfPen, halfPen,
halfPen, halfPen)
painter.drawRect(scaledRect)
self.renderer().render(painter, scaledRect)
class PatternLegendItem(QGraphicsSvgItem):
Type = 70000 + 2
def __init__(self, unitDim, width, height,
defaultSymbol, defaultColor = QColor(Qt.white),
zValue = 1, parent = None):
super(PatternLegendItem, self).__init__(parent)
# NOTE: need this distinction for cache mode based on
# the Qt version otherwise rendering is broken
if NO_ITEM_CACHING:
self.setCacheMode(QGraphicsItem.NoCache)
else:
self.setCacheMode(QGraphicsItem.DeviceCoordinateCache)
self.setZValue(zValue)
self.setFlag(QGraphicsItem.ItemIsMovable, True)
self.origin = QPointF(0.0, 0.0)
self.unitDim = unitDim
self.width = width
self.height = height
self.size = QSizeF(self.unitDim.width() * width,
self.unitDim.height() * height)
self.color = defaultColor
self.symbol = None
self._set_symbol(defaultSymbol)
self._penSize = 1.0
self._pen = QPen()
self._pen.setWidthF(self._penSize)
self._pen.setJoinStyle(Qt.MiterJoin)
self._pen.setColor(Qt.black)
self.setAcceptsHoverEvents(True)
self._outline = None
def hoverEnterEvent(self, event):
""" Stuff related to hover enter events.
For now we just show a rectangular outline.
"""
if not self._outline:
self._outline = QGraphicsRectItem(\
self.boundingRect().adjusted(-1,-1,1,1), self)
highlightColor = QColor(Qt.blue)
highlightColor.setAlpha(30)
self._outline.setBrush(highlightColor)
highlightPen = QPen(Qt.blue)
highlightPen.setWidth(2)
self._outline.setPen(highlightPen)
else:
self._outline.show()
def hoverLeaveEvent(self, event):
""" Stuff related to hover leave events.
For now we just show a rectangular outline.
"""
self._outline.hide()
def mousePressEvent(self, event):
""" We reimplement this function to store the position of
the item when a user issues a mouse press.
"""
self._position = self.pos()
if (event.modifiers() & Qt.ControlModifier):
QApplication.setOverrideCursor(QCursor(Qt.SizeAllCursor))
else:
event.ignore()
return QGraphicsSvgItem.mousePressEvent(self, event)
def mouseReleaseEvent(self, event):
""" We reimplement this function to check if its position
has changed since the last mouse click. If yes we
let the canvas know so it can store the action as
a Redo/Undo event.
"""
QApplication.restoreOverrideCursor()
# this is needed for redo/undo
if self._position != self.pos():
self.scene().canvas_item_position_changed(self, self._position,
self.pos())
return QGraphicsSvgItem.mouseReleaseEvent(self, event)
def change_geometry(self, newDim):
""" This slot changes the unit dimensions of the item. """
self.unitDim = newDim
self.size = QSizeF(self.unitDim.width() * self.width,
self.unitDim.height() * self.height)
@property
def name(self):
""" Return the name of the knitting symbol we contain. """
return self.symbol["name"]
def _set_symbol(self, newSymbol):
""" Adds a new svg image of a knitting symbol to the scene. """
self.symbol = newSymbol
svgPath = newSymbol["svgPath"]
if not self.renderer().load(svgPath):
errorMessage = ("PatternLegendItem._set_symbol: failed to load "
"symbol %s" % svgPath)
logger.error(errorMessage)
return
# apply color if present
if "backgroundColor" in newSymbol:
self.color = QColor(newSymbol["backgroundColor"])
def boundingRect(self):
""" Return the bounding rectangle of the item. """
halfPen = self._penSize * 0.5
return QRectF(self.origin, self.size).adjusted(halfPen, halfPen,
halfPen, halfPen)
def paint(self, painter, option, widget):
""" Paint ourselves. """
painter.setPen(self._pen)
brush = QBrush(self.color)
painter.setBrush(brush)
halfPen = self._penSize * 0.5
painter.drawRect(\
QRectF(self.origin, self.size).adjusted(halfPen, halfPen,
halfPen, halfPen))
self.renderer().render(painter, QRectF(self.origin, self.size))
def hoverEnterEvent(self, event):
pen = QPen(self.pen())
pen.setWidthF(3)
self.setPen(pen)
return RugItem.hoverEnterEvent(self, event)
class RepeatLegendItem(QGraphicsRectItem):
Type = 70000 + 7
def __init__(self, color, parent = None):
super(RepeatLegendItem, self).__init__(parent)
# NOTE: need this distinction for cache mode based on
# the Qt version otherwise rendering is broken
if NO_ITEM_CACHING:
self.setCacheMode(QGraphicsItem.NoCache)
else:
self.setCacheMode(QGraphicsItem.DeviceCoordinateCache)
self.setZValue(1)
self.setFlag(QGraphicsItem.ItemIsMovable)
self._position = self.pos()
self.penColor = color
self.itemHeight = 20
self.itemWidth = 40
self._pen = QPen()
self._pen.setWidthF(3.0)
self._pen.setColor(self.penColor)
self.setPen(self._pen)
self.setRect(0, 0, self.itemWidth, self.itemHeight)
self.setAcceptsHoverEvents(True)
self._outline = None
@property
def height(self):
return self.itemHeight
@property
def width(self):
return self.itemWidth
@property
def color(self):
return self.penColor
@color.setter
def color(self, newColor):
self.penColor = newColor
self._pen.setColor(self.penColor)
self.setPen(self._pen)
def hoverEnterEvent(self, event):
""" Stuff related to hover enter events.
For now we just show a rectangular outline.
"""
if not self._outline:
self._outline = QGraphicsRectItem(\
self.boundingRect().adjusted(-1,-1,1,1), self)
highlightColor = QColor(Qt.blue)
highlightColor.setAlpha(30)
self._outline.setBrush(highlightColor)
highlightPen = QPen(Qt.blue)
highlightPen.setWidth(2)
self._outline.setPen(highlightPen)
else:
self._outline.show()
def hoverLeaveEvent(self, event):
""" Stuff related to hover leave events.
For now we just show a rectangular outline.
"""
self._outline.hide()
def mousePressEvent(self, event):
""" We reimplement this function to store the position of
the item when a user issues a mouse press.
"""
self._position = self.pos()
if (event.modifiers() & Qt.ControlModifier):
QApplication.setOverrideCursor(QCursor(Qt.SizeAllCursor))
else:
event.ignore()
return QGraphicsRectItem.mousePressEvent(self, event)
def mouseReleaseEvent(self, event):
""" We reimplement this function to check if its position
has changed since the last mouse click. If yes we
let the canvas know so it can store the action as
a Redo/Undo event.
"""
QApplication.restoreOverrideCursor()
# this is needed for undo/redo
if self._position != self.pos():
self.scene().canvas_item_position_changed(self, self._position,
self.pos())
return QGraphicsRectItem.mouseReleaseEvent(self, event)
class lineItem(QGraphicsLineItem):
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 setParents(self, parentList, allItems, id):
self.parentList = [item for item in parentList if not item == self]
self.parentSelected = False
self.id = id
self.allItems = allItems
def getLayer(self):
return self.layer
def setLayer(self, name):
self.layer = name
def setOneRow(self, row1):
self.tableItem1 = row1
self.haveTwoItems = False
def setTwoRow(self, row1, row2):
self.tableItem1 = row1
self.tableItem2 = row2
self.haveTwoItems = True
def testprint(self):
print "I'm printable!"
def dragEnterEvent(self, event):
print event
def setPressed(self, key):
if (key == QtCore.Qt.Key_Control):
self.ctrlPressed = True
def setUnPressed(self, key):
if (key == QtCore.Qt.Key_Control):
self.ctrlPressed = False
def myIsSelected(self):
return self.selec
def isPressed(self):
return self.ctrlPressed
def setBackupPen(self, pen):
self.backupPen = pen
def getBackupPen(self):
return self.backupPen
def decreaseWidth(self):
pen = self.pen()
if (self.myIsSelected()):
pen.setWidthF(pen.widthF() * 1 / 1.05)
self.selectWidth = pen.widthF()
self.backupPen.setWidthF(self.backupPen.widthF() * 1 / 1.05)
else:
pen.setWidthF(pen.widthF() * 1 / 1.05)
self.selectWidth = self.selectWidth * 1 / 1.05
self.backupPen = pen
self.setPen(pen)
def increaseWidth(self):
pen = self.pen()
if (self.myIsSelected()):
pen.setWidthF(pen.widthF() * 1.05)
self.selectWidth = pen.widthF()
self.backupPen.setWidthF(self.backupPen.widthF() * 1.05)
else:
pen.setWidthF(pen.widthF() * 1.05)
self.selectWidth = self.selectWidth * 1.05
self.backupPen = pen
self.setPen(pen)
def setWidth(self, width):
self.backupPen.setWidthF(width)
self.setPen(self.backupPen)
def selectParents(self, selection):
for each in self.parentList:
#each.setParentSelected(selection)
each.setSelected(selection)
def setParentSelected(self, value):
self.parentSelected = value
def mySetSelected(self, selection, first):
if (selection):
self.setPen(self.pen)
self.setSelected(selection)
if (first):
self.selectParents(True)
else:
self.setPen(self.backupPen)
self.setSelected(selection)
if (first):
self.selectParents(False)
self.selec = selection
def deselectRow(self):
if (self.haveTwoItems):
self.tableItem2.setSelected(False)
self.tableItem1.setSelected(False)
def selectRow(self):
if (self.haveTwoItems):
self.tableItem2.setSelected(self.selec)
self.tableItem1.setSelected(self.selec)
def getId(self):
return self.id
def hoverEnterEvent(self, event):
print event
def itemChange(self, event, value):
if event == QGraphicsItem.ItemSelectedHasChanged:
if self.isSelected():
self.setPen(self.select_pen)
self.selec = True
else:
self.setPen(self.backupPen)
self.selec = False
return value
def hoverEnterEvent(self, event):
pen = QPen(self.pen())
pen.setWidthF(3)
self.setPen(pen)
return RugItem.hoverEnterEvent(self, event)
def addLines(self, show_max, axislimits=None):
self.backupRows = []
self.backupRows.append([])
#print str(axislimits)
parentcontainer = []
linecounter = self.axes_number - 1
plotnb = -1
parentDict = {}
row = self.ui.tableWidget.rowCount()
self.ui.tableWidget.insertRow(row)
hidden = []
for line in self.image['lines']:
plotnb = plotnb + 1
linecounter = linecounter + 1
qtcolor = self.QTColorGet(line['color'])
currentLine = lineItem(plotnb * defaults.axiswidth,
self.image['height'] - line['y1'],
(plotnb + 1) * defaults.axiswidth,
self.image['height'] - line['y2'])
# Setting the pen
pen = QPen()
pen.setColor(qtcolor)
pen.setWidthF(line['penwidth'])
currentLine.setPen(pen)
currentLine.setToolTip("%s -> %s" %
(line['x1_strval'], line['x2_strval']))
currentLine.setCursor(QtCore.Qt.OpenHandCursor)
currentLine.setLayer(line['layer'])
self.scene.createLayer(line['layer'], linecounter, currentLine)
self.scene.addItem(currentLine)
self.ui.tableWidget.setItem(row, plotnb,
QTableWidgetItem(line['x1_strval']))
self.backupRows[row].append(line['x1_strval'])
currentLine.setOneRow(self.ui.tableWidget.item(row, plotnb))
parentcontainer.append(linecounter)
if line['hidden']:
hidden.append(currentLine)
if plotnb == self.axes_number - 2:
self.ui.tableWidget.setItem(
row, plotnb + 1, QTableWidgetItem(line['x2_strval']))
currentLine.setTwoRow(
self.ui.tableWidget.item(row, plotnb),
self.ui.tableWidget.item(row, plotnb + 1))
self.backupRows[row].append(line['x2_strval'])
row = self.ui.tableWidget.rowCount()
self.backupRows.append([])
self.ui.tableWidget.insertRow(row)
for each in parentcontainer:
parentDict[each] = parentcontainer
parentcontainer = []
plotnb = -1
# Set the headers of tableWidget
count = 0
for each in self.comboList:
self.ui.tableWidget.horizontalHeaderItem(count).setText(
each.currentText().__str__())
count = count + 1
#remove a unused row
self.ui.tableWidget.removeRow(row)
# Sets a backup control value, to slider hide/show correctly and
# efficiently
self.hideValue = linecounter - \
(self.axes_number - 1) / (self.axes_number - 1)
#Gets items of scene only 1 time
self.graph_item = self.scene.items()
self.scene.getItems(self.graph_item, self.axes_number)
self.graph_size = len(self.graph_item)
for each in parentDict:
count = 0
parentList = []
for i in parentDict[each]:
variant = QtCore.QVariant(i)
self.graph_item[each].setData(count, variant)
parentList.append(self.graph_item[i])
count = count + 1
if isinstance(self.graph_item[each], lineItem):
self.graph_item[each].setParents(parentList, self.graph_item,
each)
del parentList
self.doSelectable()
self.scene.hideList(hidden)
