def __init__(self, parent=None, **kwargs):
super().__init__(parent, **kwargs)
self._lower_bound = self.DEFAULT_LOWER_BOUND
self._upper_bound = self.DEFAULT_UPPER_BOUND
self.setLayout(QVBoxLayout())
box = QGroupBox(title="Clipping", flat=True)
form = QFormLayout()
self.lower_check = QCheckBox("Lower Bound: ")
self.lower_check.clicked.connect(self.edited)
self.lower_spin = QSpinBox(minimum=-99,
maximum=0,
value=self._lower_bound)
self.lower_spin.valueChanged[int].connect(self._set_lower_bound)
self.lower_spin.editingFinished.connect(self.edited)
self.upper_check = QCheckBox("Upper Bound: ")
self.upper_check.clicked.connect(self.edited)
self.upper_spin = QSpinBox(value=self._upper_bound)
self.upper_spin.valueChanged[int].connect(self._set_upper_bound)
self.upper_spin.editingFinished.connect(self.edited)
form.addRow(self.lower_check, self.lower_spin)
form.addRow(self.upper_check, self.upper_spin)
box.setLayout(form)
self.layout().addWidget(box)
def init_form(self):
self._boundingbox = GaugeWidgetHorizontal() if self._horizontal else GaugeWidgetVertical()
self._boundingbox.changed_event = self.__update
if self._show_spinboxes:
self._form = hwidget = QWidget()
if self._horizontal:
hlayout = QHBoxLayout()
else:
hlayout = QVBoxLayout()
if _api.USED_API == _api.QT_API_PYQT5:
hlayout.setContentsMargins(0,0,0,0)
elif _api.USED_API == _api.QT_API_PYQT4:
hlayout.setMargin(0)
if self._label is not None:
self._controllabel = QLabel(self.form)
hlayout.addWidget(self._controllabel)
self._controllabel.setAccessibleName('ControlBoundingSlider-label')
self.label = self._label
else:
self._controllabel = None
hwidget.setLayout(hlayout)
self._min_spinbox = QSpinBox()
self._min_spinbox.valueChanged.connect(self.__min_spinbox_changed)
self._min_spinbox.setMaximumWidth(95)
self._max_spinbox = QSpinBox()
self._max_spinbox.valueChanged.connect(self.__max_spinbox_changed)
self._max_spinbox.setMaximumWidth(95)
if self._horizontal:
hlayout.addWidget(self._min_spinbox)
else:
hlayout.addWidget(self._max_spinbox)
hlayout.addWidget(self._boundingbox)
if self._horizontal:
hlayout.addWidget(self._max_spinbox)
else:
hlayout.addWidget(self._min_spinbox)
else:
self._form = self._boundingbox
super(ControlBoundingSlider, self).init_form()
def __init__(self, parent=None, **kwargs):
super().__init__(parent, **kwargs)
self.fixedThresh = 50
self.percThresh = 5
self.useFixedThreshold = False
self.filter0 = True
self.setLayout(QVBoxLayout())
self.layout().addWidget(QLabel("Remove features with too many"))
options = ["missing values", "zeros"]
self.filter_buttons = QButtonGroup(exclusive=True)
self.filter_buttons.buttonClicked.connect(self.filterByClicked)
for idx, option, in enumerate(options):
btn = QRadioButton(self, text=option, checked=idx == 0)
self.filter_buttons.addButton(btn, id=idx)
self.layout().addWidget(btn)
self.layout().addSpacing(20)
filter_settings = QGroupBox(title='Threshold:', flat=True)
filter_settings.setLayout(QFormLayout())
self.settings_buttons = QButtonGroup(exclusive=True)
self.settings_buttons.buttonClicked.connect(self.filterSettingsClicked)
btn_perc = QRadioButton(self,
text='Percentage',
checked=not self.useFixedThreshold)
self.settings_buttons.addButton(btn_perc, id=0)
self.percSpin = QSpinBox(minimum=0,
maximum=100,
value=self.percThresh,
enabled=not self.useFixedThreshold)
self.percSpin.valueChanged[int].connect(self.setPercThresh)
self.percSpin.editingFinished.connect(self.edited)
btn_fix = QRadioButton(self,
text='Fixed',
checked=self.useFixedThreshold)
self.settings_buttons.addButton(btn_fix, id=1)
self.fixedSpin = QSpinBox(minimum=0,
maximum=1000000,
value=self.fixedThresh,
enabled=self.useFixedThreshold)
self.fixedSpin.valueChanged[int].connect(self.setFixedThresh)
self.fixedSpin.editingFinished.connect(self.edited)
filter_settings.layout().addRow(btn_fix, self.fixedSpin)
filter_settings.layout().addRow(btn_perc, self.percSpin)
self.layout().addWidget(filter_settings)
def __init__(self):
super().__init__()
rb = self.radios = gui.radioButtons(self.controlArea,
self,
"graph_type",
box="Graph type",
callback=self.on_type_changed)
self.arg_spins = {}
for name, _, arguments, post, *_ in self.GRAPH_TYPES:
argbox = gui.hBox(rb)
gui.appendRadioButton(rb, name, argbox)
self.arg_spins[name] = box = []
min_max = self.mins_maxs.get(name, ((1, 100), ) * len(arguments))
for arg, (minv, maxv) in zip(arguments, min_max):
box.append(gui.widgetLabel(argbox, arg))
spin = QSpinBox(value=self.arguments[_ctrl_name(name, arg)],
minimum=minv,
maximum=maxv)
argbox.layout().addWidget(spin)
spin.valueChanged.connect(lambda value, name=name, arg=arg:
self.update_arg(value, name, arg))
box.append(spin)
if post:
box.append(gui.widgetLabel(gui.hBox(argbox), post))
self.bt_generate = gui.button(self.controlArea,
self,
"Regenerate Network",
callback=self.generate)
self.on_type_changed()
def _(value: int, values: Iterable[int], parent: QGroupBox, key: KeyType,
signal: Callable) -> QSpinBox:
spin = QSpinBox(minimum=values.start, maximum=values.stop,
singleStep=values.step, value=value)
parent.layout().addWidget(spin)
spin.valueChanged.connect(lambda val: signal.emit(key, val))
return spin
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 __init__(self, parent=None, **kwargs):
super().__init__(parent, **kwargs)
self.setLayout(QVBoxLayout())
self.__scoreidx = 0
self.__strategy = UnivariateFeatureSelect.Fixed
self.__k = 10
self.__p = 75.0
box = QGroupBox(title="Score", flat=True)
box.setLayout(QVBoxLayout())
self.__cb = cb = QComboBox(self, )
self.__cb.currentIndexChanged.connect(self.setScoreIndex)
self.__cb.activated.connect(self.edited)
box.layout().addWidget(cb)
self.layout().addWidget(box)
box = QGroupBox(title="Strategy", flat=True)
self.__group = group = QButtonGroup(self, exclusive=True)
self.__spins = {}
form = QFormLayout()
fixedrb = QRadioButton("Fixed:", checked=True)
group.addButton(fixedrb, UnivariateFeatureSelect.Fixed)
kspin = QSpinBox(
minimum=1,
value=self.__k,
enabled=self.__strategy == UnivariateFeatureSelect.Fixed)
kspin.valueChanged[int].connect(self.setK)
kspin.editingFinished.connect(self.edited)
self.__spins[UnivariateFeatureSelect.Fixed] = kspin
form.addRow(fixedrb, kspin)
percrb = QRadioButton("Percentile:")
group.addButton(percrb, UnivariateFeatureSelect.Percentile)
pspin = QDoubleSpinBox(
minimum=0.0,
maximum=100.0,
singleStep=0.5,
value=self.__p,
suffix="%",
enabled=self.__strategy == UnivariateFeatureSelect.Percentile)
pspin.valueChanged[float].connect(self.setP)
pspin.editingFinished.connect(self.edited)
self.__spins[UnivariateFeatureSelect.Percentile] = pspin
# Percentile controls disabled for now.
pspin.setEnabled(False)
percrb.setEnabled(False)
form.addRow(percrb, pspin)
# form.addRow(QRadioButton("FDR"), QDoubleSpinBox())
# form.addRow(QRadioButton("FPR"), QDoubleSpinBox())
# form.addRow(QRadioButton("FWE"), QDoubleSpinBox())
self.__group.buttonClicked.connect(self.__on_buttonClicked)
box.setLayout(form)
self.layout().addWidget(box)
def _(values: Iterable[int], value: int, key: KeyType, signal: Callable) \
-> QSpinBox:
spin = QSpinBox(minimum=values.start,
maximum=values.stop,
singleStep=values.step,
value=value)
spin.valueChanged.connect(lambda val: signal.emit(key, val))
return spin
def intspin():
s = QSpinBox(self)
s.setMinimum(2)
s.setMaximum(10)
s.setFixedWidth(60)
s.setAlignment(Qt.AlignRight)
s.setContentsMargins(0, 0, 0, 0)
return s, s.valueChanged
def __init__(self, parent=None, **kwargs):
super().__init__(parent, **kwargs)
self.setLayout(QVBoxLayout())
self.sparse_thresh = 5
form = QFormLayout()
self.cspin = QSpinBox(minimum=1, maximum=100, value=self.sparse_thresh)
self.cspin.valueChanged[int].connect(self.setThresh)
self.cspin.editingFinished.connect(self.edited)
form.addRow("Min % of nonzero values:", self.cspin)
self.layout().addLayout(form)
def init_form(self):
self._boundingbox = GaugeWidgetHorizontal(
) if self._horizontal else GaugeWidgetVertical()
self._boundingbox.changed_event = self.__update
if self._show_spinboxes:
self._form = hwidget = QWidget()
if self._horizontal:
hlayout = QHBoxLayout()
else:
hlayout = QVBoxLayout()
if conf.PYFORMS_USE_QT5:
hlayout.setContentsMargins(0, 0, 0, 0)
else:
hlayout.setMargin(0)
hwidget.setLayout(hlayout)
self._min_spinbox = QSpinBox()
self._min_spinbox.valueChanged.connect(self.__min_spinbox_changed)
self._min_spinbox.setMaximumWidth(95)
self._max_spinbox = QSpinBox()
self._max_spinbox.valueChanged.connect(self.__max_spinbox_changed)
self._max_spinbox.setMaximumWidth(95)
if self._horizontal:
hlayout.addWidget(self._min_spinbox)
else:
hlayout.addWidget(self._max_spinbox)
hlayout.addWidget(self._boundingbox)
if self._horizontal:
hlayout.addWidget(self._max_spinbox)
else:
hlayout.addWidget(self._min_spinbox)
else:
self._form = self._boundingbox
super(ControlBoundingSlider, self).init_form()
def __init__(self, parent=None, **kwargs):
super().__init__(parent, **kwargs)
self.setLayout(QVBoxLayout())
self._n_genes = self.DEFAULT_N_GENES
form = QFormLayout()
self.n_genes_spin = QSpinBox(minimum=1,
maximum=10**6,
value=self._n_genes)
self.n_genes_spin.valueChanged[int].connect(self._set_n_genes)
self.n_genes_spin.editingFinished.connect(self.edited)
form.addRow("Number of genes:", self.n_genes_spin)
self.layout().addLayout(form)
def __init__(self, parent=None, **kwargs):
super().__init__(parent, **kwargs)
self.setLayout(QVBoxLayout())
self.n_components = 10
form = QFormLayout()
self.cspin = QSpinBox(minimum=1, value=self.n_components)
self.cspin.valueChanged[int].connect(self.setC)
self.cspin.editingFinished.connect(self.edited)
form.addRow("Components:", self.cspin)
self.layout().addLayout(form)
def __init__(self, parent=None, **kwargs):
super().__init__(parent, **kwargs)
self.setLayout(QVBoxLayout())
self._n_genes = self.DEFAULT_N_GENS
self._n_groups = self.DEFAULT_N_GROUPS
form = QFormLayout()
self.n_genes_spin = QSpinBox(minimum=1,
maximum=10**6,
value=self._n_genes)
self.n_genes_spin.valueChanged[int].connect(self._set_n_genes)
self.n_genes_spin.editingFinished.connect(self.edited)
form.addRow("Number of genes:", self.n_genes_spin)
self.layout().addLayout(form)
disp_b = QRadioButton("Dispersion", checked=True)
vari_b = QRadioButton("Variance")
mean_b = QRadioButton("Mean")
self.group = QButtonGroup()
self.group.buttonClicked.connect(self._on_button_clicked)
for i, button in enumerate([disp_b, vari_b, mean_b]):
index = index_to_enum(SelectMostVariableGenes.Method, i).value
self.group.addButton(button, index - 1)
form.addRow(button)
self.stats_check = QCheckBox("Compute statistics for",
checked=self.DEFAULT_COMPUTE_STATS)
self.stats_check.clicked.connect(self.edited)
self.n_groups_spin = QSpinBox(minimum=1, value=self._n_groups)
self.n_groups_spin.valueChanged[int].connect(self._set_n_groups)
self.n_groups_spin.editingFinished.connect(self.edited)
box = QHBoxLayout()
box.addWidget(self.stats_check)
box.addWidget(self.n_groups_spin)
box.addWidget(QLabel("gene groups."))
box.addStretch()
self.layout().addLayout(box)
def __init__(self):
def space(a, b):
if not isinstance(a, str) or a[-1] in string.ascii_letters \
and not isinstance(b, str) or b[0] in string.ascii_letters:
return " "
else:
return ""
super().__init__()
rb = self.radios = gui.radioButtons(self.controlArea,
self,
"graph_type",
box=True,
callback=self.on_type_changed)
rb.layout().setSpacing(6)
self.arg_spins = {}
for (_1, name, _2, *arguments), defaults \
in zip(self.GRAPH_TYPES, self.arguments.values()):
argbox = gui.hBox(rb)
argbox.layout().setSpacing(0)
rbb = gui.appendRadioButton(rb, name, argbox)
rbb.setAttribute(Qt.WA_LayoutUsesWidgetRect)
argbox.setAttribute(Qt.WA_LayoutUsesWidgetRect)
self.arg_spins[name] = box = []
values = iter(defaults)
argno = 0
for prev, arg, post in \
zip([""] + arguments, arguments, arguments + [""]):
if isinstance(arg, str):
label = space(prev, arg) + arg + space(arg, post)
box.append(gui.widgetLabel(argbox, label))
else:
assert isinstance(arg, tuple)
_value, minv, maxv = arg
spin = QSpinBox(value=next(values),
minimum=minv,
maximum=maxv)
argbox.layout().addWidget(spin)
spin.valueChanged.connect(
lambda value, name=name, argidx=argno: self.update_arg(
value, name, argidx))
argno += 1
box.append(spin)
self.bt_generate = gui.button(self.controlArea,
self,
"Regenerate Network",
callback=self.generate)
self.on_type_changed()
def __init__(self, *args, **kwargs):
super().__init__(*args)
layout = QStackedLayout(self)
self.double_spin = QDoubleSpinBox()
self.double_spin.valueChanged.connect(self.double_value_changed)
self.double_spin.editingFinished.connect(self.double_editing_finished)
layout.addWidget(self.double_spin)
self.int_spin = QSpinBox()
self.int_spin.setMaximum(10**4)
self.int_spin.valueChanged.connect(self.int_value_changed)
self.int_spin.editingFinished.connect(self.int_editing_finished)
layout.addWidget(self.int_spin)
self.setValue(kwargs.get('value', 0.))
def __init__(self, parent=None, **kwargs):
super().__init__(parent, **kwargs)
self.setLayout(QVBoxLayout())
self.__strategy = RandomFeatureSelectEditor.Fixed
self.__k = 10
self.__p = 75.0
box = QGroupBox(title="Strategy", flat=True)
self.__group = group = QButtonGroup(self, exclusive=True)
self.__spins = {}
form = QFormLayout()
fixedrb = QRadioButton("Fixed", checked=True)
group.addButton(fixedrb, RandomFeatureSelectEditor.Fixed)
kspin = QSpinBox(
minimum=1,
value=self.__k,
enabled=self.__strategy == RandomFeatureSelectEditor.Fixed,
)
kspin.valueChanged[int].connect(self.setK)
kspin.editingFinished.connect(self.edited)
self.__spins[RandomFeatureSelectEditor.Fixed] = kspin
form.addRow(fixedrb, kspin)
percrb = QRadioButton("Percentage")
group.addButton(percrb, RandomFeatureSelectEditor.Percentage)
pspin = QDoubleSpinBox(
minimum=0.0,
maximum=100.0,
singleStep=0.5,
value=self.__p,
suffix="%",
enabled=self.__strategy == RandomFeatureSelectEditor.Percentage,
)
pspin.valueChanged[float].connect(self.setP)
pspin.editingFinished.connect(self.edited)
self.__spins[RandomFeatureSelectEditor.Percentage] = pspin
form.addRow(percrb, pspin)
self.__group.buttonClicked.connect(self.__on_buttonClicked)
box.setLayout(form)
self.layout().addWidget(box)
def test_prop(self):
w = QWidget()
layout = QVBoxLayout()
cb = QCheckBox("Check", w)
sp = QSpinBox(w)
le = QLineEdit(w)
textw = QTextEdit(w, readOnly=True)
textw.setProperty("checked_", False)
textw.setProperty("spin_", 0)
textw.setProperty("line_", "")
textexpr = PropertyBindingExpr(
r"""
("Check box is {0}\n"
"Spin has value {1}\n"
"Line contains {2}").format(
"checked" if checked else "unchecked",
spin,
line)
""",
dict(
checked=binding_for(cb, "checked"),
spin=binding_for(sp, "value"),
line=binding_for(le, "text"),
),
)
layout.addWidget(cb)
layout.addWidget(sp)
layout.addWidget(le)
layout.addWidget(textw)
manager = BindingManager(submitPolicy=BindingManager.AutoSubmit)
manager.bind(PropertyBinding(textw, "plainText", "textChanged"),
textexpr)
w.setLayout(layout)
w.show()
self.app.exec_()
def __init__(self, parent=None, **kwargs):
super().__init__(parent, **kwargs)
self.setLayout(QVBoxLayout())
self.rank = 10
self.max_error = 1
form = QFormLayout()
self.rspin = QSpinBox(minimum=2, maximum=1000000, value=self.rank)
self.rspin.valueChanged[int].connect(self.setR)
self.rspin.editingFinished.connect(self.edited)
self.espin = QDoubleSpinBox(
minimum=0.1, maximum=100.0, singleStep=0.1,
value=self.max_error)
self.espin.valueChanged[float].connect(self.setE)
self.espin.editingFinished.connect(self.edited)
form.addRow("Rank:", self.rspin)
form.addRow("Relative error:", self.espin)
self.layout().addLayout(form)
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 __init__(self):
super().__init__()
self._current_path = ""
icon_open_dir = self.style().standardIcon(QStyle.SP_DirOpenIcon)
# Top grid with file selection combo box
grid = QGridLayout()
lb = QLabel("File:")
lb.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.recent_combo = cb = QComboBox(
sizeAdjustPolicy=QComboBox.AdjustToMinimumContentsLengthWithIcon,
minimumContentsLength=20,
toolTip="Select a recent file")
self.recent_model = cb.model() # type: QStandardItemModel
self.recent_combo.activated[int].connect(self._select_recent)
browse = QPushButton("...",
autoDefault=False,
icon=icon_open_dir,
clicked=self.browse)
# reload = QPushButton("Reload", autoDefault=False, icon=icon_reload)
grid.addWidget(lb, 0, 0, Qt.AlignVCenter)
grid.addWidget(cb, 0, 1)
grid.addWidget(browse, 0, 2)
# grid.addWidget(reload, 0, 3)
self.summary_label = label = QLabel("", self)
label.ensurePolished()
f = label.font()
if f.pointSizeF() != -1:
f.setPointSizeF(f.pointSizeF() * 5 / 6)
else:
f.setPixelSize(f.pixelSize() * 5 / 6)
label.setFont(f)
grid.addWidget(label, 1, 1, 1, 3)
self.controlArea.layout().addLayout(grid)
box = gui.widgetBox(self.controlArea,
"Headers and Row Labels",
spacing=-1)
hl = QHBoxLayout()
hl.setContentsMargins(0, 0, 0, 0)
self.header_rows_spin = spin = QSpinBox(box,
minimum=0,
maximum=3,
value=self._header_rows_count,
keyboardTracking=False)
spin.valueChanged.connect(self.set_header_rows_count)
hl.addWidget(QLabel("Data starts with", box))
hl.addWidget(self.header_rows_spin)
hl.addWidget(QLabel("header row(s)", box))
hl.addStretch(10)
box.layout().addLayout(hl)
hl = QHBoxLayout()
hl.setContentsMargins(0, 0, 0, 0)
self.header_cols_spin = spin = QSpinBox(box,
minimum=0,
maximum=3,
value=self._header_cols_count,
keyboardTracking=False)
spin.valueChanged.connect(self.set_header_cols_count)
hl.addWidget(QLabel("First", box))
hl.addWidget(self.header_cols_spin)
hl.addWidget(QLabel("column(s) are row labels", box))
hl.addStretch(10)
box.layout().addLayout(hl)
self.data_struct_box = box = gui.widgetBox(self.controlArea,
"Input Data Structure")
gui.radioButtons(box,
self,
"_cells_in_rows", [
"Genes in rows, samples in columns",
"Samples in rows, genes in columns"
],
callback=self._invalidate)
box = gui.widgetBox(self.controlArea, "Sample Data", spacing=-1)
grid = QGridLayout()
grid.setContentsMargins(0, 0, 0, 0)
box.layout().addLayout(grid)
self.sample_rows_cb = cb = QCheckBox(checked=self._sample_rows_enabled)
spin = QSpinBox(minimum=0,
maximum=100,
value=self._sample_rows_p,
enabled=self._sample_rows_enabled)
spin.valueChanged.connect(self.set_sample_rows_p)
suffix = QLabel("% of Samples", enabled=self._sample_rows_enabled)
cb.toggled.connect(self.set_sample_rows_enabled)
cb.toggled.connect(spin.setEnabled)
cb.toggled.connect(suffix.setEnabled)
grid.addWidget(cb, 0, 0)
grid.addWidget(spin, 0, 1)
grid.addWidget(suffix, 0, 2)
self.sample_cols_cb = cb = QCheckBox(checked=self._sample_cols_enabled)
spin = QSpinBox(minimum=0,
maximum=100,
value=self._sample_cols_p,
enabled=self._sample_cols_enabled)
spin.valueChanged.connect(self.set_sample_cols_p)
suffix = QLabel("% of genes", enabled=self._sample_cols_enabled)
cb.toggled.connect(self.set_sample_cols_enabled)
cb.toggled.connect(spin.setEnabled)
cb.toggled.connect(suffix.setEnabled)
grid.addWidget(cb, 1, 0)
grid.addWidget(spin, 1, 1)
grid.addWidget(suffix, 1, 2)
grid.setColumnStretch(3, 10)
self.annotation_files_box = box = gui.widgetBox(
self.controlArea, "Cell && Gene Annotation Files")
form = QFormLayout(
formAlignment=Qt.AlignLeft,
rowWrapPolicy=QFormLayout.WrapAllRows,
)
box.layout().addLayout(form)
self.row_annotations_cb = cb = QCheckBox(
"Cell annotations", checked=self._row_annotations_enabled)
self._row_annotations_w = w = QWidget(
enabled=self._row_annotations_enabled)
cb.toggled.connect(self.set_row_annotations_enabled)
cb.toggled.connect(w.setEnabled)
hl = QHBoxLayout()
hl.setContentsMargins(0, 0, 0, 0)
w.setLayout(hl)
self.row_annotations_combo = QComboBox(
sizeAdjustPolicy=QComboBox.AdjustToMinimumContentsLengthWithIcon,
minimumContentsLength=18)
self.row_annotations_combo.activated.connect(self._invalidate)
hl.addWidget(self.row_annotations_combo)
hl.addWidget(
QPushButton("...",
box,
autoDefault=False,
icon=icon_open_dir,
clicked=self.browse_row_annotations))
# hl.addWidget(QPushButton("Reload", box, autoDefault=False,
# icon=icon_reload))
form.addRow(cb, w)
self.col_annotations_cb = cb = QCheckBox(
"Gene annotations", checked=self._col_annotations_enabled)
self._col_annotations_w = w = QWidget(
enabled=self._col_annotations_enabled)
cb.toggled.connect(self.set_col_annotations_enabled)
cb.toggled.connect(w.setEnabled)
hl = QHBoxLayout()
hl.setContentsMargins(0, 0, 0, 0)
w.setLayout(hl)
self.col_annotations_combo = QComboBox(
sizeAdjustPolicy=QComboBox.AdjustToMinimumContentsLengthWithIcon,
minimumContentsLength=18)
self.col_annotations_combo.activated.connect(self._invalidate)
hl.addWidget(self.col_annotations_combo)
hl.addWidget(
QPushButton("...",
box,
autoDefault=False,
icon=icon_open_dir,
clicked=self.browse_col_annotations))
# hl.addWidget(QPushButton("Reload", box, autoDefault=False,
# icon=icon_reload))
form.addRow(cb, w)
self.controlArea.layout().addStretch(10)
self.load_data_button = button = VariableTextPushButton(
"Load data",
autoDefault=True,
textChoiceList=["Load data", "Reload"])
self.load_data_button.setAutoDefault(True)
button.clicked.connect(self.commit, Qt.QueuedConnection)
self.controlArea.layout().addWidget(button, alignment=Qt.AlignRight)
init_recent_paths_model(
self.recent_model,
[RecentPath.create(p, []) for p in self._recent],
)
init_recent_paths_model(
self.row_annotations_combo.model(),
[RecentPath.create(p, []) for p in self._recent_row_annotations])
init_recent_paths_model(
self.col_annotations_combo.model(),
[RecentPath.create(p, []) for p in self._recent_col_annotations])
self._update_summary()
self._update_warning()
if self._last_path != "" and os.path.exists(self._last_path):
self.set_current_path(self._last_path)
else:
self.recent_combo.setCurrentIndex(-1)
def createEditor(self, parent, _QStyleOptionViewItem, _index):
# Don't edit window length if non-overlapping windows set
if self.parent().non_overlapping:
return None
spin = QSpinBox(parent, minimum=1, maximum=1000)
return spin
def __init__(self, parent=None, **kwargs):
super().__init__(parent, **kwargs)
self.__sw_lang = self.DEFAULT_LANG
self.__sw_file = self.DEFAULT_NONE
self.__lx_file = self.DEFAULT_NONE
self.__pattern = self.DEFAULT_PATTERN
self.__freq_type = self.DEFAULT_FREQ_TYPE
self.__rel_freq_st = self.DEFAULT_REL_START
self.__rel_freq_en = self.DEFAULT_REL_END
self.__abs_freq_st = self.DEFAULT_ABS_START
self.__abs_freq_en = self.DEFAULT_ABS_END
self.__n_token = self.DEFAULT_N_TOKEN
self.__invalidated = False
self.__combo = ComboBox(self, [_DEFAULT_NONE] +
StopwordsFilter.supported_languages(),
self.__sw_lang, self.__set_language)
self.__sw_loader = FileLoader()
self.__sw_loader.set_file_list()
self.__sw_loader.activated.connect(self.__sw_loader_activated)
self.__sw_loader.file_loaded.connect(self.__sw_invalidate)
self.__lx_loader = FileLoader()
self.__lx_loader.set_file_list()
self.__lx_loader.activated.connect(self.__lx_loader_activated)
self.__lx_loader.file_loaded.connect(self.__lx_invalidate)
validator = RegexpFilter.validate_regexp
self.__edit = ValidatedLineEdit(self.__pattern, validator)
self.__edit.editingFinished.connect(self.__edit_finished)
rel_freq_rb = QRadioButton("相对:")
abs_freq_rb = QRadioButton("绝对:")
self.__freq_group = group = QButtonGroup(self, exclusive=True)
group.addButton(rel_freq_rb, 0)
group.addButton(abs_freq_rb, 1)
group.buttonClicked.connect(self.__freq_group_clicked)
group.button(self.__freq_type).setChecked(True)
self.__rel_range_spins = RangeDoubleSpins(self.__rel_freq_st, 0.05,
self.__rel_freq_en,
self.REL_MIN, self.REL_MAX,
self.__set_rel_freq_start,
self.__set_rel_freq_end,
self.__rel_spins_edited)
self.__abs_range_spins = RangeSpins(self.__abs_freq_st, 1,
self.__abs_freq_en, self.ABS_MIN,
self.ABS_MAX,
self.__set_abs_freq_start,
self.__set_abs_freq_end,
self.__abs_spins_edited)
self.__spin_n = QSpinBox(minimum=1,
maximum=10**6,
value=self.__n_token)
self.__spin_n.editingFinished.connect(self.__spin_n_edited)
self.__spin_n.valueChanged.connect(self.changed)
self.layout().addWidget(self.__combo, self.Stopwords, 1)
self.layout().addWidget(self.__sw_loader.file_combo, self.Stopwords, 2,
1, 2)
self.layout().addWidget(self.__sw_loader.browse_btn, self.Stopwords, 4)
self.layout().addWidget(self.__sw_loader.load_btn, self.Stopwords, 5)
self.layout().addWidget(self.__lx_loader.file_combo, self.Lexicon, 2,
1, 2)
self.layout().addWidget(self.__lx_loader.browse_btn, self.Lexicon, 4)
self.layout().addWidget(self.__lx_loader.load_btn, self.Lexicon, 5)
self.layout().addWidget(self.__edit, self.Regexp, 1, 1, 5)
spins = self.__rel_range_spins.spins()
self.layout().addWidget(rel_freq_rb, self.DocFreq, 1)
self.layout().addWidget(spins[0], self.DocFreq, 2)
self.layout().addWidget(spins[1], self.DocFreq, 3)
spins = self.__abs_range_spins.spins()
self.layout().addWidget(abs_freq_rb, self.DummyDocFreq, 1)
self.layout().addWidget(spins[0], self.DummyDocFreq, 2)
self.layout().addWidget(spins[1], self.DummyDocFreq, 3)
title = self.layout().itemAtPosition(self.DummyDocFreq, 0).widget()
title.hide()
self.layout().addWidget(self.__spin_n, self.MostFreq, 1)
self.layout().setColumnStretch(3, 1)
