def __init__(self, parent=None, item=None):
super().__init__(parent)
self.setWindowModality(Qt.WindowModal)
self.setWindowTitle(self.tr("Edit…"))
nameLabel = QLabel(self.tr("Name:"), self)
self.nameEdit = QLineEdit(self)
self.nameEdit.setFocus(Qt.OtherFocusReason)
validator = QDoubleValidator(self)
validator.setLocale(QLocale.c())
xLabel = QLabel(self.tr("X:"), self)
self.xEdit = QLineEdit(self)
self.xEdit.setValidator(validator)
yLabel = QLabel(self.tr("Y:"), self)
self.yEdit = QLineEdit(self)
self.yEdit.setValidator(validator)
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
buttonBox.accepted.connect(self.accept)
buttonBox.rejected.connect(self.reject)
layout = QGridLayout(self)
line = 0
layout.addWidget(nameLabel, line, 0)
layout.addWidget(self.nameEdit, line, 1, 1, 3)
line += 1
layout.addWidget(xLabel, line, 0)
layout.addWidget(self.xEdit, line, 1)
layout.addWidget(yLabel, line, 2)
layout.addWidget(self.yEdit, line, 3)
line += 1
layout.addWidget(buttonBox, line, 3)
self.setLayout(layout)
def __init__(self, clipboard_ratio):
"""
Initializes the dialog.
Args:
clipboard_ratio: Text that is in clipboard.
"""
super().__init__()
uic.loadUi(gutils.get_ui_dir() / "ui_multiply_coordinate_dialog.ui",
self)
self.ratio_str = clipboard_ratio
self.used_multiplier = None
locale = QLocale.c()
self.multiplierSpinBox.setLocale(locale)
try:
float(self.ratio_str)
self.ratioLabel.setText(self.ratio_str)
except ValueError:
self.ratioLabel.setText("None")
self.ratioLabel.setEnabled(False)
self.clipboardButton.setChecked(False)
self.clipboardButton.setEnabled(False)
self.customButton.setChecked(True)
self.multiplierSpinBox.setEnabled(True)
self.clipboardButton.clicked.connect(self.switch_to_clipboard_value)
self.customButton.clicked.connect(self.switch_to_custom_value)
self.okButton.clicked.connect(self.accept_params)
self.cancelButton.clicked.connect(self.close)
self.exec_()
def _main() -> None:
"""
Execute the main application loop.
:return: nothing
:rtype: None
"""
app = QApplication(sys.argv)
QLocale.setDefault(QLocale.c())
# translation
language = QLocale.system().name()[:2]
translations_path = QLibraryInfo.location(QLibraryInfo.TranslationsPath)
base_translator = QTranslator()
base_translator.load("qtbase_{}".format(language), translations_path)
app.installTranslator(base_translator)
custom_translator = QTranslator()
custom_translator.load("cafog_{}".format(language))
app.installTranslator(custom_translator)
# generate main window
frame = MainWindow()
frame.show()
sys.exit(app.exec_())
def __init__(self, simulation: Simulation, parent):
"""Initializes an OptimizationDialog that displays various optimization
parameters.
Args:
simulation: a Simulation object
parent: a SimulationTabWidget
"""
super().__init__()
self.simulation = simulation
self.tab = parent
self.current_mode = OptimizationType.RECOIL
uic.loadUi(gutils.get_ui_dir() / "ui_optimization_params.ui", self)
self.recoil_widget = OptimizationRecoilParameterWidget()
self.fluence_widget = OptimizationFluenceParameterWidget()
self.load_properties_from_file()
locale = QLocale.c()
self.histogramTicksDoubleSpinBox.setLocale(locale)
self.pushButton_OK.setEnabled(False)
self.pushButton_Cancel.clicked.connect(self.close)
self.pushButton_OK.clicked.connect(self.start_optimization)
self.radios = QtWidgets.QButtonGroup(self)
self.radios.buttonToggled[QtWidgets.QAbstractButton, bool].connect(
self.choose_optimization_mode)
self.parametersLayout.addWidget(self.recoil_widget)
self.parametersLayout.addWidget(self.fluence_widget)
self.fluence_widget.hide()
self.radios.addButton(self.fluenceRadioButton)
self.radios.addButton(self.recoilRadioButton)
gutils.fill_tree(
self.simulationTreeWidget.invisibleRootItem(),
simulation.element_simulations,
text_func=lambda elem_sim: elem_sim.get_full_name())
self.simulationTreeWidget.itemSelectionChanged.connect(
self._enable_ok_button)
self.simulationTreeWidget.itemSelectionChanged.connect(
self._adjust_x)
self.auto_adjust_x_box.clicked.connect(self._adjust_x)
self._fill_measurement_widget()
self.measurementTreeWidget.itemSelectionChanged.connect(
self._enable_ok_button)
self.verbose = False
self.eff_file_check_box.clicked.connect(self._enable_efficiency_label)
# self.optimization_verbose_box.clicked.connect(self._verbose)
self._update_efficiency_label()
self.exec_()
def __init__(self, tmp_foils, tmp_index, icon_manager):
""" Initializes the Foil Dialog.
Args:
tmp_foils: Foil object list.
tmp_index: Index of the Foil object in tmp_foils.
icon_manager: Icon manager for TargetCompositionWidget.
"""
super().__init__()
uic.loadUi(gutils.get_ui_dir() / "ui_composition_dialog.ui", self)
self.icon_manager = icon_manager
self.foils = tmp_foils
self.index = tmp_index
self.tmp_foil = copy.deepcopy(tmp_foils[tmp_index])
self.foil_type = None
self.foil_type_changed = False
# Add foil types to combobox.
self.typeComboBox.addItem("circular")
self.typeComboBox.addItem("rectangular")
self.dimension_edits = []
self.first_dimension_edit = QtWidgets.QDoubleSpinBox()
self.first_dimension_edit.setMinimum(0.01)
self.first_dimension_edit.setMaximumWidth(9999.99)
self.first_dimension_edit.setMaximumWidth(70)
self.locale = QLocale.c()
self.first_dimension_edit.setLocale(self.locale)
self.second_dimension_edit = None
self.dimension_label = QtWidgets.QLabel("Diameter (mm):")
self.transmissionEdit.setLocale(self.locale)
self.dimension_edits.append(self.first_dimension_edit)
self.dimensionLayout.addWidget(self.dimension_label)
self.dimensionLayout.addWidget(self.dimension_edits[0])
self.fields_are_valid = False
iv.set_input_field_red(self.nameEdit)
self.nameEdit.textChanged.connect(
lambda: iv.check_text(self.nameEdit, qwidget=self))
self.nameEdit.textEdited.connect(
lambda: iv.sanitize_file_name(self.nameEdit))
self.show_parameters()
# This widget adds itself into the matplotlib_layout
self.composition = FoilCompositionWidget(self, self.tmp_foil,
self.icon_manager)
self.typeComboBox.currentIndexChanged.connect(self._change_dimensions)
self.cancelButton.clicked.connect(self.close)
self.okButton.clicked.connect(self._save_foil_info_and_close)
self.__close = True
self.exec_()
def __init__(self,
parent: BaseTab,
measurement: Measurement,
global_settings: GlobalSettings,
statusbar: Optional[QtWidgets.QStatusBar] = None):
"""Inits depth profile dialog.
Args:
parent: a MeasurementTabWidget.
measurement: a Measurement object
global_settings: a GlobalSettings object
statusbar: a QStatusBar object
"""
super().__init__()
uic.loadUi(gutils.get_ui_dir() / "ui_depth_profile_params.ui", self)
self.parent = parent
self.measurement = measurement
self.statusbar = statusbar
# Connect buttons
self.OKButton.clicked.connect(self._accept_params)
self.cancelButton.clicked.connect(self.close)
locale = QLocale.c()
self.spin_systerr.setLocale(locale)
self.sbox_reference_density.setLocale(locale)
m_name = self.measurement.name
if m_name not in DepthProfileDialog.checked_cuts:
DepthProfileDialog.checked_cuts[m_name] = set()
gutils.fill_cuts_treewidget(self.measurement,
self.treeWidget.invisibleRootItem(),
use_elemloss=True)
self.used_cuts = DepthProfileDialog.checked_cuts[m_name]
gutils.set_btn_group_data(self.group_x_axis_units, DepthProfileUnit)
self.x_axis_units = DepthProfileDialog.x_unit
if self.x_axis_units == DepthProfileUnit.NM:
self._show_reference_density()
else:
self._hide_reference_density()
self.radioButtonNm.clicked.connect(self._show_reference_density)
self.radioButtonAtPerCm2.clicked.connect(self._hide_reference_density)
self.systematic_error = DepthProfileDialog.systerr
self.show_scale_line = DepthProfileDialog.line_scale
self.show_zero_line = DepthProfileDialog.line_zero
self.cross_sections = global_settings.get_cross_sections()
self._show_measurement_settings()
self._show_efficiency_files()
self.exec_()
def __init__(self, parent, element, dialog):
"""Initializes the layout.
Args:
parent: A QWidget into which the layout is added.
element: Element object whose info is shown. None adding a
default layout.
dialog: LayerPropertiesDialog.
"""
parent.parentWidget().setStyleSheet("")
super().__init__()
self.dialog = dialog
self.element_button = QtWidgets.QPushButton("")
self.element_button.setFixedWidth(60)
self.isotope_combobox = QtWidgets.QComboBox()
self.isotope_combobox.setFixedWidth(130)
if platform.system() == "Darwin" or platform.system() == "Linux":
self.isotope_combobox.setFixedWidth(150)
self.amount_spinbox = QtWidgets.QDoubleSpinBox()
self.amount_spinbox.setMinimum(0.001)
self.amount_spinbox.setMaximum(9999.00)
self.amount_spinbox.setDecimals(3)
self.amount_spinbox.setLocale(QLocale.c())
self.delete_button = QtWidgets.QPushButton("")
self.delete_button.setIcon(icons.get_potku_icon("del.png"))
self.delete_button.setFixedWidth(28)
self.delete_button.setFixedHeight(28)
self.delete_button.clicked.connect(self.__delete_element_layout)
self.isotope_info_label = QtWidgets.QLabel()
self.horizontal_layout = QtWidgets.QHBoxLayout()
self.horizontal_layout.addWidget(self.element_button)
self.horizontal_layout.addWidget(self.isotope_combobox)
self.horizontal_layout.addWidget(self.amount_spinbox)
self.horizontal_layout.addWidget(self.delete_button)
self.isotope_selection_widget = IsotopeSelectionWidget(
self.element_button,
self.isotope_combobox,
info_label=self.isotope_info_label,
amount_input=self.amount_spinbox,
parent=self.dialog)
self.isotope_selection_widget.set_element(element)
self.selection_changed = self.isotope_selection_widget.selection_changed
self.addLayout(self.horizontal_layout)
self.addWidget(self.isotope_info_label)
self.insertStretch(-1, 0)
def __init__(self,
element_simulation: ElementSimulation,
preset_folder=None):
"""
Initializes the widget.
Args:
element_simulation: Element simulation object.
"""
super().__init__()
uic.loadUi(gutils.get_ui_dir() / "ui_request_simulation_settings.ui",
self)
# By default, disable the widget, so caller has to enable it. Without
# this, name and description fields would always be enabled when the
# widget loads.
self.setEnabled(False)
self.element_simulation = element_simulation
self.set_spinbox_maximums()
gutils.fill_combobox(self.modeComboBox, SimulationMode)
gutils.fill_combobox(self.typeOfSimulationComboBox, SimulationType)
self.fields_are_valid = False
iv.set_input_field_red(self.nameLineEdit)
self.nameLineEdit.textChanged.connect(
lambda: iv.check_text(self.nameLineEdit, qwidget=self))
self.nameLineEdit.textEdited.connect(
lambda: iv.sanitize_file_name(self.nameLineEdit))
self.nameLineEdit.setEnabled(False)
locale = QLocale.c()
self.minimumScatterAngleDoubleSpinBox.setLocale(locale)
self.minimumMainScatterAngleDoubleSpinBox.setLocale(locale)
self.minimumEnergyDoubleSpinBox.setLocale(locale)
self.__original_property_values = {}
self.set_properties(
name=self.element_simulation.name,
description=self.element_simulation.description,
modification_time=self.element_simulation.modification_time,
**self.element_simulation.get_settings())
if preset_folder is not None:
self.preset_widget = PresetWidget.add_preset_widget(
preset_folder / "simulation",
"sim",
lambda w: self.layout().insertWidget(0, w),
save_callback=self.save_properties_to_file,
load_callback=self.load_properties_from_file)
else:
self.preset_widget = None
def __init__(self, **kwargs):
"""Initialize the widget.
Args:
kwargs: property values to be shown in the widget.
"""
ui_file = gutils.get_ui_dir() / "ui_optimization_recoil_params.ui"
super().__init__(ui_file, **kwargs)
locale = QLocale.c()
self.upperXDoubleSpinBox.setLocale(locale)
self.lowerXDoubleSpinBox.setLocale(locale)
self.upperYDoubleSpinBox.setLocale(locale)
self.lowerYDoubleSpinBox.setLocale(locale)
def __init__(self, foil):
"""
Initializes the foil widget.
Args:
foil: foil object
"""
super().__init__()
uic.loadUi(gutils.get_ui_dir() / "ui_foil_widget.ui", self)
locale = QLocale.c()
self.distanceDoubleSpinBox.setLocale(locale)
self.deleteButton.clicked.connect(self._delete_foil)
self.name = foil.name
self.distance_from_previous = 0
self.cumulative_distance = foil.distance
def __init__(self, ui_file, **kwargs):
"""Initializes a optimization parameter widget.
Args:
ui_file: relative path to a ui_file
kwargs: values to show in the widget
"""
super().__init__()
uic.loadUi(ui_file, self)
locale = QLocale.c()
self.crossoverProbDoubleSpinBox.setLocale(locale)
self.mutationProbDoubleSpinBox.setLocale(locale)
self.percentDoubleSpinBox.setLocale(locale)
self.skip_sim_chk_box.stateChanged.connect(self.enable_sim_params)
self.set_properties(**kwargs)
def main():
import sys
from PyQt5.QtWidgets import QApplication
from PyQt5.QtCore import Qt, QLocale
from .gui.main import MainWindow
from silx.resources import register_resource_directory
register_resource_directory('crispy', 'crispy.resources')
QLocale.setDefault(QLocale.c())
app = QApplication(sys.argv)
window = MainWindow()
window.show()
app.setAttribute(Qt.AA_UseHighDpiPixmaps)
sys.exit(app.exec_())
def __init__(self,
main_recoil: RecoilElement,
low: Optional[float] = None,
high: Optional[float] = None):
"""
Initializes the dialog.
Args:
main_recoil: Main RecoilElement object.
"""
super().__init__()
uic.loadUi(gutils.get_ui_dir() / "ui_multiply_area_dialog.ui", self)
self.main_recoil = main_recoil
locale = QLocale.c()
self.fractionDoubleSpinBox.setLocale(locale)
self.cancelButton.clicked.connect(self.close)
self.okButton.clicked.connect(self.ok_pressed)
self.fractionCheckBox.stateChanged.connect(self.change_custom)
self.fractionDoubleSpinBox.valueChanged.connect(
self.calculate_new_area)
self.main_area = self.main_recoil.calculate_area(start=low, end=high)
text = str(round(self.main_area, 2))
self.mainAreaLabel.setText(text)
self.totalAreaLabel.setText(text)
self.new_area = self.main_area
self.reference_area = self.main_area
self.fraction = None
self.is_ok = False
self.exec_()
def __init__(self, tab, layer=None, modify=False, simulation=None,
first_layer=False):
"""Inits a layer dialog.
Args:
tab: A SimulationTabWidget
layer: Layer object to be modified. None if creating a new layer.
modify: If dialog is used to modify a layer.
simulation: A Simulation object.
first_layer: Whether the dialog is used to add the first layer.
"""
super().__init__()
uic.loadUi(gutils.get_ui_dir() / "ui_layer_dialog.ui", self)
self.tab = tab
self.layer = layer
self.ok_pressed = False
self.simulation = simulation
self.amount_mismatch = True
self.fields_are_valid = True
iv.set_input_field_red(self.nameEdit)
self.nameEdit.textChanged.connect(
lambda: iv.check_text(self.nameEdit, self))
self.nameEdit.textEdited.connect(
lambda: iv.sanitize_file_name(self.nameEdit))
# Connect buttons to events
self.addElementButton.clicked.connect(self.__add_element_layout)
self.okButton.clicked.connect(self.__save_layer)
self.cancelButton.clicked.connect(self.close)
self.thicknessEdit.setMinimum(0.01)
self.densityEdit.setMinimum(0.01)
self.__original_properties = {}
if self.layer:
self.__show_layer_info()
else:
self.__add_element_layout()
if first_layer:
self.groupBox_2.hide()
self.__close = True
self.thicknessEdit.setLocale(QLocale.c())
self.densityEdit.setLocale(QLocale.c())
if modify:
self.groupBox_2.hide()
self.placement_under = True
if platform.system() == "Darwin":
self.setMinimumWidth(450)
if platform.system() == "Linux":
self.setMinimumWidth(470)
self.exec_()
def fix_locale():
"""
Fix for issues with locale-bound number handling, we basically force decimals to use '.' rather than ','
"""
from PyQt5.QtCore import QLocale
QLocale.setDefault(QLocale.c())
def __init__(self,
obj: Detector,
request: Request,
icon_manager,
run=None):
"""Initializes a DetectorSettingsWidget object.
Args:
obj: a Detector object.
request: Which request it belongs to.
icon_manager: IconManager object.
run: Run object. None if detector is default detector.
"""
super().__init__()
uic.loadUi(gutils.get_ui_dir() / "ui_request_detector_settings.ui",
self)
self.obj = obj
self.request = request
self.icon_manager = icon_manager
self.run = run
self.__original_properties = {}
# Temporary foils list which holds all the information given in the
# foil dialog
# If user presses ok or apply, these values will be saved into
# request's default detector
self.tmp_foil_info = []
# List of foil indexes that are timing foils
self.tof_foils = []
# Add foil widgets and foil objects
self.detector_structure_widgets = []
self.foils_layout = self._add_default_foils(self.obj)
self.detectorScrollAreaContents.layout().addLayout(self.foils_layout)
self.newFoilButton.clicked.connect(
lambda: self._add_new_foil(self.foils_layout))
self.addEfficiencyButton.clicked.connect(self.__add_efficiency)
self.removeEfficiencyButton.clicked.connect(self.__remove_efficiency)
self.plotEfficiencyButton.clicked.connect(self.__plot_efficiency)
self.efficiencyListWidget.itemSelectionChanged.connect(
self._enable_remove_btn)
self._enable_remove_btn()
# Calibration settings
# TODO: Require saving affected cuts if beam setting has been changed
self.executeCalibrationButton.clicked.connect(
self.__open_calibration_dialog)
self.executeCalibrationButton.setEnabled(
not self.request.samples.measurements.is_empty())
gutils.fill_combobox(self.typeComboBox, DetectorType)
self.fields_are_valid = False
iv.set_input_field_red(self.nameLineEdit)
self.nameLineEdit.textChanged.connect(
lambda: iv.check_text(self.nameLineEdit, qwidget=self))
self.nameLineEdit.textEdited.connect(
lambda: iv.sanitize_file_name(self.nameLineEdit))
self.nameLineEdit.setEnabled(False)
locale = QLocale.c()
self.timeResSpinBox.setLocale(locale)
self.virtualSizeXSpinBox.setLocale(locale)
self.virtualSizeYSpinBox.setLocale(locale)
self.angleSlopeLineEdit.setLocale(locale)
self.angleOffsetLineEdit.setLocale(locale)
# Create scientific spinboxes for tof slope and tof offset
self.formLayout_2.removeRow(self.slopeLineEdit)
self.formLayout_2.removeRow(self.offsetLineEdit)
self.scientific_tof_slope = ScientificSpinBox(minimum=-math.inf,
maximum=math.inf)
self.scientific_tof_offset = ScientificSpinBox(minimum=-math.inf,
maximum=math.inf)
self.formLayout_2.insertRow(0, "ToF slope [s/channel]:",
self.scientific_tof_slope)
self.formLayout_2.insertRow(1, "ToF offset[s]:",
self.scientific_tof_offset)
if platform.system() == "Darwin":
self.scientific_tof_offset.scientificLineEdit.setFixedWidth(170)
self.scientific_tof_slope.scientificLineEdit.setFixedWidth(170)
# Save as and load
self.saveButton.clicked.connect(self.__save_file)
self.loadButton.clicked.connect(self.__load_file)
self.show_settings()
def __init__(self, obj: Union[Measurement, Simulation], preset_folder=None):
"""Initializes the widget.
Args:
obj: object that uses these settings, either a Measurement or a
Simulation.
"""
super().__init__()
uic.loadUi(gutils.get_ui_dir() / "ui_measurement_settings_tab.ui", self)
self.fluenceDoubleSpinBox = ScientificSpinBox()
image = gf.get_root_dir() / "images" / "measurement_setup_angles.png"
pixmap = QtGui.QPixmap(str(image))
self.picture.setScaledContents(True)
self.picture.setPixmap(pixmap)
self.obj = obj
self.__original_property_values = {}
locale = QLocale.c()
self.energyDoubleSpinBox.setLocale(locale)
self.energyDistDoubleSpinBox.setLocale(locale)
self.spotSizeXdoubleSpinBox.setLocale(locale)
self.spotSizeYdoubleSpinBox.setLocale(locale)
self.divergenceDoubleSpinBox.setLocale(locale)
self.currentDoubleSpinBox.setLocale(locale)
self.timeDoubleSpinBox.setLocale(locale)
self.runChargeDoubleSpinBox.setLocale(locale)
self.targetThetaDoubleSpinBox.setLocale(locale)
self.detectorThetaDoubleSpinBox.setLocale(locale)
self.detectorFiiDoubleSpinBox.setLocale(locale)
self.targetFiiDoubleSpinBox.setLocale(locale)
# Fii angles are currently not used so disable their spin boxes
self.detectorFiiDoubleSpinBox.setEnabled(False)
self.targetFiiDoubleSpinBox.setEnabled(False)
gutils.fill_combobox(self.profileComboBox, Profile)
# Copy of measurement's/simulation's run or default run
# TODO should default run also be copied?
if not self.obj.run:
self.tmp_run = self.obj.request.default_run
else:
self.tmp_run = copy.deepcopy(self.obj.run)
self.isotopeInfoLabel.setVisible(False)
self.beamIonButton.clicked.connect(self.change_element)
self.fields_are_valid = False
iv.set_input_field_red(self.nameLineEdit)
self.nameLineEdit.textChanged.connect(
lambda: iv.check_text(self.nameLineEdit, qwidget=self))
self.nameLineEdit.textEdited.connect(self.__validate)
self.nameLineEdit.setEnabled(False)
self.run_form_layout: QtWidgets.QFormLayout
self.run_form_layout.insertRow(3, "Fluence", self.fluenceDoubleSpinBox)
self.fluenceDoubleSpinBox.scientificLineEdit.setContextMenuPolicy(
Qt.ActionsContextMenu)
self.actionMultiply = QtWidgets.QAction(
self.fluenceDoubleSpinBox.scientificLineEdit)
self.actionMultiply.triggered.connect(self.__multiply_fluence)
self.fluenceDoubleSpinBox.scientificLineEdit.addAction(
self.actionMultiply)
self.actionUndo = QtWidgets.QAction(
self.fluenceDoubleSpinBox.scientificLineEdit)
self.actionUndo.setText("Undo multiply")
self.actionUndo.triggered.connect(self.__undo_fluence)
self.actionUndo.setEnabled(bool(self.tmp_run.previous_fluence))
self.fluenceDoubleSpinBox.scientificLineEdit.addAction(self.actionUndo)
self.clipboard = QGuiApplication.clipboard()
self._ratio = None
self.clipboard.changed.connect(self.__update_multiply_action)
self.__update_multiply_action()
self.energyDoubleSpinBox.setToolTip("Energy set in MeV with.")
if preset_folder is not None:
self.preset_widget = PresetWidget.add_preset_widget(
preset_folder / "measurement", "mea",
lambda w: self.layout().insertWidget(0, w),
save_callback=self.save_properties_to_file,
load_callback=self.load_properties_from_file
)
else:
self.preset_widget = None
self.show_settings()
def showDialog(self):
# Initialise the setup directory empty toavoid exceptions.
self.setupDictionary = {}
# ask for a project directory.
self.projectDirectory = QFileDialog.getExistingDirectory(
caption=i18n("Where should the comic project go?"),
options=QFileDialog.ShowDirsOnly)
if os.path.exists(self.projectDirectory) is False:
return
self.pagesDirectory = os.path.relpath(self.projectDirectory,
self.projectDirectory)
self.exportDirectory = os.path.relpath(self.projectDirectory,
self.projectDirectory)
wizard = QWizard()
wizard.setWindowTitle(i18n("Comic Project Setup"))
wizard.setOption(QWizard.IndependentPages, True)
# Set up the UI for the wizard
basicsPage = QWizardPage()
basicsPage.setTitle(i18n("Basic Comic Project Settings"))
formLayout = QFormLayout()
basicsPage.setLayout(formLayout)
projectLayout = QHBoxLayout()
self.lnProjectName = QLineEdit()
basicsPage.registerField("Project Name*", self.lnProjectName)
self.lnProjectName.setToolTip(
i18n(
"A Project name. This can be different from the eventual title"
))
btnRandom = QPushButton()
btnRandom.setText(i18n("Generate"))
btnRandom.setToolTip(
i18n(
"If you cannot come up with a project name, our highly sophisticated project name generator will serve to give a classy yet down to earth name."
))
btnRandom.clicked.connect(self.slot_generate)
projectLayout.addWidget(self.lnProjectName)
projectLayout.addWidget(btnRandom)
lnConcept = QLineEdit()
lnConcept.setToolTip(
i18n(
"What is your comic about? This is mostly for your own convenience so don't worry about what it says too much."
))
self.cmbLanguage = comics_metadata_dialog.language_combo_box()
self.cmbLanguage.setToolTip(i18n("The main language the comic is in"))
self.cmbLanguage.setEntryToCode(
str(QLocale.system().name()).split("_")[0])
self.cmbCountry = comics_metadata_dialog.country_combo_box()
if QLocale.system() != QLocale.c():
self.cmbCountry.setEntryToCode(
str(QLocale.system().name()).split("_")[-1])
else:
self.slot_update_countries()
self.cmbLanguage.currentIndexChanged.connect(
self.slot_update_countries)
self.lnProjectDirectory = QLabel(self.projectDirectory)
self.chkMakeProjectDirectory = QCheckBox()
labelDirectory = QLabel(
i18n("Make a new directory with the project name."))
labelDirectory.setWordWrap(True)
stringDirectoryTooltip = i18n(
"This allows you to select a generic comics project directory, in which a new folder will be made for the project using the given project name."
)
self.chkMakeProjectDirectory.setToolTip(stringDirectoryTooltip)
labelDirectory.setToolTip(stringDirectoryTooltip)
self.chkMakeProjectDirectory.setChecked(True)
self.lnPagesDirectory = QLineEdit()
self.lnPagesDirectory.setText(i18n("pages"))
self.lnPagesDirectory.setToolTip(
i18n(
"The name for the folder where the pages are contained. If it doesn't exist, it will be created."
))
self.lnExportDirectory = QLineEdit()
self.lnExportDirectory.setText(i18n("export"))
self.lnExportDirectory.setToolTip(
i18n(
"The name for the folder where the export is put. If it doesn't exist, it will be created."
))
self.lnTemplateLocation = QLineEdit()
self.lnTemplateLocation.setText(i18n("templates"))
self.lnTemplateLocation.setToolTip(
i18n(
"The name for the folder where the page templates are sought in."
))
self.lnTranslationLocation = QLineEdit()
self.lnTranslationLocation.setText(i18n("translations"))
self.lnTranslationLocation.setToolTip(
"This is the location that POT files will be stored to and PO files will be read from."
)
formLayout.addRow(i18n("Comic Concept:"), lnConcept)
formLayout.addRow(i18n("Project Name:"), projectLayout)
formLayout.addRow(i18n("Main Language:"), self.cmbLanguage)
formLayout.addRow("", self.cmbCountry)
buttonMetaData = QPushButton(i18n("Meta Data"))
buttonMetaData.clicked.connect(self.slot_edit_meta_data)
wizard.addPage(basicsPage)
foldersPage = QWizardPage()
foldersPage.setTitle(i18n("Folder names and other."))
folderFormLayout = QFormLayout()
foldersPage.setLayout(folderFormLayout)
folderFormLayout.addRow(i18n("Project Directory:"),
self.lnProjectDirectory)
folderFormLayout.addRow(self.chkMakeProjectDirectory, labelDirectory)
folderFormLayout.addRow(i18n("Pages Directory"), self.lnPagesDirectory)
folderFormLayout.addRow(i18n("Export Directory"),
self.lnExportDirectory)
folderFormLayout.addRow(i18n("Template Directory"),
self.lnTemplateLocation)
folderFormLayout.addRow(i18n("Translation Directory"),
self.lnTranslationLocation)
folderFormLayout.addRow("", buttonMetaData)
wizard.addPage(foldersPage)
# Execute the wizard, and after wards...
if (wizard.exec_()):
# First get the directories, check if the directories exist, and otherwise make them.
self.pagesDirectory = self.lnPagesDirectory.text()
self.exportDirectory = self.lnExportDirectory.text()
self.templateLocation = self.lnTemplateLocation.text()
self.translationLocation = self.lnTranslationLocation.text()
projectPath = Path(self.projectDirectory)
# Only make a project directory if the checkbox for that has been checked.
if self.chkMakeProjectDirectory.isChecked():
projectPath = projectPath / self.lnProjectName.text()
if projectPath.exists() is False:
projectPath.mkdir()
self.projectDirectory = str(projectPath)
if Path(projectPath / self.pagesDirectory).exists() is False:
Path(projectPath / self.pagesDirectory).mkdir()
if Path(projectPath / self.exportDirectory).exists() is False:
Path(projectPath / self.exportDirectory).mkdir()
if Path(projectPath / self.templateLocation).exists() is False:
Path(projectPath / self.templateLocation).mkdir()
if Path(projectPath / self.translationLocation).exists() is False:
Path(projectPath / self.translationLocation).mkdir()
# Then store the information into the setup diactionary.
self.setupDictionary["projectName"] = self.lnProjectName.text()
self.setupDictionary["concept"] = lnConcept.text()
self.setupDictionary["language"] = str(
self.cmbLanguage.codeForCurrentEntry())
self.setupDictionary["pagesLocation"] = self.pagesDirectory
self.setupDictionary["exportLocation"] = self.exportDirectory
self.setupDictionary["templateLocation"] = self.templateLocation
self.setupDictionary[
"translationLocation"] = self.translationLocation
# Finally, write the dictionary into the json file.
self.writeConfig()
def __init__(self,
parent: BaseTab,
spectrum_type: str = _MESU,
element_simulation: Optional[ElementSimulation] = None,
simulation: Optional[Simulation] = None,
measurement: Optional[Measurement] = None,
recoil_widget=None,
statusbar: Optional[QtWidgets.QStatusBar] = None,
spectra_changed=None):
"""Inits energy spectrum dialog.
Args:
parent: A TabWidget.
spectrum_type: Whether spectrum is for measurement of simulation.
element_simulation: ElementSimulation object.
recoil_widget: RecoilElement widget.
statusbar: QStatusBar
spectra_changed: pyQtSignal that is emitted when recoil atom
distribution is changed.
"""
super().__init__()
uic.loadUi(gutils.get_ui_dir() / "ui_energy_spectrum_params.ui", self)
self.parent = parent
if spectrum_type == EnergySpectrumWidget.MEASUREMENT:
if measurement is None:
raise ValueError(
f"Must provide a Measurement when spectrum type is "
f"{spectrum_type}")
elif spectrum_type is EnergySpectrumWidget.SIMULATION:
if simulation is None:
raise ValueError(
f"Must provide a Simulation when spectrum type is "
f"{spectrum_type}")
if element_simulation is None:
raise ValueError(
f"Must provide an ElementSimulation when spectrum is "
f"{spectrum_type}")
else:
raise ValueError(f"Unexpected spectrum type: {spectrum_type}")
self.spectrum_type = spectrum_type
self.measurement = measurement
self.simulation = simulation
self.element_simulation = element_simulation
self.statusbar = statusbar
self.result_files = []
self.use_eff_checkbox.stateChanged.connect(
lambda *_: self.label_efficiency_files.setEnabled(self.
use_efficiency))
self.use_efficiency = True
locale = QLocale.c()
self.histogramTicksDoubleSpinBox.setLocale(locale)
# Connect buttons
self.pushButton_Cancel.clicked.connect(self.close)
self.external_tree_widget = QtWidgets.QTreeWidget()
if self.spectrum_type == EnergySpectrumWidget.MEASUREMENT:
EnergySpectrumParamsDialog.bin_width = \
self.measurement.profile.channel_width
self.pushButton_OK.clicked.connect(
lambda: self.__accept_params(spectra_changed=spectra_changed))
m_name = self.measurement.name
if m_name not in EnergySpectrumParamsDialog.checked_cuts:
EnergySpectrumParamsDialog.checked_cuts[m_name] = set()
gutils.fill_cuts_treewidget(self.measurement,
self.treeWidget.invisibleRootItem(),
use_elemloss=True)
self.measurement_cuts = \
EnergySpectrumParamsDialog.checked_cuts[m_name]
self.importPushButton.setVisible(False)
else:
EnergySpectrumParamsDialog.bin_width = \
self.element_simulation.channel_width
self._set_simulation_files(recoil_widget)
self._set_measurement_files()
self._set_external_files()
# Change the bin width label text
self.histogramTicksLabel.setText(
"Simulation and measurement histogram bin width:")
self.pushButton_OK.clicked.connect(
self.__calculate_selected_spectra)
self.importPushButton.clicked.connect(self.__import_external_file)
self.used_bin_width = EnergySpectrumParamsDialog.bin_width
# FIXME .eff files not shown in sim mode
self.__update_eff_files()
self.exec_()
def __init__(self,
parent,
element_simulation: ElementSimulation,
target: Target,
ct: Optional[CancellationToken] = None):
super().__init__(parent)
self.parent = parent
self.element_simulation = element_simulation
self.target = target
self.locale = QLocale.c()
self.trans = matplotlib.transforms.blended_transform_factory(
self.axes.transData, self.axes.transAxes)
self.layer_colors = [(0.9, 0.9, 0.9), (0.85, 0.85, 0.85)]
self.axes.format_coord = mpl_utils.format_coord
self.current_recoil: Optional[RecoilElement] = None
self.radios = QtWidgets.QButtonGroup(self)
self.radios.buttonToggled[QtWidgets.QAbstractButton,
bool].connect(self.choose_recoil)
widget = QtWidgets.QWidget()
self.recoil_vertical_layout = QtWidgets.QVBoxLayout()
self.recoil_vertical_layout.setContentsMargins(0, 0, 0, 0)
widget.setLayout(self.recoil_vertical_layout)
self.parent.recoilListLayout.addWidget(widget)
# TODO move these to parent
btn_txts = "First solution", "Median solution", "Last solution"
for t in btn_txts:
radio_btn = QtWidgets.QRadioButton(t)
radio_btn.setEnabled(False)
self.radios.addButton(radio_btn)
self.recoil_vertical_layout.addWidget(radio_btn)
self.move_results_btn = QtWidgets.QPushButton("Accept results")
self.move_results_btn.setToolTip(
"Moves optimization results to recoil "
"atom distribution view")
self.move_results_btn.setEnabled(False)
self.move_results_btn.clicked.connect(self._move_results)
self.recoil_vertical_layout.addWidget(self.move_results_btn)
self.stop_optim_btn = QtWidgets.QPushButton("Stop optimization")
self.stop_optim_btn.setToolTip("Stops optimization after current "
"generation has been evaluated.")
self.stop_optim_btn.setEnabled(True)
self.stop_optim_btn.clicked.connect(self._stop_optim)
self.recoil_vertical_layout.addWidget(self.stop_optim_btn)
self.cancellation_token = ct
spacer = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Expanding)
self.recoil_vertical_layout.addItem(spacer)
# A dictionary where keys are recoil elements and values are line
# objects
self.lines = {}
self.selected_line = None
self.highlighted_marker = None
self.coordinates_widget = None
self.coordinates_action = None
# This customizes the toolbar buttons
self.__fork_toolbar_buttons()
self.name_y_axis = "Relative Concentration"
self.name_x_axis = "Depth [nm]"
self.canvas.mpl_connect('button_press_event', self.on_click)
self.on_draw()
if self.element_simulation.optimization_recoils:
self.show_recoils()
from backend.barista.utils.settings import applicationQSetting
from backend.caffe import path_loader
from gui.start_dialog import StartDialog
from PyQt5.QtWidgets import QApplication
from gui.caffepath_dialog import CaffepathDialog
from backend.networking.barista_server import BaristaServer
import threading
import subprocess
if __name__ == "__main__":
logging.basicConfig(
format='[%(asctime)s] %(levelname)s @ %(funcName)s: %(message)s',
datefmt='%d/%m/%Y %H:%M:%S',
filename="baristalog.txt",
level=logging.INFO)
QLocale.setDefault(QLocale.c())
# Parse command line arguments.
parser = argparse.ArgumentParser()
parser.add_argument(
'-s',
'--server',
help='start a local server and add it to the host manager',
default=False,
action='store_true')
parser.add_argument('-d',
'--dir',
help='local directory to run server sessions in',
type=str,
default='.')
parser.add_argument('-o',
'--open',
