# -*- coding: utf-8 -*- # *************************************************************************** # * Copyright (c) 2017 sliptonic * # * * # * This program is free software; you can redistribute it and/or modify * # * it under the terms of the GNU Lesser General Public License (LGPL) * # * as published by the Free Software Foundation; either version 2 of * # * the License, or (at your option) any later version. * # * for detail see the LICENCE text file. * # * * # * This program is distributed in the hope that it will be useful, * # * but WITHOUT ANY WARRANTY; without even the implied warranty of * # * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * # * GNU Library General Public License for more details. * # * * # * You should have received a copy of the GNU Library General Public * # * License along with this program; if not, write to the Free Software * # * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 * # * USA * # * * # *************************************************************************** from PySide import QtCore, QtGui from collections import Counter from contextlib import contextmanager from pivy import coin import FreeCAD import FreeCADGui import Path import Path.Base.Gui.SetupSheet as PathSetupSheetGui import Path.Base.Util as PathUtil import Path.GuiInit as PathGuiInit import Path.Main.Gui.JobCmd as PathJobCmd import Path.Main.Gui.JobDlg as PathJobDlg import Path.Main.Job as PathJob import Path.Main.Stock as PathStock import Path.Tool.Gui.Bit as PathToolBitGui import Path.Tool.Gui.Controller as PathToolControllerGui import PathScripts.PathUtils as PathUtils import json import math import traceback from PySide import QtWidgets import MatGui import Materials # lazily loaded modules from lazy_loader.lazy_loader import LazyLoader Draft = LazyLoader("Draft", globals(), "Draft") Part = LazyLoader("Part", globals(), "Part") DraftVecUtils = LazyLoader("DraftVecUtils", globals(), "DraftVecUtils") translate = FreeCAD.Qt.translate if False: Path.Log.setLevel(Path.Log.Level.DEBUG, Path.Log.thisModule()) Path.Log.trackModule(Path.Log.thisModule()) else: Path.Log.setLevel(Path.Log.Level.INFO, Path.Log.thisModule()) def _OpenCloseResourceEditor(obj, vobj, edit): job = PathUtils.findParentJob(obj) if job and job.ViewObject and job.ViewObject.Proxy: if edit: job.ViewObject.Proxy.editObject(obj) else: job.ViewObject.Proxy.uneditObject(obj) else: missing = "Job" if job: missing = "ViewObject" if job.ViewObject: missing = "Proxy" Path.Log.warning("Cannot edit %s - no %s" % (obj.Label, missing)) @contextmanager def selectionEx(): sel = FreeCADGui.Selection.getSelectionEx() try: yield sel finally: FreeCADGui.Selection.clearSelection() for s in sel: if s.SubElementNames: FreeCADGui.Selection.addSelection(s.Object, s.SubElementNames) else: FreeCADGui.Selection.addSelection(s.Object) class ViewProvider: def __init__(self, vobj): mode = 2 vobj.setEditorMode("BoundingBox", mode) vobj.setEditorMode("DisplayMode", mode) vobj.setEditorMode("Selectable", mode) vobj.setEditorMode("ShapeAppearance", mode) vobj.setEditorMode("Transparency", mode) self.deleteOnReject = True # initialized later self.axs = None self.mat = None self.obj = None self.sca = None self.scs = None self.sep = None self.sph = None self.switch = None self.taskPanel = None self.vobj = None self.baseVisibility = {} self.stockVisibility = False def attach(self, vobj): self.vobj = vobj self.obj = vobj.Object self.taskPanel = None if not hasattr(self, "baseVisibility"): self.baseVisibility = {} if not hasattr(self, "stockVisibility"): self.stockVisibility = False # Setup the axis display at the origin self.switch = coin.SoSwitch() self.sep = coin.SoSeparator() self.axs = coin.SoType.fromName("SoAxisCrossKit").createInstance() # Adjust the axis heads if needed, the scale here is just for the head self.axs.set("xHead.transform", "scaleFactor 1.5 1.5 1") self.axs.set("yHead.transform", "scaleFactor 1.5 1.5 1") self.axs.set("zHead.transform", "scaleFactor 1.5 1.5 1") # Adjust the axis heads if needed, the scale here is just for the head self.axs.set("xHead.transform", "translation 50 0 0") self.axs.set("yHead.transform", "translation 0 50 0") self.axs.set("zHead.transform", "translation 0 0 50") # Adjust the axis line width if needed self.axs.set("xAxis.transform", "scaleFactor 0.5 0.5 1") self.axs.set("xAxis.appearance.drawStyle", "lineWidth 9") self.axs.set("yAxis.transform", "scaleFactor 0.5 0.5 1") self.axs.set("yAxis.appearance.drawStyle", "lineWidth 9") self.axs.set("zAxis.transform", "scaleFactor 0.5 0.5 1") self.axs.set("zAxis.appearance.drawStyle", "lineWidth 9") self.sca = coin.SoType.fromName("SoShapeScale").createInstance() self.sca.setPart("shape", self.axs) self.sca.scaleFactor.setValue(1) # Keep or adjust if needed self.mat = coin.SoMaterial() # Set sphere color to bright yellow self.mat.diffuseColor = coin.SbColor(1, 1, 0) self.mat.transparency = 0.35 # Keep or adjust if needed self.sph = coin.SoSphere() self.scs = coin.SoType.fromName("SoShapeScale").createInstance() self.scs.setPart("shape", self.sph) # Increase the scaleFactor to make the sphere larger self.scs.scaleFactor.setValue(10) # Adjust this value as needed self.sep.addChild(self.sca) self.sep.addChild(self.mat) self.sep.addChild(self.scs) self.switch.addChild(self.sep) self.switch.addChild(self.sep) vobj.RootNode.addChild(self.switch) self.showOriginAxis(True) for base in self.obj.Model.Group: Path.Log.debug(f"{base.Name}: {base.ViewObject.Visibility}") def onChanged(self, vobj, prop): if prop == "Visibility": self.showOriginAxis(vobj.Visibility) if vobj.Visibility: self.rememberStockVisibility() self.obj.Stock.ViewObject.Visibility = True self.KeepBaseVisibility() for base in self.obj.Model.Group: base.ViewObject.Visibility = True else: self.restoreStockVisibility() self.RestoreBaseVisibility() def rememberStockVisibility(self): self.stockVisibility = self.obj.Stock.ViewObject.Visibility def restoreStockVisibility(self): self.obj.Stock.ViewObject.Visibility = self.stockVisibility def KeepBaseVisibility(self): Path.Log.debug("KeepBaseVisibility") self.visibilitystate = {} for base in self.obj.Model.Group: Path.Log.debug(f"{base.Name}: {base.ViewObject.Visibility}") self.visibilitystate[base.Name] = base.ViewObject.Visibility Path.Log.debug(self.visibilitystate) def RestoreBaseVisibility(self): Path.Log.debug("RestoreBaseVisibility") if hasattr(self, "visibilitystate"): for base in self.obj.Model.Group: base.ViewObject.Visibility = self.visibilitystate[base.Name] Path.Log.debug(self.visibilitystate) def showOriginAxis(self, yes): sw = coin.SO_SWITCH_ALL if yes else coin.SO_SWITCH_NONE self.switch.whichChild = sw def dumps(self): return None def loads(self, state): return None def deleteObjectsOnReject(self): return hasattr(self, "deleteOnReject") and self.deleteOnReject def setEdit(self, vobj=None, mode=0): Path.Log.track(mode) if 0 == mode: job = self.vobj.Object if not job.Proxy.integrityCheck(job): return False self.openTaskPanel() return True def openTaskPanel(self, activate=None): self.taskPanel = TaskPanel(self.vobj, self.deleteObjectsOnReject()) FreeCADGui.Control.closeDialog() FreeCADGui.Control.showDialog(self.taskPanel) self.taskPanel.setupUi(activate) self.showOriginAxis(True) self.deleteOnReject = False def resetTaskPanel(self): self.showOriginAxis(False) self.taskPanel = None def unsetEdit(self, arg1, arg2): if self.taskPanel: self.taskPanel.reject(False) def editObject(self, obj): if obj: if obj in self.obj.Model.Group: return self.openTaskPanel("Model") if obj == self.obj.Stock: return self.openTaskPanel("Stock") Path.Log.info("Expected a specific object to edit - %s not recognized" % obj.Label) return self.openTaskPanel() def uneditObject(self, obj=None): self.unsetEdit(None, None) def getIcon(self): return ":/icons/CAM_Job.svg" def claimChildren(self): children = [] children.append(self.obj.Operations) if hasattr(self.obj, "Model"): # unfortunately this function is called before the object has been fully loaded # which means we could be dealing with an old job which doesn't have the new Model # yet. children.append(self.obj.Model) if self.obj.Stock: children.append(self.obj.Stock) if hasattr(self.obj, "SetupSheet"): # when loading a job that didn't have a setup sheet they might not've been created yet children.append(self.obj.SetupSheet) if hasattr(self.obj, "Tools"): children.append(self.obj.Tools) return children def onDelete(self, vobj, arg2=None): Path.Log.track(vobj.Object.Label, arg2) self.obj.Proxy.onDelete(self.obj, arg2) return True def updateData(self, obj, prop): Path.Log.track(obj.Label, prop) # make sure the resource view providers are setup properly if prop == "Model" and self.obj.Model: for base in self.obj.Model.Group: if base.ViewObject and base.ViewObject.Proxy: base.ViewObject.Proxy.onEdit(_OpenCloseResourceEditor) if ( prop == "Stock" and self.obj.Stock and self.obj.Stock.ViewObject and self.obj.Stock.ViewObject.Proxy ): self.obj.Stock.ViewObject.Proxy.onEdit(_OpenCloseResourceEditor) def rememberBaseVisibility(self, obj, base): Path.Log.track() if base.ViewObject: orig = PathUtil.getPublicObject(obj.Proxy.baseObject(obj, base)) self.baseVisibility[base.Name] = ( base, base.ViewObject.Visibility, orig, orig.ViewObject.Visibility, ) orig.ViewObject.Visibility = False base.ViewObject.Visibility = True def forgetBaseVisibility(self, obj, base): Path.Log.track() # if self.baseVisibility.get(base.Name): # visibility = self.baseVisibility[base.Name] # visibility[0].ViewObject.Visibility = visibility[1] # visibility[2].ViewObject.Visibility = visibility[3] # del self.baseVisibility[base.Name] def setupEditVisibility(self, obj): Path.Log.track() self.baseVisibility = {} for base in obj.Model.Group: self.rememberBaseVisibility(obj, base) self.stockVisibility = False if obj.Stock and obj.Stock.ViewObject: self.stockVisibility = obj.Stock.ViewObject.Visibility self.obj.Stock.ViewObject.Visibility = True def resetEditVisibility(self, obj): Path.Log.track() for base in obj.Model.Group: self.forgetBaseVisibility(obj, base) if obj.Stock and obj.Stock.ViewObject: obj.Stock.ViewObject.Visibility = self.stockVisibility def setupContextMenu(self, vobj, menu): Path.Log.track() for action in menu.actions(): menu.removeAction(action) action = QtGui.QAction(translate("CAM_Job", "Edit"), menu) action.triggered.connect(self.setEdit) menu.addAction(action) class MaterialDialog(QtWidgets.QDialog): def __init__(self, parent=None): super(MaterialDialog, self).__init__(parent) self.setWindowTitle("Assign Material") self.materialTree = FreeCADGui.UiLoader().createWidget("MatGui::MaterialTreeWidget") self.materialTreeWidget = MatGui.MaterialTreeWidget(self.materialTree) material_filter = Materials.MaterialFilter() material_filter.Name = "Machining Materials" material_filter.RequiredModels = [Materials.UUIDs().Machinability] self.materialTreeWidget.setFilter(material_filter) self.materialTreeWidget.selectFilter("Machining Materials") # Create OK and Cancel buttons self.okButton = QtWidgets.QPushButton("OK") self.cancelButton = QtWidgets.QPushButton("Cancel") # Connect buttons to their actions self.okButton.clicked.connect(self.accept) self.cancelButton.clicked.connect(self.reject) # Layout setup layout = QtWidgets.QVBoxLayout() layout.addWidget(self.materialTree) buttonLayout = QtWidgets.QHBoxLayout() buttonLayout.addStretch() buttonLayout.addWidget(self.okButton) buttonLayout.addWidget(self.cancelButton) layout.addLayout(buttonLayout) self.setLayout(layout) self.materialTree.onMaterial.connect(self.onMaterial) def onMaterial(self, uuid): try: print("Selected '{0}'".format(uuid)) self.uuid = uuid except Exception as e: print(e) class StockEdit(object): Index = -1 StockType = PathStock.StockType.Unknown def __init__(self, obj, form, force): Path.Log.track(obj.Label, force) self.obj = obj self.form = form self.force = force self.setupUi(obj) @classmethod def IsStock(cls, obj): return PathStock.StockType.FromStock(obj.Stock) == cls.StockType def activate(self, obj, select=False): Path.Log.track(obj.Label, select) def showHide(widget, activeWidget): if widget == activeWidget: widget.show() else: widget.hide() if select: self.form.stock.setCurrentIndex(self.Index) editor = self.editorFrame() showHide(self.form.stockFromExisting, editor) showHide(self.form.stockFromBase, editor) showHide(self.form.stockCreateBox, editor) showHide(self.form.stockCreateCylinder, editor) self.setFields(obj) def setStock(self, obj, stock): Path.Log.track(obj.Label, stock) if obj.Stock: Path.Log.track(obj.Stock.Name) obj.Document.removeObject(obj.Stock.Name) Path.Log.track(stock.Name) obj.Stock = stock if stock.ViewObject and stock.ViewObject.Proxy: stock.ViewObject.Proxy.onEdit(_OpenCloseResourceEditor) def setLengthField(self, widget, prop): widget.setText(FreeCAD.Units.Quantity(prop.Value, FreeCAD.Units.Length).UserString) # the following members must be overwritten by subclasses def editorFrame(self): return None def setFields(self, obj): pass def setupUi(self, obj): pass class StockFromBaseBoundBoxEdit(StockEdit): Index = 2 StockType = PathStock.StockType.FromBase def __init__(self, obj, form, force): super(StockFromBaseBoundBoxEdit, self).__init__(obj, form, force) self.trackXpos = None self.trackYpos = None self.trackZpos = None def editorFrame(self): Path.Log.track() return self.form.stockFromBase def getFieldsStock(self, stock, fields=None): if fields is None: fields = ["xneg", "xpos", "yneg", "ypos", "zneg", "zpos"] try: if "xneg" in fields: stock.ExtXneg = FreeCAD.Units.Quantity(self.form.stockExtXneg.text()) if "xpos" in fields: stock.ExtXpos = FreeCAD.Units.Quantity(self.form.stockExtXpos.text()) if "yneg" in fields: stock.ExtYneg = FreeCAD.Units.Quantity(self.form.stockExtYneg.text()) if "ypos" in fields: stock.ExtYpos = FreeCAD.Units.Quantity(self.form.stockExtYpos.text()) if "zneg" in fields: stock.ExtZneg = FreeCAD.Units.Quantity(self.form.stockExtZneg.text()) if "zpos" in fields: stock.ExtZpos = FreeCAD.Units.Quantity(self.form.stockExtZpos.text()) except Exception: pass def getFields(self, obj, fields=None): if fields is None: fields = ["xneg", "xpos", "yneg", "ypos", "zneg", "zpos"] Path.Log.track(obj.Label, fields) if self.IsStock(obj): self.getFieldsStock(obj.Stock, fields) else: Path.Log.error("Stock not from Base bound box!") def setFields(self, obj): Path.Log.track() if self.force or not self.IsStock(obj): Path.Log.track() stock = PathStock.CreateFromBase(obj) if self.force and self.editorFrame().isVisible(): self.getFieldsStock(stock) self.setStock(obj, stock) self.force = False self.setLengthField(self.form.stockExtXneg, obj.Stock.ExtXneg) self.setLengthField(self.form.stockExtXpos, obj.Stock.ExtXpos) self.setLengthField(self.form.stockExtYneg, obj.Stock.ExtYneg) self.setLengthField(self.form.stockExtYpos, obj.Stock.ExtYpos) self.setLengthField(self.form.stockExtZneg, obj.Stock.ExtZneg) self.setLengthField(self.form.stockExtZpos, obj.Stock.ExtZpos) def setupUi(self, obj): Path.Log.track() self.setFields(obj) self.checkXpos() self.checkYpos() self.checkZpos() self.form.stockExtXneg.textChanged.connect(self.updateXpos) self.form.stockExtYneg.textChanged.connect(self.updateYpos) self.form.stockExtZneg.textChanged.connect(self.updateZpos) self.form.stockExtXpos.textChanged.connect(self.checkXpos) self.form.stockExtYpos.textChanged.connect(self.checkYpos) self.form.stockExtZpos.textChanged.connect(self.checkZpos) if hasattr(self.form, "linkStockAndModel"): self.form.linkStockAndModel.setChecked(False) def checkXpos(self): self.trackXpos = self.form.stockExtXneg.text() == self.form.stockExtXpos.text() self.getFields(self.obj, ["xpos"]) def checkYpos(self): self.trackYpos = self.form.stockExtYneg.text() == self.form.stockExtYpos.text() self.getFields(self.obj, ["ypos"]) def checkZpos(self): self.trackZpos = self.form.stockExtZneg.text() == self.form.stockExtZpos.text() self.getFields(self.obj, ["zpos"]) def updateXpos(self): fields = ["xneg"] if self.trackXpos: self.form.stockExtXpos.setText(self.form.stockExtXneg.text()) fields.append("xpos") self.getFields(self.obj, fields) def updateYpos(self): fields = ["yneg"] if self.trackYpos: self.form.stockExtYpos.setText(self.form.stockExtYneg.text()) fields.append("ypos") self.getFields(self.obj, fields) def updateZpos(self): fields = ["zneg"] if self.trackZpos: self.form.stockExtZpos.setText(self.form.stockExtZneg.text()) fields.append("zpos") self.getFields(self.obj, fields) class StockCreateBoxEdit(StockEdit): Index = 0 StockType = PathStock.StockType.CreateBox def editorFrame(self): return self.form.stockCreateBox def getFields(self, obj, fields=None): if fields is None: fields = ["length", "width", "height"] try: if self.IsStock(obj): if "length" in fields: obj.Stock.Length = FreeCAD.Units.Quantity(self.form.stockBoxLength.text()) if "width" in fields: obj.Stock.Width = FreeCAD.Units.Quantity(self.form.stockBoxWidth.text()) if "height" in fields: obj.Stock.Height = FreeCAD.Units.Quantity(self.form.stockBoxHeight.text()) else: Path.Log.error("Stock not a box!") except Exception: pass def setFields(self, obj): if self.force or not self.IsStock(obj): self.setStock(obj, PathStock.CreateBox(obj)) self.force = False self.setLengthField(self.form.stockBoxLength, obj.Stock.Length) self.setLengthField(self.form.stockBoxWidth, obj.Stock.Width) self.setLengthField(self.form.stockBoxHeight, obj.Stock.Height) def setupUi(self, obj): self.setFields(obj) self.form.stockBoxLength.textChanged.connect(lambda: self.getFields(obj, ["length"])) self.form.stockBoxWidth.textChanged.connect(lambda: self.getFields(obj, ["width"])) self.form.stockBoxHeight.textChanged.connect(lambda: self.getFields(obj, ["height"])) class StockCreateCylinderEdit(StockEdit): Index = 1 StockType = PathStock.StockType.CreateCylinder def editorFrame(self): return self.form.stockCreateCylinder def getFields(self, obj, fields=None): if fields is None: fields = ["radius", "height"] try: if self.IsStock(obj): if "radius" in fields: obj.Stock.Radius = FreeCAD.Units.Quantity(self.form.stockCylinderRadius.text()) if "height" in fields: obj.Stock.Height = FreeCAD.Units.Quantity(self.form.stockCylinderHeight.text()) else: Path.Log.error(translate("CAM_Job", "Stock not a cylinder!")) except Exception: pass def setFields(self, obj): if self.force or not self.IsStock(obj): self.setStock(obj, PathStock.CreateCylinder(obj)) self.force = False self.setLengthField(self.form.stockCylinderRadius, obj.Stock.Radius) self.setLengthField(self.form.stockCylinderHeight, obj.Stock.Height) def setupUi(self, obj): self.setFields(obj) self.form.stockCylinderRadius.textChanged.connect(lambda: self.getFields(obj, ["radius"])) self.form.stockCylinderHeight.textChanged.connect(lambda: self.getFields(obj, ["height"])) class StockFromExistingEdit(StockEdit): Index = 3 StockType = PathStock.StockType.Unknown StockLabelPrefix = "Stock" def editorFrame(self): return self.form.stockFromExisting def getFields(self, obj): stock = self.form.stockExisting.itemData(self.form.stockExisting.currentIndex()) if not ( hasattr(obj.Stock, "Objects") and len(obj.Stock.Objects) == 1 and obj.Stock.Objects[0] == stock ): if stock: stock = PathJob.createResourceClone(obj, stock, self.StockLabelPrefix, "Stock") stock.ViewObject.Visibility = True PathStock.SetupStockObject(stock, PathStock.StockType.Unknown) stock.Proxy.execute(stock) self.setStock(obj, stock) def candidates(self, obj): solids = [o for o in obj.Document.Objects if PathUtil.isSolid(o)] if hasattr(obj, "Model"): job = obj else: job = PathUtils.findParentJob(obj) for base in job.Model.Group: if base in solids and PathJob.isResourceClone(job, base, "Model"): solids.remove(base) if job.Stock in solids: # regardless, what stock is/was, it's not a valid choice solids.remove(job.Stock) return sorted(solids, key=lambda c: c.Label) def setFields(self, obj): self.form.stockExisting.clear() stockName = obj.Stock.Label if obj.Stock else None index = -1 for i, solid in enumerate(self.candidates(obj)): self.form.stockExisting.addItem(solid.Label, solid) label = "{}-{}".format(self.StockLabelPrefix, solid.Label) if label == stockName: index = i self.form.stockExisting.setCurrentIndex(index if index != -1 else 0) if not self.IsStock(obj): self.getFields(obj) def setupUi(self, obj): self.setFields(obj) self.form.stockExisting.currentIndexChanged.connect(lambda: self.getFields(obj)) class TaskPanel: DataObject = QtCore.Qt.ItemDataRole.UserRole DataProperty = QtCore.Qt.ItemDataRole.UserRole + 1 def __init__(self, vobj, deleteOnReject): FreeCAD.ActiveDocument.openTransaction("Edit Job") self.vobj = vobj self.vproxy = vobj.Proxy self.obj = vobj.Object self.deleteOnReject = deleteOnReject self.form = FreeCADGui.PySideUic.loadUi(":/panels/PathEdit.ui") self.template = PathJobDlg.JobTemplateExport(self.obj, self.form.jobBox.widget(1)) self.name = self.obj.Name vUnit = FreeCAD.Units.Quantity(1, FreeCAD.Units.Velocity).getUserPreferred()[2] self.form.toolControllerList.horizontalHeaderItem(1).setText("#") self.form.toolControllerList.horizontalHeaderItem(2).setText( translate("Path", "H", "H is horizontal feed rate. Must be as short as possible") ) self.form.toolControllerList.horizontalHeaderItem(3).setText( translate("Path", "V", "V is vertical feed rate. Must be as short as possible") ) self.form.toolControllerList.horizontalHeader().setResizeMode(0, QtGui.QHeaderView.Stretch) self.form.toolControllerList.horizontalHeaderItem(1).setToolTip( translate("Path", "Tool number") + " " ) self.form.toolControllerList.horizontalHeaderItem(2).setToolTip( translate("Path", "Horizontal feedrate") + " " + vUnit ) self.form.toolControllerList.horizontalHeaderItem(3).setToolTip( translate("Path", "Vertical feedrate") + " " + vUnit ) self.form.toolControllerList.horizontalHeaderItem(4).setToolTip( translate("Path", "Spindle RPM") + " " ) # ensure correct ellisis behaviour on tool controller names. self.form.toolControllerList.setWordWrap(False) self.form.toolControllerList.resizeColumnsToContents() currentPostProcessor = self.obj.PostProcessor postProcessors = Path.Preferences.allEnabledPostProcessors(["", currentPostProcessor]) for post in postProcessors: self.form.postProcessor.addItem(post) # update the enumeration values, just to make sure all selections are valid self.obj.PostProcessor = postProcessors self.obj.PostProcessor = currentPostProcessor self.postProcessorDefaultTooltip = self.form.postProcessor.toolTip() self.postProcessorArgsDefaultTooltip = self.form.postProcessorArguments.toolTip() # Populate the other comboboxes with enums from the job class comboToPropertyMap = [("orderBy", "OrderOutputBy")] enumTups = PathJob.ObjectJob.propertyEnumerations(dataType="raw") self.populateCombobox(self.form, enumTups, comboToPropertyMap) self.vproxy.setupEditVisibility(self.obj) self.stockFromBase = None self.stockFromExisting = None self.stockCreateBox = None self.stockCreateCylinder = None self.stockEdit = None self.setupGlobal = PathSetupSheetGui.GlobalEditor(self.obj.SetupSheet, self.form) self.setupOps = PathSetupSheetGui.OpsDefaultEditor(self.obj.SetupSheet, self.form) def populateCombobox(self, form, enumTups, comboBoxesPropertyMap): """populateCombobox(form, enumTups, comboBoxesPropertyMap) ... populate comboboxes with translated enumerations ** comboBoxesPropertyMap will be unnecessary if UI files use strict combobox naming protocol. Args: form = UI form enumTups = list of (translated_text, data_string) tuples comboBoxesPropertyMap = list of (translated_text, data_string) tuples """ # Load appropriate enumerations in each combobox for cb, prop in comboBoxesPropertyMap: box = getattr(form, cb) # Get the combobox box.clear() # clear the combobox for text, data in enumTups[prop]: # load enumerations box.addItem(text, data) def assignMaterial(self): dialog = MaterialDialog() result = dialog.exec_() if result == QtWidgets.QDialog.Accepted: FreeCAD.Console.PrintMessage("Material assigned\n") # Add code to handle the material assignment if dialog.uuid is not None: material_manager = Materials.MaterialManager() material = material_manager.getMaterial(dialog.uuid) self.obj.Stock.ShapeMaterial = material def preCleanup(self): Path.Log.track() FreeCADGui.Selection.removeObserver(self) self.vproxy.resetEditVisibility(self.obj) self.vproxy.resetTaskPanel() def accept(self, resetEdit=True): Path.Log.track() self._jobIntegrityCheck() # Check existence of Model and Tools self.preCleanup() self.getFields() self.setupGlobal.accept() self.setupOps.accept() FreeCAD.ActiveDocument.commitTransaction() self.cleanup(resetEdit) def reject(self, resetEdit=True): Path.Log.track() self.preCleanup() self.setupGlobal.reject() self.setupOps.reject() FreeCAD.ActiveDocument.abortTransaction() if self.deleteOnReject and FreeCAD.ActiveDocument.getObject(self.name): Path.Log.info("Uncreate Job") FreeCAD.ActiveDocument.openTransaction("Uncreate Job") if self.obj.ViewObject.Proxy.onDelete(self.obj.ViewObject, None): FreeCAD.ActiveDocument.removeObject(self.obj.Name) FreeCAD.ActiveDocument.commitTransaction() else: Path.Log.track( self.name, self.deleteOnReject, FreeCAD.ActiveDocument.getObject(self.name), ) self.cleanup(resetEdit) return True def cleanup(self, resetEdit): Path.Log.track() FreeCADGui.Control.closeDialog() if resetEdit: FreeCADGui.ActiveDocument.resetEdit() FreeCAD.ActiveDocument.recompute() def updateTooltips(self): if ( hasattr(self.obj, "Proxy") and hasattr(self.obj.Proxy, "tooltip") and self.obj.Proxy.tooltip ): self.form.postProcessor.setToolTip(self.obj.Proxy.tooltip) if hasattr(self.obj.Proxy, "tooltipArgs") and self.obj.Proxy.tooltipArgs: self.form.postProcessorArguments.setToolTip(self.obj.Proxy.tooltipArgs) else: self.form.postProcessorArguments.setToolTip(self.postProcessorArgsDefaultTooltip) else: self.form.postProcessor.setToolTip(self.postProcessorDefaultTooltip) self.form.postProcessorArguments.setToolTip(self.postProcessorArgsDefaultTooltip) def getFields(self): """sets properties in the object to match the form""" if self.obj: self.obj.PostProcessor = str(self.form.postProcessor.currentText()) self.obj.PostProcessorArgs = str(self.form.postProcessorArguments.displayText()) self.obj.PostProcessorOutputFile = str(self.form.postProcessorOutputFile.text()) self.obj.Label = str(self.form.jobLabel.text()) self.obj.Description = str(self.form.jobDescription.toPlainText()) self.obj.Operations.Group = [ self.form.operationsList.item(i).data(self.DataObject) for i in range(self.form.operationsList.count()) ] try: self.obj.SplitOutput = self.form.splitOutput.isChecked() self.obj.OrderOutputBy = str(self.form.orderBy.currentData()) flist = [] for i in range(self.form.wcslist.count()): if self.form.wcslist.item(i).checkState() == QtCore.Qt.CheckState.Checked: flist.append(self.form.wcslist.item(i).text()) self.obj.Fixtures = flist except Exception as e: Path.Log.debug(e) FreeCAD.Console.PrintWarning( "The Job was created without fixture support. Please delete and recreate the job\r\n" ) self.updateTooltips() self.stockEdit.getFields(self.obj) self.obj.Proxy.execute(self.obj) self.setupGlobal.getFields() self.setupOps.getFields() def selectComboBoxText(self, widget, text): """selectInComboBox(name, combo) ... helper function to select a specific value in a combo box.""" index = widget.currentIndex() # Save initial index # Search using currentData and return if found newindex = widget.findData(text) if newindex >= 0: widget.blockSignals(True) widget.setCurrentIndex(newindex) widget.blockSignals(False) return # if not found, search using current text newindex = widget.findText(text, QtCore.Qt.MatchFixedString) if newindex >= 0: widget.blockSignals(True) widget.setCurrentIndex(newindex) widget.blockSignals(False) return widget.blockSignals(True) widget.setCurrentIndex(index) widget.blockSignals(False) return def updateToolController(self): tcRow = self.form.toolControllerList.currentRow() tcCol = self.form.toolControllerList.currentColumn() self.form.toolControllerList.blockSignals(True) self.form.toolControllerList.clearContents() self.form.toolControllerList.setRowCount(0) self.form.activeToolController.blockSignals(True) index = self.form.activeToolController.currentIndex() select = None if index == -1 else self.form.activeToolController.itemData(index) self.form.activeToolController.clear() vUnit = FreeCAD.Units.Quantity(1, FreeCAD.Units.Velocity).getUserPreferred()[2] for row, tc in enumerate(sorted(self.obj.Tools.Group, key=lambda tc: tc.Label)): self.form.activeToolController.addItem(tc.Label, tc) if tc == select: index = row self.form.toolControllerList.insertRow(row) item = QtGui.QTableWidgetItem(tc.Label) item.setData(self.DataObject, tc) item.setData(self.DataProperty, "Label") self.form.toolControllerList.setItem(row, 0, item) item = QtGui.QTableWidgetItem("%d" % tc.ToolNumber) item.setTextAlignment(QtCore.Qt.AlignRight) item.setData(self.DataObject, tc) item.setData(self.DataProperty, "Number") self.form.toolControllerList.setItem(row, 1, item) item = QtGui.QTableWidgetItem("%g" % tc.HorizFeed.getValueAs(vUnit)) item.setTextAlignment(QtCore.Qt.AlignRight) item.setData(self.DataObject, tc) item.setData(self.DataProperty, "HorizFeed") self.form.toolControllerList.setItem(row, 2, item) item = QtGui.QTableWidgetItem("%g" % tc.VertFeed.getValueAs(vUnit)) item.setTextAlignment(QtCore.Qt.AlignRight) item.setData(self.DataObject, tc) item.setData(self.DataProperty, "VertFeed") self.form.toolControllerList.setItem(row, 3, item) item = QtGui.QTableWidgetItem( "%s%g" % ("+" if tc.SpindleDir == "Forward" else "-", tc.SpindleSpeed) ) item.setTextAlignment(QtCore.Qt.AlignRight) item.setData(self.DataObject, tc) item.setData(self.DataProperty, "Spindle") self.form.toolControllerList.setItem(row, 4, item) if index != -1: self.form.activeToolController.setCurrentIndex(index) if tcRow != -1 and tcCol != -1: self.form.toolControllerList.setCurrentCell(tcRow, tcCol) self.form.activeToolController.blockSignals(False) self.form.toolControllerList.blockSignals(False) def setFields(self): """sets fields in the form to match the object""" self.form.jobLabel.setText(self.obj.Label) self.form.jobDescription.setPlainText(self.obj.Description) if hasattr(self.obj, "SplitOutput"): self.form.splitOutput.setChecked(self.obj.SplitOutput) if hasattr(self.obj, "OrderOutputBy"): self.selectComboBoxText(self.form.orderBy, self.obj.OrderOutputBy) if hasattr(self.obj, "Fixtures"): for f in self.obj.Fixtures: item = self.form.wcslist.findItems(f, QtCore.Qt.MatchExactly)[0] item.setCheckState(QtCore.Qt.Checked) self.form.postProcessorOutputFile.setText(self.obj.PostProcessorOutputFile) self.selectComboBoxText(self.form.postProcessor, self.obj.PostProcessor) self.form.postProcessorArguments.setText(self.obj.PostProcessorArgs) # self.obj.Proxy.onChanged(self.obj, "PostProcessor") self.updateTooltips() self.form.operationsList.clear() for child in self.obj.Operations.Group: item = QtGui.QListWidgetItem(child.Label) item.setData(self.DataObject, child) self.form.operationsList.addItem(item) self.form.jobModel.clear() for name, count in Counter( [self.obj.Proxy.baseObject(self.obj, o).Label for o in self.obj.Model.Group] ).items(): if count == 1: self.form.jobModel.addItem(name) else: self.form.jobModel.addItem("%s (%d)" % (name, count)) self.updateToolController() self.stockEdit.setFields(self.obj) self.setupGlobal.setFields() self.setupOps.setFields() def setPostProcessorOutputFile(self): filename = QtGui.QFileDialog.getSaveFileName( self.form, translate("CAM_Job", "Select Output File"), None, translate("CAM_Job", "All Files (*.*)"), ) if filename and filename[0]: self.obj.PostProcessorOutputFile = str(filename[0]) self.setFields() def operationSelect(self): if self.form.operationsList.selectedItems(): self.form.operationModify.setEnabled(True) self.form.operationMove.setEnabled(True) row = self.form.operationsList.currentRow() self.form.operationUp.setEnabled(row > 0) self.form.operationDown.setEnabled(row < self.form.operationsList.count() - 1) else: self.form.operationModify.setEnabled(False) self.form.operationMove.setEnabled(False) def objectDelete(self, widget): for item in widget.selectedItems(): obj = item.data(self.DataObject) if ( obj.ViewObject and hasattr(obj.ViewObject, "Proxy") and hasattr(obj.ViewObject.Proxy, "onDelete") ): obj.ViewObject.Proxy.onDelete(obj.ViewObject, None) FreeCAD.ActiveDocument.removeObject(obj.Name) self.setFields() def operationDelete(self): self.objectDelete(self.form.operationsList) def operationMoveUp(self): row = self.form.operationsList.currentRow() if row > 0: item = self.form.operationsList.takeItem(row) self.form.operationsList.insertItem(row - 1, item) self.form.operationsList.setCurrentRow(row - 1) self.getFields() def operationMoveDown(self): row = self.form.operationsList.currentRow() if row < self.form.operationsList.count() - 1: item = self.form.operationsList.takeItem(row) self.form.operationsList.insertItem(row + 1, item) self.form.operationsList.setCurrentRow(row + 1) self.getFields() def toolControllerSelect(self): def canDeleteTC(tc): # if the TC is referenced anywhere but the job we don't want to delete it return len(tc.InList) == 1 # if anything is selected it can be edited edit = True if self.form.toolControllerList.selectedItems() else False self.form.toolControllerEdit.setEnabled(edit) # can only delete what is selected delete = edit # ... but we want to make sure there's at least one TC left if len(self.obj.Tools.Group) == len(self.form.toolControllerList.selectedItems()): delete = False # ... also don't want to delete any TCs that are already used if delete: for item in self.form.toolControllerList.selectedItems(): if not canDeleteTC(item.data(self.DataObject)): delete = False break self.form.toolControllerDelete.setEnabled(delete) def toolControllerEdit(self): for item in self.form.toolControllerList.selectedItems(): tc = item.data(self.DataObject) dlg = PathToolControllerGui.DlgToolControllerEdit(tc) dlg.exec_() self.setFields() self.toolControllerSelect() def toolControllerAdd(self): # adding a TC from a toolbit directly. # Try to find a tool number from the currently selected lib. Otherwise # use next available number tools = PathToolBitGui.LoadTools() curLib = Path.Preferences.lastFileToolLibrary() library = None if curLib is not None: with open(curLib) as fp: library = json.load(fp) for tool in tools: toolNum = self.obj.Proxy.nextToolNumber() if library is not None: for toolBit in library["tools"]: if toolBit["path"] == tool.File: toolNum = toolBit["nr"] tc = PathToolControllerGui.Create(name=tool.Label, tool=tool, toolNumber=toolNum) self.obj.Proxy.addToolController(tc) FreeCAD.ActiveDocument.recompute() self.updateToolController() def toolControllerDelete(self): self.objectDelete(self.form.toolControllerList) def toolControllerChanged(self, item): tc = item.data(self.DataObject) prop = item.data(self.DataProperty) if "Label" == prop: tc.Label = item.text() item.setText(tc.Label) elif "Number" == prop: try: tc.ToolNumber = int(item.text()) except Exception: pass item.setText("%d" % tc.ToolNumber) elif "Spindle" == prop: try: speed = float(item.text()) rot = "Forward" if speed < 0: rot = "Reverse" speed = -speed tc.SpindleDir = rot tc.SpindleSpeed = speed except Exception: pass item.setText("%s%g" % ("+" if tc.SpindleDir == "Forward" else "-", tc.SpindleSpeed)) elif "HorizFeed" == prop or "VertFeed" == prop: vUnit = FreeCAD.Units.Quantity(1, FreeCAD.Units.Velocity).getUserPreferred()[2] try: val = FreeCAD.Units.Quantity(item.text()) if FreeCAD.Units.Velocity == val.Unit: setattr(tc, prop, val) elif FreeCAD.Units.Unit() == val.Unit: val = FreeCAD.Units.Quantity(item.text() + vUnit) setattr(tc, prop, val) except Exception: pass item.setText("%g" % getattr(tc, prop).getValueAs(vUnit)) else: try: val = FreeCAD.Units.Quantity(item.text()) setattr(tc, prop, val) except Exception: pass item.setText("%g" % getattr(tc, prop).Value) self.template.updateUI() def modelSetAxis(self, axis): Path.Log.track(axis) def alignSel(sel, normal, flip=False): Path.Log.track("Vector(%.2f, %.2f, %.2f)" % (normal.x, normal.y, normal.z), flip) v = axis if flip: v = axis.negative() if Path.Geom.pointsCoincide(abs(v), abs(normal)): # Selection is already aligned with the axis of rotation leading # to a (0,0,0) cross product for rotation. # --> Need to flip the object around one of the "other" axis. # Simplest way to achieve that is to rotate the coordinate system # of the axis and use that to rotate the object. r = FreeCAD.Vector(v.y, v.z, v.x) a = 180 else: r = v.cross(normal) # rotation axis a = DraftVecUtils.angle(normal, v, r) * 180 / math.pi Path.Log.debug( "oh boy: (%.2f, %.2f, %.2f) x (%.2f, %.2f, %.2f) -> (%.2f, %.2f, %.2f) -> %.2f" % (v.x, v.y, v.z, normal.x, normal.y, normal.z, r.x, r.y, r.z, a) ) Draft.rotate(sel.Object, a, axis=r) selObject = None selFeature = None with selectionEx() as selection: for sel in selection: selObject = sel.Object for feature in sel.SubElementNames: selFeature = feature Path.Log.track(selObject.Label, feature) sub = sel.Object.Shape.getElement(feature) if "Face" == sub.ShapeType: normal = sub.normalAt(0, 0) if sub.Orientation == "Reversed": normal = FreeCAD.Vector() - normal Path.Log.debug( "(%.2f, %.2f, %.2f) -> reversed (%s)" % (normal.x, normal.y, normal.z, sub.Orientation) ) else: Path.Log.debug( "(%.2f, %.2f, %.2f) -> forward (%s)" % (normal.x, normal.y, normal.z, sub.Orientation) ) if Path.Geom.pointsCoincide(axis, normal): alignSel(sel, normal, True) elif Path.Geom.pointsCoincide(axis, FreeCAD.Vector() - normal): alignSel(sel, FreeCAD.Vector() - normal, True) else: alignSel(sel, normal) elif "Edge" == sub.ShapeType: normal = (sub.Vertexes[1].Point - sub.Vertexes[0].Point).normalize() if Path.Geom.pointsCoincide(axis, normal) or Path.Geom.pointsCoincide( axis, FreeCAD.Vector() - normal ): # Don't really know the orientation of an edge, so let's just flip the object # and if the user doesn't like it they can flip again alignSel(sel, normal, True) else: alignSel(sel, normal) else: Path.Log.track(sub.ShapeType) if selObject and selFeature: FreeCADGui.Selection.clearSelection() FreeCADGui.Selection.addSelection(selObject, selFeature) def restoreSelection(self, selection): FreeCADGui.Selection.clearSelection() for sel in selection: FreeCADGui.Selection.addSelection(sel.Object, sel.SubElementNames) def modelSet0(self, axis): Path.Log.track(axis) with selectionEx() as selection: for sel in selection: selObject = sel.Object Path.Log.track(selObject.Label) for name in sel.SubElementNames: Path.Log.track(selObject.Label, name) feature = selObject.Shape.getElement(name) bb = feature.BoundBox offset = FreeCAD.Vector(axis.x * bb.XMax, axis.y * bb.YMax, axis.z * bb.ZMax) Path.Log.track(feature.BoundBox.ZMax, offset) p = selObject.Placement p.move(offset) selObject.Placement = p if self.form.linkStockAndModel.isChecked(): # Also move the objects not selected # if selection is not model, move the model too # if the selection is not stock and there is a stock, move the stock too for model in self.obj.Model.Group: if model != selObject: Draft.move(model, offset) if selObject != self.obj.Stock and self.obj.Stock: Draft.move(self.obj.Stock, offset) def modelMove(self, axis): scale = self.form.modelMoveValue.value() with selectionEx() as selection: for sel in selection: offset = axis * scale Draft.move(sel.Object, offset) def modelRotate(self, axis): angle = self.form.modelRotateValue.value() with selectionEx() as selection: if self.form.modelRotateCompound.isChecked() and len(selection) > 1: bb = PathStock.shapeBoundBox([sel.Object for sel in selection]) for sel in selection: Draft.rotate(sel.Object, angle, bb.Center, axis) else: for sel in selection: Draft.rotate(sel.Object, angle, sel.Object.Shape.BoundBox.Center, axis) def alignSetOrigin(self): (obj, by) = self.alignMoveToOrigin() for base in self.obj.Model.Group: if base != obj: Draft.move(base, by) if obj != self.obj.Stock and self.obj.Stock: Draft.move(self.obj.Stock, by) placement = FreeCADGui.ActiveDocument.ActiveView.viewPosition() placement.Base = placement.Base + by FreeCADGui.ActiveDocument.ActiveView.viewPosition(placement, 0) def alignMoveToOrigin(self): selObject = None selFeature = None p = None for sel in FreeCADGui.Selection.getSelectionEx(): selObject = sel.Object for feature in sel.SubElementNames: selFeature = feature sub = sel.Object.Shape.getElement(feature) if "Vertex" == sub.ShapeType: p = FreeCAD.Vector() - sub.Point if "Edge" == sub.ShapeType: p = FreeCAD.Vector() - sub.Curve.Location if "Face" == sub.ShapeType: p = FreeCAD.Vector() - sub.BoundBox.Center if p: Draft.move(sel.Object, p) if selObject and selFeature: FreeCADGui.Selection.clearSelection() FreeCADGui.Selection.addSelection(selObject, selFeature) return (selObject, p) def updateStockEditor(self, index, force=False): def setupFromBaseEdit(): Path.Log.track(index, force) if force or not self.stockFromBase: self.stockFromBase = StockFromBaseBoundBoxEdit(self.obj, self.form, force) self.stockEdit = self.stockFromBase def setupCreateBoxEdit(): Path.Log.track(index, force) if force or not self.stockCreateBox: self.stockCreateBox = StockCreateBoxEdit(self.obj, self.form, force) self.stockEdit = self.stockCreateBox def setupCreateCylinderEdit(): Path.Log.track(index, force) if force or not self.stockCreateCylinder: self.stockCreateCylinder = StockCreateCylinderEdit(self.obj, self.form, force) self.stockEdit = self.stockCreateCylinder def setupFromExisting(): Path.Log.track(index, force) if force or not self.stockFromExisting: self.stockFromExisting = StockFromExistingEdit(self.obj, self.form, force) if self.stockFromExisting.candidates(self.obj): self.stockEdit = self.stockFromExisting return True return False if index == -1: if self.obj.Stock is None or StockFromBaseBoundBoxEdit.IsStock(self.obj): setupFromBaseEdit() elif StockCreateBoxEdit.IsStock(self.obj): setupCreateBoxEdit() elif StockCreateCylinderEdit.IsStock(self.obj): setupCreateCylinderEdit() elif StockFromExistingEdit.IsStock(self.obj): setupFromExisting() else: Path.Log.error( translate("CAM_Job", "Unsupported stock object %s") % self.obj.Stock.Label ) else: if index == StockFromBaseBoundBoxEdit.Index: setupFromBaseEdit() elif index == StockCreateBoxEdit.Index: setupCreateBoxEdit() elif index == StockCreateCylinderEdit.Index: setupCreateCylinderEdit() elif index == StockFromExistingEdit.Index: if not setupFromExisting(): setupFromBaseEdit() index = -1 else: Path.Log.error( translate("CAM_Job", "Unsupported stock type %s (%d)") % (self.form.stock.currentText(), index) ) self.stockEdit.activate(self.obj, index == -1) if -1 != index: self.template.updateUI() def refreshStock(self): self.updateStockEditor(self.form.stock.currentIndex(), True) def alignCenterInStock(self): bbs = self.obj.Stock.Shape.BoundBox for sel in FreeCADGui.Selection.getSelectionEx(): bbb = sel.Object.Shape.BoundBox by = bbs.Center - bbb.Center Draft.move(sel.Object, by) def alignCenterInStockXY(self): bbs = self.obj.Stock.Shape.BoundBox for sel in FreeCADGui.Selection.getSelectionEx(): bbb = sel.Object.Shape.BoundBox by = bbs.Center - bbb.Center by.z = 0 Draft.move(sel.Object, by) def isValidDatumSelection(self, sel): if sel.ShapeType in ["Vertex", "Edge", "Face"]: if hasattr(sel, "Curve") and type(sel.Curve) not in [Part.Circle]: return False return True # no valid selection return False def isValidAxisSelection(self, sel): if sel.ShapeType in ["Vertex", "Edge", "Face"]: if hasattr(sel, "Curve") and type(sel.Curve) in [Part.Circle]: return False if hasattr(sel, "Surface") and sel.Surface.curvature(0, 0, "Max") != 0: return False return True # no valid selection return False def updateSelection(self): # Remove Job object if present in Selection: source of phantom paths if self.obj in FreeCADGui.Selection.getSelection(): FreeCADGui.Selection.removeSelection(self.obj) sel = FreeCADGui.Selection.getSelectionEx() self.form.setOrigin.setEnabled(False) self.form.moveToOrigin.setEnabled(False) self.form.modelSetXAxis.setEnabled(False) self.form.modelSetYAxis.setEnabled(False) self.form.modelSetZAxis.setEnabled(False) if len(sel) == 1 and len(sel[0].SubObjects) == 1: subObj = sel[0].SubObjects[0] if self.isValidDatumSelection(subObj): self.form.setOrigin.setEnabled(True) self.form.moveToOrigin.setEnabled(True) if self.isValidAxisSelection(subObj): self.form.modelSetXAxis.setEnabled(True) self.form.modelSetYAxis.setEnabled(True) self.form.modelSetZAxis.setEnabled(True) if len(sel) == 0 or self.obj.Stock in [s.Object for s in sel]: self.form.centerInStock.setEnabled(False) self.form.centerInStockXY.setEnabled(False) else: self.form.centerInStock.setEnabled(True) self.form.centerInStockXY.setEnabled(True) if len(sel) > 0: self.form.modelSetX0.setEnabled(True) self.form.modelSetY0.setEnabled(True) self.form.modelSetZ0.setEnabled(True) self.form.modelMoveGroup.setEnabled(True) self.form.modelRotateGroup.setEnabled(True) self.form.modelRotateCompound.setEnabled(len(sel) > 1) else: self.form.modelSetX0.setEnabled(False) self.form.modelSetY0.setEnabled(False) self.form.modelSetZ0.setEnabled(False) self.form.modelMoveGroup.setEnabled(False) self.form.modelRotateGroup.setEnabled(False) def jobModelEdit(self): dialog = PathJobDlg.JobCreate() dialog.setupTitle(translate("CAM_Job", "Model Selection")) dialog.setupModel(self.obj) if dialog.exec_() == 1: models = dialog.getModels() if models: obj = self.obj proxy = obj.Proxy want = Counter(models) have = Counter([proxy.baseObject(obj, o) for o in obj.Model.Group]) obsolete = have - want additions = want - have # first remove all obsolete base models for model, count in obsolete.items(): for i in range(count): # it seems natural to remove the last of all the base objects for a given model base = [b for b in obj.Model.Group if proxy.baseObject(obj, b) == model][-1] self.vproxy.forgetBaseVisibility(obj, base) self.obj.Proxy.removeBase(obj, base, True) # do not access any of the retired objects after this point, they don't exist anymore # then add all rookie base models for model, count in additions.items(): for i in range(count): base = PathJob.createModelResourceClone(obj, model) obj.Model.addObject(base) self.vproxy.rememberBaseVisibility(obj, base) # refresh the view if obsolete or additions: self.setFields() else: Path.Log.track("no changes to model") def tabPageChanged(self, index): if index == 0: # update the template with potential changes self.getFields() self.setupGlobal.accept() self.setupOps.accept() self.obj.Document.recompute() self.template.updateUI() def setupUi(self, activate): self.setupGlobal.setupUi() try: self.setupOps.setupUi() except Exception as ee: Path.Log.error(str(ee)) self.updateStockEditor(-1, False) self.setFields() # Info self.form.jobLabel.editingFinished.connect(self.getFields) self.form.jobModelEdit.clicked.connect(self.jobModelEdit) # Post Processor self.form.postProcessor.currentIndexChanged.connect(self.getFields) self.form.postProcessorArguments.editingFinished.connect(self.getFields) self.form.postProcessorOutputFile.editingFinished.connect(self.getFields) self.form.postProcessorSetOutputFile.clicked.connect(self.setPostProcessorOutputFile) # Workplan self.form.operationsList.itemSelectionChanged.connect(self.operationSelect) self.form.operationsList.indexesMoved.connect(self.getFields) self.form.operationDelete.clicked.connect(self.operationDelete) self.form.operationUp.clicked.connect(self.operationMoveUp) self.form.operationDown.clicked.connect(self.operationMoveDown) self.form.operationEdit.hide() # not supported yet self.form.activeToolGroup.hide() # not supported yet # Tool controller self.form.toolControllerList.itemSelectionChanged.connect(self.toolControllerSelect) self.form.toolControllerList.itemChanged.connect(self.toolControllerChanged) self.form.toolControllerEdit.clicked.connect(self.toolControllerEdit) self.form.toolControllerDelete.clicked.connect(self.toolControllerDelete) self.form.toolControllerAdd.clicked.connect(self.toolControllerAdd) self.operationSelect() self.toolControllerSelect() # Stock, Orientation and Alignment self.form.btnMaterial.clicked.connect(self.assignMaterial) self.form.centerInStock.clicked.connect(self.alignCenterInStock) self.form.centerInStockXY.clicked.connect(self.alignCenterInStockXY) self.form.stock.currentIndexChanged.connect(self.updateStockEditor) self.form.refreshStock.clicked.connect(self.refreshStock) self.form.modelSetXAxis.clicked.connect(lambda: self.modelSetAxis(FreeCAD.Vector(1, 0, 0))) self.form.modelSetYAxis.clicked.connect(lambda: self.modelSetAxis(FreeCAD.Vector(0, 1, 0))) self.form.modelSetZAxis.clicked.connect(lambda: self.modelSetAxis(FreeCAD.Vector(0, 0, 1))) self.form.modelSetX0.clicked.connect(lambda: self.modelSet0(FreeCAD.Vector(-1, 0, 0))) self.form.modelSetY0.clicked.connect(lambda: self.modelSet0(FreeCAD.Vector(0, -1, 0))) self.form.modelSetZ0.clicked.connect(lambda: self.modelSet0(FreeCAD.Vector(0, 0, -1))) self.form.setOrigin.clicked.connect(self.alignSetOrigin) self.form.moveToOrigin.clicked.connect(self.alignMoveToOrigin) self.form.modelMoveLeftUp.clicked.connect(lambda: self.modelMove(FreeCAD.Vector(-1, 1, 0))) self.form.modelMoveLeft.clicked.connect(lambda: self.modelMove(FreeCAD.Vector(-1, 0, 0))) self.form.modelMoveLeftDown.clicked.connect( lambda: self.modelMove(FreeCAD.Vector(-1, -1, 0)) ) self.form.modelMoveUp.clicked.connect(lambda: self.modelMove(FreeCAD.Vector(0, 1, 0))) self.form.modelMoveDown.clicked.connect(lambda: self.modelMove(FreeCAD.Vector(0, -1, 0))) self.form.modelMoveRightUp.clicked.connect(lambda: self.modelMove(FreeCAD.Vector(1, 1, 0))) self.form.modelMoveRight.clicked.connect(lambda: self.modelMove(FreeCAD.Vector(1, 0, 0))) self.form.modelMoveRightDown.clicked.connect( lambda: self.modelMove(FreeCAD.Vector(1, -1, 0)) ) self.form.modelRotateLeft.clicked.connect(lambda: self.modelRotate(FreeCAD.Vector(0, 0, 1))) self.form.modelRotateRight.clicked.connect( lambda: self.modelRotate(FreeCAD.Vector(0, 0, -1)) ) self.updateSelection() # set active page if activate in ["General", "Model"]: self.form.setCurrentIndex(0) if activate in ["Output", "Post Processor"]: self.form.setCurrentIndex(1) if activate in ["Layout", "Stock"]: self.form.setCurrentIndex(2) if activate in ["Tools", "Tool Controller"]: self.form.setCurrentIndex(3) if activate in ["Workplan", "Operations"]: self.form.setCurrentIndex(4) self.form.currentChanged.connect(self.tabPageChanged) self.template.exportButton().clicked.connect(self.templateExport) def templateExport(self): self.getFields() PathJobCmd.CommandJobTemplateExport.SaveDialog(self.obj, self.template) def open(self): FreeCADGui.Selection.addObserver(self) def _jobIntegrityCheck(self): """_jobIntegrityCheck() ... Check Job object for existence of Model and Tools If either Model or Tools is empty, change GUI tab, issue appropriate warning, and offer chance to add appropriate item.""" def _displayWarningWindow(msg): """Display window with warning message and Add action button. Return action state.""" txtHeader = translate("CAM_Job", "Warning") txtPleaseAddOne = translate("CAM_Job", "Please add one.") txtOk = translate("CAM_Job", "Ok") txtAdd = translate("CAM_Job", "Add") msgbox = QtGui.QMessageBox( QtGui.QMessageBox.Warning, txtHeader, msg + " " + txtPleaseAddOne ) msgbox.addButton(txtOk, QtGui.QMessageBox.AcceptRole) # Add 'Ok' button msgbox.addButton(txtAdd, QtGui.QMessageBox.ActionRole) # Add 'Add' button return msgbox.exec_() # Check if at least on base model is present if len(self.obj.Model.Group) == 0: self.form.setCurrentIndex(0) # Change tab to General tab no_model_txt = translate("CAM_Job", "This job has no base model.") if _displayWarningWindow(no_model_txt) == 1: self.jobModelEdit() # Check if at least one tool is present if len(self.obj.Tools.Group) == 0: self.form.setCurrentIndex(3) # Change tab to Tools tab no_tool_txt = translate("CAM_Job", "This job has no tool.") if _displayWarningWindow(no_tool_txt) == 1: self.toolControllerAdd() # SelectionObserver interface def addSelection(self, doc, obj, sub, pnt): self.updateSelection() def removeSelection(self, doc, obj, sub): self.updateSelection() def setSelection(self, doc): self.updateSelection() def clearSelection(self, doc): self.updateSelection() def Create(base, template=None, openTaskPanel=True): """Create(base, template) ... creates a job instance for the given base object using template to configure it.""" FreeCADGui.addModule("Path.Main.Job") FreeCAD.ActiveDocument.openTransaction("Create Job") try: obj = PathJob.Create("Job", base, template) obj.ViewObject.Proxy = ViewProvider(obj.ViewObject) obj.ViewObject.addExtension("Gui::ViewProviderGroupExtensionPython") FreeCAD.ActiveDocument.commitTransaction() obj.Document.recompute() if openTaskPanel: obj.ViewObject.Proxy.editObject(obj.Stock) else: obj.ViewObject.Proxy.deleteOnReject = False return obj except Exception as exc: Path.Log.error(exc) traceback.print_exc() FreeCAD.ActiveDocument.abortTransaction() # make sure the UI has been initialized PathGuiInit.Startup()