1591 lines
65 KiB
Python
1591 lines
65 KiB
Python
# ##########################################################
|
|
# FlatCAM: 2D Post-processing for Manufacturing #
|
|
# File Author: Marius Adrian Stanciu (c) #
|
|
# Date: 3/10/2019 #
|
|
# MIT Licence #
|
|
# ##########################################################
|
|
|
|
from appTool import AppTool
|
|
from appCommon.Common import LoudDict
|
|
from appGUI.GUIElements import FCComboBox, FCEntry, FCTable, FCDoubleSpinner, FCSpinner, FCFileSaveDialog, \
|
|
FCInputSpinner
|
|
from app_Main import log
|
|
from camlib import distance
|
|
from appEditors.AppTextEditor import AppTextEditor
|
|
|
|
from PyQt5 import QtGui, QtCore, QtWidgets
|
|
from PyQt5.QtCore import Qt
|
|
from copy import deepcopy
|
|
from datetime import datetime
|
|
|
|
from shapely.geometry import Polygon, LineString
|
|
from shapely.ops import unary_union
|
|
|
|
import traceback
|
|
from io import StringIO
|
|
|
|
import gettext
|
|
import appTranslation as fcTranslate
|
|
import builtins
|
|
|
|
fcTranslate.apply_language('strings')
|
|
if '_' not in builtins.__dict__:
|
|
_ = gettext.gettext
|
|
|
|
|
|
class SolderPaste(AppTool):
|
|
|
|
def __init__(self, app):
|
|
AppTool.__init__(self, app)
|
|
self.app = app
|
|
|
|
# Number of decimals to be used for tools/nozzles in this FlatCAM Tool
|
|
self.decimals = self.app.decimals
|
|
|
|
# #############################################################################
|
|
# ######################### Tool GUI ##########################################
|
|
# #############################################################################
|
|
self.ui = SolderUI(layout=self.layout, app=self.app, solder_class=self)
|
|
self.toolName = self.ui.toolName
|
|
|
|
self.tooltable_tools = {}
|
|
self.tooluid = 0
|
|
|
|
self.options = LoudDict()
|
|
self.form_fields = {}
|
|
|
|
self.units = ''
|
|
self.name = ""
|
|
|
|
self.obj = None
|
|
self.text_editor_tab = None
|
|
|
|
# this will be used in the combobox context menu, for delete entry
|
|
self.obj_to_be_deleted_name = ''
|
|
|
|
# stpre here the flattened geometry
|
|
self.flat_geometry = []
|
|
|
|
# action to be added in the combobox context menu
|
|
self.combo_context_del_action = QtWidgets.QAction(QtGui.QIcon(self.app.resource_location + '/trash16.png'),
|
|
_("Delete Object"))
|
|
|
|
# ## Signals
|
|
self.combo_context_del_action.triggered.connect(self.on_delete_object)
|
|
|
|
self.ui.addtool_btn.clicked.connect(self.on_tool_add)
|
|
self.ui.addtool_entry.returnPressed.connect(self.on_tool_add)
|
|
self.ui.deltool_btn.clicked.connect(self.on_tool_delete)
|
|
self.ui.soldergeo_btn.clicked.connect(self.on_create_geo_click)
|
|
self.ui.solder_gcode_btn.clicked.connect(self.on_create_gcode_click)
|
|
self.ui.solder_gcode_view_btn.clicked.connect(self.on_view_gcode)
|
|
self.ui.solder_gcode_save_btn.clicked.connect(self.on_save_gcode)
|
|
|
|
self.ui.geo_obj_combo.currentIndexChanged.connect(self.on_geo_select)
|
|
self.ui.cnc_obj_combo.currentIndexChanged.connect(self.on_cncjob_select)
|
|
|
|
self.app.object_status_changed.connect(self.update_comboboxes)
|
|
self.ui.reset_button.clicked.connect(self.set_tool_ui)
|
|
|
|
def run(self, toggle=True):
|
|
self.app.defaults.report_usage("ToolSolderPaste()")
|
|
|
|
if toggle:
|
|
# if the splitter is hidden, display it, else hide it but only if the current widget is the same
|
|
if self.app.ui.splitter.sizes()[0] == 0:
|
|
self.app.ui.splitter.setSizes([1, 1])
|
|
else:
|
|
try:
|
|
if self.app.ui.tool_scroll_area.widget().objectName() == self.toolName:
|
|
# if tab is populated with the tool but it does not have the focus, focus on it
|
|
if not self.app.ui.notebook.currentWidget() is self.app.ui.tool_tab:
|
|
# focus on Tool Tab
|
|
self.app.ui.notebook.setCurrentWidget(self.app.ui.tool_tab)
|
|
else:
|
|
self.app.ui.splitter.setSizes([0, 1])
|
|
except AttributeError:
|
|
pass
|
|
else:
|
|
if self.app.ui.splitter.sizes()[0] == 0:
|
|
self.app.ui.splitter.setSizes([1, 1])
|
|
|
|
AppTool.run(self)
|
|
self.set_tool_ui()
|
|
self.build_ui()
|
|
|
|
self.app.ui.notebook.setTabText(2, _("SolderPaste Tool"))
|
|
|
|
def install(self, icon=None, separator=None, **kwargs):
|
|
AppTool.install(self, icon, separator, shortcut='Alt+K', **kwargs)
|
|
|
|
def on_add_tool_by_key(self):
|
|
tool_add_popup = FCInputSpinner(title='%s...' % _("New Tool"),
|
|
text='%s:' % _('Enter a Tool Diameter'),
|
|
min=0.0000, max=100.0000, decimals=self.decimals, step=0.1)
|
|
tool_add_popup.setWindowIcon(QtGui.QIcon(self.app.resource_location + '/letter_t_32.png'))
|
|
|
|
val, ok = tool_add_popup.get_value()
|
|
if ok:
|
|
if float(val) == 0:
|
|
self.app.inform.emit('[WARNING_NOTCL] %s' %
|
|
_("Please enter a tool diameter with non-zero value, in Float format."))
|
|
return
|
|
self.on_tool_add(dia=float(val))
|
|
else:
|
|
self.app.inform.emit('[WARNING_NOTCL] %s...' % _("Adding Tool cancelled"))
|
|
|
|
def set_tool_ui(self):
|
|
self.form_fields.update({
|
|
"tools_solderpaste_new": self.ui.addtool_entry,
|
|
"tools_solderpaste_z_start": self.ui.z_start_entry,
|
|
"tools_solderpaste_z_dispense": self.ui.z_dispense_entry,
|
|
"tools_solderpaste_z_stop": self.ui.z_stop_entry,
|
|
"tools_solderpaste_z_travel": self.ui.z_travel_entry,
|
|
"tools_solderpaste_z_toolchange": self.ui.z_toolchange_entry,
|
|
"tools_solderpaste_xy_toolchange": self.ui.xy_toolchange_entry,
|
|
"tools_solderpaste_frxy": self.ui.frxy_entry,
|
|
"tools_solderpaste_frz": self.ui.frz_entry,
|
|
"tools_solderpaste_frz_dispense": self.ui.frz_dispense_entry,
|
|
"tools_solderpaste_speedfwd": self.ui.speedfwd_entry,
|
|
"tools_solderpaste_dwellfwd": self.ui.dwellfwd_entry,
|
|
"tools_solderpaste_speedrev": self.ui.speedrev_entry,
|
|
"tools_solderpaste_dwellrev": self.ui.dwellrev_entry,
|
|
"tools_solderpaste_pp": self.ui.pp_combo
|
|
})
|
|
self.set_form_from_defaults()
|
|
self.read_form_to_options()
|
|
|
|
self.ui.tools_table.setupContextMenu()
|
|
self.ui.tools_table.addContextMenu(
|
|
_("Add"), lambda: self.on_tool_add(dia=None, muted=None),
|
|
icon=QtGui.QIcon(self.app.resource_location + "/plus16.png"))
|
|
self.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")
|
|
)
|
|
|
|
try:
|
|
dias = [float(eval(dia)) for dia in self.app.defaults["tools_solderpaste_tools"].split(",") if dia != '']
|
|
except Exception:
|
|
log.error("At least one Nozzle tool diameter needed. "
|
|
"Verify in Edit -> Preferences -> TOOLS -> Solder Paste Tools.")
|
|
return
|
|
|
|
self.tooluid = 0
|
|
|
|
self.tooltable_tools.clear()
|
|
for tool_dia in dias:
|
|
self.tooluid += 1
|
|
self.tooltable_tools.update({
|
|
int(self.tooluid): {
|
|
'tooldia': float('%.*f' % (self.decimals, tool_dia)),
|
|
'data': deepcopy(self.options),
|
|
'solid_geometry': []
|
|
}
|
|
})
|
|
|
|
self.name = ""
|
|
self.obj = None
|
|
|
|
self.units = self.app.defaults['units'].upper()
|
|
|
|
for name in list(self.app.preprocessors.keys()):
|
|
# populate only with preprocessor files that start with 'Paste_'
|
|
if name.partition('_')[0] != 'Paste':
|
|
continue
|
|
self.ui.pp_combo.addItem(name)
|
|
|
|
self.reset_fields()
|
|
|
|
def build_ui(self):
|
|
"""
|
|
Will rebuild the UI populating it (tools table)
|
|
:return:
|
|
"""
|
|
self.ui_disconnect()
|
|
|
|
# updated units
|
|
self.units = self.app.defaults['units'].upper()
|
|
|
|
sorted_tools = []
|
|
for k, v in self.tooltable_tools.items():
|
|
sorted_tools.append(float('%.*f' % (self.decimals, float(v['tooldia']))))
|
|
sorted_tools.sort(reverse=True)
|
|
|
|
n = len(sorted_tools)
|
|
self.ui.tools_table.setRowCount(n)
|
|
tool_id = 0
|
|
|
|
for tool_sorted in sorted_tools:
|
|
for tooluid_key, tooluid_value in self.tooltable_tools.items():
|
|
if float('%.*f' % (self.decimals, tooluid_value['tooldia'])) == tool_sorted:
|
|
tool_id += 1
|
|
|
|
# Tool name/id
|
|
id_item = QtWidgets.QTableWidgetItem('%d' % int(tool_id))
|
|
id_item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
|
|
row_no = tool_id - 1
|
|
self.ui.tools_table.setItem(row_no, 0, id_item)
|
|
|
|
# Diameter
|
|
dia = QtWidgets.QTableWidgetItem('%.*f' % (self.decimals, tooluid_value['tooldia']))
|
|
dia.setFlags(QtCore.Qt.ItemIsEnabled)
|
|
self.ui.tools_table.setItem(row_no, 1, dia)
|
|
|
|
# Tool unique ID
|
|
tool_uid_item = QtWidgets.QTableWidgetItem(str(int(tooluid_key)))
|
|
self.ui.tools_table.setItem(row_no, 2, tool_uid_item)
|
|
|
|
# make the diameter column editable
|
|
for row in range(tool_id):
|
|
self.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.ui.tools_table.resizeColumnsToContents()
|
|
self.ui.tools_table.resizeRowsToContents()
|
|
|
|
vertical_header = self.ui.tools_table.verticalHeader()
|
|
vertical_header.hide()
|
|
self.ui.tools_table.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
|
|
|
|
horizontal_header = self.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)
|
|
# sort by tool diameter
|
|
# self.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.ui_connect()
|
|
|
|
def update_ui(self, row=None):
|
|
"""
|
|
Will update the UI form with the data from obj.tools
|
|
:param row: the row (tool) from which to extract information's used to populate the form
|
|
:return:
|
|
"""
|
|
self.ui_disconnect()
|
|
|
|
if row is None:
|
|
try:
|
|
current_row = self.ui.tools_table.currentRow()
|
|
except Exception:
|
|
current_row = 0
|
|
else:
|
|
current_row = row
|
|
|
|
if current_row < 0:
|
|
current_row = 0
|
|
|
|
# populate the form with the data from the tool associated with the row parameter
|
|
try:
|
|
tooluid = int(self.ui.tools_table.item(current_row, 2).text())
|
|
except Exception as e:
|
|
log.debug("Tool missing. Add a tool in Tool Table. %s" % str(e))
|
|
return
|
|
|
|
# update the form
|
|
try:
|
|
# set the form with data from the newly selected tool
|
|
for tooluid_key, tooluid_value in self.tooltable_tools.items():
|
|
if int(tooluid_key) == tooluid:
|
|
self.set_form(deepcopy(tooluid_value['data']))
|
|
except Exception as e:
|
|
log.debug("ToolSolderPaste ---> update_ui() " + str(e))
|
|
|
|
self.ui_connect()
|
|
|
|
def on_row_selection_change(self):
|
|
sel_model = self.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
|
|
sel_rows = set()
|
|
for idx in sel_indexes:
|
|
sel_rows.add(idx.row())
|
|
|
|
# update UI only if only one row is selected otherwise having multiple rows selected will deform information
|
|
# for the rows other that the current one (first selected)
|
|
if len(sel_rows) == 1:
|
|
self.update_ui()
|
|
|
|
def ui_connect(self):
|
|
# on any change to the widgets that matter it will be called self.gui_form_to_storage which will save the
|
|
# changes in geometry UI
|
|
for i in range(self.ui.gcode_form_layout.count()):
|
|
if isinstance(self.ui.gcode_form_layout.itemAt(i).widget(), FCComboBox):
|
|
self.ui.gcode_form_layout.itemAt(i).widget().currentIndexChanged.connect(self.read_form_to_tooldata)
|
|
if isinstance(self.ui.gcode_form_layout.itemAt(i).widget(), FCEntry):
|
|
self.ui.gcode_form_layout.itemAt(i).widget().editingFinished.connect(self.read_form_to_tooldata)
|
|
|
|
self.ui.tools_table.itemChanged.connect(self.on_tool_edit)
|
|
self.ui.tools_table.currentItemChanged.connect(self.on_row_selection_change)
|
|
|
|
def ui_disconnect(self):
|
|
# if connected, disconnect the signal from the slot on item_changed as it creates issues
|
|
|
|
for i in range(self.ui.gcode_form_layout.count()):
|
|
if isinstance(self.ui.gcode_form_layout.itemAt(i).widget(), FCComboBox):
|
|
try:
|
|
self.ui.gcode_form_layout.itemAt(i).widget().currentIndexChanged.disconnect()
|
|
except (TypeError, AttributeError):
|
|
pass
|
|
if isinstance(self.ui.gcode_form_layout.itemAt(i).widget(), FCEntry):
|
|
try:
|
|
self.ui.gcode_form_layout.itemAt(i).widget().editingFinished.disconnect()
|
|
except (TypeError, AttributeError):
|
|
pass
|
|
|
|
try:
|
|
self.ui.tools_table.itemChanged.disconnect(self.on_tool_edit)
|
|
except (TypeError, AttributeError):
|
|
pass
|
|
|
|
try:
|
|
self.ui.tools_table.currentItemChanged.disconnect(self.on_row_selection_change)
|
|
except (TypeError, AttributeError):
|
|
pass
|
|
|
|
def update_comboboxes(self, obj, status):
|
|
"""
|
|
Modify the current text of the comboboxes to show the last object
|
|
that was created.
|
|
|
|
:param obj: object that was changed and called this PyQt slot
|
|
:param status: what kind of change happened: 'append' or 'delete'
|
|
:return:
|
|
"""
|
|
try:
|
|
obj_name = obj.options['name']
|
|
except AttributeError:
|
|
# this happen when the 'delete all' is emitted since in that case the obj is set to None and None has no
|
|
# attribute named 'options'
|
|
return
|
|
|
|
if status == 'append':
|
|
idx = self.ui.obj_combo.findText(obj_name)
|
|
if idx != -1:
|
|
self.ui.obj_combo.setCurrentIndex(idx)
|
|
|
|
idx = self.ui.geo_obj_combo.findText(obj_name)
|
|
if idx != -1:
|
|
self.ui.geo_obj_combo.setCurrentIndex(idx)
|
|
|
|
idx = self.ui.cnc_obj_combo.findText(obj_name)
|
|
if idx != -1:
|
|
self.ui.cnc_obj_combo.setCurrentIndex(idx)
|
|
|
|
def read_form_to_options(self):
|
|
"""
|
|
Will read all the parameters from Solder Paste Tool UI and update the self.options dictionary
|
|
:return:
|
|
"""
|
|
|
|
for key in self.form_fields:
|
|
self.options[key] = self.form_fields[key].get_value()
|
|
|
|
def read_form_to_tooldata(self, tooluid=None):
|
|
"""
|
|
Will read all the items in the UI form and set the self.tools data accordingly
|
|
:param tooluid: the uid of the tool to be updated in the obj.tools
|
|
:return:
|
|
"""
|
|
current_row = self.ui.tools_table.currentRow()
|
|
uid = tooluid if tooluid else int(self.ui.tools_table.item(current_row, 2).text())
|
|
for key in self.form_fields:
|
|
self.tooltable_tools[uid]['data'].update({
|
|
key: self.form_fields[key].get_value()
|
|
})
|
|
|
|
def set_form_from_defaults(self):
|
|
"""
|
|
Will read all the parameters of Solder Paste Tool from the app self.defaults and update the UI
|
|
:return:
|
|
"""
|
|
for key in self.form_fields:
|
|
if key in self.app.defaults:
|
|
self.form_fields[key].set_value(self.app.defaults[key])
|
|
|
|
def set_form(self, val):
|
|
"""
|
|
Will read all the parameters of Solder Paste Tool from the provided val parameter and update the UI
|
|
:param val: dictionary with values to store in the form
|
|
param_type: dictionary
|
|
:return:
|
|
"""
|
|
|
|
if not isinstance(val, dict):
|
|
log.debug("ToolSoderPaste.set_form() --> parameter not a dict")
|
|
return
|
|
|
|
for key in self.form_fields:
|
|
if key in val:
|
|
self.form_fields[key].set_value(val[key])
|
|
|
|
def on_tool_add(self, dia=None, muted=None):
|
|
"""
|
|
Add a Tool in the Tool Table
|
|
|
|
:param dia: diameter of the tool to be added
|
|
:param muted: if True will not send status bar messages about adding tools
|
|
:return:
|
|
"""
|
|
self.ui_disconnect()
|
|
|
|
if dia:
|
|
tool_dia = dia
|
|
else:
|
|
try:
|
|
tool_dia = float(self.ui.addtool_entry.get_value())
|
|
except ValueError:
|
|
# try to convert comma to decimal point. if it's still not working error message and return
|
|
try:
|
|
tool_dia = float(self.ui.addtool_entry.get_value().replace(',', '.'))
|
|
except ValueError:
|
|
self.app.inform.emit('[ERROR_NOTCL] %s' %
|
|
_("Wrong value format entered, use a number."))
|
|
return
|
|
if tool_dia is None:
|
|
self.build_ui()
|
|
self.app.inform.emit('[WARNING_NOTCL] %s' % _("Please enter a tool diameter to add, in Float format."))
|
|
return
|
|
|
|
if tool_dia == 0:
|
|
self.app.inform.emit('[WARNING_NOTCL] %s' %
|
|
_("Please enter a tool diameter with non-zero value, in Float format."))
|
|
return
|
|
|
|
# construct a list of all 'tooluid' in the self.tooltable_tools
|
|
tool_uid_list = []
|
|
for tooluid_key in self.tooltable_tools:
|
|
tool_uid_item = int(tooluid_key)
|
|
tool_uid_list.append(tool_uid_item)
|
|
|
|
# find maximum from the temp_uid, add 1 and this is the new 'tooluid'
|
|
if not tool_uid_list:
|
|
max_uid = 0
|
|
else:
|
|
max_uid = max(tool_uid_list)
|
|
self.tooluid = int(max_uid + 1)
|
|
|
|
tool_dias = []
|
|
for k, v in self.tooltable_tools.items():
|
|
for tool_v in v.keys():
|
|
if tool_v == 'tooldia':
|
|
tool_dias.append(float('%.*f' % (self.decimals, v[tool_v])))
|
|
|
|
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)
|
|
return
|
|
else:
|
|
if muted is None:
|
|
self.app.inform.emit('[success] %s' % _("New Nozzle tool added to Tool Table."))
|
|
self.tooltable_tools.update({
|
|
int(self.tooluid): {
|
|
'tooldia': float('%.*f' % (self.decimals, tool_dia)),
|
|
'data': deepcopy(self.options),
|
|
'solid_geometry': []
|
|
}
|
|
})
|
|
|
|
self.build_ui()
|
|
|
|
def on_tool_edit(self):
|
|
"""
|
|
Edit a tool in the Tool Table
|
|
:return:
|
|
"""
|
|
self.ui_disconnect()
|
|
|
|
tool_dias = []
|
|
for k, v in self.tooltable_tools.items():
|
|
for tool_v in v.keys():
|
|
if tool_v == 'tooldia':
|
|
tool_dias.append(float('%.*f' % (self.decimals, v[tool_v])))
|
|
|
|
for row in range(self.ui.tools_table.rowCount()):
|
|
|
|
try:
|
|
new_tool_dia = float(self.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:
|
|
new_tool_dia = float(self.ui.tools_table.item(row, 1).text().replace(',', '.'))
|
|
except ValueError:
|
|
self.app.inform.emit('[ERROR_NOTCL] %s' %
|
|
_("Wrong value format entered, use a number."))
|
|
return
|
|
|
|
tooluid = int(self.ui.tools_table.item(row, 2).text())
|
|
|
|
# identify the tool that was edited and get it's tooluid
|
|
if new_tool_dia not in tool_dias:
|
|
self.tooltable_tools[tooluid]['tooldia'] = new_tool_dia
|
|
self.app.inform.emit('[success] %s' % _("Nozzle tool from Tool Table was edited."))
|
|
self.build_ui()
|
|
return
|
|
else:
|
|
old_tool_dia = ''
|
|
# identify the old tool_dia and restore the text in tool table
|
|
for k, v in self.tooltable_tools.items():
|
|
if k == tooluid:
|
|
old_tool_dia = v['tooldia']
|
|
break
|
|
restore_dia_item = self.ui.tools_table.item(row, 1)
|
|
restore_dia_item.setText(str(old_tool_dia))
|
|
self.app.inform.emit('[WARNING_NOTCL] %s' %
|
|
_("Cancelled. New diameter value is already in the Tool Table."))
|
|
self.build_ui()
|
|
|
|
def on_tool_delete(self, rows_to_delete=None, all_tools=None):
|
|
"""
|
|
Will delete tool(s) in the Tool Table
|
|
|
|
:param rows_to_delete: tell which row (tool) to delete
|
|
:param all_tools: to delete all tools at once
|
|
:return:
|
|
"""
|
|
self.ui_disconnect()
|
|
|
|
deleted_tools_list = []
|
|
if all_tools:
|
|
self.tooltable_tools.clear()
|
|
self.build_ui()
|
|
return
|
|
|
|
if rows_to_delete:
|
|
try:
|
|
for row in rows_to_delete:
|
|
tooluid_del = int(self.ui.tools_table.item(row, 2).text())
|
|
deleted_tools_list.append(tooluid_del)
|
|
except TypeError:
|
|
deleted_tools_list.append(rows_to_delete)
|
|
|
|
for t in deleted_tools_list:
|
|
self.tooltable_tools.pop(t, None)
|
|
self.build_ui()
|
|
return
|
|
|
|
try:
|
|
if self.ui.tools_table.selectedItems():
|
|
for row_sel in self.ui.tools_table.selectedItems():
|
|
row = row_sel.row()
|
|
if row < 0:
|
|
continue
|
|
tooluid_del = int(self.ui.tools_table.item(row, 2).text())
|
|
deleted_tools_list.append(tooluid_del)
|
|
|
|
for t in deleted_tools_list:
|
|
self.tooltable_tools.pop(t, None)
|
|
|
|
except AttributeError:
|
|
self.app.inform.emit('[WARNING_NOTCL] %s' % _("Delete failed. Select a tool to delete."))
|
|
return
|
|
except Exception as e:
|
|
log.debug(str(e))
|
|
|
|
self.app.inform.emit('[success] %s' % _("Tools deleted from Tool Table."))
|
|
self.build_ui()
|
|
|
|
def on_rmb_combo(self, pos, combo):
|
|
"""
|
|
Will create a context menu on the combobox items
|
|
:param pos: mouse click position passed by the signal that called this slot
|
|
:param combo: the actual combo from where the signal was triggered
|
|
:return:
|
|
"""
|
|
view = combo.view
|
|
idx = view.indexAt(pos)
|
|
if not idx.isValid():
|
|
return
|
|
|
|
self.obj_to_be_deleted_name = combo.model().itemData(idx)[0]
|
|
|
|
menu = QtWidgets.QMenu()
|
|
menu.addAction(self.combo_context_del_action)
|
|
menu.exec(view.mapToGlobal(pos))
|
|
|
|
def on_delete_object(self):
|
|
"""
|
|
Slot for the 'delete' action triggered in the combobox context menu.
|
|
The name of the object to be deleted is collected when the combobox context menu is created.
|
|
:return:
|
|
"""
|
|
if self.obj_to_be_deleted_name != '':
|
|
self.app.collection.set_active(self.obj_to_be_deleted_name)
|
|
self.app.collection.delete_active(select_project=False)
|
|
self.obj_to_be_deleted_name = ''
|
|
|
|
def on_geo_select(self):
|
|
# if self.geo_obj_combo.currentText().rpartition('_')[2] == 'solderpaste':
|
|
# self.gcode_frame.setDisabled(False)
|
|
# else:
|
|
# self.gcode_frame.setDisabled(True)
|
|
pass
|
|
|
|
def on_cncjob_select(self):
|
|
# if self.cnc_obj_combo.currentText().rpartition('_')[2] == 'solderpaste':
|
|
# self.save_gcode_frame.setDisabled(False)
|
|
# else:
|
|
# self.save_gcode_frame.setDisabled(True)
|
|
pass
|
|
|
|
def on_create_geo_click(self):
|
|
"""
|
|
Will create a solderpaste dispensing geometry.
|
|
|
|
:return:
|
|
"""
|
|
name = self.ui.obj_combo.currentText()
|
|
if name == '':
|
|
self.app.inform.emit('[WARNING_NOTCL] %s' % _("No SolderPaste mask Gerber object loaded."))
|
|
return
|
|
|
|
obj = self.app.collection.get_by_name(name)
|
|
# update the self.options
|
|
self.read_form_to_options()
|
|
|
|
self.on_create_geo(name=name, work_object=obj)
|
|
|
|
def on_create_geo(self, name, work_object, use_thread=True):
|
|
"""
|
|
The actual work for creating solderpaste dispensing geometry is done here.
|
|
|
|
:param name: the outname for the resulting geometry object
|
|
:param work_object: the source Gerber object from which the geometry is created
|
|
:param use_thread: use thread, True or False
|
|
:return: a Geometry type object
|
|
"""
|
|
proc = self.app.proc_container.new(_("Working ..."))
|
|
obj = work_object
|
|
|
|
# Sort tools in descending order
|
|
sorted_tools = []
|
|
for k, v in self.tooltable_tools.items():
|
|
# make sure that the tools diameter is more than zero and not zero
|
|
if float(v['tooldia']) > 0:
|
|
sorted_tools.append(float('%.*f' % (self.decimals, float(v['tooldia']))))
|
|
sorted_tools.sort(reverse=True)
|
|
|
|
if not sorted_tools:
|
|
self.app.inform.emit('[WARNING_NOTCL] %s' %
|
|
_("No Nozzle tools in the tool table."))
|
|
return 'fail'
|
|
|
|
def flatten(geometry=None, reset=True, pathonly=False):
|
|
"""
|
|
Creates a list of non-iterable linear geometry objects.
|
|
Polygons are expanded into its exterior pathonly param if specified.
|
|
|
|
Results are placed in flat_geometry
|
|
|
|
:param geometry: Shapely type or list or list of list of such.
|
|
:param reset: Clears the contents of self.flat_geometry.
|
|
:param pathonly: Expands polygons into linear elements from the exterior attribute.
|
|
"""
|
|
|
|
if reset:
|
|
self.flat_geometry = []
|
|
# ## If iterable, expand recursively.
|
|
try:
|
|
for geo in geometry:
|
|
if geo is not None:
|
|
flatten(geometry=geo,
|
|
reset=False,
|
|
pathonly=pathonly)
|
|
|
|
# ## Not iterable, do the actual indexing and add.
|
|
except TypeError:
|
|
if pathonly and type(geometry) == Polygon:
|
|
self.flat_geometry.append(geometry.exterior)
|
|
else:
|
|
self.flat_geometry.append(geometry)
|
|
return self.flat_geometry
|
|
|
|
# TODO when/if the Gerber files will have solid_geometry in the self.apertures I will have to take care here
|
|
flatten(geometry=obj.solid_geometry, pathonly=True)
|
|
|
|
def geo_init(geo_obj, app_obj):
|
|
geo_obj.options.update(self.options)
|
|
geo_obj.solid_geometry = []
|
|
|
|
geo_obj.tools = {}
|
|
geo_obj.multigeo = True
|
|
geo_obj.multitool = True
|
|
geo_obj.special_group = 'solder_paste_tool'
|
|
|
|
geo = LineString()
|
|
work_geo = self.flat_geometry
|
|
rest_geo = []
|
|
tooluid = 1
|
|
|
|
for tool in sorted_tools:
|
|
offset = tool / 2
|
|
for uid, vl in self.tooltable_tools.items():
|
|
if float('%.*f' % (self.decimals, float(vl['tooldia']))) == tool:
|
|
tooluid = int(uid)
|
|
break
|
|
|
|
geo_obj.tools[tooluid] = {}
|
|
geo_obj.tools[tooluid]['tooldia'] = tool
|
|
geo_obj.tools[tooluid]['data'] = deepcopy(self.tooltable_tools[tooluid]['data'])
|
|
geo_obj.tools[tooluid]['solid_geometry'] = []
|
|
geo_obj.tools[tooluid]['offset'] = 'Path'
|
|
geo_obj.tools[tooluid]['offset_value'] = 0.0
|
|
geo_obj.tools[tooluid]['type'] = 'SolderPaste'
|
|
geo_obj.tools[tooluid]['tool_type'] = 'DN'
|
|
|
|
# self.flat_geometry is a list of LinearRings produced by flatten() from the exteriors of the Polygons
|
|
# We get possible issues if we try to directly use the Polygons, due of possible the interiors,
|
|
# so we do a hack: get first the exterior in a form of LinearRings and then convert back to Polygon
|
|
# because intersection does not work on LinearRings
|
|
for g in work_geo:
|
|
# for whatever reason intersection on LinearRings does not work so we convert back to Polygons
|
|
poly = Polygon(g)
|
|
x_min, y_min, x_max, y_max = poly.bounds
|
|
|
|
diag_1_intersect = LineString([(x_min, y_min), (x_max, y_max)]).intersection(poly)
|
|
diag_2_intersect = LineString([(x_min, y_max), (x_max, y_min)]).intersection(poly)
|
|
|
|
if self.units == 'MM':
|
|
round_diag_1 = round(diag_1_intersect.length, 1)
|
|
round_diag_2 = round(diag_2_intersect.length, 1)
|
|
else:
|
|
round_diag_1 = round(diag_1_intersect.length, 2)
|
|
round_diag_2 = round(diag_2_intersect.length, 2)
|
|
|
|
if round_diag_1 == round_diag_2:
|
|
length = distance((x_min, y_min), (x_max, y_min))
|
|
h = distance((x_min, y_min), (x_min, y_max))
|
|
|
|
if offset >= length / 2 or offset >= h / 2:
|
|
pass
|
|
else:
|
|
if length > h:
|
|
h_half = h / 2
|
|
start = [x_min, (y_min + h_half)]
|
|
stop = [(x_min + length), (y_min + h_half)]
|
|
geo = LineString([start, stop])
|
|
else:
|
|
l_half = length / 2
|
|
start = [(x_min + l_half), y_min]
|
|
stop = [(x_min + l_half), (y_min + h)]
|
|
geo = LineString([start, stop])
|
|
elif round_diag_1 > round_diag_2:
|
|
geo = diag_1_intersect
|
|
else:
|
|
geo = diag_2_intersect
|
|
|
|
offseted_poly = poly.buffer(-offset)
|
|
geo = geo.intersection(offseted_poly)
|
|
if not geo.is_empty:
|
|
try:
|
|
geo_obj.tools[tooluid]['solid_geometry'].append(geo)
|
|
except Exception as e:
|
|
log.debug('ToolSolderPaste.on_create_geo() --> %s' % str(e))
|
|
else:
|
|
rest_geo.append(g)
|
|
|
|
work_geo = deepcopy(rest_geo)
|
|
rest_geo[:] = []
|
|
|
|
if not work_geo:
|
|
a = 0
|
|
for tooluid_key in geo_obj.tools:
|
|
if not geo_obj.tools[tooluid_key]['solid_geometry']:
|
|
a += 1
|
|
if a == len(geo_obj.tools):
|
|
msg = '[ERROR_NOTCL] %s' % '%s ...' % _('Cancelled. Empty file, it has no geometry')
|
|
self.app.inform.emit(msg)
|
|
return 'fail'
|
|
|
|
app_obj.inform.emit('[success] %s...' % _("Solder Paste geometry generated successfully"))
|
|
return
|
|
|
|
# if we still have geometry not processed at the end of the tools then we failed
|
|
# some or all the pads are not covered with solder paste
|
|
if work_geo:
|
|
app_obj.inform.emit('[WARNING_NOTCL] %s' %
|
|
_("Some or all pads have no solder "
|
|
"due of inadequate nozzle diameters..."))
|
|
return 'fail'
|
|
|
|
if use_thread:
|
|
def job_thread(app_obj):
|
|
try:
|
|
app_obj.app_obj.new_object("geometry", name + "_solderpaste", geo_init)
|
|
except Exception as e:
|
|
log.error("SolderPaste.on_create_geo() --> %s" % str(e))
|
|
proc.done()
|
|
return
|
|
proc.done()
|
|
|
|
self.app.inform.emit(_("Generating Solder Paste dispensing geometry..."))
|
|
# Promise object with the new name
|
|
self.app.collection.promise(name)
|
|
|
|
# Background
|
|
self.app.worker_task.emit({'fcn': job_thread, 'params': [self.app]})
|
|
else:
|
|
self.app.app_obj.new_object("geometry", name + "_solderpaste", geo_init)
|
|
|
|
def on_create_gcode_click(self):
|
|
"""
|
|
Will create a CNCJob object from the solderpaste dispensing geometry.
|
|
|
|
:return:
|
|
"""
|
|
name = self.ui.geo_obj_combo.currentText()
|
|
obj = self.app.collection.get_by_name(name)
|
|
|
|
if name == '':
|
|
self.app.inform.emit('[WARNING_NOTCL] %s' % _("There is no Geometry object available."))
|
|
return
|
|
|
|
if obj.special_group != 'solder_paste_tool':
|
|
self.app.inform.emit('[WARNING_NOTCL] %s' %
|
|
_("This Geometry can't be processed. "
|
|
"NOT a solder_paste_tool geometry."))
|
|
return
|
|
|
|
a = 0
|
|
for tooluid_key in obj.tools:
|
|
if obj.tools[tooluid_key]['solid_geometry'] is None:
|
|
a += 1
|
|
if a == len(obj.tools):
|
|
self.app.inform.emit('[ERROR_NOTCL] %s...' % _('Cancelled. Empty file, it has no geometry'))
|
|
return
|
|
|
|
# use the name of the first tool selected in self.geo_tools_table which has the diameter passed as tool_dia
|
|
originar_name = obj.options['name'].partition('_')[0]
|
|
outname = "%s_%s" % (originar_name, 'cnc_solderpaste')
|
|
|
|
self.on_create_gcode(name=outname, workobject=obj)
|
|
|
|
def on_create_gcode(self, name, workobject, use_thread=True):
|
|
"""
|
|
Creates a multi-tool CNCJob. The actual work is done here.
|
|
|
|
:param name: outname for the resulting CNCJob object
|
|
:param workobject: the solderpaste dispensing Geometry object that is the source
|
|
:param use_thread: True if threaded execution is desired
|
|
:return:
|
|
"""
|
|
obj = workobject
|
|
|
|
try:
|
|
xmin = obj.options['xmin']
|
|
ymin = obj.options['ymin']
|
|
xmax = obj.options['xmax']
|
|
ymax = obj.options['ymax']
|
|
except Exception as e:
|
|
log.debug("SolderPaste.on_create_gcode() --> %s\n" % str(e))
|
|
msg = '[ERROR] %s' % _("An internal error has occurred. See shell.\n")
|
|
msg += 'SolderPaste.on_create_gcode() --> %s' % str(e)
|
|
msg += traceback.format_exc()
|
|
self.app.inform.emit(msg)
|
|
return
|
|
|
|
# Object initialization function for app.app_obj.new_object()
|
|
# RUNNING ON SEPARATE THREAD!
|
|
def job_init(job_obj):
|
|
assert job_obj.kind == 'cncjob', \
|
|
"Initializer expected a CNCJobObject, got %s" % type(job_obj)
|
|
|
|
# this turn on the FlatCAMCNCJob plot for multiple tools
|
|
job_obj.multitool = True
|
|
job_obj.multigeo = True
|
|
job_obj.cnc_tools.clear()
|
|
job_obj.special_group = 'solder_paste_tool'
|
|
|
|
job_obj.options['xmin'] = xmin
|
|
job_obj.options['ymin'] = ymin
|
|
job_obj.options['xmax'] = xmax
|
|
job_obj.options['ymax'] = ymax
|
|
|
|
total_gcode = ''
|
|
for tooluid_key, tooluid_value in obj.tools.items():
|
|
# find the tool_dia associated with the tooluid_key
|
|
tool_dia = tooluid_value['tooldia']
|
|
tool_cnc_dict = deepcopy(tooluid_value)
|
|
|
|
job_obj.coords_decimals = self.app.defaults["cncjob_coords_decimals"]
|
|
job_obj.fr_decimals = self.app.defaults["cncjob_fr_decimals"]
|
|
job_obj.tool = int(tooluid_key)
|
|
|
|
# Propagate options
|
|
job_obj.options["tooldia"] = tool_dia
|
|
job_obj.options['tool_dia'] = tool_dia
|
|
|
|
# ## CREATE GCODE # ##
|
|
res = job_obj.generate_gcode_from_solderpaste_geo(**tooluid_value)
|
|
|
|
if res == 'fail':
|
|
log.debug("GeometryObject.mtool_gen_cncjob() --> generate_from_geometry2() failed")
|
|
return 'fail'
|
|
else:
|
|
tool_cnc_dict['gcode'] = res
|
|
total_gcode += res
|
|
|
|
# ## PARSE GCODE # ##
|
|
tool_cnc_dict['gcode_parsed'] = job_obj.gcode_parse()
|
|
|
|
# TODO this serve for bounding box creation only; should be optimized
|
|
tool_cnc_dict['solid_geometry'] = unary_union([geo['geom'] for geo in tool_cnc_dict['gcode_parsed']])
|
|
|
|
# tell gcode_parse from which point to start drawing the lines depending on what kind of
|
|
# object is the source of gcode
|
|
job_obj.toolchange_xy_type = "geometry"
|
|
job_obj.cnc_tools.update({
|
|
tooluid_key: deepcopy(tool_cnc_dict)
|
|
})
|
|
tool_cnc_dict.clear()
|
|
|
|
job_obj.source_file = total_gcode
|
|
|
|
if use_thread:
|
|
# To be run in separate thread
|
|
def job_thread(app_obj):
|
|
with self.app.proc_container.new('%s' % _("Working ...")):
|
|
if app_obj.app_obj.new_object("cncjob", name, job_init) != 'fail':
|
|
app_obj.inform.emit('[success] [success] %s: %s' %
|
|
(_("ToolSolderPaste CNCjob created"), name))
|
|
# Create a promise with the name
|
|
self.app.collection.promise(name)
|
|
# Send to worker
|
|
self.app.worker_task.emit({'fcn': job_thread, 'params': [self.app]})
|
|
else:
|
|
self.app.app_obj.new_object("cncjob", name, job_init)
|
|
|
|
def on_view_gcode(self):
|
|
"""
|
|
View GCode in the Editor Tab.
|
|
|
|
:return:
|
|
"""
|
|
time_str = "{:%A, %d %B %Y at %H:%M}".format(datetime.now())
|
|
|
|
self.text_editor_tab = AppTextEditor(app=self.app)
|
|
|
|
# add the tab if it was closed
|
|
self.app.ui.plot_tab_area.addTab(self.text_editor_tab, _("SP GCode Editor"))
|
|
self.text_editor_tab.setObjectName('solderpaste_gcode_editor_tab')
|
|
|
|
# Switch plot_area to CNCJob tab
|
|
self.app.ui.plot_tab_area.setCurrentWidget(self.text_editor_tab)
|
|
|
|
name = self.ui.cnc_obj_combo.currentText()
|
|
obj = self.app.collection.get_by_name(name)
|
|
|
|
try:
|
|
if obj.special_group != 'solder_paste_tool':
|
|
self.app.inform.emit('[WARNING_NOTCL] %s' %
|
|
_("This CNCJob object can't be processed. "
|
|
"NOT a solder_paste_tool CNCJob object."))
|
|
return
|
|
except AttributeError:
|
|
self.app.inform.emit('[WARNING_NOTCL] %s' %
|
|
_("This CNCJob object can't be processed. "
|
|
"NOT a solder_paste_tool CNCJob object."))
|
|
return
|
|
|
|
gcode = '(G-CODE GENERATED BY FLATCAM v%s - www.flatcam.org - Version Date: %s)\n' % \
|
|
(str(self.app.version), str(self.app.version_date)) + '\n'
|
|
|
|
gcode += '(Name: ' + str(name) + ')\n'
|
|
gcode += '(Type: ' + "G-code from " + str(obj.options['type']) + " for Solder Paste dispenser" + ')\n'
|
|
|
|
# if str(p['options']['type']) == 'Excellon' or str(p['options']['type']) == 'Excellon Geometry':
|
|
# gcode += '(Tools in use: ' + str(p['options']['Tools_in_use']) + ')\n'
|
|
|
|
gcode += '(Units: ' + self.units.upper() + ')\n' + "\n"
|
|
gcode += '(Created on ' + time_str + ')\n' + '\n'
|
|
|
|
for tool in obj.cnc_tools:
|
|
gcode += obj.cnc_tools[tool]['gcode']
|
|
|
|
# then append the text from GCode to the text editor
|
|
try:
|
|
lines = StringIO(gcode)
|
|
except Exception as e:
|
|
log.debug("ToolSolderpaste.on_view_gcode() --> %s" % str(e))
|
|
self.app.inform.emit('[ERROR_NOTCL] %s...' % _("No Gcode in the object"))
|
|
return
|
|
|
|
try:
|
|
# for line in lines:
|
|
# proc_line = str(line).strip('\n')
|
|
# self.text_editor_tab.code_editor.append(proc_line)
|
|
self.text_editor_tab.load_text(lines, move_to_start=True)
|
|
except Exception as e:
|
|
log.debug('ToolSolderPaste.on_view_gcode() -->%s' % str(e))
|
|
self.app.inform.emit('[ERROR] %s --> %s' % ('ToolSolderPaste.on_view_gcode()', str(e)))
|
|
return
|
|
|
|
def on_save_gcode(self):
|
|
"""
|
|
Save solderpaste dispensing GCode to a file on HDD.
|
|
|
|
:return:
|
|
"""
|
|
time_str = "{:%A, %d %B %Y at %H:%M}".format(datetime.now())
|
|
name = self.ui.cnc_obj_combo.currentText()
|
|
obj = self.app.collection.get_by_name(name)
|
|
|
|
if obj.special_group != 'solder_paste_tool':
|
|
self.app.inform.emit('[WARNING_NOTCL] %s' %
|
|
_("This CNCJob object can't be processed. "
|
|
"NOT a solder_paste_tool CNCJob object."))
|
|
return
|
|
|
|
_filter_ = "G-Code Files (*.nc);;G-Code Files (*.txt);;G-Code Files (*.tap);;G-Code Files (*.cnc);;" \
|
|
"G-Code Files (*.g-code);;All Files (*.*);;G-Code Files (*.gcode);;G-Code Files (*.ngc)"
|
|
|
|
try:
|
|
dir_file_to_save = self.app.get_last_save_folder() + '/' + str(name)
|
|
filename, _f = FCFileSaveDialog.get_saved_filename(
|
|
caption=_("Export GCode ..."),
|
|
directory=dir_file_to_save,
|
|
ext_filter=_filter_
|
|
)
|
|
except TypeError:
|
|
filename, _f = FCFileSaveDialog.get_saved_filename(
|
|
caption=_("Export Code ..."),
|
|
ext_filter=_filter_)
|
|
|
|
if filename == '':
|
|
self.app.inform.emit('[WARNING_NOTCL] %s' % _("Export cancelled ..."))
|
|
return
|
|
|
|
gcode = '(G-CODE GENERATED BY FLATCAM v%s - www.flatcam.org - Version Date: %s)\n' % \
|
|
(str(self.app.version), str(self.app.version_date)) + '\n'
|
|
|
|
gcode += '(Name: ' + str(name) + ')\n'
|
|
gcode += '(Type: ' + "G-code from " + str(obj.options['type']) + " for Solder Paste dispenser" + ')\n'
|
|
|
|
# if str(p['options']['type']) == 'Excellon' or str(p['options']['type']) == 'Excellon Geometry':
|
|
# gcode += '(Tools in use: ' + str(p['options']['Tools_in_use']) + ')\n'
|
|
|
|
gcode += '(Units: ' + self.units.upper() + ')\n' + "\n"
|
|
gcode += '(Created on ' + time_str + ')\n' + '\n'
|
|
|
|
for tool in obj.cnc_tools:
|
|
gcode += obj.cnc_tools[tool]['gcode']
|
|
lines = StringIO(gcode)
|
|
|
|
# ## Write
|
|
if filename is not None:
|
|
try:
|
|
with open(filename, 'w') as f:
|
|
for line in lines:
|
|
f.write(line)
|
|
except FileNotFoundError:
|
|
self.app.inform.emit('[WARNING_NOTCL] %s' %
|
|
_("No such file or directory"))
|
|
return
|
|
except PermissionError:
|
|
self.app.inform.emit('[WARNING] %s' %
|
|
_("Permission denied, saving not possible.\n"
|
|
"Most likely another app is holding the file open and not accessible."))
|
|
return 'fail'
|
|
|
|
if self.app.defaults["global_open_style"] is False:
|
|
self.app.file_opened.emit("gcode", filename)
|
|
self.app.file_saved.emit("gcode", filename)
|
|
self.app.inform.emit('[success] %s: %s' % (_("Solder paste dispenser GCode file saved to"), filename))
|
|
|
|
def reset_fields(self):
|
|
self.ui.obj_combo.setRootModelIndex(self.app.collection.index(0, 0, QtCore.QModelIndex()))
|
|
self.ui.geo_obj_combo.setRootModelIndex(self.app.collection.index(2, 0, QtCore.QModelIndex()))
|
|
self.ui.cnc_obj_combo.setRootModelIndex(self.app.collection.index(3, 0, QtCore.QModelIndex()))
|
|
|
|
|
|
class SolderUI:
|
|
|
|
toolName = _("Solder Paste Tool")
|
|
|
|
def __init__(self, layout, app, solder_class):
|
|
self.app = app
|
|
self.decimals = self.app.decimals
|
|
self.layout = layout
|
|
|
|
# ## Title
|
|
title_label = QtWidgets.QLabel("%s" % self.toolName)
|
|
title_label.setStyleSheet("""
|
|
QLabel
|
|
{
|
|
font-size: 16px;
|
|
font-weight: bold;
|
|
}
|
|
""")
|
|
self.layout.addWidget(title_label)
|
|
|
|
# ## Form Layout
|
|
obj_form_layout = QtWidgets.QFormLayout()
|
|
self.layout.addLayout(obj_form_layout)
|
|
|
|
# ## Gerber Object to be used for solderpaste dispensing
|
|
self.obj_combo = FCComboBox(callback=solder_class.on_rmb_combo)
|
|
self.obj_combo.setModel(self.app.collection)
|
|
self.obj_combo.setRootModelIndex(self.app.collection.index(0, 0, QtCore.QModelIndex()))
|
|
self.obj_combo.is_last = True
|
|
self.obj_combo.obj_type = "Gerber"
|
|
|
|
self.object_label = QtWidgets.QLabel('<b>%s</b>:' % _("GERBER"))
|
|
self.object_label.setToolTip(_("Gerber Solderpaste object.")
|
|
)
|
|
obj_form_layout.addRow(self.object_label)
|
|
obj_form_layout.addRow(self.obj_combo)
|
|
|
|
separator_line = QtWidgets.QFrame()
|
|
separator_line.setFrameShape(QtWidgets.QFrame.HLine)
|
|
separator_line.setFrameShadow(QtWidgets.QFrame.Sunken)
|
|
obj_form_layout.addRow(separator_line)
|
|
|
|
# ### Tools ## ##
|
|
self.tools_table_label = QtWidgets.QLabel('<b>%s</b>' % _('Tools Table'))
|
|
self.tools_table_label.setToolTip(
|
|
_("Tools pool from which the algorithm\n"
|
|
"will pick the ones used for dispensing solder paste.")
|
|
)
|
|
self.layout.addWidget(self.tools_table_label)
|
|
|
|
self.tools_table = FCTable()
|
|
self.layout.addWidget(self.tools_table)
|
|
|
|
self.tools_table.setColumnCount(3)
|
|
self.tools_table.setHorizontalHeaderLabels(['#', _('Diameter'), ''])
|
|
self.tools_table.setColumnHidden(2, True)
|
|
self.tools_table.setSortingEnabled(False)
|
|
# self.tools_table.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows)
|
|
|
|
self.tools_table.horizontalHeaderItem(0).setToolTip(
|
|
_("This is the Tool Number.\n"
|
|
"The solder dispensing will start with the tool with the biggest \n"
|
|
"diameter, continuing until there are no more Nozzle tools.\n"
|
|
"If there are no longer tools but there are still pads not covered\n "
|
|
"with solder paste, the app will issue a warning message box.")
|
|
)
|
|
self.tools_table.horizontalHeaderItem(1).setToolTip(
|
|
_("Nozzle tool Diameter. It's value (in current FlatCAM units)\n"
|
|
"is the width of the solder paste dispensed."))
|
|
|
|
# ### Add a new Tool ## ##
|
|
hlay_tools = QtWidgets.QHBoxLayout()
|
|
self.layout.addLayout(hlay_tools)
|
|
|
|
self.addtool_entry_lbl = QtWidgets.QLabel('<b>%s:</b>' % _('New Nozzle Tool'))
|
|
self.addtool_entry_lbl.setToolTip(
|
|
_("Diameter for the new tool to add in the Tool Table")
|
|
)
|
|
self.addtool_entry = FCDoubleSpinner(callback=self.confirmation_message)
|
|
self.addtool_entry.set_range(0.0000001, 10000.0000)
|
|
self.addtool_entry.set_precision(self.decimals)
|
|
self.addtool_entry.setSingleStep(0.1)
|
|
|
|
# hlay.addWidget(self.addtool_label)
|
|
# hlay.addStretch()
|
|
hlay_tools.addWidget(self.addtool_entry_lbl)
|
|
hlay_tools.addWidget(self.addtool_entry)
|
|
|
|
grid0 = QtWidgets.QGridLayout()
|
|
self.layout.addLayout(grid0)
|
|
|
|
self.addtool_btn = QtWidgets.QPushButton(_('Add'))
|
|
self.addtool_btn.setToolTip(
|
|
_("Add a new nozzle tool to the Tool Table\n"
|
|
"with the diameter specified above.")
|
|
)
|
|
|
|
self.deltool_btn = QtWidgets.QPushButton(_('Delete'))
|
|
self.deltool_btn.setToolTip(
|
|
_("Delete a selection of tools in the Tool Table\n"
|
|
"by first selecting a row in the Tool Table.")
|
|
)
|
|
|
|
grid0.addWidget(self.addtool_btn, 0, 0)
|
|
grid0.addWidget(self.deltool_btn, 0, 2)
|
|
|
|
separator_line = QtWidgets.QFrame()
|
|
separator_line.setFrameShape(QtWidgets.QFrame.HLine)
|
|
separator_line.setFrameShadow(QtWidgets.QFrame.Sunken)
|
|
grid0.addWidget(separator_line, 1, 0, 1, 3)
|
|
|
|
# ## Buttons
|
|
grid0_1 = QtWidgets.QGridLayout()
|
|
self.layout.addLayout(grid0_1)
|
|
|
|
step1_lbl = QtWidgets.QLabel("<b>%s:</b>" % _('STEP 1'))
|
|
step1_lbl.setToolTip(
|
|
_("First step is to select a number of nozzle tools for usage\n"
|
|
"and then optionally modify the GCode parameters below.")
|
|
)
|
|
step1_description_lbl = QtWidgets.QLabel(_("Select tools.\n"
|
|
"Modify parameters."))
|
|
|
|
grid0_1.addWidget(step1_lbl, 0, 0, alignment=Qt.AlignTop)
|
|
grid0_1.addWidget(step1_description_lbl, 0, 2, alignment=Qt.AlignBottom)
|
|
|
|
self.gcode_frame = QtWidgets.QFrame()
|
|
self.gcode_frame.setContentsMargins(0, 0, 0, 0)
|
|
self.layout.addWidget(self.gcode_frame)
|
|
self.gcode_box = QtWidgets.QVBoxLayout()
|
|
self.gcode_box.setContentsMargins(0, 0, 0, 0)
|
|
self.gcode_frame.setLayout(self.gcode_box)
|
|
|
|
# ## Form Layout
|
|
self.gcode_form_layout = QtWidgets.QFormLayout()
|
|
self.gcode_box.addLayout(self.gcode_form_layout)
|
|
|
|
# Z dispense start
|
|
self.z_start_entry = FCDoubleSpinner(callback=self.confirmation_message)
|
|
self.z_start_entry.set_range(0.0000001, 10000.0000)
|
|
self.z_start_entry.set_precision(self.decimals)
|
|
self.z_start_entry.setSingleStep(0.1)
|
|
|
|
self.z_start_label = QtWidgets.QLabel('%s:' % _("Z Dispense Start"))
|
|
self.z_start_label.setToolTip(
|
|
_("The height (Z) when solder paste dispensing starts.")
|
|
)
|
|
self.gcode_form_layout.addRow(self.z_start_label, self.z_start_entry)
|
|
|
|
# Z dispense
|
|
self.z_dispense_entry = FCDoubleSpinner(callback=self.confirmation_message)
|
|
self.z_dispense_entry.set_range(0.0000001, 10000.0000)
|
|
self.z_dispense_entry.set_precision(self.decimals)
|
|
self.z_dispense_entry.setSingleStep(0.1)
|
|
|
|
self.z_dispense_label = QtWidgets.QLabel('%s:' % _("Z Dispense"))
|
|
self.z_dispense_label.setToolTip(
|
|
_("The height (Z) when doing solder paste dispensing.")
|
|
)
|
|
self.gcode_form_layout.addRow(self.z_dispense_label, self.z_dispense_entry)
|
|
|
|
# Z dispense stop
|
|
self.z_stop_entry = FCDoubleSpinner(callback=self.confirmation_message)
|
|
self.z_stop_entry.set_range(0.0000001, 10000.0000)
|
|
self.z_stop_entry.set_precision(self.decimals)
|
|
self.z_stop_entry.setSingleStep(0.1)
|
|
|
|
self.z_stop_label = QtWidgets.QLabel('%s:' % _("Z Dispense Stop"))
|
|
self.z_stop_label.setToolTip(
|
|
_("The height (Z) when solder paste dispensing stops.")
|
|
)
|
|
self.gcode_form_layout.addRow(self.z_stop_label, self.z_stop_entry)
|
|
|
|
# Z travel
|
|
self.z_travel_entry = FCDoubleSpinner(callback=self.confirmation_message)
|
|
self.z_travel_entry.set_range(0.0000001, 10000.0000)
|
|
self.z_travel_entry.set_precision(self.decimals)
|
|
self.z_travel_entry.setSingleStep(0.1)
|
|
|
|
self.z_travel_label = QtWidgets.QLabel('%s:' % _("Z Travel"))
|
|
self.z_travel_label.setToolTip(
|
|
_("The height (Z) for travel between pads\n"
|
|
"(without dispensing solder paste).")
|
|
)
|
|
self.gcode_form_layout.addRow(self.z_travel_label, self.z_travel_entry)
|
|
|
|
# Z toolchange location
|
|
self.z_toolchange_entry = FCDoubleSpinner(callback=self.confirmation_message)
|
|
self.z_toolchange_entry.set_range(0.0000001, 10000.0000)
|
|
self.z_toolchange_entry.set_precision(self.decimals)
|
|
self.z_toolchange_entry.setSingleStep(0.1)
|
|
|
|
self.z_toolchange_label = QtWidgets.QLabel('%s:' % _("Z Toolchange"))
|
|
self.z_toolchange_label.setToolTip(
|
|
_("The height (Z) for tool (nozzle) change.")
|
|
)
|
|
self.gcode_form_layout.addRow(self.z_toolchange_label, self.z_toolchange_entry)
|
|
|
|
# X,Y Toolchange location
|
|
self.xy_toolchange_entry = FCEntry()
|
|
self.xy_toolchange_label = QtWidgets.QLabel('%s:' % _("Toolchange X-Y"))
|
|
self.xy_toolchange_label.setToolTip(
|
|
_("The X,Y location for tool (nozzle) change.\n"
|
|
"The format is (x, y) where x and y are real numbers.")
|
|
)
|
|
self.gcode_form_layout.addRow(self.xy_toolchange_label, self.xy_toolchange_entry)
|
|
|
|
# Feedrate X-Y
|
|
self.frxy_entry = FCDoubleSpinner(callback=self.confirmation_message)
|
|
self.frxy_entry.set_range(0.0000, 910000.0000)
|
|
self.frxy_entry.set_precision(self.decimals)
|
|
self.frxy_entry.setSingleStep(0.1)
|
|
|
|
self.frxy_label = QtWidgets.QLabel('%s:' % _("Feedrate X-Y"))
|
|
self.frxy_label.setToolTip(
|
|
_("Feedrate (speed) while moving on the X-Y plane.")
|
|
)
|
|
self.gcode_form_layout.addRow(self.frxy_label, self.frxy_entry)
|
|
|
|
# Feedrate Z
|
|
self.frz_entry = FCDoubleSpinner(callback=self.confirmation_message)
|
|
self.frz_entry.set_range(0.0000, 910000.0000)
|
|
self.frz_entry.set_precision(self.decimals)
|
|
self.frz_entry.setSingleStep(0.1)
|
|
|
|
self.frz_label = QtWidgets.QLabel('%s:' % _("Feedrate Z"))
|
|
self.frz_label.setToolTip(
|
|
_("Feedrate (speed) while moving vertically\n"
|
|
"(on Z plane).")
|
|
)
|
|
self.gcode_form_layout.addRow(self.frz_label, self.frz_entry)
|
|
|
|
# Feedrate Z Dispense
|
|
self.frz_dispense_entry = FCDoubleSpinner(callback=self.confirmation_message)
|
|
self.frz_dispense_entry.set_range(0.0000, 910000.0000)
|
|
self.frz_dispense_entry.set_precision(self.decimals)
|
|
self.frz_dispense_entry.setSingleStep(0.1)
|
|
|
|
self.frz_dispense_label = QtWidgets.QLabel('%s:' % _("Feedrate Z Dispense"))
|
|
self.frz_dispense_label.setToolTip(
|
|
_("Feedrate (speed) while moving up vertically\n"
|
|
"to Dispense position (on Z plane).")
|
|
)
|
|
self.gcode_form_layout.addRow(self.frz_dispense_label, self.frz_dispense_entry)
|
|
|
|
# Spindle Speed Forward
|
|
self.speedfwd_entry = FCSpinner(callback=self.confirmation_message_int)
|
|
self.speedfwd_entry.set_range(0, 999999)
|
|
self.speedfwd_entry.set_step(1000)
|
|
|
|
self.speedfwd_label = QtWidgets.QLabel('%s:' % _("Spindle Speed FWD"))
|
|
self.speedfwd_label.setToolTip(
|
|
_("The dispenser speed while pushing solder paste\n"
|
|
"through the dispenser nozzle.")
|
|
)
|
|
self.gcode_form_layout.addRow(self.speedfwd_label, self.speedfwd_entry)
|
|
|
|
# Dwell Forward
|
|
self.dwellfwd_entry = FCDoubleSpinner(callback=self.confirmation_message)
|
|
self.dwellfwd_entry.set_range(0.0000001, 10000.0000)
|
|
self.dwellfwd_entry.set_precision(self.decimals)
|
|
self.dwellfwd_entry.setSingleStep(0.1)
|
|
|
|
self.dwellfwd_label = QtWidgets.QLabel('%s:' % _("Dwell FWD"))
|
|
self.dwellfwd_label.setToolTip(
|
|
_("Pause after solder dispensing.")
|
|
)
|
|
self.gcode_form_layout.addRow(self.dwellfwd_label, self.dwellfwd_entry)
|
|
|
|
# Spindle Speed Reverse
|
|
self.speedrev_entry = FCSpinner(callback=self.confirmation_message_int)
|
|
self.speedrev_entry.set_range(0, 999999)
|
|
self.speedrev_entry.set_step(1000)
|
|
|
|
self.speedrev_label = QtWidgets.QLabel('%s:' % _("Spindle Speed REV"))
|
|
self.speedrev_label.setToolTip(
|
|
_("The dispenser speed while retracting solder paste\n"
|
|
"through the dispenser nozzle.")
|
|
)
|
|
self.gcode_form_layout.addRow(self.speedrev_label, self.speedrev_entry)
|
|
|
|
# Dwell Reverse
|
|
self.dwellrev_entry = FCDoubleSpinner(callback=self.confirmation_message)
|
|
self.dwellrev_entry.set_range(0.0000001, 10000.0000)
|
|
self.dwellrev_entry.set_precision(self.decimals)
|
|
self.dwellrev_entry.setSingleStep(0.1)
|
|
|
|
self.dwellrev_label = QtWidgets.QLabel('%s:' % _("Dwell REV"))
|
|
self.dwellrev_label.setToolTip(
|
|
_("Pause after solder paste dispenser retracted,\n"
|
|
"to allow pressure equilibrium.")
|
|
)
|
|
self.gcode_form_layout.addRow(self.dwellrev_label, self.dwellrev_entry)
|
|
|
|
# Preprocessors
|
|
pp_label = QtWidgets.QLabel('%s:' % _('Preprocessor'))
|
|
pp_label.setToolTip(
|
|
_("Files that control the GCode generation.")
|
|
)
|
|
|
|
self.pp_combo = FCComboBox()
|
|
# self.pp_combo.setStyleSheet('background-color: rgb(255,255,255)')
|
|
self.gcode_form_layout.addRow(pp_label, self.pp_combo)
|
|
|
|
# ## Buttons
|
|
# grid1 = QtWidgets.QGridLayout()
|
|
# self.gcode_box.addLayout(grid1)
|
|
|
|
self.solder_gcode_btn = QtWidgets.QPushButton(_("Generate GCode"))
|
|
self.solder_gcode_btn.setToolTip(
|
|
_("Generate GCode for Solder Paste dispensing\n"
|
|
"on PCB pads.")
|
|
)
|
|
self.solder_gcode_btn.setStyleSheet("""
|
|
QPushButton
|
|
{
|
|
font-weight: bold;
|
|
}
|
|
""")
|
|
|
|
self.generation_frame = QtWidgets.QFrame()
|
|
self.generation_frame.setContentsMargins(0, 0, 0, 0)
|
|
self.layout.addWidget(self.generation_frame)
|
|
self.generation_box = QtWidgets.QVBoxLayout()
|
|
self.generation_box.setContentsMargins(0, 0, 0, 0)
|
|
self.generation_frame.setLayout(self.generation_box)
|
|
|
|
# ## Buttons
|
|
grid2 = QtWidgets.QGridLayout()
|
|
self.generation_box.addLayout(grid2)
|
|
|
|
step2_lbl = QtWidgets.QLabel("<b>%s:</b>" % _('STEP 2'))
|
|
step2_lbl.setToolTip(
|
|
_("Second step is to create a solder paste dispensing\n"
|
|
"geometry out of an Solder Paste Mask Gerber file.")
|
|
)
|
|
|
|
self.soldergeo_btn = QtWidgets.QPushButton(_("Generate Geo"))
|
|
self.soldergeo_btn.setToolTip(
|
|
_("Generate solder paste dispensing geometry.")
|
|
)
|
|
self.soldergeo_btn.setStyleSheet("""
|
|
QPushButton
|
|
{
|
|
font-weight: bold;
|
|
}
|
|
""")
|
|
|
|
grid2.addWidget(step2_lbl, 0, 0)
|
|
grid2.addWidget(self.soldergeo_btn, 0, 2)
|
|
|
|
# ## Form Layout
|
|
geo_form_layout = QtWidgets.QFormLayout()
|
|
self.generation_box.addLayout(geo_form_layout)
|
|
|
|
# ## Geometry Object to be used for solderpaste dispensing
|
|
self.geo_obj_combo = FCComboBox(callback=solder_class.on_rmb_combo)
|
|
self.geo_obj_combo.setModel(self.app.collection)
|
|
self.geo_obj_combo.setRootModelIndex(self.app.collection.index(2, 0, QtCore.QModelIndex()))
|
|
self.geo_obj_combo.is_last = True
|
|
self.geo_obj_combo.obj_type = "Geometry"
|
|
|
|
self.geo_object_label = QtWidgets.QLabel('%s:' % _("Geo Result"))
|
|
self.geo_object_label.setToolTip(
|
|
_("Geometry Solder Paste object.\n"
|
|
"The name of the object has to end in:\n"
|
|
"'_solderpaste' as a protection.")
|
|
)
|
|
geo_form_layout.addRow(self.geo_object_label, self.geo_obj_combo)
|
|
|
|
grid3 = QtWidgets.QGridLayout()
|
|
self.generation_box.addLayout(grid3)
|
|
|
|
step3_lbl = QtWidgets.QLabel("<b>%s:</b>" % _('STEP 3'))
|
|
step3_lbl.setToolTip(
|
|
_("Third step is to select a solder paste dispensing geometry,\n"
|
|
"and then generate a CNCJob object.\n\n"
|
|
"REMEMBER: if you want to create a CNCJob with new parameters,\n"
|
|
"first you need to generate a geometry with those new params,\n"
|
|
"and only after that you can generate an updated CNCJob.")
|
|
)
|
|
|
|
grid3.addWidget(step3_lbl, 0, 0)
|
|
grid3.addWidget(self.solder_gcode_btn, 0, 2)
|
|
|
|
# ## Form Layout
|
|
cnc_form_layout = QtWidgets.QFormLayout()
|
|
self.generation_box.addLayout(cnc_form_layout)
|
|
|
|
# ## Gerber Object to be used for solderpaste dispensing
|
|
self.cnc_obj_combo = FCComboBox(callback=solder_class.on_rmb_combo)
|
|
self.cnc_obj_combo.setModel(self.app.collection)
|
|
self.cnc_obj_combo.setRootModelIndex(self.app.collection.index(3, 0, QtCore.QModelIndex()))
|
|
self.cnc_obj_combo.is_last = True
|
|
self.geo_obj_combo.obj_type = "CNCJob"
|
|
|
|
self.cnc_object_label = QtWidgets.QLabel('%s:' % _("CNC Result"))
|
|
self.cnc_object_label.setToolTip(
|
|
_("CNCJob Solder paste object.\n"
|
|
"In order to enable the GCode save section,\n"
|
|
"the name of the object has to end in:\n"
|
|
"'_solderpaste' as a protection.")
|
|
)
|
|
cnc_form_layout.addRow(self.cnc_object_label, self.cnc_obj_combo)
|
|
|
|
grid4 = QtWidgets.QGridLayout()
|
|
self.generation_box.addLayout(grid4)
|
|
|
|
self.solder_gcode_view_btn = QtWidgets.QPushButton(_("View GCode"))
|
|
self.solder_gcode_view_btn.setToolTip(
|
|
_("View the generated GCode for Solder Paste dispensing\n"
|
|
"on PCB pads.")
|
|
)
|
|
self.solder_gcode_view_btn.setStyleSheet("""
|
|
QPushButton
|
|
{
|
|
font-weight: bold;
|
|
}
|
|
""")
|
|
|
|
self.solder_gcode_save_btn = QtWidgets.QPushButton(_("Save GCode"))
|
|
self.solder_gcode_save_btn.setToolTip(
|
|
_("Save the generated GCode for Solder Paste dispensing\n"
|
|
"on PCB pads, to a file.")
|
|
)
|
|
self.solder_gcode_save_btn.setStyleSheet("""
|
|
QPushButton
|
|
{
|
|
font-weight: bold;
|
|
}
|
|
""")
|
|
|
|
step4_lbl = QtWidgets.QLabel("<b>%s:</b>" % _('STEP 4'))
|
|
step4_lbl.setToolTip(
|
|
_("Fourth step (and last) is to select a CNCJob made from \n"
|
|
"a solder paste dispensing geometry, and then view/save it's GCode.")
|
|
)
|
|
|
|
grid4.addWidget(step4_lbl, 0, 0)
|
|
grid4.addWidget(self.solder_gcode_view_btn, 0, 2)
|
|
grid4.addWidget(self.solder_gcode_save_btn, 1, 0, 1, 3)
|
|
|
|
self.layout.addStretch()
|
|
|
|
# ## Reset Tool
|
|
self.reset_button = QtWidgets.QPushButton(_("Reset Tool"))
|
|
self.reset_button.setIcon(QtGui.QIcon(self.app.resource_location + '/reset32.png'))
|
|
self.reset_button.setToolTip(
|
|
_("Will reset the tool parameters.")
|
|
)
|
|
self.reset_button.setStyleSheet("""
|
|
QPushButton
|
|
{
|
|
font-weight: bold;
|
|
}
|
|
""")
|
|
self.layout.addWidget(self.reset_button)
|
|
|
|
# #################################### FINSIHED GUI ###########################
|
|
# #############################################################################
|
|
|
|
def confirmation_message(self, accepted, minval, maxval):
|
|
if accepted is False:
|
|
self.app.inform[str, bool].emit('[WARNING_NOTCL] %s: [%.*f, %.*f]' % (_("Edited value is out of range"),
|
|
self.decimals,
|
|
minval,
|
|
self.decimals,
|
|
maxval), False)
|
|
else:
|
|
self.app.inform[str, bool].emit('[success] %s' % _("Edited value is within limits."), False)
|
|
|
|
def confirmation_message_int(self, accepted, minval, maxval):
|
|
if accepted is False:
|
|
self.app.inform[str, bool].emit('[WARNING_NOTCL] %s: [%d, %d]' %
|
|
(_("Edited value is out of range"), minval, maxval), False)
|
|
else:
|
|
self.app.inform[str, bool].emit('[success] %s' % _("Edited value is within limits."), False)
|