def setup_page(self): newcb = self.create_checkbox # --- Workspace interface_group = QGroupBox(_("Interface")) restore_data_box = newcb(_("Restore data on startup"), 'restore_data_on_startup') save_data_box = newcb(_("Save data on exit"), 'save_data_on_exit') save_history_box = newcb(_("Save history"), 'save_history') save_non_project_box = newcb(_("Save non project files opened"), 'save_non_project_files') interface_layout = QVBoxLayout() interface_layout.addWidget(restore_data_box) interface_layout.addWidget(save_data_box) interface_layout.addWidget(save_history_box) interface_layout.addWidget(save_non_project_box) interface_group.setLayout(interface_layout) vlayout = QVBoxLayout() vlayout.addWidget(interface_group) vlayout.addStretch(1) self.setLayout(vlayout)
def create_controls(self): """ Create UI controls. """ vbox = QVBoxLayout() form = QFormLayout() self.num_angle = QDoubleSpinBox() self.num_angle.setValue(0.0) self.num_angle.setMinimum(-360) self.num_angle.setMaximum(360) form.addRow(tr("Angle:"), self.num_angle) vbox.addLayout(form) self.gbo_preview = QGroupBox(tr("Preview")) self.gbo_preview.setCheckable(True) self.gbo_preview.setChecked(False) gbo_vbox = QVBoxLayout() self.chk_grid = QCheckBox(tr("Grid")) self.chk_grid.setChecked(False) self.num_grid = QSpinBox() self.num_grid.setValue(4) self.num_grid.setMinimum(1) self.num_grid.setEnabled(False) self.chk_grid.toggled[bool].connect(self.num_grid.setEnabled) gbo_vbox.addWidget(self.chk_grid) gbo_vbox.addWidget(self.num_grid) self.gbo_preview.setLayout(gbo_vbox) vbox.addWidget(self.gbo_preview) self.gbo_preview.toggled[bool].connect(self.set_preview) self.gbo_output = QGroupBox(tr("Output")) self.opt_new = QRadioButton(tr("New signal")) self.opt_replace = QRadioButton(tr("In place")) self.opt_new.setChecked(True) gbo_vbox2 = QVBoxLayout() gbo_vbox2.addWidget(self.opt_new) gbo_vbox2.addWidget(self.opt_replace) self.gbo_output.setLayout(gbo_vbox2) vbox.addWidget(self.gbo_output) self.chk_reshape = QCheckBox(tr("Resize to fit")) self.chk_reshape.setChecked(False) vbox.addWidget(self.chk_reshape) self.btn_ok = QPushButton(tr("&OK")) self.btn_ok.setDefault(True) self.btn_ok.clicked.connect(self.accept) self.btn_cancel = QPushButton(tr("&Cancel")) self.btn_cancel.clicked.connect(self.reject) hbox = QHBoxLayout() hbox.addWidget(self.btn_ok) hbox.addWidget(self.btn_cancel) vbox.addLayout(hbox) vbox.addStretch(1) self.setLayout(vbox)
def setup_page(self): # Connections group connections_group = QGroupBox(_("Automatic connections")) connections_label = QLabel(_("This pane can automatically " "show an object's help information after " "a left parenthesis is written next to it. " "Below you can decide to which plugin " "you want to connect it to turn on this " "feature.")) connections_label.setWordWrap(True) editor_box = self.create_checkbox(_("Editor"), 'connect/editor') rope_installed = programs.is_module_installed('rope') jedi_installed = programs.is_module_installed('jedi', '>=0.8.1') editor_box.setEnabled(rope_installed or jedi_installed) if not rope_installed and not jedi_installed: editor_tip = _("This feature requires the Rope or Jedi libraries.\n" "It seems you don't have either installed.") editor_box.setToolTip(editor_tip) ipython_box = self.create_checkbox(_("IPython Console"), 'connect/ipython_console') connections_layout = QVBoxLayout() connections_layout.addWidget(connections_label) connections_layout.addWidget(editor_box) connections_layout.addWidget(ipython_box) connections_group.setLayout(connections_layout) # Features group features_group = QGroupBox(_("Additional features")) math_box = self.create_checkbox(_("Render mathematical equations"), 'math') req_sphinx = programs.is_module_installed('sphinx', '>=1.1') math_box.setEnabled(req_sphinx) if not req_sphinx: sphinx_ver = programs.get_module_version('sphinx') sphinx_tip = _("This feature requires Sphinx 1.1 or superior.") sphinx_tip += "\n" + _("Sphinx %s is currently installed.") % sphinx_ver math_box.setToolTip(sphinx_tip) features_layout = QVBoxLayout() features_layout.addWidget(math_box) features_group.setLayout(features_layout) # Source code group sourcecode_group = QGroupBox(_("Source code")) wrap_mode_box = self.create_checkbox(_("Wrap lines"), 'wrap') sourcecode_layout = QVBoxLayout() sourcecode_layout.addWidget(wrap_mode_box) sourcecode_group.setLayout(sourcecode_layout) # Final layout vlayout = QVBoxLayout() vlayout.addWidget(connections_group) vlayout.addWidget(features_group) vlayout.addWidget(sourcecode_group) vlayout.addStretch(1) self.setLayout(vlayout)
def setup_page(self): about_label = QLabel(_("The <b>current working directory</b> is " "the working directory for IPython consoles " "and the current directory for the File Explorer.")) about_label.setWordWrap(True) console_group = QGroupBox(_("Console directory")) console_label = QLabel(_("The working directory for new consoles is:")) console_label.setWordWrap(True) console_bg = QButtonGroup(console_group) console_project_radio = self.create_radiobutton( _("The current project directory " "or user home directory " "(if no project is active)"), 'console/use_project_or_home_directory', True, button_group=console_bg) console_cwd_radio = self.create_radiobutton( _("The current working directory"), 'console/use_cwd', False, button_group=console_bg) console_dir_radio = self.create_radiobutton( _("the following directory:"), 'console/use_fixed_directory', False, _("The directory when a new console " "is open will be the specified path"), button_group=console_bg) console_dir_bd = self.create_browsedir("", 'console/fixed_directory', getcwd()) console_dir_radio.toggled.connect(console_dir_bd.setEnabled) console_project_radio.toggled.connect(console_dir_bd.setDisabled) console_cwd_radio.toggled.connect(console_dir_bd.setDisabled) console_dir_layout = QHBoxLayout() console_dir_layout.addWidget(console_dir_radio) console_dir_layout.addWidget(console_dir_bd) console_layout = QVBoxLayout() console_layout.addWidget(console_label) console_layout.addWidget(console_project_radio) console_layout.addWidget(console_cwd_radio) console_layout.addLayout(console_dir_layout) console_group.setLayout(console_layout) vlayout = QVBoxLayout() vlayout.addWidget(about_label) vlayout.addSpacing(10) vlayout.addWidget(console_group) vlayout.addStretch(1) self.setLayout(vlayout)
def setup_page(self): ar_group = QGroupBox(_("Autorefresh")) ar_box = self.create_checkbox(_("Enable autorefresh"), 'autorefresh') ar_spin = self.create_spinbox(_("Refresh interval: "), _(" ms"), 'autorefresh/timeout', min_=100, max_=1000000, step=100) filter_group = QGroupBox(_("Filter")) filter_data = [ ('exclude_private', _("Exclude private references")), ('exclude_capitalized', _("Exclude capitalized references")), ('exclude_uppercase', _("Exclude all-uppercase references")), ('exclude_unsupported', _("Exclude unsupported data types")), ] filter_boxes = [self.create_checkbox(text, option) for option, text in filter_data] display_group = QGroupBox(_("Display")) display_data = [('truncate', _("Truncate values"), '')] if programs.is_module_installed('numpy'): display_data.append(('minmax', _("Show arrays min/max"), '')) display_data.append( ('remote_editing', _("Edit data in the remote process"), _("Editors are opened in the remote process for NumPy " "arrays, PIL images, lists, tuples and dictionaries.\n" "This avoids transfering large amount of data between " "the remote process and Spyder (through the socket).")) ) display_boxes = [self.create_checkbox(text, option, tip=tip) for option, text, tip in display_data] ar_layout = QVBoxLayout() ar_layout.addWidget(ar_box) ar_layout.addWidget(ar_spin) ar_group.setLayout(ar_layout) filter_layout = QVBoxLayout() for box in filter_boxes: filter_layout.addWidget(box) filter_group.setLayout(filter_layout) display_layout = QVBoxLayout() for box in display_boxes: display_layout.addWidget(box) display_group.setLayout(display_layout) vlayout = QVBoxLayout() vlayout.addWidget(ar_group) vlayout.addWidget(filter_group) vlayout.addWidget(display_group) vlayout.addStretch(1) self.setLayout(vlayout)
def create_fontgroup(self, option=None, text=None, title=None, tip=None, fontfilters=None, without_group=False): """Option=None -> setting plugin font""" if title: fontlabel = QLabel(title) else: fontlabel = QLabel(_("Font")) fontbox = QFontComboBox() if fontfilters is not None: fontbox.setFontFilters(fontfilters) sizelabel = QLabel(" "+_("Size")) sizebox = QSpinBox() sizebox.setRange(7, 100) self.fontboxes[(fontbox, sizebox)] = option layout = QHBoxLayout() for subwidget in (fontlabel, fontbox, sizelabel, sizebox): layout.addWidget(subwidget) layout.addStretch(1) widget = QWidget(self) widget.fontlabel = fontlabel widget.sizelabel = sizelabel widget.fontbox = fontbox widget.sizebox = sizebox widget.setLayout(layout) if not without_group: if text is None: text = _("Font style") group = QGroupBox(text) group.setLayout(layout) if tip is not None: group.setToolTip(tip) return group else: return widget
def setup_page(self): newcb = self.create_checkbox # --- Workspace vcs_group = QGroupBox(_("Version control")) use_version_control = newcb(_("Use version control"), "use_version_control") styles = ["git", "hg"] choices = list(zip(styles, [style.lower() for style in styles])) vcs_combo = self.create_combobox(_("Version control system"), choices, "version_control_system", default="git") vcs_layout = QVBoxLayout() vcs_layout.addWidget(use_version_control) vcs_layout.addWidget(vcs_combo) vcs_group.setLayout(vcs_layout) vlayout = QVBoxLayout() vlayout.addWidget(vcs_group) vlayout.addStretch(1) self.setLayout(vlayout)
def setup_page(self): settings_group = QGroupBox(_("Settings")) save_box = self.create_checkbox(_("Save file before analyzing it"), 'save_before', default=True) hist_group = QGroupBox(_("History")) hist_label1 = QLabel(_("The following option will be applied at next " "startup.")) hist_label1.setWordWrap(True) hist_spin = self.create_spinbox(_("History: "), _(" results"), 'max_entries', default=50, min_=10, max_=1000000, step=10) results_group = QGroupBox(_("Results")) results_label1 = QLabel(_("Results are stored here:")) results_label1.setWordWrap(True) # Warning: do not try to regroup the following QLabel contents with # widgets above -- this string was isolated here in a single QLabel # on purpose: to fix Issue 863 results_label2 = QLabel(PylintWidget.DATAPATH) results_label2.setTextInteractionFlags(Qt.TextSelectableByMouse) results_label2.setWordWrap(True) settings_layout = QVBoxLayout() settings_layout.addWidget(save_box) settings_group.setLayout(settings_layout) hist_layout = QVBoxLayout() hist_layout.addWidget(hist_label1) hist_layout.addWidget(hist_spin) hist_group.setLayout(hist_layout) results_layout = QVBoxLayout() results_layout.addWidget(results_label1) results_layout.addWidget(results_label2) results_group.setLayout(results_layout) vlayout = QVBoxLayout() vlayout.addWidget(settings_group) vlayout.addWidget(hist_group) vlayout.addWidget(results_group) vlayout.addStretch(1) self.setLayout(vlayout)
def setup_page(self): """Setup config page widgets and options.""" settings_group = QGroupBox(_("Settings")) hist_spin = self.create_spinbox( _("History depth: "), _(" entries"), 'max_entries', min_=10, max_=10000, step=10, tip=_("Set maximum line count")) sourcecode_group = QGroupBox(_("Source code")) wrap_mode_box = self.create_checkbox(_("Wrap lines"), 'wrap') linenumbers_mode_box = self.create_checkbox(_("Show line numbers"), 'line_numbers') go_to_eof_box = self.create_checkbox( _("Scroll automatically to last entry"), 'go_to_eof') settings_layout = QVBoxLayout() settings_layout.addWidget(hist_spin) settings_group.setLayout(settings_layout) sourcecode_layout = QVBoxLayout() sourcecode_layout.addWidget(wrap_mode_box) sourcecode_layout.addWidget(linenumbers_mode_box) sourcecode_layout.addWidget(go_to_eof_box) sourcecode_group.setLayout(sourcecode_layout) vlayout = QVBoxLayout() vlayout.addWidget(settings_group) vlayout.addWidget(sourcecode_group) vlayout.addStretch(1) self.setLayout(vlayout)
def setup_page(self): settings_group = QGroupBox(_("Settings")) use_color_box = self.create_checkbox( _("Use deterministic colors to differentiate functions"), 'use_colors', default=True) results_group = QGroupBox(_("Results")) results_label1 = QLabel(_("Memory profiler plugin results " "(the output of memory_profiler)\n" "is stored here:")) results_label1.setWordWrap(True) # Warning: do not try to regroup the following QLabel contents with # widgets above -- this string was isolated here in a single QLabel # on purpose: to fix Issue 863 of Profiler plugon results_label2 = QLabel(MemoryProfilerWidget.DATAPATH) results_label2.setTextInteractionFlags(Qt.TextSelectableByMouse) results_label2.setWordWrap(True) settings_layout = QVBoxLayout() settings_layout.addWidget(use_color_box) settings_group.setLayout(settings_layout) results_layout = QVBoxLayout() results_layout.addWidget(results_label1) results_layout.addWidget(results_label2) results_group.setLayout(results_layout) vlayout = QVBoxLayout() vlayout.addWidget(settings_group) vlayout.addWidget(results_group) vlayout.addStretch(1) self.setLayout(vlayout)
def setup_ui(self): self.setWindowTitle("Add New Grain") self.setWindowIcon(QIcon(RESOURCE_PATH + "icons/nakka-finocyl.gif")) self.resize(400, 400) controls = QGridLayout() gb_frame = QGroupBox(self.tr("Grain Design")) gb_frame.setLayout(controls) self.cb_grain_type = QComboBox() # TODO: make grain types auto propagate combobox self.cb_grain_type.addItems([self.tr("Cylindrical (BATES)")]) controls.addWidget(QLabel(self.tr("Core Shape")), 0, 0) controls.addWidget(self.cb_grain_type, 0, 1) self.cb_propellant_type = QComboBox() self.cb_propellant_type.addItems(app_context.propellant_db.propellant_names()) controls.addWidget(QLabel(self.tr("Propellant Type")), 1, 0) controls.addWidget(self.cb_propellant_type, 1, 1) # ok and cancel buttons btn_ok = QPushButton(self.tr("Apply")) btn_ok.clicked.connect(self.confirm_grain) btn_cancel = QPushButton(self.tr("Close")) btn_cancel.clicked.connect(self.close) lay_btns = QHBoxLayout() lay_btns.addWidget(btn_ok) lay_btns.addWidget(btn_cancel) frame_btns = QFrame() frame_btns.setLayout(lay_btns) # master layout master = QVBoxLayout() master.addWidget(gb_frame) master.addSpacing(10) master.addWidget(frame_btns) self.setLayout(master)
def setup_page(self): settings_group = QGroupBox(_("Settings")) hist_spin = self.create_spinbox( _("History depth: "), _(" entries"), "max_entries", min_=10, max_=10000, step=10, tip=_("Set maximum line count"), ) sourcecode_group = QGroupBox(_("Source code")) wrap_mode_box = self.create_checkbox(_("Wrap lines"), "wrap") go_to_eof_box = self.create_checkbox(_("Scroll automatically to last entry"), "go_to_eof") settings_layout = QVBoxLayout() settings_layout.addWidget(hist_spin) settings_group.setLayout(settings_layout) sourcecode_layout = QVBoxLayout() sourcecode_layout.addWidget(wrap_mode_box) sourcecode_layout.addWidget(go_to_eof_box) sourcecode_group.setLayout(sourcecode_layout) vlayout = QVBoxLayout() vlayout.addWidget(settings_group) vlayout.addWidget(sourcecode_group) vlayout.addStretch(1) self.setLayout(vlayout)
def setup_page(self): filter_group = QGroupBox(_("Filter")) filter_data = [ ('exclude_private', _("Exclude private references")), ('exclude_capitalized', _("Exclude capitalized references")), ('exclude_uppercase', _("Exclude all-uppercase references")), ('exclude_unsupported', _("Exclude unsupported data types")), ] filter_boxes = [self.create_checkbox(text, option) for option, text in filter_data] display_group = QGroupBox(_("Display")) display_data = [('minmax', _("Show arrays min/max"), '')] display_boxes = [self.create_checkbox(text, option, tip=tip) for option, text, tip in display_data] filter_layout = QVBoxLayout() for box in filter_boxes: filter_layout.addWidget(box) filter_group.setLayout(filter_layout) display_layout = QVBoxLayout() for box in display_boxes: display_layout.addWidget(box) display_group.setLayout(display_layout) vlayout = QVBoxLayout() vlayout.addWidget(filter_group) vlayout.addWidget(display_group) vlayout.addStretch(1) self.setLayout(vlayout)
def setup_page(self): network_group = QGroupBox(_("Network settings")) self.checkbox_proxy = self.create_checkbox(_("Use network proxy"), 'use_proxy_flag', default=False) server = self.create_lineedit(_('Server'), 'server', default='', alignment=Qt.Horizontal) port = self.create_lineedit(_('Port'), 'port', default='', alignment=Qt.Horizontal) user = self.create_lineedit(_('User'), 'user', default='', alignment=Qt.Horizontal) password = self.create_lineedit(_('Password'), 'password', default='', alignment=Qt.Horizontal) self.widgets = [server, port, user, password] # Layouts network_layout = QGridLayout() network_layout.addWidget(self.checkbox_proxy, 0, 0) network_layout.addWidget(server.label, 1, 0) network_layout.addWidget(server.textbox, 1, 1) network_layout.addWidget(port.label, 1, 2) network_layout.addWidget(port.textbox, 1, 3) network_layout.addWidget(user.label, 2, 0) network_layout.addWidget(user.textbox, 2, 1) network_layout.addWidget(password.label, 2, 2) network_layout.addWidget(password.textbox, 2, 3) network_group.setLayout(network_layout) vlayout = QVBoxLayout() vlayout.addWidget(network_group) vlayout.addStretch(1) self.setLayout(vlayout) # Signals self.checkbox_proxy.clicked.connect(self.proxy_settings) self.proxy_settings()
def setup_page(self): results_group = QGroupBox(_("Results")) results_label1 = QLabel( _("Profiler plugin results " "(the output of python's profile/cProfile)\n" "are stored here:") ) results_label1.setWordWrap(True) # Warning: do not try to regroup the following QLabel contents with # widgets above -- this string was isolated here in a single QLabel # on purpose: to fix Issue 863 results_label2 = QLabel(ProfilerWidget.DATAPATH) results_label2.setTextInteractionFlags(Qt.TextSelectableByMouse) results_label2.setWordWrap(True) results_layout = QVBoxLayout() results_layout.addWidget(results_label1) results_layout.addWidget(results_label2) results_group.setLayout(results_layout) vlayout = QVBoxLayout() vlayout.addWidget(results_group) vlayout.addStretch(1) self.setLayout(vlayout)
def setup_chamber_design(): # master layout master = QVBoxLayout() # master group box self.gb_chamber = QGroupBox(self.tr("Chamber Design")) # nozzle settings button self.btn_nozzle_settings = QPushButton(self.tr("Edit Nozzle")) self.btn_nozzle_settings.setMinimumHeight(50) master.addWidget(self.btn_nozzle_settings) # nozzle info pane fl_nozzle_info = QFormLayout() gb_nozzle = QGroupBox(self.tr("Nozzle Info")) gb_nozzle.setLayout(fl_nozzle_info) self.lbl_nozzle_throat = QLabel() fl_nozzle_info.addRow(QLabel(self.tr("Throat Diameter:")), self.lbl_nozzle_throat) self.lbl_nozzle_exit = QLabel() fl_nozzle_info.addRow(QLabel(self.tr("Exit Diameter:")), self.lbl_nozzle_exit) self.lbl_nozzle_expansion_ratio = QLabel() fl_nozzle_info.addRow(QLabel(self.tr("Expansion Ratio:")), self.lbl_nozzle_expansion_ratio) # add group box to master master.addWidget(gb_nozzle) master.addStretch() # overall motor info pane fl_motor_info = QFormLayout() gb_motor = QGroupBox(self.tr("Motor Info")) gb_motor.setLayout(fl_motor_info) self.lbl_kn = QLabel() fl_motor_info.addRow(QLabel(self.tr("Kn:")), self.lbl_kn) self.lbl_port_throat = QLabel() fl_motor_info.addRow(QLabel(self.tr("Port/Throat Ratio:")), self.lbl_port_throat) master.addWidget(gb_motor) self.gb_chamber.setLayout(master)
def _setup_ui(self): # setup central widget self.central_widget = QFrame() self.central_widget.setStyleSheet(""" #OkList { background-color: #eafaea; } #NokList { background-color: #ffebe6; } QLabel{ max-height: 1.29em; } QTabWidget::pane { border-left: 2px solid gray; border-bottom: 2px solid gray; border-right: 2px solid gray; }""") self.setCentralWidget(self.central_widget) self.tab = QTabWidget(self) self.tab.setObjectName('ASTab') # # PS self.ps_wid = QWidget(self) lay_ps = QGridLayout(self.ps_wid) lay_ps.setContentsMargins(0, 9, 0, 0) lay_ps.setHorizontalSpacing(0) # PS selection self.ps_tree = PVNameTree(items=self._get_ps_tree_names(), tree_levels=('sec', 'mag_group'), parent=self) self.ps_tree.tree.setHeaderHidden(True) self.ps_tree.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred) self.ps_tree.tree.setColumnCount(1) self.ps_tree.tree.doubleClicked.connect(self._open_detail) self.ps_tree.tree.itemChanged.connect( self._handle_checked_items_changed) gbox_ps_select = QGroupBox('Select PS: ', self) gbox_ps_select.setObjectName('select') gbox_ps_select.setStyleSheet(""" #select{ border-top: 0px solid transparent; border-left: 0px solid transparent; border-bottom: 0px solid transparent; }""") lay_ps_select = QVBoxLayout(gbox_ps_select) lay_ps_select.addWidget(self.ps_tree) lay_ps.addWidget(gbox_ps_select, 0, 0) lay_ps.setColumnStretch(0, 1) # PS commands self.checkcomm_ps_bt = QPushButton('Check Communication', self) self.checkcomm_ps_bt.clicked.connect(_part(self._set_lastcomm, 'PS')) self.checkcomm_ps_bt.clicked.connect(self._check_comm) self.checkcomm_ps_bt.setToolTip( 'Check PS and DCLinks communication status (verify invalid alarms ' 'and, if LI, the value of Connected-Mon PV)') self.checkstatus_ps_bt = QPushButton('Show Status Summary', self) self.checkstatus_ps_bt.clicked.connect(_part(self._set_lastcomm, 'PS')) self.checkstatus_ps_bt.clicked.connect(_part(self._check_status, 'PS')) self.checkstatus_ps_bt.setToolTip( 'Check PS and DCLinks interlock status and, if powered on, ' 'check if it is following reference') self.dsbltrigger_ps_bt = QPushButton('Disable PS triggers', self) self.dsbltrigger_ps_bt.clicked.connect(_part(self._set_lastcomm, 'PS')) self.dsbltrigger_ps_bt.clicked.connect( _part(self._set_check_trigger_state, 'PS', 'dsbl')) self.setsofbmode_ps_bt = QPushButton('Turn Off SOFBMode', self) self.setsofbmode_ps_bt.clicked.connect(_part(self._set_lastcomm, 'PS')) self.setsofbmode_ps_bt.clicked.connect( _part(self._set_check_fbp_sofbmode, 'off')) self.setslowref_ps_bt = QPushButton('Set PS and DCLinks to SlowRef', self) self.setslowref_ps_bt.clicked.connect(_part(self._set_lastcomm, 'PS')) self.setslowref_ps_bt.clicked.connect(self._set_check_opmode_slowref) self.currzero_ps_bt1 = QPushButton('Set PS Current to zero', self) self.currzero_ps_bt1.clicked.connect(_part(self._set_lastcomm, 'PS')) self.currzero_ps_bt1.clicked.connect(self._set_zero_ps) self.reset_ps_bt = QPushButton('Reset PS and DCLinks', self) self.reset_ps_bt.clicked.connect(_part(self._set_lastcomm, 'PS')) self.reset_ps_bt.clicked.connect(_part(self._reset_intlk, 'PS')) self.prep_sidclink_bt = QPushButton('Prepare SI Fam DCLinks', self) self.prep_sidclink_bt.clicked.connect(_part(self._set_lastcomm, 'PS')) self.prep_sidclink_bt.clicked.connect(self._prepare_sidclinks) self.prep_sidclink_bt.setVisible(False) self.init_sips_bt = QPushButton('Initialize SI Fam PS', self) self.init_sips_bt.clicked.connect(_part(self._set_lastcomm, 'PS')) self.init_sips_bt.clicked.connect(self._set_check_pwrstateinit) self.init_sips_bt.setVisible(False) self.aux_label = QLabel('') self.aux_label.setVisible(False) self.turnon_dcl_bt = QPushButton('Turn DCLinks On', self) self.turnon_dcl_bt.clicked.connect(_part(self._set_lastcomm, 'PS')) self.turnon_dcl_bt.clicked.connect( _part(self._set_check_pwrstate_dclinks, 'on')) self.checkctrlloop_dcl_bt = QPushButton('Check DCLinks CtrlLoop', self) self.checkctrlloop_dcl_bt.clicked.connect( _part(self._set_lastcomm, 'PS')) self.checkctrlloop_dcl_bt.clicked.connect( _part(self._set_check_ctrlloop, 'dclink')) self.setvolt_dcl_bt = QPushButton('Set DCLinks Voltage', self) self.setvolt_dcl_bt.clicked.connect(_part(self._set_lastcomm, 'PS')) self.setvolt_dcl_bt.clicked.connect(self._set_check_dclinks_capvolt) self.turnon_ps_bt = QPushButton('Turn PS On', self) self.turnon_ps_bt.clicked.connect(_part(self._set_lastcomm, 'PS')) self.turnon_ps_bt.clicked.connect( _part(self._set_check_pwrstate, 'PS', 'on', True)) self.setcheckctrlloop_ps_bt = QPushButton('Check PS CtrlLoop', self) self.setcheckctrlloop_ps_bt.clicked.connect( _part(self._set_lastcomm, 'PS')) self.setcheckctrlloop_ps_bt.clicked.connect( _part(self._set_check_ctrlloop, 'pwrsupply')) self.test_ps_bt = QPushButton('Set PS Current to test value', self) self.test_ps_bt.clicked.connect(_part(self._set_lastcomm, 'PS')) self.test_ps_bt.clicked.connect(self._set_test_ps) self.currzero_ps_bt2 = QPushButton('Set PS Current to zero', self) self.currzero_ps_bt2.clicked.connect(_part(self._set_lastcomm, 'PS')) self.currzero_ps_bt2.clicked.connect(self._set_zero_ps) self.restoretrigger_ps_bt = QPushButton('Restore PS triggers', self) self.restoretrigger_ps_bt.clicked.connect( _part(self._set_lastcomm, 'PS')) self.restoretrigger_ps_bt.clicked.connect( _part(self._restore_triggers_state, 'PS')) gbox_ps_comm = QGroupBox('Commands', self) gbox_ps_comm.setObjectName('comm') gbox_ps_comm.setStyleSheet('#comm{border: 0px solid transparent;}') lay_ps_comm = QVBoxLayout(gbox_ps_comm) lay_ps_comm.setContentsMargins(20, 9, 20, 9) lay_ps_comm.addWidget(QLabel('')) lay_ps_comm.addWidget( QLabel('<h4>Check</h4>', self, alignment=Qt.AlignCenter)) lay_ps_comm.addWidget(self.checkcomm_ps_bt) lay_ps_comm.addWidget(self.checkstatus_ps_bt) lay_ps_comm.addWidget(QLabel('')) lay_ps_comm.addWidget( QLabel('<h4>Prepare</h4>', self, alignment=Qt.AlignCenter)) lay_ps_comm.addWidget(self.dsbltrigger_ps_bt) lay_ps_comm.addWidget(self.setsofbmode_ps_bt) lay_ps_comm.addWidget(self.setslowref_ps_bt) lay_ps_comm.addWidget(self.currzero_ps_bt1) lay_ps_comm.addWidget(self.reset_ps_bt) lay_ps_comm.addWidget(QLabel('')) lay_ps_comm.addWidget(self.prep_sidclink_bt) lay_ps_comm.addWidget(self.init_sips_bt) lay_ps_comm.addWidget(self.aux_label) lay_ps_comm.addWidget( QLabel('<h4>Config DCLinks</h4>', self, alignment=Qt.AlignCenter)) lay_ps_comm.addWidget(self.turnon_dcl_bt) lay_ps_comm.addWidget(self.checkctrlloop_dcl_bt) lay_ps_comm.addWidget(self.setvolt_dcl_bt) lay_ps_comm.addWidget(QLabel('')) lay_ps_comm.addWidget( QLabel('<h4>Test</h4>', self, alignment=Qt.AlignCenter)) lay_ps_comm.addWidget(self.turnon_ps_bt) lay_ps_comm.addWidget(self.setcheckctrlloop_ps_bt) lay_ps_comm.addWidget(self.test_ps_bt) lay_ps_comm.addWidget(self.currzero_ps_bt2) lay_ps_comm.addWidget(QLabel('')) lay_ps_comm.addWidget( QLabel('<h4>Restore</h4>', self, alignment=Qt.AlignCenter)) lay_ps_comm.addWidget(self.restoretrigger_ps_bt) lay_ps_comm.addWidget(QLabel('')) lay_ps.addWidget(gbox_ps_comm, 0, 1) lay_ps.setColumnStretch(1, 1) self.tab.addTab(self.ps_wid, 'PS') # # PU self.pu_wid = QWidget(self) lay_pu = QGridLayout(self.pu_wid) lay_pu.setContentsMargins(0, 9, 0, 0) lay_pu.setHorizontalSpacing(0) # PU selection self.pu_tree = PVNameTree(items=self._get_pu_tree_names(), tree_levels=('sec', ), parent=self) self.pu_tree.tree.setHeaderHidden(True) self.pu_tree.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred) self.pu_tree.tree.setColumnCount(1) self.pu_tree.tree.doubleClicked.connect(self._open_detail) gbox_pu_select = QGroupBox('Select PU: ', self) gbox_pu_select.setObjectName('select') gbox_pu_select.setStyleSheet(""" #select{ border-top: 0px solid transparent; border-left: 0px solid transparent; border-bottom: 0px solid transparent; }""") lay_pu_select = QVBoxLayout(gbox_pu_select) lay_pu_select.addWidget(self.pu_tree) lay_pu.addWidget(gbox_pu_select, 0, 0) lay_pu.setColumnStretch(0, 1) # PU commands self.checkstatus_pu_bt = QPushButton('Show Status Summary', self) self.checkstatus_pu_bt.clicked.connect(_part(self._set_lastcomm, 'PU')) self.checkstatus_pu_bt.clicked.connect(_part(self._check_status, 'PU')) self.checkstatus_pu_bt.setToolTip( 'Check PU interlock status and, if powered on, ' 'check if it is following voltage setpoint') self.voltzero_pu_bt1 = QPushButton('Set PU Voltage to zero', self) self.voltzero_pu_bt1.clicked.connect(_part(self._set_lastcomm, 'PU')) self.voltzero_pu_bt1.clicked.connect(_part(self._set_zero_pu, False)) self.reset_pu_bt = QPushButton('Reset PU', self) self.reset_pu_bt.clicked.connect(_part(self._set_lastcomm, 'PU')) self.reset_pu_bt.clicked.connect(_part(self._reset_intlk, 'PU')) self.turnon_pu_bt = QPushButton('Turn PU On', self) self.turnon_pu_bt.clicked.connect(_part(self._set_lastcomm, 'PU')) self.turnon_pu_bt.clicked.connect( _part(self._set_check_pwrstate, 'PU', 'on', True)) self.enblpulse_pu_bt = QPushButton('Enable PU Pulse', self) self.enblpulse_pu_bt.clicked.connect(_part(self._set_lastcomm, 'PU')) self.enblpulse_pu_bt.clicked.connect(_part(self._set_check_pulse, 'on')) self.enbltrigger_pu_bt = QPushButton('Enable PU triggers', self) self.enbltrigger_pu_bt.clicked.connect(_part(self._set_lastcomm, 'PU')) self.enbltrigger_pu_bt.clicked.connect( _part(self._set_check_trigger_state, 'PU', 'on')) self.test_pu_bt = QPushButton('Set PU Voltage to test value', self) self.test_pu_bt.clicked.connect(_part(self._set_lastcomm, 'PU')) self.test_pu_bt.clicked.connect(self._set_test_pu) self.voltzero_pu_bt2 = QPushButton('Set PU Voltage to zero', self) self.voltzero_pu_bt2.clicked.connect(_part(self._set_lastcomm, 'PU')) self.voltzero_pu_bt2.clicked.connect(_part(self._set_zero_pu, True)) self.restoretrigger_pu_bt = QPushButton('Restore PU triggers', self) self.restoretrigger_pu_bt.clicked.connect( _part(self._set_lastcomm, 'PU')) self.restoretrigger_pu_bt.clicked.connect( _part(self._restore_triggers_state, 'PU')) gbox_pu_comm = QGroupBox('Commands', self) gbox_pu_comm.setObjectName('comm') gbox_pu_comm.setStyleSheet('#comm{border: 0px solid transparent;}') lay_pu_comm = QVBoxLayout(gbox_pu_comm) lay_pu_comm.setContentsMargins(20, 9, 20, 9) lay_pu_comm.addWidget(QLabel('')) lay_pu_comm.addWidget( QLabel('<h4>Check</h4>', self, alignment=Qt.AlignCenter)) lay_pu_comm.addWidget(self.checkstatus_pu_bt) lay_pu_comm.addWidget(QLabel('')) lay_pu_comm.addWidget( QLabel('<h4>Prepare</h4>', self, alignment=Qt.AlignCenter)) lay_pu_comm.addWidget(self.voltzero_pu_bt1) lay_pu_comm.addWidget(self.reset_pu_bt) lay_pu_comm.addWidget(QLabel('')) lay_pu_comm.addWidget( QLabel('<h4>Test</h4>', self, alignment=Qt.AlignCenter)) lay_pu_comm.addWidget(self.turnon_pu_bt) lay_pu_comm.addWidget(self.enblpulse_pu_bt) lay_pu_comm.addWidget(self.enbltrigger_pu_bt) lay_pu_comm.addWidget(self.test_pu_bt) lay_pu_comm.addWidget(self.voltzero_pu_bt2) lay_pu_comm.addWidget(QLabel('')) lay_pu_comm.addWidget( QLabel('<h4>Restore</h4>', self, alignment=Qt.AlignCenter)) lay_pu_comm.addWidget(self.restoretrigger_pu_bt) lay_pu_comm.addWidget(QLabel('')) lay_pu.addWidget(gbox_pu_comm, 0, 1) lay_pu.setColumnStretch(1, 1) self.tab.addTab(self.pu_wid, 'PU') # lists self.label_lastcomm = QLabel('Last Command: ', self) self.ok_ps = QListWidget(self) self.ok_ps.setObjectName('OkList') self.ok_ps.doubleClicked.connect(self._open_detail) self.ok_ps.setSelectionMode(QAbstractItemView.MultiSelection) self.ok_ps.setToolTip( 'Select rows and press Ctrl+C to copy and Esc to deselect.') self.nok_ps = QListWidget(self) self.nok_ps.setObjectName('NokList') self.nok_ps.doubleClicked.connect(self._open_detail) self.nok_ps.setSelectionMode(QAbstractItemView.MultiSelection) self.nok_ps.setToolTip( 'Select rows and press Ctrl+C to copy and Esc to deselect.') self.clearlists_bt = QPushButton('Clear', self) self.clearlists_bt.clicked.connect(self._clear_lastcomm) self.ok_ps_aux_list = list() self.nok_ps_aux_list = list() hbox = QHBoxLayout() hbox.addWidget(self.label_lastcomm) hbox.addWidget(self.clearlists_bt, alignment=Qt.AlignRight) list_layout = QGridLayout() list_layout.setContentsMargins(0, 0, 0, 0) list_layout.setVerticalSpacing(6) list_layout.setHorizontalSpacing(9) list_layout.addLayout(hbox, 0, 0, 1, 2) list_layout.addWidget( QLabel('<h4>Ok</h4>', self, alignment=Qt.AlignCenter), 1, 0) list_layout.addWidget(self.ok_ps, 2, 0) list_layout.addWidget( QLabel('<h4>Failed</h4>', self, alignment=Qt.AlignCenter), 1, 1) list_layout.addWidget(self.nok_ps, 2, 1) # menu self.menu = self.menuBar() self.act_cycle = self.menu.addAction('Open Cycle Window') connect_newprocess(self.act_cycle, 'sirius-hla-as-ps-cycle.py', parent=self) self.aux_comm = self.menu.addMenu('Auxiliary commands') # # auxiliary PS self.ps_menu = self.aux_comm.addMenu('PS') self.act_turnoff_ps = self.ps_menu.addAction('Turn PS Off') self.act_turnoff_ps.triggered.connect(_part(self._set_lastcomm, 'PS')) self.act_turnoff_ps.triggered.connect( _part(self._set_check_pwrstate, 'PS', 'off', True)) self.act_turnoff_dclink = self.ps_menu.addAction('Turn DCLinks Off') self.act_turnoff_dclink.triggered.connect( _part(self._set_lastcomm, 'PS')) self.act_turnoff_dclink.triggered.connect( _part(self._set_check_pwrstate_dclinks, 'off')) self.act_setcurrent_ps = self.ps_menu.addAction('Set PS Current') self.act_setcurrent_ps.triggered.connect( _part(self._set_lastcomm, 'PS')) self.act_setcurrent_ps.triggered.connect(self._set_check_current) self.act_opmode_ps = self.ps_menu.addAction('Set PS OpMode') self.act_opmode_ps.triggered.connect(_part(self._set_lastcomm, 'PS')) self.act_opmode_ps.triggered.connect(self._set_check_opmode) # # auxiliary PU self.pu_menu = self.aux_comm.addMenu('PU') self.act_turnoff_pu = self.pu_menu.addAction('Turn PU Off') self.act_turnoff_pu.triggered.connect(_part(self._set_lastcomm, 'PU')) self.act_turnoff_pu.triggered.connect( _part(self._set_check_pwrstate, 'PU', 'off', True)) self.act_dsblpulse_pu = self.pu_menu.addAction('Disable PU Pulse') self.act_dsblpulse_pu.triggered.connect(_part(self._set_lastcomm, 'PU')) self.act_dsblpulse_pu.triggered.connect( _part(self._set_check_pulse, 'off')) # layout lay = QGridLayout() lay.setHorizontalSpacing(15) lay.setVerticalSpacing(5) lay.addWidget( QLabel('<h3>Power Supplies Test</h3>', self, alignment=Qt.AlignCenter), 0, 0, 1, 3) lay.addWidget(self.tab, 1, 0) lay.addLayout(list_layout, 1, 1) lay.setColumnStretch(0, 2) lay.setColumnStretch(1, 2) lay.setRowStretch(0, 2) lay.setRowStretch(1, 18) self.central_widget.setLayout(lay)
class PlotSettingsWidget(QWidget): def __init__(self, settings, plotWidget, parent=None): super().__init__(parent) self.mainwindow = parent self.plotWidget = plotWidget # xmin self.xminLabel = QLabel(self.tr('xmin:')) self.xminSpinBox = CoordSpinBox() self.xminLabel.setBuddy(self.xminSpinBox) self.xminSpinBox.editingFinished.connect(self.change_limits) # xmax self.xmaxLabel = QLabel(self.tr('xmax:')) self.xmaxSpinBox = CoordSpinBox() self.xmaxLabel.setBuddy(self.xmaxSpinBox) self.xmaxSpinBox.editingFinished.connect(self.change_limits) # ymin self.yminLabel = QLabel(self.tr('ymin:')) self.yminSpinBox = CoordSpinBox() self.yminLabel.setBuddy(self.yminSpinBox) self.yminSpinBox.editingFinished.connect(self.change_limits) # ymax self.ymaxLabel = QLabel(self.tr('ymax:')) self.ymaxSpinBox = CoordSpinBox() self.ymaxLabel.setBuddy(self.ymaxSpinBox) self.ymaxSpinBox.editingFinished.connect(self.change_limits) # Autoscale Radio Group self.autoscaleButtonGroup = QButtonGroup() # Autoscale Group Box self.autoscaleGroupBox = QGroupBox() # autoscale self.autoscaleRadioButton = QRadioButton(self.tr("autoscale")) self.autoscaleButtonGroup.addButton(self.autoscaleRadioButton) # autotrack self.autoscrollRadioButton = QRadioButton(self.tr("autoscroll")) self.autoscaleButtonGroup.addButton(self.autoscrollRadioButton) # no autoscale self.manualscaleRadioButton = QRadioButton(self.tr("manual")) self.autoscaleButtonGroup.addButton(self.manualscaleRadioButton) layout = QVBoxLayout() layout.addWidget(self.autoscaleRadioButton) layout.addWidget(self.autoscrollRadioButton) layout.addWidget(self.manualscaleRadioButton) self.autoscaleGroupBox.setLayout(layout) # Layout layout = QGridLayout() layout.addWidget(self.xminLabel, 1, 0) layout.addWidget(self.xminSpinBox, 1, 1) layout.addWidget(self.xmaxLabel, 2, 0) layout.addWidget(self.xmaxSpinBox, 2, 1) layout.addWidget(self.yminLabel, 3, 0) layout.addWidget(self.yminSpinBox, 3, 1) layout.addWidget(self.ymaxLabel, 4, 0) layout.addWidget(self.ymaxSpinBox, 4, 1) layout.addWidget(self.autoscaleGroupBox, 5, 0, 1, 2) layout.setRowStretch(6, 1) self.setLayout(layout) # settings self.settings = settings self.settings.add_handler(S_XMIN, self.xminSpinBox) self.settings.add_handler(S_XMAX, self.xmaxSpinBox) self.settings.add_handler(S_YMIN, self.yminSpinBox) self.settings.add_handler(S_YMAX, self.ymaxSpinBox) self.settings.add_handler(S_AUTOSCALE, self.autoscaleButtonGroup) def refresh(self, state): pass def change_limits(self): if self.autoscale != AUTOSCALE_COMPLETE: self.plotWidget.xmin = self.xmin self.plotWidget.xmax = self.xmax self.plotWidget.ymin = self.ymin self.plotWidget.ymax = self.ymax self.plotWidget.draw() @property def xmin(self): return self.xminSpinBox.value() @property def xmax(self): return self.xmaxSpinBox.value() @property def ymin(self): return self.yminSpinBox.value() @property def ymax(self): return self.ymaxSpinBox.value() @property def autoscale(self): return self.autoscaleButtonGroup.checkedId()
def __init__(self, parent=None): QWidget.__init__(self, parent) self.dir = None self.runconf = RunConfiguration() firstrun_o = CONF.get('run', ALWAYS_OPEN_FIRST_RUN_OPTION, False) # --- Interpreter --- interpreter_group = QGroupBox(_("Console")) interpreter_layout = QVBoxLayout() interpreter_group.setLayout(interpreter_layout) self.current_radio = QRadioButton(CURRENT_INTERPRETER) interpreter_layout.addWidget(self.current_radio) self.dedicated_radio = QRadioButton(DEDICATED_INTERPRETER) interpreter_layout.addWidget(self.dedicated_radio) self.systerm_radio = QRadioButton(SYSTERM_INTERPRETER) interpreter_layout.addWidget(self.systerm_radio) # --- General settings ---- common_group = QGroupBox(_("General settings")) common_layout = QGridLayout() common_group.setLayout(common_layout) self.clear_var_cb = QCheckBox(CLEAR_ALL_VARIABLES) common_layout.addWidget(self.clear_var_cb, 0, 0) self.post_mortem_cb = QCheckBox(POST_MORTEM) common_layout.addWidget(self.post_mortem_cb, 1, 0) self.clo_cb = QCheckBox(_("Command line options:")) common_layout.addWidget(self.clo_cb, 2, 0) self.clo_edit = QLineEdit() self.clo_cb.toggled.connect(self.clo_edit.setEnabled) self.clo_edit.setEnabled(False) common_layout.addWidget(self.clo_edit, 2, 1) # --- Working directory --- wdir_group = QGroupBox(_("Working Directory settings")) wdir_layout = QVBoxLayout() wdir_group.setLayout(wdir_layout) self.file_dir_radio = QRadioButton(FILE_DIR) wdir_layout.addWidget(self.file_dir_radio) self.cwd_radio = QRadioButton(CW_DIR) wdir_layout.addWidget(self.cwd_radio) fixed_dir_layout = QHBoxLayout() self.fixed_dir_radio = QRadioButton(FIXED_DIR) fixed_dir_layout.addWidget(self.fixed_dir_radio) self.wd_edit = QLineEdit() self.fixed_dir_radio.toggled.connect(self.wd_edit.setEnabled) self.wd_edit.setEnabled(False) fixed_dir_layout.addWidget(self.wd_edit) browse_btn = QPushButton(ima.icon('DirOpenIcon'), '', self) browse_btn.setToolTip(_("Select directory")) browse_btn.clicked.connect(self.select_directory) fixed_dir_layout.addWidget(browse_btn) wdir_layout.addLayout(fixed_dir_layout) # --- System terminal --- external_group = QGroupBox(_("External system terminal")) external_group.setDisabled(True) self.systerm_radio.toggled.connect(external_group.setEnabled) external_layout = QGridLayout() external_group.setLayout(external_layout) self.interact_cb = QCheckBox(INTERACT) external_layout.addWidget(self.interact_cb, 1, 0, 1, -1) self.pclo_cb = QCheckBox(_("Command line options:")) external_layout.addWidget(self.pclo_cb, 3, 0) self.pclo_edit = QLineEdit() self.pclo_cb.toggled.connect(self.pclo_edit.setEnabled) self.pclo_edit.setEnabled(False) self.pclo_edit.setToolTip( _("<b>-u</b> is added to the " "other options you set here")) external_layout.addWidget(self.pclo_edit, 3, 1) # Checkbox to preserve the old behavior, i.e. always open the dialog # on first run hline = QFrame() hline.setFrameShape(QFrame.HLine) hline.setFrameShadow(QFrame.Sunken) self.firstrun_cb = QCheckBox(ALWAYS_OPEN_FIRST_RUN % _("this dialog")) self.firstrun_cb.clicked.connect(self.set_firstrun_o) self.firstrun_cb.setChecked(firstrun_o) layout = QVBoxLayout() layout.addWidget(interpreter_group) layout.addWidget(common_group) layout.addWidget(wdir_group) layout.addWidget(external_group) layout.addWidget(hline) layout.addWidget(self.firstrun_cb) self.setLayout(layout)
def setup_page(self): about_label = QLabel(_("The following are the default options for " "running files.These options may be overriden " "using the <b>Configuration per file</b> entry " "of the <b>Run</b> menu.")) about_label.setWordWrap(True) interpreter_group = QGroupBox(_("Console")) interpreter_bg = QButtonGroup(interpreter_group) self.current_radio = self.create_radiobutton(CURRENT_INTERPRETER, CURRENT_INTERPRETER_OPTION, True, button_group=interpreter_bg) self.dedicated_radio = self.create_radiobutton(DEDICATED_INTERPRETER, DEDICATED_INTERPRETER_OPTION, False, button_group=interpreter_bg) self.systerm_radio = self.create_radiobutton(SYSTERM_INTERPRETER, SYSTERM_INTERPRETER_OPTION, False, button_group=interpreter_bg) interpreter_layout = QVBoxLayout() interpreter_group.setLayout(interpreter_layout) interpreter_layout.addWidget(self.current_radio) interpreter_layout.addWidget(self.dedicated_radio) interpreter_layout.addWidget(self.systerm_radio) general_group = QGroupBox(_("General settings")) post_mortem = self.create_checkbox(POST_MORTEM, 'post_mortem', False) clear_variables = self.create_checkbox(CLEAR_ALL_VARIABLES, 'clear_namespace', False) general_layout = QVBoxLayout() general_layout.addWidget(clear_variables) general_layout.addWidget(post_mortem) general_group.setLayout(general_layout) wdir_group = QGroupBox(_("Working Directory settings")) wdir_bg = QButtonGroup(wdir_group) wdir_label = QLabel(_("Default working directory is:")) wdir_label.setWordWrap(True) dirname_radio = self.create_radiobutton( FILE_DIR, WDIR_USE_SCRIPT_DIR_OPTION, True, button_group=wdir_bg) cwd_radio = self.create_radiobutton( CW_DIR, WDIR_USE_CWD_DIR_OPTION, False, button_group=wdir_bg) thisdir_radio = self.create_radiobutton( FIXED_DIR, WDIR_USE_FIXED_DIR_OPTION, False, button_group=wdir_bg) thisdir_bd = self.create_browsedir("", WDIR_FIXED_DIR_OPTION, getcwd_or_home()) thisdir_radio.toggled.connect(thisdir_bd.setEnabled) dirname_radio.toggled.connect(thisdir_bd.setDisabled) cwd_radio.toggled.connect(thisdir_bd.setDisabled) thisdir_layout = QHBoxLayout() thisdir_layout.addWidget(thisdir_radio) thisdir_layout.addWidget(thisdir_bd) wdir_layout = QVBoxLayout() wdir_layout.addWidget(wdir_label) wdir_layout.addWidget(dirname_radio) wdir_layout.addWidget(cwd_radio) wdir_layout.addLayout(thisdir_layout) wdir_group.setLayout(wdir_layout) external_group = QGroupBox(_("External system terminal")) interact_after = self.create_checkbox(INTERACT, 'interact', False) external_layout = QVBoxLayout() external_layout.addWidget(interact_after) external_group.setLayout(external_layout) firstrun_cb = self.create_checkbox( ALWAYS_OPEN_FIRST_RUN % _("Run Settings dialog"), ALWAYS_OPEN_FIRST_RUN_OPTION, False) vlayout = QVBoxLayout() vlayout.addWidget(about_label) vlayout.addSpacing(10) vlayout.addWidget(interpreter_group) vlayout.addWidget(general_group) vlayout.addWidget(wdir_group) vlayout.addWidget(external_group) vlayout.addWidget(firstrun_cb) vlayout.addStretch(1) self.setLayout(vlayout)
def setup_page(self): about_label = QLabel( _("The following are the default options for " "running files.These options may be overriden " "using the <b>Configuration per file</b> entry " "of the <b>Run</b> menu.")) about_label.setWordWrap(True) interpreter_group = QGroupBox(_("Console")) interpreter_bg = QButtonGroup(interpreter_group) self.current_radio = self.create_radiobutton( CURRENT_INTERPRETER, CURRENT_INTERPRETER_OPTION, True, button_group=interpreter_bg) self.dedicated_radio = self.create_radiobutton( DEDICATED_INTERPRETER, DEDICATED_INTERPRETER_OPTION, False, button_group=interpreter_bg) self.systerm_radio = self.create_radiobutton( SYSTERM_INTERPRETER, SYSTERM_INTERPRETER_OPTION, False, button_group=interpreter_bg) interpreter_layout = QVBoxLayout() interpreter_group.setLayout(interpreter_layout) interpreter_layout.addWidget(self.current_radio) interpreter_layout.addWidget(self.dedicated_radio) interpreter_layout.addWidget(self.systerm_radio) general_group = QGroupBox(_("General settings")) post_mortem = self.create_checkbox(POST_MORTEM, 'post_mortem', False) clear_variables = self.create_checkbox(CLEAR_ALL_VARIABLES, 'clear_namespace', False) general_layout = QVBoxLayout() general_layout.addWidget(clear_variables) general_layout.addWidget(post_mortem) general_group.setLayout(general_layout) wdir_group = QGroupBox(_("Working Directory settings")) wdir_bg = QButtonGroup(wdir_group) wdir_label = QLabel(_("Default working directory is:")) wdir_label.setWordWrap(True) dirname_radio = self.create_radiobutton(FILE_DIR, WDIR_USE_SCRIPT_DIR_OPTION, True, button_group=wdir_bg) cwd_radio = self.create_radiobutton(CW_DIR, WDIR_USE_CWD_DIR_OPTION, False, button_group=wdir_bg) thisdir_radio = self.create_radiobutton(FIXED_DIR, WDIR_USE_FIXED_DIR_OPTION, False, button_group=wdir_bg) thisdir_bd = self.create_browsedir("", WDIR_FIXED_DIR_OPTION, getcwd()) thisdir_radio.toggled.connect(thisdir_bd.setEnabled) dirname_radio.toggled.connect(thisdir_bd.setDisabled) cwd_radio.toggled.connect(thisdir_bd.setDisabled) thisdir_layout = QHBoxLayout() thisdir_layout.addWidget(thisdir_radio) thisdir_layout.addWidget(thisdir_bd) wdir_layout = QVBoxLayout() wdir_layout.addWidget(wdir_label) wdir_layout.addWidget(dirname_radio) wdir_layout.addWidget(cwd_radio) wdir_layout.addLayout(thisdir_layout) wdir_group.setLayout(wdir_layout) external_group = QGroupBox(_("External system terminal")) interact_after = self.create_checkbox(INTERACT, 'interact', False) external_layout = QVBoxLayout() external_layout.addWidget(interact_after) external_group.setLayout(external_layout) firstrun_cb = self.create_checkbox( ALWAYS_OPEN_FIRST_RUN % _("Run Settings dialog"), ALWAYS_OPEN_FIRST_RUN_OPTION, False) vlayout = QVBoxLayout() vlayout.addWidget(about_label) vlayout.addSpacing(10) vlayout.addWidget(interpreter_group) vlayout.addWidget(general_group) vlayout.addWidget(wdir_group) vlayout.addWidget(external_group) vlayout.addWidget(firstrun_cb) vlayout.addStretch(1) self.setLayout(vlayout)
def __init__(self, parent): super().__init__(parent) newcb = self.create_checkbox pep_url = ( '<a href="https://www.python.org/dev/peps/pep-0008">PEP 8</a>') code_style_codes_url = _( "<a href='http://pycodestyle.pycqa.org/en/stable" "/intro.html#error-codes'>pycodestyle error codes</a>") code_style_label = QLabel( _("Spyder can use pycodestyle to analyze your code for " "conformance to the {} convention. You can also " "manually show or hide specific warnings by their " "{}.").format(pep_url, code_style_codes_url)) code_style_label.setOpenExternalLinks(True) code_style_label.setWordWrap(True) # Code style checkbox self.code_style_check = self.create_checkbox( _("Enable code style linting"), 'pycodestyle') # Code style options self.code_style_filenames_match = self.create_lineedit( _("Only check filenames matching these patterns:"), 'pycodestyle/filename', alignment=Qt.Horizontal, word_wrap=False, placeholder=_("Check Python files: *.py")) self.code_style_exclude = self.create_lineedit( _("Exclude files or directories matching these patterns:"), 'pycodestyle/exclude', alignment=Qt.Horizontal, word_wrap=False, placeholder=_("Exclude all test files: (?!test_).*\\.py")) code_style_select = self.create_lineedit( _("Show the following errors or warnings:").format( code_style_codes_url), 'pycodestyle/select', alignment=Qt.Horizontal, word_wrap=False, placeholder=_("Example codes: E113, W391")) code_style_ignore = self.create_lineedit( _("Ignore the following errors or warnings:"), 'pycodestyle/ignore', alignment=Qt.Horizontal, word_wrap=False, placeholder=_("Example codes: E201, E303")) self.code_style_max_line_length = self.create_spinbox( _("Maximum allowed line length:"), None, 'pycodestyle/max_line_length', min_=10, max_=500, step=1, tip=_("Default is 79")) vertical_line_box = newcb( _("Show vertical line at that length"), 'edge_line', section='editor') # Code style layout code_style_g_layout = QGridLayout() code_style_g_layout.addWidget( self.code_style_filenames_match.label, 1, 0) code_style_g_layout.addWidget( self.code_style_filenames_match.textbox, 1, 1) code_style_g_layout.addWidget(self.code_style_exclude.label, 2, 0) code_style_g_layout.addWidget(self.code_style_exclude.textbox, 2, 1) code_style_g_layout.addWidget(code_style_select.label, 3, 0) code_style_g_layout.addWidget(code_style_select.textbox, 3, 1) code_style_g_layout.addWidget(code_style_ignore.label, 4, 0) code_style_g_layout.addWidget(code_style_ignore.textbox, 4, 1) # Set Code style options enabled/disabled code_style_g_widget = QWidget() code_style_g_widget.setLayout(code_style_g_layout) code_style_g_widget.setEnabled(self.get_option('pycodestyle')) self.code_style_check.toggled.connect(code_style_g_widget.setEnabled) # Code style layout code_style_group = QGroupBox(_("Code style")) code_style_layout = QVBoxLayout() code_style_layout.addWidget(code_style_label) code_style_layout.addWidget(self.code_style_check) code_style_layout.addWidget(code_style_g_widget) code_style_group.setLayout(code_style_layout) # Maximum allowed line length layout line_length_group = QGroupBox(_("Line length")) line_length_layout = QVBoxLayout() line_length_layout.addWidget(self.code_style_max_line_length) line_length_layout.addWidget(vertical_line_box) line_length_group.setLayout(line_length_layout) # Code formatting label autopep8_url = ( "<a href='https://github.com/hhatto/autopep8'>Autopep8</a>" ) yapf_url = ( "<a href='https://github.com/google/yapf'>Yapf</a>" ) black_url = ( "<a href='https://black.readthedocs.io/en/stable'>Black</a>" ) code_fmt_label = QLabel( _("Spyder can use {0} or {1} to format your code for " "conformance to the {2} convention.").format( autopep8_url, black_url, pep_url)) code_fmt_label.setOpenExternalLinks(True) code_fmt_label.setWordWrap(True) # Code formatting providers code_fmt_provider = self.create_combobox( _("Choose the code formatting provider: "), (("autopep8", 'autopep8'), ("black", 'black')), 'formatting') # Autoformat on save format_on_save_box = newcb( _("Autoformat files on save"), 'format_on_save', tip=_("If enabled, autoformatting will take place when " "saving a file")) # Code formatting layout code_fmt_group = QGroupBox(_("Code formatting")) code_fmt_layout = QVBoxLayout() code_fmt_layout.addWidget(code_fmt_label) code_fmt_layout.addWidget(code_fmt_provider) code_fmt_layout.addWidget(format_on_save_box) code_fmt_group.setLayout(code_fmt_layout) code_style_fmt_layout = QVBoxLayout() code_style_fmt_layout.addWidget(code_style_group) code_style_fmt_layout.addWidget(code_fmt_group) code_style_fmt_layout.addWidget(line_length_group) self.setLayout(code_style_fmt_layout)
def _setupUi(self): title = QLabel(self.title, self, alignment=Qt.AlignCenter) title.setStyleSheet("font-weight: bold;") title.setSizePolicy(QSzPlcy.Preferred, QSzPlcy.Maximum) # limit setpoints self._wid_lims = QGroupBox('Select Thresholds: ') lay_lims = QGridLayout(self._wid_lims) lay_lims.setAlignment(Qt.AlignTop) row = 0 if 'sum' in self.metric: text = '\nThresholds must be set in Monit1 rate\n'\ 'counts. Here we make available you \n'\ 'to read Sum-Mon values, in Monit rate\n'\ 'counts, and convert them to Monit1\n'\ 'rate counts using calibration curves.\n'\ 'You can also apply a scale factor to\n'\ 'the values read.\n\n' self._label_help = QLabel(text, self) lay_lims.addWidget(self._label_help, row, 0, 1, 2) row += 1 self._pb_get = QPushButton('Get current Sum-Mon', self) self._pb_get.released.connect(self._get_new_sum) lay_lims.addWidget(self._pb_get, row, 0, 1, 2) row += 1 self._label_getsts = QLabel('\n', self) lay_lims.addWidget(self._label_getsts, row, 0, 1, 2) row += 1 self._label_scl = QLabel('Scale: ', self) lay_lims.addWidget(self._label_scl, row, 0) self._spin_scl = QDoubleSpinBox(self) self._spin_scl.setDecimals(2) self._spin_scl.setValue(1.00) self._spin_scl.setMinimum(-100.00) self._spin_scl.setMaximum(+100.00) lay_lims.addWidget(self._spin_scl, row, 1) else: self._head_value = QLabel('Value', self, alignment=Qt.AlignCenter) lay_lims.addWidget(self._head_value, 0, 1) self._head_send = QLabel('Apply', self, alignment=Qt.AlignCenter) lay_lims.addWidget(self._head_send, 0, 2) self._spins, self._checks = dict(), dict() for lsp in self.lim_sp: row += 1 text = lsp.split('-')[0].split('Lmt')[1] + ' [nm]: ' label = QLabel(text, self, alignment=Qt.AlignRight) lay_lims.addWidget(label, row, 0) spin = QSpinBox(self) self._spins[lsp] = spin spin.setValue(0) spin.setMinimum(-1e9) spin.setMaximum(1e9) lay_lims.addWidget(spin, row, 1) check = QCheckBox(self) self._checks[lsp] = check lay_lims.addWidget(check, row, 2, alignment=Qt.AlignCenter) row += 1 self._label_reforb = QLabel( '\nChoose Ref.Orb. to calculate reference\n' + self.title.lower() + ' around which we\napply the values above:') lay_lims.addWidget(self._label_reforb, row, 0, 1, 3) row += 1 self._cb_reforb = RefOrbComboBox(self) self._cb_reforb.refOrbChanged.connect(self._set_ref_orb) lay_lims.addWidget(self._cb_reforb, row, 0, 1, 3) if 'trans' in self.metric: text = '\n\nBPM calculation consider the translation\n' \ 'estimative:' \ '\n\n(pos@downstream+pos@upstream)/2\n\n' \ 'where the pairs upstream/downstream\nfolow:\n' \ ' - M1/M2\n' \ ' - C1-1/C1-2\n' \ ' - C2/C3-1\n' \ ' - C3-2/C4\n' elif 'ang' in self.metric: text = '\n\nBPM calculation consider the angulation\n' \ 'estimative:' \ '\n\n(pos@downstream - pos@upstream)\n\n' \ 'where the pairs upstream/downstream\nfolow:\n' \ ' - M1/M2\n' \ ' - C1-1/C1-2\n' \ ' - C2/C3-1\n' \ ' - C3-2/C4\n' row += 1 self._label_help = QLabel(text, self) lay_lims.addWidget(self._label_help, row, 0, 1, 3) # BPM selection groupsel = QGroupBox('Select BPMs:') groupsel.setObjectName('groupsel') groupsel.setStyleSheet('#groupsel{min-width: 27em; max-width: 27em;}') self._bpm_sel = _BPMSelectionWidget(self, show_toggle_all_false=False, toggle_all_true_text='Select All', prefix=self.prefix) lay_groupsel = QGridLayout(groupsel) lay_groupsel.addWidget(self._bpm_sel) # connect signals and slots self._bpm_sel.applyChangesClicked.connect(self.send_value) lay = QGridLayout(self) lay.addWidget(title, 0, 0, 1, 2) lay.addWidget(self._wid_lims, 1, 0) lay.addWidget(groupsel, 1, 1)
def __init__(self, parent=None): QWidget.__init__(self, parent) self.current_radio = None self.dedicated_radio = None self.systerm_radio = None self.runconf = RunConfiguration() firstrun_o = CONF.get("run", ALWAYS_OPEN_FIRST_RUN_OPTION, False) # --- General settings ---- common_group = QGroupBox(_("General settings")) common_layout = QGridLayout() common_group.setLayout(common_layout) self.clo_cb = QCheckBox(_("Command line options:")) common_layout.addWidget(self.clo_cb, 0, 0) self.clo_edit = QLineEdit() self.clo_cb.toggled.connect(self.clo_edit.setEnabled) self.clo_edit.setEnabled(False) common_layout.addWidget(self.clo_edit, 0, 1) self.wd_cb = QCheckBox(_("Working directory:")) common_layout.addWidget(self.wd_cb, 1, 0) wd_layout = QHBoxLayout() self.wd_edit = QLineEdit() self.wd_cb.toggled.connect(self.wd_edit.setEnabled) self.wd_edit.setEnabled(False) wd_layout.addWidget(self.wd_edit) browse_btn = QPushButton(ima.icon("DirOpenIcon"), "", self) browse_btn.setToolTip(_("Select directory")) browse_btn.clicked.connect(self.select_directory) wd_layout.addWidget(browse_btn) common_layout.addLayout(wd_layout, 1, 1) self.post_mortem_cb = QCheckBox(_("Enter debugging mode when " "errors appear during execution")) common_layout.addWidget(self.post_mortem_cb) # --- Interpreter --- interpreter_group = QGroupBox(_("Console")) interpreter_layout = QVBoxLayout() interpreter_group.setLayout(interpreter_layout) self.current_radio = QRadioButton(CURRENT_INTERPRETER) interpreter_layout.addWidget(self.current_radio) self.dedicated_radio = QRadioButton(DEDICATED_INTERPRETER) interpreter_layout.addWidget(self.dedicated_radio) self.systerm_radio = QRadioButton(SYSTERM_INTERPRETER) interpreter_layout.addWidget(self.systerm_radio) # --- Dedicated interpreter --- new_group = QGroupBox(_("Dedicated Python console")) self.current_radio.toggled.connect(new_group.setDisabled) new_layout = QGridLayout() new_group.setLayout(new_layout) self.interact_cb = QCheckBox(_("Interact with the Python " "console after execution")) new_layout.addWidget(self.interact_cb, 1, 0, 1, -1) self.show_kill_warning_cb = QCheckBox(_("Show warning when killing" " running process")) new_layout.addWidget(self.show_kill_warning_cb, 2, 0, 1, -1) self.pclo_cb = QCheckBox(_("Command line options:")) new_layout.addWidget(self.pclo_cb, 3, 0) self.pclo_edit = QLineEdit() self.pclo_cb.toggled.connect(self.pclo_edit.setEnabled) self.pclo_edit.setEnabled(False) self.pclo_edit.setToolTip(_("<b>-u</b> is added to the " "other options you set here")) new_layout.addWidget(self.pclo_edit, 3, 1) # Checkbox to preserve the old behavior, i.e. always open the dialog # on first run hline = QFrame() hline.setFrameShape(QFrame.HLine) hline.setFrameShadow(QFrame.Sunken) self.firstrun_cb = QCheckBox(ALWAYS_OPEN_FIRST_RUN % _("this dialog")) self.firstrun_cb.clicked.connect(self.set_firstrun_o) self.firstrun_cb.setChecked(firstrun_o) layout = QVBoxLayout() layout.addWidget(interpreter_group) layout.addWidget(common_group) layout.addWidget(new_group) layout.addWidget(hline) layout.addWidget(self.firstrun_cb) self.setLayout(layout)
class SegmentationWidget(QWidget): def __init__( self, viewer: napari.viewer.Viewer, boundaries_string=BOUNDARIES_STRING, ): super(SegmentationWidget, self).__init__() # general variables self.viewer = viewer # Main layers self.base_layer = [] # Contains registered brain / reference brain self.atlas_layer = [] # Contains annotations / region information # Other data self.hemispheres_data = [] # Track variables self.track_layers = [] # Region variables self.label_layers = [] # Atlas variables self.current_atlas_name = "" self.atlas = None self.boundaries_string = boundaries_string self.directory = "" # Set up segmentation methods self.region_seg = RegionSeg(self) self.track_seg = TrackSeg(self) # Generate main layout self.setup_main_layout() if DISPLAY_REGION_INFO: @self.viewer.mouse_move_callbacks.append def display_region_info(v, event): """ Show brain region info on mouse over in status bar on the right """ assert self.viewer == v if v.dims.ndisplay == 2: if len(v.layers) and self.atlas_layer and self.atlas: _, _, _, region_info = structure_from_viewer( self.viewer.status, self.atlas_layer, self.atlas) self.viewer.help = region_info else: self.viewer.help = "" def setup_main_layout(self): """ Construct main layout of widget """ self.layout = QGridLayout() self.layout.setContentsMargins(10, 10, 10, 10) self.layout.setAlignment(QtCore.Qt.AlignTop) self.layout.setSpacing(4) # 3 Steps: # - Loading panel # - Segmentation methods panel # -> Individual segmentation methods (which are invisible at first) # - Saving panel self.add_loading_panel(1) self.add_segmentation_methods_panel(1) self.track_seg.add_track_panel(2) # Track segmentation subpanel self.region_seg.add_region_panel(3) # Region segmentation subpanel self.add_saving_panel(4) # Take care of status label self.status_label = QLabel() self.status_label.setText("Ready") self.layout.addWidget(self.status_label, 5, 0) self.setLayout(self.layout) # PANELS ############################################################### def add_segmentation_methods_panel(self, row, column=1): """ Segmentation methods chooser panel: Toggle visibility of segmentation methods """ self.toggle_methods_panel = QGroupBox("Segmentation") self.toggle_methods_layout = QGridLayout() self.toggle_methods_layout.setContentsMargins(10, 10, 10, 10) self.toggle_methods_layout.setSpacing(5) self.toggle_methods_layout.setAlignment(QtCore.Qt.AlignBottom) self.show_trackseg_button = add_button( "Track tracing", self.toggle_methods_layout, self.track_seg.toggle_track_panel, 0, 1, minimum_width=COLUMN_WIDTH, alignment=SEGM_METHODS_PANEL_ALIGN, ) self.show_trackseg_button.setEnabled(False) self.show_regionseg_button = add_button( "Region segmentation", self.toggle_methods_layout, self.region_seg.toggle_region_panel, 1, 1, minimum_width=COLUMN_WIDTH, alignment=SEGM_METHODS_PANEL_ALIGN, ) self.show_regionseg_button.setEnabled(False) self.toggle_methods_layout.setColumnMinimumWidth(1, COLUMN_WIDTH) self.toggle_methods_panel.setLayout(self.toggle_methods_layout) self.toggle_methods_panel.setVisible(True) self.layout.addWidget(self.toggle_methods_panel, row, column, 1, 1) def add_loading_panel(self, row, column=0): """ Loading panel: - Load project (sample space) - Load project (atlas space) - Atlas chooser """ self.load_data_panel = QGroupBox("Load data") self.load_data_layout = QGridLayout() self.load_data_layout.setSpacing(15) self.load_data_layout.setContentsMargins(10, 10, 10, 10) self.load_data_layout.setAlignment(QtCore.Qt.AlignBottom) self.load_button = add_button( "Load project (sample space)", self.load_data_layout, self.load_brainreg_directory_sample, 0, 0, visibility=False, minimum_width=COLUMN_WIDTH, alignment=LOADING_PANEL_ALIGN, ) self.load_button_standard = add_button( "Load project (atlas space)", self.load_data_layout, self.load_brainreg_directory_standard, 1, 0, visibility=False, minimum_width=COLUMN_WIDTH, alignment=LOADING_PANEL_ALIGN, ) self.add_atlas_menu(self.load_data_layout) self.load_data_layout.setColumnMinimumWidth(0, COLUMN_WIDTH) self.load_data_panel.setLayout(self.load_data_layout) self.load_data_panel.setVisible(True) self.layout.addWidget(self.load_data_panel, row, column, 1, 1) # buttons made visible after adding to main widget, preventing them # from briefly appearing in a separate window self.load_button.setVisible(True) self.load_button_standard.setVisible(True) def add_saving_panel(self, row): """ Saving/Export panel """ self.save_data_panel = QGroupBox() self.save_data_layout = QGridLayout() self.export_button = add_button( "To brainrender", self.save_data_layout, self.export_to_brainrender, 0, 0, visibility=False, ) self.save_button = add_button("Save", self.save_data_layout, self.save, 0, 1, visibility=False) self.save_data_layout.setColumnMinimumWidth(1, COLUMN_WIDTH) self.save_data_panel.setLayout(self.save_data_layout) self.layout.addWidget(self.save_data_panel, row, 0, 1, 2) self.save_data_panel.setVisible(False) # ATLAS INTERACTION #################################################### def add_atlas_menu(self, layout): list_of_atlasses = ["Load atlas"] available_atlases = get_available_atlases() for atlas in available_atlases.keys(): atlas_desc = f"{atlas} v{available_atlases[atlas]}" list_of_atlasses.append(atlas_desc) atlas_menu, _ = add_combobox( layout, None, list_of_atlasses, 2, 0, label_stack=True, callback=self.initialise_atlas, width=COLUMN_WIDTH, ) self.atlas_menu = atlas_menu def initialise_atlas(self): atlas_string = self.atlas_menu.currentText() atlas_name = atlas_string.split(" ")[0].strip() if atlas_name != self.current_atlas_name: status = self.remove_layers() if not status: # Something prevented deletion self.reset_atlas_menu() return else: print(f"{atlas_string} already selected for segmentation.") self.reset_atlas_menu() return # Get / set output directory self.set_output_directory() if not self.directory: self.reset_atlas_menu() return self.current_atlas_name = atlas_name # Instantiate atlas layers self.load_atlas() self.directory = self.directory / atlas_name self.paths = Paths(self.directory, atlas_space=True) self.status_label.setText("Ready") # Set window title self.initialise_segmentation_interface() # Check / load previous regions and tracks self.region_seg.check_saved_region() self.track_seg.check_saved_track() self.reset_atlas_menu() def set_output_directory(self): self.status_label.setText("Loading...") options = QFileDialog.Options() options |= QFileDialog.DontUseNativeDialog self.directory = QFileDialog.getExistingDirectory( self, "Select output directory", options=options, ) if self.directory != "": self.directory = Path(self.directory) def load_atlas(self): atlas = BrainGlobeAtlas(self.current_atlas_name) self.atlas = atlas self.base_layer = self.viewer.add_image( self.atlas.reference, name="Reference", ) self.atlas_layer = self.viewer.add_labels( self.atlas.annotation, name=self.atlas.atlas_name, blending="additive", opacity=0.3, visible=False, ) self.standard_space = True def reset_atlas_menu(self): # Reset menu for atlas - show initial description self.atlas_menu.blockSignals(True) self.atlas_menu.setCurrentIndex(0) self.atlas_menu.blockSignals(False) # BRAINREG INTERACTION ################################################# def load_brainreg_directory_sample(self): self.get_brainreg_directory(standard_space=False) def load_brainreg_directory_standard(self): self.get_brainreg_directory(standard_space=True) def get_brainreg_directory(self, standard_space): """ Shows file dialog to choose output directory and sets global directory info """ if standard_space: self.plugin = ( "brainglobe-napari-io.brainreg_read_dir_standard_space") self.standard_space = True else: self.plugin = "brainglobe-napari-io.brainreg_read_dir" self.standard_space = False self.status_label.setText("Loading...") options = QFileDialog.Options() options |= QFileDialog.DontUseNativeDialog brainreg_directory = QFileDialog.getExistingDirectory( self, "Select brainreg directory", options=options, ) if not brainreg_directory: return if self.directory != brainreg_directory: status = self.remove_layers() if not status: return # Something prevented deletion self.directory = Path(brainreg_directory) else: print(f"{str(brainreg_directory)} already loaded.") return # Otherwise, proceed loading brainreg dir self.load_brainreg_directory() def load_brainreg_directory(self): """ Opens brainreg folder in napari. Calls initialise_loaded_data to set up layers / info. Then checks for previously loaded data. """ try: self.viewer.open(str(self.directory), plugin=self.plugin) self.paths = Paths( self.directory, standard_space=self.standard_space, ) self.initialise_loaded_data() except ValueError: print(f"The directory ({self.directory}) does not appear to be " f"a brainreg directory, please try again.") return # Check / load previous regions and tracks self.region_seg.check_saved_region() self.track_seg.check_saved_track() def initialise_loaded_data(self): """ Set up brainreg layers in napari / fill with new data and info """ try: self.viewer.layers.remove(self.boundaries_string) except ValueError: pass self.base_layer = self.viewer.layers["Registered image"] self.metadata = self.base_layer.metadata self.atlas = self.metadata["atlas_class"] self.atlas_layer = self.viewer.layers[self.metadata["atlas"]] if self.standard_space: self.hemispheres_data = self.atlas.hemispheres else: self.hemispheres_data = self.viewer.layers["Hemispheres"].data self.initialise_segmentation_interface() self.status_label.setText("Ready") # MORE LAYOUT COMPONENTS ########################################### def initialise_segmentation_interface(self): self.reset_variables() self.initialise_image_view() self.save_data_panel.setVisible(True) self.save_button.setVisible(True) self.export_button.setVisible(self.standard_space) self.show_regionseg_button.setEnabled(True) self.show_trackseg_button.setEnabled(True) self.status_label.setText("Ready") def initialise_image_view(self): self.set_z_position() def set_z_position(self): midpoint = int(round(len(self.base_layer.data) / 2)) self.viewer.dims.set_point(0, midpoint) def reset_variables(self): """ Reset atlas scale dependent variables - point_size (Track segmentation) - spline_size (Track segmentation) - brush_size (Region segmentation) """ self.mean_voxel_size = int( np.sum(self.atlas.resolution) / len(self.atlas.resolution)) self.track_seg.point_size = (self.track_seg.point_size_default / self.mean_voxel_size) self.track_seg.spline_size = (self.track_seg.spline_size_default / self.mean_voxel_size) self.region_seg.brush_size = (self.region_seg.brush_size_default / self.mean_voxel_size) return def remove_layers(self): """ TODO: This needs work. Runs into an error currently when switching from a annotated project to another one """ if len(self.viewer.layers) != 0: # Check with user if that is really what is wanted if self.track_layers or self.label_layers: choice = display_warning( self, "About to remove layers", "All layers are about to be deleted. Proceed?", ) if not choice: print('Preventing deletion because user chose "Cancel"') return False # Remove old layers for layer in list(self.viewer.layers): try: self.viewer.layers.remove(layer) except IndexError: # no idea why this happens pass self.track_layers = [] self.label_layers = [] return True def save(self, override=True): if self.label_layers or self.track_layers: if not override: choice = display_warning( self, "About to save files", "Existing files will be will be deleted. Proceed?", ) else: choice = True # for debugging if choice: print("Saving") worker = save_all( self.paths.regions_directory, self.paths.tracks_directory, self.label_layers, self.track_layers, track_file_extension=TRACK_FILE_EXT, ) worker.start() else: print('Not saving because user chose "Cancel" \n') def export_to_brainrender(self, override=False): if not override: choice = display_warning( self, "About to export files", "Existing files will be will be deleted. Proceed?", ) else: choice = True # for debugging if choice: print("Exporting") worker = export_all( self.paths.regions_directory, self.paths.tracks_directory, self.label_layers, self.track_seg.splines, self.track_seg.spline_names, self.atlas.resolution[0], ) worker.start() else: print('Not exporting because user chose "Cancel" \n')
def setup_page(self): # Connections group connections_group = QGroupBox(_("Automatic connections")) connections_label = QLabel( _("This pane can automatically " "show an object's help information after " "a left parenthesis is written next to it. " "Below you can decide to which plugin " "you want to connect it to turn on this " "feature.")) connections_label.setWordWrap(True) editor_box = self.create_checkbox(_("Editor"), 'connect/editor') rope_installed = programs.is_module_installed('rope') jedi_installed = programs.is_module_installed('jedi', '>=0.8.1') editor_box.setEnabled(rope_installed or jedi_installed) if not rope_installed and not jedi_installed: editor_tip = _( "This feature requires the Rope or Jedi libraries.\n" "It seems you don't have either installed.") editor_box.setToolTip(editor_tip) ipython_box = self.create_checkbox(_("IPython Console"), 'connect/ipython_console') connections_layout = QVBoxLayout() connections_layout.addWidget(connections_label) connections_layout.addWidget(editor_box) connections_layout.addWidget(ipython_box) connections_group.setLayout(connections_layout) # Features group features_group = QGroupBox(_("Additional features")) math_box = self.create_checkbox(_("Render mathematical equations"), 'math') req_sphinx = programs.is_module_installed('sphinx', '>=1.1') math_box.setEnabled(req_sphinx) if not req_sphinx: sphinx_ver = programs.get_module_version('sphinx') sphinx_tip = _("This feature requires Sphinx 1.1 or superior.") sphinx_tip += "\n" + _( "Sphinx %s is currently installed.") % sphinx_ver math_box.setToolTip(sphinx_tip) features_layout = QVBoxLayout() features_layout.addWidget(math_box) features_group.setLayout(features_layout) # Source code group sourcecode_group = QGroupBox(_("Source code")) wrap_mode_box = self.create_checkbox(_("Wrap lines"), 'wrap') sourcecode_layout = QVBoxLayout() sourcecode_layout.addWidget(wrap_mode_box) sourcecode_group.setLayout(sourcecode_layout) # Final layout vlayout = QVBoxLayout() vlayout.addWidget(connections_group) vlayout.addWidget(features_group) vlayout.addWidget(sourcecode_group) vlayout.addStretch(1) self.setLayout(vlayout)
def __init__(self, parent, language=None, cmd='', host='127.0.0.1', port=2084, args='', external=False, stdio=False, configurations={}, **kwargs): super(LSPServerEditor, self).__init__(parent) description = _( "To create a new server configuration, you need to select a " "programming language, set the command to start its associated " "server and enter any arguments that should be passed to it on " "startup. Additionally, you can set the server's hostname and " "port if connecting to an external server, " "or to a local one using TCP instead of stdio pipes." "<br><br>" "<i>Note</i>: You can use the placeholders <tt>{host}</tt> and " "<tt>{port}</tt> in the server arguments field to automatically " "fill in the respective values.<br>") self.parent = parent self.external = external # Widgets self.server_settings_description = QLabel(description) self.lang_cb = QComboBox(self) self.external_cb = QCheckBox(_('External server'), self) self.host_label = QLabel(_('Host:')) self.host_input = QLineEdit(self) self.port_label = QLabel(_('Port:')) self.port_spinner = QSpinBox(self) self.cmd_label = QLabel(_('Command:')) self.cmd_input = QLineEdit(self) self.args_label = QLabel(_('Arguments:')) self.args_input = QLineEdit(self) self.json_label = QLabel(self.JSON_VALID, self) self.conf_label = QLabel(_('<b>Server Configuration:</b>')) self.conf_input = CodeEditor(None) self.bbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) self.button_ok = self.bbox.button(QDialogButtonBox.Ok) self.button_cancel = self.bbox.button(QDialogButtonBox.Cancel) # Widget setup self.setMinimumSize(self.MIN_SIZE) self.setWindowTitle(_('LSP server editor')) self.server_settings_description.setWordWrap(True) self.lang_cb.setToolTip( _('Programming language provided by the LSP server')) self.lang_cb.addItem(_('Select a language')) self.lang_cb.addItems(LSP_LANGUAGES) self.button_ok.setEnabled(False) if language is not None: idx = LSP_LANGUAGES.index(language) self.lang_cb.setCurrentIndex(idx + 1) self.button_ok.setEnabled(True) self.host_input.setPlaceholderText('127.0.0.1') self.host_input.setText(host) self.host_input.textChanged.connect(lambda x: self.validate()) self.port_spinner.setToolTip(_('TCP port number of the server')) self.port_spinner.setMinimum(1) self.port_spinner.setMaximum(60000) self.port_spinner.setValue(port) self.cmd_input.setText(cmd) self.cmd_input.setPlaceholderText('/absolute/path/to/command') self.args_input.setToolTip( _('Additional arguments required to start the server')) self.args_input.setText(args) self.args_input.setPlaceholderText(r'--host {host} --port {port}') self.conf_input.setup_editor(language='json', color_scheme=CONF.get( 'appearance', 'selected'), wrap=False, edge_line=True, highlight_current_line=True, highlight_current_cell=True, occurrence_highlighting=True, auto_unindent=True, font=get_font(), filename='config.json', folding=False) self.conf_input.set_language('json', 'config.json') self.conf_input.setToolTip( _('Additional LSP server configuration ' 'set at runtime. JSON required')) try: conf_text = json.dumps(configurations, indent=4, sort_keys=True) except Exception: conf_text = '{}' self.conf_input.set_text(conf_text) self.external_cb.setToolTip( _('Check if the server runs on a remote location')) self.external_cb.setChecked(external) self.stdio_cb = QCheckBox(_('Use stdio pipes for communication'), self) self.stdio_cb.setToolTip( _('Check if the server communicates ' 'using stdin/out pipes')) self.stdio_cb.setChecked(stdio) # Layout setup hlayout = QHBoxLayout() general_vlayout = QVBoxLayout() general_vlayout.addWidget(self.server_settings_description) vlayout = QVBoxLayout() lang_group = QGroupBox(_('Language')) lang_layout = QVBoxLayout() lang_layout.addWidget(self.lang_cb) lang_group.setLayout(lang_layout) vlayout.addWidget(lang_group) server_group = QGroupBox(_('Language server')) server_layout = QGridLayout() server_layout.addWidget(self.cmd_label, 0, 0) server_layout.addWidget(self.cmd_input, 0, 1) server_layout.addWidget(self.args_label, 1, 0) server_layout.addWidget(self.args_input, 1, 1) server_group.setLayout(server_layout) vlayout.addWidget(server_group) address_group = QGroupBox(_('Server address')) host_layout = QVBoxLayout() host_layout.addWidget(self.host_label) host_layout.addWidget(self.host_input) port_layout = QVBoxLayout() port_layout.addWidget(self.port_label) port_layout.addWidget(self.port_spinner) conn_info_layout = QHBoxLayout() conn_info_layout.addLayout(host_layout) conn_info_layout.addLayout(port_layout) address_group.setLayout(conn_info_layout) vlayout.addWidget(address_group) advanced_group = QGroupBox(_('Advanced')) advanced_layout = QVBoxLayout() advanced_layout.addWidget(self.external_cb) advanced_layout.addWidget(self.stdio_cb) advanced_group.setLayout(advanced_layout) vlayout.addWidget(advanced_group) conf_layout = QVBoxLayout() conf_layout.addWidget(self.conf_label) conf_layout.addWidget(self.conf_input) conf_layout.addWidget(self.json_label) vlayout.addStretch() hlayout.addLayout(vlayout, 2) hlayout.addLayout(conf_layout, 3) general_vlayout.addLayout(hlayout) general_vlayout.addWidget(self.bbox) self.setLayout(general_vlayout) self.form_status(False) # Signals if not external: self.cmd_input.textChanged.connect(lambda x: self.validate()) self.external_cb.stateChanged.connect(self.set_local_options) self.stdio_cb.stateChanged.connect(self.set_stdio_options) self.lang_cb.currentIndexChanged.connect(self.lang_selection_changed) self.conf_input.textChanged.connect(self.validate) self.bbox.accepted.connect(self.accept) self.bbox.rejected.connect(self.reject) # Final setup if language is not None: self.form_status(True) self.validate() if stdio: self.set_stdio_options(True) if external: self.set_local_options(True)
def setup_page(self): pybutton = QPushButton('Click me', self) # pybutton.resize(100, 32) # pybutton.move(50, 50) pybutton.clicked.connect(self.clickMethod) # Connections group connections_group = QGroupBox(_("Automatic connections")) connections_label = QLabel(_("This pane can automatically " "show an object's help information after " "a left parenthesis is written next to it. " "Below you can decide to which plugin " "you want to connect it to turn on this " "feature.")) connections_label.setWordWrap(True) editor_box = self.create_checkbox(_("Editor"), 'connect/editor') ipython_box = self.create_checkbox(_("IPython Console"), 'connect/ipython_console') connections_layout = QVBoxLayout() connections_layout.addWidget(connections_label) connections_layout.addWidget(editor_box) connections_layout.addWidget(ipython_box) connections_group.setLayout(connections_layout) # Features group features_group = QGroupBox(_("Additional features")) math_box = self.create_checkbox(_("Render mathematical equations"), 'math') req_sphinx = programs.is_module_installed('sphinx', '>=1.1') math_box.setEnabled(req_sphinx) if not req_sphinx: sphinx_ver = programs.get_module_version('sphinx') sphinx_tip = _("This feature requires Sphinx 1.1 or superior.") sphinx_tip += "\n" + _("Sphinx %s is currently installed.") % sphinx_ver math_box.setToolTip(sphinx_tip) features_layout = QVBoxLayout() features_layout.addWidget(math_box) features_group.setLayout(features_layout) # Source code group sourcecode_group = QGroupBox(_("Source code")) wrap_mode_box = self.create_checkbox(_("Wrap lines"), 'wrap') sourcecode_layout = QVBoxLayout() sourcecode_layout.addWidget(wrap_mode_box) sourcecode_group.setLayout(sourcecode_layout) # Final layout vlayout = QVBoxLayout() vlayout.addWidget(connections_group) vlayout.addWidget(features_group) vlayout.addWidget(sourcecode_group) vlayout.addWidget(pybutton) vlayout.addStretch(1) self.setLayout(vlayout)
class AnimationWindow(PyDialog): """ +-------------------+ | Animation | +-------------------------+ | icase ______ | | scale ______ Default | | time ______ Default | | | | nframes ______ Default | | resolu. ______ Default | | Dir ______ Browse | | iFrame ______ | | | | Animations: | | o Scale, Phase, Time | | | | x delete images | | x repeat | # TODO: change to an integer | x make gif | | | | Step, RunAll | | Close | +-------------------------+ TODO: add key-frame support """ def __init__(self, data, win_parent=None, fringe_cases=None, is_gui_parent=False): PyDialog.__init__(self, data, win_parent) # is the parent the gui? self.is_gui_parent = False self.fringe_cases = fringe_cases self.set_font_size(data['font_size']) self.istep = 0 self._animate_type = 'time' self._updated_animation = False self._active_deformation = 0. self._icase_fringe = data['icase_fringe'] self._icase_disp = data['icase_disp'] self._icase_vector = data['icase_vector'] self._default_title = data['title'] self._default_time = data['time'] self._default_fps = data['frames/sec'] self._default_resolution = data['resolution'] self._scale = data['scale'] self._default_scale = data['default_scale'] self._default_is_scale = data['is_scale'] self._arrow_scale = data['arrow_scale'] self._default_arrow_scale = data['default_arrow_scale'] self._phase = data['phase'] self._default_phase = data['default_phase'] self._default_dirname = data['dirname'] self._default_gif_name = os.path.join(self._default_dirname, data['title'] + '.gif') self.animation_types = [ 'Animate Scale', ] #'Animate Phase', #'Animate Time', #'Animate Frequency Sweep' #] self.setWindowTitle('Animate Model') self.create_widgets() self.create_layout() self.set_connections() self.is_gui = False self.gui = None if hasattr(self.win_parent, '_updated_legend'): self.win_parent.is_animate_open = True self.is_gui = True self.gui = self.win_parent.win_parent if is_gui_parent: self.is_gui = True self.gui = self.win_parent self.on_update_min_max_defaults() def create_widgets(self): """creates the menu objects""" self.box_scale = QGroupBox('Animate Scale') self.box_time = QGroupBox('Animate Time') icase_max = 1000 # TODO: update 1000 self.checkbox_fringe = QCheckBox('Animate') self.checkbox_fringe.setToolTip( 'Animate the fringe in addition to the deflection') #self.checkbox_disp = QCheckBox('Animate') self.checkbox_fringe.setEnabled(False) self.icase_fringe_label = QLabel("iCase (Fringe):") self.icase_fringe_edit = QSpinBox(self) self.icase_fringe_edit.setRange(0, icase_max) self.icase_fringe_edit.setSingleStep(1) if self._icase_fringe is not None: self.icase_fringe_edit.setValue(self._icase_fringe) self.icase_fringe_edit.setToolTip( 'Case Number for the Scale/Phase Animation Type.\n' 'Defaults to the result you had shown when you clicked "Create Animation".\n' 'iCase can be seen by clicking "Apply" on a result.') self.icase_disp_label = QLabel("iCase (Disp):") self.icase_disp_edit = QSpinBox(self) self.icase_disp_edit.setRange(1, icase_max) self.icase_disp_edit.setSingleStep(1) if self._icase_disp is not None: self.icase_disp_edit.setValue(self._icase_disp) self.checkbox_vector = QCheckBox('Animate') self.checkbox_vector.setToolTip( 'Animate the vector in addition to the deflection') self.checkbox_vector.hide() #self.checkbox_disp = QCheckBox('Animate') self.icase_vector_label = QLabel("iCase (Vector):") self.icase_vector_edit = QSpinBox(self) self.icase_vector_edit.setRange(1, icase_max) self.icase_vector_edit.setSingleStep(1) if self._icase_vector is not None: self.icase_vector_edit.setValue(self._icase_vector) self.scale_label = QLabel("True Scale:") self.scale_edit = QLineEdit(str(self._scale)) self.scale_button = QPushButton("Default") self.scale_edit.setToolTip('Scale factor of the "deflection"') self.scale_button.setToolTip('Sets the scale factor of the gif to %s' % self._scale) self.arrow_scale_label = QLabel("Arrow Scale:") self.arrow_scale_edit = QLineEdit(str(self._scale)) self.arrow_scale_button = QPushButton("Default") self.arrow_scale_edit.setToolTip('Scale factor of the "arrows"') self.arrow_scale_button.setToolTip('Sets the arrow scale factor of the gif to %s' % ( self._arrow_scale)) self.arrow_scale_label.setVisible(False) self.arrow_scale_edit.setVisible(False) self.arrow_scale_button.setVisible(False) self.time_label = QLabel("Total Time (sec):") self.time_edit = QDoubleSpinBox(self) self.time_edit.setValue(self._default_time) self.time_edit.setRange(0.1, 5. * 60.) self.time_edit.setDecimals(2) self.time_edit.setSingleStep(0.1) self.time_button = QPushButton("Default") self.time_edit.setToolTip("Total time of the gif") self.time_button.setToolTip('Sets the total time of the gif to %.2f' % self._default_time) self.fps_label = QLabel("Frames/Second:") self.fps_edit = QSpinBox(self) self.fps_edit.setRange(1, 60) self.fps_edit.setSingleStep(1) self.fps_edit.setValue(self._default_fps) self.fps_button = QPushButton("Default") self.fps_edit.setToolTip("A higher FPS is smoother, but may not play well for large gifs") self.fps_button.setToolTip('Sets the FPS to %s' % self._default_fps) self.resolution_label = QLabel("Resolution Scale:") self.resolution_edit = QSpinBox(self) self.resolution_edit.setRange(1, 5) self.resolution_edit.setSingleStep(1) self.resolution_edit.setValue(self._default_resolution) self.resolution_button = QPushButton("Default") self.resolution_edit.setToolTip('Scales the window resolution by an integer factor') self.resolution_button.setToolTip('Sets the resolution to %s' % self._default_resolution) #----------------- # Time plot self.fringe_label = QLabel("Fringe") self.icase_fringe_start_edit = QSpinBox(self) self.icase_fringe_start_edit.setRange(0, icase_max) self.icase_fringe_start_edit.setSingleStep(1) self.icase_fringe_start_edit.setValue(self._icase_fringe) self.icase_fringe_start_button = QPushButton("Default") self.icase_fringe_end_edit = QSpinBox(self) self.icase_fringe_end_edit.setRange(0, icase_max) self.icase_fringe_end_edit.setSingleStep(1) self.icase_fringe_end_edit.setValue(self._icase_fringe) self.icase_fringe_end_button = QPushButton("Default") self.icase_fringe_delta_edit = QSpinBox(self) self.icase_fringe_delta_edit.setRange(1, icase_max) self.icase_fringe_delta_edit.setSingleStep(1) self.icase_fringe_delta_edit.setValue(1) self.icase_fringe_delta_button = QPushButton("Default") self.displacement_label = QLabel("Displacement") self.icase_start = QLabel("iCase Start:") self.icase_disp_start_edit = QSpinBox(self) self.icase_disp_start_edit.setRange(0, icase_max) self.icase_disp_start_edit.setSingleStep(1) self.icase_disp_start_edit.setValue(self._icase_fringe) self.icase_disp_start_button = QPushButton("Default") self.icase_end_label = QLabel("iCase End:") self.icase_disp_end_edit = QSpinBox(self) self.icase_disp_end_edit.setRange(0, icase_max) self.icase_disp_end_edit.setSingleStep(1) self.icase_disp_end_edit.setValue(self._icase_fringe) self.icase_disp_end_button = QPushButton("Default") self.icase_delta_label = QLabel("iCase Delta:") self.icase_disp_delta_edit = QSpinBox(self) self.icase_disp_delta_edit.setRange(1, icase_max) self.icase_disp_delta_edit.setSingleStep(1) self.icase_disp_delta_edit.setValue(1) self.icase_disp_delta_button = QPushButton("Default") self.min_value_enable = QCheckBox() self.min_value_label = QLabel("Min Value:") self.min_value_edit = QLineEdit('') #self.min_value_edit.setRange(1, 1000) #self.min_value_edit.setSingleStep(1) #self.min_value_edit.setValue(1) self.min_value_button = QPushButton("Default") self.max_value_enable = QCheckBox() self.max_value_label = QLabel("Max Value:") self.max_value_edit = QLineEdit('') #self.min_value_edit.setRange(1, 1000) # TODO: update 1000 #self.min_value_edit.setSingleStep(1) #self.min_value_edit.setValue(1) self.max_value_button = QPushButton("Default") # TODO: enable this (uncomment) ------------------------------------------ #self.min_value_enable.hide() #self.min_value.hide() #self.min_value_edit.hide() #self.min_value_button.hide() #self.max_value_enable.hide() #self.max_value.hide() #self.max_value_edit.hide() #self.max_value_button.hide() # TODO: enable this (uncomment) ------------------------------------------ self.icase_disp_start_edit.setToolTip('The first frame of the animation') self.icase_disp_end_edit.setToolTip( 'The last frame of the animation\n' 'Assumes icase_start + nframes * icase_delta = icase_end') self.icase_disp_delta_edit.setToolTip( 'The frame step size (to skip non-consecutive results).\n' 'Frame skipping can be used to:\n' " - skip across results that you don't want to plot\n" ' - adjust the FPS') self.min_value_edit.setToolTip('Min value of the legend (not supported)') self.max_value_edit.setToolTip('Max value of the legend (not supported)') #'time' : 0., #'default_time' : 0, #'icase_start' : 10, #'icase_delta' : 3, #'min_value' : 0., #'max_value' : 1000., self.browse_folder_label = QLabel('Output Directory:') self.browse_folder_edit = QLineEdit(str(self._default_dirname)) self.browse_folder_button = QPushButton('Browse...') self.browse_folder_edit.setToolTip('Location to save the png/gif files') self.gif_label = QLabel("Gif Filename:") self.gif_edit = QLineEdit(str(self._default_title + '.gif')) self.gif_button = QPushButton('Default') self.gif_edit.setToolTip('Name of the gif') self.gif_button.setToolTip('Sets the name of the gif to %s.gif' % self._default_title) # scale / phase if 1: # pragma: no cover self.animate_scale_radio = QRadioButton("Animate Scale") self.animate_phase_radio = QRadioButton("Animate Phase") self.animate_time_radio = QRadioButton("Animate Time") self.animate_freq_sweeep_radio = QRadioButton("Animate Frequency Sweep") self.animate_scale_radio.setToolTip( 'Animates the scale factor based on the "Animation Type"') self.animate_time_radio.setToolTip('Animates the time/load/mode step') self.animate_scale_radio.setChecked(self._default_is_scale) self.animate_phase_radio.setChecked(not self._default_is_scale) self.animate_time_radio.setChecked(False) msg = 'Scale : Animates the scale factor based on the "Animation Profile"\n' if self._default_phase is None: self.animate_phase_radio.setDisabled(True) self.animate_phase_radio.setToolTip('Animates the phase angle ' '(only for complex results)') msg += 'Phase : Animates the phase angle (only for complex results)\n' else: self.animate_phase_radio.setToolTip("Animates the phase angle") msg += 'Phase : Animates the phase angle\n' msg += ( 'Time : Animates the time/load/mode step\n' 'Freq Sweep : Animates a complex result across a range of frequencies ' '(not supported)\n' ) self.animate_freq_sweeep_radio.setDisabled(True) self.animate_freq_sweeep_radio.setToolTip( 'Animates a complex result across a range of frequencies (not supported)') else: msg = 'Scale : Animates the scale factor based on the "Animation Profile"\n' if self._default_phase is None: #self.animate_phase_radio.setDisabled(True) #self.animate_phase_radio.setToolTip('Animates the phase angle ' #'(only for complex results)') msg += 'Phase : Animates the phase angle (only for complex results)\n' else: #self.animate_phase_radio.setToolTip("Animates the phase angle") msg += 'Phase : Animates the phase angle\n' msg += ( 'Time : Animates the time/load/mode step\n' 'Freq Sweep : Animates a complex result across a range of frequencies ' '(not supported)\n' ) self.animation_type = QLabel("Animation Type:") animation_type = OrderedDict() #scale_msg = 'Scale\n' #phase_msg = 'Phase\n' #time_msg = 'Time\n' #animation_types = [ #('Animate Scale', scale_msg), #('Animate Phase', phase_msg), #('Animate Time', time_msg), ##'Animate Frequency Sweep' #] if self._phase is not None: self.animation_types.append('Animate Phase') self.animation_types.append('Animate Time') self.animation_profile_label = QLabel("Animation Profile:") self.animation_profile_edit = QComboBox() for animation_profile in ANIMATION_PROFILES: self.animation_profile_edit.addItem(animation_profile) self.animation_profile_edit.setToolTip('The profile for a scaled GIF') self.animation_type_edit = QComboBox() # TODO: add a tooltip for each item for animation_type in self.animation_types: self.animation_type_edit.addItem(animation_type) #self.animation_type_edit.setToolTip('The profile for a scaled GIF') self.animation_type_edit.setToolTip(msg.rstrip()) self.csv_profile_label = QLabel("CSV profile:") self.csv_profile_edit = QLineEdit() self.csv_profile_browse_button = QPushButton('Browse') self.csv_profile_edit.setToolTip( 'The path to the CSV file of (Scale1, Scale2, Scale3, ...)') #widget = QWidget(self) #horizontal_vertical_group = QButtonGroup(widget) #horizontal_vertical_group.addButton(self.animate_scale_radio) #horizontal_vertical_group.addButton(self.animate_phase_radio) #horizontal_vertical_group.addButton(self.animate_time_radio) #horizontal_vertical_group.addButton(self.animate_freq_sweeep_radio) # animate in gui self.animate_in_gui_checkbox = QCheckBox("Animate In GUI?") self.animate_in_gui_checkbox.setChecked(True) # make images self.make_images_checkbox = QCheckBox("Make images?") self.make_images_checkbox.setChecked(True) # make images self.overwrite_images_checkbox = QCheckBox("Overwrite images?") self.overwrite_images_checkbox.setChecked(True) # delete images when finished self.delete_images_checkbox = QCheckBox("Delete images when finished?") self.delete_images_checkbox.setChecked(True) # endless loop self.repeat_checkbox = QCheckBox("Repeat?") self.repeat_checkbox.setChecked(True) self.repeat_checkbox.setToolTip("Repeating creates an infinitely looping gif") # endless loop self.make_gif_checkbox = QCheckBox("Make Gif?") if IS_IMAGEIO: self.make_gif_checkbox.setChecked(True) else: self.make_gif_checkbox.setChecked(False) self.make_gif_checkbox.setEnabled(False) self.make_gif_checkbox.setToolTip('imageio is not available; install it') # bottom buttons self.step_button = QPushButton("Step") self.wipe_button = QPushButton("Wipe Deformed Shape") self.stop_button = QPushButton("Stop") self.run_button = QPushButton("Run") self.step_button.setToolTip('Steps through the animation (for testing)') self.wipe_button.setToolTip('Removes the existing "deflecton" from the animation') self.stop_button.setToolTip('Stops the animation') self.run_button.setToolTip('Creates the animation') self.step_button.hide() self.wipe_button.hide() self.wipe_button.setEnabled(False) #self.wipe_button.hide() self.stop_button.setEnabled(False) self.cancel_button = QPushButton("Close") #self.set_grid_time(enabled=False) #self.set_grid_scale(enabled=self._default_is_scale) if self._default_phase: self.on_animate_phase(force=True) set_combo_box_text(self.animation_type_edit, 'Animate Phase') else: self.on_animate_scale(force=True) def set_connections(self): """creates the actions for the menu""" self.checkbox_vector.clicked.connect(self.on_checkbox_vector) self.scale_button.clicked.connect(self.on_default_scale) self.arrow_scale_button.clicked.connect(self.on_default_arrow_scale) self.time_button.clicked.connect(self.on_default_time) self.fps_button.clicked.connect(self.on_default_fps) self.resolution_button.clicked.connect(self.on_default_resolution) self.browse_folder_button.clicked.connect(self.on_browse_folder) self.csv_profile_browse_button.clicked.connect(self.on_browse_csv) self.gif_button.clicked.connect(self.on_default_title) self.step_button.clicked.connect(self.on_step) self.wipe_button.clicked.connect(self.on_wipe) self.stop_button.clicked.connect(self.on_stop) self.run_button.clicked.connect(self.on_run) self.min_value_enable.clicked.connect(self.on_min_value_enable) self.max_value_enable.clicked.connect(self.on_max_value_enable) self.min_value_button.clicked.connect(self.on_min_value_default) self.max_value_button.clicked.connect(self.on_max_value_default) self.icase_disp_start_button.clicked.connect(self.on_update_min_max_defaults) #self.animate_scale_radio.clicked.connect(self.on_animate_scale) #self.animate_phase_radio.clicked.connect(self.on_animate_phase) #self.animate_time_radio.clicked.connect(self.on_animate_time) self.animation_type_edit.currentIndexChanged.connect(self.on_animate) #self.animate_freq_sweeep_radio self.cancel_button.clicked.connect(self.on_cancel) self.animate_in_gui_checkbox.clicked.connect(self.on_animate_in_gui) self.animate_in_gui_checkbox.setChecked(True) self.on_animate_in_gui() def on_checkbox_vector(self): is_enabled = self.checkbox_vector.isEnabled() is_checked = self.checkbox_vector.isChecked() enable_edit = is_enabled and is_checked self.icase_vector_label.setEnabled(is_checked) self.icase_vector_edit.setEnabled(enable_edit) def on_animate_in_gui(self): animate_in_gui = self.animate_in_gui_checkbox.isChecked() enable = not animate_in_gui if HIDE_WHEN_INACTIVE: self.make_images_checkbox.setVisible(enable) self.delete_images_checkbox.setVisible(enable) self.make_gif_checkbox.setVisible(enable) self.repeat_checkbox.setVisible(enable) self.resolution_button.setVisible(enable) self.resolution_label.setVisible(enable) self.resolution_edit.setVisible(enable) self.gif_label.setVisible(enable) self.gif_edit.setVisible(enable) self.gif_button.setVisible(enable) self.browse_folder_label.setVisible(enable) self.browse_folder_button.setVisible(enable) self.browse_folder_edit.setVisible(enable) self.step_button.setEnabled(enable) self.make_images_checkbox.setEnabled(enable) self.delete_images_checkbox.setEnabled(enable) self.make_gif_checkbox.setEnabled(enable) self.repeat_checkbox.setEnabled(enable) self.resolution_button.setEnabled(enable) self.resolution_edit.setEnabled(enable) self.gif_edit.setEnabled(enable) self.gif_button.setEnabled(enable) self.browse_folder_button.setEnabled(enable) self.browse_folder_edit.setEnabled(enable) self.step_button.setEnabled(enable) #wipe_button def on_animate(self, value): """ animate pulldown Parameters ---------- value : int index in animation_types """ #animation_types = ['Animate Scale', 'Animate Phase', 'Animate Time', #'Animate Frequency Sweep'] animation_type = self.animation_types[value] if animation_type == 'Animate Scale': self.on_animate_scale() elif animation_type == 'Animate Phase': self.on_animate_phase() elif animation_type == 'Animate Time': self.on_animate_time() else: raise NotImplementedError('value = ', value) def on_animate_time(self, force=False): """enables the secondary input""" #print('on_animate_time') if self._animate_type == 'scale' or force: self.set_grid_scale(False, 'time') self.set_grid_time(True, 'time') self._animate_type = 'time' def on_animate_scale(self, force=False): """enables the secondary input""" #print('on_animate_scale') self.set_grid_scale(True, 'scale') if self._animate_type == 'time' or force: self.set_grid_time(False, 'scale') self._animate_type = 'scale' def on_animate_phase(self, force=False): """enables the secondary input""" #print('on_animate_phase') if self._animate_type == 'scale' or force: self.set_grid_scale(False, 'phase') if self._animate_type == 'time' or force: self.set_grid_time(False, 'phase') self._animate_type = 'phase' def set_grid_scale(self, enabled=True, word=''): """enables/disables the secondary input""" #print('%s-set_grid_scale; enabled = %r' % (word, enabled)) if HIDE_WHEN_INACTIVE: self.box_scale.setVisible(enabled) self.animation_profile_label.setVisible(enabled) self.animation_profile_edit.setVisible(enabled) #self.min_value_enable.setVisible(enabled) #self.max_value_enable.setVisible(enabled) self.animation_profile_label.setEnabled(enabled) self.animation_profile_edit.setEnabled(enabled) # TODO: doesn't work... #self.csv_profile.setEnabled(enabled) #self.csv_profile_edit.setEnabled(enabled) #self.csv_profile_button.setEnabled(enabled) self.min_value_enable.setEnabled(enabled) self.max_value_enable.setEnabled(enabled) self.on_min_value_enable() self.on_max_value_enable() def set_grid_time(self, enabled=True, word=''): """enables/disables the secondary input""" #print('%s-set_grid_time; enabled = %r' % (word, enabled)) if HIDE_WHEN_INACTIVE: self.box_time.setVisible(enabled) self.checkbox_fringe.setVisible(not enabled) self.icase_fringe_label.setVisible(not enabled) self.icase_fringe_edit.setVisible(not enabled) self.icase_disp_label.setVisible(not enabled) self.icase_disp_edit.setVisible(not enabled) self.icase_vector_label.setVisible(not enabled) self.icase_vector_edit.setVisible(not enabled) #self.icase_fringe_delta_edit.setVisible(enabled) self.icase_disp_delta_edit.setVisible(enabled) self.icase_disp_delta_edit.setVisible(enabled) self.fps_label.setVisible(enabled) self.fps_edit.setVisible(enabled) self.fps_button.setVisible(enabled) self.displacement_label.setEnabled(enabled) self.fringe_label.setEnabled(enabled) self.icase_start.setEnabled(enabled) self.icase_disp_start_edit.setEnabled(enabled) self.icase_disp_start_button.setEnabled(enabled) self.icase_fringe_start_edit.setEnabled(enabled) self.icase_fringe_start_button.setEnabled(enabled) self.icase_end_label.setEnabled(enabled) self.icase_disp_end_edit.setEnabled(enabled) self.icase_disp_end_button.setEnabled(enabled) self.icase_fringe_end_edit.setEnabled(enabled) self.icase_fringe_end_button.setEnabled(enabled) self.icase_delta_label.setEnabled(enabled) self.icase_disp_delta_edit.setEnabled(enabled) self.icase_disp_delta_button.setEnabled(enabled) self.icase_fringe_delta_edit.setEnabled(enabled) self.icase_fringe_delta_button.setEnabled(enabled) #----------------------------------------------------------------------- is_min_enabled = self.min_value_enable.isChecked() self.min_value_label.setEnabled(is_min_enabled) self.min_value_edit.setEnabled(is_min_enabled) self.min_value_button.setEnabled(is_min_enabled) is_max_enabled = self.max_value_enable.isChecked() self.max_value_label.setEnabled(is_max_enabled) self.max_value_edit.setEnabled(is_max_enabled) self.max_value_button.setEnabled(is_max_enabled) self.min_value_enable.setEnabled(enabled) self.on_min_value_enable() #self.min_value.setEnabled(enabled) #self.min_value_edit.setEnabled(enabled) #self.min_value_button.setEnabled(enabled) self.max_value_enable.setEnabled(enabled) self.on_max_value_enable() #self.max_value.setEnabled(enabled) #self.max_value_edit.setEnabled(enabled) #self.max_value_button.setEnabled(enabled) self.icase_fringe_label.setEnabled(not enabled) self.icase_fringe_edit.setEnabled(not enabled) self.checkbox_fringe.setEnabled(not enabled) self.icase_disp_label.setEnabled(not enabled) self.icase_disp_edit.setEnabled(not enabled) self.icase_vector_label.setEnabled(not enabled) self.icase_vector_edit.setEnabled(not enabled) self.checkbox_vector.setEnabled(not enabled) self.on_checkbox_vector() self.fps_label.setEnabled(not enabled) self.fps_edit.setEnabled(not enabled) self.fps_button.setEnabled(not enabled) def on_min_value_enable(self): """ The min edit value box is enabled when we switch to time and the box is checked """ is_min_enabled = self.min_value_enable.isChecked() and self.min_value_enable.isEnabled() self.min_value_label.setEnabled(is_min_enabled) self.min_value_edit.setEnabled(is_min_enabled) self.min_value_button.setEnabled(is_min_enabled) def on_max_value_enable(self): """ The max edit value box is enabled when we switch to time and the box is checked """ is_max_enabled = self.max_value_enable.isChecked() and self.max_value_enable.isEnabled() self.max_value_label.setEnabled(is_max_enabled) self.max_value_edit.setEnabled(is_max_enabled) self.max_value_button.setEnabled(is_max_enabled) def on_update_min_max_defaults(self): """ When the icase is changed, the min/max value default message is changed """ icase = self.icase_disp_start_edit.value() min_value, max_value = self.get_min_max(icase) self.min_value_button.setToolTip('Sets the min value to %g' % min_value) self.max_value_button.setToolTip('Sets the max value to %g' % max_value) def on_min_value_default(self): """When min default icase is pressued, update the value""" icase = self.icase_disp_start_edit.value() min_value = self.get_min_max(icase)[0] self.min_value_edit.setText(str(min_value)) self.min_value_edit.setStyleSheet("QLineEdit{background: white;}") def on_max_value_default(self): """When max default icase is pressued, update the value""" icase = self.icase_disp_start_edit.value() max_value = self.get_min_max(icase)[1] self.max_value_edit.setText(str(max_value)) self.max_value_edit.setStyleSheet("QLineEdit{background: white;}") def on_browse_folder(self): """opens a folder dialog""" dirname = getexistingdirectory(parent=self, caption='Select a Directory', basedir='', options=QFileDialog.ShowDirsOnly) if not dirname: return self.browse_folder_edit.setText(dirname) def on_browse_csv(self): """opens a file dialog""" default_filename = '' file_types = 'Delimited Text (*.txt; *.dat; *.csv)' dirname = open_file_dialog(self, 'Select a CSV File', default_filename, file_types) if not dirname: return self.csv_profile_browse_button.setText(dirname) def on_default_title(self): """sets the default gif name""" self.gif_edit.setText(self._default_title + '.gif') def on_default_scale(self): """sets the default displacement scale factor""" if self.is_gui: icase_disp = self.icase_disp_edit.value() out = self.gui.legend_obj.get_legend_disp( icase_disp) unused_scale, unused_phase, default_scale, unused_default_phase = out else: default_scale = self._default_scale self.scale_edit.setText(str(default_scale)) self.scale_edit.setStyleSheet("QLineEdit{background: white;}") def on_default_arrow_scale(self): """sets the default arrow scale factor""" if self.is_gui: icase_vector = self.icase_vector_edit.value() out = self.gui.legend_obj.get_legend_vector(icase_vector) unused_arrow_scale, default_arrow_scale = out else: default_arrow_scale = self._default_arrow_scale self.arrow_scale_edit.setText(str(default_arrow_scale)) self.arrow_scale_edit.setStyleSheet("QLineEdit{background: white;}") def on_default_time(self): """sets the default gif time""" self.time_edit.setValue(self._default_time) def on_default_fps(self): """sets the default FPS""" self.fps_edit.setValue(self._default_fps) def on_default_resolution(self): """sets the default image resolution scale factor""" self.resolution_edit.setValue(self._default_resolution) def create_layout(self): """displays the menu objects""" grid = QGridLayout() irow = 0 grid.addWidget(self.icase_fringe_label, irow, 0) grid.addWidget(self.icase_fringe_edit, irow, 1) grid.addWidget(self.checkbox_fringe, irow, 2) irow += 1 grid.addWidget(self.icase_disp_label, irow, 0) grid.addWidget(self.icase_disp_edit, irow, 1) #grid.addWidget(self.checkbox_disp, irow, 2) irow += 1 grid.addWidget(self.icase_vector_label, irow, 0) grid.addWidget(self.icase_vector_edit, irow, 1) grid.addWidget(self.checkbox_vector, irow, 2) irow += 1 grid.addWidget(self.scale_label, irow, 0) grid.addWidget(self.scale_edit, irow, 1) grid.addWidget(self.scale_button, irow, 2) irow += 1 grid.addWidget(self.arrow_scale_label, irow, 0) grid.addWidget(self.arrow_scale_edit, irow, 1) grid.addWidget(self.arrow_scale_button, irow, 2) irow += 1 grid.addWidget(self.time_label, irow, 0) grid.addWidget(self.time_edit, irow, 1) grid.addWidget(self.time_button, irow, 2) irow += 1 # spacer spacer = QLabel('') grid.addWidget(self.fps_label, irow, 0) grid.addWidget(self.fps_edit, irow, 1) grid.addWidget(self.fps_button, irow, 2) irow += 1 grid.addWidget(self.animation_type, irow, 0) grid.addWidget(self.animation_type_edit, irow, 1) irow += 1 grid.addWidget(spacer, irow, 0) irow += 1 #---------- #Time grid_time = QGridLayout() jrow = 0 self.fringe_label.setAlignment(Qt.AlignCenter) self.displacement_label.setAlignment(Qt.AlignCenter) if not IS_TIME_FRINGE: self.fringe_label.hide() self.icase_fringe_delta_edit.hide() self.icase_fringe_start_edit.hide() self.icase_fringe_end_edit.hide() self.icase_fringe_delta_button.hide() grid_time.addWidget(self.displacement_label, jrow, 1) grid_time.addWidget(self.fringe_label, jrow, 2) jrow += 1 grid_time.addWidget(self.icase_start, jrow, 0) grid_time.addWidget(self.icase_disp_start_edit, jrow, 1) grid_time.addWidget(self.icase_fringe_start_edit, jrow, 2) #grid_time.addWidget(self.icase_disp_start_button, jrow, 2) jrow += 1 grid_time.addWidget(self.icase_end_label, jrow, 0) grid_time.addWidget(self.icase_disp_end_edit, jrow, 1) grid_time.addWidget(self.icase_fringe_end_edit, jrow, 2) #grid_time.addWidget(self.icase_end_button, jrow, 2) jrow += 1 grid_time.addWidget(self.icase_delta_label, jrow, 0) grid_time.addWidget(self.icase_disp_delta_edit, jrow, 1) grid_time.addWidget(self.icase_fringe_delta_edit, jrow, 2) #grid_time.addWidget(self.icase_delta_button, jrow, 2) jrow += 1 hbox_min = QHBoxLayout() hbox_min.addWidget(self.min_value_enable) hbox_min.addWidget(self.min_value_label) grid_time.addLayout(hbox_min, jrow, 0) grid_time.addWidget(self.min_value_edit, jrow, 1) grid_time.addWidget(self.min_value_button, jrow, 2) jrow += 1 hbox_max = QHBoxLayout() hbox_max.addWidget(self.max_value_enable) hbox_max.addWidget(self.max_value_label) grid_time.addLayout(hbox_max, jrow, 0) grid_time.addWidget(self.max_value_edit, jrow, 1) grid_time.addWidget(self.max_value_button, jrow, 2) jrow += 1 grid_time.addWidget(spacer, jrow, 0) jrow += 1 #-------------- grid_scale = QGridLayout() grid_scale.addWidget(self.animation_profile_label, 0, 0) grid_scale.addWidget(self.animation_profile_edit, 0, 1) #grid_scale.addWidget(self.csv_profile, 1, 0) #grid_scale.addWidget(self.csv_profile_edit, 1, 1) #grid_scale.addWidget(self.csv_profile_browse_button, 1, 2) self.csv_profile = QLabel("CSV profile:") self.csv_profile_edit = QLineEdit() self.csv_profile_button = QPushButton('Browse') #box_time = QVBoxLayout() # TODO: It's super annoying that the animate time box doesn't # line up with the previous box self.box_scale.setLayout(grid_scale) self.box_time.setLayout(grid_time) #---------- grid2 = QGridLayout() irow = 0 #grid2.addWidget(self.animate_scale_radio, 8, 0) #grid2.addWidget(self.animate_phase_radio, 8, 1) #grid2.addWidget(self.animate_time_radio, 8, 2) #grid2.addWidget(self.animate_freq_sweeep_radio, 8, 3) grid2.addWidget(self.animate_in_gui_checkbox, irow, 0) irow += 1 grid2.addWidget(self.resolution_label, irow, 0) grid2.addWidget(self.resolution_edit, irow, 1) grid2.addWidget(self.resolution_button, irow, 2) irow += 1 grid2.addWidget(self.browse_folder_label, irow, 0) grid2.addWidget(self.browse_folder_edit, irow, 1) grid2.addWidget(self.browse_folder_button, irow, 2) irow += 1 grid2.addWidget(self.gif_label, irow, 0) grid2.addWidget(self.gif_edit, irow, 1) grid2.addWidget(self.gif_button, irow, 2) irow += 1 grid2.addWidget(self.make_images_checkbox, irow, 0) #grid2.addWidget(self.overwrite_images_checkbox, irow, 0) grid2.addWidget(self.delete_images_checkbox, irow, 1) grid2.addWidget(self.make_gif_checkbox, irow, 2) irow += 1 grid2.addWidget(self.repeat_checkbox, irow, 0) irow += 1 grid2.addWidget(spacer, irow, 0) grid_hbox = QHBoxLayout() grid_hbox.addWidget(spacer) grid_hbox.addLayout(grid2) grid_hbox.addWidget(spacer) # bottom buttons step_run_box = QHBoxLayout() step_run_box.addWidget(self.step_button) step_run_box.addWidget(self.wipe_button) step_run_box.addWidget(self.stop_button) step_run_box.addWidget(self.run_button) ok_cancel_box = QHBoxLayout() ok_cancel_box.addWidget(self.cancel_button) vbox = QVBoxLayout() vbox.addLayout(grid) vbox.addWidget(self.box_scale) vbox.addWidget(self.box_time) #vbox.addLayout(checkboxes) vbox.addLayout(grid_hbox) vbox.addStretch() vbox.addLayout(step_run_box) vbox.addLayout(ok_cancel_box) if IS_RESULTS_SELECTOR and self.fringe_cases: cases = get_cases_from_tree(self.fringe_cases) parent = self name = 'main' data = self.fringe_cases choices = cases results_widget = ResultsWindow(parent, name, data, choices, include_clear=False, include_delete=False) vbox_results = QVBoxLayout() results_widget_label = QLabel('Results:') vbox_results.addWidget(results_widget_label) vbox_results.addWidget(results_widget) hbox_main = QHBoxLayout() hbox_main.addLayout(vbox) hbox_main.addLayout(vbox_results) self.setLayout(hbox_main) else: self.setLayout(vbox) def on_fringe(self, icase): """sets the icase fringe""" self.icase_fringe_edit.setValue(icase) def on_disp(self, icase): """sets the icase disp""" self.icase_disp_edit.setValue(icase) def on_vector(self, icase): """sets the icase vector""" self.icase_vector_edit.setValue(icase) def on_clear_results(self): """sink for the right click menu""" pass def on_step(self): """click the Step button""" passed, validate_out = self.on_validate() if passed: try: self._make_gif(validate_out, istep=self.istep) self.istep += 1 except IndexError: self._make_gif(validate_out, istep=0) self.istep += 1 self.wipe_button.setEnabled(True) def on_wipe(self): """click the Wipe button""" passed, validate_out = self.on_validate(wipe=True) if passed: self.istep = 0 self._make_gif(validate_out, istep=self.istep) self.wipe_button.setEnabled(False) self.stop_button.setEnabled(False) def on_stop(self): """click the Stop button""" #passed, validate_out = self.on_validate() #if passed: #self._make_gif(validate_out, stop_animation=True) if self.is_gui: self.gui.stop_animation() self.wipe_button.setEnabled(True) self.stop_button.setEnabled(False) def on_run(self): """click the Run button""" self.istep = 0 self.wipe_button.setEnabled(False) self.stop_button.setEnabled(True) passed, validate_out = self.on_validate() if passed: self._make_gif(validate_out, istep=None) return passed def _make_gif(self, validate_out, istep=None, stop_animation=False): """interface for making the gif""" (icase_fringe, icase_disp, icase_vector, scale, time, fps, animate_in_gui, magnify, output_dir, gifbase, min_value, max_value) = validate_out fps = int(fps) gif_filename = None if not stop_animation and not animate_in_gui and gifbase is not None: if gifbase.lower().endswith('.gif'): gifbase = gifbase[:-4] gif_filename = os.path.join(output_dir, gifbase + '.gif') animate_fringe = self.checkbox_fringe.isChecked() animate_vector = self.checkbox_vector.isChecked() animate_scale = self.animate_scale_radio.isChecked() animate_phase = self.animate_phase_radio.isChecked() animate_time = self.animate_time_radio.isChecked() if not self.checkbox_vector.isEnabled(): icase_vector = None animate_scale = False animate_phase = False animate_time = False if self._animate_type == 'scale': animate_scale = True elif self._animate_type == 'phase': animate_phase = True elif self._animate_type == 'time': animate_time = True else: raise NotImplementedError(self._animate_type) make_images = self.make_images_checkbox.isChecked() delete_images = self.delete_images_checkbox.isChecked() make_gif = self.make_gif_checkbox.isChecked() animation_profile = str(self.animation_profile_edit.currentText()) icase_disp_start = self.icase_disp_start_edit.value() icase_disp_end = self.icase_disp_end_edit.value() icase_disp_delta = self.icase_disp_delta_edit.value() bool_repeat = self.repeat_checkbox.isChecked() # TODO: change this to an integer if bool_repeat: nrepeat = 0 else: nrepeat = 1 #self.out_data['is_shown'] = self.show_radio.isChecked() #icase = self._icase if self.is_gui: self.gui.make_gif( gif_filename, scale, istep=istep, animate_scale=animate_scale, animate_phase=animate_phase, animate_time=animate_time, icase_fringe=icase_fringe, icase_disp=icase_disp, icase_vector=icase_vector, animate_fringe=animate_fringe, animate_vector=animate_vector, icase_start=icase_disp_start, icase_end=icase_disp_end, icase_delta=icase_disp_delta, time=time, animation_profile=animation_profile, nrepeat=nrepeat, fps=fps, magnify=magnify, make_images=make_images, delete_images=delete_images, make_gif=make_gif, stop_animation=stop_animation, animate_in_gui=animate_in_gui, min_value=min_value, max_value=max_value, ) self.out_data['clicked_ok'] = True self.out_data['close'] = True def get_min_max(self, icase): if self.is_gui: (obj, (i, name)) = self.gui.result_cases[icase] min_value, max_value = obj.get_min_max(i, name) else: return 0., 1.0 return min_value, max_value def on_validate(self, wipe=False): """checks to see if the input is valid""" # requires no special validation icase_fringe, flag0 = check_int(self.icase_fringe_edit) icase_disp, unused_flaga = check_int(self.icase_disp_edit) icase_vector, unused_flagb = check_int(self.icase_vector_edit) #icase_disp = self._icase_disp #icase_vector = self._icase_vector scale, flag1 = check_float(self.scale_edit) time, flag2 = check_float(self.time_edit) fps, flag3 = check_float(self.fps_edit) min_value = max_value = None flag4 = flag5 = True if self.min_value_edit.isEnabled(): min_value, flag4 = check_float(self.min_value_edit) if self.max_value_edit.isEnabled(): max_value, flag5 = check_float(self.max_value_edit) if wipe: animate_in_gui = False scale = 0. flag1 = True else: animate_in_gui = self.animate_in_gui_checkbox.isChecked() if scale == 0.0: self.scale_edit.setStyleSheet("QLineEdit{background: red;}") flag1 = False if animate_in_gui or wipe: passed = all([flag0, flag1, flag2, flag3, flag4, flag5]) magnify, output_dir, gifbase = None, None, None else: magnify, flag6 = check_int(self.resolution_edit) output_dir, flag7 = check_path(self.browse_folder_edit) gifbase, flag8 = check_name_str(self.gif_edit) passed = all([flag0, flag1, flag2, flag3, flag4, flag5, flag6, flag7, flag8]) return passed, (icase_fringe, icase_disp, icase_vector, scale, time, fps, animate_in_gui, magnify, output_dir, gifbase, min_value, max_value) #def on_ok(self): #"""click the OK button""" #passed = self.on_apply() #if passed: #self.win_parent._animation_window_shown = False #self.close() ##self.destroy() def on_cancel(self): """click the Cancel button""" self.on_stop() self.out_data['close'] = True self.close()
def create_widgets(self): """creates the menu objects""" self.box_scale = QGroupBox('Animate Scale') self.box_time = QGroupBox('Animate Time') icase_max = 1000 # TODO: update 1000 self.checkbox_fringe = QCheckBox('Animate') self.checkbox_fringe.setToolTip( 'Animate the fringe in addition to the deflection') #self.checkbox_disp = QCheckBox('Animate') self.checkbox_fringe.setEnabled(False) self.icase_fringe_label = QLabel("iCase (Fringe):") self.icase_fringe_edit = QSpinBox(self) self.icase_fringe_edit.setRange(0, icase_max) self.icase_fringe_edit.setSingleStep(1) if self._icase_fringe is not None: self.icase_fringe_edit.setValue(self._icase_fringe) self.icase_fringe_edit.setToolTip( 'Case Number for the Scale/Phase Animation Type.\n' 'Defaults to the result you had shown when you clicked "Create Animation".\n' 'iCase can be seen by clicking "Apply" on a result.') self.icase_disp_label = QLabel("iCase (Disp):") self.icase_disp_edit = QSpinBox(self) self.icase_disp_edit.setRange(1, icase_max) self.icase_disp_edit.setSingleStep(1) if self._icase_disp is not None: self.icase_disp_edit.setValue(self._icase_disp) self.checkbox_vector = QCheckBox('Animate') self.checkbox_vector.setToolTip( 'Animate the vector in addition to the deflection') self.checkbox_vector.hide() #self.checkbox_disp = QCheckBox('Animate') self.icase_vector_label = QLabel("iCase (Vector):") self.icase_vector_edit = QSpinBox(self) self.icase_vector_edit.setRange(1, icase_max) self.icase_vector_edit.setSingleStep(1) if self._icase_vector is not None: self.icase_vector_edit.setValue(self._icase_vector) self.scale_label = QLabel("True Scale:") self.scale_edit = QLineEdit(str(self._scale)) self.scale_button = QPushButton("Default") self.scale_edit.setToolTip('Scale factor of the "deflection"') self.scale_button.setToolTip('Sets the scale factor of the gif to %s' % self._scale) self.arrow_scale_label = QLabel("Arrow Scale:") self.arrow_scale_edit = QLineEdit(str(self._scale)) self.arrow_scale_button = QPushButton("Default") self.arrow_scale_edit.setToolTip('Scale factor of the "arrows"') self.arrow_scale_button.setToolTip('Sets the arrow scale factor of the gif to %s' % ( self._arrow_scale)) self.arrow_scale_label.setVisible(False) self.arrow_scale_edit.setVisible(False) self.arrow_scale_button.setVisible(False) self.time_label = QLabel("Total Time (sec):") self.time_edit = QDoubleSpinBox(self) self.time_edit.setValue(self._default_time) self.time_edit.setRange(0.1, 5. * 60.) self.time_edit.setDecimals(2) self.time_edit.setSingleStep(0.1) self.time_button = QPushButton("Default") self.time_edit.setToolTip("Total time of the gif") self.time_button.setToolTip('Sets the total time of the gif to %.2f' % self._default_time) self.fps_label = QLabel("Frames/Second:") self.fps_edit = QSpinBox(self) self.fps_edit.setRange(1, 60) self.fps_edit.setSingleStep(1) self.fps_edit.setValue(self._default_fps) self.fps_button = QPushButton("Default") self.fps_edit.setToolTip("A higher FPS is smoother, but may not play well for large gifs") self.fps_button.setToolTip('Sets the FPS to %s' % self._default_fps) self.resolution_label = QLabel("Resolution Scale:") self.resolution_edit = QSpinBox(self) self.resolution_edit.setRange(1, 5) self.resolution_edit.setSingleStep(1) self.resolution_edit.setValue(self._default_resolution) self.resolution_button = QPushButton("Default") self.resolution_edit.setToolTip('Scales the window resolution by an integer factor') self.resolution_button.setToolTip('Sets the resolution to %s' % self._default_resolution) #----------------- # Time plot self.fringe_label = QLabel("Fringe") self.icase_fringe_start_edit = QSpinBox(self) self.icase_fringe_start_edit.setRange(0, icase_max) self.icase_fringe_start_edit.setSingleStep(1) self.icase_fringe_start_edit.setValue(self._icase_fringe) self.icase_fringe_start_button = QPushButton("Default") self.icase_fringe_end_edit = QSpinBox(self) self.icase_fringe_end_edit.setRange(0, icase_max) self.icase_fringe_end_edit.setSingleStep(1) self.icase_fringe_end_edit.setValue(self._icase_fringe) self.icase_fringe_end_button = QPushButton("Default") self.icase_fringe_delta_edit = QSpinBox(self) self.icase_fringe_delta_edit.setRange(1, icase_max) self.icase_fringe_delta_edit.setSingleStep(1) self.icase_fringe_delta_edit.setValue(1) self.icase_fringe_delta_button = QPushButton("Default") self.displacement_label = QLabel("Displacement") self.icase_start = QLabel("iCase Start:") self.icase_disp_start_edit = QSpinBox(self) self.icase_disp_start_edit.setRange(0, icase_max) self.icase_disp_start_edit.setSingleStep(1) self.icase_disp_start_edit.setValue(self._icase_fringe) self.icase_disp_start_button = QPushButton("Default") self.icase_end_label = QLabel("iCase End:") self.icase_disp_end_edit = QSpinBox(self) self.icase_disp_end_edit.setRange(0, icase_max) self.icase_disp_end_edit.setSingleStep(1) self.icase_disp_end_edit.setValue(self._icase_fringe) self.icase_disp_end_button = QPushButton("Default") self.icase_delta_label = QLabel("iCase Delta:") self.icase_disp_delta_edit = QSpinBox(self) self.icase_disp_delta_edit.setRange(1, icase_max) self.icase_disp_delta_edit.setSingleStep(1) self.icase_disp_delta_edit.setValue(1) self.icase_disp_delta_button = QPushButton("Default") self.min_value_enable = QCheckBox() self.min_value_label = QLabel("Min Value:") self.min_value_edit = QLineEdit('') #self.min_value_edit.setRange(1, 1000) #self.min_value_edit.setSingleStep(1) #self.min_value_edit.setValue(1) self.min_value_button = QPushButton("Default") self.max_value_enable = QCheckBox() self.max_value_label = QLabel("Max Value:") self.max_value_edit = QLineEdit('') #self.min_value_edit.setRange(1, 1000) # TODO: update 1000 #self.min_value_edit.setSingleStep(1) #self.min_value_edit.setValue(1) self.max_value_button = QPushButton("Default") # TODO: enable this (uncomment) ------------------------------------------ #self.min_value_enable.hide() #self.min_value.hide() #self.min_value_edit.hide() #self.min_value_button.hide() #self.max_value_enable.hide() #self.max_value.hide() #self.max_value_edit.hide() #self.max_value_button.hide() # TODO: enable this (uncomment) ------------------------------------------ self.icase_disp_start_edit.setToolTip('The first frame of the animation') self.icase_disp_end_edit.setToolTip( 'The last frame of the animation\n' 'Assumes icase_start + nframes * icase_delta = icase_end') self.icase_disp_delta_edit.setToolTip( 'The frame step size (to skip non-consecutive results).\n' 'Frame skipping can be used to:\n' " - skip across results that you don't want to plot\n" ' - adjust the FPS') self.min_value_edit.setToolTip('Min value of the legend (not supported)') self.max_value_edit.setToolTip('Max value of the legend (not supported)') #'time' : 0., #'default_time' : 0, #'icase_start' : 10, #'icase_delta' : 3, #'min_value' : 0., #'max_value' : 1000., self.browse_folder_label = QLabel('Output Directory:') self.browse_folder_edit = QLineEdit(str(self._default_dirname)) self.browse_folder_button = QPushButton('Browse...') self.browse_folder_edit.setToolTip('Location to save the png/gif files') self.gif_label = QLabel("Gif Filename:") self.gif_edit = QLineEdit(str(self._default_title + '.gif')) self.gif_button = QPushButton('Default') self.gif_edit.setToolTip('Name of the gif') self.gif_button.setToolTip('Sets the name of the gif to %s.gif' % self._default_title) # scale / phase if 1: # pragma: no cover self.animate_scale_radio = QRadioButton("Animate Scale") self.animate_phase_radio = QRadioButton("Animate Phase") self.animate_time_radio = QRadioButton("Animate Time") self.animate_freq_sweeep_radio = QRadioButton("Animate Frequency Sweep") self.animate_scale_radio.setToolTip( 'Animates the scale factor based on the "Animation Type"') self.animate_time_radio.setToolTip('Animates the time/load/mode step') self.animate_scale_radio.setChecked(self._default_is_scale) self.animate_phase_radio.setChecked(not self._default_is_scale) self.animate_time_radio.setChecked(False) msg = 'Scale : Animates the scale factor based on the "Animation Profile"\n' if self._default_phase is None: self.animate_phase_radio.setDisabled(True) self.animate_phase_radio.setToolTip('Animates the phase angle ' '(only for complex results)') msg += 'Phase : Animates the phase angle (only for complex results)\n' else: self.animate_phase_radio.setToolTip("Animates the phase angle") msg += 'Phase : Animates the phase angle\n' msg += ( 'Time : Animates the time/load/mode step\n' 'Freq Sweep : Animates a complex result across a range of frequencies ' '(not supported)\n' ) self.animate_freq_sweeep_radio.setDisabled(True) self.animate_freq_sweeep_radio.setToolTip( 'Animates a complex result across a range of frequencies (not supported)') else: msg = 'Scale : Animates the scale factor based on the "Animation Profile"\n' if self._default_phase is None: #self.animate_phase_radio.setDisabled(True) #self.animate_phase_radio.setToolTip('Animates the phase angle ' #'(only for complex results)') msg += 'Phase : Animates the phase angle (only for complex results)\n' else: #self.animate_phase_radio.setToolTip("Animates the phase angle") msg += 'Phase : Animates the phase angle\n' msg += ( 'Time : Animates the time/load/mode step\n' 'Freq Sweep : Animates a complex result across a range of frequencies ' '(not supported)\n' ) self.animation_type = QLabel("Animation Type:") animation_type = OrderedDict() #scale_msg = 'Scale\n' #phase_msg = 'Phase\n' #time_msg = 'Time\n' #animation_types = [ #('Animate Scale', scale_msg), #('Animate Phase', phase_msg), #('Animate Time', time_msg), ##'Animate Frequency Sweep' #] if self._phase is not None: self.animation_types.append('Animate Phase') self.animation_types.append('Animate Time') self.animation_profile_label = QLabel("Animation Profile:") self.animation_profile_edit = QComboBox() for animation_profile in ANIMATION_PROFILES: self.animation_profile_edit.addItem(animation_profile) self.animation_profile_edit.setToolTip('The profile for a scaled GIF') self.animation_type_edit = QComboBox() # TODO: add a tooltip for each item for animation_type in self.animation_types: self.animation_type_edit.addItem(animation_type) #self.animation_type_edit.setToolTip('The profile for a scaled GIF') self.animation_type_edit.setToolTip(msg.rstrip()) self.csv_profile_label = QLabel("CSV profile:") self.csv_profile_edit = QLineEdit() self.csv_profile_browse_button = QPushButton('Browse') self.csv_profile_edit.setToolTip( 'The path to the CSV file of (Scale1, Scale2, Scale3, ...)') #widget = QWidget(self) #horizontal_vertical_group = QButtonGroup(widget) #horizontal_vertical_group.addButton(self.animate_scale_radio) #horizontal_vertical_group.addButton(self.animate_phase_radio) #horizontal_vertical_group.addButton(self.animate_time_radio) #horizontal_vertical_group.addButton(self.animate_freq_sweeep_radio) # animate in gui self.animate_in_gui_checkbox = QCheckBox("Animate In GUI?") self.animate_in_gui_checkbox.setChecked(True) # make images self.make_images_checkbox = QCheckBox("Make images?") self.make_images_checkbox.setChecked(True) # make images self.overwrite_images_checkbox = QCheckBox("Overwrite images?") self.overwrite_images_checkbox.setChecked(True) # delete images when finished self.delete_images_checkbox = QCheckBox("Delete images when finished?") self.delete_images_checkbox.setChecked(True) # endless loop self.repeat_checkbox = QCheckBox("Repeat?") self.repeat_checkbox.setChecked(True) self.repeat_checkbox.setToolTip("Repeating creates an infinitely looping gif") # endless loop self.make_gif_checkbox = QCheckBox("Make Gif?") if IS_IMAGEIO: self.make_gif_checkbox.setChecked(True) else: self.make_gif_checkbox.setChecked(False) self.make_gif_checkbox.setEnabled(False) self.make_gif_checkbox.setToolTip('imageio is not available; install it') # bottom buttons self.step_button = QPushButton("Step") self.wipe_button = QPushButton("Wipe Deformed Shape") self.stop_button = QPushButton("Stop") self.run_button = QPushButton("Run") self.step_button.setToolTip('Steps through the animation (for testing)') self.wipe_button.setToolTip('Removes the existing "deflecton" from the animation') self.stop_button.setToolTip('Stops the animation') self.run_button.setToolTip('Creates the animation') self.step_button.hide() self.wipe_button.hide() self.wipe_button.setEnabled(False) #self.wipe_button.hide() self.stop_button.setEnabled(False) self.cancel_button = QPushButton("Close") #self.set_grid_time(enabled=False) #self.set_grid_scale(enabled=self._default_is_scale) if self._default_phase: self.on_animate_phase(force=True) set_combo_box_text(self.animation_type_edit, 'Animate Phase') else: self.on_animate_scale(force=True)
def setup_page(self): newcb = self.create_checkbox # Python executable Group pyexec_group = QGroupBox(_("Python interpreter")) pyexec_bg = QButtonGroup(pyexec_group) pyexec_label = QLabel(_("Select the Python interpreter for all Spyder " "consoles")) def_exec_radio = self.create_radiobutton( _("Default (i.e. the same as Spyder's)"), 'default', button_group=pyexec_bg) self.cus_exec_radio = self.create_radiobutton( _("Use the following Python interpreter:"), 'custom', button_group=pyexec_bg) if os.name == 'nt': filters = _("Executables")+" (*.exe)" else: filters = None pyexec_file = self.create_browsefile('', 'executable', filters=filters) for le in self.lineedits: if self.lineedits[le][0] == 'executable': self.pyexec_edit = le def_exec_radio.toggled.connect(pyexec_file.setDisabled) self.cus_exec_radio.toggled.connect(pyexec_file.setEnabled) pyexec_layout = QVBoxLayout() pyexec_layout.addWidget(pyexec_label) pyexec_layout.addWidget(def_exec_radio) pyexec_layout.addWidget(self.cus_exec_radio) pyexec_layout.addWidget(pyexec_file) pyexec_group.setLayout(pyexec_layout) # UMR Group umr_group = QGroupBox(_("User Module Reloader (UMR)")) umr_label = QLabel(_("UMR forces Python to reload modules which were " "imported when executing a file in a Python or " "IPython console with the <i>runfile</i> " "function.")) umr_label.setWordWrap(True) umr_enabled_box = newcb(_("Enable UMR"), 'umr/enabled', msg_if_enabled=True, msg_warning=_( "This option will enable the User Module Reloader (UMR) " "in Python/IPython consoles. UMR forces Python to " "reload deeply modules during import when running a " "Python script using the Spyder's builtin function " "<b>runfile</b>." "<br><br><b>1.</b> UMR may require to restart the " "console in which it will be called " "(otherwise only newly imported modules will be " "reloaded when executing files)." "<br><br><b>2.</b> If errors occur when re-running a " "PyQt-based program, please check that the Qt objects " "are properly destroyed (e.g. you may have to use the " "attribute <b>Qt.WA_DeleteOnClose</b> on your main " "window, using the <b>setAttribute</b> method)"), ) umr_verbose_box = newcb(_("Show reloaded modules list"), 'umr/verbose', msg_info=_( "Please note that these changes will " "be applied only to new consoles")) umr_namelist_btn = QPushButton( _("Set UMR excluded (not reloaded) modules")) umr_namelist_btn.clicked.connect(self.set_umr_namelist) umr_layout = QVBoxLayout() umr_layout.addWidget(umr_label) umr_layout.addWidget(umr_enabled_box) umr_layout.addWidget(umr_verbose_box) umr_layout.addWidget(umr_namelist_btn) umr_group.setLayout(umr_layout) vlayout = QVBoxLayout() vlayout.addWidget(pyexec_group) vlayout.addWidget(umr_group) vlayout.addStretch(1) self.setLayout(vlayout)
def setup_page(self): interface_group = QGroupBox(_("Interface")) newcb = self.create_checkbox singletab_box = newcb(_("One tab per script"), 'single_tab') showtime_box = newcb(_("Show elapsed time"), 'show_elapsed_time') icontext_box = newcb(_("Show icons and text"), 'show_icontext') # Interface Group interface_layout = QVBoxLayout() interface_layout.addWidget(singletab_box) interface_layout.addWidget(showtime_box) interface_layout.addWidget(icontext_box) interface_group.setLayout(interface_layout) # Source Code Group display_group = QGroupBox(_("Source code")) buffer_spin = self.create_spinbox(_("Buffer: "), _(" lines"), 'max_line_count', min_=0, max_=1000000, step=100, tip=_("Set maximum line count")) wrap_mode_box = newcb(_("Wrap lines"), 'wrap') merge_channels_box = newcb( _("Merge process standard output/error channels"), 'merge_output_channels', tip=_("Merging the output channels of the process means that\n" "the standard error won't be written in red anymore,\n" "but this has the effect of speeding up display.")) colorize_sys_stderr_box = newcb( _("Colorize standard error channel using ANSI escape codes"), 'colorize_sys_stderr', tip=_("This method is the only way to have colorized standard\n" "error channel when the output channels have been " "merged.")) merge_channels_box.toggled.connect(colorize_sys_stderr_box.setEnabled) merge_channels_box.toggled.connect(colorize_sys_stderr_box.setChecked) colorize_sys_stderr_box.setEnabled( self.get_option('merge_output_channels')) display_layout = QVBoxLayout() display_layout.addWidget(buffer_spin) display_layout.addWidget(wrap_mode_box) display_layout.addWidget(merge_channels_box) display_layout.addWidget(colorize_sys_stderr_box) display_group.setLayout(display_layout) # Background Color Group bg_group = QGroupBox(_("Background color")) bg_label = QLabel( _("This option will be applied the next time " "a Python console or a terminal is opened.")) bg_label.setWordWrap(True) lightbg_box = newcb(_("Light background (white color)"), 'light_background') bg_layout = QVBoxLayout() bg_layout.addWidget(bg_label) bg_layout.addWidget(lightbg_box) bg_group.setLayout(bg_layout) # Advanced settings source_group = QGroupBox(_("Source code")) completion_box = newcb(_("Automatic code completion"), 'codecompletion/auto') case_comp_box = newcb(_("Case sensitive code completion"), 'codecompletion/case_sensitive') comp_enter_box = newcb(_("Enter key selects completion"), 'codecompletion/enter_key') calltips_box = newcb(_("Display balloon tips"), 'calltips') source_layout = QVBoxLayout() source_layout.addWidget(completion_box) source_layout.addWidget(case_comp_box) source_layout.addWidget(comp_enter_box) source_layout.addWidget(calltips_box) source_group.setLayout(source_layout) # PYTHONSTARTUP replacement pystartup_group = QGroupBox(_("PYTHONSTARTUP replacement")) pystartup_bg = QButtonGroup(pystartup_group) pystartup_label = QLabel( _("This option will override the " "PYTHONSTARTUP environment variable which\n" "defines the script to be executed during " "the Python console startup.")) def_startup_radio = self.create_radiobutton( _("Default PYTHONSTARTUP script"), 'pythonstartup/default', button_group=pystartup_bg) cus_startup_radio = self.create_radiobutton( _("Use the following startup script:"), 'pythonstartup/custom', button_group=pystartup_bg) pystartup_file = self.create_browsefile('', 'pythonstartup', '', filters=_("Python scripts")+\ " (*.py)") def_startup_radio.toggled.connect(pystartup_file.setDisabled) cus_startup_radio.toggled.connect(pystartup_file.setEnabled) pystartup_layout = QVBoxLayout() pystartup_layout.addWidget(pystartup_label) pystartup_layout.addWidget(def_startup_radio) pystartup_layout.addWidget(cus_startup_radio) pystartup_layout.addWidget(pystartup_file) pystartup_group.setLayout(pystartup_layout) # Monitor Group monitor_group = QGroupBox(_("Monitor")) monitor_label = QLabel( _("The monitor provides introspection " "features to console: code completion, " "calltips and variable explorer. " "Because it relies on several modules, " "disabling the monitor may be useful " "to accelerate console startup.")) monitor_label.setWordWrap(True) monitor_box = newcb(_("Enable monitor"), 'monitor/enabled') for obj in (completion_box, case_comp_box, comp_enter_box, calltips_box): monitor_box.toggled.connect(obj.setEnabled) obj.setEnabled(self.get_option('monitor/enabled')) monitor_layout = QVBoxLayout() monitor_layout.addWidget(monitor_label) monitor_layout.addWidget(monitor_box) monitor_group.setLayout(monitor_layout) # Qt Group opts = [ (_("Default library"), 'default'), ('PyQt5', 'pyqt5'), ('PyQt4', 'pyqt'), ('PySide', 'pyside'), ] qt_group = QGroupBox(_("Qt-Python Bindings")) qt_setapi_box = self.create_combobox( _("Library:") + " ", opts, 'qt/api', default='default', tip=_("This option will act on<br> " "libraries such as Matplotlib, guidata " "or ETS")) qt_layout = QVBoxLayout() qt_layout.addWidget(qt_setapi_box) qt_group.setLayout(qt_layout) # Matplotlib Group mpl_group = QGroupBox(_("Graphics")) mpl_label = QLabel( _("Decide which backend to use to display graphics. " "If unsure, please select the <b>Automatic</b> " "backend.<br><br>" "<b>Note:</b> We support a very limited number " "of backends in our Python consoles. If you " "prefer to work with a different one, please use " "an IPython console.")) mpl_label.setWordWrap(True) backends = [(_("Automatic"), 0), (_("None"), 1)] if not os.name == 'nt' and programs.is_module_installed('_tkinter'): backends.append(("Tkinter", 2)) backends = tuple(backends) mpl_backend_box = self.create_combobox( _("Backend:") + " ", backends, 'matplotlib/backend/value', tip=_("This option will be applied the " "next time a console is opened.")) mpl_installed = programs.is_module_installed('matplotlib') mpl_layout = QVBoxLayout() mpl_layout.addWidget(mpl_label) mpl_layout.addWidget(mpl_backend_box) mpl_group.setLayout(mpl_layout) mpl_group.setEnabled(mpl_installed) # ETS Group ets_group = QGroupBox(_("Enthought Tool Suite")) ets_label = QLabel( _("Enthought Tool Suite (ETS) supports " "PyQt4 (qt4) and wxPython (wx) graphical " "user interfaces.")) ets_label.setWordWrap(True) ets_edit = self.create_lineedit(_("ETS_TOOLKIT:"), 'ets_backend', alignment=Qt.Horizontal) ets_layout = QVBoxLayout() ets_layout.addWidget(ets_label) ets_layout.addWidget(ets_edit) ets_group.setLayout(ets_layout) if CONF.get('main_interpreter', 'default'): interpreter = get_python_executable() else: interpreter = CONF.get('main_interpreter', 'executable') ets_group.setEnabled( programs.is_module_installed("enthought.etsconfig.api", interpreter=interpreter)) tabs = QTabWidget() tabs.addTab(self.create_tab(interface_group, display_group, bg_group), _("Display")) tabs.addTab(self.create_tab(monitor_group, source_group), _("Introspection")) tabs.addTab(self.create_tab(pystartup_group), _("Advanced settings")) tabs.addTab(self.create_tab(qt_group, mpl_group, ets_group), _("External modules")) vlayout = QVBoxLayout() vlayout.addWidget(tabs) self.setLayout(vlayout)
def setup_page(self): """Create configuration page.""" options_layout = QGridLayout() # Custom shell options shell_group = QGroupBox(_("Terminal shell")) shell_layout = QVBoxLayout() if WINDOWS: self.shells = WINDOWS_SHELLS else: self.shells = UNIX_SHELLS valid_shells = [] for shell in self.shells: if find_program(shell) is not None: valid_shells.append(shell) valid_shells = zip(valid_shells, valid_shells) if WINDOWS: default_option = 'cmd' elif sys.platform.startswith('linux'): default_option = 'bash' else: mac_ver = LooseVersion(platform.mac_ver()[0]) if mac_ver >= LooseVersion('10.15.0'): # Catalina changed the default shell to zsh default_option = 'zsh' else: default_option = 'bash' shell_combo = self.create_combobox(_("Select the shell interpreter:"), valid_shells, 'shell', restart=True, default=default_option) shell_combo.combobox.setMinimumContentsLength(15) shell_layout.addWidget(shell_combo) shell_group.setLayout(shell_layout) shell_layout.addStretch(1) options_layout.addWidget(shell_group) # Display preferences display_group = QGroupBox(_("Terminal display preferences")) display_layout = QVBoxLayout() # Custom buffer limit self.buffer_sb = self.create_spinbox(_("Buffer limit: "), "", 'buffer_limit', min_=100, default=1000, max_=1000000, step=1) display_layout.addWidget(self.buffer_sb) display_group.setLayout(display_layout) display_layout.addStretch(1) options_layout.addWidget(display_group) # Style preferences terminal_group = QGroupBox(_("Terminal style preferences")) # Custom bar option cursor_choices = [(_("Block"), 0), (_("Underline"), 1), (_("Bar"), 2)] self.cursor_combo = self.create_combobox(_("Type of cursor:"), cursor_choices, 'cursor_type') self.cursor_combo.combobox.setMinimumContentsLength(15) options_layout.addWidget(self.cursor_combo) # Custom sound option self.sound_cb = self.create_checkbox( _("Enable bell sound"), 'sound', tip=_("Enable bell sound on terminal")) options_layout.addWidget(self.sound_cb) terminal_group.setLayout(options_layout) layout = QVBoxLayout() layout.addWidget(shell_group) layout.addWidget(display_group) layout.addWidget(terminal_group) layout.addStretch(1) self.setLayout(layout)
def setup_page(self): ar_group = QGroupBox(_("Autorefresh")) ar_box = self.create_checkbox(_("Enable autorefresh"), 'autorefresh') ar_spin = self.create_spinbox(_("Refresh interval: "), _(" ms"), 'autorefresh/timeout', min_=100, max_=1000000, step=100) filter_group = QGroupBox(_("Filter")) filter_data = [ ('exclude_private', _("Exclude private references")), ('exclude_capitalized', _("Exclude capitalized references")), ('exclude_uppercase', _("Exclude all-uppercase references")), ('exclude_unsupported', _("Exclude unsupported data types")), ] filter_boxes = [ self.create_checkbox(text, option) for option, text in filter_data ] display_group = QGroupBox(_("Display")) display_data = [('truncate', _("Truncate values"), '')] if programs.is_module_installed('numpy'): display_data.append(('minmax', _("Show arrays min/max"), '')) display_data.append( ('remote_editing', _("Edit data in the remote process"), _("Editors are opened in the remote process for NumPy " "arrays, PIL images, lists, tuples and dictionaries.\n" "This avoids transfering large amount of data between " "the remote process and Spyder (through the socket)."))) display_boxes = [ self.create_checkbox(text, option, tip=tip) for option, text, tip in display_data ] ar_layout = QVBoxLayout() ar_layout.addWidget(ar_box) ar_layout.addWidget(ar_spin) ar_group.setLayout(ar_layout) filter_layout = QVBoxLayout() for box in filter_boxes: filter_layout.addWidget(box) filter_group.setLayout(filter_layout) display_layout = QVBoxLayout() for box in display_boxes: display_layout.addWidget(box) display_group.setLayout(display_layout) vlayout = QVBoxLayout() vlayout.addWidget(ar_group) vlayout.addWidget(filter_group) vlayout.addWidget(display_group) vlayout.addStretch(1) self.setLayout(vlayout)
def setup_page(self): newcb = self.create_checkbox # Python executable Group pyexec_group = QGroupBox(_("Python interpreter")) pyexec_bg = QButtonGroup(pyexec_group) pyexec_label = QLabel( _("Select the Python interpreter for all Spyder " "consoles")) self.def_exec_radio = self.create_radiobutton( _("Default (i.e. the same as Spyder's)"), 'default', button_group=pyexec_bg, ) self.cus_exec_radio = self.create_radiobutton( _("Use the following Python interpreter:"), 'custom', button_group=pyexec_bg, ) if os.name == 'nt': filters = _("Executables") + " (*.exe)" else: filters = None pyexec_layout = QVBoxLayout() pyexec_layout.addWidget(pyexec_label) pyexec_layout.addWidget(self.def_exec_radio) pyexec_layout.addWidget(self.cus_exec_radio) self.validate_custom_interpreters_list() self.cus_exec_combo = self.create_file_combobox( _('Recent custom interpreters'), self.get_option('custom_interpreters_list'), 'custom_interpreter', filters=filters, default_line_edit=True, adjust_to_contents=True, validate_callback=programs.is_python_interpreter, ) self.def_exec_radio.toggled.connect(self.cus_exec_combo.setDisabled) self.cus_exec_radio.toggled.connect(self.cus_exec_combo.setEnabled) pyexec_layout.addWidget(self.cus_exec_combo) pyexec_group.setLayout(pyexec_layout) self.pyexec_edit = self.cus_exec_combo.combobox.lineEdit() # UMR Group umr_group = QGroupBox(_("User Module Reloader (UMR)")) umr_label = QLabel( _("UMR forces Python to reload modules which were " "imported when executing a file in a Python or " "IPython console with the <i>runfile</i> " "function.")) umr_label.setWordWrap(True) umr_enabled_box = newcb( _("Enable UMR"), 'umr/enabled', msg_if_enabled=True, msg_warning=_( "This option will enable the User Module Reloader (UMR) " "in Python/IPython consoles. UMR forces Python to " "reload deeply modules during import when running a " "Python file using the Spyder's builtin function " "<b>runfile</b>." "<br><br><b>1.</b> UMR may require to restart the " "console in which it will be called " "(otherwise only newly imported modules will be " "reloaded when executing files)." "<br><br><b>2.</b> If errors occur when re-running a " "PyQt-based program, please check that the Qt objects " "are properly destroyed (e.g. you may have to use the " "attribute <b>Qt.WA_DeleteOnClose</b> on your main " "window, using the <b>setAttribute</b> method)"), ) umr_verbose_box = newcb( _("Show reloaded modules list"), 'umr/verbose', msg_info=_("Please note that these changes will " "be applied only to new consoles"), ) umr_namelist_btn = QPushButton( _("Set UMR excluded (not reloaded) modules")) umr_namelist_btn.clicked.connect(self.set_umr_namelist) umr_layout = QVBoxLayout() umr_layout.addWidget(umr_label) umr_layout.addWidget(umr_enabled_box) umr_layout.addWidget(umr_verbose_box) umr_layout.addWidget(umr_namelist_btn) umr_group.setLayout(umr_layout) vlayout = QVBoxLayout() vlayout.addWidget(pyexec_group) vlayout.addWidget(umr_group) vlayout.addStretch(1) self.setLayout(vlayout)
def setup_page(self): self.ICON = ima.icon('genprefs') newcb = self.create_checkbox # --- Interface general_group = QGroupBox(_("General")) # Remove disabled languages language_codes = LANGUAGE_CODES.copy() for lang in DISABLED_LANGUAGES: language_codes.pop(lang) languages = language_codes.items() language_choices = sorted([(val, key) for key, val in languages]) language_combo = self.create_combobox(_('Language:'), language_choices, 'interface_language', restart=True) opengl_options = ['Automatic', 'Desktop', 'Software', 'GLES'] opengl_choices = list( zip(opengl_options, [c.lower() for c in opengl_options])) opengl_combo = self.create_combobox(_('Rendering engine:'), opengl_choices, 'opengl', restart=True) single_instance_box = newcb(_("Use a single instance"), 'single_instance', tip=_("Set this to open external<br> " "Python files in an already running " "instance (Requires a restart)")) prompt_box = newcb(_("Prompt when exiting"), 'prompt_on_exit') popup_console_box = newcb( _("Show internal Spyder errors to report " "them to Github"), 'show_internal_errors') check_updates = newcb(_("Check for updates on startup"), 'check_updates_on_startup') # Decide if it's possible to activate or not single instance mode if running_in_mac_app(): self.set_option("single_instance", True) single_instance_box.setEnabled(False) comboboxes_advanced_layout = QHBoxLayout() cbs_adv_grid = QGridLayout() cbs_adv_grid.addWidget(language_combo.label, 0, 0) cbs_adv_grid.addWidget(language_combo.combobox, 0, 1) cbs_adv_grid.addWidget(opengl_combo.label, 1, 0) cbs_adv_grid.addWidget(opengl_combo.combobox, 1, 1) comboboxes_advanced_layout.addLayout(cbs_adv_grid) comboboxes_advanced_layout.addStretch(1) general_layout = QVBoxLayout() general_layout.addLayout(comboboxes_advanced_layout) general_layout.addWidget(single_instance_box) general_layout.addWidget(prompt_box) general_layout.addWidget(popup_console_box) general_layout.addWidget(check_updates) general_group.setLayout(general_layout) # --- Theme interface_group = QGroupBox(_("Interface")) verttabs_box = newcb(_("Vertical tabs in panes"), 'vertical_tabs') margin_box = newcb(_("Custom margin for panes:"), 'use_custom_margin') margin_spin = self.create_spinbox("", _("pixels"), 'custom_margin', default=0, min_=0, max_=30) margin_box.toggled.connect(margin_spin.spinbox.setEnabled) margin_box.toggled.connect(margin_spin.slabel.setEnabled) margin_spin.spinbox.setEnabled(self.get_option('use_custom_margin')) margin_spin.slabel.setEnabled(self.get_option('use_custom_margin')) cursor_box = newcb(_("Cursor blinking:"), 'use_custom_cursor_blinking') cursor_spin = self.create_spinbox( "", _("ms"), 'custom_cursor_blinking', default=QApplication.cursorFlashTime(), min_=0, max_=5000, step=100) cursor_box.toggled.connect(cursor_spin.spinbox.setEnabled) cursor_box.toggled.connect(cursor_spin.slabel.setEnabled) cursor_spin.spinbox.setEnabled( self.get_option('use_custom_cursor_blinking')) cursor_spin.slabel.setEnabled( self.get_option('use_custom_cursor_blinking')) margins_cursor_layout = QGridLayout() margins_cursor_layout.addWidget(margin_box, 0, 0) margins_cursor_layout.addWidget(margin_spin.spinbox, 0, 1) margins_cursor_layout.addWidget(margin_spin.slabel, 0, 2) margins_cursor_layout.addWidget(cursor_box, 1, 0) margins_cursor_layout.addWidget(cursor_spin.spinbox, 1, 1) margins_cursor_layout.addWidget(cursor_spin.slabel, 1, 2) margins_cursor_layout.setColumnStretch(2, 100) # Layout interface interface_layout = QVBoxLayout() interface_layout.addWidget(verttabs_box) interface_layout.addLayout(margins_cursor_layout) interface_group.setLayout(interface_layout) if sys.platform == "darwin": def set_open_file(state): if state: register_app_launchservices() else: restore_launchservices() macOS_group = QGroupBox(_("macOS integration")) mac_open_file_box = newcb( _("Open files from Finder with Spyder"), 'mac_open_file', tip=_("Register Spyder with the Launch Services")) mac_open_file_box.toggled.connect(set_open_file) macOS_layout = QVBoxLayout() macOS_layout.addWidget(mac_open_file_box) if als.get_bundle_identifier() is None: # Disable setting mac_open_file_box.setDisabled(True) macOS_layout.addWidget( QLabel( _('Launch Spyder with <code>python.app</code> to enable' ' Apple event integrations.'))) macOS_group.setLayout(macOS_layout) # --- Status bar sbar_group = QGroupBox(_("Status bar")) show_status_bar = newcb(_("Show status bar"), 'show_status_bar') memory_box = newcb(_("Show memory usage every"), 'memory_usage/enable', tip=self.main.mem_status.toolTip()) memory_spin = self.create_spinbox("", _(" ms"), 'memory_usage/timeout', min_=100, max_=1000000, step=100) memory_box.toggled.connect(memory_spin.setEnabled) memory_spin.setEnabled(self.get_option('memory_usage/enable')) memory_box.setEnabled(self.main.mem_status.is_supported()) memory_spin.setEnabled(self.main.mem_status.is_supported()) cpu_box = newcb(_("Show CPU usage every"), 'cpu_usage/enable', tip=self.main.cpu_status.toolTip()) cpu_spin = self.create_spinbox("", _(" ms"), 'cpu_usage/timeout', min_=100, max_=1000000, step=100) cpu_box.toggled.connect(cpu_spin.setEnabled) cpu_spin.setEnabled(self.get_option('cpu_usage/enable')) cpu_box.setEnabled(self.main.cpu_status.is_supported()) cpu_spin.setEnabled(self.main.cpu_status.is_supported()) clock_box = newcb(_("Show clock"), 'clock/enable') status_bar_o = self.get_option('show_status_bar') show_status_bar.toggled.connect(memory_box.setEnabled) show_status_bar.toggled.connect(memory_spin.setEnabled) show_status_bar.toggled.connect(cpu_box.setEnabled) show_status_bar.toggled.connect(cpu_spin.setEnabled) show_status_bar.toggled.connect(clock_box.setEnabled) memory_box.setEnabled(status_bar_o) memory_spin.setEnabled(status_bar_o) cpu_box.setEnabled(status_bar_o) cpu_spin.setEnabled(status_bar_o) clock_box.setEnabled(status_bar_o) # Layout status bar cpu_memory_layout = QGridLayout() cpu_memory_layout.addWidget(memory_box, 0, 0) cpu_memory_layout.addWidget(memory_spin, 0, 1) cpu_memory_layout.addWidget(cpu_box, 1, 0) cpu_memory_layout.addWidget(cpu_spin, 1, 1) cpu_memory_layout.addWidget(clock_box, 2, 0) sbar_layout = QVBoxLayout() sbar_layout.addWidget(show_status_bar) sbar_layout.addLayout(cpu_memory_layout) sbar_group.setLayout(sbar_layout) # --- Screen resolution Group (hidpi) screen_resolution_group = QGroupBox(_("Screen resolution")) screen_resolution_bg = QButtonGroup(screen_resolution_group) screen_resolution_label = QLabel( _("Configuration for high DPI " "screens<br><br>" "Please see " "<a href=\"{0}\">{0}</a><> " "for more information about " "these options (in " "English).").format(HDPI_QT_PAGE)) screen_resolution_label.setWordWrap(True) screen_resolution_label.setOpenExternalLinks(True) normal_radio = self.create_radiobutton( _("Normal"), 'normal_screen_resolution', button_group=screen_resolution_bg) auto_scale_radio = self.create_radiobutton( _("Enable auto high DPI scaling"), 'high_dpi_scaling', button_group=screen_resolution_bg, tip=_("Set this for high DPI displays"), restart=True) custom_scaling_radio = self.create_radiobutton( _("Set a custom high DPI scaling"), 'high_dpi_custom_scale_factor', button_group=screen_resolution_bg, tip=_("Set this for high DPI displays when " "auto scaling does not work"), restart=True) self.custom_scaling_edit = self.create_lineedit( "", 'high_dpi_custom_scale_factors', tip=_("Enter values for different screens " "separated by semicolons ';'.\n" "Float values are supported"), alignment=Qt.Horizontal, regex=r"[0-9]+(?:\.[0-9]*)(;[0-9]+(?:\.[0-9]*))*", restart=True) normal_radio.toggled.connect(self.custom_scaling_edit.setDisabled) auto_scale_radio.toggled.connect(self.custom_scaling_edit.setDisabled) custom_scaling_radio.toggled.connect( self.custom_scaling_edit.setEnabled) # Layout Screen resolution screen_resolution_layout = QVBoxLayout() screen_resolution_layout.addWidget(screen_resolution_label) screen_resolution_inner_layout = QGridLayout() screen_resolution_inner_layout.addWidget(normal_radio, 0, 0) screen_resolution_inner_layout.addWidget(auto_scale_radio, 1, 0) screen_resolution_inner_layout.addWidget(custom_scaling_radio, 2, 0) screen_resolution_inner_layout.addWidget(self.custom_scaling_edit, 2, 1) screen_resolution_layout.addLayout(screen_resolution_inner_layout) screen_resolution_group.setLayout(screen_resolution_layout) if sys.platform == "darwin": interface_tab = self.create_tab(screen_resolution_group, interface_group, macOS_group) else: interface_tab = self.create_tab(screen_resolution_group, interface_group) tabs = QTabWidget() tabs.addTab(interface_tab, _("Interface")) tabs.addTab(self.create_tab(general_group, sbar_group), _("Advanced settings")) vlayout = QVBoxLayout() vlayout.addWidget(tabs) self.setLayout(vlayout)
def setup_page(self): run_dlg = _("Run Settings") run_menu = _("Run") about_label = QLabel( _( "The following are the default <i>%s</i>. " "These options may be overriden using the " "<b>%s</b> dialog box (see the <b>%s</b> menu)" ) % (run_dlg, run_dlg, run_menu) ) about_label.setWordWrap(True) interpreter_group = QGroupBox(_("Console")) interpreter_bg = QButtonGroup(interpreter_group) self.current_radio = self.create_radiobutton( CURRENT_INTERPRETER, CURRENT_INTERPRETER_OPTION, True, button_group=interpreter_bg ) self.dedicated_radio = self.create_radiobutton( DEDICATED_INTERPRETER, DEDICATED_INTERPRETER_OPTION, False, button_group=interpreter_bg ) self.systerm_radio = self.create_radiobutton( SYSTERM_INTERPRETER, SYSTERM_INTERPRETER_OPTION, False, button_group=interpreter_bg ) interpreter_layout = QVBoxLayout() interpreter_group.setLayout(interpreter_layout) interpreter_layout.addWidget(self.current_radio) interpreter_layout.addWidget(self.dedicated_radio) interpreter_layout.addWidget(self.systerm_radio) general_group = QGroupBox("General settings") wdir_bg = QButtonGroup(general_group) wdir_label = QLabel(_("Default working directory is:")) wdir_label.setWordWrap(True) dirname_radio = self.create_radiobutton( _("the script directory"), WDIR_USE_SCRIPT_DIR_OPTION, True, button_group=wdir_bg ) thisdir_radio = self.create_radiobutton( _("the following directory:"), WDIR_USE_FIXED_DIR_OPTION, False, button_group=wdir_bg ) thisdir_bd = self.create_browsedir("", WDIR_FIXED_DIR_OPTION, getcwd()) thisdir_radio.toggled.connect(thisdir_bd.setEnabled) dirname_radio.toggled.connect(thisdir_bd.setDisabled) thisdir_layout = QHBoxLayout() thisdir_layout.addWidget(thisdir_radio) thisdir_layout.addWidget(thisdir_bd) post_mortem = self.create_checkbox( _("Enter debugging mode when errors appear during execution"), "post_mortem", False ) general_layout = QVBoxLayout() general_layout.addWidget(wdir_label) general_layout.addWidget(dirname_radio) general_layout.addLayout(thisdir_layout) general_layout.addWidget(post_mortem) general_group.setLayout(general_layout) dedicated_group = QGroupBox(_("Dedicated Python console")) interact_after = self.create_checkbox(_("Interact with the Python console after execution"), "interact", False) show_warning = self.create_checkbox(_("Show warning when killing running processes"), "show_kill_warning", True) dedicated_layout = QVBoxLayout() dedicated_layout.addWidget(interact_after) dedicated_layout.addWidget(show_warning) dedicated_group.setLayout(dedicated_layout) firstrun_cb = self.create_checkbox( ALWAYS_OPEN_FIRST_RUN % _("Run Settings dialog"), ALWAYS_OPEN_FIRST_RUN_OPTION, False ) vlayout = QVBoxLayout() vlayout.addWidget(about_label) vlayout.addSpacing(10) vlayout.addWidget(interpreter_group) vlayout.addWidget(general_group) vlayout.addWidget(dedicated_group) vlayout.addWidget(firstrun_cb) vlayout.addStretch(1) self.setLayout(vlayout)
def create_layout(self): """displays the menu objects""" grid = QGridLayout() grid.addWidget(self.icase_fringe, 0, 0) grid.addWidget(self.icase_fringe_edit, 0, 1) grid.addWidget(self.scale, 1, 0) grid.addWidget(self.scale_edit, 1, 1) grid.addWidget(self.scale_button, 1, 2) grid.addWidget(self.arrow_scale, 2, 0) grid.addWidget(self.arrow_scale_edit, 2, 1) grid.addWidget(self.arrow_scale_button, 2, 2) grid.addWidget(self.time, 3, 0) grid.addWidget(self.time_edit, 3, 1) grid.addWidget(self.time_button, 3, 2) # spacer spacer = QLabel('') grid.addWidget(self.fps, 4, 0) grid.addWidget(self.fps_edit, 4, 1) grid.addWidget(self.fps_button, 4, 2) grid.addWidget(self.resolution, 5, 0) grid.addWidget(self.resolution_edit, 5, 1) grid.addWidget(self.resolution_button, 5, 2) grid.addWidget(self.browse_folder, 6, 0) grid.addWidget(self.browse_folder_edit, 6, 1) grid.addWidget(self.browse_folder_button, 6, 2) grid.addWidget(self.gif, 7, 0) grid.addWidget(self.gif_edit, 7, 1) grid.addWidget(self.gif_button, 7, 2) grid.addWidget(self.animation_type, 8, 0) grid.addWidget(self.animation_type_edit, 8, 1) grid.addWidget(spacer, 9, 0) #---------- #Time grid_time = QGridLayout() grid_time.addWidget(self.icase_start, 0, 0) grid_time.addWidget(self.icase_start_edit, 0, 1) #grid_time.addWidget(self.icase_start_button, 0, 2) grid_time.addWidget(self.icase_end, 1, 0) grid_time.addWidget(self.icase_end_edit, 1, 1) #grid_time.addWidget(self.icase_end_button, 1, 2) grid_time.addWidget(self.icase_delta, 2, 0) grid_time.addWidget(self.icase_delta_edit, 2, 1) #grid_time.addWidget(self.icase_delta_button, 2, 2) hbox = QHBoxLayout() hbox.addWidget(self.min_value_enable) hbox.addWidget(self.min_value) grid_time.addLayout(hbox, 3, 0) grid_time.addWidget(self.min_value_edit, 3, 1) grid_time.addWidget(self.min_value_button, 3, 2) hbox = QHBoxLayout() hbox.addWidget(self.max_value_enable) hbox.addWidget(self.max_value) grid_time.addLayout(hbox, 4, 0) grid_time.addWidget(self.max_value_edit, 4, 1) grid_time.addWidget(self.max_value_button, 4, 2) grid_time.addWidget(spacer, 5, 0) #-------------- grid_scale = QGridLayout() grid_scale.addWidget(self.animation_profile, 0, 0) grid_scale.addWidget(self.animation_profile_edit, 0, 1) #grid_scale.addWidget(self.csv_profile, 1, 0) #grid_scale.addWidget(self.csv_profile_edit, 1, 1) #grid_scale.addWidget(self.csv_profile_browse_button, 1, 2) self.csv_profile = QLabel("CSV profile:") self.csv_profile_edit = QLineEdit() self.csv_profile_button = QPushButton('Browse') #box_time = QVBoxLayout() # TODO: It's super annoying that the animate time box doesn't # line up with the previous box box_scale = QGroupBox('Animate Scale') box_scale.setLayout(grid_scale) box_time = QGroupBox('Animate Time') box_time.setLayout(grid_time) #---------- grid2 = QGridLayout() #grid2.addWidget(self.animate_scale_radio, 8, 0) #grid2.addWidget(self.animate_phase_radio, 8, 1) #grid2.addWidget(self.animate_time_radio, 8, 2) #grid2.addWidget(self.animate_freq_sweeep_radio, 8, 3) grid2.addWidget(self.animate_in_gui_checkbox, 10, 0) grid2.addWidget(self.make_images_checkbox, 11, 0) #grid2.addWidget(self.overwrite_images_checkbox, 11, 0) grid2.addWidget(self.delete_images_checkbox, 11, 1) grid2.addWidget(self.make_gif_checkbox, 11, 2) grid2.addWidget(self.repeat_checkbox, 12, 0) grid2.addWidget(spacer, 13, 0) grid_hbox = QHBoxLayout() grid_hbox.addWidget(spacer) grid_hbox.addLayout(grid2) grid_hbox.addWidget(spacer) # bottom buttons step_run_box = QHBoxLayout() step_run_box.addWidget(self.step_button) step_run_box.addWidget(self.wipe_button) step_run_box.addWidget(self.stop_button) step_run_box.addWidget(self.run_button) ok_cancel_box = QHBoxLayout() ok_cancel_box.addWidget(self.cancel_button) vbox = QVBoxLayout() vbox.addLayout(grid) vbox.addWidget(box_scale) vbox.addWidget(box_time) #vbox.addLayout(checkboxes) vbox.addLayout(grid_hbox) vbox.addStretch() vbox.addLayout(step_run_box) vbox.addLayout(ok_cancel_box) self.setLayout(vbox)
def __init__(self, parent, text): QWidget.__init__(self, parent) self.text_editor = QTextEdit(self) self.text_editor.setText(text) self.text_editor.setReadOnly(True) # Type frame type_layout = QHBoxLayout() type_label = QLabel(_("Import as")) type_layout.addWidget(type_label) data_btn = QRadioButton(_("data")) data_btn.setChecked(True) self._as_data= True type_layout.addWidget(data_btn) code_btn = QRadioButton(_("code")) self._as_code = False type_layout.addWidget(code_btn) txt_btn = QRadioButton(_("text")) type_layout.addWidget(txt_btn) h_spacer = QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum) type_layout.addItem(h_spacer) type_frame = QFrame() type_frame.setLayout(type_layout) # Opts frame grid_layout = QGridLayout() grid_layout.setSpacing(0) col_label = QLabel(_("Column separator:")) grid_layout.addWidget(col_label, 0, 0) col_w = QWidget() col_btn_layout = QHBoxLayout() self.tab_btn = QRadioButton(_("Tab")) self.tab_btn.setChecked(False) col_btn_layout.addWidget(self.tab_btn) other_btn_col = QRadioButton(_("other")) other_btn_col.setChecked(True) col_btn_layout.addWidget(other_btn_col) col_w.setLayout(col_btn_layout) grid_layout.addWidget(col_w, 0, 1) self.line_edt = QLineEdit(",") self.line_edt.setMaximumWidth(30) self.line_edt.setEnabled(True) other_btn_col.toggled.connect(self.line_edt.setEnabled) grid_layout.addWidget(self.line_edt, 0, 2) row_label = QLabel(_("Row separator:")) grid_layout.addWidget(row_label, 1, 0) row_w = QWidget() row_btn_layout = QHBoxLayout() self.eol_btn = QRadioButton(_("EOL")) self.eol_btn.setChecked(True) row_btn_layout.addWidget(self.eol_btn) other_btn_row = QRadioButton(_("other")) row_btn_layout.addWidget(other_btn_row) row_w.setLayout(row_btn_layout) grid_layout.addWidget(row_w, 1, 1) self.line_edt_row = QLineEdit(";") self.line_edt_row.setMaximumWidth(30) self.line_edt_row.setEnabled(False) other_btn_row.toggled.connect(self.line_edt_row.setEnabled) grid_layout.addWidget(self.line_edt_row, 1, 2) grid_layout.setRowMinimumHeight(2, 15) other_group = QGroupBox(_("Additional options")) other_layout = QGridLayout() other_group.setLayout(other_layout) skiprows_label = QLabel(_("Skip rows:")) other_layout.addWidget(skiprows_label, 0, 0) self.skiprows_edt = QLineEdit('0') self.skiprows_edt.setMaximumWidth(30) intvalid = QIntValidator(0, len(to_text_string(text).splitlines()), self.skiprows_edt) self.skiprows_edt.setValidator(intvalid) other_layout.addWidget(self.skiprows_edt, 0, 1) other_layout.setColumnMinimumWidth(2, 5) comments_label = QLabel(_("Comments:")) other_layout.addWidget(comments_label, 0, 3) self.comments_edt = QLineEdit('#') self.comments_edt.setMaximumWidth(30) other_layout.addWidget(self.comments_edt, 0, 4) self.trnsp_box = QCheckBox(_("Transpose")) #self.trnsp_box.setEnabled(False) other_layout.addWidget(self.trnsp_box, 1, 0, 2, 0) grid_layout.addWidget(other_group, 3, 0, 2, 0) opts_frame = QFrame() opts_frame.setLayout(grid_layout) data_btn.toggled.connect(opts_frame.setEnabled) data_btn.toggled.connect(self.set_as_data) code_btn.toggled.connect(self.set_as_code) # self.connect(txt_btn, SIGNAL("toggled(bool)"), # self, SLOT("is_text(bool)")) # Final layout layout = QVBoxLayout() layout.addWidget(type_frame) layout.addWidget(self.text_editor) layout.addWidget(opts_frame) self.setLayout(layout)
class DesignTab(QWidget): def __init__(self): super(DesignTab, self).__init__() self.setup_ui() self.grain_dialog = None self.btn_new_grain.clicked.connect(self.create_grain_dialog) def create_grain_dialog(self): self.grain_dialog = NewGrainDialog() self.grain_dialog.show() self.grain_dialog.activateWindow() self.grain_dialog.raise_() def setup_ui(self): sp = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self.setSizePolicy(sp) def setup_grain_design(): # grain table view master = QHBoxLayout(self) master.addWidget(QTableView()) # grain design controls controls = QVBoxLayout(self) # add a push button self.btn_new_grain = QPushButton(self.tr("New Grain")) self.btn_new_grain.setMinimumHeight(50) controls.addWidget(self.btn_new_grain) # add a dividing line line = QFrame() line.setFrameShape(QFrame.HLine) line.setFrameShadow(QFrame.Sunken) controls.addSpacing(5) controls.addWidget(line) # rest of the controls buttons self.btn_edit_grain = QPushButton(self.tr("Edit")) self.btn_edit_grain.setMinimumHeight(30) controls.addWidget(self.btn_edit_grain) self.btn_delete_Grain = QPushButton(self.tr("Delete")) self.btn_delete_Grain.setMinimumHeight(30) controls.addWidget(self.btn_delete_Grain) # move grain up and down moveup = QHBoxLayout() self.btn_move_up = QToolButton() self.btn_move_up.setArrowType(Qt.UpArrow) moveup.addWidget(self.btn_move_up) moveup.addWidget(QLabel(self.tr("Move Up"))) controls.addLayout(moveup) movedown = QHBoxLayout() self.btn_move_down = QToolButton() self.btn_move_down.setArrowType(Qt.DownArrow) movedown.addWidget(self.btn_move_down) movedown.addWidget(QLabel(self.tr("Move Down"))) controls.addLayout(movedown) controls.addStretch() # add info for motor design fl_propellant_info = QFormLayout() gb_motor_info = QGroupBox(self.tr("Propellant Info")) gb_motor_info.setLayout(fl_propellant_info) self.lbl_num_grains = QLabel() fl_propellant_info.addRow(QLabel(self.tr("Number of Segments:")), self.lbl_num_grains) self.lbl_motor_dia = QLabel() fl_propellant_info.addRow(QLabel(self.tr("Motor Diameter:")), self.lbl_motor_dia) self.lbl_motor_len = QLabel() fl_propellant_info.addRow(QLabel(self.tr("Propellant Length:")), self.lbl_motor_len) self.lbl_prop_mass = QLabel() fl_propellant_info.addRow(QLabel(self.tr("Propellant Mass:")), self.lbl_prop_mass) self.lbl_volume_loading = QLabel() fl_propellant_info.addRow(QLabel(self.tr("Volume Loading:")), self.lbl_volume_loading) # set group box's layout controls.addWidget(gb_motor_info) # setup master layout master.addLayout(controls) self.gb_design = QGroupBox(self.tr("Grain Design")) self.gb_design.setLayout(master) def setup_chamber_design(): # master layout master = QVBoxLayout() # master group box self.gb_chamber = QGroupBox(self.tr("Chamber Design")) # nozzle settings button self.btn_nozzle_settings = QPushButton(self.tr("Edit Nozzle")) self.btn_nozzle_settings.setMinimumHeight(50) master.addWidget(self.btn_nozzle_settings) # nozzle info pane fl_nozzle_info = QFormLayout() gb_nozzle = QGroupBox(self.tr("Nozzle Info")) gb_nozzle.setLayout(fl_nozzle_info) self.lbl_nozzle_throat = QLabel() fl_nozzle_info.addRow(QLabel(self.tr("Throat Diameter:")), self.lbl_nozzle_throat) self.lbl_nozzle_exit = QLabel() fl_nozzle_info.addRow(QLabel(self.tr("Exit Diameter:")), self.lbl_nozzle_exit) self.lbl_nozzle_expansion_ratio = QLabel() fl_nozzle_info.addRow(QLabel(self.tr("Expansion Ratio:")), self.lbl_nozzle_expansion_ratio) # add group box to master master.addWidget(gb_nozzle) master.addStretch() # overall motor info pane fl_motor_info = QFormLayout() gb_motor = QGroupBox(self.tr("Motor Info")) gb_motor.setLayout(fl_motor_info) self.lbl_kn = QLabel() fl_motor_info.addRow(QLabel(self.tr("Kn:")), self.lbl_kn) self.lbl_port_throat = QLabel() fl_motor_info.addRow(QLabel(self.tr("Port/Throat Ratio:")), self.lbl_port_throat) master.addWidget(gb_motor) self.gb_chamber.setLayout(master) def setup_gfx_ui(): # design overview self.motor_display_view = QGraphicsView() self.motor_display_scene = QGraphicsScene() self.motor_display_view.setScene(self.motor_display_scene) self.motor_display_view.show() # sliced cross section self.grain_slice_view = QGraphicsView() self.grain_slice_scene = QGraphicsScene() self.grain_slice_view.setScene(self.grain_slice_scene) self.grain_slice_view.show() # splitter self.splt_gfx = QSplitter(Qt.Horizontal) self.splt_gfx.addWidget(self.motor_display_view) self.splt_gfx.addWidget(self.grain_slice_view) self.splt_gfx.setStretchFactor(0, 10) self.splt_gfx.setStretchFactor(1, 3) self.splt_gfx.setMinimumHeight(50) setup_grain_design() setup_chamber_design() setup_gfx_ui() self.splt_grain_design = QSplitter(Qt.Horizontal) self.splt_grain_design.addWidget(self.gb_design) self.splt_grain_design.addWidget(self.gb_chamber) self.splt_grain_design.setStretchFactor(0, 10) self.splt_grain_design.setStretchFactor(1, 3) self.splt_main = QSplitter(Qt.Vertical) self.splt_main.addWidget(self.splt_grain_design) self.splt_main.addWidget(self.splt_gfx) self.splt_main.setSizes([300, 150]) layout = QVBoxLayout() layout.addWidget(self.splt_main) self.setLayout(layout)
def _get_config_widget(self, parent): gb_pos = QGroupBox('Image Processing ', parent) meth_sp = PyDMEnumComboBox( gb_pos, init_channel=self._dev+':CalcMethod-Sel') meth_lb = SiriusLabel(gb_pos, init_channel=self._dev+':CalcMethod-Sts') meth_ld = QLabel('Method', gb_pos) nrpt_ld = QLabel('Num. Pts.', gb_pos) nrpt_sp = SiriusSpinbox( gb_pos, init_channel=self._dev+':NrAverages-SP') nrpt_sp.showStepExponent = False rdb = PyDMLabel(gb_pos, init_channel=self._dev+':NrAverages-RB') rdb.setAlignment(Qt.AlignLeft | Qt.AlignVCenter) slsh = QLabel('/', gb_pos, alignment=Qt.AlignCenter) slsh.setStyleSheet('min-width:0.7em; max-width:0.7em;') cnt = PyDMLabel(gb_pos, init_channel=self._dev+':BufferSize-Mon') cnt.setAlignment(Qt.AlignRight | Qt.AlignVCenter) cnt.setToolTip('Current Buffer Size') pbt = PyDMPushButton( gb_pos, init_channel=self._dev+':ResetBuffer-Cmd', pressValue=1) pbt.setToolTip('Reset Buffer') pbt.setIcon(qta.icon('mdi.delete-empty')) pbt.setObjectName('rst') pbt.setStyleSheet( '#rst{min-width:25px; max-width:25px; icon-size:20px;}') nrpt_wd = QWidget(gb_pos) hbl = QHBoxLayout(nrpt_wd) hbl.addWidget(pbt) hbl.addStretch() hbl.addWidget(cnt) hbl.addWidget(slsh) hbl.addWidget(rdb) rsx_sp = SiriusSpinbox(gb_pos, init_channel=self._dev+':ROISizeX-SP') rsx_sp.showStepExponent = False rsx_lb = SiriusLabel(gb_pos, init_channel=self._dev+':ROISizeX-RB') rsx_ld = QLabel('ROI Size X', gb_pos) rsy_sp = SiriusSpinbox(gb_pos, init_channel=self._dev+':ROISizeY-SP') rsy_sp.showStepExponent = False rsy_lb = SiriusLabel(gb_pos, init_channel=self._dev+':ROISizeY-RB') rsy_ld = QLabel('ROI Size Y', gb_pos) ra_bt = PyDMStateButton( gb_pos, init_channel=self._dev+':ROIAutoCenter-Sel') ra_lb = SiriusLabel( gb_pos, init_channel=self._dev+':ROIAutoCenter-Sts') ra_ld = QLabel('Auto Center:', gb_pos) rcx_sp = SiriusSpinbox(gb_pos, init_channel=self._dev+':ROICenterX-SP') rcx_sp.showStepExponent = False rcx_lb = SiriusLabel(gb_pos, init_channel=self._dev+':ROICenterX-RB') rcx_ld = QLabel('ROI Center X', gb_pos) rcy_sp = SiriusSpinbox(gb_pos, init_channel=self._dev+':ROICenterY-SP') rcy_sp.showStepExponent = False rcy_lb = SiriusLabel(gb_pos, init_channel=self._dev+':ROICenterY-RB') rcy_ld = QLabel('ROI Center Y', gb_pos) sts_bt = QPushButton(qta.icon('fa5s.ellipsis-h'), '', gb_pos) sts_bt.setToolTip('Open Detailed Configs') sts_bt.setObjectName('sts') sts_bt.setStyleSheet( '#sts{min-width:25px; max-width:25px; icon-size:20px;}') Window = create_window_from_widget( _DetailedWidget, title='Image Processing Detailed Configs') connect_window( sts_bt, Window, gb_pos, device=self._dev, convertion_set=self._conv_set) hlay = QHBoxLayout() hlay.addWidget(sts_bt, alignment=Qt.AlignRight) lay = QGridLayout(gb_pos) if self._ori == 'V': lay.addWidget(meth_ld, 0, 0, 2, 1, alignment=Qt.AlignLeft) lay.addWidget(meth_sp, 0, 1) lay.addWidget(meth_lb, 1, 1) lay.addWidget(nrpt_ld, 2, 0, alignment=Qt.AlignLeft) lay.addWidget(nrpt_sp, 2, 1) lay.addWidget(nrpt_wd, 3, 0, 1, 2) lay.addWidget(rsx_ld, 4+0, 0, 2, 1, alignment=Qt.AlignLeft) lay.addWidget(rsx_sp, 4+0, 1) lay.addWidget(rsx_lb, 4+1, 1) lay.addWidget(rsy_ld, 6+0, 0, 2, 1, alignment=Qt.AlignLeft) lay.addWidget(rsy_sp, 6+0, 1) lay.addWidget(rsy_lb, 6+1, 1) lay.addWidget(sts_bt, 0, 0+4, alignment=Qt.AlignRight) lay.addWidget(ra_ld, 2+0, 0+3, 2, 1, alignment=Qt.AlignLeft) lay.addWidget(ra_bt, 2+0, 1+3) lay.addWidget(ra_lb, 2+1, 1+3, alignment=Qt.AlignLeft) lay.addWidget(rcx_ld, 4+0, 0+3, 2, 1, alignment=Qt.AlignLeft) lay.addWidget(rcx_sp, 4+0, 1+3) lay.addWidget(rcx_lb, 4+1, 1+3) lay.addWidget(rcy_ld, 6+0, 0+3, 2, 1, alignment=Qt.AlignLeft) lay.addWidget(rcy_sp, 6+0, 1+3) lay.addWidget(rcy_lb, 6+1, 1+3) else: lay.addWidget(meth_ld, 0, 0, 2, 1, alignment=Qt.AlignLeft) lay.addWidget(meth_sp, 0, 1) lay.addWidget(meth_lb, 1, 1) lay.addWidget(nrpt_ld, 2, 0, alignment=Qt.AlignLeft) lay.addWidget(nrpt_sp, 2, 1) lay.addWidget(nrpt_wd, 3, 0, 1, 2) lay.addWidget(rsx_ld, 4+0, 0, 2, 1, alignment=Qt.AlignLeft) lay.addWidget(rsx_sp, 4+0, 1) lay.addWidget(rsx_lb, 4+1, 1) lay.addWidget(rsy_ld, 6+0, 0, 2, 1, alignment=Qt.AlignLeft) lay.addWidget(rsy_sp, 6+0, 1) lay.addWidget(rsy_lb, 6+1, 1) lay.addWidget(ra_ld, 8+0, 0, 2, 1, alignment=Qt.AlignLeft) lay.addWidget(ra_bt, 8+0, 1) lay.addWidget(ra_lb, 8+1, 1, alignment=Qt.AlignLeft) lay.addWidget(rcx_ld, 10+0, 0, 2, 1, alignment=Qt.AlignLeft) lay.addWidget(rcx_sp, 10+0, 1) lay.addWidget(rcx_lb, 10+1, 1) lay.addWidget(rcy_ld, 12+0, 0, 2, 1, alignment=Qt.AlignLeft) lay.addWidget(rcy_sp, 12+0, 1) lay.addWidget(rcy_lb, 12+1, 1) lay.addWidget(sts_bt, 14, 0, alignment=Qt.AlignLeft) lay.setRowStretch(15, 5) return gb_pos
def setup_page(self): if ERR_MSG: label = QLabel(_("Could not load plugin:\n{0}".format(ERR_MSG))) layout = QVBoxLayout() layout.addWidget(label) self.setLayout(layout) return # General options # Hack : the spinbox widget will be added to self.spinboxes # spinboxes_before = set(self.spinboxes) # line length line_length_spin = self.create_spinbox( _("Line length: "), "", "line_length", default=self.OPTIONS["line_length"], min_=40, max_=200, step=1, tip=_("Set line lenght"), ) # spinbox = set(self.spinboxes) - spinboxes_before # spinbox = spinbox.pop() # target python version versions_group = QGroupBox(_("Target versions")) target_layout = QGridLayout() default = get_python_version() # the python version being used for i, option in enumerate(self.OPTIONS["target_version"]): if default == option[0]: value = True else: value = False col = i - (i // 2) * 2 row = i // 2 cb = self.create_checkbox(option[0], option[1], default=value) target_layout.addWidget(cb, row, col) versions_group.setLayout(target_layout) # skip string normalization choices = self.OPTIONS["skip_string_normalization"] default = "False" skip_string_combobox = self.create_combobox( _("Skip string normalization: "), choices, "skip_string_normalization", default=default, ) # General layout options_layout = QVBoxLayout() options_layout.addWidget(line_length_spin) options_layout.addWidget(versions_group) options_layout.addWidget(skip_string_combobox) options_group = QGroupBox(_("Options")) options_group.setLayout(options_layout) vlayout = QVBoxLayout() vlayout.addWidget(options_group) self.setLayout(vlayout)
def setup_grain_design(): # grain table view master = QHBoxLayout(self) master.addWidget(QTableView()) # grain design controls controls = QVBoxLayout(self) # add a push button self.btn_new_grain = QPushButton(self.tr("New Grain")) self.btn_new_grain.setMinimumHeight(50) controls.addWidget(self.btn_new_grain) # add a dividing line line = QFrame() line.setFrameShape(QFrame.HLine) line.setFrameShadow(QFrame.Sunken) controls.addSpacing(5) controls.addWidget(line) # rest of the controls buttons self.btn_edit_grain = QPushButton(self.tr("Edit")) self.btn_edit_grain.setMinimumHeight(30) controls.addWidget(self.btn_edit_grain) self.btn_delete_Grain = QPushButton(self.tr("Delete")) self.btn_delete_Grain.setMinimumHeight(30) controls.addWidget(self.btn_delete_Grain) # move grain up and down moveup = QHBoxLayout() self.btn_move_up = QToolButton() self.btn_move_up.setArrowType(Qt.UpArrow) moveup.addWidget(self.btn_move_up) moveup.addWidget(QLabel(self.tr("Move Up"))) controls.addLayout(moveup) movedown = QHBoxLayout() self.btn_move_down = QToolButton() self.btn_move_down.setArrowType(Qt.DownArrow) movedown.addWidget(self.btn_move_down) movedown.addWidget(QLabel(self.tr("Move Down"))) controls.addLayout(movedown) controls.addStretch() # add info for motor design fl_propellant_info = QFormLayout() gb_motor_info = QGroupBox(self.tr("Propellant Info")) gb_motor_info.setLayout(fl_propellant_info) self.lbl_num_grains = QLabel() fl_propellant_info.addRow(QLabel(self.tr("Number of Segments:")), self.lbl_num_grains) self.lbl_motor_dia = QLabel() fl_propellant_info.addRow(QLabel(self.tr("Motor Diameter:")), self.lbl_motor_dia) self.lbl_motor_len = QLabel() fl_propellant_info.addRow(QLabel(self.tr("Propellant Length:")), self.lbl_motor_len) self.lbl_prop_mass = QLabel() fl_propellant_info.addRow(QLabel(self.tr("Propellant Mass:")), self.lbl_prop_mass) self.lbl_volume_loading = QLabel() fl_propellant_info.addRow(QLabel(self.tr("Volume Loading:")), self.lbl_volume_loading) # set group box's layout controls.addWidget(gb_motor_info) # setup master layout master.addLayout(controls) self.gb_design = QGroupBox(self.tr("Grain Design")) self.gb_design.setLayout(master)
def __init__(self, parent): QGroupBox.__init__(self, parent) self.ui = Ui_groupBoxZ_Component_Single() self.ui.setupUi(self)
def __init__(self, parent=None): QWidget.__init__(self, parent) self.dir = None self.runconf = RunConfiguration() firstrun_o = CONF.get('run', ALWAYS_OPEN_FIRST_RUN_OPTION, False) # --- Interpreter --- interpreter_group = QGroupBox(_("Console")) interpreter_layout = QVBoxLayout() interpreter_group.setLayout(interpreter_layout) self.current_radio = QRadioButton(CURRENT_INTERPRETER) interpreter_layout.addWidget(self.current_radio) self.dedicated_radio = QRadioButton(DEDICATED_INTERPRETER) interpreter_layout.addWidget(self.dedicated_radio) self.systerm_radio = QRadioButton(SYSTERM_INTERPRETER) interpreter_layout.addWidget(self.systerm_radio) # --- General settings ---- common_group = QGroupBox(_("General settings")) common_layout = QGridLayout() common_group.setLayout(common_layout) self.clear_var_cb = QCheckBox(CLEAR_ALL_VARIABLES) common_layout.addWidget(self.clear_var_cb, 0, 0) self.post_mortem_cb = QCheckBox(POST_MORTEM) common_layout.addWidget(self.post_mortem_cb, 1, 0) self.clo_cb = QCheckBox(_("Command line options:")) common_layout.addWidget(self.clo_cb, 2, 0) self.clo_edit = QLineEdit() self.clo_cb.toggled.connect(self.clo_edit.setEnabled) self.clo_edit.setEnabled(False) common_layout.addWidget(self.clo_edit, 2, 1) # --- Working directory --- wdir_group = QGroupBox(_("Working Directory settings")) wdir_layout = QVBoxLayout() wdir_group.setLayout(wdir_layout) self.file_dir_radio = QRadioButton(FILE_DIR) wdir_layout.addWidget(self.file_dir_radio) self.cwd_radio = QRadioButton(CW_DIR) wdir_layout.addWidget(self.cwd_radio) fixed_dir_layout = QHBoxLayout() self.fixed_dir_radio = QRadioButton(FIXED_DIR) fixed_dir_layout.addWidget(self.fixed_dir_radio) self.wd_edit = QLineEdit() self.fixed_dir_radio.toggled.connect(self.wd_edit.setEnabled) self.wd_edit.setEnabled(False) fixed_dir_layout.addWidget(self.wd_edit) browse_btn = QPushButton(ima.icon('DirOpenIcon'), '', self) browse_btn.setToolTip(_("Select directory")) browse_btn.clicked.connect(self.select_directory) fixed_dir_layout.addWidget(browse_btn) wdir_layout.addLayout(fixed_dir_layout) # --- System terminal --- external_group = QGroupBox(_("External system terminal")) external_group.setDisabled(True) self.systerm_radio.toggled.connect(external_group.setEnabled) external_layout = QGridLayout() external_group.setLayout(external_layout) self.interact_cb = QCheckBox(INTERACT) external_layout.addWidget(self.interact_cb, 1, 0, 1, -1) self.pclo_cb = QCheckBox(_("Command line options:")) external_layout.addWidget(self.pclo_cb, 3, 0) self.pclo_edit = QLineEdit() self.pclo_cb.toggled.connect(self.pclo_edit.setEnabled) self.pclo_edit.setEnabled(False) self.pclo_edit.setToolTip(_("<b>-u</b> is added to the " "other options you set here")) external_layout.addWidget(self.pclo_edit, 3, 1) # Checkbox to preserve the old behavior, i.e. always open the dialog # on first run hline = QFrame() hline.setFrameShape(QFrame.HLine) hline.setFrameShadow(QFrame.Sunken) self.firstrun_cb = QCheckBox(ALWAYS_OPEN_FIRST_RUN % _("this dialog")) self.firstrun_cb.clicked.connect(self.set_firstrun_o) self.firstrun_cb.setChecked(firstrun_o) layout = QVBoxLayout() layout.addWidget(interpreter_group) layout.addWidget(common_group) layout.addWidget(wdir_group) layout.addWidget(external_group) layout.addWidget(hline) layout.addWidget(self.firstrun_cb) self.setLayout(layout)
def _get_acq_commom_params_grpbx(self): grp_bx = QGroupBox('Common Parameters', self) fbl = QFormLayout(grp_bx) lbl = QLabel('Non-linear Corr.', grp_bx, alignment=Qt.AlignCenter) wid = self.create_pair_butled(grp_bx, 'PolyCalibration') fbl.addRow(lbl, wid) self._set_detailed([lbl, wid]) lbl = QLabel('Channel Rate', grp_bx, alignment=Qt.AlignCenter) wid = self.create_pair_sel(grp_bx, 'TrigAcqChan') fbl.addRow(lbl, wid) lbl = QLabel('Trigger Type', grp_bx, alignment=Qt.AlignCenter) wid = self.create_pair_sel(grp_bx, 'TrigAcqTrigger') fbl.addRow(lbl, wid) self._set_detailed([lbl, wid]) lbl = QLabel('Repeat', grp_bx, alignment=Qt.AlignCenter) wid = self.create_pair_butled(grp_bx, 'TrigAcqRepeat') fbl.addRow(lbl, wid) self._set_detailed([lbl, wid]) if self.isring: lbl = QLabel('Nr of Shots', grp_bx, alignment=Qt.AlignCenter) wid = self.create_pair(grp_bx, 'TrigNrShots') fbl.addRow(lbl, wid) self._set_detailed([lbl, wid]) lbl = QLabel('SamplesPre', grp_bx, alignment=Qt.AlignCenter) wid = self.create_pair(grp_bx, 'TrigNrSamplesPre') fbl.addRow(lbl, wid) lbl = QLabel('SamplesPost', grp_bx, alignment=Qt.AlignCenter) wid = self.create_pair(grp_bx, 'TrigNrSamplesPost') fbl.addRow(lbl, wid) lbl = QLabel('Acquisition:', grp_bx, alignment=Qt.AlignCenter) strt = PyDMPushButton( grp_bx, label='', init_channel=self.devpref.substitute(propty='TrigAcqCtrl-Sel'), pressValue=self._csorb.TrigAcqCtrl.Start) strt.setToolTip('Start Acquisition') strt.setIcon(qta.icon('fa5s.play')) strt.setObjectName('strt') strt.setStyleSheet( '#strt{min-width:25px; max-width:25px; icon-size:20px;}') stop = PyDMPushButton( grp_bx, label='', init_channel=self.devpref.substitute(propty='TrigAcqCtrl-Sel'), pressValue=self._csorb.TrigAcqCtrl.Stop) stop.setToolTip('Stop Acquisition') stop.setIcon(qta.icon('fa5s.stop')) stop.setObjectName('stop') stop.setStyleSheet( '#stop{min-width:25px; max-width:25px; icon-size:20px;}') abrt = PyDMPushButton( grp_bx, label='', init_channel=self.devpref.substitute(propty='TrigAcqCtrl-Sel'), pressValue=self._csorb.TrigAcqCtrl.Abort) abrt.setToolTip('Abort Acquisition') abrt.setIcon(qta.icon('fa5s.ban')) abrt.setObjectName('abrt') abrt.setStyleSheet( '#abrt{min-width:25px; max-width:25px; icon-size:20px;}') pdmlbl = PyDMLabel(grp_bx, self.devpref.substitute(propty='TrigAcqCtrl-Sts')) pdmlbl.setObjectName('pdmlbl') pdmlbl.setStyleSheet('#pdmlbl{min-width:6em; max-width:6em;}') pdmlbl.setAlignment(Qt.AlignCenter) hbl = QHBoxLayout() fbl.addRow(hbl) hbl.addStretch() hbl.addWidget(lbl) hbl.addWidget(strt) hbl.addWidget(stop) hbl.addWidget(abrt) hbl.addWidget(pdmlbl) conf = PyDMPushButton( grp_bx, pressValue=1, init_channel=self.devpref.substitute(propty='TrigAcqConfig-Cmd')) conf.setToolTip('Resend Configurations') conf.setIcon(qta.icon('fa5s.sync')) conf.setObjectName('conf') conf.setStyleSheet( '#conf{min-width:25px; max-width:25px; icon-size:20px;}') sts = QPushButton('', grp_bx) sts.setIcon(qta.icon('fa5s.list-ul')) sts.setToolTip('Open Detailed Status View') sts.setObjectName('sts') sts.setStyleSheet( '#sts{min-width:25px; max-width:25px; icon-size:20px;}') Window = create_window_from_widget(StatusWidget, title='Orbit Status') connect_window(sts, Window, grp_bx, device=self.device, prefix=self.prefix, acc=self.acc, is_orb=True) pdm_led = SiriusLedAlert( grp_bx, self.devpref.substitute(propty='OrbStatus-Mon')) lbl = QLabel('Status:', grp_bx) hbl = QHBoxLayout() hbl.setSpacing(9) hbl.addStretch() hbl.addWidget(lbl) hbl.addWidget(pdm_led) hbl.addWidget(sts) hbl.addWidget(conf) fbl.addRow(hbl) return grp_bx
def __init__(self, parent, text): QWidget.__init__(self, parent) self.text_editor = QTextEdit(self) self.text_editor.setText(text) self.text_editor.setReadOnly(True) # Type frame type_layout = QHBoxLayout() type_label = QLabel(_("Import as")) type_layout.addWidget(type_label) data_btn = QRadioButton(_("data")) data_btn.setChecked(True) self._as_data = True type_layout.addWidget(data_btn) code_btn = QRadioButton(_("code")) self._as_code = False type_layout.addWidget(code_btn) txt_btn = QRadioButton(_("text")) type_layout.addWidget(txt_btn) h_spacer = QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum) type_layout.addItem(h_spacer) type_frame = QFrame() type_frame.setLayout(type_layout) # Opts frame grid_layout = QGridLayout() grid_layout.setSpacing(0) col_label = QLabel(_("Column separator:")) grid_layout.addWidget(col_label, 0, 0) col_w = QWidget() col_btn_layout = QHBoxLayout() self.tab_btn = QRadioButton(_("Tab")) self.tab_btn.setChecked(False) col_btn_layout.addWidget(self.tab_btn) other_btn_col = QRadioButton(_("other")) other_btn_col.setChecked(True) col_btn_layout.addWidget(other_btn_col) col_w.setLayout(col_btn_layout) grid_layout.addWidget(col_w, 0, 1) self.line_edt = QLineEdit(",") self.line_edt.setMaximumWidth(30) self.line_edt.setEnabled(True) other_btn_col.toggled.connect(self.line_edt.setEnabled) grid_layout.addWidget(self.line_edt, 0, 2) row_label = QLabel(_("Row separator:")) grid_layout.addWidget(row_label, 1, 0) row_w = QWidget() row_btn_layout = QHBoxLayout() self.eol_btn = QRadioButton(_("EOL")) self.eol_btn.setChecked(True) row_btn_layout.addWidget(self.eol_btn) other_btn_row = QRadioButton(_("other")) row_btn_layout.addWidget(other_btn_row) row_w.setLayout(row_btn_layout) grid_layout.addWidget(row_w, 1, 1) self.line_edt_row = QLineEdit(";") self.line_edt_row.setMaximumWidth(30) self.line_edt_row.setEnabled(False) other_btn_row.toggled.connect(self.line_edt_row.setEnabled) grid_layout.addWidget(self.line_edt_row, 1, 2) grid_layout.setRowMinimumHeight(2, 15) other_group = QGroupBox(_("Additional options")) other_layout = QGridLayout() other_group.setLayout(other_layout) skiprows_label = QLabel(_("Skip rows:")) other_layout.addWidget(skiprows_label, 0, 0) self.skiprows_edt = QLineEdit('0') self.skiprows_edt.setMaximumWidth(30) intvalid = QIntValidator(0, len(to_text_string(text).splitlines()), self.skiprows_edt) self.skiprows_edt.setValidator(intvalid) other_layout.addWidget(self.skiprows_edt, 0, 1) other_layout.setColumnMinimumWidth(2, 5) comments_label = QLabel(_("Comments:")) other_layout.addWidget(comments_label, 0, 3) self.comments_edt = QLineEdit('#') self.comments_edt.setMaximumWidth(30) other_layout.addWidget(self.comments_edt, 0, 4) self.trnsp_box = QCheckBox(_("Transpose")) #self.trnsp_box.setEnabled(False) other_layout.addWidget(self.trnsp_box, 1, 0, 2, 0) grid_layout.addWidget(other_group, 3, 0, 2, 0) opts_frame = QFrame() opts_frame.setLayout(grid_layout) data_btn.toggled.connect(opts_frame.setEnabled) data_btn.toggled.connect(self.set_as_data) code_btn.toggled.connect(self.set_as_code) # self.connect(txt_btn, SIGNAL("toggled(bool)"), # self, SLOT("is_text(bool)")) # Final layout layout = QVBoxLayout() layout.addWidget(type_frame) layout.addWidget(self.text_editor) layout.addWidget(opts_frame) self.setLayout(layout)
def setup_page(self): self.ICON = ima.icon('eyedropper') names = self.get_option("names") try: names.pop(names.index(u'Custom')) except ValueError: pass custom_names = self.get_option("custom_names", []) # Interface options theme_group = QGroupBox(_("Main interface")) # Interface Widgets ui_themes = ['Automatic', 'Light', 'Dark'] ui_theme_choices = list( zip(ui_themes, [ui_theme.lower() for ui_theme in ui_themes])) ui_theme_combo = self.create_combobox(_('Interface theme'), ui_theme_choices, 'ui_theme', restart=True) styles = [str(txt) for txt in list(QStyleFactory.keys())] # Don't offer users the possibility to change to a different # style in Gtk-based desktops # Fixes Issue 2036 if is_gtk_desktop() and ('GTK+' in styles): styles = ['GTK+'] choices = list(zip(styles, [style.lower() for style in styles])) style_combo = self.create_combobox(_('Qt windows style'), choices, 'windows_style', default=self.main.default_style) self.style_combobox = style_combo.combobox themes = ['Spyder 2', 'Spyder 3'] icon_choices = list(zip(themes, [theme.lower() for theme in themes])) icons_combo = self.create_combobox(_('Icon theme'), icon_choices, 'icon_theme', restart=True) theme_comboboxes_layout = QGridLayout() theme_comboboxes_layout.addWidget(ui_theme_combo.label, 0, 0) theme_comboboxes_layout.addWidget(ui_theme_combo.combobox, 0, 1) theme_comboboxes_layout.addWidget(style_combo.label, 1, 0) theme_comboboxes_layout.addWidget(self.style_combobox, 1, 1) theme_comboboxes_layout.addWidget(icons_combo.label, 2, 0) theme_comboboxes_layout.addWidget(icons_combo.combobox, 2, 1) theme_layout = QVBoxLayout() theme_layout.addLayout(theme_comboboxes_layout) theme_group.setLayout(theme_layout) # Syntax coloring options syntax_group = QGroupBox(_("Syntax highlighting theme")) # Syntax Widgets edit_button = QPushButton(_("Edit selected scheme")) create_button = QPushButton(_("Create new scheme")) self.delete_button = QPushButton(_("Delete scheme")) self.reset_button = QPushButton(_("Reset to defaults")) self.preview_editor = CodeEditor(self) self.stacked_widget = QStackedWidget(self) self.scheme_editor_dialog = SchemeEditor(parent=self, stack=self.stacked_widget) self.scheme_choices_dict = {} schemes_combobox_widget = self.create_combobox('', [('', '')], 'selected') self.schemes_combobox = schemes_combobox_widget.combobox # Syntax layout syntax_layout = QGridLayout(syntax_group) btns = [ self.schemes_combobox, edit_button, self.reset_button, create_button, self.delete_button ] for i, btn in enumerate(btns): syntax_layout.addWidget(btn, i, 1) syntax_layout.setColumnStretch(0, 1) syntax_layout.setColumnStretch(1, 2) syntax_layout.setColumnStretch(2, 1) syntax_layout.setContentsMargins(0, 12, 0, 12) # Fonts options fonts_group = QGroupBox(_("Fonts")) # Fonts widgets plain_text_font = self.create_fontgroup( option='font', title=_("Plain text"), fontfilters=QFontComboBox.MonospacedFonts, without_group=True) rich_text_font = self.create_fontgroup(option='rich_font', title=_("Rich text"), without_group=True) # Fonts layouts fonts_layout = QGridLayout(fonts_group) fonts_layout.addWidget(plain_text_font.fontlabel, 0, 0) fonts_layout.addWidget(plain_text_font.fontbox, 0, 1) fonts_layout.addWidget(plain_text_font.sizelabel, 0, 2) fonts_layout.addWidget(plain_text_font.sizebox, 0, 3) fonts_layout.addWidget(rich_text_font.fontlabel, 1, 0) fonts_layout.addWidget(rich_text_font.fontbox, 1, 1) fonts_layout.addWidget(rich_text_font.sizelabel, 1, 2) fonts_layout.addWidget(rich_text_font.sizebox, 1, 3) fonts_layout.setRowStretch(fonts_layout.rowCount(), 1) # Left options layout options_layout = QVBoxLayout() options_layout.addWidget(theme_group) options_layout.addWidget(syntax_group) options_layout.addWidget(fonts_group) # Right preview layout preview_group = QGroupBox(_("Preview")) preview_layout = QVBoxLayout() preview_layout.addWidget(self.preview_editor) preview_group.setLayout(preview_layout) # Combined layout combined_layout = QGridLayout() combined_layout.setRowStretch(0, 1) combined_layout.setColumnStretch(1, 100) combined_layout.addLayout(options_layout, 0, 0) combined_layout.addWidget(preview_group, 0, 1) self.setLayout(combined_layout) # Signals and slots create_button.clicked.connect(self.create_new_scheme) edit_button.clicked.connect(self.edit_scheme) self.reset_button.clicked.connect(self.reset_to_default) self.delete_button.clicked.connect(self.delete_scheme) self.schemes_combobox.currentIndexChanged.connect(self.update_preview) self.schemes_combobox.currentIndexChanged.connect(self.update_buttons) # Setup for name in names: self.scheme_editor_dialog.add_color_scheme_stack(name) for name in custom_names: self.scheme_editor_dialog.add_color_scheme_stack(name, custom=True) self.update_combobox() self.update_preview() self.update_qt_style_combobox()
def setup_page(self): self.ICON = ima.icon('genprefs') newcb = self.create_checkbox # --- Interface general_group = QGroupBox(_("General")) languages = LANGUAGE_CODES.items() language_choices = sorted([(val, key) for key, val in languages]) language_combo = self.create_combobox(_('Language:'), language_choices, 'interface_language', restart=True) opengl_options = ['Automatic', 'Desktop', 'Software', 'GLES'] opengl_choices = list(zip(opengl_options, [c.lower() for c in opengl_options])) opengl_combo = self.create_combobox(_('Rendering engine:'), opengl_choices, 'opengl', restart=True) single_instance_box = newcb(_("Use a single instance"), 'single_instance', tip=_("Set this to open external<br> " "Python files in an already running " "instance (Requires a restart)")) prompt_box = newcb(_("Prompt when exiting"), 'prompt_on_exit') popup_console_box = newcb(_("Show internal Spyder errors to report " "them to Github"), 'show_internal_errors') check_updates = newcb(_("Check for updates on startup"), 'check_updates_on_startup') # Decide if it's possible to activate or not single instance mode if running_in_mac_app(): self.set_option("single_instance", True) single_instance_box.setEnabled(False) comboboxes_advanced_layout = QHBoxLayout() cbs_adv_grid = QGridLayout() cbs_adv_grid.addWidget(language_combo.label, 0, 0) cbs_adv_grid.addWidget(language_combo.combobox, 0, 1) cbs_adv_grid.addWidget(opengl_combo.label, 1, 0) cbs_adv_grid.addWidget(opengl_combo.combobox, 1, 1) comboboxes_advanced_layout.addLayout(cbs_adv_grid) comboboxes_advanced_layout.addStretch(1) general_layout = QVBoxLayout() general_layout.addLayout(comboboxes_advanced_layout) general_layout.addWidget(single_instance_box) general_layout.addWidget(prompt_box) general_layout.addWidget(popup_console_box) general_layout.addWidget(check_updates) general_group.setLayout(general_layout) # --- Theme interface_group = QGroupBox(_("Interface")) vertdock_box = newcb(_("Vertical title bars in panes"), 'vertical_dockwidget_titlebars') verttabs_box = newcb(_("Vertical tabs in panes"), 'vertical_tabs') animated_box = newcb(_("Animated toolbars and panes"), 'animated_docks') tear_off_box = newcb(_("Tear off menus"), 'tear_off_menus', tip=_("Set this to detach any<br> " "menu from the main window")) margin_box = newcb(_("Custom margin for panes:"), 'use_custom_margin') margin_spin = self.create_spinbox("", _("pixels"), 'custom_margin', 0, 0, 30) margin_box.toggled.connect(margin_spin.spinbox.setEnabled) margin_box.toggled.connect(margin_spin.slabel.setEnabled) margin_spin.spinbox.setEnabled(self.get_option('use_custom_margin')) margin_spin.slabel.setEnabled(self.get_option('use_custom_margin')) cursor_box = newcb(_("Cursor blinking:"), 'use_custom_cursor_blinking') cursor_spin = self.create_spinbox( "", _("ms"), 'custom_cursor_blinking', default=QApplication.cursorFlashTime(), min_=0, max_=5000, step=100) cursor_box.toggled.connect(cursor_spin.spinbox.setEnabled) cursor_box.toggled.connect(cursor_spin.slabel.setEnabled) cursor_spin.spinbox.setEnabled( self.get_option('use_custom_cursor_blinking')) cursor_spin.slabel.setEnabled( self.get_option('use_custom_cursor_blinking')) margins_cursor_layout = QGridLayout() margins_cursor_layout.addWidget(margin_box, 0, 0) margins_cursor_layout.addWidget(margin_spin.spinbox, 0, 1) margins_cursor_layout.addWidget(margin_spin.slabel, 0, 2) margins_cursor_layout.addWidget(cursor_box, 1, 0) margins_cursor_layout.addWidget(cursor_spin.spinbox, 1, 1) margins_cursor_layout.addWidget(cursor_spin.slabel, 1, 2) margins_cursor_layout.setColumnStretch(2, 100) # Layout interface interface_layout = QVBoxLayout() interface_layout.addWidget(vertdock_box) interface_layout.addWidget(verttabs_box) interface_layout.addWidget(animated_box) interface_layout.addWidget(tear_off_box) interface_layout.addLayout(margins_cursor_layout) interface_group.setLayout(interface_layout) # --- Status bar sbar_group = QGroupBox(_("Status bar")) show_status_bar = newcb(_("Show status bar"), 'show_status_bar') memory_box = newcb(_("Show memory usage every"), 'memory_usage/enable', tip=self.main.mem_status.toolTip()) memory_spin = self.create_spinbox("", _(" ms"), 'memory_usage/timeout', min_=100, max_=1000000, step=100) memory_box.toggled.connect(memory_spin.setEnabled) memory_spin.setEnabled(self.get_option('memory_usage/enable')) memory_box.setEnabled(self.main.mem_status.is_supported()) memory_spin.setEnabled(self.main.mem_status.is_supported()) cpu_box = newcb(_("Show CPU usage every"), 'cpu_usage/enable', tip=self.main.cpu_status.toolTip()) cpu_spin = self.create_spinbox("", _(" ms"), 'cpu_usage/timeout', min_=100, max_=1000000, step=100) cpu_box.toggled.connect(cpu_spin.setEnabled) cpu_spin.setEnabled(self.get_option('cpu_usage/enable')) cpu_box.setEnabled(self.main.cpu_status.is_supported()) cpu_spin.setEnabled(self.main.cpu_status.is_supported()) status_bar_o = self.get_option('show_status_bar') show_status_bar.toggled.connect(memory_box.setEnabled) show_status_bar.toggled.connect(memory_spin.setEnabled) show_status_bar.toggled.connect(cpu_box.setEnabled) show_status_bar.toggled.connect(cpu_spin.setEnabled) memory_box.setEnabled(status_bar_o) memory_spin.setEnabled(status_bar_o) cpu_box.setEnabled(status_bar_o) cpu_spin.setEnabled(status_bar_o) # Layout status bar cpu_memory_layout = QGridLayout() cpu_memory_layout.addWidget(memory_box, 0, 0) cpu_memory_layout.addWidget(memory_spin, 0, 1) cpu_memory_layout.addWidget(cpu_box, 1, 0) cpu_memory_layout.addWidget(cpu_spin, 1, 1) sbar_layout = QVBoxLayout() sbar_layout.addWidget(show_status_bar) sbar_layout.addLayout(cpu_memory_layout) sbar_group.setLayout(sbar_layout) # --- Screen resolution Group (hidpi) screen_resolution_group = QGroupBox(_("Screen resolution")) screen_resolution_bg = QButtonGroup(screen_resolution_group) screen_resolution_label = QLabel(_("Configuration for high DPI " "screens<br><br>" "Please see " "<a href=\"{0}\">{0}</a><> " "for more information about " "these options (in " "English).").format(HDPI_QT_PAGE)) screen_resolution_label.setWordWrap(True) normal_radio = self.create_radiobutton( _("Normal"), 'normal_screen_resolution', button_group=screen_resolution_bg) auto_scale_radio = self.create_radiobutton( _("Enable auto high DPI scaling"), 'high_dpi_scaling', button_group=screen_resolution_bg, tip=_("Set this for high DPI displays"), restart=True) custom_scaling_radio = self.create_radiobutton( _("Set a custom high DPI scaling"), 'high_dpi_custom_scale_factor', button_group=screen_resolution_bg, tip=_("Set this for high DPI displays when " "auto scaling does not work"), restart=True) custom_scaling_edit = self.create_lineedit( "", 'high_dpi_custom_scale_factors', tip=_("Enter values for different screens " "separated by semicolons ';', " "float values are supported"), alignment=Qt.Horizontal, regex=r"[0-9]+(?:\.[0-9]*)(;[0-9]+(?:\.[0-9]*))*", restart=True) normal_radio.toggled.connect(custom_scaling_edit.setDisabled) auto_scale_radio.toggled.connect(custom_scaling_edit.setDisabled) custom_scaling_radio.toggled.connect(custom_scaling_edit.setEnabled) # Layout Screen resolution screen_resolution_layout = QVBoxLayout() screen_resolution_layout.addWidget(screen_resolution_label) screen_resolution_inner_layout = QGridLayout() screen_resolution_inner_layout.addWidget(normal_radio, 0, 0) screen_resolution_inner_layout.addWidget(auto_scale_radio, 1, 0) screen_resolution_inner_layout.addWidget(custom_scaling_radio, 2, 0) screen_resolution_inner_layout.addWidget(custom_scaling_edit, 2, 1) screen_resolution_layout.addLayout(screen_resolution_inner_layout) screen_resolution_group.setLayout(screen_resolution_layout) tabs = QTabWidget() tabs.addTab(self.create_tab(screen_resolution_group, interface_group), _("Interface")) tabs.addTab(self.create_tab(general_group, sbar_group), _("Advanced Settings")) vlayout = QVBoxLayout() vlayout.addWidget(tabs) self.setLayout(vlayout)
class KernelConnectionDialog(QDialog): """Dialog to connect to existing kernels (either local or remote).""" def __init__(self, parent=None): super(KernelConnectionDialog, self).__init__(parent) self.setWindowTitle(_('Connect to an existing kernel')) main_label = QLabel(_( "<p>Please select the JSON connection file (<i>e.g.</i> " "<tt>kernel-1234.json</tt>) of the existing kernel, and enter " "the SSH information if connecting to a remote machine. " "To learn more about starting external kernels and connecting " "to them, see <a href=\"https://docs.spyder-ide.org/" "ipythonconsole.html#connect-to-an-external-kernel\">" "our documentation</a>.</p>")) main_label.setWordWrap(True) main_label.setAlignment(Qt.AlignJustify) main_label.setOpenExternalLinks(True) # Connection file cf_label = QLabel(_('Connection file:')) self.cf = QLineEdit() self.cf.setPlaceholderText(_('Kernel connection file path')) self.cf.setMinimumWidth(350) cf_open_btn = QPushButton(_('Browse')) cf_open_btn.clicked.connect(self.select_connection_file) cf_layout = QHBoxLayout() cf_layout.addWidget(cf_label) cf_layout.addWidget(self.cf) cf_layout.addWidget(cf_open_btn) # Remote kernel groupbox self.rm_group = QGroupBox(_("This is a remote kernel (via SSH)")) # SSH connection hn_label = QLabel(_('Hostname:')) self.hn = QLineEdit() pn_label = QLabel(_('Port:')) self.pn = QLineEdit() self.pn.setMaximumWidth(75) self.pn.setText('22') un_label = QLabel(_('Username:'******'Password:'******'SSH keyfile:')) self.pw = QLineEdit() self.pw.setEchoMode(QLineEdit.Password) self.pw_radio.toggled.connect(self.pw.setEnabled) self.kf_radio.toggled.connect(self.pw.setDisabled) self.kf = QLineEdit() kf_open_btn = QPushButton(_('Browse')) kf_open_btn.clicked.connect(self.select_ssh_key) kf_layout = QHBoxLayout() kf_layout.addWidget(self.kf) kf_layout.addWidget(kf_open_btn) kfp_label = QLabel(_('Passphase:')) self.kfp = QLineEdit() self.kfp.setPlaceholderText(_('Optional')) self.kfp.setEchoMode(QLineEdit.Password) self.kf_radio.toggled.connect(self.kf.setEnabled) self.kf_radio.toggled.connect(self.kfp.setEnabled) self.kf_radio.toggled.connect(kf_open_btn.setEnabled) self.kf_radio.toggled.connect(kfp_label.setEnabled) self.pw_radio.toggled.connect(self.kf.setDisabled) self.pw_radio.toggled.connect(self.kfp.setDisabled) self.pw_radio.toggled.connect(kf_open_btn.setDisabled) self.pw_radio.toggled.connect(kfp_label.setDisabled) # SSH layout ssh_layout = QGridLayout() ssh_layout.addWidget(hn_label, 0, 0, 1, 2) ssh_layout.addWidget(self.hn, 0, 2) ssh_layout.addWidget(pn_label, 0, 3) ssh_layout.addWidget(self.pn, 0, 4) ssh_layout.addWidget(un_label, 1, 0, 1, 2) ssh_layout.addWidget(self.un, 1, 2, 1, 3) # SSH authentication layout auth_layout = QGridLayout() auth_layout.addWidget(self.pw_radio, 1, 0) auth_layout.addWidget(pw_label, 1, 1) auth_layout.addWidget(self.pw, 1, 2) auth_layout.addWidget(self.kf_radio, 2, 0) auth_layout.addWidget(kf_label, 2, 1) auth_layout.addLayout(kf_layout, 2, 2) auth_layout.addWidget(kfp_label, 3, 1) auth_layout.addWidget(self.kfp, 3, 2) auth_group.setLayout(auth_layout) # Remote kernel layout rm_layout = QVBoxLayout() rm_layout.addLayout(ssh_layout) rm_layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 8))) rm_layout.addWidget(auth_group) self.rm_group.setLayout(rm_layout) self.rm_group.setCheckable(True) self.rm_group.setChecked(False) self.rm_group.toggled.connect(self.pw_radio.setChecked) # Ok and Cancel buttons self.accept_btns = QDialogButtonBox( QDialogButtonBox.Ok | QDialogButtonBox.Cancel, Qt.Horizontal, self) self.accept_btns.accepted.connect(self.accept) self.accept_btns.rejected.connect(self.reject) # Dialog layout layout = QVBoxLayout(self) layout.addWidget(main_label) layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 8))) layout.addLayout(cf_layout) layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 12))) layout.addWidget(self.rm_group) layout.addWidget(self.accept_btns) def select_connection_file(self): cf = getopenfilename(self, _('Select kernel connection file'), jupyter_runtime_dir(), '*.json;;*.*')[0] self.cf.setText(cf) def select_ssh_key(self): kf = getopenfilename(self, _('Select SSH keyfile'), get_home_dir(), '*.pem;;*')[0] self.kf.setText(kf) @staticmethod def get_connection_parameters(parent=None, dialog=None): if not dialog: dialog = KernelConnectionDialog(parent) result = dialog.exec_() is_remote = bool(dialog.rm_group.isChecked()) accepted = result == QDialog.Accepted if is_remote: def falsy_to_none(arg): return arg if arg else None if dialog.hn.text() and dialog.un.text(): port = dialog.pn.text() if dialog.pn.text() else '22' hostname = "{0}@{1}:{2}".format(dialog.un.text(), dialog.hn.text(), port) else: hostname = None if dialog.pw_radio.isChecked(): password = falsy_to_none(dialog.pw.text()) keyfile = None elif dialog.kf_radio.isChecked(): keyfile = falsy_to_none(dialog.kf.text()) password = falsy_to_none(dialog.kfp.text()) else: # imposible? keyfile = None password = None return (dialog.cf.text(), hostname, keyfile, password, accepted) else: path = dialog.cf.text() _dir, filename = osp.dirname(path), osp.basename(path) if _dir == '' and not filename.endswith('.json'): path = osp.join(jupyter_runtime_dir(), 'kernel-'+path+'.json') return (path, None, None, None, accepted)
def __init__(self, settings, plotWidget, parent=None): super().__init__(parent) self.mainwindow = parent self.plotWidget = plotWidget # xmin self.xminLabel = QLabel(self.tr('xmin:')) self.xminSpinBox = CoordSpinBox() self.xminLabel.setBuddy(self.xminSpinBox) self.xminSpinBox.editingFinished.connect(self.change_limits) # xmax self.xmaxLabel = QLabel(self.tr('xmax:')) self.xmaxSpinBox = CoordSpinBox() self.xmaxLabel.setBuddy(self.xmaxSpinBox) self.xmaxSpinBox.editingFinished.connect(self.change_limits) # ymin self.yminLabel = QLabel(self.tr('ymin:')) self.yminSpinBox = CoordSpinBox() self.yminLabel.setBuddy(self.yminSpinBox) self.yminSpinBox.editingFinished.connect(self.change_limits) # ymax self.ymaxLabel = QLabel(self.tr('ymax:')) self.ymaxSpinBox = CoordSpinBox() self.ymaxLabel.setBuddy(self.ymaxSpinBox) self.ymaxSpinBox.editingFinished.connect(self.change_limits) # Autoscale Radio Group self.autoscaleButtonGroup = QButtonGroup() # Autoscale Group Box self.autoscaleGroupBox = QGroupBox() # autoscale self.autoscaleRadioButton = QRadioButton(self.tr("autoscale")) self.autoscaleButtonGroup.addButton(self.autoscaleRadioButton) # autotrack self.autoscrollRadioButton = QRadioButton(self.tr("autoscroll")) self.autoscaleButtonGroup.addButton(self.autoscrollRadioButton) # no autoscale self.manualscaleRadioButton = QRadioButton(self.tr("manual")) self.autoscaleButtonGroup.addButton(self.manualscaleRadioButton) layout = QVBoxLayout() layout.addWidget(self.autoscaleRadioButton) layout.addWidget(self.autoscrollRadioButton) layout.addWidget(self.manualscaleRadioButton) self.autoscaleGroupBox.setLayout(layout) # Layout layout = QGridLayout() layout.addWidget(self.xminLabel, 1, 0) layout.addWidget(self.xminSpinBox, 1, 1) layout.addWidget(self.xmaxLabel, 2, 0) layout.addWidget(self.xmaxSpinBox, 2, 1) layout.addWidget(self.yminLabel, 3, 0) layout.addWidget(self.yminSpinBox, 3, 1) layout.addWidget(self.ymaxLabel, 4, 0) layout.addWidget(self.ymaxSpinBox, 4, 1) layout.addWidget(self.autoscaleGroupBox, 5, 0, 1, 2) layout.setRowStretch(6, 1) self.setLayout(layout) # settings self.settings = settings self.settings.add_handler(S_XMIN, self.xminSpinBox) self.settings.add_handler(S_XMAX, self.xmaxSpinBox) self.settings.add_handler(S_YMIN, self.yminSpinBox) self.settings.add_handler(S_YMAX, self.ymaxSpinBox) self.settings.add_handler(S_AUTOSCALE, self.autoscaleButtonGroup)
def __init__(self, parent): super().__init__(parent) lsp_advanced_group = QGroupBox( _('Python Language Server configuration')) advanced_label = QLabel( _("<b>Warning</b>: Only modify these values if " "you know what you're doing!")) advanced_label.setWordWrap(True) advanced_label.setAlignment(Qt.AlignJustify) # Advanced settings checkbox self.advanced_options_check = self.create_checkbox( _("Enable advanced settings"), 'advanced/enabled') # Advanced options self.advanced_module = self.create_lineedit( _("Module for the Python language server: "), 'advanced/module', alignment=Qt.Horizontal, word_wrap=False) self.advanced_host = self.create_lineedit( _("IP Address and port to bind the server to: "), 'advanced/host', alignment=Qt.Horizontal, word_wrap=False) self.advanced_port = self.create_spinbox(":", "", 'advanced/port', min_=1, max_=65535, step=1) self.external_server = self.create_checkbox( _("This is an external server"), 'advanced/external') self.use_stdio = self.create_checkbox( _("Use stdio pipes to communicate with server"), 'advanced/stdio') self.use_stdio.stateChanged.connect(self.disable_tcp) self.external_server.stateChanged.connect(self.disable_stdio) # Advanced layout advanced_g_layout = QGridLayout() advanced_g_layout.addWidget(self.advanced_module.label, 1, 0) advanced_g_layout.addWidget(self.advanced_module.textbox, 1, 1) advanced_g_layout.addWidget(self.advanced_host.label, 2, 0) advanced_host_port_g_layout = QGridLayout() advanced_host_port_g_layout.addWidget(self.advanced_host.textbox, 1, 0) advanced_host_port_g_layout.addWidget(self.advanced_port.plabel, 1, 1) advanced_host_port_g_layout.addWidget(self.advanced_port.spinbox, 1, 2) advanced_g_layout.addLayout(advanced_host_port_g_layout, 2, 1) # External server and stdio options layout advanced_server_layout = QVBoxLayout() advanced_server_layout.addWidget(self.external_server) advanced_server_layout.addWidget(self.use_stdio) advanced_options_layout = QVBoxLayout() advanced_options_layout.addLayout(advanced_g_layout) advanced_options_layout.addLayout(advanced_server_layout) # Set advanced options enabled/disabled advanced_options_widget = QWidget() advanced_options_widget.setLayout(advanced_options_layout) advanced_options_widget.setEnabled(self.get_option('advanced/enabled')) self.advanced_options_check.toggled.connect( advanced_options_widget.setEnabled) self.advanced_options_check.toggled.connect(self.show_advanced_warning) # Advanced options layout advanced_layout = QVBoxLayout() advanced_layout.addWidget(advanced_label) advanced_layout.addWidget(self.advanced_options_check) advanced_layout.addWidget(advanced_options_widget) lsp_advanced_group.setLayout(advanced_layout) layout = QVBoxLayout() layout.addWidget(lsp_advanced_group) self.setLayout(layout)
def setup_page(self): about_label = QLabel(_("The <b>global working directory</b> is " "the working directory for newly opened <i>consoles</i> " "(Python/IPython consoles and terminals), for the " "<i>file explorer</i>, for the <i>find in files</i> " "plugin and for new files created in the <i>editor</i>.")) about_label.setWordWrap(True) startup_group = QGroupBox(_("Startup")) startup_bg = QButtonGroup(startup_group) startup_label = QLabel(_("At startup, the global working " "directory is:")) startup_label.setWordWrap(True) lastdir_radio = self.create_radiobutton( _("the same as in last session"), 'startup/use_last_directory', True, _("At startup, Spyder will restore the " "global directory from last session"), button_group=startup_bg) thisdir_radio = self.create_radiobutton( _("the following directory:"), 'startup/use_fixed_directory', False, _("At startup, the global working " "directory will be the specified path"), button_group=startup_bg) thisdir_bd = self.create_browsedir("", 'startup/fixed_directory', getcwd()) thisdir_radio.toggled.connect(thisdir_bd.setEnabled) lastdir_radio.toggled.connect(thisdir_bd.setDisabled) thisdir_layout = QHBoxLayout() thisdir_layout.addWidget(thisdir_radio) thisdir_layout.addWidget(thisdir_bd) editor_o_group = QGroupBox(_("Open file")) editor_o_label = QLabel(_("Files are opened from:")) editor_o_label.setWordWrap(True) editor_o_bg = QButtonGroup(editor_o_group) editor_o_radio1 = self.create_radiobutton( _("the current file directory"), 'editor/open/browse_scriptdir', button_group=editor_o_bg) editor_o_radio2 = self.create_radiobutton( _("the global working directory"), 'editor/open/browse_workdir', button_group=editor_o_bg) editor_n_group = QGroupBox(_("New file")) editor_n_label = QLabel(_("Files are created in:")) editor_n_label.setWordWrap(True) editor_n_bg = QButtonGroup(editor_n_group) editor_n_radio1 = self.create_radiobutton( _("the current file directory"), 'editor/new/browse_scriptdir', button_group=editor_n_bg) editor_n_radio2 = self.create_radiobutton( _("the global working directory"), 'editor/new/browse_workdir', button_group=editor_n_bg) # Note: default values for the options above are set in plugin's # constructor (see below) other_group = QGroupBox(_("Change to file base directory")) newcb = self.create_checkbox open_box = newcb(_("When opening a file"), 'editor/open/auto_set_to_basedir') save_box = newcb(_("When saving a file"), 'editor/save/auto_set_to_basedir') startup_layout = QVBoxLayout() startup_layout.addWidget(startup_label) startup_layout.addWidget(lastdir_radio) startup_layout.addLayout(thisdir_layout) startup_group.setLayout(startup_layout) editor_o_layout = QVBoxLayout() editor_o_layout.addWidget(editor_o_label) editor_o_layout.addWidget(editor_o_radio1) editor_o_layout.addWidget(editor_o_radio2) editor_o_group.setLayout(editor_o_layout) editor_n_layout = QVBoxLayout() editor_n_layout.addWidget(editor_n_label) editor_n_layout.addWidget(editor_n_radio1) editor_n_layout.addWidget(editor_n_radio2) editor_n_group.setLayout(editor_n_layout) other_layout = QVBoxLayout() other_layout.addWidget(open_box) other_layout.addWidget(save_box) other_group.setLayout(other_layout) vlayout = QVBoxLayout() vlayout.addWidget(about_label) vlayout.addSpacing(10) vlayout.addWidget(startup_group) vlayout.addWidget(editor_o_group) vlayout.addWidget(editor_n_group) vlayout.addWidget(other_group) vlayout.addStretch(1) self.setLayout(vlayout)
def __init__(self, settings: QSettings, parent: Optional[QObject] = None): # noinspection PyArgumentList super(NappingDialog, self).__init__(parent) checked_selection_mode = NappingDialog.SelectionMode( int( settings.value( self.SELECTION_MODE_SETTING, defaultValue=self.DEFAULT_SELECTION_MODE.value))) self._file_selection_mode_button = QRadioButton( 'Single file pair', self) self._file_selection_mode_button.setChecked( checked_selection_mode == NappingDialog.SelectionMode.FILE) self._dir_selection_mode_button = QRadioButton( 'Directories (multiple file pairs)', self) self._dir_selection_mode_button.setChecked( checked_selection_mode == NappingDialog.SelectionMode.DIR) self._selection_mode_buttons_group = QButtonGroup(self) self._selection_mode_buttons_group.addButton( self._file_selection_mode_button, NappingDialog.SelectionMode.FILE) self._selection_mode_buttons_group.addButton( self._dir_selection_mode_button, NappingDialog.SelectionMode.DIR) # noinspection PyUnresolvedReferences self._selection_mode_buttons_group.buttonClicked.connect( lambda _: self.refresh()) matching_strategy_combo_box_current_text = str( settings.value(self.MATCHING_STRATEGY_SETTING, defaultValue=self.DEFAULT_MATCHING_STRATEGY.value)) self._matching_strategy_combo_box = QComboBox(self) self._matching_strategy_combo_box.addItems( [x.value for x in NappingDialog.MatchingStrategy]) self._matching_strategy_combo_box.setCurrentText( matching_strategy_combo_box_current_text) # noinspection PyUnresolvedReferences self._matching_strategy_combo_box.currentIndexChanged.connect( lambda _: self.refresh()) source_images_file_line_edit_text = str( settings.value(self.SOURCE_IMAGES_SETTING, defaultValue=self.DEFAULT_SOURCE_IMAGES)) self._source_images_file_line_edit = FileLineEdit(check_exists=True, parent=self) self._source_images_file_line_edit.file_dialog.setWindowTitle( 'Select source image(s)') self._source_images_file_line_edit.setText( source_images_file_line_edit_text) # noinspection PyUnresolvedReferences self._source_images_file_line_edit.textChanged.connect( lambda text: self.refresh(text)) source_regex_line_edit_text = str( settings.value(self.SOURCE_REGEX_SETTING, defaultValue=self.DEFAULT_SOURCE_REGEX)) self._source_regex_label = QLabel(' RegEx:') self._source_regex_line_edit = QLineEdit(self) self._source_regex_line_edit.setText(source_regex_line_edit_text) # noinspection PyUnresolvedReferences self._source_regex_line_edit.textChanged.connect( lambda _: self.refresh()) target_images_file_line_edit_text = str( settings.value(self.TARGET_IMAGES_SETTING, defaultValue=self.DEFAULT_TARGET_IMAGES)) self._target_images_file_line_edit = FileLineEdit(check_exists=True, parent=self) self._target_images_file_line_edit.file_dialog.setWindowTitle( 'Select target image(s)') self._target_images_file_line_edit.setText( target_images_file_line_edit_text) # noinspection PyUnresolvedReferences self._target_images_file_line_edit.textChanged.connect( lambda text: self.refresh(text)) target_regex_line_edit_text = str( settings.value(self.TARGET_REGEX_SETTING, defaultValue=self.DEFAULT_TARGET_REGEX)) self._target_regex_label = QLabel(' RegEx:') self._target_regex_line_edit = QLineEdit(self) self._target_regex_line_edit.setText(target_regex_line_edit_text) # noinspection PyUnresolvedReferences self._target_regex_line_edit.textChanged.connect( lambda _: self.refresh()) control_points_dest_file_line_edit_text = str( settings.value(self.CONTROL_POINTS_DEST_SETTING, defaultValue=self.DEFAULT_CONTROL_POINTS_DEST)) self._control_points_dest_file_line_edit = FileLineEdit(parent=self) self._control_points_dest_file_line_edit.file_dialog.setWindowTitle( 'Select control points destination') self._control_points_dest_file_line_edit.setText( control_points_dest_file_line_edit_text) # noinspection PyUnresolvedReferences self._control_points_dest_file_line_edit.textChanged.connect( lambda text: self.refresh(text)) joint_transform_dest_file_line_edit_text = str( settings.value(self.JOINT_TRANSFORM_DEST_SETTING, defaultValue=self.DEFAULT_JOINT_TRANSFORM_DEST)) self._joint_transform_dest_file_line_edit = FileLineEdit(parent=self) self._joint_transform_dest_file_line_edit.file_dialog.setWindowTitle( 'Select joint transform destination') self._joint_transform_dest_file_line_edit.setText( joint_transform_dest_file_line_edit_text) # noinspection PyUnresolvedReferences self._joint_transform_dest_file_line_edit.textChanged.connect( lambda text: self.refresh(text)) transform_type_combo_box_current_text = str( settings.value(self.TRANSFORM_TYPE_SETTING, defaultValue=self.DEFAULT_TRANSFORM_TYPE)) self._transform_type_combo_box = QComboBox(self) self._transform_type_combo_box.addItems( [x.value for x in NappingDialog.TransformType]) self._transform_type_combo_box.setCurrentText( transform_type_combo_box_current_text) # noinspection PyUnresolvedReferences self._transform_type_combo_box.currentIndexChanged.connect( lambda _: self.refresh()) source_coords_file_line_edit_text = str( settings.value(self.SOURCE_COORDS_SETTING, defaultValue=self.DEFAULT_SOURCE_COORDS)) self._source_coords_file_line_edit = FileLineEdit(check_exists=True, parent=self) self._source_coords_file_line_edit.file_dialog.setWindowTitle( 'Select source coordinates') self._source_coords_file_line_edit.setText( source_coords_file_line_edit_text) # noinspection PyUnresolvedReferences self._source_coords_file_line_edit.textChanged.connect( lambda text: self.refresh(text)) source_coords_regex_line_edit_text = str( settings.value(self.SOURCE_COORDS_REGEX_SETTING, defaultValue=self.DEFAULT_SOURCE_COORDS_REGEX)) self._source_coords_regex_label = QLabel(' RegEx:') self._source_coords_regex_line_edit = QLineEdit(self) self._source_coords_regex_line_edit.setText( source_coords_regex_line_edit_text) # noinspection PyUnresolvedReferences self._source_coords_regex_line_edit.textChanged.connect( lambda _: self.refresh()) transformed_coords_dest_file_line_edit_text = str( settings.value(self.TRANSFORMED_COORDS_DEST_SETTING, defaultValue=self.DEFAULT_TRANSFORMED_COORDS_DEST)) self._transformed_coords_dest_file_line_edit = FileLineEdit( parent=self) self._transformed_coords_dest_file_line_edit.file_dialog.setWindowTitle( 'Select transformed coordinates destination') self._transformed_coords_dest_file_line_edit.setText( transformed_coords_dest_file_line_edit_text) # noinspection PyUnresolvedReferences self._transformed_coords_dest_file_line_edit.textChanged.connect( lambda text: self.refresh(text)) pre_transform_file_line_edit_text = str( settings.value(self.PRE_TRANSFORM_SETTING, defaultValue=self.DEFAULT_PRE_TRANSFORM)) self._pre_transform_file_line_edit = FileLineEdit(parent=self) self._pre_transform_file_line_edit.file_dialog.setWindowTitle( 'Select pre-transform') self._pre_transform_file_line_edit.setText( pre_transform_file_line_edit_text) self._pre_transform_file_line_edit.file_dialog.setFileMode( QFileDialog.ExistingFile) self._pre_transform_file_line_edit.file_dialog.setNameFilter( 'Numpy files (*.npy)') # noinspection PyUnresolvedReferences self._pre_transform_file_line_edit.textChanged.connect( lambda text: self.refresh(text)) post_transform_file_line_edit_text = str( settings.value(self.POST_TRANSFORM_SETTING, defaultValue=self.DEFAULT_POST_TRANSFORM)) self._post_transform_file_line_edit = FileLineEdit(parent=self) self._post_transform_file_line_edit.file_dialog.setWindowTitle( 'Select post-transform') self._post_transform_file_line_edit.file_dialog.setFileMode( QFileDialog.ExistingFile) self._post_transform_file_line_edit.file_dialog.setNameFilter( 'Numpy files (*.npy)') self._post_transform_file_line_edit.setText( post_transform_file_line_edit_text) # noinspection PyUnresolvedReferences self._post_transform_file_line_edit.textChanged.connect( lambda text: self.refresh(text)) self._button_box = QDialogButtonBox( QDialogButtonBox.Ok | QDialogButtonBox.Cancel, self) # noinspection PyUnresolvedReferences self._button_box.rejected.connect(self.reject) # noinspection PyUnresolvedReferences @self._button_box.accepted.connect def on_button_box_accepted(): settings.setValue(self.SELECTION_MODE_SETTING, self.selection_mode.value) settings.setValue(self.SOURCE_IMAGES_SETTING, str(self.source_images_path)) settings.setValue(self.SOURCE_REGEX_SETTING, self.source_regex) settings.setValue(self.TARGET_IMAGES_SETTING, str(self.target_images_path)) settings.setValue(self.TARGET_REGEX_SETTING, self.target_regex) settings.setValue(self.CONTROL_POINTS_DEST_SETTING, str(self.control_points_dest_path)) settings.setValue(self.JOINT_TRANSFORM_DEST_SETTING, str(self.joint_transform_dest_path)) settings.setValue(self.TRANSFORM_TYPE_SETTING, self.transform_type.value) settings.setValue(self.MATCHING_STRATEGY_SETTING, self.matching_strategy.value) settings.setValue(self.SOURCE_COORDS_SETTING, str(self.source_coords_path or '')) settings.setValue(self.SOURCE_COORDS_REGEX_SETTING, self.source_coords_regex) settings.setValue(self.TRANSFORMED_COORDS_DEST_SETTING, str(self.transformed_coords_dest_path or '')) settings.setValue(self.PRE_TRANSFORM_SETTING, str(self.pre_transform_path or '')) settings.setValue(self.POST_TRANSFORM_SETTING, str(self.post_transform_path or '')) settings.sync() self.accept() required_group_box = QGroupBox(self) required_group_box_layout = QFormLayout() required_group_box_layout.setLabelAlignment(Qt.AlignLeft) required_group_box_layout.setRowWrapPolicy(QFormLayout.DontWrapRows) required_group_box_layout.setFieldGrowthPolicy( QFormLayout.AllNonFixedFieldsGrow) required_group_box_layout.addRow('Source image(s):', self._source_images_file_line_edit) required_group_box_layout.addRow(self._source_regex_label, self._source_regex_line_edit) required_group_box_layout.addRow('Target image(s):', self._target_images_file_line_edit) required_group_box_layout.addRow(self._target_regex_label, self._target_regex_line_edit) required_group_box_layout.addRow( 'Control points dest.:', self._control_points_dest_file_line_edit) required_group_box_layout.addRow( 'Joint transform dest.:', self._joint_transform_dest_file_line_edit) required_group_box_layout.addRow('Transform type:', self._transform_type_combo_box) required_group_box.setLayout(required_group_box_layout) optional_group_box = QGroupBox(self) optional_group_box_layout = QFormLayout() optional_group_box_layout.setLabelAlignment(Qt.AlignLeft) optional_group_box_layout.setRowWrapPolicy(QFormLayout.DontWrapRows) optional_group_box_layout.setFieldGrowthPolicy( QFormLayout.AllNonFixedFieldsGrow) optional_group_box_layout.addRow('Source coordinates:', self._source_coords_file_line_edit) optional_group_box_layout.addRow(self._source_coords_regex_label, self._source_coords_regex_line_edit) optional_group_box_layout.addRow( 'Transformed coord. dest.:', self._transformed_coords_dest_file_line_edit) optional_group_box_layout.addRow('Pre-transform:', self._pre_transform_file_line_edit) optional_group_box_layout.addRow('Post-transform:', self._post_transform_file_line_edit) optional_group_box.setLayout(optional_group_box_layout) layout = QVBoxLayout() mode_layout = QHBoxLayout() # noinspection PyArgumentList mode_layout.addWidget(self._file_selection_mode_button) # noinspection PyArgumentList mode_layout.addWidget(self._dir_selection_mode_button) # noinspection PyArgumentList mode_layout.addWidget(self._matching_strategy_combo_box) mode_layout.addStretch() layout.addLayout(mode_layout) # noinspection PyArgumentList layout.addWidget(required_group_box) # noinspection PyArgumentList layout.addWidget(optional_group_box) # noinspection PyArgumentList layout.addWidget(self._button_box) self.setLayout(layout) self.setWindowTitle('Control point matching') self.setMinimumWidth(600) self.refresh()
def _setupCoefficientsEditWidget(self, parent=None): wid = QGroupBox('Edit Coefficients', parent or self) le_coefdesc = PyDMLineEdit(self, self.dev_pref + ':DESC_COEFF') graph_coefs = WfmGraph(wid) graph_coefs.add_scatter_curve(ychannel=self.dev_pref + ':COEFF', lineStyle=Qt.SolidLine) graph_fftmag = WfmGraph(wid) graph_fftmag.setObjectName('graph') graph_fftmag.setStyleSheet('#graph{min-height: 12em;}') graph_fftmag.setLabel('left', text='Magnitude [dB]') graph_fftmag.setLabel('bottom', text='Fractional Freq.') graph_fftmag.add_scatter_curve(ychannel=self.dev_pref + ':FTF_MAG', xchannel=self.dev_pref + ':FTF_FREQ', color=QColor('blue'), lineWidth=2, lineStyle=Qt.SolidLine, symbolSize=4) graph_fftmag.add_scatter_curve(ychannel=self.dev_pref + ':FTF_GTUNE', xchannel=self.dev_pref + ':FTF_FTUNE', name='Tune', color=QColor('red')) graph_fftphs = WfmGraph(wid) graph_fftphs.setLabel('left', text='Phase [°]') graph_fftphs.setLabel('bottom', text='Fractional Freq.') graph_fftphs.add_scatter_curve(ychannel=self.dev_pref + ':FTF_PHASE', xchannel=self.dev_pref + ':FTF_FREQ', color=QColor('blue'), lineWidth=2, lineStyle=Qt.SolidLine, symbolSize=4) graph_fftphs.add_scatter_curve(ychannel=self.dev_pref + ':FTF_PTUNE', xchannel=self.dev_pref + ':FTF_FTUNE', name='Tune', color=QColor('red')) ld_fractune = QLabel('<h4> Marker:</h4>', wid, alignment=Qt.AlignLeft | Qt.AlignVCenter) ld_ftval = QLabel('Frequency [0-1]', wid, alignment=Qt.AlignRight | Qt.AlignVCenter) sb_ftval = PyDMSpinbox(wid, self.dev_pref + ':FTF_TUNE') sb_ftval.showStepExponent = False ld_ftgain = QLabel('Gain [dB]', wid, alignment=Qt.AlignRight | Qt.AlignVCenter) lb_ftgain = Label(wid, self.dev_pref + ':FTF_GTUNE') lb_ftgain.precisionFromPV = False lb_ftgain.precision = 2 ld_ftphs = QLabel('Phase [°]', wid, alignment=Qt.AlignRight | Qt.AlignVCenter) lb_ftphs = Label(wid, self.dev_pref + ':FTF_PTUNE') lb_ftphs.precisionFromPV = False lb_ftphs.precision = 2 lay_genft = QGridLayout() lay_genft.setVerticalSpacing(6) lay_genft.setHorizontalSpacing(9) lay_genft.addWidget(ld_fractune, 0, 0) lay_genft.addWidget(ld_ftval, 0, 2) lay_genft.addWidget(sb_ftval, 0, 3) lay_genft.addWidget(ld_ftgain, 0, 5) lay_genft.addWidget(lb_ftgain, 0, 6) lay_genft.addWidget(ld_ftphs, 0, 8) lay_genft.addWidget(lb_ftphs, 0, 9) lay_genft.setRowStretch(1, 2) lay_genft.setRowStretch(4, 2) lay_genft.setRowStretch(7, 2) lay_genft.setRowStretch(10, 2) coef_edit_wid = self._setupCoeffSettingsWidget() lay = QGridLayout(wid) lay.setVerticalSpacing(15) lay.addWidget(coef_edit_wid, 0, 0, 2, 1) lay.addWidget(le_coefdesc, 0, 1) lay.addWidget(graph_coefs, 1, 1) lay.addWidget(graph_fftmag, 2, 0) lay.addWidget(graph_fftphs, 2, 1) lay.addLayout(lay_genft, 3, 0, 1, 2) return wid
def _setupCoefficientsViewWidget(self): ld_coef0 = QLabel('<h4>Set 0</h4>', self) ld_coef0.setStyleSheet('max-width: 3em;') lb_coef0 = PyDMLabel(self, self.dev_pref + ':DESC_CSET0') lb_coef0.setStyleSheet('background-color: #DCDCDC;') led_coef0 = SiriusLedAlert(self, self.dev_pref + ':CVERIFY.C') led_coef0.setStyleSheet('min-width: 1.29em; max-width: 1.29em;') graph_coef0 = WfmGraph(self) graph_coef0.add_scatter_curve(ychannel=self.dev_pref + ':CSET0', lineStyle=Qt.SolidLine) ld_coef1 = QLabel('<h4>Set 1</h4>', self) ld_coef1.setStyleSheet('max-width: 3em;') lb_coef1 = PyDMLabel(self, self.dev_pref + ':DESC_CSET1') lb_coef1.setStyleSheet('background-color: #DCDCDC;') led_coef1 = SiriusLedAlert(self, self.dev_pref + ':CVERIFY.D') led_coef1.setStyleSheet('min-width: 1.29em; max-width: 1.29em;') graph_coef1 = WfmGraph(self) graph_coef1.add_scatter_curve(ychannel=self.dev_pref + ':CSET1', lineStyle=Qt.SolidLine) ld_coef2 = QLabel('<h4>Set 2</h4>', self) ld_coef2.setStyleSheet('max-width: 3em;') lb_coef2 = PyDMLabel(self, self.dev_pref + ':DESC_CSET2') lb_coef2.setStyleSheet('background-color: #DCDCDC;') led_coef2 = SiriusLedAlert(self, self.dev_pref + ':CVERIFY.G') led_coef2.setStyleSheet('min-width: 1.29em; max-width: 1.29em;') graph_coef2 = WfmGraph(self) graph_coef2.add_scatter_curve(ychannel=self.dev_pref + ':CSET2', lineStyle=Qt.SolidLine) ld_coef3 = QLabel('<h4>Set 3</h4>', self) ld_coef3.setStyleSheet('max-width: 3em;') lb_coef3 = PyDMLabel(self, self.dev_pref + ':DESC_CSET3') lb_coef3.setStyleSheet('background-color: #DCDCDC;') led_coef3 = SiriusLedAlert(self, self.dev_pref + ':CVERIFY.H') led_coef3.setStyleSheet('min-width: 1.29em; max-width: 1.29em;') graph_coef3 = WfmGraph(self) graph_coef3.add_scatter_curve(ychannel=self.dev_pref + ':CSET3', lineStyle=Qt.SolidLine) gbox_coefview = QGroupBox('Coefficient Sets View', self) gbox_coefview.setLayout(QGridLayout()) tab_coefview = QTabWidget(gbox_coefview) gbox_coefview.layout().addWidget(tab_coefview, 0, 0) norm_wid = QWidget(tab_coefview) tab_coefview.addTab(norm_wid, 'Normal') lay_norm = QGridLayout(norm_wid) lay_norm.addWidget(ld_coef0, 0, 0) lay_norm.addWidget(lb_coef0, 0, 1) lay_norm.addWidget(led_coef0, 0, 2) lay_norm.addWidget(graph_coef0, 1, 0, 1, 3) lay_norm.addWidget(ld_coef1, 2, 0) lay_norm.addWidget(lb_coef1, 2, 1) lay_norm.addWidget(led_coef1, 2, 2) lay_norm.addWidget(graph_coef1, 3, 0, 1, 3) alter_wid = QWidget(tab_coefview) tab_coefview.addTab(alter_wid, 'Alternate') lay_alter = QGridLayout(alter_wid) lay_alter.addWidget(ld_coef2, 0, 3) lay_alter.addWidget(lb_coef2, 0, 4) lay_alter.addWidget(led_coef2, 0, 5) lay_alter.addWidget(graph_coef2, 1, 3, 1, 3) lay_alter.addWidget(ld_coef3, 2, 3) lay_alter.addWidget(lb_coef3, 2, 4) lay_alter.addWidget(led_coef3, 2, 5) lay_alter.addWidget(graph_coef3, 3, 3, 1, 3) return gbox_coefview
def add_color_scheme_stack(self, scheme_name, custom=False): """Add a stack for a given scheme and connects the CONF values.""" color_scheme_groups = [(_('Text'), [ "normal", "comment", "string", "number", "keyword", "builtin", "definition", "instance", ]), (_('Highlight'), [ "currentcell", "currentline", "occurrence", "matched_p", "unmatched_p", "ctrlclick" ]), (_('Background'), ["background", "sideareas"])] parent = self.parent line_edit = parent.create_lineedit(_("Scheme name:"), '{0}/name'.format(scheme_name)) self.widgets[scheme_name] = {} # Widget setup line_edit.label.setAlignment(Qt.AlignRight | Qt.AlignVCenter) self.setWindowTitle(_('Color scheme editor')) # Layout name_layout = QHBoxLayout() name_layout.addWidget(line_edit.label) name_layout.addWidget(line_edit.textbox) self.scheme_name_textbox[scheme_name] = line_edit.textbox if not custom: line_edit.textbox.setDisabled(True) if not self.isVisible(): line_edit.setVisible(False) cs_layout = QVBoxLayout() cs_layout.addLayout(name_layout) h_layout = QHBoxLayout() v_layout = QVBoxLayout() for index, item in enumerate(color_scheme_groups): group_name, keys = item group_layout = QGridLayout() for row, key in enumerate(keys): option = "{0}/{1}".format(scheme_name, key) value = self.parent.get_option(option) name = syntaxhighlighters.COLOR_SCHEME_KEYS[key] if is_text_string(value): label, clayout = parent.create_coloredit( name, option, without_layout=True, ) label.setAlignment(Qt.AlignRight | Qt.AlignVCenter) group_layout.addWidget(label, row + 1, 0) group_layout.addLayout(clayout, row + 1, 1) # Needed to update temp scheme to obtain instant preview self.widgets[scheme_name][key] = [clayout] else: label, clayout, cb_bold, cb_italic = parent.create_scedit( name, option, without_layout=True, ) label.setAlignment(Qt.AlignRight | Qt.AlignVCenter) group_layout.addWidget(label, row + 1, 0) group_layout.addLayout(clayout, row + 1, 1) group_layout.addWidget(cb_bold, row + 1, 2) group_layout.addWidget(cb_italic, row + 1, 3) # Needed to update temp scheme to obtain instant preview self.widgets[scheme_name][key] = [ clayout, cb_bold, cb_italic ] group_box = QGroupBox(group_name) group_box.setLayout(group_layout) if index == 0: h_layout.addWidget(group_box) else: v_layout.addWidget(group_box) h_layout.addLayout(v_layout) cs_layout.addLayout(h_layout) stackitem = QWidget() stackitem.setLayout(cs_layout) self.stack.addWidget(stackitem) self.order.append(scheme_name)
def setup_page(self): settings_group = QGroupBox(_("Settings")) save_box = self.create_checkbox(_("Save file before analyzing it"), 'save_before', default=True) hist_group = QGroupBox(_("History")) hist_label1 = QLabel( _("The following option will be applied at next " "startup.")) hist_label1.setWordWrap(True) hist_spin = self.create_spinbox(_("History: "), _(" results"), 'max_entries', default=50, min_=10, max_=1000000, step=10) results_group = QGroupBox(_("Results")) results_label1 = QLabel(_("Results are stored here:")) results_label1.setWordWrap(True) # Warning: do not try to regroup the following QLabel contents with # widgets above -- this string was isolated here in a single QLabel # on purpose: to fix Issue 863 results_label2 = QLabel(PylintWidget.DATAPATH) results_label2.setTextInteractionFlags(Qt.TextSelectableByMouse) results_label2.setWordWrap(True) settings_layout = QVBoxLayout() settings_layout.addWidget(save_box) settings_group.setLayout(settings_layout) hist_layout = QVBoxLayout() hist_layout.addWidget(hist_label1) hist_layout.addWidget(hist_spin) hist_group.setLayout(hist_layout) results_layout = QVBoxLayout() results_layout.addWidget(results_label1) results_layout.addWidget(results_label2) results_group.setLayout(results_layout) vlayout = QVBoxLayout() vlayout.addWidget(settings_group) vlayout.addWidget(hist_group) vlayout.addWidget(results_group) vlayout.addStretch(1) self.setLayout(vlayout)
def __init__(self, parent=None): super(KernelConnectionDialog, self).__init__(parent) self.setWindowTitle(_('Connect to an existing kernel')) main_label = QLabel(_( "<p>Please select the JSON connection file (<i>e.g.</i> " "<tt>kernel-1234.json</tt>) of the existing kernel, and enter " "the SSH information if connecting to a remote machine. " "To learn more about starting external kernels and connecting " "to them, see <a href=\"https://docs.spyder-ide.org/" "ipythonconsole.html#connect-to-an-external-kernel\">" "our documentation</a>.</p>")) main_label.setWordWrap(True) main_label.setAlignment(Qt.AlignJustify) main_label.setOpenExternalLinks(True) # Connection file cf_label = QLabel(_('Connection file:')) self.cf = QLineEdit() self.cf.setPlaceholderText(_('Kernel connection file path')) self.cf.setMinimumWidth(350) cf_open_btn = QPushButton(_('Browse')) cf_open_btn.clicked.connect(self.select_connection_file) cf_layout = QHBoxLayout() cf_layout.addWidget(cf_label) cf_layout.addWidget(self.cf) cf_layout.addWidget(cf_open_btn) # Remote kernel groupbox self.rm_group = QGroupBox(_("This is a remote kernel (via SSH)")) # SSH connection hn_label = QLabel(_('Hostname:')) self.hn = QLineEdit() pn_label = QLabel(_('Port:')) self.pn = QLineEdit() self.pn.setMaximumWidth(75) self.pn.setText('22') un_label = QLabel(_('Username:'******'Password:'******'SSH keyfile:')) self.pw = QLineEdit() self.pw.setEchoMode(QLineEdit.Password) self.pw_radio.toggled.connect(self.pw.setEnabled) self.kf_radio.toggled.connect(self.pw.setDisabled) self.kf = QLineEdit() kf_open_btn = QPushButton(_('Browse')) kf_open_btn.clicked.connect(self.select_ssh_key) kf_layout = QHBoxLayout() kf_layout.addWidget(self.kf) kf_layout.addWidget(kf_open_btn) kfp_label = QLabel(_('Passphase:')) self.kfp = QLineEdit() self.kfp.setPlaceholderText(_('Optional')) self.kfp.setEchoMode(QLineEdit.Password) self.kf_radio.toggled.connect(self.kf.setEnabled) self.kf_radio.toggled.connect(self.kfp.setEnabled) self.kf_radio.toggled.connect(kf_open_btn.setEnabled) self.kf_radio.toggled.connect(kfp_label.setEnabled) self.pw_radio.toggled.connect(self.kf.setDisabled) self.pw_radio.toggled.connect(self.kfp.setDisabled) self.pw_radio.toggled.connect(kf_open_btn.setDisabled) self.pw_radio.toggled.connect(kfp_label.setDisabled) # SSH layout ssh_layout = QGridLayout() ssh_layout.addWidget(hn_label, 0, 0, 1, 2) ssh_layout.addWidget(self.hn, 0, 2) ssh_layout.addWidget(pn_label, 0, 3) ssh_layout.addWidget(self.pn, 0, 4) ssh_layout.addWidget(un_label, 1, 0, 1, 2) ssh_layout.addWidget(self.un, 1, 2, 1, 3) # SSH authentication layout auth_layout = QGridLayout() auth_layout.addWidget(self.pw_radio, 1, 0) auth_layout.addWidget(pw_label, 1, 1) auth_layout.addWidget(self.pw, 1, 2) auth_layout.addWidget(self.kf_radio, 2, 0) auth_layout.addWidget(kf_label, 2, 1) auth_layout.addLayout(kf_layout, 2, 2) auth_layout.addWidget(kfp_label, 3, 1) auth_layout.addWidget(self.kfp, 3, 2) auth_group.setLayout(auth_layout) # Remote kernel layout rm_layout = QVBoxLayout() rm_layout.addLayout(ssh_layout) rm_layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 8))) rm_layout.addWidget(auth_group) self.rm_group.setLayout(rm_layout) self.rm_group.setCheckable(True) self.rm_group.setChecked(False) self.rm_group.toggled.connect(self.pw_radio.setChecked) # Ok and Cancel buttons self.accept_btns = QDialogButtonBox( QDialogButtonBox.Ok | QDialogButtonBox.Cancel, Qt.Horizontal, self) self.accept_btns.accepted.connect(self.accept) self.accept_btns.rejected.connect(self.reject) # Dialog layout layout = QVBoxLayout(self) layout.addWidget(main_label) layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 8))) layout.addLayout(cf_layout) layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 12))) layout.addWidget(self.rm_group) layout.addWidget(self.accept_btns)
def setup_page(self): newcb = self.create_checkbox # --- Introspection --- # Basic features group basic_features_group = QGroupBox(_("Basic features")) completion_box = newcb(_("Enable code completion"), 'code_completion') enable_hover_hints_box = newcb( _("Enable hover hints"), 'enable_hover_hints', tip=_("If enabled, hovering the mouse pointer over an object\n" "name will display that object's signature and/or\n" "docstring (if present).")) goto_definition_box = newcb( _("Enable Go to definition"), 'jedi_definition', tip=_("If enabled, left-clicking on an object name while \n" "pressing the {} key will go to that object's definition\n" "(if resolved).".format(self.CTRL))) follow_imports_box = newcb( _("Follow imports when going to a " "definition"), 'jedi_definition/follow_imports') show_signature_box = newcb(_("Show calltips"), 'jedi_signature_help') basic_features_layout = QVBoxLayout() basic_features_layout.addWidget(completion_box) basic_features_layout.addWidget(enable_hover_hints_box) basic_features_layout.addWidget(goto_definition_box) basic_features_layout.addWidget(follow_imports_box) basic_features_layout.addWidget(show_signature_box) basic_features_group.setLayout(basic_features_layout) # Advanced group advanced_group = QGroupBox(_("Advanced")) modules_textedit = self.create_textedit( _("Preload the following modules to make completion faster " "and more accurate:"), 'preload_modules') if is_dark_interface(): modules_textedit.textbox.setStyleSheet( "border: 1px solid #32414B;") advanced_layout = QVBoxLayout() advanced_layout.addWidget(modules_textedit) advanced_group.setLayout(advanced_layout) # --- Linting --- # Linting options linting_label = QLabel( _("Spyder can optionally highlight syntax " "errors and possible problems with your " "code in the editor.")) linting_label.setOpenExternalLinks(True) linting_label.setWordWrap(True) linting_check = self.create_checkbox(_("Enable basic linting"), 'pyflakes') linting_complexity_box = self.create_checkbox( _("Enable complexity linting with " "the Mccabe package"), 'mccabe') # Linting layout linting_layout = QVBoxLayout() linting_layout.addWidget(linting_label) linting_layout.addWidget(linting_check) linting_layout.addWidget(linting_complexity_box) linting_widget = QWidget() linting_widget.setLayout(linting_layout) # --- Code style tab --- # Code style label pep_url = ( '<a href="https://www.python.org/dev/peps/pep-0008">PEP 8</a>') code_style_codes_url = _( "<a href='http://pycodestyle.pycqa.org/en/stable" "/intro.html#error-codes'>pycodestyle error codes</a>") code_style_label = QLabel( _("Spyder can use pycodestyle to analyze your code for " "conformance to the {} convention. You can also " "manually show or hide specific warnings by their " "{}.").format(pep_url, code_style_codes_url)) code_style_label.setOpenExternalLinks(True) code_style_label.setWordWrap(True) # Code style checkbox code_style_check = self.create_checkbox(_("Enable code style linting"), 'pycodestyle') # Code style options self.code_style_filenames_match = self.create_lineedit( _("Only check filenames matching these patterns:"), 'pycodestyle/filename', alignment=Qt.Horizontal, word_wrap=False, placeholder=_("Check Python files: *.py")) self.code_style_exclude = self.create_lineedit( _("Exclude files or directories matching these patterns:"), 'pycodestyle/exclude', alignment=Qt.Horizontal, word_wrap=False, placeholder=_("Exclude all test files: (?!test_).*\\.py")) code_style_select = self.create_lineedit( _("Show the following errors or warnings:").format( code_style_codes_url), 'pycodestyle/select', alignment=Qt.Horizontal, word_wrap=False, placeholder=_("Example codes: E113, W391")) code_style_ignore = self.create_lineedit( _("Ignore the following errors or warnings:"), 'pycodestyle/ignore', alignment=Qt.Horizontal, word_wrap=False, placeholder=_("Example codes: E201, E303")) code_style_max_line_length = self.create_spinbox( _("Maximum allowed line length:"), None, 'pycodestyle/max_line_length', min_=10, max_=500, step=1, tip=_("Default is 79")) # Code style layout code_style_g_layout = QGridLayout() code_style_g_layout.addWidget(self.code_style_filenames_match.label, 1, 0) code_style_g_layout.addWidget(self.code_style_filenames_match.textbox, 1, 1) code_style_g_layout.addWidget(self.code_style_exclude.label, 2, 0) code_style_g_layout.addWidget(self.code_style_exclude.textbox, 2, 1) code_style_g_layout.addWidget(code_style_select.label, 3, 0) code_style_g_layout.addWidget(code_style_select.textbox, 3, 1) code_style_g_layout.addWidget(code_style_ignore.label, 4, 0) code_style_g_layout.addWidget(code_style_ignore.textbox, 4, 1) code_style_g_layout.addWidget(code_style_max_line_length.plabel, 5, 0) code_style_g_layout.addWidget(code_style_max_line_length.spinbox, 5, 1) # Set Code style options enabled/disabled code_style_g_widget = QWidget() code_style_g_widget.setLayout(code_style_g_layout) code_style_g_widget.setEnabled(self.get_option('pycodestyle')) code_style_check.toggled.connect(code_style_g_widget.setEnabled) # Code style layout code_style_layout = QVBoxLayout() code_style_layout.addWidget(code_style_label) code_style_layout.addWidget(code_style_check) code_style_layout.addWidget(code_style_g_widget) code_style_widget = QWidget() code_style_widget.setLayout(code_style_layout) # --- Docstring tab --- # Docstring style label numpy_url = ("<a href='https://numpydoc.readthedocs.io/en/" "latest/format.html'>Numpy</a>") pep257_url = ( "<a href='https://www.python.org/dev/peps/pep-0257/'>PEP 257</a>") docstring_style_codes = _( "<a href='http://www.pydocstyle.org/en/stable" "/error_codes.html'>page</a>") docstring_style_label = QLabel( _("Here you can decide if you want to perform style analysis on " "your docstrings according to the {} or {} conventions. You can " "also decide if you want to show or ignore specific errors, " "according to the codes found on this {}.").format( numpy_url, pep257_url, docstring_style_codes)) docstring_style_label.setOpenExternalLinks(True) docstring_style_label.setWordWrap(True) # Docstring style checkbox docstring_style_check = self.create_checkbox( _("Enable docstring style linting"), 'pydocstyle') # Docstring style options docstring_style_convention = self.create_combobox( _("Choose the convention used to lint docstrings: "), (("Numpy", 'numpy'), ("PEP 257", 'pep257'), ("Custom", 'custom')), 'pydocstyle/convention') self.docstring_style_select = self.create_lineedit( _("Show the following errors:"), 'pydocstyle/select', alignment=Qt.Horizontal, word_wrap=False, placeholder=_("Example codes: D413, D414")) self.docstring_style_ignore = self.create_lineedit( _("Ignore the following errors:"), 'pydocstyle/ignore', alignment=Qt.Horizontal, word_wrap=False, placeholder=_("Example codes: D107, D402")) self.docstring_style_match = self.create_lineedit( _("Only check filenames matching these patterns:"), 'pydocstyle/match', alignment=Qt.Horizontal, word_wrap=False, placeholder=_("Skip test files: (?!test_).*\\.py")) self.docstring_style_match_dir = self.create_lineedit( _("Only check in directories matching these patterns:"), 'pydocstyle/match_dir', alignment=Qt.Horizontal, word_wrap=False, placeholder=_("Skip dot directories: [^\\.].*")) # Custom option handling docstring_style_convention.combobox.currentTextChanged.connect( self.setup_docstring_style_convention) current_convention = docstring_style_convention.combobox.currentText() self.setup_docstring_style_convention(current_convention) # Docstring style layout docstring_style_g_layout = QGridLayout() docstring_style_g_layout.addWidget(docstring_style_convention.label, 1, 0) docstring_style_g_layout.addWidget(docstring_style_convention.combobox, 1, 1) docstring_style_g_layout.addWidget(self.docstring_style_select.label, 2, 0) docstring_style_g_layout.addWidget(self.docstring_style_select.textbox, 2, 1) docstring_style_g_layout.addWidget(self.docstring_style_ignore.label, 3, 0) docstring_style_g_layout.addWidget(self.docstring_style_ignore.textbox, 3, 1) docstring_style_g_layout.addWidget(self.docstring_style_match.label, 4, 0) docstring_style_g_layout.addWidget(self.docstring_style_match.textbox, 4, 1) docstring_style_g_layout.addWidget( self.docstring_style_match_dir.label, 5, 0) docstring_style_g_layout.addWidget( self.docstring_style_match_dir.textbox, 5, 1) # Set Docstring style options enabled/disabled docstring_style_g_widget = QWidget() docstring_style_g_widget.setLayout(docstring_style_g_layout) docstring_style_g_widget.setEnabled(self.get_option('pydocstyle')) docstring_style_check.toggled.connect( docstring_style_g_widget.setEnabled) # Docstring style layout docstring_style_layout = QVBoxLayout() docstring_style_layout.addWidget(docstring_style_label) docstring_style_layout.addWidget(docstring_style_check) docstring_style_layout.addWidget(docstring_style_g_widget) docstring_style_widget = QWidget() docstring_style_widget.setLayout(docstring_style_layout) # --- Advanced tab --- # Advanced label advanced_label = QLabel( _("Please don't modify these values unless " "you know what you're doing!")) advanced_label.setWordWrap(True) advanced_label.setAlignment(Qt.AlignJustify) # Advanced options advanced_command_launch = self.create_lineedit( _("Command to launch the Python language server: "), 'advanced/command_launch', alignment=Qt.Horizontal, word_wrap=False) advanced_host = self.create_lineedit( _("IP Address and port to bind the server to: "), 'advanced/host', alignment=Qt.Horizontal, word_wrap=False) advanced_port = self.create_spinbox(":", "", 'advanced/port', min_=1, max_=65535, step=1) external_server = self.create_checkbox(_("This is an external server"), 'advanced/external') # Advanced layout advanced_g_layout = QGridLayout() advanced_g_layout.addWidget(advanced_command_launch.label, 1, 0) advanced_g_layout.addWidget(advanced_command_launch.textbox, 1, 1) advanced_g_layout.addWidget(advanced_host.label, 2, 0) advanced_host_port_g_layout = QGridLayout() advanced_host_port_g_layout.addWidget(advanced_host.textbox, 1, 0) advanced_host_port_g_layout.addWidget(advanced_port.plabel, 1, 1) advanced_host_port_g_layout.addWidget(advanced_port.spinbox, 1, 2) advanced_g_layout.addLayout(advanced_host_port_g_layout, 2, 1) advanced_widget = QWidget() advanced_layout = QVBoxLayout() advanced_layout.addWidget(advanced_label) advanced_layout.addLayout(advanced_g_layout) advanced_layout.addWidget(external_server) advanced_widget.setLayout(advanced_layout) # --- Other servers tab --- # Section label servers_label = QLabel( _("Spyder uses the <a href=\"{lsp_url}\">Language Server " "Protocol</a> to provide code completion and linting " "for its Editor. Here, you can setup and configure LSP servers " "for languages other than Python, so Spyder can provide such " "features for those languages as well.").format(lsp_url=LSP_URL)) servers_label.setOpenExternalLinks(True) servers_label.setWordWrap(True) servers_label.setAlignment(Qt.AlignJustify) # Servers table table_group = QGroupBox(_('Available servers:')) self.table = LSPServerTable(self, text_color=ima.MAIN_FG_COLOR) table_layout = QVBoxLayout() table_layout.addWidget(self.table) table_group.setLayout(table_layout) # Buttons self.reset_btn = QPushButton(_("Reset to default values")) self.new_btn = QPushButton(_("Set up a new server")) self.delete_btn = QPushButton(_("Delete currently selected server")) self.delete_btn.setEnabled(False) # Slots connected to buttons self.new_btn.clicked.connect(self.create_new_server) self.reset_btn.clicked.connect(self.reset_to_default) self.delete_btn.clicked.connect(self.delete_server) # Buttons layout btns = [self.new_btn, self.delete_btn, self.reset_btn] buttons_layout = QGridLayout() for i, btn in enumerate(btns): buttons_layout.addWidget(btn, i, 1) buttons_layout.setColumnStretch(0, 1) buttons_layout.setColumnStretch(1, 2) buttons_layout.setColumnStretch(2, 1) # Combined layout servers_widget = QWidget() servers_layout = QVBoxLayout() servers_layout.addSpacing(-10) servers_layout.addWidget(servers_label) servers_layout.addWidget(table_group) servers_layout.addSpacing(10) servers_layout.addLayout(buttons_layout) servers_widget.setLayout(servers_layout) # --- Tabs organization --- tabs = QTabWidget() tabs.addTab(self.create_tab(basic_features_group, advanced_group), _('Introspection')) tabs.addTab(self.create_tab(linting_widget), _('Linting')) tabs.addTab(self.create_tab(code_style_widget), _('Code style')) tabs.addTab(self.create_tab(docstring_style_widget), _('Docstring style')) tabs.addTab(self.create_tab(advanced_widget), _('Advanced')) tabs.addTab(self.create_tab(servers_widget), _('Other languages')) vlayout = QVBoxLayout() vlayout.addWidget(tabs) self.setLayout(vlayout)