def reset( self ):
     """
     Resets the user interface buttons for this widget.
     """
     # clear previous widgets
     for btn in self.findChildren(QToolButton):
         btn.close()
         btn.setParent(None)
         btn.deleteLater()
     
     # determine coloring options
     palette             = self.palette()
     unchecked           = palette.color(palette.Button)
     
     # determine if this is a dark or light scheme
     avg = (unchecked.red() + unchecked.green() + unchecked.blue()) / 3.0
     if ( avg < 140 ):
         checked             = unchecked.lighter(115)
         
         checked_clr         = self.colorString(unchecked.lighter(120))
         border_clr          = self.colorString(unchecked.darker(140))
         unchecked_clr       = self.colorString(checked.lighter(140))
         unchecked_clr_alt   = self.colorString(checked.lighter(120))
         checked_clr_alt     = self.colorString(unchecked)
     else:
         checked             = unchecked.lighter(120)
         
         checked_clr         = self.colorString(unchecked)
         border_clr          = self.colorString(unchecked.darker(160))
         unchecked_clr       = self.colorString(checked)
         unchecked_clr_alt   = self.colorString(checked.darker(130))
         checked_clr_alt     = self.colorString(unchecked.darker(120))
     
     # define the stylesheet options
     options = {}
     options['top_left_radius']      = 0
     options['top_right_radius']     = 0
     options['bot_left_radius']      = 0
     options['bot_right_radius']     = 0
     options['border_color']         = border_clr
     options['checked_clr']          = checked_clr
     options['checked_clr_alt']      = checked_clr_alt
     options['unchecked_clr']        = unchecked_clr
     options['unchecked_clr_alt']    = unchecked_clr_alt
     options['padding_top']          = 1
     options['padding_bottom']       = 1
     options['padding_left']         = 1
     options['padding_right']        = 1
     
     horiz = self.direction() in (QBoxLayout.LeftToRight, 
                                  QBoxLayout.RightToLeft)
     
     if ( horiz ):
         options['x1'] = 0
         options['y1'] = 0
         options['x2'] = 0
         options['y2'] = 1
     else:
         options['x1'] = 0
         options['y1'] = 0
         options['x2'] = 1
         options['y2'] = 1
     
     actions = self.actionGroup().actions()
     count = len(actions)
     for i, action in enumerate(actions):
         btn = QToolButton(self)
         btn.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
         btn.setDefaultAction(action)
         self.layout().insertWidget(i, btn)
         
         options['top_left_radius']  = 1
         options['bot_left_radius']  = 1
         options['top_right_radius'] = 1
         options['bot_right_radius'] = 1
         
         if ( horiz ):
             options['padding_left']     = self._padding
             options['padding_right']    = self._padding
         else:
             options['padding_top']      = self._padding
             options['padding_bottom']   = self._padding
         
         if ( not i ):
             if ( horiz ):
                 options['top_left_radius'] = self.cornerRadius()
                 options['bot_left_radius'] = self.cornerRadius()
                 options['padding_left']    += self.cornerRadius() / 3.0
             else:
                 options['top_left_radius'] = self.cornerRadius()
                 options['top_right_radius'] = self.cornerRadius()
                 options['padding_top']     += self.cornerRadius() / 3.0
                 
         elif ( i == count - 1 ):
             if ( horiz ):
                 options['top_right_radius'] = self.cornerRadius()
                 options['bot_right_radius'] = self.cornerRadius()
                 options['padding_right']    += self.cornerRadius() / 3.0
             else:
                 options['bot_left_radius']  = self.cornerRadius()
                 options['bot_right_radius'] = self.cornerRadius()
                 options['padding_bottom']   += self.cornerRadius() / 3.0
         
         btn.setStyleSheet(TOOLBUTTON_STYLE % options)
         btn.setAutoFillBackground(True)
Exemple #2
0
class XToolBar(QToolBar):
    collapseToggled = Signal(bool)

    def __init__(self, *args):
        super(XToolBar, self).__init__(*args)

        # set custom properties
        self._collapseButton = None
        self._collapsable = True
        self._collapsed = True
        self._collapsedSize = 14
        self._autoCollapsible = False
        self._precollapseSize = None
        self._shadowed = False
        self._colored = False

        # set standard options
        self.layout().setSpacing(0)
        self.layout().setContentsMargins(1, 1, 1, 1)
        self.setMovable(False)
        self.clear()
        self.setMouseTracking(True)
        self.setOrientation(Qt.Horizontal)
        self.setCollapsed(False)

    def autoCollapsible(self):
        """
        Returns whether or not this toolbar is auto-collapsible.  When
        True, it will enter its collapsed state when the user hovers out
        of the bar.
        
        :return     <bool>
        """
        return self._autoCollapsible

    def clear(self):
        """
        Clears out this toolbar from the system.
        """
        # preserve the collapse button
        super(XToolBar, self).clear()

        # clears out the toolbar
        if self.isCollapsable():
            self._collapseButton = QToolButton(self)
            self._collapseButton.setAutoRaise(True)
            self._collapseButton.setSizePolicy(QSizePolicy.Expanding,
                                               QSizePolicy.Expanding)

            self.addWidget(self._collapseButton)
            self.refreshButton()

            # create connection
            self._collapseButton.clicked.connect(self.toggleCollapsed)

        elif self._collapseButton:
            self._collapseButton.setParent(None)
            self._collapseButton.deleteLater()
            self._collapseButton = None

    def count(self):
        """
        Returns the number of actions linked with this toolbar.
        
        :return     <int>
        """
        return len(self.actions())

    def collapseButton(self):
        """
        Returns the collapsing button for this toolbar.
        
        :return     <QToolButton>
        """
        return self._collapseButton

    def isCollapsable(self):
        """
        Returns whether or not this toolbar is collapsable.
        
        :return     <bool>
        """
        return self._collapsable

    def isCollapsed(self):
        """
        Returns whether or not this toolbar is in a collapsed state.
        
        :return     <bool>
        """
        return self._collapsed and self.isCollapsable()

    def isColored(self):
        """
        Returns whether or not to colorize the buttons on the toolbar
        when they are highlighted.
        
        :return     <bool>
        """
        return self._colored

    def isShadowed(self):
        """
        Returns whether or not to show this toolbar with shadows.
        
        :return     <bool>
        """
        return self._shadowed

    def refreshButton(self):
        """
        Refreshes the button for this toolbar.
        """
        collapsed = self.isCollapsed()
        btn = self._collapseButton

        if not btn:
            return

        btn.setMaximumSize(MAX_SIZE, MAX_SIZE)

        # set up a vertical scrollbar
        if self.orientation() == Qt.Vertical:
            btn.setMaximumHeight(12)
        else:
            btn.setMaximumWidth(12)

        icon = ''

        # collapse/expand a vertical toolbar
        if self.orientation() == Qt.Vertical:
            if collapsed:
                self.setFixedWidth(self._collapsedSize)
                btn.setMaximumHeight(MAX_SIZE)
                btn.setArrowType(Qt.RightArrow)
            else:
                self.setMaximumWidth(MAX_SIZE)
                self._precollapseSize = None
                btn.setMaximumHeight(12)
                btn.setArrowType(Qt.LeftArrow)

        else:
            if collapsed:
                self.setFixedHeight(self._collapsedSize)
                btn.setMaximumWidth(MAX_SIZE)
                btn.setArrowType(Qt.DownArrow)
            else:
                self.setMaximumHeight(1000)
                self._precollapseSize = None
                btn.setMaximumWidth(12)
                btn.setArrowType(Qt.UpArrow)

        for index in range(1, self.layout().count()):
            item = self.layout().itemAt(index)
            if not item.widget():
                continue

            if collapsed:
                item.widget().setMaximumSize(0, 0)
            else:
                item.widget().setMaximumSize(MAX_SIZE, MAX_SIZE)

        if not self.isCollapsable():
            btn.hide()
        else:
            btn.show()

    def resizeEvent(self, event):
        super(XToolBar, self).resizeEvent(event)

        if not self._collapsed:
            if self.orientation() == Qt.Vertical:
                self._precollapseSize = self.width()
            else:
                self._precollapseSize = self.height()

    def setAutoCollapsible(self, state):
        """
        Sets whether or not this toolbar is auto-collapsible.
        
        :param      state | <bool>
        """
        self._autoCollapsible = state

    def setCollapsed(self, state):
        """
        Sets whether or not this toolbar is in a collapsed state.
        
        :return     <bool> changed
        """
        if state == self._collapsed:
            return False

        self._collapsed = state
        self.refreshButton()

        if not self.signalsBlocked():
            self.collapseToggled.emit(state)

        return True

    def setCollapsable(self, state):
        """
        Sets whether or not this toolbar is collapsable.
        
        :param      state | <bool>
        """
        if self._collapsable == state:
            return

        self._collapsable = state
        self.clear()

    def setOrientation(self, orientation):
        """
        Sets the orientation for this toolbar to the inputed value, and \
        updates the contents margins and collapse button based on the vaule.
        
        :param      orientation | <Qt.Orientation>
        """
        super(XToolBar, self).setOrientation(orientation)
        self.refreshButton()

    def setShadowed(self, state):
        """
        Sets whether or not this toolbar is shadowed.
        
        :param      state | <bool>
        """
        self._shadowed = state
        if state:
            self._colored = False

        for child in self.findChildren(XToolButton):
            child.setShadowed(state)

    def setColored(self, state):
        """
        Sets whether or not this toolbar is shadowed.
        
        :param      state | <bool>
        """
        self._colored = state
        if state:
            self._shadowed = False

        for child in self.findChildren(XToolButton):
            child.setColored(state)

    def toggleCollapsed(self):
        """
        Toggles the collapsed state for this toolbar.
        
        :return     <bool> changed
        """
        return self.setCollapsed(not self.isCollapsed())

    x_shadowed = Property(bool, isShadowed, setShadowed)
    x_colored = Property(bool, isColored, setColored)
Exemple #3
0
 def rebuild( self ):
     """
     Rebuilds the user interface buttons for this widget.
     """
     self.setUpdatesEnabled(False)
     
     # sync up the toolbuttons with our actions
     actions = self._actionGroup.actions()
     btns    = self.findChildren(QToolButton)
     horiz   = self.direction() in (QBoxLayout.LeftToRight, 
                                    QBoxLayout.RightToLeft)
     
     # remove unnecessary buttons
     if len(actions) < len(btns):
         rem_btns = btns[len(actions)-1:]
         btns = btns[:len(actions)]
         
         for btn in rem_btns:
             btn.close()
             btn.setParent(None)
             btn.deleteLater()
     
     # create new buttons
     elif len(btns) < len(actions):
         for i in range(len(btns), len(actions)):
             btn = QToolButton(self)
             btn.setAutoFillBackground(True)
             btns.append(btn)
             self.layout().addWidget(btn)
             
             btn.clicked.connect(self.emitClicked)
     
     # determine coloring options
     palette      = self.palette()
     checked      = palette.color(palette.Highlight)
     checked_fg   = palette.color(palette.HighlightedText)
     unchecked    = palette.color(palette.Button)
     unchecked_fg = palette.color(palette.ButtonText)
     border       = palette.color(palette.Mid)
     
     # define the stylesheet options
     options = {}
     options['top_left_radius']      = 0
     options['top_right_radius']     = 0
     options['bot_left_radius']      = 0
     options['bot_right_radius']     = 0
     options['border_color']         = border.name()
     options['checked_fg']           = checked_fg.name()
     options['checked_bg']           = checked.name()
     options['checked_bg_alt']       = checked.darker(120).name()
     options['unchecked_fg']         = unchecked_fg.name()
     options['unchecked_bg']         = unchecked.name()
     options['unchecked_bg_alt']     = unchecked.darker(120).name()
     options['padding_top']          = 1
     options['padding_bottom']       = 1
     options['padding_left']         = 1
     options['padding_right']        = 1
     
     if horiz:
         options['x1'] = 0
         options['y1'] = 0
         options['x2'] = 0
         options['y2'] = 1
     else:
         options['x1'] = 0
         options['y1'] = 0
         options['x2'] = 1
         options['y2'] = 1
     
     # sync up the actions and buttons
     count = len(actions)
     palette = self.palette()
     font = self.font()
     for i, action in enumerate(actions):
         btn = btns[i]
         
         # assign the action for this button
         if btn.defaultAction() != action:
             # clear out any existing actions
             for act in btn.actions():
                 btn.removeAction(act)
             
             # assign the given action
             btn.setDefaultAction(action)
         
         options['top_left_radius']  = 1
         options['bot_left_radius']  = 1
         options['top_right_radius'] = 1
         options['bot_right_radius'] = 1
         
         if horiz:
             options['padding_left']     = self._padding
             options['padding_right']    = self._padding
         else:
             options['padding_top']      = self._padding
             options['padding_bottom']   = self._padding
         
         if not i:
             if horiz:
                 options['top_left_radius'] = self.cornerRadius()
                 options['bot_left_radius'] = self.cornerRadius()
                 options['padding_left']    += self.cornerRadius() / 3.0
             else:
                 options['top_left_radius'] = self.cornerRadius()
                 options['top_right_radius'] = self.cornerRadius()
                 options['padding_top']     += self.cornerRadius() / 3.0
                 
         if i == count - 1:
             if horiz:
                 options['top_right_radius'] = self.cornerRadius()
                 options['bot_right_radius'] = self.cornerRadius()
                 options['padding_right']    += self.cornerRadius() / 3.0
             else:
                 options['bot_left_radius']  = self.cornerRadius()
                 options['bot_right_radius'] = self.cornerRadius()
                 options['padding_bottom']   += self.cornerRadius() / 3.0
         
         btn.setFont(font)
         btn.setPalette(palette)
         btn.setStyleSheet(TOOLBUTTON_STYLE % options)
         if horiz:
             btn.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
         else:
             btn.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Expanding)
     
     self.setUpdatesEnabled(True)
Exemple #4
0
    def rebuild(self):
        """
        Rebuilds the user interface buttons for this widget.
        """
        self.setUpdatesEnabled(False)

        # sync up the toolbuttons with our actions
        actions = self._actionGroup.actions()
        btns = self.findChildren(QToolButton)
        horiz = self.direction() in (QBoxLayout.LeftToRight,
                                     QBoxLayout.RightToLeft)

        # remove unnecessary buttons
        if len(actions) < len(btns):
            rem_btns = btns[len(actions) - 1:]
            btns = btns[:len(actions)]

            for btn in rem_btns:
                btn.close()
                btn.setParent(None)
                btn.deleteLater()

        # create new buttons
        elif len(btns) < len(actions):
            for i in range(len(btns), len(actions)):
                btn = QToolButton(self)
                btn.setAutoFillBackground(True)
                btns.append(btn)
                self.layout().addWidget(btn)

                btn.clicked.connect(self.emitClicked)

        # determine coloring options
        palette = self.palette()
        checked = palette.color(palette.Highlight)
        checked_fg = palette.color(palette.HighlightedText)
        unchecked = palette.color(palette.Button)
        unchecked_fg = palette.color(palette.ButtonText)
        border = palette.color(palette.Mid)

        # define the stylesheet options
        options = {}
        options['top_left_radius'] = 0
        options['top_right_radius'] = 0
        options['bot_left_radius'] = 0
        options['bot_right_radius'] = 0
        options['border_color'] = border.name()
        options['checked_fg'] = checked_fg.name()
        options['checked_bg'] = checked.name()
        options['checked_bg_alt'] = checked.darker(120).name()
        options['unchecked_fg'] = unchecked_fg.name()
        options['unchecked_bg'] = unchecked.name()
        options['unchecked_bg_alt'] = unchecked.darker(120).name()
        options['padding_top'] = 1
        options['padding_bottom'] = 1
        options['padding_left'] = 1
        options['padding_right'] = 1

        if horiz:
            options['x1'] = 0
            options['y1'] = 0
            options['x2'] = 0
            options['y2'] = 1
        else:
            options['x1'] = 0
            options['y1'] = 0
            options['x2'] = 1
            options['y2'] = 1

        # sync up the actions and buttons
        count = len(actions)
        palette = self.palette()
        font = self.font()
        for i, action in enumerate(actions):
            btn = btns[i]

            # assign the action for this button
            if btn.defaultAction() != action:
                # clear out any existing actions
                for act in btn.actions():
                    btn.removeAction(act)

                # assign the given action
                btn.setDefaultAction(action)

            options['top_left_radius'] = 1
            options['bot_left_radius'] = 1
            options['top_right_radius'] = 1
            options['bot_right_radius'] = 1

            if horiz:
                options['padding_left'] = self._padding
                options['padding_right'] = self._padding
            else:
                options['padding_top'] = self._padding
                options['padding_bottom'] = self._padding

            if not i:
                if horiz:
                    options['top_left_radius'] = self.cornerRadius()
                    options['bot_left_radius'] = self.cornerRadius()
                    options['padding_left'] += self.cornerRadius() / 3.0
                else:
                    options['top_left_radius'] = self.cornerRadius()
                    options['top_right_radius'] = self.cornerRadius()
                    options['padding_top'] += self.cornerRadius() / 3.0

            if i == count - 1:
                if horiz:
                    options['top_right_radius'] = self.cornerRadius()
                    options['bot_right_radius'] = self.cornerRadius()
                    options['padding_right'] += self.cornerRadius() / 3.0
                else:
                    options['bot_left_radius'] = self.cornerRadius()
                    options['bot_right_radius'] = self.cornerRadius()
                    options['padding_bottom'] += self.cornerRadius() / 3.0

            btn.setFont(font)
            btn.setPalette(palette)
            btn.setStyleSheet(TOOLBUTTON_STYLE % options)
            if horiz:
                btn.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
            else:
                btn.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Expanding)

        self.setUpdatesEnabled(True)
Exemple #5
0
class XToolBar(QToolBar):
    collapseToggled = Signal(bool)
    
    def __init__(self, *args):
        super(XToolBar, self).__init__(*args)
        
        # set custom properties
        self._collapseButton    = None
        self._collapsable       = True
        self._collapsed         = True
        self._collapsedSize     = 14
        self._autoCollapsible   = False
        self._precollapseSize   = None
        self._shadowed          = False
        self._colored           = False
        
        # set standard options
        self.layout().setSpacing(0)
        self.layout().setContentsMargins(1, 1, 1, 1)
        self.setMovable(False)
        self.clear()
        self.setMouseTracking(True)
        self.setOrientation(Qt.Horizontal)
        self.setCollapsed(False)
    
    def autoCollapsible(self):
        """
        Returns whether or not this toolbar is auto-collapsible.  When
        True, it will enter its collapsed state when the user hovers out
        of the bar.
        
        :return     <bool>
        """
        return self._autoCollapsible
    
    def clear(self):
        """
        Clears out this toolbar from the system.
        """
        # preserve the collapse button
        super(XToolBar, self).clear()
        
        # clears out the toolbar
        if self.isCollapsable():
            self._collapseButton = QToolButton(self)
            self._collapseButton.setAutoRaise(True)
            self._collapseButton.setSizePolicy(QSizePolicy.Expanding,
                                               QSizePolicy.Expanding)
            
            self.addWidget(self._collapseButton)
            self.refreshButton()
            
            # create connection
            self._collapseButton.clicked.connect(self.toggleCollapsed)
        
        elif self._collapseButton:
            self._collapseButton.setParent(None)
            self._collapseButton.deleteLater()
            self._collapseButton = None
    
    def count(self):
        """
        Returns the number of actions linked with this toolbar.
        
        :return     <int>
        """
        return len(self.actions())
    
    def collapseButton(self):
        """
        Returns the collapsing button for this toolbar.
        
        :return     <QToolButton>
        """
        return self._collapseButton
    
    def isCollapsable(self):
        """
        Returns whether or not this toolbar is collapsable.
        
        :return     <bool>
        """
        return self._collapsable
    
    def isCollapsed( self ):
        """
        Returns whether or not this toolbar is in a collapsed state.
        
        :return     <bool>
        """
        return self._collapsed and self.isCollapsable()
    
    def isColored(self):
        """
        Returns whether or not to colorize the buttons on the toolbar
        when they are highlighted.
        
        :return     <bool>
        """
        return self._colored
    
    def isShadowed(self):
        """
        Returns whether or not to show this toolbar with shadows.
        
        :return     <bool>
        """
        return self._shadowed
    
    def refreshButton(self):
        """
        Refreshes the button for this toolbar.
        """
        collapsed   = self.isCollapsed()
        btn         = self._collapseButton
        
        if not btn:
            return
        
        btn.setMaximumSize(MAX_SIZE, MAX_SIZE)
        
        # set up a vertical scrollbar
        if self.orientation() == Qt.Vertical:
            btn.setMaximumHeight(12)
        else:
            btn.setMaximumWidth(12)
            
        icon = ''
        
        # collapse/expand a vertical toolbar
        if self.orientation() == Qt.Vertical:
            if collapsed:
                self.setFixedWidth(self._collapsedSize)
                btn.setMaximumHeight(MAX_SIZE)
                btn.setArrowType(Qt.RightArrow)
            else:
                self.setMaximumWidth(MAX_SIZE)
                self._precollapseSize = None
                btn.setMaximumHeight(12)
                btn.setArrowType(Qt.LeftArrow)
                
        else:
            if collapsed:
                self.setFixedHeight(self._collapsedSize)
                btn.setMaximumWidth(MAX_SIZE)
                btn.setArrowType(Qt.DownArrow)
            else:
                self.setMaximumHeight(1000)
                self._precollapseSize = None
                btn.setMaximumWidth(12)
                btn.setArrowType(Qt.UpArrow)
        
        for index in range(1, self.layout().count()):
            item = self.layout().itemAt(index)
            if not item.widget():
                continue
                
            if collapsed:
                item.widget().setMaximumSize(0, 0)
            else:
                item.widget().setMaximumSize(MAX_SIZE, MAX_SIZE)
        
        if not self.isCollapsable():
            btn.hide()
        else:
            btn.show()

    def resizeEvent(self, event):
        super(XToolBar, self).resizeEvent(event)
        
        if not self._collapsed:
            if self.orientation() == Qt.Vertical:
                self._precollapseSize = self.width()
            else:
                self._precollapseSize = self.height()
    
    def setAutoCollapsible(self, state):
        """
        Sets whether or not this toolbar is auto-collapsible.
        
        :param      state | <bool>
        """
        self._autoCollapsible = state
    
    def setCollapsed(self, state):
        """
        Sets whether or not this toolbar is in a collapsed state.
        
        :return     <bool> changed
        """
        if state == self._collapsed:
            return False
        
        self._collapsed = state
        self.refreshButton()
        
        if not self.signalsBlocked():
            self.collapseToggled.emit(state)
        
        return True
    
    def setCollapsable(self, state):
        """
        Sets whether or not this toolbar is collapsable.
        
        :param      state | <bool>
        """
        if self._collapsable == state:
            return
        
        self._collapsable = state
        self.clear()
    
    def setOrientation( self, orientation ):
        """
        Sets the orientation for this toolbar to the inputed value, and \
        updates the contents margins and collapse button based on the vaule.
        
        :param      orientation | <Qt.Orientation>
        """
        super(XToolBar, self).setOrientation(orientation)
        self.refreshButton()
    
    def setShadowed(self, state):
        """
        Sets whether or not this toolbar is shadowed.
        
        :param      state | <bool>
        """
        self._shadowed = state
        if state:
            self._colored = False
        
        for child in self.findChildren(XToolButton):
            child.setShadowed(state)
    
    def setColored(self, state):
        """
        Sets whether or not this toolbar is shadowed.
        
        :param      state | <bool>
        """
        self._colored = state
        if state:
            self._shadowed = False
        
        for child in self.findChildren(XToolButton):
            child.setColored(state)
    
    def toggleCollapsed( self ):
        """
        Toggles the collapsed state for this toolbar.
        
        :return     <bool> changed
        """
        return self.setCollapsed(not self.isCollapsed())
    
    x_shadowed = Property(bool, isShadowed, setShadowed)
    x_colored = Property(bool, isColored, setColored)