def paintEvent(self, event=None):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing, True)
xOffset = self.width() / 3
yOffset = self.height() / 3
for x in range(3):
for y in range(3):
cell = self.grid[x][y]
rect = QRectF(x * xOffset, y * yOffset, xOffset,
yOffset).adjusted(0.5, 0.5, -0.5, -0.5)
color = None
if cell == RED:
color = Qt.red
elif cell == YELLOW:
color = Qt.yellow
if color is not None:
painter.save()
painter.setPen(Qt.black)
painter.setBrush(color)
painter.drawEllipse(rect.adjusted(2, 2, -2, -2))
painter.restore()
if [x, y] == self.selected:
painter.setPen(QPen(Qt.blue, 3))
else:
painter.setPen(Qt.black)
painter.drawRect(rect)
def boundingRect(self):
if self._line is None:
if self._orientation == Qt.Vertical:
self._line = QLineF(0, self._value, self._length, self._value)
else:
self._line = QLineF(self._value, 0, self._value, self._length)
r = QRectF(self._line.p1(), self._line.p2())
penw = self.pen().width()
return r.adjusted(-penw, -penw, penw, penw)
def boundingRect(self):
if self._line is None:
if self._orientation == Qt.Vertical:
self._line = QLineF(0, self._value, self._length, self._value)
else:
self._line = QLineF(self._value, 0, self._value, self._length)
r = QRectF(self._line.p1(), self._line.p2())
penw = self.pen().width()
return r.adjusted(-penw, -penw, penw, penw)
def paintEvent(self, event):
pixmap = self._shadowPixmap
widget_rect = QRectF(QPointF(0.0, 0.0), QSizeF(self.size()))
frame_rect = QRectF(self.contentsRect())
left, top, right, bottom = self.getContentsMargins()
pixmap_rect = QRectF(QPointF(0, 0), QSizeF(pixmap.size()))
# Shadow casting rectangle.
pixmap_shadow_rect = pixmap_rect.adjusted(left, top, -right, -bottom)
source_rects = self._shadowPixmapFragments(pixmap_rect,
pixmap_shadow_rect)
target_rects = self._shadowPixmapFragments(widget_rect, frame_rect)
painter = QPainter(self)
for source, target in zip(source_rects, target_rects):
painter.drawPixmap(target, pixmap, source)
painter.end()
def mouseReleaseEvent(self, event):
# Reimplemented
if event.button() == Qt.LeftButton:
if self.__selectionRect is not None:
self.__selectionRect.setParentItem(None)
if self.scene() is not None:
self.scene().removeItem(self.__selectionRect)
self.__selectionRect = None
event.accept()
rect = QRectF(event.buttonDownPos(Qt.LeftButton), event.pos()).normalized()
if not rect.isValid():
rect = rect.adjusted(-1e-7, -1e-7, 1e-7, 1e-7)
rect = rect.intersected(self.contentsRect())
action = action = self.__selstate.action & ~SelectAction.Current
self.__setSelectionRect(rect, action)
self.__selstate = None
def mouseMoveEvent(self, event):
# Reimplemented
if event.buttons() & Qt.LeftButton:
assert self.__selstate is not None
if self.__selectionRect is None:
self.__selectionRect = QtGui.QGraphicsRectItem(self)
rect = QRectF(event.buttonDownPos(Qt.LeftButton), event.pos()).normalized()
if not rect.width():
rect = rect.adjusted(-1e-7, -1e-7, 1e-7, 1e-7)
rect = rect.intersected(self.contentsRect())
self.__selectionRect.setRect(rect)
self.__selstate.rect = rect
self.__selstate.action |= SelectAction.Current
self.__setSelectionRect(rect, self.__selstate.action)
event.accept()
def paintEvent(self, event):
# TODO: Use QPainter.drawPixmapFragments on Qt 4.7
opt = QStyleOption()
opt.initFrom(self)
pixmap = self.__shadowPixmap
shadow_rect = QRectF(opt.rect)
widget_rect = QRectF(self.widget().geometry())
widget_rect.moveTo(self.radius_, self.radius_)
left = top = right = bottom = self.radius_
pixmap_rect = QRectF(QPointF(0, 0), QSizeF(pixmap.size()))
# Shadow casting rectangle in the source pixmap.
pixmap_shadow_rect = pixmap_rect.adjusted(left, top, -right, -bottom)
source_rects = self.__shadowPixmapFragments(pixmap_rect,
pixmap_shadow_rect)
target_rects = self.__shadowPixmapFragments(shadow_rect, widget_rect)
painter = QPainter(self)
for source, target in zip(source_rects, target_rects):
painter.drawPixmap(target, pixmap, source)
painter.end()
def draw(self, painter, size=None):
"""
:Arguments:
painter : QPainter
Opened painter on which to draw
"""
bounding_rect = QRectF()
position = self.position
transfer_function = self.transfer_function
font = QFont(self.font)
text_color = self.text_color
line_color = self.line_color
line_thickness = self.line_thickness
value_range = self.value_range
if size is None:
viewport = painter.viewport() # viewport rectangle
mat, ok = painter.worldMatrix().inverted()
if not ok:
raise ValueError(
"Transformation matrix of painter is singular.")
viewport = mat.mapRect(viewport)
else:
viewport = size
# First, prepare the gradient
w = viewport.width()
h = viewport.height()
#print("Size of viewport: {0}x{1}".format(w, h))
gr = QLinearGradient()
nb_values = ceil(w / 5.0)
brush_color = QColor()
for i in range(int(nb_values)):
brush_color.setRgbF(*transfer_function.rgba(i / nb_values))
gr.setColorAt(i / nb_values, brush_color)
# Second, find its position
metric = QFontMetricsF(font, painter.device())
font_test = [str(i) * 5 for i in range(10)]
lim_width = 0
lim_height = 0
for t in font_test:
rect = metric.boundingRect(t)
lim_width = max(lim_width, rect.width())
lim_height = max(lim_height, rect.height())
lim_height *= 3
length = self.scale_length
shift_length = (1 - length) / 2
width = self.scale_width
shift_width = self.scale_shift_width
delta_value = value_range[1] - value_range[0]
if position == "Top":
scale_rect = QRectF(shift_length * w, shift_width * h, length * w,
width * h)
limit_rect(scale_rect, viewport, lim_width, lim_height)
gr.setStart(scale_rect.left(), scale_rect.center().y())
gr.setFinalStop(scale_rect.right(), scale_rect.center().y())
start_pos = scale_rect.bottomLeft()
end_pos = scale_rect.bottomRight()
elif position == "Right":
scale_rect = QRectF((1 - shift_width - width) * w,
shift_length * h, width * w, length * h)
limit_rect(scale_rect, viewport, lim_width, lim_height)
gr.setStart(scale_rect.center().x(), scale_rect.bottom())
gr.setFinalStop(scale_rect.center().x(), scale_rect.top())
start_pos = scale_rect.bottomLeft()
end_pos = scale_rect.topLeft()
elif position == "Bottom":
scale_rect = QRectF(shift_length * w,
(1 - shift_width - width) * h, length * w,
width * h)
limit_rect(scale_rect, viewport, lim_width, lim_height)
gr.setStart(scale_rect.left(), scale_rect.center().y())
gr.setFinalStop(scale_rect.right(), scale_rect.center().y())
start_pos = scale_rect.topLeft()
end_pos = scale_rect.topRight()
elif position == "Left":
scale_rect = QRectF(shift_width * w, shift_length * h, width * w,
length * h)
limit_rect(scale_rect, viewport, lim_width, lim_height)
gr.setStart(scale_rect.center().x(), scale_rect.bottom())
gr.setFinalStop(scale_rect.center().x(), scale_rect.top())
start_pos = scale_rect.bottomRight()
end_pos = scale_rect.topRight()
else:
raise ValueError("Invalid scale position: %s" % position)
shift_pos = (end_pos - start_pos) / delta_value
if position in ["Left", "Right"]:
is_vertical = True
length = scale_rect.height()
else:
is_vertical = False
length = scale_rect.width()
# Get the ticks
ticks = self.selectValues(length, is_vertical, painter)
if len(ticks) == 0:
return
ticks_str, ticks_extra = self._tick2str(ticks)
# Figure the shifts
dist_to_bar = self.text_to_bar
max_width = 0
max_height = 0
for t in ticks_str:
rect = metric.boundingRect(t)
max_width = max(rect.width(), max_width)
max_height = max(rect.height(), max_height)
if position == "Left":
shift_left = dist_to_bar
shift_top = None
elif position == "Right":
shift_left = -dist_to_bar - max_width
shift_top = None
elif position == "Top":
shift_left = None
shift_top = dist_to_bar
else:
shift_left = None
shift_top = -dist_to_bar - max_height
painter.save()
painter.translate(viewport.topLeft())
#print("viewport.topLeft() = {0}x{1}".format(viewport.left(), viewport.top()))
painter.setBrush(gr)
line_pen = QPen(line_color)
line_pen.setWidth(line_thickness)
painter.setPen(line_pen)
painter.drawRect(scale_rect)
bounding_rect |= scale_rect
#print("Scale rect: +{0}+{1}x{2}x{3}".format(scale_rect.left(),
#scale_rect.top(), scale_rect.width(), scale_rect.height()))
painter.setFont(font)
painter.setPen(text_color)
for ts, t in zip(ticks_str, ticks):
r = metric.boundingRect(ts)
pos = start_pos + shift_pos * (t - value_range[0])
if shift_left is None:
pos.setX(pos.x() - r.width() / 2)
else:
pos.setX(pos.x() + shift_left)
if shift_top is None:
pos.setY(pos.y() - r.height() / 2)
else:
pos.setY(pos.y() + shift_top)
r.moveTo(pos)
real_rect = painter.drawText(
r, Qt.TextDontClip | Qt.AlignVCenter | Qt.AlignHCenter, ts)
bounding_rect |= real_rect
if ticks_extra is not None or self.unit:
unit = self.unit
exp_width = width = space_width = 0
exp_txt = ""
r = exp_r = unit_r = QRectF()
exp_font = None
if ticks_extra is not None:
exp_txt = u"×10"
r = metric.boundingRect(exp_txt)
exp_font = QFont(font)
exp_size = self.exp_size
if exp_font.pixelSize() != -1:
exp_font.setPixelSize(exp_size * exp_font.pixelSize())
else:
exp_font.setPointSizeF(exp_size * exp_font.pointSizeF())
exp_metric = QFontMetricsF(exp_font, painter.device())
exp_r = exp_metric.boundingRect(ticks_extra)
if unit:
unit_r = metric.boundingRect(unit)
total_width = r.width() + exp_r.width() + unit_r.width()
total_height = max(r.height(),
unit_r.height()) + exp_r.height() / 2
pos = scale_rect.topRight()
log_debug("top right of scale bar = (%g,%g)" % (pos.x(), pos.y()))
log_debug("Size of image = (%d,%d)" % (w, h))
log_debug("Size of text = (%g,%g)" % (total_width, total_height))
if position == "Bottom":
pos.setY(pos.y() + scale_rect.height() + dist_to_bar)
pos.setX(pos.x() - total_width)
elif position == "Top":
pos.setY(pos.y() - dist_to_bar - total_height)
pos.setX(pos.x() - total_width)
else: # position == "left" or "right"
pos.setX(pos.x() - (scale_rect.width() + total_width) / 2)
if pos.x() < 0:
pos.setX(dist_to_bar)
elif pos.x() + total_width + dist_to_bar > w:
pos.setX(w - total_width - dist_to_bar)
pos.setY(pos.y() - dist_to_bar - total_height)
log_debug("Display unit at position: (%g,%g)" % (pos.x(), pos.y()))
if ticks_extra is not None:
r.moveTo(pos)
real_rect = painter.drawText(
r, Qt.TextDontClip | Qt.AlignVCenter | Qt.AlignHCenter,
exp_txt)
bounding_rect |= real_rect
pos.setX(pos.x() + r.width())
pos.setY(pos.y() - metric.ascent() / 2)
exp_r.moveTo(pos)
painter.setFont(exp_font)
real_rect = painter.drawText(
exp_r, Qt.TextDontClip | Qt.AlignVCenter | Qt.AlignHCenter,
ticks_extra)
bounding_rect |= real_rect
pos.setY(pos.y() + metric.ascent() / 2)
if unit:
pos.setX(pos.x() + space_width + exp_r.width())
unit_r.moveTo(pos)
painter.setFont(font)
real_rect = painter.drawText(
unit_r,
Qt.TextDontClip | Qt.AlignVCenter | Qt.AlignHCenter, unit)
bounding_rect |= real_rect
# Draw the ticks now
painter.setPen(line_pen)
tick_size = self.tick_size
if is_vertical:
width = scale_rect.width() * tick_size
else:
width = scale_rect.height() * tick_size
pen_width = painter.pen().widthF()
if pen_width == 0:
pen_width = 1.0
for t in ticks:
pos1 = start_pos + shift_pos * (t - value_range[0])
pos2 = QPointF(pos1)
if is_vertical:
pos1.setX(scale_rect.left() + pen_width)
pos2.setX(pos1.x() + width - pen_width)
painter.drawLine(pos1, pos2)
pos1.setX(scale_rect.right() - pen_width)
pos2.setX(pos1.x() - width + pen_width)
painter.drawLine(pos1, pos2)
else:
pos1.setY(scale_rect.top() + pen_width)
pos2.setY(pos1.y() + width - pen_width)
painter.drawLine(pos1, pos2)
pos1.setY(scale_rect.bottom() - pen_width)
pos2.setY(pos1.y() - width + pen_width)
painter.drawLine(pos1, pos2)
painter.restore()
bounding_rect = bounding_rect.adjusted(-pen_width, -pen_width,
pen_width, pen_width)
return bounding_rect
class ClassGraphicsItem(QGraphicsItem):
def __init__(self, model, parent=None, size=None, color=None):
super(ClassGraphicsItem, self).__init__(parent)
self.setFlags(QGraphicsItem.ItemIsSelectable
| QGraphicsItem.ItemIsMovable
| QGraphicsItem.ItemClipsChildrenToShape
| QGraphicsItem.ItemSendsGeometryChanges)
self.model = model
self._offset = 0
self.setGeometry(self.model.depth())
if size:
self.rect = QRectF(-size[0] / 2, -size[1 / 2], size[0], size[1])
if color:
self.color = color
if self.model.location:
self.setPos(*self.model.location[0])
if not self.model.isLeaf():
for child in self.model.childIter():
ClassGraphicsItem(child, parent=self)
self.setCursor(Qt.PointingHandCursor)
QObject.connect(self.model, SIGNAL("levelChanged(int)"),
self.setGeometry)
def boundingRect(self):
return self.rect.adjusted(-1, -1, 1, 1)
def paint(self, painter, option, widget):
if self.isSelected():
pen = QPen(Qt.DashLine)
pen.setColor(QColor(0xccff33))
pen.setWidth(2)
painter.setPen(pen)
else:
pen = QPen(Qt.SolidLine)
pen.setColor(Qt.black)
painter.setPen(pen)
painter.setBrush(QBrush(self.color))
painter.drawRoundedRect(self.rect, 5, 5)
painter.setPen(Qt.SolidLine | Qt.black)
painter.drawText(self.rect,
str(self.model.id()),
option=QTextOption(Qt.AlignCenter))
def addChild(self, modeldata):
# self.model.addChild(modeldata)
child = ClassGraphicsItem(modeldata, parent=self)
child.setPos(self.x() + self._offset, self.y() + self._offset)
self._offset += OFFSET
self.update()
def setGeometry(self, depth):
strachfactor = STRACHFACTOR**(depth - 1)
size = LEAFRECTSIZE[0] * strachfactor, LEAFRECTSIZE[1] * strachfactor
self.rect = QRectF(-size[0] / 2, -size[1] / 2, size[0], size[1])
colorfactor = COLORFACTOR**(depth - 1) * 100
self.color = LEAFCOLOR.lighter(colorfactor)
self.prepareGeometryChange()
def mousePressEvent(self, event):
self.setSelected(not self.isSelected())
self.update()
event.accept()
def itemChange(self, change, value):
if change == QGraphicsItem.ItemPositionHasChanged:
self.model.setLocation(
[self.x(), self.y()],
[self.scenePos().x(), self.scenePos().y()])
return super(ClassGraphicsItem, self).itemChange(change, value)
class ItemMovel(QGraphicsWidget):
rectChanged = pyqtSignal()
def __init__(self, moveX=True, moveY=True, rect=QRectF(0, 0, 30, 30), parent=None):
super().__init__(parent)
self._movel = Movel(moveX, moveY, self)
self.installEventFilter(self._movel)
self._newPos = QPointF()
self._oldPos = QPointF()
self._rect = QRectF()
self._newRect = QRectF()
self._oldRect = QRectF()
self._timePos = QTimeLine(1000)
self._timePos.setCurveShape(QTimeLine.EaseInOutCurve)
self._timePos.valueChanged.connect(self._atualizaPos)
self._timeRect = QTimeLine(1000)
self._timeRect.valueChanged.connect(self._atualizaRect)
self.setTamanho(rect)
def setMoveXY(self, x, y):
self._movel.setMoveXY(x, y)
def getRect(self):
return self._rect
def setRect(self, rect):
self._rect = rect
self._atualizaGeometria()
def boundingRect(self):
return self._rect.adjusted(-1, -1, 1, 1)
def altura(self):
return self._newRect.height()
def _atualizaPos(self, t):
# Funcao da curva que parametriza um segmento AB
# C(t) = A + (B - A)*t
pos = self._oldPos + (self._newPos - self._oldPos) * t
self.setPos(pos)
self._atualizaGeometria()
def _atualizaRect(self, t):
oldP1 = self._oldRect.topLeft()
oldP2 = self._oldRect.bottomRight()
newP1 = self._newRect.topLeft()
newP2 = self._newRect.bottomRight()
p1 = oldP1 + (newP1 - oldP1) * t
p2 = oldP2 + (newP2 - oldP2) * t
self.setRect(QRectF(p1, p2))
def _atualizaGeometria(self):
self.setGeometry(QRectF(self.pos(), self.pos() + self._rect.bottomRight()))
def goto(self, pos):
if self.pos() == pos:
return
if self._timePos.state() == QTimeLine.Running:
self._timePos.stop()
self._oldPos = self.pos()
self._newPos = pos
self._timePos.start()
def setTamanho(self, tam):
if self._rect == tam:
return
if self._timeRect.state() == QTimeLine.Running:
self._timeRect.stop()
self._oldRect = self._rect
self._newRect = tam
self._timeRect.start()
self.rectChanged.emit()
def resize(self, size):
if isinstance(size, QRect):
size = size.size()
self.setTamanho(QRectF(0, 0, size.width() - 3, self._newRect.height()))
def paint(self, painter, widget, option):
if self._timePos.state() == QTimeLine.Running:
currentValue = self._timePos.currentValue()
nextValue = self._timePos.valueForTime(self._timePos.currentTime() + 100)
painter.setBrush(QColor(255, 0, 0, (nextValue - currentValue) * 150))
painter.drawRoundedRect(self._rect, 7, 5)
def draw(self, painter, size = None):
"""
:Arguments:
painter : QPainter
Opened painter on which to draw
"""
bounding_rect = QRectF()
position = self.position
transfer_function = self.transfer_function
font = QFont(self.font)
text_color = self.text_color
line_color = self.line_color
line_thickness = self.line_thickness
value_range = self.value_range
if size is None:
viewport = painter.viewport() # viewport rectangle
mat, ok = painter.worldMatrix().inverted()
if not ok:
raise ValueError("Transformation matrix of painter is singular.")
viewport = mat.mapRect(viewport)
else:
viewport = size
# First, prepare the gradient
w = viewport.width()
h = viewport.height()
#print("Size of viewport: {0}x{1}".format(w, h))
gr = QLinearGradient()
nb_values = ceil(w/5.0)
brush_color = QColor()
for i in range(int(nb_values)):
brush_color.setRgbF(*transfer_function.rgba(i/nb_values))
gr.setColorAt(i/nb_values, brush_color)
# Second, find its position
metric = QFontMetricsF(font, painter.device())
font_test = [ str(i)*5 for i in range(10) ]
lim_width = 0
lim_height = 0
for t in font_test:
rect = metric.boundingRect(t)
lim_width = max(lim_width, rect.width())
lim_height = max(lim_height, rect.height())
lim_height *= 3
length = self.scale_length
shift_length = (1-length)/2
width = self.scale_width
shift_width = self.scale_shift_width
delta_value = value_range[1]-value_range[0]
if position == "Top":
scale_rect = QRectF(shift_length*w, shift_width*h, length*w, width*h)
limit_rect(scale_rect, viewport, lim_width, lim_height)
gr.setStart(scale_rect.left(), scale_rect.center().y())
gr.setFinalStop(scale_rect.right(), scale_rect.center().y())
start_pos = scale_rect.bottomLeft()
end_pos = scale_rect.bottomRight()
elif position == "Right":
scale_rect = QRectF((1-shift_width-width)*w, shift_length*h, width*w, length*h)
limit_rect(scale_rect, viewport, lim_width, lim_height)
gr.setStart(scale_rect.center().x(), scale_rect.bottom())
gr.setFinalStop(scale_rect.center().x(), scale_rect.top())
start_pos = scale_rect.bottomLeft()
end_pos = scale_rect.topLeft()
elif position == "Bottom":
scale_rect = QRectF(shift_length*w, (1-shift_width-width)*h, length*w, width*h)
limit_rect(scale_rect, viewport, lim_width, lim_height)
gr.setStart(scale_rect.left(), scale_rect.center().y())
gr.setFinalStop(scale_rect.right(), scale_rect.center().y())
start_pos = scale_rect.topLeft()
end_pos = scale_rect.topRight()
elif position == "Left":
scale_rect = QRectF(shift_width*w, shift_length*h, width*w, length*h)
limit_rect(scale_rect, viewport, lim_width, lim_height)
gr.setStart(scale_rect.center().x(), scale_rect.bottom())
gr.setFinalStop(scale_rect.center().x(), scale_rect.top())
start_pos = scale_rect.bottomRight()
end_pos = scale_rect.topRight()
else:
raise ValueError("Invalid scale position: %s" % position)
shift_pos = (end_pos-start_pos)/delta_value
if position in ["Left", "Right"]:
is_vertical = True
length = scale_rect.height()
else:
is_vertical = False
length = scale_rect.width()
# Get the ticks
ticks = self.selectValues(length, is_vertical, painter)
if len(ticks) == 0:
return
ticks_str, ticks_extra = self._tick2str(ticks)
# Figure the shifts
dist_to_bar = self.text_to_bar
max_width = 0
max_height = 0
for t in ticks_str:
rect = metric.boundingRect(t)
max_width = max(rect.width(), max_width)
max_height = max(rect.height(), max_height)
if position == "Left":
shift_left = dist_to_bar
shift_top = None
elif position == "Right":
shift_left = -dist_to_bar-max_width
shift_top = None
elif position == "Top":
shift_left = None
shift_top = dist_to_bar
else:
shift_left = None
shift_top = -dist_to_bar-max_height
painter.save()
painter.translate(viewport.topLeft())
#print("viewport.topLeft() = {0}x{1}".format(viewport.left(), viewport.top()))
painter.setBrush(gr)
line_pen = QPen(line_color)
line_pen.setWidth(line_thickness)
painter.setPen(line_pen)
painter.drawRect(scale_rect)
bounding_rect |= scale_rect
#print("Scale rect: +{0}+{1}x{2}x{3}".format(scale_rect.left(),
#scale_rect.top(), scale_rect.width(), scale_rect.height()))
painter.setFont(font)
painter.setPen(text_color)
for ts,t in zip(ticks_str, ticks):
r = metric.boundingRect(ts)
pos = start_pos+shift_pos*(t-value_range[0])
if shift_left is None:
pos.setX( pos.x() - r.width()/2 )
else:
pos.setX( pos.x() + shift_left )
if shift_top is None:
pos.setY( pos.y() - r.height()/2)
else:
pos.setY( pos.y() + shift_top )
r.moveTo(pos)
real_rect = painter.drawText(r, Qt.TextDontClip | Qt.AlignVCenter | Qt.AlignHCenter, ts)
bounding_rect |= real_rect
if ticks_extra is not None or self.unit:
unit = self.unit
exp_width = width = space_width = 0
exp_txt = ""
r = exp_r = unit_r = QRectF()
exp_font = None
if ticks_extra is not None:
exp_txt = u"×10"
r = metric.boundingRect(exp_txt)
exp_font = QFont(font)
exp_size = self.exp_size
if exp_font.pixelSize() != -1:
exp_font.setPixelSize(exp_size*exp_font.pixelSize())
else:
exp_font.setPointSizeF(exp_size*exp_font.pointSizeF())
exp_metric = QFontMetricsF(exp_font, painter.device())
exp_r = exp_metric.boundingRect(ticks_extra)
if unit:
unit_r = metric.boundingRect(unit)
total_width = r.width()+exp_r.width()+unit_r.width()
total_height = max(r.height(),unit_r.height())+exp_r.height()/2
pos = scale_rect.topRight()
log_debug("top right of scale bar = (%g,%g)" % (pos.x(), pos.y()))
log_debug("Size of image = (%d,%d)" % (w,h))
log_debug("Size of text = (%g,%g)" % (total_width, total_height))
if position == "Bottom":
pos.setY(pos.y() + scale_rect.height() + dist_to_bar)
pos.setX(pos.x() - total_width)
elif position == "Top":
pos.setY(pos.y() - dist_to_bar - total_height)
pos.setX(pos.x() - total_width)
else: # position == "left" or "right"
pos.setX(pos.x() - (scale_rect.width() + total_width)/2)
if pos.x() < 0:
pos.setX(dist_to_bar)
elif pos.x()+total_width+dist_to_bar > w:
pos.setX(w - total_width - dist_to_bar)
pos.setY(pos.y() - dist_to_bar - total_height)
log_debug("Display unit at position: (%g,%g)" % (pos.x(), pos.y()))
if ticks_extra is not None:
r.moveTo(pos)
real_rect = painter.drawText(r, Qt.TextDontClip | Qt.AlignVCenter | Qt.AlignHCenter, exp_txt)
bounding_rect |= real_rect
pos.setX( pos.x() + r.width() )
pos.setY( pos.y() - metric.ascent()/2 )
exp_r.moveTo(pos)
painter.setFont(exp_font)
real_rect = painter.drawText(exp_r, Qt.TextDontClip | Qt.AlignVCenter | Qt.AlignHCenter, ticks_extra)
bounding_rect |= real_rect
pos.setY(pos.y() + metric.ascent()/2)
if unit:
pos.setX(pos.x() + space_width + exp_r.width())
unit_r.moveTo(pos)
painter.setFont(font)
real_rect = painter.drawText(unit_r, Qt.TextDontClip | Qt.AlignVCenter | Qt.AlignHCenter, unit)
bounding_rect |= real_rect
# Draw the ticks now
painter.setPen(line_pen)
tick_size = self.tick_size
if is_vertical:
width = scale_rect.width()*tick_size
else:
width = scale_rect.height()*tick_size
pen_width = painter.pen().widthF()
if pen_width == 0:
pen_width = 1.0
for t in ticks:
pos1 = start_pos + shift_pos*(t-value_range[0])
pos2 = QPointF(pos1)
if is_vertical:
pos1.setX(scale_rect.left() + pen_width)
pos2.setX(pos1.x() + width - pen_width)
painter.drawLine(pos1, pos2)
pos1.setX(scale_rect.right() - pen_width)
pos2.setX(pos1.x() - width + pen_width)
painter.drawLine(pos1, pos2)
else:
pos1.setY(scale_rect.top() + pen_width)
pos2.setY(pos1.y() + width - pen_width)
painter.drawLine(pos1, pos2)
pos1.setY(scale_rect.bottom() - pen_width)
pos2.setY(pos1.y() - width + pen_width)
painter.drawLine(pos1, pos2)
painter.restore()
bounding_rect = bounding_rect.adjusted(-pen_width, -pen_width, pen_width, pen_width)
return bounding_rect
class TemplateItem(QGraphicsItem):
def __init__(self, parent=None):
QGraphicsItem.__init__(self, parent)
self.setZValue(5)
self.setFlags(QGraphicsItem.ItemIsMovable)
self.setAcceptsHoverEvents(True)
self.on_search = False
self.on_template = None
self.last_pos = None
self.changing = False
self.setGeometry()
#self.setFlag(QGraphicsItem.ItemIgnoresTransformations, True)
def __del__(self):
cleanQObject(self)
def setGeometry(self):
params = parameters.instance
self.prepareGeometryChange()
ss = params.search_size
ts = params.template_size
self.search_size = ss
self.template_size = ts
self.search_rect = QRectF(-ss, -ss, 2 * ss, 2 * ss)
self.template_rect = QRectF(-ts, -ts, 2 * ts, 2 * ts)
ssi = min(0.1 * ss, 5)
if 2 * ssi > ss - ts:
ssi = (ss - ts) / 2.
self.sensitive_size = ssi
self.sensitive_rect = self.search_rect.adjusted(-ssi, -ssi, ssi, ssi)
def itemChange(self, change, value):
if change == QGraphicsItem.ItemPositionChange:
pos = value.toPointF()
scene = self.scene()
if not self.changing and scene is not None:
self.changing = True
scene.templatePosChange.emit(pos)
self.changing = False
return QGraphicsItem.itemChange(self, change, value)
def resetCursor(self):
self.unsetCursor()
def updateCursor(self, x, y, all_dir):
if y != 0:
r = x / y
else:
r = 10
if all_dir:
if abs(r) > 2:
self.setCursor(QCursor(Qt.SizeHorCursor))
elif abs(r) < 0.5:
self.setCursor(QCursor(Qt.SizeVerCursor))
elif r < 0:
self.setCursor(QCursor(Qt.SizeBDiagCursor))
else:
self.setCursor(QCursor(Qt.SizeFDiagCursor))
else:
if abs(r) > 1:
self.setCursor(QCursor(Qt.SizeHorCursor))
else:
self.setCursor(QCursor(Qt.SizeVerCursor))
def hoverMoveEvent(self, event):
pos = event.pos()
x = pos.x()
y = pos.y()
event.accept()
ss = self.search_size
ts = self.template_size
ssi = self.sensitive_size
#diff = abs(dist_from_center-ss)
diff = min(abs(abs(x) - ss), abs(abs(y) - ss))
self.on_template = False
self.on_search = False
if diff < ssi:
self.on_search = True
self.updateCursor(x, y, True)
return
diff = min(abs(abs(x) - ts), abs(abs(y) - ts))
if diff < ssi:
self.on_template = True
self.updateCursor(x, y, False)
return
self.resetCursor()
def mousePressEvent(self, event):
pos = event.pos()
x = pos.x()
y = pos.y()
if self.on_search:
self.updateCursor(x, y, True)
event.accept()
return
elif self.on_template:
self.updateCursor(x, y, False)
event.accept()
return
QGraphicsItem.mousePressEvent(self, event)
def mouseMoveEvent(self, event):
params = parameters.instance
pos = event.pos()
x = pos.x()
y = pos.y()
if self.on_search:
ns = norm(x, y)
params.search_size = ns
self.updateCursor(x, y, True)
event.accept()
return
elif self.on_template:
ns = max(abs(x), abs(y))
params.template_size = ns
self.updateCursor(x, y, False)
event.accept()
return
QGraphicsItem.mouseMoveEvent(self, event)
def mouseReleaseEvent(self, event):
pos = event.pos()
x = pos.x()
y = pos.y()
if self.on_search:
self.updateCursor(x, y, True)
event.accept()
return
elif self.on_template:
self.updateCursor(x, y, False)
event.accept()
return
QGraphicsItem.mouseReleaseEvent(self, event)
def boundingRect(self):
return self.sensitive_rect
def shape(self):
shape = QPainterPath()
shape.addEllipse(self.sensitive_rect)
return shape
def paint(self, painter, option, widget):
params = parameters.instance
#tr = painter.worldMatrix()
painter.setPen(QColor(Qt.black))
painter.setBrush(params.search_color)
painter.drawRect(params.search_rect)
#painter.drawEllipse(params.search_rect)
painter.setBrush(params.template_color)
painter.drawRect(params.template_rect)
class TemplateItem(QGraphicsItem):
def __init__(self, parent=None):
QGraphicsItem.__init__(self, parent)
self.setZValue(5)
self.setFlags(QGraphicsItem.ItemIsMovable)
self.setAcceptsHoverEvents(True)
self.on_search = False
self.on_template = None
self.last_pos = None
self.changing = False
self.setGeometry()
#self.setFlag(QGraphicsItem.ItemIgnoresTransformations, True)
def __del__(self):
cleanQObject(self)
def setGeometry(self):
params = parameters.instance
self.prepareGeometryChange()
ss = params.search_size
ts = params.template_size
self.search_size = ss
self.template_size = ts
self.search_rect = QRectF(-ss, -ss, 2*ss, 2*ss)
self.template_rect = QRectF(-ts, -ts, 2*ts, 2*ts)
ssi = min(0.1*ss, 5)
if 2*ssi > ss-ts:
ssi = (ss-ts)/2.
self.sensitive_size = ssi
self.sensitive_rect = self.search_rect.adjusted(-ssi, -ssi, ssi, ssi)
def itemChange(self, change, value):
if change == QGraphicsItem.ItemPositionChange:
pos = value.toPointF()
scene = self.scene()
if not self.changing and scene is not None:
self.changing = True
scene.templatePosChange.emit(pos)
self.changing = False
return QGraphicsItem.itemChange(self, change, value)
def resetCursor(self):
self.unsetCursor()
def updateCursor(self, x, y, all_dir):
if y != 0:
r = x/y
else:
r = 10
if all_dir:
if abs(r) > 2:
self.setCursor(QCursor(Qt.SizeHorCursor))
elif abs(r) < 0.5:
self.setCursor(QCursor(Qt.SizeVerCursor))
elif r < 0:
self.setCursor(QCursor(Qt.SizeBDiagCursor))
else:
self.setCursor(QCursor(Qt.SizeFDiagCursor))
else:
if abs(r) > 1:
self.setCursor(QCursor(Qt.SizeHorCursor))
else:
self.setCursor(QCursor(Qt.SizeVerCursor))
def hoverMoveEvent(self, event):
pos = event.pos()
x = pos.x()
y = pos.y()
event.accept()
ss = self.search_size
ts = self.template_size
ssi = self.sensitive_size
#diff = abs(dist_from_center-ss)
diff = min(abs(abs(x)-ss), abs(abs(y)-ss))
self.on_template = False
self.on_search = False
if diff < ssi:
self.on_search = True
self.updateCursor(x, y, True)
return
diff = min(abs(abs(x)-ts), abs(abs(y)-ts))
if diff < ssi:
self.on_template = True
self.updateCursor(x, y, False)
return
self.resetCursor()
def mousePressEvent(self, event):
pos = event.pos()
x = pos.x()
y = pos.y()
if self.on_search:
self.updateCursor(x, y, True)
event.accept()
return
elif self.on_template:
self.updateCursor(x, y, False)
event.accept()
return
QGraphicsItem.mousePressEvent(self, event)
def mouseMoveEvent(self, event):
params = parameters.instance
pos = event.pos()
x = pos.x()
y = pos.y()
if self.on_search:
ns = norm(x, y)
params.search_size = ns
self.updateCursor(x, y, True)
event.accept()
return
elif self.on_template:
ns = max(abs(x), abs(y))
params.template_size = ns
self.updateCursor(x, y, False)
event.accept()
return
QGraphicsItem.mouseMoveEvent(self, event)
def mouseReleaseEvent(self, event):
pos = event.pos()
x = pos.x()
y = pos.y()
if self.on_search:
self.updateCursor(x, y, True)
event.accept()
return
elif self.on_template:
self.updateCursor(x, y, False)
event.accept()
return
QGraphicsItem.mouseReleaseEvent(self, event)
def boundingRect(self):
return self.sensitive_rect
def shape(self):
shape = QPainterPath()
shape.addEllipse(self.sensitive_rect)
return shape
def paint(self, painter, option, widget):
params = parameters.instance
#tr = painter.worldMatrix()
painter.setPen(QColor(Qt.black))
painter.setBrush(params.search_color)
painter.drawRect(params.search_rect)
#painter.drawEllipse(params.search_rect)
painter.setBrush(params.template_color)
painter.drawRect(params.template_rect)
