03c5661690
Moved the translation method from PathFeatureExtensionsGui module to proper location within QuantitySpinBox class in PathGui module. This change adds a missing translation method for passing the `editingFinished` signal to the parent task panel when the user is finished editing a QuantitySpinBox object with an active expression in the Gui. If no expression is active, this new method is dormant. Some cleanup of initial changes related to development of this fix are included.
746 lines
29 KiB
Python
746 lines
29 KiB
Python
# -*- coding: utf-8 -*-
|
|
# ***************************************************************************
|
|
# * Copyright (c) 2019 sliptonic <shopinthewoods@gmail.com> *
|
|
# * *
|
|
# * 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 pivy import coin
|
|
import FreeCAD
|
|
import FreeCADGui
|
|
import PathScripts.PathFeatureExtensions as FeatureExtensions
|
|
import PathScripts.PathGeom as PathGeom
|
|
import PathScripts.PathGui as PathGui
|
|
import PathScripts.PathLog as PathLog
|
|
import PathScripts.PathOpGui as PathOpGui
|
|
|
|
# lazily loaded modules
|
|
from lazy_loader.lazy_loader import LazyLoader
|
|
|
|
Part = LazyLoader("Part", globals(), "Part")
|
|
|
|
__title__ = "Path Feature Extensions UI"
|
|
__author__ = "sliptonic (Brad Collette)"
|
|
__url__ = "https://www.freecadweb.org"
|
|
__doc__ = "Extensions feature page controller."
|
|
|
|
|
|
translate = FreeCAD.Qt.translate
|
|
|
|
if False:
|
|
PathLog.setLevel(PathLog.Level.DEBUG, PathLog.thisModule())
|
|
PathLog.trackModule(PathLog.thisModule())
|
|
else:
|
|
PathLog.setLevel(PathLog.Level.INFO, PathLog.thisModule())
|
|
|
|
|
|
class _Extension(object):
|
|
ColourEnabled = (1.0, 0.5, 1.0)
|
|
ColourDisabled = (1.0, 1.0, 0.5)
|
|
TransparencySelected = 0.0
|
|
TransparencyDeselected = 0.7
|
|
|
|
def __init__(self, obj, base, face, edge):
|
|
self.obj = obj
|
|
self.base = base
|
|
self.face = face
|
|
self.edge = edge
|
|
self.ext = None
|
|
|
|
if edge:
|
|
self.ext = FeatureExtensions.createExtension(obj, base, face, edge)
|
|
|
|
self.switch = self.createExtensionSoSwitch(self.ext)
|
|
self.root = self.switch
|
|
|
|
def createExtensionSoSwitch(self, ext):
|
|
if not ext:
|
|
return None
|
|
|
|
sep = coin.SoSeparator()
|
|
pos = coin.SoTranslation()
|
|
mat = coin.SoMaterial()
|
|
crd = coin.SoCoordinate3()
|
|
fce = coin.SoFaceSet()
|
|
hnt = coin.SoShapeHints()
|
|
numVert = list() # track number of vertices in each polygon face
|
|
|
|
try:
|
|
wire = ext.getWire()
|
|
except FreeCAD.Base.FreeCADError:
|
|
wire = None
|
|
|
|
if not wire:
|
|
return None
|
|
|
|
if isinstance(wire, (list, tuple)):
|
|
p0 = [p for p in wire[0].discretize(Deflection=0.02)]
|
|
p1 = [p for p in wire[1].discretize(Deflection=0.02)]
|
|
p2 = list(reversed(p1))
|
|
polygon = [(p.x, p.y, p.z) for p in (p0 + p2)]
|
|
else:
|
|
if ext.extFaces:
|
|
# Create polygon for each extension face in compound extensions
|
|
allPolys = list()
|
|
extFaces = ext.getExtensionFaces(wire)
|
|
for f in extFaces:
|
|
pCnt = 0
|
|
wCnt = 0
|
|
for w in f.Wires:
|
|
if wCnt == 0:
|
|
poly = [p for p in w.discretize(Deflection=0.01)]
|
|
else:
|
|
poly = [p for p in w.discretize(Deflection=0.01)][:-1]
|
|
pCnt += len(poly)
|
|
allPolys.extend(poly)
|
|
numVert.append(pCnt)
|
|
polygon = [(p.x, p.y, p.z) for p in allPolys]
|
|
else:
|
|
# poly = [p for p in wire.discretize(Deflection=0.02)][:-1]
|
|
poly = [p for p in wire.discretize(Deflection=0.02)]
|
|
polygon = [(p.x, p.y, p.z) for p in poly]
|
|
crd.point.setValues(polygon)
|
|
|
|
mat.diffuseColor = self.ColourDisabled
|
|
mat.transparency = self.TransparencyDeselected
|
|
|
|
hnt.faceType = coin.SoShapeHints.UNKNOWN_FACE_TYPE
|
|
hnt.vertexOrdering = coin.SoShapeHints.CLOCKWISE
|
|
|
|
if numVert:
|
|
# Transfer vertex counts for polygon faces
|
|
fce.numVertices.setValues(tuple(numVert))
|
|
|
|
sep.addChild(pos)
|
|
sep.addChild(mat)
|
|
sep.addChild(hnt)
|
|
sep.addChild(crd)
|
|
sep.addChild(fce)
|
|
|
|
# Finalize SoSwitch
|
|
switch = coin.SoSwitch()
|
|
switch.addChild(sep)
|
|
switch.whichChild = coin.SO_SWITCH_NONE
|
|
|
|
self.material = mat
|
|
|
|
return switch
|
|
|
|
def _setColour(self, r, g, b):
|
|
self.material.diffuseColor = (r, g, b)
|
|
|
|
def isValid(self):
|
|
return not self.root is None
|
|
|
|
def show(self):
|
|
if self.switch:
|
|
self.switch.whichChild = coin.SO_SWITCH_ALL
|
|
|
|
def hide(self):
|
|
if self.switch:
|
|
self.switch.whichChild = coin.SO_SWITCH_NONE
|
|
|
|
def enable(self, ena=True):
|
|
if ena:
|
|
self.material.diffuseColor = self.ColourEnabled
|
|
else:
|
|
self.disable()
|
|
|
|
def disable(self):
|
|
self.material.diffuseColor = self.ColourDisabled
|
|
|
|
def select(self):
|
|
self.material.transparency = self.TransparencySelected
|
|
|
|
def deselect(self):
|
|
self.material.transparency = self.TransparencyDeselected
|
|
|
|
|
|
class TaskPanelExtensionPage(PathOpGui.TaskPanelPage):
|
|
DataObject = QtCore.Qt.ItemDataRole.UserRole
|
|
DataSwitch = QtCore.Qt.ItemDataRole.UserRole + 2
|
|
|
|
Direction = {
|
|
FeatureExtensions.Extension.DirectionNormal: translate("PathPocket", "Normal"),
|
|
FeatureExtensions.Extension.DirectionX: translate("PathPocket", "X"),
|
|
FeatureExtensions.Extension.DirectionY: translate("PathPocket", "Y"),
|
|
}
|
|
|
|
def initPage(self, obj):
|
|
self.setTitle("Extensions")
|
|
self.OpIcon = ":/icons/view-axonometric.svg"
|
|
self.setIcon(self.OpIcon)
|
|
self.initialEdgeCount = -1
|
|
self.edgeCountThreshold = 30
|
|
self.fieldsSet = False
|
|
self.useOutlineCheckbox = None
|
|
self.useOutline = -1
|
|
self.extensionsCache = dict()
|
|
self.extensionsReady = False
|
|
self.enabled = True
|
|
self.lastDefaultLength = ""
|
|
|
|
self.extensions = list()
|
|
|
|
self.defaultLength = PathGui.QuantitySpinBox(
|
|
self.form.defaultLength, obj, "ExtensionLengthDefault"
|
|
)
|
|
|
|
self.form.extensionTree.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
|
|
self.form.extensionTree.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
|
|
|
|
self.switch = coin.SoSwitch()
|
|
self.obj.ViewObject.RootNode.addChild(self.switch)
|
|
self.switch.whichChild = coin.SO_SWITCH_ALL
|
|
|
|
self.model = QtGui.QStandardItemModel(self.form.extensionTree)
|
|
self.model.setHorizontalHeaderLabels(["Base", "Extension"])
|
|
|
|
"""
|
|
# russ4262: This `if` block shows all available extensions upon edit of operation with any extension enabled.
|
|
# This can cause the model(s) to overly obscured due to previews of extensions.
|
|
# Would be great if only enabled extensions were shown.
|
|
if 0 < len(obj.ExtensionFeature):
|
|
self.form.showExtensions.setCheckState(QtCore.Qt.Checked)
|
|
else:
|
|
self.form.showExtensions.setCheckState(QtCore.Qt.Unchecked)
|
|
"""
|
|
self.form.showExtensions.setCheckState(QtCore.Qt.Unchecked)
|
|
|
|
self.blockUpdateData = False
|
|
|
|
def cleanupPage(self, obj):
|
|
try:
|
|
self.obj.ViewObject.RootNode.removeChild(self.switch)
|
|
except ReferenceError:
|
|
PathLog.debug("obj already destroyed - no cleanup required")
|
|
|
|
def getForm(self):
|
|
form = FreeCADGui.PySideUic.loadUi(":/panels/PageOpPocketExtEdit.ui")
|
|
return form
|
|
|
|
def forAllItemsCall(self, cb):
|
|
for modelRow in range(self.model.rowCount()):
|
|
model = self.model.item(modelRow, 0)
|
|
for featureRow in range(model.rowCount()):
|
|
feature = model.child(featureRow, 0)
|
|
for edgeRow in range(feature.rowCount()):
|
|
item = feature.child(edgeRow, 0)
|
|
ext = item.data(self.DataObject)
|
|
cb(item, ext)
|
|
|
|
def currentExtensions(self):
|
|
PathLog.debug("currentExtensions()")
|
|
extensions = []
|
|
|
|
def extractExtension(item, ext):
|
|
if ext and ext.edge and item.checkState() == QtCore.Qt.Checked:
|
|
extensions.append(ext.ext)
|
|
|
|
if self.form.enableExtensions.isChecked():
|
|
self.forAllItemsCall(extractExtension)
|
|
PathLog.track("extensions", extensions)
|
|
return extensions
|
|
|
|
def updateProxyExtensions(self, obj):
|
|
PathLog.debug("updateProxyExtensions()")
|
|
self.extensions = self.currentExtensions()
|
|
FeatureExtensions.setExtensions(obj, self.extensions)
|
|
|
|
def getFields(self, obj):
|
|
PathLog.track(obj.Label, self.model.rowCount(), self.model.columnCount())
|
|
self.blockUpdateData = True
|
|
|
|
if obj.ExtensionCorners != self.form.extendCorners.isChecked():
|
|
obj.ExtensionCorners = self.form.extendCorners.isChecked()
|
|
self.defaultLength.updateProperty()
|
|
|
|
self.updateProxyExtensions(obj)
|
|
self.blockUpdateData = False
|
|
|
|
def setFields(self, obj):
|
|
PathLog.track(obj.Label)
|
|
# PathLog.debug("setFields()")
|
|
|
|
if obj.ExtensionCorners != self.form.extendCorners.isChecked():
|
|
self.form.extendCorners.toggle()
|
|
|
|
self._autoEnableExtensions() # Check edge count for auto-disable Extensions on initial Task Panel loading
|
|
self._initializeExtensions(obj) # Efficiently initialize Extensions
|
|
self.defaultLength.updateSpinBox()
|
|
self._getUseOutlineState() # Find `useOutline` checkbox and get its boolean value
|
|
self.lastDefaultLength = self.form.defaultLength.text() # set last DL value
|
|
self.fieldsSet = True # flag to identify initial values set
|
|
|
|
def _initializeExtensions(self, obj):
|
|
"""_initializeExtensions()...
|
|
Subroutine called inside `setFields()` to initialize Extensions efficiently."""
|
|
if self.enabled:
|
|
self.extensions = FeatureExtensions.getExtensions(obj)
|
|
elif len(obj.ExtensionFeature) > 0:
|
|
self.extensions = FeatureExtensions.getExtensions(obj)
|
|
self.form.enableExtensions.setChecked(True)
|
|
self._includeEdgesAndWires()
|
|
else:
|
|
self.form.extensionEdit.setDisabled(True)
|
|
self.setExtensions(self.extensions)
|
|
|
|
def _applyDefaultLengthChange(self, index=None):
|
|
"""_applyDefaultLengthChange(index=None)...
|
|
Helper method to update Default Length spinbox,
|
|
and update extensions due to change in Default Length."""
|
|
self.defaultLength.updateSpinBox()
|
|
if self.form.defaultLength.text() != self.lastDefaultLength:
|
|
self.lastDefaultLength = self.form.defaultLength.text()
|
|
self._resetCachedExtensions() # Reset extension cache because extension dimensions likely changed
|
|
self._enableExtensions() # Recalculate extensions
|
|
|
|
def createItemForBaseModel(self, base, sub, edges, extensions):
|
|
PathLog.track(
|
|
base.Label, sub, "+", len(edges), len(base.Shape.getElement(sub).Edges)
|
|
)
|
|
# PathLog.debug("createItemForBaseModel() label: {}, sub: {}, {}, edgeCnt: {}, subEdges: {}".format(base.Label, sub, '+', len(edges), len(base.Shape.getElement(sub).Edges)))
|
|
|
|
extendCorners = self.form.extendCorners.isChecked()
|
|
subShape = base.Shape.getElement(sub)
|
|
|
|
def createSubItem(label, ext0):
|
|
if ext0.root:
|
|
self.switch.addChild(ext0.root)
|
|
item0 = QtGui.QStandardItem()
|
|
item0.setData(label, QtCore.Qt.EditRole)
|
|
item0.setData(ext0, self.DataObject)
|
|
item0.setCheckable(True)
|
|
for e in extensions:
|
|
if e.obj == base and e.sub == label:
|
|
item0.setCheckState(QtCore.Qt.Checked)
|
|
ext0.enable()
|
|
break
|
|
item.appendRow([item0])
|
|
|
|
# ext = self._cachedExtension(self.obj, base, sub, None)
|
|
ext = None
|
|
item = QtGui.QStandardItem()
|
|
item.setData(sub, QtCore.Qt.EditRole)
|
|
item.setData(ext, self.DataObject)
|
|
item.setSelectable(False)
|
|
|
|
extensionEdges = {}
|
|
if self.useOutline == 1 and sub.startswith("Face"):
|
|
# Only show exterior extensions if `Use Outline` is True
|
|
subEdges = subShape.Wires[0].Edges
|
|
else:
|
|
# Show all exterior and interior extensions if `Use Outline` is False
|
|
subEdges = subShape.Edges
|
|
|
|
for edge in subEdges:
|
|
for (e, label) in edges:
|
|
if edge.isSame(e):
|
|
ext1 = self._cachedExtension(self.obj, base, sub, label)
|
|
if ext1.isValid():
|
|
extensionEdges[e] = label[4:] # isolate edge number
|
|
if not extendCorners:
|
|
createSubItem(label, ext1)
|
|
|
|
if extendCorners:
|
|
|
|
def edgesMatchShape(e0, e1):
|
|
flipped = PathGeom.flipEdge(e1)
|
|
if flipped:
|
|
return PathGeom.edgesMatch(e0, e1) or PathGeom.edgesMatch(
|
|
e0, flipped
|
|
)
|
|
else:
|
|
return PathGeom.edgesMatch(e0, e1)
|
|
|
|
self.extensionEdges = extensionEdges
|
|
PathLog.debug("extensionEdges.values(): {}".format(extensionEdges.values()))
|
|
for edgeList in Part.sortEdges(
|
|
list(extensionEdges.keys())
|
|
): # Identify connected edges that form wires
|
|
self.edgeList = edgeList
|
|
if len(edgeList) == 1:
|
|
label = (
|
|
"Edge%s"
|
|
% [
|
|
extensionEdges[keyEdge]
|
|
for keyEdge in extensionEdges.keys()
|
|
if edgesMatchShape(keyEdge, edgeList[0])
|
|
][0]
|
|
)
|
|
else:
|
|
label = "Wire(%s)" % ",".join(
|
|
sorted(
|
|
[
|
|
extensionEdges[keyEdge]
|
|
for e in edgeList
|
|
for keyEdge in extensionEdges.keys()
|
|
if edgesMatchShape(e, keyEdge)
|
|
],
|
|
key=lambda s: int(s),
|
|
)
|
|
)
|
|
ext2 = self._cachedExtension(self.obj, base, sub, label)
|
|
createSubItem(label, ext2)
|
|
|
|
return item
|
|
|
|
def setExtensions(self, extensions):
|
|
PathLog.track(len(extensions))
|
|
PathLog.debug("setExtensions()")
|
|
|
|
if self.extensionsReady:
|
|
PathLog.debug("setExtensions() returning per `extensionsReady` flag")
|
|
return
|
|
|
|
self.form.extensionTree.blockSignals(True)
|
|
|
|
# remember current visual state
|
|
if hasattr(self, "selectionModel"):
|
|
selectedExtensions = [
|
|
self.model.itemFromIndex(index).data(self.DataObject).ext
|
|
for index in self.selectionModel.selectedIndexes()
|
|
]
|
|
else:
|
|
selectedExtensions = []
|
|
collapsedModels = []
|
|
collapsedFeatures = []
|
|
for modelRow in range(self.model.rowCount()):
|
|
model = self.model.item(modelRow, 0)
|
|
modelName = model.data(QtCore.Qt.EditRole)
|
|
if not self.form.extensionTree.isExpanded(model.index()):
|
|
collapsedModels.append(modelName)
|
|
for featureRow in range(model.rowCount()):
|
|
feature = model.child(featureRow, 0)
|
|
if not self.form.extensionTree.isExpanded(feature.index()):
|
|
collapsedFeatures.append(
|
|
"%s.%s" % (modelName, feature.data(QtCore.Qt.EditRole))
|
|
)
|
|
|
|
# remove current extensions and all their visuals
|
|
def removeItemSwitch(item, ext):
|
|
ext.hide()
|
|
if ext.root:
|
|
self.switch.removeChild(ext.root)
|
|
|
|
self.forAllItemsCall(removeItemSwitch)
|
|
self.model.clear()
|
|
|
|
# create extensions for model and given argument
|
|
if self.enabled:
|
|
for base in self.obj.Base:
|
|
show = False
|
|
edges = [
|
|
(edge, "Edge%d" % (i + 1))
|
|
for i, edge in enumerate(base[0].Shape.Edges)
|
|
]
|
|
baseItem = QtGui.QStandardItem()
|
|
baseItem.setData(base[0].Label, QtCore.Qt.EditRole)
|
|
baseItem.setSelectable(False)
|
|
for sub in sorted(base[1]):
|
|
if sub.startswith("Face"):
|
|
show = True
|
|
baseItem.appendRow(
|
|
self.createItemForBaseModel(base[0], sub, edges, extensions)
|
|
)
|
|
if show:
|
|
self.model.appendRow(baseItem)
|
|
|
|
self.form.extensionTree.setModel(self.model)
|
|
self.form.extensionTree.expandAll()
|
|
self.form.extensionTree.resizeColumnToContents(0)
|
|
|
|
# restore previous state - at least the parts that are still valid
|
|
for modelRow in range(self.model.rowCount()):
|
|
model = self.model.item(modelRow, 0)
|
|
modelName = model.data(QtCore.Qt.EditRole)
|
|
if modelName in collapsedModels:
|
|
self.form.extensionTree.setExpanded(model.index(), False)
|
|
for featureRow in range(model.rowCount()):
|
|
feature = model.child(featureRow, 0)
|
|
featureName = "%s.%s" % (modelName, feature.data(QtCore.Qt.EditRole))
|
|
if featureName in collapsedFeatures:
|
|
self.form.extensionTree.setExpanded(feature.index(), False)
|
|
if hasattr(self, "selectionModel") and selectedExtensions:
|
|
self.restoreSelection(selectedExtensions)
|
|
|
|
self.form.extensionTree.blockSignals(False)
|
|
self.extensionsReady = True
|
|
PathLog.debug(" setExtensions() finished and setting `extensionsReady=True`")
|
|
|
|
def updateData(self, obj, prop):
|
|
PathLog.track(obj.Label, prop, self.blockUpdateData)
|
|
# PathLog.debug("updateData({})".format(prop))
|
|
|
|
if not self.blockUpdateData:
|
|
if self.fieldsSet:
|
|
if self.form.enableExtensions.isChecked():
|
|
if prop == "ExtensionLengthDefault":
|
|
self._applyDefaultLengthChange()
|
|
elif prop == "Base":
|
|
self.extensionsReady = False
|
|
self.setExtensions(FeatureExtensions.getExtensions(obj))
|
|
elif prop == "UseOutline":
|
|
self._getUseOutlineState() # Find `useOutline` checkbox and get its boolean value
|
|
self._includeEdgesAndWires()
|
|
elif prop == "Base":
|
|
self.extensionsReady = False
|
|
|
|
def restoreSelection(self, selection):
|
|
PathLog.debug("restoreSelection()")
|
|
PathLog.track()
|
|
if 0 == self.model.rowCount():
|
|
PathLog.track("-")
|
|
self.form.buttonClear.setEnabled(False)
|
|
self.form.buttonDisable.setEnabled(False)
|
|
self.form.buttonEnable.setEnabled(False)
|
|
else:
|
|
self.form.buttonClear.setEnabled(True)
|
|
|
|
if selection or self.selectionModel.selectedIndexes():
|
|
self.form.buttonDisable.setEnabled(True)
|
|
self.form.buttonEnable.setEnabled(True)
|
|
else:
|
|
self.form.buttonDisable.setEnabled(False)
|
|
self.form.buttonEnable.setEnabled(False)
|
|
|
|
FreeCADGui.Selection.clearSelection()
|
|
|
|
def selectItem(item, ext):
|
|
for sel in selection:
|
|
if ext.base == sel.obj and ext.edge == sel.sub:
|
|
return True
|
|
return False
|
|
|
|
def setSelectionVisuals(item, ext):
|
|
if selectItem(item, ext):
|
|
self.selectionModel.select(
|
|
item.index(), QtCore.QItemSelectionModel.Select
|
|
)
|
|
|
|
selected = self.selectionModel.isSelected(item.index())
|
|
if selected:
|
|
FreeCADGui.Selection.addSelection(ext.base, ext.face)
|
|
ext.select()
|
|
else:
|
|
ext.deselect()
|
|
|
|
if self.form.showExtensions.isChecked() or selected:
|
|
ext.show()
|
|
else:
|
|
ext.hide()
|
|
|
|
self.forAllItemsCall(setSelectionVisuals)
|
|
|
|
def selectionChanged(self):
|
|
PathLog.debug("selectionChanged()")
|
|
self.restoreSelection([])
|
|
|
|
def extensionsClear(self):
|
|
PathLog.debug("extensionsClear()")
|
|
|
|
def disableItem(item, ext):
|
|
item.setCheckState(QtCore.Qt.Unchecked)
|
|
ext.disable()
|
|
|
|
self.forAllItemsCall(disableItem)
|
|
self.setDirty()
|
|
|
|
def _extensionsSetState(self, state):
|
|
PathLog.debug("_extensionsSetState()")
|
|
PathLog.track(state)
|
|
for index in self.selectionModel.selectedIndexes():
|
|
item = self.model.itemFromIndex(index)
|
|
ext = item.data(self.DataObject)
|
|
if ext.edge:
|
|
item.setCheckState(state)
|
|
ext.enable(state == QtCore.Qt.Checked)
|
|
self.setDirty()
|
|
|
|
def extensionsDisable(self):
|
|
self._extensionsSetState(QtCore.Qt.Unchecked)
|
|
|
|
def extensionsEnable(self):
|
|
self._extensionsSetState(QtCore.Qt.Checked)
|
|
|
|
def updateItemEnabled(self, item):
|
|
PathLog.track(item)
|
|
ext = item.data(self.DataObject)
|
|
if item.checkState() == QtCore.Qt.Checked:
|
|
ext.enable()
|
|
else:
|
|
ext.disable()
|
|
self.updateProxyExtensions(self.obj)
|
|
self.setDirty()
|
|
|
|
def showHideExtension(self):
|
|
if self.form.showExtensions.isChecked():
|
|
|
|
def enableExtensionEdit(item, ext):
|
|
ext.show()
|
|
|
|
self.forAllItemsCall(enableExtensionEdit)
|
|
else:
|
|
|
|
def disableExtensionEdit(item, ext):
|
|
if not self.selectionModel.isSelected(item.index()):
|
|
ext.hide()
|
|
|
|
self.forAllItemsCall(disableExtensionEdit)
|
|
# self.setDirty()
|
|
|
|
def toggleExtensionCorners(self):
|
|
PathLog.debug("toggleExtensionCorners()")
|
|
PathLog.track()
|
|
self.extensionsReady = False
|
|
extensions = FeatureExtensions.getExtensions(self.obj)
|
|
self.setExtensions(extensions)
|
|
self.selectionChanged()
|
|
self.setDirty()
|
|
|
|
def getSignalsForUpdate(self, obj):
|
|
PathLog.track(obj.Label)
|
|
signals = []
|
|
signals.append(self.form.defaultLength.editingFinished)
|
|
signals.append(self.form.enableExtensions.toggled)
|
|
return signals
|
|
|
|
def registerSignalHandlers(self, obj):
|
|
self.form.showExtensions.clicked.connect(self.showHideExtension)
|
|
self.form.extendCorners.clicked.connect(self.toggleExtensionCorners)
|
|
self.form.buttonClear.clicked.connect(self.extensionsClear)
|
|
self.form.buttonDisable.clicked.connect(self.extensionsDisable)
|
|
self.form.buttonEnable.clicked.connect(self.extensionsEnable)
|
|
self.form.enableExtensions.toggled.connect(self._enableExtensions)
|
|
self.form.defaultLength.editingFinished.connect(self._applyDefaultLengthChange)
|
|
|
|
self.model.itemChanged.connect(self.updateItemEnabled)
|
|
|
|
self.selectionModel = self.form.extensionTree.selectionModel()
|
|
self.selectionModel.selectionChanged.connect(self.selectionChanged)
|
|
self.selectionChanged()
|
|
|
|
# Support methods
|
|
def _getUseOutlineState(self):
|
|
"""_getUseOutlineState() ...
|
|
This method locates the `useOutline` form checkbox in the `Operation` tab,
|
|
and saves that reference to self.useOutlineInput. If found, then the boolean
|
|
value of the checkbox is saved to self.useOutline.
|
|
"""
|
|
if self.useOutlineCheckbox:
|
|
self.useOutline = self.useOutlineCheckbox.isChecked()
|
|
|
|
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 == "Operation" and hasattr(
|
|
page.form, "useOutline"
|
|
):
|
|
PathLog.debug("Found useOutline checkbox")
|
|
self.useOutlineCheckbox = page.form.useOutline
|
|
if page.form.useOutline.isChecked():
|
|
self.useOutline = 1
|
|
return
|
|
else:
|
|
self.useOutline = 0
|
|
return
|
|
|
|
self.useOutline = -1
|
|
|
|
# Methods for enable and disablement of Extensions feature
|
|
def _autoEnableExtensions(self):
|
|
"""_autoEnableExtensions() ...
|
|
This method is called to determine if the Extensions feature should be enabled,
|
|
or auto disabled due to total edge count of selected faces.
|
|
The auto enable/disable feature is designed to allow quicker access
|
|
to operations that implement the Extensions feature when selected faces contain
|
|
large numbers of edges, which require long computation times for preparation.
|
|
|
|
The return value is a simple boolean to communicate whether or not Extensions
|
|
are be enabled.
|
|
"""
|
|
enabled = False
|
|
|
|
if self.form.enableExtensions.isChecked():
|
|
enabled = True
|
|
|
|
PathLog.debug("_autoEnableExtensions() is {}".format(enabled))
|
|
self.enabled = enabled
|
|
|
|
def _enableExtensions(self):
|
|
"""_enableExtensions() ...
|
|
This method is called when the enableExtensions push button is toggled.
|
|
This method manages the enabled or disabled state of the extensionsEdit
|
|
Task Panel input group.
|
|
"""
|
|
PathLog.debug("_enableExtensions()")
|
|
|
|
if self.form.enableExtensions.isChecked():
|
|
self.enabled = True
|
|
self.extensionsReady = False
|
|
self.form.extensionEdit.setEnabled(True)
|
|
self.extensions = FeatureExtensions.getExtensions(self.obj)
|
|
self.setExtensions(self.extensions)
|
|
else:
|
|
self.form.extensionEdit.setDisabled(True)
|
|
self.enabled = False
|
|
|
|
def _includeEdgesAndWires(self):
|
|
"""_includeEdgesAndWires() ...
|
|
This method is called when the includeEdges push button is toggled.
|
|
This method manages the state of the button and the message thereof.
|
|
"""
|
|
self._getUseOutlineState() # Find `useOutline` checkbox and get its boolean value
|
|
PathLog.debug("_includeEdgesAndWires()")
|
|
self.extensionsReady = False
|
|
self._enableExtensions()
|
|
|
|
# Methods for creating and managing cached extensions
|
|
def _cachedExtension(self, obj, base, sub, label):
|
|
"""_cachedExtension(obj, base, sub, label)...
|
|
This method creates a new _Extension object if none is found within
|
|
the extensionCache dictionary."""
|
|
|
|
if label:
|
|
cacheLabel = base.Name + "_" + sub + "_" + label
|
|
else:
|
|
cacheLabel = base.Name + "_" + sub + "_None"
|
|
|
|
if cacheLabel in self.extensionsCache.keys():
|
|
# PathLog.debug("return _cachedExtension({})".format(cacheLabel))
|
|
return self.extensionsCache[cacheLabel]
|
|
else:
|
|
# PathLog.debug("_cachedExtension({}) created".format(cacheLabel))
|
|
_ext = _Extension(obj, base, sub, label)
|
|
self.extensionsCache[cacheLabel] = _ext # cache the extension
|
|
return _ext
|
|
|
|
def _resetCachedExtensions(self):
|
|
PathLog.debug("_resetCachedExtensions()")
|
|
reset = dict()
|
|
self.extensionsCache = reset
|
|
self.extensionsReady = False
|
|
|
|
|
|
# Eclass
|
|
|
|
FreeCAD.Console.PrintLog("Loading PathFeatureExtensionsGui... done\n")
|