| | |
| |
|
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| |
|
| | import FreeCAD |
| | import FreeCADGui |
| | import Path |
| | import Path.Base.Gui.GetPoint as PathGetPoint |
| | import Path.Base.Gui.Util as PathGuiUtil |
| | import Path.Base.SetupSheet as PathSetupSheet |
| | import Path.Base.Util as PathUtil |
| | import Path.Main.Job as PathJob |
| | import Path.Op.Base as PathOp |
| | import Path.Op.Gui.Selection as PathSelection |
| | import Path.Tool.Controller as PathToolController |
| | from Path.Tool.library.ui.dock import ToolBitLibraryDock |
| | import PathScripts.PathUtils as PathUtils |
| | import importlib |
| | from PySide.QtCore import QT_TRANSLATE_NOOP |
| |
|
| | from PySide import QtCore, QtGui, QtWidgets |
| |
|
| | __title__ = "CAM Operation UI base classes" |
| | __author__ = "sliptonic (Brad Collette)" |
| | __url__ = "https://www.freecad.org" |
| | __doc__ = "Base classes and framework for CAM operation's UI" |
| |
|
| | 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()) |
| |
|
| |
|
| | class ViewProvider(object): |
| | """ |
| | Generic view provider for path objects. |
| | Deducts the icon name from operation name, brings up the TaskPanel |
| | with pages corresponding to the operation's opFeatures() and forwards |
| | property change notifications to the page controllers. |
| | """ |
| |
|
| | def __init__(self, vobj, resources): |
| | Path.Log.track() |
| | self.deleteOnReject = True |
| | self.OpIcon = ":/icons/%s.svg" % resources.pixmap |
| | self.OpName = resources.name |
| | self.OpPageModule = resources.opPageClass.__module__ |
| | self.OpPageClass = resources.opPageClass.__name__ |
| |
|
| | |
| | self.vobj = vobj |
| | self.Object = None |
| | self.panel = None |
| |
|
| | def attach(self, vobj): |
| | Path.Log.track() |
| | self.vobj = vobj |
| | self.Object = vobj.Object |
| | self.panel = None |
| | return |
| |
|
| | def deleteObjectsOnReject(self): |
| | """ |
| | deleteObjectsOnReject() ... return true if all objects should |
| | be created if the user hits cancel. This is used during the initial |
| | edit session, if the user does not press OK, it is assumed they've |
| | changed their mind about creating the operation. |
| | """ |
| | Path.Log.track() |
| | return hasattr(self, "deleteOnReject") and self.deleteOnReject |
| |
|
| | def setDeleteObjectsOnReject(self, state=False): |
| | Path.Log.track() |
| | self.deleteOnReject = state |
| | return self.deleteOnReject |
| |
|
| | def setEdit(self, vobj=None, mode=0): |
| | """setEdit(vobj, mode=0) ... initiate editing of receivers model.""" |
| | Path.Log.track() |
| | if 0 == mode: |
| | if vobj is None: |
| | vobj = self.vobj |
| | page = self.getTaskPanelOpPage(vobj.Object) |
| | page.setTitle(self.OpName) |
| | page.setIcon(self.OpIcon) |
| | selection = self.getSelectionFactory() |
| | self.setupTaskPanel( |
| | TaskPanel(vobj.Object, self.deleteObjectsOnReject(), page, selection) |
| | ) |
| | self.deleteOnReject = False |
| | return True |
| | |
| | return False |
| |
|
| | def setupTaskPanel(self, panel): |
| | """setupTaskPanel(panel) ... internal function to start the editor.""" |
| | self.panel = panel |
| | FreeCADGui.Control.closeDialog() |
| | FreeCADGui.Control.showDialog(panel) |
| | panel.setupUi() |
| | job = self.Object.Proxy.getJob(self.Object) |
| | if job: |
| | job.ViewObject.Proxy.setupEditVisibility(job) |
| | else: |
| | Path.Log.info("did not find no job") |
| |
|
| | def clearTaskPanel(self): |
| | """clearTaskPanel() ... internal callback function when editing has finished.""" |
| | self.panel = None |
| | job = self.Object.Proxy.getJob(self.Object) |
| | if job: |
| | job.ViewObject.Proxy.resetEditVisibility(job) |
| |
|
| | def unsetEdit(self, arg1, arg2): |
| | if self.panel: |
| | self.panel.reject(False) |
| |
|
| | def dumps(self): |
| | """dumps() ... callback before receiver is saved to a file. |
| | Returns a dictionary with the receiver's resources as strings.""" |
| | Path.Log.track() |
| | state = {} |
| | state["OpName"] = self.OpName |
| | state["OpIcon"] = self.OpIcon |
| | state["OpPageModule"] = self.OpPageModule |
| | state["OpPageClass"] = self.OpPageClass |
| | return state |
| |
|
| | def loads(self, state): |
| | """loads(state) ... callback on restoring a saved instance, pendant to dumps() |
| | state is the dictionary returned by dumps().""" |
| | self.OpName = state["OpName"] |
| | self.OpIcon = state["OpIcon"] |
| | self.OpPageModule = state["OpPageModule"] |
| | self.OpPageClass = state["OpPageClass"] |
| |
|
| | def getIcon(self): |
| | """getIcon() ... the icon used in the object tree""" |
| | if self.Object.Active: |
| | return self.OpIcon |
| | else: |
| | return ":/icons/CAM_OpActive.svg" |
| |
|
| | def getTaskPanelOpPage(self, obj): |
| | """getTaskPanelOpPage(obj) ... use the stored information to instantiate the receiver op's page controller.""" |
| | mod = importlib.import_module(self.OpPageModule) |
| | cls = getattr(mod, self.OpPageClass) |
| | return cls(obj, 0) |
| |
|
| | def getSelectionFactory(self): |
| | """getSelectionFactory() ... return a factory function that can be used to create the selection observer.""" |
| | return PathSelection.select(self.OpName) |
| |
|
| | def updateData(self, obj, prop): |
| | """updateData(obj, prop) ... callback whenever a property of the receiver's model is assigned. |
| | The callback is forwarded to the task panel - in case an editing session is ongoing.""" |
| | |
| | if self.panel: |
| | self.panel.updateData(obj, prop) |
| |
|
| | def onDelete(self, vobj, arg2=None): |
| | PathUtil.clearExpressionEngine(vobj.Object) |
| | return True |
| |
|
| | def setupContextMenu(self, vobj, menu): |
| | Path.Log.track() |
| | for action in menu.actions(): |
| | menu.removeAction(action) |
| | action = QtGui.QAction(translate("PathOp", "Edit"), menu) |
| | action.triggered.connect(self._editInContextMenuTriggered) |
| | menu.addAction(action) |
| |
|
| | def _editInContextMenuTriggered(self, checked): |
| | self.setEdit() |
| |
|
| |
|
| | class TaskPanelPage(object): |
| | """Base class for all task panel pages.""" |
| |
|
| | |
| | def __init__(self, obj, features): |
| | """__init__(obj, features) ... framework initialisation. |
| | Do not overwrite, implement initPage(obj) instead.""" |
| | self.obj = obj |
| | self.job = PathUtils.findParentJob(obj) |
| | self.form = self.getForm() |
| | self.signalDirtyChanged = None |
| | self.setClean() |
| | self.setTitle("-") |
| | self.setIcon(None) |
| | self.features = features |
| | self.isdirty = False |
| | self.parent = None |
| | self.panelTitle = "Operation" |
| | self.tcEditor = None |
| | self.combo = None |
| |
|
| | if self._installTCUpdate(): |
| | PathJob.Notification.updateTC.connect(self.resetToolController) |
| | self.form.toolController.currentIndexChanged.connect(self.tcComboChanged) |
| |
|
| | def show_error_message(self, title, message): |
| | msg_box = QtGui.QMessageBox() |
| | msg_box.setIcon(QtGui.QMessageBox.Critical) |
| | msg_box.setWindowTitle(title) |
| | msg_box.setText(message) |
| | msg_box.setStandardButtons(QtGui.QMessageBox.Ok) |
| | msg_box.exec_() |
| |
|
| | def _installTCUpdate(self): |
| | return hasattr(self.form, "toolController") |
| |
|
| | def setParent(self, parent): |
| | """setParent() ... used to transfer parent object link to child class. |
| | Do not overwrite.""" |
| | self.parent = parent |
| |
|
| | def onDirtyChanged(self, callback): |
| | """onDirtyChanged(callback) ... set callback when dirty state changes.""" |
| | self.signalDirtyChanged = callback |
| |
|
| | def setDirty(self): |
| | """setDirty() ... mark receiver as dirty, causing the model to be recalculated if OK or Apply is pressed.""" |
| | self.isdirty = True |
| | if self.signalDirtyChanged: |
| | self.signalDirtyChanged(self) |
| |
|
| | def setClean(self): |
| | """setClean() ... mark receiver as clean, indicating there is no need to recalculate the model even if the user presses OK or Apply.""" |
| | self.isdirty = False |
| | if self.signalDirtyChanged: |
| | self.signalDirtyChanged(self) |
| |
|
| | def pageGetFields(self): |
| | """pageGetFields() ... internal callback. |
| | Do not overwrite, implement getFields(obj) instead.""" |
| | self.getFields(self.obj) |
| | self.setDirty() |
| |
|
| | def pageSetFields(self): |
| | """pageSetFields() ... internal callback. |
| | Do not overwrite, implement setFields(obj) instead.""" |
| | self.setFields(self.obj) |
| |
|
| | def pageCleanup(self): |
| | """pageCleanup() ... internal callback. |
| | Do not overwrite, implement cleanupPage(obj) instead.""" |
| | if self._installTCUpdate(): |
| | PathJob.Notification.updateTC.disconnect(self.resetToolController) |
| | self.cleanupPage(self.obj) |
| |
|
| | def pageRegisterSignalHandlers(self): |
| | """pageRegisterSignalHandlers() .. internal callback. |
| | Registers a callback for all signals returned by getSignalsForUpdate(obj). |
| | Do not overwrite, implement getSignalsForUpdate(obj) and/or registerSignalHandlers(obj) instead. |
| | """ |
| | for signal in self.getSignalsForUpdate(self.obj): |
| | signal.connect(self.pageGetFields) |
| | self.registerSignalHandlers(self.obj) |
| |
|
| | def pageUpdateData(self, obj, prop): |
| | """pageUpdateData(obj, prop) ... internal callback. |
| | Do not overwrite, implement updateData(obj) instead.""" |
| | self.updateData(obj, prop) |
| |
|
| | def setTitle(self, title): |
| | """setTitle(title) ... sets a title for the page.""" |
| | self.title = title |
| |
|
| | def getTitle(self, obj): |
| | """getTitle(obj) ... return title to be used for the receiver page. |
| | The default implementation returns what was previously set with setTitle(title). |
| | Can safely be overwritten by subclasses.""" |
| | return self.title |
| |
|
| | def setIcon(self, icon): |
| | """setIcon(icon) ... sets the icon for the page.""" |
| | self.icon = icon |
| |
|
| | def getIcon(self, obj): |
| | """getIcon(obj) ... return icon for page or None. |
| | Can safely be overwritten by subclasses.""" |
| | return self.icon |
| |
|
| | |
| | def initPage(self, obj): |
| | """initPage(obj) ... overwrite to customize UI for specific model. |
| | Note that this function is invoked after all page controllers have been created. |
| | Should be overwritten by subclasses.""" |
| | pass |
| |
|
| | def cleanupPage(self, obj): |
| | """cleanupPage(obj) ... overwrite to perform any cleanup tasks before page is destroyed. |
| | Can safely be overwritten by subclasses.""" |
| | pass |
| |
|
| | def modifyStandardButtons(self, buttonBox): |
| | """modifyStandardButtons(buttonBox) ... overwrite if the task panel standard buttons need to be modified. |
| | Can safely be overwritten by subclasses.""" |
| | pass |
| |
|
| | def getForm(self): |
| | """getForm() ... return UI form for this page. |
| | Must be overwritten by subclasses.""" |
| | pass |
| |
|
| | def getFields(self, obj): |
| | """getFields(obj) ... overwrite to transfer values from UI to obj's properties. |
| | Can safely be overwritten by subclasses.""" |
| | pass |
| |
|
| | def setFields(self, obj): |
| | """setFields(obj) ... overwrite to transfer obj's property values to UI. |
| | Can safely be overwritten by subclasses.""" |
| | pass |
| |
|
| | def getSignalsForUpdate(self, obj): |
| | """getSignalsForUpdate(obj) ... return signals which, when triggered, cause the receiver to update the model. |
| | See also registerSignalHandlers(obj) |
| | Can safely be overwritten by subclasses.""" |
| | return [] |
| |
|
| | def registerSignalHandlers(self, obj): |
| | """registerSignalHandlers(obj) ... overwrite to register custom signal handlers. |
| | In case an update of a model is not the desired operation of a signal invocation |
| | (see getSignalsForUpdate(obj)) this function can be used to register signal handlers |
| | manually. |
| | Can safely be overwritten by subclasses.""" |
| | pass |
| |
|
| | def updateData(self, obj, prop): |
| | """updateData(obj, prop) ... overwrite if the receiver needs to react to property changes that might not have been caused by the receiver itself. |
| | Sometimes a model will recalculate properties based on a change of another property. In order to keep the UI up to date with such changes this |
| | function can be used. |
| | Please note that the callback is synchronous with the property assignment operation. Also note that the notification is invoked regardless of the |
| | actual value of the property assignment. In other words it also fires if a property gets assigned the same value it already has. |
| | Taking above observations into account the implementation has to take care that it doesn't overwrite modified UI values by invoking setFields(obj). |
| | This can happen if a subclass unconditionally transfers all values in getFields(obj) to the model and just calls setFields(obj) in this callback. |
| | In such a scenario the first property assignment will cause all changes in the UI of the other fields to be overwritten by setFields(obj). |
| | You have been warned.""" |
| | pass |
| |
|
| | def updateSelection(self, obj, sel): |
| | """updateSelection(obj, sel) ... |
| | overwrite to customize UI depending on current selection. |
| | Can safely be overwritten by subclasses.""" |
| | pass |
| |
|
| | def selectInComboBox(self, name, combo): |
| | """selectInComboBox(name, combo) ... |
| | helper function to select a specific value in a combo box.""" |
| | try: |
| | combo.blockSignals(True) |
| | index = combo.currentIndex() |
| |
|
| | |
| | newindex = combo.findData(name) |
| | if newindex >= 0: |
| | combo.setCurrentIndex(newindex) |
| | return |
| |
|
| | |
| | newindex = combo.findText(name, QtCore.Qt.MatchFixedString) |
| | if newindex >= 0: |
| | combo.setCurrentIndex(newindex) |
| | return |
| |
|
| | |
| | combo.setCurrentIndex(index) |
| | finally: |
| | combo.blockSignals(False) |
| |
|
| | def populateCombobox(self, form, enumTups, comboBoxesPropertyMap): |
| | """populateCombobox(form, enumTups, comboBoxesPropertyMap) ... proxy for PathGuiUtil.populateCombobox()""" |
| | PathGuiUtil.populateCombobox(form, enumTups, comboBoxesPropertyMap) |
| |
|
| | def tcComboChanged(self, newIndex): |
| | if self.obj is not None and self.tcEditor: |
| | if newIndex == self.combo.count() - 1: |
| | |
| | dock = ToolBitLibraryDock(self.job, True) |
| | dock.open() |
| | self.resetTCCombo() |
| | elif newIndex == self.combo.count() - 2: |
| | |
| | self.copyToolController() |
| | self.resetTCCombo() |
| | else: |
| | tc = PathUtils.findToolController( |
| | self.obj, self.obj.Proxy, self.form.toolController.currentText() |
| | ) |
| | self.obj.ToolController = tc |
| | self.setupToolController() |
| |
|
| | def updateToolControllerEditorVisibility(self): |
| | if self.form.editToolController.isChecked(): |
| | self.tcEditor.controller.show() |
| | else: |
| | self.tcEditor.controller.hide() |
| |
|
| | def resetToolController(self, job, tc): |
| | if self.obj is None: |
| | return |
| | self.obj.ToolController = tc |
| | self.setupToolController() |
| |
|
| | def copyToolController(self): |
| | oldTc = self.tcEditor.obj |
| | self.tcEditor.updateToolController() |
| | job = self.obj.Proxy.getJob(self.obj) |
| | self.obj.ToolController = PathToolController.copyTC(oldTc, job) |
| | self.setupToolController() |
| |
|
| | def tcEditorChanged(self): |
| | self.setDirty() |
| | self.resetTCCombo() |
| |
|
| | def resetTCCombo(self): |
| | controllers = PathUtils.getToolControllers(self.obj) |
| |
|
| | if self.obj.ToolController is None: |
| | self.obj.ToolController = PathUtils.findToolController(self.obj, self.obj.Proxy) |
| | if len(controllers) > 0 and not self.obj.Proxy.isToolSupported( |
| | self.obj, self.obj.ToolController.Tool |
| | ): |
| | self.obj.ToolController = controllers[0] |
| |
|
| | tcName = self.obj.ToolController.Label if self.obj.ToolController else "" |
| | labels = [c.Label for c in controllers] |
| | labels.append(FreeCAD.Qt.translate("CAM_Operation", "Copy {0}…").format(tcName)) |
| | labels.append(FreeCAD.Qt.translate("CAM_Operation", "New tool controller…")) |
| | self.combo.blockSignals(True) |
| | self.combo.clear() |
| | self.combo.addItems(labels) |
| | self.combo.insertSeparator(len(controllers)) |
| | self.combo.blockSignals(False) |
| |
|
| | if self.obj.ToolController is not None: |
| | self.selectInComboBox(self.obj.ToolController.Label, self.combo) |
| |
|
| | def setupToolController(self, obj=None, combo=None): |
| | """setupToolController(obj, combo) ... |
| | helper function to setup obj's ToolController |
| | in the given combo box.""" |
| | obj = obj or self.obj |
| | combo = combo or self.combo |
| | self.obj, self.combo = obj, combo |
| |
|
| | self.resetTCCombo() |
| |
|
| | if hasattr(self.form, "editToolController"): |
| | layout = self.form.editToolController.parent().layout() |
| | oldEditor = self.tcEditor |
| |
|
| | |
| | |
| | tcCount = 0 |
| | for job in PathUtils.GetJobs(): |
| | for op in job.Operations.Group: |
| | if op == self.obj: |
| | continue |
| | elif hasattr(op, "ToolController") and op.ToolController == obj.ToolController: |
| | tcCount += 1 |
| |
|
| | self.tcEditor = Path.Tool.Gui.Controller.ToolControllerEditor( |
| | obj.ToolController, |
| | False, |
| | self.tcEditorChanged, |
| | True, |
| | True, |
| | ) |
| | self.tcEditor.setupUi() |
| |
|
| | labelStr = FreeCAD.Qt.translate( |
| | "CAM_Operation", "This tool controller is used by {0} other operations." |
| | ).format(tcCount) |
| | self.tcEditor.controller.tcOperationCountLabel.setText(labelStr) |
| |
|
| | |
| | if isinstance(layout, QtWidgets.QGridLayout): |
| | layout.addWidget( |
| | self.tcEditor.controller, layout.rowCount(), 0, 1, layout.columnCount() |
| | ) |
| | else: |
| | Path.Log.error( |
| | "Panel uses a layout incompatible with editing tool controllers. Report a bug: it should be a QGridLayout" |
| | ) |
| |
|
| | self.updateToolControllerEditorVisibility() |
| | self.tcEditor.updateUi() |
| | checkbox = self.form.editToolController |
| | checkboxSignal = ( |
| | checkbox.checkStateChanged |
| | if hasattr(checkbox, "checkStateChanged") |
| | else checkbox.stateChanged |
| | ) |
| | checkboxSignal.connect(self.updateToolControllerEditorVisibility) |
| |
|
| | if oldEditor: |
| | oldEditor.updateToolController() |
| | oldEditor.controller.hide() |
| | layout.removeWidget(oldEditor.controller) |
| |
|
| | def updateToolController(self, obj, combo): |
| | """updateToolController(obj, combo) ... |
| | helper function to update obj's ToolController property if a different |
| | one has been selected in the combo box.""" |
| | tc = PathUtils.findToolController(obj, obj.Proxy, combo.currentText()) |
| | if obj.ToolController != tc: |
| | obj.ToolController = tc |
| | if self.tcEditor: |
| | self.tcEditor.updateToolController() |
| |
|
| | def setupCoolant(self, obj, combo): |
| | """setupCoolant(obj, combo) ... |
| | helper function to setup obj's Coolant option.""" |
| | job = PathUtils.findParentJob(obj) |
| | options = job.SetupSheet.CoolantModes |
| | combo.blockSignals(True) |
| | combo.clear() |
| | combo.addItems(options) |
| | combo.blockSignals(False) |
| |
|
| | if hasattr(obj, "CoolantMode"): |
| | self.selectInComboBox(obj.CoolantMode, combo) |
| |
|
| | def updateCoolant(self, obj, combo): |
| | """updateCoolant(obj, combo) ... |
| | helper function to update obj's Coolant property if a different |
| | one has been selected in the combo box.""" |
| | option = combo.currentText() |
| | if hasattr(obj, "CoolantMode") and option: |
| | if obj.CoolantMode != option: |
| | obj.CoolantMode = option |
| |
|
| | def updatePanelVisibility(self, panelTitle, obj): |
| | """updatePanelVisibility(panelTitle, obj) ... |
| | Function to call the `updateVisibility()` GUI method of the |
| | page whose panel title is as indicated.""" |
| | if hasattr(self, "parent"): |
| | parent = getattr(self, "parent") |
| | if parent and hasattr(parent, "featurePages"): |
| | for page in parent.featurePages: |
| | if hasattr(page, "panelTitle"): |
| | if page.panelTitle == panelTitle and hasattr(page, "updateVisibility"): |
| | page.updateVisibility() |
| | break |
| |
|
| |
|
| | class TaskPanelBaseGeometryPage(TaskPanelPage): |
| | """Page controller for the base geometry.""" |
| |
|
| | DataObject = QtCore.Qt.ItemDataRole.UserRole |
| | DataObjectSub = QtCore.Qt.ItemDataRole.UserRole + 1 |
| |
|
| | def __init__(self, obj, features): |
| | super(TaskPanelBaseGeometryPage, self).__init__(obj, features) |
| |
|
| | self.panelTitle = "Base Geometry" |
| | self.OpIcon = ":/icons/CAM_BaseGeometry.svg" |
| | self.setIcon(self.OpIcon) |
| |
|
| | def getForm(self): |
| | panel = FreeCADGui.PySideUic.loadUi(":/panels/PageBaseGeometryEdit.ui") |
| | self.modifyPanel(panel) |
| | return panel |
| |
|
| | def modifyPanel(self, panel): |
| | """modifyPanel(self, panel) ... |
| | Helper method to modify the current form immediately after |
| | it is loaded.""" |
| | |
| | availableOps = list() |
| | ops = self.job.Operations.Group |
| | for op in ops: |
| | if hasattr(op, "Base") and isinstance(op.Base, list): |
| | if len(op.Base) > 0: |
| | availableOps.append(op.Label) |
| |
|
| | |
| | if len(availableOps) > 0: |
| | |
| | try: |
| | panel.geometryImportList.blockSignals(True) |
| | panel.geometryImportList.clear() |
| | availableOps.sort() |
| | for opLbl in availableOps: |
| | panel.geometryImportList.addItem(opLbl) |
| | panel.geometryImportList.blockSignals(False) |
| | except (AttributeError, RuntimeError): |
| | |
| | pass |
| | else: |
| | try: |
| | panel.geometryImportList.hide() |
| | panel.geometryImportButton.hide() |
| | except (AttributeError, RuntimeError): |
| | |
| | pass |
| |
|
| | def getTitle(self, obj): |
| | return translate("PathOp", "Base Geometry") |
| |
|
| | def getFields(self, obj): |
| | pass |
| |
|
| | def setFields(self, obj): |
| | self.form.baseList.blockSignals(True) |
| | self.form.baseList.clear() |
| | for base in self.obj.Base: |
| | for sub in base[1]: |
| | item = QtGui.QListWidgetItem("%s.%s" % (base[0].Label, sub)) |
| | item.setData(self.DataObject, base[0]) |
| | item.setData(self.DataObjectSub, sub) |
| | self.form.baseList.addItem(item) |
| | self.form.baseList.blockSignals(False) |
| | self.resizeBaseList() |
| |
|
| | def itemActivated(self): |
| | FreeCADGui.Selection.clearSelection() |
| | for item in self.form.baseList.selectedItems(): |
| | obj = item.data(self.DataObject) |
| | sub = item.data(self.DataObjectSub) |
| | if sub: |
| | FreeCADGui.Selection.addSelection(obj, sub) |
| | else: |
| | FreeCADGui.Selection.addSelection(obj) |
| | |
| |
|
| | def supportsVertexes(self): |
| | return self.features & PathOp.FeatureBaseVertexes |
| |
|
| | def supportsEdges(self): |
| | return self.features & PathOp.FeatureBaseEdges |
| |
|
| | def supportsFaces(self): |
| | return self.features & PathOp.FeatureBaseFaces |
| |
|
| | def supportsPanels(self): |
| | return self.features & PathOp.FeatureBasePanels |
| |
|
| | def featureName(self): |
| | if self.supportsEdges() and self.supportsFaces(): |
| | return "features" |
| | if self.supportsFaces(): |
| | return "faces" |
| | if self.supportsEdges(): |
| | return "edges" |
| | return "nothing" |
| |
|
| | def selectionSupportedAsBaseGeometry(self, sel, ignoreErrors): |
| | if sel.HasSubObjects: |
| | if not self.supportsVertexes() and sel.SubObjects[0].ShapeType == "Vertex": |
| | return False |
| | if not self.supportsEdges() and sel.SubObjects[0].ShapeType == "Edge": |
| | return False |
| | if not self.supportsFaces() and sel.SubObjects[0].ShapeType == "Face": |
| | return False |
| | else: |
| | if not self.supportsPanels() or "Panel" not in sel.Object.Name: |
| | return False |
| | return True |
| |
|
| | def addBaseGeometry(self, selection): |
| | Path.Log.track(selection) |
| | for sel in selection: |
| | |
| | if self.selectionSupportedAsBaseGeometry(sel, False): |
| | for sub in sel.SubElementNames: |
| | self.obj.Proxy.addBase(self.obj, sel.Object, sub) |
| | return False |
| |
|
| | def addBase(self): |
| | Path.Log.track() |
| | if self.addBaseGeometry(FreeCADGui.Selection.getSelectionEx()): |
| | |
| | self.setFields(self.obj) |
| | self.setDirty() |
| | self.updatePanelVisibility("Operation", self.obj) |
| |
|
| | def deleteBase(self): |
| | Path.Log.track() |
| | selected = self.form.baseList.selectedItems() |
| | for item in selected: |
| | self.form.baseList.takeItem(self.form.baseList.row(item)) |
| | self.setDirty() |
| | self.updateBase() |
| | self.updatePanelVisibility("Operation", self.obj) |
| | self.resizeBaseList() |
| |
|
| | def updateBase(self): |
| | newlist = [] |
| | for i in range(self.form.baseList.count()): |
| | item = self.form.baseList.item(i) |
| | obj = item.data(self.DataObject) |
| | sub = item.data(self.DataObjectSub) |
| | if sub: |
| | base = (obj, str(sub)) |
| | newlist.append(base) |
| | Path.Log.debug("Setting new base: %s -> %s" % (self.obj.Base, newlist)) |
| | self.obj.Base = newlist |
| |
|
| | def clearBase(self): |
| | self.obj.Base = [] |
| | self.setDirty() |
| | self.updatePanelVisibility("Operation", self.obj) |
| | self.resizeBaseList() |
| |
|
| | def importBaseGeometry(self): |
| | opLabel = str(self.form.geometryImportList.currentText()) |
| | ops = FreeCAD.ActiveDocument.getObjectsByLabel(opLabel) |
| | if len(ops) > 1: |
| | msg = translate("PathOp", "Multiple operations are labeled as") |
| | msg += " {}\n".format(opLabel) |
| | FreeCAD.Console.PrintWarning(msg) |
| | for base, subList in ops[0].Base: |
| | FreeCADGui.Selection.clearSelection() |
| | FreeCADGui.Selection.addSelection(base, subList) |
| | self.addBase() |
| |
|
| | def registerSignalHandlers(self, obj): |
| | self.form.baseList.itemSelectionChanged.connect(self.itemActivated) |
| | self.form.addBase.clicked.connect(self.addBase) |
| | self.form.deleteBase.clicked.connect(self.deleteBase) |
| | self.form.clearBase.clicked.connect(self.clearBase) |
| | self.form.geometryImportButton.clicked.connect(self.importBaseGeometry) |
| |
|
| | def pageUpdateData(self, obj, prop): |
| | if prop in ["Base"]: |
| | self.setFields(obj) |
| |
|
| | def updateSelection(self, obj, selection): |
| | for sel in selection: |
| | if self.selectionSupportedAsBaseGeometry(sel, True): |
| | self.form.addBase.setEnabled(True) |
| | else: |
| | self.form.addBase.setEnabled(False) |
| |
|
| | def resizeBaseList(self): |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | qList = self.form.baseList |
| | row = (qList.count() + qList.frameWidth()) * 15 |
| | |
| | Path.Log.debug( |
| | "baseList({}, {}) {} * {}".format( |
| | qList.size(), row, qList.count(), qList.sizeHintForRow(0) |
| | ) |
| | ) |
| |
|
| |
|
| | class TaskPanelBaseLocationPage(TaskPanelPage): |
| | """Page controller for base locations. Uses PathGetPoint.""" |
| |
|
| | DataLocation = QtCore.Qt.ItemDataRole.UserRole |
| |
|
| | def __init__(self, obj, features): |
| | super(TaskPanelBaseLocationPage, self).__init__(obj, features) |
| |
|
| | |
| | self.editRow = None |
| | self.panelTitle = "Base Location" |
| |
|
| | def getForm(self): |
| | self.formLoc = FreeCADGui.PySideUic.loadUi(":/panels/PageBaseLocationEdit.ui") |
| | if QtCore.qVersion()[0] == "4": |
| | self.formLoc.baseList.horizontalHeader().setResizeMode(QtGui.QHeaderView.Stretch) |
| | else: |
| | self.formLoc.baseList.horizontalHeader().setSectionResizeMode(QtGui.QHeaderView.Stretch) |
| | self.getPoint = PathGetPoint.TaskPanel(self.formLoc.addRemoveEdit) |
| | return self.formLoc |
| |
|
| | def modifyStandardButtons(self, buttonBox): |
| | self.getPoint.buttonBox = buttonBox |
| |
|
| | def getTitle(self, obj): |
| | return translate("PathOp", "Base Location") |
| |
|
| | def getFields(self, obj): |
| | pass |
| |
|
| | def setFields(self, obj): |
| | self.formLoc.baseList.blockSignals(True) |
| | self.formLoc.baseList.clearContents() |
| | self.formLoc.baseList.setRowCount(0) |
| | for location in self.obj.Locations: |
| | self.formLoc.baseList.insertRow(self.formLoc.baseList.rowCount()) |
| |
|
| | item = QtGui.QTableWidgetItem("%.2f" % location.x) |
| | item.setData(self.DataLocation, location.x) |
| | self.formLoc.baseList.setItem(self.formLoc.baseList.rowCount() - 1, 0, item) |
| |
|
| | item = QtGui.QTableWidgetItem("%.2f" % location.y) |
| | item.setData(self.DataLocation, location.y) |
| | self.formLoc.baseList.setItem(self.formLoc.baseList.rowCount() - 1, 1, item) |
| | self.formLoc.baseList.resizeColumnToContents(0) |
| | self.formLoc.baseList.blockSignals(False) |
| | self.itemActivated() |
| |
|
| | def removeLocation(self): |
| | deletedRows = [] |
| | selected = self.formLoc.baseList.selectedItems() |
| | for item in selected: |
| | row = self.formLoc.baseList.row(item) |
| | if row not in deletedRows: |
| | deletedRows.append(row) |
| | self.formLoc.baseList.removeRow(row) |
| | self.updateLocations() |
| | FreeCAD.ActiveDocument.recompute() |
| |
|
| | def updateLocations(self): |
| | Path.Log.track() |
| | locations = [] |
| | for i in range(self.formLoc.baseList.rowCount()): |
| | x = self.formLoc.baseList.item(i, 0).data(self.DataLocation) |
| | y = self.formLoc.baseList.item(i, 1).data(self.DataLocation) |
| | location = FreeCAD.Vector(x, y, 0) |
| | locations.append(location) |
| | self.obj.Locations = locations |
| |
|
| | def addLocation(self): |
| | self.getPoint.getPoint(self.addLocationAt) |
| |
|
| | def addLocationAt(self, point, obj): |
| | if point: |
| | locations = self.obj.Locations |
| | locations.append(point) |
| | self.obj.Locations = locations |
| | FreeCAD.ActiveDocument.recompute() |
| |
|
| | def editLocation(self): |
| | selected = self.formLoc.baseList.selectedItems() |
| | if selected: |
| | row = self.formLoc.baseList.row(selected[0]) |
| | self.editRow = row |
| | x = self.formLoc.baseList.item(row, 0).data(self.DataLocation) |
| | y = self.formLoc.baseList.item(row, 1).data(self.DataLocation) |
| | start = FreeCAD.Vector(x, y, 0) |
| | self.getPoint.getPoint(self.editLocationAt, start) |
| |
|
| | def editLocationAt(self, point, obj): |
| | if point: |
| | self.formLoc.baseList.item(self.editRow, 0).setData(self.DataLocation, point.x) |
| | self.formLoc.baseList.item(self.editRow, 1).setData(self.DataLocation, point.y) |
| | self.updateLocations() |
| | FreeCAD.ActiveDocument.recompute() |
| |
|
| | def itemActivated(self): |
| | if self.formLoc.baseList.selectedItems(): |
| | self.form.removeLocation.setEnabled(True) |
| | self.form.editLocation.setEnabled(True) |
| | else: |
| | self.form.removeLocation.setEnabled(False) |
| | self.form.editLocation.setEnabled(False) |
| |
|
| | def registerSignalHandlers(self, obj): |
| | self.form.baseList.itemSelectionChanged.connect(self.itemActivated) |
| | self.formLoc.addLocation.clicked.connect(self.addLocation) |
| | self.formLoc.removeLocation.clicked.connect(self.removeLocation) |
| | self.formLoc.editLocation.clicked.connect(self.editLocation) |
| |
|
| | def pageUpdateData(self, obj, prop): |
| | if prop in ["Locations"]: |
| | self.setFields(obj) |
| |
|
| |
|
| | class TaskPanelHeightsPage(TaskPanelPage): |
| | """Page controller for heights.""" |
| |
|
| | def __init__(self, obj, features): |
| | super(TaskPanelHeightsPage, self).__init__(obj, features) |
| |
|
| | |
| | self.clearanceHeight = None |
| | self.safeHeight = None |
| | self.panelTitle = "Heights" |
| | self.OpIcon = ":/icons/CAM_Heights.svg" |
| | self.setIcon(self.OpIcon) |
| |
|
| | def getForm(self): |
| | return FreeCADGui.PySideUic.loadUi(":/panels/PageHeightsEdit.ui") |
| |
|
| | def initPage(self, obj): |
| | self.safeHeight = PathGuiUtil.QuantitySpinBox(self.form.safeHeight, obj, "SafeHeight") |
| | self.clearanceHeight = PathGuiUtil.QuantitySpinBox( |
| | self.form.clearanceHeight, obj, "ClearanceHeight" |
| | ) |
| |
|
| | def getTitle(self, obj): |
| | return translate("PathOp", "Heights") |
| |
|
| | def getFields(self, obj): |
| | self.safeHeight.updateProperty() |
| | self.clearanceHeight.updateProperty() |
| |
|
| | def setFields(self, obj): |
| | self.safeHeight.updateWidget() |
| | self.clearanceHeight.updateWidget() |
| |
|
| | def getSignalsForUpdate(self, obj): |
| | signals = [] |
| | signals.append(self.form.safeHeight.editingFinished) |
| | signals.append(self.form.clearanceHeight.editingFinished) |
| | return signals |
| |
|
| | def pageUpdateData(self, obj, prop): |
| | if prop in ["SafeHeight", "ClearanceHeight"]: |
| | self.setFields(obj) |
| |
|
| |
|
| | class TaskPanelDepthsPage(TaskPanelPage): |
| | """Page controller for depths.""" |
| |
|
| | def __init__(self, obj, features): |
| | super(TaskPanelDepthsPage, self).__init__(obj, features) |
| |
|
| | |
| | self.startDepth = None |
| | self.finalDepth = None |
| | self.finishDepth = None |
| | self.stepDown = None |
| | self.panelTitle = "Depths" |
| | self.OpIcon = ":/icons/CAM_Depths.svg" |
| | self.setIcon(self.OpIcon) |
| |
|
| | def getForm(self): |
| | return FreeCADGui.PySideUic.loadUi(":/panels/PageDepthsEdit.ui") |
| |
|
| | def haveStartDepth(self): |
| | return PathOp.FeatureDepths & self.features |
| |
|
| | def haveFinalDepth(self): |
| | return ( |
| | PathOp.FeatureDepths & self.features and not PathOp.FeatureNoFinalDepth & self.features |
| | ) |
| |
|
| | def haveFinishDepth(self): |
| | return PathOp.FeatureDepths & self.features and PathOp.FeatureFinishDepth & self.features |
| |
|
| | def haveStepDown(self): |
| | return PathOp.FeatureStepDown & self.features |
| |
|
| | def initPage(self, obj): |
| |
|
| | if self.haveStartDepth(): |
| | self.startDepth = PathGuiUtil.QuantitySpinBox(self.form.startDepth, obj, "StartDepth") |
| | else: |
| | self.form.startDepth.hide() |
| | self.form.startDepthLabel.hide() |
| | self.form.startDepthSet.hide() |
| |
|
| | if self.haveFinalDepth(): |
| | self.finalDepth = PathGuiUtil.QuantitySpinBox(self.form.finalDepth, obj, "FinalDepth") |
| | else: |
| | if self.haveStartDepth(): |
| | self.form.finalDepth.setEnabled(False) |
| | self.form.finalDepth.setToolTip( |
| | translate( |
| | "PathOp", |
| | "FinalDepth cannot be modified for this operation.\nIf it is necessary to set the FinalDepth manually please select a different operation.", |
| | ) |
| | ) |
| | else: |
| | self.form.finalDepth.hide() |
| | self.form.finalDepthLabel.hide() |
| | self.form.finalDepthSet.hide() |
| |
|
| | if self.haveStepDown(): |
| | self.stepDown = PathGuiUtil.QuantitySpinBox(self.form.stepDown, obj, "StepDown") |
| | else: |
| | self.form.stepDown.hide() |
| | self.form.stepDownLabel.hide() |
| |
|
| | if self.haveFinishDepth(): |
| | self.finishDepth = PathGuiUtil.QuantitySpinBox( |
| | self.form.finishDepth, obj, "FinishDepth" |
| | ) |
| | else: |
| | self.form.finishDepth.hide() |
| | self.form.finishDepthLabel.hide() |
| |
|
| | def getTitle(self, obj): |
| | return translate("PathOp", "Depths") |
| |
|
| | def getFields(self, obj): |
| | if self.haveStartDepth(): |
| | self.startDepth.updateProperty() |
| | if self.haveFinalDepth(): |
| | self.finalDepth.updateProperty() |
| | if self.haveStepDown(): |
| | self.stepDown.updateProperty() |
| | if self.haveFinishDepth(): |
| | self.finishDepth.updateProperty() |
| |
|
| | def setFields(self, obj): |
| | if self.haveStartDepth(): |
| | self.startDepth.updateWidget() |
| | if self.haveFinalDepth(): |
| | self.finalDepth.updateWidget() |
| | if self.haveStepDown(): |
| | self.stepDown.updateWidget() |
| | if self.haveFinishDepth(): |
| | self.finishDepth.updateWidget() |
| | self.updateSelection(obj, FreeCADGui.Selection.getSelectionEx()) |
| |
|
| | def getSignalsForUpdate(self, obj): |
| | signals = [] |
| | if self.haveStartDepth(): |
| | signals.append(self.form.startDepth.editingFinished) |
| | if self.haveFinalDepth(): |
| | signals.append(self.form.finalDepth.editingFinished) |
| | if self.haveStepDown(): |
| | signals.append(self.form.stepDown.editingFinished) |
| | if self.haveFinishDepth(): |
| | signals.append(self.form.finishDepth.editingFinished) |
| | return signals |
| |
|
| | def registerSignalHandlers(self, obj): |
| | if self.haveStartDepth(): |
| | self.form.startDepthSet.clicked.connect( |
| | lambda: self.depthSet(obj, self.startDepth, "StartDepth") |
| | ) |
| | if self.haveFinalDepth(): |
| | self.form.finalDepthSet.clicked.connect( |
| | lambda: self.depthSet(obj, self.finalDepth, "FinalDepth") |
| | ) |
| |
|
| | def pageUpdateData(self, obj, prop): |
| | if prop in ["StartDepth", "FinalDepth", "StepDown", "FinishDepth"]: |
| | self.setFields(obj) |
| |
|
| | def depthSet(self, obj, spinbox, prop): |
| | z = self.selectionZLevel(FreeCADGui.Selection.getSelectionEx()) |
| | if z is not None: |
| | Path.Log.debug("depthSet(%s, %s, %.2f)" % (obj.Label, prop, z)) |
| | if spinbox.expression(): |
| | obj.setExpression(prop, None) |
| | self.setDirty() |
| | spinbox.updateWidget(FreeCAD.Units.Quantity(z, FreeCAD.Units.Length)) |
| | if spinbox.updateProperty(): |
| | self.setDirty() |
| | else: |
| | Path.Log.info("depthSet(-)") |
| |
|
| | def selectionZLevel(self, sel): |
| | if len(sel) == 1 and len(sel[0].SubObjects) == 1: |
| | sub = sel[0].SubObjects[0] |
| | if "Vertex" == sub.ShapeType: |
| | return sub.Z |
| | if Path.Geom.isHorizontal(sub): |
| | if "Edge" == sub.ShapeType: |
| | return sub.Vertexes[0].Z |
| | if "Face" == sub.ShapeType: |
| | return sub.BoundBox.ZMax |
| | return None |
| |
|
| | def updateSelection(self, obj, sel): |
| | if self.selectionZLevel(sel) is not None: |
| | self.form.startDepthSet.setEnabled(True) |
| | self.form.finalDepthSet.setEnabled(True) |
| | else: |
| | self.form.startDepthSet.setEnabled(False) |
| | self.form.finalDepthSet.setEnabled(False) |
| |
|
| |
|
| | class TaskPanelDiametersPage(TaskPanelPage): |
| | """Page controller for diameters.""" |
| |
|
| | def __init__(self, obj, features): |
| | super(TaskPanelDiametersPage, self).__init__(obj, features) |
| |
|
| | |
| | self.clearanceHeight = None |
| | self.safeHeight = None |
| |
|
| | def getForm(self): |
| | return FreeCADGui.PySideUic.loadUi(":/panels/PageDiametersEdit.ui") |
| |
|
| | def initPage(self, obj): |
| | self.minDiameter = PathGuiUtil.QuantitySpinBox(self.form.minDiameter, obj, "MinDiameter") |
| | self.maxDiameter = PathGuiUtil.QuantitySpinBox(self.form.maxDiameter, obj, "MaxDiameter") |
| |
|
| | def getTitle(self, obj): |
| | return translate("PathOp", "Diameters") |
| |
|
| | def getFields(self, obj): |
| | self.minDiameter.updateProperty() |
| | self.maxDiameter.updateProperty() |
| |
|
| | def setFields(self, obj): |
| | self.minDiameter.updateWidget() |
| | self.maxDiameter.updateWidget() |
| |
|
| | def getSignalsForUpdate(self, obj): |
| | signals = [] |
| | signals.append(self.form.minDiameter.editingFinished) |
| | signals.append(self.form.maxDiameter.editingFinished) |
| | return signals |
| |
|
| | def pageUpdateData(self, obj, prop): |
| | if prop in ["MinDiameter", "MaxDiameter"]: |
| | self.setFields(obj) |
| |
|
| |
|
| | class TaskPanel(object): |
| | """ |
| | Generic TaskPanel implementation handling the standard Path operation layout. |
| | This class only implements the framework and takes care of bringing all pages up and down in a controller fashion. |
| | It implements the standard editor behaviour for OK, Cancel and Apply and tracks if the model is still in sync with |
| | the UI. |
| | However, all display and processing of fields is handled by the page controllers which are managed in a list. All |
| | event callbacks and framework actions are forwarded to the page controllers in turn and each page controller is |
| | expected to process all events concerning the data it manages. |
| | """ |
| |
|
| | def __init__(self, obj, deleteOnReject, opPage, selectionFactory): |
| | Path.Log.track(obj.Label, deleteOnReject, opPage, selectionFactory) |
| | FreeCAD.ActiveDocument.openTransaction(translate("PathOp", "AreaOp Operation")) |
| | self.obj = obj |
| | self.deleteOnReject = deleteOnReject |
| | self.featurePages = [] |
| | self.parent = None |
| |
|
| | |
| | self.clearanceHeight = None |
| | self.safeHeight = None |
| | self.startDepth = None |
| | self.finishDepth = None |
| | self.finalDepth = None |
| | self.stepDown = None |
| | self.buttonBox = None |
| | self.minDiameter = None |
| | self.maxDiameter = None |
| |
|
| | features = obj.Proxy.opFeatures(obj) |
| | opPage.features = features |
| |
|
| | if PathOp.FeatureBaseGeometry & features: |
| | if hasattr(opPage, "taskPanelBaseGeometryPage"): |
| | self.featurePages.append(opPage.taskPanelBaseGeometryPage(obj, features)) |
| | else: |
| | self.featurePages.append(TaskPanelBaseGeometryPage(obj, features)) |
| |
|
| | if PathOp.FeatureLocations & features: |
| | if hasattr(opPage, "taskPanelBaseLocationPage"): |
| | self.featurePages.append(opPage.taskPanelBaseLocationPage(obj, features)) |
| | else: |
| | self.featurePages.append(TaskPanelBaseLocationPage(obj, features)) |
| |
|
| | if PathOp.FeatureDepths & features or PathOp.FeatureStepDown & features: |
| | if hasattr(opPage, "taskPanelDepthsPage"): |
| | self.featurePages.append(opPage.taskPanelDepthsPage(obj, features)) |
| | else: |
| | self.featurePages.append(TaskPanelDepthsPage(obj, features)) |
| |
|
| | if PathOp.FeatureHeights & features: |
| | if hasattr(opPage, "taskPanelHeightsPage"): |
| | self.featurePages.append(opPage.taskPanelHeightsPage(obj, features)) |
| | else: |
| | self.featurePages.append(TaskPanelHeightsPage(obj, features)) |
| |
|
| | if PathOp.FeatureDiameters & features: |
| | if hasattr(opPage, "taskPanelDiametersPage"): |
| | self.featurePages.append(opPage.taskPanelDiametersPage(obj, features)) |
| | else: |
| | self.featurePages.append(TaskPanelDiametersPage(obj, features)) |
| |
|
| | self.featurePages.append(opPage) |
| |
|
| | for page in self.featurePages: |
| | page.parent = self |
| | page.initPage(obj) |
| | page.onDirtyChanged(self.pageDirtyChanged) |
| |
|
| | taskPanelLayout = Path.Preferences.defaultTaskPanelLayout() |
| |
|
| | if taskPanelLayout < 2: |
| | opTitle = opPage.getTitle(obj) |
| | opPage.setTitle(translate("PathOp", "Operation")) |
| | toolbox = QtGui.QToolBox() |
| | if taskPanelLayout == 0: |
| | for page in self.featurePages: |
| | toolbox.addItem(page.form, page.getTitle(obj)) |
| | itemIdx = toolbox.count() - 1 |
| | if page.icon: |
| | toolbox.setItemIcon(itemIdx, QtGui.QIcon(page.icon)) |
| | toolbox.setCurrentIndex(len(self.featurePages) - 1) |
| | else: |
| | for page in reversed(self.featurePages): |
| | toolbox.addItem(page.form, page.getTitle(obj)) |
| | itemIdx = toolbox.count() - 1 |
| | if page.icon: |
| | toolbox.setItemIcon(itemIdx, QtGui.QIcon(page.icon)) |
| | toolbox.setWindowTitle(opTitle) |
| | if opPage.getIcon(obj): |
| | toolbox.setWindowIcon(QtGui.QIcon(opPage.getIcon(obj))) |
| |
|
| | self.form = toolbox |
| | elif taskPanelLayout == 2: |
| | forms = [] |
| | for page in self.featurePages: |
| | page.form.setWindowTitle(page.getTitle(obj)) |
| | forms.append(page.form) |
| | self.form = forms |
| | elif taskPanelLayout == 3: |
| | forms = [] |
| | for page in reversed(self.featurePages): |
| | page.form.setWindowTitle(page.getTitle(obj)) |
| | forms.append(page.form) |
| | self.form = forms |
| |
|
| | self.selectionFactory = selectionFactory |
| | self.obj = obj |
| | self.isdirty = deleteOnReject |
| | self.visibility = obj.ViewObject.Visibility |
| | obj.ViewObject.Visibility = True |
| |
|
| | def isDirty(self): |
| | """isDirty() ... returns true if the model is not in sync with the UI anymore.""" |
| | for page in self.featurePages: |
| | if page.isdirty: |
| | return True |
| | return self.isdirty |
| |
|
| | def setClean(self): |
| | """setClean() ... set the receiver and all its pages clean.""" |
| | self.isdirty = False |
| | for page in self.featurePages: |
| | page.setClean() |
| |
|
| | def accept(self, resetEdit=True): |
| | """accept() ... callback invoked when user presses the task panel OK button.""" |
| | self.preCleanup() |
| | if self.isDirty(): |
| | self.panelGetFields() |
| | FreeCAD.ActiveDocument.commitTransaction() |
| | self.cleanup(resetEdit) |
| |
|
| | def reject(self, resetEdit=True): |
| | """reject() ... callback invoked when user presses the task panel Cancel button.""" |
| | self.preCleanup() |
| | FreeCAD.ActiveDocument.abortTransaction() |
| | if self.deleteOnReject: |
| | FreeCAD.ActiveDocument.openTransaction(translate("PathOp", "Uncreate AreaOp Operation")) |
| | try: |
| | PathUtil.clearExpressionEngine(self.obj) |
| | FreeCAD.ActiveDocument.removeObject(self.obj.Name) |
| | except Exception as ee: |
| | Path.Log.debug("{}\n".format(ee)) |
| | FreeCAD.ActiveDocument.commitTransaction() |
| | self.cleanup(resetEdit) |
| | return True |
| |
|
| | def preCleanup(self): |
| | for page in self.featurePages: |
| | page.onDirtyChanged(None) |
| | PathSelection.clear() |
| | FreeCADGui.Selection.removeObserver(self) |
| | self.obj.ViewObject.Proxy.clearTaskPanel() |
| | self.obj.ViewObject.Visibility = self.visibility |
| |
|
| | def cleanup(self, resetEdit): |
| | """cleanup() ... implements common cleanup tasks.""" |
| | self.panelCleanup() |
| | FreeCADGui.Control.closeDialog() |
| | if resetEdit: |
| | FreeCADGui.ActiveDocument.resetEdit() |
| | FreeCAD.ActiveDocument.recompute() |
| |
|
| | def pageDirtyChanged(self, page): |
| | """pageDirtyChanged(page) ... internal callback""" |
| | self.buttonBox.button(QtGui.QDialogButtonBox.Apply).setEnabled(self.isDirty()) |
| |
|
| | def clicked(self, button): |
| | """clicked(button) ... callback invoked when the user presses any of the task panel buttons.""" |
| | if button == QtGui.QDialogButtonBox.Apply: |
| | self.panelGetFields() |
| | self.setClean() |
| | FreeCAD.ActiveDocument.recompute() |
| |
|
| | def modifyStandardButtons(self, buttonBox): |
| | """modifyStandarButtons(buttonBox) ... callback in case the task panel buttons need to be modified.""" |
| | self.buttonBox = buttonBox |
| | for page in self.featurePages: |
| | page.modifyStandardButtons(buttonBox) |
| | self.pageDirtyChanged(None) |
| |
|
| | def panelGetFields(self): |
| | """panelGetFields() ... invoked to trigger a complete transfer of UI data to the model.""" |
| | Path.Log.track() |
| | for page in self.featurePages: |
| | page.pageGetFields() |
| |
|
| | def panelSetFields(self): |
| | """panelSetFields() ... invoked to trigger a complete transfer of the model's properties to the UI.""" |
| | Path.Log.track() |
| | self.obj.Proxy.sanitizeBase(self.obj) |
| | for page in self.featurePages: |
| | page.pageSetFields() |
| |
|
| | def panelCleanup(self): |
| | """panelCleanup() ... invoked before the receiver is destroyed.""" |
| | Path.Log.track() |
| | for page in self.featurePages: |
| | page.pageCleanup() |
| |
|
| | def open(self): |
| | """open() ... callback invoked when the task panel is opened.""" |
| | self.selectionFactory() |
| | FreeCADGui.Selection.addObserver(self) |
| |
|
| | def getStandardButtons(self): |
| | """getStandardButtons() ... returns the Buttons for the task panel.""" |
| | return ( |
| | QtGui.QDialogButtonBox.Ok | QtGui.QDialogButtonBox.Apply | QtGui.QDialogButtonBox.Cancel |
| | ) |
| |
|
| | def setupUi(self): |
| | """setupUi() ... internal function to initialise all pages.""" |
| | Path.Log.track(self.deleteOnReject) |
| |
|
| | if self.deleteOnReject and PathOp.FeatureBaseGeometry & self.obj.Proxy.opFeatures(self.obj): |
| | sel = FreeCADGui.Selection.getSelectionEx() |
| | for page in self.featurePages: |
| | if getattr(page, "InitBase", True) and hasattr(page, "addBase"): |
| | page.clearBase() |
| | page.addBaseGeometry(sel) |
| |
|
| | |
| | for prp, expr in self.obj.ExpressionEngine: |
| | evalExpr = self.obj.evalExpression(expr) |
| | if not isinstance(evalExpr, (int, float, FreeCAD.Units.Quantity)): |
| | continue |
| | val = FreeCAD.Units.Quantity(evalExpr) |
| | value = val.Value if hasattr(val, "Value") else val |
| | prop = getattr(self.obj, prp) |
| | if hasattr(prop, "Value"): |
| | prop.Value = value |
| | else: |
| | prop = value |
| |
|
| | self.panelSetFields() |
| |
|
| | for page in self.featurePages: |
| | page.pageRegisterSignalHandlers() |
| |
|
| | def updateData(self, obj, prop): |
| | """updateDate(obj, prop) ... callback invoked whenever a model's property is assigned a value.""" |
| | |
| | for page in self.featurePages: |
| | page.pageUpdateData(obj, prop) |
| |
|
| | def needsFullSpace(self): |
| | return True |
| |
|
| | def updateSelection(self): |
| | sel = FreeCADGui.Selection.getSelectionEx() |
| | for page in self.featurePages: |
| | page.updateSelection(self.obj, sel) |
| |
|
| | |
| | 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() |
| |
|
| |
|
| | class CommandSetStartPoint: |
| | """Command to set the start point for an operation.""" |
| |
|
| | def GetResources(self): |
| | return { |
| | "Pixmap": "CAM_StartPoint", |
| | "MenuText": QT_TRANSLATE_NOOP("PathOp", "Start Point Selection"), |
| | "ToolTip": QT_TRANSLATE_NOOP("PathOp", "Selects the start point"), |
| | } |
| |
|
| | def IsActive(self): |
| | if FreeCAD.ActiveDocument is None: |
| | return False |
| | sel = FreeCADGui.Selection.getSelection() |
| | if not sel: |
| | return False |
| | obj = sel[0] |
| | return obj and hasattr(obj, "StartPoint") |
| |
|
| | def setpoint(self, point, o): |
| | FreeCADGui.Snapper.grid.off() |
| | obj = self.obj |
| | obj.StartPoint.x = point.x |
| | obj.StartPoint.y = point.y |
| | obj.StartPoint.z = obj.ClearanceHeight.Value |
| | obj.UseStartPoint = True |
| | obj.recompute() |
| | textPoint = f"{obj.StartPoint.x:.2f}, {obj.StartPoint.y:.2f}, {obj.StartPoint.z:.2f}" |
| | print(f"Set start point for operation {obj.Label} >>> {textPoint}") |
| |
|
| | def Activated(self): |
| | self.obj = FreeCADGui.Selection.getSelection()[0] |
| | if not hasattr(FreeCADGui, "Snapper"): |
| | import DraftTools |
| | FreeCADGui.Snapper.getPoint(callback=self.setpoint) |
| |
|
| |
|
| | def Create(res): |
| | """Create(res) ... generic implementation of a create function. |
| | res is an instance of CommandResources. It is not expected that the user invokes |
| | this function directly, but calls the Activated() function of the Command object |
| | that is created in each operations Gui implementation.""" |
| | FreeCAD.ActiveDocument.openTransaction("Create %s" % res.name) |
| | if res.job is None: |
| | FreeCAD.ActiveDocument.abortTransaction() |
| | raise ValueError("No job selected. Operation creation aborted.") |
| | try: |
| | obj = res.objFactory(res.name, obj=None, parentJob=res.job) |
| | if obj.Proxy: |
| | obj.ViewObject.Proxy = ViewProvider(obj.ViewObject, res) |
| | obj.ViewObject.Visibility = True |
| | FreeCAD.ActiveDocument.commitTransaction() |
| |
|
| | obj.ViewObject.Document.setEdit(obj.ViewObject, 0) |
| | return obj |
| | except PathUtils.PathNoTCExistsException: |
| | msg = translate("PathOp", "No suitable tool controller found.\nAborting op creation") |
| | diag = QtGui.QMessageBox(QtGui.QMessageBox.Warning, "Error", msg) |
| | diag.setWindowModality(QtCore.Qt.ApplicationModal) |
| | diag.exec_() |
| | except PathOp.PathNoTCException: |
| | Path.Log.warning(translate("PathOp", "No tool controller, aborting op creation")) |
| |
|
| | FreeCAD.ActiveDocument.abortTransaction() |
| | FreeCAD.ActiveDocument.recompute() |
| | return None |
| |
|
| |
|
| | class CommandPathOp: |
| | """Generic, data driven implementation of a Path operation creation command. |
| | Instances of this class are stored in all Path operation Gui modules and can |
| | be used to create said operations with view providers and all.""" |
| |
|
| | def __init__(self, resources): |
| | self.res = resources |
| |
|
| | def GetResources(self): |
| | ress = { |
| | "Pixmap": self.res.pixmap, |
| | "MenuText": self.res.menuText, |
| | "ToolTip": self.res.toolTip, |
| | } |
| | if self.res.accelKey: |
| | ress["Accel"] = self.res.accelKey |
| | return ress |
| |
|
| | def IsActive(self): |
| | if FreeCAD.ActiveDocument is not None: |
| | for o in FreeCAD.ActiveDocument.Objects: |
| | if o.Name[:3] == "Job": |
| | return True |
| | return False |
| |
|
| | def Activated(self): |
| | jobs = PathUtils.GetJobs() |
| | if not jobs: |
| | return |
| | job = PathUtils.UserInput.chooseJob(jobs) |
| | if job is None: |
| | return |
| | self.res.job = job |
| | return Create(self.res) |
| |
|
| | def setJob(self, job): |
| | self.res.job = job |
| | return Create(self.res) |
| |
|
| |
|
| | class CommandResources: |
| | """POD class to hold command specific resources.""" |
| |
|
| | def __init__(self, name, objFactory, opPageClass, pixmap, menuText, accelKey, toolTip): |
| | self.name = name |
| | self.objFactory = objFactory |
| | self.opPageClass = opPageClass |
| | self.pixmap = pixmap |
| | self.menuText = menuText |
| | self.accelKey = accelKey |
| | self.toolTip = toolTip |
| | self.job = None |
| |
|
| |
|
| | def SetupOperation(name, objFactory, opPageClass, pixmap, menuText, toolTip, setupProperties=None): |
| | """SetupOperation(name, objFactory, opPageClass, pixmap, menuText, toolTip, setupProperties=None) |
| | Creates an instance of CommandPathOp with the given parameters and registers the command with FreeCAD. |
| | When activated it creates a model with proxy (by invoking objFactory), assigns a view provider to it |
| | (see ViewProvider in this module) and starts the editor specifically for this operation (driven by opPageClass). |
| | This is an internal function that is automatically called by the initialisation code for each operation. |
| | It is not expected to be called manually. |
| | """ |
| |
|
| | res = CommandResources(name, objFactory, opPageClass, pixmap, menuText, None, toolTip) |
| |
|
| | command = CommandPathOp(res) |
| | FreeCADGui.addCommand("CAM_%s" % name.replace(" ", "_"), command) |
| |
|
| | if setupProperties is not None: |
| | PathSetupSheet.RegisterOperation(name, objFactory, setupProperties) |
| |
|
| | return command |
| |
|
| |
|
| | FreeCADGui.addCommand("CAM_SetStartPoint", CommandSetStartPoint()) |
| |
|
| | FreeCAD.Console.PrintLog("Loading PathOpGui… done\n") |
| |
|
