def __init__(self, parent=None, **kwargs):
super().__init__(parent, acceptDrops=True, **kwargs)
self.setLayout(QVBoxLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self.addonwidget = AddonManagerWidget()
self.layout().addWidget(self.addonwidget)
info_bar = QWidget()
info_layout = QHBoxLayout()
info_bar.setLayout(info_layout)
self.layout().addWidget(info_bar)
buttons = QDialogButtonBox(
orientation=Qt.Horizontal,
standardButtons=QDialogButtonBox.Ok | QDialogButtonBox.Cancel,
)
addmore = QPushButton("Add more...",
toolTip="Add an add-on not listed below",
autoDefault=False)
self.addonwidget.tophlayout.addWidget(addmore)
addmore.clicked.connect(self.__run_add_package_dialog)
buttons.accepted.connect(self.__accepted)
buttons.rejected.connect(self.reject)
self.layout().addWidget(buttons)
self._executor = concurrent.futures.ThreadPoolExecutor(max_workers=1)
if AddonManagerDialog._packages is None:
self._f_pypi_addons = self._executor.submit(
list_available_versions)
else:
self._f_pypi_addons = concurrent.futures.Future()
self._f_pypi_addons.set_result(AddonManagerDialog._packages)
self._f_pypi_addons.add_done_callback(
method_queued(self._set_packages, (object, )))
self.__progress = None # type: Optional[QProgressDialog]
self.__thread = None
self.__installer = None
if not self._f_pypi_addons.done():
self.__progressDialog()
def __init__(self, parent=None, **kwargs):
super(AddonManagerWidget, self).__init__(parent, **kwargs)
self.__items = []
self.setLayout(QVBoxLayout())
self.__header = QLabel(wordWrap=True, textFormat=Qt.RichText)
self.__search = QLineEdit(placeholderText=self.tr("Filter"))
self.tophlayout = topline = QHBoxLayout()
topline.addWidget(self.__search)
self.layout().addLayout(topline)
self.__view = view = QTreeView(rootIsDecorated=False,
editTriggers=QTreeView.NoEditTriggers,
selectionMode=QTreeView.SingleSelection,
alternatingRowColors=True)
self.__view.setItemDelegateForColumn(0, TristateCheckItemDelegate())
self.layout().addWidget(view)
self.__model = model = QStandardItemModel()
model.setHorizontalHeaderLabels(["", "Name", "Version", "Action"])
model.dataChanged.connect(self.__data_changed)
self.__proxy = proxy = QSortFilterProxyModel(
filterKeyColumn=1, filterCaseSensitivity=Qt.CaseInsensitive)
proxy.setSourceModel(model)
self.__search.textChanged.connect(proxy.setFilterFixedString)
view.setModel(proxy)
view.selectionModel().selectionChanged.connect(self.__update_details)
header = self.__view.header()
header.setSectionResizeMode(0, QHeaderView.Fixed)
header.setSectionResizeMode(2, QHeaderView.ResizeToContents)
self.__details = QTextBrowser(
frameShape=QTextBrowser.NoFrame,
readOnly=True,
lineWrapMode=QTextBrowser.WidgetWidth,
openExternalLinks=True,
)
self.__details.setWordWrapMode(QTextOption.WordWrap)
palette = QPalette(self.palette())
palette.setColor(QPalette.Base, Qt.transparent)
self.__details.setPalette(palette)
self.layout().addWidget(self.__details)
def container_widget_helper(orientation=Qt.Vertical, spacing=None, margin=0):
widget = QWidget()
if orientation == Qt.Vertical:
layout = QVBoxLayout()
widget.setSizePolicy(QSizePolicy.Fixed,
QSizePolicy.MinimumExpanding)
else:
layout = QHBoxLayout()
if spacing is not None:
layout.setSpacing(spacing)
if margin is not None:
layout.setContentsMargins(0, 0, 0, 0)
widget.setLayout(layout)
return widget
def __init__(self, parent=None, **kwargs):
super().__init__(parent, **kwargs)
self.setLayout(QVBoxLayout())
form = QFormLayout()
self.__rand_type_cb = QComboBox()
self.__rand_type_cb.addItems(
["类别(Classes)", "特征(Features)", "元数据(Meta data)"])
self.__rand_type_cb.currentIndexChanged.connect(self.changed)
self.__rand_type_cb.activated.connect(self.edited)
self.__rand_seed_ch = QCheckBox()
self.__rand_seed_ch.clicked.connect(self.edited)
form.addRow("随机化(Randomize):", self.__rand_type_cb)
form.addRow("可复制的无序(Replicable shuffling):", self.__rand_seed_ch)
self.layout().addLayout(form)
def __init__(self, master, **kwargs):
QGroupBox.__init__(self, **kwargs)
gui.OWComponent.__init__(self, master)
self.model = self.create_model()
QVBoxLayout(self)
for parameter, description, minv, maxv, step, _type in self.parameters:
spin = gui.spin(self,
self,
parameter,
minv=minv,
maxv=maxv,
step=step,
label=self.spin_format.format(
description=description, parameter=parameter),
labelWidth=220,
spinType=_type)
spin.clearFocus()
spin.editingFinished.connect(self.on_change)
def __init__(self, master, model):
QDialog.__init__(self)
self.master = master
self.setWindowFlags(Qt.Tool)
self.setLayout(QVBoxLayout())
self.setWindowTitle("Hidden Axes")
btns_area = gui.widgetBox(
self, addSpace=0, spacing=9, orientation=Qt.Horizontal,
sizePolicy=QSizePolicy(*SIZE_POLICY_FIXED)
)
self.btn_add = QPushButton(
"Add", autoDefault=False, sizePolicy=QSizePolicy(*SIZE_POLICY_FIXED)
)
self.btn_add.clicked.connect(self._add)
self.btn_cancel = QPushButton(
"Cancel", autoDefault=False, sizePolicy=QSizePolicy(*SIZE_POLICY_FIXED)
)
self.btn_cancel.clicked.connect(self._cancel)
btns_area.layout().addWidget(self.btn_add)
btns_area.layout().addWidget(self.btn_cancel)
filter_edit, view = variables_filter(model=model)
self.view_other = view
view.setMinimumSize(QSize(30, 60))
view.setSizePolicy(*SIZE_POLICY_ADAPTING)
view.viewport().setAcceptDrops(True)
self.layout().addWidget(filter_edit)
self.layout().addWidget(view)
self.layout().addWidget(btns_area)
master = self.master
box = master.box
master.master.setEnabled(False)
self.move(box.mapToGlobal(QPoint(0, box.pos().y() + box.height())))
self.setFixedWidth(master.master.controlArea.width())
self.setMinimumHeight(300)
self.show()
self.raise_()
self.activateWindow()
def __init__(self, parent=None, **kwargs):
# type: (Optional[QWidget], Any)-> None
super().__init__(parent, **kwargs)
self.__pages = [] # type: List[_ToolBoxPage]
self.__tabButtonHeight = -1
self.__tabIconSize = QSize()
self.__exclusive = False
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
# Scroll area for the contents.
self.__scrollArea = QScrollArea(
self,
objectName="toolbox-scroll-area",
sizePolicy=QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding),
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOff,
widgetResizable=True,
)
self.__scrollArea.setFrameStyle(QScrollArea.NoFrame)
# 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",
exclusive=self.__exclusive)
self.__actionMapper = QSignalMapper(self)
self.__actionMapper.mapped[QObject].connect(self.__onTabActionToggled)
def __init__(self, parent=None, **kwargs):
super().__init__(parent, **kwargs)
self.setLayout(QVBoxLayout())
form = QFormLayout()
self.__centercb = QComboBox()
self.__centercb.addItems(
["No Centering", "Center by Mean", "Center by Median"])
self.__scalecb = QComboBox()
self.__scalecb.addItems(["No scaling", "Scale by SD", "Scale by span"])
form.addRow("Center:", self.__centercb)
form.addRow("Scale:", self.__scalecb)
self.layout().addLayout(form)
self.__centercb.currentIndexChanged.connect(self.changed)
self.__scalecb.currentIndexChanged.connect(self.changed)
self.__centercb.activated.connect(self.edited)
self.__scalecb.activated.connect(self.edited)
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 __init__(self, parent, windowTitle='Date picker'):
super().__init__(parent, windowTitle=windowTitle)
self.parent = parent
self.setLayout(QVBoxLayout())
self.mainArea = gui.widgetBox(self)
self.layout().addWidget(self.mainArea)
self.cal = QCalendarWidget(self)
self.cal.setGridVisible(True)
self.cal.move(20, 20)
self.cal.clicked[QDate].connect(self.set_date)
self.mainArea.layout().addWidget(self.cal)
# Set the default date.
self.picked_date = self.cal.selectedDate().toString('yyyy/MM/dd')
gui.button(self.mainArea, self, 'OK', lambda: QDialog.accept(self))
def __init__(self, parent):
super(AddOBAUI, self).__init__()
self.title = 'Create OBA Element'
self.setLayout(QVBoxLayout(self))
self.parent = parent
self.oba = OBA(name='',
outputPin=0,
enabled=False,
icon=Config.icon('oba', 'airhose'),
momentary=False)
self._nameControl = LineEdit('Name', self)
self._nameControl.kb.connect(self.showOSK)
self._outputPinControlLabel = QLabel('Output Pin', self)
self._outputPinControl = QComboBox(self)
for _pin in self.parent.availablePins():
self._outputPinControl.addItem(str(_pin))
self._outputPinControl.setCurrentIndex(
self._outputPinControl.findText(str(self.oba.outputPin)))
self._momentaryControl = QCheckBox('Momentary', self)
self._enabledControl = QCheckBox('Enabled', self)
self._iconControlLabel = QLabel('Icon', self)
self._iconControl = QComboBox(self)
for _key in Config.icons['oba'].keys():
icon = Config.icon('oba', _key)
self._iconControl.addItem(icon['name'], _key)
self._iconControl.setItemIcon(self._iconControl.count() - 1,
QIcon(icon['path']))
self._addOBABtn = QPushButton('Add OBA Element', self)
self._addOBABtn.clicked.connect(self.__createOBABtnAction)
self._cancelBtn = QPushButton('Cancel', self)
self._cancelBtn.clicked.connect(self.__cancel)
_layout = [['_nameControl'],
['_outputPinControlLabel', '_outputPinControl'],
['_momentaryControl', '_enabledControl'],
['_iconControlLabel', '_iconControl'],
['_addOBABtn', '_cancelBtn']]
for _list in _layout:
_panel = QWidget(self)
_panel.setLayout(QHBoxLayout(_panel))
_panel.layout().setAlignment(Qt.AlignCenter)
for _control in _list:
_panel.layout().addWidget(eval('self.%s' % _control))
self.layout().addWidget(_panel)
def __init__(self, parent=None):
super().__init__(parent)
self.setLayout(QVBoxLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self.__score = 0
self.__selecionidx = 0
self.__uni_fs = UnivariateFeatureSelect()
self.__uni_fs.setItems([
{
"text": "Information Gain",
"tooltip": ""
},
{
"text": "Gain Ratio"
},
{
"text": "Gini Index"
},
{
"text": "ReliefF"
},
{
"text": "Fast Correlation Based Filter"
},
{
"text": "ANOVA"
},
{
"text": "Chi2"
},
{
"text": "RReliefF"
},
{
"text": "Univariate Linear Regression"
},
])
self.layout().addWidget(self.__uni_fs)
self.__uni_fs.changed.connect(self.changed)
self.__uni_fs.edited.connect(self.edited)
def test1(self):
class FT(QToolBar):
def paintEvent(self, e):
pass
w = QMainWindow()
ftt, ftb = FT(), FT()
ftt.setFixedHeight(15)
ftb.setFixedHeight(15)
w.addToolBar(Qt.TopToolBarArea, ftt)
w.addToolBar(Qt.BottomToolBarArea, ftb)
f = dropshadow.DropShadowFrame()
te = QTextEdit()
c = QWidget()
c.setLayout(QVBoxLayout())
c.layout().setContentsMargins(20, 0, 20, 0)
c.layout().addWidget(te)
w.setCentralWidget(c)
f.setWidget(te)
f.radius = 15
f.color = QColor(Qt.blue)
w.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 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):
BaseEditor.__init__(self, parent, **kwargs)
self.__method = DiscretizeEditor.EqualFreq
self.__nintervals = 4
layout = QVBoxLayout()
self.setLayout(layout)
self.__group = group = QButtonGroup(self, exclusive=True)
for method in [
self.EntropyMDL, self.EqualFreq, self.EqualWidth, self.Drop
]:
rb = QRadioButton(self,
text=self.Names[method],
checked=self.__method == method)
layout.addWidget(rb)
group.addButton(rb, method)
group.buttonClicked.connect(self.__on_buttonClicked)
self.__slbox = slbox = QGroupBox(
title="间隔数(等宽/等频)Number of intervals (for equal width/frequency)",
flat=True)
slbox.setLayout(QHBoxLayout())
self.__slider = slider = QSlider(orientation=Qt.Horizontal,
minimum=2,
maximum=10,
value=self.__nintervals,
enabled=self.__method
in [self.EqualFreq, self.EqualWidth],
pageStep=1,
tickPosition=QSlider.TicksBelow)
slider.valueChanged.connect(self.__on_valueChanged)
slbox.layout().addWidget(slider)
self.__slabel = slabel = QLabel()
slbox.layout().addWidget(slabel)
container = QHBoxLayout()
container.setContentsMargins(13, 0, 0, 0)
container.addWidget(slbox)
self.layout().insertLayout(3, container)
self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Preferred)
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, 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 set_basic_layout(self):
"""Provide the basic widget layout
Which parts are created is regulated by class attributes
`want_main_area`, `want_control_area` and `buttons_area_orientation`,
the presence of method `send_report` and attribute `graph_name`.
"""
self.setLayout(QVBoxLayout())
self.layout().setContentsMargins(2, 2, 2, 2)
if not self.resizing_enabled:
self.layout().setSizeConstraint(QVBoxLayout.SetFixedSize)
self.want_main_area = self.want_main_area or self.graph_name
self._create_default_buttons()
self.insert_message_bar()
self._insert_splitter()
if self.want_control_area:
self._insert_control_area()
if self.want_main_area:
self._insert_main_area()
def __init__(self, rgbColors, parent=None, windowTitle="Palette Editor",
**kwargs):
super().__init__(parent, **kwargs)
self.setLayout(QVBoxLayout())
self.layout().setContentsMargins(4, 4, 4, 4)
hbox = gui.hBox(self, "Information")
gui.widgetLabel(
hbox,
'<p align="center">You can reorder colors in the list using the'
'<br/>buttons on the right or by dragging and dropping the items.'
'<br/>To change a specific color double click the item in the '
'list.</p>')
hbox = gui.hBox(self, box=True)
self.discListbox = gui.listBox(hbox, self, enableDragDrop=1)
vbox = gui.vBox(hbox)
buttonUPAttr = gui.button(vbox, self, "", callback=self.moveAttrUP,
tooltip="Move selected colors up")
buttonDOWNAttr = gui.button(vbox, self, "", callback=self.moveAttrDOWN,
tooltip="Move selected colors down")
buttonUPAttr.setIcon(QIcon(gui.resource_filename("icons/Dlg_up3.png")))
buttonUPAttr.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding))
buttonUPAttr.setMaximumWidth(30)
buttonDOWNAttr.setIcon(QIcon(gui.resource_filename("icons/Dlg_down3.png")))
buttonDOWNAttr.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding))
buttonDOWNAttr.setMaximumWidth(30)
self.discListbox.itemDoubleClicked.connect(self.changeDiscreteColor)
box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel,
accepted=self.accept, rejected=self.reject)
self.layout().addWidget(box)
self.discListbox.setIconSize(QSize(25, 25))
for ind, (r, g, b) in enumerate(rgbColors):
item = QListWidgetItem(ColorPixmap(QColor(r, g, b), 25), "Color %d" % (ind + 1))
item.rgbColor = (r, g, b)
self.discListbox.addItem(item)
self.resize(300, 300)
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)
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):
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 __init__(self, parent=None, **kwargs):
super().__init__(parent, acceptDrops=True, **kwargs)
self.setLayout(QVBoxLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self.addonwidget = AddonManagerWidget()
self.layout().addWidget(self.addonwidget)
info_bar = QWidget()
info_layout = QHBoxLayout()
info_bar.setLayout(info_layout)
self.layout().addWidget(info_bar)
buttons = QDialogButtonBox(orientation=Qt.Horizontal,
standardButtons=QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
buttons.accepted.connect(self.__accepted)
buttons.rejected.connect(self.reject)
self.layout().addWidget(buttons)
# No system access => install into user site-packages
self.user_install = not os.access(sysconfig.get_path("purelib"),
os.W_OK)
self._executor = concurrent.futures.ThreadPoolExecutor(max_workers=1)
if AddonManagerDialog._packages is None:
self._f_pypi_addons = self._executor.submit(list_pypi_addons)
else:
self._f_pypi_addons = concurrent.futures.Future()
self._f_pypi_addons.set_result(AddonManagerDialog._packages)
self._f_pypi_addons.add_done_callback(
method_queued(self._set_packages, (object, )))
self.__progress = None # type: Optional[QProgressDialog]
self.__thread = None
self.__installer = None
if not self._f_pypi_addons.done():
self.__progressDialog()
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 __init__(self, parent=None, **kwargs):
super().__init__(parent, **kwargs)
self._threshold = self.DEFAULT_THRESHOLD
self.setLayout(QVBoxLayout())
form = QFormLayout()
self.cond_cb = QComboBox()
self.cond_cb.addItems(["Greater or Equal", "Greater"])
self.cond_cb.currentIndexChanged.connect(self.changed)
self.cond_cb.activated.connect(self.edited)
self.thr_spin = QDoubleSpinBox(minimum=0,
singleStep=0.5,
decimals=1,
value=self._threshold)
self.thr_spin.valueChanged[float].connect(self._set_threshold)
self.thr_spin.editingFinished.connect(self.edited)
form.addRow("Condition:", self.cond_cb)
form.addRow("Threshold:", self.thr_spin)
self.layout().addLayout(form)
def __init__(self, title, text, parent=None):
super().__init__(parent)
self.setLayout(QVBoxLayout())
self.title_le = QLineEdit()
self.title_le.setPlaceholderText("Document title")
self.title_le.setText(title)
self.title_le.editingFinished.connect(self._on_text_changed)
self.text_area = CustomQPlainTextEdit()
self.text_area.setPlaceholderText("Document text")
self.text_area.setPlainText(text)
self.text_area.editingFinished.connect(self._on_text_changed)
remove_button = QPushButton("x")
remove_button.setFixedWidth(35)
remove_button.setFocusPolicy(Qt.NoFocus)
remove_button.clicked.connect(self._on_remove_clicked)
box = gui.hBox(self)
box.layout().addWidget(self.title_le)
box.layout().addWidget(remove_button)
self.layout().addWidget(self.text_area)
def init_form(self):
self._form = QWidget()
layout = QVBoxLayout()
if _api.USED_API == _api.QT_API_PYQT5:
layout.setContentsMargins(0, 0, 0, 0)
else:
layout.setMargin(0)
self._form.setLayout(layout)
self._app = vv.use('pyqt5')
self._app.Create()
Figure = self._app.GetFigureClass()
self._fig = Figure(self._form)
policy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
widget = self._fig._widget
widget.setSizePolicy(policy)
layout.addWidget(widget)
def __init__(self):
super().__init__()
self.corpus = None
self.learning_thread = None
self.__pending_selection = self.selection
# Commit button
gui.auto_commit(self.buttonsArea,
self,
'autocommit',
'Commit',
box=False)
button_group = QButtonGroup(self, exclusive=True)
button_group.buttonClicked[int].connect(self.change_method)
self.widgets = []
method_layout = QVBoxLayout()
self.controlArea.layout().addLayout(method_layout)
for i, (method, attr_name) in enumerate(self.methods):
widget = method(self, title='Options')
widget.setFixedWidth(self.control_area_width)
widget.valueChanged.connect(self.commit)
self.widgets.append(widget)
setattr(self, attr_name, widget)
rb = QRadioButton(text=widget.Model.name)
button_group.addButton(rb, i)
method_layout.addWidget(rb)
method_layout.addWidget(widget)
button_group.button(self.method_index).setChecked(True)
self.toggle_widgets()
method_layout.addStretch()
# Topics description
self.topic_desc = TopicViewer()
self.topic_desc.topicSelected.connect(self.send_topic_by_id)
self.mainArea.layout().addWidget(self.topic_desc)
self.topic_desc.setFocus()
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.ow = kwargs.get('parent', None)
# set layout
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
# set splitter
self.splitter = QSplitter()
self.splitter.setOrientation(Qt.Horizontal)
# data models
self.genes_model = None
self.info_model = None
# left side list view
self.genes_view = QTableView()
self.genes_view.horizontalHeader().hide()
self.genes_view.setItemDelegate(GeneItemDelegate())
self.genes_view.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
# right side list view
self.info_view = QTableView()
self.info_view.setItemDelegate(HTMLDelegate())
self.info_view.horizontalHeader().hide()
self.info_view.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
self.splitter.addWidget(self.genes_view)
self.splitter.addWidget(self.info_view)
# self.splitter.setStretchFactor(0, 60)
# self.splitter.setStretchFactor(1, 40)
self.layout().addWidget(self.splitter)
def __init__(self, parent=None):
super().__init__(parent)
self.setTitle(self.name)
self.setLayout(QVBoxLayout())
hbox = gui.hBox(self)
self.add_standard_parameters(hbox)
gui.separator(hbox, 20)
gui.rubber(hbox)
self.add_specific_parameters(hbox)
self.error = QLabel()
self.error.setHidden(True)
self.layout().addWidget(self.error)
self.trash_button = trash = QPushButton(
self,
icon=self.style().standardIcon(QStyle.SP_DockWidgetCloseButton))
trash.setGeometry(0, 20, 15, 15)
trash.setFlat(True)
trash.setHidden(True)
trash.clicked.connect(self.on_trash_clicked)
def __init__(self, *args, **kwargs):
title = kwargs.get('title', args[0] if len(args) > 0 else '')
parent_win = kwargs.get('parent_win',
kwargs.get('parent_widget', None))
win_flag = kwargs.get('win_flag', None)
self._parent_widget = parent_win
if parent_win is not None and win_flag is None:
win_flag = QtCore.Qt.Dialog
QFrame.__init__(self) if parent_win is None else QFrame.__init__(
self, parent_win, win_flag)
layout = QVBoxLayout()
self.setLayout(layout)
if _api.USED_API == _api.QT_API_PYQT5:
layout.setContentsMargins(0, 0, 0, 0)
elif _api.USED_API == _api.QT_API_PYQT4:
layout.setMargin(0)
self.title = title
self.title = title
self.has_progress = False
self.toolbar = []
self._mainmenu = []
self._splitters = []
self.vlayouts = []
self.hlayouts = []
self._tabs = []
self._formset = None
self._formLoaded = False
self.uid = id(self)
self.setAccessibleName('BaseWidget')
