def select(self): if not self.__selected: self.set_selected(True) effect = QGraphicsDropShadowEffect() effect.setBlurRadius(20) effect.setXOffset(0) effect.setYOffset(0) effect.setColor(QColor(0, 0, 0, 180)) self.setGraphicsEffect(effect) self.raise_()
def select(self, val: bool): if val: effect = QGraphicsDropShadowEffect() effect.setBlurRadius(20) effect.setXOffset(0) effect.setYOffset(0) effect.setColor(QColor(0, 0, 0, 180)) self.setGraphicsEffect(effect) self.raise_() else: eff = self.graphicsEffect() del eff self.setGraphicsEffect(None)
def __init__(self, treeItem): super(XGanttViewItem, self).__init__() # define custom properties self._color = QColor(255, 255, 255, 200) self._alternateColor = QColor(230, 230, 230, 200) self._highlightColor = QColor(255, 255, 0, 200) self._alternateHighlightColor = self._highlightColor.darker(110) self._textColor = QColor('black') self._borderColor = QColor(50, 50, 50) self._progressColor = QColor(200, 200, 250) self._alternateProgressColor = QColor(180, 180, 230) self._showProgress = True self._padding = 1 self._borderRadius = 5 self._percentComplete = 0 self._text = '' self._syncing = False self._treeItem = weakref.ref(treeItem) self._scrollBar = '' self._locked = False # setup standard properties self.setPrivelages() effect = QGraphicsDropShadowEffect() effect.setXOffset(0) effect.setYOffset(0) effect.setColor(QColor(40, 40, 40, 100)) effect.setBlurRadius(10) self.setAcceptHoverEvents(True) self.setGraphicsEffect(effect) # need this flag for Qt 4.6+ try: self.setFlag(self.ItemSendsGeometryChanges) except AttributeError: pass
def __init__(self, parent=None, workdir=None, fontsize=42): super(BillboardDisplay, self).__init__(parent) self.workdir = workdir self.logger = logging.getLogger('display') self.logger.info('Working directory: {}'.format(self.workdir)) self.current_display = os.path.join(self.workdir, 'current.jpg') desktop = QDesktopWidget() self.display = QWidget(self) size = desktop.availableGeometry(desktop.primaryScreen()); self.display.resize(size.width(), size.height()) self.display.setWindowTitle("Billboard") self.image_label = QLabel(self.display) self.image_label.resize(size.width(), size.height()) self.text_label = QLabel(self.display) self.text_label.resize(size.width(), size.height()) self.text_label.setMargin(100) self.text_label.setStyleSheet(''' QLabel {{ font-size: {}pt; font-weight: bold; color: #eeeeee; text-align: center; }} '''.format(fontsize)) self.text_label.setWordWrap(True) self.text_label.setAlignment(Qt.AlignCenter) dse = QGraphicsDropShadowEffect() dse.setBlurRadius(0) dse.setXOffset(5) dse.setYOffset(5) dse.setColor(QColor(0, 0, 0, 255)) self.text_label.setGraphicsEffect(dse) QObject.connect(self, SIGNAL("updateimage"), self.display_image) QObject.connect(self, SIGNAL("updatecurrent"), self.take_screenshot)
def __init__(self, parent=None, workdir=None, fontsize=42): super(BillboardDisplay, self).__init__(parent) self.workdir = workdir self.logger = logging.getLogger('display') self.logger.info('Working directory: {}'.format(self.workdir)) self.current_display = os.path.join(self.workdir, 'current.jpg') desktop = QDesktopWidget() self.display = QWidget(self) size = desktop.availableGeometry(desktop.primaryScreen()) self.display.resize(size.width(), size.height()) self.display.setWindowTitle("Billboard") self.image_label = QLabel(self.display) self.image_label.resize(size.width(), size.height()) self.text_label = QLabel(self.display) self.text_label.resize(size.width(), size.height()) self.text_label.setMargin(100) self.text_label.setStyleSheet(''' QLabel {{ font-size: {}pt; font-weight: bold; color: #eeeeee; text-align: center; }} '''.format(fontsize)) self.text_label.setWordWrap(True) self.text_label.setAlignment(Qt.AlignCenter) dse = QGraphicsDropShadowEffect() dse.setBlurRadius(0) dse.setXOffset(5) dse.setYOffset(5) dse.setColor(QColor(0, 0, 0, 255)) self.text_label.setGraphicsEffect(dse) QObject.connect(self, SIGNAL("updateimage"), self.display_image) QObject.connect(self, SIGNAL("updatecurrent"), self.take_screenshot)
class CImprovedPanel(QFrame): def __init__(self, parent=None): QFrame.__init__(self, parent) #FADING self.__opacity_effect = QGraphicsOpacityEffect() self.__fading_timer = QTimer(parent) self.__fading_timer.timeout.connect(self.__on_fading_timer) self.__FADE_TYPE = Enum("IN", "OUT") self.__fade_time = 20 self.__opacity = 1.0 self.__opacity_fading_coefficient = 0.02 self.__selected_fade_type = self.__FADE_TYPE.IN self.resizeEvent = self.__onResize #MOVE self.__move_animation_type = QEasingCurve.Linear self.__move_time = 350 self.__is_moving = False #RESIZE self.__resize_animation_type = QEasingCurve.Linear self.__resize_time = 700 self.__is_resizing = False #PIXMAP & MASCHERA self.__pmap = QPixmap(self.size()) self.__pmap_fname = "" self.__show_mask_preview = False #SHADOW self.__shadow_Xoffset = 3.0 #default value self.__shadow_Yoffset = 3.0 #default value self.__shadow_blur_radius = 8.0 #default value self.__shadow_color = QColor(38,38,38,150) #default value self.__shadow_effect = QGraphicsDropShadowEffect() self.__shadow_effect.setXOffset(self.__shadow_Xoffset) self.__shadow_effect.setYOffset(self.__shadow_Yoffset) self.__shadow_effect.setBlurRadius(self.__shadow_blur_radius) self.__shadow_effect.setColor(self.__shadow_color) self._shadow_visible = False ##FUNZIONI PER FADING def fadeIn(self): """ Labels fades in from completely invisible to completely visible. """ self.__opacity = 0.0 self.__selected_fade_type = self.__FADE_TYPE.IN self.__fading_timer.start(self.__fade_time) def fadeOut(self): """ Labels fades out from completely visible to completely invisible. """ self.__selected_fade_type = self.__FADE_TYPE.OUT self.__fading_timer.start(self.__fade_time) def setFadeTime(self, value): """ Sets fading time. Everytime interval is reached, alpha is increased (or decreased) by __opacity_fading_coefficient. @param value: fade time (msec) @type value: int """ self.__fade_time = value def getFadeTime(self): return self.__fade_time fadeInterval = QtCore.pyqtProperty("int", getFadeTime, setFadeTime) def setFadeCoefficient(self, value): """ Sets fading coefficient. Alpha is increased (or decreased) by this value. @param value: coefficient (min 0.0 - max 1.0) @type value: float """ self.__opacity_fading_coefficient = value def getFadeCoefficient(self): return self.__opacity_fading_coefficient fadeCoefficient = QtCore.pyqtProperty("double", getFadeCoefficient, setFadeCoefficient) def __on_fading_timer(self): if self.__selected_fade_type == self.__FADE_TYPE.OUT: if self.__opacity > 0: self.__opacity -= self.__opacity_fading_coefficient self.__opacity_effect.setOpacity(self.__opacity) self.setGraphicsEffect(self.__opacity_effect) else: self.__fading_timer.stop() if self.__selected_fade_type == self.__FADE_TYPE.IN: if self.__opacity <= 1.0: self.__opacity += self.__opacity_fading_coefficient self.__opacity_effect.setOpacity(self.__opacity) self.setGraphicsEffect(self.__opacity_effect) else: self.__fading_timer.stop() ## FUNZIONI PER SPOSTAMENTO VERSO PUNTO (ANIMATO) def setMoveAnimationType(self, animation_type): """ Sets move animation type. @param animation_type: animation type @type animation_type: QtEasingCurve """ self.__move_animation_type = animation_type def getMoveAnimationType(self): return self.__move_animation_type #asd = QtCore.pyqtProperty("QEasingCurve", getMoveAnimationType, setMoveAnimationType) #sembra nn essere supportato per ora (06/05/2013) def setMoveTime(self, value): """ Sets animation moving time. @param value: animation time (duration) (msec) @type value: int """ self.__move_time = value def getMoveTime(self): return self.__move_time moveTime = QtCore.pyqtProperty("int", getMoveTime, setMoveTime) def setResizeTime(self, value): """ Sets animation resize time. @param value: animation time (duration) (msec) @type value: int """ self.__resize_time = value def getResizeTime(self): return self.__resize_time resizeTime = QtCore.pyqtProperty("int", getResizeTime, setResizeTime) def moveTo(self, x, y): """ Move itself to a given point with the given animation in the given duration. @param x: X point coordinate @type x: int @param y: Y point coordinate @type y: int """ if self.__is_moving: return self.__is_moving = True self.__starting_position = QPoint(self.pos()) self.__moveAnimation = QPropertyAnimation(self, "pos", self) self.__moveAnimation.finished.connect(self.__on_finished_moving) self.__moveAnimation.setDuration(self.__move_time) self.__moveAnimation.setEasingCurve(self.__move_animation_type) self.__moveAnimation.setStartValue(self.__starting_position) self.__moveAnimation.setEndValue(QPoint(x, y)) self.__moveAnimation.start() def hideLeft(self): """ Panel hides sliding on the left. The slide amount is equal to his width - 5px. """ dest_x = self.geometry().x() - self.width() - 5 dest_y = self.geometry().y() self.moveTo(dest_x, dest_y) def showFromLeft(self): """ Panel shows sliding from the left. The slide amount is equal to his width + 5px. """ dest_x = self.geometry().x() + self.width() + 5 dest_y = self.geometry().y() self.moveTo(dest_x, dest_y) def hideRight(self): """ Panel hides sliding on the right. The slide amount is equal to his width - 5px. """ dest_x = self.geometry().x() + self.width() + 5 dest_y = self.geometry().y() self.moveTo(dest_x, dest_y) def showFromRight(self): """ Panel shows sliding from the right. The slide amount is equal to his width + 5px. """ dest_x = self.geometry().x() - self.width() - 5 dest_y = self.geometry().y() self.moveTo(dest_x, dest_y) def hideTop(self): """ Panel hides sliding on the top. The slide amount is equal to his height - 5px. """ dest_x = self.geometry().x() dest_y = self.geometry().y() - self.height() - 5 self.moveTo(dest_x, dest_y) def showFromTop(self): """ Panel shows sliding from the top. The slide amount is equal to his height - 5px. """ dest_x = self.geometry().x() dest_y = self.geometry().y() + self.height() - 5 self.moveTo(dest_x, dest_y) def hideBottom(self): """ Panel hides sliding to the bottom. The slide amount is equal to his height - 5px. """ dest_x = self.geometry().x() dest_y = self.geometry().y() + self.height() + 5 self.moveTo(dest_x, dest_y) def showFromBottom(self): """ Panel hides sliding from the bottom. The slide amount is equal to his height - 5px. """ dest_x = self.geometry().x() dest_y = self.geometry().y() - self.height() - 5 self.moveTo(dest_x, dest_y) def returnToOriginalPoint(self): """ Panel returns in its original position. The original position is stored when calling moveTo() method. """ if self.__is_moving: return self.__is_moving = True self.__moveAnimation = QPropertyAnimation(self, "pos", self) self.__moveAnimation.finished.connect(self.__on_finished_moving) self.__moveAnimation.setDuration(self.__move_time) self.__moveAnimation.setEasingCurve(self.__move_animation_type) self.__moveAnimation.setStartValue(QPoint(self.pos().x(), self.pos().y())) self.__moveAnimation.setEndValue(self.__starting_position) self.__moveAnimation.start() #FUNZIONI PER RIDIMENSIONAMENTO def setResizeAnimationType(self, animation_type): """ Sets move animation type. @param animation_type: animation type @type animation_type: QtEasingCurve """ self.__resize_animation_type = animation_type def resizeTo(self, width, height): """ Resize itself to a given size with the given animation in the given duration. @param width: New width @type width: int @param height: New height @type height: int """ if self.__is_resizing: return self.__is_resizing = True self.__original_size = self.geometry() self.__resizeAnimation = QPropertyAnimation(self, "geometry", self) self.__resizeAnimation.finished.connect(self.__on_finished_resizing) self.__resizeAnimation.setDuration(self.__resize_time) self.__resizeAnimation.setEasingCurve(self.__resize_animation_type) self.__resizeAnimation.setStartValue(self.__original_size) self.__resizeAnimation.setEndValue(QRect(self.pos().x(), self.pos().y(), width, height)) self.__resizeAnimation.start() def foldLeft(self): """ Panel hides folding to the left. """ new_width = 0 new_height = self.height() self.resizeTo(new_width, new_height) def unfoldLeft(self): """ Panel shows folding from the left. """ new_width = self.__original_size.width() new_height = self.height() self.resizeTo(new_width, new_height) def foldTop(self): """ Panel hides folding to the top. """ new_width = self.width() new_height = 0 self.resizeTo(new_width, new_height) def unfoldTop(self): """ Panel shows folding from the top. """ new_width = self.width() new_height = self.__original_size.height() self.resizeTo(new_width, new_height) #FUNZIONI PER PIXMAP & MASCHERA def setPixmapFile(self, image_file): self.__pmap = image_file self.__pmap.scaled(self.size()) #NB: Il pixmap deve essere BIANCO e NERO. Con heuristicMask il primo pixel in alto a sinistra (0,0) viene #usato per decidere il colore trasparente, tutto il resto è visibile. def getPixmapFile(self): return self.__pmap pixmapFile = QtCore.pyqtProperty("QPixmap", getPixmapFile, setPixmapFile) def applyMask(self, bool): self.__show_mask_preview = bool if bool: self.setMask(QBitmap(self.__pmap.createHeuristicMask().scaled(self.size()))) else: self.setMask(QBitmap()) def getMask(self): return self.__show_mask_preview appliedMask = QtCore.pyqtProperty("bool", fget=getMask, fset=applyMask) def __on_finished_moving(self): self.__is_moving = False def __on_finished_resizing(self): self.__is_resizing = False def __onResize(self, event): self.__pmap.scaled(self.size()) if self.__show_mask_preview: self.setMask(QBitmap(self.__pmap.createHeuristicMask().scaled(self.size()))) #FUNZIONI PER SHADOW def getShadow(self): return self._shadow_visible def setShadow(self, bool): self.setGraphicsEffect(self.__shadow_effect) self._shadow_visible = bool self.__shadow_effect.setEnabled(bool) shadow = QtCore.pyqtProperty("bool", fget=getShadow, fset=setShadow) def setShadowXOffset(self, value): """ Sets shadow offset on X. @param value: offset @type value: float """ self.__shadow_Xoffset = value self.__shadow_effect.setXOffset(self.__shadow_Xoffset) def getShadowXOffset(self): return self.__shadow_Xoffset shadowXOffset = QtCore.pyqtProperty("double", getShadowXOffset, setShadowXOffset) def setShadowYOffset(self, value): """ Sets shadow offset on Y. @param value: offset @type value: float """ self.__shadow_Yoffset = value self.__shadow_effect.setYOffset(self.__shadow_Yoffset) def getShadowYOffset(self): return self.__shadow_Yoffset shadowYOffset = QtCore.pyqtProperty("double", getShadowYOffset, setShadowYOffset) def setShadowBlur(self, value): """ Sets blurred effect on item's shadow. @param value: coefficient @type value: float """ self.__shadow_blur_radius = value self.__shadow_effect.setBlurRadius(self.__shadow_blur_radius) def getShadowBlur(self): return self.__shadow_blur_radius shadowBlur = QtCore.pyqtProperty("double", getShadowBlur, setShadowBlur) def setShadowColor(self, color): """ Sets shadow's color. @param color: value @type color: color """ self.__shadow_color = color self.__shadow_effect.setColor(self.__shadow_color) def getShadowColor(self): return self.__shadow_color
class FreezeTableWidget(QTableView): def __init__(self, table_data, headers, parent=None, *args): """ Creates two QTableViews one of which is a frozen table while the other one can scroll behind it. :param table_data: The data that goes into the tables :type table_data: List :param headers: The header data of the tables. :type headers: List :param parent: The parent of the QTableView :type parent: QWidget :param args: :type args: """ QTableView.__init__(self, parent) # set the table model self.table_model = BaseSTDMTableModel(table_data, headers, parent) # set the proxy model proxy_model = QSortFilterProxyModel(self) proxy_model.setSourceModel(self.table_model) # Assign a data model for TableView self.setModel(self.table_model) # frozen_table_view - first column self.frozen_table_view = QTableView(self) # Set the model for the widget, fixed column self.frozen_table_view.setModel(self.table_model) # Hide row headers self.frozen_table_view.verticalHeader().hide() # Widget does not accept focus self.frozen_table_view.setFocusPolicy(Qt.StrongFocus | Qt.TabFocus | Qt.ClickFocus) # The user can not resize columns self.frozen_table_view.horizontalHeader().\ setResizeMode(QHeaderView.Fixed) self.frozen_table_view.setObjectName('frozen_table') self.setSelectionMode(QAbstractItemView.NoSelection) self.set_style() # Remove the scroll bar self.frozen_table_view.setHorizontalScrollBarPolicy( Qt.ScrollBarAlwaysOff) self.frozen_table_view.setVerticalScrollBarPolicy( Qt.ScrollBarAlwaysOff) # Puts more widgets to the foreground self.viewport().stackUnder(self.frozen_table_view) # # Log in to edit mode - even with one click # Set the properties of the column headings hh = self.horizontalHeader() # Text alignment centered hh.setDefaultAlignment(Qt.AlignCenter) self.set_column_width() # Set properties header lines vh = self.verticalHeader() vh.setDefaultSectionSize(25) # height lines # text alignment centered vh.setDefaultAlignment(Qt.AlignCenter) vh.setVisible(True) # Height of rows - as in the main widget self.frozen_table_view.verticalHeader().\ setDefaultSectionSize( vh.defaultSectionSize() ) # Show frozen table view self.frozen_table_view.show() # Set the size of him like the main self.setHorizontalScrollMode(QAbstractItemView.ScrollPerPixel) self.setVerticalScrollMode(QAbstractItemView.ScrollPerPixel) self.frozen_table_view.setVerticalScrollMode( QAbstractItemView.ScrollPerPixel) ## select the first column (STR Type) self.frozen_table_view.selectColumn(0) self.frozen_table_view.setEditTriggers( QAbstractItemView.AllEditTriggers) self.set_size() self.signals() def set_size(self): """ Sets the size and size policy of the tables. :return: :rtype: """ size_policy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) size_policy.setHorizontalStretch(0) size_policy.setVerticalStretch(0) size_policy.setHeightForWidth(self.sizePolicy().hasHeightForWidth()) self.setSizePolicy(size_policy) self.setMinimumSize(QSize(55, 75)) self.setMaximumSize(QSize(5550, 5555)) self.SelectionMode(QAbstractItemView.SelectColumns) # set column width to fit contents self.frozen_table_view.resizeColumnsToContents() # set row height self.frozen_table_view.resizeRowsToContents() def signals(self): """ Connects signals of the tables. """ # Connect the headers and scrollbars of # both tableviews together self.horizontalHeader().sectionResized.connect( self.update_section_width) self.verticalHeader().sectionResized.connect( self.update_section_height) self.frozen_table_view.verticalScrollBar(). \ valueChanged.connect( self.verticalScrollBar().setValue ) self.verticalScrollBar().valueChanged.connect( self.frozen_table_view.verticalScrollBar().setValue) def set_column_width(self): """ Sets the column width of the frozen QTableView. """ # Set the width of columns columns_count = self.table_model.columnCount(self) for col in range(columns_count): if col == 0: # Set the size self.horizontalHeader().resizeSection(col, 60) # Fix width self.horizontalHeader().setResizeMode(col, QHeaderView.Fixed) # Width of a fixed column - as in the main widget self.frozen_table_view.setColumnWidth(col, self.columnWidth(col)) elif col == 1: self.horizontalHeader().resizeSection(col, 150) self.horizontalHeader().setResizeMode(col, QHeaderView.Fixed) self.frozen_table_view.setColumnWidth(col, self.columnWidth(col)) else: self.horizontalHeader().resizeSection(col, 150) # Hide unnecessary columns in the # widget fixed columns self.frozen_table_view.setColumnHidden(col, True) def set_style(self): """ Sets the style of the frozen table. """ # Style frozentable view self.frozen_table_view.setStyleSheet(''' #frozen_table{ border-top:none; } ''') self.shadow = QGraphicsDropShadowEffect(self) self.shadow.setBlurRadius(5) self.shadow.setOffset(2) self.shadow.setYOffset(0) self.frozen_table_view.setGraphicsEffect(self.shadow) def add_widgets(self, str_type_id, insert_row): """ Adds widget delete into the frozen table. :param str_type_id: The STR type id of the tenure type combobox :type str_type_id: Integer :param insert_row: The row number the widgets to be added. :type insert_row: Integer """ delegate = STRTypeDelegate(str_type_id) # Set delegate to add combobox under # social tenure type column self.frozen_table_view.setItemDelegate(delegate) self.frozen_table_view.setItemDelegateForColumn(0, delegate) index = self.frozen_table_view.model().index(insert_row, 0, QModelIndex()) self.frozen_table_view.model().setData(index, '', Qt.EditRole) self.frozen_table_view.openPersistentEditor( self.frozen_table_view.model().index(insert_row, 0)) self.frozen_table_view.openPersistentEditor( self.frozen_table_view.model().index(insert_row, 1)) def update_section_width(self, logicalIndex, oldSize, newSize): """ Updates frozen table column width and geometry. :param logicalIndex: The section's logical number :type logicalIndex: Integer :param oldSize: The old size of the section :type oldSize: Integer :param newSize: The new size of the section :type newSize: Integer """ if logicalIndex == 0 or logicalIndex == 1: self.frozen_table_view.setColumnWidth(logicalIndex, newSize) self.update_frozen_table_geometry() def update_section_height(self, logicalIndex, oldSize, newSize): """ Updates frozen table column height. :param logicalIndex: The section's logical number :type logicalIndex: Integer :param oldSize: The old size of the section :type oldSize: Integer :param newSize: The new size of the section :type newSize: Integer """ self.frozen_table_view.setRowHeight(logicalIndex, newSize) def resizeEvent(self, event): """ Handles the resize event of the frozen table view. It updates the frozen table view geometry on resize of table. :param event: The event :type event: QEvent """ QTableView.resizeEvent(self, event) try: self.update_frozen_table_geometry() except Exception as log: LOGGER.debug(str(log)) def scrollTo(self, index, hint): """ Scrolls the view if necessary to ensure that the item at index is visible. The view will try to position the item according to the given hint. :param index: The scroll index :type index: QModelIndex :param hint: The scroll hint :type hint: Integer """ if index.column() > 1: QTableView.scrollTo(self, index, hint) def update_frozen_table_geometry(self): """ Updates the frozen table view geometry. """ if self.verticalHeader().isVisible(): self.frozen_table_view.setGeometry( self.verticalHeader().width() + self.frameWidth(), self.frameWidth(), self.columnWidth(0) + self.columnWidth(1), self.viewport().height() + self.horizontalHeader().height()) else: self.frozen_table_view.setGeometry( self.frameWidth(), self.frameWidth(), self.columnWidth(0) + self.columnWidth(1), self.viewport().height() + self.horizontalHeader().height()) def move_cursor(self, cursor_action, modifiers): """ Override function for correct left to scroll the keyboard. Returns a QModelIndex object pointing to the next object in the table view, based on the given cursorAction and keyboard modifiers specified by modifiers. :param cursor_action: The cursor action :type cursor_action: Integer :param modifiers: Qt.KeyboardModifier value. :type modifiers: Object :return: The current cursor position. :rtype: QModelIndex """ current = QTableView.move_cursor(self, cursor_action, modifiers) if cursor_action == self.MoveLeft and current.column() > 1 and \ self.visualRect(current).topLeft().x() < \ (self.frozen_table_view.columnWidth(0) + self.frozen_table_view.columnWidth(1)): new_value = self.horizontalScrollBar().value() + \ self.visualRect(current).topLeft().x() - \ (self.frozen_table_view.columnWidth(0) + self.frozen_table_view.columnWidth(1)) self.horizontalScrollBar().setValue(new_value) return current
def setCurrentAction(self, action): """ Sets the current action for this widget that highlights the size for this toolbar. :param action | <QAction> """ if action == self._currentAction: return self._currentAction = action self.currentActionChanged.emit(action) labels = self.actionLabels() anim_grp = QParallelAnimationGroup(self) max_size = self.maximumPixmapSize() min_size = self.minimumPixmapSize() if action: label = self.labelForAction(action) index = labels.index(label) # create the highlight effect palette = self.palette() effect = QGraphicsDropShadowEffect(label) effect.setXOffset(0) effect.setYOffset(0) effect.setBlurRadius(20) effect.setColor(QColor(40, 40, 40)) label.setGraphicsEffect(effect) offset = self.padding() if self.position() in (XDockToolbar.Position.East, XDockToolbar.Position.West): self.resize(max_size.width() + offset, self.height()) elif self.position() in (XDockToolbar.Position.North, XDockToolbar.Position.South): self.resize(self.width(), max_size.height() + offset) w = max_size.width() h = max_size.height() dw = (max_size.width() - min_size.width()) / 3 dh = (max_size.height() - min_size.height()) / 3 for i in range(4): before = index - i after = index + i if 0 <= before and before < len(labels): anim = XObjectAnimation(labels[before], 'setPixmapSize', anim_grp) anim.setEasingCurve(self.easingCurve()) anim.setStartValue(labels[before].pixmapSize()) anim.setEndValue(QSize(w, h)) anim.setDuration(self.duration()) anim_grp.addAnimation(anim) if i: labels[before].setGraphicsEffect(None) if after != before and 0 <= after and after < len(labels): anim = XObjectAnimation(labels[after], 'setPixmapSize', anim_grp) anim.setEasingCurve(self.easingCurve()) anim.setStartValue(labels[after].pixmapSize()) anim.setEndValue(QSize(w, h)) anim.setDuration(self.duration()) anim_grp.addAnimation(anim) if i: labels[after].setGraphicsEffect(None) w -= dw h -= dh else: offset = self.padding() for label in self.actionLabels(): # clear the graphics effect label.setGraphicsEffect(None) # create the animation anim = XObjectAnimation(label, 'setPixmapSize', self) anim.setEasingCurve(self.easingCurve()) anim.setStartValue(label.pixmapSize()) anim.setEndValue(min_size) anim.setDuration(self.duration()) anim_grp.addAnimation(anim) anim_grp.finished.connect(self.resizeToMinimum) anim_grp.start() self._animating = True anim_grp.finished.connect(anim_grp.deleteLater) anim_grp.finished.connect(self.__markAnimatingFinished) if self._currentAction: self._hoverTimer.start() else: self._hoverTimer.stop()