def __init__(self, parent=None):
super().__init__(parent)
## Attributes
self.data = None
self.distances = None
self.groups = None
self.unique_pos = None
self.base_group_index = 0
## GUI
box = gui.widgetBox(self.controlArea, "Info")
self.info_box = gui.widgetLabel(box, "\n")
## Separate By box
box = gui.widgetBox(self.controlArea, "Separate By")
self.split_by_model = itemmodels.PyListModel(parent=self)
self.split_by_view = QListView()
self.split_by_view.setSelectionMode(QListView.ExtendedSelection)
self.split_by_view.setModel(self.split_by_model)
box.layout().addWidget(self.split_by_view)
self.split_by_view.selectionModel().selectionChanged.connect(
self.on_split_key_changed)
## Sort By box
box = gui.widgetBox(self.controlArea, "Sort By")
self.sort_by_model = itemmodels.PyListModel(parent=self)
self.sort_by_view = QListView()
self.sort_by_view.setSelectionMode(QListView.ExtendedSelection)
self.sort_by_view.setModel(self.sort_by_model)
box.layout().addWidget(self.sort_by_view)
self.sort_by_view.selectionModel().selectionChanged.connect(
self.on_sort_key_changed)
## Distance box
box = gui.widgetBox(self.controlArea, "Distance Measure")
gui.comboBox(box, self, "selected_distance_index",
items=[name for name, _ in self.DISTANCE_FUNCTIONS],
callback=self.on_distance_measure_changed)
self.scene = QGraphicsScene()
self.scene_view = QGraphicsView(self.scene)
self.scene_view.setRenderHints(QPainter.Antialiasing)
self.scene_view.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.mainArea.layout().addWidget(self.scene_view)
self.scene_view.installEventFilter(self)
self._disable_updates = False
self._cached_distances = {}
self._base_index_hints = {}
self.main_widget = None
self.resize(800, 600)
def test_dock_standalone(self):
widget = QWidget()
layout = QHBoxLayout()
widget.setLayout(layout)
layout.addStretch(1)
widget.show()
dock = CollapsibleDockWidget()
layout.addWidget(dock)
list_view = QListView()
list_view.setModel(QStringListModel(["a", "b"], list_view))
label = QLabel("A label. ")
label.setWordWrap(True)
dock.setExpandedWidget(label)
dock.setCollapsedWidget(list_view)
dock.setExpanded(True)
dock.setExpanded(False)
timer = QTimer(dock, interval=50)
timer.timeout.connect(lambda: dock.setExpanded(not dock.expanded()))
timer.start()
self.qWait()
timer.stop()
def __layout(self):
if self.default_view is None: # __layout was called from __init__
view = self.default_view = QListView(self)
view.setModel(DefaultDiscModel())
view.verticalScrollBar().setDisabled(True)
view.horizontalScrollBar().setDisabled(True)
view.setHorizontalScrollBarPolicy(
Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
view.setVerticalScrollBarPolicy(
Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
font = view.font()
font.setBold(True)
view.setFont(font)
else:
view = self.default_view
# Put the list view with default on top
margins = self.viewportMargins()
def_height = view.sizeHintForRow(0) + 2 * view.spacing() + 2
view.setGeometry(0, 0, self.geometry().width(), def_height)
view.setFixedHeight(def_height)
# Then search
search = self.__search
src_height = search.sizeHint().height()
size = self.size()
search.setGeometry(0, def_height + 2, size.width(), src_height)
# Then the real list view
margins.setTop(def_height + 2 + src_height)
self.setViewportMargins(margins)
def __init__(self):
super().__init__()
self.data = None
self.component_x = 0
self.component_y = 1
box = gui.vBox(self.controlArea, "Variables")
self.varlist = itemmodels.VariableListModel()
self.varview = view = QListView(selectionMode=QListView.MultiSelection)
view.setModel(self.varlist)
view.selectionModel().selectionChanged.connect(self._var_changed)
box.layout().addWidget(view)
axes_box = gui.vBox(self.controlArea, "Axes")
box = gui.vBox(axes_box, "Axis X", margin=0)
box.setFlat(True)
self.axis_x_cb = gui.comboBox(
box, self, "component_x", callback=self._component_changed)
box = gui.vBox(axes_box, "Axis Y", margin=0)
box.setFlat(True)
self.axis_y_cb = gui.comboBox(
box, self, "component_y", callback=self._component_changed)
self.infotext = gui.widgetLabel(
gui.vBox(self.controlArea, "Contribution to Inertia"), "\n"
)
gui.rubber(self.controlArea)
self.plot = pg.PlotWidget(background="w")
self.plot.setMenuEnabled(False)
self.mainArea.layout().addWidget(self.plot)
def __init__(self):
self.data = None
box = gui.vBox(self.controlArea, 'Seasonal Adjustment')
gui.spin(
box,
self,
'n_periods',
2,
MAX_PERIODS,
label='Season period:',
callback=self.on_changed,
tooltip='The expected length of full cycle. E.g., if you have '
'monthly data and the apparent season repeats every '
'year, you put in 12.')
gui.radioButtons(box,
self,
'decomposition',
self.DECOMPOSITION_MODELS,
label='Decomposition model:',
orientation=Qt.Horizontal,
callback=self.on_changed)
self.view = view = QListView(self,
selectionMode=QListView.ExtendedSelection)
self.model = model = VariableListModel(parent=self)
view.setModel(model)
view.selectionModel().selectionChanged.connect(self.on_changed)
box.layout().addWidget(view)
gui.auto_commit(box, self, 'autocommit', '&Apply')
def __init__(self):
super().__init__()
self.data = None
self.input_vars = ()
self._invalidated = False
box = gui.vBox(self.controlArea, "Domain Features")
self.domain_model = itemmodels.VariableListModel()
self.domain_view = QListView(selectionMode=QListView.SingleSelection,
uniformItemSizes=True)
self.domain_view.setModel(self.domain_model)
self.domain_view.selectionModel().selectionChanged.connect(
self._on_selection_changed)
box.layout().addWidget(self.domain_view)
box = gui.hBox(self.controlArea)
gui.button(box, self, "Reset Selected", callback=self.reset_selected)
gui.button(box, self, "Reset All", callback=self.reset_all)
gui.auto_commit(self.controlArea, self, "autocommit", "Apply")
box = gui.vBox(self.mainArea, "Edit")
self.editor_stack = QStackedWidget()
self.editor_stack.addWidget(DiscreteVariableEditor())
self.editor_stack.addWidget(ContinuousVariableEditor())
self.editor_stack.addWidget(VariableEditor())
box.layout().addWidget(self.editor_stack)
self.Error.add_message("duplicate_var_name",
"A variable name is duplicated.")
def main(argv=[]):
app = QApplication(argv)
w = ToolBox()
style = app.style()
icon = QIcon(style.standardIcon(QStyle.SP_FileIcon))
p1 = QLabel("A Label")
p2 = QListView()
p3 = QLabel("Another\nlabel")
p4 = QSpinBox()
i1 = w.addItem(p1, "Tab 1", icon)
i2 = w.addItem(p2, "Tab 2", icon, "The second tab")
i3 = w.addItem(p3, "Tab 3")
i4 = w.addItem(p4, "Tab 4")
p6 = QTextBrowser()
p6.setHtml(
"<h1>Hello Visitor</h1>"
"<p>Are you interested in some of our wares?</p>"
)
w.insertItem(2, p6, "Dear friend")
w.show()
return app.exec_()
def make_list_view(self, callback, append_to):
data = unc.years()
list = QListView()
list.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
model = QStandardItemModel(0, 1)
for i in range(1, len(data)):
item = QStandardItem(str(data[i]))
model.appendRow(item)
model.itemChanged.connect(callback)
list.setModel(model)
list.setEditTriggers(QAbstractItemView.NoEditTriggers)
list.setSelectionMode(QAbstractItemView.ExtendedSelection)
proxy_model = FindFilterProxyModel()
proxy_model.setSourceModel(model)
proxy_model.setFilterKeyColumn(-1)
list.setModel(proxy_model)
list.selectionModel().selectionChanged.connect(callback)
append_to.layout().addWidget(list)
return [list, proxy_model, model]
def test_dock_standalone(self):
widget = QWidget()
layout = QHBoxLayout()
widget.setLayout(layout)
layout.addStretch(1)
widget.show()
dock = CollapsibleDockWidget()
layout.addWidget(dock)
list_view = QListView()
list_view.setModel(QStringListModel(["a", "b"], list_view))
label = QLabel("A label. ")
label.setWordWrap(True)
dock.setExpandedWidget(label)
dock.setCollapsedWidget(list_view)
dock.setExpanded(True)
self.app.processEvents()
def toogle():
dock.setExpanded(not dock.expanded())
self.singleShot(2000, toogle)
toogle()
self.app.exec_()
def __init__(self):
super().__init__()
self.data = None
self._invalidated = False
# List of available preprocessors (DescriptionRole : Description)
self.preprocessors = QStandardItemModel()
def mimeData(indexlist):
assert len(indexlist) == 1
index = indexlist[0]
qname = index.data(DescriptionRole).qualname
m = QMimeData()
m.setData("application/x-qwidget-ref", qname.encode("utf-8"))
return m
# TODO: Fix this (subclass even if just to pass a function
# for mimeData delegate)
self.preprocessors.mimeData = mimeData
box = gui.vBox(self.controlArea, "Preprocessors")
self.preprocessorsView = view = QListView(
selectionMode=QListView.SingleSelection,
dragEnabled=True,
dragDropMode=QListView.DragOnly)
view.setModel(self.preprocessors)
view.activated.connect(self.__activated)
box.layout().addWidget(view)
####
self._qname2ppdef = {ppdef.qualname: ppdef for ppdef in PREPROCESSORS}
# List of 'selected' preprocessors and their parameters.
self.preprocessormodel = None
self.flow_view = SequenceFlow()
self.controler = Controller(self.flow_view, parent=self)
self.overlay = OverlayWidget(self)
self.overlay.setAttribute(Qt.WA_TransparentForMouseEvents)
self.overlay.setWidget(self.flow_view)
self.overlay.setLayout(QVBoxLayout())
self.overlay.layout().addWidget(
QLabel("Drag items from the list on the left", wordWrap=True))
self.scroll_area = QScrollArea(
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn)
self.scroll_area.viewport().setAcceptDrops(True)
self.scroll_area.setWidget(self.flow_view)
self.scroll_area.setWidgetResizable(True)
self.mainArea.layout().addWidget(self.scroll_area)
self.flow_view.installEventFilter(self)
box = gui.vBox(self.controlArea, "Output")
gui.auto_commit(box, self, "autocommit", "Send", box=False)
self._initialize()
def __init__(self, var, lc, widget_parent=None, widget=None):
QWidget.__init__(self)
self.list_view = QListView()
text = []
model = QStandardItemModel(self.list_view)
for (i, val) in enumerate(var.values):
item = QStandardItem(val)
item.setCheckable(True)
if i + 1 in lc:
item.setCheckState(Qt.Checked)
text.append(val)
model.appendRow(item)
model.itemChanged.connect(widget_parent.conditions_changed)
self.list_view.setModel(model)
layout = QGridLayout(self)
layout.addWidget(self.list_view)
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
self.adjustSize()
self.setWindowFlags(Qt.Popup)
self.widget = widget
self.widget.desc_text = ', '.join(text)
self.widget.set_text()
def test(self):
lv = QListView()
mw = QMainWindow()
# Add two tool bars, the shadow should extend over them.
mw.addToolBar(Qt.BottomToolBarArea, QToolBar())
mw.addToolBar(Qt.TopToolBarArea, QToolBar())
mw.setCentralWidget(lv)
f = dropshadow.DropShadowFrame(color=Qt.blue, radius=20)
f.setWidget(lv)
self.assertIs(f.parentWidget(), mw)
self.assertIs(f.widget(), lv)
mw.show()
canim = QPropertyAnimation(
f, b"color_", f,
startValue=QColor(Qt.red), endValue=QColor(Qt.blue),
loopCount=-1, duration=2000
)
canim.start()
ranim = QPropertyAnimation(
f, b"radius_", f, startValue=30, endValue=40, loopCount=-1,
duration=3000
)
ranim.start()
self.app.exec_()
def __init__(self):
# Commit is thunked because autocommit redefines it
# pylint: disable=unnecessary-lambda
super().__init__()
self.data = None
list_args = dict(alternatingRowColors=True,
dragEnabled=True,
dragDropMode=QListView.DragDrop,
acceptDrops=True,
defaultDropAction=Qt.MoveAction,
showDropIndicator=True,
selectionMode=QListView.ExtendedSelection,
selectionBehavior=QListView.SelectRows)
hbox = gui.hBox(self.controlArea)
listview_avail = QListView(self, **list_args)
self.model_avail = VariableListModel(parent=self, enable_dnd=True)
listview_avail.setModel(self.model_avail)
gui.vBox(hbox,
'Available Variables').layout().addWidget(listview_avail)
listview_key = QListView(self, **list_args)
self.model_key = VariableListModel(parent=self, enable_dnd=True)
listview_key.setModel(self.model_key)
self.model_key.rowsInserted.connect(lambda: self.commit())
self.model_key.rowsRemoved.connect(lambda: self.commit())
gui.vBox(hbox, 'Group by Variables').layout().addWidget(listview_key)
gui.comboBox(self.controlArea,
self,
'tiebreaker',
box="Item Selection",
label='Instance to select in each group:',
orientation=Qt.Horizontal,
items=tuple(self.TIEBREAKERS),
callback=lambda: self.commit(),
sendSelectedValue=True,
sizeAdjustPolicy=QComboBox.AdjustToContents,
minimumContentsLength=20,
sizePolicy=(QSizePolicy.Minimum, QSizePolicy.Preferred))
gui.auto_commit(self.controlArea,
self,
'autocommit',
'Commit',
orientation=Qt.Horizontal)
def test_drop_shadow_old(self):
w = dropshadow._DropShadowWidget()
w.setContentsMargins(20, 20, 20, 20)
w.setLayout(QHBoxLayout())
w.layout().setContentsMargins(0, 0, 0, 0)
w.layout().addWidget(QListView())
w.show()
QTimer.singleShot(1500, lambda: w.setRadius(w.radius + 5))
self.app.exec_()
def _setup_gui_values(self):
self.values_edit = QListView()
self.values_edit.setEditTriggers(QTreeView.CurrentChanged)
self.values_model = itemmodels.PyListModel(
flags=Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemIsEditable)
self.values_edit.setModel(self.values_model)
self.values_model.dataChanged.connect(self.on_values_changed)
self.main_form.addRow("Values:", self.values_edit)
def test_focus_out(self):
cb = self.cb
cb.showPopup()
popup = cb.findChild(QListView)
# Activate some other window to simulate focus out
w = QListView()
w.show()
w.activateWindow()
w.hide()
self.assertFalse(popup.isVisible())
def __init__(self, owwidget, ax, varmodel):
QWidget.__init__(self, owwidget)
gui.OWComponent.__init__(self)
self.ax = ax
self.view = view = QListView(
self,
selectionMode=QTreeWidget.ExtendedSelection,
)
view.setModel(varmodel)
selection = view.selectionModel()
selection.selectionChanged.connect(self.selection_changed)
box = QVBoxLayout(self)
box.setContentsMargins(0, 0, 0, 0)
self.setLayout(box)
hbox = gui.hBox(self)
gui.comboBox(
hbox,
self,
"plot_type",
label="类型:",
orientation="horizontal",
items=("线", "折线", "柱", "面积", "样条曲线"),
sendSelectedValue=True,
callback=lambda: self.sigType.emit(ax, self.plot_types[self.
plot_type]),
)
gui.rubber(hbox)
self.button_close = button = QPushButton(
"×",
hbox,
visible=False,
minimumSize=QSize(20, 20),
maximumSize=QSize(20, 20),
styleSheet="""
QPushButton {
font-weight: bold;
font-size:14pt;
margin:0;
padding:0;
}""",
)
button.clicked.connect(lambda: self.sigClosed.emit(ax, self))
hbox.layout().addWidget(button)
gui.checkBox(
self,
self,
"is_logarithmic",
"对数轴",
callback=lambda: self.sigLogarithmic.emit(ax, self.is_logarithmic),
)
box.addWidget(view)
def __init__(self, parent=None):
super().__init__(self, parent)
self.data = None
self.partitions = []
self.matrix = None
self.split_groups = []
self._disable_updates = False
########
# GUI
########
box = gui.widgetBox(self.controlArea, "Input")
self.info_box = gui.widgetLabel(box, "No data on input\n")
box = gui.widgetBox(self.controlArea, "Separate By", addSpace=True)
self.separate_view = QListView(selectionMode=QListView.MultiSelection)
box.layout().addWidget(self.separate_view)
box = gui.widgetBox(self.controlArea, "Sort By", addSpace=True)
self.relevant_view = QListView(selectionMode=QListView.MultiSelection)
box.layout().addWidget(self.relevant_view)
self.distance_view = gui.comboBox(
self.controlArea,
self,
"distance_measure",
box="Distance Measure",
items=[name for name, _ in self.DISTANCE_FUNCTIONS])
gui.rubber(self.controlArea)
gui.auto_commit(self.controlArea, self, "auto_commit", "Commit")
self.groups_box = gui.widgetBox(self.mainArea, "Groups")
self.groups_scroll_area = QScrollArea()
self.groups_box.layout().addWidget(self.groups_scroll_area)
def __init__(self):
self.data = None
self.indices = []
box = gui.vBox(self.controlArea, 'Axes')
self.combo_ax2_model = VariableListModel(parent=self)
self.combo_ax1_model = VariableListModel(parent=self)
for model in (self.combo_ax1_model, self.combo_ax2_model):
model[:] = [_enum_str(i) for i in Spiralogram.AxesCategories]
self.combo_ax2 = gui.comboBox(box,
self,
'ax2',
label='Y axis:',
callback=self.replot,
sendSelectedValue=True,
orientation='horizontal',
model=self.combo_ax2_model)
self.combo_ax1 = gui.comboBox(box,
self,
'ax1',
label='Radial:',
callback=self.replot,
sendSelectedValue=True,
orientation='horizontal',
model=self.combo_ax1_model)
gui.checkBox(box,
self,
'invert_date_order',
'Invert Y axis order',
callback=self.replot)
box = gui.vBox(self.controlArea, 'Aggregation')
self.combo_func = gui.comboBox(box,
self,
'agg_func',
label='Function:',
orientation='horizontal',
callback=self.replot)
func_model = ListModel(AGG_FUNCTIONS, parent=self)
self.combo_func.setModel(func_model)
self.attrlist_model = VariableListModel(parent=self)
self.attrlist = QListView(selectionMode=QListView.SingleSelection)
self.attrlist.setModel(self.attrlist_model)
self.attrlist.selectionModel().selectionChanged.connect(
self.attrlist_selectionChanged)
box.layout().addWidget(self.attrlist)
gui.rubber(self.controlArea)
self.chart = chart = Spiralogram(self,
selection_callback=self.on_selection)
self.mainArea.layout().addWidget(chart)
def _setup_gui_values(self):
vlayout = QVBoxLayout()
vlayout.setContentsMargins(0, 0, 0, 0)
vlayout.setSpacing(1)
self.values_edit = QListView()
self.values_edit.setEditTriggers(QTreeView.CurrentChanged)
self.values_model = itemmodels.PyListModel(flags=Qt.ItemIsSelectable | \
Qt.ItemIsEnabled | Qt.ItemIsEditable)
self.values_edit.setModel(self.values_model)
self.values_edit.selectionModel().selectionChanged.connect(
self.on_value_selection_changed)
self.values_model.dataChanged.connect(self.on_values_changed)
vlayout.addWidget(self.values_edit)
hlayout = QHBoxLayout()
hlayout.setContentsMargins(0, 0, 0, 0)
hlayout.setSpacing(1)
self.move_value_up = QAction(unicodedata.lookup("UPWARDS ARROW"),
self,
toolTip="Move up.",
triggered=self.move_up,
enabled=False,
shortcut=QKeySequence(QKeySequence.New))
self.move_value_down = QAction(unicodedata.lookup("DOWNWARDS ARROW"),
self,
toolTip="Move down.",
triggered=self.move_down,
enabled=False,
shortcut=QKeySequence(
QKeySequence.Delete))
button_size = gui.toolButtonSizeHint()
button_size = QSize(button_size, button_size)
button = QToolButton(self)
button.setFixedSize(button_size)
button.setDefaultAction(self.move_value_up)
hlayout.addWidget(button)
button = QToolButton(self)
button.setFixedSize(button_size)
button.setDefaultAction(self.move_value_down)
hlayout.addWidget(button)
hlayout.addStretch(10)
vlayout.addLayout(hlayout)
self.main_form.addRow("Values:", vlayout)
def _setup_library_box(self):
self.library_view = QListView(
editTriggers=QListView.DoubleClicked | QListView.EditKeyPressed,
minimumWidth=200,
sizePolicy=QSizePolicy(QSizePolicy.Ignored, QSizePolicy.Expanding),
)
self.library_view.setItemDelegate(WordListItemDelegate(self))
self.library_view.setModel(self.library_model)
self.library_view.selectionModel().selectionChanged.connect(
self.__on_library_selection_changed)
self.__library_box.layout().setSpacing(1)
self.__library_box.layout().addWidget(self.library_view)
actions_widget = ModelActionsWidget()
actions_widget.layout().setSpacing(1)
action = QAction("+", self)
action.setToolTip("Add a new word list to the library")
action.triggered.connect(self.__on_add_word_list)
actions_widget.addAction(action)
action = QAction("\N{MINUS SIGN}", self)
action.setToolTip("Remove word list from library")
action.triggered.connect(self.__on_remove_word_list)
actions_widget.addAction(action)
action = QAction("Update", self)
action.setToolTip("Save changes in the editor to library")
action.setShortcut(QKeySequence(QKeySequence.Save))
action.triggered.connect(self.__on_update_word_list)
actions_widget.addAction(action)
gui.rubber(actions_widget.layout())
action = QAction("More", self, toolTip="More actions")
new_from_file = QAction("Import Words from File", self)
new_from_file.triggered.connect(self.__on_import_word_list)
save_to_file = QAction("Save Words to File", self)
save_to_file.setShortcut(QKeySequence(QKeySequence.SaveAs))
save_to_file.triggered.connect(self.__on_save_word_list)
menu = QMenu(actions_widget)
menu.addAction(new_from_file)
menu.addAction(save_to_file)
action.setMenu(menu)
button = actions_widget.addAction(action)
button.setPopupMode(QToolButton.InstantPopup)
self.__library_box.layout().addWidget(actions_widget)
def __init__(self):
self.data = None
box = gui.vBox(self.controlArea, 'Differencing')
gui.comboBox(box,
self,
'chosen_operation',
orientation=Qt.Horizontal,
items=[el.value for el in self.Operation],
label='Compute:',
callback=self.on_changed,
sendSelectedValue=True)
self.order_spin = gui.spin(
box,
self,
'diff_order',
1,
2,
label='Differencing order:',
callback=self.on_changed,
tooltip='The value corresponds to n-th order numerical '
'derivative of the series. \nThe order is fixed to 1 '
'if the shift period is other than 1.')
gui.spin(box,
self,
'shift_period',
1,
100,
label='Shift:',
callback=self.on_changed,
tooltip='Set this to other than 1 if you don\'t want to '
'compute differences for subsequent values but for '
'values shifted number of spaces apart. \n'
'If this value is different from 1, differencing '
'order is fixed to 1.')
gui.checkBox(box,
self,
'invert_direction',
label='Invert differencing direction',
callback=self.on_changed,
tooltip='Influences where the series is padded with nan '
'values — at the beginning or at the end.')
self.view = view = QListView(self,
selectionMode=QListView.ExtendedSelection)
self.model = model = VariableListModel(parent=self)
view.setModel(model)
view.selectionModel().selectionChanged.connect(self.on_changed)
box.layout().addWidget(view)
gui.auto_commit(box, self, 'autocommit', '&Apply')
def __init__(self, owwidget, ax, varmodel):
QWidget.__init__(self, owwidget)
gui.OWComponent.__init__(self)
self.ax = ax
self.view = view = QListView(
self,
selectionMode=QTreeWidget.ExtendedSelection,
)
view.setModel(varmodel)
selection = view.selectionModel()
selection.selectionChanged.connect(self.selection_changed)
box = QVBoxLayout(self)
box.setContentsMargins(0, 0, 0, 0)
self.setLayout(box)
hbox = gui.hBox(self)
gui.comboBox(hbox,
self,
'plot_type',
label='Type:',
orientation='horizontal',
items=('line', 'step line', 'column', 'area', 'spline'),
sendSelectedValue=True,
callback=lambda: self.sigType.emit(ax, self.plot_type))
gui.rubber(hbox)
self.button_close = button = QPushButton('×',
hbox,
visible=False,
minimumSize=QSize(20, 20),
maximumSize=QSize(20, 20),
styleSheet='''
QPushButton {
font-weight: bold;
font-size:14pt;
margin:0;
padding:0;
}''')
button.clicked.connect(lambda: self.sigClosed.emit(ax, self))
hbox.layout().addWidget(button)
gui.checkBox(
self,
self,
"is_logarithmic",
"Logarithmic axis",
callback=self.on_logarithmic,
)
box.addWidget(view)
def __init__(self):
super().__init__()
self.__model = None
self.__selectionMode = QListView.ExtendedSelection
self.__currentIndex = -1
self.__selections = {}
self.__parent = None
self.targets = []
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
def group_box(title):
box = QGroupBox(title)
box.setFlat(True)
lay = QVBoxLayout()
lay.setContentsMargins(0, 0, 0, 0)
box.setLayout(lay)
return box
self.labels_combo = QComboBox()
self.values_view = QListView(selectionMode=self.__selectionMode)
self.labels_combo.currentIndexChanged.connect(
self.__onCurrentIndexChanged)
l_box = group_box(self.tr("Label"))
v_box = group_box(self.tr("Values"))
l_box.layout().addWidget(self.labels_combo)
v_box.layout().addWidget(self.values_view)
layout.addWidget(l_box)
layout.addWidget(v_box)
self.setLayout(layout)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
def test_tool_box(self):
w = toolbox.ToolBox()
style = self.app.style()
icon = QIcon(style.standardPixmap(style.SP_FileIcon))
p1 = QLabel("A Label")
p2 = QListView()
p3 = QLabel("Another\nlabel")
p4 = QSpinBox()
i1 = w.addItem(p1, "T1", icon)
i2 = w.addItem(p2, "Tab " * 10, icon, "a tab")
i3 = w.addItem(p3, "t3")
i4 = w.addItem(p4, "t4")
self.assertSequenceEqual([i1, i2, i3, i4], range(4))
self.assertEqual(w.count(), 4)
for i, item in enumerate([p1, p2, p3, p4]):
self.assertIs(item, w.widget(i))
b = w.tabButton(i)
a = w.tabAction(i)
self.assertIsInstance(b, QAbstractButton)
self.assertIs(b.defaultAction(), a)
w.show()
w.removeItem(2)
self.assertEqual(w.count(), 3)
self.assertIs(w.widget(2), p4)
p3 = QLabel("Once More Unto the Breach")
w.insertItem(2, p3, "Dear friend")
self.assertEqual(w.count(), 4)
self.assertIs(w.widget(1), p2)
self.assertIs(w.widget(2), p3)
self.assertIs(w.widget(3), p4)
self.app.exec_()
def test_delegate(self):
model = VariableListModel([None, None])
def set_item(row: int, v: dict):
model.setItemData(model.index(row), v)
def get_style_option(row: int) -> QStyleOptionViewItem:
opt = QStyleOptionViewItem()
delegate.initStyleOption(opt, model.index(row))
return opt
set_item(0, {Qt.EditRole: Categorical("a", (), (), False)})
delegate = VariableEditDelegate()
opt = get_style_option(0)
self.assertEqual(opt.text, "a")
self.assertFalse(opt.font.italic())
set_item(0, {TransformRole: [Rename("b")]})
opt = get_style_option(0)
self.assertEqual(opt.text, "a \N{RIGHTWARDS ARROW} b")
self.assertTrue(opt.font.italic())
set_item(0, {TransformRole: [AsString()]})
opt = get_style_option(0)
self.assertIn("reinterpreted", opt.text)
self.assertTrue(opt.font.italic())
set_item(1, {
Qt.EditRole: String("b", (), False),
TransformRole: [Rename("a")]
})
opt = get_style_option(1)
self.assertEqual(opt.palette.color(QPalette.Text), QColor(Qt.red))
view = QListView()
with patch.object(QToolTip, "showText") as p:
delegate.helpEvent(
QHelpEvent(QHelpEvent.ToolTip, QPoint(0, 0), QPoint(0, 0)),
view,
opt,
model.index(1),
)
p.assert_called_once()
def test(self):
lv = QListView()
mw = QMainWindow()
# Add two tool bars, the shadow should extend over them.
mw.addToolBar(Qt.BottomToolBarArea, QToolBar())
mw.addToolBar(Qt.TopToolBarArea, QToolBar())
mw.setCentralWidget(lv)
f = dropshadow.DropShadowFrame(color=Qt.blue, radius=20)
f.setWidget(lv)
self.assertIs(f.parentWidget(), mw)
self.assertIs(f.widget(), lv)
mw.show()
self.app.processEvents()
self.singleShot(3000, lambda: f.setColor(Qt.red))
self.singleShot(4000, lambda: f.setRadius(30))
self.singleShot(5000, lambda: f.setRadius(40))
self.app.exec_()
def __init__(self):
super().__init__()
#: input data
self.data = None
#: Current variable discretization state
self.var_state = {}
#: Saved variable discretization settings (context setting)
self.saved_var_states = {}
self.method = 0
self.k = 5
box = gui.vBox(self.controlArea, self.tr("Default Discretization"))
self.default_bbox = rbox = gui.radioButtons(
box, self, "default_method", callback=self._default_disc_changed)
rb = gui.hBox(rbox)
self.left = gui.vBox(rb)
right = gui.vBox(rb)
rb.layout().setStretch(0, 1)
rb.layout().setStretch(1, 1)
options = self.options = [
self.tr("Default"),
self.tr("Leave numeric"),
self.tr("Entropy-MDL discretization"),
self.tr("Equal-frequency discretization"),
self.tr("Equal-width discretization"),
self.tr("Remove numeric variables")
]
for opt in options[1:]:
t = gui.appendRadioButton(rbox, opt)
# This condition is ugly, but it keeps the same order of
# options for backward compatibility of saved schemata
[right, self.left][opt.startswith("Equal")].layout().addWidget(t)
gui.separator(right, 18, 18)
def _intbox(widget, attr, callback):
box = gui.indentedBox(widget)
s = gui.spin(box,
self,
attr,
minv=2,
maxv=10,
label="Num. of intervals:",
callback=callback)
s.setMaximumWidth(60)
s.setAlignment(Qt.AlignRight)
gui.rubber(s.box)
return box.box
self.k_general = _intbox(self.left, "default_k",
self._default_disc_changed)
self.k_general.layout().setContentsMargins(0, 0, 0, 0)
vlayout = QHBoxLayout()
box = gui.widgetBox(self.controlArea,
"Individual Attribute Settings",
orientation=vlayout,
spacing=8)
# List view with all attributes
self.varview = QListView(selectionMode=QListView.ExtendedSelection)
self.varview.setItemDelegate(DiscDelegate())
self.varmodel = itemmodels.VariableListModel()
self.varview.setModel(self.varmodel)
self.varview.selectionModel().selectionChanged.connect(
self._var_selection_changed)
vlayout.addWidget(self.varview)
# Controls for individual attr settings
self.bbox = controlbox = gui.radioButtons(
box, self, "method", callback=self._disc_method_changed)
vlayout.addWidget(controlbox)
for opt in options[:5]:
gui.appendRadioButton(controlbox, opt)
self.k_specific = _intbox(controlbox, "k", self._disc_method_changed)
gui.appendRadioButton(controlbox, "Remove attribute")
gui.rubber(controlbox)
controlbox.setEnabled(False)
self.controlbox = controlbox
box = gui.auto_commit(self.controlArea,
self,
"autosend",
"Apply",
orientation=Qt.Horizontal,
checkbox_label="Apply automatically")
box.layout().insertSpacing(0, 20)
box.layout().insertWidget(0, self.report_button)
self._update_spin_positions()
def __init__(self):
super().__init__()
self.libraryListSource = []
for name in self.signal_names:
setattr(self, name, {})
self._cachedDocuments = {}
self.infoBox = gui.vBox(self.controlArea, 'Info')
gui.label(
self.infoBox, self,
"<p>Execute python script.</p><p>Input variables:<ul><li> " +
"<li>".join(map("in_{0}, in_{0}s".format, self.signal_names)) +
"</ul></p><p>Output variables:<ul><li>" +
"<li>".join(map("out_{0}".format, self.signal_names)) +
"</ul></p>")
self.libraryList = itemmodels.PyListModel(
[],
self,
flags=Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemIsEditable)
self.libraryList.wrap(self.libraryListSource)
self.controlBox = gui.vBox(self.controlArea, 'Library')
self.controlBox.layout().setSpacing(1)
self.libraryView = QListView(
editTriggers=QListView.DoubleClicked | QListView.EditKeyPressed,
sizePolicy=QSizePolicy(QSizePolicy.Ignored, QSizePolicy.Preferred))
self.libraryView.setItemDelegate(ScriptItemDelegate(self))
self.libraryView.setModel(self.libraryList)
self.libraryView.selectionModel().selectionChanged.connect(
self.onSelectedScriptChanged)
self.controlBox.layout().addWidget(self.libraryView)
w = itemmodels.ModelActionsWidget()
self.addNewScriptAction = action = QAction("+", self)
action.setToolTip("Add a new script to the library")
action.triggered.connect(self.onAddScript)
w.addAction(action)
action = QAction(unicodedata.lookup("MINUS SIGN"), self)
action.setToolTip("Remove script from library")
action.triggered.connect(self.onRemoveScript)
w.addAction(action)
action = QAction("Update", self)
action.setToolTip("Save changes in the editor to library")
action.setShortcut(QKeySequence(QKeySequence.Save))
action.triggered.connect(self.commitChangesToLibrary)
w.addAction(action)
action = QAction("More", self, toolTip="More actions")
new_from_file = QAction("Import Script from File", self)
save_to_file = QAction("Save Selected Script to File", self)
restore_saved = QAction("Undo Changes to Selected Script", self)
save_to_file.setShortcut(QKeySequence(QKeySequence.SaveAs))
new_from_file.triggered.connect(self.onAddScriptFromFile)
save_to_file.triggered.connect(self.saveScript)
restore_saved.triggered.connect(self.restoreSaved)
menu = QMenu(w)
menu.addAction(new_from_file)
menu.addAction(save_to_file)
menu.addAction(restore_saved)
action.setMenu(menu)
button = w.addAction(action)
button.setPopupMode(QToolButton.InstantPopup)
w.layout().setSpacing(1)
self.controlBox.layout().addWidget(w)
self.execute_button = gui.button(self.controlArea,
self,
'Run',
callback=self.commit)
run = QAction("Run script",
self,
triggered=self.commit,
shortcut=QKeySequence(Qt.ControlModifier | Qt.Key_R))
self.addAction(run)
self.splitCanvas = QSplitter(Qt.Vertical, self.mainArea)
self.mainArea.layout().addWidget(self.splitCanvas)
self.defaultFont = defaultFont = \
"Monaco" if sys.platform == "darwin" else "Courier"
self.textBox = gui.vBox(self, 'Python Script')
self.splitCanvas.addWidget(self.textBox)
self.text = PythonScriptEditor(self)
self.textBox.layout().addWidget(self.text)
self.textBox.setAlignment(Qt.AlignVCenter)
self.text.setTabStopWidth(4)
self.text.modificationChanged[bool].connect(self.onModificationChanged)
self.saveAction = action = QAction("&Save", self.text)
action.setToolTip("Save script to file")
action.setShortcut(QKeySequence(QKeySequence.Save))
action.setShortcutContext(Qt.WidgetWithChildrenShortcut)
action.triggered.connect(self.saveScript)
self.consoleBox = gui.vBox(self, 'Console')
self.splitCanvas.addWidget(self.consoleBox)
self.console = PythonConsole({}, self)
self.consoleBox.layout().addWidget(self.console)
self.console.document().setDefaultFont(QFont(defaultFont))
self.consoleBox.setAlignment(Qt.AlignBottom)
self.console.setTabStopWidth(4)
self.splitCanvas.setSizes([2, 1])
self.setAcceptDrops(True)
self.controlArea.layout().addStretch(10)
self._restoreState()
self.settingsAboutToBePacked.connect(self._saveState)
def __init__(self):
super().__init__()
self.data = None
self.editors = {}
box = gui.vBox(self.controlArea, "Variable Definitions")
toplayout = QHBoxLayout()
toplayout.setContentsMargins(0, 0, 0, 0)
box.layout().addLayout(toplayout)
self.editorstack = QStackedWidget(
sizePolicy=QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
)
for descclass, editorclass in self.EDITORS:
editor = editorclass()
editor.featureChanged.connect(self._on_modified)
self.editors[descclass] = editor
self.editorstack.addWidget(editor)
self.editorstack.setEnabled(False)
buttonlayout = QVBoxLayout(spacing=10)
buttonlayout.setContentsMargins(0, 0, 0, 0)
self.addbutton = QPushButton(
"New", toolTip="Create a new variable",
minimumWidth=120,
shortcut=QKeySequence.New
)
def unique_name(fmt, reserved):
candidates = (fmt.format(i) for i in count(1))
return next(c for c in candidates if c not in reserved)
def reserved_names():
varnames = []
if self.data is not None:
varnames = [var.name for var in
self.data.domain.variables + self.data.domain.metas]
varnames += [desc.name for desc in self.featuremodel]
return set(varnames)
def generate_newname(fmt):
return unique_name(fmt, reserved_names())
menu = QMenu(self.addbutton)
cont = menu.addAction("Continuous")
cont.triggered.connect(
lambda: self.addFeature(
ContinuousDescriptor(generate_newname("X{}"), "", 3))
)
disc = menu.addAction("Discrete")
disc.triggered.connect(
lambda: self.addFeature(
DiscreteDescriptor(generate_newname("D{}"), "",
("A", "B"), -1, False))
)
string = menu.addAction("String")
string.triggered.connect(
lambda: self.addFeature(
StringDescriptor(generate_newname("S{}"), ""))
)
menu.addSeparator()
self.duplicateaction = menu.addAction("Duplicate Selected Variable")
self.duplicateaction.triggered.connect(self.duplicateFeature)
self.duplicateaction.setEnabled(False)
self.addbutton.setMenu(menu)
self.removebutton = QPushButton(
"Remove", toolTip="Remove selected variable",
minimumWidth=120,
shortcut=QKeySequence.Delete
)
self.removebutton.clicked.connect(self.removeSelectedFeature)
buttonlayout.addWidget(self.addbutton)
buttonlayout.addWidget(self.removebutton)
buttonlayout.addStretch(10)
toplayout.addLayout(buttonlayout, 0)
toplayout.addWidget(self.editorstack, 10)
# Layout for the list view
layout = QVBoxLayout(spacing=1, margin=0)
self.featuremodel = DescriptorModel(parent=self)
self.featureview = QListView(
minimumWidth=200,
sizePolicy=QSizePolicy(QSizePolicy.Minimum,
QSizePolicy.MinimumExpanding)
)
self.featureview.setItemDelegate(FeatureItemDelegate(self))
self.featureview.setModel(self.featuremodel)
self.featureview.selectionModel().selectionChanged.connect(
self._on_selectedVariableChanged
)
layout.addWidget(self.featureview)
box.layout().addLayout(layout, 1)
box = gui.hBox(self.controlArea)
box.layout().addWidget(self.report_button)
self.report_button.setMinimumWidth(180)
gui.rubber(box)
commit = gui.button(box, self, "Send", callback=self.apply,
default=True)
commit.setMinimumWidth(180)
