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)
