Orange.canvas.gui.ToolBoxTabButton.__paintEventNoStyle() - Code Metrics - hugobuddel/orange3 - Measure and Improve Code Quality continuously with Scrutinizer

__paintEventNoStyle() F
last analyzed 2015-12-08 12:38 UTC

↳ Parent: Orange.canvas.gui.ToolBoxTabButton

Complexity

Conditions

Size

Total Lines

105

Duplication

Lines	0
Ratio	0 %

Metric	Value
cc	13
dl	0
loc	105
rs	2

How to fix Long Method Complexity

"""
==============
Tool Box Widget
==============

A reimplementation of the :class:`QToolBox` widget that keeps all the tabs
in a single :class:`QScrollArea` instance and can keep multiple open tabs.

"""

from collections import namedtuple
from operator import eq, attrgetter

from PyQt4.QtGui import (
# .scrutinizer.yml
before_commands:
    - sudo pip install abc # Python2
    - sudo pip3 install abc # Python3
    QWidget, QFrame, QSizePolicy, QIcon, QFontMetrics, QPainter, QStyle,
    QStyleOptionToolButton, QStyleOptionToolBoxV2, QPalette, QBrush, QPen,
    QColor, QScrollArea, QVBoxLayout, QToolButton, QAction, QActionGroup
)

from PyQt4.QtCore import (
# .scrutinizer.yml
before_commands:
    - sudo pip install abc # Python2
    - sudo pip3 install abc # Python3
    Qt, QObject, QSize, QRect, QPoint, QSignalMapper, QEvent
)

from PyQt4.QtCore import pyqtSignal as Signal, pyqtProperty as Property
# .scrutinizer.yml
before_commands:
    - sudo pip install abc # Python2
    - sudo pip3 install abc # Python3

from .utils import brush_darker

_ToolBoxPage = namedtuple(
    "_ToolBoxPage",
    ["index",
     "widget",
     "action",
     "button"]
    )


FOCUS_OUTLINE_COLOR = "#609ED7"


class ToolBoxTabButton(QToolButton):
    """
    A tab button for an item in a :class:`ToolBox`.
    """

    def setNativeStyling(self, state):
        """
        Render tab buttons as native (or css styled) :class:`QToolButtons`.
        If set to `False` (default) the button is pained using a custom
        paint routine.

        """
        self.__nativeStyling = state
        self.update()

    def nativeStyling(self):
        """
        Use :class:`QStyle`'s to paint the class:`QToolButton` look.
        """
        return self.__nativeStyling

    nativeStyling_ = Property(bool,
                              fget=nativeStyling,
                              fset=setNativeStyling,
                              designable=True)

    def __init__(self, *args, **kwargs):
        self.__nativeStyling = False
        self.position = QStyleOptionToolBoxV2.OnlyOneTab
        self.selected = QStyleOptionToolBoxV2.NotAdjacent

        QToolButton.__init__(self, *args, **kwargs)

    def paintEvent(self, event):
        if self.__nativeStyling:
            QToolButton.paintEvent(self, event)
        else:
            self.__paintEventNoStyle()

    def __paintEventNoStyle(self):
        p = QPainter(self)
        opt = QStyleOptionToolButton()
        self.initStyleOption(opt)

        fm = QFontMetrics(opt.font)
        palette = opt.palette

        # highlight brush is used as the background for the icon and background
        # when the tab is expanded and as mouse hover color (lighter).
        brush_highlight = palette.highlight()
        if opt.state & QStyle.State_Sunken:
            # State 'down' pressed during a mouse press (slightly darker).
            background_brush = brush_darker(brush_highlight, 110)
        elif opt.state & QStyle.State_MouseOver:
            background_brush = brush_darker(brush_highlight, 95)
        elif opt.state & QStyle.State_On:
            background_brush = brush_highlight
        else:
            # The default button brush.
            background_brush = palette.button()

        rect = opt.rect
        icon = opt.icon
        icon_size = opt.iconSize

        # TODO: add shift for pressed as set by the style (PM_ButtonShift...)


        pm = None
        if not icon.isNull():
            if opt.state & QStyle.State_Enabled:
                mode = QIcon.Normal
            else:
                mode = QIcon.Disabled

            pm = opt.icon.pixmap(
                    rect.size().boundedTo(icon_size), mode,
                    QIcon.On if opt.state & QStyle.State_On else QIcon.Off)

        icon_area_rect = QRect(rect)
        icon_area_rect.setRight(int(icon_area_rect.height() * 1.26))

        text_rect = QRect(rect)
        text_rect.setLeft(icon_area_rect.right() + 10)

        # Background  (TODO: Should the tab button have native
        # toolbutton shape, drawn using PE_PanelButtonTool or even
        # QToolBox tab shape)

        # Default outline pen
        pen = QPen(palette.color(QPalette.Mid))

        p.save()
        p.setPen(Qt.NoPen)
        p.setBrush(QBrush(background_brush))
        p.drawRect(rect)

        # Draw the background behind the icon if the background_brush
        # is different.
        if not opt.state & QStyle.State_On:
            p.setBrush(brush_highlight)
            p.drawRect(icon_area_rect)
            # Line between the icon and text
            p.setPen(pen)
            p.drawLine(icon_area_rect.topRight(),
                       icon_area_rect.bottomRight())

        if opt.state & QStyle.State_HasFocus:
            # Set the focus frame pen and draw the border
            pen = QPen(QColor(FOCUS_OUTLINE_COLOR))
            p.setPen(pen)
            p.setBrush(Qt.NoBrush)
            # Adjust for pen
            rect = rect.adjusted(0, 0, -1, -1)
            p.drawRect(rect)

        else:
            p.setPen(pen)
            # Draw the top/bottom border
            if self.position == QStyleOptionToolBoxV2.OnlyOneTab or \
                    self.position == QStyleOptionToolBoxV2.Beginning or \
                    self.selected & \
                        QStyleOptionToolBoxV2.PreviousIsSelected:

                p.drawLine(rect.topLeft(), rect.topRight())

            p.drawLine(rect.bottomLeft(), rect.bottomRight())

        p.restore()

        p.save()
        text = fm.elidedText(opt.text, Qt.ElideRight, text_rect.width())
        p.setPen(QPen(palette.color(QPalette.ButtonText)))
        p.setFont(opt.font)

        p.drawText(text_rect,
                   int(Qt.AlignVCenter | Qt.AlignLeft) | \
                   int(Qt.TextSingleLine),
                   text)
        if pm:
            pm_rect = QRect(QPoint(0, 0), pm.size())
            centered_rect = QRect(pm_rect)
            centered_rect.moveCenter(icon_area_rect.center())
            p.drawPixmap(centered_rect, pm, pm_rect)
        p.restore()


class _ToolBoxScrollArea(QScrollArea):
    def eventFilter(self, obj, event):
        if obj is self.widget() and event.type() == QEvent.Resize:
            if event.size() == event.oldSize() and self.widgetResizable():
                # This is driving me insane. This should not have happened.
                # Before the event is sent QWidget specifically makes sure the
                # sizes are different, but somehow I still get this, and enter
                # an infinite recursion if I enter QScrollArea.eventFilter.
                # I can only duplicate this on one development machine a
                # Mac OSX using fink and Qt 4.7.3
                return False

        return QScrollArea.eventFilter(self, obj, event)


class ToolBox(QFrame):
    """
    A tool box widget.
    """
    # Emitted when a tab is toggled.
    tabToogled = Signal(int, bool)

    def setExclusive(self, exclusive):
        """
        Set exclusive tabs (only one tab can be open at a time).
        """
        if self.__exclusive != exclusive:
            self.__exclusive = exclusive
            self.__tabActionGroup.setExclusive(exclusive)
            checked = self.__tabActionGroup.checkedAction()
            if checked is None:
                # The action group can be out of sync with the actions state
                # when switching between exclusive states.
                actions_checked = [page.action for page in self.__pages
                                   if page.action.isChecked()]
                if actions_checked:
                    checked = actions_checked[0]

            # Trigger/toggle remaining open pages
            if exclusive and checked is not None:
                for page in self.__pages:
                    if checked != page.action and page.action.isChecked():
                        page.action.trigger()

    def exclusive(self):
        """
        Are the tabs in the toolbox exclusive.
        """
        return self.__exclusive

    exclusive_ = Property(bool,
                          fget=exclusive,
                          fset=setExclusive,
                          designable=True,
                          doc="Exclusive tabs")

    def __init__(self, parent=None, **kwargs):
        QFrame.__init__(self, parent, **kwargs)

        self.__pages = []
        self.__tabButtonHeight = -1
        self.__tabIconSize = QSize()
        self.__exclusive = False
        self.__setupUi()

    def __setupUi(self):
        layout = QVBoxLayout()
        layout.setContentsMargins(0, 0, 0, 0)

        # Scroll area for the contents.
        self.__scrollArea = \
                _ToolBoxScrollArea(self, objectName="toolbox-scroll-area")

        self.__scrollArea.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
        self.__scrollArea.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.__scrollArea.setSizePolicy(QSizePolicy.MinimumExpanding,
                                        QSizePolicy.MinimumExpanding)
        self.__scrollArea.setFrameStyle(QScrollArea.NoFrame)
        self.__scrollArea.setWidgetResizable(True)

        # A widget with all of the contents.
        # The tabs/contents are placed in the layout inside this widget
        self.__contents = QWidget(self.__scrollArea,
                                  objectName="toolbox-contents")

        # The layout where all the tab/pages are placed
        self.__contentsLayout = QVBoxLayout()
        self.__contentsLayout.setContentsMargins(0, 0, 0, 0)
        self.__contentsLayout.setSizeConstraint(QVBoxLayout.SetMinAndMaxSize)
        self.__contentsLayout.setSpacing(0)

        self.__contents.setLayout(self.__contentsLayout)

        self.__scrollArea.setWidget(self.__contents)

        layout.addWidget(self.__scrollArea)

        self.setLayout(layout)
        self.setSizePolicy(QSizePolicy.Fixed,
                           QSizePolicy.MinimumExpanding)

        self.__tabActionGroup = \
                QActionGroup(self, objectName="toolbox-tab-action-group")

        self.__tabActionGroup.setExclusive(self.__exclusive)

        self.__actionMapper = QSignalMapper(self)
        self.__actionMapper.mapped[QObject].connect(self.__onTabActionToogled)

    def setTabButtonHeight(self, height):
        """
        Set the tab button height.
        """
        if self.__tabButtonHeight != height:
            self.__tabButtonHeight = height
            for page in self.__pages:
                page.button.setFixedHeight(height)

    def tabButtonHeight(self):
        """
        Return the tab button height.
        """
        return self.__tabButtonHeight

    def setTabIconSize(self, size):
        """
        Set the tab button icon size.
        """
        if self.__tabIconSize != size:
            self.__tabIconSize = size
            for page in self.__pages:
                page.button.setIconSize(size)

    def tabIconSize(self):
        """
        Return the tab icon size.
        """
        return self.__tabIconSize

    def tabButton(self, index):
        """
        Return the tab button at `index`
        """
        return self.__pages[index].button

    def tabAction(self, index):
        """
        Return open/close action for the tab at `index`.
        """
        return self.__pages[index].action

    def addItem(self, widget, text, icon=None, toolTip=None):
        """
        Append the `widget` in a new tab and return its index.

        Parameters
        ----------
        widget : :class:`QWidget`
            A widget to be inserted. The toolbox takes ownership
            of the widget.

        text : str
            Name/title of the new tab.

        icon : :class:`QIcon`, optional
            An icon for the tab button.

        toolTip : str, optional
            Tool tip for the tab button.

        """
        return self.insertItem(self.count(), widget, text, icon, toolTip)

    def insertItem(self, index, widget, text, icon=None, toolTip=None):
        """
        Insert the `widget` in a new tab at position `index`.

        See also
        --------
        ToolBox.addItem

        """
        button = self.createTabButton(widget, text, icon, toolTip)

        self.__contentsLayout.insertWidget(index * 2, button)
        self.__contentsLayout.insertWidget(index * 2 + 1, widget)

        widget.hide()

        page = _ToolBoxPage(index, widget, button.defaultAction(), button)
        self.__pages.insert(index, page)

        for i in range(index + 1, self.count()):
            self.__pages[i] = self.__pages[i]._replace(index=i)

        self.__updatePositions()

        # Show (open) the first tab.
        if self.count() == 1 and index == 0:
            page.action.trigger()

        self.__updateSelected()

        self.updateGeometry()
        return index

    def removeItem(self, index):
        """
        Remove the widget at `index`.

        .. note:: The widget hidden but is is not deleted.

        """
        self.__contentsLayout.takeAt(2 * index + 1)
        self.__contentsLayout.takeAt(2 * index)
        page = self.__pages.pop(index)

        # Update the page indexes
        for i in range(index, self.count()):
            self.__pages[i] = self.__pages[i]._replace(index=i)

        page.button.deleteLater()

        # Hide the widget and reparent to self
        # This follows QToolBox.removeItem
        page.widget.hide()
        page.widget.setParent(self)

        self.__updatePositions()
        self.__updateSelected()

        self.updateGeometry()

    def count(self):
        """
        Return the number of widgets inserted in the toolbox.
        """
        return len(self.__pages)

    def widget(self, index):
        """
        Return the widget at `index`.
        """
        return self.__pages[index].widget

    def createTabButton(self, widget, text, icon=None, toolTip=None):

        """
        Create the tab button for `widget`.
        """
        action = QAction(text, self)
        action.setCheckable(True)

        if icon:
            action.setIcon(icon)

        if toolTip:
            action.setToolTip(toolTip)
        self.__tabActionGroup.addAction(action)
        self.__actionMapper.setMapping(action, action)
        action.toggled.connect(self.__actionMapper.map)

        button = ToolBoxTabButton(self, objectName="toolbox-tab-button")
        button.setDefaultAction(action)
        button.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
        button.setSizePolicy(QSizePolicy.Expanding,
                             QSizePolicy.Fixed)

        if self.__tabIconSize.isValid():
            button.setIconSize(self.__tabIconSize)

        if self.__tabButtonHeight > 0:
            button.setFixedHeight(self.__tabButtonHeight)

        return button

    def ensureWidgetVisible(self, child, xmargin=50, ymargin=50):
        """
        Scroll the contents so child widget instance is visible inside
        the viewport.

        """
        self.__scrollArea.ensureWidgetVisible(child, xmargin, ymargin)

    def sizeHint(self):
        hint = self.__contentsLayout.sizeHint()

        if self.count():
            # Compute max width of hidden widgets also.
            scroll = self.__scrollArea
            scroll_w = scroll.verticalScrollBar().sizeHint().width()
            frame_w = self.frameWidth() * 2 + scroll.frameWidth() * 2
            max_w = max([p.widget.sizeHint().width() for p in self.__pages])
            hint = QSize(max(max_w, hint.width()) + scroll_w + frame_w,
                         hint.height())

        return QSize(200, 200).expandedTo(hint)

    def __onTabActionToogled(self, action):
        page = find(self.__pages, action, key=attrgetter("action"))
        on = action.isChecked()
        page.widget.setVisible(on)
        index = page.index

        if index > 0:
            # Update the `previous` tab buttons style hints
            previous = self.__pages[index - 1].button
            flag = QStyleOptionToolBoxV2.NextIsSelected
            if on:
                previous.selected |= flag
            else:
                previous.selected &= ~flag

            previous.update()

        if index < self.count() - 1:
            next = self.__pages[index + 1].button

            flag = QStyleOptionToolBoxV2.PreviousIsSelected
            if on:
                next.selected |= flag
            else:
                next.selected &= ~flag

            next.update()

        self.tabToogled.emit(index, on)

        self.__contentsLayout.invalidate()

    def __updateSelected(self):
        """Update the tab buttons selected style flags.
        """
        if self.count() == 0:
            return

        opt = QStyleOptionToolBoxV2

        def update(button, next_sel, prev_sel):
            if next_sel:
                button.selected |= opt.NextIsSelected
            else:
                button.selected &= ~opt.NextIsSelected

            if prev_sel:
                button.selected |= opt.PreviousIsSelected
            else:
                button.selected &= ~ opt.PreviousIsSelected

            button.update()

        if self.count() == 1:
            update(self.__pages[0].button, False, False)
        elif self.count() >= 2:
            pages = self.__pages
            for i in range(1, self.count() - 1):
                update(pages[i].button,
                       pages[i + 1].action.isChecked(),
                       pages[i - 1].action.isChecked())

    def __updatePositions(self):
        """Update the tab buttons position style flags.
        """
        if self.count() == 0:
            return
        elif self.count() == 1:
            self.__pages[0].button.position = QStyleOptionToolBoxV2.OnlyOneTab
        else:
            self.__pages[0].button.position = QStyleOptionToolBoxV2.Beginning
            self.__pages[-1].button.position = QStyleOptionToolBoxV2.End
            for p in self.__pages[1:-1]:
                p.button.position = QStyleOptionToolBoxV2.Middle

        for p in self.__pages:
            p.button.update()


def identity(arg):
    return arg


def find(iterable, *what, **kwargs):
    """
    find(iterable, [what, [key=None, [predicate=operator.eq]]])
    """
    if what:
        what = what[0]
    key, predicate = kwargs.get("key", identity), kwargs.get("predicate", eq)
    for item in iterable:
        item_key = key(item)
        if predicate(item_key, what):
            return item
    else:

        raise ValueError(what)


GitHub Access Token became invalid

__paintEventNoStyle() F
last analyzed 2015-12-08 12:38 UTC

Complexity

Size

Duplication

How to fix Long Method Complexity

Long Method

Complexity

1. Missing Dependencies

2. Missing init.py files

1. Missing Dependencies

2. Missing init.py files

1. Missing Dependencies

2. Missing init.py files

1			"""
2			==============
3			Tool Box Widget
4			==============
5
6			A reimplementation of the :class:`QToolBox` widget that keeps all the tabs
7			in a single :class:`QScrollArea` instance and can keep multiple open tabs.
8
9			"""
10
11			from collections import namedtuple
12			from operator import eq, attrgetter
13
14			from PyQt4.QtGui import (
			0 ignored issues – show Configuration introduced 2015-12-02 09:15 UTC by Report Bug Copy Issue Report The import `PyQt4.QtGui` could not be resolved. This can be caused by one of the following: 1. Missing Dependencies This error could indicate a configuration issue of Pylint. Make sure that your libraries are available by adding the necessary commands. # .scrutinizer.yml before_commands: - sudo pip install abc # Python2 - sudo pip3 install abc # Python3 Tip: We are currently not using virtualenv to run pylint, when installing your modules make sure to use the command for the correct version. 2. Missing __init__.py files This error could also result from missing `__init__.py` files in your module folders. Make sure that you place one file in each sub-folder. Loading history...
15			QWidget, QFrame, QSizePolicy, QIcon, QFontMetrics, QPainter, QStyle,
16			QStyleOptionToolButton, QStyleOptionToolBoxV2, QPalette, QBrush, QPen,
17			QColor, QScrollArea, QVBoxLayout, QToolButton, QAction, QActionGroup
18			)
19
20			from PyQt4.QtCore import (
			0 ignored issues – show Configuration introduced 2015-12-02 09:15 UTC by Report Bug Copy Issue Report The import `PyQt4.QtCore` could not be resolved. This can be caused by one of the following: 1. Missing Dependencies This error could indicate a configuration issue of Pylint. Make sure that your libraries are available by adding the necessary commands. # .scrutinizer.yml before_commands: - sudo pip install abc # Python2 - sudo pip3 install abc # Python3 Tip: We are currently not using virtualenv to run pylint, when installing your modules make sure to use the command for the correct version. 2. Missing __init__.py files This error could also result from missing `__init__.py` files in your module folders. Make sure that you place one file in each sub-folder. Loading history...
21			Qt, QObject, QSize, QRect, QPoint, QSignalMapper, QEvent
22			)
23
24			from PyQt4.QtCore import pyqtSignal as Signal, pyqtProperty as Property
			0 ignored issues – show Configuration introduced 2015-12-02 09:15 UTC by Report Bug Copy Issue Report The import `PyQt4.QtCore` could not be resolved. This can be caused by one of the following: 1. Missing Dependencies This error could indicate a configuration issue of Pylint. Make sure that your libraries are available by adding the necessary commands. # .scrutinizer.yml before_commands: - sudo pip install abc # Python2 - sudo pip3 install abc # Python3 Tip: We are currently not using virtualenv to run pylint, when installing your modules make sure to use the command for the correct version. 2. Missing __init__.py files This error could also result from missing `__init__.py` files in your module folders. Make sure that you place one file in each sub-folder. Loading history...
25
26			from .utils import brush_darker
27
28			_ToolBoxPage = namedtuple(
29			"_ToolBoxPage",
30			["index",
31			"widget",
32			"action",
33			"button"]
34			)
35
36
37			FOCUS_OUTLINE_COLOR = "#609ED7"
38
39
40			class ToolBoxTabButton(QToolButton):
41			"""
42			A tab button for an item in a :class:`ToolBox`.
43			"""
44
45			def setNativeStyling(self, state):
46			"""
47			Render tab buttons as native (or css styled) :class:`QToolButtons`.
48			If set to `False` (default) the button is pained using a custom
49			paint routine.
50
51			"""
52			self.__nativeStyling = state
53			self.update()
54
55			def nativeStyling(self):
56			"""
57			Use :class:`QStyle`'s to paint the class:`QToolButton` look.
58			"""
59			return self.__nativeStyling
60
61			nativeStyling_ = Property(bool,
62			fget=nativeStyling,
63			fset=setNativeStyling,
64			designable=True)
65
66			def __init__(self, args, *kwargs):
67			self.__nativeStyling = False
68			self.position = QStyleOptionToolBoxV2.OnlyOneTab
69			self.selected = QStyleOptionToolBoxV2.NotAdjacent
70
71			QToolButton.__init__(self, args, *kwargs)
72
73			def paintEvent(self, event):
74			if self.__nativeStyling:
75			QToolButton.paintEvent(self, event)
76			else:
77			self.__paintEventNoStyle()
78
79			def __paintEventNoStyle(self):
80			p = QPainter(self)
81			opt = QStyleOptionToolButton()
82			self.initStyleOption(opt)
83
84			fm = QFontMetrics(opt.font)
85			palette = opt.palette
86
87			# highlight brush is used as the background for the icon and background
88			# when the tab is expanded and as mouse hover color (lighter).
89			brush_highlight = palette.highlight()
90			if opt.state & QStyle.State_Sunken:
91			# State 'down' pressed during a mouse press (slightly darker).
92			background_brush = brush_darker(brush_highlight, 110)
93			elif opt.state & QStyle.State_MouseOver:
94			background_brush = brush_darker(brush_highlight, 95)
95			elif opt.state & QStyle.State_On:
96			background_brush = brush_highlight
97			else:
98			# The default button brush.
99			background_brush = palette.button()
100
101			rect = opt.rect
102			icon = opt.icon
103			icon_size = opt.iconSize
104
105			# TODO: add shift for pressed as set by the style (PM_ButtonShift...)
			0 ignored issues – show Coding Style introduced 2015-12-02 09:15 UTC by Report Bug Copy Issue Report `TODO` and `FIXME` comments should generally be avoided. Loading history...
106
107			pm = None
108			if not icon.isNull():
109			if opt.state & QStyle.State_Enabled:
110			mode = QIcon.Normal
111			else:
112			mode = QIcon.Disabled
113
114			pm = opt.icon.pixmap(
115			rect.size().boundedTo(icon_size), mode,
116			QIcon.On if opt.state & QStyle.State_On else QIcon.Off)
117
118			icon_area_rect = QRect(rect)
119			icon_area_rect.setRight(int(icon_area_rect.height() * 1.26))
120
121			text_rect = QRect(rect)
122			text_rect.setLeft(icon_area_rect.right() + 10)
123
124			# Background (TODO: Should the tab button have native
125			# toolbutton shape, drawn using PE_PanelButtonTool or even
126			# QToolBox tab shape)
127
128			# Default outline pen
129			pen = QPen(palette.color(QPalette.Mid))
130
131			p.save()
132			p.setPen(Qt.NoPen)
133			p.setBrush(QBrush(background_brush))
134			p.drawRect(rect)
135
136			# Draw the background behind the icon if the background_brush
137			# is different.
138			if not opt.state & QStyle.State_On:
139			p.setBrush(brush_highlight)
140			p.drawRect(icon_area_rect)
141			# Line between the icon and text
142			p.setPen(pen)
143			p.drawLine(icon_area_rect.topRight(),
144			icon_area_rect.bottomRight())
145
146			if opt.state & QStyle.State_HasFocus:
147			# Set the focus frame pen and draw the border
148			pen = QPen(QColor(FOCUS_OUTLINE_COLOR))
149			p.setPen(pen)
150			p.setBrush(Qt.NoBrush)
151			# Adjust for pen
152			rect = rect.adjusted(0, 0, -1, -1)
153			p.drawRect(rect)
154
155			else:
156			p.setPen(pen)
157			# Draw the top/bottom border
158			if self.position == QStyleOptionToolBoxV2.OnlyOneTab or \
159			self.position == QStyleOptionToolBoxV2.Beginning or \
160			self.selected & \
161			QStyleOptionToolBoxV2.PreviousIsSelected:
162
163			p.drawLine(rect.topLeft(), rect.topRight())
164
165			p.drawLine(rect.bottomLeft(), rect.bottomRight())
166
167			p.restore()
168
169			p.save()
170			text = fm.elidedText(opt.text, Qt.ElideRight, text_rect.width())
171			p.setPen(QPen(palette.color(QPalette.ButtonText)))
172			p.setFont(opt.font)
173
174			p.drawText(text_rect,
175			int(Qt.AlignVCenter \| Qt.AlignLeft) \| \
176			int(Qt.TextSingleLine),
177			text)
178			if pm:
179			pm_rect = QRect(QPoint(0, 0), pm.size())
180			centered_rect = QRect(pm_rect)
181			centered_rect.moveCenter(icon_area_rect.center())
182			p.drawPixmap(centered_rect, pm, pm_rect)
183			p.restore()
184
185
186			class _ToolBoxScrollArea(QScrollArea):
187			def eventFilter(self, obj, event):
188			if obj is self.widget() and event.type() == QEvent.Resize:
189			if event.size() == event.oldSize() and self.widgetResizable():
190			# This is driving me insane. This should not have happened.
191			# Before the event is sent QWidget specifically makes sure the
192			# sizes are different, but somehow I still get this, and enter
193			# an infinite recursion if I enter QScrollArea.eventFilter.
194			# I can only duplicate this on one development machine a
195			# Mac OSX using fink and Qt 4.7.3
196			return False
197
198			return QScrollArea.eventFilter(self, obj, event)
199
200
201			class ToolBox(QFrame):
202			"""
203			A tool box widget.
204			"""
205			# Emitted when a tab is toggled.
206			tabToogled = Signal(int, bool)
207
208			def setExclusive(self, exclusive):
209			"""
210			Set exclusive tabs (only one tab can be open at a time).
211			"""
212			if self.__exclusive != exclusive:
213			self.__exclusive = exclusive
214			self.__tabActionGroup.setExclusive(exclusive)
215			checked = self.__tabActionGroup.checkedAction()
216			if checked is None:
217			# The action group can be out of sync with the actions state
218			# when switching between exclusive states.
219			actions_checked = [page.action for page in self.__pages
220			if page.action.isChecked()]
221			if actions_checked:
222			checked = actions_checked[0]
223
224			# Trigger/toggle remaining open pages
225			if exclusive and checked is not None:
226			for page in self.__pages:
227			if checked != page.action and page.action.isChecked():
228			page.action.trigger()
229
230			def exclusive(self):
231			"""
232			Are the tabs in the toolbox exclusive.
233			"""
234			return self.__exclusive
235
236			exclusive_ = Property(bool,
237			fget=exclusive,
238			fset=setExclusive,
239			designable=True,
240			doc="Exclusive tabs")
241
242			def __init__(self, parent=None, **kwargs):
243			QFrame.__init__(self, parent, **kwargs)
244
245			self.__pages = []
246			self.__tabButtonHeight = -1
247			self.__tabIconSize = QSize()
248			self.__exclusive = False
249			self.__setupUi()
250
251			def __setupUi(self):
252			layout = QVBoxLayout()
253			layout.setContentsMargins(0, 0, 0, 0)
254
255			# Scroll area for the contents.
256			self.__scrollArea = \
257			_ToolBoxScrollArea(self, objectName="toolbox-scroll-area")
258
259			self.__scrollArea.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
260			self.__scrollArea.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
261			self.__scrollArea.setSizePolicy(QSizePolicy.MinimumExpanding,
262			QSizePolicy.MinimumExpanding)
263			self.__scrollArea.setFrameStyle(QScrollArea.NoFrame)
264			self.__scrollArea.setWidgetResizable(True)
265
266			# A widget with all of the contents.
267			# The tabs/contents are placed in the layout inside this widget
268			self.__contents = QWidget(self.__scrollArea,
269			objectName="toolbox-contents")
270
271			# The layout where all the tab/pages are placed
272			self.__contentsLayout = QVBoxLayout()
273			self.__contentsLayout.setContentsMargins(0, 0, 0, 0)
274			self.__contentsLayout.setSizeConstraint(QVBoxLayout.SetMinAndMaxSize)
275			self.__contentsLayout.setSpacing(0)
276
277			self.__contents.setLayout(self.__contentsLayout)
278
279			self.__scrollArea.setWidget(self.__contents)
280
281			layout.addWidget(self.__scrollArea)
282
283			self.setLayout(layout)
284			self.setSizePolicy(QSizePolicy.Fixed,
285			QSizePolicy.MinimumExpanding)
286
287			self.__tabActionGroup = \
288			QActionGroup(self, objectName="toolbox-tab-action-group")
289
290			self.__tabActionGroup.setExclusive(self.__exclusive)
291
292			self.__actionMapper = QSignalMapper(self)
293			self.__actionMapper.mapped[QObject].connect(self.__onTabActionToogled)
294
295			def setTabButtonHeight(self, height):
296			"""
297			Set the tab button height.
298			"""
299			if self.__tabButtonHeight != height:
300			self.__tabButtonHeight = height
301			for page in self.__pages:
302			page.button.setFixedHeight(height)
303
304			def tabButtonHeight(self):
305			"""
306			Return the tab button height.
307			"""
308			return self.__tabButtonHeight
309
310			def setTabIconSize(self, size):
311			"""
312			Set the tab button icon size.
313			"""
314			if self.__tabIconSize != size:
315			self.__tabIconSize = size
316			for page in self.__pages:
317			page.button.setIconSize(size)
318
319			def tabIconSize(self):
320			"""
321			Return the tab icon size.
322			"""
323			return self.__tabIconSize
324
325			def tabButton(self, index):
326			"""
327			Return the tab button at `index`
328			"""
329			return self.__pages[index].button
330
331			def tabAction(self, index):
332			"""
333			Return open/close action for the tab at `index`.
334			"""
335			return self.__pages[index].action
336
337			def addItem(self, widget, text, icon=None, toolTip=None):
338			"""
339			Append the `widget` in a new tab and return its index.
340
341			Parameters
342			----------
343			widget : :class:`QWidget`
344			A widget to be inserted. The toolbox takes ownership
345			of the widget.
346
347			text : str
348			Name/title of the new tab.
349
350			icon : :class:`QIcon`, optional
351			An icon for the tab button.
352
353			toolTip : str, optional
354			Tool tip for the tab button.
355
356			"""
357			return self.insertItem(self.count(), widget, text, icon, toolTip)
358
359			def insertItem(self, index, widget, text, icon=None, toolTip=None):
360			"""
361			Insert the `widget` in a new tab at position `index`.
362
363			See also
364			--------
365			ToolBox.addItem
366
367			"""
368			button = self.createTabButton(widget, text, icon, toolTip)
369
370			self.__contentsLayout.insertWidget(index * 2, button)
371			self.__contentsLayout.insertWidget(index * 2 + 1, widget)
372
373			widget.hide()
374
375			page = _ToolBoxPage(index, widget, button.defaultAction(), button)
376			self.__pages.insert(index, page)
377
378			for i in range(index + 1, self.count()):
379			self.__pages[i] = self.__pages[i]._replace(index=i)
380
381			self.__updatePositions()
382
383			# Show (open) the first tab.
384			if self.count() == 1 and index == 0:
385			page.action.trigger()
386
387			self.__updateSelected()
388
389			self.updateGeometry()
390			return index
391
392			def removeItem(self, index):
393			"""
394			Remove the widget at `index`.
395
396			.. note:: The widget hidden but is is not deleted.
397
398			"""
399			self.__contentsLayout.takeAt(2 * index + 1)
400			self.__contentsLayout.takeAt(2 * index)
401			page = self.__pages.pop(index)
402
403			# Update the page indexes
404			for i in range(index, self.count()):
405			self.__pages[i] = self.__pages[i]._replace(index=i)
406
407			page.button.deleteLater()
408
409			# Hide the widget and reparent to self
410			# This follows QToolBox.removeItem
411			page.widget.hide()
412			page.widget.setParent(self)
413
414			self.__updatePositions()
415			self.__updateSelected()
416
417			self.updateGeometry()
418
419			def count(self):
420			"""
421			Return the number of widgets inserted in the toolbox.
422			"""
423			return len(self.__pages)
424
425			def widget(self, index):
426			"""
427			Return the widget at `index`.
428			"""
429			return self.__pages[index].widget
430
431			def createTabButton(self, widget, text, icon=None, toolTip=None):
			0 ignored issues – show Unused Code introduced 2015-12-02 09:15 UTC by Report Bug Copy Issue Report The argument `widget` seems to be unused. Loading history...
432			"""
433			Create the tab button for `widget`.
434			"""
435			action = QAction(text, self)
436			action.setCheckable(True)
437
438			if icon:
439			action.setIcon(icon)
440
441			if toolTip:
442			action.setToolTip(toolTip)
443			self.__tabActionGroup.addAction(action)
444			self.__actionMapper.setMapping(action, action)
445			action.toggled.connect(self.__actionMapper.map)
446
447			button = ToolBoxTabButton(self, objectName="toolbox-tab-button")
448			button.setDefaultAction(action)
449			button.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
450			button.setSizePolicy(QSizePolicy.Expanding,
451			QSizePolicy.Fixed)
452
453			if self.__tabIconSize.isValid():
454			button.setIconSize(self.__tabIconSize)
455
456			if self.__tabButtonHeight > 0:
457			button.setFixedHeight(self.__tabButtonHeight)
458
459			return button
460
461			def ensureWidgetVisible(self, child, xmargin=50, ymargin=50):
462			"""
463			Scroll the contents so child widget instance is visible inside
464			the viewport.
465
466			"""
467			self.__scrollArea.ensureWidgetVisible(child, xmargin, ymargin)
468
469			def sizeHint(self):
470			hint = self.__contentsLayout.sizeHint()
471
472			if self.count():
473			# Compute max width of hidden widgets also.
474			scroll = self.__scrollArea
475			scroll_w = scroll.verticalScrollBar().sizeHint().width()
476			frame_w = self.frameWidth() * 2 + scroll.frameWidth() * 2
477			max_w = max([p.widget.sizeHint().width() for p in self.__pages])
478			hint = QSize(max(max_w, hint.width()) + scroll_w + frame_w,
479			hint.height())
480
481			return QSize(200, 200).expandedTo(hint)
482
483			def __onTabActionToogled(self, action):
484			page = find(self.__pages, action, key=attrgetter("action"))
485			on = action.isChecked()
486			page.widget.setVisible(on)
487			index = page.index
488
489			if index > 0:
490			# Update the `previous` tab buttons style hints
491			previous = self.__pages[index - 1].button
492			flag = QStyleOptionToolBoxV2.NextIsSelected
493			if on:
494			previous.selected \|= flag
495			else:
496			previous.selected &= ~flag
497
498			previous.update()
499
500			if index < self.count() - 1:
501			next = self.__pages[index + 1].button
			0 ignored issues – show Bug Best Practice introduced 2015-12-02 09:15 UTC by Report Bug Copy Issue Report This seems to re-define the built-in `next`. It is generally discouraged to redefine built-ins as this makes code very hard to read. Loading history...
502			flag = QStyleOptionToolBoxV2.PreviousIsSelected
503			if on:
504			next.selected \|= flag
505			else:
506			next.selected &= ~flag
507
508			next.update()
509
510			self.tabToogled.emit(index, on)
511
512			self.__contentsLayout.invalidate()
513
514			def __updateSelected(self):
515			"""Update the tab buttons selected style flags.
516			"""
517			if self.count() == 0:
518			return
519
520			opt = QStyleOptionToolBoxV2
521
522			def update(button, next_sel, prev_sel):
523			if next_sel:
524			button.selected \|= opt.NextIsSelected
525			else:
526			button.selected &= ~opt.NextIsSelected
527
528			if prev_sel:
529			button.selected \|= opt.PreviousIsSelected
530			else:
531			button.selected &= ~ opt.PreviousIsSelected
532
533			button.update()
534
535			if self.count() == 1:
536			update(self.__pages[0].button, False, False)
537			elif self.count() >= 2:
538			pages = self.__pages
539			for i in range(1, self.count() - 1):
540			update(pages[i].button,
541			pages[i + 1].action.isChecked(),
542			pages[i - 1].action.isChecked())
543
544			def __updatePositions(self):
545			"""Update the tab buttons position style flags.
546			"""
547			if self.count() == 0:
548			return
549			elif self.count() == 1:
550			self.__pages[0].button.position = QStyleOptionToolBoxV2.OnlyOneTab
551			else:
552			self.__pages[0].button.position = QStyleOptionToolBoxV2.Beginning
553			self.__pages[-1].button.position = QStyleOptionToolBoxV2.End
554			for p in self.__pages[1:-1]:
555			p.button.position = QStyleOptionToolBoxV2.Middle
556
557			for p in self.__pages:
558			p.button.update()
559
560
561			def identity(arg):
562			return arg
563
564
565			def find(iterable, what, *kwargs):
566			"""
567			find(iterable, [what, [key=None, [predicate=operator.eq]]])
568			"""
569			if what:
570			what = what[0]
571			key, predicate = kwargs.get("key", identity), kwargs.get("predicate", eq)
572			for item in iterable:
573			item_key = key(item)
574			if predicate(item_key, what):
575			return item
576			else:
			0 ignored issues – show Bug introduced 2015-12-02 09:15 UTC by Report Bug Copy Issue Report The `else` clause is not necessary as the loop does not contain a `break` statement. If the loop cannot exit early through the use of `break`, the `else` part will always be executed. You can therefore just leave off the `else`. Loading history...
577			raise ValueError(what)
578

hugobuddel / orange3

GitHub Access Token became invalid

__paintEventNoStyle() F last analyzed 2015-12-08 12:38 UTC

Complexity

Size

Duplication

How to fix Long Method Complexity

Long Method

Complexity

1. Missing Dependencies

2. Missing __init__.py files

1. Missing Dependencies

2. Missing __init__.py files

1. Missing Dependencies

2. Missing __init__.py files

Duplication Side-by-Side

Filter issues like

__paintEventNoStyle() F
last analyzed 2015-12-08 12:38 UTC

2. Missing init.py files

2. Missing init.py files

2. Missing init.py files