def sizeHint(self):
"""
Reimplemented from `QPushButton.sizeHint`.
Returns
-------
sh : QSize
"""
sh = super().sizeHint()
option = QStyleOptionButton()
self.initStyleOption(option)
style = self.style()
fm = option.fontMetrics
if option.iconSize.isValid():
icsize = option.iconSize
icsize.setWidth(icsize.width() + 4)
else:
icsize = QSize()
for text in self.__textChoiceList:
option.text = text
size = fm.size(Qt.TextShowMnemonic, text)
if not icsize.isNull():
size.setWidth(size.width() + icsize.width())
size.setHeight(max(size.height(), icsize.height()))
sh = sh.expandedTo(
style.sizeFromContents(QStyle.CT_PushButton, option,
size, self))
return sh
def __updatePixmap(self):
"""
Update the cached shadow pixmap.
"""
rect_size = QSize(50, 50)
left = top = right = bottom = self.radius_
# Size of the pixmap.
pixmap_size = QSize(rect_size.width() + left + right,
rect_size.height() + top + bottom)
shadow_rect = QRect(QPoint(left, top), rect_size)
pixmap = QPixmap(pixmap_size)
pixmap.fill(QColor(0, 0, 0, 0))
rect_fill_color = self.palette().color(QPalette.Window)
pixmap = render_drop_shadow_frame(
pixmap,
QRectF(shadow_rect),
shadow_color=self.color_,
offset=QPointF(0, 0),
radius=self.radius_,
rect_fill_color=rect_fill_color
)
self.__shadowPixmap = pixmap
self.update()
def sizeHint(self, option, index):
size = QStyledItemDelegate.sizeHint(self, option, index)
parent = self.parent()
item = parent.itemFromIndex(index)
widget = parent.itemWidget(item, 0)
if widget:
size = QSize(size.width(), widget.sizeHint().height() / 2)
return size
def __init__(self, *args):
QComboBox.__init__(self, *args)
self.paletteImg = []
self.cachedPalettes = []
## self.setItemDelegate(PaletteItemDelegate(self, self))
size = self.sizeHint()
size = QSize(size.width() * 2 / 3, size.height() * 2 / 3)
self.setIconSize(size)
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 __init__(self, parent=None, icon=None, iconSize=None, **kwargs):
QGraphicsItem.__init__(self, parent, **kwargs)
self.setFlag(QGraphicsItem.ItemUsesExtendedStyleOption, True)
if icon is None:
icon = QIcon()
if iconSize is None:
style = QApplication.instance().style()
size = style.pixelMetric(style.PM_LargeIconSize)
iconSize = QSize(size, size)
self.__transformationMode = Qt.SmoothTransformation
self.__iconSize = QSize(iconSize)
self.__icon = QIcon(icon)
self._opacity = 1
self.anim = QPropertyAnimation(self, b"opacity")
self.anim.setDuration(350)
self.anim.setStartValue(1)
self.anim.setKeyValueAt(0.5, 0)
self.anim.setEndValue(1)
self.anim.setEasingCurve(QEasingCurve.OutQuad)
self.anim.setLoopCount(5)
def __init__(self, parent=None, icon=QIcon(), iconSize=QSize(), **kwargs):
sizePolicy = kwargs.pop("sizePolicy", QSizePolicy(QSizePolicy.Fixed,
QSizePolicy.Fixed))
super().__init__(parent, **kwargs)
self.__icon = QIcon(icon)
self.__iconSize = QSize(iconSize)
self.setSizePolicy(sizePolicy)
def __init__(self, parent=None, **kwargs):
super().__init__(parent, **kwargs)
self.__pages = []
self.__tabButtonHeight = -1
self.__tabIconSize = QSize()
self.__exclusive = False
self.__setupUi()
def setIconSize(self, size):
"""
Set the icon (and this item's) size (:class:`QSize`).
"""
if self.__iconSize != size:
self.prepareGeometryChange()
self.__iconSize = QSize(size)
self.update()
class IconWidget(QWidget):
"""
A widget displaying an `QIcon`
"""
def __init__(self, parent=None, icon=QIcon(), iconSize=QSize(), **kwargs):
sizePolicy = kwargs.pop("sizePolicy", QSizePolicy(QSizePolicy.Fixed,
QSizePolicy.Fixed))
super().__init__(parent, **kwargs)
self.__icon = QIcon(icon)
self.__iconSize = QSize(iconSize)
self.setSizePolicy(sizePolicy)
def setIcon(self, icon):
# type: (QIcon) -> None
if self.__icon != icon:
self.__icon = QIcon(icon)
self.updateGeometry()
self.update()
def icon(self):
# type: () -> QIcon
return QIcon(self.__icon)
def iconSize(self):
# type: () -> QSize
if not self.__iconSize.isValid():
size = self.style().pixelMetric(QStyle.PM_ButtonIconSize)
return QSize(size, size)
else:
return QSize(self.__iconSize)
def setIconSize(self, iconSize):
# type: (QSize) -> None
if self.__iconSize != iconSize:
self.__iconSize = QSize(iconSize)
self.updateGeometry()
self.update()
def sizeHint(self):
sh = self.iconSize()
m = self.contentsMargins()
return QSize(sh.width() + m.left() + m.right(),
sh.height() + m.top() + m.bottom())
def paintEvent(self, event):
painter = QStylePainter(self)
opt = QStyleOption()
opt.initFrom(self)
painter.drawPrimitive(QStyle.PE_Widget, opt)
if not self.__icon.isNull():
rect = self.contentsRect()
if opt.state & QStyle.State_Active:
mode = QIcon.Active
else:
mode = QIcon.Disabled
self.__icon.paint(painter, rect, Qt.AlignCenter, mode, QIcon.Off)
painter.end()
def __layoutActions(self):
left, right = self.__actions
contents = self.contentsRect()
buttonSize = QSize(contents.height(), contents.height())
margins = self.textMargins()
if left:
geom = QRect(contents.topLeft(), buttonSize)
left.button.setGeometry(geom)
margins.setLeft(buttonSize.width())
if right:
geom = QRect(contents.topRight(), buttonSize)
right.button.setGeometry(geom.translated(-buttonSize.width(), 0))
margins.setLeft(buttonSize.width())
self.setTextMargins(margins)
def _updateShadowPixmap(self):
"""Update the cached drop shadow pixmap.
"""
# Rectangle casting the shadow
rect_size = QSize(*CACHED_SHADOW_RECT_SIZE)
left, top, right, bottom = self.getContentsMargins()
# Size of the pixmap.
pixmap_size = QSize(rect_size.width() + left + right,
rect_size.height() + top + bottom)
shadow_rect = QRect(QPoint(left, top), rect_size)
pixmap = QPixmap(pixmap_size)
pixmap.fill(QColor(0, 0, 0, 0))
rect_fill_color = self.palette().color(QPalette.Window)
pixmap = render_drop_shadow_frame(pixmap, QRectF(shadow_rect),
shadow_color=self.color,
offset=self.offset,
radius=self.radius,
rect_fill_color=rect_fill_color)
self._shadowPixmap = pixmap
def __init__(self, parent=None, icon=None, iconSize=None, **kwargs):
QGraphicsItem.__init__(self, parent, **kwargs)
self.setFlag(QGraphicsItem.ItemUsesExtendedStyleOption, True)
if icon is None:
icon = QIcon()
if iconSize is None:
style = QApplication.instance().style()
size = style.pixelMetric(style.PM_LargeIconSize)
iconSize = QSize(size, size)
self.__transformationMode = Qt.SmoothTransformation
self.__iconSize = QSize(iconSize)
self.__icon = QIcon(icon)
def __init__(self):
super().__init__()
self.results = None
self.scores = None
self.classifier_names = []
self.colors = []
self.line = None
self._last_score_value = -1
box = gui.vBox(self.controlArea, box="设置")
self.target_cb = gui.comboBox(box,
self,
"target_index",
label="目标:",
orientation=Qt.Horizontal,
callback=self.target_index_changed,
contentsLength=8)
gui.checkBox(box,
self,
"display_rug",
"显示须线(Show rug)",
callback=self._on_display_rug_changed)
gui.checkBox(box,
self,
"fold_curves",
"单个折叠的曲线(Curves for individual folds)",
callback=self._replot)
self.classifiers_list_box = gui.listBox(
self.controlArea,
self,
"selected_classifiers",
"classifier_names",
box="分类器",
selectionMode=QListWidget.ExtendedSelection,
sizePolicy=(QSizePolicy.Preferred, QSizePolicy.Preferred),
sizeHint=QSize(150, 40),
callback=self._on_selection_changed)
box = gui.vBox(self.controlArea, "度量")
combo = gui.comboBox(box,
self,
"score",
items=(metric.name for metric in Metrics),
callback=self.score_changed)
self.explanation = gui.widgetLabel(box,
wordWrap=True,
fixedWidth=combo.sizeHint().width())
self.explanation.setContentsMargins(8, 8, 0, 0)
font = self.explanation.font()
font.setPointSizeF(0.85 * font.pointSizeF())
self.explanation.setFont(font)
gui.radioButtons(box,
self,
value="output_calibration",
btnLabels=("Sigmoid 校准", "Isotonic 校准"),
label="输出模型校准",
callback=self.apply)
self.info_box = gui.widgetBox(self.controlArea, "信息")
self.info_label = gui.widgetLabel(self.info_box)
gui.auto_apply(self.controlArea,
self,
"auto_commit",
commit=self.apply)
self.plotview = pg.GraphicsView(background="w")
self.plot = pg.PlotItem(enableMenu=False)
self.plot.setMouseEnabled(False, False)
self.plot.hideButtons()
for axis_name in ("bottom", "left"):
axis = self.plot.getAxis(axis_name)
axis.setPen(pg.mkPen(color=0.0))
# Remove the condition (that is, allow setting this for bottom
# axis) when pyqtgraph is fixed
# Issue: https://github.com/pyqtgraph/pyqtgraph/issues/930
# Pull request: https://github.com/pyqtgraph/pyqtgraph/pull/932
if axis_name != "bottom": # remove if when pyqtgraph is fixed
axis.setStyle(stopAxisAtTick=(True, True))
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0), padding=0.05)
self.plotview.setCentralItem(self.plot)
self.mainArea.layout().addWidget(self.plotview)
self._set_explanation()
def _setup_table_view(self, view, data):
"""Setup the `view` (QTableView) with `data` (Orange.data.Table)
"""
if data is None:
view.setModel(None)
return
datamodel = TableModel(data)
datamodel = RichTableDecorator(datamodel)
rowcount = data.approx_len()
if self.color_by_class and data.domain.has_discrete_class:
color_schema = [
QColor(*c) for c in data.domain.class_var.colors]
else:
color_schema = None
if self.show_distributions:
view.setItemDelegate(
gui.TableBarItem(
self, color=self.dist_color, color_schema=color_schema)
)
else:
view.setItemDelegate(QStyledItemDelegate(self))
# Enable/disable view sorting based on data's type
view.setSortingEnabled(is_sortable(data))
header = view.horizontalHeader()
header.setSectionsClickable(is_sortable(data))
header.setSortIndicatorShown(is_sortable(data))
view.setModel(datamodel)
vheader = view.verticalHeader()
option = view.viewOptions()
size = view.style().sizeFromContents(
QStyle.CT_ItemViewItem, option,
QSize(20, 20), view)
vheader.setDefaultSectionSize(size.height() + 2)
vheader.setMinimumSectionSize(5)
vheader.setSectionResizeMode(QHeaderView.Fixed)
# Limit the number of rows displayed in the QTableView
# (workaround for QTBUG-18490 / QTBUG-28631)
maxrows = (2 ** 31 - 1) // (vheader.defaultSectionSize() + 2)
if rowcount > maxrows:
sliceproxy = TableSliceProxy(
parent=view, rowSlice=slice(0, maxrows))
sliceproxy.setSourceModel(datamodel)
# First reset the view (without this the header view retains
# it's state - at this point invalid/broken)
view.setModel(None)
view.setModel(sliceproxy)
assert view.model().rowCount() <= maxrows
assert vheader.sectionSize(0) > 1 or datamodel.rowCount() == 0
# update the header (attribute names)
self._update_variable_labels(view)
selmodel = BlockSelectionModel(
view.model(), parent=view, selectBlocks=not self.select_rows)
view.setSelectionModel(selmodel)
view.selectionModel().selectionChanged.connect(self.update_selection)
class GraphicsIconItem(QGraphicsWidget):
"""
A graphics item displaying an :class:`QIcon`.
"""
def __init__(self, parent=None, icon=None, iconSize=None, **kwargs):
QGraphicsItem.__init__(self, parent, **kwargs)
self.setFlag(QGraphicsItem.ItemUsesExtendedStyleOption, True)
if icon is None:
icon = QIcon()
if iconSize is None:
style = QApplication.instance().style()
size = style.pixelMetric(style.PM_LargeIconSize)
iconSize = QSize(size, size)
self.__transformationMode = Qt.SmoothTransformation
self.__iconSize = QSize(iconSize)
self.__icon = QIcon(icon)
self._opacity = 1
self.anim = QPropertyAnimation(self, b"opacity")
self.anim.setDuration(350)
self.anim.setStartValue(1)
self.anim.setKeyValueAt(0.5, 0)
self.anim.setEndValue(1)
self.anim.setEasingCurve(QEasingCurve.OutQuad)
self.anim.setLoopCount(5)
def setIcon(self, icon):
"""
Set the icon (:class:`QIcon`).
"""
if self.__icon != icon:
self.__icon = QIcon(icon)
self.update()
def getOpacity(self):
return self._opacity
def setOpacity(self, o):
self._opacity = o
self.update()
opacity = Property(float, fget=getOpacity, fset=setOpacity)
def icon(self):
"""
Return the icon (:class:`QIcon`).
"""
return QIcon(self.__icon)
def setIconSize(self, size):
"""
Set the icon (and this item's) size (:class:`QSize`).
"""
if self.__iconSize != size:
self.prepareGeometryChange()
self.__iconSize = QSize(size)
self.update()
def iconSize(self):
"""
Return the icon size (:class:`QSize`).
"""
return QSize(self.__iconSize)
def setTransformationMode(self, mode):
"""
Set pixmap transformation mode. (`Qt.SmoothTransformation` or
`Qt.FastTransformation`).
"""
if self.__transformationMode != mode:
self.__transformationMode = mode
self.update()
def transformationMode(self):
"""
Return the pixmap transformation mode.
"""
return self.__transformationMode
def boundingRect(self):
return QRectF(0, 0, self.__iconSize.width(), self.__iconSize.height())
def paint(self, painter, option, widget=None):
if not self.__icon.isNull():
if option.state & QStyle.State_Selected:
mode = QIcon.Selected
elif option.state & QStyle.State_Enabled:
mode = QIcon.Normal
elif option.state & QStyle.State_Active:
mode = QIcon.Active
else:
mode = QIcon.Disabled
w, h = self.__iconSize.width(), self.__iconSize.height()
target = QRect(0, 0, w, h)
painter.setRenderHint(
QPainter.SmoothPixmapTransform,
self.__transformationMode == Qt.SmoothTransformation
)
painter.setOpacity(self._opacity)
self.__icon.paint(painter, target, Qt.AlignCenter, mode)
def __layout(self):
# position itself over `widget`
widget = self.__widget
if widget is None:
return
alignment = self.__alignment
policy = self.sizePolicy()
if widget.isWindow():
bounds = widget.geometry()
else:
bounds = QRect(widget.mapToGlobal(QPoint(0, 0)),
widget.size())
if self.isWindow():
bounds = bounds
else:
bounds = QRect(self.parent().mapFromGlobal(bounds.topLeft()),
bounds.size())
sh = self.sizeHint()
minsh = self.minimumSizeHint()
minsize = self.minimumSize()
if minsize.isNull():
minsize = minsh
maxsize = bounds.size().boundedTo(self.maximumSize())
minsize = minsize.boundedTo(maxsize)
effectivesh = sh.expandedTo(minsize).boundedTo(maxsize)
hpolicy = policy.horizontalPolicy()
vpolicy = policy.verticalPolicy()
def getsize(hint, minimum, maximum, policy):
if policy == QSizePolicy.Ignored:
return maximum
elif policy & QSizePolicy.ExpandFlag:
return maximum
else:
return max(hint, minimum)
width = getsize(effectivesh.width(), minsize.width(),
maxsize.width(), hpolicy)
heightforw = self.heightForWidth(width)
if heightforw > 0:
height = getsize(heightforw, minsize.height(),
maxsize.height(), vpolicy)
else:
height = getsize(effectivesh.height(), minsize.height(),
maxsize.height(), vpolicy)
size = QSize(width, height)
if alignment & Qt.AlignLeft:
x = bounds.x()
elif alignment & Qt.AlignRight:
x = bounds.right() - size.width()
else:
x = bounds.x() + max(0, bounds.width() - size.width()) // 2
if alignment & Qt.AlignTop:
y = bounds.y()
elif alignment & Qt.AlignBottom:
y = bounds.bottom() - size.height()
else:
y = bounds.y() + max(0, bounds.height() - size.height()) // 2
geom = QRect(QPoint(x, y), size)
self.setGeometry(geom)
class GraphicsIconItem(QGraphicsItem):
"""
A graphics item displaying an :class:`QIcon`.
"""
def __init__(self, parent=None, icon=None, iconSize=None, **kwargs):
QGraphicsItem.__init__(self, parent, **kwargs)
self.setFlag(QGraphicsItem.ItemUsesExtendedStyleOption, True)
if icon is None:
icon = QIcon()
if iconSize is None:
style = QApplication.instance().style()
size = style.pixelMetric(style.PM_LargeIconSize)
iconSize = QSize(size, size)
self.__transformationMode = Qt.SmoothTransformation
self.__iconSize = QSize(iconSize)
self.__icon = QIcon(icon)
def setIcon(self, icon):
"""
Set the icon (:class:`QIcon`).
"""
if self.__icon != icon:
self.__icon = QIcon(icon)
self.update()
def icon(self):
"""
Return the icon (:class:`QIcon`).
"""
return QIcon(self.__icon)
def setIconSize(self, size):
"""
Set the icon (and this item's) size (:class:`QSize`).
"""
if self.__iconSize != size:
self.prepareGeometryChange()
self.__iconSize = QSize(size)
self.update()
def iconSize(self):
"""
Return the icon size (:class:`QSize`).
"""
return QSize(self.__iconSize)
def setTransformationMode(self, mode):
"""
Set pixmap transformation mode. (`Qt.SmoothTransformation` or
`Qt.FastTransformation`).
"""
if self.__transformationMode != mode:
self.__transformationMode = mode
self.update()
def transformationMode(self):
"""
Return the pixmap transformation mode.
"""
return self.__transformationMode
def boundingRect(self):
return QRectF(0, 0, self.__iconSize.width(), self.__iconSize.height())
def paint(self, painter, option, widget=None):
if not self.__icon.isNull():
if option.state & QStyle.State_Selected:
mode = QIcon.Selected
elif option.state & QStyle.State_Enabled:
mode = QIcon.Normal
elif option.state & QStyle.State_Active:
mode = QIcon.Active
else:
mode = QIcon.Disabled
transform = self.sceneTransform()
if widget is not None:
# 'widget' is the QGraphicsView.viewport()
view = widget.parent()
if isinstance(view, QGraphicsView):
# Combine the scene transform with the view transform.
view_transform = view.transform()
transform = view_transform * view_transform
lod = option.levelOfDetailFromTransform(transform)
w, h = self.__iconSize.width(), self.__iconSize.height()
target = QRectF(0, 0, w, h)
source = QRectF(0, 0, w * lod, w * lod).toRect()
# The actual size of the requested pixmap can be smaller.
size = self.__icon.actualSize(source.size(), mode=mode)
source.setSize(size)
pixmap = self.__icon.pixmap(source.size(), mode=mode)
painter.setRenderHint(
QPainter.SmoothPixmapTransform,
self.__transformationMode == Qt.SmoothTransformation
)
painter.drawPixmap(target, pixmap, QRectF(source))
def sizeHint(self):
return QSize(600, 30)
def sizeHint(self):
return QSize(450, 600)
def sizeHint(self):
sh = super().sizeHint()
return QSize(780, sh.height())
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 = QStyleOptionToolBox.NextIsSelected
if on:
previous.selected |= flag
else:
previous.selected &= ~flag
previous.update()
if index < self.count() - 1:
next = self.__pages[index + 1].button
flag = QStyleOptionToolBox.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 = QStyleOptionToolBox
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 = QStyleOptionToolBox.OnlyOneTab
else:
self.__pages[0].button.position = QStyleOptionToolBox.Beginning
self.__pages[-1].button.position = QStyleOptionToolBox.End
for p in self.__pages[1:-1]:
p.button.position = QStyleOptionToolBox.Middle
for p in self.__pages:
p.button.update()
def sizeHint():
"""Initial size"""
return QSize(750, 340)
def sizeHint(self):
sh = super().sizeHint()
return sh.expandedTo(QSize(sh.width() + 300, 500))
def sizeHint():
return QSize(1050, 500)
def paint(self, painter, option, index):
dist = self.distribution(index)
if dist is None or self.colors is None:
super().paint(painter, option, index)
return
if not numpy.isfinite(numpy.sum(dist)):
super().paint(painter, option, index)
return
if option.widget is not None:
style = option.widget.style()
else:
style = QApplication.style()
self.initStyleOption(option, index)
text = option.text
metrics = option.fontMetrics
margin = style.pixelMetric(
QStyle.PM_FocusFrameHMargin, option, option.widget) + 1
bottommargin = min(margin, 1)
rect = option.rect.adjusted(margin, margin, -margin, -bottommargin)
textrect = style.subElementRect(
QStyle.SE_ItemViewItemText, option, option.widget)
# Are the margins included in the subElementRect?? -> No!
textrect = textrect.adjusted(margin, margin, -margin, -bottommargin)
text = option.fontMetrics.elidedText(
text, option.textElideMode, textrect.width())
spacing = max(metrics.leading(), 1)
distheight = rect.height() - metrics.height() - spacing
distheight = numpy.clip(distheight, 2, metrics.height())
painter.save()
painter.setClipRect(option.rect)
painter.setFont(option.font)
painter.setRenderHint(QPainter.Antialiasing)
style.drawPrimitive(
QStyle.PE_PanelItemViewRow, option, painter, option.widget)
style.drawPrimitive(
QStyle.PE_PanelItemViewItem, option, painter, option.widget)
if option.state & QStyle.State_Selected:
color = option.palette.highlightedText().color()
else:
color = option.palette.text().color()
painter.setPen(QPen(color))
textrect = textrect.adjusted(0, 0, 0, -distheight - spacing)
distrect = QRect(
textrect.bottomLeft() + QPoint(0, spacing),
QSize(rect.width(), distheight))
painter.setPen(QPen(Qt.lightGray, 0.3))
self.drawDistBar(painter, distrect, dist)
painter.restore()
if text:
style.drawItemText(
painter, textrect, option.displayAlignment, option.palette,
option.state & QStyle.State_Enabled, text)
class GraphicsIconItem(QGraphicsItem):
"""
A graphics item displaying an :class:`QIcon`.
"""
def __init__(self, parent=None, icon=None, iconSize=None, **kwargs):
QGraphicsItem.__init__(self, parent, **kwargs)
self.setFlag(QGraphicsItem.ItemUsesExtendedStyleOption, True)
if icon is None:
icon = QIcon()
if iconSize is None:
style = QApplication.instance().style()
size = style.pixelMetric(style.PM_LargeIconSize)
iconSize = QSize(size, size)
self.__transformationMode = Qt.SmoothTransformation
self.__iconSize = QSize(iconSize)
self.__icon = QIcon(icon)
def setIcon(self, icon):
"""
Set the icon (:class:`QIcon`).
"""
if self.__icon != icon:
self.__icon = QIcon(icon)
self.update()
def icon(self):
"""
Return the icon (:class:`QIcon`).
"""
return QIcon(self.__icon)
def setIconSize(self, size):
"""
Set the icon (and this item's) size (:class:`QSize`).
"""
if self.__iconSize != size:
self.prepareGeometryChange()
self.__iconSize = QSize(size)
self.update()
def iconSize(self):
"""
Return the icon size (:class:`QSize`).
"""
return QSize(self.__iconSize)
def setTransformationMode(self, mode):
"""
Set pixmap transformation mode. (`Qt.SmoothTransformation` or
`Qt.FastTransformation`).
"""
if self.__transformationMode != mode:
self.__transformationMode = mode
self.update()
def transformationMode(self):
"""
Return the pixmap transformation mode.
"""
return self.__transformationMode
def boundingRect(self):
return QRectF(0, 0, self.__iconSize.width(), self.__iconSize.height())
def paint(self, painter, option, widget=None):
if not self.__icon.isNull():
if option.state & QStyle.State_Selected:
mode = QIcon.Selected
elif option.state & QStyle.State_Enabled:
mode = QIcon.Normal
elif option.state & QStyle.State_Active:
mode = QIcon.Active
else:
mode = QIcon.Disabled
w, h = self.__iconSize.width(), self.__iconSize.height()
target = QRect(0, 0, w, h)
painter.setRenderHint(
QPainter.SmoothPixmapTransform,
self.__transformationMode == Qt.SmoothTransformation
)
self.__icon.paint(painter, target, Qt.AlignCenter, mode)
def sizeHint(self) -> QSize:
size: QSize = super().sizeHint()
return QSize(size.width(), size.height() + 2)
def sizeHint(self):
return QSize(800, 500)
def sizeHint(self):
return QSize(super().sizeHint().width(), 40)
def __init__(self, *args, thresholds=(0.0, 1.0), center=None, **kwargs):
super().__init__(*args, **kwargs)
low = round(clip(thresholds[0], 0., 1.), 2)
high = round(clip(thresholds[1], 0., 1.), 2)
high = max(low, high)
self.__threshold_low, self.__threshold_high = low, high
self.__center = center
form = QFormLayout(formAlignment=Qt.AlignLeft,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow)
form.setContentsMargins(0, 0, 0, 0)
self.gradient_cb = QComboBox(
None,
objectName="gradient-combo-box",
)
self.gradient_cb.setAttribute(Qt.WA_LayoutUsesWidgetRect)
icsize = self.style().pixelMetric(QStyle.PM_SmallIconSize, None,
self.gradient_cb)
self.gradient_cb.setIconSize(QSize(64, icsize))
model = itemmodels.ContinuousPalettesModel()
model.setParent(self)
self.gradient_cb.setModel(model)
self.gradient_cb.activated[int].connect(self.activated)
self.gradient_cb.currentIndexChanged.connect(self.currentIndexChanged)
if center is not None:
def on_center_spin_value_changed(value):
if self.__center != value:
self.__center = value
self.centerChanged.emit(self.__center)
self.center_box = QWidget()
center_layout = QHBoxLayout()
self.center_box.setLayout(center_layout)
self.center_edit = DoubleSpinBox(
value=self.__center,
minimum=DBL_MIN,
maximum=DBL_MAX,
minimumStep=0.01,
minimumContentsLenght=8,
stepType=DoubleSpinBox.AdaptiveDecimalStepType,
keyboardTracking=False,
sizePolicy=QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed))
self.center_edit.valueChanged.connect(on_center_spin_value_changed)
center_layout.setContentsMargins(0, 0, 0, 0)
center_layout.addStretch(1)
center_layout.addWidget(QLabel("Centered at"))
center_layout.addWidget(self.center_edit)
self.gradient_cb.currentIndexChanged.connect(
self.__update_center_visibility)
else:
self.center_box = None
slider_low = Slider(objectName="threshold-low-slider",
minimum=0,
maximum=100,
value=int(low * 100),
orientation=Qt.Horizontal,
tickPosition=QSlider.TicksBelow,
pageStep=10,
toolTip=self.tr("Low gradient threshold"),
whatsThis=self.tr(
"Applying a low threshold will squeeze the "
"gradient from the lower end"))
slider_high = Slider(objectName="threshold-low-slider",
minimum=0,
maximum=100,
value=int(high * 100),
orientation=Qt.Horizontal,
tickPosition=QSlider.TicksAbove,
pageStep=10,
toolTip=self.tr("High gradient threshold"),
whatsThis=self.tr(
"Applying a high threshold will squeeze the "
"gradient from the higher end"))
form.setWidget(0, QFormLayout.SpanningRole, self.gradient_cb)
if self.center_box:
form.setWidget(1, QFormLayout.SpanningRole, self.center_box)
form.addRow(self.tr("Low:"), slider_low)
form.addRow(self.tr("High:"), slider_high)
self.slider_low = slider_low
self.slider_high = slider_high
self.slider_low.valueChanged.connect(self.__on_slider_low_moved)
self.slider_high.valueChanged.connect(self.__on_slider_high_moved)
self.setLayout(form)
def sizeHint():
return QSize(600, 500)
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):
super().__init__(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")
self.__contentsLayout = _ToolBoxLayout(
sizeConstraint=_ToolBoxLayout.SetMinAndMaxSize,
spacing=0
)
self.__contentsLayout.setContentsMargins(0, 0, 0, 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.Ignored,
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 = QStyleOptionToolBox.NextIsSelected
if on:
previous.selected |= flag
else:
previous.selected &= ~flag
previous.update()
if index < self.count() - 1:
next = self.__pages[index + 1].button
flag = QStyleOptionToolBox.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 = QStyleOptionToolBox
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 = QStyleOptionToolBox.OnlyOneTab
else:
self.__pages[0].button.position = QStyleOptionToolBox.Beginning
self.__pages[-1].button.position = QStyleOptionToolBox.End
for p in self.__pages[1:-1]:
p.button.position = QStyleOptionToolBox.Middle
for p in self.__pages:
p.button.update()
def color_settings_box(self):
box = gui.vBox(self)
self.color_cb = gui.comboBox(box,
self,
"palette_index",
label="Color:",
labelWidth=50,
orientation=Qt.Horizontal)
self.color_cb.setIconSize(QSize(64, 16))
palettes = _color_palettes
self.palette_index = min(self.palette_index, len(palettes) - 1)
model = color_palette_model(palettes, self.color_cb.iconSize())
model.setParent(self)
self.color_cb.setModel(model)
self.color_cb.activated.connect(self.update_color_schema)
self.color_cb.setCurrentIndex(self.palette_index)
gui.checkBox(box,
self,
"show_legend",
label="Show legend",
callback=self.update_legend_visible)
form = QFormLayout(formAlignment=Qt.AlignLeft,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow)
def limit_changed():
self.update_levels()
self.reset_thresholds()
self._level_low_le = lineEditDecimalOrNone(self,
self,
"level_low",
callback=limit_changed)
self._level_low_le.validator().setDefault(0)
form.addRow("Low limit:", self._level_low_le)
self._level_high_le = lineEditDecimalOrNone(self,
self,
"level_high",
callback=limit_changed)
self._level_high_le.validator().setDefault(1)
form.addRow("High limit:", self._level_high_le)
lowslider = gui.hSlider(box,
self,
"threshold_low",
minValue=0.0,
maxValue=1.0,
step=0.05,
ticks=True,
intOnly=False,
createLabel=False,
callback=self.update_levels)
highslider = gui.hSlider(box,
self,
"threshold_high",
minValue=0.0,
maxValue=1.0,
step=0.05,
ticks=True,
intOnly=False,
createLabel=False,
callback=self.update_levels)
form.addRow("Low:", lowslider)
form.addRow("High:", highslider)
box.layout().addLayout(form)
self.update_legend_visible()
return box
def sizeHint():
return QSize(780, 1)
def sizeHint(self):
style = self.style()
size = (style.pixelMetric(QStyle.PM_SmallIconSize) +
style.pixelMetric(QStyle.PM_ButtonMargin))
return QSize(size, size)
def sizeHint(self):
return QSize(400, 85)
def sizeHint(self):
sh = self.controlArea.sizeHint()
return sh.expandedTo(QSize(600, 720))
class PandasModel(QAbstractTableModel):
"""
Class to populate a table view with a pandas dataframe
"""
COLOR_MSG = QBrush(QColor(200, 200, 200))
COLOR_DEBUG = QBrush(QColor(200, 200, 200))
COLOR_TRIAL = QBrush(QColor(0, 100, 200))
COLOR_ERROR = QBrush(QColor(240, 0, 0))
COLOR_INFO = QBrush(QColor(150, 150, 255))
COLOR_SOFTCODE_OCCURENCE = QBrush(QColor(40, 30, 30))
COLOR_STATE_OCCURENCE = QBrush(QColor(70, 180, 70))
COLOR_STATE_TRANSITION = QBrush(QColor(0, 100, 0))
COLOR_STDERR = QBrush(QColor(255, 0, 0))
COLOR_STDOUT = QBrush(QColor(150, 150, 150))
COLOR_TRIAL = QBrush(QColor(0, 0, 255))
COLOR_WARNING = QBrush(QColor(255, 100, 0))
COLUMNS_WIDTHS = [
QSize(100, 30),
QSize(400, 30),
QSize(200, 30),
QSize(200, 30),
QSize(200, 30),
QSize(200, 30)
]
def __init__(self, data, parent=None):
QAbstractTableModel.__init__(self, parent)
self._data = np.array(data.values)
self._cols = data.columns
self.r, self.c = np.shape(self._data)
def rowCount(self, parent=None):
return self.r
def columnCount(self, parent=None):
return self.c
def data(self, index, role=Qt.DisplayRole):
if index.isValid():
if role == Qt.ForegroundRole:
dtype = self._data[index.row()][0]
if dtype == Session.MSGTYPE_DEBUG: return self.COLOR_DEBUG
elif dtype == Session.MSGTYPE_ENDTRIAL: return self.COLOR_TRIAL
elif dtype == Session.MSGTYPE_ERROR: return self.COLOR_ERROR
elif dtype == Session.MSGTYPE_INFO: return self.COLOR_INFO
elif dtype == Session.MSGTYPE_SOFTCODE:
return self.COLOR_SOFTCODE_OCCURENCE
elif dtype == Session.MSGTYPE_STATE:
return self.COLOR_STATE_OCCURENCE
elif dtype == Session.MSGTYPE_TRANSITION:
return self.COLOR_STATE_TRANSITION
elif dtype == Session.MSGTYPE_STDERR:
return self.COLOR_STDERR
elif dtype == Session.MSGTYPE_STDOUT:
return self.COLOR_STDOUT
elif dtype == Session.MSGTYPE_TRIAL:
return self.COLOR_TRIAL
elif dtype == Session.MSGTYPE_WARNING:
return self.COLOR_WARNING
else:
return self.COLOR_MSG
elif role == Qt.DisplayRole:
return str(self._data[index.row(), index.column()])
return None
def headerData(self, col, orientation, role):
if orientation == Qt.Horizontal and role == Qt.DisplayRole:
return self._cols[col]
#elif orientation == Qt.Horizontal and role == Qt.SizeHintRole:
# return QVariant(self.COLUMNS_WIDTHS[col])
def flags(self, index):
return Qt.ItemIsEnabled
def sizeHint(self):
return QSize(450, 550)
def setIconSize(self, iconSize):
# type: (QSize) -> None
if self.__iconSize != iconSize:
self.__iconSize = QSize(iconSize)
self.updateGeometry()
self.update()
def sizeHint():
return QSize(500, 570)
def sizeHint(self, option, index):
size = QStyledItemDelegate.sizeHint(self, option, index)
size = QSize(size.width(), size.height() + 4)
return size
def sizeHint(self) -> QSize:
return super().sizeHint().expandedTo(QSize(900, 700))
def sizeHint():
return QSize(640, 525)
def sizeHint(self):
return QSize(1280, 960)
def __init__(self, *args, preferred_size=None, **kwargs):
super().__init__(*args, **kwargs)
if isinstance(preferred_size, tuple):
preferred_size = QSize(*preferred_size)
self.preferred_size = preferred_size
def sizeHint(self):
sh = super().sizeHint()
return sh.expandedTo(QSize(660, 550))
def sizeHint(self):
return super().sizeHint().expandedTo(QSize(200, 200))
def showPopup(self):
# type: () -> None
"""
Reimplemented from QComboBox.showPopup
Popup up a customized view and filter edit line.
Note
----
The .popup(), .lineEdit(), .completer() of the base class are not used.
"""
if self.__popup is not None:
# We have user entered state that cannot be disturbed
# (entered filter text, scroll offset, ...)
return # pragma: no cover
if self.count() == 0:
return
opt = QStyleOptionComboBox()
self.initStyleOption(opt)
popup = QListView(
uniformItemSizes=True,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOff,
verticalScrollBarPolicy=Qt.ScrollBarAsNeeded,
iconSize=self.iconSize(),
)
popup.setFocusProxy(self.__searchline)
popup.setParent(self, Qt.Popup | Qt.FramelessWindowHint)
popup.setItemDelegate(_ComboBoxListDelegate(popup))
proxy = QSortFilterProxyModel(
popup, filterCaseSensitivity=Qt.CaseInsensitive
)
proxy.setFilterKeyColumn(self.modelColumn())
proxy.setSourceModel(self.model())
popup.setModel(proxy)
root = proxy.mapFromSource(self.rootModelIndex())
popup.setRootIndex(root)
self.__popup = popup
self.__proxy = proxy
self.__searchline.setText("")
self.__searchline.setPlaceholderText("Filter...")
self.__searchline.setVisible(True)
self.__searchline.textEdited.connect(proxy.setFilterFixedString)
style = self.style() # type: QStyle
popuprect_origin = style.subControlRect(
QStyle.CC_ComboBox, opt, QStyle.SC_ComboBoxListBoxPopup, self
) # type: QRect
if sys.platform == "darwin":
slmargin = self.__searchline.style() \
.pixelMetric(QStyle.PM_FocusFrameVMargin)
popuprect_origin.adjust(slmargin // 2, 0,
-(slmargin * 3) // 2, slmargin)
popuprect_origin = QRect(
self.mapToGlobal(popuprect_origin.topLeft()),
popuprect_origin.size()
)
editrect = style.subControlRect(
QStyle.CC_ComboBox, opt, QStyle.SC_ComboBoxEditField, self
) # type: QRect
self.__searchline.setGeometry(editrect)
screenrect = self.screen().availableGeometry()
# get the height for the view
listrect = QRect()
for i in range(min(proxy.rowCount(root), self.maxVisibleItems())):
index = proxy.index(i, self.modelColumn(), root)
if index.isValid():
listrect = listrect.united(popup.visualRect(index))
if listrect.height() >= screenrect.height():
break
window = popup.window() # type: QWidget
window.ensurePolished()
if window.layout() is not None:
window.layout().activate()
else:
QApplication.sendEvent(window, QEvent(QEvent.LayoutRequest))
margins = qwidget_margin_within(popup.viewport(), window)
height = (listrect.height() + 2 * popup.spacing() +
margins.top() + margins.bottom())
popup_size = (QSize(popuprect_origin.width(), height)
.expandedTo(window.minimumSize())
.boundedTo(window.maximumSize())
.boundedTo(screenrect.size()))
popuprect = QRect(popuprect_origin.bottomLeft(), popup_size)
popuprect = dropdown_popup_geometry(
popuprect, popuprect_origin, screenrect)
popup.setGeometry(popuprect)
current = proxy.mapFromSource(
self.model().index(self.currentIndex(), self.modelColumn(),
self.rootModelIndex()))
popup.setCurrentIndex(current)
popup.scrollTo(current, QAbstractItemView.EnsureVisible)
popup.show()
popup.setFocus(Qt.PopupFocusReason)
popup.installEventFilter(self)
popup.viewport().installEventFilter(self)
popup.viewport().setMouseTracking(True)
self.update()
self.__popupTimer.restart()