class FaderWidget(QWidget):
def __init__(self, old_widget, new_widget):
super(FaderWidget, self).__init__(new_widget)
self.old_pixmap = QPixmap(new_widget.size())
old_widget.render(self.old_pixmap)
self.pixmap_opacity = 1.0
self.timeline = QTimeLine()
self.timeline.valueChanged.connect(self.animate)
self.timeline.finished.connect(self.close)
self.timeline.setDuration(500)
self.timeline.start()
self.resize(new_widget.size())
self.show()
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setOpacity(self.pixmap_opacity)
painter.drawPixmap(0, 0, self.old_pixmap)
painter.end()
def animate(self, value):
self.pixmap_opacity = 1.0 - value
self.repaint()
class FaderWidget(QWidget):
"""
A QWidget that allows for fading in and out on display.
"""
def __init__(self, old_widget, new_widget):
QWidget.__init__(self, new_widget)
self.old_pixmap = QPixmap(new_widget.size())
old_widget.render(self.old_pixmap)
self.pixmap_opacity = 1.0
self.timeline = QTimeLine()
self.timeline.valueChanged.connect(self.animate)
self.timeline.finished.connect(self.close)
self.timeline.setDuration(450)
self.timeline.start()
self.resize(new_widget.size())
self.show()
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setOpacity(self.pixmap_opacity)
painter.drawPixmap(0, 0, self.old_pixmap)
painter.end()
def animate(self, value):
self.pixmap_opacity = 1.0 - value
self.repaint()
class FaderWidget(QLabel):
"""Custom Placeholder Fading Widget for tabs on TabWidget."""
def __init__(self, parent):
"""Init class."""
super(FaderWidget, self).__init__(parent)
self.timeline, self.opacity, self.old_pic = QTimeLine(), 1.0, None
self.timeline.valueChanged.connect(self.animate)
self.timeline.finished.connect(self.close)
self.timeline.setDuration(750) # 500 ~ 750 Ms is Ok, Not more.
def paintEvent(self, event):
"""Overloaded paintEvent to set opacity and pic."""
painter = QPainter(self)
painter.setOpacity(self.opacity)
if self.old_pic:
painter.drawPixmap(0, 0, self.old_pic)
def animate(self, value):
"""Animation of Opacity."""
self.opacity = 1.0 - value
return self.hide() if self.opacity < 0.1 else self.repaint()
def fade(self, old_pic, old_geometry, move_to):
"""Fade from previous tab to new tab."""
if self.isVisible():
self.close()
if self.timeline.state():
self.timeline.stop()
self.setGeometry(old_geometry)
self.move(1, move_to)
self.old_pic = old_pic
self.timeline.start()
self.show()
class FaderWidget(QtWidgets.QWidget):
pixmap_opacity = 0
def __init__(self, old_widget, new_widget):
QtWidgets.QWidget.__init__(self, new_widget)
self.old_pixmap = QtGui.QPixmap(new_widget.size())
old_widget.render(self.old_pixmap)
self.pixmap_opacity = 1.0
self.timeline = QTimeLine()
self.timeline.valueChanged.connect(self.animate)
self.timeline.finished.connect(self.close)
self.timeline.setDuration(500)
self.timeline.start()
self.resize(new_widget.size())
self.show()
def paintEvent(self, event):
painter = QtGui.QPainter()
painter.begin(self)
painter.setOpacity(self.pixmap_opacity)
painter.drawPixmap(0, 0, self.old_pixmap)
painter.end()
def animate(self, value):
self.pixmap_opacity = 1.0 - value
self.repaint()
class CCountUp(QLabel):
def __init__(self, *args, **kwargs):
super(CCountUp, self).__init__(*args, **kwargs)
self.isFloat = False # 是否是小数
font = self.font() or QFont()
font.setBold(True)
self.setFont(font)
self.timeline = QTimeLine(6000, self)
self.timeline.setEasingCurve(QEasingCurve.OutExpo)
self.timeline.frameChanged.connect(self.onFrameChanged)
def pause(self):
"""暂停
"""
self.timeline.setPaused(True)
def resume(self):
"""继续
"""
self.timeline.resume()
def isPaused(self):
"""是否暂停
"""
return self.timeline.state() == QTimeLine.Paused
def reset(self):
"""重置
"""
self.timeline.stop()
self.isFloat = False # 是否是小数
self.setText('0')
def onFrameChanged(self, value):
if self.isFloat:
value = round(value / 100.0 + 0.00001, 2)
value = str(format(value, ','))
self.setText(value + '0' if value.endswith('.0') else value)
def setDuration(self, duration):
"""设置动画持续时间
:param duration:
"""
self.timeline.setDuration(duration)
def setNum(self, number):
"""设置数字
:param number: int or float
"""
if isinstance(number, int):
self.isFloat = False
self.timeline.setFrameRange(0, number)
elif isinstance(number, float):
self.isFloat = True
self.timeline.setFrameRange(0, number * 100)
self.timeline.stop()
self.setText('0')
self.timeline.start()
class Robot(RobotPart):
def __init__(self):
super(Robot, self).__init__()
self.torsoItem = RobotTorso(self)
self.headItem = RobotHead(self.torsoItem)
self.upperLeftArmItem = RobotLimb(self.torsoItem)
self.lowerLeftArmItem = RobotLimb(self.upperLeftArmItem)
self.upperRightArmItem = RobotLimb(self.torsoItem)
self.lowerRightArmItem = RobotLimb(self.upperRightArmItem)
self.upperRightLegItem = RobotLimb(self.torsoItem)
self.lowerRightLegItem = RobotLimb(self.upperRightLegItem)
self.upperLeftLegItem = RobotLimb(self.torsoItem)
self.lowerLeftLegItem = RobotLimb(self.upperLeftLegItem)
self.timeline = QTimeLine()
settings = [
# item position rotation at
# x y time 0 / 1
( self.headItem, 0, -18, 20, -20 ),
( self.upperLeftArmItem, -15, -10, 190, 180 ),
( self.lowerLeftArmItem, 30, 0, 50, 10 ),
( self.upperRightArmItem, 15, -10, 300, 310 ),
( self.lowerRightArmItem, 30, 0, 0, -70 ),
( self.upperRightLegItem, 10, 32, 40, 120 ),
( self.lowerRightLegItem, 30, 0, 10, 50 ),
( self.upperLeftLegItem, -10, 32, 150, 80 ),
( self.lowerLeftLegItem, 30, 0, 70, 10 ),
( self.torsoItem, 0, 0, 5, -20 )
]
self.animations = []
for item, pos_x, pos_y, rotation1, rotation2 in settings:
item.setPos(pos_x,pos_y)
animation = QGraphicsItemAnimation()
animation.setItem(item)
animation.setTimeLine(self.timeline)
animation.setRotationAt(0, rotation1)
animation.setRotationAt(1, rotation2)
self.animations.append(animation)
self.animations[0].setScaleAt(1, 1.1, 1.1)
self.timeline.setUpdateInterval(1000 / 25)
self.timeline.setCurveShape(QTimeLine.SineCurve)
self.timeline.setLoopCount(0)
self.timeline.setDuration(2000)
self.timeline.start()
def boundingRect(self):
return QRectF()
def paint(self, painter, option, widget=None):
pass
class Robot(RobotPart):
def __init__(self):
super(Robot, self).__init__()
self.torsoItem = RobotTorso(self)
self.headItem = RobotHead(self.torsoItem)
self.upperLeftArmItem = RobotLimb(self.torsoItem)
self.lowerLeftArmItem = RobotLimb(self.upperLeftArmItem)
self.upperRightArmItem = RobotLimb(self.torsoItem)
self.lowerRightArmItem = RobotLimb(self.upperRightArmItem)
self.upperRightLegItem = RobotLimb(self.torsoItem)
self.lowerRightLegItem = RobotLimb(self.upperRightLegItem)
self.upperLeftLegItem = RobotLimb(self.torsoItem)
self.lowerLeftLegItem = RobotLimb(self.upperLeftLegItem)
self.timeline = QTimeLine()
settings = [
# item position rotation at
# x y time 0 / 1
(self.headItem, 0, -18, 20, -20),
(self.upperLeftArmItem, -15, -10, 190, 180),
(self.lowerLeftArmItem, 30, 0, 50, 10),
(self.upperRightArmItem, 15, -10, 300, 310),
(self.lowerRightArmItem, 30, 0, 0, -70),
(self.upperRightLegItem, 10, 32, 40, 120),
(self.lowerRightLegItem, 30, 0, 10, 50),
(self.upperLeftLegItem, -10, 32, 150, 80),
(self.lowerLeftLegItem, 30, 0, 70, 10),
(self.torsoItem, 0, 0, 5, -20)
]
self.animations = []
for item, pos_x, pos_y, rotation1, rotation2 in settings:
item.setPos(pos_x, pos_y)
animation = QGraphicsItemAnimation()
animation.setItem(item)
animation.setTimeLine(self.timeline)
animation.setRotationAt(0, rotation1)
animation.setRotationAt(1, rotation2)
self.animations.append(animation)
self.animations[0].setScaleAt(1, 1.1, 1.1)
self.timeline.setUpdateInterval(1000 / 25)
self.timeline.setCurveShape(QTimeLine.SineCurve)
self.timeline.setLoopCount(0)
self.timeline.setDuration(2000)
self.timeline.start()
def boundingRect(self):
return QRectF()
def paint(self, painter, option, widget=None):
pass
class TimedProgressBar(QProgressBar):
"""A QProgressBar showing a certain time elapse."""
hideOnTimeout = True
def __init__(self, parent=None):
super(TimedProgressBar, self).__init__(parent, minimum=0, maximum=100)
self._timeline = QTimeLine(updateInterval=100,
frameChanged=self.setValue)
self._timeline.setFrameRange(0, 100)
self._hideTimer = QTimer(timeout=self._done,
singleShot=True,
interval=3000)
def start(self, total, elapsed=0.0):
"""Starts showing progress.
total is the number of seconds (maybe float) the timeline will last,
elapsed (defaulting to 0) is the value to start with.
"""
self._hideTimer.stop()
self._timeline.stop()
self._timeline.setDuration(total * 1000)
self._timeline.setCurrentTime(elapsed * 1000)
self.setValue(self._timeline.currentFrame())
self._timeline.resume()
if self.hideOnTimeout:
self.show()
def stop(self, showFinished=True):
"""Ends the progress display.
If showFinished is True (the default), 100% is shown for a few
seconds and then the progress is reset.
The progressbar is hidden if the hideOnTimeout attribute is True.
"""
self._hideTimer.stop()
self._timeline.stop()
if showFinished:
self.setValue(100)
self._hideTimer.start()
else:
self._done()
def _done(self):
if self.hideOnTimeout:
self.hide()
self.reset()
class TimedProgressBar(QProgressBar):
"""A QProgressBar showing a certain time elapse."""
hideOnTimeout = True
def __init__(self, parent=None):
super(TimedProgressBar, self).__init__(parent, minimum=0, maximum=100)
self._timeline = QTimeLine(updateInterval=100, frameChanged=self.setValue)
self._timeline.setFrameRange(0, 100)
self._hideTimer = QTimer(timeout=self._done, singleShot=True, interval=3000)
def start(self, total, elapsed=0.0):
"""Starts showing progress.
total is the number of seconds (maybe float) the timeline will last,
elapsed (defaulting to 0) is the value to start with.
"""
self._hideTimer.stop()
self._timeline.stop()
self._timeline.setDuration(total * 1000)
self._timeline.setCurrentTime(elapsed * 1000)
self.setValue(self._timeline.currentFrame())
self._timeline.resume()
if self.hideOnTimeout:
self.show()
def stop(self, showFinished=True):
"""Ends the progress display.
If showFinished is True (the default), 100% is shown for a few
seconds and then the progress is reset.
The progressbar is hidden if the hideOnTimeout attribute is True.
"""
self._hideTimer.stop()
self._timeline.stop()
if showFinished:
self.setValue(100)
self._hideTimer.start()
else:
self._done()
def _done(self):
if self.hideOnTimeout:
self.hide()
self.reset()
class MainWindow(QMainWindow):
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.setWindowTitle("Screen and Gaze Capture")
grid = QGridLayout()
layout_frame = QFrame()
layout_frame.setLayout(grid)
self.setCentralWidget(layout_frame)
self.tracker_label = QLabel("No eye tracker connected.")
grid.addWidget(self.tracker_label, 0, 0)
connect_button = QPushButton("Connect to Eye Tracker")
connect_button.pressed.connect(connect_to_tracker)
grid.addWidget(connect_button, 1, 0)
calibrate_button = QPushButton("Calibrate Eye Tracker")
calibrate_button.pressed.connect(calibrate)
grid.addWidget(calibrate_button, 2, 0)
self.record_button = QPushButton("Record Screen and Gaze")
self.record_button.pressed.connect(capture_screen)
grid.addWidget(self.record_button, 3, 0)
self.author_vid_button = QPushButton("Write Author Video")
self.author_vid_button.pressed.connect(create_video)
grid.addWidget(self.author_vid_button, 4, 0)
self.author_vid_button.setEnabled(False)
self.timeline = QTimeLine()
self.timeline.setCurveShape(QTimeLine.LinearCurve)
self.timeline.setDuration(360000) #Totsl video lengthn in milliseconds
self.timeline.setFrameRange(
0, 7500) #Maximum Frames in this video as 30 fps
self.timeline.frameChanged.connect(update_frame)
self.timeline.setUpdateInterval(10) #Rate of Frame Capture
def keyPressEvent(self, event):
if event.key() == Qt.Key_Escape:
app.closeAllWindows()
class SideSlideDecorator(QWidget):
m_slidePos: QPoint
m_slideWidgetPixmap: QPixmap
m_timeline: QTimeLine
m_backgroundPixmap: QPixmap
m_decorationColor: QColor
clicked = pyqtSignal()
def __init__(self, *args, **kwargs):
super(SideSlideDecorator, self).__init__(*args, **kwargs)
self.resize(self.maximumSize())
self.m_backgroundPixmap = QPixmap()
self.m_slidePos = QPoint()
self.m_timeline = QTimeLine()
self.m_timeline.setDuration(260)
self.m_timeline.setUpdateInterval(40)
self.m_timeline.setEasingCurve(QEasingCurve.OutQuad)
self.m_timeline.setStartFrame(0)
self.m_timeline.setEndFrame(10000)
self.m_decorationColor = QColor(0, 0, 0, 0)
def frameChanged(_value):
self.m_decorationColor = QColor(0, 0, 0, _value / 100)
self.update()
self.m_timeline.frameChanged.connect(frameChanged)
def grabSlideWidget(self, _slideWidget):
self.m_slideWidgetPixmap = _slideWidget.grab()
def grabParent(self):
# self.m_backgroundPixmap = self.parentWidget().grab()
pass
def decorate(self, _dark):
if self.m_timeline.state() == QTimeLine.Running:
self.m_timeline.stop()
self.m_timeline.setDirection(
QTimeLine.Forward if _dark else QTimeLine.Backward)
self.m_timeline.start()
def slidePos(self):
return self.m_slidePos
def setSlidePos(self, _pos):
if self.m_slidePos != _pos:
self.m_slidePos = _pos
self.update()
def paintEvent(self, _event):
painter = QPainter(self)
painter.drawPixmap(0, 0, self.m_backgroundPixmap)
painter.fillRect(self.rect(), self.m_decorationColor)
painter.drawPixmap(self.m_slidePos, self.m_slideWidgetPixmap)
super(SideSlideDecorator, self).paintEvent(_event)
def mousePressEvent(self, _event):
self.clicked.emit()
super(SideSlideDecorator, self).mousePressEvent(_event)
_slidePos = pyqtProperty(QPoint, fget=slidePos, fset=setSlidePos)
class QTreeWidget(CoreQTreeWidget):
def __init__(self, tableWidget, icons, showHidden):
super(QTreeWidget, self).__init__(tableWidget, icons, showHidden)
self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.setAcceptDrops(True)
self.dragModSoon = False # dragMod just starts after 0.1 sec
self.started = 0 # to take the time of dragModSoon
self.dragSource = None
self.dragMod = False
self.copyDrag = False
self.lastp = QtCore.QPoint(0, 0) # Last position of the dragged item
# USED FOR PREVIEW #
# idx of a temporary moved/inserted item (not Voiditem)
self.callback = None
# Used for the drag and drop preview
self.stillInItem = None
self.voididxlist = []
# SIZES(some handeld automatically) #
self.circleSize = 1.5/2. # Scaling factor for the nodes
self.rw = 0
self.rh = 0
self.minr = 0
# ANIMATION HELP #
self.lineList_old = []
self.lineList_new = []
self.nodeCopy = [] # dictionarys filled with information
self.old_opacity = 1
self.timeline = None
self.animationDuration = 200
self.needUpdate = False
def getItemList(self):
"""Returns a list of the items (Depth-first search [preordering])"""
itemlist = []
self.rekursivHelp(self.topLevelItem(0), itemlist)
return itemlist
def rekursivHelp(self, item, list):
"""Recursive help for the getItemList method"""
list.append(item)
for i in range(item.childCount()):
self.rekursivHelp(item.child(i), list)
def tableChanged(self):
super(QTreeWidget, self).tableChanged()
self.needUpdate = True
def paintEvent(self, event):
"""Painting the view, if there is a root item"""
if self.itemAt(0, 0) is None:
return
painter = QPainter(self.viewport())
self.makeImage(painter)
# drawing the dragged item
if (self.dragMod and self.dragSource == self.source and
self.currentItem() is not None):
pos = self.lastp - QtCore.QPoint(self.minr/4, self.minr/4)
self.paintItem(self.currentItem(), pos,
painter, self.xml)
if self.timeline is None:
# paintItem saves the drawn node. But the dragged Node is not
# fixed thats why I remove it again.
del self.nodeCopy[-1]
painter.end()
def makeImage(self, painter):
"""
This method draws the image to a given painter.
The algorithm works like this:
- Find out how the items have to be placed, relativly
- Take the relativ height and width of the tree
- Now, set the position with absolute values
- Save the lines
- Check if some transitions have to be made:
- if there is no transition required at the moment
- and the lines changed or needUpdate flag is set
For the tranistion take a look at the methods
'animate' and 'animationEnd'.
"""
painter.setRenderHint(QPainter.TextAntialiasing, True)
painter.setRenderHint(QPainter.Antialiasing, True)
itemList = self.getItemList()
wDSF = 1 # width Dependend Scaling Factor
hDSF = 1 # height Dependend Scaling Factor
width = self.width()
height = self.height()
# The depth of the Tree
maxlevel = 4
# Max width in a Tree level
maxlevelwidth = 1
# Setting up maxlevel & item.level values
for item in itemList:
item.pos = QtCore.QPoint(0, 0)
if item.parent() is not None:
if item.getType() not in ['PULSE']:
item.level = item.parent().level+1
if item.level > maxlevel:
maxlevel = item.level
# List of the width in a tree level
levelwidth = [0] * len(itemList)
for item in itemList:
if item.parent() is not None:
# This way, we dont write a node over the child of another node
for j in range(item.level, len(levelwidth)):
if levelwidth[item.level] < levelwidth[j]:
levelwidth[item.level] = levelwidth[j]
# Setting up the Item position
item.pos = QtCore.QPoint(levelwidth[item.level], item.level)
# A child cant be on the left side of a parent node
if item.pos.x() < item.parent().pos.x():
item.pos = QtCore.QPoint(item.parent().pos.x(),
item.pos.y())
levelwidth[item.level] = item.pos.x()
# PULSE nodes don't grow to the side
if item.getType() not in ['PULSE']:
levelwidth[item.level] += 1
# To handle multiply PULSE nodes, we take their parent node
if item.getType() in ['ATOMICSEQUENCE']:
if item.childCount() != 0:
# Multiple PULSE nodes takes 1 width in a tree level
levelwidth[item.level+1] += 1
# Multiple PULES nodes increasing the tree depth
if (item.level + item.childCount()) > maxlevel:
maxlevel = (item.level + item.childCount())
# Getting the maxlevelwidth
maxlevelwidth = max(levelwidth)
if maxlevelwidth == 0:
maxlevelwidth = 1
self.rw = width/(maxlevelwidth) * wDSF
self.rh = height/(maxlevel+1) * hDSF # +1 is needed, to make it fit
self.minr = self.rw if self.rw < self.rh else self.rh
# ------------------------------------------------------------------- #
# Positioning #
# ------------------------------------------------------------------- #
for item in itemList:
if item.getType() not in ['PULSE']:
qpoint = QtCore.QPoint(self.minr/6 + 3, 3)
item.pos = QtCore.QPoint(item.pos.x()*self.rw,
item.pos.y()*self.rh) + qpoint
if item.getType() in ['ATOMICSEQUENCE']:
for i in range(item.childCount()):
child = item.child(i)
child.pos = QtCore.QPoint(
item.pos.x(), item.pos.y() +
(i+1)*self.minr*self.circleSize)
# ------------------------------------------------------------------- #
# Save Lines #
# ------------------------------------------------------------------- #
painter.linePainter(item)
self.lineList_new = [[]]
for item in itemList:
# No lines between ATOMIC... and PULSE
if item.getType() not in ['ATOMICSEQUENCE', 'COILARRAY']:
for i in range(item.childCount()):
if not item.child(i).visible:
continue
self.lineList_new += [[
item.pos +
QtCore.QPoint(self.minr*self.circleSize/2,
self.minr*self.circleSize/2),
item.child(i).pos +
QtCore.QPoint(self.minr*self.circleSize/2,
self.minr*self.circleSize/2)]]
# ------------------------------------------------------------------- #
# possible Animation start #
# ------------------------------------------------------------------- #
if (self.timeline is None and
(self.lineList_new[:] != self.lineList_old[:] or
self.needUpdate)):
self.needUpdate = False
self.timeline = QTimeLine()
self.timeline.valueChanged.connect(self.animate)
self.timeline.finished.connect(self.animationEnd)
self.timeline.setDuration(self.animationDuration)
self.timeline.start()
# ------------------------------------------------------------------- #
# Drawing Lines #
# ------------------------------------------------------------------- #
painter.setOpacity(self.old_opacity)
for line in self.lineList_old:
if line != []:
painter.drawLine(line[0], line[1])
if self.old_opacity != 1: # with Animation
painter.setOpacity(1-self.old_opacity)
for line in self.lineList_new:
if line != []:
painter.drawLine(line[0], line[1])
# ------------------------------------------------------------------- #
# Drawing Nodes #
# ------------------------------------------------------------------- #
painter.setOpacity(1)
if self.timeline is None: # without Animation
if len(self.nodeCopy) == 0:
tmp = copy.deepcopy(self.xml)
for item in itemList: # drawing and saving new nodes
if item is not None and item.visible:
self.paintItem(item, item.pos, painter, tmp)
else:
for cp in self.nodeCopy: # using old nodes for drawing
self.paintItem2(cp, painter)
else: # with Animation
painter.setOpacity(self.old_opacity)
for cp in self.nodeCopy:
self.paintItem2(cp, painter)
painter.setOpacity(1-self.old_opacity)
for item in itemList:
if item is not None and item.visible:
self.paintItem(item, item.pos, painter, self.xml)
def animationEnd(self):
"""
AnimationEnd cleans up the animation. Called by QTimeLine.
"""
self.lineList_old = self.lineList_new
self.lineList_new = None
self.old_opacity = 1.0
self.nodeCopy = [] # removing old nodes
self.timeline = None
self.updateImage()
def animate(self, value):
"""
Animate makes a little change for the tranistion. Called by QTimeLine.
"""
self.old_opacity = 1.0 - value
self.updateImage()
def calcVoidItems(self):
"""
This method creates the Voiditems for the preview.
"""
if not self.dragMod:
return
# ------------------------------------------------------------------- #
# Calculating VoidItems indexes #
# ------------------------------------------------------------------- #
self.voididxlist = []
for item in self.getItemList():
if item.getType() not in ['PULSE']:
idx = item.idx() + [item.childCount()]
if self.checkVoidItem(idx):
self.voididxlist += [idx]
dragIndex = None
if self.currentItem() is not None: # saving the current item idx
dragIndex = self.currentItem().idx()
# ------------------------------------------------------------------- #
# Creation of Voiditems #
# ------------------------------------------------------------------- #
for voididx in self.voididxlist:
if self.dragSource == self.source: # not using button drag
if self.callback is not None: # item not moved/copyd
self.setCurrentItem(self.getItem(self.callback))
#
self.itemCopy.emit()
self.itemMoved.emit(self.callback, voididx)
else: # item moved/copyd
if voididx is self.voididxlist[0]:
dragIndex[-1] += 1
self.itemCopy.emit()
self.itemMoved.emit(dragIndex, voididx)
dragIndex[-1] -= 1
self.setCurrentItem(self.getItem(dragIndex))
else:
self.setCurrentItem(self.getItem(self.voididxlist[0]))
self.itemCopy.emit()
self.itemMoved.emit(self.voididxlist[0], voididx)
else: # using button drag
if self.callback is None: # item not inserted
if voididx is self.voididxlist[0]:
self.insertItem(voididx)
else:
self.setCurrentItem(self.getItem(self.voididxlist[0]))
self.itemCopy.emit()
self.itemMoved.emit(self.voididxlist[0], voididx)
else: # item already inserted
self.setCurrentItem(self.getItem(self.callback))
self.itemCopy.emit()
self.itemMoved.emit(self.callback, voididx)
if dragIndex is not None: # setting the current item back
self.setCurrentItem(self.getItem(dragIndex))
self.markVoidItems() # finishing void items
def checkVoidItem(self, idx):
"""
Checks, if an idx can be taken for a new VoidItem. First some special
cases are caught and then the standard checkDrop function is used.
"""
if self.callback is not None:
if len(idx) == len(self.callback):
numb = len(self.callback)-1
if (idx[0:numb] == self.callback[0:numb] and
idx[numb] >= self.callback[numb]):
return False
else:
if len(idx) >= len(self.callback):
numb = len(self.callback)
if idx[0:numb] == self.callback[0:numb]:
return False
return self.checkDrop(idx)
def setBranchVoid(self, root, isVoid):
"""
This Method sets the isVoid flag of a hole branch to the given
boolean value in 'isVoid'.
"""
change = [root]
for node in change:
node.isVoid = isVoid
for i in range(node.childCount()):
change += [node.child(i)]
def checkDrop(self, dropidx):
"""
This Methods checks, if a (copy)move/insertion of an item is
legal.
"""
dropIndex = dropidx[:]
tmp = copy.deepcopy(self.xml)
if self.dragSource == self.source:
dragIndex = self.currentItem().idx()
if self.copyDrag:
tmp.copy(dragIndex)
dragIndex[-1] += 1
else:
if len(dropIndex) >= len(dragIndex):
numb = len(dragIndex)
if dragIndex[0:numb] <= dropIndex[0:numb]:
if dropIndex[0:numb] == dragIndex[0:numb]:
return False
dropIndex[numb-1] -= 1
try:
tmp._move(dragIndex, dropIndex)
status, msg = tmp.checkCommand(dropIndex)
if msg is not None:
return False
# exception caused, when tmp.checkCommand wont return 2 values
except:
return False
else:
tag = self.dragSource.text()
idx = dropIndex[0:-1]
if len(idx) == 0:
return False
tmp = copy.deepcopy(self.xml)
msg = tmp._insert(idx, tag)
if msg is not None:
return False
return True
def deleteVoidItems(self):
"""
Removs all Items, which are VoidItems.
"""
savedidx = None
if self.currentItem() is not None:
savedidx = self.currentItem().idx()
for idx in self.voididxlist:
self.setCurrentItem(self.getItem(idx))
self.treeItemDelete()
if savedidx is not None:
self.setCurrentItem(self.getItem(savedidx))
self.voididxlist = []
def paintItem(self, item, pos, painter, xml):
"""
This method is a preparation for the item painting in 'paintItem2'.
The infomation, which is required to draw an item, is saved if
needed (for the animation).
"""
informlist = {
"pos": pos, "text": item.getName(),
"backgroundColor": item.background(0).color(),
"isVoid": item.isVoid,
"type": item.getType(),
"iscurrent": item is self.currentItem(),
"idx": item.idx(),
"xml": xml,
"textcolor": item.foreground(0).color(),
"font": item.font(0),
"minr": self.minr}
if self.timeline is None:
self.nodeCopy.append(informlist)
self.paintItem2(informlist, painter)
def paintItem2(self, itemInfos, painter):
"""
In this method, the items are painted. The attribute 'iteminfos'
should contain a dictionary with the needed informtion.
"""
minSizeForPulsPic = 25
sIC = QtGui.QColor(0, 150, 200) # selected item color
sICBW = 2 # selected item color border width
minr = itemInfos["minr"]
# ------------------------------------------------------------------- #
# Draw Form #
# ------------------------------------------------------------------- #
# drawshape = needed shape
# rect = Postion + size of the shape
if itemInfos["type"] in ['PULSE', 'COIL']:
rect = QtCore.QRect(itemInfos["pos"].x()-minr/6,
itemInfos["pos"].y(),
minr*self.circleSize + self.minr/3,
minr*self.circleSize)
drawshape = painter.drawRect
else:
rect = QtCore.QRect(itemInfos["pos"].x(), itemInfos["pos"].y(),
minr*self.circleSize,
minr*self.circleSize)
drawshape = painter.drawEllipse
# shape color
colorB = itemInfos["backgroundColor"]
if self.callback is not None:
if ((self.dragSource == self.source and
itemInfos["idx"] == self.callback and
not itemInfos["iscurrent"]) or
(self.dragSource != self.source and
itemInfos["iscurrent"])):
colorB = QtGui.QColor(220, 220, 220)
# alphaf(1) to overdraw the lines, which connects the nodes
# TODO:
colorB.setAlphaF(1)
if itemInfos["iscurrent"]: # draw a blue border for the currentItem
painter.setBrush(sIC)
drawshape(QtCore.QRect(rect.x() - sICBW,
rect.y() - sICBW,
rect.width() + 2*sICBW,
rect.height() + 2*sICBW))
if itemInfos["isVoid"]: # VoidItems are drawn with orange
colorB = QtGui.QColor('orange')
painter.formPainter(rect, None, colorB, itemtype=itemInfos["type"])
else:
painter.formPainter(rect, None, colorB, itemtype=itemInfos["type"])
drawshape(rect) # Drawing the shape
# ------------------------------------------------------------------- #
# Draw Icon #
# ------------------------------------------------------------------- #
painter.iconPainter()
icon = None
if minr >= minSizeForPulsPic:
xitem = itemInfos["xml"].read(itemInfos["idx"])
if xitem.get('type') in ['PULSE', 'COIL']:
icon = self.icons[xitem.tag]
painter.drawPixmap(
itemInfos["pos"] + QtCore.QPoint(0, minr * 1/7),
icon, QtCore.QRect(0, 0, icon.width(), icon.height()))
# ------------------------------------------------------------------- #
# Draw Text #
# ------------------------------------------------------------------- #
painter.textPainter(textColor=itemInfos["textcolor"],
font=itemInfos["font"])
if icon is not None:
painter.drawText(itemInfos["pos"] + QtCore.QPoint(
icon.width(), icon.height() + minr*1/7), itemInfos["text"])
else:
painter.drawText(QtCore.QRectF(rect), QtCore.Qt.AlignCenter,
itemInfos["text"])
def pointInItem(self, p, item):
"""
Checks if a point is in the shape of an Item. This is used to
detect, if a user clicks or hovers over an item (possible drop
action).
"""
m = self.minr
if item.getType() in ['PULSE']: # Checks if p is in a Rectangle
return (p.x() > item.pos.x()-m/6 and
p.y() > item.pos.y() and
p.x() < item.pos.x()-m/6-2+m*self.circleSize+m/3 and
p.y() < item.pos.y()+m*self.circleSize)
else: # Checks if p is in a Circle
return (math.sqrt((p.x()-item.pos.x()-m*self.circleSize/2)**2 +
(p.y()-item.pos.y()-m*self.circleSize/2)**2) <
m*self.circleSize/2)
def mousePressEvent(self, e):
self.lastp = e.pos()
for item in self.getItemList():
if self.pointInItem(self.lastp, item):
self.setCurrentItem(item)
self.treeItemClicked()
self.dragModSoon = True
self.started = time.time()
self.nodeCopy = []
self.updateImage()
break
def mouseReleaseEvent(self, e):
self.lastp = e.pos()
if self.dragMod:
dropevent = QtGui.QDropEvent(e.pos(), QtCore.Qt.DropAction(),
QtCore.QMimeData(),
QtCore.Qt.MouseButton(),
QtCore.Qt.KeyboardModifiers(),
QtCore.QEvent.Drop)
dropevent.source = self.source
if self.callback is not None and self.callback in self.voididxlist:
self.voididxlist.remove(self.callback)
self.deleteVoidItems()
if self.callback is not None:
if self.dragSource == self.source and not self.copyDrag:
self.treeItemDelete()
self.callback = None
self.dragMod = False
self.needUpdate = True
self.updateImage()
self.dragModSoon = False
def mouseMoveEvent(self, event):
e = QtGui.QMouseEvent(event)
self.lastp = e.pos()
if self.dragModSoon and not self.dragMod:
if time.time() - self.started > 0.1:
self.dragMod = True
self.dragSource = self.source
self.calcVoidItems()
if self.dragMod:
self.previewManager(event)
self.updateImage()
def stillInItemFunc(self, p):
"""
This Method detects, if the cursor is still hovering over the
shape, which causes a change. By making a move/copy/insert preview,
it is possible, that the new shapes don't matches the cursor
position, so that a preview would be volatile without this method.
"""
m = self.stillInItem[2]
itempos = self.stillInItem[1]
if self.stillInItem[0] in ['PULSE']: # p in Rectangle
return (p.x() > itempos.x()-m/6 and
p.y() > itempos.y() and
p.x() < itempos.x()-m/6-2+m*self.circleSize+m/3 and
p.y() < itempos.y()+m*self.circleSize)
else: # p in Circle
return (math.sqrt((p.x()-itempos.x()-m*self.circleSize/2)**2 +
(p.y()-itempos.y()-m*self.circleSize/2)**2) <
m*self.circleSize/2)
def setBranchVisible(self, item, visible):
"""
Changes the visibility of a complete branch. The given item should be
the root of the branch. This method is used in the move preview
(without copy).
"""
change = [item]
for node in change:
node.visible = visible
for i in range(node.childCount()):
change += [node.child(i)]
def previewManager(self, event):
"""
This method decides, if a (copy)move/insert preview has to be done.
It can also delete a preview, if the dragged item is not over a shape
anymore.
"""
# Limiting the the calls of this method
if time.time() - self.started > 0.1:
self.started = time.time()
dropIndex = self.calcDropIndex(event.pos())
if dropIndex is not None: # Cursor over shape
if self.callback is None: # There is no preview
self.makePreview(event, dropIndex) # make move/copy/insert
elif (self.callback is not None and
not self.stillInItemFunc(event.pos())):
self.deletePreview() # undo move/copy/insert
self.stillInItem = None
def deletePreview(self):
"""
This method deletes a preview, that is caused by dragging an item over
another item.
"""
self.deleteVoidItems()
if self.dragSource == self.source: # not caused by a button drag
item = self.getItem(self.callback)
self.setCurrentItem(item)
self.treeItemDelete()
self.callback = None
self.setCurrentItem(self.getItem(self.copyhelp))
if not self.copyDrag:
self.currentItem().visible = True
else: # caused by a button drag
self.setCurrentItem(self.getItem(self.callback))
self.treeItemDelete()
self.callback = None
self.calcVoidItems()
self.needUpdate = True
def makePreview(self, event, dropIndex):
"""
Checks and creates a new (copy)move/insert preview.
"""
if not self.checkDrop(dropIndex): # We can't drop the Item here
return
if self.dragSource == self.source: # not caused by a button
self.makePreviewCopyDrag(event, dropIndex) # (copy)move
else: # caused by a button
self.makePreviewInsert(event, dropIndex) # insert
self.needUpdate = True # repainting the image of the widget
def makePreviewCopyDrag(self, event, dropIndex):
"""
This Method creates a preview of a (copy)move action.
"""
self.deleteVoidItems()
dragIndex = self.currentItem().idx()
self.callback = dropIndex
event.source = self.source
self.copydropEvent(event, dropIndex)
self.copyhelp = dragIndex[:]
if len(dragIndex) >= len(dropIndex):
numb = len(dropIndex)-1
if (dropIndex[0:numb] == dragIndex[0:numb] and
dropIndex[numb] <= dragIndex[numb]):
dragIndex[numb] += 1
self.setCurrentItem(self.getItem(dragIndex))
self.calcVoidItems()
if not self.copyDrag:
self.setBranchVisible(self.currentItem(), False)
self.paintactivated = True
def makePreviewInsert(self, event, dropIndex):
"""
This method creates a preview of a button drag action.
"""
if dropIndex == [0]: # you can't drop anything on the root item
return
self.deleteVoidItems()
self.insertItem(dropIndex)
new = self.getItem(dropIndex)
self.setCurrentItem(new)
self.callback = dropIndex
self.calcVoidItems()
def insertItem(self, dropIndex):
"""
Insert an item as a consequence of a button action.
"""
idx = dropIndex[0:-1]
prep = self.getItem(idx)
self.setCurrentItem(prep)
idx += [prep.childCount()]
self.dragSource.sendInsertSignal()
self.itemMoved.emit(idx, dropIndex)
# self.emit(QtCore.SIGNAL('itemMoved'), idx, dropIndex)
def markVoidItems(self, dropIndex=None):
"""
This method marks all VoidItems, which are children of a VoidItem.
"""
for voididx in self.voididxlist:
if dropIndex is not None and len(voididx) >= len(dropIndex):
numb = len(dropIndex)
if (dropIndex[0:numb] <= voididx[0:numb]):
voididx[numb-1] += 1
self.setBranchVoid(self.getItem(voididx), True)
voididx[numb-1] -= 1
else:
self.setBranchVoid(self.getItem(voididx), True)
def getItem(self, idx):
"""
Returns the item at a given item index.
"""
for item in self.getItemList():
if item.idx() == idx:
return item
def source(self):
# just for creating the dropevent
return self
def updateImage(self):
# forcing this widget to create a paintEvent
self.viewport().repaint()
def calcDropIndex(self, pos):
"""
This methods finds out, if a dragged item is hovering over another
item.
"""
idx = None
for item in self.getItemList():
if self.pointInItem(pos, item):
searched = item
idx = searched.idx()
if searched.isVoid:
for voididx in self.voididxlist:
if len(idx) >= len(voididx):
numb = len(voididx)
if idx[0:numb] == voididx[0:numb]:
idx = voididx
self.stillInItem = [searched.getType(),
searched.pos, self.minr]
break
return idx
def copydropEvent(self, event, dropIndex=None):
"""
Make a copy of an Item and then move it to the given dropIndex.
"""
if event.source() == self:
dragIndex = self.currentItem().idx()
if dropIndex is None:
dropIndex = self.calcDropIndex(event.pos())
if dropIndex is None:
return
tmp = copy.deepcopy(self.xml)
tmp.copy(dragIndex)
dragIndex[-1] += 1
tmp._move(dragIndex, dropIndex)
status, msg = tmp.checkCommand(dropIndex)
if status:
self.itemCopy.emit()
self.itemMoved.emit(dragIndex, dropIndex)
def dragEnterEvent(self, e): # button drag is over the widget
e.accept()
self.dragSource = e.source()
self.dragMod = True
self.calcVoidItems()
self.paintactivated = True
self.updateImage()
def dragLeaveEvent(self, e): # button drag leaves the widget
self.deleteVoidItems()
self.dragMod = False
self.dragSource = None
self.paintactivated = True
self.updateImage()
def dragMoveEvent(self, e):
"""
This method gets called, when the button drag function is used.
"""
self.previewManager(e)
def dropEvent(self, event):
if event.source() == self: # not a button
item = self.currentItem()
dragIndex = item.idx()
dropIndex = self.calcDropIndex(event.pos())
if dropIndex is None:
return
self.itemMoved.emit(dragIndex, dropIndex)
else: # a button
if self.callback is None:
for item in self.getItemList():
if self.pointInItem(event.pos(), item):
self.setCurrentItem(item)
self.treeItemInsert()
break
self.callback = None
self.dragMod = False
self.deleteVoidItems()
self.paintactivated = True
self.dragMod = False
def keyPressEvent(self, event):
"""
Detects if the CopyDrag gets enabled.
"""
if not self.dragMod:
super(QTreeWidget, self).keyPressEvent(event)
if event.key() == QtCore.Qt.Key_Shift:
if self.dragMod:
if self.callback is not None:
dropIndex = self.callback[:]
self.deletePreview()
self.copyDrag = True
self.makePreview(event, dropIndex)
else:
self.deleteVoidItems()
self.copyDrag = True
self.calcVoidItems()
self.paintactivated = True
else:
self.nodeCopy = []
self.copyDrag = True
self.updateImage()
def keyReleaseEvent(self, event):
"""
Detects if the CopyDrag gets disabled.
"""
if event.key() == QtCore.Qt.Key_Shift:
if self.dragMod:
if self.callback is not None:
dropIndex = self.callback[:]
self.deletePreview()
self.copyDrag = False
self.makePreview(event, dropIndex)
else:
self.deleteVoidItems()
self.copyDrag = False
self.calcVoidItems()
self.needUpdate = True
else:
self.copyDrag = False
self.nodeCopy = []
self.updateImage()
class QPageWidget(QScrollArea):
""" The QPageWidget provides a stack widget with animated page transitions. """
#Emits
currentChanged = pyqtSignal()
def __init__(self, parent=None, direction="ltr", rtf=False):
""" Creates a new QPageWidget on given parent object.
parent: QWidget parent
direction: "ltr" -> Left To Right
"ttb" -> Top To Bottom
rtf: Return to first, if its True it flips to the first page
when next page requested at the last page
"""
# First initialize, QPageWidget is based on QScrollArea
QScrollArea.__init__(self, parent)
# Properties for QScrollArea
self.setFrameShape(QFrame.NoFrame)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setWidgetResizable(True)
# Main widget, which stores all Pages in it
self.widget = QWidget(self)
# Layout based on QBoxLayout which supports Vertical or Horizontal layout
if direction == "ltr":
self.layout = QBoxLayout(QBoxLayout.LeftToRight, self.widget)
self.__scrollBar = self.horizontalScrollBar()
self.__base_value = self.width
else:
self.layout = QBoxLayout(QBoxLayout.TopToBottom, self.widget)
self.__scrollBar = self.verticalScrollBar()
self.__base_value = self.height
self.layout.setSpacing(0)
#qboxlayout setmargin özelliği yok
#self.layout.setMargin(0)
# Return to first
self.__return_to_first = rtf
# TMP_PAGE, its using as last page in stack
# A workaround for a QScrollArea bug
self.__tmp_page = Page(QWidget(self.widget))
self.__pages = [self.__tmp_page]
self.__current = 0
self.__last = 0
# Set main widget
self.setWidget(self.widget)
# Animation TimeLine
self.__timeline = QTimeLine()
self.__timeline.setUpdateInterval(2)
# Updates scrollbar position when frame changed
self.__timeline.frameChanged.connect(
lambda x: self.__scrollBar.setValue(x))
# End of the animation
self.__timeline.finished.connect(self._animateFinished)
# Initialize animation
self.setAnimation()
self.setDuration()
def _animateFinished(self):
""" Its called by TimeLine when animation finished.
It first runs the outMethod of last Page and then the inMethod of current Page
Finally tt gives the focus to the current page and fixes the scrollBar
"""
# Disable other widgets
for page in self.__pages:
if not page == self.__pages[self.__current]:
page.widget.setEnabled(False)
# Run last page's outMethod if exists
if self.__pages[self.__last].outMethod:
self.__pages[self.__last].outMethod()
# Run new page's inMethod if exists
if self.__pages[self.__current].inMethod:
self.__pages[self.__current].inMethod()
# Give focus to the current Page
self.__pages[self.__current].widget.setFocus()
# Update scrollbar position for current page
self.__scrollBar.setValue(self.__current * self.__base_value())
# Emit currentChanged SIGNAL
self.currentChanged.emit()
def event(self, event):
""" Overrides the main event handler to catch resize events """
# Catch Resize event
if event.type() == QEvent.Resize:
# Update each page size limits to mainwidget's new size
for page in self.__pages:
page.widget.setMinimumSize(self.size())
page.widget.setMaximumSize(self.size())
# Update viewport size limits to mainwidget's new size
# It's a workaround for QScrollArea updateGeometry bug
self.viewport().setMinimumSize(self.size())
self.viewport().setMaximumSize(self.size())
# Update scrollbar position for current page
self.__scrollBar.setValue(self.__current * self.__base_value())
# Return the Event
return QScrollArea.event(self, event)
def keyPressEvent(self, event):
""" Overrides the keyPressEvent to ignore them """
pass
def wheelEvent(self, event):
""" Overrides the wheelEvent to ignore them """
pass
def createPage(self, widget, inMethod=None, outMethod=None):
""" Creates and adds new Page for given widget with given in/out methods.
widget: A QWidget which is the mainwidget for this Page
inMethod: (optional) QPageWidget triggers this method when the Page appear
outMethod: (optional) QPageWidget triggers this method when the Page disappear
"""
self.addPage(Page(widget, inMethod, outMethod))
def addPage(self, page):
""" Adds the given Page to the stack.
page: A Page object
"""
# First remove the last page; its __tmp_page
self.__pages.pop()
# Add new page
self.__pages.append(page)
self.layout.addWidget(page.widget)
# Add __tmp_page to end
self.__pages.append(self.__tmp_page)
self.layout.addWidget(self.__tmp_page.widget)
# Create connections for page navigation signals from new page
try:
page.widget.pageNext.connect(self.next)
page.widget.pagePrevious.connect(self.prev)
page.widget.setCurrent[int].connect(self.setCurrent)
except:
pass
def __setCurrent(self, pageNumber):
""" Internal method to set current page index. """
self.__last = self.__current
self.__current = min(max(0, pageNumber), len(self.__pages) - 2)
if pageNumber == len(self.__pages) - 1 and self.__return_to_first:
self.__current = 0
def setCurrent(self, pageNumber=0):
""" Set and flip the page with given pageNumber.
pageNumber: index number of Page (default is 0)
"""
self.__setCurrent(pageNumber)
self.flipPage()
def getCurrent(self):
""" Returns current page index. """
return self.__current
def getCurrentWidget(self):
""" Returns current page widget. """
return self.getWidget(self.getCurrent())
def getWidget(self, pageNumber):
""" Returns widget for given page index
pageNumber: index number of Page
"""
try:
return self.__pages[pageNumber].widget
except:
return None
def count(self):
""" Returns number of pages. """
return len(self.__pages) - 1
def setAnimation(self, animation=35):
""" Set the transition animation with the given animation.
animation: the number represents predefined QEasingCurves
List of predefined QEasingCurves can be found from:
http://doc.qt.nokia.com/4/qeasingcurve.html#Type-enum
Default is QEasingCurve::InOutBack (35)
"""
self.__animation = animation
self.__timeline.setEasingCurve(QEasingCurve(self.__animation))
def setDuration(self, duration=400):
""" Set the transition duration.
duration: duration time in ms
"""
self.__duration = duration
self.__timeline.setDuration(self.__duration)
def flipPage(self, direction=0):
""" Flip the page with given direction.
direction: can be -1, 0 or +1
-1: previous page (if exists)
0: just flip to current page
+1: next page (if exists)
"""
# Enable all widgets
for page in self.__pages:
page.widget.setEnabled(True)
# Check given direction
direction = direction if direction == 0 else max(min(1, direction), -1)
# If direction is equal to zero no need to re-set current
if not direction == 0:
self.__setCurrent(self.__current + direction)
# If last page is different from new page, flip it !
if not self.__last == self.__current:
self.__timeline.setFrameRange(self.__scrollBar.value(),
self.__current * self.__base_value())
self.__timeline.start()
def next(self):
""" Helper method to flip next page. """
self.flipPage(1)
def prev(self):
""" Helper method to flip previous page. """
self.flipPage(-1)
class QPageWidget(QScrollArea):
""" The QPageWidget provides a stack widget with animated page transitions. """
#Emits
currentChanged = pyqtSignal()
def __init__(self, parent = None, direction = "ltr", rtf = False):
""" Creates a new QPageWidget on given parent object.
parent: QWidget parent
direction: "ltr" -> Left To Right
"ttb" -> Top To Bottom
rtf: Return to first, if its True it flips to the first page
when next page requested at the last page
"""
# First initialize, QPageWidget is based on QScrollArea
QScrollArea.__init__(self, parent)
# Properties for QScrollArea
self.setFrameShape(QFrame.NoFrame)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setWidgetResizable(True)
# Main widget, which stores all Pages in it
self.widget = QWidget(self)
# Layout based on QBoxLayout which supports Vertical or Horizontal layout
if direction == "ltr":
self.layout = QBoxLayout(QBoxLayout.LeftToRight, self.widget)
self.__scrollBar = self.horizontalScrollBar()
self.__base_value = self.width
else:
self.layout = QBoxLayout(QBoxLayout.TopToBottom, self.widget)
self.__scrollBar = self.verticalScrollBar()
self.__base_value = self.height
self.layout.setSpacing(0)
#qboxlayout setmargin özelliği yok
#self.layout.setMargin(0)
# Return to first
self.__return_to_first = rtf
# TMP_PAGE, its using as last page in stack
# A workaround for a QScrollArea bug
self.__tmp_page = Page(QWidget(self.widget))
self.__pages = [self.__tmp_page]
self.__current = 0
self.__last = 0
# Set main widget
self.setWidget(self.widget)
# Animation TimeLine
self.__timeline = QTimeLine()
self.__timeline.setUpdateInterval(2)
# Updates scrollbar position when frame changed
self.__timeline.frameChanged.connect(lambda x: self.__scrollBar.setValue(x))
# End of the animation
self.__timeline.finished.connect(self._animateFinished)
# Initialize animation
self.setAnimation()
self.setDuration()
def _animateFinished(self):
""" Its called by TimeLine when animation finished.
It first runs the outMethod of last Page and then the inMethod of current Page
Finally tt gives the focus to the current page and fixes the scrollBar
"""
# Disable other widgets
for page in self.__pages:
if not page == self.__pages[self.__current]:
page.widget.setEnabled(False)
# Run last page's outMethod if exists
if self.__pages[self.__last].outMethod:
self.__pages[self.__last].outMethod()
# Run new page's inMethod if exists
if self.__pages[self.__current].inMethod:
self.__pages[self.__current].inMethod()
# Give focus to the current Page
self.__pages[self.__current].widget.setFocus()
# Update scrollbar position for current page
self.__scrollBar.setValue(self.__current * self.__base_value())
# Emit currentChanged SIGNAL
self.currentChanged.emit()
def event(self, event):
""" Overrides the main event handler to catch resize events """
# Catch Resize event
if event.type() == QEvent.Resize:
# Update each page size limits to mainwidget's new size
for page in self.__pages:
page.widget.setMinimumSize(self.size())
page.widget.setMaximumSize(self.size())
# Update viewport size limits to mainwidget's new size
# It's a workaround for QScrollArea updateGeometry bug
self.viewport().setMinimumSize(self.size())
self.viewport().setMaximumSize(self.size())
# Update scrollbar position for current page
self.__scrollBar.setValue(self.__current * self.__base_value())
# Return the Event
return QScrollArea.event(self, event)
def keyPressEvent(self, event):
""" Overrides the keyPressEvent to ignore them """
pass
def wheelEvent(self, event):
""" Overrides the wheelEvent to ignore them """
pass
def createPage(self, widget, inMethod = None, outMethod = None):
""" Creates and adds new Page for given widget with given in/out methods.
widget: A QWidget which is the mainwidget for this Page
inMethod: (optional) QPageWidget triggers this method when the Page appear
outMethod: (optional) QPageWidget triggers this method when the Page disappear
"""
self.addPage(Page(widget, inMethod, outMethod))
def addPage(self, page):
""" Adds the given Page to the stack.
page: A Page object
"""
# First remove the last page; its __tmp_page
self.__pages.pop()
# Add new page
self.__pages.append(page)
self.layout.addWidget(page.widget)
# Add __tmp_page to end
self.__pages.append(self.__tmp_page)
self.layout.addWidget(self.__tmp_page.widget)
# Create connections for page navigation signals from new page
try:
page.widget.pageNext.connect(self.next)
page.widget.pagePrevious.connect(self.prev)
page.widget.setCurrent[int].connect(self.setCurrent)
except:
pass
def __setCurrent(self, pageNumber):
""" Internal method to set current page index. """
self.__last = self.__current
self.__current = min(max(0, pageNumber), len(self.__pages) - 2)
if pageNumber == len(self.__pages) - 1 and self.__return_to_first:
self.__current = 0
def setCurrent(self, pageNumber = 0):
""" Set and flip the page with given pageNumber.
pageNumber: index number of Page (default is 0)
"""
self.__setCurrent(pageNumber)
self.flipPage()
def getCurrent(self):
""" Returns current page index. """
return self.__current
def getCurrentWidget(self):
""" Returns current page widget. """
return self.getWidget(self.getCurrent())
def getWidget(self, pageNumber):
""" Returns widget for given page index
pageNumber: index number of Page
"""
try:
return self.__pages[pageNumber].widget
except:
return None
def count(self):
""" Returns number of pages. """
return len(self.__pages) - 1
def setAnimation(self, animation = 35):
""" Set the transition animation with the given animation.
animation: the number represents predefined QEasingCurves
List of predefined QEasingCurves can be found from:
http://doc.qt.nokia.com/4/qeasingcurve.html#Type-enum
Default is QEasingCurve::InOutBack (35)
"""
self.__animation = animation
self.__timeline.setEasingCurve(QEasingCurve(self.__animation))
def setDuration(self, duration = 400):
""" Set the transition duration.
duration: duration time in ms
"""
self.__duration = duration
self.__timeline.setDuration(self.__duration)
def flipPage(self, direction=0):
""" Flip the page with given direction.
direction: can be -1, 0 or +1
-1: previous page (if exists)
0: just flip to current page
+1: next page (if exists)
"""
# Enable all widgets
for page in self.__pages:
page.widget.setEnabled(True)
# Check given direction
direction = direction if direction == 0 else max(min(1, direction), -1)
# If direction is equal to zero no need to re-set current
if not direction == 0:
self.__setCurrent(self.__current + direction)
# If last page is different from new page, flip it !
if not self.__last == self.__current:
self.__timeline.setFrameRange(self.__scrollBar.value(), self.__current * self.__base_value())
self.__timeline.start()
def next(self):
""" Helper method to flip next page. """
self.flipPage(1)
def prev(self):
""" Helper method to flip previous page. """
self.flipPage(-1)