feat: integrate usual settings completely

src/controller.py

@@ -118,24 +118,8 @@ def _connect_signals(self):
         self.view.setts.get_element("printer_path", "add_btn").clicked.connect(
             self.create_printer
         )
-        self.view.printer_path_edit.clicked.connect(self.choose_printer_path)
-        self.view.number_wall_lines_value.textChanged.connect(
-            self.update_wall_thickness
-        )
-        self.view.line_width_value.textChanged.connect(self.update_wall_thickness)
-        self.view.layer_height_value.textChanged.connect(self.change_layer_height)
-        self.view.number_of_bottom_layers_value.textChanged.connect(
-            self.update_bottom_thickness
-        )
-        self.view.number_of_lid_layers_value.textChanged.connect(
-            self.update_lid_thickness
-        )
-        self.view.supports_number_of_bottom_layers_value.textChanged.connect(
-            self.update_supports_bottom_thickness
-        )
-        self.view.supports_number_of_lid_layers_value.textChanged.connect(
-            self.update_supports_lid_thickness
-        )
+        self.view.setts.edit("printer_path").clicked.connect(self.choose_printer_path)
+
         self.view.model_switch_box.stateChanged.connect(self.view.switch_stl_gcode)
         self.view.model_centering_box.stateChanged.connect(self.view.model_centering)
         self.view.picture_slider.valueChanged.connect(self.change_layer_view)
@@ -676,10 +660,10 @@ def save_settings(self, slicing_type, filename=""):
         if self.view.stlActor is not None:
             tf = self.view.stlActor.GetUserTransform()
         s.uninterrupted_print.enabled = bool(
-            self.view.uninterrupted_print_box.isChecked()
+            self.view.setts.checkbox("uninterrupted_print").isChecked()
         )
         s.uninterrupted_print.cut_distance = float(
-            self.view.m10_cut_distance_value.text()
+            self.view.setts.edit("m10_cut_distance").text()
         )
         s.slicing.originx, s.slicing.originy, s.slicing.originz = tf.GetPosition()
         (
@@ -688,57 +672,77 @@ def save_settings(self, slicing_type, filename=""):
             s.slicing.rotationz,
         ) = tf.GetOrientation()
         s.slicing.scalex, s.slicing.scaley, s.slicing.scalez = tf.GetScale()
-        s.slicing.layer_height = float(self.view.layer_height_value.text())
-        s.slicing.print_speed = float(self.view.print_speed_value.text())
-        s.slicing.print_speed_layer1 = float(self.view.print_speed_layer1_value.text())
-        s.slicing.print_speed_wall = float(self.view.print_speed_wall_value.text())
-        s.slicing.extruder_temperature = float(self.view.extruder_temp_value.text())
-        s.slicing.bed_temperature = float(self.view.bed_temp_value.text())
-        s.slicing.fill_density = float(self.view.fill_density_value.text())
-        s.slicing.wall_thickness = float(self.view.wall_thickness_value.text())
-        s.slicing.line_width = float(self.view.line_width_value.text())
+        s.slicing.layer_height = float(self.view.setts.edit("layer_height").text())
+        s.slicing.print_speed = float(self.view.setts.edit("print_speed").text())
+        s.slicing.print_speed_layer1 = float(
+            self.view.setts.edit("print_speed_layer1").text()
+        )
+        s.slicing.print_speed_wall = float(
+            self.view.setts.edit("print_speed_wall").text()
+        )
+        s.slicing.extruder_temperature = float(
+            self.view.setts.edit("extruder_temp").text()
+        )
+        s.slicing.bed_temperature = float(self.view.setts.edit("bed_temp").text())
+        s.slicing.fill_density = float(self.view.setts.edit("fill_density").text())
+        s.slicing.wall_thickness = float(
+            self.view.setts.get_element(
+                "number_wall_lines", "wall_thickness_value"
+            ).text()
+        )
+        s.slicing.line_width = float(self.view.setts.edit("line_width").text())
         s.slicing.filling_type = locales.getLocaleByLang("en").FillingTypeValues[
-            self.view.filling_type_values.currentIndex()
+            self.view.setts.values("filling_type").currentIndex()
         ]
-        s.slicing.retraction_on = self.view.retraction_on_box.isChecked()
+        s.slicing.retraction_on = self.view.setts.checkbox("retraction_on").isChecked()
         s.slicing.retraction_distance = float(
-            self.view.retraction_distance_value.text()
+            self.view.setts.edit("retraction_distance").text()
+        )
+        s.slicing.retraction_speed = float(
+            self.view.setts.edit("retraction_speed").text()
         )
-        s.slicing.retraction_speed = float(self.view.retraction_speed_value.text())
         s.slicing.retract_compensation_amount = float(
-            self.view.retract_compensation_amount_value.text()
+            self.view.setts.edit("retraction_compensation").text()
         )
-        s.slicing.skirt_line_count = int(self.view.skirt_line_count_value.text())
-        s.slicing.fan_off_layer1 = self.view.fan_off_layer1_box.isChecked()
-        s.slicing.fan_speed = float(self.view.fan_speed_value.text())
+        s.slicing.skirt_line_count = int(
+            self.view.setts.edit("skirt_line_count").text()
+        )
+        s.slicing.fan_off_layer1 = self.view.setts.checkbox(
+            "fan_off_layer1"
+        ).isChecked()
+        s.slicing.fan_speed = float(self.view.setts.edit("fan_speed").text())
         s.slicing.angle = float(self.view.colorize_angle_value.text())
 
-        s.slicing.lids_depth = int(self.view.number_of_lid_layers_value.text())
-        s.slicing.bottoms_depth = int(self.view.number_of_bottom_layers_value.text())
+        s.slicing.lids_depth = int(self.view.setts.edit("number_of_lids_layers").text())
+        s.slicing.bottoms_depth = int(
+            self.view.setts.edit("number_of_bottom_layers").text()
+        )
 
-        s.supports.enabled = self.view.supports_on_box.isChecked()
-        s.supports.xy_offset = float(self.view.support_xy_offset_value.text())
+        s.supports.enabled = self.view.setts.checkbox("supports_on").isChecked()
+        s.supports.xy_offset = float(self.view.setts.edit("support_xy_offset").text())
         s.supports.z_offset_layers = int(
-            float(self.view.support_z_offset_layers_value.text())
+            float(self.view.setts.edit("support_z_offset").text())
         )
-        s.supports.fill_density = float(self.view.support_density_value.text())
+        s.supports.fill_density = float(self.view.setts.edit("support_density").text())
         s.supports.fill_type = locales.getLocaleByLang("en").FillingTypeValues[
-            self.view.support_fill_type_values.currentIndex()
+            self.view.setts.values("support_fill_type").currentIndex()
         ]
         s.supports.priority_z_offset = bool(
-            self.view.support_priority_z_offset_box.isChecked()
+            self.view.setts.checkbox("support_priority_zoffset").isChecked()
         )
         s.supports.lids_depth = int(
-            self.view.supports_number_of_lid_layers_value.text()
+            self.view.setts.edit("support_number_of_lid_layers").text()
         )
         s.supports.bottoms_depth = int(
-            self.view.supports_number_of_bottom_layers_value.text()
+            self.view.setts.edit("support_number_of_bottom_layers").text()
         )
 
         s.slicing.overlapping_infill_percentage = float(
-            self.view.overlapping_infill_value.text()
+            self.view.setts.edit("overlap_infill").text()
+        )
+        s.slicing.material_shrinkage = float(
+            self.view.setts.edit("material_shrinkage").text()
         )
-        s.slicing.material_shrinkage = float(self.view.material_shrinkage_value.text())
 
         s.slicing.slicing_type = slicing_type
 

src/settings_widget.py

@@ -110,24 +110,29 @@ def checkbox(self, name: str):
         """
         Return checkbox element associated with the given name
         """
-        assert name in self.__elements, f"There is no checkbox for {name}"
+        if name not in self.__elements:
+            raise KeyError(f"There is no checkbox for {name}")
 
         return self.__elements[name]["checkbox"]
 
     def values(self, name: str):
         """
         Return combobox element associated with the given name
         """
-        assert name in self.__elements, f"There is no combobox for {name}"
+        if name not in self.__elements:
+            raise KeyError(f"There is no combobox for {name}")
 
         return self.__elements[name]["values"]
 
     def get_element(self, name: str, key: str):
         """
         Return element associated with the given name and key
         """
-        assert name in self.__elements, f"There is no element for {name}"
-        assert key in self.__elements[name], f"There is no element for {key}"
+        if name not in self.__elements:
+            raise KeyError(f"There is no element for {name}")
+
+        if key not in self.__elements[name]:
+            raise KeyError(f"There is no element for {key}")
 
         return self.__elements[name][key]
 
@@ -136,6 +141,19 @@ def with_all(self):
             self.with_sett(param)
         return self
 
+    def update_dependent_fields(self, entry_field_1, entry_field_2, output_field):
+        entry_field_1_text = entry_field_1.text().replace(",", ".")
+        entry_field_2_text = entry_field_2.text().replace(",", ".")
+
+        if ((not entry_field_1_text) or entry_field_1_text == ".") or (
+            (not entry_field_2_text) or entry_field_2_text == "."
+        ):
+            output_field.setText("0.0")
+        else:
+            output_field.setText(
+                str(round(float(entry_field_1_text) * float(entry_field_2_text), 2))
+            )
+
     def with_sett(self, name: str):
         # we match the given name with each setting and add it to the layout
         match name:
@@ -244,6 +262,7 @@ def on_uninterrupted_print_change():
                 line_width_value = QLineEdit()
                 line_width_value.setText(str(self.sett().slicing.line_width))
                 line_width_value.setValidator(self.doubleValidator)
+                line_width_value.textChanged.connect(self.__update_wall_thickness)
                 self.panel.addWidget(line_width, self.next_row, 1)
                 self.panel.addWidget(
                     line_width_value, self.cur_row, 2, 1, self.col2_cells
@@ -259,6 +278,7 @@ def on_uninterrupted_print_change():
                 layer_height_value = QLineEdit()
                 layer_height_value.setText(str(self.sett().slicing.layer_height))
                 layer_height_value.setValidator(self.doubleValidator)
+                layer_height_value.textChanged.connect(self.__change_layer_height)
                 self.panel.addWidget(layer_height, self.next_row, 1)
                 self.panel.addWidget(
                     layer_height_value, self.cur_row, 2, 1, self.col2_cells
@@ -282,6 +302,10 @@ def on_uninterrupted_print_change():
                 number_wall_lines_value = LineEdit(str(number_wall_lines_value))
                 number_wall_lines_value.setValidator(self.intValidator)
 
+                number_wall_lines_value.textChanged.connect(
+                    self.__update_wall_thickness
+                )
+
                 self.panel.addWidget(number_wall_lines_label, self.next_row, 1)
                 self.panel.addWidget(number_wall_lines_value, self.cur_row, 2)
 
@@ -306,6 +330,10 @@ def on_uninterrupted_print_change():
                     str(self.sett().slicing.bottoms_depth)
                 )
                 number_of_bottom_layers_value.setValidator(self.intValidator)
+                number_of_bottom_layers_value.textChanged.connect(
+                    self.__update_bottom_thickness
+                )
+
                 self.panel.addWidget(number_of_bottom_layers_label, self.next_row, 1)
                 self.panel.addWidget(number_of_bottom_layers_value, self.cur_row, 2)
 
@@ -339,6 +367,10 @@ def on_uninterrupted_print_change():
                     str(self.sett().slicing.lids_depth)
                 )
                 number_of_lids_layers_value.setValidator(self.intValidator)
+                number_of_lids_layers_value.textChanged.connect(
+                    self.__update_lid_thickness
+                )
+
                 self.panel.addWidget(number_of_lids_layers_label, self.next_row, 1)
                 self.panel.addWidget(number_of_lids_layers_value, self.cur_row, 2)
 
@@ -727,6 +759,9 @@ def on_uninterrupted_print_change():
                     str(self.sett().supports.bottoms_depth)
                 )
                 support_number_of_bottom_layers_value.setValidator(self.intValidator)
+                support_number_of_bottom_layers_value.textChanged.connect(
+                    self.__update_supports_bottom_thickness
+                )
                 self.panel.addWidget(
                     support_number_of_bottom_layers_label, self.next_row, 1
                 )
@@ -766,6 +801,9 @@ def on_uninterrupted_print_change():
                     str(self.sett().supports.lids_depth)
                 )
                 support_number_of_lid_layers_value.setValidator(self.intValidator)
+                support_number_of_lid_layers_value.textChanged.connect(
+                    self.__update_supports_lid_thickness
+                )
                 self.panel.addWidget(
                     support_number_of_lid_layers_label, self.next_row, 1
                 )
@@ -798,3 +836,70 @@ def on_uninterrupted_print_change():
                 }
 
         return self
+
+    def __update_wall_thickness(self):
+        """Callback to update wall thickness when number of wall lines or line width changes."""
+        try:
+            self.update_dependent_fields(
+                self.edit("number_wall_lines"),
+                self.edit("line_width"),
+                self.get_element("number_wall_lines", "wall_thickness_value"),
+            )
+        except KeyError:
+            pass
+
+    def __update_bottom_thickness(self):
+        """Callback to update bottom thickness when number of bottom layers or layer height changes."""
+        try:
+            self.update_dependent_fields(
+                self.edit("number_of_bottom_layers"),
+                self.edit("layer_height"),
+                self.get_element("number_of_bottom_layers", "bottom_thickness_value"),
+            )
+        except KeyError:
+            pass
+
+    def __update_lid_thickness(self):
+        """Callback to update lid thickness when number of lid layers or layer height changes."""
+        try:
+            self.update_dependent_fields(
+                self.edit("number_of_lids_layers"),
+                self.edit("layer_height"),
+                self.get_element("number_of_lids_layers", "lid_thickness_value"),
+            )
+        except KeyError:
+            pass
+
+    def __update_supports_bottom_thickness(self):
+        """Callback to update bottom thickness when number of bottom layers or layer height changes."""
+        try:
+            self.update_dependent_fields(
+                self.edit("support_number_of_bottom_layers"),
+                self.edit("layer_height"),
+                self.get_element(
+                    "support_number_of_bottom_layers", "bottom_thickness_value"
+                ),
+            )
+        except KeyError:
+            pass
+
+    def __update_supports_lid_thickness(self):
+        """Callback to update lid thickness when number of lid layers or layer height changes."""
+        try:
+            self.update_dependent_fields(
+                self.edit("support_number_of_lid_layers"),
+                self.edit("layer_height"),
+                self.get_element("support_number_of_lid_layers", "lid_thickness_value"),
+            )
+        except KeyError:
+            pass
+
+    def __change_layer_height(self):
+        """Callback to update wall thickness, bottom thickness and lid thickness when layer height changes."""
+        try:
+            self.__update_bottom_thickness()
+            self.__update_lid_thickness()
+            self.__update_supports_bottom_thickness()
+            self.__update_supports_lid_thickness()
+        except KeyError:
+            pass