RobWorld.RobWorldProxy Class Reference

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

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

Detailed Description

Proxy class for a DocumentObjectGroupPython RobWorld instance.

A RobWorldProxy instance adds properties to a DocumentObjectGroupPython RobWorld instance and responds to their changes.

To connect this Proxy object to a DocumentObjectGroupPython RobWorld do:

    a = FreeCAD.ActiveDocument.addObject("App::DocumentObjectGroupPython",
                                         "RobWorld")
    RobWorldProxy(a)

Definition at line 60 of file RobWorld.py.

Constructor & Destructor Documentation

__init__()

def RobWorld.RobWorldProxy.__init__	(		self,
			fp
	)

Initialization method for RobWorldProxy.

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

Parameters

fp	A DocumentObjectGroupPython RobWorld object to be extended.

Definition at line 72 of file RobWorld.py.

    def __init__(self, fp):
        # Add (and preset) properties
        self.setProperties(fp)
        fp.Proxy = self

Member Function Documentation

execute()

def RobWorld.RobWorldProxy.execute	(		self,
			fp
	)

Method called when recomputing a DocumentObjectGroupPython.

Placement is computed from Yaw, Pitch and Roll angle rotations about Z, Y and X axes originating in (0, 0, 0).

Parameters

fp	A DocumentObjectGroupPython RobWorld object.

Definition at line 105 of file RobWorld.py.

    def execute(self, fp):
        rotation = FreeCAD.Rotation(fp.AngleYaw, fp.AnglePitch, fp.AngleRoll)
        rotation_center = FreeCAD.Vector(0, 0, 0)
        position = FreeCAD.Vector(fp.PositionX, fp.PositionY, fp.PositionZ)
        fp.Placement = FreeCAD.Placement(position, rotation, rotation_center)

onChanged()

def RobWorld.RobWorldProxy.onChanged	(		self,
			fp,
			prop
	)

Method called after DocumentObjectGroupPython RobWorld was changed.

A RobWorld is checked for its validity. If the Placement property is changed, then ParentFramePlacement property of a RobWorld's children is set to equal the new Placement.

Parameters

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

Definition at line 88 of file RobWorld.py.

    def onChanged(self, fp, prop):
        if prop == "Placement":
            # Propagate the Placement updates down the chain
            if hasattr(fp, "Group") and len(fp.Group) != 0:
                for child in fp.Group:
                    child.ParentFramePlacement = fp.Placement
                    child.purgeTouched()

onDocumentRestored()

def RobWorld.RobWorldProxy.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 RobWorld object.

Definition at line 121 of file RobWorld.py.

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

setProperties()

def RobWorld.RobWorldProxy.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 RobWorld object.

Definition at line 135 of file RobWorld.py.

    def setProperties(self, fp):
        # Add (and preset) properties
        # Animation properties
        if not hasattr(fp, "AllowServer"):
            fp.addProperty("App::PropertyBool", "AllowServer", "General",
                           "Should this object allow a Server object to "
                           + "change it.").AllowServer = True

        # Frame Placement
        if not hasattr(fp, "PositionX"):
            fp.addProperty("App::PropertyFloat", "PositionX", "FramePlacement",
                           "X position of the world frame.").PositionX = 0
        if not hasattr(fp, "PositionY"):
            fp.addProperty("App::PropertyFloat", "PositionY", "FramePlacement",
                           "Y position of the world frame.").PositionY = 0
        if not hasattr(fp, "PositionZ"):
            fp.addProperty("App::PropertyFloat", "PositionZ", "FramePlacement",
                           "Z position of the world frame.").PositionZ = 0
        if not hasattr(fp, "AngleYaw"):
            fp.addProperty("App::PropertyFloat", "AngleYaw", "FramePlacement",
                           "Yaw angle (rotation about Z axis) of the world"
                           + " frame in degrees.").AngleYaw = 0
        if not hasattr(fp, "AnglePitch"):
            fp.addProperty("App::PropertyFloat", "AnglePitch",
                           "FramePlacement", "Pitch angle (rotation about Y"
                           + " axis) of the world frame in degrees."
                           ).AnglePitch = 0
        if not hasattr(fp, "AngleRoll"):
            fp.addProperty("App::PropertyFloat", "AngleRoll", "FramePlacement",
                           "Roll angle (rotation about X axis) of the world"
                           + " frame in degrees.").AngleRoll = 0

        # Frame properties
        if not hasattr(fp, "ShowFrame"):
            fp.addProperty("App::PropertyBool", "ShowFrame", "Frame",
                           "Show a frame for current pose."
                           ).ShowFrame = True
        if not hasattr(fp, "FrameTransparency"):
            fp.addProperty("App::PropertyPercent", "FrameTransparency",
                           "Frame", "Transparency of the frame in percents."
                           ).FrameTransparency = 0
        if not hasattr(fp, "ShowFrameArrowheads"):
            fp.addProperty("App::PropertyBool", "ShowFrameArrowheads", "Frame",
                           "Show arrowheads for frame axis arrow's."
                           ).ShowFrameArrowheads = True
        if not hasattr(fp, "FrameArrowheadLength"):
            fp.addProperty("App::PropertyFloatConstraint",
                           "FrameArrowheadLength", "Frame",
                           "Frame axis arrow's arrowhead length.\n"
                           + "Range is < 1.0 | 1e6 >."
                           ).FrameArrowheadLength = (10, 1.0, 1e6, 1)
        else:
            fp.FrameArrowheadLength = (fp.FrameArrowheadLength, 1.0, 1e6, 1)
        if not hasattr(fp, "FrameArrowheadRadius"):
            fp.addProperty("App::PropertyFloatConstraint",
                           "FrameArrowheadRadius", "Frame",
                           "Frame axis arrow's arrowhead bottom radius.\n"
                           + "Range is < 0.5 | 1e6 >."
                           ).FrameArrowheadRadius = (5, 0.5, 1e6, 0.5)
        else:
            fp.FrameArrowheadRadius = (fp.FrameArrowheadRadius, 0.5, 1e6, 0.5)
        if not hasattr(fp, "ShaftLength"):
            fp.addProperty("App::PropertyFloatConstraint", "ShaftLength",
                           "Frame", "Frame axis arrow's shaft length.\n"
                           + "Range is < 1.0 | 1e6 >."
                           ).ShaftLength = (20, 1.0, 1e6, 1)
        else:
            fp.ShaftLength = (fp.ShaftLength, 1.0, 1e6, 1)
        if not hasattr(fp, "ShaftWidth"):
            fp.addProperty("App::PropertyFloatConstraint", "ShaftWidth",
                           "Frame", "Frame axis arrow's shaft width.\n"
                           + "Range is < 1.0 | 64 >."
                           ).ShaftWidth = (4, 1.0, 64, 1)
        else:
            fp.ShaftWidth = (fp.ShaftWidth, 1.0, 64, 1)
        if not hasattr(fp, "ShowFrameLabels"):
            fp.addProperty("App::PropertyBool", "ShowFrameLabels",
                           "Frame", "Show label for frame axes."
                           ).ShowFrameLabels = True

        # Label properties
        if not hasattr(fp, "FontSize"):
            fp.addProperty("App::PropertyIntegerConstraint", "FontSize",
                           "Labels", "Label font size.\n"
                           + "Range is < 1 | 100 >."
                           ).FontSize = (10, 1, 100, 1)
        else:
            fp.FontSize = (fp.FontSize, 1, 100, 1)
        if not hasattr(fp, "DistanceToAxis"):
            fp.addProperty("App::PropertyFloatConstraint", "DistanceToAxis",
                           "Labels", "Distance from label to its axis.\n"
                           + "Range is < 0.5 | 1e6 >."
                           ).DistanceToAxis = (5, 0.5, 1e6, 0.5)
        else:
            fp.DistanceToAxis = (fp.DistanceToAxis, 0.5, 1e6, 0.5)
        if not hasattr(fp, "Subscription"):
            fp.addProperty("App::PropertyString", "Subscription", "Labels",
                           "Subscription added to an axis name."
                           ).Subscription = ""
        if not hasattr(fp, "Superscription"):
            fp.addProperty("App::PropertyString", "Superscription", "Labels",
                           "Superscription added to an axis name."
                           ).Superscription = ""
        if not hasattr(fp, "FontFamily"):
            fp.addProperty("App::PropertyEnumeration", "FontFamily",
                           "Labels", "Label font family."
                           ).FontFamily = ["SERIF", "SANS", "TYPEWRITER"]
        if not hasattr(fp, "FontStyle"):
            fp.addProperty("App::PropertyEnumeration", "FontStyle",
                           "Labels", "Label font style."
                           ).FontStyle = ["NONE", "BOLD", "ITALIC",
                                          "BOLD ITALIC"]

        # Placement properties
        if not hasattr(fp, "Placement"):
            fp.addProperty("App::PropertyPlacement", "Placement", "Base",
                           "Current placement for animated objects in "
                           + "world frame.")

        # Hide some properties
        fp.setEditorMode("Placement", 2)

        import AnimateDocumentObserver
        AnimateDocumentObserver.addObserver()

---

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

• Doxypypy outputs/RobWorld.py