spire-presentation 11.2.0__py3-none-macosx_11_0_arm64.whl

spire/presentation/transition/LRTransition.py

@@ -0,0 +1,47 @@
+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 LRTransition (  Transition) :
+    """Represents a left-right slide transition effect."""
+    @property
+
+    def Direction(self)->'TransitionTwoDirection':
+        """Gets or sets the direction of the transition effect.
+        
+        Returns:
+            TransitionTwoDirection: Current transition direction
+        """
+        GetDllLibPpt().LRTransition_get_Direction.argtypes=[c_void_p]
+        GetDllLibPpt().LRTransition_get_Direction.restype=c_int
+        ret = CallCFunction(GetDllLibPpt().LRTransition_get_Direction,self.Ptr)
+        objwraped = TransitionTwoDirection(ret)
+        return objwraped
+
+    @Direction.setter
+    def Direction(self, value:'TransitionTwoDirection'):
+        GetDllLibPpt().LRTransition_set_Direction.argtypes=[c_void_p, c_int]
+        CallCFunction(GetDllLibPpt().LRTransition_set_Direction,self.Ptr, value.value)
+
+
+    def Equals(self ,obj:'SpireObject')->bool:
+        """
+        Determines whether the current LRTransition is equal to another object.
+        
+        Args:
+            obj (SpireObject): The object to compare with
+            
+        Returns:
+            bool: True if equal, otherwise False
+        """
+        intPtrobj:c_void_p = obj.Ptr
+
+        GetDllLibPpt().LRTransition_Equals.argtypes=[c_void_p ,c_void_p]
+        GetDllLibPpt().LRTransition_Equals.restype=c_bool
+        ret = CallCFunction(GetDllLibPpt().LRTransition_Equals,self.Ptr, intPtrobj)
+        return ret
+

spire/presentation/transition/OptionalBlackTransition.py

@@ -0,0 +1,52 @@
+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 OptionalBlackTransition (  Transition) :
+    """
+    Represents an optional black slide transition effect between slides.
+    This transition effect can optionally start from a black screen before transitioning to the new slide.
+    
+    Attributes:
+        FromBlack (bool): Controls whether the transition starts from a black screen.
+    """
+    @property
+    def FromBlack(self)->bool:
+        """
+        Determines if the transition starts from a black screen.
+        
+        Returns:
+            bool: True if the transition starts from a black screen; otherwise, False.
+        """
+        GetDllLibPpt().OptionalBlackTransition_get_FromBlack.argtypes=[c_void_p]
+        GetDllLibPpt().OptionalBlackTransition_get_FromBlack.restype=c_bool
+        ret = CallCFunction(GetDllLibPpt().OptionalBlackTransition_get_FromBlack,self.Ptr)
+        return ret
+
+    @FromBlack.setter
+    def FromBlack(self, value:bool):
+        GetDllLibPpt().OptionalBlackTransition_set_FromBlack.argtypes=[c_void_p, c_bool]
+        CallCFunction(GetDllLibPpt().OptionalBlackTransition_set_FromBlack,self.Ptr, value)
+
+
+    def Equals(self ,obj:'SpireObject')->bool:
+        """
+        Determines whether the specified object is equal to the current transition object.
+        
+        Args:
+            obj (SpireObject): The object to compare with the current object.
+        
+        Returns:
+            bool: True if the specified object is equal to the current object; otherwise, False.
+        """
+        intPtrobj:c_void_p = obj.Ptr
+
+        GetDllLibPpt().OptionalBlackTransition_Equals.argtypes=[c_void_p ,c_void_p]
+        GetDllLibPpt().OptionalBlackTransition_Equals.restype=c_bool
+        ret = CallCFunction(GetDllLibPpt().OptionalBlackTransition_Equals,self.Ptr, intPtrobj)
+        return ret
+

spire/presentation/transition/RevealTransition.py

@@ -0,0 +1,51 @@
+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 RevealTransition (  Transition) :
+    """
+    Represents the Reveal slide transition effect.
+    Inherits from: Transition class
+    """
+    @property
+
+    def Direction(self)->'TransitionRevealLRDirection':
+        """
+        Gets or sets the direction of the Reveal transition effect.
+
+        Returns:
+            TransitionRevealLRDirection: The current direction setting of the transition.
+        """
+        GetDllLibPpt().RevealTransition_get_Direction.argtypes=[c_void_p]
+        GetDllLibPpt().RevealTransition_get_Direction.restype=c_int
+        ret = CallCFunction(GetDllLibPpt().RevealTransition_get_Direction,self.Ptr)
+        objwraped = TransitionRevealLRDirection(ret)
+        return objwraped
+
+    @Direction.setter
+    def Direction(self, value:'TransitionRevealLRDirection'):
+        GetDllLibPpt().RevealTransition_set_Direction.argtypes=[c_void_p, c_int]
+        CallCFunction(GetDllLibPpt().RevealTransition_set_Direction,self.Ptr, value.value)
+
+
+    def Equals(self ,obj:'SpireObject')->bool:
+        """
+        Determines whether the current RevealTransition 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().RevealTransition_Equals.argtypes=[c_void_p ,c_void_p]
+        GetDllLibPpt().RevealTransition_Equals.restype=c_bool
+        ret = CallCFunction(GetDllLibPpt().RevealTransition_Equals,self.Ptr, intPtrobj)
+        return ret
+

spire/presentation/transition/ShredTransition.py

@@ -0,0 +1,52 @@
+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 ShredTransition (  Transition) :
+    """
+    Represents a shred paper transition effect between slides.
+    
+    Inherits from Transition base class and controls the shredding direction.
+    """
+    @property
+
+    def Direction(self)->'TransitionShredInOutDirection':
+        """
+        Gets or sets the shred direction.
+        
+        Returns:
+            TransitionShredInOutDirection: Current shred direction.
+        """
+        GetDllLibPpt().ShredTransition_get_Direction.argtypes=[c_void_p]
+        GetDllLibPpt().ShredTransition_get_Direction.restype=c_int
+        ret = CallCFunction(GetDllLibPpt().ShredTransition_get_Direction,self.Ptr)
+        objwraped = TransitionShredInOutDirection(ret)
+        return objwraped
+
+    @Direction.setter
+    def Direction(self, value:'TransitionShredInOutDirection'):
+        GetDllLibPpt().ShredTransition_set_Direction.argtypes=[c_void_p, c_int]
+        CallCFunction(GetDllLibPpt().ShredTransition_set_Direction,self.Ptr, value.value)
+
+
+    def Equals(self ,obj:'SpireObject')->bool:
+        """
+        Determines if objects are equivalent.
+        
+        Args:
+            obj: Object to compare with.
+            
+        Returns:
+            bool: True if objects are equal.
+        """
+        intPtrobj:c_void_p = obj.Ptr
+
+        GetDllLibPpt().ShredTransition_Equals.argtypes=[c_void_p ,c_void_p]
+        GetDllLibPpt().ShredTransition_Equals.restype=c_bool
+        ret = CallCFunction(GetDllLibPpt().ShredTransition_Equals,self.Ptr, intPtrobj)
+        return ret
+

spire/presentation/transition/SideDirectionTransition.py

@@ -0,0 +1,50 @@
+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 SideDirectionTransition (  Transition) :
+    """
+    Represents a side direction slide transition effect.
+    """
+    @property
+
+    def Direction(self)->'TransitionSideDirectionType':
+        """
+        Gets the current direction of the transition effect.
+        
+        Returns:
+            TransitionSideDirectionType: The current transition direction value.
+        """
+        GetDllLibPpt().SideDirectionTransition_get_Direction.argtypes=[c_void_p]
+        GetDllLibPpt().SideDirectionTransition_get_Direction.restype=c_int
+        ret = CallCFunction(GetDllLibPpt().SideDirectionTransition_get_Direction,self.Ptr)
+        objwraped = TransitionSideDirectionType(ret)
+        return objwraped
+
+    @Direction.setter
+    def Direction(self, value:'TransitionSideDirectionType'):
+        GetDllLibPpt().SideDirectionTransition_set_Direction.argtypes=[c_void_p, c_int]
+        CallCFunction(GetDllLibPpt().SideDirectionTransition_set_Direction,self.Ptr, value.value)
+
+
+    def Equals(self ,obj:'SpireObject')->bool:
+        """
+        Determines whether the current object is equal to another object.
+        
+        Args:
+            obj (SpireObject): The object to compare with the current object.
+            
+        Returns:
+            bool: True if the objects are equal; otherwise False.
+        """
+        intPtrobj:c_void_p = obj.Ptr
+
+        GetDllLibPpt().SideDirectionTransition_Equals.argtypes=[c_void_p ,c_void_p]
+        GetDllLibPpt().SideDirectionTransition_Equals.restype=c_bool
+        ret = CallCFunction(GetDllLibPpt().SideDirectionTransition_Equals,self.Ptr, intPtrobj)
+        return ret
+

spire/presentation/transition/SlideShowTransition.py

@@ -0,0 +1,262 @@
+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 SlideShowTransition (SpireObject) :
+    """
+    Represents slide show transition effects for a presentation slide.
+
+    This class handles various aspects of slide transitions including sound effects, 
+    timing, speed, and visual transition types.
+    """
+
+    @property
+
+    def SoundMode(self)->'TransitionSoundMode':
+        """
+        Gets or sets the sound mode for the slide transition.
+
+        Returns:
+            TransitionSoundMode: The current sound mode setting.
+        """
+        GetDllLibPpt().SlideShowTransition_get_SoundMode.argtypes=[c_void_p]
+        GetDllLibPpt().SlideShowTransition_get_SoundMode.restype=c_int
+        ret = CallCFunction(GetDllLibPpt().SlideShowTransition_get_SoundMode,self.Ptr)
+        objwraped = TransitionSoundMode(ret)
+        return objwraped
+
+    @SoundMode.setter
+    def SoundMode(self, value:'TransitionSoundMode'):
+        GetDllLibPpt().SlideShowTransition_set_SoundMode.argtypes=[c_void_p, c_int]
+        CallCFunction(GetDllLibPpt().SlideShowTransition_set_SoundMode,self.Ptr, value.value)
+
+    @property
+    def BuiltInSound(self)->bool:
+        """
+        Indicates whether the transition sound is a built-in sound.
+
+        Returns:
+            bool: True if using a built-in sound, False otherwise.
+        """
+        GetDllLibPpt().SlideShowTransition_get_BuiltInSound.argtypes=[c_void_p]
+        GetDllLibPpt().SlideShowTransition_get_BuiltInSound.restype=c_bool
+        ret = CallCFunction(GetDllLibPpt().SlideShowTransition_get_BuiltInSound,self.Ptr)
+        return ret
+
+    @BuiltInSound.setter
+    def BuiltInSound(self, value:bool):
+        GetDllLibPpt().SlideShowTransition_set_BuiltInSound.argtypes=[c_void_p, c_bool]
+        CallCFunction(GetDllLibPpt().SlideShowTransition_set_BuiltInSound,self.Ptr, value)
+
+    @property
+    def Loop(self)->bool:
+        """
+        Determines if the sound loops until next sound event.
+
+        Returns:
+            bool: True if sound should loop, False otherwise.
+        """
+        GetDllLibPpt().SlideShowTransition_get_Loop.argtypes=[c_void_p]
+        GetDllLibPpt().SlideShowTransition_get_Loop.restype=c_bool
+        ret = CallCFunction(GetDllLibPpt().SlideShowTransition_get_Loop,self.Ptr)
+        return ret
+
+    @Loop.setter
+    def Loop(self, value:bool):
+        GetDllLibPpt().SlideShowTransition_set_Loop.argtypes=[c_void_p, c_bool]
+        CallCFunction(GetDllLibPpt().SlideShowTransition_set_Loop,self.Ptr, value)
+
+    @property
+    def AdvanceOnClick(self)->bool:
+        """
+        Determines if mouse click advances the slide.
+
+        Returns:
+            bool: True if click advances slide, False otherwise.
+        """
+        GetDllLibPpt().SlideShowTransition_get_AdvanceOnClick.argtypes=[c_void_p]
+        GetDllLibPpt().SlideShowTransition_get_AdvanceOnClick.restype=c_bool
+        ret = CallCFunction(GetDllLibPpt().SlideShowTransition_get_AdvanceOnClick,self.Ptr)
+        return ret
+
+    @AdvanceOnClick.setter
+    def AdvanceOnClick(self, value:bool):
+        GetDllLibPpt().SlideShowTransition_set_AdvanceOnClick.argtypes=[c_void_p, c_bool]
+        CallCFunction(GetDllLibPpt().SlideShowTransition_set_AdvanceOnClick,self.Ptr, value)
+
+    @property
+
+    def AdvanceAfterTime(self)->'int':
+        """
+        Gets auto-advance time in milliseconds.
+
+        Returns:
+            int: Time delay before auto-advancing (0 = no auto-advance).
+        """
+        GetDllLibPpt().SlideShowTransition_get_AdvanceAfterTime.argtypes=[c_void_p]
+        GetDllLibPpt().SlideShowTransition_get_AdvanceAfterTime.restype=c_void_p
+        ret = CallCFunction(GetDllLibPpt().SlideShowTransition_get_AdvanceAfterTime,self.Ptr)
+        return ret
+
+
+    @AdvanceAfterTime.setter
+    def AdvanceAfterTime(self, value:'int'):
+        GetDllLibPpt().SlideShowTransition_set_AdvanceAfterTime.argtypes=[c_void_p, c_int]
+        CallCFunction(GetDllLibPpt().SlideShowTransition_set_AdvanceAfterTime,self.Ptr, value)
+
+    @property
+
+    def Speed(self)->'TransitionSpeed':
+        """
+        Gets transition speed setting.
+
+        Returns:
+            TransitionSpeed: Current transition speed.
+        """
+        GetDllLibPpt().SlideShowTransition_get_Speed.argtypes=[c_void_p]
+        GetDllLibPpt().SlideShowTransition_get_Speed.restype=c_int
+        ret = CallCFunction(GetDllLibPpt().SlideShowTransition_get_Speed,self.Ptr)
+        objwraped = TransitionSpeed(ret)
+        return objwraped
+
+    @Speed.setter
+    def Speed(self, value:'TransitionSpeed'):
+        GetDllLibPpt().SlideShowTransition_set_Speed.argtypes=[c_void_p, c_int]
+        CallCFunction(GetDllLibPpt().SlideShowTransition_set_Speed,self.Ptr, value.value)
+
+    @property
+
+    def Duration(self)->'int':
+        """
+        Gets transition duration in milliseconds.
+
+        Returns:
+            int: Duration of transition effect.
+        """
+        GetDllLibPpt().SlideShowTransition_get_Duration.argtypes=[c_void_p]
+        GetDllLibPpt().SlideShowTransition_get_Duration.restype=c_void_p
+        ret = CallCFunction(GetDllLibPpt().SlideShowTransition_get_Duration,self.Ptr)
+        return ret
+
+
+    @Duration.setter
+    def Duration(self, value:'int'):
+        GetDllLibPpt().SlideShowTransition_set_Duration.argtypes=[c_void_p, c_int]
+        CallCFunction(GetDllLibPpt().SlideShowTransition_set_Duration,self.Ptr, value)
+
+    @property
+
+    def Value(self)->'Transition':
+        """
+        Gets the concrete transition object.
+
+        Returns:
+            Transition: Specific transition effect instance.
+        """
+        GetDllLibPpt().SlideShowTransition_get_Value.argtypes=[c_void_p]
+        GetDllLibPpt().SlideShowTransition_get_Value.restype=IntPtrWithTypeName
+        intPtrWithTypeName = CallCFunction(GetDllLibPpt().SlideShowTransition_get_Value,self.Ptr)
+        ret = None if intPtrWithTypeName==None else self.CreateTransition(intPtrWithTypeName)
+        return ret
+
+    @staticmethod
+    def CreateTransition(intPtrWithTypeName:IntPtrWithTypeName)->'Transition':
+        ret = None
+        if intPtrWithTypeName == None :
+            return ret
+        intPtr = intPtrWithTypeName.intPtr[0] + (intPtrWithTypeName.intPtr[1]<<32)
+        strName = PtrToStr(intPtrWithTypeName.typeName)
+        if(strName == 'Spire.Presentation.Drawing.Transition.BlindsSlideTransition'):
+            ret = BlindsSlideTransition(intPtr)
+        elif (strName == 'Spire.Presentation.Drawing.Transition.FlythroughTransition'):
+            ret = FlythroughTransition(intPtr)
+        elif (strName == 'Spire.Presentation.Drawing.Transition.GlitterTransition'):
+            ret = GlitterTransition(intPtr)
+        elif (strName == 'Spire.Presentation.Drawing.Transition.InvXTransition'):
+            ret = InvXTransition(intPtr)
+        elif (strName == 'Spire.Presentation.Drawing.Transition.LRTransition'):
+            ret = LRTransition(intPtr)
+        elif (strName == 'Spire.Presentation.Drawing.Transition.OptionalBlackTransition'):
+            ret = OptionalBlackTransition(intPtr)
+        elif (strName == 'Spire.Presentation.Drawing.Transition.RevealTransition'):
+            ret = RevealTransition(intPtr)
+        elif (strName == 'Spire.Presentation.Drawing.Transition.ShredTransition'):
+            ret = ShredTransition(intPtr)
+        elif (strName == 'Spire.Presentation.Drawing.Transition.SideDirectionTransition'):
+            ret = SideDirectionTransition(intPtr)
+        elif (strName == 'Spire.Presentation.Drawing.Transition.SplitSlideTransition'):
+            ret = SplitSlideTransition(intPtr)
+        elif (strName == 'Spire.Presentation.Drawing.Transition.StripsSlideTransition'):
+            ret = StripsSlideTransition(intPtr)
+        elif (strName == 'Spire.Presentation.Drawing.Transition.WheelSlideTransition'):
+            ret = WheelSlideTransition(intPtr)
+        elif (strName == 'Spire.Presentation.Drawing.Transition.ZoomSlideTransition'):
+            ret = ZoomSlideTransition(intPtr)
+        else:
+            ret = Transition(intPtr)
+
+        return ret
+
+    @property
+
+    def Type(self)->'TransitionType':
+        """
+        Gets or sets the transition type.
+
+        Returns:
+            TransitionType: Current transition effect type.
+        """
+        GetDllLibPpt().SlideShowTransition_get_Type.argtypes=[c_void_p]
+        GetDllLibPpt().SlideShowTransition_get_Type.restype=c_int
+        ret = CallCFunction(GetDllLibPpt().SlideShowTransition_get_Type,self.Ptr)
+        objwraped = TransitionType(ret)
+        return objwraped
+
+    @Type.setter
+    def Type(self, value:'TransitionType'):
+        GetDllLibPpt().SlideShowTransition_set_Type.argtypes=[c_void_p, c_int]
+        CallCFunction(GetDllLibPpt().SlideShowTransition_set_Type,self.Ptr, value.value)
+
+    @property
+
+    def Option(self)->'SpireObject':
+        """
+        Gets transition options object.
+
+        Returns:
+            SpireObject: Additional transition configuration options.
+        """
+        GetDllLibPpt().SlideShowTransition_get_Option.argtypes=[c_void_p]
+        GetDllLibPpt().SlideShowTransition_get_Option.restype=c_void_p
+        intPtr = CallCFunction(GetDllLibPpt().SlideShowTransition_get_Option,self.Ptr)
+        ret = None if intPtr==None else SpireObject(intPtr)
+        return ret
+
+
+    @Option.setter
+    def Option(self, value:'SpireObject'):
+        GetDllLibPpt().SlideShowTransition_set_Option.argtypes=[c_void_p, c_void_p]
+        CallCFunction(GetDllLibPpt().SlideShowTransition_set_Option,self.Ptr, value.value)
+
+
+    def Equals(self ,obj:'SpireObject')->bool:
+        """
+        Compares this transition with another object.
+
+        Args:
+            obj (SpireObject): Object to compare with.
+
+        Returns:
+            bool: True if objects are equal, False otherwise.
+        """
+        intPtrobj:c_void_p = obj.Ptr
+
+        GetDllLibPpt().SlideShowTransition_Equals.argtypes=[c_void_p ,c_void_p]
+        GetDllLibPpt().SlideShowTransition_Equals.restype=c_bool
+        ret = CallCFunction(GetDllLibPpt().SlideShowTransition_Equals,self.Ptr, intPtrobj)
+        return ret
+

spire/presentation/transition/SplitSlideTransition.py

@@ -0,0 +1,53 @@
+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 SplitSlideTransition (  Transition) :
+    """
+    Represents a split slide transition effect between presentation slides.
+
+    Attributes:
+        Direction (TransitionSplitDirection): Specifies the splitting direction for the transition effect.
+    """
+    @property
+
+    def Direction(self)->'TransitionSplitDirection':
+        """
+        Gets or sets the splitting direction for the transition.
+
+        Returns:
+            TransitionSplitDirection: Current split direction configuration
+        """
+        GetDllLibPpt().SplitSlideTransition_get_Direction.argtypes=[c_void_p]
+        GetDllLibPpt().SplitSlideTransition_get_Direction.restype=c_int
+        ret = CallCFunction(GetDllLibPpt().SplitSlideTransition_get_Direction,self.Ptr)
+        objwraped = TransitionSplitDirection(ret)
+        return objwraped
+
+    @Direction.setter
+    def Direction(self, value:'TransitionSplitDirection'):
+        GetDllLibPpt().SplitSlideTransition_set_Direction.argtypes=[c_void_p, c_int]
+        CallCFunction(GetDllLibPpt().SplitSlideTransition_set_Direction,self.Ptr, value.value)
+
+
+    def Equals(self ,obj:'SpireObject')->bool:
+        """
+        Determines whether the current SplitSlideTransition is equal to another object.
+
+        Args:
+            obj (SpireObject): The object to compare with the current transition
+
+        Returns:
+            bool: True if the objects are equivalent, False otherwise
+        """
+        intPtrobj:c_void_p = obj.Ptr
+
+        GetDllLibPpt().SplitSlideTransition_Equals.argtypes=[c_void_p ,c_void_p]
+        GetDllLibPpt().SplitSlideTransition_Equals.restype=c_bool
+        ret = CallCFunction(GetDllLibPpt().SplitSlideTransition_Equals,self.Ptr, intPtrobj)
+        return ret
+

spire/presentation/transition/StripsSlideTransition.py

@@ -0,0 +1,52 @@
+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 StripsSlideTransition (  Transition) :
+    """
+    Represents a strips-style slide transition effect.
+    
+    Inherits from base Transition class and adds direction control.
+    """
+    @property
+
+    def Direction(self)->'TransitionCornerDirection':
+        """
+        Gets the direction of the transition effect.
+        
+        Returns:
+            TransitionCornerDirection: Current animation direction
+        """
+        GetDllLibPpt().StripsSlideTransition_get_Direction.argtypes=[c_void_p]
+        GetDllLibPpt().StripsSlideTransition_get_Direction.restype=c_int
+        ret = CallCFunction(GetDllLibPpt().StripsSlideTransition_get_Direction,self.Ptr)
+        objwraped = TransitionCornerDirection(ret)
+        return objwraped
+
+    @Direction.setter
+    def Direction(self, value:'TransitionCornerDirection'):
+        GetDllLibPpt().StripsSlideTransition_set_Direction.argtypes=[c_void_p, c_int]
+        CallCFunction(GetDllLibPpt().StripsSlideTransition_set_Direction,self.Ptr, value.value)
+
+
+    def Equals(self ,obj:'SpireObject')->bool:
+        """
+        Compares this object with another for equality.
+        
+        Args:
+            obj (SpireObject): Object to compare with
+        
+        Returns:
+            bool: True if objects are equal, False otherwise
+        """
+        intPtrobj:c_void_p = obj.Ptr
+
+        GetDllLibPpt().StripsSlideTransition_Equals.argtypes=[c_void_p ,c_void_p]
+        GetDllLibPpt().StripsSlideTransition_Equals.restype=c_bool
+        ret = CallCFunction(GetDllLibPpt().StripsSlideTransition_Equals,self.Ptr, intPtrobj)
+        return ret
+

spire/presentation/transition/Transition.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 Transition (  PptObject) :
+    """
+    Represents slide transition effects in a presentation.
+
+    Methods:
+        Equals: Compares with another object for equality.
+    """
+
+    def Equals(self ,obj:'SpireObject')->bool:
+        """
+        Determines whether the specified object is equal to the current Transition object.
+
+        Args:
+            obj (SpireObject): The object to compare with.
+
+        Returns:
+            bool: True if objects are equal, otherwise False.
+        """
+        intPtrobj:c_void_p = obj.Ptr
+
+        GetDllLibPpt().Transition_Equals.argtypes=[c_void_p ,c_void_p]
+        GetDllLibPpt().Transition_Equals.restype=c_bool
+        ret = CallCFunction(GetDllLibPpt().Transition_Equals,self.Ptr, intPtrobj)
+        return ret
+

spire/presentation/transition/TransitionCornerDirection.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 TransitionCornerDirection(Enum):
+    """
+    Specifies corner directions for slide transition effects.
+
+    Attributes:
+        LeftDown: Transition from left-bottom corner.
+        LeftUp: Transition from left-top corner.
+        RightDown: Transition from right-bottom corner.
+        RightUp: Transition from right-top corner.
+        none: No corner direction specified.
+    """
+    LeftDown = 0
+    LeftUp = 1
+    RightDown = 2
+    RightUp = 3
+    none = 4
+