spire-presentation 11.2.0__py3-none-macosx_11_0_arm64.whl

spire/presentation/animation/GraphicAnimationCollection.py

@@ -0,0 +1,134 @@
+from enum import Enum
+from plum import dispatch
+from typing import TypeVar,Union,Generic,List,Tuple
+from spire.presentation.common import *
+from spire.presentation import *
+from ctypes import *
+import abc
+
+class GraphicAnimationCollection (  ICollection, IEnumerable) :
+    """
+    Represent collection of graphic animations.
+
+    """
+    @property
+    def Count(self)->int:
+        """
+        Gets a number of elements in the collection.
+        """
+        GetDllLibPpt().GraphicAnimationCollection_get_Count.argtypes=[c_void_p]
+        GetDllLibPpt().GraphicAnimationCollection_get_Count.restype=c_int
+        ret = CallCFunction(GetDllLibPpt().GraphicAnimationCollection_get_Count,self.Ptr)
+        return ret
+
+    @dispatch
+
+    def get_Item(self ,index:int)->GraphicAnimation:
+        """
+        Gets element by index.
+        
+        Args:
+            index (int): The index of the element.
+            
+        Returns:
+            GraphicAnimation: The animation at the specified index.
+        """
+        
+        GetDllLibPpt().GraphicAnimationCollection_get_Item.argtypes=[c_void_p ,c_int]
+        GetDllLibPpt().GraphicAnimationCollection_get_Item.restype=c_void_p
+        intPtr = CallCFunction(GetDllLibPpt().GraphicAnimationCollection_get_Item,self.Ptr, index)
+        ret = None if intPtr==None else GraphicAnimation(intPtr)
+        return ret
+
+
+#    @dispatch
+#
+#    def get_Item(self ,shape:IShape)->List[GraphicAnimation]:
+#        """
+#    <summary>
+#        Gets all elements 
+#    </summary>
+#    <param name="shape"></param>
+#    <returns></returns>
+#        """
+#        intPtrshape:c_void_p = shape.Ptr
+#
+#        GetDllLibPpt().GraphicAnimationCollection_get_ItemS.argtypes=[c_void_p ,c_void_p]
+#        GetDllLibPpt().GraphicAnimationCollection_get_ItemS.restype=IntPtrArray
+#        intPtrArray = CallCFunction(GetDllLibPpt().GraphicAnimationCollection_get_ItemS,self.Ptr, intPtrshape)
+#        ret = GetObjVectorFromArray(intPtrArray, GraphicAnimation)
+#        return ret
+
+
+
+    def Equals(self ,obj:'SpireObject')->bool:
+        """
+        Determines whether the current collection is equal to another object.
+        
+        Args:
+            obj (SpireObject): The object to compare with.
+            
+        Returns:
+            bool: True if the objects are equal, otherwise False.
+        """
+        intPtrobj:c_void_p = obj.Ptr
+
+        GetDllLibPpt().GraphicAnimationCollection_Equals.argtypes=[c_void_p ,c_void_p]
+        GetDllLibPpt().GraphicAnimationCollection_Equals.restype=c_bool
+        ret = CallCFunction(GetDllLibPpt().GraphicAnimationCollection_Equals,self.Ptr, intPtrobj)
+        return ret
+
+
+    def GetEnumerator(self)->'IEnumerator':
+        """
+        Gets an iterator for the collection.
+        
+        Returns:
+            IEnumerator: An iterator object.
+        """
+        GetDllLibPpt().GraphicAnimationCollection_GetEnumerator.argtypes=[c_void_p]
+        GetDllLibPpt().GraphicAnimationCollection_GetEnumerator.restype=c_void_p
+        intPtr = CallCFunction(GetDllLibPpt().GraphicAnimationCollection_GetEnumerator,self.Ptr)
+        ret = None if intPtr==None else IEnumerator(intPtr)
+        return ret
+
+
+#
+#    def CopyTo(self ,array:'Array',index:int):
+#        """
+#    <summary>
+#        Copies all elements from the collection into the specified array.
+#    </summary>
+#    <param name="array">Array to fill.</param>
+#    <param name="index">Starting position in target array.</param>
+#        """
+#        intPtrarray:c_void_p = array.Ptr
+#
+#        GetDllLibPpt().GraphicAnimationCollection_CopyTo.argtypes=[c_void_p ,c_void_p,c_int]
+#        CallCFunction(GetDllLibPpt().GraphicAnimationCollection_CopyTo,self.Ptr, intPtrarray,index)
+
+
+    @property
+    def IsSynchronized(self)->bool:
+        """
+        Gets a value indicating whether access to the collection is synchronized (thread-safe).
+        """
+        GetDllLibPpt().GraphicAnimationCollection_get_IsSynchronized.argtypes=[c_void_p]
+        GetDllLibPpt().GraphicAnimationCollection_get_IsSynchronized.restype=c_bool
+        ret = CallCFunction(GetDllLibPpt().GraphicAnimationCollection_get_IsSynchronized,self.Ptr)
+        return ret
+
+    @property
+
+    def SyncRoot(self)->'SpireObject':
+        """
+        Gets a synchronization root.
+        Readonly.
+        """
+        GetDllLibPpt().GraphicAnimationCollection_get_SyncRoot.argtypes=[c_void_p]
+        GetDllLibPpt().GraphicAnimationCollection_get_SyncRoot.restype=c_void_p
+        intPtr = CallCFunction(GetDllLibPpt().GraphicAnimationCollection_get_SyncRoot,self.Ptr)
+        ret = None if intPtr==None else SpireObject(intPtr)
+        return ret
+
+

spire/presentation/animation/GraphicBuildType.py

@@ -0,0 +1,25 @@
+from enum import Enum
+from plum import dispatch
+from typing import TypeVar,Union,Generic,List,Tuple
+from spire.presentation.common import *
+from spire.presentation import *
+from ctypes import *
+import abc
+
+class GraphicBuildType(Enum):
+    """
+    Indicates how graphic display style during animation.
+    
+    Attributes:
+        BuildAsOne: The entire graphic is built as one object.
+        BuildAsSeries: The graphic is built by series.
+        BuildAsCategory: The graphic is built by category.
+        BuildAsSeriesElement: The graphic is built by series elements.
+        BuildAsCategoryElement: The graphic is built by category elements.
+    """
+    BuildAsOne = 0
+    BuildAsSeries = 1
+    BuildAsCategory = 2
+    BuildAsSeriesElement = 3
+    BuildAsCategoryElement = 4
+

spire/presentation/animation/MotionCmdPath.py

@@ -0,0 +1,115 @@
+from enum import Enum
+from plum import dispatch
+from typing import TypeVar,Union,Generic,List,Tuple
+from spire.presentation.common import *
+from spire.presentation import *
+from ctypes import *
+import abc
+
+class MotionCmdPath (SpireObject) :
+    """
+    Represents a single command segment within an animation motion path.
+    """
+    @property
+
+    def Points(self)->List['PointF']:
+        """
+        Gets the collection of points defining the path segment.
+        
+        Returns:
+            List[PointF]: Array of point coordinates
+        """
+        GetDllLibPpt().MotionCmdPath_get_Points.argtypes=[c_void_p]
+        GetDllLibPpt().MotionCmdPath_get_Points.restype=IntPtrArray
+        intPtrArray = CallCFunction(GetDllLibPpt().MotionCmdPath_get_Points,self.Ptr)
+        ret = GetObjVectorFromArray(intPtrArray, PointF)
+        return ret
+
+
+#    @Points.setter
+#    def Points(self, value:List['PointF']):
+#        vCount = len(value)
+#        ArrayType = c_void_p * vCount
+#        vArray = ArrayType()
+#        for i in range(0, vCount):
+#            vArray[i] = value[i].Ptr
+#        GetDllLibPpt().MotionCmdPath_set_Points.argtypes=[c_void_p, ArrayType, c_int]
+#        CallCFunction(GetDllLibPpt().MotionCmdPath_set_Points,self.Ptr, vArray, vCount)
+
+
+    @property
+
+    def CommandType(self)->'MotionCommandPathType':
+        """
+        Gets or sets the command type for this path segment.
+        
+        Returns:
+            MotionCommandPathType: Current command type
+        """
+        GetDllLibPpt().MotionCmdPath_get_CommandType.argtypes=[c_void_p]
+        GetDllLibPpt().MotionCmdPath_get_CommandType.restype=c_int
+        ret = CallCFunction(GetDllLibPpt().MotionCmdPath_get_CommandType,self.Ptr)
+        objwraped = MotionCommandPathType(ret)
+        return objwraped
+
+    @CommandType.setter
+    def CommandType(self, value:'MotionCommandPathType'):
+        """
+        Sets the command type for this path segment.
+        
+        Args:
+            value (MotionCommandPathType): New command type
+        """
+        GetDllLibPpt().MotionCmdPath_set_CommandType.argtypes=[c_void_p, c_int]
+        CallCFunction(GetDllLibPpt().MotionCmdPath_set_CommandType,self.Ptr, value.value)
+
+    @property
+    def IsRelative(self)->bool:
+        """
+        Determines if path coordinates are relative to starting position.
+        
+        Returns:
+            bool: True if coordinates are relative
+        """
+        GetDllLibPpt().MotionCmdPath_get_IsRelative.argtypes=[c_void_p]
+        GetDllLibPpt().MotionCmdPath_get_IsRelative.restype=c_bool
+        ret = CallCFunction(GetDllLibPpt().MotionCmdPath_get_IsRelative,self.Ptr)
+        return ret
+
+    @IsRelative.setter
+    def IsRelative(self, value:bool):
+        """
+        Sets whether path coordinates are relative to starting position.
+        
+        Args:
+            value (bool): True for relative coordinates
+        """
+        GetDllLibPpt().MotionCmdPath_set_IsRelative.argtypes=[c_void_p, c_bool]
+        CallCFunction(GetDllLibPpt().MotionCmdPath_set_IsRelative,self.Ptr, value)
+
+    @property
+
+    def PointsType(self)->'MotionPathPointsType':
+        """
+        Gets or sets the interpretation method for path points.
+        
+        Returns:
+            MotionPathPointsType: Current points interpretation
+        """
+        GetDllLibPpt().MotionCmdPath_get_PointsType.argtypes=[c_void_p]
+        GetDllLibPpt().MotionCmdPath_get_PointsType.restype=c_int
+        ret = CallCFunction(GetDllLibPpt().MotionCmdPath_get_PointsType,self.Ptr)
+        objwraped = MotionPathPointsType(ret)
+        return objwraped
+
+    @PointsType.setter
+    def PointsType(self, value:'MotionPathPointsType'):
+        """
+        Sets the interpretation method for path points.
+        
+        Args:
+            value (MotionPathPointsType): New points interpretation
+        """
+        GetDllLibPpt().MotionCmdPath_set_PointsType.argtypes=[c_void_p, c_int]
+        CallCFunction(GetDllLibPpt().MotionCmdPath_set_PointsType,self.Ptr, value.value)
+

spire/presentation/animation/MotionCommandPathType.py

@@ -0,0 +1,25 @@
+from enum import Enum
+from plum import dispatch
+from typing import TypeVar,Union,Generic,List,Tuple
+from spire.presentation.common import *
+from spire.presentation import *
+from ctypes import *
+import abc
+
+class MotionCommandPathType(Enum):
+    """
+    Defines command types for animation motion path segments.
+    
+    Attributes:
+        MoveTo: Represents a move-to command (reposition without drawing)
+        LineTo: Represents a straight line path segment
+        CurveTo: Represents a curved path segment (Bezier)
+        CloseLoop: Closes the current path loop
+        End: Terminates the path definition
+    """
+    MoveTo = 0
+    LineTo = 1
+    CurveTo = 2
+    CloseLoop = 3
+    End = 4
+

spire/presentation/animation/MotionPath.py

@@ -0,0 +1,120 @@
+from enum import Enum
+from plum import dispatch
+from typing import TypeVar,Union,Generic,List,Tuple
+from spire.presentation.common import *
+from spire.presentation import *
+from ctypes import *
+import abc
+
+class MotionPath ( SpireObject ) :
+    """
+    Represents a complete animation motion path composed of command segments.
+    
+    """
+
+    @dispatch
+    def __init__(self):
+        """
+        Initializes a new empty MotionPath instance.
+        """
+        GetDllLibPpt().MotionPath_CreateMotionPath.restype = c_void_p
+        intPtr = CallCFunction(GetDllLibPpt().MotionPath_CreateMotionPath)
+        super(MotionPath, self).__init__(intPtr)
+    """
+
+    """
+    @dispatch
+    def __getitem__(self, key):
+        """
+        Gets the path command segment at the specified index.
+        
+        Args:
+            key (int): Segment index
+            
+        Returns:
+            MotionCmdPath: Path command segment
+        """
+        if key >= self.Count:
+            raise StopIteration
+        GetDllLibPpt().MotionPath_get_Item.argtypes=[c_void_p ,c_int]
+        GetDllLibPpt().MotionPath_get_Item.restype=c_void_p
+        intPtr = CallCFunction(GetDllLibPpt().MotionPath_get_Item,self.Ptr, key)
+        ret = None if intPtr==None else MotionCmdPath(intPtr)
+        return ret
+
+    def Add(self ,pathType:'MotionCommandPathType',pts:'PointF[]',ptsType:'MotionPathPointsType',bRelativeCoord:bool)->int:
+        """
+        Adds a new command segment to the motion path.
+        
+        Args:
+            pathType (MotionCommandPathType): Type of path command
+            pts (List[PointF]): Control points for the segment
+            ptsType (MotionPathPointsType): Interpretation method for points
+            bRelativeCoord (bool): Whether coordinates are relative
+            
+        Returns:
+            int: Index of the newly added command segment
+        """
+        enumtype:c_int = pathType.value
+        #arraypts:ArrayTypepts = ""
+        countpts = len(pts)
+        ArrayTypepts = c_void_p * countpts
+        arraypts = ArrayTypepts()
+        for i in range(0, countpts):
+            arraypts[i] = pts[i].Ptr
+
+        enumptsType:c_int = ptsType.value
+
+        GetDllLibPpt().MotionPath_Add.argtypes=[c_void_p ,c_int,ArrayTypepts,c_int,c_int,c_bool]
+        GetDllLibPpt().MotionPath_Add.restype=c_int
+        ret = CallCFunction(GetDllLibPpt().MotionPath_Add,self.Ptr, enumtype,arraypts,countpts,enumptsType,bRelativeCoord)
+        return ret
+
+
+    @property
+    def Count(self)->int:
+        """
+        Gets the number of command segments in the motion path.
+        
+        Returns:
+            int: Total segment count
+        """
+        GetDllLibPpt().MotionPath_get_Count.argtypes=[c_void_p]
+        GetDllLibPpt().MotionPath_get_Count.restype=c_int
+        ret = CallCFunction(GetDllLibPpt().MotionPath_get_Count,self.Ptr)
+        return ret
+
+
+    def get_Item(self ,index:int)->'MotionCmdPath':
+        """
+        Retrieves a specific path command segment by index.
+        
+        Args:
+            index (int): Zero-based segment index
+            
+        Returns:
+            MotionCmdPath: Path command segment object
+        """
+        
+        GetDllLibPpt().MotionPath_get_Item.argtypes=[c_void_p ,c_int]
+        GetDllLibPpt().MotionPath_get_Item.restype=c_void_p
+        intPtr = CallCFunction(GetDllLibPpt().MotionPath_get_Item,self.Ptr, index)
+        ret = None if intPtr==None else MotionCmdPath(intPtr)
+        return ret
+
+
+
+    def GetEnumerator(self)->'IEnumerator':
+        """
+        Gets an iterator for traversing all command segments.
+        
+        Returns:
+            IEnumerator: Enumerator object for path segments
+        """
+        GetDllLibPpt().MotionPath_GetEnumerator.argtypes=[c_void_p]
+        GetDllLibPpt().MotionPath_GetEnumerator.restype=c_void_p
+        intPtr = CallCFunction(GetDllLibPpt().MotionPath_GetEnumerator,self.Ptr)
+        ret = None if intPtr==None else IEnumerator(intPtr)
+        return ret
+
+

spire/presentation/animation/MotionPathPointsType.py

@@ -0,0 +1,33 @@
+from enum import Enum
+from plum import dispatch
+from typing import TypeVar,Union,Generic,List,Tuple
+from spire.presentation.common import *
+from spire.presentation import *
+from ctypes import *
+import abc
+
+class MotionPathPointsType(Enum):
+    """
+    Specifies the types of points used in animation motion paths.
+    
+    Attributes:
+        none: No specific point type.
+        Auto: Automatically determined point type.
+        Corner: Point represents a sharp corner in the path.
+        Straight: Point connects straight path segments.
+        Smooth: Point creates a smooth curved path.
+        CurveAuto: Automatically determined curve point.
+        CurveCorner: Curve point with sharp corner behavior.
+        CurveStraight: Curve point connecting straight segments.
+        CurveSmooth: Curve point creating smooth transitions.
+    """
+    none = 0
+    Auto = 1
+    Corner = 2
+    Straight = 3
+    Smooth = 4
+    CurveAuto = 5
+    CurveCorner = 6
+    CurveStraight = 7
+    CurveSmooth = 8
+

spire/presentation/animation/ParagraphBuildType.py

@@ -0,0 +1,31 @@
+from enum import Enum
+from plum import dispatch
+from typing import TypeVar,Union,Generic,List,Tuple
+from spire.presentation.common import *
+from spire.presentation import *
+from ctypes import *
+import abc
+
+class ParagraphBuildType(Enum):
+    """
+    Specifies how text is displayed during animation sequences.
+    
+    Attributes:
+        Whole: Display the entire paragraph at once
+        AllAtOnce: Display all paragraphs simultaneously
+        Paragraphs1: Build by individual paragraphs (level 1)
+        Paragraphs2: Build by individual paragraphs (level 2)
+        Paragraphs3: Build by individual paragraphs (level 3)
+        Paragraphs4: Build by individual paragraphs (level 4)
+        Paragraphs5: Build by individual paragraphs (level 5)
+        cust: Custom build behavior
+    """
+    Whole = 0
+    AllAtOnce = 1
+    Paragraphs1 = 2
+    Paragraphs2 = 3
+    Paragraphs3 = 4
+    Paragraphs4 = 5
+    Paragraphs5 = 6
+    cust = 7
+

spire/presentation/animation/PropertyValueType.py

@@ -0,0 +1,23 @@
+from enum import Enum
+from plum import dispatch
+from typing import TypeVar,Union,Generic,List,Tuple
+from spire.presentation.common import *
+from spire.presentation import *
+from ctypes import *
+import abc
+
+class PropertyValueType(Enum):
+    """
+    Specifies the data type of a property value in presentation elements.
+    
+    Attributes:
+        none (-1): Uninitialized or undefined property value type
+        String (0): Property value is a text string
+        Number (1): Property value is a numerical value
+        Color (2): Property value specifies a color
+    """
+    none = -1
+    String = 0
+    Number = 1
+    Color = 2
+

spire/presentation/animation/SequenceCollection.py

@@ -0,0 +1,111 @@
+from enum import Enum
+from plum import dispatch
+from typing import TypeVar,Union,Generic,List,Tuple
+from spire.presentation.common import *
+from spire.presentation import *
+from ctypes import *
+import abc
+
+class SequenceCollection (  IEnumerable) :
+    """
+    Manages interactive animation sequences for presentation objects.
+    """
+    @property
+    def Count(self)->int:
+        """
+        Gets the total number of animation sequences.
+        
+        Returns:
+            int: Count of animation sequences.
+        """
+        GetDllLibPpt().SequenceCollection_get_Count.argtypes=[c_void_p]
+        GetDllLibPpt().SequenceCollection_get_Count.restype=c_int
+        ret = CallCFunction(GetDllLibPpt().SequenceCollection_get_Count,self.Ptr)
+        return ret
+
+
+    def Add(self ,shape:'IShape')->'AnimationEffectCollection':
+        """
+        Creates a new animation sequence for a shape.
+        
+        Args:
+            shape: Target shape to animate.
+            
+        Returns:
+            AnimationEffectCollection: New animation sequence container.
+        """
+        intPtrshape:c_void_p = shape.Ptr
+
+        GetDllLibPpt().SequenceCollection_Add.argtypes=[c_void_p ,c_void_p]
+        GetDllLibPpt().SequenceCollection_Add.restype=c_void_p
+        intPtr = CallCFunction(GetDllLibPpt().SequenceCollection_Add,self.Ptr, intPtrshape)
+        ret = None if intPtr==None else AnimationEffectCollection(intPtr)
+        return ret
+
+
+
+    def Remove(self ,item:'AnimationEffectCollection'):
+        """
+        Deletes a specific animation sequence.
+        
+        Args:
+            item: Animation sequence to remove.
+        """
+        intPtritem:c_void_p = item.Ptr
+
+        GetDllLibPpt().SequenceCollection_Remove.argtypes=[c_void_p ,c_void_p]
+        CallCFunction(GetDllLibPpt().SequenceCollection_Remove,self.Ptr, intPtritem)
+
+
+    def RemoveAt(self ,index:int):
+        """
+        Deletes an animation sequence by position index.
+        
+        Args:
+            index: Zero-based sequence index.
+        """
+        
+        GetDllLibPpt().SequenceCollection_RemoveAt.argtypes=[c_void_p ,c_int]
+        CallCFunction(GetDllLibPpt().SequenceCollection_RemoveAt,self.Ptr, index)
+
+    def Clear(self):
+        """
+        Removes all animation sequences from the collection.
+        """
+        GetDllLibPpt().SequenceCollection_Clear.argtypes=[c_void_p]
+        CallCFunction(GetDllLibPpt().SequenceCollection_Clear,self.Ptr)
+
+
+    def get_Item(self ,index:int)->'AnimationEffectCollection':
+        """
+        Retrieves an animation sequence by index.
+        
+        Args:
+            index: Zero-based sequence index.
+            
+        Returns:
+            AnimationEffectCollection: Animation sequence object.
+        """
+        
+        GetDllLibPpt().SequenceCollection_get_Item.argtypes=[c_void_p ,c_int]
+        GetDllLibPpt().SequenceCollection_get_Item.restype=c_void_p
+        intPtr = CallCFunction(GetDllLibPpt().SequenceCollection_get_Item,self.Ptr, index)
+        ret = None if intPtr==None else AnimationEffectCollection(intPtr)
+        return ret
+
+
+
+    def GetEnumerator(self)->'IEnumerator':
+        """
+        Gets an iterator to traverse the sequence collection.
+        
+        Returns:
+            IEnumerator: Iterator object.
+        """
+        GetDllLibPpt().SequenceCollection_GetEnumerator.argtypes=[c_void_p]
+        GetDllLibPpt().SequenceCollection_GetEnumerator.restype=c_void_p
+        intPtr = CallCFunction(GetDllLibPpt().SequenceCollection_GetEnumerator,self.Ptr)
+        ret = None if intPtr==None else IEnumerator(intPtr)
+        return ret
+
+