Exemplo n.º 1
0
def insert(filename, docname):
    """called when freecad imports a file"""
    PathLog.track(filename)
    gfile = pythonopen(filename)
    gcode = gfile.read()
    gfile.close()

    # Regular expression to match tool changes in the format 'M6 Tn'
    p = re.compile("[mM]+?\s?0?6\s?T\d*\s")

    # split the gcode on tool changes
    paths = re.split("([mM]+?\s?0?6\s?T\d*\s)", gcode)

    # iterate the gcode sections and add customs for each
    toolnumber = 0

    for path in paths:

        # if the section is a tool change, extract the tool number
        m = p.match(path)
        if m:
            toolnumber = int(m.group().split("T")[-1])
            continue

        # Parse the gcode and throw away any empty lists
        gcode = parse(path)
        if len(gcode) == 0:
            continue

        # Create a custom and viewobject
        obj = PathCustom.Create("Custom")
        res = PathOpGui.CommandResources(
            "Custom",
            PathCustom.Create,
            PathCustomGui.TaskPanelOpPage,
            "Path_Custom",
            QT_TRANSLATE_NOOP("Path_Custom", "Custom"),
            "",
            "",
        )
        obj.ViewObject.Proxy = PathOpGui.ViewProvider(obj.ViewObject, res)
        obj.ViewObject.Proxy.setDeleteObjectsOnReject(False)

        # Set the gcode and try to match a tool controller
        obj.Gcode = gcode
        obj.ToolController = matchToolController(obj, toolnumber)

    FreeCAD.ActiveDocument.recompute()
def SetupOperation(name,
                   resName,
                   objFactory,
                   opPageClass,
                   pixmap,
                   menuText,
                   toolTip,
                   accelKey=None):
    '''SetupOperation(name, objFactory, opPageClass, pixmap, menuText, toolTip, accelKey=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.
    '''

    import Adaptive2_rc
    import PathScripts.PathOpGui as PathOpGui
    res = PathOpGui.CommandResources(resName, objFactory, opPageClass, pixmap, menuText, accelKey, toolTip)

    command = PathOpGui.CommandPathOp(res)
    FreeCADGui.addCommand("Path_%s" % name.replace(' ', '_'), command)
    return command
Exemplo n.º 3
0
# ***************************************************************************

import FreeCAD
import PathScripts.PathMillFace as PathMillFace
import PathScripts.PathOpGui as PathOpGui
import PathScripts.PathPocketBaseGui as PathPocketBaseGui

from PySide import QtCore

__title__ = "Path Face Mill Operation UI"
__author__ = "sliptonic (Brad Collette)"
__url__ = "https://www.freecadweb.org"
__doc__ = "Face Mill operation page controller and command implementation."


class TaskPanelOpPage(PathPocketBaseGui.TaskPanelOpPage):
    '''Page controller class for the face milling operation.'''
    def pocketFeatures(self):
        '''pocketFeatures() ... return FeatureFacing (see PathPocketBaseGui)'''
        return PathPocketBaseGui.FeatureFacing


Command = PathOpGui.SetupOperation(
    'MillFace', PathMillFace.Create, TaskPanelOpPage, 'Path-Face',
    QtCore.QT_TRANSLATE_NOOP("PathFace", "Face"),
    QtCore.QT_TRANSLATE_NOOP("PathFace",
                             "Create a Facing Operation from a model or face"),
    PathMillFace.SetupProperties)

FreeCAD.Console.PrintLog("Loading PathMillFaceGui... done\n")
__author__ = "dubstar-04 (Daniel Wood)"
__url__ = "http://www.freecadweb.org"
__doc__ = "Gui implementation for turning profiling operations."

LOGLEVEL = False

if LOGLEVEL:
    PathLog.setLevel(PathLog.Level.DEBUG, PathLog.thisModule())
    PathLog.trackModule(PathLog.thisModule())
else:
    PathLog.setLevel(PathLog.Level.NOTICE, PathLog.thisModule())


class TaskPanelOpPage(PathTurnBaseGui.TaskPanelTurnBase):
    '''Page controller class for Turning operations.'''
    def setOpFields(self, obj):
        '''setFields(obj) ... transfers obj's property values to UI'''

        self.form.finishPasses.setEnabled(False)


Command = PathOpGui.SetupOperation(
    'TurnRough', PathTurnRough.Create, TaskPanelOpPage, 'Path-TurnRough',
    QtCore.QT_TRANSLATE_NOOP("PathTurnRough", "Turn Rough"),
    QtCore.QT_TRANSLATE_NOOP(
        "PathTurnRough",
        "Creates a Path Turning Roughing object from a features of a base object"
    ), PathTurnRough.SetupProperties)

FreeCAD.Console.PrintLog("Loading PathTurnRoughGui... done\n")
import FreeCAD
import PathScripts.PathOpGui as PathOpGui
import PathScripts.PathProfile as PathProfile
import PathScripts.PathProfileGui as PathProfileGui
from PySide import QtCore

__title__ = "Path Contour Operation UI (depreciated)"
__author__ = "sliptonic (Brad Collette)"
__url__ = "https://www.freecadweb.org"
__doc__ = "Contour operation page controller and command implementation (depreciated)."


class TaskPanelOpPage(PathProfileGui.TaskPanelOpPage):
    '''Psuedo page controller class for Profile operation,
    allowing for backward compatibility with pre-existing "Contour" operations.'''
    pass


# Eclass

Command = PathOpGui.SetupOperation(
    'Profile', PathProfile.Create, TaskPanelOpPage, 'Path-Contour',
    QtCore.QT_TRANSLATE_NOOP("PathProfile", "Profile"),
    QtCore.QT_TRANSLATE_NOOP(
        "PathProfile",
        "Profile entire model, selected face(s) or selected edge(s)"),
    PathProfile.SetupProperties)

FreeCAD.Console.PrintLog("Loading PathProfileContourGui... done\n")
Exemplo n.º 6
0
        return signals

    def updateVisibility(self):
        if self.form.algorithmSelect.currentText() == "OCL Dropcutter":
            self.form.boundBoxExtraOffsetX.setEnabled(True)
            self.form.boundBoxExtraOffsetY.setEnabled(True)
            self.form.boundBoxSelect.setEnabled(True)
            self.form.dropCutterDirSelect.setEnabled(True)
            self.form.stepOver.setEnabled(True)
        else:
            self.form.boundBoxExtraOffsetX.setEnabled(False)
            self.form.boundBoxExtraOffsetY.setEnabled(False)
            self.form.boundBoxSelect.setEnabled(False)
            self.form.dropCutterDirSelect.setEnabled(False)
            self.form.stepOver.setEnabled(False)

    def registerSignalHandlers(self, obj):
        self.form.algorithmSelect.currentIndexChanged.connect(
            self.updateVisibility)


Command = PathOpGui.SetupOperation(
    'Surface', PathSurface.Create, TaskPanelOpPage, 'Path-3DSurface',
    QtCore.QT_TRANSLATE_NOOP("Surface", "3D Surface"),
    QtCore.QT_TRANSLATE_NOOP("Surface",
                             "Create a 3D Surface Operation from a model"),
    PathSurface.SetupProperties)

FreeCAD.Console.PrintLog("Loading PathSurfaceGui... done\n")
Exemplo n.º 7
0
    def getFields(self, obj):
        '''getFields(obj) ... transfers values from UI to obj's properties'''
        self.updateToolController(obj, self.form.toolController)
        self.updateCoolant(obj, self.form.coolantController)

    def setFields(self, obj):
        '''setFields(obj) ... transfers obj's property values to UI'''
        self.setupToolController(obj, self.form.toolController)
        self.form.txtGCode.setText("\n".join(obj.Gcode))
        self.setupCoolant(obj, self.form.coolantController)

    def getSignalsForUpdate(self, obj):
        '''getSignalsForUpdate(obj) ... return list of signals for updating obj'''
        signals = []
        signals.append(self.form.toolController.currentIndexChanged)
        signals.append(self.form.coolantController.currentIndexChanged)
        self.form.txtGCode.textChanged.connect(self.setGCode)
        return signals

    def setGCode(self):
        self.obj.Gcode = self.form.txtGCode.toPlainText().splitlines()


Command = PathOpGui.SetupOperation(
    'Custom', PathCustom.Create, TaskPanelOpPage, 'Path_Custom',
    QtCore.QT_TRANSLATE_NOOP("Path_Custom", "Custom"),
    QtCore.QT_TRANSLATE_NOOP("Path_Custom", "Create custom gcode snippet"),
    PathCustom.SetupProperties)

FreeCAD.Console.PrintLog("Loading PathCustomGui... done\n")
Exemplo n.º 8
0
        signals.append(self.form.joinMiter.clicked)
        signals.append(self.form.joinRound.clicked)
        signals.append(self.form.coolantController.currentIndexChanged)
        signals.append(self.form.direction.currentIndexChanged)
        signals.append(self.form.value_W.valueChanged)
        signals.append(self.form.value_h.valueChanged)
        return signals

    def registerSignalHandlers(self, obj):
        self.form.value_W.editingFinished.connect(self.updateWidth)
        self.form.value_h.editingFinished.connect(self.updateExtraDepth)

    def taskPanelBaseGeometryPage(self, obj, features):
        """taskPanelBaseGeometryPage(obj, features) ... return page for adding base geometries."""
        return TaskPanelBaseGeometryPage(obj, features)


Command = PathOpGui.SetupOperation(
    "Deburr",
    PathDeburr.Create,
    TaskPanelOpPage,
    "Path_Deburr",
    QT_TRANSLATE_NOOP("Path_Deburr", "Deburr"),
    QT_TRANSLATE_NOOP(
        "Path_Deburr", "Creates a Deburr Path along Edges or around Faces"
    ),
    PathDeburr.SetupProperties,
)

FreeCAD.Console.PrintLog("Loading PathDeburrGui... done\n")
Exemplo n.º 9
0
        obj.StepOver = self.form.StepOver.value()
        obj.Tolerance = 1.0 * self.form.Tolerance.value() / 100.0
        obj.HelixAngle = self.form.HelixAngle.value()
        obj.HelixDiameterLimit = self.form.HelixDiameterLimit.value()
        obj.LiftDistance = self.form.LiftDistance.value()

        if hasattr(obj, 'KeepToolDownRatio'):
            obj.KeepToolDownRatio = self.form.KeepToolDownRatio.value()

        if hasattr(obj, 'StockToLeave'):
            obj.StockToLeave = self.form.StockToLeave.value()

        obj.ForceInsideOut = self.form.ForceInsideOut.isChecked()
        obj.Stopped = self.form.StopButton.isChecked()
        if (obj.Stopped):
            self.form.StopButton.setChecked(False)  # reset the button
            obj.StopProcessing = True

        self.updateToolController(obj, self.form.ToolController)
        obj.setEditorMode('AdaptiveInputState', 2)  # hide this property
        obj.setEditorMode('AdaptiveOutputState', 2)  # hide this property
        obj.setEditorMode('StopProcessing', 2)  # hide this property
        obj.setEditorMode('Stopped', 2)  # hide this property


Command = PathOpGui.SetupOperation(
    'Adaptive', PathAdaptive.Create, TaskPanelOpPage, 'Path-Adaptive',
    QtCore.QT_TRANSLATE_NOOP("PathAdaptive", "Adaptive"),
    QtCore.QT_TRANSLATE_NOOP("PathPocket", "Adaptive clearing and profiling"))
Exemplo n.º 10
0
            self.form.boundaryAdjustment.show()
            self.form.cutPattern_label.show()
            self.form.boundaryAdjustment_label.show()
            if self.form.cutPattern.currentData() == "None":
                self.form.stepOver.hide()
                self.form.stepOver_label.hide()
            else:
                self.form.stepOver.show()
                self.form.stepOver_label.show()
            self.form.sampleInterval.hide()
            self.form.sampleInterval_label.hide()

    def registerSignalHandlers(self, obj):
        self.form.algorithmSelect.currentIndexChanged.connect(
            self.updateVisibility)
        self.form.cutPattern.currentIndexChanged.connect(self.updateVisibility)


Command = PathOpGui.SetupOperation(
    "Waterline",
    PathWaterline.Create,
    TaskPanelOpPage,
    "Path_Waterline",
    QT_TRANSLATE_NOOP("Path_Waterline", "Waterline"),
    QT_TRANSLATE_NOOP("Path_Waterline",
                      "Create a Waterline Operation from a model"),
    PathWaterline.SetupProperties,
)

FreeCAD.Console.PrintLog("Loading PathWaterlineGui... done\n")
Exemplo n.º 11
0
# ***************************************************************************

import FreeCAD
import PathScripts.PathOpGui as PathOpGui
import PathScripts.PathProfileBaseGui as PathProfileBaseGui
import PathScripts.PathProfileContour as PathProfileContour

from PySide import QtCore

__title__ = "Path Contour Operation UI"
__author__ = "sliptonic (Brad Collette)"
__url__ = "http://www.freecadweb.org"
__doc__ = "Contour operation page controller and command implementation."


class TaskPanelOpPage(PathProfileBaseGui.TaskPanelOpPage):
    '''Page controller for the contour operation UI.'''
    def profileFeatures(self):
        '''profileFeatues() ... return 0 - profile doesn't support any of the optional UI features.'''
        return 0


Command = PathOpGui.SetupOperation(
    'Contour', PathProfileContour.Create, TaskPanelOpPage, 'Path-Contour',
    QtCore.QT_TRANSLATE_NOOP("PathProfileContour", "Contour"),
    QtCore.QT_TRANSLATE_NOOP("PathProfileContour",
                             "Creates a Contour Path for the Base Object "),
    PathProfileContour.SetupProperties)

FreeCAD.Console.PrintLog("Loading PathProfileContourGui... done\n")
Exemplo n.º 12
0
            ("offsetPattern", "OffsetPattern"),
            ("boundaryShape", "BoundaryShape"),
        ]

        enumTups = PathMillFace.ObjectFace.propertyEnumerations(dataType="raw")
        enumTups.update(
            PathPocketShape.ObjectPocket.pocketPropertyEnumerations(dataType="raw")
        )

        self.populateCombobox(form, enumTups, comboToPropertyMap)
        return form

    def pocketFeatures(self):
        """pocketFeatures() ... return FeatureFacing (see PathPocketBaseGui)"""
        return PathPocketBaseGui.FeatureFacing


Command = PathOpGui.SetupOperation(
    "MillFace",
    PathMillFace.Create,
    TaskPanelOpPage,
    "Path_Face",
    QT_TRANSLATE_NOOP("Path_MillFace", "Face"),
    QT_TRANSLATE_NOOP(
        "Path_MillFace", "Create a Facing Operation from a model or face"
    ),
    PathMillFace.SetupProperties,
)

FreeCAD.Console.PrintLog("Loading PathMillFaceGui... done\n")
Exemplo n.º 13
0
# *                                                                         *
# ***************************************************************************

import FreeCAD
import PathScripts.PathOpGui as PathOpGui
import PathScripts.PathPocket as PathPocket
import PathScripts.PathPocketBaseGui as PathPocketBaseGui

from PySide import QtCore

__title__ = "Path Pocket Operation UI"
__author__ = "sliptonic (Brad Collette)"
__url__ = "http://www.freecadweb.org"
__doc__ = "Pocket operation page controller and command implementation."

class TaskPanelOpPage(PathPocketBaseGui.TaskPanelOpPage):
    '''Page controller class for Pocket operation'''

    def pocketFeatures(self):
        '''pocketFeatures() ... return FeaturePocket (see PathPocketBaseGui)'''
        return PathPocketBaseGui.FeaturePocket

Command = PathOpGui.SetupOperation('Pocket 3D',
        PathPocket.Create,
        TaskPanelOpPage,
        'Path-3DPocket',
        QtCore.QT_TRANSLATE_NOOP("PathPocket", "3D Pocket"),
        QtCore.QT_TRANSLATE_NOOP("PathPocket", "Creates a Path 3D Pocket object from a face or faces"))

FreeCAD.Console.PrintLog("Loading PathPocketGui... done\n")
Exemplo n.º 14
0
    PathLog.setLevel(PathLog.Level.INFO, PathLog.thisModule())


__title__ = "Path Pocket Operation UI"
__author__ = "sliptonic (Brad Collette)"
__url__ = "https://www.freecadweb.org"
__doc__ = "Pocket operation page controller and command implementation."


class TaskPanelOpPage(PathPocketBaseGui.TaskPanelOpPage):
    """Page controller class for Pocket operation"""

    def pocketFeatures(self):
        """pocketFeatures() ... return FeaturePocket (see PathPocketBaseGui)"""
        return PathPocketBaseGui.FeaturePocket


Command = PathOpGui.SetupOperation(
    "Pocket3D",
    PathPocket.Create,
    TaskPanelOpPage,
    "Path_3DPocket",
    QT_TRANSLATE_NOOP("Path_Pocket3D", "3D Pocket"),
    QT_TRANSLATE_NOOP(
        "Path_Pocket3D", "Creates a Path 3D Pocket object from a face or faces"
    ),
    PathPocket.SetupProperties,
)

FreeCAD.Console.PrintLog("Loading PathPocketGui... done\n")
Exemplo n.º 15
0
        self.form.colinearFilter.setValue(obj.Colinear)
        self.setupToolController(obj, self.form.toolController)
        self.setupCoolant(obj, self.form.coolantController)

    def getSignalsForUpdate(self, obj):
        """getSignalsForUpdate(obj) ... return list of signals for updating obj"""
        signals = []
        signals.append(self.form.discretize.editingFinished)
        signals.append(self.form.colinearFilter.editingFinished)
        signals.append(self.form.toolController.currentIndexChanged)
        signals.append(self.form.coolantController.currentIndexChanged)
        return signals

    def taskPanelBaseGeometryPage(self, obj, features):
        """taskPanelBaseGeometryPage(obj, features) ... return page for adding base geometries."""
        return TaskPanelBaseGeometryPage(obj, features)


Command = PathOpGui.SetupOperation(
    "Vcarve",
    PathVcarve.Create,
    TaskPanelOpPage,
    "Path_Vcarve",
    QtCore.QT_TRANSLATE_NOOP("Path_Vcarve", "Vcarve"),
    QtCore.QT_TRANSLATE_NOOP("Path_Vcarve",
                             "Creates a medial line engraving path"),
    PathVcarve.SetupProperties,
)

FreeCAD.Console.PrintLog("Loading PathVcarveGui... done\n")
Exemplo n.º 16
0
import PathScripts.PathProfile as PathProfile
import PathScripts.PathProfileGui as PathProfileGui
from PySide.QtCore import QT_TRANSLATE_NOOP

__title__ = "Path Contour Operation UI (depreciated)"
__author__ = "sliptonic (Brad Collette)"
__url__ = "https://www.freecadweb.org"
__doc__ = "Contour operation page controller and command implementation (deprecated)."


class TaskPanelOpPage(PathProfileGui.TaskPanelOpPage):
    """Psuedo page controller class for Profile operation,
    allowing for backward compatibility with pre-existing "Contour" operations."""

    pass


Command = PathOpGui.SetupOperation(
    "Profile",
    PathProfile.Create,
    TaskPanelOpPage,
    "Path_Contour",
    QT_TRANSLATE_NOOP("Path_Profile", "Profile"),
    QT_TRANSLATE_NOOP(
        "Path_Profile",
        "Profile entire model, selected face(s) or selected edge(s)"),
    PathProfile.SetupProperties,
)

FreeCAD.Console.PrintLog("Loading PathProfileContourGui... done\n")
Exemplo n.º 17
0
    def getSignalsForUpdate(self, obj):
        '''getSignalsForUpdate(obj) ... return list of signals for updating obj'''
        signals = []
        signals.append(self.form.toolController.currentIndexChanged)
        signals.append(self.form.PointCountX.valueChanged)
        signals.append(self.form.PointCountY.valueChanged)
        signals.append(self.form.OutputFileName.editingFinished)
        signals.append(self.form.Xoffset.valueChanged)
        signals.append(self.form.Yoffset.valueChanged)
        self.form.SetOutputFileName.clicked.connect(self.SetOutputFileName)
        return signals

    def SetOutputFileName(self):
        filename = QtGui.QFileDialog.getSaveFileName(
            self.form, translate("Path_Probe", "Select Output File"), None,
            translate("Path_Probe", "All Files (*.*)"))
        if filename and filename[0]:
            self.obj.OutputFileName = str(filename[0])
            self.setFields(self.obj)


Command = PathOpGui.SetupOperation(
    'Probe', PathProbe.Create, TaskPanelOpPage, 'Path_Probe',
    QtCore.QT_TRANSLATE_NOOP("Probe", "Probe"),
    QtCore.QT_TRANSLATE_NOOP("Probe",
                             "Create a Probing Grid from a job stock"),
    PathProbe.SetupProperties)

FreeCAD.Console.PrintLog("Loading PathProbeGui... done\n")
Exemplo n.º 18
0
        obj.UseOutline = self.form.useOutline.isChecked()
        obj.Stopped = self.form.StopButton.isChecked()
        if obj.Stopped:
            self.form.StopButton.setChecked(False)  # reset the button
            obj.StopProcessing = True

        self.updateToolController(obj, self.form.ToolController)
        self.updateCoolant(obj, self.form.coolantController)
        obj.setEditorMode("AdaptiveInputState", 2)  # hide this property
        obj.setEditorMode("AdaptiveOutputState", 2)  # hide this property
        obj.setEditorMode("StopProcessing", 2)  # hide this property
        obj.setEditorMode("Stopped", 2)  # hide this property

    def taskPanelBaseLocationPage(self, obj, features):
        if not hasattr(self, "extensionsPanel"):
            self.extensionsPanel = PathFeatureExtensionsGui.TaskPanelExtensionPage(
                obj, features)  # pylint: disable=attribute-defined-outside-init
        return self.extensionsPanel


Command = PathOpGui.SetupOperation(
    "Adaptive",
    PathAdaptive.Create,
    TaskPanelOpPage,
    "Path_Adaptive",
    QtCore.QT_TRANSLATE_NOOP("Path_Adaptive", "Adaptive"),
    QtCore.QT_TRANSLATE_NOOP("Path_Adaptive",
                             "Adaptive clearing and profiling"),
    PathAdaptive.SetupProperties,
)
Exemplo n.º 19
0
        self.updateToolController(obj, self.form.toolController)
        self.updateCoolant(obj, self.form.coolantController)

    def setFields(self, obj):
        '''setFields(obj) ... transfers obj's property values to UI'''
        self.form.startVertex.setValue(obj.StartVertex)
        self.setupToolController(obj, self.form.toolController)
        self.setupCoolant(obj, self.form.coolantController)

    def getSignalsForUpdate(self, obj):
        '''getSignalsForUpdate(obj) ... return list of signals for updating obj'''
        signals = []
        signals.append(self.form.startVertex.editingFinished)
        signals.append(self.form.toolController.currentIndexChanged)
        signals.append(self.form.coolantController.currentIndexChanged)
        return signals

    def taskPanelBaseGeometryPage(self, obj, features):
        '''taskPanelBaseGeometryPage(obj, features) ... return page for adding base geometries.'''
        return TaskPanelBaseGeometryPage(obj, features)


Command = PathOpGui.SetupOperation(
    'Engrave', PathEngrave.Create, TaskPanelOpPage, 'Path-Engrave',
    QtCore.QT_TRANSLATE_NOOP("PathEngrave", "Engrave"),
    QtCore.QT_TRANSLATE_NOOP(
        "PathEngrave", "Creates an Engraving Path around a Draft ShapeString"),
    PathEngrave.SetupProperties)

FreeCAD.Console.PrintLog("Loading PathEngraveGui... done\n")
Exemplo n.º 20
0
        # Search using currentData and return if found
        newindex = combo.findData(name)
        if newindex >= 0:
            combo.setCurrentIndex(newindex)
            return

        # if not found, search using current text
        newindex = combo.findText(name, QtCore.Qt.MatchFixedString)
        if newindex >= 0:
            combo.setCurrentIndex(newindex)
            return

        # not found, return unchanged
        combo.setCurrentIndex(0)
        return


Command = PathOpGui.SetupOperation(
    "Slot",
    PathSlot.Create,
    TaskPanelOpPage,
    "Path_Slot",
    QtCore.QT_TRANSLATE_NOOP("Path_Slot", "Slot"),
    QtCore.QT_TRANSLATE_NOOP(
        "Path_Slot", "Create a Slot operation from selected geometry or custom points."
    ),
    PathSlot.SetupProperties,
)

FreeCAD.Console.PrintLog("Loading PathSlotGui... done\n")
Exemplo n.º 21
0
        self.form.buttonDisable.clicked.connect(self.extensionsDisable)
        self.form.buttonEnable.clicked.connect(self.extensionsEnable)

        self.model.itemChanged.connect(self.updateItemEnabled)

        self.selectionModel = self.form.extensionTree.selectionModel() # pylint: disable=attribute-defined-outside-init
        self.selectionModel.selectionChanged.connect(self.selectionChanged)
        self.selectionChanged()

class TaskPanelOpPage(PathPocketBaseGui.TaskPanelOpPage):
    '''Page controller class for Pocket operation'''

    def pocketFeatures(self):
        '''pocketFeatures() ... return FeaturePocket (see PathPocketBaseGui)'''
        return PathPocketBaseGui.FeaturePocket | PathPocketBaseGui.FeatureOutline

    def taskPanelBaseLocationPage(self, obj, features):
        if not hasattr(self, 'extensionsPanel'):
            self.extensionsPanel = TaskPanelExtensionPage(obj, features) # pylint: disable=attribute-defined-outside-init
        return self.extensionsPanel

Command = PathOpGui.SetupOperation('Pocket Shape',
        PathPocketShape.Create,
        TaskPanelOpPage,
        'Path_Pocket',
        QtCore.QT_TRANSLATE_NOOP("Path_Pocket", "Pocket Shape"),
        QtCore.QT_TRANSLATE_NOOP("Path_Pocket", "Creates a Path Pocket object from a face or faces"),
        PathPocketShape.SetupProperties)

FreeCAD.Console.PrintLog("Loading PathPocketShapeGui... done\n")
Exemplo n.º 22
0
        signals.append(self.form.opDirection.currentIndexChanged)
        signals.append(self.form.opPasses.editingFinished)
        signals.append(self.form.leadInOut.stateChanged)

        signals.append(self.form.toolController.currentIndexChanged)

        return signals

    def registerSignalHandlers(self, obj):
        self.form.threadType.currentIndexChanged.connect(
            self._updateFromThreadType)
        self.form.threadName.currentIndexChanged.connect(
            self._updateFromThreadName)
        self.form.threadFit.valueChanged.connect(self._updateFromThreadName)


Command = PathOpGui.SetupOperation(
    "ThreadMilling",
    PathThreadMilling.Create,
    TaskPanelOpPage,
    "Path_ThreadMilling",
    QT_TRANSLATE_NOOP("Path_ThreadMilling", "Thread Milling"),
    QT_TRANSLATE_NOOP(
        "Path_ThreadMilling",
        "Creates a Path Thread Milling operation from features of a base object",
    ),
    PathThreadMilling.SetupProperties,
)

FreeCAD.Console.PrintLog("Loading PathThreadMillingGui ... done\n")
import FreeCAD
import PathScripts.PathOpGui as PathOpGui
import PathScripts.PathProfileBaseGui as PathProfileBaseGui
import PathScripts.PathProfileFaces as PathProfileFaces

from PySide import QtCore

__title__ = "Path Profile based on faces Operation UI"
__author__ = "sliptonic (Brad Collette)"
__url__ = "http://www.freecadweb.org"
__doc__ = "Profile based on faces operation page controller and command implementation."


class TaskPanelOpPage(PathProfileBaseGui.TaskPanelOpPage):
    '''Page controller for profile based on faces operation.'''
    def profileFeatures(self):
        '''profileFeatures() ... return FeatureSide | FeatureProcessing.
        See PathProfileBaseGui.py for details.'''
        return PathProfileBaseGui.FeatureSide | PathProfileBaseGui.FeatureProcessing


Command = PathOpGui.SetupOperation(
    'Profile Faces', PathProfileFaces.Create,
    TaskPanelOpPage, 'Path-Profile-Face',
    QtCore.QT_TRANSLATE_NOOP("PathProfile", "Face Profile"),
    QtCore.QT_TRANSLATE_NOOP("PathProfile", "Profile based on face or faces"),
    PathProfileFaces.SetupProperties)

FreeCAD.Console.PrintLog("Loading PathProfileFacesGui... done\n")
Exemplo n.º 24
0
        self.setupToolController(obj, self.form.toolController)
        self.form.joinRound.setChecked('Round' == obj.Join)
        self.form.joinMiter.setChecked('Miter' == obj.Join)
        self.form.joinFrame.hide()

    def updateWidth(self):
        PathGui.updateInputField(self.obj, 'Width', self.form.value_W)

    def updateExtraDepth(self):
        PathGui.updateInputField(self.obj, 'ExtraDepth', self.form.value_h)

    def getSignalsForUpdate(self, obj):
        signals = []
        signals.append(self.form.joinMiter.clicked)
        signals.append(self.form.joinRound.clicked)
        return signals

    def registerSignalHandlers(self, obj):
        self.form.value_W.editingFinished.connect(self.updateWidth)
        self.form.value_h.editingFinished.connect(self.updateExtraDepth)


Command = PathOpGui.SetupOperation(
    'Deburr', PathDeburr.Create, TaskPanelOpPage, 'Path-Deburr',
    QtCore.QT_TRANSLATE_NOOP("PathDeburr", "Deburr"),
    QtCore.QT_TRANSLATE_NOOP(
        "PathDeburr", "Creates a Deburr Path along Edges or around Faces"),
    PathDeburr.SetupProperties)

FreeCAD.Console.PrintLog("Loading PathDeburrGui... done\n")
Exemplo n.º 25
0
            FreeCAD.Units.Quantity(obj.OffsetExtra.Value,
                                   FreeCAD.Units.Length).UserString)

    def getSignalsForUpdate(self, obj):
        """getSignalsForUpdate(obj) ... return list of signals for updating obj"""
        signals = []

        signals.append(self.form.stepOverPercent.editingFinished)
        signals.append(self.form.extraOffset.editingFinished)
        signals.append(self.form.direction.currentIndexChanged)
        signals.append(self.form.startSide.currentIndexChanged)
        signals.append(self.form.toolController.currentIndexChanged)
        signals.append(self.form.coolantController.currentIndexChanged)

        return signals


Command = PathOpGui.SetupOperation(
    "Helix",
    PathHelix.Create,
    TaskPanelOpPage,
    "Path_Helix",
    QT_TRANSLATE_NOOP("Path_Helix", "Helix"),
    QT_TRANSLATE_NOOP(
        "Path_Helix",
        "Creates a Path Helix object from a features of a base object"),
    PathHelix.SetupProperties,
)

FreeCAD.Console.PrintLog("Loading PathHelixGui... done\n")
Exemplo n.º 26
0
            self.form.sampleInterval.show()
            self.form.sampleInterval_label.show()
        elif Algorithm == 'Experimental':
            self.form.cutPattern.show()
            self.form.boundaryAdjustment.show()
            self.form.cutPattern_label.show()
            self.form.boundaryAdjustment_label.show()
            if self.form.cutPattern.currentText() == 'None':
                self.form.stepOver.hide()
                self.form.stepOver_label.hide()
            else:
                self.form.stepOver.show()
                self.form.stepOver_label.show()
            self.form.sampleInterval.hide()
            self.form.sampleInterval_label.hide()

    def registerSignalHandlers(self, obj):
        self.form.algorithmSelect.currentIndexChanged.connect(
            self.updateVisibility)
        self.form.cutPattern.currentIndexChanged.connect(self.updateVisibility)


Command = PathOpGui.SetupOperation(
    'Waterline', PathWaterline.Create, TaskPanelOpPage, 'Path-Waterline',
    QtCore.QT_TRANSLATE_NOOP("Waterline", "Waterline"),
    QtCore.QT_TRANSLATE_NOOP("Waterline",
                             "Create a Waterline Operation from a model"),
    PathWaterline.SetupProperties)

FreeCAD.Console.PrintLog("Loading PathWaterlineGui... done\n")
Exemplo n.º 27
0
    def setFields(self, obj):
        '''setFields(obj) ... transfers obj's property values to UI'''
        PathLog.track()

        self.form.stepOverPercent.setValue(obj.StepOver)
        self.selectInComboBox(obj.Direction, self.form.direction)
        self.selectInComboBox(obj.StartSide, self.form.startSide)

        self.setupToolController(obj, self.form.toolController)

    def getSignalsForUpdate(self, obj):
        '''getSignalsForUpdate(obj) ... return list of signals for updating obj'''
        signals = []

        signals.append(self.form.stepOverPercent.editingFinished)
        signals.append(self.form.direction.currentIndexChanged)
        signals.append(self.form.startSide.currentIndexChanged)
        signals.append(self.form.toolController.currentIndexChanged)

        return signals

Command = PathOpGui.SetupOperation('Helix',
        PathHelix.Create,
        TaskPanelOpPage,
        'Path-Helix',
        QtCore.QT_TRANSLATE_NOOP("PathHelix", "Helix"),
        QtCore.QT_TRANSLATE_NOOP("PathHelix", "Creates a Path Helix object from a features of a base object"))

FreeCAD.Console.PrintLog("Loading PathHelixGui... done\n")
Exemplo n.º 28
0
        self.setupToolController(obj, self.form.toolController)

    def getSignalsForUpdate(self, obj):
        '''getSignalsForUpdate(obj) ... return list of signals which cause the receiver to update the model'''
        signals = []

        signals.append(self.form.peckRetractHeight.editingFinished)
        signals.append(self.form.peckDepth.editingFinished)
        signals.append(self.form.dwellTime.editingFinished)
        signals.append(self.form.dwellEnabled.stateChanged)
        signals.append(self.form.peckEnabled.stateChanged)
        signals.append(self.form.useTipLength.stateChanged)
        signals.append(self.form.toolController.currentIndexChanged)

        return signals
    
    def updateData(self, obj, prop):
        if prop in ['PeckDepth', 'RetractHeight'] and not prop in ['Base', 'Disabled']:
            self.updateQuantitySpinBoxes()

Command = PathOpGui.SetupOperation('Drilling',
        PathDrilling.Create,
        TaskPanelOpPage,
        'Path-Drilling',
        QtCore.QT_TRANSLATE_NOOP("PathDrilling", "Drilling"),
        QtCore.QT_TRANSLATE_NOOP("PathDrilling", "Creates a Path Drilling object from a features of a base object"),
        PathDrilling.SetupProperties)

FreeCAD.Console.PrintLog("Loading PathDrillingGui... done\n")
Exemplo n.º 29
0
                                   FreeCAD.Units.Length).UserString)
        self.setupToolController(obj, self.form.toolController)
        self.form.joinRound.setChecked('Round' == obj.Join)
        self.form.joinMiter.setChecked('Miter' == obj.Join)
        self.form.joinFrame.hide()

    def updateWidth(self):
        PathGui.updateInputField(self.obj, 'Width', self.form.value_W)

    def updateExtraDepth(self):
        PathGui.updateInputField(self.obj, 'ExtraDepth', self.form.value_h)

    def getSignalsForUpdate(self, obj):
        signals = []
        signals.append(self.form.joinMiter.clicked)
        signals.append(self.form.joinRound.clicked)
        return signals

    def registerSignalHandlers(self, obj):
        self.form.value_W.editingFinished.connect(self.updateWidth)
        self.form.value_h.editingFinished.connect(self.updateExtraDepth)


Command = PathOpGui.SetupOperation(
    'Chamfer', PathChamfer.Create, TaskPanelOpPage, 'Path-Chamfer',
    QtCore.QT_TRANSLATE_NOOP("PathChamfer", "Chamfer"),
    QtCore.QT_TRANSLATE_NOOP(
        "PathChamfer", "Creates a Chamfer Path along Edges or around Faces"))

FreeCAD.Console.PrintLog("Loading PathChamferGui... done\n")
Exemplo n.º 30
0
# ***************************************************************************

import FreeCAD
import PathScripts.PathOpGui as PathOpGui
import PathScripts.PathProfileBaseGui as PathProfileBaseGui
import PathScripts.PathProfileEdges as PathProfileEdges

from PySide import QtCore

__title__ = "Path Profile based on edges Operation UI"
__author__ = "sliptonic (Brad Collette)"
__url__ = "http://www.freecadweb.org"
__doc__ = "Profile based on edges operation page controller and command implementation."


class TaskPanelOpPage(PathProfileBaseGui.TaskPanelOpPage):
    '''Page controller for profile based on edges operation.'''
    def profileFeatures(self):
        '''profileFeatures() ... return FeatureSide
        See PathProfileBaseGui.py for details.'''
        return PathProfileBaseGui.FeatureSide


Command = PathOpGui.SetupOperation(
    'Profile Edges', PathProfileEdges.Create, TaskPanelOpPage,
    'Path-Profile-Edges',
    QtCore.QT_TRANSLATE_NOOP("PathProfile", "Edge Profile"),
    QtCore.QT_TRANSLATE_NOOP("PathProfile", "Profile based on edges"))

FreeCAD.Console.PrintLog("Loading PathProfileEdgesGui... done\n")