def __init__(self, *args, **kwargs): QDialog.__init__(self, *args, **kwargs) self.setupUi(self) self.ckpt_path = None self.extra_ep = None self.new_cmt = None self.trnPath = None self.valPath = None self.tstPath = None self.wherePath = None self.loggerDir = os.path.join( os.path.dirname(os.path.dirname(__file__)), 'log', 'latest_resume.json') if os.path.exists(self.loggerDir): with open(self.loggerDir, 'r') as f: tmp = json.load(f) try: # set attribute self.ckpt_path = tmp['ckpt_path'] self.extra_ep = tmp['extra_ep'] self.new_cmt = tmp['new_cmt'] self.trnPath = tmp['trn repo. path'] self.valPath = tmp['val repo. path'] self.tstPath = tmp['tst repo. path'] self.wherePath = tmp['mdl. saved path'] self.init_lr = tmp["lr_init"] self.lr_dec_ratio = tmp["lr_decay"] self.lr_dec_period = tmp["lr_period"] self.gap = tmp["gap"] self.cond = tmp["condition"] self.svstep = tmp["sv step"] self.tbstep = tmp['tb step'] # set lines self.ckptLine.setText(self.ckpt_path) self.epochLine.setText(self.extra_ep) self.commentLine.setText(self.new_cmt) self.trnPathLine.setText(self.trnPath) self.valPathLine.setText(self.valPath) self.tstPathLine.setText(self.tstPath) self.whereToSave.setText(self.wherePath) self.new_init_lr.setText(self.init_lr) self.new_lr_dec_ratio.setText(self.lr_dec_ratio) self.new_lr_dec_period.setText(self.lr_dec_period) self.sampling_gap.setText(self.gap) self.stop_cond.setText(self.cond) self.svstepLine.setText(self.svstep) self.tbstepLine.setText(self.tbstep) except KeyError as e: print(e) pass self.ckptButton.clicked.connect(self.selectckpt) self.trnPathButton.clicked.connect(self.selectTrnPath) self.valPathButton.clicked.connect(self.selectValPath) self.tstPathButton.clicked.connect(self.selectTstPath) self.whereToSaveButton.clicked.connect(self.selectWherePath) self.buttonBox.accepted.connect(self.accept) self.buttonBox.rejected.connect(self.reject)
def __init__(self, parent, data): assert type(data) == BinaryView self.bv = data QDialog.__init__(self, parent) debug_state = binjaplug.get_state(self.bv) self.setWindowTitle("Debug Adapter Settings") self.setMinimumSize(UIContext.getScaledWindowSize(400, 130)) self.setAttribute(Qt.WA_DeleteOnClose) layout = QVBoxLayout() layout.setSpacing(0) titleLabel = QLabel("Adapter Settings") titleLayout = QHBoxLayout() titleLayout.setContentsMargins(0, 0, 0, 0) titleLayout.addWidget(titleLabel) self.adapterEntry = QPushButton(self) self.adapterMenu = QMenu(self) for adapter in DebugAdapter.ADAPTER_TYPE: if not DebugAdapter.ADAPTER_TYPE.can_use(adapter): continue def select_adapter(adapter): return lambda: self.selectAdapter(adapter) self.adapterMenu.addAction(adapter.name, select_adapter(adapter)) if adapter == debug_state.adapter_type: self.adapterEntry.setText(adapter.name) self.adapterEntry.setMenu(self.adapterMenu) self.argumentsEntry = QLineEdit(self) self.addressEntry = QLineEdit(self) self.portEntry = QLineEdit(self) self.formLayout = QFormLayout() self.formLayout.addRow("Adapter Type", self.adapterEntry) self.formLayout.addRow("Command Line Arguments", self.argumentsEntry) self.formLayout.addRow("Address", self.addressEntry) self.formLayout.addRow("Port", self.portEntry) buttonLayout = QHBoxLayout() buttonLayout.setContentsMargins(0, 0, 0, 0) self.cancelButton = QPushButton("Cancel") self.cancelButton.clicked.connect(lambda: self.reject()) self.acceptButton = QPushButton("Accept") self.acceptButton.clicked.connect(lambda: self.accept()) self.acceptButton.setDefault(True) buttonLayout.addStretch(1) buttonLayout.addWidget(self.cancelButton) buttonLayout.addWidget(self.acceptButton) layout.addLayout(titleLayout) layout.addSpacing(10) layout.addLayout(self.formLayout) layout.addStretch(1) layout.addSpacing(10) layout.addLayout(buttonLayout) self.setLayout(layout) self.addressEntry.setText(debug_state.remote_host) self.portEntry.setText(str(debug_state.remote_port)) self.addressEntry.textEdited.connect(lambda: self.apply()) self.portEntry.textEdited.connect(lambda: self.apply()) self.argumentsEntry.setText(' '.join( shlex.quote(arg) for arg in debug_state.command_line_args)) self.argumentsEntry.textEdited.connect(lambda: self.updateArguments()) self.accepted.connect(lambda: self.apply())
def __init__(self, machine, matlib, is_stator=False): """Initialize the widget according to machine Parameters ---------- self : SMagnet A SMagnet widget machine : Machine current machine to edit matlib : MatLib Material Library is_stator : bool To adapt the GUI to set either the stator or the rotor """ # Build the interface according to the .ui file QDialog.__init__(self) self.setupUi(self) # Saving arguments self.machine = machine self.matlib = matlib self.is_stator = is_stator # Get the correct available widgets according to the machine if self.machine.rotor.is_internal: self.wid_list = [PMagnet10, PMagnet11, PMagnet12, PMagnet13, PMagnet14] elif self.machine.type_machine == 6: # For SPMSM only polar magnet for external rotor self.wid_list = [PMagnet11] else: # Magnet 14 not available for SIPMSM self.wid_list = [PMagnet10, PMagnet11, PMagnet12, PMagnet13] self.mag_type_index = [wid.mag_type for wid in self.wid_list] self.slot_type_index = [wid.slot_type for wid in self.wid_list] self.mag_name_index = [wid.mag_name for wid in self.wid_list] # Help URL self.b_help.url = "https://eomys.com/produits/manatee/howtos/article/" self.b_help.url += "how-to-set-up-inset-magnet" # Fill the combobox with the available magnet self.c_type.clear() for mag in self.mag_name_index: self.c_type.addItem(mag) # Avoid erase all the parameters when navigating though the magnets self.previous_mag = dict() for mag_type in self.mag_type_index: self.previous_mag[mag_type] = None # Set the GUI with the current values if provided if ( type(self.machine.rotor.slot) is Slot or type(self.machine.rotor.slot.magnet[0]) is Magnet ): # Magnet or slot not set # Type 11 is default self.set_type(1) self.c_type.setCurrentIndex(1) else: # The Magnet is set => load the parameter # Set the type index = self.mag_type_index.index(type(self.machine.rotor.slot.magnet[0])) self.set_type_gui(index) self.c_type.setCurrentIndex(index) # Only one magnet in the GUI (for now) self.machine.rotor.slot.W3 = 0 # Set magnetization if self.machine.rotor.slot.magnet[0].type_magnetization is None: self.machine.rotor.slot.magnet[0].type_magnetization = 0 self.c_type_magnetization.setCurrentIndex( self.machine.rotor.slot.magnet[0].type_magnetization ) self.set_slot_pitch() # Set material self.w_mat.setText(self.tr("mat_mag:")) self.w_mat.def_mat = "Magnet1" self.w_mat.update(self.machine.rotor.slot.magnet[0], "mat_type", self.matlib) # Connect signals self.c_type.currentIndexChanged.connect(self.set_type) self.c_type_magnetization.currentIndexChanged.connect( self.s_set_type_magnetization ) self.b_plot.clicked.connect(self.s_plot) self.w_mat.saveNeeded.connect(self.emit_save)
def __init__(self, parent=None): QDialog.__init__(self, parent) self._ui = Ui_LogDetails() self._ui.setupUi(self)
def __init__(self, data, title="", comment="", icon=None, parent=None, apply=None, ok=None, cancel=None, result=None, outfile=None, type=None, scrollbar=None, background_color=None, widget_color=None): QDialog.__init__(self, parent) #self.setWindowModality(Qt.ApplicationModal) self.setWindowFlags((self.windowFlags() & ~Qt.WindowContextHelpButtonHint) ) # djb added # Destroying the C++ object right after closing the dialog box, # otherwise it may be garbage-collected in another QThread # (e.g. the editor's analysis thread in Spyder), thus leading to # a segmentation fault on UNIX or an application crash on Windows self.setAttribute(Qt.WA_DeleteOnClose) self.type = type self.title = title self.ok = ok self.cancel = cancel self.apply_ = None self.apply_callback = None if callable(apply): self.apply_callback = apply elif isinstance(apply, (list, tuple)): self.apply_, self.apply_callback = apply elif apply is not None: raise AssertionError("`apply` argument must be either a function or tuple ('Apply label', apply_callback)") self.outfile = outfile self.result = result if self.result in ['OrderedDict', 'JSON']: global OrderedDict from collections import OrderedDict if self.result == 'JSON': global json import json elif self.result == 'XML': global ET import xml.etree.ElementTree as ET self.widget_color = widget_color if background_color: style = "FormDialog {background-color:" + background_color + ";}" self.setStyleSheet(style) # Form if isinstance(data[0][0], (list, tuple)): self.formwidget = FormTabWidget(data, comment=comment,parent=self) elif len(data[0])==3: self.formwidget = FormComboWidget(data, comment=comment,parent=self) else: self.formwidget = FormWidget(data, comment=comment,parent=self) layout = QVBoxLayout() if scrollbar == True: scroll = QScrollArea(parent=self) scroll.setWidgetResizable(True) scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) scroll.setWidget(self.formwidget) layout.addWidget(scroll) else: layout.addWidget(self.formwidget) self.float_fields = [] self.required_fields = [] self.formwidget.setup() # Button box self.bbox = bbox = QDialogButtonBox() if self.ok == True: bbox.addButton(QDialogButtonBox.Ok) elif self.ok: ok_btn = QPushButton(self.ok) bbox.addButton(ok_btn, QDialogButtonBox.AcceptRole) if self.cancel == True: bbox.addButton(QDialogButtonBox.Cancel) elif self.cancel: cancel_btn = QPushButton(self.cancel) bbox.addButton(cancel_btn, QDialogButtonBox.RejectRole) if self.apply_callback is not None: if self.apply_: apply_btn = QPushButton(self.apply_) bbox.addButton(apply_btn, QDialogButtonBox.ApplyRole) else: apply_btn = bbox.addButton(QDialogButtonBox.Apply) if SIGNAL is None: apply_btn.clicked.connect(self.apply) else: self.connect(apply_btn, SIGNAL("clicked()"), self.apply) if SIGNAL is None: if self.ok: bbox.accepted.connect(self.accept) if self.cancel: bbox.rejected.connect(self.reject) else: if self.ok: self.connect(bbox, SIGNAL("accepted()"), SLOT("accept()")) if self.cancel: self.connect(bbox, SIGNAL("rejected()"), SLOT("reject()")) layout.addWidget(bbox) self.required_valid() self.setLayout(layout) self.setWindowTitle(self.title) if not isinstance(icon, QIcon): icon = QPixmap(icon) if icon.isNull(): icon = QWidget().style().standardIcon(QStyle.SP_MessageBoxQuestion) self.setWindowIcon(icon)
def __init__(self, settings) -> None: QDialog.__init__(self) ABookLogin.__init__(self) self.initLayout() if settings['auto_login']: self.login_widget.loginButton.click()
def __init__(self, name, skeleton, share_widget, parent=None, enable_line_edit=False, skeleton_model=None): self.initialized = False QDialog.__init__(self, parent) Ui_Dialog.setupUi(self, self) self.view = SceneViewerWidget(parent, share_widget, size=(400, 400)) self.view.setObjectName("left") self.view.setMinimumSize(400, 400) self.view.initializeGL() self.nameLineEdit.setText(name) self.nameLineEdit.setEnabled(enable_line_edit) self.name = name self.view.enable_mouse_interaction = True self.view.mouse_click.connect(self.on_mouse_click) self.viewerLayout.addWidget(self.view) self.radius = 1.0 self.fps = 60 self.dt = 1 / 60 self.timer = QTimer() self.timer.timeout.connect(self.draw) self.timer.start(0) self.timer.setInterval(1000.0 / self.fps) self.skeleton = skeleton self.view.makeCurrent() self.scene = EditorScene(True) self.scene.enable_scene_edit_widget = True if skeleton_model is not None: self.skeleton_model = skeleton_model elif skeleton.skeleton_model is not None: self.skeleton_model = skeleton.skeleton_model else: self.skeleton_model = dict() print("create new skeleton model") if "cos_map" not in self.skeleton_model: self.skeleton_model["cos_map"] = dict() if "joints" not in self.skeleton_model: self.skeleton_model["joints"] = dict() if "joint_constraints" not in self.skeleton_model: self.skeleton_model["joint_constraints"] = dict() motion_vector = MotionVector() self.reference_frame = skeleton.reference_frame print(self.reference_frame[:3]) motion_vector.frames = [skeleton.reference_frame] motion_vector.n_frames = 1 o = self.scene.object_builder.create_object("animation_controller", "skeleton", skeleton, motion_vector, skeleton.frame_time) self.controller = o._components["animation_controller"] self.skeleton = self.controller.get_skeleton() self.skeleton_vis = o._components["skeleton_vis"] self.init_joints(self.controller) self.fill_joint_map() self.selectButton.clicked.connect(self.slot_accept) self.cancelButton.clicked.connect(self.slot_reject) self.applyTwistRotationButton.clicked.connect(self.slot_set_twist) self.applySwingRotationButton.clicked.connect(self.slot_set_swing) self.setOrthogonalTwistButton.clicked.connect( self.slot_set_orthogonal_twist) self.setOrthogonalSwingButton.clicked.connect( self.slot_set_orthogonal_swing) self.rotateTwistButton.clicked.connect(self.slot_rotate_twist) self.rotateSwingButton.clicked.connect(self.slot_rotate_swing) self.flipTwistButton.clicked.connect(self.slot_flip_twist) self.flipSwingButton.clicked.connect(self.slot_flip_swing) self.flipZAxisButton.clicked.connect(self.slot_flip_z_axis) self.alignToUpAxisButton.clicked.connect(self.slot_align_to_up_axis) self.alignToForwardAxisButton.clicked.connect( self.slot_align_to_forward_axis) self.guessSelectedButton.clicked.connect( self.slot_guess_selected_cos_map) self.resetSelectedCosButton.clicked.connect( self.slot_reset_selected_cos_map) self.guessAllCosButton.clicked.connect(self.slot_guess_cos_map) self.resetAllCosButton.clicked.connect(self.slot_reset_cos_map) self.loadDefaultPoseButton.clicked.connect(self.slot_load_default_pose) self.applyScaleButton.clicked.connect(self.slot_apply_scale) self.jointMapComboBox.currentIndexChanged.connect( self.slot_update_joint_map) self.aligningRootComboBox.currentIndexChanged.connect( self.slot_update_aligning_root_joint) self.mirrorLeftButton.clicked.connect(self.slot_mirror_left_to_right) self.mirrorRightButton.clicked.connect(self.slot_mirror_right_to_left) self.is_updating_joint_info = False self.success = False self.initialized = False self.skeleton_data = None self.precision = 3 self.aligning_root_node = self.skeleton.aligning_root_node self.fill_root_combobox() self.init_aligning_root_node()
def __init__(self, parent=None): QDialog.__init__(self, parent) self._ui = Ui_LoadWindow() self._ui.setupUi(self) self._makeConnections()
def __init__(self, backup, window, edit=False): QDialog.__init__(self) Ui_BackupSettingsDialog.__init__(self) self.setupUi(self) self.backup = backup self.window = window self.edit = edit self.paths = set() self.exclude_rules = set() self.map = { "mon": self.mon_checkbox, "tue": self.tue_checkbox, "wed": self.wed_checkbox, "thu": self.thu_checkbox, "fri": self.fri_checkbox, "sat": self.sat_checkbox, "sun": self.sun_checkbox } self.days_checked = set() prefix = self.backup.cloud_prefix if self.backup.cloud_prefix is not None else self.backup.local_directory window_title = f"{self.backup.location} ({prefix})" # Hiding unsupported add file button for now self.add_file_button.hide() self.add_button.pressed.connect(self.add_folder) self.add_file_button.pressed.connect(self.add_file) self.remove_button.pressed.connect(self.remove_folder) self.add_exclude_rule.pressed.connect(self.add_rule) self.remove_exclude_rule.pressed.connect(self.remove_rule) self.group_schedule = QButtonGroup() self.group_schedule.addButton(self.manual_radio_button) self.group_schedule.addButton(self.backup_every_radio_button) self.group_schedule.addButton(self.daily_radio_button) self.group_retention = QButtonGroup() self.group_retention.addButton(self.forever_radio_button) self.group_retention.addButton(self.keep_last_radio_button) self.forever_radio_button.setChecked(True) self.manual_radio_button.setChecked(True) self.daily_radio_button.pressed.connect(self.daily_radio_pressed) self.backup_every_radio_button.pressed.connect( self.backup_every_pressed) self.manual_radio_button.pressed.connect(self.manual_radio_pressed) self.forever_radio_button.pressed.connect( lambda: self.days_spin_box.setEnabled(False)) self.keep_last_radio_button.pressed.connect( lambda: self.days_spin_box.setEnabled(True)) self.mon_checkbox.clicked.connect( lambda: self.state_changed("mon", self.mon_checkbox)) self.tue_checkbox.clicked.connect( lambda: self.state_changed("tue", self.tue_checkbox)) self.wed_checkbox.clicked.connect( lambda: self.state_changed("wed", self.wed_checkbox)) self.thu_checkbox.clicked.connect( lambda: self.state_changed("thu", self.thu_checkbox)) self.fri_checkbox.clicked.connect( lambda: self.state_changed("fri", self.fri_checkbox)) self.sat_checkbox.clicked.connect( lambda: self.state_changed("sat", self.sat_checkbox)) self.sun_checkbox.clicked.connect( lambda: self.state_changed("sun", self.sun_checkbox)) self.activation_label.hide() self.setWindowTitle(window_title) self.thread_count_spin_box.setValue(DEFAULT_THREAD_COUNT) self.compression_level_spin_box.setValue(DEFAULT_COMPRESSION_LEVEL) self.populate()
def __init__(self, parent=None): QDialog.__init__(self) self.ui = Ui_FindReplaceDialog() self.ui.setupUi(self)
def __init__(self, parent=None, material=None): """Dialog for edit/show material properties Parameters ---------- material : Material material to edit parent : Widget Parent Widget (DMatLib) material : Material Material object to show/edit """ # Build the interface according to the .ui file QDialog.__init__(self) self.setupUi(self) self.is_save_needed = False self.init_name = None # Initial name of current Material (to revert rename) self.init_path = None # Initial part of current Material (for rename) self.mat = None # Current material being edited # Set initial material if material is not None: self.set_material(material=material) # === setup signals === # General self.le_name.editingFinished.connect(self.set_name) self.is_isotropic.toggled.connect(self.set_is_isotropic) # Elec self.lf_rho_elec.editingFinished.connect(self.set_rho_elec) # Magnetics self.lf_mur_lin.editingFinished.connect(self.set_mur_lin) self.lf_Brm20.editingFinished.connect(self.set_Brm20) self.lf_alpha_Br.editingFinished.connect(self.set_alpha_Br) self.lf_Wlam.editingFinished.connect(self.set_Wlam) # Economical self.lf_cost_unit.editingFinished.connect(self.set_cost_unit) # Thermics self.lf_Cp.editingFinished.connect(self.set_Cp) self.lf_alpha.editingFinished.connect(self.set_alpha) self.lf_L.editingFinished.connect(self.set_lambda) self.lf_Lx.editingFinished.connect(self.set_lambda_x) self.lf_Ly.editingFinished.connect(self.set_lambda_y) self.lf_Lz.editingFinished.connect(self.set_lambda_z) # Mechanics self.lf_rho_meca.editingFinished.connect(self.set_rho_meca) self.lf_E.editingFinished.connect(self.set_E) self.lf_Ex.editingFinished.connect(self.set_Ex) self.lf_Ey.editingFinished.connect(self.set_Ey) self.lf_Ez.editingFinished.connect(self.set_Ez) self.lf_G.editingFinished.connect(self.set_G) self.lf_Gxy.editingFinished.connect(self.set_Gxy) self.lf_Gxz.editingFinished.connect(self.set_Gxz) self.lf_Gyz.editingFinished.connect(self.set_Gyz) self.lf_nu.editingFinished.connect(self.set_nu) self.lf_nu_xy.editingFinished.connect(self.set_nu_xy) self.lf_nu_xz.editingFinished.connect(self.set_nu_xz) self.lf_nu_yz.editingFinished.connect(self.set_nu_yz) # Connect buttons self.b_delete.clicked.connect(lambda: self.materialToDelete.emit()) self.b_save.clicked.connect(lambda: self.materialToSave.emit()) self.b_cancel.clicked.connect(lambda: self.materialToRevert.emit())
def __init__(self, dxf_path=None, Zh=None, Lmag=None, lam=None): """Initialize the Dialog Parameters ---------- self : DXF_Hole a DXF_Hole object dxf_path : str Path to a dxf file to read """ # Widget setup QDialog.__init__(self) self.setupUi(self) # Icon preparation self.delete_icon = QPixmap(pixmap_dict["cross"]) self.delete_icon.scaled(ICON_SIZE, ICON_SIZE, Qt.KeepAspectRatio) self.highlight_icon = QPixmap(pixmap_dict["search"]) self.highlight_icon.scaled(ICON_SIZE, ICON_SIZE, Qt.KeepAspectRatio) # Tutorial video link self.url = "https://pyleecan.org/videos.html#feature-tutorials" self.b_tuto.setEnabled(True) # Set units self.lf_mag_len.unit = "m" wid_list = [ self.unit_mag_len, ] for wid in wid_list: wid.setText("[" + gui_option.unit.get_m_name() + "]") # Initialize the graph self.init_graph() # Not used yet self.lf_axe_angle.hide() self.in_axe_angle.hide() self.unit_axe_angle.hide() # Set default values if Zh is not None: self.si_Zh.setValue(Zh) if Lmag is not None: self.lf_mag_len.setValue(Lmag) if lam is None: self.lam = lam else: self.lam = lam.copy() # Init properties self.line_list = list() # List of line from DXF self.selected_list = list() # List of currently selected lines self.surf_list = list() # List of defined surfaces self.Zcenter = 0 # For translate offset # Set DXF edit widget self.lf_center_x.setValue(0) self.lf_center_y.setValue(0) self.lf_scaling.validator().setBottom(0) self.lf_scaling.setValue(1) # Load the DXF file if provided self.dxf_path = dxf_path if dxf_path is not None and isfile(dxf_path): self.open_document() # Setup Path selector for DXF files self.w_path_selector.obj = self self.w_path_selector.param_name = "dxf_path" self.w_path_selector.verbose_name = "DXF File" self.w_path_selector.extension = "DXF file (*.dxf)" self.w_path_selector.set_path_txt(self.dxf_path) self.w_path_selector.update() # Set table column width header = self.w_surface_list.horizontalHeader() header.setSectionResizeMode(DEL_COL, QHeaderView.ResizeToContents) header.setSectionResizeMode(HL_COL, QHeaderView.ResizeToContents) header.setSectionResizeMode(TYPE_COL, QHeaderView.ResizeToContents) header.setSectionResizeMode(REF_COL, QHeaderView.ResizeToContents) header.setSectionResizeMode(OFF_COL, QHeaderView.ResizeToContents) # Connect signals to slot self.w_path_selector.pathChanged.connect(self.open_document) self.b_save.pressed.connect(self.save) self.b_plot.pressed.connect(self.plot) self.b_reset.pressed.connect(self.update_graph) self.b_cancel.pressed.connect(self.remove_selection) self.b_tuto.pressed.connect(self.open_tuto) self.is_convert.toggled.connect(self.enable_tolerance) self.lf_center_x.editingFinished.connect(self.set_center) self.lf_center_y.editingFinished.connect(self.set_center) # Display the GUI self.show()
def __init__(self, dxf_path=None, Zh=None, Lmag=None, lam=None): """Initialize the Dialog Parameters ---------- self : DXF_Hole a DXF_Hole object dxf_path : str Path to a dxf file to read """ # Widget setup QDialog.__init__(self) self.setupUi(self) # Icon preparation self.delete_icon = QPixmap(pixmap_dict["cross"]) self.delete_icon.scaled(ICON_SIZE, ICON_SIZE, Qt.KeepAspectRatio) self.highlight_icon = QPixmap(pixmap_dict["search"]) self.highlight_icon.scaled(ICON_SIZE, ICON_SIZE, Qt.KeepAspectRatio) # Initialize the graph self.init_graph() # Not used yet self.in_coord_center.hide() self.lf_center_x.hide() self.lf_center_y.hide() self.lf_axe_angle.hide() self.in_axe_angle.hide() # Set default values if Zh is not None: self.si_Zh.setValue(Zh) if Lmag is not None: self.lf_mag_len.setValue(Lmag) if lam is None: self.lam = lam else: self.lam = lam.copy() # Init properties self.line_list = list() # List of line from DXF self.selected_list = list() # List of currently selected lines self.surf_list = list() # List of defined surfaces self.lf_center_x.setValue(0) self.lf_center_y.setValue(0) self.lf_scaling.validator().setBottom(0) self.lf_scaling.setValue(1) # Load the DXF file if provided self.dxf_path = dxf_path if dxf_path is not None and isfile(dxf_path): self.open_document() # Setup Path selector for DXF files self.w_path_selector.obj = self self.w_path_selector.param_name = "dxf_path" self.w_path_selector.verbose_name = "DXF File" self.w_path_selector.extension = "DXF file (*.dxf)" self.w_path_selector.set_path_txt(self.dxf_path) self.w_path_selector.update() # Set table column width header = self.w_surface_list.horizontalHeader() header.setSectionResizeMode(DEL_COL, QHeaderView.ResizeToContents) header.setSectionResizeMode(HL_COL, QHeaderView.ResizeToContents) header.setSectionResizeMode(TYPE_COL, QHeaderView.ResizeToContents) header.setSectionResizeMode(REF_COL, QHeaderView.ResizeToContents) header.setSectionResizeMode(OFF_COL, QHeaderView.ResizeToContents) # Connect signals to slot self.w_path_selector.pathChanged.connect(self.open_document) self.b_save.pressed.connect(self.save) self.b_plot.pressed.connect(self.plot) self.b_reset.pressed.connect(self.update_graph) self.b_cancel.pressed.connect(self.remove_selection) # Display the GUI self.show()
def __init__(self, *args, **kwargs): QDialog.__init__(self, *args, **kwargs) self.setupUi(self) self.buttonBox.accepted.connect(self.accept) self.buttonBox.rejected.connect(self.reject)
def __init__(self, parent=None): QDialog.__init__(self, parent=parent) self.setWindowTitle('Register here') self.setStyleSheet(get_style(self.style_path)) self.initUI()
def __init__(self): QDialog.__init__(self) self.setWindowTitle(tr("btn_config")) self.setFixedSize(QSize(700, 675)) # Retrieve current settings self.settings = AssetManager.getInstance().config_to_dico( AssetManager.getInstance().get_config_parser()) self.__restart_needed = False self.__restore_required = False # Version self.lab_version = QLabel(self.settings['main']['version']) # Language self.combo_language = QComboBox() self.combo_language.addItems(list(self.languages.keys())) for lang in self.languages: # Look for the current language to select it if self.languages[lang] == self.settings['main']['language']: self.combo_language.setCurrentText(lang) break # CSV separator self.csv_sep_edit = QLineEdit() self.csv_sep_edit.setMaxLength(2) self.csv_sep_edit.setFixedWidth(25) self.csv_sep_edit.setAlignment(Qt.AlignCenter) self.csv_sep_edit.setText(self.settings['main']['csv_separator']) # BDD path self.btn_bdd_path = QPushButton(self.settings['main']['bdd_path']) self.btn_bdd_path.clicked.connect(self.choose_bdd_path) # Port self.wepapp_port = QSpinBox() self.wepapp_port.setMinimum(1024) self.wepapp_port.setMaximum(65535) self.wepapp_port.setValue(int(self.settings['webapp']['port'])) # Colors self.tile_color = ColorChooser(self.settings['colors']['tile']) self.hovered_tile_color = ColorChooser( self.settings['colors']['hovered_tile']) self.hovered_empty_tile_color = ColorChooser( self.settings['colors']['hovered_empty_tile']) self.dragged_tile_color = ColorChooser( self.settings['colors']['dragged_tile']) self.drag_selected_tile_color = ColorChooser( self.settings['colors']['drag_selected_tile']) self.selected_tile_color = ColorChooser( self.settings['colors']['selected_tile']) self.tile_text_color = ColorChooser( self.settings['colors']['tile_text']) self.room_bg_color = ColorChooser(self.settings['colors']['room_bg']) self.room_grid_color = ColorChooser( self.settings['colors']['room_grid']) self.main_bg_color = ColorChooser(self.settings['colors']['main_bg']) self.board_bg_color = ColorChooser(self.settings['colors']['board_bg']) self.attr_colors = "" # Chosen colors self.attributes_colors_chooser = AttrColorsChooser( self.settings['colors']['attr_colors'].split()) # Sizes # Desk sizes self.desk_size_h = QSpinBox() self.desk_size_h.setMinimum(10) self.desk_size_h.setMaximum(200) self.desk_size_h.setValue(int(self.settings['size']['desk_height'])) self.desk_size_h.setFixedWidth(50) self.desk_size_w = QSpinBox() self.desk_size_w.setMinimum(10) self.desk_size_w.setMaximum(200) self.desk_size_w.setValue(int(self.settings['size']['desk_width'])) self.desk_size_w.setFixedWidth(50) # Font size self.desk_font_size = QSpinBox() self.desk_font_size.setMinimum(4) self.desk_font_size.setValue(int(self.settings['size']['font_size'])) self.desk_font_size.setFixedWidth(50) # Grid rows self.grid_rows = QSpinBox() self.grid_rows.setMinimum(1) self.grid_rows.setMaximum(40) self.grid_rows.setValue(int( self.settings['size']['default_room_rows'])) self.grid_rows.setFixedWidth(50) # Grid columns self.grid_cols = QSpinBox() self.grid_cols.setMinimum(1) self.grid_cols.setMaximum(40) self.grid_cols.setValue( int(self.settings['size']['default_room_columns'])) self.grid_cols.setFixedWidth(50) # --- Buttons --- # Confirm button self.ok_btn = QPushButton(tr("btn_save")) self.ok_btn.clicked.connect(self.accept) self.ok_btn.setFixedWidth(200) self.ok_btn.setFocus() # Cancel button self.cancel_btn = QPushButton(tr("btn_cancel")) self.cancel_btn.clicked.connect(self.reject) self.cancel_btn.setFixedWidth(200) # Restore defaults button self.restore_btn = QPushButton(tr("btn_restore")) self.restore_btn.clicked.connect(self.__restore) self.restore_btn.setFixedWidth(200) self.__set_layout()
def __init__(self, parent=None): QDialog.__init__(self, parent) Ui_Dialog.setupUi(self, self) self.acceptButton.clicked.connect(self.slot_accept) self.rejectButton.clicked.connect(self.slot_reject) self.success = False
def __init__(self, dxf_path=None, Zh=None, Lmag=None): """Initialize the Dialog Parameters ---------- self : DXF_Hole a DXF_Hole object dxf_path : str Path to a dxf file to read """ # Widget setup QDialog.__init__(self) self.setupUi(self) # Icon preparation self.delete_icon = QPixmap(pixmap_dict["cross"]) self.delete_icon.scaled(ICON_SIZE, ICON_SIZE, Qt.KeepAspectRatio) self.highlight_icon = QPixmap(pixmap_dict["search"]) self.highlight_icon.scaled(ICON_SIZE, ICON_SIZE, Qt.KeepAspectRatio) # Initialize the graph self.init_graph() # Not used yet self.in_coord_center.hide() self.lf_center_x.hide() self.lf_center_y.hide() self.lf_axe_angle.hide() self.in_axe_angle.hide() # Set default values if Zh is not None: self.si_Zh.setValue(Zh) if Lmag is not None: self.lf_mag_len.setValue(Lmag) # Init properties self.line_list = list() # List of line from DXF self.selected_list = list() # List of currently selected lines self.surf_list = list() # List of defined surfaces self.lf_center_x.setValue(0) self.lf_center_y.setValue(0) # Load the DXF file if provided self.dxf_path = dxf_path if dxf_path is not None and isfile(dxf_path): self.open_document() # Setup Path selector for DXF files self.w_path_selector.obj = self self.w_path_selector.param_name = "dxf_path" self.w_path_selector.verbose_name = "DXF File" self.w_path_selector.extension = "DXF file (*.dxf)" self.w_path_selector.set_path_txt(self.dxf_path) self.w_path_selector.update() # Format w_surface_list table (QTableWidget) self.w_surface_list.setColumnCount(3) self.w_surface_list.horizontalHeader().hide() self.w_surface_list.verticalHeader().hide() # Connect signals to slot self.w_path_selector.pathChanged.connect(self.open_document) self.b_save.pressed.connect(self.save) self.b_plot.pressed.connect(self.plot) # Display the GUI self.show()
def __init__(self, parent=None): QDialog.__init__(self, parent) self.ui = Ui_ValueInputDialog() self.ui.setupUi(self)
def __init__(self, db, table, columns, title='', search_field=None, toggle=None, tree_view=False, relations=None): QDialog.__init__(self) self.setupUi(self) self.selected_id = 0 self.p_selected_name = '' self.dialog_visible = False self.tree_view = tree_view self.parent = 0 self.last_parent = 0 self.group_id = None self.group_key_field = None self.group_key_index = None self.group_fkey_field = None self.toggle_state = False self.toggle_field = None self.search_text = "" self.search_field = search_field self.db = db self.table = table self.Model = UseSqlTable(self.db, self.table, columns, relations) self.delegates = ConfigureTableView(self.DataView, self.Model, columns) # Storage of delegates inside class is required to keep ownership and prevent SIGSEGV as # https://doc.qt.io/qt-5/qabstractitemview.html#setItemDelegateForColumn says: # Any existing column delegate for column will be removed, but not deleted. # QAbstractItemView does not take ownership of delegate. self.GroupLbl.setVisible(False) self.GroupCombo.setVisible(False) if relations is not None: for relation in relations: if relation[rel_idx.GROUP_NAME] is not None: self.GroupLbl.setVisible(True) self.GroupLbl.setText(relation[rel_idx.GROUP_NAME]) self.GroupCombo.setVisible(True) self.group_key_field = relation[rel_idx.KEY_FIELD] self.group_key_index = self.Model.fieldIndex( relation[rel_idx.KEY_FIELD]) self.group_fkey_field = relation[rel_idx.FOREIGN_KEY] relation_model = self.Model.relationModel( self.group_key_index) self.GroupCombo.setModel(relation_model) self.GroupCombo.setModelColumn( relation_model.fieldIndex( relation[rel_idx.LOOKUP_FIELD])) self.group_id = relation_model.data( relation_model.index( 0, relation_model.fieldIndex(self.group_fkey_field))) self.Toggle.setVisible(False) if toggle: self.Toggle.setVisible(True) self.toggle_field = toggle[0] self.Toggle.setText(toggle[1]) self.setWindowTitle(title) if self.search_field is not None: self.SearchFrame.setVisible(True) else: self.SearchFrame.setVisible(False) self.UpBtn.setVisible(self.tree_view) self.SearchString.textChanged.connect(self.OnSearchChange) self.UpBtn.clicked.connect(self.OnUpClick) self.GroupCombo.currentIndexChanged.connect(self.OnGroupChange) self.Toggle.stateChanged.connect(self.OnToggleChange) self.AddBtn.clicked.connect(self.OnAdd) self.RemoveBtn.clicked.connect(self.OnRemove) self.CommitBtn.clicked.connect(self.OnCommit) self.RevertBtn.clicked.connect(self.OnRevert) self.DataView.clicked.connect(self.OnClicked) self.DataView.selectionModel().selectionChanged.connect( self.OnRowSelected) self.Model.dataChanged.connect(self.OnDataChanged) self.Model.select() self.setFilter()
def __init__(self, *args, **kwargs): QDialog.__init__(self, *args, **kwargs) self.setupUi(self)
def __init__(self, model: BaseModel, controller: BaseController) -> None: QDialog.__init__(self) BaseView.__init__(self, model, controller, Ui_AppSettings()) self._connectSignals()
def __init__(self, window: Any, parent: Optional[Any], style: Optional[Any], title_bar: bool, transparent_window: bool, titlebar_height: Optional[int], titlebar_color: Optional[QColor], titlebar_nofocus_color: Optional[QColor], titlebar_text_color: Optional[QColor], titlebar_widget: Optional[Union[QWidget, QTabWidget]], window_buttons_position: Optional[str]) -> None: """ Constructor. Parameters: * window: Qt widget that should be wrapped * window_style: choose from one of the pre-defined styles, e.g. 'APL', 'WOW' * title_bar: display a traditional titlebar or not * titlebar_height: height of the titlebar in pixel * titlebar_color: override background color of the titlebar * titlebar_nofocus_color: override background color of the titlebar when the window is out of focus * titlebar_text_color: override color for the window title text * window_button_position: positions the window close/min/max buttons left (macOS) or right of the window title (Windows, Gnome, KDE, etc.) * transparent_window: turns off window transparency. This ensures compatibility with certain widgets and draw modes, such as QMediaWidget on Windows. Drawbacks: when transparent_window is False, window drop shadow effects will be disabled, except for operating systems that automatically add a drop shadow to all windows. """ def expose_msgbox_methods() -> None: """ensure Qt methods of wrapped children are exposed""" assert self.__window is not None self.setText = self.__window.setText self.setInformativeText = self.__window.setInformativeText self.setDetailedText = self.__window.setDetailedText def add_window_buttons() -> None: """create window widget buttons""" button_size_policy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) if not isinstance(self.__window, QDIALOG_TYPES): self._minimize_button = QToolButton(self) self._minimize_button.setObjectName('btnMinimize') self._minimize_button.setSizePolicy(button_size_policy) self._minimize_button.clicked.connect( self.__on_minimize_button_clicked) # pylint: disable=no-member self._restore_button = QToolButton(self) self._restore_button.setObjectName('btnRestore') self._restore_button.setSizePolicy(button_size_policy) self._restore_button.clicked.connect( self.__on_restore_button_clicked) # pylint: disable=no-member self._maximize_button = QToolButton(self) self._maximize_button.setObjectName('btnMaximize') self._maximize_button.setSizePolicy(button_size_policy) self._maximize_button.clicked.connect( self.__on_maximize_button_clicked) # pylint: disable=no-member self._close_button = QToolButton(self) self._close_button.setObjectName('btnClose') self._close_button.setSizePolicy(button_size_policy) self._close_button.clicked.connect(self.__on_close_button_clicked) # pylint: disable=no-member self.__move_window_buttons() # place buttons def set_window_properties(titlebar_height: int) -> None: """Sets Qt Properties for the wrapper window""" assert self.__window is not None self.setStyleSheet(self.__style.get_window_stylesheet()) self.setWindowFlags(Qt.Window | Qt.FramelessWindowHint | Qt.WindowSystemMenuHint | Qt.WindowCloseButtonHint | Qt.WindowMinimizeButtonHint | Qt.WindowMaximizeButtonHint) if sys.platform not in ["darwin"] and self.__transparent_window: self.setAttribute(Qt.WA_TranslucentBackground, True) # no need for translucency on macOS if sys.platform == 'win32': self.setAttribute( Qt.WA_OpaquePaintEvent, True) # avoid flickering on window resize on Windows else: self.setAttribute(Qt.WA_OpaquePaintEvent, False) self.setAttribute(Qt.WA_NoSystemBackground, True) self.setWindowTitle(self.__window.windowTitle()) self.setGeometry(self.__window.geometry()) height = titlebar_height if self.__use_shadow: height += self.__style.window.SHADOW_RADIUS_PX * 2 self.setMinimumHeight(self.__window.minimumSizeHint().height() + height) self.setMinimumWidth(self.__window.minimumSizeHint().width()) def add_window_drop_shadow() -> None: """Adds a drop-shadow behind the window""" if self.__use_shadow: self.layout().setMargin(self.__style.window.SHADOW_RADIUS_PX) drop_shadow_effect = QGraphicsDropShadowEffect(self) drop_shadow_effect.setEnabled(True) drop_shadow_effect.setBlurRadius( self.__style.window.SHADOW_RADIUS_PX) color = QColor(self.__style.window.SHADOW_COLOR_RGB) color.setAlpha(self.__style.window.SHADOW_OPACITY_HEX) drop_shadow_effect.setColor(color) drop_shadow_effect.setOffset(0) self.setGraphicsEffect(drop_shadow_effect) def adjust_wrapped_window_object() -> None: """Adding attribute to clean up the parent window when the child is closed""" assert self.__window is not None self.__window.wrapper = self self.__window.setAttribute(Qt.WA_DeleteOnClose, True) self.__window.destroyed.connect(self.__child_was_closed) def add_resizers() -> None: """Adds resizer widgets, which act as resize handles, to the window wrapper""" if isinstance(window, QDIALOG_TYPES): assert self.__window is not None self.__window.installEventFilter(self) else: self.resizer_top = Resizer( self, Resizer.TOP, self.__style.window.SHADOW_RADIUS_PX) self.resizer_bot = Resizer( self, Resizer.BOTTOM, self.__style.window.SHADOW_RADIUS_PX) self.resizer_lef = Resizer( self, Resizer.LEFT, self.__style.window.SHADOW_RADIUS_PX) self.resizer_rig = Resizer( self, Resizer.RIGHT, self.__style.window.SHADOW_RADIUS_PX) self.resizer_tl = Resizer(self, Resizer.TOP_LEFT, self.__style.window.SHADOW_RADIUS_PX) self.resizer_tr = Resizer(self, Resizer.TOP_RIGHT, self.__style.window.SHADOW_RADIUS_PX) self.resizer_br = Resizer(self, Resizer.BOTTOM_RIGHT, self.__style.window.SHADOW_RADIUS_PX) self.resizer_bl = Resizer(self, Resizer.BOTTOM_LEFT, self.__style.window.SHADOW_RADIUS_PX) def get_window_frame_widget( window_buttons_position: str) -> WindowFrame: """Returns a widget which acts as Qt 'windowFrame' element""" window_frame_widget = WindowFrame( titlebar_height=self.__titlebar_height, titlebar_color=self.__titlebar_color, background_color=self.__style.window.WINDOW_BACKGROUND_RGB, corner_radius=self.__style.window.WINDOW_CORNER_RADIUS_PX, parent=self) if not isinstance(window, QDIALOG_TYPES): window_frame_widget.double_clicked.connect( self.__on_title_bar_double_clicked) # type: ignore window_frame_widget.setObjectName('windowFrame') self.__vbox_frame_layout = QVBoxLayout(window_frame_widget) self.__vbox_frame_layout.setContentsMargins(0, 0, 0, 0) self.__vbox_frame_layout.setSpacing(0) if self.__title_bar: # add optional titlebar tcolor = QColor(self.__style.window.TITLE_BAR_FONT_COLOR_RGB) if titlebar_text_color is not None: tcolor = titlebar_text_color self.__title_widget = WindowTitleLabel( text='', height=self.__titlebar_height, color=tcolor, window_buttons_position=window_buttons_position, margin=self.__style.window. TITLE_BAR_TITLE_TEXT_RIGHT_MARGIN_PX, button_bar_width=self.window_buttons_width + self.window_buttons_margin, minimum_width=self.__style.window. TITLE_LABEL_MINIMUM_WIDTH_PX, parent=None) self.__title_widget.setMinimumHeight(self.__titlebar_height) self.__vbox_frame_layout.addWidget(self.__title_widget) else: # no title-bar; add dummy widget to create a margin self.__title_widget = QWidget() self.__title_widget.setGeometry( 0, 0, 1, self.__style.window.TITLE_BAR_TOP_MARGIN_PX) self.__title_widget.setMinimumHeight( self.__style.window.TITLE_BAR_TOP_MARGIN_PX) self.__vbox_frame_layout.addWidget(self.__title_widget) assert self.__window is not None self.__vbox_frame_layout.addWidget(self.__window) return window_frame_widget QDialog.__init__(self, parent) self.__style: Any = style if titlebar_height is None: titlebar_height = self.__style.window.TITLE_BAR_HEIGHT_PX assert window_buttons_position in [ None, WINDOW_BUTTONS_LEFT, WINDOW_BUTTONS_RIGHT ] if window_buttons_position is None: window_buttons_position = WINDOW_BUTTONS_LEFT if sys.platform == 'darwin' else WINDOW_BUTTONS_RIGHT self.__window: Optional[QWidget] = window self.__title_bar: bool = True if isinstance( self.__window, QDIALOG_TYPES) else title_bar self.__titlebar_height: int = titlebar_height self.__transparent_window: bool = transparent_window # True if window uses WA_TranslucentBackground self.__use_shadow: bool = sys.platform != 'darwin' and transparent_window self.__maximized: bool = False self.__drag_move_enabled: bool = True self.__mouse_pressed: bool = False self.__mouse_pos: Optional[QPoint] = None self.__window_pos: Optional[QPoint] = None self.__window_buttons_width: int = 0 self.__window_buttons_position: str = window_buttons_position # create main contaner layout self.__vbox_master_layout = QGridLayout(self) self.__vbox_master_layout.setContentsMargins(0, 0, 0, 0) if titlebar_color is None: self.__titlebar_color: QColor = QColor( self.__style.window.TITLE_BAR_COLOR_RGB) else: self.__titlebar_color = titlebar_color if titlebar_nofocus_color is None: self.__titlebar_nofocus_color: QColor = QColor( self.__style.window.TITLE_BAR_NOFOCUS_COLOR_RGB) else: self.__titlebar_nofocus_color = titlebar_nofocus_color self.__window_frame_widget: WindowFrame = get_window_frame_widget( window_buttons_position=self.__window_buttons_position) self.__vbox_master_layout.addWidget(self.__window_frame_widget, 0, 0) # run window initialization methods add_resizers() if isinstance(self.__window, QMessageBox): expose_msgbox_methods() adjust_wrapped_window_object() add_window_drop_shadow() add_window_buttons() set_window_properties(self.__titlebar_height) # connect slot to detect if window/app loses focus app = QApplication.instance() app.focusChanged.connect(self.__app_focus_changed_slot) self.setFocus() self.layout().setSizeConstraint( QLayout.SetMinimumSize ) # ensure widgets cannot be resized below their min size # attributes for title-bar tab widget self.__tab_widget_dummy_close_button: Optional[QWidget] = None self.__tab_widget_filter: Optional[TabFilter] = None self.__tab_widget: Optional[QTabWidget] = None if titlebar_widget is not None: self.__adjust_title_tabwidget(titlebar_widget)
def __init__(self): QDialog.__init__(self) self.setGeometry(125, 100, 0, 0) self.setModal(True) self.setWindowTitle('Add Category') self.show()
def __init__(self): QDialog.__init__(self) import lib.aboutUi as aboutUi self.child = aboutUi.Ui_Dialog_about() self.child.setupUi(self)
def __init__(self): QDialog.__init__(self) self.setGeometry(125, 100, 0, 0) self.setModal(True) self.setWindowTitle('Edit Total') self.show()
def __init__(self, controller, scene, share_widget, parent=None): QDialog.__init__(self, parent) Ui_Dialog.setupUi(self, self) self.leftView = SceneViewerWidget(parent, share_widget, size=(400, 400), use_frame_buffer=False) self.leftView.setObjectName("left") self.leftView.setMinimumSize(400, 400) self.leftView.initializeGL() self.leftView.enable_mouse_interaction = False self.leftViewerLayout.addWidget(self.leftView) self.rightView = SceneViewerWidget(parent, self.leftView, size=(400, 400), use_frame_buffer=False) self.rightView.setObjectName("right") self.rightView.setMinimumSize(400, 400) self.rightView.initializeGL() self.rightView.enable_mouse_interaction = False self.rightViewerLayout.addWidget(self.rightView) self.fps = 60 self.dt = 1 / 60 self.timer = QTimer() self.timer.timeout.connect(self.draw) self.timer.start(0) self.timer.setInterval(1000.0 / self.fps) self.scene = scene self.right_controller = None self.skeleton = None self.rightView.makeCurrent() self.right_scene = EditorScene(True) if controller is not None: self.right_controller = self.copy_controller( controller, self.right_scene) self.skeleton = self.right_controller.get_skeleton() n_frames = self.right_controller.getNumberOfFrames() self._fill_list_with_joints(controller) else: n_frames = 0 self.leftView.makeCurrent() self.left_scene = EditorScene(True) self.copyButton.clicked.connect(self.copy_from_left_to_right) self.left_controller = None self.controllers = dict() self._fill_list_with_scene_objects(scene) self.selectButton.clicked.connect(self.slot_accept) self.cancelButton.clicked.connect(self.slot_reject) self.selectAllJointsButton.clicked.connect(self.slot_select_all_joints) self.selectJointChildrenButton.clicked.connect( self.slot_select_joint_children) self.deselectJointChildrenButton.clicked.connect( self.slot_deselect_joint_children) self.clearSelectedJointsButton.clicked.connect( self.slot_clear_all_joints) self.leftStartFrameSlider.valueChanged.connect( self.left_slider_frame_changed) self.leftEndFrameSlider.valueChanged.connect( self.left_slider_frame_changed) self.leftStartFrameSpinBox.valueChanged.connect( self.left_spinbox_frame_changed) self.leftEndFrameSpinBox.valueChanged.connect( self.left_spinbox_frame_changed) self.leftDisplayFrameSlider.valueChanged.connect( self.left_display_changed) self.leftDisplayFrameSpinBox.valueChanged.connect( self.left_display_changed) self.rightStartFrameSlider.valueChanged.connect( self.right_slider_frame_changed) self.rightStartFrameSpinBox.valueChanged.connect( self.right_spinbox_frame_changed) self.rightEndFrameSlider.valueChanged.connect( self.right_slider_frame_changed) self.rightEndFrameSpinBox.valueChanged.connect( self.right_spinbox_frame_changed) self.rightDisplayFrameSpinBox.valueChanged.connect( self.right_display_changed) self.rightDisplayFrameSlider.valueChanged.connect( self.right_display_changed) self.sceneObjectListWidget.itemClicked.connect( self.load_src_controller) self.success = False self.n_frames = n_frames self.start_frame = 0 self.end_frame = n_frames - 1 # self.set_right_frame_range() self.initialized = False
def __init__(self, parent): QDialog.__init__(self, parent) self.main_layout = QVBoxLayout(self) self.setModal(True)
def __init__(self, dxf_path=None, Zs=None, lam=None): """Initialize the Dialog Parameters ---------- self : DXF_Slot a DXF_Slot object dxf_path : str Path to a dxf file to read """ # Widget setup QDialog.__init__(self) self.setupUi(self) # Init properties self.line_list = list() # List of line from DXF self.selected_list = list() # List of currently selected lines self.lam = lam self.Zcenter = 0 # For offset # Tutorial video link self.url = "https://pyleecan.org/videos.html#feature-tutorials" self.b_tuto.setEnabled(True) # Initialize the graph self.init_graph() # Not used yet self.lf_axe_angle.hide() self.in_axe_angle.hide() # Set DXF edit widget self.lf_center_x.setValue(0) self.lf_center_y.setValue(0) self.lf_scaling.validator().setBottom(0) self.lf_scaling.setValue(1) # Set default values if Zs is not None: self.si_Zs.setValue(Zs) # Setup Path selector for DXF files self.dxf_path = dxf_path self.w_path_selector.obj = self self.w_path_selector.param_name = "dxf_path" self.w_path_selector.verbose_name = "DXF File" self.w_path_selector.extension = "DXF file (*.dxf)" self.w_path_selector.set_path_txt(self.dxf_path) self.w_path_selector.update() # Load the DXF file if provided if self.dxf_path is not None and isfile(self.dxf_path): self.open_document() # Set font font = QFont() font.setFamily(FONT_NAME) font.setPointSize(FONT_SIZE) self.textBrowser.setFont(font) # Connect signals to slot self.w_path_selector.pathChanged.connect(self.open_document) self.b_save.pressed.connect(self.save) self.b_plot.pressed.connect(self.plot) self.b_reset.pressed.connect(self.update_graph) self.b_cancel.pressed.connect(self.remove_selection) self.b_tuto.pressed.connect(self.open_tuto) self.is_convert.toggled.connect(self.enable_tolerance) self.lf_center_x.editingFinished.connect(self.set_center) self.lf_center_y.editingFinished.connect(self.set_center) # Display the GUI self.show()
def __init__(self, material, is_matlib=True): """ Dialog for editing material data. Parameters ---------- material : Material material to edit is_matlib : bool material already in matlib """ # Build the interface according to the .ui file QDialog.__init__(self) self.setupUi(self) # Copy to set the modification only if validated self.mat = Material(init_dict=material.as_dict()) self.le_name.setText(self.mat.name) if self.mat.is_isotropic: self.is_isotropic.setCheckState(Qt.Checked) self.nav_meca.setCurrentIndex(1) self.nav_ther.setCurrentIndex(1) else: self.is_isotropic.setCheckState(Qt.Unchecked) self.nav_meca.setCurrentIndex(0) self.nav_ther.setCurrentIndex(0) # Edit button text if the Material selected is in the ref matlib if is_matlib: self.b_add_matlib.setText("Add to machine") # Three button to close self.b_cancel.clicked.connect(self.close) self.b_save.clicked.connect(lambda: self.done(1)) self.b_add_matlib.clicked.connect(lambda: self.done(2)) # === check material attribute and set values === # Elec if self.mat.elec is None: self.set_default("elec", "electrical") self.lf_rho_elec.setValue(self.mat.elec.rho) # Economical if self.mat.eco is None: self.set_default("eco", "economical") self.lf_cost_unit.setValue(self.mat.eco.cost_unit) # Thermics if self.mat.HT is None: self.set_default("HT", "thermaical") self.lf_Cp.setValue(self.mat.HT.Cp) self.lf_alpha.setValue(self.mat.HT.alpha) self.lf_L.setValue(self.mat.HT.lambda_x) self.lf_Lx.setValue(self.mat.HT.lambda_x) self.lf_Ly.setValue(self.mat.HT.lambda_y) self.lf_Lz.setValue(self.mat.HT.lambda_z) # Structural if self.mat.struct is None: self.set_default("struct", "structural") self.lf_rho_meca.setValue(self.mat.struct.rho) self.lf_E.setValue(self.mat.struct.Ex) self.lf_Ex.setValue(self.mat.struct.Ex) self.lf_Ey.setValue(self.mat.struct.Ey) self.lf_Ez.setValue(self.mat.struct.Ez) self.lf_G.setValue(self.mat.struct.Gxy) self.lf_Gxy.setValue(self.mat.struct.Gxy) self.lf_Gxz.setValue(self.mat.struct.Gxz) self.lf_Gyz.setValue(self.mat.struct.Gyz) self.lf_nu.setValue(self.mat.struct.nu_xy) self.lf_nu_xy.setValue(self.mat.struct.nu_xy) self.lf_nu_xz.setValue(self.mat.struct.nu_xz) self.lf_nu_yz.setValue(self.mat.struct.nu_yz) # Magnetical if self.mat.mag is None: self.set_default("mag", "magnetical") self.lf_mur_lin.setValue(self.mat.mag.mur_lin) self.lf_Brm20.setValue(self.mat.mag.Brm20) self.lf_alpha_Br.setValue(self.mat.mag.alpha_Br) self.lf_Wlam.setValue(self.mat.mag.Wlam) # Setup import B(H) widget self.w_BH_import.verbose_name = "B(H) curve" self.w_BH_import.obj = self.mat.mag self.w_BH_import.param_name = "BH_curve" self.w_BH_import.expected_shape = (None, 2) self.w_BH_import.update() # Hide useless widget self.in_epsr.hide() self.lf_epsr.hide() # === setup signals === # Misc. self.le_name.editingFinished.connect(self.set_name) self.is_isotropic.toggled.connect(self.set_is_isotropic) self.lf_rho_elec.editingFinished.connect(self.set_rho_elec) # Magnetics self.lf_mur_lin.editingFinished.connect(self.set_mur_lin) self.lf_Brm20.editingFinished.connect(self.set_Brm20) self.lf_alpha_Br.editingFinished.connect(self.set_alpha_Br) self.lf_Wlam.editingFinished.connect(self.set_Wlam) # Economical self.lf_cost_unit.editingFinished.connect(self.set_cost_unit) # Thermics self.lf_Cp.editingFinished.connect(self.set_Cp) self.lf_alpha.editingFinished.connect(self.set_alpha) self.lf_L.editingFinished.connect(self.set_lambda) self.lf_Lx.editingFinished.connect(self.set_lambda_x) self.lf_Ly.editingFinished.connect(self.set_lambda_y) self.lf_Lz.editingFinished.connect(self.set_lambda_z) # Mechanics self.lf_rho_meca.editingFinished.connect(self.set_rho_meca) self.lf_E.editingFinished.connect(self.set_E) self.lf_Ex.editingFinished.connect(self.set_Ex) self.lf_Ey.editingFinished.connect(self.set_Ey) self.lf_Ez.editingFinished.connect(self.set_Ez) self.lf_G.editingFinished.connect(self.set_G) self.lf_Gxy.editingFinished.connect(self.set_Gxy) self.lf_Gxz.editingFinished.connect(self.set_Gxz) self.lf_Gyz.editingFinished.connect(self.set_Gyz) self.lf_nu.editingFinished.connect(self.set_nu) self.lf_nu_xy.editingFinished.connect(self.set_nu_xy) self.lf_nu_xz.editingFinished.connect(self.set_nu_xz) self.lf_nu_yz.editingFinished.connect(self.set_nu_yz)