def __init__(self, parent, name): QWidget.__init__(self, parent) self.setStyleSheet(get_stylesheet("ribbonPane")) horizontal_layout = QHBoxLayout() horizontal_layout.setSpacing(0) horizontal_layout.setContentsMargins(0, 0, 0, 0) self.setLayout(horizontal_layout) vertical_widget = QWidget(self) horizontal_layout.addWidget(vertical_widget) horizontal_layout.addWidget(RibbonSeparator(self)) vertical_layout = QVBoxLayout() vertical_layout.setSpacing(0) vertical_layout.setContentsMargins(0, 0, 0, 0) vertical_widget.setLayout(vertical_layout) label = QLabel(name) label.setAlignment(Qt.AlignCenter) label.setStyleSheet("color:#666;") content_widget = QWidget(self) vertical_layout.addWidget(content_widget) vertical_layout.addWidget(label) content_layout = QHBoxLayout() content_layout.setAlignment(Qt.AlignLeft) content_layout.setSpacing(0) content_layout.setContentsMargins(0, 0, 0, 0) self.contentLayout = content_layout content_widget.setLayout(content_layout)
def __init__(self, parent): super(PercentSlider, self).__init__(parent) self._slider = QSlider(Qt.Vertical, self) self._slider.setMinimum(-100) self._slider.setMaximum(100) self._slider.setValue(0) self._slider.setTickInterval(100) self._slider.setTickPosition(QSlider.TicksBothSides) self._slider.valueChanged.connect(lambda: self._spinbox.setValue(self._slider.value())) self._spinbox = QSpinBox(self) self._spinbox.setMinimum(-100) self._spinbox.setMaximum(100) self._spinbox.setValue(0) self._spinbox.valueChanged.connect(lambda: self._slider.setValue(self._spinbox.value())) self._zero_button = make_icon_button("hand-stop-o", "Zero setpoint", self, on_clicked=self.zero) layout = QVBoxLayout(self) sub_layout = QHBoxLayout(self) sub_layout.addStretch() sub_layout.addWidget(self._slider) sub_layout.addStretch() layout.addLayout(sub_layout) layout.addWidget(self._spinbox) layout.addWidget(self._zero_button) self.setLayout(layout) self.setMinimumHeight(400)
def __init__(self, parent=None): super().__init__(parent) self.setSubTitle(self.tr("<h2>Select Menu Style</h2>")) texts = [ self.tr("<p>Application Menu is the default for KaOS because of its \ extremely lightweight (and fast) structure.</p>"), self.tr("<p>Application Launcher is the standard for KDE. \ Application shortcuts are arranged under a tab structure.</p>"), self.tr("<p>Application Panel is a full screen menu style. \ Application shortcuts are arranged so that you can access them quickly and easily.</p>") ] self.menus = [[":/data/images/menu-kicker.png", texts[0]], [":/data/images/menu-kickoff.png", texts[1]], [":/data/images/menu-kimpanel.png", texts[2]]] vlayout = QVBoxLayout(self) labelLayout = QHBoxLayout() iconLabel = QLabel() iconLabel.setMaximumSize(64, 64) iconLabel.setPixmap(QIcon.fromTheme("kde").pixmap(64, 64)) labelLayout.addWidget(iconLabel) label = QLabel(self) label.setText(self.tr("<p>You can also customize your <strong>KDE menu</strong> as you like. \ Please choose one from the following styles.</p>")) labelLayout.addWidget(label) vlayout.addLayout(labelLayout) vlayout.addItem(QSpacerItem(20, 40, QSizePolicy.Preferred, QSizePolicy.Preferred)) self.comboBox = QComboBox(self) self.comboBox.addItem(self.tr("Application Menu")) self.comboBox.addItem(self.tr("Application Launcher")) self.comboBox.addItem(self.tr("Application Dashboard")) vlayout.addWidget(self.comboBox) vlayout.addItem(QSpacerItem(20, 40, QSizePolicy.Preferred, QSizePolicy.Preferred)) hlayout = QHBoxLayout(self) self.labelMenu = QLabel(self) self.labelMenu.setPixmap(QPixmap(self.menus[0][0])) self.labelMenu.setMaximumSize(350 ,214) hlayout.addWidget(self.labelMenu) self.labelText = QLabel(self) self.labelText.setWordWrap(True) self.labelText.setText(self.tr(self.menus[0][1])) hlayout.addWidget(self.labelText) vlayout.addLayout(hlayout) vlayout.addItem(QSpacerItem(20, 40, QSizePolicy.Preferred, QSizePolicy.Preferred)) self.comboBox.currentIndexChanged.connect(self.menuSelect) self.menuSelected = 0
def show_info_dialog( caption, parent, initial_text ): dialog = QDialog( parent ) dialog.setWindowTitle( caption ) # Create OK and Cancel buttons in a horizontal box. ok_button = QPushButton("OK") ok_button.setDefault(True) ok_button.clicked.connect(dialog.accept) cancel_button = QPushButton("Cancel") cancel_button.setDefault(False) cancel_button.clicked.connect(dialog.reject) hbox = QHBoxLayout() hbox.addWidget(cancel_button,0) hbox.addStretch() hbox.addWidget(ok_button,0) # Lay out a Plain Text Edit above the buttons. vbox = QVBoxLayout() pt_editor = QPlainTextEdit() pt_editor.document().setPlainText( initial_text ) vbox.addWidget(pt_editor,1) vbox.addLayout(hbox,0) dialog.setLayout(vbox) result = dialog.exec_() if result : return pt_editor.document().toPlainText() else : return None
def __init__(self): QMainWindow.__init__(self) self.setAttribute(QtCore.Qt.WA_DeleteOnClose) self.setWindowTitle("程序主窗口") self.file_menu = QMenu('&File', self) self.file_menu.addAction('&Quit', self.fileQuit, QtCore.Qt.CTRL + QtCore.Qt.Key_Q) self.menuBar().addMenu(self.file_menu) self.help_menu = QMenu('&Help', self) self.menuBar().addSeparator() self.menuBar().addMenu(self.help_menu) self.help_menu.addAction('&About', self.about) self.main_widget = QWidget(self) l = QVBoxLayout(self.main_widget) sc = MyStaticMplCanvas(self.main_widget, width=5, height=4, dpi=100) dc = MyDynamicMplCanvas(self.main_widget, width=5, height=4, dpi=100) l.addWidget(sc) l.addWidget(dc) self.main_widget.setFocus() self.setCentralWidget(self.main_widget) # 状态条显示2秒 self.statusBar().showMessage("matplotlib 万岁!", 2000)
def add_to_layout(layout, *items): """Add items to QVBox and QHBox layouts easily. Keyword arguments: layout -- a layout oject (QVBoxLayout or QHBoxLayout) or a string if "v" or "h" create a QVBox or QHBox respectively *items -- list with items to be added """ if isinstance(layout, str): if layout == "v": layout = QVBoxLayout() elif layout == "h": layout = QHBoxLayout() else: raise TypeError("Invalid layout!") for item in items: if isinstance(item, QWidget): layout.addWidget(item) elif isinstance(item, QLayout): layout.addLayout(item) elif isinstance(item, QSpacerItem): layout.addItem(item) elif item is None: layout.addStretch() else: raise TypeError("Argument of wrong type!") return layout
def createTreeView(self): dockWidget = QDockWidget() dockWidget.setAllowedAreas(Qt.LeftDockWidgetArea) dockWidget.setFeatures(QDockWidget.NoDockWidgetFeatures) dockWidget.setTitleBarWidget(QWidget()) self.treeView = QTreeView() self.treeView.clicked.connect(self.treeItemClicked) self.treeModel = TreeModel() self.treeView.setModel(self.treeModel) self.logo = QLabel() logoPixmap = QPixmap(CMAKE_INSTALL_PREFIX + '/share/jderobot/resources/jderobot.png') self.logo.setPixmap(logoPixmap) self.upButton = QPushButton() self.upButton.setText('Up') self.upButton.clicked.connect(self.upButtonClicked) leftContainer = QWidget() leftLayout = QVBoxLayout() leftLayout.addWidget(self.treeView) leftLayout.addWidget(self.upButton) leftLayout.addWidget(self.logo) leftContainer.setLayout(leftLayout) dockWidget.setWidget(leftContainer) self.addDockWidget(Qt.LeftDockWidgetArea, dockWidget)
def __init__(self, opPixelClassification, parent): super( QDialog, self ).__init__(parent=parent) self._op = opPixelClassification classifier_listwidget = QListWidget(parent=self) classifier_listwidget.setSelectionMode( QListWidget.SingleSelection ) classifier_factories = self._get_available_classifier_factories() for name, classifier_factory in list(classifier_factories.items()): item = QListWidgetItem( name ) item.setData( Qt.UserRole, classifier_factory ) classifier_listwidget.addItem(item) buttonbox = QDialogButtonBox( Qt.Horizontal, parent=self ) buttonbox.setStandardButtons( QDialogButtonBox.Ok | QDialogButtonBox.Cancel ) buttonbox.accepted.connect( self.accept ) buttonbox.rejected.connect( self.reject ) layout = QVBoxLayout() layout.addWidget( classifier_listwidget ) layout.addWidget( buttonbox ) self.setLayout(layout) self.setWindowTitle( "Select Classifier Type" ) # Save members self._classifier_listwidget = classifier_listwidget
def __init__(self, parent=None): super(ResultHandler, self).__init__() self.setWindowTitle('Dash results') self.control_label = QLabel() self.rendered_label = QLabel() self.diff_label = QLabel() self.mask_label = QLabel() self.new_mask_label = QLabel() self.scrollArea = QScrollArea() self.widget = QWidget() self.test_name_label = QLabel() grid = QGridLayout() grid.addWidget(self.test_name_label, 0, 0) grid.addWidget(QLabel('Control'), 1, 0) grid.addWidget(QLabel('Rendered'), 1, 1) grid.addWidget(QLabel('Difference'), 1, 2) grid.addWidget(self.control_label, 2, 0) grid.addWidget(self.rendered_label, 2, 1) grid.addWidget(self.diff_label, 2, 2) grid.addWidget(QLabel('Current Mask'), 3, 0) grid.addWidget(QLabel('New Mask'), 3, 1) grid.addWidget(self.mask_label, 4, 0) grid.addWidget(self.new_mask_label, 4, 1) self.widget.setLayout(grid) self.scrollArea.setWidget(self.widget) v_layout = QVBoxLayout() v_layout.addWidget(self.scrollArea, 1) next_image_button = QPushButton() next_image_button.setText('Skip') next_image_button.pressed.connect(self.load_next) self.overload_spin = QDoubleSpinBox() self.overload_spin.setMinimum(1) self.overload_spin.setMaximum(255) self.overload_spin.setValue(1) self.overload_spin.valueChanged.connect(lambda: save_mask_button.setEnabled(False)) preview_mask_button = QPushButton() preview_mask_button.setText('Preview New Mask') preview_mask_button.pressed.connect(self.preview_mask) preview_mask_button.pressed.connect(lambda: save_mask_button.setEnabled(True)) save_mask_button = QPushButton() save_mask_button.setText('Save New Mask') save_mask_button.pressed.connect(self.save_mask) button_layout = QHBoxLayout() button_layout.addWidget(next_image_button) button_layout.addWidget(QLabel('Mask diff multiplier:')) button_layout.addWidget(self.overload_spin) button_layout.addWidget(preview_mask_button) button_layout.addWidget(save_mask_button) button_layout.addStretch() v_layout.addLayout(button_layout) self.setLayout(v_layout)
class dailyTab(QWidget): def __init__(self): super().__init__() # Виджет для дейлков # Содержит содержит главный таб виджет для дейликов self.tab = QTabWidget() self.vbox = QVBoxLayout() self.vbox.addWidget(self.tab) self.setLayout(self.vbox) self.threads = [] # При ините создаём тред для получения дейликов self.loadDataThread = loadDataThread(r'https://api.guildwars2.com/v2/achievements/daily') self.loadDataThread.signal.connect(self.getEvent, Qt.QueuedConnection) self.loadDataThread.start() def getEvent(self, signal): signal = json.loads(signal) for metaEvent in signal.keys(): setattr(self,metaEvent,frame()) self.tab.addTab(getattr(self,metaEvent),metaEvent) for event in signal[metaEvent]: if (event['level']['max'] == 80 and metaEvent == 'pve') or metaEvent != 'pve': getattr(self,metaEvent).getEvent(event) def addTab(self, event, metaEvent): getattr(self,'{}Tab'.format(metaEvent)).addEvent(event) self.resize(self.grid.sizeHint())
class frame(QWidget): def __init__(self): super().__init__() self.vbox = QVBoxLayout() self.setLayout(self.vbox) self.threads = [] def getEvent(self, event): self.threads.append(loadDataThread(r'https://api.guildwars2.com/v2/achievements?id='+str(event['id']))) self.threads[-1].signal.connect(self.addEvent, Qt.QueuedConnection) self.threads[-1].start() def addEvent(self, signal): signal = json.loads(signal) print(type(signal)) setattr(self,str(signal['id']),label(signal)) getattr(self,str(signal['id'])).setText(signal['name']) getattr(self, str(signal['id'])).signal.connect(self.setEventWindow) self.vbox.addWidget(getattr(self,str(signal['id']))) # self.resize(self.grid.sizeHint()) def setEventWindow(self, event): self.eventWindow = eventWindow(event) self.eventWindow.show()
def __init__(self, parent, cli_iface, iface_name): super(ControlPanelWindow, self).__init__(parent) self.setWindowTitle('SLCAN Adapter Control Panel') self.setAttribute(Qt.WA_DeleteOnClose) # This is required to stop background timers! self._cli_iface = cli_iface self._iface_name = iface_name self._state_widget = StateWidget(self, self._cli_iface) self._config_widget = ConfigWidget(self, self._cli_iface) self._cli_widget = CLIWidget(self, self._cli_iface) self._tab_widget = QTabWidget(self) self._tab_widget.addTab(self._state_widget, get_icon('dashboard'), 'Adapter State') self._tab_widget.addTab(self._config_widget, get_icon('wrench'), 'Configuration') self._tab_widget.addTab(self._cli_widget, get_icon('terminal'), 'Command Line') self._status_bar = QStatusBar(self) self._status_bar.setSizeGripEnabled(False) iface_name_label = QLabel(iface_name.split('/')[-1], self) iface_name_label.setFont(get_monospace_font()) layout = QVBoxLayout(self) layout.addWidget(iface_name_label) layout.addWidget(self._tab_widget) layout.addWidget(self._status_bar) left, top, right, bottom = layout.getContentsMargins() bottom = 0 layout.setContentsMargins(left, top, right, bottom) self.setLayout(layout) self.resize(400, 400)
def initMainUi(self): role_names = self.parentApplet.dataSelectionApplet.topLevelOperator.DatasetRoles.value self.list_widgets = [] # Create a tab for each role for role_index, role_name in enumerate(role_names): select_button = QPushButton("Select " + role_name + " Files...", clicked=partial(self.select_files, role_index) ) clear_button = QPushButton("Clear " + role_name + " Files", clicked=partial(self.clear_files, role_index) ) button_layout = QHBoxLayout() button_layout.addWidget(select_button) button_layout.addSpacerItem( QSpacerItem(0,0,hPolicy=QSizePolicy.Expanding) ) button_layout.addWidget(clear_button) button_layout.setContentsMargins(0, 0, 0, 0) button_layout_widget = QWidget() button_layout_widget.setLayout(button_layout) button_layout_widget.setSizePolicy( QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Maximum) ) list_widget = QListWidget(parent=self) list_widget.setSizePolicy( QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) ) self.list_widgets.append( list_widget ) tab_layout = QVBoxLayout() tab_layout.setContentsMargins(0, 0, 0, 0) tab_layout.addWidget( button_layout_widget ) tab_layout.addWidget( list_widget ) layout_widget = QWidget(parent=self) layout_widget.setLayout(tab_layout) self.addTab(layout_widget, role_name)
def main(args): app = QApplication([]) main_frame = QFrame() layout = QVBoxLayout(main_frame) number_edit = PyQtExtras.NumberEdit() number_edit.set_value(10) print "Current value of 1 is: " + str(number_edit.get_value()) number_edit2 = PyQtExtras.NumberEdit(max_length=2) number_edit2.set_value(2) print "Current value of 2 is: " + str(number_edit2.get_value()) number_edit2.set_value(20) print "Current value of 2 is: " + str(number_edit2.get_value()) number_edit3 = PyQtExtras.NumberEdit(max_length=1) number_edit3.set_value(2) print "Current value of 3 is: " + str(number_edit3.get_value()) number_edit3.set_value(50) print "Current values of 3 is: " + str(number_edit3.get_value()) number_edit3.set_value(25) print "Current value of 3 is: " + str(number_edit3.get_value()) number_edit3.set_value("text") print "Current value of 3 is: " + str(number_edit3.get_value()) layout.addWidget(number_edit) layout.addWidget(number_edit2) layout.addWidget(number_edit3) main_frame.show() app.exec_()
def __init__(self, page, parent=None): super(HelpForm, self).__init__(parent) self.setAttribute(Qt.WA_DeleteOnClose) self.setWindowModality(Qt.WindowModal) # actions backAction = QAction(QIcon(":/back.png"), "&Back", self) backAction.setShortcut(QKeySequence.Back) homeAction = QAction(QIcon(":/home.png"), "&Home", self) homeAction.setShortcut("Home") self.pageLabel = QLabel() #toolbar toolBar = QToolBar() toolBar.addAction(backAction) toolBar.addAction(homeAction) toolBar.addWidget(self.pageLabel) self.textBrowser = QTextBrowser() # layout layout = QVBoxLayout() layout.addWidget(toolBar) layout.addWidget(self.textBrowser, 1) self.setLayout(layout) # signals and slots backAction.triggered.connect(self.textBrowser.backward) homeAction.triggered.connect(self.textBrowser.home) self.textBrowser.sourceChanged.connect(self.updatePageTitle) self.textBrowser.setSearchPaths([":/help"]) self.textBrowser.setSource(QUrl(page)) self.resize(400, 600) self.setWindowTitle("{0} Help".format( QApplication.applicationName()))
class LP_PlaylistsPanel(FFrame): def __init__(self, app, parent=None): super().__init__(parent) self._app = app self.header = LP_GroupHeader(self._app, '歌单') self._layout = QVBoxLayout(self) self.setObjectName('lp_playlists_panel') self.set_theme_style() self.setup_ui() def set_theme_style(self): theme = self._app.theme_manager.current_theme style_str = ''' #{0} {{ background: transparent; }} '''.format(self.objectName(), theme.color5.name()) self.setStyleSheet(style_str) def add_item(self, item): self._layout.addWidget(item) def setup_ui(self): self._layout.setContentsMargins(0, 0, 0, 0) self._layout.setSpacing(0) self._layout.addWidget(self.header)
class LeftPanel(FFrame): def __init__(self, app, parent=None): super().__init__(parent) self._app = app self.library_panel = LP_LibraryPanel(self._app) self.playlists_panel = LP_PlaylistsPanel(self._app) self._layout = QVBoxLayout(self) self.setLayout(self._layout) self.setObjectName('c_left_panel') self.set_theme_style() self.setup_ui() def set_theme_style(self): theme = self._app.theme_manager.current_theme style_str = ''' #{0} {{ background: transparent; }} '''.format(self.objectName(), theme.color5.name()) self.setStyleSheet(style_str) def setup_ui(self): self._layout.setContentsMargins(0, 0, 0, 0) self._layout.setSpacing(0) self._layout.addWidget(self.library_panel) self._layout.addWidget(self.playlists_panel) self._layout.addStretch(1)
def _createPlotWidget(self): self._plotWidget = QWidget() self._plotFigure = Figure() self._plotCanvas = FigureCanvas(self._plotFigure) self._plotCanvas.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self._plotCanvas.updateGeometry() self._plotCanvas.setParent(self._plotWidget) self._plotCanvas.mpl_connect('scroll_event', self._onScroll) self._plotFigure.set_canvas(self._plotCanvas) # Vm and command voltage go in the same subplot self._vm_axes = self._plotFigure.add_subplot(2,2,1, title='Membrane potential') self._vm_axes.set_ylim(-20.0, 120.0) # Channel conductances go to the same subplot self._g_axes = self._plotFigure.add_subplot(2,2,2, title='Channel conductance') self._g_axes.set_ylim(0.0, 0.5) # Injection current for Vclamp/Iclamp go to the same subplot self._im_axes = self._plotFigure.add_subplot(2,2,3, title='Injection current') self._im_axes.set_ylim(-0.5, 0.5) # Channel currents go to the same subplot self._i_axes = self._plotFigure.add_subplot(2,2,4, title='Channel current') self._i_axes.set_ylim(-10, 10) for axis in self._plotFigure.axes: axis.set_autoscale_on(False) layout = QVBoxLayout() layout.addWidget(self._plotCanvas) self._plotNavigator = NavigationToolbar(self._plotCanvas, self._plotWidget) layout.addWidget(self._plotNavigator) self._plotWidget.setLayout(layout)
def init(self): vbox = QVBoxLayout() self.setLayout(vbox) text = QLineEdit('0.') text.setReadOnly(True) vbox.addWidget(text) grid = QGridLayout() vbox.addLayout(grid) names = ['Exit', 'AC', 'DEL', '+/-', '7', '8', '9', '/', '4', '5', '6', '*', '1', '2', '3', '-', '0', '.', '=', '+'] positions = [(i, j) for i in range(5) for j in range(4)] for position, name in zip(positions, names): btn = QPushButton(name) grid.addWidget(btn, *position) self.move(300, 200) self.setWindowTitle('Calculator') self.show()
class ScrollAreaWidget(QWidget): def __init__(self, parent=None): super().__init__(parent) self.parent = parent #Container Widget widget = QWidget() #Layout of Container Widget self.layout = QVBoxLayout(self) widget.setLayout(self.layout) #Scroll Area Properties self.scroll = QScrollArea() self.scroll.setWidgetResizable(False) self.scroll.setWidget(widget) #Scroll Area Layer add scroll_layout = QVBoxLayout(self) scroll_layout.addWidget(self.scroll) self.setLayout(scroll_layout) def add_widget_item(self, widget_item): self.layout.addWidget(widget_item) widget_item.show() widget = QWidget() widget.setLayout(self.layout) self.scroll.setWidget(widget)
def __init__(self, parent): super(CharacterDialog, self).__init__(parent) self.setWindowTitle(_("KeepKey Seed Recovery")) self.character_pos = 0 self.word_pos = 0 self.loop = QEventLoop() self.word_help = QLabel() self.char_buttons = [] vbox = QVBoxLayout(self) vbox.addWidget(WWLabel(CHARACTER_RECOVERY)) hbox = QHBoxLayout() hbox.addWidget(self.word_help) for i in range(4): char_button = CharacterButton('*') char_button.setMaximumWidth(36) self.char_buttons.append(char_button) hbox.addWidget(char_button) self.accept_button = CharacterButton(_("Accept Word")) self.accept_button.clicked.connect(partial(self.process_key, 32)) self.rejected.connect(partial(self.loop.exit, 1)) hbox.addWidget(self.accept_button) hbox.addStretch(1) vbox.addLayout(hbox) self.finished_button = QPushButton(_("Seed Entered")) self.cancel_button = QPushButton(_("Cancel")) self.finished_button.clicked.connect(partial(self.process_key, Qt.Key_Return)) self.cancel_button.clicked.connect(self.rejected) buttons = Buttons(self.finished_button, self.cancel_button) vbox.addSpacing(40) vbox.addLayout(buttons) self.refresh() self.show()
def message_dialog(self, msg): self.clear_dialog() self.dialog = dialog = WindowModalDialog(self.top_level_window(), _("Coldcard Status")) l = QLabel(msg) vbox = QVBoxLayout(dialog) vbox.addWidget(l) dialog.show()
class Bool(SimpleBlackbox): author = "DrLuke" name = "Bool" modulename = "drluke.builtin.bool" Category = ["Builtin"] placeable = True implementation = BoolImplementation def __init__(self, *args, **kwargs): super(Bool, self).__init__(*args, **kwargs) self.propertiesWidget = QWidget() self.vlayout = QVBoxLayout() self.toggle = QCheckBox("Output") self.toggle.toggled.connect(self.toggleTrueFalse) self.vlayout.addWidget(self.toggle) self.vlayout.addItem(QSpacerItem(40, 20, QSizePolicy.Minimum, QSizePolicy.Expanding)) self.propertiesWidget.setLayout(self.vlayout) def toggleTrueFalse(self, bool): self.sendDataToImplementations(bool) def getPropertiesWidget(self): return self.propertiesWidget def defineIO(self): self.addOutput(bool, "boolout", "Bool out")
def __init__(self, parent=None): super(ToolOffsetDialog, self).__init__(parent) self._color = QColor(0, 0, 0, 150) self._state = False self.setWindowModality(Qt.ApplicationModal) self.setWindowFlags(self.windowFlags() | Qt.Tool | Qt.Dialog | Qt.WindowStaysOnTopHint | Qt.WindowSystemMenuHint) self.setMinimumSize(200, 200) buttonBox = QDialogButtonBox() buttonBox.setEnabled(False) STATUS.connect('not-all-homed', lambda w, axis: buttonBox.setEnabled(False)) STATUS.connect('all-homed', lambda w: buttonBox.setEnabled(True)) STATUS.connect('state-estop', lambda w: buttonBox.setEnabled(False)) STATUS.connect('state-estop-reset', lambda w: buttonBox.setEnabled(STATUS.machine_is_on() and STATUS.is_all_homed())) for i in('X', 'Y', 'Z'): b = 'button_%s' % i self[b] = QPushButton('Zero %s' % i) self[b].clicked.connect(self.zeroPress('%s' % i)) buttonBox.addButton(self[b], 3) v = QVBoxLayout() h = QHBoxLayout() self._o = TOOLVIEW_WIDGET() self._o._hal_init() self.setLayout(v) v.addWidget(self._o) b = QPushButton('OK') b.clicked.connect(lambda: self.close()) h.addWidget(b) h.addWidget(buttonBox) v.addLayout(h) self.setModal(True)
def widgetImage(self): """Create main image display. """ imageArea = QHBoxLayout() scroll = QScrollArea() scroll.setAlignment(QtCore.Qt.AlignCenter) self.imageLabel = QLabel(self) scroll.setWidget(self.imageLabel) next = QPushButton(self.tr('>')) next.clicked.connect(self.nextCluster) prev = QPushButton(self.tr('<')) prev.clicked.connect(self.prevCluster) imageArea.addWidget(prev) imageArea.addWidget(scroll) imageArea.addWidget(next) vbox = QVBoxLayout() self.clusterCountLabel = QLabel(self) self.clusterCountLabel.setAlignment(QtCore.Qt.AlignCenter) f = QtGui.QFont('Arial', 14, QtGui.QFont.Bold); self.clusterCountLabel.setFont(f) vbox.addWidget(self.clusterCountLabel) vbox.addLayout(imageArea) return vbox
def initUI(self): self.setWindowTitle('Twitter Client') self.setWindowIcon(QIcon("twitter.svg")) QIcon.setThemeName("Adwaita") lay = QVBoxLayout(self) scr = QScrollArea(self) scr.setWidgetResizable(True) scr.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff) lay2 = QVBoxLayout() self.setLayout(lay) placehold = QWidget() lay.addWidget(scr) scr.setWidget(placehold) placehold.setLayout(lay2) self.lay = lay2 lay2.setSpacing(0) lay.setSpacing(0) lay.setContentsMargins(0, 0, 0, 0) but = QPushButton("Refresh") lay.addWidget(but) but.pressed.connect(self.fetch_tweets) self.show()
def __init__(self): super(Dialog, self).__init__() self.createMenu() self.widget_register_url() self.widget_download() self.thread_download = threading.Thread( group=None, target=self.run_downloader, name=None, args=(), kwargs={}, daemon=True ) self.running = False bigEditor = QTextEdit() bigEditor.setPlainText("This widget takes up all the remaining space " "in the top-level layout.") buttonBox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) buttonBox.accepted.connect(self.accept) buttonBox.rejected.connect(self.reject) mainLayout = QVBoxLayout() mainLayout.setMenuBar(self.menuBar) mainLayout.addWidget(self.form_register_url) mainLayout.addWidget(self.form_download_urls) self.setLayout(mainLayout) self.setWindowTitle("Bamboodl")
def __init__(self, parent=None): super(LocatorWidget, self).__init__( parent, Qt.Dialog | Qt.FramelessWindowHint) self._parent = parent self.setModal(True) self.setAttribute(Qt.WA_TranslucentBackground) self.setStyleSheet("background:transparent;") self.setFixedHeight(400) self.setFixedWidth(500) view = QQuickWidget() view.rootContext().setContextProperty("theme", resources.QML_COLORS) view.setResizeMode(QQuickWidget.SizeRootObjectToView) view.setSource(ui_tools.get_qml_resource("Locator.qml")) self._root = view.rootObject() vbox = QVBoxLayout(self) vbox.setContentsMargins(0, 0, 0, 0) vbox.setSpacing(0) vbox.addWidget(view) self.locate_symbols = locator.LocateSymbolsThread() self.locate_symbols.finished.connect(self._cleanup) # FIXME: invalid signal # self.locate_symbols.terminated.connect(self._cleanup) # Hide locator with Escape key shortEscMisc = QShortcut(QKeySequence(Qt.Key_Escape), self) shortEscMisc.activated.connect(self.hide) # Locator things self.filterPrefix = re.compile(r'(@|<|>|-|!|\.|/|:)') self.page_items_step = 10 self._colors = { "@": "#5dade2", "<": "#4becc9", ">": "#ff555a", "-": "#66ff99", ".": "#a591c6", "/": "#f9d170", ":": "#18ffd6", "!": "#ff884d"} self._filters_list = [ ("@", "Filename"), ("<", "Class"), (">", "Function"), ("-", "Attribute"), (".", "Current"), ("/", "Opened"), (":", "Line"), ("!", "NoPython") ] self._replace_symbol_type = {"<": "<", ">": ">"} self.reset_values() self._filter_actions = { '.': self._filter_this_file, '/': self._filter_tabs, ':': self._filter_lines } self._root.textChanged['QString'].connect(self.set_prefix) self._root.open['QString', int].connect(self._open_item) self._root.fetchMore.connect(self._fetch_more)
class LayerListDialog(QDialog): def __init__(self, parent): QDialog.__init__(self, parent) # add a button box self.layout = QVBoxLayout() self.layer_list = LayerListWidget(self) self.button_box = QDialogButtonBox(self) self.button_box.setOrientation(Qt.Horizontal) self.button_box.setStandardButtons(QDialogButtonBox.Cancel | QDialogButtonBox.Ok) self.button_box.accepted.connect(self.accept) self.button_box.rejected.connect(self.reject) self.layout.addWidget(self.layer_list) self.layout.addWidget(self.button_box) self.setLayout(self.layout) def set_labeling_model(self, model): self.layer_list.set_model(model) def exec_(self): self.layer_list.update_from_layers() return QDialog.exec_(self) def accept(self): # update layers self.layer_list.update_labeling_from_list() QDialog.accept(self)
def __init__(self, *args): super().__init__(BrickletAnalogIn, *args) self.ai = self.device # the firmware version of a EEPROM Bricklet can (under common circumstances) # not change during the lifetime of an EEPROM Bricklet plugin. therefore, # it's okay to make final decisions based on it here self.has_range = self.firmware_version >= (2, 0, 1) self.has_averaging = self.firmware_version >= (2, 0, 3) self.cbe_voltage = CallbackEmulator(self.ai.get_voltage, None, self.cb_voltage, self.increase_error_count) self.current_voltage = CurveValueWrapper() # float, V plots = [('Voltage', Qt.red, self.current_voltage, format_voltage)] self.plot_widget = PlotWidget('Voltage [V]', plots, y_resolution=0.001) layout = QVBoxLayout(self) layout.addWidget(self.plot_widget) if self.has_range: self.combo_range = QComboBox() self.combo_range.addItem('Automatic', BrickletAnalogIn.RANGE_AUTOMATIC) if self.has_averaging: self.combo_range.addItem('0 - 3.30 V', BrickletAnalogIn.RANGE_UP_TO_3V) self.combo_range.addItem('0 - 6.05 V', BrickletAnalogIn.RANGE_UP_TO_6V) self.combo_range.addItem('0 - 10.32 V', BrickletAnalogIn.RANGE_UP_TO_10V) self.combo_range.addItem('0 - 36.30 V', BrickletAnalogIn.RANGE_UP_TO_36V) self.combo_range.addItem('0 - 45.00 V', BrickletAnalogIn.RANGE_UP_TO_45V) self.combo_range.currentIndexChanged.connect(self.range_changed) hlayout = QHBoxLayout() hlayout.addWidget(QLabel('Range:')) hlayout.addWidget(self.combo_range) hlayout.addStretch() if self.has_averaging: self.spin_average = QSpinBox() self.spin_average.setMinimum(0) self.spin_average.setMaximum(255) self.spin_average.setSingleStep(1) self.spin_average.setValue(50) self.spin_average.editingFinished.connect(self.spin_average_finished) hlayout.addWidget(QLabel('Average Length:')) hlayout.addWidget(self.spin_average) line = QFrame() line.setObjectName("line") line.setFrameShape(QFrame.HLine) line.setFrameShadow(QFrame.Sunken) layout.addWidget(line) layout.addLayout(hlayout)
class PreferencesDialog(QDialog): fft_check_signal = pyqtSignal() fft_check_result = 0 def __init__(self, preferences): super(PreferencesDialog, self).__init__() self.setAttribute(Qt.WA_DeleteOnClose) self.setWindowTitle self.title = 'Additional Preferences | ' + __appname__ + 'v' + __version__ self.setWindowTitle(self.title) self.resize(500, 500) self.outer_layout = QVBoxLayout() self.outer_layout.setContentsMargins(5, 3, 5, 7) self.outer_layout.setSpacing(10) self.pref_widget = QWidget() self.vlayout = QVBoxLayout() self.vlayout.setContentsMargins(5, 3, 5, 7) self.vlayout.setSpacing(10) self.app_settings_gb = AppSettingsGroupBox(preferences) self.data_settings_gb = DataSettingsGroupBox(preferences) self.ref_proc_settings_gb = IterativeProcedureSettingsGroupBox( preferences) self.refine_settings_gb = SolverSettingsGroupBox(preferences) self.global_min_settings_gb = GlobalMinSettingsGroupBox(preferences) self.gaussian_fit_settings_gb = GaussianFittingSettingsGroupBox( preferences) self.vlayout.addWidget(self.app_settings_gb) self.vlayout.addWidget(self.data_settings_gb) self.vlayout.addWidget(self.ref_proc_settings_gb) self.vlayout.addWidget(self.refine_settings_gb) self.vlayout.addWidget(self.global_min_settings_gb) self.vlayout.addWidget(self.gaussian_fit_settings_gb) self.pref_widget.setLayout(self.vlayout) self.scroll_area = QScrollArea() self.scroll_area.setFrameShape(QFrame.NoFrame) self.scroll_area.setWidget(self.pref_widget) self.scroll_area.setWidgetResizable(True) self.button_box = QDialogButtonBox() self.button_box.addButton('&Cancel', QDialogButtonBox.RejectRole) self.button_box.addButton('&Apply', QDialogButtonBox.AcceptRole) self.hline = QFrame() self.hline.setFrameShape(QFrame.HLine) self.hline.setFrameShadow(QFrame.Sunken) self.hline.setObjectName('hline') self.outer_layout.addWidget(self.scroll_area) self.outer_layout.addWidget(self.hline) self.outer_layout.addWidget(self.button_box) self.setLayout(self.outer_layout) self.button_box.accepted.connect(self.accept_preferences) self.button_box.rejected.connect(self.rejected) self.rejected.connect(self.close) def accept_preferences(self): # Log mode if self.app_settings_gb.log_mode_input.currentText() == 'Append': _append_log_mode = 1 else: _append_log_mode = 0 try: _data_units = np.int( self.data_settings_gb.data_units_input.currentIndex()) _window_length = np.int( self.data_settings_gb.window_length_input.text()) _poly_order = np.int(self.data_settings_gb.poly_order_input.text()) _rescale_AL = np.int( self.data_settings_gb.rescale_AL_input.isChecked()) _fft_N = np.int(self.data_settings_gb.fft_N_input.value()) self.fft_check = _fft_N self.fft_check_signal.emit() if self.fft_check_result == 1: raise RuntimeWarning() _mod_func_mode = np.int( self.ref_proc_settings_gb.mod_func_mode_input.isChecked()) _op_method = self.refine_settings_gb.op_method_input.currentText() _disp = np.int(self.refine_settings_gb.disp_check.isChecked()) _maxiter = np.int(self.refine_settings_gb.maxiter_input.text()) _ftol = np.float(self.refine_settings_gb.ftol_input.text()) # Get l_bfgs_b specific options if _op_method == 'L-BFGS-B': _maxfun = np.int(self.refine_settings_gb.maxfun_input.text()) _gtol = np.float(self.refine_settings_gb.gtol_input.text()) # Get globam minimisation (basin-hopping) options _bh_disp = np.int( self.global_min_settings_gb.disp_check.isChecked()) _bh_niter = np.int( self.global_min_settings_gb.niter_basin_input.text()) _bh_temp = np.float( self.global_min_settings_gb.temp_basin_input.text()) _bh_step_size = np.float( self.global_min_settings_gb.stepsize_basin_input.text()) _bh_interval = np.int( self.global_min_settings_gb.interval_basin_input.text()) # Get Gaussiant fitting options _xray_weight_mode = np.int(self.gaussian_fit_settings_gb. xray_weight_mode_input.isChecked()) # Handle for missing values except ValueError: _message = [ 'Missing Values!', 'Please ensures all values are set properly' ] self.error_msg = ErrorMessageBox(_message) self.error_msg.show() return except RuntimeWarning: _message = [ '\'N\' out of range!', 'Please increase N\nDefault: 12' ] self.error_msg = ErrorMessageBox(_message) self.error_msg.show() return if not _window_length % 2: _message = [ 'Error!', 'Please ensure window_length is positive odd integer!' ] self.error_msg = ErrorMessageBox(_message) self.error_msg.show() return if _poly_order >= _window_length: _message = ['Error!', 'Please ensure poly_order < window_length!'] self.error_msg = ErrorMessageBox(_message) self.error_msg.show() return # Set minimisation options dictionary _minimisation_options = { 'disp': _disp, 'maxiter': _maxiter, 'ftol': _ftol } # Add additional optiosn for l_bfgs_b method if _op_method == 'L-BFGS-B': _minimisation_options['maxfun'] = _maxfun _minimisation_options['gtol'] = _gtol _global_minimisation = self.global_min_settings_gb.isChecked() _global_min_options = { 'disp': _bh_disp, 'niter': _bh_niter, 'T': _bh_temp, 'stepsize': _bh_step_size, 'interval': _bh_interval } # Set preferences dictionary to return self._preferences = { 'append_log_mode': _append_log_mode, 'data_units': _data_units, 'window_length': _window_length, 'poly_order': _poly_order, 'rescale_AL': _rescale_AL, 'fft_N': _fft_N, 'mod_func_mode': _mod_func_mode, 'op_method': _op_method, 'minimisation_options': _minimisation_options, 'global_minimisation': _global_minimisation, 'global_min_options': _global_min_options, 'xray_weight_mode': _xray_weight_mode } # handle for ValueError if nothing entered self.done(1) def get_preferences(self): return self._preferences
def initUI(self): backButton = QPushButton('') backButton.setIcon(QIcon('image/back_2.png')) backButton.setIconSize(QSize(75, 75)) backButton.clicked.connect(self.back) tab = QTabWidget() tab.setTabPosition(QTabWidget.South) self.city_name = QLineEdit() cities = QWidget() form_cities = QFormLayout() form_cities.setAlignment(Qt.AlignVCenter) form_cities.addRow(QLabel('Название города'), self.city_name) cities.setLayout(form_cities) tab.addTab(cities, 'Города') btn = QPushButton('xii') btn.clicked.connect(self.search_city) btn_h = QHBoxLayout() btn_h.addStretch(3) btn_h.addWidget(backButton) hh = QHBoxLayout() hh.addStretch(1) hh.addWidget(tab, 3) hh.addStretch(1) vv = QVBoxLayout() vv.addLayout(btn_h) vv.addStretch(1) vv.addLayout(hh) vv.addStretch(1) vv.addWidget(btn) self.setLayout(vv) style = "QTabWidget {background-color: rgb(117, 160, 252); font-size: 30px;}" \ "QLabel {background-color: transparent; font-size: 20px;}" \ "QLineEdit {background-color: white; font-size: 20px; border: 1px solid transparent; margin: 0px;}" backButton.setStyleSheet( "background-color: rgba(255, 255, 255, 0.1); padding: 12px;") self.setStyleSheet(style) tab.setStyleSheet("background-color: rgb(117, 160, 252);") p = QPalette() gradient = QLinearGradient(0, 0, 120, 400) gradient.setColorAt(0.0, QColor(117, 160, 252)) gradient.setColorAt(1.0, QColor(193, 203, 253)) p.setBrush(QPalette.Window, QBrush(gradient)) self.setPalette(p) if self.expansion == '1': self.showFullScreen() else: self.setGeometry(0, 30, 800, 600) self.setFixedSize(800, 600) self.setWindowTitle('Menubar') self.show()
class DockContainer(QWidget): def __init__(self, parent=None): """ Class constructor :param parent: Widget """ super(DockContainer, self).__init__(parent=parent, flags=Qt.Widget) self.vertical_layout = QVBoxLayout() # Create a vertical layout container # Adding some elements self.n_stimuli = DockElement("Number of stimuli:") self.stimuli_duration = DockElement("Stimuli duration:") self.fs_element = DockElement("FS:") # Test button self.test_button = QPushButton("Test button") self.init_ui() def init_ui(self) -> None: """ initialize ui elements :return: None """ # bind action to button self.test_button.clicked.connect(self.show_values) # Add all widgets to the vertical_layout self.vertical_layout.addWidget(self.n_stimuli) self.vertical_layout.addWidget(self.stimuli_duration) self.vertical_layout.addWidget(self.fs_element) # Set default values self.n_stimuli.set_text(10) self.stimuli_duration.set_text(1.024) self.fs_element.set_text(200) self.vertical_layout.addWidget(self.test_button, alignment=Qt.AlignCenter) self.vertical_layout.addStretch() # Keep widgets at the top of the vertical_layout self.setLayout(self.vertical_layout) # Set self layout as vertical_layout self.show() # Set self visible def show_values(self) -> None: """ To be deleted :return: None """ wave = AFMWave(self.c_frequency_element.get_value(), self.c_amplitude_element.get_value(), 2048) wave.setAMFrequency(self.am_frequency_element.get_value()) wave.setAMDepth(self.am_depth_element.get_value()) wave.setFS(self.fs_element.get_value()) frq, yf = Calc.calc_fft(wave.getAMWave(), wave.getBufferSize(), wave.getFS()) fig, ax = plt.subplots(2) ax[0].plot(frq[:wave.getBufferSize() // 2], abs(yf[:wave.getBufferSize() // 2])) ax[1].plot(wave.getAMWave()) plt.show()
def make_page(self): toppage = QFrame() toplayout = QVBoxLayout() toppage.setLayout(toplayout) page = QFrame() layout = QFormLayout() page.setLayout(layout) toplayout.addWidget(page) self.edit_start_freq = QLineEdit() self.edit_start_freq.setFixedWidth(350) self.edit_start_freq.textChanged.connect(self.onChange) self.edit_end_freq = QLineEdit() self.edit_end_freq.setFixedWidth(350) self.edit_end_freq.textChanged.connect(self.onChange) self.edit_duration = QLineEdit() self.edit_duration.setFixedWidth(350) self.edit_duration.textChanged.connect(self.onChange) self.edit_ampl = QLineEdit() self.edit_ampl.setFixedWidth(350) self.edit_ampl.textChanged.connect(self.onChange) self.edit_inject = QComboBoxNoWheel() self.edit_inject.setFixedWidth(350) self.edit_inject.addItem('aileron') self.edit_inject.addItem('elevator') self.edit_inject.addItem('rudder') self.edit_inject.addItem('flaps') self.edit_inject.addItem('throttle') self.edit_inject.currentIndexChanged.connect(self.onChange) layout.addRow("<b>Start Freqency (hz):</b>", self.edit_start_freq) layout.addRow("<b>End Freqency (hz):</b>", self.edit_end_freq) layout.addRow("<b>Duration (sec):</b>", self.edit_duration) layout.addRow("<b>Amplitude (deg):</b>", self.edit_ampl) layout.addRow("<b>Injection Point:</b>", self.edit_inject) # 'Parameter' button bar param_group = QFrame() toplayout.addWidget(param_group) param_layout = QHBoxLayout() param_group.setLayout(param_layout) param_layout.addWidget(QLabel("<b>Chirp Parameters:</b> ")) update = QPushButton('Update') update.clicked.connect(self.update) param_layout.addWidget(update) revert = QPushButton('Revert') revert.clicked.connect(self.revert) param_layout.addWidget(revert) param_layout.addStretch(1) # 'Command' button bar cmd_group = QFrame() toplayout.addWidget(cmd_group) cmd_layout = QHBoxLayout() cmd_group.setLayout(cmd_layout) cmd_layout.addWidget( QLabel( "<b>Task Commands: (set params, then engage with physical switch)</b> " )) # circle = QPushButton('Circle Here') # circle.clicked.connect(self.task_circle) # cmd_layout.addWidget(circle) # home = QPushButton('Go Home (and Circle)') # home.clicked.connect(self.task_home) # cmd_layout.addWidget(home) # resume = QPushButton('Resume Route') # resume.clicked.connect(self.task_resume) # cmd_layout.addWidget(resume) cmd_layout.addStretch(1) toplayout.addStretch(1) # set initial values self.revert() return toppage
def add_tx_stats(self, vbox): hbox_stats = QHBoxLayout() # left column vbox_left = QVBoxLayout() self.tx_desc = TxDetailLabel(word_wrap=True) vbox_left.addWidget(self.tx_desc) self.status_label = TxDetailLabel() vbox_left.addWidget(self.status_label) self.date_label = TxDetailLabel() vbox_left.addWidget(self.date_label) self.amount_label = TxDetailLabel() vbox_left.addWidget(self.amount_label) self.ln_amount_label = TxDetailLabel() vbox_left.addWidget(self.ln_amount_label) fee_hbox = QHBoxLayout() self.fee_label = TxDetailLabel() fee_hbox.addWidget(self.fee_label) self.fee_warning_icon = QLabel() pixmap = QPixmap(icon_path("warning")) pixmap_size = round(2 * char_width_in_lineedit()) pixmap = pixmap.scaled(pixmap_size, pixmap_size, Qt.KeepAspectRatio, Qt.SmoothTransformation) self.fee_warning_icon.setPixmap(pixmap) self.fee_warning_icon.setVisible(False) fee_hbox.addWidget(self.fee_warning_icon) fee_hbox.addStretch(1) vbox_left.addLayout(fee_hbox) vbox_left.addStretch(1) hbox_stats.addLayout(vbox_left, 50) # vertical line separator line_separator = QFrame() line_separator.setFrameShape(QFrame.VLine) line_separator.setFrameShadow(QFrame.Sunken) line_separator.setLineWidth(1) hbox_stats.addWidget(line_separator) # right column vbox_right = QVBoxLayout() self.size_label = TxDetailLabel() vbox_right.addWidget(self.size_label) self.rbf_label = TxDetailLabel() vbox_right.addWidget(self.rbf_label) self.rbf_cb = QCheckBox(_('Replace by fee')) self.rbf_cb.setChecked(bool(self.config.get('use_rbf', True))) vbox_right.addWidget(self.rbf_cb) self.locktime_final_label = TxDetailLabel() vbox_right.addWidget(self.locktime_final_label) locktime_setter_hbox = QHBoxLayout() locktime_setter_hbox.setContentsMargins(0, 0, 0, 0) locktime_setter_hbox.setSpacing(0) locktime_setter_label = TxDetailLabel() locktime_setter_label.setText("LockTime: ") self.locktime_e = LockTimeEdit(self) locktime_setter_hbox.addWidget(locktime_setter_label) locktime_setter_hbox.addWidget(self.locktime_e) locktime_setter_hbox.addStretch(1) self.locktime_setter_widget = QWidget() self.locktime_setter_widget.setLayout(locktime_setter_hbox) vbox_right.addWidget(self.locktime_setter_widget) self.block_height_label = TxDetailLabel() vbox_right.addWidget(self.block_height_label) vbox_right.addStretch(1) hbox_stats.addLayout(vbox_right, 50) vbox.addLayout(hbox_stats) # below columns self.block_hash_label = TxDetailLabel(word_wrap=True) vbox.addWidget(self.block_hash_label) # set visibility after parenting can be determined by Qt self.rbf_label.setVisible(self.finalized) self.rbf_cb.setVisible(not self.finalized) self.locktime_final_label.setVisible(self.finalized) self.locktime_setter_widget.setVisible(not self.finalized)
def __init__(self, *, parent: 'ElectrumWindow', desc, prompt_if_unsaved, finalized: bool, external_keypairs=None): '''Transactions in the wallet will show their description. Pass desc to give a description for txs not yet in the wallet. ''' # We want to be a top-level window QDialog.__init__(self, parent=None) self.tx = None # type: Optional[Transaction] self.external_keypairs = external_keypairs self.finalized = finalized self.main_window = parent self.config = parent.config self.wallet = parent.wallet self.prompt_if_unsaved = prompt_if_unsaved self.saved = False self.desc = desc self.setMinimumWidth(640) self.resize(1200, 600) self.set_title() self.psbt_only_widgets = [] # type: List[QWidget] vbox = QVBoxLayout() self.setLayout(vbox) vbox.addWidget(QLabel(_("Transaction ID:"))) self.tx_hash_e = ButtonsLineEdit() self.tx_hash_e.add_qr_show_button(config=self.config, title='Transaction ID') self.tx_hash_e.setReadOnly(True) vbox.addWidget(self.tx_hash_e) self.add_tx_stats(vbox) vbox.addSpacing(10) self.inputs_header = QLabel() vbox.addWidget(self.inputs_header) self.inputs_textedit = QTextEditWithDefaultSize() vbox.addWidget(self.inputs_textedit) self.txo_color_recv = TxOutputColoring( legend=_("Receiving Address"), color=ColorScheme.GREEN, tooltip=_("Wallet receive address")) self.txo_color_change = TxOutputColoring( legend=_("Change Address"), color=ColorScheme.YELLOW, tooltip=_("Wallet change address")) self.txo_color_2fa = TxOutputColoring( legend=_("TrustedCoin (2FA) batch fee"), color=ColorScheme.BLUE, tooltip=_( "TrustedCoin (2FA) fee for the next batch of transactions")) outheader_hbox = QHBoxLayout() outheader_hbox.setContentsMargins(0, 0, 0, 0) vbox.addLayout(outheader_hbox) self.outputs_header = QLabel() outheader_hbox.addWidget(self.outputs_header) outheader_hbox.addStretch(2) outheader_hbox.addWidget(self.txo_color_recv.legend_label) outheader_hbox.addWidget(self.txo_color_change.legend_label) outheader_hbox.addWidget(self.txo_color_2fa.legend_label) self.outputs_textedit = QTextEditWithDefaultSize() vbox.addWidget(self.outputs_textedit) self.sign_button = b = QPushButton(_("Sign")) b.clicked.connect(self.sign) self.broadcast_button = b = QPushButton(_("Broadcast")) b.clicked.connect(self.do_broadcast) self.save_button = b = QPushButton(_("Save")) b.clicked.connect(self.save) self.cancel_button = b = QPushButton(_("Close")) b.clicked.connect(self.close) b.setDefault(True) self.export_actions_menu = export_actions_menu = QMenu() self.add_export_actions_to_menu(export_actions_menu) export_actions_menu.addSeparator() export_submenu = export_actions_menu.addMenu( _("For CoinJoin; strip privates")) self.add_export_actions_to_menu(export_submenu, gettx=self._gettx_for_coinjoin) self.psbt_only_widgets.append(export_submenu) export_submenu = export_actions_menu.addMenu( _("For hardware device; include xpubs")) self.add_export_actions_to_menu(export_submenu, gettx=self._gettx_for_hardware_device) self.psbt_only_widgets.append(export_submenu) self.export_actions_button = QToolButton() self.export_actions_button.setText(_("Export")) self.export_actions_button.setMenu(export_actions_menu) self.export_actions_button.setPopupMode(QToolButton.InstantPopup) self.finalize_button = QPushButton(_('Finalize')) self.finalize_button.clicked.connect(self.on_finalize) partial_tx_actions_menu = QMenu() ptx_merge_sigs_action = QAction(_("Merge signatures from"), self) ptx_merge_sigs_action.triggered.connect(self.merge_sigs) partial_tx_actions_menu.addAction(ptx_merge_sigs_action) self._ptx_join_txs_action = QAction(_("Join inputs/outputs"), self) self._ptx_join_txs_action.triggered.connect(self.join_tx_with_another) partial_tx_actions_menu.addAction(self._ptx_join_txs_action) self.partial_tx_actions_button = QToolButton() self.partial_tx_actions_button.setText(_("Combine")) self.partial_tx_actions_button.setMenu(partial_tx_actions_menu) self.partial_tx_actions_button.setPopupMode(QToolButton.InstantPopup) self.psbt_only_widgets.append(self.partial_tx_actions_button) # Action buttons self.buttons = [ self.partial_tx_actions_button, self.sign_button, self.broadcast_button, self.cancel_button ] # Transaction sharing buttons self.sharing_buttons = [ self.finalize_button, self.export_actions_button, self.save_button ] run_hook('transaction_dialog', self) if not self.finalized: self.create_fee_controls() vbox.addWidget(self.feecontrol_fields) self.hbox = hbox = QHBoxLayout() hbox.addLayout(Buttons(*self.sharing_buttons)) hbox.addStretch(1) hbox.addLayout(Buttons(*self.buttons)) vbox.addLayout(hbox) self.set_buttons_visibility() dialogs.append(self)
class AboutDialog(QDialog): def __init__(self): super(AboutDialog, self).__init__() self.setAttribute(Qt.WA_DeleteOnClose) self.setWindowTitle self.title = __appname__ + ' v' + __version__ self.setWindowTitle(self.title) self.resize(595, 630) self.vlayout = QVBoxLayout() self.vlayout.setContentsMargins(5, 15, 5, 7) self.vlayout.setSpacing(10) self.logo_box = QLabel() with importlib_resources.path('LiquidDiffract.resources.icons', 'logo.png') as path: self.logo = QPixmap(str(path)) self.logo_box.setPixmap(self.logo) self.logo_box.setAlignment(Qt.AlignCenter) self.text_display = QTextBrowser() self.text_display.setReadOnly(True) self.text_display.setFrameStyle(QFrame.NoFrame) self.text_display.setStyleSheet( "* { background-color: rgba(0, 0, 0, 0); }") self.text_display.setOpenExternalLinks(True) _app_url = 'https://github.com/bjheinen/LiquidDiffract' _gpl_url = 'https://www.gnu.org/licenses/gpl.html' _pstr = '<p class="western" align="center">' _description = ('LiquidDiffract is a graphical application for ' 'X-ray total-scattering analysis of liquids and ' 'disordered solids.\n' 'It implements procedures to obtain information on ' 'macroscopic bulk properties and local atomic-scale ' 'structure from total scattering data.\n' 'LiquidDiffract provides tools for background ' 'subtraction; calculation, normalisation, and ' 'refinement of the reciprocal-space structure factor ' 'and real-space correlation functions; ' 'and extraction of structural information such as ' 'bond lengths, coordination number and bulk density.') _app_url_str = (f'{_pstr}<a class="western" href="{_app_url}">' f'<span style="color: #000080;"><span lang="zxx">' f'<u>{_app_url}</u></span></span></a></p>') _copyright = 'Copyright © 2018-2021 – Benedict J. Heinen' _warranty = ('This program comes with absolutely no ' 'warranty or guarantee.') _license = '<u>GNU General Public Licence, version 3 or later</u>' _l_str = (f'See the </span><a class="western" href="{_gpl_url}">' f'<span style="color: #000080;"><span style=' f'"font-size: small;"><span lang="zxx">{_license}</span>' f'</span></span></a><span style="font-size: small;"> ' f'for details.</span></p>') _text = ( f'{_pstr}<strong>{__appname__}</strong></p>' f'{_pstr}v{__version__}</p>' f'{_pstr} </p>' f'{_pstr}<em>{_description}</em></p>' f'{_pstr} </p>' f'{_app_url_str}' f'{_pstr} </p>' f'{_pstr}<span style="font-size: small;">{_copyright}</span></p>' f'{_pstr}<span style="font-size: small;">{_warranty}<br>' f'{_l_str}') self.text_display.textCursor().insertHtml(_text) self.vlayout.addWidget(self.logo_box) self.vlayout.addWidget(self.text_display) self.setLayout(self.vlayout)
class SearchMSTitle(QMdiSubWindow): def __init__(self, main, type): """ Search movie or series by title. :param main: Reference for main windows. :param type: String if is "movie" then search for movie if not search by "series". """ super(SearchMSTitle, self).__init__() self.session = DB.get_session() self.type = type self.main = main self.row_select = -1 if self.type == 'movie': self.obj = self.session.query(Movie).order_by(Movie.name) name = texts.movie_p else: self.obj = self.session.query(Series).order_by(Series.name) name = texts.series_p windows_title = texts.search + ' ' + name + ' ' + texts.for_ \ + ' ' + texts.title_p self.setWindowTitle(windows_title) self.width = int(0.9 * main.frameSize().width()) self.height = int(0.9 * main.frameSize().height()) self.setGeometry(0, 0, self.width, self.height) self.subwindow = QWidget() p = self.palette() p.setColor(self.backgroundRole(), QColor(230, 230, 250)) self.setPalette(p) self.setWidget(self.subwindow) self.vbox_main = QVBoxLayout(self.subwindow) self.vbox_main.setContentsMargins(20, 20, 20, 20) # Title self.lb_title = QLabel(texts.title_s) self.lb_title.setMaximumSize(QSize(100, 25)) self.cb_title = cb_create() self.cb_title.addItem('', 0) for ms in self.obj: self.cb_title.addItem(ms.name, ms.id) # Words text = texts.or_s + ' ' + texts.with_the_p + ' ' + texts.term_p self.lb_term = QLabel(text) self.le_term = le_create(30, texts.with_term_tt) self.le_term.setPlaceholderText('pressione enter') # # HBoxSearch self.hbox_search = hbox_create( [self.lb_title, self.cb_title, self.lb_term, self.le_term]) spacer = QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum) self.hbox_search.addItem(spacer) self.vbox_main.addLayout(self.hbox_search) # total self.lb_total = QLabel(texts.lb_total) self.le_total = le_create(255) self.le_total.setMaximumWidth(100) # Buttons self.pb_clear = pb_create(texts.pb_clear, 11, 30) self.pb_clear.setMaximumWidth(100) self.pb_clear.setShortcut('Ctrl+L') # self.pb_clear.clicked.connect(self.clear) self.pb_leave = pb_create(texts.pb_leave, 11, 30) self.pb_leave.setMaximumWidth(100) self.pb_leave.setShortcut('Ctrl+Q') self.pb_leave.clicked.connect(self.close) # Hbox_result self.hbox_result = hbox_create( [self.lb_total, self.le_total, self.pb_clear, self.pb_leave]) spacer = QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum) self.hbox_result.addItem(spacer) self.vbox_main.addLayout(self.hbox_result) # Table self.table = QTableWidget() self.table.setObjectName('table-search') self.rows = 0 self.clear_table() self.set_table(self.obj) self.vbox_main.addWidget(self.table) self.cb_title.currentIndexChanged.connect(self.query_title) self.le_term.editingFinished.connect(self.query_term) # Clear Table def clear_table(self): """ Clear all tables values. """ self.table.clear() self.table.setRowCount(0) self.table.setColumnCount(6) self.rows = 0 if self.type == 'movie': headers = [ texts.title_s, texts.original_title_s, texts.lb_time, texts.media_s, texts.year_s, 'id' ] else: headers = [ texts.title_s, texts.original_title_s, texts.season_p, texts.media_s, texts.year_s, 'id' ] self.table.setHorizontalHeaderLabels(headers) col_width = self.width - 70 self.table.setColumnWidth(0, 0.35 * col_width) self.table.setColumnWidth(1, 0.35 * col_width) self.table.setColumnWidth(2, 0.10 * col_width) self.table.setColumnWidth(3, 0.10 * col_width) self.table.setColumnWidth(4, 0.10 * col_width) self.table.setColumnWidth(5, 0) self.table.verticalHeader().setVisible(False) self.table.setStyleSheet('background-color: #FFFFFF;') self.table.setSortingEnabled(True) # Resize Event def resizeEvent(self, event): """ Resize actors and character combobox in table cast if windows resize. :param event: Window. """ self.width = event.size().width() col_width = self.width - 70 self.table.setColumnWidth(0, 0.35 * col_width) self.table.setColumnWidth(1, 0.35 * col_width) self.table.setColumnWidth(2, 0.10 * col_width) self.table.setColumnWidth(3, 0.10 * col_width) self.table.setColumnWidth(4, 0.10 * col_width) self.table.setColumnWidth(5, 0) # Important don't delete it QMdiSubWindow.resizeEvent(self, event) # View Movie def view_obj(self, row, col): """ When clicked a cell table who has title show the html view of movie. :param row: The number of the row on which the cell was clicked. :param col: The number of the column on which the cell was clicked. """ if self.row_select != row and col == 0: obj_id = self.table.item(row, 5).text() if self.type == 'movie': obj = self.session.query(Movie).get(obj_id) else: obj = self.session.query(Series).get(obj_id) if obj.view: self.main.view_html(obj.view, obj.name) self.row_select = row # Set Table def set_table(self, objs): """ Set table with all movies. :param query: The movies values. """ self.clear_table() for o in objs: self.table.insertRow(self.rows) self.table.setItem(self.rows, 0, QTableWidgetItem(o.name)) font = QFont() font.setUnderline(True) self.table.item(self.rows, 0).setForeground(QColor(55, 34, 243)) self.table.item(self.rows, 0).setFont(font) self.table.setItem(self.rows, 1, QTableWidgetItem(o.original_name)) if self.type == 'movie': self.table.setItem(self.rows, 2, QTableWidgetItem(o.time)) else: self.table.setItem(self.rows, 2, QTableWidgetItem(o.seasons)) if o.media_id: self.table.setItem(self.rows, 3, QTableWidgetItem(o.media.name)) else: self.table.setItem(self.rows, 3, QTableWidgetItem('')) self.table.setItem(self.rows, 4, QTableWidgetItem(o.year)) self.table.setItem(self.rows, 5, QTableWidgetItem(str(o.id))) for i in range(6): if self.table.item(self.rows, i): self.table.item(self.rows, i).setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled) self.table.cellDoubleClicked.connect(self.view_obj) self.rows += 1 self.table.setAlternatingRowColors(True) self.table.setStyleSheet( "alternate-background-color: #F0FAE4;; background-color: #FFFFFF;") self.le_total.setText(str(self.rows)) # Set Query Title def set_table_title(self, obj): """ Set table with movies values search in database. :param obj: The movies values from a database search. """ self.clear_table() self.table.insertRow(self.rows) self.table.setItem(self.rows, 0, QTableWidgetItem(obj.name)) font = QFont() font.setUnderline(True) self.table.item(self.rows, 0).setForeground(QColor(55, 34, 243)) self.table.item(self.rows, 0).setFont(font) self.table.setItem(self.rows, 1, QTableWidgetItem(obj.original_name)) if self.type == 'movie': self.table.setItem(self.rows, 2, QTableWidgetItem(obj.time)) else: self.table.setItem(self.rows, 2, QTableWidgetItem(obj.seasons)) if obj.media: self.table.setItem(self.rows, 3, QTableWidgetItem(obj.media.name)) else: self.table.setItem(self.rows, 3, QTableWidgetItem('')) self.table.setItem(self.rows, 4, QTableWidgetItem(obj.year)) self.table.setItem(self.rows, 5, QTableWidgetItem(str(obj.id))) self.table.cellClicked.connect(self.view_obj) self.rows += 1 self.table.setAlternatingRowColors(True) self.table.setStyleSheet( "alternate-background-color: #F0FAE4; background-color: #ffffff;") self.le_total.setText(str(self.rows)) # Query Title def query_title(self): """ Search movie by selected title in QCombobox. """ id, name = get_combobox_info(self.cb_title) if self.type == 'movie': query = self.session.query(Movie).get(id) else: query = self.session.query(Series).get(id) self.set_table_title(query) def query_term(self): """ Search movie by words in title. """ words = self.le_term.text().split() queries = [] for word in words: word = '%{0}%'.format(word) if self.type == 'movie': query = self.session.query(Movie)\ .filter(Movie.name.ilike(word)).all() else: query = self.session.query(Series) \ .filter(Series.name.ilike(word)).all() queries += query self.set_table(queries) def clear(self): """ Clear all values in windows. """ self.cb_title.currentIndexChanged.disconnect() self.cb_title.setCurrentIndex(0) self.clear_table() self.set_table(self.obj) self.cb_title.currentIndexChanged.connect(self.query_title) # Close Event def closeEvent(self, event): self.session.close()
def settings_win(self): # Define Settings Win self.settings = QMainWindow(self.main) self.settings.setWindowTitle('Settings') # Create StackedWidget and Selection List self.stacked_settings = QStackedWidget() self.settings_list = QListWidget() self.settings_list.setFixedWidth(110) self.settings_list.addItems(['Main', 'About']) self.settings_list.clicked.connect(self.actions.select_settings) # Central Widget central_widget = QWidget() hbox = QHBoxLayout() hbox.addWidget(self.settings_list) hbox.addWidget(self.stacked_settings) central_widget.setLayout(hbox) self.settings.setCentralWidget(central_widget) ''' Child widget Behavior Settings ''' behavior_settings = QWidget() self.stacked_settings.addWidget(behavior_settings) # Main Layouts vbox = QVBoxLayout() vbox.setAlignment(Qt.AlignTop) form_layout = QFormLayout() # Change Directory dl_directory_label = QLabel('Download directory:') form_layout.addRow(dl_directory_label) dl_directory_btn = QPushButton('Select..') dl_directory_btn.clicked.connect(self.actions.set_dl_directory) self.dl_directory_input = QLineEdit() if self.actions.settings is not None: self.dl_directory_input.setText(self.actions.settings[0]) self.dl_directory_input.setDisabled(True) form_layout.addRow(dl_directory_btn, self.dl_directory_input) # Bottom Buttons save_settings = QPushButton('Save') save_settings.clicked.connect(self.actions.save_settings) # Change theme theme_label = QLabel('Theme:') form_layout.addRow(theme_label) self.theme_select = QComboBox() self.theme_select.addItems(['Light', 'Dark']) self.theme_select.currentIndexChanged.connect( self.actions.change_theme) form_layout.addRow(self.theme_select) vbox.addLayout(form_layout) vbox.addStretch() vbox.addWidget(save_settings) behavior_settings.setLayout(vbox) ''' Child widget About ''' about_settings = QWidget() self.stacked_settings.addWidget(about_settings) about_layout = QGridLayout() about_layout.setAlignment(Qt.AlignCenter) logo = QLabel() logo.setPixmap(QPixmap(absp('res/zap.svg'))) logo.setAlignment(Qt.AlignCenter) text = QLabel(self.app_name) text.setStyleSheet('font-weight: bold; color: #4256AD') github_btn = QPushButton(QIcon(absp('res/github.svg')), '') github_btn.setFixedWidth(32) github_btn.clicked.connect( lambda: webbrowser.open('https://github.com/manuGMG/1fichier-dl')) about_layout.addWidget(logo, 0, 0, 1, 0) about_layout.addWidget(github_btn, 1, 0) about_layout.addWidget(text, 1, 1) about_settings.setLayout(about_layout)
class WaterfallPlotter(QWidget): generated_rectangles_signal = QtCore.pyqtSignal( list) #send list of rects for data display in tree def __init__(self, parent): super(WaterfallPlotter, self).__init__(parent) self.get_settings() self.settings_update = False self.figure = plt.figure() self.canvas = FigureCanvas(self.figure) self.toolbar = NavigationToolbar(self.canvas, self) self.btn_plot = QPushButton('Default Plot') self.btn_plot.clicked.connect(self.plot) self.layout = QVBoxLayout() self.layout.addWidget(self.toolbar) self.layout.addWidget(self.canvas) self.layout.addWidget(self.btn_plot) self.setLayout(self.layout) def on_waterfall_data_signal(self, signal): self.waterfall_data = signal['waterfall_data'] #pandas dataframe self.btn_plot.setEnabled(True) def get_settings(self): # try: # with shelve.open('WaterfallSettings') as shelfFile: # self.keys_and_colors = shelfFile['keys_and_colors'] # shelfFile.close() # except: # #set and use default settings # self.keys_and_colors = { # 'CR':'#03945D', # 'PR':'#B1EE97', # 'PD':'#FF6F69', # 'SD':'#707070', # 'a':'r', # 'b':'g', # 'c':'b' # } # with shelve.open('WaterfallSettings') as shelfFile: # shelfFile['keys_and_colors'] = self.keys_and_colors # shelfFile.close() self.keys_and_colors = { 'CR': '#03945D', 'PR': '#B1EE97', 'PD': '#FF6F69', 'SD': '#707070', 'a': '#FF0000', 'b': '#00FF00', 'c': '#0000FF' } def on_general_settings_signal(self, signal): self.gen_settings = signal self.settings_update = True self.plot() def get_bar_colors(self, responses): return [self.keys_and_colors[x] for x in responses] def plot(self): ''' Plot waterfall data ''' self.figure.clear() self.rect_locations = np.arange( len(self.waterfall_data['Best response percent change'])) self.ax = self.figure.add_subplot(111) self.patches = [] self.bar_labels = self.waterfall_data['Overall response'] if self.settings_update == False: self.ax.tick_params( axis='x', # changes apply to the x-axis which='both', # both major and minor ticks are affected bottom='on', # ticks along the bottom edge are off top='on', # ticks along the top edge are off labelbottom='on') # labels along the bottom edge are off self.ax.axhline(y=20, linestyle='--', c='k', alpha=0.5, lw=2.0, label='twenty_percent') self.ax.axhline(y=-30, linestyle='--', c='k', alpha=0.5, lw=2.0, label='thirty_percent') self.ax.axhline(y=0, c='k', alpha=1, lw=2.0, label='zero_percent') self.ax.grid(color='k', axis='y', alpha=0.25) self.bar_colors = self.get_bar_colors( self.waterfall_data['Overall response']) self.rects = self.ax.bar( self.rect_locations, self.waterfall_data['Best response percent change'], color=self.bar_colors, label=self.waterfall_data['Overall response']) for key in self.keys_and_colors.keys(): self.patches.append( mpatches.Patch(color=self.keys_and_colors[key], label=key)) self.ax.legend(handles=self.patches) else: self.ax.legend([]) #settings were updated, we received them and stored in variable self.gen_settings self.ax.set_title(self.gen_settings[0]) self.ax.set_xlabel(self.gen_settings[1]) self.ax.set_ylabel(self.gen_settings[2]) if self.gen_settings[3][0]: self.ax.axhline(y=20, linestyle='--', c='k', alpha=0.5, lw=2.0, label='twenty_percent') if self.gen_settings[3][1]: self.ax.axhline(y=-30, linestyle='--', c='k', alpha=0.5, lw=2.0, label='thirty_percent') if self.gen_settings[3][2]: self.ax.axhline(y=0, c='k', alpha=1, lw=2.0, label='zero_percent') if self.gen_settings[4][0] and ~self.gen_settings[6]: #show responses as labels, default color bars #legend depends on user specified keys self.rects = self.ax.bar( self.rect_locations, self.waterfall_data['Best response percent change'], label=self.waterfall_data['Overall response']) self.add_labels(self.ax, self.rects, self.waterfall_data, 1) elif self.gen_settings[4][1]: #color bars with response type self.bar_colors = self.get_bar_colors( self.waterfall_data['Overall response']) self.rects = self.ax.bar( self.rect_locations, self.waterfall_data['Best response percent change'], color=self.bar_colors, label=self.waterfall_data['Overall response']) for key in self.keys_and_colors.keys(): self.patches.append( mpatches.Patch(color=self.keys_and_colors[key], label=key)) self.ax.legend(handles=self.patches) elif self.gen_settings[4][2]: #response not shown as color coding, custom color code the bars self.bar_labels = self.gen_settings[7] self.bar_colors = self.get_bar_colors(self.gen_settings[7]) used_keys = list(set(self.gen_settings[7])) self.rects = self.ax.bar( self.rect_locations, self.waterfall_data['Best response percent change'], color=self.bar_colors, label=self.gen_settings[7]) for key in used_keys: self.patches.append( mpatches.Patch(color=self.keys_and_colors[key], label=key)) self.ax.legend(handles=self.patches) else: self.rects = self.ax.bar( self.rect_locations, self.waterfall_data['Best response percent change'], label=self.waterfall_data['Overall response']) if self.gen_settings[5]: self.plot_table() if self.gen_settings[6] and ~self.gen_settings[4][0]: self.add_labels(self.ax, self.rects, self.waterfall_data, 0) self.ax.grid(color='k', axis='y', alpha=0.25) self.canvas.draw() self.generated_rectangles_signal.emit([self.rects, self.bar_labels]) def plot_table(self): rows = ['%s' % x for x in self.waterfall_data.keys()] rows = rows[ 4:] #skip first three, they are the 4 standard headers, rest are table rows columns = self.waterfall_data['Patient number'] #patient numbers cell_text = [] for row in rows: cell_text_temp = [] for col in range(len(columns)): cell_text_temp.append(self.waterfall_data[row][col]) cell_text.append(cell_text_temp) the_table = self.ax.table(cellText=cell_text, rowLabels=rows, colLabels=columns, loc='bottom', cellLoc='center', colLoc='center') plt.subplots_adjust(bottom=0.15, left=0.5) self.ax.set_xlim(-0.5, len(columns) - 0.5) self.ax.tick_params( axis='x', # changes apply to the x-axis which='both', # both major and minor ticks are affected bottom='off', # ticks along the bottom edge are off top='off', # ticks along the top edge are off labelbottom='off') # labels along the bottom edge are off def add_labels(self, ax, rects, waterfall_data, label_type): ''' Add labels above/below bars. label_type == 1 --> display responses; == 0 --> display cancer type ''' i = 0 if label_type: for rect in rects: height = rect.get_height() if height >= 0: valign = 'bottom' else: valign = 'top' ax.text(rect.get_x() + rect.get_width() / 2., height, '%s' % waterfall_data['Overall response'][i], ha='center', va=valign) i += 1 else: for rect in rects: height = rect.get_height() if height >= 0: valign = 'top' hgt = -1 else: valign = 'bottom' hgt = 1 ax.text(rect.get_x() + rect.get_width() / 2., hgt, '%s' % waterfall_data['Cancer'][i], ha='center', va=valign, rotation='vertical') i += 1
def init_ui(self): layout = QVBoxLayout() layout.addWidget(self.output_dir) layout.addWidget(self.preserve_dir) layout.addWidget(self.preserve_times) layout.addWidget(self.delete_metadata) layout.addWidget(self.overwrite_files) layout.addWidget(self.history) layout.addWidget(self.sort_by_size) layout.addWidget(QHLine()) layout.addWidget(self.encoder_editor) layout.addWidget(QHLine()) layout.addWidget(QLabel("<u>Advanced</u>")) h_layout = QHBoxLayout() h_layout.addWidget( QLabel("Number of files to encode at the same time")) h_layout.addWidget(self.max_threads) layout.addLayout(h_layout) layout.addWidget(self.single_thread_video) layout.addWidget(QHLine()) layout.addWidget(QLabel("<u>Unsupported files</u>")) layout.addWidget( QLabel( "Copy files with the following extensions to output\n(Separate with ;)" )) layout.addWidget(self.unsupported_extensions_to_copy) layout.addWidget(QHLine()) layout.addWidget(QLabel("<u>Appearance</u>")) layout.addWidget(self.use_system_theme) layout.addWidget(QHLine()) buttons = QDialogButtonBox(QDialogButtonBox.Ok, Qt.Horizontal, self) buttons.clicked.connect(self.close) layout.addWidget(buttons) self.setLayout(layout) self.setWindowTitle("Settings") self.setWindowIcon(TransCoda.theme.ico_app_icon)
def initUI(self): # set window size and title self.setGeometry(300, 300, 500, 250) self.setWindowTitle('Assignment6') # to send warning to user self.warning_msg = QMessageBox() self.warning_msg.setIcon(QMessageBox.Warning) self.warning_msg.setText("empty DB") self.warning_msg.setDetailedText("Add Student's Data") self.warning_msg.setWindowTitle(self.windowTitle()) self.warning_msg.setStandardButtons(QMessageBox.Ok) # to send is Ok or not self.ask_msg = QMessageBox() self.ask_msg.setIcon(QMessageBox.Question) self.ask_msg.setText("are you sure?") self.ask_msg.setWindowTitle(self.windowTitle()) self.ask_msg.setStandardButtons(QMessageBox.Yes | QMessageBox.No) # first row is user input name_lbl = QLabel('Name:') age_lbl = QLabel('Age:') score_lbl = QLabel('Score:') self.name_edit = QLineEdit() self.age_edit = QLineEdit() self.score_edit = QLineEdit() vbox = QVBoxLayout() user_data_hbox = QHBoxLayout() user_data_hbox.addWidget(name_lbl) user_data_hbox.addWidget(self.name_edit) user_data_hbox.addWidget(age_lbl) user_data_hbox.addWidget(self.age_edit) user_data_hbox.addWidget(score_lbl) user_data_hbox.addWidget(self.score_edit) vbox.addLayout(user_data_hbox) # end of first row # second row is key combo and amount amount_lbl = QLabel('Amount:') self.amount_edit = QLineEdit() sort_key_lbl = QLabel('Key') self.sort_key_combo = QComboBox() self.sort_key_combo.addItems(ScoreDB.ColumnName) key_and_amount_hbox = QHBoxLayout() key_and_amount_hbox.addStretch(1) key_and_amount_hbox.addWidget(amount_lbl) key_and_amount_hbox.addWidget(self.amount_edit) key_and_amount_hbox.addWidget(sort_key_lbl) key_and_amount_hbox.addWidget(self.sort_key_combo) vbox.addLayout(key_and_amount_hbox) # end of second row # third row is 5 push buttons # command buttons self.add_btn = QPushButton('Add') self.del_btn = QPushButton('Del') self.find_btn = QPushButton('Find') self.inc_btn = QPushButton('Inc') self.show_btn = QPushButton('show') command_hbox = QHBoxLayout() command_hbox.addStretch(1) command_hbox.addWidget(self.add_btn) command_hbox.addWidget(self.del_btn) command_hbox.addWidget(self.find_btn) command_hbox.addWidget(self.inc_btn) command_hbox.addWidget(self.show_btn) vbox.addLayout(command_hbox) # end of third row # last row is label and text edit result_lbl = QLabel('Result:') self.result_txt = QTextEdit() self.result_txt.setReadOnly(True) result_hbox = QHBoxLayout() result_vbox = QVBoxLayout() result_vbox.addWidget(result_lbl) result_vbox.addStretch(1) result_hbox.addLayout(result_vbox) result_hbox.addWidget(self.result_txt) vbox.addLayout(result_hbox) # end of last row self.setLayout(vbox) self.is_first_shown = True self.connect_events() self.show()
def setup_ui(self): """ Setup Ui """ main_wrap = QVBoxLayout() main_wrap.setContentsMargins(0, 0, 0, 0) # updatebar on top self.update_bar = UpdateBar(self) self.update_bar.onUpdateNowClicked.connect(self._update_dwarf) self.update_bar.setVisible(False) main_wrap.addWidget(self.update_bar) # main content h_box = QHBoxLayout() h_box.setContentsMargins(15, 15, 15, 15) wrapper = QVBoxLayout() head = QHBoxLayout() head.setContentsMargins(50, 10, 0, 10) # dwarf icon icon = QLabel() icon.setPixmap(QPixmap(utils.resource_path('assets/dwarf.svg'))) icon.setAlignment(Qt.AlignCenter) icon.setMinimumSize(QSize(125, 125)) icon.setMaximumSize(QSize(125, 125)) head.addWidget(icon) # main title v_box = QVBoxLayout() title = QLabel('Dwarf') title.setContentsMargins(0, 0, 0, 0) font = QFont('Anton', 100, QFont.Bold) font.setPixelSize(120) title.setFont(font) title.setMaximumHeight(125) title.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum) title.setAlignment(Qt.AlignCenter) head.addWidget(title) sub_title_text = (self._pick_random_word(0) + ' ' + self._pick_random_word(1) + ' ' + self._pick_random_word(2) + ' ' + self._pick_random_word(3) + ' ' + self._pick_random_word(4)) sub_title_text = sub_title_text[:1].upper() + sub_title_text[1:] self._sub_title = QLabel(sub_title_text) font = QFont('OpenSans', 16, QFont.Bold) font.setPixelSize(24) self._sub_title.setFont(font) font_metric = QFontMetrics(self._sub_title.font()) self._char_width = font_metric.widthChar('#') self._sub_title.setAlignment(Qt.AlignCenter) self._sub_title.setContentsMargins(175, 0, 0, 20) self._sub_title.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum) v_box.addLayout(head) v_box.addWidget(self._sub_title) wrapper.addLayout(v_box) recent = QLabel('Recent saved Sessions') font = recent.font() font.setPixelSize(14) font.setBold(True) # font.setPointSize(10) recent.setFont(font) wrapper.addWidget(recent) wrapper.addWidget(self._recent_list) h_box.addLayout(wrapper, stretch=False) buttonSpacer = QSpacerItem(15, 100, QSizePolicy.Fixed, QSizePolicy.Minimum) h_box.addItem(buttonSpacer) wrapper = QVBoxLayout() btn = QPushButton() ico = QIcon(QPixmap(utils.resource_path('assets/android.svg'))) btn.setIconSize(QSize(75, 75)) btn.setIcon(ico) btn.setToolTip('New Android Session') btn.clicked.connect(self._on_android_button) wrapper.addWidget(btn) btn = QPushButton() ico = QIcon(QPixmap(utils.resource_path('assets/apple.svg'))) btn.setIconSize(QSize(75, 75)) btn.setIcon(ico) btn.setToolTip('New iOS Session') btn.clicked.connect(self._on_ios_button) wrapper.addWidget(btn) btn = QPushButton() ico = QIcon(QPixmap(utils.resource_path('assets/local.svg'))) btn.setIconSize(QSize(75, 75)) btn.setIcon(ico) btn.setToolTip('New Local Session') btn.clicked.connect(self._on_local_button) wrapper.addWidget(btn) btn = QPushButton() ico = QIcon(QPixmap(utils.resource_path('assets/remote.svg'))) btn.setIconSize(QSize(75, 75)) btn.setIcon(ico) btn.setToolTip('New Remote Session') btn.clicked.connect(self._on_remote_button) wrapper.addWidget(btn) h_box.addLayout(wrapper, stretch=False) main_wrap.addLayout(h_box) self.setLayout(main_wrap)
class MainWindow(QMainWindow, mainwindow.Ui_MainWindow): waterfall_data_signal = QtCore.pyqtSignal(list) def __init__(self, parent=None): QMainWindow.__init__(self, parent) self.setupUi(self) self.setup_window() def setup_window(self): #Dialogs self.Waterfall_Plot = WaterfallPlotter(self) self.Waterfall = Waterfall(self) self.Waterfall_Widget = QWidget() self.Waterfall_Box = QVBoxLayout() self.Waterfall_Splitter = QSplitter(QtCore.Qt.Horizontal) self.Waterfall_Splitter.addWidget(self.Waterfall) self.Waterfall_Splitter.addWidget(self.Waterfall_Plot) self.Waterfall_Box.addWidget(self.Waterfall_Splitter) self.Waterfall_Widget.setLayout(self.Waterfall_Box) self.Spider_Widget = QWidget() self.Spider_Box = QVBoxLayout() self.Spider_Splitter = QSplitter(QtCore.Qt.Horizontal) self.Spider_Plot = SpiderPlotter(self) self.Spider = Spider(self) self.Spider_Splitter.addWidget(self.Spider) self.Spider_Splitter.addWidget(self.Spider_Plot) self.Spider_Box.addWidget(self.Spider_Splitter) self.Spider_Widget.setLayout(self.Spider_Box) self.Swimmer_Widget = QWidget() self.Swimmer_Box = QVBoxLayout() self.Swimmer_Splitter = QSplitter(QtCore.Qt.Horizontal) self.Swimmer_Plot = SwimmerPlotter(self) self.Swimmer = Swimmer(self) self.Swimmer_Splitter.addWidget(self.Swimmer) self.Swimmer_Splitter.addWidget(self.Swimmer_Plot) self.Swimmer_Box.addWidget(self.Swimmer_Splitter) self.Swimmer_Widget.setLayout(self.Swimmer_Box) self.stackedWidget.addWidget(self.Waterfall_Widget) #0 self.stackedWidget.addWidget(self.Spider_Widget) #1 self.stackedWidget.addWidget(self.Swimmer_Widget) #2 self.stackedWidget.hide() #Set up toolBar self.toolBar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon) importAction = QAction( QtGui.QIcon(os.path.join(image_dir, 'images\Download.png')), 'Import date template', self) importAction.triggered.connect(self.import_data) importAction.setIconText("Import") self.toolBar.addAction(importAction) self.toolBar.addSeparator() dumpAction = QAction( QtGui.QIcon(os.path.join(image_dir, 'images\Rubbish.png')), 'Import date template', self) #dumpAction.triggered.connect(self.dump_data) dumpAction.setIconText("Dump data") self.toolBar.addAction(dumpAction) self.toolBar.addSeparator() self.waterfallAction = QAction( QtGui.QIcon(os.path.join(image_dir, 'images\waterfall.png')), 'Waterfall plot', self) waterfallAction.triggered.connect(self.launch_waterfall) waterfallAction.setIconText("Waterfall") waterfallAction.setEnabled(False) self.toolBar.addAction(waterfallAction) spiderAction = QAction( QtGui.QIcon(os.path.join(image_dir, 'images\spider.png')), 'Spider plot', self) spiderAction.triggered.connect(self.launch_spider) spiderAction.setIconText("Spider") spiderAction.setEnabled(False) self.toolBar.addAction(spiderAction) swimmerAction = QAction( QtGui.QIcon(os.path.join(image_dir, 'images\swimmer_stack.png')), 'Swimmer plot', self) swimmerAction.triggered.connect(self.launch_spider) swimmerAction.setIconText("Swimmer") swimmerAction.setEnabled(False) self.toolBar.addAction(swimmerAction) self.toolBar.addSeparator() #Signal interconnections self.waterfall_data_signal.connect( self.Waterfall.on_waterfall_data_signal) self.waterfall_data_signal.connect( self.Waterfall_Plot.on_waterfall_data_signal) self.Waterfall.general_settings_signal.connect( self.Waterfall_Plot.on_general_settings_signal) #Launch functions def launch_waterfall(self): self.stackedWidget.setCurrentIndex(0) self.stackedWidget.show() def launch_spider(self): self.stackedWidget.setCurrentIndex(1) self.stackedWidget.show() def launch_swimmer(self): self.stackedWidget.setCurrentIndex(2) self.stackedWidget.show() def import_data(self): self.file_path = QFileDialog.getOpenFileName(self, "Select Data Template", "C:\\")[0] if self.file_path == '': pass else: self.waterfall_data = import_plot_data(self.file_path) self.waterfall_data_signal.emit(self.waterfall_data) waterfallAction.setEnabled(True) spiderAction.setEnabled(True) swimmerAction.setEnabled(True)
class tab_widget(QWidget): def __init__(self): super().__init__() self.layout = QVBoxLayout() self.exeUI() def exeUI(self): # tab 설정 self.tabs = QTabWidget() self.tab1 = QWidget() self.tab2 = QWidget() self.tab3 = QWidget() self.tab4 = QWidget() # 각 TAB 이름 설정 및 추가 self.tabs.addTab(self.tab1, 'Quotation') self.tabs.addTab(self.tab2, 'Progress') self.tabs.addTab(self.tab3, 'Result') self.tabs.addTab(self.tab4, 'Report') # tab1의 실행 명령어 self.tab1_play = self.tab1_f() # tab 전체 위젯을 완성시키는 명령어 self.layout.addWidget(self.tabs) self.setLayout(self.layout) # tab1 실행 함수 def tab1_f(self): # tab1 의 layout 을 그리드로 설정 self.tab1.layout = QGridLayout() self.tab1_func1 = self.code_c_search() self.tab1_func2 = self.Quotation() self.tab1.setLayout(self.tab1.layout) # tab1 의 code_c_search def code_c_search(self): self.c_code_search = QGroupBox('C-CODE SEARCH') # GropBox 크기 조절 self.c_code_search.setMaximumSize(430, 800) self.tab1.layout.addWidget(self.c_code_search, 0, 0) self.c_code_label = QLabel('검 색:') self.c_code_line = QLineEdit() self.c_code_btn = QPushButton('확인') self.c_code_btn2 = QPushButton('입력') self.c_code_table = QTableWidget(self.c_code_search) # TableWidget 설정 self.c_code_table.resize(300, 700) # Table 짝수번째 색 변화 self.c_code_table.setAlternatingRowColors(True) # Table 셀을 선택할 때 전체 행을 선택하도록 설정 self.c_code_table.setSelectionBehavior(QAbstractItemView.SelectRows) # Table을 수정하지 못하도록 설정 self.c_code_table.setEditTriggers(QAbstractItemView.NoEditTriggers) # Table에서 더블클릭을 하면 실행되는 기능 self.c_code_table.doubleClicked.connect(self.move_toQ) # 버튼을 누르면 시작 self.c_code_btn.clicked.connect(self.tab1_ccode_btn) self.c_code_btn2.clicked.connect(self.tab1_ccode_btn2) self.c_code_line.returnPressed.connect(self.tab1_ccode_btn) # c_code_search 의 GroupBox 에 대한 정렬코드 # label 과 line 의 위치를 설정 Hbox = QHBoxLayout() Vbox = QVBoxLayout() Hbox.addStretch(1) Hbox.addWidget(self.c_code_label) Hbox.addWidget(self.c_code_line) Hbox.addWidget(self.c_code_btn) Hbox.addStretch(1) # Vbox.addStretch(0) Vbox.addLayout(Hbox) # Vbox.addStretch(20) Vbox.addWidget(self.c_code_table) Vbox.addWidget(self.c_code_btn2) self.c_code_search.setLayout(Vbox) # c_code 의 확인 button def tab1_ccode_btn(self): df_fun = ef.excel_pd() df = df_fun.search_ccode() ccode_text = self.c_code_line.text() df_search = df['COMPANY'].str.contains(ccode_text) DF = df[df_search] if DF.empty: reply = QMessageBox(self) reply.question(self, 'Error', '검색되지 않습니다.', QMessageBox.Yes) else: self.numROW = len(DF) self.numCOL = len(DF.columns) # ROW와 COLUMN 수 지정 self.c_code_table.setRowCount(self.numROW) self.c_code_table.setColumnCount(self.numCOL) # COLUMN 지정 self.c_code_table.setHorizontalHeaderLabels(DF.columns.tolist()) # 요소 넣기 self.v_list = DF.values.tolist() for m, n in zip(self.v_list, range(self.numROW)): for a, b in zip(range(self.numCOL), m): self.c_code_table.setItem(n, a, QTableWidgetItem(b)) # c_code 의 입력 button def tab1_ccode_btn2(self): tab1_btn2_play = InputDialog() tab1_btn2_play.exec_() # 검색기능 def move_toQ(self): # 더블 클릭된 행을 불러와서 각각 이름을 선언한다. row = self.c_code_table.currentRow() self.tb_code = self.c_code_table.item(row, 0).text() self.tb_comp = self.c_code_table.item(row, 1).text() self.tb_name = self.c_code_table.item(row, 2).text() # N NUMBER 추출 mkfunc = ef.excel_pd() self.Nnumber = mkfunc.MK_DB() self.Nrow = len(self.Nnumber) last = self.Nnumber[self.Nnumber.columns[0]][-1:].values.tolist() # 마지막 N 번호 다음 번호를 붙일 땐 +1 해서 사용 self.last = int(last[0][6:]) self.N = str(self.last + 1) Message1 = 'C-CODE: ' + self.tb_code Message2 = 'COMPANY: ' + self.tb_comp Message3 = 'NAME: ' + self.tb_name Message4 = 'Quotation Number: ' + self.N self.Quotation_label1.setText(Message1) self.Quotation_label2.setText(Message2) self.Quotation_label3.setText(Message3) self.Quotation_number.setText(Message4) # tab1의 Quotation def Quotation(self): self.Quotation_1 = QGroupBox('Quotation') self.Quotation_1.setStyleSheet('border-style: solid;' 'border-width: 2px;' 'border-color: #9E9E9E;' 'border-radius: 3px') self.Quotation_1.setMaximumSize(700, 100) self.tab1.layout.addWidget(self.Quotation_1, 0, 1) self.Quotation_label1 = QLabel('C-CODE: ') self.Quotation_label2 = QLabel('C-COMP: ') self.Quotation_label3 = QLabel('C-NAME: ') self.Quotation_number = QLabel('Quotation Number: ') layout = QGridLayout() layout.addWidget(self.Quotation_number, 0, 1) layout.addWidget(self.Quotation_label1, 1, 0) layout.addWidget(self.Quotation_label2, 1, 1) layout.addWidget(self.Quotation_label3, 1, 2) self.Quotation_1.setLayout(layout)
class AutomaticRL(QWidget): """ This class represents a widget for the Q-learning mode. It consists of play/step buttons, labels for visualization of Q-values for hovered cell. It uses instance of `logic.gameLogic.GameLogic` as an environment for RL agent. """ made_step_signal = pyqtSignal() user_interacted = pyqtSignal() def _init_ui(self): self._command_layout = QVBoxLayout() # Text label self._description_label = QLabel() self._description_label.setFont(QFont("Pacifico", 14, QFont.Normal)) self._description_label.setAlignment(Qt.AlignCenter) self._description_label.setText(settings.Q_LEARNING_DESCRIPTION) self._description_label.setSizePolicy( QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum)) self._description_label.setFixedSize( settings.AUTO_RL_DESCRIPTION_NAILS) self._command_layout.addWidget(self._description_label, 0, Qt.AlignHCenter) # q-values visualization self._qlabels = QLabelsVisualization(self._q_learning) self._command_layout.addWidget(self._qlabels, 0, Qt.AlignHCenter) # rl buttons self._buttons = QWidget() self._buttons_layout = QHBoxLayout() self._play_button = Button(settings.PLAY_BUTTON_IMAGE) self._next_step_button = Button(settings.STEP_BUTTON_IMAGE) self._buttons_layout.addWidget(self._play_button) self._buttons_layout.addWidget(self._next_step_button) self._buttons.setLayout(self._buttons_layout) self._buttons.setFixedWidth(settings.BUTTONS_NAILS_WIDTH) self._command_layout.addWidget(self._buttons, 0, Qt.AlignHCenter) self.setLayout(self._command_layout) def __init__(self, game_screen: GameScreen): """ Constructs an AutomaticRL widget. AutomaticRL widget needs `game_screen` to update information in cells about Q-values. Args: game_screen - GameScreen instance. """ super().__init__() self._game_screen = game_screen self._params = GameParams(Modes.AUTOMATICRL, game_height=settings.GAME_HEIGHT, game_width=settings.GAME_WIDTH, lava_random=settings.AUTOMATIC_LAVA_RANDOM, lava_reward=settings.LAVA_REWARD, lava_is_terminal=True, green_random=settings.GREEN_RANDOM, green_reward=settings.GREEN_REWARD, green_is_terminal=True) self._logic = GameLogic(self._params) self._q_learning = QLearning(self._logic) self._playing = False self._timer = QTimer() self._timer.timeout.connect(self._next_step) self._init_ui() # connecting player buttons self._play_button.clicked.connect(self._play) self._next_step_button.clicked.connect(self._next_step_click) self.made_step_signal.connect(game_screen.update_screen) def enter_mode(self): """Replaces game screen logic with RL environment and resets cells.""" self._game_screen.change_logic(self._logic) self.init_cells() def exit_mode(self): """Stops playing. Used when current mode is being changed.""" if self._playing: self._playing = False self._timer.stop() return def init_cells(self): """ Reinitializes self if cells have changed. Internally does two things: 1. Connects signals to new cells; 2. Resets values for each cell. #TODO: if graphic scene will be switched without scene reinitialization (see issue #44), this function will not be required. """ # connecting mouse hover from cells to our q-values visualization for cell in self._game_screen.cells: cell.enter_signal.connect(self._qlabels.cell_entered) cell.leave_signal.connect(self._qlabels.cell_left) # initialize values for i in range(self._logic.game_size[0]): for j in range(self._logic.game_size[1]): self._game_screen.set_cell_value(i, j, 0.) for pos in self._logic.terminal_cells: reward = self._logic.game_board.cell_reward(pos) self._game_screen.set_cell_value(pos[0], pos[1], reward) def _next_step_click(self): self.user_interacted.emit() self._stop_playing() self._next_step() def _next_step(self): if self._logic.done: self._q_learning.reset() else: old_x, old_y = self._logic.scrat_position # pylint: disable=W0612 reward, done, info = self._q_learning.step() new_value = max(self._q_learning.get_q_values((old_x, old_y))) # updating value on the cell in game field self._game_screen.set_cell_value(old_x, old_y, new_value) # updating q-visualization self._qlabels.values_updates(old_x, old_y) self.made_step_signal.emit() def _stop_playing(self): if self._playing: self._playing = False self._timer.stop() self._play_button.updatePic(settings.PLAY_BUTTON_IMAGE) def reset(self): """Reset game state and send signal that state changed""" self._stop_playing() self._q_learning.reset() self.made_step_signal.emit() def full_reset(self): """Reinitialize logic randomly""" self._stop_playing() self._logic.full_reset() self._q_learning.reset_q() self.init_cells() self.made_step_signal.emit() def _play(self): self.user_interacted.emit() if self._playing: self._playing = False self._timer.stop() self._play_button.updatePic(settings.PLAY_BUTTON_IMAGE) return self._playing = True self._timer.start(settings.Q_LEARNING_PLAY_SPEED) self._play_button.updatePic(settings.STOP_BUTTON_IMAGE)
SIMULATE_WINDOWS = True if SIMULATE_WINDOWS: import ntpath os.sep = ntpath.sep os.path = ntpath buttons = [] buttons.append(FilePathButton(r"c:\some\long\path\to\the\file.txt", " (Don't abbreviate this suffix)")) buttons.append(FilePathButton(r"file.txt", " (some suffix)")) buttons.append(FilePathButton("\\some\\long\\path\\to\\the\\", " (some suffix)")) else: buttons = [] buttons.append(FilePathButton("/some/long/path/to/the/file.txt", " (Don't abbreviate this suffix)")) buttons.append(FilePathButton("file.txt", " (some suffix)")) buttons.append(FilePathButton("/some/long/path/to/the/", " (some suffix)")) layout = QVBoxLayout() for button in buttons: # Typically, the button chooses a minimum size that is appropriate for its shortest possible text # But for this little test we force an even smaller minimum size so we can test multiple paths at once... button.setMinimumWidth(10) layout.addWidget(button) widget = QWidget() widget.setLayout(layout) widget.show() app.exec_()
def set_layout(self, file_name_tuple): file_type, file_usage = file_name_tuple file_name = '{}_{}.txt'.format(file_type, file_usage) vertical_box_layout = QVBoxLayout() vertical_box_layout.setContentsMargins(0, 0, 0, 0) label = QLabel(' '.join(file_name_tuple)) label.setAlignment(Qt.AlignCenter) vertical_box_layout.addWidget(label) if file_type == 'complete': with open(file_name, 'a+b') as f: f.seek(0) achievement_points = calculate_points(parser(f.read())) self.text_browser = QTextBrowser(maximumHeight=27) self.text_browser.setAlignment(Qt.AlignCenter) self.text_browser.setText( 'achievement points: {}'.format(achievement_points)) vertical_box_layout.addWidget(self.text_browser) self.list_widget = ListWidget(file_name, 'recent') vertical_box_layout.addWidget(self.list_widget) button_delete = ButtonDelete(self, file_name) vertical_box_layout.addWidget(button_delete) else: self.list_widget = ListWidget(file_name) vertical_box_layout.addWidget(self.list_widget) points_text_edit = None if file_usage == 'note': button_delete = ButtonDelete(self, file_name) vertical_box_layout.addWidget(button_delete) task_text_edit = QTextEdit(maximumHeight=27) task_text_edit.setPlaceholderText('note') vertical_box_layout.addWidget(task_text_edit) else: horizontal_box_layout = QHBoxLayout() horizontal_box_layout.setContentsMargins(0, 0, 0, 0) button_done = ButtonDone(self, file_name) horizontal_box_layout.addWidget(button_done) button_delete = ButtonDelete(self, file_name) horizontal_box_layout.addWidget(button_delete) widget = QWidget(maximumHeight=27) widget.setContentsMargins(0, 0, 0, 0) widget.setLayout(horizontal_box_layout) vertical_box_layout.addWidget(widget) horizontal_box_layout = QHBoxLayout() horizontal_box_layout.setContentsMargins(0, 0, 0, 0) task_text_edit = QTextEdit(maximumHeight=27) task_text_edit.setPlaceholderText('task') horizontal_box_layout.addWidget(task_text_edit) points_text_edit = QTextEdit(maximumHeight=27) points_text_edit.setPlaceholderText('points') points_text_edit.setText('1') horizontal_box_layout.addWidget(points_text_edit) widget = QWidget(maximumHeight=27) widget.setContentsMargins(0, 0, 0, 0) widget.setLayout(horizontal_box_layout) vertical_box_layout.addWidget(widget) button_add = ButtonAdd(self.list_widget, task_text_edit, file_name, points_text_edit) vertical_box_layout.addWidget(button_add) self.setLayout(vertical_box_layout)
class App(QFrame): def __init__(self): super().__init__() self.setWindowTitle('Navegador Web') self.CrearApp() self.setBaseSize(1366, 768) def CrearApp(self): # CreateApp() self.layout = QVBoxLayout() self.layout.setSpacing(0) self.layout.setContentsMargins(0, 0, 0, 0) #- crear pestañas self.tabbar = QTabBar(movable=True, tabsClosable=True) self.tabbar.tabCloseRequested.connect(self.CerrarTab) self.tabbar.tabBarClicked.connect(self.CambiarTab) self.tabbar.setCurrentIndex(0) #- seguimiento de pestañas self.cuentaTab = 0 #tabCount self.tabs = [] #- crear barra de direcciones self.Toolbar = QWidget() self.ToolbarLayout = QHBoxLayout() self.addressbar = BarraDirecciones() self.Toolbar.setLayout(self.ToolbarLayout) self.ToolbarLayout.addWidget(self.addressbar) #- boton nueva pestaña self.botonAgregarTab = QPushButton('+') # AddTabButton self.addressbar.returnPressed.connect(self.IrA) self.botonAgregarTab.clicked.connect(self.AgregarTab) self.ToolbarLayout.addWidget(self.botonAgregarTab) #- establecer vista principal self.contenedor = QWidget() # container self.contenedor.layout = QStackedLayout() self.contenedor.setLayout(self.contenedor.layout) self.layout.addWidget(self.tabbar) self.layout.addWidget(self.Toolbar) self.layout.addWidget(self.contenedor) self.setLayout(self.layout) self.AgregarTab() self.show() def CerrarTab(self, i): # CloseTab() self.tabbar.removeTab(i) def AgregarTab(self): # AddTab i = self.cuentaTab self.tabs.append(QWidget()) self.tabs[i].layout = QVBoxLayout() self.tabs[i].setObjectName('pestaña' + str(i)) #- abrir webview self.tabs[i].content = QWebEngineView() self.tabs[i].content.load(QUrl.fromUserInput('http://google.com')) #- agregar webview al diseño de pestañas (layout) self.tabs[i].layout.addWidget(self.tabs[i].content) #- establecer pestaña top de [] al diseño (layout) self.tabs[i].setLayout(self.tabs[i].layout) #- agregar pestaña al top al widget apilado self.contenedor.layout.addWidget(self.tabs[i]) self.contenedor.layout.setCurrentWidget(self.tabs[i]) #- establecer la pestaña al tope de la pantalla self.tabbar.addTab('Nueva pestaña') self.tabbar.setTabData(i, 'tab' + str(i)) self.tabbar.setCurrentIndex(i) self.cuentaTab += 1 def CambiarTab(self, i): tab_dato = self.tabbar.tabData(i) print('tab:', tab_dato) tab_contenido = self.findChild(QWidget, tab_dato) self.contenedor.layout.setCurrentWidget(tab_contenido) # self.contenedor.layout.setCurrentWidget(self.tabs[i]) def IrA(self): text = self.addressbar.text() print(text) i = self.tabbar.currentIndex() tab = self.tabbar.tabData(i) wv = self.findChild(QWidget, tab).content if 'http' not in text: if '.' not in text: url = 'https://google.com/#q=' + text else: url = 'http://' + text else: url = text wv.load(QUrl.fromUserInput(url))
class MyGraphWindow(QMainWindow): ALPHA_OTHER = 0.2 #lasso非選択データの透明度 PICKER = 5 #lineをクリックしたときに取得できるための領域 mycolors = MyColors() #memory the color to use for self.plot method. def __init__(self, fig=None, geo=None, title='temp'): super().__init__() #mutableなオブジェクトをデフォルトに指定するとまずいのでこのように書く if fig == None: self.fig = Figure(figsize=(6, 6), dpi=100) else: self.fig = fig if geo == None: self.geo = QRect(30, 30, 500, 500) else: self.geo = geo self.canvas = FigureCanvas(self.fig) self.canvas.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self.navi_toolbar = NavigationToolbar(self.canvas, self) self.lassoAction = QAction('lasso', self.canvas) self.pointerAction = QAction('pointer', self.canvas) self.lineAction = QAction('line', self.canvas) self.lassoAction.setCheckable(True) self.pointerAction.setCheckable(True) self.lineAction.setCheckable(True) self.navi_toolbar.addAction(self.lassoAction) self.navi_toolbar.addAction(self.pointerAction) self.navi_toolbar.addAction(self.lineAction) self.lassoAction.triggered.connect(self.lassoTriggered) self.pointerAction.triggered.connect(self.pointerTriggered) self.lineAction.triggered.connect(self.lineTriggered) self.lassoTarget = None #選択対象 lasso時はcilickでalphaを下げる self.selectedLine = None #選択中の点をself.lassoTargetの上にプロットする self.pre_alpha = 1 #alphaを下げる前の値 self.pre_settings = None #markerの色とサイズselectedLineをplotする時に使う #setTargetで指定したlineの点とそこからlassoで選ばれたindexを保存 self.xys = None #numpy.array 列数2の行列 self.selectedIndices = set() self.unselectedIndices = set() #クリックされたlineを記憶しておいてgetLineで参照を渡す self.line = None self.pre_width = 0 #太くした後元に戻すのに使う #点の座標を表示する self.pointer = MyPointer() self.pointer.deactivate() self.vbl = QVBoxLayout() self.vbl.addWidget(self.navi_toolbar) self.vbl.addWidget(self.canvas) self.vbl.addWidget(self.pointer) self.frontPanel = QWidget() self.frontPanel.setLayout(self.vbl) self.setCentralWidget(self.frontPanel) self.setGeometry(self.geo) self.setWindowTitle(title) self.show() def __reduce_ex__(self, proto): #pickleのためのメソッド QMainWindowはそのままpickleできないことに注意 return geneMyGraph, (self.fig, self.geometry(), self.windowTitle()) def getSelected(self): points = self.xys[list(self.selectedIndices)] return points def getUnSelected(self): points = self.xys[list(self.unselectedIndices)] return points def getLine(self): return self.line def plot(self, *args, **kwargs): #pickerはlineの選択に使うので必要 kwargs = self._addPickerToValue(kwargs) kwargs = self._addColorToValue(kwargs) try: #axが指定されていたらそのaxに対して描画を行う axが無いまたはaxオブジェクト以外が指定されていると引数にaxが無い状態で次 ax = kwargs.pop('ax') ax.plot(*args, **kwargs) except: #無ければself.figの最初のaxに描画 それもなければ新たにaxを追加して描画 try: ax = self.fig.get_axes()[0] ax.plot(*args, **kwargs) except: ax = self.fig.add_subplot(111) ax.plot(*args, **kwargs) self.canvas.draw() def _addPickerToValue(self, kwargs): #pickerが無いとlassoで選択できないのでユーザーが引数にpickerを指定しなかった場合はpickerを加える if 'picker' in kwargs.keys(): return kwargs else: kwargs['picker'] = self.PICKER return kwargs def _addColorToValue(self, kwargs): #If color is in the kwargs use it. Otherwise get a color from self.mycolors and use it. if not 'color' in kwargs.keys(): color = self.mycolors.get_color() kwargs['color'] = color return kwargs def lassoTriggered(self): if self.lassoAction.isChecked() == True: #pointer Off lasso On if self.pointerAction.isChecked() == True: self.pointerAction.setChecked(False) self.pointer.deactivate() if self.lineAction.isChecked() == True: self.lineAction.setChecked(False) self.removeLine() self.setLasso() else: self.removeLasso() def pointerTriggered(self): if self.pointerAction.isChecked() == True: #pointer on lasso off if self.lassoAction.isChecked() == True: self.lassoAction.setChecked(False) self.removeLasso() if self.lineAction.isChecked() == True: self.lineAction.setChecked(False) self.removeLine() self.pointer.activate(self.canvas) else: self.pointer.deactivate() def lineTriggered(self): if self.lineAction.isChecked() == True: #他をoff if self.lassoAction.isChecked() == True: self.lassoAction.setChecked(False) self.removeLasso() if self.pointerAction.isChecked() == True: self.pointerAction.setChecked(False) self.pointer.deactivate() self.setLine() else: self.removeLine() def setLine(self): self.linepick = self.canvas.mpl_connect('pick_event', self.highlightLine) def removeLine(self): try: self.canvas.mpl_disconnect(self.linepick) if not self.line == None: #選択されていたものを元に戻す self.line.set_linewidth(self.pre_width) self.canvas.draw() self.line = None self.pre_width = 0 except: print('line is still not sellected') def highlightLine(self, event): #選択中のlineの輪郭を太くする if not len(event.ind): return True if not self.line == None: #初回のclickでない場合は先に選択されていたものを元に戻す self.line.set_linewidth(self.pre_width) #plotの設定を保存 self.line = event.artist self.pre_width = self.line.get_linewidth() #alphaの調整とselectedLineの描画 まだinvisible データの取得 self.line.set_linewidth(self.pre_width * 5) self.canvas.draw() def setLasso(self): self.pick = self.canvas.mpl_connect('pick_event', self.setTarget) def removeLasso(self): try: self.canvas.mpl_disconnect(self.pick) del self.lasso if not self.lassoTarget == None: #先に選択されていたものを元に戻す self.lassoTarget.set_alpha(self.pre_alpha) self.selectedLine.remove() self.canvas.draw() #多分必要ないが念のために初期化 self.lassoTarget = None self.selectedLine = None self.pre_alpha = 1 self.pre_settings = None self.xys = None self.selectedIndices = set() self.unselectedIndices = set() except: print('Lasso is still not setted') def setTarget(self, event): #lassoの対象をclickから決定する if not len(event.ind): return True if not self.lassoTarget == None: #初回のclickでない場合は先に選択されていたものを元に戻す self.lassoTarget.set_alpha(self.pre_alpha) try: #あったら掃除 多分いつもある self.selectedLine.remove() except: pass self.selectedIndices = set() self.unselectedIndices = set() #plotの設定を保存 self.lassoTarget = event.artist self.pre_alpha = self.lassoTarget.get_alpha() self.pre_settings = self.getSettings(self.lassoTarget) #alphaの調整とselectedLineの描画 まだinvisible データの取得 self.lassoTarget.set_alpha(self.ALPHA_OTHER) self.selectedLine, = self.lassoTarget.axes.plot([], [], visible=False, linestyle='None', **self.pre_settings) self.lasso = LassoSelector(self.lassoTarget.axes, onselect=self.onselect) self.xys = np.array([[x, y] for x, y in zip( self.lassoTarget.get_xdata(), self.lassoTarget.get_ydata())]) self.canvas.draw() def getSettings(self, line): settings = { 'color': line.get_color(), 'marker': line.get_marker(), 'markersize': line.get_markersize() } return settings def onselect(self, verts): path = Path(verts) try: selected_ind = set( np.nonzero([path.contains_point(xy) for xy in self.xys])[0]) all_ind = set(range(self.xys.shape[0])) unselected_ind = all_ind - selected_ind except: print('canot determin selected points') #選択される度にselcectedlineに追加 self.selectedIndices = self.selectedIndices | selected_ind self.unselectedIndices = self.unselectedIndices | unselected_ind self.selectedLine.set_visible(True) points = self.xys[list(self.selectedIndices)] self.selectedLine.set_data(points[:, 0], points[:, 1]) self.canvas.draw()
def confirm(self, message, title): label = WWLabel(message) vbox = QVBoxLayout() vbox.addWidget(label) self.exec_layout(vbox, title)
class pca_viewer(QMainWindow): def __init__(self, pca_data): super().__init__() self.init_window() self.define_widgets() self.position_widgets() self.plots_active = True self.update_data(pca_data) self.connect_event_handlers() def init_window(self): self.setGeometry(500, 500, 1200, 900) #xPos, yPos, width, heigth self.center() #center function is defined below self.setWindowTitle('PCA viewer') self.container0 = QWidget(self) self.setCentralWidget(self.container0) self.grid_container = QGridLayout() self.container0.setLayout(self.grid_container) def define_widgets(self): self.select_column_combo = QComboBox() self.scores_plot = plot_canvas( plot_title='Scores plot', x_axis_title='PC score') self.loadings_plot = plot_canvas( plot_title='Loadings plot', x_axis_title='wavenumber [cm-1]') self.explained_variance_plot = plot_canvas( plot_title='Explained variance', x_axis_title='PC number') self.reconstructed_spectra_plot = plot_canvas( plot_title='Reconstructed data', x_axis_title='wavenumber [cm-1]') self.x_coord_label = QLabel('x') self.x_coord_combo = QComboBox() self.y_coord_label = QLabel('y') self.y_coord_combo = QComboBox() self.z_coord_label = QLabel('z') self.z_coord_combo = QComboBox() self.sample_label = QLabel('Sample') self.sample_combo = QComboBox() self.pcs_for_reconstruction_label = QLabel('PCs for reconstruction') self.pcs_for_reconstruction_combo = QComboBox() self.first_pc_scores_combo = QComboBox() self.second_pc_scores_combo = QComboBox() self.pc_loadings_combo = QComboBox() def position_widgets(self): self.pc_selection_scores_layout = QHBoxLayout() self.pc_selection_scores_layout.addWidget(self.first_pc_scores_combo) self.pc_selection_scores_layout.addWidget(self.second_pc_scores_combo) self.coord_combos_layout = QHBoxLayout() self.coord_combos_layout.addWidget(self.x_coord_label) self.coord_combos_layout.addWidget(self.x_coord_combo) self.coord_combos_layout.addWidget(self.y_coord_label) self.coord_combos_layout.addWidget(self.y_coord_combo) self.coord_combos_layout.addWidget(self.z_coord_label) self.coord_combos_layout.addWidget(self.z_coord_combo) self.coord_combos_layout.addWidget(self.sample_label) self.coord_combos_layout.addWidget(self.sample_combo) self.coord_combos_layout.addWidget(self.pcs_for_reconstruction_label) self.coord_combos_layout.addWidget(self.pcs_for_reconstruction_combo) self.coord_combos_layout.addStretch(1) self.reconstructed_spectra_layout = QVBoxLayout() self.reconstructed_spectra_layout.addWidget( self.reconstructed_spectra_plot) self.reconstructed_spectra_layout.addLayout(self.coord_combos_layout) self.grid_container.addLayout(self.pc_selection_scores_layout, *(0, 0), 1, 1) self.grid_container.addWidget(self.pc_loadings_combo, *(0, 1), 1, 1) self.grid_container.addWidget(self.scores_plot, *(1, 0), 1, 1) self.grid_container.addWidget(self.loadings_plot, *(1, 1), 1, 1) self.grid_container.addWidget(self.explained_variance_plot, *(2, 0), 1, 1) self.grid_container.addLayout(self.reconstructed_spectra_layout, *(2, 1), 1, 1) def connect_event_handlers(self): self.first_pc_scores_combo.currentIndexChanged.connect( self.update_plots) self.second_pc_scores_combo.currentIndexChanged.connect( self.update_plots) self.pc_loadings_combo.currentIndexChanged.connect(self.update_plots) self.x_coord_combo.currentIndexChanged.connect(self.update_plots) self.y_coord_combo.currentIndexChanged.connect(self.update_plots) self.z_coord_combo.currentIndexChanged.connect(self.update_plots) self.sample_combo.currentIndexChanged.connect(self.update_plots) self.pcs_for_reconstruction_combo.currentIndexChanged.connect( self.update_plots) def update_data(self, pca_data): self.input_datatype = type(pca_data) self.input_data = pca_data if type(pca_data) in [spectroscopy_data, raman_image]: self.pcr_object = self.input_data.pca else: # is assumed to be instance of principal_component_regression self.pcr_object = self.input_data self.init_combo_boxes() self.update_plots() def init_combo_boxes(self): # Disables the update_spectra_plots function. self.plots_active = False self.first_pc_scores_combo.clear() self.first_pc_scores_combo.addItems( self.pcr_object.pca_scores.columns.to_numpy().astype(str)) self.first_pc_scores_combo.setCurrentIndex(0) self.second_pc_scores_combo.clear() self.second_pc_scores_combo.addItems( self.pcr_object.pca_scores.columns.to_numpy().astype(str)) self.second_pc_scores_combo.setCurrentIndex(1) self.pc_loadings_combo.clear() self.pc_loadings_combo.addItems( self.pcr_object.pca_loadings.columns.to_numpy().astype(str)) self.pc_loadings_combo.setCurrentIndex(0) self.sample_combo.clear() self.x_coord_combo.clear() self.y_coord_combo.clear() self.z_coord_combo.clear() if self.input_datatype is raman_image: self.x_coord_combo.addItems( np.char.mod('%s',np.around( self.input_data.get_coord_values( 'real',axis = 'x'),1))) self.y_coord_combo.addItems( np.char.mod('%s',np.around( self.input_data.get_coord_values( 'real',axis = 'y'),1))) self.z_coord_combo.addItems( np.char.mod('%s',np.around( self.input_data.get_coord_values( 'real',axis = 'z'),1))) if len(self.input_data.get_coord_values('coded',axis = 'x')) > 1: self.x_coord_combo.setEnabled(True) else: self.x_coord_combo.setEnabled(False) if len(self.input_data.get_coord_values('coded',axis = 'y')) > 1: self.y_coord_combo.setEnabled(True) else: self.y_coord_combo.setEnabled(False) if len(self.input_data.get_coord_values('coded',axis = 'z')) > 1: self.z_coord_combo.setEnabled(True) else: self.z_coord_combo.setEnabled(False) self.sample_combo.setEnabled(False) else: self.x_coord_combo.setEnabled(False) self.y_coord_combo.setEnabled(False) self.z_coord_combo.setEnabled(False) self.sample_combo.setEnabled(True) self.sample_combo.addItems( self.pcr_object.pca_scores.index.values.astype(str)) self.sample_combo.setCurrentIndex(0) self.pcs_for_reconstruction_combo.clear() self.pcs_for_reconstruction_combo.addItems( self.pcr_object.pca_scores.columns.to_numpy().astype(str)) self.pcs_for_reconstruction_combo.setCurrentIndex(0) # Now the update_spectra_plots function will do something. self.plots_active = True def update_plots(self): if self.plots_active is False: return self.scores_plot.axes.clear() self.loadings_plot.axes.clear() self.explained_variance_plot.axes.clear() self.scores_plot.plot( self.pcr_object.pca_scores[ int(self.first_pc_scores_combo.currentText())], self.pcr_object.pca_scores[ int(self.second_pc_scores_combo.currentText())], pen='b', mode='scatter') # self.scores_plot.axes.axhline(0, ls='dotted') # self.scores_plot.axes.axvline(0, ls='dotted') self.loadings_plot.plot( self.pcr_object.pca_loadings.index, self.pcr_object.pca_loadings[ int(self.pc_loadings_combo.currentText())], pen='b', mode='line') x_explained_variance = np.insert( self.pcr_object.pca_explained_variance.index.values, 0, 0) y_explained_variance = np.insert( self.pcr_object.pca_explained_variance['cum'].values, 0, 0) for ii, jj in zip(x_explained_variance[1:], y_explained_variance[1:]): self.explained_variance_plot.axes.annotate( str(round(jj, 3)), xy=(ii, 0.05)) self.explained_variance_plot.plot( x_explained_variance, y_explained_variance, pen='b', mode='line') reconstruction_pca_components = int( self.pcs_for_reconstruction_combo.currentText()) self.reconstructed_data = self.pcr_object.reconstruct_data( used_pcs=reconstruction_pca_components) if self.input_datatype is raman_image: selected_spectrum_index = ( self.get_coord( 'coded', coord_value=float(self.x_coord_combo.currentText())), self.get_coord( 'coded', coord_value=float(self.y_coord_combo.currentText())), self.get_coord( 'coded', coord_value=float(self.z_coord_combo.currentText()))) else: selected_spectrum_index = self.sample_combo.currentText() self.reconstructed_spectra_plot.axes.clear() self.reconstructed_spectra_plot.plot( self.pcr_object.x.columns, self.pcr_object.reconstruct_input().loc[ selected_spectrum_index, :], pen='k') self.reconstructed_spectra_plot.plot( self.reconstructed_data.columns, self.reconstructed_data.loc[ selected_spectrum_index, :], pen='r') def center(self): # centers object on screen qr = self.frameGeometry() cp = QDesktopWidget().availableGeometry().center() qr.moveCenter(cp) self.move(qr.topLeft()) def get_coord(self, value_sort, axis='x', coord_value=None, mode='raw_data'): if coord_value is not None: if value_sort == 'coded': return_value = round( coord_value*self.input_data.coord_conversion_factor) else: return_value = (coord_value/ self.input_data.coord_conversion_factor) else: if mode == 'raw_data': if axis == 'x': return_value = float(self.x_coord_combo.currentText()) elif axis == 'y': return_value = float(self.y_coord_combo.currentText()) elif axis == 'z': return_value = float(self.z_coord_combo.currentText()) elif mode == 'processed': if axis == 'x': return_value = float( self.x_coord_combo_edited.currentText()) elif axis == 'y': return_value = float( self.y_coord_combo_edited.currentText()) elif axis == 'z': return_value = float( self.z_coord_combo_edited.currentText()) if value_sort == 'coded': return_value = round( return_value*self.input_data.coord_conversion_factor) return return_value
def __init__(self, config: 'SimpleConfig', exctype, value, tb): BaseCrashReporter.__init__(self, exctype, value, tb) self.network = Network.get_instance() self.config = config QWidget.__init__(self) self.setWindowTitle('Electrum - ' + _('An Error Occurred')) self.setMinimumSize(600, 300) Logger.__init__(self) main_box = QVBoxLayout() heading = QLabel('<h2>' + BaseCrashReporter.CRASH_TITLE + '</h2>') main_box.addWidget(heading) main_box.addWidget(QLabel(BaseCrashReporter.CRASH_MESSAGE)) main_box.addWidget(QLabel(BaseCrashReporter.REQUEST_HELP_MESSAGE)) collapse_info = QPushButton(_("Show report contents")) collapse_info.clicked.connect( lambda: self.msg_box(QMessageBox.NoIcon, self, _("Report contents"), self.get_report_string(), rich_text=True)) main_box.addWidget(collapse_info) main_box.addWidget(QLabel(BaseCrashReporter.DESCRIBE_ERROR_MESSAGE)) self.description_textfield = QTextEdit() self.description_textfield.setFixedHeight(50) self.description_textfield.setPlaceholderText( self.USER_COMMENT_PLACEHOLDER) main_box.addWidget(self.description_textfield) main_box.addWidget(QLabel(BaseCrashReporter.ASK_CONFIRM_SEND)) buttons = QHBoxLayout() report_button = QPushButton(_('Send Bug Report')) report_button.clicked.connect(self.send_report) report_button.setIcon(read_QIcon("tab_send.png")) buttons.addWidget(report_button) never_button = QPushButton(_('Never')) never_button.clicked.connect(self.show_never) buttons.addWidget(never_button) close_button = QPushButton(_('Not Now')) close_button.clicked.connect(self.close) buttons.addWidget(close_button) main_box.addLayout(buttons) self.setLayout(main_box) self.show()
def derivation_and_script_type_gui_specific_dialog( self, *, title: str, message1: str, choices: List[Tuple[str, str, str]], hide_choices: bool = False, message2: str, test_text: Callable[[str], int], run_next, default_choice_idx: int = 0, get_account_xpub=None, ) -> Tuple[str, str]: vbox = QVBoxLayout() if get_account_xpub: button = QPushButton(_("Detect Existing Accounts")) def on_account_select(account): script_type = account["script_type"] if script_type == "p2pkh": script_type = "standard" button_index = c_values.index(script_type) button = clayout.group.buttons()[button_index] button.setChecked(True) line.setText(account["derivation_path"]) button.clicked.connect(lambda: Bip39RecoveryDialog( self, get_account_xpub, on_account_select)) vbox.addWidget(button, alignment=Qt.AlignLeft) vbox.addWidget(QLabel(_("Or"))) c_values = [x[0] for x in choices] c_titles = [x[1] for x in choices] c_default_text = [x[2] for x in choices] def on_choice_click(clayout): idx = clayout.selected_index() line.setText(c_default_text[idx]) clayout = ChoicesLayout(message1, c_titles, on_choice_click, checked_index=default_choice_idx) if not hide_choices: vbox.addLayout(clayout.layout()) vbox.addWidget(WWLabel(message2)) line = QLineEdit() def on_text_change(text): self.next_button.setEnabled(test_text(text)) line.textEdited.connect(on_text_change) on_choice_click(clayout) # set default text for "line" vbox.addWidget(line) self.exec_layout(vbox, title) choice = c_values[clayout.selected_index()] return str(line.text()), choice
class WaterfallPlotter(QWidget): generated_rectangles_signal = QtCore.pyqtSignal(list) #send list of rects for data display in tree def __init__(self,parent): super(WaterfallPlotter,self).__init__(parent) self.figure = plt.figure() self.canvas = FigureCanvas(self.figure) self.toolbar = NavigationToolbar(self.canvas,self) self.btn_plot = QPushButton('Default Plot') self.btn_plot.clicked.connect(self.default_plot) self.layout = QVBoxLayout() self.layout.addWidget(self.toolbar) self.layout.addWidget(self.canvas) self.layout.addWidget(self.btn_plot) self.setLayout(self.layout) def on_waterfall_data_signal(self,signal): self.waterfall_data = signal['waterfall_data'] #pandas dataframe self.btn_plot.setEnabled(True) def on_general_settings_signal(self,signal): try: hasattr(self,'ax') self.ax.set_title(signal[0]) self.ax.set_xlabel(signal[1]) self.ax.set_ylabel(signal[2]) self.canvas.draw() except Exception as e: print(e) def default_plot(self): ''' Plot waterfall data ''' self.figure.clear() self.rect_locations = np.arange(len(self.waterfall_data['Best response percent change'])) self.ax = self.figure.add_subplot(111) self.ax.axhline(y=20, linestyle='--', c='k', alpha=0.5, lw=2.0, label='twenty_percent') self.ax.axhline(y=-30, linestyle='--', c='k', alpha=0.5, lw=2.0, label='thirty_percent') self.ax.axhline(y=0, c='k', alpha=1, lw=2.0, label='zero_percent') self.ax.grid(color = 'k', axis = 'y', alpha=0.25) self.rects = self.ax.bar(self.rect_locations,self.waterfall_data['Best response percent change']) self.auto_label_responses(self.ax, self.rects, self.waterfall_data) #self.plot_table() self.canvas.draw() self.ax.hold(False) #rewrite the plot when plot() called self.generated_rectangles_signal.emit([self.rects]) def plot_table(self): rows = ['%s' % x for x in self.waterfall_data.keys()] rows = rows[4:] #skip first three, they are the 4 standard headers, rest are table rows columns = self.waterfall_data['Patient number'] #patient numbers cell_text = [] for row in rows: cell_text_temp = [] for col in range(len(columns)): cell_text_temp.append(self.waterfall_data[row][col]) cell_text.append(cell_text_temp) the_table = plt.table(cellText=cell_text, rowLabels=rows, colLabels=columns, loc='bottom', cellLoc='center') plt.subplots_adjust(bottom=0.15,left=0.5) self.ax.set_xlim(-0.5,len(columns)-0.5) plt.tick_params( axis='x', # changes apply to the x-axis which='both', # both major and minor ticks are affected bottom='off', # ticks along the bottom edge are off top='off', # ticks along the top edge are off labelbottom='off' ) # labels along the bottom edge are off def update_plot(self): ''' TODO ''' pass def auto_label_responses(self, ax, rects, waterfall_data): '''Add labels above/below bars''' i = 0 for rect in rects: height = rect.get_height() if height >= 0: valign = 'bottom' else: valign = 'top' ax.text(rect.get_x() + rect.get_width()/2., height, '%s' % waterfall_data['Overall response'][i], ha='center', va=valign) i+=1
def select_storage( self, path, get_wallet_from_daemon) -> Tuple[str, Optional[WalletStorage]]: vbox = QVBoxLayout() hbox = QHBoxLayout() hbox.addWidget(QLabel(_('Wallet') + ':')) name_e = QLineEdit() hbox.addWidget(name_e) button = QPushButton(_('Choose...')) hbox.addWidget(button) vbox.addLayout(hbox) msg_label = WWLabel('') vbox.addWidget(msg_label) hbox2 = QHBoxLayout() pw_e = PasswordLineEdit('', self) pw_e.setFixedWidth(17 * char_width_in_lineedit()) pw_label = QLabel(_('Password') + ':') hbox2.addWidget(pw_label) hbox2.addWidget(pw_e) hbox2.addStretch() vbox.addLayout(hbox2) vbox.addSpacing(50) vbox_create_new = QVBoxLayout() vbox_create_new.addWidget(QLabel(_('Alternatively') + ':'), alignment=Qt.AlignLeft) button_create_new = QPushButton(_('Create New Wallet')) button_create_new.setMinimumWidth(120) vbox_create_new.addWidget(button_create_new, alignment=Qt.AlignLeft) widget_create_new = QWidget() widget_create_new.setLayout(vbox_create_new) vbox_create_new.setContentsMargins(0, 0, 0, 0) vbox.addWidget(widget_create_new) self.set_layout(vbox, title=_('Electrum-ECC wallet')) temp_storage = None # type: Optional[WalletStorage] wallet_folder = os.path.dirname(path) def on_choose(): path, __ = QFileDialog.getOpenFileName(self, "Select your wallet file", wallet_folder) if path: name_e.setText(path) def on_filename(filename): # FIXME? "filename" might contain ".." (etc) and hence sketchy path traversals are possible nonlocal temp_storage temp_storage = None msg = None if filename: path = os.path.join(wallet_folder, filename) wallet_from_memory = get_wallet_from_daemon(path) try: if wallet_from_memory: temp_storage = wallet_from_memory.storage # type: Optional[WalletStorage] else: temp_storage = WalletStorage(path) except (StorageReadWriteError, WalletFileException) as e: msg = _('Cannot read file') + f'\n{repr(e)}' except Exception as e: self.logger.exception('') msg = _('Cannot read file') + f'\n{repr(e)}' else: msg = _('') self.next_button.setEnabled(temp_storage is not None) user_needs_to_enter_password = False if temp_storage: if not temp_storage.file_exists(): msg =_("This file does not exist.") + '\n' \ + _("Press 'Next' to create this wallet, or choose another file.") elif not wallet_from_memory: if temp_storage.is_encrypted_with_user_pw(): msg = _("This file is encrypted with a password.") + '\n' \ + _('Enter your password or choose another file.') user_needs_to_enter_password = True elif temp_storage.is_encrypted_with_hw_device(): msg = _("This file is encrypted using a hardware device.") + '\n' \ + _("Press 'Next' to choose device to decrypt.") else: msg = _("Press 'Next' to open this wallet.") else: msg = _("This file is already open in memory.") + "\n" \ + _("Press 'Next' to create/focus window.") if msg is None: msg = _('Cannot read file') msg_label.setText(msg) widget_create_new.setVisible( bool(temp_storage and temp_storage.file_exists())) if user_needs_to_enter_password: pw_label.show() pw_e.show() pw_e.setFocus() else: pw_label.hide() pw_e.hide() button.clicked.connect(on_choose) button_create_new.clicked.connect( partial(name_e.setText, get_new_wallet_name(wallet_folder))) name_e.textChanged.connect(on_filename) name_e.setText(os.path.basename(path)) def run_user_interaction_loop(): while True: if self.loop.exec_() != 2: # 2 = next raise UserCancelled() assert temp_storage if temp_storage.file_exists( ) and not temp_storage.is_encrypted(): break if not temp_storage.file_exists(): break wallet_from_memory = get_wallet_from_daemon(temp_storage.path) if wallet_from_memory: raise WalletAlreadyOpenInMemory(wallet_from_memory) if temp_storage.file_exists() and temp_storage.is_encrypted(): if temp_storage.is_encrypted_with_user_pw(): password = pw_e.text() try: temp_storage.decrypt(password) break except InvalidPassword as e: self.show_message(title=_('Error'), msg=str(e)) continue except BaseException as e: self.logger.exception('') self.show_message(title=_('Error'), msg=repr(e)) raise UserCancelled() elif temp_storage.is_encrypted_with_hw_device(): try: self.run('choose_hw_device', HWD_SETUP_DECRYPT_WALLET, storage=temp_storage) except InvalidPassword as e: self.show_message( title=_('Error'), msg= _('Failed to decrypt using this hardware device.' ) + '\n' + _('If you use a passphrase, make sure it is correct.' )) self.reset_stack() return self.select_storage(path, get_wallet_from_daemon) except (UserCancelled, GoBack): raise except BaseException as e: self.logger.exception('') self.show_message(title=_('Error'), msg=repr(e)) raise UserCancelled() if temp_storage.is_past_initial_decryption(): break else: raise UserCancelled() else: raise Exception('Unexpected encryption version') try: run_user_interaction_loop() finally: try: pw_e.clear() except RuntimeError: # wrapped C/C++ object has been deleted. pass # happens when decrypting with hw device return temp_storage.path, (temp_storage if temp_storage.file_exists() else None)
class PlotDialog(QDialog): def __init__(self, size=(640, 480), lock_aspect=False, straxis=None, par=None): super(PlotDialog, self).__init__() self.setAttribute(Qt.WA_DeleteOnClose) self.setWindowFlags(self.windowFlags() | Qt.WindowSystemMenuHint | Qt.WindowMinMaxButtonsHint) self.size = size self.par = par if straxis is None: self.axes = Axes(lock_aspect=lock_aspect) else: self.axes = Axes(lock_aspect=lock_aspect, axisItems={'bottom': straxis}) self.opts_dlg = PlotOptions(parent=self) self.initVar() self.initUI() self.sigConnect() def initVar(self): self.n_data = 0 self.xlabel = None self.ylabel = None self.x_unit = None self.y_unit = None def initUI(self): self.setWindowTitle('Plot') self.layout = QVBoxLayout() self.txt = {} self.inf_line = { 'meanx': None, 'meany': None, 'std1x': None, 'std2x': None, 'std1y': None, 'std2y': None, } self.tr_line = False btns = QDialogButtonBox.Save | QDialogButtonBox.Close self.buttons = QDialogButtonBox(btns) self.opts_btn = QPushButton('Options') # self.test_btn = QPushButton('Test') self.buttons.button(QDialogButtonBox.Close).setAutoDefault(True) self.buttons.button(QDialogButtonBox.Close).setDefault(True) self.buttons.button(QDialogButtonBox.Save).setText('Save Plot') self.buttons.button(QDialogButtonBox.Save).setAutoDefault(False) self.buttons.button(QDialogButtonBox.Save).setDefault(False) self.opts_btn.setAutoDefault(False) self.opts_btn.setDefault(False) # self.test_btn.setAutoDefault(False) # self.test_btn.setDefault(False) self.actionEnabled(False) btn_layout = QHBoxLayout() btn_layout.addWidget(self.opts_btn) # btn_layout.addWidget(self.test_btn) btn_layout.addStretch() btn_layout.addWidget(self.buttons) self.layout.addWidget(self.axes) self.layout.addLayout(btn_layout) self.setLayout(self.layout) self.resize(self.size[0], self.size[1]) # self.crosshair() # self.axis_line() def sigConnect(self): self.buttons.rejected.connect(self.on_close) self.buttons.accepted.connect(self.on_save) self.opts_btn.clicked.connect(self.on_opts_dialog) # self.test_btn.clicked.connect(self.on_test) [ opt.stateChanged.connect(self.apply_stddev_opts) for opt in self.opts_dlg.stdv_chks ] [ opt.stateChanged.connect(self.apply_mean_opts) for opt in self.opts_dlg.mean_chks ] self.opts_dlg.trdl_btngrp.buttonClicked[int].connect( self.apply_trendline_opts) self.opts_dlg.poly_ordr_spn.valueChanged.connect( self.on_poly_order_changed) # self.proxy = pg.SignalProxy(self.axes.linePlot.scene().sigMouseMoved, rateLimit=60, slot=self.mouseMoved) def on_test(self): pass def plot(self, *args, **kwargs): self.axes.plot(*args, **kwargs) self.n_data += 1 def scatter(self, *args, **kwargs): self.axes.scatterPlot.clear() self.axes.scatter(*args, **kwargs) self.n_data += 1 def histogram(self, data, bins=20, **kwargs): y, x = np.histogram(data, bins=bins) self.plot(x, y, stepMode=True, savedata=False, **kwargs) self.axes.setXRange(np.min(x), np.max(x)) self.axes.setYRange(np.min(y), np.max(y)) tag = kwargs['name'] if 'name' in kwargs.keys( ) else f'series{self.n_data-1}' self.axes.data[tag] = np.stack((data, data)).T def annotate(self, tag, pos=(0, 0), angle=0, *args, **kwargs): txt = pg.TextItem(*args, **kwargs) txt.setPos(pos[0], pos[1]) txt.setAngle(angle) self.txt[tag] = txt self.axes.addItem(txt) def clearAnnotation(self, tag): if self.txt: self.axes.removeItem(self.txt[tag]) self.txt.pop(tag) def setLabels(self, xlabel, ylabel, x_unit=None, y_unit=None, x_prefix=None, y_prefix=None): self.xlabel = xlabel self.ylabel = ylabel self.x_unit = x_unit self.y_unit = y_unit self.axes.setLabel('bottom', xlabel, x_unit, x_prefix) self.axes.setLabel('left', ylabel, y_unit, y_prefix) def setTitle(self, title): self.setWindowTitle('Graph of ' + title) self.axes.setTitle(title) def actionEnabled(self, state): self.meanActionEnabled(state) self.stddevActionEnabled(state) self.trendActionEnabled(state) def meanActionEnabled(self, state): [opt.setEnabled(state) for opt in self.opts_dlg.mean_chks] def trendActionEnabled(self, state): [opt.setEnabled(state) for opt in self.opts_dlg.trdl_opts] def stddevActionEnabled(self, state): [opt.setEnabled(state) for opt in self.opts_dlg.stdv_chks] def on_avgline(self, axis): name = "mean" if self.inf_line[name + axis]: return x, y = self.get_data() if x is None or y is None: return mean = x.mean() if axis == 'x' else y.mean() anchor = (0, 1) #if axis=='x' else (0, 0) pos = (mean, max(y)) if axis == 'x' else (max(x), mean) angle = 0 if axis == 'y' else 90 unit = self.x_unit if axis == 'x' else self.y_unit self.create_inf_line(mean, axis, name, pg.mkPen(color='c', width=2)) self.annotate(name + axis, anchor=anchor, pos=pos, angle=angle, text=f'mean_{axis}: {mean:#.2f} {unit}') def get_data(self): max_size = 0 max_tag = None for tag, data in self.axes.data.items(): if data.shape[0] > max_size: max_size = data.shape[0] max_tag = tag if max_size == 0 or max_tag is None: return None, None return self.axes.data[max_tag].T def get_plot_data(self): max_size = 0 max_idx = 0 for idx, curve in enumerate(self.axes.plotItem.curves): curve_data = curve.getData() if curve_data[0] is None or curve.name() == 'trendline': continue size = curve_data[0].size if size > max_size: max_size = size max_idx = idx if max_size == 0: return None, None return self.axes.plotItem.curves[max_idx].getData() def on_stddev(self, axis): name1 = 'std1' name2 = 'std2' if self.inf_line[name1 + axis] and self.inf_line[name2 + axis]: return x, y = self.get_data() if x is None or y is None: return dep_v = x if axis == 'x' else y indep_v = y if axis == 'x' else x mean = dep_v.mean() std = dep_v.std() pos1 = (max(x), mean + std) if axis == 'y' else (mean + std, max(y)) pos2 = (max(x), mean - std) if axis == 'y' else (mean - std, max(y)) anchor1 = (0, 1) if axis == 'y' else (0, 1) anchor2 = (0, 1) if axis == 'y' else (0, 1) angle = 0 if axis == 'y' else 90 unit = self.x_unit if axis == 'x' else self.y_unit pen = pg.mkPen(color='m', width=2) self.create_inf_line(mean + std, axis, name1, pen) self.create_inf_line(mean - std, axis, name2, pen) self.annotate(name1 + axis, anchor=anchor1, pos=pos1, angle=angle, text=f'std_{axis}: +{std:#.2f} {unit}') self.annotate(name2 + axis, anchor=anchor2, pos=pos2, angle=angle, text=f'std_{axis}: -{std:#.2f} {unit}') def on_trendline(self, method): if self.tr_line: self.clear_trendline() x, y = self.get_data() if x is None or y is None: return model = CurveFit(x, y) if method == 'linear' or method == 'polynomial': degree = 1 if method == 'linear' else self.opts_dlg.poly_ordr_spn.value( ) param, r2, predict = model.polyfit(degree) eq = model.get_poly_eq(param) elif method == 'exponential': param, r2, predict = model.expfit() eq = model.get_exp_eq(param) elif method == 'logarithmic': param, r2, predict = model.logfit() eq = model.get_log_eq(param) else: return pos = ((x[0] + x[-1]) // 2, (y[0] + y[-1]) // 2) x_trend = np.arange(x[0], x[-1] + 0.01, 0.01) self.plot(x_trend, predict(x_trend), name='trendline', pen={ 'color': "FF0000", 'width': 2.5 }) self.annotate('tr', pos=pos, text=f'y = {eq}\nR² = {r2:#.4f}') self.tr_line = True def clear_stddev(self, axis): if self.inf_line['std1' + axis] and self.inf_line['std2' + axis]: self.clear_inf_line(axis, 'std1') self.clear_inf_line(axis, 'std2') self.clearAnnotation('std1' + axis) self.clearAnnotation('std2' + axis) def clear_mean(self, axis): if self.inf_line['mean' + axis]: self.clear_inf_line(axis, 'mean') self.clearAnnotation('mean' + axis) def clear_trendline(self): if self.tr_line: self.tr_line = False self.axes.clear_graph('trendline') self.clearAnnotation('tr') def apply_mean_opts(self): self.on_avgline('x') if self.opts_dlg.x_mean_chk.isChecked( ) else self.clear_mean('x') self.on_avgline('y') if self.opts_dlg.y_mean_chk.isChecked( ) else self.clear_mean('y') def apply_stddev_opts(self): self.on_stddev('x') if self.opts_dlg.x_stdv_chk.isChecked( ) else self.clear_stddev('x') self.on_stddev('y') if self.opts_dlg.y_stdv_chk.isChecked( ) else self.clear_stddev('y') def apply_trendline_opts(self, idx): button = self.opts_dlg.trdl_btngrp.button(idx) method = button.text().lower() self.on_trendline(method) def on_poly_order_changed(self): self.on_trendline('polynomial') def on_opts_dialog(self): if self.opts_dlg.isVisible(): self.opts_dlg.close() return rect = self.frameGeometry() x, y = rect.topLeft().x(), rect.topLeft().y() self.opts_dlg.show() if x - self.opts_dlg.width() < 0: self.opts_dlg.move(x, y) else: self.opts_dlg.move(x - self.opts_dlg.width(), y) def on_close(self): self.close() def on_save(self): accepted_format = """ PNG (*.png);; TIFF (*.tif;*.tiff);; JPEG (*.jpg;*.jpeg;*.jpe;*.jfif);; Bitmap (*.bmp);; Scalable Vector Graphics (*.svg);; Comma-Separated Value (*.csv);; Microsoft Excel Workbook (*.xlsx) """ filename, _ = QFileDialog.getSaveFileName(self, "Save plot as image...", self.windowTitle(), accepted_format) if not filename: return if not filename.lower().endswith(('.csv', '.svg', '.xlsx')): exporter = pg.exporters.ImageExporter(self.axes.plotItem) exporter.parameters()['width'] *= 2 elif filename.lower().endswith('.csv'): exporter = CSVExporter(self.axes.plotItem, xheader=self.xlabel, yheader=self.ylabel) elif filename.lower().endswith('.xlsx'): exporter = XLSXExporter(self.axes.plotItem, xheader=self.xlabel, yheader=self.ylabel) elif filename.lower().endswith('.svg'): exporter = pg.exporters.SVGExporter(self.axes.plotItem) else: return exporter.export(filename) def create_inf_line(self, value, axis, name, pen=None): if axis == 'x' or axis == 'y': angle = 90 if axis == 'x' else 0 else: return self.inf_line[name + axis] = pg.InfiniteLine(angle=angle, movable=False, pen=pen) self.axes.addItem(self.inf_line[name + axis]) self.inf_line[name + axis].setPos(value) self.inf_line[name + axis].setZValue(-10) def bar(self, *args, **kwargs): self.axes.clearAll() self.axes.bar(*args, **kwargs) def clear_inf_line(self, axis, name): if self.inf_line[name + axis]: self.axes.removeItem(self.inf_line[name + axis]) self.inf_line[name + axis] = None def axis_line(self): self.y_axis = pg.InfiniteLine(angle=90, movable=False, pen={ 'color': "FFFFFF", 'width': 1.5 }) self.x_axis = pg.InfiniteLine(angle=0, movable=False, pen={ 'color': "FFFFFF", 'width': 1.5 }) self.y_axis.setZValue(-100) self.x_axis.setZValue(-100) self.axes.addItem(self.y_axis, ignoreBounds=True) self.axes.addItem(self.x_axis, ignoreBounds=True) def crosshair(self): self.vLine = pg.InfiniteLine(angle=90, movable=False, pen={ 'color': "FFFFFF", 'width': 1.5 }) self.hLine = pg.InfiniteLine(angle=0, movable=False, pen={ 'color': "FFFFFF", 'width': 1.5 }) self.axes.addItem(self.vLine, ignoreBounds=True) self.axes.addItem(self.hLine, ignoreBounds=True) def mouseMoved(self, evt): pos = evt[ 0] ## using signal proxy turns original arguments into a tuple if self.axes.sceneBoundingRect().contains(pos): mousePoint = self.axes.plotItem.vb.mapSceneToView(pos) index = int(mousePoint.x()) # if index > 0 and index < len(data1): self.axes.setTitle( "<span style='font-size: 12pt'>x=%0.1f, <span style='color: red'>y=%0.1f</span>" % (mousePoint.x(), mousePoint.y())) self.vLine.setPos(mousePoint.x()) self.hLine.setPos(mousePoint.y()) def closeEvent(self, event): if self.opts_dlg.isVisible(): self.opts_dlg.close() if self.par is not None: self.par.plot_dialog_closed()
class RenameROIWindow(QDialog): def __init__(self, standard_volume_names, standard_organ_names, rtss, roi_id, roi_name, rename_signal, suggested_text="", *args, **kwargs): super(RenameROIWindow, self).__init__(*args, **kwargs) if platform.system() == 'Darwin': self.stylesheet_path = "src/res/stylesheet.qss" else: self.stylesheet_path = "src/res/stylesheet-win-linux.qss" stylesheet = open(resource_path(self.stylesheet_path)).read() self.setStyleSheet(stylesheet) self.standard_volume_names = standard_volume_names self.standard_organ_names = standard_organ_names self.rtss = rtss self.roi_id = roi_id self.roi_name = roi_name self.rename_signal = rename_signal self.suggested_text = suggested_text self.setWindowTitle("Rename Region of Interest") self.setMinimumSize(300, 90) self.icon = QtGui.QIcon() self.icon.addPixmap( QtGui.QPixmap(resource_path("src/res/images/icon.ico")), QtGui.QIcon.Normal, QtGui.QIcon.Off) # adding icon self.setWindowIcon(self.icon) self.explanation_text = QLabel("Enter a new name:") self.input_field = QLineEdit() self.input_field.setText(self.suggested_text) self.input_field.textChanged.connect(self.on_text_edited) self.feedback_text = QLabel() self.button_area = QWidget() self.cancel_button = QPushButton("Cancel") self.cancel_button.clicked.connect(self.close) self.rename_button = QPushButton("Rename") self.rename_button.clicked.connect(self.on_rename_clicked) self.button_layout = QHBoxLayout() self.button_layout.addWidget(self.cancel_button) self.button_layout.addWidget(self.rename_button) self.button_area.setLayout(self.button_layout) self.list_label = QLabel() self.list_label.setText("List of Standard Region of Interests") # Populating the table of ROIs self.list_of_ROIs = QListWidget() self.list_of_ROIs.addItem( "------------Standard Organ Names------------") for organ in self.standard_organ_names: self.list_of_ROIs.addItem(organ) self.list_of_ROIs.addItem( "------------Standard Volume Names------------") for volume in self.standard_volume_names: self.list_of_ROIs.addItem(volume) self.list_of_ROIs.clicked.connect(self.on_ROI_clicked) self.layout = QVBoxLayout() self.layout.addWidget(self.explanation_text) self.layout.addWidget(self.input_field) self.layout.addWidget(self.feedback_text) self.layout.addWidget(self.button_area) self.layout.addWidget(self.list_label) self.layout.addWidget(self.list_of_ROIs) self.setLayout(self.layout) def on_text_edited(self, text): if text in self.standard_volume_names or text in self.standard_organ_names: self.feedback_text.setStyleSheet("color: green") self.feedback_text.setText("Entered text is in standard names") elif text.upper() in self.standard_volume_names or text.upper( ) in self.standard_organ_names: self.feedback_text.setStyleSheet("color: orange") self.feedback_text.setText( "Entered text exists but should be in capitals") elif text == "": self.feedback_text.setText("") else: self.feedback_text.setStyleSheet("color: red") self.feedback_text.setText("Entered text is not in standard names") for item in self.standard_volume_names: if text.startswith(item): self.feedback_text.setStyleSheet("color: green") self.feedback_text.setText("Entered text is in standard names") else: upper_text = text.upper() if upper_text.startswith(item): self.feedback_text.setStyleSheet("color: orange") self.feedback_text.setText( "Entered text exists but should be in capitals") def on_rename_clicked(self): self.new_name = self.input_field.text() progress_window = RenameROIProgressWindow(self, QtCore.Qt.WindowTitleHint) progress_window.signal_roi_renamed.connect(self.on_roi_renamed) progress_window.start_renaming(self.rtss, self.roi_id, self.new_name) progress_window.show() def on_roi_renamed(self, new_rtss): self.rename_signal.emit((new_rtss, { "rename": [self.roi_name, self.new_name] })) QtWidgets.QMessageBox.about( self, "Saved", "Region of interest successfully renamed!") self.close() def on_ROI_clicked(self): clicked_ROI = self.list_of_ROIs.currentItem() # Excluding headers from being clicked. if not str(clicked_ROI.text()).startswith("------------Standard"): self.input_field.setText(str(clicked_ROI.text()))
def __init__(self): super(RoadMapWindow, self).__init__() self.proxy = TableProxy() self.BeadPlateTable = self.proxy.makeTable('Bead Plate Table', MAX_ROW, 30) self.bigRoadTable = self.proxy.makeTable('Big Road Table', MAX_ROW, 30) self.bigEyeRoadTable = self.proxy.makeTable('Big Eye Road Table', MAX_ROW, 15) self.smallRoadTable = self.proxy.makeTable('Small Road Table', MAX_ROW, 15) self.cockroachPigTable = self.proxy.makeTable('Cockroach Pig Table', MAX_ROW, 15) self.playerWinButton = QPushButton("Player Win") palette = self.playerWinButton.palette() palette.setColor(QPalette.ButtonText, Qt.blue) self.playerWinButton.setPalette(palette) self.bankerWinButton = QPushButton("Banker Win") palette = self.bankerWinButton.palette() palette.setColor(QPalette.ButtonText, Qt.red) self.bankerWinButton.setPalette(palette) self.cleanButton = QPushButton("Clean All") self.buttonBox = QDialogButtonBox() self.buttonBox.addButton(self.playerWinButton, QDialogButtonBox.ActionRole) self.buttonBox.addButton(self.bankerWinButton, QDialogButtonBox.ActionRole) self.buttonBox.addButton(self.cleanButton, QDialogButtonBox.ActionRole) self.playerWinButton.pressed.connect(self.updatePlayerWin) self.bankerWinButton.pressed.connect(self.updateBankerWin) self.cleanButton.pressed.connect(self.cleanAllTable) leftLayout = QVBoxLayout() leftLayout.addWidget(self.bigEyeRoadTable) leftLayout.addWidget(self.smallRoadTable) leftLayout.addWidget(self.cockroachPigTable) downLayout = QHBoxLayout() downLayout.addLayout(leftLayout) downLayout.addWidget(self.BeadPlateTable) mainLayout = QVBoxLayout() mainLayout.addWidget(self.bigRoadTable) mainLayout.addLayout(downLayout) mainLayout.addWidget(self.buttonBox) mainLayout.setStretchFactor(self.bigRoadTable, 1) mainLayout.setStretchFactor(downLayout, 1.5) self.setLayout(mainLayout) self.setWindowTitle("Baccarat RoadMap") self.setMinimumSize(960, 640) self.bigRoadColumn = 0 self.bigRoadRow = 0 self.bigEyeColumn = 0 self.bigEyeRow = 0
def initUI(self): self.setWindowTitle('Options') self.x_mean_chk = QCheckBox('x-data') self.y_mean_chk = QCheckBox('y-data') self.mean_chks = [self.x_mean_chk, self.y_mean_chk] mean_grpbox = QGroupBox('Mean') mean_layout = QVBoxLayout() mean_layout.addWidget(self.x_mean_chk) mean_layout.addWidget(self.y_mean_chk) mean_grpbox.setLayout(mean_layout) self.x_stdv_chk = QCheckBox('x-data') self.y_stdv_chk = QCheckBox('y-data') self.stdv_chks = [self.x_stdv_chk, self.y_stdv_chk] stdv_grpbox = QGroupBox('Standard Deviation') stdv_layout = QVBoxLayout() stdv_layout.addWidget(self.x_stdv_chk) stdv_layout.addWidget(self.y_stdv_chk) stdv_grpbox.setLayout(stdv_layout) self.none_trdl_btn = QRadioButton('None') self.linr_trdl_btn = QRadioButton('Linear') self.poly_trdl_btn = QRadioButton('Polynomial') self.exp_trdl_btn = QRadioButton('Exponential') self.log_trdl_btn = QRadioButton('Logarithmic') self.poly_ordr_spn = QSpinBox() self.trdl_btngrp = QButtonGroup() self.trdl_opts = [ self.none_trdl_btn, self.linr_trdl_btn, self.poly_trdl_btn, self.exp_trdl_btn, self.log_trdl_btn ] self.trdl_btngrp.addButton(self.none_trdl_btn) self.trdl_btngrp.addButton(self.linr_trdl_btn) self.trdl_btngrp.addButton(self.poly_trdl_btn) self.trdl_btngrp.addButton(self.exp_trdl_btn) self.trdl_btngrp.addButton(self.log_trdl_btn) self.none_trdl_btn.setChecked(True) self.poly_ordr_spn.setValue(2) self.poly_ordr_spn.setMinimum(2) self.poly_ordr_spn.setMaximumWidth(50) self.poly_ordr_spn.setEnabled(False) trdl_grpbox = QGroupBox('Trendline') trdl_layout = QFormLayout() trdl_layout.addRow(self.none_trdl_btn, QLabel('')) trdl_layout.addRow(self.linr_trdl_btn, QLabel('')) trdl_layout.addRow(self.poly_trdl_btn, self.poly_ordr_spn) trdl_layout.addRow(self.exp_trdl_btn, QLabel('')) trdl_layout.addRow(self.log_trdl_btn, QLabel('')) trdl_grpbox.setLayout(trdl_layout) self.buttons = QDialogButtonBox(QDialogButtonBox.Close) layout = QVBoxLayout() layout.addWidget(mean_grpbox) layout.addWidget(stdv_grpbox) layout.addWidget(trdl_grpbox) layout.addWidget(self.buttons) self.setLayout(layout)