diff --git a/CHANGELOG.md b/CHANGELOG.md index 3345bf61..63d8ceb2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,10 @@ CHANGELOG for FlatCAM beta ================================================= +27.06.2020 + +- Drilling Tool - UI is working as expected; I will have to propagate the changes to other tools too, to increase likeness between different parts of the app + 25.06.2020 - made sure that when trying to view the source but no object is selected, the messages are correct diff --git a/Common.py b/Common.py index ee51773d..a8c0b382 100644 --- a/Common.py +++ b/Common.py @@ -406,6 +406,7 @@ class ExclusionAreas(QtCore.QObject): # since the exclusion areas should apply to all objects in the app collection, this check is limited to # only the current object therefore it will not guarantee success self.app.inform.emit("%s" % _("Exclusion areas added. Checking overlap with the object geometry ...")) + for el in self.exclusion_areas_storage: if el["shape"].intersects(unary_union(self.solid_geometry)): self.on_clear_area_click() @@ -413,8 +414,7 @@ class ExclusionAreas(QtCore.QObject): "[ERROR_NOTCL] %s" % _("Failed. Exclusion areas intersects the object geometry ...")) return - self.app.inform.emit( - "[success] %s" % _("Exclusion areas added.")) + self.app.inform.emit("[success] %s" % _("Exclusion areas added.")) self.cnc_button.setStyleSheet(""" QPushButton { diff --git a/appGUI/GUIElements.py b/appGUI/GUIElements.py index 78a04a65..15b92673 100644 --- a/appGUI/GUIElements.py +++ b/appGUI/GUIElements.py @@ -2418,8 +2418,8 @@ class FCTable(QtWidgets.QTableWidget): palette.color(QtGui.QPalette.Active, QtGui.QPalette.Highlight)) # make inactive rows text some color as active; may be useful in the future - # palette.setColor(QtGui.QPalette.Inactive, QtGui.QPalette.HighlightedText, - # palette.color(QtGui.QPalette.Active, QtGui.QPalette.HighlightedText)) + palette.setColor(QtGui.QPalette.Inactive, QtGui.QPalette.HighlightedText, + palette.color(QtGui.QPalette.Active, QtGui.QPalette.HighlightedText)) self.setPalette(palette) if drag_drop: diff --git a/appTools/ToolDrilling.py b/appTools/ToolDrilling.py index 210e5a68..fae5caa6 100644 --- a/appTools/ToolDrilling.py +++ b/appTools/ToolDrilling.py @@ -61,8 +61,8 @@ class ToolDrilling(AppTool, Excellon): # ############################################################################# # ######################### Tool GUI ########################################## # ############################################################################# - self.ui = DrillingUI(layout=self.layout, app=self.app) - self.toolName = self.ui.toolName + self.t_ui = DrillingUI(layout=self.layout, app=self.app) + self.toolName = self.t_ui.toolName # ############################################################################# # ########################## VARIABLES ######################################## @@ -70,6 +70,7 @@ class ToolDrilling(AppTool, Excellon): self.units = '' self.excellon_tools = {} self.tooluid = 0 + self.kind = "excellon" # dict that holds the object names and the option name # the key is the object name (defines in ObjectUI) for each UI element that is a parameter @@ -126,18 +127,18 @@ class ToolDrilling(AppTool, Excellon): self.poly_sel_disconnect_flag = False self.form_fields = { - "cutz": self.ui.cutz_entry, - "multidepth": self.ui.mpass_cb, - "depthperpass": self.ui.maxdepth_entry, - "travelz": self.ui.travelz_entry, - "feedrate_z": self.ui.feedrate_z_entry, - "feedrate_rapid": self.ui.feedrate_rapid_entry, + "cutz": self.t_ui.cutz_entry, + "multidepth": self.t_ui.mpass_cb, + "depthperpass": self.t_ui.maxdepth_entry, + "travelz": self.t_ui.travelz_entry, + "feedrate_z": self.t_ui.feedrate_z_entry, + "feedrate_rapid": self.t_ui.feedrate_rapid_entry, - "spindlespeed": self.ui.spindlespeed_entry, - "dwell": self.ui.dwell_cb, - "dwelltime": self.ui.dwelltime_entry, + "spindlespeed": self.t_ui.spindlespeed_entry, + "dwell": self.t_ui.dwell_cb, + "dwelltime": self.t_ui.dwelltime_entry, - "offset": self.ui.offset_entry + "offset": self.t_ui.offset_entry } self.name2option = { @@ -192,7 +193,7 @@ class ToolDrilling(AppTool, Excellon): self.build_ui() # all the tools are selected by default - self.ui.tools_table.selectAll() + self.t_ui.tools_table.selectAll() self.app.ui.notebook.setTabText(2, _("Drilling Tool")) @@ -201,22 +202,22 @@ class ToolDrilling(AppTool, Excellon): # ############################ SIGNALS ######################################## # ############################################################################# - self.ui.apply_param_to_all.clicked.connect(self.on_apply_param_to_all_clicked) - self.ui.generate_cnc_button.clicked.connect(self.on_cnc_button_click) - self.ui.tools_table.drag_drop_sig.connect(self.rebuild_ui) + self.t_ui.apply_param_to_all.clicked.connect(self.on_apply_param_to_all_clicked) + self.t_ui.generate_cnc_button.clicked.connect(self.on_cnc_button_click) + self.t_ui.tools_table.drag_drop_sig.connect(self.rebuild_ui) # Exclusion areas signals - self.ui.exclusion_table.horizontalHeader().sectionClicked.connect(self.exclusion_table_toggle_all) - self.ui.exclusion_table.lost_focus.connect(self.clear_selection) - self.ui.exclusion_table.itemClicked.connect(self.draw_sel_shape) - self.ui.add_area_button.clicked.connect(self.on_add_area_click) - self.ui.delete_area_button.clicked.connect(self.on_clear_area_click) - self.ui.delete_sel_area_button.clicked.connect(self.on_delete_sel_areas) - self.ui.strategy_radio.activated_custom.connect(self.on_strategy) + self.t_ui.exclusion_table.horizontalHeader().sectionClicked.connect(self.exclusion_table_toggle_all) + self.t_ui.exclusion_table.lost_focus.connect(self.clear_selection) + self.t_ui.exclusion_table.itemClicked.connect(self.draw_sel_shape) + self.t_ui.add_area_button.clicked.connect(self.on_add_area_click) + self.t_ui.delete_area_button.clicked.connect(self.on_clear_area_click) + self.t_ui.delete_sel_area_button.clicked.connect(self.on_delete_sel_areas) + self.t_ui.strategy_radio.activated_custom.connect(self.on_strategy) - self.ui.pp_excellon_name_cb.activated.connect(self.on_pp_changed) + self.t_ui.pp_excellon_name_cb.activated.connect(self.on_pp_changed) - self.ui.reset_button.clicked.connect(self.set_tool_ui) + self.t_ui.reset_button.clicked.connect(self.set_tool_ui) # Cleanup on Graceful exit (CTRL+ALT+X combo key) self.app.cleanup.connect(self.set_tool_ui) @@ -229,7 +230,7 @@ class ToolDrilling(AppTool, Excellon): selected_obj = self.app.collection.get_active() if selected_obj.kind == 'excellon': current_name = selected_obj.options['name'] - self.ui.object_combo.set_value(current_name) + self.t_ui.object_combo.set_value(current_name) except Exception: pass @@ -238,34 +239,34 @@ class ToolDrilling(AppTool, Excellon): # the HPGL preprocessor is only for Geometry not for Excellon job therefore don't add it if name == 'hpgl': continue - self.ui.pp_excellon_name_cb.addItem(name) + self.t_ui.pp_excellon_name_cb.addItem(name) # update the changes in UI depending on the selected preprocessor in Preferences # after this moment all the changes in the Posprocessor combo will be handled by the activated signal of the - # self.ui.pp_excellon_name_cb combobox + # self.t_ui.pp_excellon_name_cb combobox self.on_pp_changed() app_mode = self.app.defaults["global_app_level"] # Show/Hide Advanced Options if app_mode == 'b': - self.ui.level.setText('%s' % _('Basic')) - self.ui.estartz_label.hide() - self.ui.estartz_entry.hide() - self.ui.feedrate_rapid_label.hide() - self.ui.feedrate_rapid_entry.hide() - self.ui.pdepth_label.hide() - self.ui.pdepth_entry.hide() - self.ui.feedrate_probe_label.hide() - self.ui.feedrate_probe_entry.hide() + self.t_ui.level.setText('%s' % _('Basic')) + self.t_ui.estartz_label.hide() + self.t_ui.estartz_entry.hide() + self.t_ui.feedrate_rapid_label.hide() + self.t_ui.feedrate_rapid_entry.hide() + self.t_ui.pdepth_label.hide() + self.t_ui.pdepth_entry.hide() + self.t_ui.feedrate_probe_label.hide() + self.t_ui.feedrate_probe_entry.hide() else: - self.ui.level.setText('%s' % _('Advanced')) + self.t_ui.level.setText('%s' % _('Advanced')) - self.ui.tools_frame.show() + self.t_ui.tools_frame.show() - self.ui.order_radio.set_value(self.app.defaults["excellon_tool_order"]) + self.t_ui.order_radio.set_value(self.app.defaults["excellon_tool_order"]) - loaded_obj = self.app.collection.get_by_name(self.ui.object_combo.get_value()) + loaded_obj = self.app.collection.get_by_name(self.t_ui.object_combo.get_value()) if loaded_obj: outname = loaded_obj.options['name'] else: @@ -275,15 +276,15 @@ class ToolDrilling(AppTool, Excellon): self.default_data.clear() self.default_data = { "name": outname + '_drill', - "plot": self.app.defaults["excellon_plot"], - "solid": self.app.defaults["excellon_solid"], - "multicolored": self.app.defaults["excellon_multicolored"], - "merge_fuse_tools": self.app.defaults["excellon_merge_fuse_tools"], - "format_upper_in": self.app.defaults["excellon_format_upper_in"], - "format_lower_in": self.app.defaults["excellon_format_lower_in"], - "format_upper_mm": self.app.defaults["excellon_format_upper_mm"], - "lower_mm": self.app.defaults["excellon_format_lower_mm"], - "zeros": self.app.defaults["excellon_zeros"], + "plot": self.app.defaults["excellon_plot"], + "solid": self.app.defaults["excellon_solid"], + "multicolored": self.app.defaults["excellon_multicolored"], + "merge_fuse_tools": self.app.defaults["excellon_merge_fuse_tools"], + "format_upper_in": self.app.defaults["excellon_format_upper_in"], + "format_lower_in": self.app.defaults["excellon_format_lower_in"], + "format_upper_mm": self.app.defaults["excellon_format_upper_mm"], + "lower_mm": self.app.defaults["excellon_format_lower_mm"], + "zeros": self.app.defaults["excellon_zeros"], "excellon_units": self.app.defaults["excellon_units"], "excellon_update": self.app.defaults["excellon_update"], @@ -357,9 +358,9 @@ class ToolDrilling(AppTool, Excellon): # #######3 TEMP SETTINGS ################# # ######################################## - self.ui.tools_table.setRowCount(0) - self.ui.tools_table.setMinimumHeight(self.ui.tools_table.getHeight()) - self.ui.tools_table.setMaximumHeight(self.ui.tools_table.getHeight()) + self.t_ui.tools_table.setRowCount(2) + self.t_ui.tools_table.setMinimumHeight(self.t_ui.tools_table.getHeight()) + self.t_ui.tools_table.setMaximumHeight(self.t_ui.tools_table.getHeight()) if self.excellon_obj: # make sure to update the UI on init @@ -371,40 +372,43 @@ class ToolDrilling(AppTool, Excellon): # ####### Fill in the parameters ######### # ######################################## # ######################################## - self.ui.cutz_entry.set_value(self.app.defaults["excellon_cutz"]) - self.ui.mpass_cb.set_value(self.app.defaults["excellon_multidepth"]) - self.ui.maxdepth_entry.set_value(self.app.defaults["excellon_depthperpass"]) - self.ui.travelz_entry.set_value(self.app.defaults["excellon_travelz"]) - self.ui.feedrate_z_entry.set_value(self.app.defaults["excellon_feedrate_z"]) - self.ui.feedrate_rapid_entry.set_value(self.app.defaults["excellon_feedrate_rapid"]) - self.ui.spindlespeed_entry.set_value(self.app.defaults["excellon_spindlespeed"]) - self.ui.dwell_cb.set_value(self.app.defaults["excellon_dwell"]) - self.ui.dwelltime_entry.set_value(self.app.defaults["excellon_dwelltime"]) - self.ui.offset_entry.set_value(self.app.defaults["excellon_offset"]) - self.ui.toolchange_cb.set_value(self.app.defaults["excellon_toolchange"]) - self.ui.toolchangez_entry.set_value(self.app.defaults["excellon_toolchangez"]) - self.ui.estartz_entry.set_value(self.app.defaults["excellon_startz"]) - self.ui.endz_entry.set_value(self.app.defaults["excellon_endz"]) - self.ui.endxy_entry.set_value(self.app.defaults["excellon_endxy"]) - self.ui.pdepth_entry.set_value(self.app.defaults["excellon_z_pdepth"]) - self.ui.feedrate_probe_entry.set_value(self.app.defaults["excellon_feedrate_probe"]) - self.ui.exclusion_cb.set_value(self.app.defaults["excellon_area_exclusion"]) - self.ui.strategy_radio.set_value(self.app.defaults["excellon_area_strategy"]) - self.ui.over_z_entry.set_value(self.app.defaults["excellon_area_overz"]) - self.ui.area_shape_radio.set_value(self.app.defaults["excellon_area_shape"]) + self.t_ui.cutz_entry.set_value(self.app.defaults["excellon_cutz"]) + self.t_ui.mpass_cb.set_value(self.app.defaults["excellon_multidepth"]) + self.t_ui.maxdepth_entry.set_value(self.app.defaults["excellon_depthperpass"]) + self.t_ui.travelz_entry.set_value(self.app.defaults["excellon_travelz"]) + self.t_ui.feedrate_z_entry.set_value(self.app.defaults["excellon_feedrate_z"]) + self.t_ui.feedrate_rapid_entry.set_value(self.app.defaults["excellon_feedrate_rapid"]) + self.t_ui.spindlespeed_entry.set_value(self.app.defaults["excellon_spindlespeed"]) + self.t_ui.dwell_cb.set_value(self.app.defaults["excellon_dwell"]) + self.t_ui.dwelltime_entry.set_value(self.app.defaults["excellon_dwelltime"]) + self.t_ui.offset_entry.set_value(self.app.defaults["excellon_offset"]) + self.t_ui.toolchange_cb.set_value(self.app.defaults["excellon_toolchange"]) + self.t_ui.toolchangez_entry.set_value(self.app.defaults["excellon_toolchangez"]) + self.t_ui.estartz_entry.set_value(self.app.defaults["excellon_startz"]) + self.t_ui.endz_entry.set_value(self.app.defaults["excellon_endz"]) + self.t_ui.endxy_entry.set_value(self.app.defaults["excellon_endxy"]) + self.t_ui.pdepth_entry.set_value(self.app.defaults["excellon_z_pdepth"]) + self.t_ui.feedrate_probe_entry.set_value(self.app.defaults["excellon_feedrate_probe"]) + self.t_ui.exclusion_cb.set_value(self.app.defaults["excellon_area_exclusion"]) + self.t_ui.strategy_radio.set_value(self.app.defaults["excellon_area_strategy"]) + self.t_ui.over_z_entry.set_value(self.app.defaults["excellon_area_overz"]) + self.t_ui.area_shape_radio.set_value(self.app.defaults["excellon_area_shape"]) try: - self.ui.object_combo.currentTextChanged.disconnect() + self.t_ui.object_combo.currentTextChanged.disconnect() except (AttributeError, TypeError): pass - self.ui.object_combo.currentTextChanged.connect(self.on_object_changed) + self.t_ui.object_combo.currentTextChanged.connect(self.on_object_changed) def rebuild_ui(self): # read the table tools uid current_uid_list = [] - for row in range(self.ui.tools_table.rowCount()): - uid = int(self.ui.tools_table.item(row, 3).text()) - current_uid_list.append(uid) + for row in range(self.t_ui.tools_table.rowCount()): + try: + uid = int(self.t_ui.tools_table.item(row, 3).text()) + current_uid_list.append(uid) + except AttributeError: + continue new_tools = {} new_uid = 1 @@ -420,32 +424,43 @@ class ToolDrilling(AppTool, Excellon): def build_ui(self): log.debug("ToolDrilling.build_ui()") - self.ui_disconnect() - # updated units - self.units = self.app.defaults['units'].upper() - self.obj_name = self.ui.object_combo.currentText() - - # Get source object. - try: - self.excellon_obj = self.app.collection.get_by_name(self.obj_name) - except Exception: - self.app.inform.emit('[ERROR_NOTCL] %s: %s' % (_("Could not retrieve object"), str(self.obj_name))) - return - - if self.excellon_obj and self.excellon_obj.tools: - self.ui.exc_param_frame.setDisabled(False) - tools = [k for k in self.excellon_tools] + # order the tools by tool diameter if it's the case + sorted_tools = [] + for k, v in self.excellon_tools.items(): + sorted_tools.append(float('%.*f' % (self.decimals, float(v['tooldia'])))) + order = self.t_ui.order_radio.get_value() + if order == 'fwd': + sorted_tools.sort(reverse=False) + elif order == 'rev': + sorted_tools.sort(reverse=True) else: - self.ui.exc_param_frame.setDisabled(True) - self.ui.tools_table.setRowCount(0) + pass + + # remake the excellon_tools dict in the order above + new_id = 1 + new_tools = {} + for tooldia in sorted_tools: + for old_tool in self.excellon_tools: + if float('%.*f' % (self.decimals, float(self.excellon_tools[old_tool]['tooldia']))) == tooldia: + new_tools[new_id] = deepcopy(self.excellon_tools[old_tool]) + new_id += 1 + + self.excellon_tools = new_tools + + if self.excellon_obj and self.excellon_tools: + self.t_ui.exc_param_frame.setDisabled(False) + tools = [k for k in self.excellon_tools] + else: + self.t_ui.exc_param_frame.setDisabled(True) + self.t_ui.tools_table.setRowCount(2) tools = [] n = len(tools) # we have (n+2) rows because there are 'n' tools, each a row, plus the last 2 rows for totals. - self.ui.tools_table.setRowCount(n + 2) + self.t_ui.tools_table.setRowCount(n + 2) self.tool_row = 0 tot_drill_cnt = 0 @@ -469,30 +484,30 @@ class ToolDrilling(AppTool, Excellon): # Tool name/id exc_id_item = QtWidgets.QTableWidgetItem('%d' % int(tool_no)) - exc_id_item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled) - self.ui.tools_table.setItem(self.tool_row, 0, exc_id_item) + exc_id_item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsDragEnabled) + self.t_ui.tools_table.setItem(self.tool_row, 0, exc_id_item) # Tool Diameter dia_item = QtWidgets.QTableWidgetItem('%.*f' % (self.decimals, self.excellon_tools[tool_no]['tooldia'])) - dia_item.setFlags(QtCore.Qt.ItemIsEnabled) - self.ui.tools_table.setItem(self.tool_row, 1, dia_item) + dia_item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsDragEnabled) + self.t_ui.tools_table.setItem(self.tool_row, 1, dia_item) # Number of drills per tool drill_count_item = QtWidgets.QTableWidgetItem('%d' % drill_cnt) - drill_count_item.setFlags(QtCore.Qt.ItemIsEnabled) - self.ui.tools_table.setItem(self.tool_row, 2, drill_count_item) + drill_count_item.setFlags(QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsDragEnabled) + self.t_ui.tools_table.setItem(self.tool_row, 2, drill_count_item) # Tool unique ID tool_uid_item = QtWidgets.QTableWidgetItem(str(int(tool_no))) # ## REMEMBER: THIS COLUMN IS HIDDEN in UI - self.ui.tools_table.setItem(self.tool_row, 3, tool_uid_item) + self.t_ui.tools_table.setItem(self.tool_row, 3, tool_uid_item) # Number of slots per tool # if the slot number is zero is better to not clutter the GUI with zero's so we print a space slot_count_str = '%d' % slot_cnt if slot_cnt > 0 else '' slot_count_item = QtWidgets.QTableWidgetItem(slot_count_str) - slot_count_item.setFlags(QtCore.Qt.ItemIsEnabled) - self.ui.tools_table.setItem(self.tool_row, 4, slot_count_item) + slot_count_item.setFlags(QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsDragEnabled) + self.t_ui.tools_table.setItem(self.tool_row, 4, slot_count_item) self.tool_row += 1 @@ -508,18 +523,18 @@ class ToolDrilling(AppTool, Excellon): tot_drill_count = QtWidgets.QTableWidgetItem('%d' % tot_drill_cnt) tot_drill_count.setFlags(QtCore.Qt.ItemIsEnabled) - self.ui.tools_table.setItem(self.tool_row, 0, empty_1) - self.ui.tools_table.setItem(self.tool_row, 1, label_tot_drill_count) - self.ui.tools_table.setItem(self.tool_row, 2, tot_drill_count) # Total number of drills - self.ui.tools_table.setItem(self.tool_row, 4, empty_1_1) + self.t_ui.tools_table.setItem(self.tool_row, 0, empty_1) + self.t_ui.tools_table.setItem(self.tool_row, 1, label_tot_drill_count) + self.t_ui.tools_table.setItem(self.tool_row, 2, tot_drill_count) # Total number of drills + self.t_ui.tools_table.setItem(self.tool_row, 4, empty_1_1) font = QtGui.QFont() font.setBold(True) font.setWeight(75) for k in [1, 2]: - self.ui.tools_table.item(self.tool_row, k).setForeground(QtGui.QColor(127, 0, 255)) - self.ui.tools_table.item(self.tool_row, k).setFont(font) + self.t_ui.tools_table.item(self.tool_row, k).setForeground(QtGui.QColor(127, 0, 255)) + self.t_ui.tools_table.item(self.tool_row, k).setFont(font) self.tool_row += 1 @@ -534,29 +549,29 @@ class ToolDrilling(AppTool, Excellon): label_tot_slot_count.setFlags(QtCore.Qt.ItemIsEnabled) tot_slot_count.setFlags(QtCore.Qt.ItemIsEnabled) - self.ui.tools_table.setItem(self.tool_row, 0, empty_2) - self.ui.tools_table.setItem(self.tool_row, 1, label_tot_slot_count) - self.ui.tools_table.setItem(self.tool_row, 2, empty_2_1) - self.ui.tools_table.setItem(self.tool_row, 4, tot_slot_count) # Total number of slots + self.t_ui.tools_table.setItem(self.tool_row, 0, empty_2) + self.t_ui.tools_table.setItem(self.tool_row, 1, label_tot_slot_count) + self.t_ui.tools_table.setItem(self.tool_row, 2, empty_2_1) + self.t_ui.tools_table.setItem(self.tool_row, 4, tot_slot_count) # Total number of slots for kl in [1, 2, 4]: - self.ui.tools_table.item(self.tool_row, kl).setFont(font) - self.ui.tools_table.item(self.tool_row, kl).setForeground(QtGui.QColor(0, 70, 255)) + self.t_ui.tools_table.item(self.tool_row, kl).setFont(font) + self.t_ui.tools_table.item(self.tool_row, kl).setForeground(QtGui.QColor(0, 70, 255)) # make the diameter column editable - for row in range(self.ui.tools_table.rowCount() - 2): - self.ui.tools_table.item(row, 1).setFlags( - QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled) + # for row in range(self.t_ui.tools_table.rowCount() - 2): + # self.t_ui.tools_table.item(row, 1).setFlags( + # QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled) - self.ui.tools_table.resizeColumnsToContents() - self.ui.tools_table.resizeRowsToContents() + self.t_ui.tools_table.resizeColumnsToContents() + self.t_ui.tools_table.resizeRowsToContents() - vertical_header = self.ui.tools_table.verticalHeader() + vertical_header = self.t_ui.tools_table.verticalHeader() vertical_header.hide() - self.ui.tools_table.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff) + self.t_ui.tools_table.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff) - horizontal_header = self.ui.tools_table.horizontalHeader() - self.ui.tools_table.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff) + horizontal_header = self.t_ui.tools_table.horizontalHeader() + self.t_ui.tools_table.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff) horizontal_header.setMinimumSectionSize(10) horizontal_header.setDefaultSectionSize(70) @@ -567,17 +582,17 @@ class ToolDrilling(AppTool, Excellon): horizontal_header.setSectionResizeMode(2, QtWidgets.QHeaderView.ResizeToContents) horizontal_header.setSectionResizeMode(4, QtWidgets.QHeaderView.ResizeToContents) - self.ui.tools_table.setSortingEnabled(False) + self.t_ui.tools_table.setSortingEnabled(False) - self.ui.tools_table.setMinimumHeight(self.ui.tools_table.getHeight()) - self.ui.tools_table.setMaximumHeight(self.ui.tools_table.getHeight()) + self.t_ui.tools_table.setMinimumHeight(self.t_ui.tools_table.getHeight()) + self.t_ui.tools_table.setMaximumHeight(self.t_ui.tools_table.getHeight()) # all the tools are selected by default - self.ui.tools_table.selectAll() + # self.t_ui.tools_table.selectAll() # Build Exclusion Areas section e_len = len(self.app.exc_areas.exclusion_areas_storage) - self.ui.exclusion_table.setRowCount(e_len) + self.t_ui.exclusion_table.setRowCount(e_len) area_id = 0 @@ -588,28 +603,28 @@ class ToolDrilling(AppTool, Excellon): area_id_item = QtWidgets.QTableWidgetItem('%d' % int(area_id)) area_id_item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled) - self.ui.exclusion_table.setItem(area, 0, area_id_item) # Area id + self.t_ui.exclusion_table.setItem(area, 0, area_id_item) # Area id object_item = QtWidgets.QTableWidgetItem('%s' % area_dict["obj_type"]) object_item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled) - self.ui.exclusion_table.setItem(area, 1, object_item) # Origin Object + self.t_ui.exclusion_table.setItem(area, 1, object_item) # Origin Object strategy_item = QtWidgets.QTableWidgetItem('%s' % area_dict["strategy"]) strategy_item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled) - self.ui.exclusion_table.setItem(area, 2, strategy_item) # Strategy + self.t_ui.exclusion_table.setItem(area, 2, strategy_item) # Strategy overz_item = QtWidgets.QTableWidgetItem('%s' % area_dict["overz"]) overz_item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled) - self.ui.exclusion_table.setItem(area, 3, overz_item) # Over Z + self.t_ui.exclusion_table.setItem(area, 3, overz_item) # Over Z - self.ui.exclusion_table.resizeColumnsToContents() - self.ui.exclusion_table.resizeRowsToContents() + self.t_ui.exclusion_table.resizeColumnsToContents() + self.t_ui.exclusion_table.resizeRowsToContents() - area_vheader = self.ui.exclusion_table.verticalHeader() + area_vheader = self.t_ui.exclusion_table.verticalHeader() area_vheader.hide() - self.ui.exclusion_table.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff) + self.t_ui.exclusion_table.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff) - area_hheader = self.ui.exclusion_table.horizontalHeader() + area_hheader = self.t_ui.exclusion_table.horizontalHeader() area_hheader.setMinimumSectionSize(10) area_hheader.setDefaultSectionSize(70) @@ -620,29 +635,38 @@ class ToolDrilling(AppTool, Excellon): area_hheader.setSectionResizeMode(3, QtWidgets.QHeaderView.ResizeToContents) # area_hheader.setStretchLastSection(True) - self.ui.exclusion_table.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff) + self.t_ui.exclusion_table.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff) - self.ui.exclusion_table.setColumnWidth(0, 20) + self.t_ui.exclusion_table.setColumnWidth(0, 20) - self.ui.exclusion_table.setMinimumHeight(self.ui.exclusion_table.getHeight()) - self.ui.exclusion_table.setMaximumHeight(self.ui.exclusion_table.getHeight()) + self.t_ui.exclusion_table.setMinimumHeight(self.t_ui.exclusion_table.getHeight()) + self.t_ui.exclusion_table.setMaximumHeight(self.t_ui.exclusion_table.getHeight()) self.ui_connect() # set the text on tool_data_label after loading the object sel_rows = set() - sel_items = self.ui.tools_table.selectedItems() + sel_items = self.t_ui.tools_table.selectedItems() for it in sel_items: sel_rows.add(it.row()) if len(sel_rows) > 1: - self.ui.tool_data_label.setText( + self.t_ui.tool_data_label.setText( "%s: %s" % (_('Parameters for'), _("Multiple Tools")) ) + elif len(sel_rows) == 1: + # update the QLabel that shows for which Tool we have the parameters in the UI form + toolnr = int(self.t_ui.tools_table.item(list(sel_rows)[0], 0).text()) + self.t_ui.tool_data_label.setText( + "%s: %s %d" % (_('Parameters for'), _("Tool"), toolnr) + ) def on_object_changed(self): log.debug("ToolDrilling.on_object_changed()") + # updated units + self.units = self.app.defaults['units'].upper() + # load the Excellon object - self.obj_name = self.ui.object_combo.currentText() + self.obj_name = self.t_ui.object_combo.currentText() # Get source object. try: @@ -651,28 +675,31 @@ class ToolDrilling(AppTool, Excellon): self.app.inform.emit('[ERROR_NOTCL] %s: %s' % (_("Could not retrieve object"), str(self.obj_name))) return + self.excellon_tools = self.excellon_obj.tools + if self.excellon_obj is None: - self.ui.exc_param_frame.setDisabled(True) + self.t_ui.exc_param_frame.setDisabled(True) self.set_tool_ui() else: - self.ui.exc_param_frame.setDisabled(False) + self.app.collection.set_active(self.obj_name) + self.t_ui.exc_param_frame.setDisabled(False) self.excellon_tools = self.excellon_obj.tools self.build_ui() sel_rows = set() - table_items = self.ui.tools_table.selectedItems() + table_items = self.t_ui.tools_table.selectedItems() if table_items: for it in table_items: sel_rows.add(it.row()) if not sel_rows or len(sel_rows) == 0: - self.ui.generate_cnc_button.setDisabled(True) - self.ui.tool_data_label.setText( + self.t_ui.generate_cnc_button.setDisabled(True) + self.t_ui.tool_data_label.setText( "%s: %s" % (_('Parameters for'), _("No Tool Selected")) ) else: - self.ui.generate_cnc_button.setDisabled(False) + self.t_ui.generate_cnc_button.setDisabled(False) def ui_connect(self): @@ -686,8 +713,8 @@ class ToolDrilling(AppTool, Excellon): self.app.exc_areas.e_shape_modified.connect(self.update_exclusion_table) # rows selected - self.ui.tools_table.clicked.connect(self.on_row_selection_change) - self.ui.tools_table.horizontalHeader().sectionClicked.connect(self.on_toggle_all_rows) + self.t_ui.tools_table.clicked.connect(self.on_row_selection_change) + self.t_ui.tools_table.horizontalHeader().sectionClicked.connect(self.on_toggle_all_rows) # Tool Parameters for opt in self.form_fields: @@ -701,24 +728,24 @@ class ToolDrilling(AppTool, Excellon): elif isinstance(current_widget, FCComboBox): current_widget.currentIndexChanged.connect(self.form_to_storage) - self.ui.order_radio.activated_custom[str].connect(self.on_order_changed) + self.t_ui.order_radio.activated_custom[str].connect(self.on_order_changed) def ui_disconnect(self): # rows selected try: - self.ui.tools_table.clicked.disconnect() + self.t_ui.tools_table.clicked.disconnect(self.on_row_selection_change) except (TypeError, AttributeError): pass try: - self.ui.tools_table.horizontalHeader().sectionClicked.disconnect() + self.t_ui.tools_table.horizontalHeader().sectionClicked.disconnect(self.on_toggle_all_rows) except (TypeError, AttributeError): pass # tool table widgets - for row in range(self.ui.tools_table.rowCount()): + for row in range(self.t_ui.tools_table.rowCount()): try: - self.ui.tools_table.cellWidget(row, 2).currentIndexChanged.disconnect() + self.t_ui.tools_table.cellWidget(row, 2).currentIndexChanged.disconnect() except (TypeError, AttributeError): pass @@ -747,7 +774,7 @@ class ToolDrilling(AppTool, Excellon): pass try: - self.ui.order_radio.activated_custom[str].disconnect() + self.t_ui.order_radio.activated_custom[str].disconnect() except (TypeError, ValueError): pass @@ -757,7 +784,7 @@ class ToolDrilling(AppTool, Excellon): :return: """ - sel_model = self.ui.tools_table.selectionModel() + sel_model = self.t_ui.tools_table.selectionModel() sel_indexes = sel_model.selectedIndexes() # it will iterate over all indexes which means all items in all columns too but I'm interested only on rows @@ -765,10 +792,12 @@ class ToolDrilling(AppTool, Excellon): for idx in sel_indexes: sel_rows.add(idx.row()) - if len(sel_rows) == self.ui.tools_table.rowCount(): - self.ui.tools_table.clearSelection() + if len(sel_rows) == self.t_ui.tools_table.rowCount(): + self.t_ui.tools_table.clearSelection() + self.t_ui.exc_param_frame.setDisabled(True) else: - self.ui.tools_table.selectAll() + self.t_ui.tools_table.selectAll() + self.t_ui.exc_param_frame.setDisabled(False) self.update_ui() def on_row_selection_change(self): @@ -778,37 +807,39 @@ class ToolDrilling(AppTool, Excellon): self.blockSignals(True) sel_rows = set() - table_items = self.ui.tools_table.selectedItems() + table_items = self.t_ui.tools_table.selectedItems() if table_items: for it in table_items: sel_rows.add(it.row()) - # sel_rows = sorted(set(index.row() for index in self.ui.tools_table.selectedIndexes())) + # sel_rows = sorted(set(index.row() for index in self.t_ui.tools_table.selectedIndexes())) if not sel_rows or len(sel_rows) == 0: - self.ui.generate_cnc_button.setDisabled(True) - self.ui.tool_data_label.setText( + self.t_ui.generate_cnc_button.setDisabled(True) + self.t_ui.exc_param_frame.setDisabled(True) + self.t_ui.tool_data_label.setText( "%s: %s" % (_('Parameters for'), _("No Tool Selected")) ) self.blockSignals(False) return else: - self.ui.generate_cnc_button.setDisabled(False) + self.t_ui.generate_cnc_button.setDisabled(False) + self.t_ui.exc_param_frame.setDisabled(False) if len(sel_rows) == 1: # update the QLabel that shows for which Tool we have the parameters in the UI form - tooluid = int(self.ui.tools_table.item(list(sel_rows)[0], 0).text()) - self.ui.tool_data_label.setText( + tooluid = int(self.t_ui.tools_table.item(list(sel_rows)[0], 0).text()) + self.t_ui.tool_data_label.setText( "%s: %s %d" % (_('Parameters for'), _("Tool"), tooluid) ) else: - self.ui.tool_data_label.setText( + self.t_ui.tool_data_label.setText( "%s: %s" % (_('Parameters for'), _("Multiple Tools")) ) for c_row in sel_rows: # populate the form with the data from the tool associated with the row parameter try: - item = self.ui.tools_table.item(c_row, 3) + item = self.t_ui.tools_table.item(c_row, 3) if type(item) is not None: tooluid = int(item.text()) self.storage_to_form(self.excellon_tools[tooluid]['data']) @@ -847,7 +878,7 @@ class ToolDrilling(AppTool, Excellon): :return: None :rtype: """ - if self.ui.tools_table.rowCount() == 2: + if self.t_ui.tools_table.rowCount() == 2: # there is no tool in tool table so we can't save the GUI elements values to storage # Excellon Tool Table has 2 rows by default return @@ -858,12 +889,12 @@ class ToolDrilling(AppTool, Excellon): wdg_objname = widget_changed.objectName() option_changed = self.name2option[wdg_objname] - # row = self.ui.tools_table.currentRow() - rows = sorted(set(index.row() for index in self.ui.tools_table.selectedIndexes())) + # row = self.t_ui.tools_table.currentRow() + rows = sorted(list(set(index.row() for index in self.t_ui.tools_table.selectedIndexes()))) for row in rows: if row < 0: row = 0 - tooluid_item = int(self.ui.tools_table.item(row, 3).text()) + tooluid_item = int(self.t_ui.tools_table.item(row, 3).text()) for tooluid_key, tooluid_val in self.excellon_tools.items(): if int(tooluid_key) == tooluid_item: @@ -884,7 +915,7 @@ class ToolDrilling(AppTool, Excellon): :rtype: list """ - return [str(x.text()) for x in self.ui.tools_table.selectedItems()] + return [str(x.text()) for x in self.t_ui.tools_table.selectedItems()] def get_selected_tools_table_items(self): """ @@ -894,41 +925,41 @@ class ToolDrilling(AppTool, Excellon): :rtype: list """ table_tools_items = [] - for x in self.ui.tools_table.selectedItems(): + for x in self.t_ui.tools_table.selectedItems(): # from the columnCount we subtract a value of 1 which represent the last column (plot column) # which does not have text txt = '' elem = [] - for column in range(0, self.ui.tools_table.columnCount() - 1): + for column in range(0, self.t_ui.tools_table.columnCount() - 1): try: - txt = self.ui.tools_table.item(x.row(), column).text() + txt = self.t_ui.tools_table.item(x.row(), column).text() except AttributeError: try: - txt = self.ui.tools_table.cellWidget(x.row(), column).currentText() + txt = self.t_ui.tools_table.cellWidget(x.row(), column).currentText() except AttributeError: pass elem.append(txt) table_tools_items.append(deepcopy(elem)) - # table_tools_items.append([self.ui.tools_table.item(x.row(), column).text() - # for column in range(0, self.ui.tools_table.columnCount() - 1)]) + # table_tools_items.append([self.t_ui.tools_table.item(x.row(), column).text() + # for column in range(0, self.t_ui.tools_table.columnCount() - 1)]) for item in table_tools_items: item[0] = str(item[0]) return table_tools_items def on_apply_param_to_all_clicked(self): - if self.ui.tools_table.rowCount() == 0: + if self.t_ui.tools_table.rowCount() == 0: # there is no tool in tool table so we can't save the GUI elements values to storage log.debug("ToolDrilling.on_apply_param_to_all_clicked() --> no tool in Tools Table, aborting.") return self.blockSignals(True) - row = self.ui.tools_table.currentRow() + row = self.t_ui.tools_table.currentRow() if row < 0: row = 0 - tooluid_item = int(self.ui.tools_table.item(row, 3).text()) + tooluid_item = int(self.t_ui.tools_table.item(row, 3).text()) temp_tool_data = {} for tooluid_key, tooluid_val in self.excellon_tools.items(): @@ -953,11 +984,11 @@ class ToolDrilling(AppTool, Excellon): assert isinstance(cw, QtWidgets.QComboBox), \ "Expected a QtWidgets.QComboBox, got %s" % isinstance(cw, QtWidgets.QComboBox) - cw_index = self.ui.tools_table.indexAt(cw.pos()) + cw_index = self.t_ui.tools_table.indexAt(cw.pos()) cw_row = cw_index.row() cw_col = cw_index.column() - current_uid = int(self.ui.tools_table.item(cw_row, 3).text()) + current_uid = int(self.t_ui.tools_table.item(cw_row, 3).text()) # if the sender is in the column with index 2 then we update the tool_type key if cw_col == 2: @@ -1203,94 +1234,94 @@ class ToolDrilling(AppTool, Excellon): return True, "" def on_pp_changed(self): - current_pp = self.ui.pp_excellon_name_cb.get_value() + current_pp = self.t_ui.pp_excellon_name_cb.get_value() if "toolchange_probe" in current_pp.lower(): - self.ui.pdepth_entry.setVisible(True) - self.ui.pdepth_label.show() + self.t_ui.pdepth_entry.setVisible(True) + self.t_ui.pdepth_label.show() - self.ui.feedrate_probe_entry.setVisible(True) - self.ui.feedrate_probe_label.show() + self.t_ui.feedrate_probe_entry.setVisible(True) + self.t_ui.feedrate_probe_label.show() else: - self.ui.pdepth_entry.setVisible(False) - self.ui.pdepth_label.hide() + self.t_ui.pdepth_entry.setVisible(False) + self.t_ui.pdepth_label.hide() - self.ui.feedrate_probe_entry.setVisible(False) - self.ui.feedrate_probe_label.hide() + self.t_ui.feedrate_probe_entry.setVisible(False) + self.t_ui.feedrate_probe_label.hide() if 'marlin' in current_pp.lower() or 'custom' in current_pp.lower(): - self.ui.feedrate_rapid_label.show() - self.ui.feedrate_rapid_entry.show() + self.t_ui.feedrate_rapid_label.show() + self.t_ui.feedrate_rapid_entry.show() else: - self.ui.feedrate_rapid_label.hide() - self.ui.feedrate_rapid_entry.hide() + self.t_ui.feedrate_rapid_label.hide() + self.t_ui.feedrate_rapid_entry.hide() if 'laser' in current_pp.lower(): - self.ui.cutzlabel.hide() - self.ui.cutz_entry.hide() + self.t_ui.cutzlabel.hide() + self.t_ui.cutz_entry.hide() try: - self.ui.mpass_cb.hide() - self.ui.maxdepth_entry.hide() + self.t_ui.mpass_cb.hide() + self.t_ui.maxdepth_entry.hide() except AttributeError: pass if 'marlin' in current_pp.lower(): - self.ui.travelzlabel.setText('%s:' % _("Focus Z")) - self.ui.endz_label.show() - self.ui.endz_entry.show() + self.t_ui.travelzlabel.setText('%s:' % _("Focus Z")) + self.t_ui.endz_label.show() + self.t_ui.endz_entry.show() else: - self.ui.travelzlabel.hide() - self.ui.travelz_entry.hide() + self.t_ui.travelzlabel.hide() + self.t_ui.travelz_entry.hide() - self.ui.endz_label.hide() - self.ui.endz_entry.hide() + self.t_ui.endz_label.hide() + self.t_ui.endz_entry.hide() try: - self.ui.frzlabel.hide() - self.ui.feedrate_z_entry.hide() + self.t_ui.frzlabel.hide() + self.t_ui.feedrate_z_entry.hide() except AttributeError: pass - self.ui.dwell_cb.hide() - self.ui.dwelltime_entry.hide() + self.t_ui.dwell_cb.hide() + self.t_ui.dwelltime_entry.hide() - self.ui.spindle_label.setText('%s:' % _("Laser Power")) + self.t_ui.spindle_label.setText('%s:' % _("Laser Power")) try: - self.ui.tool_offset_label.hide() - self.ui.offset_entry.hide() + self.t_ui.tool_offset_label.hide() + self.t_ui.offset_entry.hide() except AttributeError: pass else: - self.ui.cutzlabel.show() - self.ui.cutz_entry.show() + self.t_ui.cutzlabel.show() + self.t_ui.cutz_entry.show() try: - self.ui.mpass_cb.show() - self.ui.maxdepth_entry.show() + self.t_ui.mpass_cb.show() + self.t_ui.maxdepth_entry.show() except AttributeError: pass - self.ui.travelzlabel.setText('%s:' % _('Travel Z')) + self.t_ui.travelzlabel.setText('%s:' % _('Travel Z')) - self.ui.travelzlabel.show() - self.ui.travelz_entry.show() + self.t_ui.travelzlabel.show() + self.t_ui.travelz_entry.show() - self.ui.endz_label.show() - self.ui.endz_entry.show() + self.t_ui.endz_label.show() + self.t_ui.endz_entry.show() try: - self.ui.frzlabel.show() - self.ui.feedrate_z_entry.show() + self.t_ui.frzlabel.show() + self.t_ui.feedrate_z_entry.show() except AttributeError: pass - self.ui.dwell_cb.show() - self.ui.dwelltime_entry.show() + self.t_ui.dwell_cb.show() + self.t_ui.dwelltime_entry.show() - self.ui.spindle_label.setText('%s:' % _('Spindle speed')) + self.t_ui.spindle_label.setText('%s:' % _('Spindle speed')) try: - # self.ui.tool_offset_lbl.show() - self.ui.offset_entry.show() + # self.t_ui.tool_offset_lbl.show() + self.t_ui.offset_entry.show() except AttributeError: pass @@ -1339,12 +1370,12 @@ class ToolDrilling(AppTool, Excellon): self.delete_tool_selection_shape() def on_add_area_click(self): - shape_button = self.ui.area_shape_radio - overz_button = self.ui.over_z_entry - strategy_radio = self.ui.strategy_radio - cnc_button = self.ui.generate_cnc_button - solid_geo = self.solid_geometry - obj_type = self.kind + shape_button = self.t_ui.area_shape_radio + overz_button = self.t_ui.over_z_entry + strategy_radio = self.t_ui.strategy_radio + cnc_button = self.t_ui.generate_cnc_button + solid_geo = self.excellon_obj.solid_geometry + obj_type = self.excellon_obj.kind self.app.exc_areas.on_add_area_click( shape_button=shape_button, overz_button=overz_button, cnc_button=cnc_button, strategy_radio=strategy_radio, @@ -1359,7 +1390,7 @@ class ToolDrilling(AppTool, Excellon): self.app.exc_areas.e_shape_modified.emit() def on_delete_sel_areas(self): - sel_model = self.ui.exclusion_table.selectionModel() + sel_model = self.t_ui.exclusion_table.selectionModel() sel_indexes = sel_model.selectedIndexes() # it will iterate over all indexes which means all items in all columns too but I'm interested only on rows @@ -1376,7 +1407,7 @@ class ToolDrilling(AppTool, Excellon): self.app.exc_areas.e_shape_modified.emit() def draw_sel_shape(self): - sel_model = self.ui.exclusion_table.selectionModel() + sel_model = self.t_ui.exclusion_table.selectionModel() sel_indexes = sel_model.selectedIndexes() # it will iterate over all indexes which means all items in all columns too but I'm interested only on rows @@ -1402,24 +1433,24 @@ class ToolDrilling(AppTool, Excellon): def clear_selection(self): self.app.delete_selection_shape() - # self.ui.exclusion_table.clearSelection() + # self.t_ui.exclusion_table.clearSelection() def delete_sel_shape(self): self.app.delete_selection_shape() def update_exclusion_table(self): - self.exclusion_area_cb_is_checked = True if self.ui.exclusion_cb.isChecked() else False + self.exclusion_area_cb_is_checked = True if self.t_ui.exclusion_cb.isChecked() else False self.build_ui() - self.ui.exclusion_cb.set_value(self.exclusion_area_cb_is_checked) + self.t_ui.exclusion_cb.set_value(self.exclusion_area_cb_is_checked) def on_strategy(self, val): if val == 'around': - self.ui.over_z_label.setDisabled(True) - self.ui.over_z_entry.setDisabled(True) + self.t_ui.over_z_label.setDisabled(True) + self.t_ui.over_z_entry.setDisabled(True) else: - self.ui.over_z_label.setDisabled(False) - self.ui.over_z_entry.setDisabled(False) + self.t_ui.over_z_label.setDisabled(False) + self.t_ui.over_z_entry.setDisabled(False) def exclusion_table_toggle_all(self): """ @@ -1427,7 +1458,7 @@ class ToolDrilling(AppTool, Excellon): :return: """ - sel_model = self.ui.exclusion_table.selectionModel() + sel_model = self.t_ui.exclusion_table.selectionModel() sel_indexes = sel_model.selectedIndexes() # it will iterate over all indexes which means all items in all columns too but I'm interested only on rows @@ -1436,14 +1467,14 @@ class ToolDrilling(AppTool, Excellon): sel_rows.add(idx.row()) if sel_rows: - self.ui.exclusion_table.clearSelection() + self.t_ui.exclusion_table.clearSelection() self.delete_sel_shape() else: - self.ui.exclusion_table.selectAll() + self.t_ui.exclusion_table.selectAll() self.draw_sel_shape() def on_cnc_button_click(self): - obj_name = self.ui.object_combo.currentText() + obj_name = self.t_ui.object_combo.currentText() # Get source object. try: @@ -1458,8 +1489,8 @@ class ToolDrilling(AppTool, Excellon): # Get the tools from the Tool Table selected_uid = set() - for it in self.ui.tools_table.selectedItems(): - uid = self.ui.tools_table.item(it.row(), 3).text() + for it in self.t_ui.tools_table.selectedItems(): + uid = self.t_ui.tools_table.item(it.row(), 3).text() selected_uid.add(uid) tools = list(selected_uid) @@ -1467,8 +1498,8 @@ class ToolDrilling(AppTool, Excellon): # if there is a single tool in the table (remember that the last 2 rows are for totals and do not count in # tool number) it means that there are 3 rows (1 tool and 2 totals). # in this case regardless of the selection status of that tool, use it. - if self.ui.tools_table.rowCount() == 3: - tools.append(self.ui.tools_table.item(0, 0).text()) + if self.t_ui.tools_table.rowCount() == 3: + tools.append(self.t_ui.tools_table.item(0, 0).text()) else: self.app.inform.emit('[ERROR_NOTCL] %s' % _("Please select one or more tools from the list and try again.")) @@ -1480,14 +1511,14 @@ class ToolDrilling(AppTool, Excellon): ymax = self.excellon_obj.options['ymax'] job_name = self.excellon_obj.options["name"] + "_cnc" - pp_excellon_name = self.ui.pp_excellon_name_cb.get_value() - # z_pdepth = self.ui.pdepth_entry.get_value() - # feedrate_probe = self.ui.feedrate_probe_entry.get_value() - # toolchange = self.ui.toolchange_cb.get_value() - # z_toolchange = self.ui.toolchangez_entry.get_value() - # startz = self.ui.estartz_entry.get_value() - # endz = self.ui.endz_entry.get_value() - # xy_end = self.ui.endxy_entry.get_value() + pp_excellon_name = self.t_ui.pp_excellon_name_cb.get_value() + # z_pdepth = self.t_ui.pdepth_entry.get_value() + # feedrate_probe = self.t_ui.feedrate_probe_entry.get_value() + # toolchange = self.t_ui.toolchange_cb.get_value() + # z_toolchange = self.t_ui.toolchangez_entry.get_value() + # startz = self.t_ui.estartz_entry.get_value() + # endz = self.t_ui.endz_entry.get_value() + # xy_end = self.t_ui.endxy_entry.get_value() # Object initialization function for app.app_obj.new_object() def job_init(job_obj, app_obj): diff --git a/appTools/ToolIsolation.py b/appTools/ToolIsolation.py index 1b54d31f..b50dda27 100644 --- a/appTools/ToolIsolation.py +++ b/appTools/ToolIsolation.py @@ -46,20 +46,20 @@ class ToolIsolation(AppTool, Gerber): # ############################################################################# # ######################### Tool GUI ########################################## # ############################################################################# - self.ui = IsoUI(layout=self.layout, app=self.app) - self.toolName = self.ui.toolName + self.t_ui = IsoUI(layout=self.layout, app=self.app) + self.toolName = self.t_ui.toolName # ############################################################################# # ###################### Setup CONTEXT MENU ################################### # ############################################################################# - self.ui.tools_table.setupContextMenu() - self.ui.tools_table.addContextMenu( + self.t_ui.tools_table.setupContextMenu() + self.t_ui.tools_table.addContextMenu( _("Add"), self.on_add_tool_by_key, icon=QtGui.QIcon(self.app.resource_location + "/plus16.png") ) - self.ui.tools_table.addContextMenu( + self.t_ui.tools_table.addContextMenu( _("Add from DB"), self.on_add_tool_by_key, icon=QtGui.QIcon(self.app.resource_location + "/plus16.png") ) - self.ui.tools_table.addContextMenu( + self.t_ui.tools_table.addContextMenu( _("Delete"), lambda: self.on_tool_delete(rows_to_delete=None, all_tools=None), icon=QtGui.QIcon(self.app.resource_location + "/delete32.png") @@ -122,12 +122,12 @@ class ToolIsolation(AppTool, Gerber): self.poly_sel_disconnect_flag = False self.form_fields = { - "tools_iso_passes": self.ui.passes_entry, - "tools_iso_overlap": self.ui.iso_overlap_entry, - "tools_iso_milling_type": self.ui.milling_type_radio, - "tools_iso_combine": self.ui.combine_passes_cb, - "tools_iso_follow": self.ui.follow_cb, - "tools_iso_isotype": self.ui.iso_type_radio + "tools_iso_passes": self.t_ui.passes_entry, + "tools_iso_overlap": self.t_ui.iso_overlap_entry, + "tools_iso_milling_type": self.t_ui.milling_type_radio, + "tools_iso_combine": self.t_ui.combine_passes_cb, + "tools_iso_follow": self.t_ui.follow_cb, + "tools_iso_isotype": self.t_ui.iso_type_radio } self.name2option = { @@ -179,7 +179,7 @@ class ToolIsolation(AppTool, Gerber): self.build_ui() # all the tools are selected by default - self.ui.tools_table.selectAll() + self.t_ui.tools_table.selectAll() self.app.ui.notebook.setTabText(2, _("Isolation Tool")) @@ -187,34 +187,34 @@ class ToolIsolation(AppTool, Gerber): # ############################################################################# # ############################ SIGNALS ######################################## # ############################################################################# - self.ui.addtool_btn.clicked.connect(self.on_tool_add) - self.ui.addtool_entry.returnPressed.connect(self.on_tooldia_updated) - self.ui.deltool_btn.clicked.connect(self.on_tool_delete) + self.t_ui.addtool_btn.clicked.connect(self.on_tool_add) + self.t_ui.addtool_entry.returnPressed.connect(self.on_tooldia_updated) + self.t_ui.deltool_btn.clicked.connect(self.on_tool_delete) - self.ui.tipdia_entry.returnPressed.connect(self.on_calculate_tooldia) - self.ui.tipangle_entry.returnPressed.connect(self.on_calculate_tooldia) - self.ui.cutz_entry.returnPressed.connect(self.on_calculate_tooldia) + self.t_ui.tipdia_entry.returnPressed.connect(self.on_calculate_tooldia) + self.t_ui.tipangle_entry.returnPressed.connect(self.on_calculate_tooldia) + self.t_ui.cutz_entry.returnPressed.connect(self.on_calculate_tooldia) - self.ui.reference_combo_type.currentIndexChanged.connect(self.on_reference_combo_changed) - self.ui.select_combo.currentIndexChanged.connect(self.on_toggle_reference) + self.t_ui.reference_combo_type.currentIndexChanged.connect(self.on_reference_combo_changed) + self.t_ui.select_combo.currentIndexChanged.connect(self.on_toggle_reference) - self.ui.type_excobj_radio.activated_custom.connect(self.on_type_excobj_index_changed) - self.ui.apply_param_to_all.clicked.connect(self.on_apply_param_to_all_clicked) - self.ui.addtool_from_db_btn.clicked.connect(self.on_tool_add_from_db_clicked) + self.t_ui.type_excobj_radio.activated_custom.connect(self.on_type_excobj_index_changed) + self.t_ui.apply_param_to_all.clicked.connect(self.on_apply_param_to_all_clicked) + self.t_ui.addtool_from_db_btn.clicked.connect(self.on_tool_add_from_db_clicked) - self.ui.generate_iso_button.clicked.connect(self.on_iso_button_click) - self.ui.reset_button.clicked.connect(self.set_tool_ui) + self.t_ui.generate_iso_button.clicked.connect(self.on_iso_button_click) + self.t_ui.reset_button.clicked.connect(self.set_tool_ui) # Cleanup on Graceful exit (CTRL+ALT+X combo key) self.app.cleanup.connect(self.set_tool_ui) def on_type_excobj_index_changed(self, val): obj_type = 0 if val == 'gerber' else 2 - self.ui.exc_obj_combo.setRootModelIndex(self.app.collection.index(obj_type, 0, QtCore.QModelIndex())) - self.ui.exc_obj_combo.setCurrentIndex(0) - self.ui.exc_obj_combo.obj_type = { + self.t_ui.exc_obj_combo.setRootModelIndex(self.app.collection.index(obj_type, 0, QtCore.QModelIndex())) + self.t_ui.exc_obj_combo.setCurrentIndex(0) + self.t_ui.exc_obj_combo.obj_type = { "gerber": "Gerber", "geometry": "Geometry" - }[self.ui.type_excobj_radio.get_value()] + }[self.t_ui.type_excobj_radio.get_value()] def set_tool_ui(self): self.units = self.app.defaults['units'].upper() @@ -225,7 +225,7 @@ class ToolIsolation(AppTool, Gerber): selected_obj = self.app.collection.get_active() if selected_obj.kind == 'gerber': current_name = selected_obj.options['name'] - self.ui.object_combo.set_value(current_name) + self.t_ui.object_combo.set_value(current_name) except Exception: pass @@ -233,101 +233,101 @@ class ToolIsolation(AppTool, Gerber): # Show/Hide Advanced Options if app_mode == 'b': - self.ui.level.setText('%s' % _('Basic')) + self.t_ui.level.setText('%s' % _('Basic')) # override the Preferences Value; in Basic mode the Tool Type is always Circular ('C1') - self.ui.tool_type_radio.set_value('C1') - self.ui.tool_type_label.hide() - self.ui.tool_type_radio.hide() + self.t_ui.tool_type_radio.set_value('C1') + self.t_ui.tool_type_label.hide() + self.t_ui.tool_type_radio.hide() - self.ui.milling_type_label.hide() - self.ui.milling_type_radio.hide() + self.t_ui.milling_type_label.hide() + self.t_ui.milling_type_radio.hide() - self.ui.iso_type_label.hide() - self.ui.iso_type_radio.set_value('full') - self.ui.iso_type_radio.hide() + self.t_ui.iso_type_label.hide() + self.t_ui.iso_type_radio.set_value('full') + self.t_ui.iso_type_radio.hide() - self.ui.follow_cb.set_value(False) - self.ui.follow_cb.hide() - self.ui.follow_label.hide() + self.t_ui.follow_cb.set_value(False) + self.t_ui.follow_cb.hide() + self.t_ui.follow_label.hide() - self.ui.rest_cb.set_value(False) - self.ui.rest_cb.hide() + self.t_ui.rest_cb.set_value(False) + self.t_ui.rest_cb.hide() - self.ui.except_cb.set_value(False) - self.ui.except_cb.hide() + self.t_ui.except_cb.set_value(False) + self.t_ui.except_cb.hide() - self.ui.type_excobj_radio.hide() - self.ui.exc_obj_combo.hide() + self.t_ui.type_excobj_radio.hide() + self.t_ui.exc_obj_combo.hide() - self.ui.select_combo.setCurrentIndex(0) - self.ui.select_combo.hide() - self.ui.select_label.hide() + self.t_ui.select_combo.setCurrentIndex(0) + self.t_ui.select_combo.hide() + self.t_ui.select_label.hide() else: - self.ui.level.setText('%s' % _('Advanced')) + self.t_ui.level.setText('%s' % _('Advanced')) - self.ui.tool_type_radio.set_value(self.app.defaults["tools_iso_tool_type"]) - self.ui.tool_type_label.show() - self.ui.tool_type_radio.show() + self.t_ui.tool_type_radio.set_value(self.app.defaults["tools_iso_tool_type"]) + self.t_ui.tool_type_label.show() + self.t_ui.tool_type_radio.show() - self.ui.milling_type_label.show() - self.ui.milling_type_radio.show() + self.t_ui.milling_type_label.show() + self.t_ui.milling_type_radio.show() - self.ui.iso_type_label.show() - self.ui.iso_type_radio.set_value(self.app.defaults["tools_iso_isotype"]) - self.ui.iso_type_radio.show() + self.t_ui.iso_type_label.show() + self.t_ui.iso_type_radio.set_value(self.app.defaults["tools_iso_isotype"]) + self.t_ui.iso_type_radio.show() - self.ui.follow_cb.set_value(self.app.defaults["tools_iso_follow"]) - self.ui.follow_cb.show() - self.ui.follow_label.show() + self.t_ui.follow_cb.set_value(self.app.defaults["tools_iso_follow"]) + self.t_ui.follow_cb.show() + self.t_ui.follow_label.show() - self.ui.rest_cb.set_value(self.app.defaults["tools_iso_rest"]) - self.ui.rest_cb.show() + self.t_ui.rest_cb.set_value(self.app.defaults["tools_iso_rest"]) + self.t_ui.rest_cb.show() - self.ui.except_cb.set_value(self.app.defaults["tools_iso_isoexcept"]) - self.ui.except_cb.show() + self.t_ui.except_cb.set_value(self.app.defaults["tools_iso_isoexcept"]) + self.t_ui.except_cb.show() - self.ui.select_combo.set_value(self.app.defaults["tools_iso_selection"]) - self.ui.select_combo.show() - self.ui.select_label.show() + self.t_ui.select_combo.set_value(self.app.defaults["tools_iso_selection"]) + self.t_ui.select_combo.show() + self.t_ui.select_label.show() if self.app.defaults["gerber_buffering"] == 'no': - self.ui.create_buffer_button.show() + self.t_ui.create_buffer_button.show() try: - self.ui.create_buffer_button.clicked.disconnect(self.on_generate_buffer) + self.t_ui.create_buffer_button.clicked.disconnect(self.on_generate_buffer) except TypeError: pass - self.ui.create_buffer_button.clicked.connect(self.on_generate_buffer) + self.t_ui.create_buffer_button.clicked.connect(self.on_generate_buffer) else: - self.ui.create_buffer_button.hide() + self.t_ui.create_buffer_button.hide() - self.ui.tools_frame.show() + self.t_ui.tools_frame.show() - self.ui.type_excobj_radio.set_value('gerber') + self.t_ui.type_excobj_radio.set_value('gerber') # run those once so the obj_type attribute is updated for the FCComboboxes # so the last loaded object is displayed self.on_type_excobj_index_changed(val="gerber") self.on_reference_combo_changed() - self.ui.order_radio.set_value(self.app.defaults["tools_iso_order"]) - self.ui.passes_entry.set_value(self.app.defaults["tools_iso_passes"]) - self.ui.iso_overlap_entry.set_value(self.app.defaults["tools_iso_overlap"]) - self.ui.milling_type_radio.set_value(self.app.defaults["tools_iso_milling_type"]) - self.ui.combine_passes_cb.set_value(self.app.defaults["tools_iso_combine_passes"]) - self.ui.area_shape_radio.set_value(self.app.defaults["tools_iso_area_shape"]) - self.ui.poly_int_cb.set_value(self.app.defaults["tools_iso_poly_ints"]) - self.ui.forced_rest_iso_cb.set_value(self.app.defaults["tools_iso_force"]) + self.t_ui.order_radio.set_value(self.app.defaults["tools_iso_order"]) + self.t_ui.passes_entry.set_value(self.app.defaults["tools_iso_passes"]) + self.t_ui.iso_overlap_entry.set_value(self.app.defaults["tools_iso_overlap"]) + self.t_ui.milling_type_radio.set_value(self.app.defaults["tools_iso_milling_type"]) + self.t_ui.combine_passes_cb.set_value(self.app.defaults["tools_iso_combine_passes"]) + self.t_ui.area_shape_radio.set_value(self.app.defaults["tools_iso_area_shape"]) + self.t_ui.poly_int_cb.set_value(self.app.defaults["tools_iso_poly_ints"]) + self.t_ui.forced_rest_iso_cb.set_value(self.app.defaults["tools_iso_force"]) - self.ui.cutz_entry.set_value(self.app.defaults["tools_iso_tool_cutz"]) - self.ui.tool_type_radio.set_value(self.app.defaults["tools_iso_tool_type"]) - self.ui.tipdia_entry.set_value(self.app.defaults["tools_iso_tool_vtipdia"]) - self.ui.tipangle_entry.set_value(self.app.defaults["tools_iso_tool_vtipangle"]) - self.ui.addtool_entry.set_value(self.app.defaults["tools_iso_newdia"]) + self.t_ui.cutz_entry.set_value(self.app.defaults["tools_iso_tool_cutz"]) + self.t_ui.tool_type_radio.set_value(self.app.defaults["tools_iso_tool_type"]) + self.t_ui.tipdia_entry.set_value(self.app.defaults["tools_iso_tool_vtipdia"]) + self.t_ui.tipangle_entry.set_value(self.app.defaults["tools_iso_tool_vtipangle"]) + self.t_ui.addtool_entry.set_value(self.app.defaults["tools_iso_newdia"]) - self.on_tool_type(val=self.ui.tool_type_radio.get_value()) + self.on_tool_type(val=self.t_ui.tool_type_radio.get_value()) - loaded_obj = self.app.collection.get_by_name(self.ui.object_combo.get_value()) + loaded_obj = self.app.collection.get_by_name(self.t_ui.object_combo.get_value()) if loaded_obj: outname = loaded_obj.options['name'] else: @@ -401,7 +401,7 @@ class ToolIsolation(AppTool, Gerber): 'offset': 'Path', 'offset_value': 0.0, 'type': 'Iso', - 'tool_type': self.ui.tool_type_radio.get_value(), + 'tool_type': self.t_ui.tool_type_radio.get_value(), 'data': deepcopy(self.default_data), 'solid_geometry': [] } @@ -425,13 +425,13 @@ class ToolIsolation(AppTool, Gerber): self.on_rest_machining_check(state=self.app.defaults["tools_iso_rest"]) - self.ui.tools_table.drag_drop_sig.connect(self.rebuild_ui) + self.t_ui.tools_table.drag_drop_sig.connect(self.rebuild_ui) def rebuild_ui(self): # read the table tools uid current_uid_list = [] - for row in range(self.ui.tools_table.rowCount()): - uid = int(self.ui.tools_table.item(row, 3).text()) + for row in range(self.t_ui.tools_table.rowCount()): + uid = int(self.t_ui.tools_table.item(row, 3).text()) current_uid_list.append(uid) new_tools = {} @@ -456,7 +456,7 @@ class ToolIsolation(AppTool, Gerber): for k, v in self.iso_tools.items(): sorted_tools.append(float('%.*f' % (self.decimals, float(v['tooldia'])))) - order = self.ui.order_radio.get_value() + order = self.t_ui.order_radio.get_value() if order == 'fwd': sorted_tools.sort(reverse=False) elif order == 'rev': @@ -465,86 +465,89 @@ class ToolIsolation(AppTool, Gerber): pass n = len(sorted_tools) - self.ui.tools_table.setRowCount(n) + self.t_ui.tools_table.setRowCount(n) tool_id = 0 for tool_sorted in sorted_tools: for tooluid_key, tooluid_value in self.iso_tools.items(): if float('%.*f' % (self.decimals, tooluid_value['tooldia'])) == tool_sorted: tool_id += 1 + + # Tool name/id id_ = QtWidgets.QTableWidgetItem('%d' % int(tool_id)) id_.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled) row_no = tool_id - 1 - self.ui.tools_table.setItem(row_no, 0, id_) # Tool name/id - + self.t_ui.tools_table.setItem(row_no, 0, id_) + # Diameter dia = QtWidgets.QTableWidgetItem('%.*f' % (self.decimals, tooluid_value['tooldia'])) dia.setFlags(QtCore.Qt.ItemIsEnabled) - self.ui.tools_table.setItem(row_no, 1, dia) # Diameter + self.t_ui.tools_table.setItem(row_no, 1, dia) + # Tool Type tool_type_item = FCComboBox() tool_type_item.addItems(self.tool_type_item_options) - # tool_type_item.setStyleSheet('background-color: rgb(255,255,255)') idx = tool_type_item.findText(tooluid_value['tool_type']) tool_type_item.setCurrentIndex(idx) - self.ui.tools_table.setCellWidget(row_no, 2, tool_type_item) + self.t_ui.tools_table.setCellWidget(row_no, 2, tool_type_item) + # Tool unique ID + # REMEMBER: THIS COLUMN IS HIDDEN tool_uid_item = QtWidgets.QTableWidgetItem(str(int(tooluid_key))) - # ## REMEMBER: THIS COLUMN IS HIDDEN IN OBJECTUI.PY # ## - self.ui.tools_table.setItem(row_no, 3, tool_uid_item) # Tool unique ID + self.t_ui.tools_table.setItem(row_no, 3, tool_uid_item) # make the diameter column editable for row in range(tool_id): - self.ui.tools_table.item(row, 1).setFlags( + self.t_ui.tools_table.item(row, 1).setFlags( QtCore.Qt.ItemIsEditable | QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled) # all the tools are selected by default - self.ui.tools_table.selectColumn(0) + self.t_ui.tools_table.selectColumn(0) # - self.ui.tools_table.resizeColumnsToContents() - self.ui.tools_table.resizeRowsToContents() + self.t_ui.tools_table.resizeColumnsToContents() + self.t_ui.tools_table.resizeRowsToContents() - vertical_header = self.ui.tools_table.verticalHeader() + vertical_header = self.t_ui.tools_table.verticalHeader() vertical_header.hide() - self.ui.tools_table.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff) + self.t_ui.tools_table.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff) - horizontal_header = self.ui.tools_table.horizontalHeader() + horizontal_header = self.t_ui.tools_table.horizontalHeader() horizontal_header.setMinimumSectionSize(10) horizontal_header.setSectionResizeMode(0, QtWidgets.QHeaderView.Fixed) horizontal_header.resizeSection(0, 20) horizontal_header.setSectionResizeMode(1, QtWidgets.QHeaderView.Stretch) - # self.ui.tools_table.setSortingEnabled(True) + # self.t_ui.tools_table.setSortingEnabled(True) # sort by tool diameter - # self.ui.tools_table.sortItems(1) + # self.t_ui.tools_table.sortItems(1) - self.ui.tools_table.setMinimumHeight(self.ui.tools_table.getHeight()) - self.ui.tools_table.setMaximumHeight(self.ui.tools_table.getHeight()) + self.t_ui.tools_table.setMinimumHeight(self.t_ui.tools_table.getHeight()) + self.t_ui.tools_table.setMaximumHeight(self.t_ui.tools_table.getHeight()) self.ui_connect() # set the text on tool_data_label after loading the object sel_rows = set() - sel_items = self.ui.tools_table.selectedItems() + sel_items = self.t_ui.tools_table.selectedItems() for it in sel_items: sel_rows.add(it.row()) if len(sel_rows) > 1: - self.ui.tool_data_label.setText( + self.t_ui.tool_data_label.setText( "%s: %s" % (_('Parameters for'), _("Multiple Tools")) ) def ui_connect(self): - self.ui.tools_table.itemChanged.connect(self.on_tool_edit) - self.ui.tool_type_radio.activated_custom.connect(self.on_tool_type) + self.t_ui.tools_table.itemChanged.connect(self.on_tool_edit) + self.t_ui.tool_type_radio.activated_custom.connect(self.on_tool_type) # rows selected - self.ui.tools_table.clicked.connect(self.on_row_selection_change) - self.ui.tools_table.horizontalHeader().sectionClicked.connect(self.on_toggle_all_rows) + self.t_ui.tools_table.clicked.connect(self.on_row_selection_change) + self.t_ui.tools_table.horizontalHeader().sectionClicked.connect(self.on_toggle_all_rows) # tool table widgets - for row in range(self.ui.tools_table.rowCount()): + for row in range(self.t_ui.tools_table.rowCount()): try: - self.ui.tools_table.cellWidget(row, 2).currentIndexChanged.connect(self.on_tooltable_cellwidget_change) + self.t_ui.tools_table.cellWidget(row, 2).currentIndexChanged.connect(self.on_tooltable_cellwidget_change) except AttributeError: pass @@ -560,38 +563,38 @@ class ToolIsolation(AppTool, Gerber): elif isinstance(current_widget, FCComboBox): current_widget.currentIndexChanged.connect(self.form_to_storage) - self.ui.rest_cb.stateChanged.connect(self.on_rest_machining_check) - self.ui.order_radio.activated_custom[str].connect(self.on_order_changed) + self.t_ui.rest_cb.stateChanged.connect(self.on_rest_machining_check) + self.t_ui.order_radio.activated_custom[str].connect(self.on_order_changed) def ui_disconnect(self): try: # if connected, disconnect the signal from the slot on item_changed as it creates issues - self.ui.tools_table.itemChanged.disconnect() + self.t_ui.tools_table.itemChanged.disconnect() except (TypeError, AttributeError): pass try: # if connected, disconnect the signal from the slot on item_changed as it creates issues - self.ui.tool_type_radio.activated_custom.disconnect() + self.t_ui.tool_type_radio.activated_custom.disconnect() except (TypeError, AttributeError): pass # rows selected try: - self.ui.tools_table.clicked.disconnect() + self.t_ui.tools_table.clicked.disconnect() except (TypeError, AttributeError): pass try: - self.ui.tools_table.horizontalHeader().sectionClicked.disconnect() + self.t_ui.tools_table.horizontalHeader().sectionClicked.disconnect() except (TypeError, AttributeError): pass # tool table widgets - for row in range(self.ui.tools_table.rowCount()): + for row in range(self.t_ui.tools_table.rowCount()): try: - self.ui.tools_table.cellWidget(row, 2).currentIndexChanged.disconnect() + self.t_ui.tools_table.cellWidget(row, 2).currentIndexChanged.disconnect() except (TypeError, AttributeError): pass @@ -620,11 +623,11 @@ class ToolIsolation(AppTool, Gerber): pass try: - self.ui.rest_cb.stateChanged.disconnect() + self.t_ui.rest_cb.stateChanged.disconnect() except (TypeError, ValueError): pass try: - self.ui.order_radio.activated_custom[str].disconnect() + self.t_ui.order_radio.activated_custom[str].disconnect() except (TypeError, ValueError): pass @@ -634,7 +637,7 @@ class ToolIsolation(AppTool, Gerber): :return: """ - sel_model = self.ui.tools_table.selectionModel() + sel_model = self.t_ui.tools_table.selectionModel() sel_indexes = sel_model.selectedIndexes() # it will iterate over all indexes which means all items in all columns too but I'm interested only on rows @@ -642,10 +645,10 @@ class ToolIsolation(AppTool, Gerber): for idx in sel_indexes: sel_rows.add(idx.row()) - if len(sel_rows) == self.ui.tools_table.rowCount(): - self.ui.tools_table.clearSelection() + if len(sel_rows) == self.t_ui.tools_table.rowCount(): + self.t_ui.tools_table.clearSelection() else: - self.ui.tools_table.selectAll() + self.t_ui.tools_table.selectAll() self.update_ui() def on_row_selection_change(self): @@ -655,26 +658,26 @@ class ToolIsolation(AppTool, Gerber): self.blockSignals(True) sel_rows = set() - table_items = self.ui.tools_table.selectedItems() + table_items = self.t_ui.tools_table.selectedItems() if table_items: for it in table_items: sel_rows.add(it.row()) - # sel_rows = sorted(set(index.row() for index in self.ui.tools_table.selectedIndexes())) + # sel_rows = sorted(set(index.row() for index in self.t_ui.tools_table.selectedIndexes())) if not sel_rows or len(sel_rows) == 0: - self.ui.generate_iso_button.setDisabled(True) - self.ui.tool_data_label.setText( + self.t_ui.generate_iso_button.setDisabled(True) + self.t_ui.tool_data_label.setText( "%s: %s" % (_('Parameters for'), _("No Tool Selected")) ) self.blockSignals(False) return else: - self.ui.generate_iso_button.setDisabled(False) + self.t_ui.generate_iso_button.setDisabled(False) for current_row in sel_rows: # populate the form with the data from the tool associated with the row parameter try: - item = self.ui.tools_table.item(current_row, 3) + item = self.t_ui.tools_table.item(current_row, 3) if item is not None: tooluid = int(item.text()) else: @@ -686,7 +689,7 @@ class ToolIsolation(AppTool, Gerber): # update the QLabel that shows for which Tool we have the parameters in the UI form if len(sel_rows) == 1: cr = current_row + 1 - self.ui.tool_data_label.setText( + self.t_ui.tool_data_label.setText( "%s: %s %d" % (_('Parameters for'), _("Tool"), cr) ) try: @@ -699,7 +702,7 @@ class ToolIsolation(AppTool, Gerber): except Exception as e: log.debug("ToolIsolation ---> update_ui() " + str(e)) else: - self.ui.tool_data_label.setText( + self.t_ui.tool_data_label.setText( "%s: %s" % (_('Parameters for'), _("Multiple Tools")) ) @@ -716,7 +719,7 @@ class ToolIsolation(AppTool, Gerber): pass def form_to_storage(self): - if self.ui.tools_table.rowCount() == 0: + if self.t_ui.tools_table.rowCount() == 0: # there is no tool in tool table so we can't save the GUI elements values to storage return @@ -726,12 +729,12 @@ class ToolIsolation(AppTool, Gerber): wdg_objname = widget_changed.objectName() option_changed = self.name2option[wdg_objname] - # row = self.ui.tools_table.currentRow() - rows = sorted(set(index.row() for index in self.ui.tools_table.selectedIndexes())) + # row = self.t_ui.tools_table.currentRow() + rows = sorted(set(index.row() for index in self.t_ui.tools_table.selectedIndexes())) for row in rows: if row < 0: row = 0 - tooluid_item = int(self.ui.tools_table.item(row, 3).text()) + tooluid_item = int(self.t_ui.tools_table.item(row, 3).text()) for tooluid_key, tooluid_val in self.iso_tools.items(): if int(tooluid_key) == tooluid_item: @@ -744,18 +747,18 @@ class ToolIsolation(AppTool, Gerber): self.blockSignals(False) def on_apply_param_to_all_clicked(self): - if self.ui.tools_table.rowCount() == 0: + if self.t_ui.tools_table.rowCount() == 0: # there is no tool in tool table so we can't save the GUI elements values to storage log.debug("ToolIsolation.on_apply_param_to_all_clicked() --> no tool in Tools Table, aborting.") return self.blockSignals(True) - row = self.ui.tools_table.currentRow() + row = self.t_ui.tools_table.currentRow() if row < 0: row = 0 - tooluid_item = int(self.ui.tools_table.item(row, 3).text()) + tooluid_item = int(self.t_ui.tools_table.item(row, 3).text()) temp_tool_data = {} for tooluid_key, tooluid_val in self.iso_tools.items(): @@ -788,62 +791,62 @@ class ToolIsolation(AppTool, Gerber): self.app.inform.emit('[WARNING_NOTCL] %s...' % _("Adding Tool cancelled")) def on_tooldia_updated(self): - if self.ui.tool_type_radio.get_value() == 'C1': - self.old_tool_dia = self.ui.addtool_entry.get_value() + if self.t_ui.tool_type_radio.get_value() == 'C1': + self.old_tool_dia = self.t_ui.addtool_entry.get_value() def on_reference_combo_changed(self): - obj_type = self.ui.reference_combo_type.currentIndex() - self.ui.reference_combo.setRootModelIndex(self.app.collection.index(obj_type, 0, QtCore.QModelIndex())) - self.ui.reference_combo.setCurrentIndex(0) - self.ui.reference_combo.obj_type = { + obj_type = self.t_ui.reference_combo_type.currentIndex() + self.t_ui.reference_combo.setRootModelIndex(self.app.collection.index(obj_type, 0, QtCore.QModelIndex())) + self.t_ui.reference_combo.setCurrentIndex(0) + self.t_ui.reference_combo.obj_type = { _("Gerber"): "Gerber", _("Excellon"): "Excellon", _("Geometry"): "Geometry" - }[self.ui.reference_combo_type.get_value()] + }[self.t_ui.reference_combo_type.get_value()] def on_toggle_reference(self): - val = self.ui.select_combo.get_value() + val = self.t_ui.select_combo.get_value() if val == _("All"): - self.ui.reference_combo.hide() - self.ui.reference_combo_label.hide() - self.ui.reference_combo_type.hide() - self.ui.reference_combo_type_label.hide() - self.ui.area_shape_label.hide() - self.ui.area_shape_radio.hide() - self.ui.poly_int_cb.hide() + self.t_ui.reference_combo.hide() + self.t_ui.reference_combo_label.hide() + self.t_ui.reference_combo_type.hide() + self.t_ui.reference_combo_type_label.hide() + self.t_ui.area_shape_label.hide() + self.t_ui.area_shape_radio.hide() + self.t_ui.poly_int_cb.hide() # disable rest-machining for area painting - self.ui.rest_cb.setDisabled(False) + self.t_ui.rest_cb.setDisabled(False) elif val == _("Area Selection"): - self.ui.reference_combo.hide() - self.ui.reference_combo_label.hide() - self.ui.reference_combo_type.hide() - self.ui.reference_combo_type_label.hide() - self.ui.area_shape_label.show() - self.ui.area_shape_radio.show() - self.ui.poly_int_cb.hide() + self.t_ui.reference_combo.hide() + self.t_ui.reference_combo_label.hide() + self.t_ui.reference_combo_type.hide() + self.t_ui.reference_combo_type_label.hide() + self.t_ui.area_shape_label.show() + self.t_ui.area_shape_radio.show() + self.t_ui.poly_int_cb.hide() # disable rest-machining for area isolation - self.ui.rest_cb.set_value(False) - self.ui.rest_cb.setDisabled(True) + self.t_ui.rest_cb.set_value(False) + self.t_ui.rest_cb.setDisabled(True) elif val == _("Polygon Selection"): - self.ui.reference_combo.hide() - self.ui.reference_combo_label.hide() - self.ui.reference_combo_type.hide() - self.ui.reference_combo_type_label.hide() - self.ui.area_shape_label.hide() - self.ui.area_shape_radio.hide() - self.ui.poly_int_cb.show() + self.t_ui.reference_combo.hide() + self.t_ui.reference_combo_label.hide() + self.t_ui.reference_combo_type.hide() + self.t_ui.reference_combo_type_label.hide() + self.t_ui.area_shape_label.hide() + self.t_ui.area_shape_radio.hide() + self.t_ui.poly_int_cb.show() else: - self.ui.reference_combo.show() - self.ui.reference_combo_label.show() - self.ui.reference_combo_type.show() - self.ui.reference_combo_type_label.show() - self.ui.area_shape_label.hide() - self.ui.area_shape_radio.hide() - self.ui.poly_int_cb.hide() + self.t_ui.reference_combo.show() + self.t_ui.reference_combo_label.show() + self.t_ui.reference_combo_type.show() + self.t_ui.reference_combo_type_label.show() + self.t_ui.area_shape_label.hide() + self.t_ui.area_shape_radio.hide() + self.t_ui.poly_int_cb.hide() # disable rest-machining for area painting - self.ui.rest_cb.setDisabled(False) + self.t_ui.rest_cb.setDisabled(False) def on_order_changed(self, order): if order != 'no': @@ -851,34 +854,34 @@ class ToolIsolation(AppTool, Gerber): def on_rest_machining_check(self, state): if state: - self.ui.order_radio.set_value('rev') - self.ui.order_label.setDisabled(True) - self.ui.order_radio.setDisabled(True) + self.t_ui.order_radio.set_value('rev') + self.t_ui.order_label.setDisabled(True) + self.t_ui.order_radio.setDisabled(True) - self.old_combine_state = self.ui.combine_passes_cb.get_value() - self.ui.combine_passes_cb.set_value(True) - self.ui.combine_passes_cb.setDisabled(True) + self.old_combine_state = self.t_ui.combine_passes_cb.get_value() + self.t_ui.combine_passes_cb.set_value(True) + self.t_ui.combine_passes_cb.setDisabled(True) - self.ui.forced_rest_iso_cb.setDisabled(False) + self.t_ui.forced_rest_iso_cb.setDisabled(False) else: - self.ui.order_label.setDisabled(False) - self.ui.order_radio.setDisabled(False) + self.t_ui.order_label.setDisabled(False) + self.t_ui.order_radio.setDisabled(False) - self.ui.combine_passes_cb.set_value(self.old_combine_state) - self.ui.combine_passes_cb.setDisabled(False) + self.t_ui.combine_passes_cb.set_value(self.old_combine_state) + self.t_ui.combine_passes_cb.setDisabled(False) - self.ui.forced_rest_iso_cb.setDisabled(True) + self.t_ui.forced_rest_iso_cb.setDisabled(True) def on_tooltable_cellwidget_change(self): cw = self.sender() assert isinstance(cw, QtWidgets.QComboBox), \ "Expected a QtWidgets.QComboBox, got %s" % isinstance(cw, QtWidgets.QComboBox) - cw_index = self.ui.tools_table.indexAt(cw.pos()) + cw_index = self.t_ui.tools_table.indexAt(cw.pos()) cw_row = cw_index.row() cw_col = cw_index.column() - current_uid = int(self.ui.tools_table.item(cw_row, 3).text()) + current_uid = int(self.t_ui.tools_table.item(cw_row, 3).text()) # if the sender is in the column with index 2 then we update the tool_type key if cw_col == 2: @@ -892,29 +895,29 @@ class ToolIsolation(AppTool, Gerber): def on_tool_type(self, val): if val == 'V': - self.ui.addtool_entry_lbl.setDisabled(True) - self.ui.addtool_entry.setDisabled(True) - self.ui.tipdialabel.show() - self.ui.tipdia_entry.show() - self.ui.tipanglelabel.show() - self.ui.tipangle_entry.show() + self.t_ui.addtool_entry_lbl.setDisabled(True) + self.t_ui.addtool_entry.setDisabled(True) + self.t_ui.tipdialabel.show() + self.t_ui.tipdia_entry.show() + self.t_ui.tipanglelabel.show() + self.t_ui.tipangle_entry.show() self.on_calculate_tooldia() else: - self.ui.addtool_entry_lbl.setDisabled(False) - self.ui.addtool_entry.setDisabled(False) - self.ui.tipdialabel.hide() - self.ui.tipdia_entry.hide() - self.ui.tipanglelabel.hide() - self.ui.tipangle_entry.hide() + self.t_ui.addtool_entry_lbl.setDisabled(False) + self.t_ui.addtool_entry.setDisabled(False) + self.t_ui.tipdialabel.hide() + self.t_ui.tipdia_entry.hide() + self.t_ui.tipanglelabel.hide() + self.t_ui.tipangle_entry.hide() - self.ui.addtool_entry.set_value(self.old_tool_dia) + self.t_ui.addtool_entry.set_value(self.old_tool_dia) def on_calculate_tooldia(self): - if self.ui.tool_type_radio.get_value() == 'V': - tip_dia = float(self.ui.tipdia_entry.get_value()) - tip_angle = float(self.ui.tipangle_entry.get_value()) / 2.0 - cut_z = float(self.ui.cutz_entry.get_value()) + if self.t_ui.tool_type_radio.get_value() == 'V': + tip_dia = float(self.t_ui.tipdia_entry.get_value()) + tip_angle = float(self.t_ui.tipangle_entry.get_value()) / 2.0 + cut_z = float(self.t_ui.cutz_entry.get_value()) cut_z = -cut_z if cut_z < 0 else cut_z # calculated tool diameter so the cut_z parameter is obeyed @@ -926,11 +929,11 @@ class ToolIsolation(AppTool, Gerber): "vtipangle": (tip_angle * 2), }) - self.ui.addtool_entry.set_value(tool_dia) + self.t_ui.addtool_entry.set_value(tool_dia) return tool_dia else: - return float(self.ui.addtool_entry.get_value()) + return float(self.t_ui.addtool_entry.get_value()) def on_tool_add(self, dia=None, muted=None): self.blockSignals(True) @@ -975,7 +978,7 @@ class ToolIsolation(AppTool, Gerber): if float('%.*f' % (self.decimals, tool_dia)) in tool_dias: if muted is None: self.app.inform.emit('[WARNING_NOTCL] %s' % _("Cancelled. Tool already in Tool Table.")) - # self.ui.tools_table.itemChanged.connect(self.on_tool_edit) + # self.t_ui.tools_table.itemChanged.connect(self.on_tool_edit) self.blockSignals(False) return @@ -988,7 +991,7 @@ class ToolIsolation(AppTool, Gerber): 'offset': 'Path', 'offset_value': 0.0, 'type': ' Iso', - 'tool_type': self.ui.tool_type_radio.get_value(), + 'tool_type': self.t_ui.tool_type_radio.get_value(), 'data': deepcopy(self.default_data), 'solid_geometry': [] } @@ -998,24 +1001,24 @@ class ToolIsolation(AppTool, Gerber): self.build_ui() # select the tool just added - for row in range(self.ui.tools_table.rowCount()): - if int(self.ui.tools_table.item(row, 3).text()) == self.tooluid: - self.ui.tools_table.selectRow(row) + for row in range(self.t_ui.tools_table.rowCount()): + if int(self.t_ui.tools_table.item(row, 3).text()) == self.tooluid: + self.t_ui.tools_table.selectRow(row) break def on_tool_edit(self, item): self.blockSignals(True) edited_row = item.row() - editeduid = int(self.ui.tools_table.item(edited_row, 3).text()) + editeduid = int(self.t_ui.tools_table.item(edited_row, 3).text()) tool_dias = [] try: - new_tool_dia = float(self.ui.tools_table.item(edited_row, 1).text()) + new_tool_dia = float(self.t_ui.tools_table.item(edited_row, 1).text()) except ValueError: # try to convert comma to decimal point. if it's still not working error message and return try: - new_tool_dia = float(self.ui.tools_table.item(edited_row, 1).text().replace(',', '.')) + new_tool_dia = float(self.t_ui.tools_table.item(edited_row, 1).text().replace(',', '.')) except ValueError: self.app.inform.emit('[ERROR_NOTCL] %s' % _("Wrong value format entered, use a number.")) self.blockSignals(False) @@ -1036,7 +1039,7 @@ class ToolIsolation(AppTool, Gerber): for k, v in self.iso_tools.items(): if k == editeduid: old_tool_dia = v['tooldia'] - restore_dia_item = self.ui.tools_table.item(edited_row, 1) + restore_dia_item = self.t_ui.tools_table.item(edited_row, 1) restore_dia_item.setText(str(old_tool_dia)) break @@ -1065,10 +1068,10 @@ class ToolIsolation(AppTool, Gerber): if rows_to_delete: try: for row in rows_to_delete: - tooluid_del = int(self.ui.tools_table.item(row, 3).text()) + tooluid_del = int(self.t_ui.tools_table.item(row, 3).text()) deleted_tools_list.append(tooluid_del) except TypeError: - tooluid_del = int(self.ui.tools_table.item(rows_to_delete, 3).text()) + tooluid_del = int(self.t_ui.tools_table.item(rows_to_delete, 3).text()) deleted_tools_list.append(tooluid_del) for t in deleted_tools_list: @@ -1079,12 +1082,12 @@ class ToolIsolation(AppTool, Gerber): return try: - if self.ui.tools_table.selectedItems(): - for row_sel in self.ui.tools_table.selectedItems(): + if self.t_ui.tools_table.selectedItems(): + for row_sel in self.t_ui.tools_table.selectedItems(): row = row_sel.row() if row < 0: continue - tooluid_del = int(self.ui.tools_table.item(row, 3).text()) + tooluid_del = int(self.t_ui.tools_table.item(row, 3).text()) deleted_tools_list.append(tooluid_del) for t in deleted_tools_list: @@ -1104,7 +1107,7 @@ class ToolIsolation(AppTool, Gerber): def on_generate_buffer(self): self.app.inform.emit('[WARNING_NOTCL] %s...' % _("Buffering solid geometry")) - self.obj_name = self.ui.object_combo.currentText() + self.obj_name = self.t_ui.object_combo.currentText() # Get source object. try: @@ -1131,7 +1134,7 @@ class ToolIsolation(AppTool, Gerber): def on_iso_button_click(self): - self.obj_name = self.ui.object_combo.currentText() + self.obj_name = self.t_ui.object_combo.currentText() # Get source object. try: @@ -1193,7 +1196,7 @@ class ToolIsolation(AppTool, Gerber): :type isolated_obj: AppObjects.FlatCAMGerber.GerberObject :return: None """ - selection = self.ui.select_combo.get_value() + selection = self.t_ui.select_combo.get_value() if selection == _("All"): self.isolate(isolated_obj=isolated_obj) @@ -1238,7 +1241,7 @@ class ToolIsolation(AppTool, Gerber): self.poly_sel_disconnect_flag = True elif selection == _("Reference Object"): - ref_obj = self.app.collection.get_by_name(self.ui.reference_combo.get_value()) + ref_obj = self.app.collection.get_by_name(self.t_ui.reference_combo.get_value()) ref_geo = cascaded_union(ref_obj.solid_geometry) use_geo = cascaded_union(isolated_obj.solid_geometry).difference(ref_geo) self.isolate(isolated_obj=isolated_obj, geometry=use_geo) @@ -1260,14 +1263,14 @@ class ToolIsolation(AppTool, Gerber): :return: None """ - combine = self.ui.combine_passes_cb.get_value() + combine = self.t_ui.combine_passes_cb.get_value() tools_storage = self.iso_tools sorted_tools = [] - table_items = self.ui.tools_table.selectedItems() + table_items = self.t_ui.tools_table.selectedItems() sel_rows = {t.row() for t in table_items} for row in sel_rows: - tid = int(self.ui.tools_table.item(row, 3).text()) + tid = int(self.t_ui.tools_table.item(row, 3).text()) sorted_tools.append(tid) if not sorted_tools: self.app.inform.emit('[ERROR_NOTCL] %s' % _("No selected tools in Tool Table.")) @@ -1277,14 +1280,14 @@ class ToolIsolation(AppTool, Gerber): for tool_iso in self.iso_tools: for key in self.iso_tools[tool_iso]: if key == 'data': - self.iso_tools[tool_iso][key]["tools_iso_rest"] = self.ui.rest_cb.get_value() + self.iso_tools[tool_iso][key]["tools_iso_rest"] = self.t_ui.rest_cb.get_value() self.iso_tools[tool_iso][key]["tools_iso_combine_passes"] = combine - self.iso_tools[tool_iso][key]["tools_iso_isoexcept"] = self.ui.except_cb.get_value() - self.iso_tools[tool_iso][key]["tools_iso_selection"] = self.ui.select_combo.get_value() - self.iso_tools[tool_iso][key]["tools_iso_area_shape"] = self.ui.area_shape_radio.get_value() + self.iso_tools[tool_iso][key]["tools_iso_isoexcept"] = self.t_ui.except_cb.get_value() + self.iso_tools[tool_iso][key]["tools_iso_selection"] = self.t_ui.select_combo.get_value() + self.iso_tools[tool_iso][key]["tools_iso_area_shape"] = self.t_ui.area_shape_radio.get_value() if combine: - if self.ui.rest_cb.get_value(): + if self.t_ui.rest_cb.get_value(): self.combined_rest(iso_obj=isolated_obj, iso2geo=geometry, tools_storage=tools_storage, lim_area=limited_area, negative_dia=negative_dia, plot=plot) else: @@ -1314,7 +1317,7 @@ class ToolIsolation(AppTool, Gerber): milling_type = tool_data['tools_iso_milling_type'] - iso_except = self.ui.except_cb.get_value() + iso_except = self.t_ui.except_cb.get_value() for i in range(passes): tool_dia = tools_storage[tool]['tooldia'] @@ -1374,7 +1377,7 @@ class ToolIsolation(AppTool, Gerber): # ############################################################ # ########## AREA SUBTRACTION ################################ # ############################################################ - if self.ui.except_cb.get_value(): + if self.t_ui.except_cb.get_value(): self.app.proc_container.update_view_text(' %s' % _("Subtracting Geo")) geo_obj.solid_geometry = self.area_subtraction(geo_obj.solid_geometry) @@ -1457,15 +1460,15 @@ class ToolIsolation(AppTool, Gerber): # sorted_tools.append(float('%.*f' % (self.decimals, float(v['tooldia'])))) sorted_tools = [] - table_items = self.ui.tools_table.selectedItems() + table_items = self.t_ui.tools_table.selectedItems() sel_rows = {t.row() for t in table_items} for row in sel_rows: try: - tdia = float(self.ui.tools_table.item(row, 1).text()) + tdia = float(self.t_ui.tools_table.item(row, 1).text()) except ValueError: # try to convert comma to decimal point. if it's still not working error message and return try: - tdia = float(self.ui.tools_table.item(row, 1).text().replace(',', '.')) + tdia = float(self.t_ui.tools_table.item(row, 1).text().replace(',', '.')) except ValueError: self.app.inform.emit('[ERROR_NOTCL] %s' % _("Wrong value format entered, use a number.")) continue @@ -1475,7 +1478,7 @@ class ToolIsolation(AppTool, Gerber): self.app.inform.emit('[ERROR_NOTCL] %s' % _("No selected tools in Tool Table.")) return 'fail' - order = self.ui.order_radio.get_value() + order = self.t_ui.order_radio.get_value() if order == 'fwd': sorted_tools.sort(reverse=False) elif order == 'rev': @@ -1507,8 +1510,8 @@ class ToolIsolation(AppTool, Gerber): 'full': 2 }[tool_data['tools_iso_isotype']] - forced_rest = self.ui.forced_rest_iso_cb.get_value() - iso_except = self.ui.except_cb.get_value() + forced_rest = self.t_ui.forced_rest_iso_cb.get_value() + iso_except = self.t_ui.except_cb.get_value() outname = "%s_%.*f" % (iso_obj.options["name"], self.decimals, float(tool_dia)) internal_name = outname + "_iso" @@ -1653,10 +1656,10 @@ class ToolIsolation(AppTool, Gerber): prog_plot = self.app.defaults["tools_iso_plotting"] sorted_tools = [] - table_items = self.ui.tools_table.selectedItems() + table_items = self.t_ui.tools_table.selectedItems() sel_rows = {t.row() for t in table_items} for row in sel_rows: - tid = int(self.ui.tools_table.item(row, 3).text()) + tid = int(self.t_ui.tools_table.item(row, 3).text()) sorted_tools.append(tid) if not sorted_tools: self.app.inform.emit('[ERROR_NOTCL] %s' % _("No selected tools in Tool Table.")) @@ -1687,7 +1690,7 @@ class ToolIsolation(AppTool, Gerber): milling_type = tool_data['tools_iso_milling_type'] - iso_except = self.ui.except_cb.get_value() + iso_except = self.t_ui.except_cb.get_value() outname = "%s_%.*f" % (iso_obj.options["name"], self.decimals, float(tool_dia)) @@ -1815,7 +1818,7 @@ class ToolIsolation(AppTool, Gerber): if subtraction_geo: sub_union = cascaded_union(subtraction_geo) else: - name = self.ui.exc_obj_combo.currentText() + name = self.t_ui.exc_obj_combo.currentText() subtractor_obj = self.app.collection.get_by_name(name) sub_union = cascaded_union(subtractor_obj.solid_geometry) @@ -1938,7 +1941,7 @@ class ToolIsolation(AppTool, Gerber): curr_pos = (curr_pos[0], curr_pos[1]) if event.button == 1: - if self.ui.poly_int_cb.get_value() is True: + if self.t_ui.poly_int_cb.get_value() is True: clicked_poly = self.find_polygon_ignore_interiors(point=(curr_pos[0], curr_pos[1]), geoset=self.grb_obj.solid_geometry) @@ -2000,7 +2003,7 @@ class ToolIsolation(AppTool, Gerber): if self.poly_dict: poly_list = deepcopy(list(self.poly_dict.values())) - if self.ui.poly_int_cb.get_value() is True: + if self.t_ui.poly_int_cb.get_value() is True: # isolate the interior polygons with a negative tool self.isolate(isolated_obj=self.grb_obj, geometry=poly_list, negative_dia=True) else: @@ -2138,7 +2141,7 @@ class ToolIsolation(AppTool, Gerber): return "" elif event.button == right_button and self.mouse_is_dragging is False: - shape_type = self.ui.area_shape_radio.get_value() + shape_type = self.t_ui.area_shape_radio.get_value() if shape_type == "square": self.first_click = False @@ -2198,7 +2201,7 @@ class ToolIsolation(AppTool, Gerber): # called on mouse move def on_mouse_move(self, event): - shape_type = self.ui.area_shape_radio.get_value() + shape_type = self.t_ui.area_shape_radio.get_value() if self.app.is_legacy is False: event_pos = event.pos @@ -2352,9 +2355,9 @@ class ToolIsolation(AppTool, Gerber): # select last tool added toolid = res - for row in range(self.ui.tools_table.rowCount()): - if int(self.ui.tools_table.item(row, 3).text()) == toolid: - self.ui.tools_table.selectRow(row) + for row in range(self.t_ui.tools_table.rowCount()): + if int(self.t_ui.tools_table.item(row, 3).text()) == toolid: + self.t_ui.tools_table.selectRow(row) self.on_row_selection_change() def on_tool_from_db_inserted(self, tool): @@ -2415,12 +2418,12 @@ class ToolIsolation(AppTool, Gerber): self.build_ui() # select the tool just added - for row in range(self.ui.tools_table.rowCount()): - if int(self.ui.tools_table.item(row, 3).text()) == self.tooluid: - self.ui.tools_table.selectRow(row) + for row in range(self.t_ui.tools_table.rowCount()): + if int(self.t_ui.tools_table.item(row, 3).text()) == self.tooluid: + self.t_ui.tools_table.selectRow(row) break - # if self.ui.tools_table.rowCount() != 0: + # if self.t_ui.tools_table.rowCount() != 0: # self.param_frame.setDisabled(False) def on_tool_add_from_db_clicked(self): diff --git a/defaults.py b/defaults.py index c896b818..96294d41 100644 --- a/defaults.py +++ b/defaults.py @@ -251,7 +251,7 @@ class FlatCAMDefaults: # Excellon Options "excellon_operation": "drill", - "excellon_tool_order": 'rev', + "excellon_tool_order": 'no', "excellon_milling_type": "drills", "excellon_milling_dia": 0.8,