- working on Isolation Tool: added a Preferences section in Edit -> Preferences and updated their usage within the Isolation tool

AppGUI/preferences/PreferencesUIManager.py

@@ -127,12 +127,6 @@ class PreferencesUIManager:
             "gerber_plot_line": self.ui.gerber_defaults_form.gerber_gen_group.pl_color_entry,
 
             # Gerber Options
-            "gerber_isotooldia": self.ui.gerber_defaults_form.gerber_opt_group.iso_tool_dia_entry,
-            "gerber_isopasses": self.ui.gerber_defaults_form.gerber_opt_group.iso_width_entry,
-            "gerber_isooverlap": self.ui.gerber_defaults_form.gerber_opt_group.iso_overlap_entry,
-            "gerber_combine_passes": self.ui.gerber_defaults_form.gerber_opt_group.combine_passes_cb,
-            "gerber_iso_scope": self.ui.gerber_defaults_form.gerber_opt_group.select_combo,
-            "gerber_milling_type": self.ui.gerber_defaults_form.gerber_opt_group.milling_type_radio,
             "gerber_noncoppermargin": self.ui.gerber_defaults_form.gerber_opt_group.noncopper_margin_entry,
             "gerber_noncopperrounded": self.ui.gerber_defaults_form.gerber_opt_group.noncopper_rounded_cb,
             "gerber_bboxmargin": self.ui.gerber_defaults_form.gerber_opt_group.bbmargin_entry,
@@ -143,12 +137,6 @@ class PreferencesUIManager:
             # "gerber_aperture_scale_factor": self.ui.gerber_defaults_form.gerber_adv_opt_group.scale_aperture_entry,
             # "gerber_aperture_buffer_factor": self.ui.gerber_defaults_form.gerber_adv_opt_group.buffer_aperture_entry,
             "gerber_follow": self.ui.gerber_defaults_form.gerber_adv_opt_group.follow_cb,
-            "gerber_tool_type": self.ui.gerber_defaults_form.gerber_adv_opt_group.tool_type_radio,
-            "gerber_vtipdia": self.ui.gerber_defaults_form.gerber_adv_opt_group.tipdia_spinner,
-            "gerber_vtipangle": self.ui.gerber_defaults_form.gerber_adv_opt_group.tipangle_spinner,
-            "gerber_vcutz": self.ui.gerber_defaults_form.gerber_adv_opt_group.cutz_spinner,
-            "gerber_iso_type": self.ui.gerber_defaults_form.gerber_adv_opt_group.iso_type_radio,
-
             "gerber_buffering": self.ui.gerber_defaults_form.gerber_adv_opt_group.buffering_radio,
             "gerber_simplification": self.ui.gerber_defaults_form.gerber_adv_opt_group.simplify_cb,
             "gerber_simp_tolerance": self.ui.gerber_defaults_form.gerber_adv_opt_group.simplification_tol_spinner,
@@ -221,31 +209,31 @@ class PreferencesUIManager:
             "excellon_gcode_type": self.ui.excellon_defaults_form.excellon_opt_group.excellon_gcode_type_radio,
 
             # Excellon Advanced Options
-            "excellon_offset": self.ui.excellon_defaults_form.excellon_adv_opt_group.offset_entry,
-            "excellon_toolchangexy": self.ui.excellon_defaults_form.excellon_adv_opt_group.toolchangexy_entry,
-            "excellon_startz": self.ui.excellon_defaults_form.excellon_adv_opt_group.estartz_entry,
-            "excellon_feedrate_rapid": self.ui.excellon_defaults_form.excellon_adv_opt_group.feedrate_rapid_entry,
-            "excellon_z_pdepth": self.ui.excellon_defaults_form.excellon_adv_opt_group.pdepth_entry,
-            "excellon_feedrate_probe": self.ui.excellon_defaults_form.excellon_adv_opt_group.feedrate_probe_entry,
-            "excellon_spindledir": self.ui.excellon_defaults_form.excellon_adv_opt_group.spindledir_radio,
-            "excellon_f_plunge": self.ui.excellon_defaults_form.excellon_adv_opt_group.fplunge_cb,
-            "excellon_f_retract": self.ui.excellon_defaults_form.excellon_adv_opt_group.fretract_cb,
+            "excellon_offset":          self.ui.excellon_defaults_form.excellon_adv_opt_group.offset_entry,
+            "excellon_toolchangexy":    self.ui.excellon_defaults_form.excellon_adv_opt_group.toolchangexy_entry,
+            "excellon_startz":          self.ui.excellon_defaults_form.excellon_adv_opt_group.estartz_entry,
+            "excellon_feedrate_rapid":  self.ui.excellon_defaults_form.excellon_adv_opt_group.feedrate_rapid_entry,
+            "excellon_z_pdepth":        self.ui.excellon_defaults_form.excellon_adv_opt_group.pdepth_entry,
+            "excellon_feedrate_probe":  self.ui.excellon_defaults_form.excellon_adv_opt_group.feedrate_probe_entry,
+            "excellon_spindledir":      self.ui.excellon_defaults_form.excellon_adv_opt_group.spindledir_radio,
+            "excellon_f_plunge":        self.ui.excellon_defaults_form.excellon_adv_opt_group.fplunge_cb,
+            "excellon_f_retract":       self.ui.excellon_defaults_form.excellon_adv_opt_group.fretract_cb,
 
             # Excellon Export
-            "excellon_exp_units": self.ui.excellon_defaults_form.excellon_exp_group.excellon_units_radio,
-            "excellon_exp_format": self.ui.excellon_defaults_form.excellon_exp_group.format_radio,
-            "excellon_exp_integer": self.ui.excellon_defaults_form.excellon_exp_group.format_whole_entry,
-            "excellon_exp_decimals": self.ui.excellon_defaults_form.excellon_exp_group.format_dec_entry,
-            "excellon_exp_zeros": self.ui.excellon_defaults_form.excellon_exp_group.zeros_radio,
-            "excellon_exp_slot_type": self.ui.excellon_defaults_form.excellon_exp_group.slot_type_radio,
+            "excellon_exp_units":       self.ui.excellon_defaults_form.excellon_exp_group.excellon_units_radio,
+            "excellon_exp_format":      self.ui.excellon_defaults_form.excellon_exp_group.format_radio,
+            "excellon_exp_integer":     self.ui.excellon_defaults_form.excellon_exp_group.format_whole_entry,
+            "excellon_exp_decimals":    self.ui.excellon_defaults_form.excellon_exp_group.format_dec_entry,
+            "excellon_exp_zeros":       self.ui.excellon_defaults_form.excellon_exp_group.zeros_radio,
+            "excellon_exp_slot_type":   self.ui.excellon_defaults_form.excellon_exp_group.slot_type_radio,
 
             # Excellon Editor
-            "excellon_editor_sel_limit": self.ui.excellon_defaults_form.excellon_editor_group.sel_limit_entry,
-            "excellon_editor_newdia": self.ui.excellon_defaults_form.excellon_editor_group.addtool_entry,
-            "excellon_editor_array_size": self.ui.excellon_defaults_form.excellon_editor_group.drill_array_size_entry,
-            "excellon_editor_lin_dir": self.ui.excellon_defaults_form.excellon_editor_group.drill_axis_radio,
-            "excellon_editor_lin_pitch": self.ui.excellon_defaults_form.excellon_editor_group.drill_pitch_entry,
-            "excellon_editor_lin_angle": self.ui.excellon_defaults_form.excellon_editor_group.drill_angle_entry,
+            "excellon_editor_sel_limit":    self.ui.excellon_defaults_form.excellon_editor_group.sel_limit_entry,
+            "excellon_editor_newdia":       self.ui.excellon_defaults_form.excellon_editor_group.addtool_entry,
+            "excellon_editor_array_size":   self.ui.excellon_defaults_form.excellon_editor_group.drill_array_size_entry,
+            "excellon_editor_lin_dir":      self.ui.excellon_defaults_form.excellon_editor_group.drill_axis_radio,
+            "excellon_editor_lin_pitch":    self.ui.excellon_defaults_form.excellon_editor_group.drill_pitch_entry,
+            "excellon_editor_lin_angle":    self.ui.excellon_defaults_form.excellon_editor_group.drill_angle_entry,
             "excellon_editor_circ_dir": self.ui.excellon_defaults_form.excellon_editor_group.drill_circular_dir_radio,
             "excellon_editor_circ_angle":
                 self.ui.excellon_defaults_form.excellon_editor_group.drill_circular_angle_entry,
@@ -270,94 +258,115 @@ class PreferencesUIManager:
                 self.ui.excellon_defaults_form.excellon_editor_group.slot_array_circular_angle_entry,
 
             # Geometry General
-            "geometry_plot": self.ui.geometry_defaults_form.geometry_gen_group.plot_cb,
-            "geometry_circle_steps": self.ui.geometry_defaults_form.geometry_gen_group.circle_steps_entry,
-            "geometry_cnctooldia": self.ui.geometry_defaults_form.geometry_gen_group.cnctooldia_entry,
-            "geometry_plot_line": self.ui.geometry_defaults_form.geometry_gen_group.line_color_entry,
+            "geometry_plot":            self.ui.geometry_defaults_form.geometry_gen_group.plot_cb,
+            "geometry_circle_steps":    self.ui.geometry_defaults_form.geometry_gen_group.circle_steps_entry,
+            "geometry_cnctooldia":      self.ui.geometry_defaults_form.geometry_gen_group.cnctooldia_entry,
+            "geometry_plot_line":       self.ui.geometry_defaults_form.geometry_gen_group.line_color_entry,
 
             # Geometry Options
-            "geometry_cutz": self.ui.geometry_defaults_form.geometry_opt_group.cutz_entry,
-            "geometry_travelz": self.ui.geometry_defaults_form.geometry_opt_group.travelz_entry,
-            "geometry_feedrate": self.ui.geometry_defaults_form.geometry_opt_group.cncfeedrate_entry,
-            "geometry_feedrate_z": self.ui.geometry_defaults_form.geometry_opt_group.feedrate_z_entry,
-            "geometry_spindlespeed": self.ui.geometry_defaults_form.geometry_opt_group.cncspindlespeed_entry,
-            "geometry_dwell": self.ui.geometry_defaults_form.geometry_opt_group.dwell_cb,
-            "geometry_dwelltime": self.ui.geometry_defaults_form.geometry_opt_group.dwelltime_entry,
-            "geometry_ppname_g": self.ui.geometry_defaults_form.geometry_opt_group.pp_geometry_name_cb,
-            "geometry_toolchange": self.ui.geometry_defaults_form.geometry_opt_group.toolchange_cb,
-            "geometry_toolchangez": self.ui.geometry_defaults_form.geometry_opt_group.toolchangez_entry,
-            "geometry_endz": self.ui.geometry_defaults_form.geometry_opt_group.endz_entry,
-            "geometry_endxy": self.ui.geometry_defaults_form.geometry_opt_group.endxy_entry,
-            "geometry_depthperpass": self.ui.geometry_defaults_form.geometry_opt_group.depthperpass_entry,
-            "geometry_multidepth": self.ui.geometry_defaults_form.geometry_opt_group.multidepth_cb,
+            "geometry_cutz":            self.ui.geometry_defaults_form.geometry_opt_group.cutz_entry,
+            "geometry_travelz":         self.ui.geometry_defaults_form.geometry_opt_group.travelz_entry,
+            "geometry_feedrate":        self.ui.geometry_defaults_form.geometry_opt_group.cncfeedrate_entry,
+            "geometry_feedrate_z":      self.ui.geometry_defaults_form.geometry_opt_group.feedrate_z_entry,
+            "geometry_spindlespeed":    self.ui.geometry_defaults_form.geometry_opt_group.cncspindlespeed_entry,
+            "geometry_dwell":           self.ui.geometry_defaults_form.geometry_opt_group.dwell_cb,
+            "geometry_dwelltime":       self.ui.geometry_defaults_form.geometry_opt_group.dwelltime_entry,
+            "geometry_ppname_g":        self.ui.geometry_defaults_form.geometry_opt_group.pp_geometry_name_cb,
+            "geometry_toolchange":      self.ui.geometry_defaults_form.geometry_opt_group.toolchange_cb,
+            "geometry_toolchangez":     self.ui.geometry_defaults_form.geometry_opt_group.toolchangez_entry,
+            "geometry_endz":            self.ui.geometry_defaults_form.geometry_opt_group.endz_entry,
+            "geometry_endxy":           self.ui.geometry_defaults_form.geometry_opt_group.endxy_entry,
+            "geometry_depthperpass":    self.ui.geometry_defaults_form.geometry_opt_group.depthperpass_entry,
+            "geometry_multidepth":      self.ui.geometry_defaults_form.geometry_opt_group.multidepth_cb,
 
             # Geometry Advanced Options
-            "geometry_toolchangexy": self.ui.geometry_defaults_form.geometry_adv_opt_group.toolchangexy_entry,
-            "geometry_startz": self.ui.geometry_defaults_form.geometry_adv_opt_group.gstartz_entry,
-            "geometry_feedrate_rapid": self.ui.geometry_defaults_form.geometry_adv_opt_group.feedrate_rapid_entry,
-            "geometry_extracut": self.ui.geometry_defaults_form.geometry_adv_opt_group.extracut_cb,
+            "geometry_toolchangexy":    self.ui.geometry_defaults_form.geometry_adv_opt_group.toolchangexy_entry,
+            "geometry_startz":          self.ui.geometry_defaults_form.geometry_adv_opt_group.gstartz_entry,
+            "geometry_feedrate_rapid":  self.ui.geometry_defaults_form.geometry_adv_opt_group.feedrate_rapid_entry,
+            "geometry_extracut":        self.ui.geometry_defaults_form.geometry_adv_opt_group.extracut_cb,
             "geometry_extracut_length": self.ui.geometry_defaults_form.geometry_adv_opt_group.e_cut_entry,
-            "geometry_z_pdepth": self.ui.geometry_defaults_form.geometry_adv_opt_group.pdepth_entry,
-            "geometry_feedrate_probe": self.ui.geometry_defaults_form.geometry_adv_opt_group.feedrate_probe_entry,
-            "geometry_spindledir": self.ui.geometry_defaults_form.geometry_adv_opt_group.spindledir_radio,
-            "geometry_f_plunge": self.ui.geometry_defaults_form.geometry_adv_opt_group.fplunge_cb,
-            "geometry_segx": self.ui.geometry_defaults_form.geometry_adv_opt_group.segx_entry,
-            "geometry_segy": self.ui.geometry_defaults_form.geometry_adv_opt_group.segy_entry,
-            "geometry_area_exclusion": self.ui.geometry_defaults_form.geometry_adv_opt_group.exclusion_cb,
-            "geometry_area_shape": self.ui.geometry_defaults_form.geometry_adv_opt_group.area_shape_radio,
-            "geometry_area_strategy": self.ui.geometry_defaults_form.geometry_adv_opt_group.strategy_radio,
-            "geometry_area_overz": self.ui.geometry_defaults_form.geometry_adv_opt_group.over_z_entry,
+            "geometry_z_pdepth":        self.ui.geometry_defaults_form.geometry_adv_opt_group.pdepth_entry,
+            "geometry_feedrate_probe":  self.ui.geometry_defaults_form.geometry_adv_opt_group.feedrate_probe_entry,
+            "geometry_spindledir":      self.ui.geometry_defaults_form.geometry_adv_opt_group.spindledir_radio,
+            "geometry_f_plunge":        self.ui.geometry_defaults_form.geometry_adv_opt_group.fplunge_cb,
+            "geometry_segx":            self.ui.geometry_defaults_form.geometry_adv_opt_group.segx_entry,
+            "geometry_segy":            self.ui.geometry_defaults_form.geometry_adv_opt_group.segy_entry,
+            "geometry_area_exclusion":  self.ui.geometry_defaults_form.geometry_adv_opt_group.exclusion_cb,
+            "geometry_area_shape":      self.ui.geometry_defaults_form.geometry_adv_opt_group.area_shape_radio,
+            "geometry_area_strategy":   self.ui.geometry_defaults_form.geometry_adv_opt_group.strategy_radio,
+            "geometry_area_overz":      self.ui.geometry_defaults_form.geometry_adv_opt_group.over_z_entry,
 
             # Geometry Editor
-            "geometry_editor_sel_limit": self.ui.geometry_defaults_form.geometry_editor_group.sel_limit_entry,
-            "geometry_editor_milling_type": self.ui.geometry_defaults_form.geometry_editor_group.milling_type_radio,
+            "geometry_editor_sel_limit":        self.ui.geometry_defaults_form.geometry_editor_group.sel_limit_entry,
+            "geometry_editor_milling_type":     self.ui.geometry_defaults_form.geometry_editor_group.milling_type_radio,
 
             # CNCJob General
-            "cncjob_plot": self.ui.cncjob_defaults_form.cncjob_gen_group.plot_cb,
-            "cncjob_plot_kind": self.ui.cncjob_defaults_form.cncjob_gen_group.cncplot_method_radio,
-            "cncjob_annotation": self.ui.cncjob_defaults_form.cncjob_gen_group.annotation_cb,
-
-            "cncjob_tooldia": self.ui.cncjob_defaults_form.cncjob_gen_group.tooldia_entry,
-            "cncjob_coords_type": self.ui.cncjob_defaults_form.cncjob_gen_group.coords_type_radio,
-            "cncjob_coords_decimals": self.ui.cncjob_defaults_form.cncjob_gen_group.coords_dec_entry,
-            "cncjob_fr_decimals": self.ui.cncjob_defaults_form.cncjob_gen_group.fr_dec_entry,
-            "cncjob_steps_per_circle": self.ui.cncjob_defaults_form.cncjob_gen_group.steps_per_circle_entry,
-            "cncjob_line_ending": self.ui.cncjob_defaults_form.cncjob_gen_group.line_ending_cb,
-            "cncjob_plot_line": self.ui.cncjob_defaults_form.cncjob_gen_group.line_color_entry,
-            "cncjob_plot_fill": self.ui.cncjob_defaults_form.cncjob_gen_group.fill_color_entry,
-            "cncjob_travel_line": self.ui.cncjob_defaults_form.cncjob_gen_group.tline_color_entry,
-            "cncjob_travel_fill": self.ui.cncjob_defaults_form.cncjob_gen_group.tfill_color_entry,
+            "cncjob_plot":              self.ui.cncjob_defaults_form.cncjob_gen_group.plot_cb,
+            "cncjob_plot_kind":         self.ui.cncjob_defaults_form.cncjob_gen_group.cncplot_method_radio,
+            "cncjob_annotation":        self.ui.cncjob_defaults_form.cncjob_gen_group.annotation_cb,
+
+            "cncjob_tooldia":           self.ui.cncjob_defaults_form.cncjob_gen_group.tooldia_entry,
+            "cncjob_coords_type":       self.ui.cncjob_defaults_form.cncjob_gen_group.coords_type_radio,
+            "cncjob_coords_decimals":   self.ui.cncjob_defaults_form.cncjob_gen_group.coords_dec_entry,
+            "cncjob_fr_decimals":       self.ui.cncjob_defaults_form.cncjob_gen_group.fr_dec_entry,
+            "cncjob_steps_per_circle":  self.ui.cncjob_defaults_form.cncjob_gen_group.steps_per_circle_entry,
+            "cncjob_line_ending":       self.ui.cncjob_defaults_form.cncjob_gen_group.line_ending_cb,
+            "cncjob_plot_line":         self.ui.cncjob_defaults_form.cncjob_gen_group.line_color_entry,
+            "cncjob_plot_fill":         self.ui.cncjob_defaults_form.cncjob_gen_group.fill_color_entry,
+            "cncjob_travel_line":       self.ui.cncjob_defaults_form.cncjob_gen_group.tline_color_entry,
+            "cncjob_travel_fill":       self.ui.cncjob_defaults_form.cncjob_gen_group.tfill_color_entry,
 
             # CNC Job Options
-            "cncjob_prepend": self.ui.cncjob_defaults_form.cncjob_opt_group.prepend_text,
-            "cncjob_append": self.ui.cncjob_defaults_form.cncjob_opt_group.append_text,
+            "cncjob_prepend":   self.ui.cncjob_defaults_form.cncjob_opt_group.prepend_text,
+            "cncjob_append":    self.ui.cncjob_defaults_form.cncjob_opt_group.append_text,
 
             # CNC Job Advanced Options
-            "cncjob_toolchange_macro": self.ui.cncjob_defaults_form.cncjob_adv_opt_group.toolchange_text,
-            "cncjob_toolchange_macro_enable": self.ui.cncjob_defaults_form.cncjob_adv_opt_group.toolchange_cb,
-            "cncjob_annotation_fontsize": self.ui.cncjob_defaults_form.cncjob_adv_opt_group.annotation_fontsize_sp,
+            "cncjob_toolchange_macro":          self.ui.cncjob_defaults_form.cncjob_adv_opt_group.toolchange_text,
+            "cncjob_toolchange_macro_enable":   self.ui.cncjob_defaults_form.cncjob_adv_opt_group.toolchange_cb,
+            "cncjob_annotation_fontsize":  self.ui.cncjob_defaults_form.cncjob_adv_opt_group.annotation_fontsize_sp,
             "cncjob_annotation_fontcolor": self.ui.cncjob_defaults_form.cncjob_adv_opt_group.annotation_fontcolor_entry,
 
+            # Isolation Routing Tool
+            "tools_iso_tooldia":        self.ui.tools_defaults_form.tools_iso_group.tool_dia_entry,
+            "tools_iso_order":          self.ui.tools_defaults_form.tools_iso_group.order_radio,
+            "tools_iso_tool_type":      self.ui.tools_defaults_form.tools_iso_group.tool_type_radio,
+            "tools_iso_tool_vtipdia":   self.ui.tools_defaults_form.tools_iso_group.tipdia_spinner,
+            "tools_iso_tool_vtipangle": self.ui.tools_defaults_form.tools_iso_group.tipangle_spinner,
+            "tools_iso_tool_cutz":      self.ui.tools_defaults_form.tools_iso_group.cutz_spinner,
+            "tools_iso_newdia":         self.ui.tools_defaults_form.tools_iso_group.newdia_entry,
+
+            "tools_iso_passes":         self.ui.tools_defaults_form.tools_iso_group.passes_entry,
+            "tools_iso_overlap":        self.ui.tools_defaults_form.tools_iso_group.overlap_entry,
+            "tools_iso_milling_type":   self.ui.tools_defaults_form.tools_iso_group.milling_type_radio,
+            "tools_iso_follow":         self.ui.tools_defaults_form.tools_iso_group.follow_cb,
+            "tools_iso_isotype":        self.ui.tools_defaults_form.tools_iso_group.iso_type_radio,
+
+            "tools_iso_rest":           self.ui.tools_defaults_form.tools_iso_group.rest_cb,
+            "tools_iso_combine_passes": self.ui.tools_defaults_form.tools_iso_group.combine_passes_cb,
+            "tools_iso_isoexcept":      self.ui.tools_defaults_form.tools_iso_group.except_cb,
+            "tools_iso_selection":      self.ui.tools_defaults_form.tools_iso_group.select_combo,
+            "tools_iso_area_shape":     self.ui.tools_defaults_form.tools_iso_group.area_shape_radio,
+
             # NCC Tool
-            "tools_ncctools": self.ui.tools_defaults_form.tools_ncc_group.ncc_tool_dia_entry,
-            "tools_nccorder": self.ui.tools_defaults_form.tools_ncc_group.ncc_order_radio,
-            "tools_nccoverlap": self.ui.tools_defaults_form.tools_ncc_group.ncc_overlap_entry,
-            "tools_nccmargin": self.ui.tools_defaults_form.tools_ncc_group.ncc_margin_entry,
-            "tools_nccmethod": self.ui.tools_defaults_form.tools_ncc_group.ncc_method_combo,
-            "tools_nccconnect": self.ui.tools_defaults_form.tools_ncc_group.ncc_connect_cb,
-            "tools_ncccontour": self.ui.tools_defaults_form.tools_ncc_group.ncc_contour_cb,
-            "tools_nccrest": self.ui.tools_defaults_form.tools_ncc_group.ncc_rest_cb,
-            "tools_ncc_offset_choice": self.ui.tools_defaults_form.tools_ncc_group.ncc_choice_offset_cb,
-            "tools_ncc_offset_value": self.ui.tools_defaults_form.tools_ncc_group.ncc_offset_spinner,
-            "tools_nccref": self.ui.tools_defaults_form.tools_ncc_group.select_combo,
-            "tools_ncc_area_shape": self.ui.tools_defaults_form.tools_ncc_group.area_shape_radio,
-            "tools_ncc_plotting": self.ui.tools_defaults_form.tools_ncc_group.ncc_plotting_radio,
-            "tools_nccmilling_type": self.ui.tools_defaults_form.tools_ncc_group.milling_type_radio,
-            "tools_ncctool_type": self.ui.tools_defaults_form.tools_ncc_group.tool_type_radio,
-            "tools_ncccutz": self.ui.tools_defaults_form.tools_ncc_group.cutz_entry,
-            "tools_ncctipdia": self.ui.tools_defaults_form.tools_ncc_group.tipdia_entry,
-            "tools_ncctipangle": self.ui.tools_defaults_form.tools_ncc_group.tipangle_entry,
-            "tools_nccnewdia": self.ui.tools_defaults_form.tools_ncc_group.newdia_entry,
+            "tools_ncctools":           self.ui.tools_defaults_form.tools_ncc_group.ncc_tool_dia_entry,
+            "tools_nccorder":           self.ui.tools_defaults_form.tools_ncc_group.ncc_order_radio,
+            "tools_nccoverlap":         self.ui.tools_defaults_form.tools_ncc_group.ncc_overlap_entry,
+            "tools_nccmargin":          self.ui.tools_defaults_form.tools_ncc_group.ncc_margin_entry,
+            "tools_nccmethod":          self.ui.tools_defaults_form.tools_ncc_group.ncc_method_combo,
+            "tools_nccconnect":         self.ui.tools_defaults_form.tools_ncc_group.ncc_connect_cb,
+            "tools_ncccontour":         self.ui.tools_defaults_form.tools_ncc_group.ncc_contour_cb,
+            "tools_nccrest":            self.ui.tools_defaults_form.tools_ncc_group.ncc_rest_cb,
+            "tools_ncc_offset_choice":  self.ui.tools_defaults_form.tools_ncc_group.ncc_choice_offset_cb,
+            "tools_ncc_offset_value":   self.ui.tools_defaults_form.tools_ncc_group.ncc_offset_spinner,
+            "tools_nccref":             self.ui.tools_defaults_form.tools_ncc_group.select_combo,
+            "tools_ncc_area_shape":     self.ui.tools_defaults_form.tools_ncc_group.area_shape_radio,
+            "tools_ncc_plotting":       self.ui.tools_defaults_form.tools_ncc_group.ncc_plotting_radio,
+            "tools_nccmilling_type":    self.ui.tools_defaults_form.tools_ncc_group.milling_type_radio,
+            "tools_ncctool_type":       self.ui.tools_defaults_form.tools_ncc_group.tool_type_radio,
+            "tools_ncccutz":            self.ui.tools_defaults_form.tools_ncc_group.cutz_entry,
+            "tools_ncctipdia":          self.ui.tools_defaults_form.tools_ncc_group.tipdia_entry,
+            "tools_ncctipangle":        self.ui.tools_defaults_form.tools_ncc_group.tipangle_entry,
+            "tools_nccnewdia":          self.ui.tools_defaults_form.tools_ncc_group.newdia_entry,
 
             # CutOut Tool
             "tools_cutouttooldia": self.ui.tools_defaults_form.tools_cutout_group.cutout_tooldia_entry,

AppGUI/preferences/tools/ToolsISOPrefGroupUI.py

@@ -0,0 +1,319 @@
+from PyQt5 import QtWidgets
+from PyQt5.QtCore import QSettings
+
+from AppGUI.GUIElements import FCEntry, RadioSet, FCDoubleSpinner, FCComboBox, FCCheckBox, FCSpinner
+from AppGUI.preferences.OptionsGroupUI import OptionsGroupUI
+
+import gettext
+import AppTranslation as fcTranslate
+import builtins
+
+fcTranslate.apply_language('strings')
+if '_' not in builtins.__dict__:
+    _ = gettext.gettext
+
+settings = QSettings("Open Source", "FlatCAM")
+if settings.contains("machinist"):
+    machinist_setting = settings.value('machinist', type=int)
+else:
+    machinist_setting = 0
+
+
+class ToolsISOPrefGroupUI(OptionsGroupUI):
+    def __init__(self, decimals=4, parent=None):
+        super(ToolsISOPrefGroupUI, self).__init__(self, parent=parent)
+
+        self.setTitle(str(_("Isolation Tool Options")))
+        self.decimals = decimals
+
+        # ## Clear non-copper regions
+        self.iso_label = QtWidgets.QLabel("<b>%s:</b>" % _("Parameters"))
+        self.iso_label.setToolTip(
+            _("Create a Geometry object with\n"
+              "toolpaths to cut around polygons.")
+        )
+        self.layout.addWidget(self.clearcopper_label)
+
+        grid0 = QtWidgets.QGridLayout()
+        self.layout.addLayout(grid0)
+
+        # Tool Dias
+        isotdlabel = QtWidgets.QLabel('<b><font color="green">%s:</font></b>' % _('Tools Dia'))
+        isotdlabel.setToolTip(
+            _("Diameters of the tools, separated by comma.\n"
+              "The value of the diameter has to use the dot decimals separator.\n"
+              "Valid values: 0.3, 1.0")
+        )
+        self.tool_dia_entry = FCEntry(border_color='#0069A9')
+        self.tool_dia_entry.setPlaceholderText(_("Comma separated values"))
+
+        grid0.addWidget(isotdlabel, 0, 0)
+        grid0.addWidget(self.tool_dia_entry, 0, 1)
+
+        # Tool order Radio Button
+        self.order_label = QtWidgets.QLabel('%s:' % _('Tool order'))
+        self.order_label.setToolTip(_("This set the way that the tools in the tools table are used.\n"
+                                      "'No' --> means that the used order is the one in the tool table\n"
+                                      "'Forward' --> means that the tools will be ordered from small to big\n"
+                                      "'Reverse' --> means that the tools will ordered from big to small\n\n"
+                                      "WARNING: using rest machining will automatically set the order\n"
+                                      "in reverse and disable this control."))
+
+        self.order_radio = RadioSet([{'label': _('No'), 'value': 'no'},
+                                     {'label': _('Forward'), 'value': 'fwd'},
+                                     {'label': _('Reverse'), 'value': 'rev'}])
+
+        grid0.addWidget(self.order_label, 1, 0)
+        grid0.addWidget(self.order_radio, 1, 1)
+
+        # Tool Type Radio Button
+        self.tool_type_label = QtWidgets.QLabel('%s:' % _('Tool Type'))
+        self.tool_type_label.setToolTip(
+            _("Default tool type:\n"
+              "- 'V-shape'\n"
+              "- Circular")
+        )
+
+        self.tool_type_radio = RadioSet([{'label': _('V-shape'), 'value': 'V'},
+                                         {'label': _('Circular'), 'value': 'C1'}])
+        self.tool_type_radio.setToolTip(
+            _("Default tool type:\n"
+              "- 'V-shape'\n"
+              "- Circular")
+        )
+
+        grid0.addWidget(self.tool_type_label, 2, 0)
+        grid0.addWidget(self.tool_type_radio, 2, 1)
+
+        # Tip Dia
+        self.tipdialabel = QtWidgets.QLabel('%s:' % _('V-Tip Dia'))
+        self.tipdialabel.setToolTip(
+            _("The tip diameter for V-Shape Tool"))
+        self.tipdia_entry = FCDoubleSpinner()
+        self.tipdia_entry.set_precision(self.decimals)
+        self.tipdia_entry.set_range(0, 1000)
+        self.tipdia_entry.setSingleStep(0.1)
+
+        grid0.addWidget(self.tipdialabel, 3, 0)
+        grid0.addWidget(self.tipdia_entry, 3, 1)
+
+        # Tip Angle
+        self.tipanglelabel = QtWidgets.QLabel('%s:' % _('V-Tip Angle'))
+        self.tipanglelabel.setToolTip(
+            _("The tip angle for V-Shape Tool.\n"
+              "In degrees."))
+        self.tipangle_entry = FCDoubleSpinner()
+        self.tipangle_entry.set_precision(self.decimals)
+        self.tipangle_entry.set_range(1, 180)
+        self.tipangle_entry.setSingleStep(5)
+        self.tipangle_entry.setWrapping(True)
+
+        grid0.addWidget(self.tipanglelabel, 4, 0)
+        grid0.addWidget(self.tipangle_entry, 4, 1)
+
+        # Cut Z entry
+        cutzlabel = QtWidgets.QLabel('%s:' % _('Cut Z'))
+        cutzlabel.setToolTip(
+           _("Depth of cut into material. Negative value.\n"
+             "In FlatCAM units.")
+        )
+        self.cutz_entry = FCDoubleSpinner()
+        self.cutz_entry.set_precision(self.decimals)
+        self.cutz_entry.set_range(-9999.9999, 0.0000)
+        self.cutz_entry.setSingleStep(0.1)
+
+        self.cutz_entry.setToolTip(
+           _("Depth of cut into material. Negative value.\n"
+             "In FlatCAM units.")
+        )
+
+        grid0.addWidget(cutzlabel, 5, 0)
+        grid0.addWidget(self.cutz_entry, 5, 1)
+
+        # New Diameter
+        self.newdialabel = QtWidgets.QLabel('%s:' % _('New Dia'))
+        self.newdialabel.setToolTip(
+            _("Diameter for the new tool to add in the Tool Table.\n"
+              "If the tool is V-shape type then this value is automatically\n"
+              "calculated from the other parameters.")
+        )
+        self.newdia_entry = FCDoubleSpinner()
+        self.newdia_entry.set_precision(self.decimals)
+        self.newdia_entry.set_range(0.0001, 9999.9999)
+        self.newdia_entry.setSingleStep(0.1)
+
+        grid0.addWidget(self.newdialabel, 6, 0)
+        grid0.addWidget(self.newdia_entry, 6, 1)
+
+        separator_line = QtWidgets.QFrame()
+        separator_line.setFrameShape(QtWidgets.QFrame.HLine)
+        separator_line.setFrameShadow(QtWidgets.QFrame.Sunken)
+        grid0.addWidget(separator_line, 7, 0, 1, 2)
+
+        # Passes
+        passlabel = QtWidgets.QLabel('%s:' % _('Passes'))
+        passlabel.setToolTip(
+            _("Width of the isolation gap in\n"
+              "number (integer) of tool widths.")
+        )
+        self.passes_entry = FCSpinner()
+        self.passes_entry.set_range(1, 999)
+        self.passes_entry.setObjectName("i_passes")
+
+        grid0.addWidget(passlabel, 8, 0)
+        grid0.addWidget(self.passes_entry, 8, 1)
+
+        # Overlap Entry
+        overlabel = QtWidgets.QLabel('%s:' % _('Overlap'))
+        overlabel.setToolTip(
+            _("How much (percentage) of the tool width to overlap each tool pass.")
+        )
+        self.overlap_entry = FCDoubleSpinner(suffix='%')
+        self.overlap_entry.set_precision(self.decimals)
+        self.overlap_entry.setWrapping(True)
+        self.overlap_entry.set_range(0.0000, 99.9999)
+        self.overlap_entry.setSingleStep(0.1)
+        self.overlap_entry.setObjectName("i_overlap")
+
+        grid0.addWidget(overlabel, 9, 0)
+        grid0.addWidget(self.overlap_entry, 9, 1)
+
+        # Milling Type Radio Button
+        self.milling_type_label = QtWidgets.QLabel('%s:' % _('Milling Type'))
+        self.milling_type_label.setToolTip(
+            _("Milling type when the selected tool is of type: 'iso_op':\n"
+              "- climb / best for precision milling and to reduce tool usage\n"
+              "- conventional / useful when there is no backlash compensation")
+        )
+
+        self.milling_type_radio = RadioSet([{'label': _('Climb'), 'value': 'cl'},
+                                            {'label': _('Conventional'), 'value': 'cv'}])
+        self.milling_type_radio.setToolTip(
+            _("Milling type when the selected tool is of type: 'iso_op':\n"
+              "- climb / best for precision milling and to reduce tool usage\n"
+              "- conventional / useful when there is no backlash compensation")
+        )
+
+        grid0.addWidget(self.milling_type_label, 10, 0)
+        grid0.addWidget(self.milling_type_radio, 10, 1)
+
+        # Follow
+        self.follow_label = QtWidgets.QLabel('%s:' % _('Follow'))
+        self.follow_label.setToolTip(
+            _("Generate a 'Follow' geometry.\n"
+              "This means that it will cut through\n"
+              "the middle of the trace.")
+        )
+
+        self.follow_cb = FCCheckBox()
+        self.follow_cb.setToolTip(_("Generate a 'Follow' geometry.\n"
+                                    "This means that it will cut through\n"
+                                    "the middle of the trace."))
+        self.follow_cb.setObjectName("i_follow")
+
+        grid0.addWidget(self.follow_label, 11, 0)
+        grid0.addWidget(self.follow_cb, 11, 1)
+
+        # Isolation Type
+        self.iso_type_label = QtWidgets.QLabel('%s:' % _('Isolation Type'))
+        self.iso_type_label.setToolTip(
+            _("Choose how the isolation will be executed:\n"
+              "- 'Full' -> complete isolation of polygons\n"
+              "- 'Ext' -> will isolate only on the outside\n"
+              "- 'Int' -> will isolate only on the inside\n"
+              "'Exterior' isolation is almost always possible\n"
+              "(with the right tool) but 'Interior'\n"
+              "isolation can be done only when there is an opening\n"
+              "inside of the polygon (e.g polygon is a 'doughnut' shape).")
+        )
+        self.iso_type_radio = RadioSet([{'label': _('Full'), 'value': 'full'},
+                                        {'label': _('Ext'), 'value': 'ext'},
+                                        {'label': _('Int'), 'value': 'int'}])
+        self.iso_type_radio.setObjectName("i_type")
+
+        grid0.addWidget(self.iso_type_label, 12, 0)
+        grid0.addWidget(self.iso_type_radio, 12, 1)
+
+        separator_line = QtWidgets.QFrame()
+        separator_line.setFrameShape(QtWidgets.QFrame.HLine)
+        separator_line.setFrameShadow(QtWidgets.QFrame.Sunken)
+        grid0.addWidget(separator_line, 13, 0, 1, 2)
+
+        # Rest machining CheckBox
+        self.rest_cb = FCCheckBox('%s' % _("Rest Machining"))
+        self.rest_cb.setObjectName("i_rest_machining")
+        self.rest_cb.setToolTip(
+            _("If checked, use 'rest machining'.\n"
+              "Basically it will isolate outside PCB features,\n"
+              "using the biggest tool and continue with the next tools,\n"
+              "from bigger to smaller, to isolate the copper features that\n"
+              "could not be cleared by previous tool, until there is\n"
+              "no more copper features to isolate or there are no more tools.\n"
+              "If not checked, use the standard algorithm.")
+        )
+
+        grid0.addWidget(self.ncc_rest_cb, 17, 0, 1, 2)
+
+        # Combine All Passes
+        self.combine_passes_cb = FCCheckBox(label=_('Combine'))
+        self.combine_passes_cb.setToolTip(
+            _("Combine all passes into one object")
+        )
+        self.combine_passes_cb.setObjectName("i_combine")
+
+        grid0.addWidget(self.combine_passes_cb, 18, 0, 1, 2)
+
+        # Exception Areas
+        self.except_cb = FCCheckBox(label=_('Except'))
+        self.except_cb.setToolTip(_("When the isolation geometry is generated,\n"
+                                    "by checking this, the area of the object below\n"
+                                    "will be subtracted from the isolation geometry."))
+        self.except_cb.setObjectName("i_except")
+        grid0.addWidget(self.except_cb, 19, 0, 1, 2)
+
+        # Isolation Scope
+        self.select_label = QtWidgets.QLabel('%s:' % _("Selection"))
+        self.select_label.setToolTip(
+            _("Isolation scope. Choose what to isolate:\n"
+              "- 'All' -> Isolate all the polygons in the object\n"
+              "- 'Selection' -> Isolate a selection of polygons.\n"
+              "- 'Reference Object' - will process the area specified by another object.")
+        )
+        self.select_combo = FCComboBox()
+        self.select_combo.addItems(
+            [_("All"), _("Area Selection"), _("Reference Object")]
+        )
+        self.select_combo.setObjectName("i_selection")
+
+        grid0.addWidget(self.select_label, 20, 0)
+        grid0.addWidget(self.select_combo, 20, 1)
+
+        # Area Shape
+        self.area_shape_label = QtWidgets.QLabel('%s:' % _("Shape"))
+        self.area_shape_label.setToolTip(
+            _("The kind of selection shape used for area selection.")
+        )
+
+        self.area_shape_radio = RadioSet([{'label': _("Square"), 'value': 'square'},
+                                          {'label': _("Polygon"), 'value': 'polygon'}])
+
+        grid0.addWidget(self.area_shape_label, 21, 0)
+        grid0.addWidget(self.area_shape_radio, 21, 1)
+
+        separator_line = QtWidgets.QFrame()
+        separator_line.setFrameShape(QtWidgets.QFrame.HLine)
+        separator_line.setFrameShadow(QtWidgets.QFrame.Sunken)
+        grid0.addWidget(separator_line, 22, 0, 1, 2)
+
+        # ## Plotting type
+        self.ncc_plotting_radio = RadioSet([{'label': _('Normal'), 'value': 'normal'},
+                                            {"label": _("Progressive"), "value": "progressive"}])
+        plotting_label = QtWidgets.QLabel('%s:' % _("ISO Plotting"))
+        plotting_label.setToolTip(
+            _("- 'Normal' -  normal plotting, done at the end of the job\n"
+              "- 'Progressive' - each shape is plotted after it is generated")
+        )
+        grid0.addWidget(plotting_label, 21, 0)
+        grid0.addWidget(self.ncc_plotting_radio, 21, 1)
+
+        self.layout.addStretch()

AppGUI/preferences/tools/ToolsNCCPrefGroupUI.py

@@ -340,8 +340,8 @@ class ToolsNCCPrefGroupUI(OptionsGroupUI):
                                             {"label": _("Progressive"), "value": "progressive"}])
         plotting_label = QtWidgets.QLabel('%s:' % _("NCC Plotting"))
         plotting_label.setToolTip(
-            _("- 'Normal' -  normal plotting, done at the end of the NCC job\n"
-              "- 'Progressive' - after each shape is generated it will be plotted.")
+            _("- 'Normal' -  normal plotting, done at the end of the job\n"
+              "- 'Progressive' - each shape is plotted after it is generated")
         )
         grid0.addWidget(plotting_label, 21, 0)
         grid0.addWidget(self.ncc_plotting_radio, 21, 1)

AppGUI/preferences/tools/ToolsPaintPrefGroupUI.py

@@ -277,7 +277,7 @@ class ToolsPaintPrefGroupUI(OptionsGroupUI):
         # )
         self.selectmethod_combo = FCComboBox()
         self.selectmethod_combo.addItems(
-            [_("Polygon Selection"), _("Area Selection"), _("All Polygons"), _("Reference Object")]
+            [_("Polygon Selection"), _("Area Selection"), _("All"), _("Reference Object")]
         )
 
         grid0.addWidget(selectlabel, 15, 0)
@@ -304,8 +304,8 @@ class ToolsPaintPrefGroupUI(OptionsGroupUI):
                                               {"label": _("Progressive"), "value": "progressive"}])
         plotting_label = QtWidgets.QLabel('%s:' % _("Paint Plotting"))
         plotting_label.setToolTip(
-            _("- 'Normal' -  normal plotting, done at the end of the Paint job\n"
-              "- 'Progressive' - after each shape is generated it will be plotted.")
+            _("- 'Normal' -  normal plotting, done at the end of the job\n"
+              "- 'Progressive' - each shape is plotted after it is generated")
         )
         grid0.addWidget(plotting_label, 20, 0)
         grid0.addWidget(self.paint_plotting_radio, 20, 1)

AppGUI/preferences/tools/ToolsPreferencesUI.py

@@ -8,10 +8,12 @@ from AppGUI.preferences.tools.ToolsTransformPrefGroupUI import ToolsTransformPre
 from AppGUI.preferences.tools.ToolsCalculatorsPrefGroupUI import ToolsCalculatorsPrefGroupUI
 from AppGUI.preferences.tools.ToolsPanelizePrefGroupUI import ToolsPanelizePrefGroupUI
 from AppGUI.preferences.tools.ToolsFilmPrefGroupUI import ToolsFilmPrefGroupUI
-from AppGUI.preferences.tools.ToolsPaintPrefGroupUI import ToolsPaintPrefGroupUI
 from AppGUI.preferences.tools.Tools2sidedPrefGroupUI import Tools2sidedPrefGroupUI
+
 from AppGUI.preferences.tools.ToolsCutoutPrefGroupUI import ToolsCutoutPrefGroupUI
 from AppGUI.preferences.tools.ToolsNCCPrefGroupUI import ToolsNCCPrefGroupUI
+from AppGUI.preferences.tools.ToolsPaintPrefGroupUI import ToolsPaintPrefGroupUI
+from AppGUI.preferences.tools.ToolsISOPrefGroupUI import ToolsISOPrefGroupUI
 
 import gettext
 import AppTranslation as fcTranslate
@@ -36,6 +38,9 @@ class ToolsPreferencesUI(QtWidgets.QWidget):
         self.setLayout(self.layout)
         self.decimals = decimals
 
+        self.tools_iso_group = ToolsISOPrefGroupUI(decimals=self.decimals)
+        self.tools_iso_group.setMinimumWidth(220)
+
         self.tools_ncc_group = ToolsNCCPrefGroupUI(decimals=self.decimals)
         self.tools_ncc_group.setMinimumWidth(220)
 
@@ -75,7 +80,7 @@ class ToolsPreferencesUI(QtWidgets.QWidget):
 
         self.vlay1 = QtWidgets.QVBoxLayout()
         self.vlay1.addWidget(self.tools_paint_group)
-        self.vlay1.addWidget(self.tools_panelize_group)
+        self.vlay1.addWidget(self.tools_iso_group)
 
         self.vlay2 = QtWidgets.QVBoxLayout()
         self.vlay2.addWidget(self.tools_transform_group)
@@ -89,6 +94,7 @@ class ToolsPreferencesUI(QtWidgets.QWidget):
         self.vlay4 = QtWidgets.QVBoxLayout()
         self.vlay4.addWidget(self.tools_solderpaste_group)
         self.vlay4.addWidget(self.tools_corners_group)
+        self.vlay4.addWidget(self.tools_panelize_group)
 
         self.layout.addLayout(self.vlay)
         self.layout.addLayout(self.vlay1)

AppTools/ToolIsolation.py

@@ -436,11 +436,11 @@ class ToolIsolation(AppTool, Gerber):
         self.rest_cb.setObjectName("i_rest_machining")
         self.rest_cb.setToolTip(
             _("If checked, use 'rest machining'.\n"
-              "Basically it will clear copper outside PCB features,\n"
+              "Basically it will isolate outside PCB features,\n"
               "using the biggest tool and continue with the next tools,\n"
-              "from bigger to smaller, to clear areas of copper that\n"
+              "from bigger to smaller, to isolate the copper features that\n"
               "could not be cleared by previous tool, until there is\n"
-              "no more copper to clear or there are no more tools.\n"
+              "no more copper features to isolate or there are no more tools.\n"
               "If not checked, use the standard algorithm.")
         )
 
@@ -628,7 +628,7 @@ class ToolIsolation(AppTool, Gerber):
         # ########################## VARIABLES ########################################
         # #############################################################################
         self.units = ''
-        self.ncc_tools = {}
+        self.iso_tools = {}
         self.tooluid = 0
 
         # store here the default data for Geometry Data
@@ -682,7 +682,7 @@ class ToolIsolation(AppTool, Gerber):
             "tools_iso_milling_type": self.milling_type_radio,
             "tools_iso_combine": self.combine_passes_cb,
             "tools_iso_follow": self.follow_cb,
-            "tools_iso_type": self.iso_type_radio
+            "tools_iso_isotype": self.iso_type_radio
         }
 
         self.name2option = {
@@ -691,7 +691,7 @@ class ToolIsolation(AppTool, Gerber):
             "i_milling_type": "tools_iso_milling_type",
             "i_combine": "tools_iso_combine",
             "i_follow": "tools_iso_follow",
-            "i_type": "tools_iso_type"
+            "i_type": "tools_iso_isotype"
         }
 
         self.old_tool_dia = None
@@ -742,7 +742,7 @@ class ToolIsolation(AppTool, Gerber):
         current_row = self.tools_table.currentRow()
         try:
             current_uid = int(self.tools_table.item(current_row, 3).text())
-            self.ncc_tools[current_uid]['data']['tools_nccoperation'] = val
+            self.iso_tools[current_uid]['data']['tools_nccoperation'] = val
         except AttributeError:
             return
 
@@ -775,7 +775,7 @@ class ToolIsolation(AppTool, Gerber):
                 )
                 try:
                     # set the form with data from the newly selected tool
-                    for tooluid_key, tooluid_value in list(self.ncc_tools.items()):
+                    for tooluid_key, tooluid_value in list(self.iso_tools.items()):
                         if int(tooluid_key) == tooluid:
                             for key, value in tooluid_value.items():
                                 if key == 'data':
@@ -818,7 +818,7 @@ class ToolIsolation(AppTool, Gerber):
                 row = 0
             tooluid_item = int(self.tools_table.item(row, 3).text())
 
-            for tooluid_key, tooluid_val in self.ncc_tools.items():
+            for tooluid_key, tooluid_val in self.iso_tools.items():
                 if int(tooluid_key) == tooluid_item:
                     new_option_value = self.form_fields[option_changed].get_value()
                     if option_changed in tooluid_val:
@@ -843,14 +843,14 @@ class ToolIsolation(AppTool, Gerber):
         tooluid_item = int(self.tools_table.item(row, 3).text())
         temp_tool_data = {}
 
-        for tooluid_key, tooluid_val in self.ncc_tools.items():
+        for tooluid_key, tooluid_val in self.iso_tools.items():
             if int(tooluid_key) == tooluid_item:
                 # this will hold the 'data' key of the self.tools[tool] dictionary that corresponds to
                 # the current row in the tool table
                 temp_tool_data = tooluid_val['data']
                 break
 
-        for tooluid_key, tooluid_val in self.ncc_tools.items():
+        for tooluid_key, tooluid_val in self.iso_tools.items():
             tooluid_val['data'] = deepcopy(temp_tool_data)
 
         # store all the data associated with the row parameter to the self.tools storage
@@ -866,7 +866,7 @@ class ToolIsolation(AppTool, Gerber):
         # temp_dia = {}
         # temp_data = {}
         #
-        # for tooluid_key, tooluid_value in self.ncc_tools.items():
+        # for tooluid_key, tooluid_value in self.iso_tools.items():
         #     for key, value in tooluid_value.items():
         #         if key == 'data':
         #             # update the 'data' section
@@ -888,8 +888,8 @@ class ToolIsolation(AppTool, Gerber):
         #
         #         temp_tools[tooluid_key] = deepcopy(temp_dia)
         #
-        # self.ncc_tools.clear()
-        # self.ncc_tools = deepcopy(temp_tools)
+        # self.iso_tools.clear()
+        # self.iso_tools = deepcopy(temp_tools)
         # temp_tools.clear()
 
         self.app.inform.emit('[success] %s' % _("Current Tool parameters were applied to all tools."))
@@ -952,7 +952,7 @@ class ToolIsolation(AppTool, Gerber):
 
     def set_tool_ui(self):
         self.units = self.app.defaults['units'].upper()
-        self.old_tool_dia = self.app.defaults["tools_nccnewdia"]
+        self.old_tool_dia = self.app.defaults["tools_iso_newdia"]
 
         # try to select in the Gerber combobox the active object
         try:
@@ -982,10 +982,13 @@ class ToolIsolation(AppTool, Gerber):
             self.follow_cb.setChecked(False)
             self.follow_cb.hide()
             self.follow_label.hide()
+
             self.rest_cb.setChecked(False)
             self.rest_cb.hide()
+
             self.except_cb.setChecked(False)
             self.except_cb.hide()
+
             self.select_combo.setCurrentIndex(0)
             self.select_combo.hide()
             self.select_label.hide()
@@ -993,7 +996,7 @@ class ToolIsolation(AppTool, Gerber):
             self.level.setText('<span style="color:red;"><b>%s</b></span>' % _('Advanced'))
 
             # TODO remember to set the GUI elements to values from app.defaults dict
-            self.tool_type_radio.set_value(self.app.defaults["gerber_tool_type"])
+            self.tool_type_radio.set_value(self.app.defaults["tools_iso_tool_type"])
             self.tool_type_label.show()
             self.tool_type_radio.show()
 
@@ -1001,17 +1004,20 @@ class ToolIsolation(AppTool, Gerber):
             self.milling_type_radio.show()
 
             self.iso_type_label.show()
-            self.iso_type_radio.set_value(self.app.defaults["gerber_iso_type"])
+            self.iso_type_radio.set_value(self.app.defaults["tools_iso_isotype"])
             self.iso_type_radio.show()
 
-            self.follow_cb.setChecked(False)
+            self.follow_cb.setChecked(self.app.defaults["tools_iso_follow"])
             self.follow_cb.show()
             self.follow_label.show()
-            self.rest_cb.setChecked(False)
+
+            self.rest_cb.setChecked(self.app.defaults["tools_iso_rest"])
             self.rest_cb.show()
-            self.except_cb.setChecked(False)
+
+            self.except_cb.setChecked(self.app.defaults["tools_iso_isoexcept"])
             self.except_cb.show()
-            self.select_combo.setCurrentIndex(0)
+
+            self.select_combo.setCurrentIndex(self.app.defaults["tools_iso_selection"])
             self.select_combo.show()
             self.select_label.show()
 
@@ -1034,25 +1040,18 @@ class ToolIsolation(AppTool, Gerber):
         self.on_type_excobj_index_changed(val="gerber")
         self.on_reference_combo_changed()
 
-        self.order_radio.set_value(self.app.defaults["tools_nccorder"])
-        self.passes_entry.set_value(self.app.defaults["gerber_isopasses"])
-        self.iso_overlap_entry.set_value(self.app.defaults["gerber_isooverlap"])
-        self.milling_type_radio.set_value(self.app.defaults["gerber_milling_type"])
-        self.combine_passes_cb.set_value(self.app.defaults["gerber_combine_passes"])
-        self.follow_cb.set_value(self.app.defaults["gerber_follow"])
-        self.except_cb.set_value(False)
-        self.iso_type_radio.set_value(self.app.defaults["gerber_iso_type"])
-        self.rest_cb.set_value(False)
-        self.select_combo.set_value(self.app.defaults["gerber_iso_scope"])
-        self.area_shape_radio.set_value('square')
-
-        self.cutz_entry.set_value(self.app.defaults["tools_ncccutz"])
-        self.tool_type_radio.set_value(self.app.defaults["tools_ncctool_type"])
-        self.tipdia_entry.set_value(self.app.defaults["tools_ncctipdia"])
-        self.tipangle_entry.set_value(self.app.defaults["tools_ncctipangle"])
-        self.addtool_entry.set_value(self.app.defaults["tools_nccnewdia"])
-
-        self.old_tool_dia = self.app.defaults["tools_nccnewdia"]
+        self.order_radio.set_value(self.app.defaults["tools_iso_order"])
+        self.passes_entry.set_value(self.app.defaults["tools_iso_passes"])
+        self.iso_overlap_entry.set_value(self.app.defaults["tools_iso_overlap"])
+        self.milling_type_radio.set_value(self.app.defaults["tools_iso_milling_type"])
+        self.combine_passes_cb.set_value(self.app.defaults["tools_iso_combine_passes"])
+        self.area_shape_radio.set_value(self.app.defaults["tools_iso_combine_passes"])
+
+        self.cutz_entry.set_value(self.app.defaults["tools_iso_tool_cutz"])
+        self.tool_type_radio.set_value(self.app.defaults["tools_iso_tool_type"])
+        self.tipdia_entry.set_value(self.app.defaults["tools_iso_tool_vtipdia"])
+        self.tipangle_entry.set_value(self.app.defaults["tools_iso_tool_vtipangle"])
+        self.addtool_entry.set_value(self.app.defaults["tools_iso_newdia"])
 
         self.on_tool_type(val=self.tool_type_radio.get_value())
 
@@ -1089,24 +1088,23 @@ class ToolIsolation(AppTool, Gerber):
             "area_strategy": self.app.defaults["geometry_area_strategy"],
             "area_overz": float(self.app.defaults["geometry_area_overz"]),
 
-            "tools_iso_passes": self.app.defaults["gerber_isopasses"],
-            "tools_iso_overlap": self.app.defaults["gerber_isooverlap"],
-            "tools_iso_milling_type": self.app.defaults["gerber_milling_type"],
-            "tools_iso_combine": self.app.defaults["gerber_combine_passes"],
-            "tools_iso_follow": self.app.defaults["gerber_follow"],
-            "tools_iso_type": self.app.defaults["gerber_iso_type"],
-
-            "nccrest": self.app.defaults["tools_nccrest"],
-            "nccref": self.app.defaults["gerber_iso_scope"],
-
-            "tools_iso_exclusion": True,
-
+            "tools_iso_passes": self.app.defaults["tools_iso_passes"],
+            "tools_iso_overlap": self.app.defaults["tools_iso_overlap"],
+            "tools_iso_milling_type": self.app.defaults["tools_iso_milling_type"],
+            "tools_iso_follow": self.app.defaults["tools_iso_follow"],
+            "tools_iso_isotype": self.app.defaults["tools_iso_isotype"],
+
+            "tools_iso_rest": self.app.defaults["tools_iso_rest"],
+            "tools_iso_combine_passes": self.app.defaults["tools_iso_combine_passes"],
+            "tools_iso_isoexcept": self.app.defaults["tools_iso_isoexcept"],
+            "tools_iso_selection": self.app.defaults["tools_iso_selection"],
+            "tools_iso_area_shape": self.app.defaults["tools_iso_area_shape"]
         }
 
         try:
-            dias = [float(self.app.defaults["gerber_isotooldia"])]
+            dias = [float(self.app.defaults["tools_iso_tooldia"])]
         except (ValueError, TypeError):
-            dias = [float(eval(dia)) for dia in self.app.defaults["gerber_isotooldia"].split(",") if dia != '']
+            dias = [float(eval(dia)) for dia in self.app.defaults["tools_iso_tooldia"].split(",") if dia != '']
 
         if not dias:
             log.error("At least one tool diameter needed. Verify in Edit -> Preferences -> TOOLS -> Isolation Tools.")
@@ -1114,10 +1112,10 @@ class ToolIsolation(AppTool, Gerber):
 
         self.tooluid = 0
 
-        self.ncc_tools.clear()
+        self.iso_tools.clear()
         for tool_dia in dias:
             self.tooluid += 1
-            self.ncc_tools.update({
+            self.iso_tools.update({
                 int(self.tooluid): {
                     'tooldia': float('%.*f' % (self.decimals, tool_dia)),
                     'offset': 'Path',
@@ -1144,7 +1142,7 @@ class ToolIsolation(AppTool, Gerber):
         self.units = self.app.defaults['units'].upper()
 
         sorted_tools = []
-        for k, v in self.ncc_tools.items():
+        for k, v in self.iso_tools.items():
             if self.units == "IN":
                 sorted_tools.append(float('%.*f' % (self.decimals, float(v['tooldia']))))
             else:
@@ -1163,7 +1161,7 @@ class ToolIsolation(AppTool, Gerber):
         tool_id = 0
 
         for tool_sorted in sorted_tools:
-            for tooluid_key, tooluid_value in self.ncc_tools.items():
+            for tooluid_key, tooluid_value in self.iso_tools.items():
                 if float('%.*f' % (self.decimals, tooluid_value['tooldia'])) == tool_sorted:
                     tool_id += 1
                     id_ = QtWidgets.QTableWidgetItem('%d' % int(tool_id))
@@ -1410,7 +1408,7 @@ class ToolIsolation(AppTool, Gerber):
             tt = cw.currentText()
             typ = 'Iso' if tt == 'V' else "Rough"
 
-            self.ncc_tools[current_uid].update({
+            self.iso_tools[current_uid].update({
                 'type': typ,
                 'tool_type': tt,
             })
@@ -1445,7 +1443,7 @@ class ToolIsolation(AppTool, Gerber):
             # calculated tool diameter so the cut_z parameter is obeyed
             tool_dia = tip_dia + (2 * cut_z * math.tan(math.radians(tip_angle)))
 
-            # update the default_data so it is used in the ncc_tools dict
+            # update the default_data so it is used in the iso_tools dict
             self.default_data.update({
                 "vtipdia": tip_dia,
                 "vtipangle": (tip_angle * 2),
@@ -1480,7 +1478,7 @@ class ToolIsolation(AppTool, Gerber):
 
         # construct a list of all 'tooluid' in the self.tools
         tool_uid_list = []
-        for tooluid_key in self.ncc_tools:
+        for tooluid_key in self.iso_tools:
             tool_uid_item = int(tooluid_key)
             tool_uid_list.append(tool_uid_item)
 
@@ -1492,7 +1490,7 @@ class ToolIsolation(AppTool, Gerber):
         self.tooluid = int(max_uid + 1)
 
         tool_dias = []
-        for k, v in self.ncc_tools.items():
+        for k, v in self.iso_tools.items():
             for tool_v in v.keys():
                 if tool_v == 'tooldia':
                     tool_dias.append(float('%.*f' % (self.decimals, (v[tool_v]))))
@@ -1507,7 +1505,7 @@ class ToolIsolation(AppTool, Gerber):
         else:
             if muted is None:
                 self.app.inform.emit('[success] %s' % _("New tool added to Tool Table."))
-            self.ncc_tools.update({
+            self.iso_tools.update({
                 int(self.tooluid): {
                     'tooldia': float('%.*f' % (self.decimals, tool_dia)),
                     'offset': 'Path',
@@ -1527,7 +1525,7 @@ class ToolIsolation(AppTool, Gerber):
 
         old_tool_dia = ''
         tool_dias = []
-        for k, v in self.ncc_tools.items():
+        for k, v in self.iso_tools.items():
             for tool_v in v.keys():
                 if tool_v == 'tooldia':
                     tool_dias.append(float('%.*f' % (self.decimals, v[tool_v])))
@@ -1549,14 +1547,14 @@ class ToolIsolation(AppTool, Gerber):
 
             # identify the tool that was edited and get it's tooluid
             if new_tool_dia not in tool_dias:
-                self.ncc_tools[tooluid]['tooldia'] = new_tool_dia
+                self.iso_tools[tooluid]['tooldia'] = new_tool_dia
                 self.app.inform.emit('[success] %s' % _("Tool from Tool Table was edited."))
                 self.blockSignals(False)
                 self.build_ui()
                 return
             else:
                 # identify the old tool_dia and restore the text in tool table
-                for k, v in self.ncc_tools.items():
+                for k, v in self.iso_tools.items():
                     if k == tooluid:
                         old_tool_dia = v['tooldia']
                         break
@@ -1580,7 +1578,7 @@ class ToolIsolation(AppTool, Gerber):
         deleted_tools_list = []
 
         if all_tools:
-            self.ncc_tools.clear()
+            self.iso_tools.clear()
             self.blockSignals(False)
             self.build_ui()
             return
@@ -1595,7 +1593,7 @@ class ToolIsolation(AppTool, Gerber):
                 deleted_tools_list.append(tooluid_del)
 
             for t in deleted_tools_list:
-                self.ncc_tools.pop(t, None)
+                self.iso_tools.pop(t, None)
 
             self.blockSignals(False)
             self.build_ui()
@@ -1611,7 +1609,7 @@ class ToolIsolation(AppTool, Gerber):
                     deleted_tools_list.append(tooluid_del)
 
                 for t in deleted_tools_list:
-                    self.ncc_tools.pop(t, None)
+                    self.iso_tools.pop(t, None)
 
         except AttributeError:
             self.app.inform.emit('[WARNING_NOTCL] %s' % _("Delete failed. Select a tool to delete."))
@@ -2140,7 +2138,7 @@ class ToolIsolation(AppTool, Gerber):
         :param isotooldia:      a tuple or single element made out of diameters of the tools to be used for isolation
         :param outname:         name of the resulting object
         :param order:           Tools order
-        :param tools_storage:   whether to use the current tools_storage self.ncc_tools or a different one.
+        :param tools_storage:   whether to use the current tools_storage self.iso_tools or a different one.
                                 Usage of the different one is related to when this function is called
                                 from a TcL command.
 
@@ -2167,7 +2165,7 @@ class ToolIsolation(AppTool, Gerber):
 
         # determine if to use the progressive plotting
         prog_plot = True if self.app.defaults["tools_ncc_plotting"] == 'progressive' else False
-        tools_storage = tools_storage if tools_storage is not None else self.ncc_tools
+        tools_storage = tools_storage if tools_storage is not None else self.iso_tools
 
         # ######################################################################################################
         # # Read the tooldia parameter and create a sorted list out them - they may be more than one diameter ##
@@ -2185,9 +2183,9 @@ class ToolIsolation(AppTool, Gerber):
             # for row in range(self.tools_table.rowCount()):
             #     if self.tools_table.cellWidget(row, 1).currentText() == 'clear_op':
             #         sorted_clear_tools.append(float(self.tools_table.item(row, 1).text()))
-            for tooluid in self.ncc_tools:
-                if self.ncc_tools[tooluid]['data']['tools_nccoperation'] == 'clear':
-                    sorted_clear_tools.append(self.ncc_tools[tooluid]['tooldia'])
+            for tooluid in self.iso_tools:
+                if self.iso_tools[tooluid]['data']['tools_nccoperation'] == 'clear':
+                    sorted_clear_tools.append(self.iso_tools[tooluid]['tooldia'])
 
         # ########################################################################################################
         # set the name for the future Geometry object
@@ -2256,19 +2254,19 @@ class ToolIsolation(AppTool, Gerber):
                 app_obj.proc_container.update_view_text(' %d%%' % 0)
 
                 tool_uid = 0  # find the current tool_uid
-                for k, v in self.ncc_tools.items():
+                for k, v in self.iso_tools.items():
                     if float('%.*f' % (self.decimals, v['tooldia'])) == float('%.*f' % (self.decimals, tool)):
                         tool_uid = int(k)
                         break
 
                 # parameters that are particular to the current tool
-                ncc_overlap = float(self.ncc_tools[tool_uid]["data"]["tools_nccoverlap"]) / 100.0
-                ncc_margin = float(self.ncc_tools[tool_uid]["data"]["tools_nccmargin"])
-                ncc_method = self.ncc_tools[tool_uid]["data"]["tools_nccmethod"]
-                ncc_connect = self.ncc_tools[tool_uid]["data"]["tools_nccconnect"]
-                ncc_contour = self.ncc_tools[tool_uid]["data"]["tools_ncccontour"]
-                has_offset = self.ncc_tools[tool_uid]["data"]["tools_ncc_offset_choice"]
-                ncc_offset = float(self.ncc_tools[tool_uid]["data"]["tools_ncc_offset_value"])
+                ncc_overlap = float(self.iso_tools[tool_uid]["data"]["tools_nccoverlap"]) / 100.0
+                ncc_margin = float(self.iso_tools[tool_uid]["data"]["tools_nccmargin"])
+                ncc_method = self.iso_tools[tool_uid]["data"]["tools_nccmethod"]
+                ncc_connect = self.iso_tools[tool_uid]["data"]["tools_nccconnect"]
+                ncc_contour = self.iso_tools[tool_uid]["data"]["tools_ncccontour"]
+                has_offset = self.iso_tools[tool_uid]["data"]["tools_ncc_offset_choice"]
+                ncc_offset = float(self.iso_tools[tool_uid]["data"]["tools_ncc_offset_value"])
 
                 # Get remaining tools offset
                 offset -= (tool - 1e-12)
@@ -2508,18 +2506,18 @@ class ToolIsolation(AppTool, Gerber):
                 tool = sorted_clear_tools.pop(0)
 
                 tool_uid = 0
-                for k, v in self.ncc_tools.items():
+                for k, v in self.iso_tools.items():
                     if float('%.*f' % (self.decimals, v['tooldia'])) == float('%.*f' % (self.decimals, tool)):
                         tool_uid = int(k)
                         break
 
-                ncc_overlap = float(self.ncc_tools[tool_uid]["data"]["tools_nccoverlap"]) / 100.0
-                ncc_margin = float(self.ncc_tools[tool_uid]["data"]["tools_nccmargin"])
-                ncc_method = self.ncc_tools[tool_uid]["data"]["tools_nccmethod"]
-                ncc_connect = self.ncc_tools[tool_uid]["data"]["tools_nccconnect"]
-                ncc_contour = self.ncc_tools[tool_uid]["data"]["tools_ncccontour"]
-                has_offset = self.ncc_tools[tool_uid]["data"]["tools_ncc_offset_choice"]
-                ncc_offset = float(self.ncc_tools[tool_uid]["data"]["tools_ncc_offset_value"])
+                ncc_overlap = float(self.iso_tools[tool_uid]["data"]["tools_nccoverlap"]) / 100.0
+                ncc_margin = float(self.iso_tools[tool_uid]["data"]["tools_nccmargin"])
+                ncc_method = self.iso_tools[tool_uid]["data"]["tools_nccmethod"]
+                ncc_connect = self.iso_tools[tool_uid]["data"]["tools_nccconnect"]
+                ncc_contour = self.iso_tools[tool_uid]["data"]["tools_ncccontour"]
+                has_offset = self.iso_tools[tool_uid]["data"]["tools_ncc_offset_choice"]
+                ncc_offset = float(self.iso_tools[tool_uid]["data"]["tools_ncc_offset_value"])
 
                 tool_used = tool - 1e-12
                 cleared_geo[:] = []
@@ -2844,7 +2842,7 @@ class ToolIsolation(AppTool, Gerber):
 
         # construct a list of all 'tooluid' in the self.tools
         tool_uid_list = []
-        for tooluid_key in self.ncc_tools:
+        for tooluid_key in self.iso_tools:
             tool_uid_item = int(tooluid_key)
             tool_uid_list.append(tool_uid_item)
 
@@ -2858,7 +2856,7 @@ class ToolIsolation(AppTool, Gerber):
         tooldia = float('%.*f' % (self.decimals, tooldia))
 
         tool_dias = []
-        for k, v in self.ncc_tools.items():
+        for k, v in self.iso_tools.items():
             for tool_v in v.keys():
                 if tool_v == 'tooldia':
                     tool_dias.append(float('%.*f' % (self.decimals, (v[tool_v]))))
@@ -2868,7 +2866,7 @@ class ToolIsolation(AppTool, Gerber):
             self.ui_connect()
             return 'fail'
 
-        self.ncc_tools.update({
+        self.iso_tools.update({
             tooluid: {
                 'tooldia': float('%.*f' % (self.decimals, tooldia)),
                 'offset': tool['offset'],
@@ -2879,7 +2877,7 @@ class ToolIsolation(AppTool, Gerber):
                 'solid_geometry': []
             }
         })
-        self.ncc_tools[tooluid]['data']['name'] = '_ncc'
+        self.iso_tools[tooluid]['data']['name'] = '_ncc'
 
         self.app.inform.emit('[success] %s' % _("New tool added to Tool Table."))
 

AppTools/ToolPaint.py

@@ -482,7 +482,7 @@ class ToolPaint(AppTool, Gerber):
 
         self.selectmethod_combo = FCComboBox()
         self.selectmethod_combo.addItems(
-            [_("Polygon Selection"), _("Area Selection"), _("All Polygons"), _("Reference Object")]
+            [_("Polygon Selection"), _("Area Selection"), _("All"), _("Reference Object")]
         )
         self.selectmethod_combo.setObjectName('p_selection')
 
@@ -1423,7 +1423,7 @@ class ToolPaint(AppTool, Gerber):
             self.app.inform.emit('[ERROR_NOTCL] %s' % _("No selected tools in Tool Table."))
             return
 
-        if self.select_method == _("All Polygons"):
+        if self.select_method == _("All"):
             self.paint_poly_all(self.paint_obj,
                                 tooldia=self.tooldia_list,
                                 outname=self.o_name)

App_Main.py

@@ -3855,9 +3855,9 @@ class App(QtCore.QObject):
             return
 
         # Keys in self.defaults for which to scale their values
-        dimensions = ['gerber_isotooldia', 'gerber_noncoppermargin', 'gerber_bboxmargin',
-                      "gerber_editor_newsize", "gerber_editor_lin_pitch", "gerber_editor_buff_f", "gerber_vtipdia",
-                      "gerber_vcutz", "gerber_editor_newdim", "gerber_editor_ma_low",
+        dimensions = ['tools_iso_tooldia', 'gerber_noncoppermargin', 'gerber_bboxmargin',
+                      "gerber_editor_newsize", "gerber_editor_lin_pitch", "gerber_editor_buff_f", "tools_iso_tool_vtipdia",
+                      "tools_iso_tool_cutz", "gerber_editor_newdim", "gerber_editor_ma_low",
                       "gerber_editor_ma_high",
 
                       'excellon_cutz', 'excellon_travelz', "excellon_toolchangexy", 'excellon_offset',

CHANGELOG.md

@@ -13,6 +13,7 @@ CHANGELOG for FlatCAM beta
 - Isolation Tool: reworked the GUI
 - if there is a Gerber object selected then in Isolation Tool the Gerber object combobox will show that object name as current
 - made the Project Tree items not editable by clicking on selected Tree items (the object rename can still be done in the Selected tab)
+- working on Isolation Tool: added a Preferences section in Edit -> Preferences and updated their usage within the Isolation tool
 
 25.05.2020
 

defaults.py

@@ -172,12 +172,6 @@ class FlatCAMDefaults:
                                "All Files (*.*)",
 
         # Gerber Options
-        "gerber_isotooldia": 0.1,
-        "gerber_isopasses": 1,
-        "gerber_isooverlap": 10,
-        "gerber_milling_type": "cl",
-        "gerber_combine_passes": False,
-        "gerber_iso_scope": _("All"),
         "gerber_noncoppermargin": 0.1,
         "gerber_noncopperrounded": False,
         "gerber_bboxmargin": 0.1,
@@ -188,11 +182,6 @@ class FlatCAMDefaults:
         "gerber_aperture_scale_factor": 1.0,
         "gerber_aperture_buffer_factor": 0.0,
         "gerber_follow": False,
-        "gerber_tool_type": 'C1',
-        "gerber_vtipdia": 0.1,
-        "gerber_vtipangle": 30,
-        "gerber_vcutz": -0.05,
-        "gerber_iso_type": "full",
         "gerber_buffering": "full",
         "gerber_simplification": False,
         "gerber_simp_tolerance": 0.0005,
@@ -391,6 +380,27 @@ class FlatCAMDefaults:
         "cncjob_annotation_fontsize": 9,
         "cncjob_annotation_fontcolor": '#990000',
 
+        # Isolation Routing Tool
+        "tools_iso_tooldia": "0.1",
+        "tools_iso_order": 'rev',
+        "tools_iso_tool_type": 'C1',
+        "tools_iso_tool_vtipdia": 0.1,
+        "tools_iso_tool_vtipangle": 30,
+        "tools_iso_tool_cutz": -0.05,
+        "tools_iso_newdia": 0.1,
+
+        "tools_iso_passes": 1,
+        "tools_iso_overlap": 10,
+        "tools_iso_milling_type": "cl",
+        "tools_iso_follow": False,
+        "tools_iso_isotype": "full",
+
+        "tools_iso_rest": False,
+        "tools_iso_combine_passes": False,
+        "tools_iso_isoexcept": False,
+        "tools_iso_selection": _("All"),
+        "tools_iso_area_shape": "square",
+
         # NCC Tool
         "tools_ncctools": "1.0, 0.5",
         "tools_nccorder": 'rev',
@@ -430,7 +440,7 @@ class FlatCAMDefaults:
         "tools_paintoverlap": 20,
         "tools_paintmargin": 0.0,
         "tools_paintmethod": _("Seed"),
-        "tools_selectmethod": _("All Polygons"),
+        "tools_selectmethod": _("All"),
         "tools_paint_area_shape": "square",
         "tools_pathconnect": True,
         "tools_paintcontour": True,

tclCommands/TclCommandIsolate.py

@@ -89,7 +89,7 @@ class TclCommandIsolate(TclCommandSignaled):
                 par = args['combine']
             args['combine'] = bool(eval(par))
         else:
-            args['combine'] = bool(eval(self.app.defaults["gerber_combine_passes"]))
+            args['combine'] = bool(eval(self.app.defaults["tools_iso_combine_passes"]))
 
         obj = self.app.collection.get_by_name(name)
         if obj is None:

tclCommands/TclCommandPaint.py

@@ -159,7 +159,7 @@ class TclCommandPaint(TclCommand):
 
         # used only to have correct information's in the obj.tools[tool]['data'] dict
         if "all" in args:
-            select = _("All Polygons")
+            select = _("All")
         elif "single" in args:
             select = _("Polygon Selection")
         else: