Control.ControlProxy Class Reference

Proxy class for a DocumentObjectGroupPython Control instance. More...

Public Member Functions
def	__init__ (self, fp)
	Initialization method for ControlProxy. More...
def	onDocumentRestored (self, fp)
	Method called when document is restored to make sure everything is as it was. More...
def	onBeforeChange (self, fp, prop)
	Method called before DocumentObjectGroupPython Control is changed. More...
def	onChanged (self, fp, prop)
	Method called after DocumentObjectGroupPython Control was changed. More...
def	setProperties (self, fp)
	Method to set properties during initialization or document restoration. More...

Public Attributes
	temporary_export_path
	A str path to an export folder. More...
	updated

Static Public Attributes
bool	updated = False
	A bool - True if a property was changed by a class and not user. More...

Detailed Description

Proxy class for a DocumentObjectGroupPython Control instance.

A ControlProxy instance adds properties to a DocumentObjectGroupPython Control instance and responds to their changes. It provides a control panel to control animations.

To access such a dialog double-click Control in Tree View or right click and select Show control panel option from a context menu.

To connect this Proxy object to a DocumentObjectGroupPython Control do:

a = FreeCAD.ActiveDocument.addObject("App::DocumentObjectGroupPython",
                                     "Control")
ControlProxy(a)

Definition at line 1051 of file Control.py.

Constructor & Destructor Documentation

__init__()

def Control.ControlProxy.__init__	(		self,
			fp
	)

Initialization method for ControlProxy.

A class instance is created and made a Proxy for a generic DocumentObjectGroupPython Control object. During initialization number of properties are specified and preset.

Parameters

fp	A barebone DocumentObjectGroupPython Control object to be extended.

Definition at line 1071 of file Control.py.

    def __init__(self, fp):
        self.setProperties(fp)
        fp.Proxy = self

Member Function Documentation

onBeforeChange()

def Control.ControlProxy.onBeforeChange	(		self,
			fp,
			prop
	)

Method called before DocumentObjectGroupPython Control is changed.

An old export path is stored for a case in which a new export path is not a valid path.

Parameters

fp	A DocumentObjectGroupPython Control object.
prop	A str name of a property about to change.

Definition at line 1099 of file Control.py.

    def onBeforeChange(self, fp, prop):
        # Save an export path before it's changed to restore it if new
        # path is invalid
        if prop == "ExportPath" and hasattr(fp, "ExportPath") and \
           not self.updated:
            self.temporary_export_path = fp.ExportPath

onChanged()

def Control.ControlProxy.onChanged	(		self,
			fp,
			prop
	)

Method called after DocumentObjectGroupPython Control was changed.

Values of changed properties (start time, step time, stop time, export path) are checked for validity and edited if they are not.

Parameters

fp	A DocumentObjectGroupPython Control object.
prop	A str name of a changed property.

Definition at line 1116 of file Control.py.

    def onChanged(self, fp, prop):
        # Don't do anything if a value was updated because another property
        # had changed
        if self.updated:
            self.updated = False
            return

        # Control animation range so that step size is less than range size
        elif prop == "StartTime" and hasattr(fp, "StopTime") and \
                hasattr(fp, "StepTime"):
            self.updated = True
            fp.StopTime = (fp.StopTime, fp.StartTime + fp.StepTime,
                           float("inf"), 0.5)
            self.updated = True
            fp.StepTime = (fp.StepTime, 0.01, fp.StopTime - fp.StartTime, 0.1)
        elif prop == "StepTime" and hasattr(fp, "StartTime") and \
                hasattr(fp, "StopTime"):
            self.updated = True
            fp.StopTime = (fp.StopTime, fp.StartTime + fp.StepTime,
                           float("inf"), 0.5)
            self.updated = True
            fp.StartTime = (fp.StartTime, -float("inf"),
                            fp.StopTime - fp.StepTime, 0.5)
        elif prop == "StopTime" and hasattr(fp, "StartTime") and \
                hasattr(fp, "StepTime"):
            self.updated = True
            fp.StartTime = (fp.StartTime, -float("inf"),
                            fp.StopTime - fp.StepTime, 0.5)
            self.updated = True
            fp.StepTime = (fp.StepTime, 0.01, fp.StopTime - fp.StartTime, 0.1)

        # Return to previous export path if the new one is invalid
        elif prop == "ExportPath":
            # Test access right in the folder an show warning if they are not
            # sufficient
            if not os.access(fp.ExportPath, os.W_OK | os.R_OK):
                QMessageBox.warning(None, 'Error while setting Export Path',
                                    "You don't have access to read and write "
                                    + "in this folder.")
                self.updated = True
                fp.ExportPath = self.temporary_export_path
                del self.temporary_export_path

onDocumentRestored()

def Control.ControlProxy.onDocumentRestored	(		self,
			fp
	)

Method called when document is restored to make sure everything is as it was.

Reinitialization it creates properties and sets them to default, if they were not restored automatically. Properties of connected ViewObject are also recreated and reset if necessary.

Parameters

fp	A restored DocumentObjectGroupPython Control object.

Definition at line 1085 of file Control.py.

    def onDocumentRestored(self, fp):
        fp.ViewObject.Proxy.setProperties(fp.ViewObject)
        self.setProperties(fp)

setProperties()

def Control.ControlProxy.setProperties	(		self,
			fp
	)

Method to set properties during initialization or document restoration.

The properties are set if they are not already present and an AnimateDocumentObserver is recreated.

Parameters

fp	A restored or barebone DocumentObjectGroupPython Control object.

Definition at line 1168 of file Control.py.

    def setProperties(self, fp):
        # Add (and preset) properties
        if not hasattr(fp, "StartTime"):
            fp.addProperty(
                "App::PropertyFloatConstraint", "StartTime", "Timing",
                "Animation start time. \nRange is "
                "< - inf | Stop Time - Step Time >."
                ).StartTime = (0, -float("inf"), 9.5, 0.5)
        elif hasattr(fp, "StepTime") and hasattr(fp, "StopTime"):
            fp.StartTime = (fp.StartTime, -float("inf"),
                            fp.StopTime - fp.StepTime, 0.5)
        if not hasattr(fp, "StepTime"):
            fp.addProperty(
                "App::PropertyFloatConstraint", "StepTime", "Timing",
                "Animation step time. \nRange is "
                "< 0.01 | Stop Time - Start Time >."
                ).StepTime = (0.5, 0.01, 10, 0.1)
        elif hasattr(fp, "StartTime") and hasattr(fp, "StopTime"):
            fp.StepTime = (fp.StepTime, 0.01, fp.StopTime - fp.StartTime, 0.1)
        if not hasattr(fp, "StopTime"):
            fp.addProperty(
                "App::PropertyFloatConstraint", "StopTime", "Timing",
                "Animation stop time. \nRange is "
                + "< Start Time + Step Time | inf >."
                ).StopTime = (10, 0.5, float("inf"), 0.5)
        elif hasattr(fp, "StartTime") and hasattr(fp, "StepTime"):
            fp.StopTime = (fp.StopTime, fp.StartTime + fp.StepTime,
                           float("inf"), 0.5)

        if not hasattr(fp, "ExportPath"):
            fp.addProperty(
                "App::PropertyPath", "ExportPath", "Record & Export",
                "Path to a folder, where recorded rendered images will be "
                "saved to be converted into a video.")
        if not hasattr(fp, "VideoWidth"):
            fp.addProperty(
                "App::PropertyIntegerConstraint", "VideoWidth",
                "Record & Export", "Width of the exported video in pixels.\n"
                + "Range is < 32 | 7680 >.").VideoWidth = (1280, 32, 7680, 10)
        else:
            fp.VideoWidth = (fp.VideoWidth, 32, 7680, 10)
        if not hasattr(fp, "VideoHeight"):
            fp.addProperty(
                "App::PropertyIntegerConstraint", "VideoHeight",
                "Record & Export", "Height of the exported video in pixels.\n"
                + "Range is < 32 | 4320 >.").VideoHeight = (720, 32, 4320, 10)
        else:
            fp.VideoHeight = (fp.VideoHeight, 32, 4320, 10)

        # Add an document observer to control the structure
        import AnimateDocumentObserver
        AnimateDocumentObserver.addObserver()

Member Data Documentation

temporary_export_path

Control.ControlProxy.temporary_export_path

A str path to an export folder.

Definition at line 1104 of file Control.py.

updated

Control.ControlProxy.updated = False

static

A bool - True if a property was changed by a class and not user.

Definition at line 1059 of file Control.py.

---

The documentation for this class was generated from the following file:

• Doxypypy outputs/Control.py