def rotate_image(self):
pm = self.label.pixmap()
t = QTransform()
t.rotate(90)
pm = pm.transformed(t)
self.label.setPixmap(pm)
self.label.adjustSize()
def __init__(self, file_object, page_width, page_height, left_margin,
top_margin, right_margin, bottom_margin, width, height,
errors=print, debug=print, compress=True,
mark_links=False):
QPaintEngine.__init__(self, self.FEATURES)
self.file_object = file_object
self.compress, self.mark_links = compress, mark_links
self.page_height, self.page_width = page_height, page_width
self.left_margin, self.top_margin = left_margin, top_margin
self.right_margin, self.bottom_margin = right_margin, bottom_margin
self.pixel_width, self.pixel_height = width, height
# Setup a co-ordinate transform that allows us to use co-ords
# from Qt's pixel based co-ordinate system with its origin at the top
# left corner. PDF's co-ordinate system is based on pts and has its
# origin in the bottom left corner. We also have to implement the page
# margins. Therefore, we need to translate, scale and reflect about the
# x-axis.
dy = self.page_height - self.top_margin
dx = self.left_margin
sx = (self.page_width - self.left_margin -
self.right_margin) / self.pixel_width
sy = (self.page_height - self.top_margin -
self.bottom_margin) / self.pixel_height
self.pdf_system = QTransform(sx, 0, 0, -sy, dx, dy)
self.graphics = Graphics(self.pixel_width, self.pixel_height)
self.errors_occurred = False
self.errors, self.debug = errors, debug
self.fonts = {}
self.current_page_num = 1
self.current_page_inited = False
self.qt_hack, err = plugins['qt_hack']
if err:
raise RuntimeError('Failed to load qt_hack with err: %s'%err)
def rotate_image(self):
pm = self.label.pixmap()
t = QTransform()
t.rotate(90)
pm = self.current_img = pm.transformed(t)
self.label.setPixmap(pm)
self.label.adjustSize()
self.factor = 1
for sb in (self.scrollarea.horizontalScrollBar(),
self.scrollarea.verticalScrollBar()):
sb.setValue(0)
def rotate_image(self):
pm = self.label.pixmap()
t = QTransform()
t.rotate(90)
pm = self.current_img = pm.transformed(t)
self.label.setPixmap(pm)
self.label.adjustSize()
self.factor = 1
for sb in (self.scrollarea.horizontalScrollBar(),
self.scrollarea.verticalScrollBar()):
sb.setValue(0)
def main():
# written/taken from https://www.codesd.com/item/how-to-create-a-pie-chart-with-pyqt-in-python.html
app = QApplication(sys.argv)
radius = 200
scene = WheelScene(radius=radius)
wheel = WheelPhoto()
wheel.show()
wheel.spinWheel(7)
wheel_label = WheelLabel()
wheel_label.show()
view = QGraphicsView(scene)
view.setStyleSheet("background: transparent")
view.setSceneRect(0, 0, radius * 2, radius * 2)
group = scene.createItemGroup(scene.items())
print("view: sceneRect=%s" % view.sceneRect())
#print("view: rect=%s" %view.cen)
view.show()
i = 0
while True:
transform = QTransform()
offset = group.boundingRect().center()
transform.translate(offset.x(), offset.y())
transform.rotate(i)
transform.translate(-offset.x(), -offset.y())
group.setTransform(transform)
view.transform()
QtTest.QTest.qWait(50)
i += 1
app.exec_()
def dst_FileDialog():
# 1 часть функции (прогресс, работа иконки указателя, доступ к след. кнопке)
if process_label.text(
) == "Ожидание старта..." or process_label.text() != "Повторный выбор...":
process_label.setText("Ожидание старта...")
process_label.setToolTip("Сейчас происходит: %s" %
process_label.text())
else:
process_label.setText("Повторное ожидание..")
process_label.setToolTip("Сейчас происходит: %s" %
process_label.text())
transform = QTransform().rotate(220)
arrow_label.setPixmap(arrow.transformed(transform, mode=1))
arrow_label.setGeometry(QRect(55, 54, 80, 80))
active_button.setEnabled(True)
# 2 часть функции (диалоговое окно)
dialog_dst = QFileDialog(
parent=window,
filter="",
caption="Сюда будут сгенерированы случайные композиции")
dialog_dst.setFileMode(QFileDialog.Directory)
dialog_dst.setOption(QFileDialog.DontUseNativeDialog, True)
result_dst = dialog_dst.exec()
if result_dst == QDialog.Accepted:
for dst in dialog_dst.selectedFiles():
dst_button.setToolTip(dst)
else: # Если не выбрана папка
msg_event(4)
dst_FileDialog()
def resolve_fill(self, rect, pdf_system, qt_system):
'''
Qt's paint system does not update brushOrigin when using
TexturePatterns and it also uses TexturePatterns to emulate gradients,
leading to brokenness. So this method allows the paint engine to update
the brush origin before painting an object. While not perfect, this is
better than nothing. The problem is that if the rect being filled has a
border, then QtWebKit generates an image of the rect size - border but
fills the full rect, and there's no way for the paint engine to know
that and adjust the brush origin.
'''
if not hasattr(self, 'last_fill') or not self.current_state.do_fill:
return
if isinstance(self.last_fill.brush, TexturePattern):
tl = rect.topLeft()
if tl == self.last_fill.origin:
return
matrix = (QTransform.fromTranslate(tl.x(), tl.y())
* pdf_system * qt_system.inverted()[0])
pat = TexturePattern(None, matrix, self.pdf, clone=self.last_fill.brush)
pattern = self.pdf.add_pattern(pat)
self.pdf.apply_fill(self.last_fill.color, pattern)
def corner():
b = QBrush(self.ccolor1)
p.fillPath(path, b)
p.rotate(90), p.translate(100, -100), p.scale(1, -1), p.translate(
-103, -97)
p.fillPath(path, b)
p.setWorldTransform(QTransform())
def src_FileDialog():
# 1 часть функции (прогресс, работа иконки указателя, доступ к след. кнопке)
if process_label.text() != "Ожидание старта..." and process_label.text(
) != "Выбор папок...":
process_label.setText("Повторный выбор...")
process_label.setToolTip("Сейчас происходит: %s" %
process_label.text())
transform = QTransform().rotate(130)
arrow_label.setPixmap(arrow.transformed(transform, mode=1))
arrow_label.setGeometry(QRect(64, 62, 80, 80))
dst_button.setEnabled(True)
# 2 часть функции (диалоговое окно)
dialog_src = QFileDialog(
parent=window,
filter="",
caption="Отсюда будут собраны музыкальные композиции")
dialog_src.setFileMode(QFileDialog.Directory)
dialog_src.setOption(QFileDialog.DontUseNativeDialog, True)
result_src = dialog_src.exec()
if result_src == QDialog.Accepted:
for src in dialog_src.selectedFiles():
src_button.setToolTip(src)
else: # Если не выбрана папка
msg_event(4)
src_FileDialog()
def __init__(self, file_object, page_width, page_height, left_margin,
top_margin, right_margin, bottom_margin, width, height,
errors=print, debug=print, compress=True,
mark_links=False):
QPaintEngine.__init__(self, self.FEATURES)
self.file_object = file_object
self.compress, self.mark_links = compress, mark_links
self.page_height, self.page_width = page_height, page_width
self.left_margin, self.top_margin = left_margin, top_margin
self.right_margin, self.bottom_margin = right_margin, bottom_margin
self.pixel_width, self.pixel_height = width, height
# Setup a co-ordinate transform that allows us to use co-ords
# from Qt's pixel based co-ordinate system with its origin at the top
# left corner. PDF's co-ordinate system is based on pts and has its
# origin in the bottom left corner. We also have to implement the page
# margins. Therefore, we need to translate, scale and reflect about the
# x-axis.
dy = self.page_height - self.top_margin
dx = self.left_margin
sx = (self.page_width - self.left_margin -
self.right_margin) / self.pixel_width
sy = (self.page_height - self.top_margin -
self.bottom_margin) / self.pixel_height
self.pdf_system = QTransform(sx, 0, 0, -sy, dx, dy)
self.graphics = Graphics(self.pixel_width, self.pixel_height)
self.errors_occurred = False
self.errors, self.debug = errors, debug
self.fonts = {}
self.current_page_num = 1
self.current_page_inited = False
self.content_written_to_current_page = False
self.qt_hack, err = plugins['qt_hack']
if err:
raise RuntimeError('Failed to load qt_hack with err: %s'%err)
def __init__(self):
self.fill = QBrush(Qt.white)
self.stroke = QPen()
self.opacity = 1.0
self.transform = QTransform()
self.brush_origin = QPointF()
self.clip_updated = False
self.do_fill = False
self.do_stroke = True
self.qt_pattern_cache = {}
def copy(self):
ans = GraphicsState()
ans.fill = QBrush(self.fill)
ans.stroke = QPen(self.stroke)
ans.opacity = self.opacity
ans.transform = self.transform * QTransform()
ans.brush_origin = QPointF(self.brush_origin)
ans.clip_updated = self.clip_updated
ans.do_fill, ans.do_stroke = self.do_fill, self.do_stroke
return ans
def drawContents(self, painter):
self.drawn_once = True
painter.save()
painter.setPen(Qt.black)
painter.setRenderHint(painter.TextAntialiasing, True)
painter.setRenderHint(painter.Antialiasing, True)
f = painter.font()
f.setPixelSize(18)
painter.setFont(f)
t = QTransform()
t.translate(330, 450)
painter.setTransform(t)
painter.rotate(-98)
if iswindows:
# On windows Qt cannot anti-alias rotated text
p = QPainterPath()
p.addText(0, 0, f, self.message())
painter.fillPath(p, QBrush(Qt.black))
else:
painter.drawText(0, 0, self.message())
painter.restore()
def drawContents(self, painter):
self.drawn_once = True
painter.save()
painter.setPen(Qt.black)
painter.setRenderHint(painter.TextAntialiasing, True)
painter.setRenderHint(painter.Antialiasing, True)
f = painter.font()
f.setPixelSize(18)
painter.setFont(f)
t = QTransform()
t.translate(330, 450)
painter.setTransform(t)
painter.rotate(-98)
left_margin = 25
if iswindows:
# On windows Qt cannot anti-alias rotated text
p = QPainterPath()
p.addText(left_margin, 0, f, self.message())
painter.fillPath(p, QBrush(Qt.black))
else:
painter.drawText(left_margin, 0, self.message())
painter.restore()
def convert_brush(self, brush, brush_origin, global_opacity, pdf_system,
qt_system):
# Convert a QBrush to PDF operators
style = brush.style()
pdf = self.pdf
pattern = color = pat = None
opacity = global_opacity
do_fill = True
matrix = (
QTransform.fromTranslate(brush_origin.x(), brush_origin.y()) *
pdf_system * qt_system.inverted()[0])
vals = list(brush.color().getRgbF())
self.brushobj = None
if style <= Qt.DiagCrossPattern:
opacity *= vals[-1]
color = vals[:3]
if style > Qt.SolidPattern:
pat = QtPattern(style, matrix)
elif style == Qt.TexturePattern:
pat = TexturePattern(brush.texture(), matrix, pdf)
if pat.paint_type == 2:
opacity *= vals[-1]
color = vals[:3]
elif style == Qt.LinearGradientPattern:
pat = LinearGradientPattern(brush, matrix, pdf, self.page_width_px,
self.page_height_px)
opacity *= pat.const_opacity
# TODO: Add support for radial/conical gradient fills
if opacity < 1e-4 or style == Qt.NoBrush:
do_fill = False
self.brushobj = Brush(brush_origin, pat, color)
if pat is not None:
pattern = pdf.add_pattern(pat)
return color, opacity, pattern, do_fill
def convert_brush(self, brush, brush_origin, global_opacity,
pdf_system, qt_system):
# Convert a QBrush to PDF operators
style = brush.style()
pdf = self.pdf
pattern = color = pat = None
opacity = global_opacity
do_fill = True
matrix = (QTransform.fromTranslate(brush_origin.x(), brush_origin.y())
* pdf_system * qt_system.inverted()[0])
vals = list(brush.color().getRgbF())
self.brushobj = None
if style <= Qt.DiagCrossPattern:
opacity *= vals[-1]
color = vals[:3]
if style > Qt.SolidPattern:
pat = QtPattern(style, matrix)
elif style == Qt.TexturePattern:
pat = TexturePattern(brush.texture(), matrix, pdf)
if pat.paint_type == 2:
opacity *= vals[-1]
color = vals[:3]
elif style == Qt.LinearGradientPattern:
pat = LinearGradientPattern(brush, matrix, pdf, self.page_width_px,
self.page_height_px)
opacity *= pat.const_opacity
# TODO: Add support for radial/conical gradient fills
if opacity < 1e-4 or style == Qt.NoBrush:
do_fill = False
self.brushobj = Brush(brush_origin, pat, color)
if pat is not None:
pattern = pdf.add_pattern(pat)
return color, opacity, pattern, do_fill
def create_transform(self,
left_margin=None,
top_margin=None,
right_margin=None,
bottom_margin=None):
# Setup a co-ordinate transform that allows us to use co-ords
# from Qt's pixel based co-ordinate system with its origin at the top
# left corner. PDF's co-ordinate system is based on pts and has its
# origin in the bottom left corner. We also have to implement the page
# margins. Therefore, we need to translate, scale and reflect about the
# x-axis.
left_margin = self.left_margin if left_margin is None else left_margin
top_margin = self.top_margin if top_margin is None else top_margin
right_margin = self.right_margin if right_margin is None else right_margin
bottom_margin = self.bottom_margin if bottom_margin is None else bottom_margin
dy = self.page_height - top_margin
dx = left_margin
sx = (self.page_width - left_margin - right_margin) / self.pixel_width
sy = (self.page_height - top_margin -
bottom_margin) / self.pixel_height
return QTransform(sx, 0, 0, -sy, dx, dy)
def rotate_image(img, degrees):
t = QTransform()
t.rotate(degrees)
return image_from_data(img).transformed(t)
def rotate_image(img, degrees):
t = QTransform()
t.rotate(degrees)
return image_from_data(img).transformed(t)
def spinWheel(self, destination):
""" Make the Wheel Spin. Ensure it lands on Destination"""
if self.use_qgraphics_wheel:
i = 0
self.wheel_transform = QTransform()
self.wheel_offset = self.wheel_group.boundingRect().center()
self.wheel_transform.translate(self.wheel_offset.x(),
self.wheel_offset.y())
self.wheel_transform.setRotateCropHalve(i)
self.wheel_transform.translate(-self.wheel_offset.x(),
-self.wheel_offset.y())
self.wheel_group.setTransform(self.wheel_transform)
self.wheel_view.transform()
QtTest.QTest.qWait(50)
i += 1
else:
data = None
num_sectors = 0
if self.use_textwheel:
for each in range(0, 12):
if getattr(self, "label_wheel_" + str(each)).isEnabled():
num_sectors += 1
else:
num_sectors = 12
if self.wheel_resting_place is None:
self.wheel_resting_place = 0
last = self.wheel_resting_place
def cycle(start_number: int,
delay_ms: int,
num_switches: int,
sectors: int,
target: int = None) -> None:
number = start_number
delay_ms = delay_ms / 5
if start_number > 0:
last = start_number - 1
else:
last = sectors - 1
for each in range(number, num_switches):
each = each % sectors
# betterspin.wav from
# https://freesound.org/people/door15studio/sounds/244774/
QSound.play("betterspin.wav")
rot_angle = 360 / 12
self.wheel_gui.setRotateCropHalve(rot_angle)
self.selectionTitle.setText(
getattr(self, "label_wheel_%s" % each).text())
if self.use_textwheel:
if last is not None:
getattr(self, "label_wheel_" +
str(last)).setAlignment(Qt.AlignLeft)
getattr(self, "label_wheel_" + str(each)).setAlignment(
Qt.AlignRight)
number = each
last = each
if number == target and target is not None:
return number
QtTest.QTest.qWait(delay_ms)
return number
if self.skip_spinanimation:
if self.use_textwheel:
for each in range(0, num_sectors):
if each != int(destination):
getattr(self, "label_wheel_" +
str(each)).setAlignment(Qt.AlignLeft)
else:
getattr(self, "label_wheel_" +
str(each)).setAlignment(Qt.AlignRight)
else:
pass
else:
self.wheel_resting_place = cycle(last, 170, num_sectors * 2,
num_sectors)
self.wheel_resting_place = cycle(self.wheel_resting_place, 190,
num_sectors, num_sectors)
self.wheel_resting_place = cycle(self.wheel_resting_place, 210,
num_sectors, num_sectors)
self.wheel_resting_place = cycle(self.wheel_resting_place, 250,
num_sectors * 2, num_sectors)
self.wheel_resting_place = cycle(self.wheel_resting_place,
350,
num_sectors * 2,
num_sectors,
target=int(destination))
self.logic_controller.issueAck("spinWheel")
def drawControl(self, element, option, painter, widget):
'''
@param: element ControlElement
@param: option QStyleOption
@param: painter QPainter
@param: widget QWidget
'''
v_opt = option
if element != self.CE_TabBarTab or not isinstance(
v_opt, QStyleOptionTab):
QProxyStyle.drawControl(element, option, painter, widget)
return
rect = v_opt.rect
selected = v_opt.state & self.State_Selected
vertical_tabs = v_opt.shape == QTabBar.RoundedWest
text = v_opt.text
if selected:
# background
painter.save()
grad = QLinearGradient(rect.topLeft(), rect.topRight())
grad.setColorAt(0, QColor(255, 255, 255, 140))
grad.setColorAt(0, QColor(255, 255, 255, 210))
painter.fillRect(rect.adjusted(0, 0, 0, -1), grad)
painter.restore()
# shadows
painter.setPen(QColor(0, 0, 0, 110))
painter.drawLine(rect.topLeft() + QPoint(1, -1),
rect.topRight() - QPoint(0, 1))
painter.drawLine(rect.bottomLeft(), rect.bottomRight())
painter.setPen(QColor(0, 0, 0, 40))
painter.drawLine(rect.topLeft(), rect.bottomLeft())
# highlights
painter.setPen(QColor(255, 255, 255, 50))
painter.drawLine(rect.topLeft() + QPoint(0, -2),
rect.topRight() - QPoint(0, 2))
painter.drawLine(rect.bottomLeft() + QPoint(0, 1),
rect.bottomRight() + QPoint(0, 1))
painter.setPen(QColor(255, 255, 255, 40))
painter.drawLine(rect.topLeft() + QPoint(0, 0), rect.topRight())
painter.drawLine(rect.topRight() + QPoint(0, 1),
rect.bottomRight() - QPoint(0, 1))
painter.drawLine(rect.bottomLeft() + QPoint(0, -1),
rect.bottomRight() - QPoint(0, 1))
m = QTransform()
if vertical_tabs:
m = QTransform.fromTranslate(rect.left(), rect.bottom())
m.rotate(-90)
else:
m = QTransform.fromTranslate(rect.left(), rect.top())
draw_rect = QRect(QPoint(0, 0), m.mapRect(rect).size())
painter.save()
painter.setTransform(m)
icon_rect = QRect(QPoint(8, 0), v_opt.iconSize)
text_rect = QRect(icon_rect.topRight() + QPoint(4, 0),
draw_rect.size())
text_rect.setRight(draw_rect.width())
icon_rect.translate(0, (draw_rect.height() - icon_rect.height()) / 2)
boldFont = QFont(painter.font())
boldFont.setPointSizeF(styleHelper.sidebarFontSize())
boldFont.setBold(True)
painter.setFont(boldFont)
painter.setPen(selected and QColor(255, 255, 255, 160)
or QColor(0, 0, 0, 110))
textFlags = Qt.AlignHCenter | Qt.AlignVCenter
painter.drawText(text_rect, textFlags, text)
painter.setPen(selected and QColor(60, 60, 60)
or styleHelper.panelTextColor())
if widget:
fader_key = 'tab_' + text + '_fader'
animation_key = 'tab_' + text + '_animation'
tab_hover = widget.property('tab_hover')
# int
fader = widget.property(fader_key)
# QPropertyAnimation
animation = widget.property(animation_key)
if not animation:
mut_widget = widget
fader = 0
mut_widget.setProperty(fader_key, fader)
animation = QPropertyAnimation(mut_widget, fader_key,
mut_widget)
animation.valueChanged.connect(mut_widget.update)
mut_widget.setProperty(animation_key, animation)
if text == tab_hover:
if animation.state(
) != QAbstractAnimation.Running and fader != 40:
animation.stop()
animation.setDuration(80)
animation.setEndValue(40)
animation.start()
else:
if animation.state(
) != QAbstractAnimation.Running and fader != 0:
animation.stop()
animation.setDuration(160)
animation.setEndValue(0)
animation.start()
if not selected:
painter.save()
painter.fillRect(draw_rect, QColor(255, 255, 255, fader))
painter.setPen(QPen(QColor(255, 255, 255, fader), 1.0))
painter.drawLine(
draw_rect.topLeft(),
vertical_tabs and draw_rect.bottomLeft()
or draw_rect.topRight())
painter.drawLine(
draw_rect.bottomRight(),
vertical_tabs and draw_rect.topRight()
or draw_rect.bottomLeft())
painter.restore()
if selected:
iconMode = QIcon.Selected
else:
iconMode = QIcon.Normal
styleHelper.drawIconWithShadow(v_opt.icon, icon_rect, painter,
iconMode)
painter.drawText(text_rect.translated(0, -1), textFlags, text)
painter.restore()
def update(self):
restant = 360
i = 0
#self.my_scene.clear()
for item in self.pie_items :
self.my_scene.removeItem(item)
self.pie_items = []
self.scene().setSceneRect(QRectF(0,0,self.frameSize().width(),self.frameSize().height()))
#print ('size',self.scene().sceneRect())
#proxy = QGraphicsProxyWidget ()
for item in self.data :
if (i==len(self.data)-1 ):
angle = restant
else:
try :
angle = int(360*item[self.c_box.currentText()]/self.total_value[self.c_box.currentText()])
except ZeroDivisionError:
angle = 0
ellipse = Section(0,0,self.size_pie.width(),self.size_pie.height())
y = (self.parent().size().height()-self.size_pie.height())/2.0
x_pie = ((self.parent().size().width()/2.0)-self.size_pie.height())/2.0
ellipse.setPos(x_pie,y)
ellipse.setStartAngle(16*(360-restant))
ellipse.setSpanAngle(angle*16)
ellipse.setBrush(item['color'])
self.my_scene.addItem(ellipse)
self.pie_items.append(ellipse)
# text pourcentage a afficher dans les portions de disque
try :
v = (item[self.c_box.currentText()]/self.total_value[self.c_box.currentText()])*100
except ZeroDivisionError :
v = 0
text = QGraphicsSimpleTextItem("{0:5.2f}".format(v)+"%")
trans = QTransform().translate(x_pie+self.size_pie.width()/2.0,y+self.size_pie.height()/2.0).rotate(((360-restant)+angle/2.0)*-1)
pts = trans.map(QPointF(self.size_pie.width()/3.0,0))
text.setPos(pts.x(),pts.y())
self.my_scene.addItem(text)
self.pie_items.append(text)
#libelle
rect = QGraphicsRectItem(0,0,10,10)
x = x_pie + self.size_pie.width()+ self.space
interval_height = (self.parent().size().height()-self.margin['top']-self.margin['bottom'])/(len(self.data)+1)
rect.setPos(QPointF(x,self.margin['top']+((i+1)*interval_height)))
rect.setBrush(item['color'])
self.my_scene.addItem(rect)
self.pie_items.append(rect)
text = QGraphicsSimpleTextItem(item['label']+ " ("+str(int(item[self.c_box.currentText()]))+")")
pts = rect.pos()
transform = QTransform().translate(30, 0)
pts = transform.map(pts)
text.setPos(pts)
self.my_scene.addItem(text)
self.pie_items.append(text)
restant = restant - angle
i +=1
# self.fitInView(self.scene.sceneRect())
class PdfEngine(QPaintEngine):
FEATURES = QPaintEngine.AllFeatures & ~(
QPaintEngine.PorterDuff | QPaintEngine.PerspectiveTransform |
QPaintEngine.ObjectBoundingModeGradients |
QPaintEngine.RadialGradientFill |
QPaintEngine.ConicalGradientFill
)
def __init__(self, file_object, page_width, page_height, left_margin,
top_margin, right_margin, bottom_margin, width, height,
errors=print, debug=print, compress=True,
mark_links=False, opts=None):
QPaintEngine.__init__(self, self.FEATURES)
self.file_object = file_object
self.compress, self.mark_links = compress, mark_links
self.page_height, self.page_width = page_height, page_width
self.left_margin, self.top_margin = left_margin, top_margin
self.right_margin, self.bottom_margin = right_margin, bottom_margin
self.pixel_width, self.pixel_height = width, height
# Setup a co-ordinate transform that allows us to use co-ords
# from Qt's pixel based co-ordinate system with its origin at the top
# left corner. PDF's co-ordinate system is based on pts and has its
# origin in the bottom left corner. We also have to implement the page
# margins. Therefore, we need to translate, scale and reflect about the
# x-axis.
dy = self.page_height - self.top_margin
dx = self.left_margin
sx = (self.page_width - self.left_margin -
self.right_margin) / self.pixel_width
sy = (self.page_height - self.top_margin -
self.bottom_margin) / self.pixel_height
self.pdf_system = QTransform(sx, 0, 0, -sy, dx, dy)
self.graphics = Graphics(self.pixel_width, self.pixel_height)
self.errors_occurred = False
self.errors, self.debug = errors, debug
self.fonts = {}
self.current_page_num = 1
self.current_page_inited = False
self.content_written_to_current_page = False
self.qt_hack, err = plugins['qt_hack']
self.has_footers = opts is not None and (opts.pdf_page_numbers or opts.pdf_footer_template is not None)
self.has_headers = opts is not None and opts.pdf_header_template is not None
self.header_height = (opts.margin_top or 0) if opts else 0
self.footer_height = (opts.margin_bottom) or 0 if opts else 0
if err:
raise RuntimeError('Failed to load qt_hack with err: %s'%err)
def apply_graphics_state(self):
self.graphics(self.pdf_system, self.painter())
def resolve_fill(self, rect):
self.graphics.resolve_fill(rect, self.pdf_system,
self.painter().transform())
@property
def do_fill(self):
return self.graphics.current_state.do_fill
@property
def do_stroke(self):
return self.graphics.current_state.do_stroke
def init_page(self):
self.content_written_to_current_page = False
self.pdf.transform(self.pdf_system)
self.pdf.apply_fill(color=(1, 1, 1)) # QPainter has a default background brush of white
self.graphics.reset()
self.pdf.save_stack()
self.current_page_inited = True
def begin(self, device):
if not hasattr(self, 'pdf'):
try:
self.pdf = PDFStream(self.file_object, (self.page_width,
self.page_height), compress=self.compress,
mark_links=self.mark_links,
debug=self.debug)
self.graphics.begin(self.pdf)
except:
self.errors(traceback.format_exc())
self.errors_occurred = True
return False
return True
def end_page(self, is_last_page=False):
if self.current_page_inited:
self.pdf.restore_stack()
drop_page = is_last_page and not self.content_written_to_current_page
self.pdf.end_page(drop_page=drop_page)
self.current_page_inited = False
self.current_page_num += 0 if drop_page else 1
return self.content_written_to_current_page
def end(self):
try:
self.end_page()
self.pdf.end()
except:
self.errors(traceback.format_exc())
self.errors_occurred = True
return False
finally:
self.pdf = self.file_object = None
return True
def type(self):
return QPaintEngine.Pdf
def add_image(self, img, cache_key):
if img.isNull():
return
return self.pdf.add_image(img, cache_key)
@store_error
def drawTiledPixmap(self, rect, pixmap, point):
self.content_written_to_current_page = 'drawTiledPixmap'
self.apply_graphics_state()
brush = QBrush(pixmap)
bl = rect.topLeft()
color, opacity, pattern, do_fill = self.graphics.convert_brush(
brush, bl-point, 1.0, self.pdf_system,
self.painter().transform())
self.pdf.save_stack()
self.pdf.apply_fill(color, pattern)
self.pdf.draw_rect(bl.x(), bl.y(), rect.width(), rect.height(),
stroke=False, fill=True)
self.pdf.restore_stack()
@store_error
def drawPixmap(self, rect, pixmap, source_rect):
self.content_written_to_current_page = 'drawPixmap'
self.apply_graphics_state()
source_rect = source_rect.toRect()
pixmap = (pixmap if source_rect == pixmap.rect() else
pixmap.copy(source_rect))
image = pixmap.toImage()
ref = self.add_image(image, pixmap.cacheKey())
if ref is not None:
self.pdf.draw_image(rect.x(), rect.y(), rect.width(),
rect.height(), ref)
@store_error
def drawImage(self, rect, image, source_rect, flags=Qt.AutoColor):
self.content_written_to_current_page = 'drawImage'
self.apply_graphics_state()
source_rect = source_rect.toRect()
image = (image if source_rect == image.rect() else
image.copy(source_rect))
ref = self.add_image(image, image.cacheKey())
if ref is not None:
self.pdf.draw_image(rect.x(), rect.y(), rect.width(),
rect.height(), ref)
@store_error
def updateState(self, state):
self.graphics.update_state(state, self.painter())
@store_error
def drawPath(self, path):
self.content_written_to_current_page = 'drawPath'
self.apply_graphics_state()
p = convert_path(path)
fill_rule = {Qt.OddEvenFill:'evenodd',
Qt.WindingFill:'winding'}[path.fillRule()]
self.pdf.draw_path(p, stroke=self.do_stroke,
fill=self.do_fill, fill_rule=fill_rule)
@store_error
def drawPoints(self, points):
self.content_written_to_current_page = 'drawPoints'
self.apply_graphics_state()
p = Path()
for point in points:
p.move_to(point.x(), point.y())
p.line_to(point.x(), point.y() + 0.001)
self.pdf.draw_path(p, stroke=self.do_stroke, fill=False)
@store_error
def drawRects(self, rects):
self.apply_graphics_state()
with self.graphics:
for rect in rects:
self.resolve_fill(rect)
bl = rect.topLeft()
if self.do_stroke or self.do_fill:
self.content_written_to_current_page = 'drawRects'
self.pdf.draw_rect(bl.x(), bl.y(), rect.width(), rect.height(),
stroke=self.do_stroke, fill=self.do_fill)
def create_sfnt(self, text_item):
get_table = partial(self.qt_hack.get_sfnt_table, text_item)
try:
ans = Font(Sfnt(get_table))
except UnsupportedFont as e:
raise UnsupportedFont('The font %s is not a valid sfnt. Error: %s'%(
text_item.font().family(), e))
glyph_map = self.qt_hack.get_glyph_map(text_item)
gm = {}
for uc, glyph_id in enumerate(glyph_map):
if glyph_id not in gm:
gm[glyph_id] = unichr(uc)
ans.full_glyph_map = gm
return ans
@store_error
def drawTextItem(self, point, text_item):
# return super(PdfEngine, self).drawTextItem(point, text_item)
self.apply_graphics_state()
gi = GlyphInfo(*self.qt_hack.get_glyphs(point, text_item))
if not gi.indices:
return
metrics = self.fonts.get(gi.name)
if metrics is None:
from calibre.utils.fonts.utils import get_all_font_names
try:
names = get_all_font_names(gi.name, True)
names = ' '.join('%s=%s'%(k, names[k]) for k in sorted(names))
except Exception:
names = 'Unknown'
self.debug('Loading font: %s' % names)
try:
self.fonts[gi.name] = metrics = self.create_sfnt(text_item)
except UnsupportedFont:
return super(PdfEngine, self).drawTextItem(point, text_item)
for glyph_id in gi.indices:
try:
metrics.glyph_map[glyph_id] = metrics.full_glyph_map[glyph_id]
except (KeyError, ValueError):
pass
glyphs = []
last_x = last_y = 0
for glyph_index, (x, y) in zip(gi.indices, gi.positions):
glyphs.append((x-last_x, last_y - y, glyph_index))
last_x, last_y = x, y
if not self.content_written_to_current_page:
dy = self.graphics.current_state.transform.dy()
ypositions = [y + dy for x, y in gi.positions]
miny = min(ypositions or (0,))
maxy = max(ypositions or (self.pixel_height,))
page_top = self.header_height if self.has_headers else 0
page_bottom = self.pixel_height - (self.footer_height if self.has_footers else 0)
if page_top <= miny <= page_bottom or page_top <= maxy <= page_bottom:
self.content_written_to_current_page = 'drawTextItem'
else:
self.debug('Text in header/footer: miny=%s maxy=%s page_top=%s page_bottom=%s'% (
miny, maxy, page_top, page_bottom))
self.pdf.draw_glyph_run([gi.stretch, 0, 0, -1, 0, 0], gi.size, metrics,
glyphs)
@store_error
def drawPolygon(self, points, mode):
self.content_written_to_current_page = 'drawPolygon'
self.apply_graphics_state()
if not points:
return
p = Path()
p.move_to(points[0].x(), points[0].y())
for point in points[1:]:
p.line_to(point.x(), point.y())
p.close()
fill_rule = {self.OddEvenMode:'evenodd',
self.WindingMode:'winding'}.get(mode, 'evenodd')
self.pdf.draw_path(p, stroke=True, fill_rule=fill_rule,
fill=(mode in (self.OddEvenMode, self.WindingMode, self.ConvexMode)))
def set_metadata(self, *args, **kwargs):
self.pdf.set_metadata(*args, **kwargs)
def add_outline(self, toc):
self.pdf.links.add_outline(toc)
def add_links(self, current_item, start_page, links, anchors):
for pos in anchors.itervalues():
pos['left'], pos['top'] = self.pdf_system.map(pos['left'], pos['top'])
for link in links:
pos = link[1]
llx = pos['left']
lly = pos['top'] + pos['height']
urx = pos['left'] + pos['width']
ury = pos['top']
llx, lly = self.pdf_system.map(llx, lly)
urx, ury = self.pdf_system.map(urx, ury)
link[1] = pos['column'] + start_page
link.append((llx, lly, urx, ury))
self.pdf.links.add(current_item, start_page, links, anchors)
def eventFilter(self, source, event):
'''Handle events for the scene.'''
if source == self.scene:
if (event.type() == QEvent.GraphicsSceneMouseMove and
event.modifiers() == Qt.AltModifier):
# Get nodes/edges
items = source.selectedItems()
# Filter to only get nodes
nodes = [item for item in items if
isinstance(item, GraphicsNode)]
# Update all edges for each selected nodes
for node in nodes:
self.updateEdgesOfNode(node)
self.nodeHasBeenMoved = True
if (self.nodeHasBeenMoved and
event.type() == QEvent.GraphicsSceneMouseRelease):
# Get nodes/edges
items = source.selectedItems()
# Filter to only get nodes
nodes = [item for item in items if
isinstance(item, GraphicsNode)]
for node in nodes:
# Update position
node.onEditPos()
# Enlarge scene if outside
if self.enlargeSceneRect(node):
self.centerOn(node)
self.nodeHasBeenMoved = False
# Left double click (mouse button)
if (event.type() == QEvent.GraphicsSceneMouseDoubleClick and
event.buttons() == Qt.LeftButton):
# Create a node if there is not an item where we double click
if not source.itemAt(event.scenePos(), QTransform()):
pos = event.scenePos()
self.controller.onCreateNode(pos.x(), pos.y())
return True
# Key press
if event.type() == QEvent.KeyPress:
if event.key() == Qt.Key_Delete:
# Get selected items (nodes/edges)
items = source.selectedItems()
for item in items:
# Remove node
if (isinstance(item, GraphicsNode) and not
item.graphicsTextNode.hasFocus()):
self.controller.onRemoveNode(item.id)
# Remove edge
elif isinstance(item, GraphicsEdge):
self.controller.onRemoveEdge(item.id)
return False
def __call__(self, canvas):
img = canvas.current_image
m = QTransform()
m.rotate(90)
return img.transformed(m, Qt.SmoothTransformation)
class PdfEngine(QPaintEngine):
FEATURES = QPaintEngine.AllFeatures & ~(
QPaintEngine.PorterDuff | QPaintEngine.PerspectiveTransform |
QPaintEngine.ObjectBoundingModeGradients |
QPaintEngine.RadialGradientFill |
QPaintEngine.ConicalGradientFill
)
def __init__(self, file_object, page_width, page_height, left_margin,
top_margin, right_margin, bottom_margin, width, height,
errors=print, debug=print, compress=True,
mark_links=False):
QPaintEngine.__init__(self, self.FEATURES)
self.file_object = file_object
self.compress, self.mark_links = compress, mark_links
self.page_height, self.page_width = page_height, page_width
self.left_margin, self.top_margin = left_margin, top_margin
self.right_margin, self.bottom_margin = right_margin, bottom_margin
self.pixel_width, self.pixel_height = width, height
# Setup a co-ordinate transform that allows us to use co-ords
# from Qt's pixel based co-ordinate system with its origin at the top
# left corner. PDF's co-ordinate system is based on pts and has its
# origin in the bottom left corner. We also have to implement the page
# margins. Therefore, we need to translate, scale and reflect about the
# x-axis.
dy = self.page_height - self.top_margin
dx = self.left_margin
sx = (self.page_width - self.left_margin -
self.right_margin) / self.pixel_width
sy = (self.page_height - self.top_margin -
self.bottom_margin) / self.pixel_height
self.pdf_system = QTransform(sx, 0, 0, -sy, dx, dy)
self.graphics = Graphics(self.pixel_width, self.pixel_height)
self.errors_occurred = False
self.errors, self.debug = errors, debug
self.fonts = {}
self.current_page_num = 1
self.current_page_inited = False
self.qt_hack, err = plugins['qt_hack']
if err:
raise RuntimeError('Failed to load qt_hack with err: %s'%err)
def apply_graphics_state(self):
self.graphics(self.pdf_system, self.painter())
def resolve_fill(self, rect):
self.graphics.resolve_fill(rect, self.pdf_system,
self.painter().transform())
@property
def do_fill(self):
return self.graphics.current_state.do_fill
@property
def do_stroke(self):
return self.graphics.current_state.do_stroke
def init_page(self):
self.pdf.transform(self.pdf_system)
self.pdf.apply_fill(color=(1, 1, 1)) # QPainter has a default background brush of white
self.graphics.reset()
self.pdf.save_stack()
self.current_page_inited = True
def begin(self, device):
if not hasattr(self, 'pdf'):
try:
self.pdf = PDFStream(self.file_object, (self.page_width,
self.page_height), compress=self.compress,
mark_links=self.mark_links,
debug=self.debug)
self.graphics.begin(self.pdf)
except:
self.errors(traceback.format_exc())
self.errors_occurred = True
return False
return True
def end_page(self):
if self.current_page_inited:
self.pdf.restore_stack()
self.pdf.end_page()
self.current_page_inited = False
self.current_page_num += 1
def end(self):
try:
self.end_page()
self.pdf.end()
except:
self.errors(traceback.format_exc())
self.errors_occurred = True
return False
finally:
self.pdf = self.file_object = None
return True
def type(self):
return QPaintEngine.Pdf
def add_image(self, img, cache_key):
if img.isNull():
return
return self.pdf.add_image(img, cache_key)
@store_error
def drawTiledPixmap(self, rect, pixmap, point):
self.apply_graphics_state()
brush = QBrush(pixmap)
bl = rect.topLeft()
color, opacity, pattern, do_fill = self.graphics.convert_brush(
brush, bl-point, 1.0, self.pdf_system,
self.painter().transform())
self.pdf.save_stack()
self.pdf.apply_fill(color, pattern)
self.pdf.draw_rect(bl.x(), bl.y(), rect.width(), rect.height(),
stroke=False, fill=True)
self.pdf.restore_stack()
@store_error
def drawPixmap(self, rect, pixmap, source_rect):
self.apply_graphics_state()
source_rect = source_rect.toRect()
pixmap = (pixmap if source_rect == pixmap.rect() else
pixmap.copy(source_rect))
image = pixmap.toImage()
ref = self.add_image(image, pixmap.cacheKey())
if ref is not None:
self.pdf.draw_image(rect.x(), rect.y(), rect.width(),
rect.height(), ref)
@store_error
def drawImage(self, rect, image, source_rect, flags=Qt.AutoColor):
self.apply_graphics_state()
source_rect = source_rect.toRect()
image = (image if source_rect == image.rect() else
image.copy(source_rect))
ref = self.add_image(image, image.cacheKey())
if ref is not None:
self.pdf.draw_image(rect.x(), rect.y(), rect.width(),
rect.height(), ref)
@store_error
def updateState(self, state):
self.graphics.update_state(state, self.painter())
@store_error
def drawPath(self, path):
self.apply_graphics_state()
p = convert_path(path)
fill_rule = {Qt.OddEvenFill:'evenodd',
Qt.WindingFill:'winding'}[path.fillRule()]
self.pdf.draw_path(p, stroke=self.do_stroke,
fill=self.do_fill, fill_rule=fill_rule)
@store_error
def drawPoints(self, points):
self.apply_graphics_state()
p = Path()
for point in points:
p.move_to(point.x(), point.y())
p.line_to(point.x(), point.y() + 0.001)
self.pdf.draw_path(p, stroke=self.do_stroke, fill=False)
@store_error
def drawRects(self, rects):
self.apply_graphics_state()
with self.graphics:
for rect in rects:
self.resolve_fill(rect)
bl = rect.topLeft()
self.pdf.draw_rect(bl.x(), bl.y(), rect.width(), rect.height(),
stroke=self.do_stroke, fill=self.do_fill)
def create_sfnt(self, text_item):
get_table = partial(self.qt_hack.get_sfnt_table, text_item)
try:
ans = Font(Sfnt(get_table))
except UnsupportedFont as e:
raise UnsupportedFont('The font %s is not a valid sfnt. Error: %s'%(
text_item.font().family(), e))
glyph_map = self.qt_hack.get_glyph_map(text_item)
gm = {}
for uc, glyph_id in enumerate(glyph_map):
if glyph_id not in gm:
gm[glyph_id] = unichr(uc)
ans.full_glyph_map = gm
return ans
@store_error
def drawTextItem(self, point, text_item):
# return super(PdfEngine, self).drawTextItem(point, text_item)
self.apply_graphics_state()
gi = GlyphInfo(*self.qt_hack.get_glyphs(point, text_item))
if not gi.indices:
return
metrics = self.fonts.get(gi.name)
if metrics is None:
from calibre.utils.fonts.utils import get_all_font_names
try:
names = get_all_font_names(gi.name, True)
names = ' '.join('%s=%s'%(k, names[k]) for k in sorted(names))
except Exception:
names = 'Unknown'
self.debug('Loading font: %s' % names)
try:
self.fonts[gi.name] = metrics = self.create_sfnt(text_item)
except UnsupportedFont:
return super(PdfEngine, self).drawTextItem(point, text_item)
for glyph_id in gi.indices:
try:
metrics.glyph_map[glyph_id] = metrics.full_glyph_map[glyph_id]
except (KeyError, ValueError):
pass
glyphs = []
last_x = last_y = 0
for glyph_index, (x, y) in zip(gi.indices, gi.positions):
glyphs.append((x-last_x, last_y - y, glyph_index))
last_x, last_y = x, y
self.pdf.draw_glyph_run([gi.stretch, 0, 0, -1, 0, 0], gi.size, metrics,
glyphs)
@store_error
def drawPolygon(self, points, mode):
self.apply_graphics_state()
if not points:
return
p = Path()
p.move_to(points[0].x(), points[0].y())
for point in points[1:]:
p.line_to(point.x(), point.y())
p.close()
fill_rule = {self.OddEvenMode:'evenodd',
self.WindingMode:'winding'}.get(mode, 'evenodd')
self.pdf.draw_path(p, stroke=True, fill_rule=fill_rule,
fill=(mode in (self.OddEvenMode, self.WindingMode, self.ConvexMode)))
def set_metadata(self, *args, **kwargs):
self.pdf.set_metadata(*args, **kwargs)
def add_outline(self, toc):
self.pdf.links.add_outline(toc)
def add_links(self, current_item, start_page, links, anchors):
for pos in anchors.itervalues():
pos['left'], pos['top'] = self.pdf_system.map(pos['left'], pos['top'])
for link in links:
pos = link[1]
llx = pos['left']
lly = pos['top'] + pos['height']
urx = pos['left'] + pos['width']
ury = pos['top']
llx, lly = self.pdf_system.map(llx, lly)
urx, ury = self.pdf_system.map(urx, ury)
link[1] = pos['column'] + start_page
link.append((llx, lly, urx, ury))
self.pdf.links.add(current_item, start_page, links, anchors)
class HMI(QtWidgets.QMainWindow, Ui_MainWindow):
signal_send_message = pyqtSignal(str)
signal_temp_select_category = pyqtSignal(str)
signal_start_timer = pyqtSignal(int)
def __init__(self,
parent=None,
ui_file=None,
loglevel=logging.INFO,
hmi_port=None,
game_port=None,
skip_userreg=False,
skip_spinanimation=False):
super(HMI, self).__init__(parent)
if not IMPORT_UI_ONTHEFLY:
self.setupUi(self)
else:
# used for on-the-fly compilation of ui xml
if ui_file is None:
raise Exception("Did not specify a .ui file")
uic.loadUi(ui_file, self)
self.logger = logs.build_logger(__name__, loglevel)
self.loglevel = loglevel
self.hmi_port = hmi_port
self.game_port = game_port
self.logger.debug("selected hmi_port=%s" % (self.hmi_port))
self.logger.debug("selected game_port=%s" % (self.game_port))
self.skip_spinanimation = skip_spinanimation
self.setWindowTitle("Wheel of Jeopardy")
self.setStyleSheet("background-color: gray;")
self.sounds = {
"Correct": QSound("Correct.wav"),
"Incorrect": QSound("Incorrect.wav"),
"Bankrupt": QSound("Bankrupt.wav"),
"Double": QSound("Double.wav")
}
self.stack = QStackedWidget()
for i in reversed(range(self.baseLayout.count())):
self.baseLayout.takeAt(0)
for i in reversed(range(self.verticalLayout.count())):
self.verticalLayout.takeAt(0)
self.verticalLayout.addWidget(self.stack)
self.setCentralWidget(self.stack)
self.mw = QVBoxLayout()
self.mw.addLayout(self.contextLayout)
self.mw.addLayout(self.bodyLayout)
self.mw.addLayout(self.controlLayout)
self.qw = QWidget()
self.qw.setLayout(self.mw)
self.mw.setStretchFactor(self.contextLayout, 1)
self.mw.setStretchFactor(self.bodyLayout, 5)
self.mw.setStretchFactor(self.controlLayout, 1)
self.stack.raise_()
self.stack.addWidget(self.qw)
self.MSG_controller = messaging.HMIMessageController(
loglevel=loglevel,
msg_controller_name="HMILogic",
listen_port=self.hmi_port,
target_port=self.game_port)
self.registration_wizard = wizard.MyWizard(
ui_file="register_user_wizard.ui", loglevel=self.loglevel)
self.stack.addWidget(self.registration_wizard)
self.logic_controller = HMILogicController(loglevel=loglevel)
self.logic_controller_thread = QThread(self)
self.buttonSpin = HoverButton(self)
self.buttonSpin.setText("Spin")
self.buttonSpin.setAlignment(Qt.AlignCenter)
self.buttonSpin.clicked.connect(self.logic_controller.askToSpin)
self.controlLayout.addWidget(self.buttonSpin)
# Pass messages received to the logic controller
self.MSG_controller.signal_recieve_message.connect(
self.logic_controller.processMessage)
# Pass responses from the logic controller into the output of the message controller
self.logic_controller.signal_send_message.connect(
self.MSG_controller.send_message)
self.signal_send_message.connect(self.MSG_controller.send_message)
# Pass requests from the logic controller to update game stats to the HMI engine
self.logic_controller.signal_update_game_stats.connect(
self.updateGameStats)
# Pass requests from the logic controller to update player stats to the HMI engine
self.logic_controller.signal_update_player_data.connect(
self.updatePlayer)
# Pass requests from the logic controller to spin the wheel to the HMI engine
self.logic_controller.signal_spin_wheel.connect(self.spinWheel)
# Pass requests from the logic controller to alter UI to indicate the name of winner
self.logic_controller.signal_display_winner.connect(self.displayWinner)
# Pass requests from the logic controller to prompt a user to select a category
self.logic_controller.signal_playerselect_category.connect(
partial(self.selectCategory, target="player"))
self.logic_controller.signal_opponentselect_category.connect(
partial(self.selectCategory, target="opponents"))
# temporarily, connect category stuff up
self.signal_temp_select_category.connect(
self.logic_controller.returnCategory)
# Pass requests form the logic controller to ask HMI to update the board
self.logic_controller.signal_update_board.connect(self.updateBoard)
# Pass requests from the logic controller to ask HMI to update the wheel
self.logic_controller.signal_update_wheel.connect(self.updateWheel)
# Pass requests from the logic controller to ask HMI to diplay a question
self.logic_controller.signal_display_question.connect(
self.displayQuestion)
# Pass requests from the logic controller to prompt the user to indicate the outcome of the question
self.logic_controller.signal_determine_correctness.connect(
self.selectOutcome)
# Pass requests from the logic controller to ask HMI to display the answer to a question
self.logic_controller.signal_display_answer.connect(self.displayAnswer)
# Pass requests from the logic controller to ask HMI to adjust various items
self.logic_controller.signal_lock_unlock.connect(self.setUIState)
self.logic_controller.moveToThread(self.logic_controller_thread)
#connect logic controller to wizard success/fail
self.logic_controller.signal_feedback_registration_fail.connect(
self.registration_wizard.pageUserEntry.
signal_validation_response_failure)
self.logic_controller.signal_feedback_registration_failmsg.connect(
self.registration_wizard.setFeedback)
self.logic_controller.signal_feedback_registration_success.connect(
self.registration_wizard.pageUserEntry.
signal_validation_response_success)
self.registration_wizard.signal_submit_players.connect(
self.logic_controller.notifyUserRegistration)
#connect sounds
self.logic_controller.signal_play_correct_sound.connect(
self.playCorrect)
self.logic_controller.signal_play_incorrect_sound.connect(
self.playIncorrect)
self.logic_controller.signal_play_bankrupt_sound.connect(
self.playBankrupt)
self.logic_controller.signal_play_double_sound.connect(self.playDouble)
self.logic_controller.signal_determine_freeturn_spend.connect(
self.determineFreeTurnSpend)
#help from https://stackoverflow.com/questions/46174073/open-a-new-window-after-finish-button-has-been-clicked-on-qwizard-pyqt5?rq=1
self.registration_wizard.button(
QtWidgets.QWizard.FinishButton).clicked.connect(
self.shiftToComboWheelBoardScore)
#self.logic_controller.signal_scene_change_to_wheel.connect(self.shiftToWheelScene)
self.logic_controller.signal_scene_change_to_main.connect(
self.shiftToComboWheelBoardScore)
self.main_scorebar = ScoreBar(self)
self.contextLayout.addWidget(self.main_scorebar)
self.round_spin_frame = RoundSpinFrame(self)
self.main_scorebar.resized.connect(self.round_spin_frame.setMaxHeight)
self.contextLayout.addWidget(self.round_spin_frame)
self.contextLayout.setStretchFactor(self.main_scorebar, 15)
self.contextLayout.setStretchFactor(self.round_spin_frame, 2)
self.use_textwheel = False
self.use_qgraphics_wheel = False
self.wheelinfo = dict()
for each in range(0, 13):
setattr(self, "label_wheel_%s" % str(each), QLabel())
getattr(self, "label_wheel_%s" % str(each)).setDisabled(True)
if self.use_qgraphics_wheel:
self.wheel_radius = 125
self.wheel_scene = WheelScene(parent=self,
radius=self.wheel_radius)
self.wheel_view = QtWidgets.QGraphicsView(parent=self)
self.wheel_view.setScene(self.wheel_scene)
self.wheel_view.setStyleSheet("background: transparent")
self.wheel_view.setSceneRect(0, 0, self.wheel_radius * 2,
self.wheel_radius * 2)
self.wheel_view.rotate((360 / 12) / 2)
self.wheel_group = self.wheel_scene.createItemGroup(
self.wheel_scene.items())
self.wheel_view.show()
self.bodyLayout.addWidget(self.wheel_view)
self.bodyLayout.setStretchFactor(self.wheel_view, 6)
else:
self.wheel_gui = WheelPhoto(self)
self.bodyLayout.addWidget(self.wheel_gui)
self.bodyLayout.setContentsMargins(0, 0, 0, 0)
self.bodyLayout.setStretchFactor(self.wheel_gui, 6)
self.selectionTitle = QLabel(self.wheel_gui)
self.selectionTitle.setText("")
self.selectionTitle.setAlignment(Qt.AlignRight)
self.selectionTitle.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.selectionTitle.move(
self.wheel_gui.frameRect().width() / 2 -
self.selectionTitle.width() * 1.5,
self.wheel_gui.geometry().height() / 2.1)
self.selectionTitle.setFixedWidth(self.wheel_gui.rect().width() /
2.5)
#self.bodyLayout.addWidget(self.tempButton)
self.arrowPointer = ArrowPointer(self)
self.bodyLayout.addWidget(self.arrowPointer)
self.bodyLayout.setStretchFactor(self.arrowPointer, 1)
self.board = Board(self)
self.bodyLayout.addWidget(self.board)
self.bodyLayout.setStretchFactor(self.board, 16)
self.buttonFreeTurnSpend = HoverButton(self)
self.buttonFreeTurnSpend.setText("Spend FreeTurn Token")
self.buttonFreeTurnSpend.setAlignment(Qt.AlignCenter)
self.buttonFreeTurnSpend.clicked.connect(self.renderSpinButton)
self.controlLayout.addWidget(self.buttonFreeTurnSpend)
self.buttonFreeTurnSpend.hide()
self.buttonFreeTurnSkip = HoverButton(self)
self.buttonFreeTurnSkip.setText("Skip")
self.buttonFreeTurnSkip.setAlignment(Qt.AlignCenter)
self.buttonFreeTurnSkip.clicked.connect(self.renderSpinButton)
self.controlLayout.addWidget(self.buttonFreeTurnSkip)
self.buttonFreeTurnSkip.hide()
self.scene_question = questionanswer.MyQuestionScene(
parent=self,
ui_file="scene_question.ui",
loglevel=self.loglevel,
)
self.scene_question.signal_reveal.connect(
self.logic_controller.notifyNeedAnswer)
self.scene_question.signal_incorrect.connect(
self.logic_controller.notifyUnsuccesfullOutcome)
self.scene_question.signal_correct.connect(
self.logic_controller.notifySuccesfullOutcome)
self.scene_question.signal_skipfreeturn.connect(
self.logic_controller.notifyFreeTurnSkip)
self.buttonFreeTurnSkip.clicked.connect(
self.logic_controller.notifyFreeTurnSkip)
self.scene_question.signal_spendfreeturn.connect(
self.logic_controller.notifyFreeTurnSpend)
self.buttonFreeTurnSpend.clicked.connect(
self.logic_controller.notifyFreeTurnSpend)
self.scene_question.show()
self.stack.addWidget(self.scene_question)
self.timer_obj = MyTimer(loglevel=self.loglevel)
self.timer_thread = QThread()
self.timer_thread.start()
self.timer_obj.moveToThread(self.timer_thread)
self.signal_start_timer.connect(self.timer_obj.count_down)
self.timer_obj.signal_update_timer.connect(
self.scene_question.updateTimer)
self.logger.debug("building connection to start timer")
self.logic_controller.signal_start_timer.connect(self.startTimer)
self.logger.debug("building connection to stop timer")
self.logic_controller.signal_stop_timer.connect(self.stopTimer)
self.logic_controller.signal_update_main_score_bar_player.connect(
self.main_scorebar.updatePlayers)
self.logic_controller.signal_retain_player_data.connect(
self.retainPlayerData)
self.logic_controller_thread.start()
self.MSG_controller.start()
self.wheel_resting_place = None
self.registration_wizard.signal_close.connect(self.close)
self.logic_controller_thread.start()
self.MSG_controller.start()
#self.main = self.takeCentralWidget()
if not skip_userreg:
self.stack.setCurrentWidget(self.registration_wizard)
#self.setCentralWidget(self.registration_wizard)
else:
self.stack.setCurrentWidget(self.qw)
#self.setCentralWidget(self.main)
@pyqtSlot()
def shiftToComboWheelBoardScore(self):
self.logger.debug("Shifting focus to combo-wheel-board-score panel")
self.stack.setCurrentWidget(self.qw)
#self.setCentralWidget(self.main)
self.setStyleSheet("background-color: gray;")
@pyqtSlot(list)
def selectCategory(self, categories, target="player"):
"""Prompt user or opponents to select a category"""
if isinstance(categories, list):
if len(categories) <= 0:
raise Exception("Category List does not include a sane value")
else:
self.cat_select = catselect.MyCatSelect(
ui_file="select_category.ui",
loglevel=self.loglevel,
categories=categories,
audience=target)
self.stack.addWidget(self.cat_select)
self.stack.setCurrentWidget(self.cat_select)
self.cat_select.signal_submit_category.connect(
self.logic_controller.returnCategory)
self.cat_select.signal_shift_scene.connect(
self.shiftToComboWheelBoardScore)
#self.main = self.takeCentralWidget()
#self.setCentralWidget(self.cat_select)
#self.cat_select.show()
@pyqtSlot()
def selectOutcome(self):
"""Prompt players to indicate whether a response was correct or incorrect"""
pass
@pyqtSlot(dict)
def displayQuestion(self, question_dict):
"""Render provided question to display"""
self.stack.setCurrentWidget(self.scene_question)
self.scene_question.set_context(self.playerData)
self.scene_question.set_category(question_dict['category'])
self.scene_question.set_value(question_dict['score'])
self.scene_question.set_question(question_dict['question'])
self.scene_question.render_controls_reveal()
#self.main = self.takeCentralWidget()
#self.setCentralWidget(self.scene_question)
self.logger.debug("shift scene to question/answer")
self.logic_controller.issueAck("displayQuestion")
@pyqtSlot(dict)
def displayAnswer(self, question_dict):
"""Render provided question to display"""
self.scene_question.set_answer(question_dict['answer'])
self.scene_question.render_controls_correct_incorrect()
@pyqtSlot(int)
def spinWheel(self, destination):
""" Make the Wheel Spin. Ensure it lands on Destination"""
if self.use_qgraphics_wheel:
i = 0
self.wheel_transform = QTransform()
self.wheel_offset = self.wheel_group.boundingRect().center()
self.wheel_transform.translate(self.wheel_offset.x(),
self.wheel_offset.y())
self.wheel_transform.setRotateCropHalve(i)
self.wheel_transform.translate(-self.wheel_offset.x(),
-self.wheel_offset.y())
self.wheel_group.setTransform(self.wheel_transform)
self.wheel_view.transform()
QtTest.QTest.qWait(50)
i += 1
else:
data = None
num_sectors = 0
if self.use_textwheel:
for each in range(0, 12):
if getattr(self, "label_wheel_" + str(each)).isEnabled():
num_sectors += 1
else:
num_sectors = 12
if self.wheel_resting_place is None:
self.wheel_resting_place = 0
last = self.wheel_resting_place
def cycle(start_number: int,
delay_ms: int,
num_switches: int,
sectors: int,
target: int = None) -> None:
number = start_number
delay_ms = delay_ms / 5
if start_number > 0:
last = start_number - 1
else:
last = sectors - 1
for each in range(number, num_switches):
each = each % sectors
# betterspin.wav from
# https://freesound.org/people/door15studio/sounds/244774/
QSound.play("betterspin.wav")
rot_angle = 360 / 12
self.wheel_gui.setRotateCropHalve(rot_angle)
self.selectionTitle.setText(
getattr(self, "label_wheel_%s" % each).text())
if self.use_textwheel:
if last is not None:
getattr(self, "label_wheel_" +
str(last)).setAlignment(Qt.AlignLeft)
getattr(self, "label_wheel_" + str(each)).setAlignment(
Qt.AlignRight)
number = each
last = each
if number == target and target is not None:
return number
QtTest.QTest.qWait(delay_ms)
return number
if self.skip_spinanimation:
if self.use_textwheel:
for each in range(0, num_sectors):
if each != int(destination):
getattr(self, "label_wheel_" +
str(each)).setAlignment(Qt.AlignLeft)
else:
getattr(self, "label_wheel_" +
str(each)).setAlignment(Qt.AlignRight)
else:
pass
else:
self.wheel_resting_place = cycle(last, 170, num_sectors * 2,
num_sectors)
self.wheel_resting_place = cycle(self.wheel_resting_place, 190,
num_sectors, num_sectors)
self.wheel_resting_place = cycle(self.wheel_resting_place, 210,
num_sectors, num_sectors)
self.wheel_resting_place = cycle(self.wheel_resting_place, 250,
num_sectors * 2, num_sectors)
self.wheel_resting_place = cycle(self.wheel_resting_place,
350,
num_sectors * 2,
num_sectors,
target=int(destination))
self.logic_controller.issueAck("spinWheel")
@pyqtSlot(str, str, str, str)
def updateGameStats(self, spinsExecuted, maxSpins, currentRound,
totalRounds):
self.logger.debug("enter updateGameStats")
self.round_spin_frame.setSpinsOccurred(spinsExecuted)
self.round_spin_frame.setSpinsMax(maxSpins)
self.round_spin_frame.setRound(currentRound)
self.round_spin_frame.setRoundTotal(totalRounds)
@pyqtSlot(str, str, str, str, str)
def updatePlayer(self, playerid, name, score, tokens, currentPlayer):
# help with font: https://stackoverflow.com/questions/34398797/bold-font-in-label-with-setbold-method
getattr(self, "player" + playerid + "Name").setText(name)
highlight_font = QtGui.QFont()
if currentPlayer == name:
highlight_font.setBold(True)
getattr(self, "player" + playerid + "Name").setFont(highlight_font)
else:
highlight_font.setBold(False)
getattr(self, "player" + playerid + "Name").setFont(highlight_font)
getattr(self, "player" + playerid + "Score").setText(score)
getattr(self, "player" + playerid + "FT").setText(tokens)
@pyqtSlot(list)
def updateWheel(self, sector_list):
for i, each in enumerate(sector_list):
sector_alias = getattr(self, "label_wheel_" + str(i))
# TODO: This breaks the rules. hmi shouldn't know anything about the protocol
if each == "bankrupt":
sector_alias.setStyleSheet(
'background-color: black; color: white')
elif each == "loseturn":
sector_alias.setStyleSheet("")
elif each == "accumulatefreeturn":
sector_alias.setStyleSheet("")
elif each == 'playerschoice':
sector_alias.setStyleSheet("")
elif each == "opponentschoice":
sector_alias.setStyleSheet("")
elif each == "doublescore":
sector_alias.setStyleSheet("")
#sector_alias.setStylesheet("background-color:#ff0000;")
sector_alias.setText(each)
num_sectors = len(sector_list)
if num_sectors != 12:
for each in range(num_sectors, 12):
getattr(self, "label_wheel_" + str(each)).setDisabled(True)
@pyqtSlot(list)
def updateBoard(self, category_list):
for xpos, each in enumerate(category_list, 1):
valid_prices = each['valid_prices']
getattr(self.board,
"label_board_col" + str(xpos) + "_row1").setText(
str(each['name']))
#self.logger.debug("category_list=%s" % (category_list))
for ypos, score in enumerate(valid_prices, 2):
#ypos == enumerate starts at 0 + (row1 is category row), so it starts at 2. therefore ypos + 2. ugly.
row_alias = getattr(
self.board,
"label_board_col" + str(xpos) + "_row" + str(ypos))
if str(score) in each['questions']:
getattr(self.board, "label_board_col" + str(xpos) +
"_row" + str(ypos)).setText(str(score))
else:
getattr(self.board, "label_board_col" + str(xpos) +
"_row" + str(ypos)).setText("")
@pyqtSlot(str)
def displayWinner(self, playername):
for i in reversed(range(self.bodyLayout.count())):
self.bodyLayout.itemAt(i).widget().hide()
self.winnerLayout = QtWidgets.QVBoxLayout()
self.winnerLayout.setObjectName("winnerLayout")
self.bodyLayout.addLayout(self.winnerLayout)
self.winnerTitle = QLabel(self)
self.winnerTitle.setAlignment(Qt.AlignCenter)
self.winnerTitle.setText("WINNER IS")
self.winnerTitle.setStyleSheet('''
font-family: Arial, Helvetica, sans-serif;
background-color: rgb(6,12,233);
font-size: 45px;
color: #FFFFFF;
font-weight: 700;
text-decoration: none;
font-style: normal;
font-variant: normal;
text-transform: uppercase;
''')
self.winnerLabel = QLabel(self)
self.winnerLabel.setAlignment(Qt.AlignCenter)
self.winnerLabel.setText(playername)
self.winnerLabel.setWordWrap(True)
self.winnerLabel.setStyleSheet('''
font-family: Arial, Helvetica, sans-serif;
background-color: rgb(6,12,233);
font-size: 120px;
color: #FFFFFF;
font-weight: 700;
text-decoration: none;
font-style: normal;
font-variant: normal;
text-transform: uppercase;
''')
self.winnerLayout.setStretchFactor(self.winnerTitle, 1)
self.winnerLayout.setStretchFactor(self.winnerLabel, 5)
self.winnerLayout.addWidget(self.winnerTitle)
self.winnerLayout.addWidget(self.winnerLabel)
for i in reversed(range(self.controlLayout.count())):
self.controlLayout.itemAt(i).widget().hide()
self.exitButton = HoverButton(self)
self.exitButton.setText("Quit")
self.exitButton.setAlignment(Qt.AlignCenter)
self.exitButton.clicked.connect(self.close)
self.controlLayout.addWidget(self.exitButton)
@pyqtSlot(dict)
def setUIState(self, state):
if not isinstance(state, dict):
raise Exception("was expecting state of type dict, received %s" %
(str(type(state))))
if "lock" in state.keys():
lock = state['lock']
for each in lock:
getattr(self, each).setDisabled(True)
if "unlock" in state.keys():
unlock = state['unlock']
for each in unlock:
getattr(self, each).setEnabled(True)
if "clear_lcd" in state.keys():
clear = state['clear_lcd']
for each in clear:
getattr(self, each).display("")
if "clear_textbox" in state.keys():
clear = state['clear_textbox']
for each in clear:
getattr(self, each).setText("")
pass
@pyqtSlot(int)
def startTimer(self, i):
self.logger.debug("Start")
self.signal_start_timer.emit(i)
@pyqtSlot()
def stopTimer(self):
self.timer_obj.stop()
@pyqtSlot()
def playSpin(self):
self.sounds["Spin"].play()
@pyqtSlot()
def playCorrect(self):
self.sounds["Correct"].play()
@pyqtSlot()
def playIncorrect(self):
self.sounds["Incorrect"].play()
@pyqtSlot()
def playBankrupt(self):
self.sounds["Bankrupt"].play()
@pyqtSlot()
def playDouble(self):
self.sounds["Double"].play()
@pyqtSlot()
def determineFreeTurnSpend(self):
self.scene_question.render_controls_freeturn()
for i in reversed(range(self.controlLayout.count())):
self.controlLayout.itemAt(i).widget().hide()
self.buttonSpin.hide()
self.buttonFreeTurnSkip.show()
self.buttonFreeTurnSpend.show()
def close(self):
self.logger.debug("closing")
self.MSG_controller.quit()
super(HMI, self).close()
@pyqtSlot(list)
def retainPlayerData(self, playerData):
self.playerData = playerData
@pyqtSlot()
def renderSpinButton(self):
for i in reversed(range(self.controlLayout.count())):
self.controlLayout.itemAt(i).widget().hide()
self.buttonSpin.show()
active_button_icon = QIcon() # Иконка для кнопки "Сформировать"
active_button_icon.addPixmap(QPixmap(main_ico), QIcon.Normal, QIcon.Off)
active_button.setIcon(active_button_icon)
active_button.setIconSize(QSize(24, 24)) # Размеры иконки
active_button.setToolTip("Сформировать случайный список песен")
active_button.setEnabled(False)
# Надпись Процесса
process_label = QLabel(window)
process_label.setGeometry(QRect(9, 158, 97, 11))
process_label.setFont(process_font)
process_label.setText("Выбор папок...")
process_label.setToolTip("Сейчас происходит: %s" % process_label.text())
# Стрелка
arrow_label = QLabel(window)
arrow = QPixmap(arrow_path)
transform = QTransform().rotate(-50)
arrow_label.setPixmap(arrow.transformed(transform, mode=1))
arrow_label.setGeometry(QRect(64, 0, 90, 70))
# Функции:
# Генерация окна сообщения:
def msg_event(number):
if number == 1: # Программа отработала 100%
QMessageBox.information(window,
"Готово",
"Песни собраны, наслаждайтесь!",
buttons=QMessageBox.Ok,
defaultButton=QMessageBox.Ok)
elif number == 2: # Недостаточно места
QMessageBox.information(
def update(self):
i = 0
#self.my_scene.clear()
for item in self.histo_items :
self.my_scene.removeItem(item)
self.histo_items = []
self.scene().setSceneRect(QRectF(0,0,self.frameSize().width(),self.frameSize().height()))
max = -1
for value in self.data.values():
if value[self.c_box.currentText()] > max:
max = value[self.c_box.currentText()]
size_text_number = QGraphicsTextItem(str(max)).boundingRect().width()+10
interval= self.parent().size().height()-self.margin['top']-self.margin['bottom']
interval = interval /len(self.data)
temp = "aaaaaaaaaaaaaaaaa"
if len(temp)> self.max_length_text:
data = temp[:self.max_length_text]+"."
else :
data = temp
self.size_text_width = QGraphicsTextItem(data).boundingRect().width()+10
#print ('width:',self.size_text_width)
horizontal_size = self.parent().size().width()- self.margin['left']- self.margin['right']-self.size_text_width- size_text_number
try:
ratio = horizontal_size/ max
except ZeroDivisionError :
ratio = 0
i = 0
for groupe,value in zip(self.data.keys(),self.data.values()) :
if self.c_box.currentText() == "warrior":
title_str = 'Nombre de Heros'
bar_all = QGraphicsRectItem(0,self.margin['top'],value['warrior']*ratio,interval*0.8)
bar_all.setPos(self.size_text_width,interval*0.2+(i*interval))
gradient = QLinearGradient(QPointF(bar_all.rect().width()/2,0),QPointF(bar_all.rect().width()/2,bar_all.rect().height()+self.margin['top']))
gradient.setColorAt(0,QColor('white'))
gradient.setColorAt(1,QColor('red'))
brush = QBrush(gradient)
#brush.setTexture(QPixmap(":/textures/"+groupe.attribs['color']))
bar_all.setBrush(brush)
self.my_scene.addItem(bar_all)
self.histo_items.append(bar_all)
bar_alive = QGraphicsRectItem(0,self.margin['top'],value['alive']*ratio,interval*0.8)
bar_alive.setPos(self.size_text_width,interval*0.2+(i*interval))
gradient = QLinearGradient(QPointF(bar_alive.rect().width()/2,0),QPointF(bar_alive.rect().width()/2,bar_alive.rect().height()+self.margin['top']))
# gradient.setStart(QPointF(0.5,0))
# gradient.setStop(QPointF(0.5,1))
gradient.setColorAt(0,QColor('white'))
gradient.setColorAt(1,QColor('green'))
brush = QBrush(gradient)
bar_alive.setBrush(brush)
self.my_scene.addItem(bar_alive)
self.histo_items.append(bar_alive)
text_nb_warriors= QGraphicsTextItem(str(value['warrior']))
text_nb_warriors.setDefaultTextColor(QColor('green'))
trans = QTransform().translate(bar_all.pos().x()+bar_all.rect().width()+10,interval*0.2+(i*interval)+self.margin['top'])
pts = trans.map(QPointF(0,0.0))
text_nb_warriors.setPos(pts.x(),pts.y())
self.my_scene.addItem(text_nb_warriors)
self.histo_items.append(text_nb_warriors)
#bar ranl
elif self.c_box.currentText()== "rank":
title_str = "Rank Moyen"
bar_rank = QGraphicsRectItem(0,self.margin['top'],value['rank']*ratio,interval*0.8)
bar_rank.setPos(self.size_text_width, interval*0.2+(i*interval))
gradient = QLinearGradient(QPointF(bar_rank.rect().width()/2,0),QPointF(bar_rank.rect().width()/2,bar_rank.rect().height()+self.margin['top']))
# gradient.setStart(QPointF(0.5,0))
# gradient.setStop(QPointF(0.5,1))
gradient.setColorAt(0,QColor('white'))
gradient.setColorAt(1,QColor('red'))
brush = QBrush(gradient)
bar_rank.setBrush(brush)
self.my_scene.addItem(bar_rank)
self.histo_items.append(bar_rank)
# value
text_rank = QGraphicsTextItem("{0:1.1f}".format(value['rank']))
text_rank.setDefaultTextColor(QColor('red'))
trans = QTransform().translate(bar_rank.pos().x()+bar_rank.rect().width()+10,interval*0.2+(i*interval)+self.margin['top'])
pts = trans.map(QPointF(0,0.0))
text_rank.setPos(pts.x(),pts.y())
self.my_scene.addItem(text_rank)
self.histo_items.append(text_rank)
else:
title_str = "Puissance"
bar_rank = QGraphicsRectItem(0,self.margin['top'],value['power']*ratio,interval*0.8)
bar_rank.setPos(self.size_text_width, interval*0.2+(i*interval))
gradient = QLinearGradient(QPointF(bar_rank.rect().width()/2,0),QPointF(bar_rank.rect().width()/2,bar_rank.rect().height()+self.margin['top']))
# gradient.setStart(QPointF(0.5,0))
# gradient.setStop(QPointF(0.5,1))
gradient.setColorAt(0,QColor('white'))
gradient.setColorAt(1,QColor('blue'))
brush = QBrush(gradient)
bar_rank.setBrush(brush)
self.my_scene.addItem(bar_rank)
self.histo_items.append(bar_rank)
# value
try :
valeur = (value['power']/max)*100
except ZeroDivisionError :
valeur = 0
text_rank = QGraphicsTextItem("{0:1.1f}".format(valeur))
text_rank.setDefaultTextColor(QColor('blue'))
trans = QTransform().translate(bar_rank.pos().x()+bar_rank.rect().width()+10,interval*0.2+(i*interval)+self.margin['top'])
pts = trans.map(QPointF(0,0.0))
text_rank.setPos(pts.x(),pts.y())
self.my_scene.addItem(text_rank)
self.histo_items.append(text_rank)
#dessin du titre
title = QGraphicsTextItem(title_str)
title.setPos(self.margin['left']+self.size_text_width+horizontal_size/2.0,self.c_box.pos().y())
self.my_scene.addItem(title)
self.histo_items.append(title)
#affichage des label colonne de gauche
if len(groupe.name)> self.max_length_text:
data = groupe.name[:self.max_length_text]+".."
else :
data = groupe.name
text = QGraphicsTextItem(data)
#text.setTextWidth(20)
trans = QTransform().translate(self.margin['left'],interval*0.2+(i*interval)+self.margin['top'])
pts = trans.map(QPointF(0,0.0))
text.setPos(pts.x(),pts.y())
self.my_scene.addItem(text)
self.histo_items.append(text)
i +=1
# self.fitInView(self.scene.sceneRect())
def __call__(self, canvas):
img = canvas.current_image
m = QTransform()
m.rotate(90)
return img.transformed(m, Qt.SmoothTransformation)
