thorvg-python 1.0.1__py3-none-win32.whl

thorvg_python/__init__.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+"""thorvg-python"""
+
+__version__ = "1.0.1"
+
+from .animation import Animation  # type: ignore  # noqa: F401
+from .animation.lottie import LottieAnimation  # type: ignore  # noqa: F401
+from .base import BlendMethod  # type: ignore  # noqa: F401
+from .base import Colorspace  # type: ignore  # noqa: F401
+from .base import ColorStop  # type: ignore  # noqa: F401
+from .base import CompositeMethod  # type: ignore  # noqa: F401
+from .base import EngineBackend  # type: ignore  # noqa: F401
+from .base import FillRule  # type: ignore  # noqa: F401
+from .base import Identifier  # type: ignore  # noqa: F401
+from .base import Matrix  # type: ignore  # noqa: F401
+from .base import MempoolPolicy  # type: ignore  # noqa: F401
+from .base import PathCommand  # type: ignore  # noqa: F401
+from .base import PointStruct  # type: ignore  # noqa: F401
+from .base import Result  # type: ignore  # noqa: F401
+from .base import StrokeCap  # type: ignore  # noqa: F401
+from .base import StrokeFill  # type: ignore  # noqa: F401
+from .base import StrokeJoin  # type: ignore  # noqa: F401
+from .base import TvgType  # type: ignore  # noqa: F401
+from .canvas import Canvas  # type: ignore  # noqa: F401
+from .canvas.sw import SwCanvas  # type: ignore  # noqa: F401
+from .engine import Engine  # type: ignore  # noqa: F401
+from .gradient import Gradient  # type: ignore  # noqa: F401
+from .gradient.linear import LinearGradient  # type: ignore  # noqa: F401
+from .gradient.radial import RadialGradient  # type: ignore  # noqa: F401
+from .paint import Paint  # type: ignore  # noqa: F401
+from .paint.picture import Picture  # type: ignore  # noqa: F401
+from .paint.scene import Scene  # type: ignore  # noqa: F401
+from .paint.shape import Shape  # type: ignore  # noqa: F401
+from .paint.text import Text  # type: ignore  # noqa: F401
+from .saver import Saver  # type: ignore  # noqa: F401

thorvg_python/animation/__init__.py

@@ -0,0 +1,251 @@
+#!/usr/bin/env python3
+import ctypes
+from typing import Optional, Tuple
+
+from ..base import AnimationStruct, PaintStruct, Result
+from ..engine import Engine
+from ..paint.picture import Picture
+
+
+class Animation:
+    """
+    Animation API
+
+    A module for manipulation of animatable images.
+
+    The module supports the display and control of animation frames.
+    """
+
+    def __init__(self, engine: Engine, animation: Optional[AnimationStruct] = None):
+        self.engine = engine
+        self.thorvg_lib = engine.thorvg_lib
+        if animation is None:
+            self._animation = self._new()
+        else:
+            self._animation = animation
+
+    def _new(self) -> AnimationStruct:
+        """Creates a new Animation object.
+
+        Note that you need not call this method as it is auto called when initializing ``Animation()``.
+
+        :return: AnimationStruct A new AnimationStruct object.
+        :rtype: AnimationStruct
+
+        .. versionadded:: 0.13
+        """
+        self.thorvg_lib.tvg_animation_new.restype = ctypes.POINTER(AnimationStruct)
+        return self.thorvg_lib.tvg_animation_new().contents
+
+    def set_frame(
+        self,
+        no: float,
+    ) -> Result:
+        """Specifies the current frame in the animation.
+
+        :param float no: The index of the animation frame to be displayed. The index should be less than the Animation.get_total_frame().
+
+        :return:
+            - INVALID_ARGUMENT An invalid AnimationStruct pointer.
+            - INSUFFICIENT_CONDITION if the given ``no`` is the same as the current frame value.
+            - NOT_SUPPORTED The picture data does not support animations.
+        :rtype: Result
+
+        .. note::
+            For efficiency, ThorVG ignores updates to the new frame value if the difference from the current frame value
+            is less than 0.001. In such cases, it returns ``Result::InsufficientCondition``.
+            Values less than 0.001 may be disregarded and may not be accurately retained by the Animation.
+
+        .. seealso:: Animation.get_total_frame()
+
+        .. versionadded:: 0.13
+        """
+        self.thorvg_lib.tvg_animation_set_frame.argtypes = [
+            ctypes.POINTER(AnimationStruct),
+            ctypes.c_float,
+        ]
+        self.thorvg_lib.tvg_animation_set_frame.restype = Result
+        return self.thorvg_lib.tvg_animation_set_frame(
+            ctypes.pointer(self._animation),
+            ctypes.c_float(no),
+        )
+
+    def get_picture(self) -> Picture:
+        """Retrieves a picture instance associated with this animation instance.
+
+        This function provides access to the picture instance that can be used to load animation formats, such as Lottie(json).
+        After setting up the picture, it can be pushed to the designated canvas, enabling control over animation frames
+        with this Animation instance.
+
+        :return: A picture instance that is tied to this animation.
+        :rtype: Picture
+
+        .. warning::
+            The picture instance is owned by Animation. It should not be deleted manually.
+
+        .. versionadded:: 0.13
+        """
+        self.thorvg_lib.tvg_animation_get_picture.argtypes = [
+            ctypes.POINTER(AnimationStruct),
+        ]
+        self.thorvg_lib.tvg_animation_get_picture.restype = ctypes.POINTER(PaintStruct)
+        return Picture(
+            self.engine,
+            self.thorvg_lib.tvg_animation_get_picture(
+                ctypes.pointer(self._animation),
+            ).contents,
+        )
+
+    def get_frame(self) -> Tuple[Result, float]:
+        """Retrieves the current frame number of the animation.
+
+        :return: INVALID_ARGUMENT An invalid AnimationStruct pointer or ``no``
+        :rtype: Result
+        :return: The current frame number of the animation, between 0 and totalFrame() - 1.
+        :rtype: float
+
+        .. seealso:: Animation.get_total_frame()
+        .. seealso:: Animation.set_frame()
+
+        .. versionadded:: 0.13
+        """
+        no = ctypes.c_float()
+        self.thorvg_lib.tvg_animation_get_frame.argtypes = [
+            ctypes.POINTER(AnimationStruct),
+            ctypes.POINTER(ctypes.c_float),
+        ]
+        self.thorvg_lib.tvg_animation_get_frame.restype = Result
+        result = self.thorvg_lib.tvg_animation_get_frame(
+            ctypes.pointer(self._animation),
+            ctypes.pointer(no),
+        )
+        return result, no.value
+
+    def get_total_frame(self) -> Tuple[Result, float]:
+        """Retrieves the total number of frames in the animation.
+
+        :return: INVALID_ARGUMENT An invalid AnimationStruct pointer or ``cnt``.
+        :rtype: Result
+        :return: The total number of frames in the animation.
+        :rtype: float
+
+        .. note::
+            Frame numbering starts from 0.
+        .. note::
+            If the Picture is not properly configured, this function will return 0.
+
+        .. versionadded:: 0.13
+        """
+        cnt = ctypes.c_float()
+        self.thorvg_lib.tvg_animation_get_total_frame.argtypes = [
+            ctypes.POINTER(AnimationStruct),
+            ctypes.POINTER(ctypes.c_float),
+        ]
+        self.thorvg_lib.tvg_animation_get_total_frame.restype = Result
+        result = self.thorvg_lib.tvg_animation_get_total_frame(
+            ctypes.pointer(self._animation),
+            ctypes.pointer(cnt),
+        )
+        return result, cnt.value
+
+    def get_duration(self) -> Tuple[Result, float]:
+        """Retrieves the duration of the animation in seconds.
+
+        :return: INVALID_ARGUMENT An invalid AnimationStruct pointer or ``duration``.
+        :rtype: Result
+        :return: The duration of the animation in seconds.
+        :rtype: float
+
+        .. note::
+            If the Picture is not properly configured, this function will return 0.
+
+        .. versionadded:: 0.13
+        """
+        duration = ctypes.c_float()
+        self.thorvg_lib.tvg_animation_get_duration.argtypes = [
+            ctypes.POINTER(AnimationStruct),
+            ctypes.POINTER(ctypes.c_float),
+        ]
+        self.thorvg_lib.tvg_animation_get_duration.restype = Result
+        result = self.thorvg_lib.tvg_animation_get_duration(
+            ctypes.pointer(self._animation),
+            ctypes.pointer(duration),
+        )
+        return result, duration.value
+
+    def set_segment(
+        self,
+        begin: float,
+        end: float,
+    ) -> Result:
+        """Specifies the playback segment of the animation.
+
+        :param float begin: segment begin.
+        :param float end: segment end.
+
+        :return:
+            - INSUFFICIENT_CONDITION In case the animation is not loaded.
+            - INVALID_ARGUMENT When the given parameters are out of range.
+        :rtype: Result
+
+        .. note::
+            Experimental API
+        """
+        self.thorvg_lib.tvg_animation_set_segment.argtypes = [
+            ctypes.POINTER(AnimationStruct),
+            ctypes.c_float,
+            ctypes.c_float,
+        ]
+        self.thorvg_lib.tvg_animation_set_segment.restype = Result
+        result = self.thorvg_lib.tvg_animation_set_segment(
+            ctypes.pointer(self._animation),
+            ctypes.c_float(begin),
+            ctypes.c_float(end),
+        )
+        return result
+
+    def get_segment(self) -> Tuple[Result, float, float]:
+        """Gets the current segment.
+
+        :return:
+            - INSUFFICIENT_CONDITION In case the animation is not loaded.
+            - INVALID_ARGUMENT When the given parameters are ``nullptr``.
+        :rtype: Result
+        :return: segment begin.
+        :rtype: float
+        :return: segment end.
+        :rtype: float
+
+        .. note::
+            Experimental API
+        """
+        begin = ctypes.c_float()
+        end = ctypes.c_float()
+        self.thorvg_lib.tvg_animation_get_segment.argtypes = [
+            ctypes.POINTER(AnimationStruct),
+            ctypes.POINTER(ctypes.c_float),
+            ctypes.POINTER(ctypes.c_float),
+        ]
+        self.thorvg_lib.tvg_animation_get_segment.restype = Result
+        result = self.thorvg_lib.tvg_animation_get_segment(
+            ctypes.pointer(self._animation),
+            ctypes.pointer(begin),
+            ctypes.pointer(end),
+        )
+        return result, begin.value, end.value
+
+    def _del(self) -> Result:
+        """Deletes the given AnimationStruct object.
+
+        :return: INVALID_ARGUMENT An invalid AnimationStruct pointer.
+        :rtype: Result
+
+        .. versionadded:: 0.13
+        """
+        self.thorvg_lib.tvg_animation_del.argtypes = [
+            ctypes.POINTER(AnimationStruct),
+        ]
+        self.thorvg_lib.tvg_animation_del.restype = Result
+        return self.thorvg_lib.tvg_animation_del(
+            ctypes.pointer(self._animation),
+        )

thorvg_python/animation/lottie.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+import ctypes
+from typing import Optional, Tuple
+
+from ..base import AnimationStruct, Result
+from ..engine import Engine
+from . import Animation
+
+
+class LottieAnimation(Animation):
+    """
+    LottieAnimation Extension API
+
+    A module for manipulation of the scene tree
+
+    This module helps to control the scene tree.
+    """
+
+    def __init__(self, engine: Engine, animation: Optional[AnimationStruct] = None):
+        self.engine = engine
+        self.thorvg_lib = engine.thorvg_lib
+        if animation is None:
+            self._animation = self._new()
+        else:
+            self._animation = animation
+
+    def new(self) -> AnimationStruct:
+        """Creates a new LottieAnimation object.
+
+        :return: AnimationStruct A new Tvg_LottieAnimation object.
+        :rtype: AnimationStruct
+
+        .. versionadded:: 0.15
+        """
+        self.thorvg_lib.tvg_lottie_animation_new.restype = ctypes.POINTER(
+            AnimationStruct
+        )
+        return self.thorvg_lib.tvg_lottie_animation_new().contents
+
+    def override(
+        self,
+        slot: Optional[str],
+    ) -> Result:
+        """Override the lottie properties through the slot data.
+
+        :param str slot: The Lottie slot data in json, or ``None`` to reset.
+
+        :return:
+            - INSUFFICIENT_CONDITION In case the animation is not loaded.
+            - INVALID_ARGUMENT When the given ``slot`` is invalid
+            - NOT_SUPPORTED The Lottie Animation is not supported.
+        :rtype: Result
+
+        .. note::
+            Experimental API
+        """
+        if slot is not None and slot != "":
+            slot_bytes = slot.encode() + b"\x00"
+            slot_arr_type = ctypes.c_char * len(slot_bytes)
+            slot_arr_type_ptr = ctypes.POINTER(slot_arr_type)
+            slot_arr_ptr = ctypes.pointer(slot_arr_type.from_buffer_copy(slot_bytes))
+        else:
+            slot_arr_type_ptr = ctypes.c_void_p  # type: ignore
+            slot_arr_ptr = ctypes.c_void_p()  # type: ignore
+        self.thorvg_lib.tvg_lottie_animation_override.argtypes = [
+            ctypes.POINTER(AnimationStruct),
+            slot_arr_type_ptr,
+        ]
+        self.thorvg_lib.tvg_lottie_animation_override.restype = Result
+        return self.thorvg_lib.tvg_lottie_animation_override(
+            ctypes.pointer(self._animation),
+            slot_arr_ptr,
+        )
+
+    def set_marker(
+        self,
+        marker: str,
+    ) -> Result:
+        """Specifies a segment by marker.
+
+        :param str marker: The name of the segment marker.
+
+        :return:
+            - INSUFFICIENT_CONDITION In case the animation is not loaded.
+            - INVALID_ARGUMENT When the given ``marker`` is invalid.
+            - NOT_SUPPORTED The Lottie Animation is not supported.
+        :rtype: Result
+
+        .. note::
+            Experimental API
+        """
+        marker_bytes = marker.encode() + b"\x00"
+        marker_arr_type = ctypes.c_char * len(marker_bytes)
+        marker_arr = marker_arr_type.from_buffer_copy(marker_bytes)
+        self.thorvg_lib.tvg_lottie_animation_set_marker.argtypes = [
+            ctypes.POINTER(AnimationStruct),
+            ctypes.POINTER(marker_arr_type),
+        ]
+        self.thorvg_lib.tvg_lottie_animation_set_marker.restype = Result
+        return self.thorvg_lib.tvg_lottie_animation_set_marker(
+            ctypes.pointer(self._animation),
+            ctypes.pointer(marker_arr),
+        )
+
+    def get_markers_cnt(
+        self,
+    ) -> Tuple[Result, int]:
+        """Gets the marker count of the animation.
+
+        :return: INVALID_ARGUMENT In case a ``nullptr`` is passed as the argument.
+        :rtype: Result
+        :return: The count value of the markers.
+        :rtype: int
+
+        .. note::
+            Experimental API
+        """
+        cnt = ctypes.c_uint32()
+        self.thorvg_lib.tvg_lottie_animation_get_markers_cnt.argtypes = [
+            ctypes.POINTER(AnimationStruct),
+            ctypes.POINTER(ctypes.c_uint32),
+        ]
+        self.thorvg_lib.tvg_lottie_animation_get_markers_cnt.restype = Result
+        result = self.thorvg_lib.tvg_lottie_animation_get_markers_cnt(
+            ctypes.pointer(self._animation),
+            ctypes.pointer(cnt),
+        )
+        return result, cnt.value
+
+    def get_marker(
+        self,
+        idx: int,
+    ) -> Tuple[Result, Optional[str]]:
+        """Gets the marker name by a given index.
+
+        :param int idx: The index of the animation marker, starts from 0.
+
+        :return: INVALID_ARGUMENT In case ``nullptr`` is passed as the argument or ``idx`` is out of range.
+        :rtyle: Result
+        :return: The name of marker when succeed.
+        :rtype: Optional[str]
+
+        .. note::
+            Experimental API
+        """
+        name = ctypes.c_char_p()
+        self.thorvg_lib.tvg_lottie_animation_get_marker.argtypes = [
+            ctypes.POINTER(AnimationStruct),
+            ctypes.POINTER(ctypes.c_uint32),
+            ctypes.POINTER(ctypes.c_char_p),
+        ]
+        self.thorvg_lib.tvg_lottie_animation_get_marker.restype = Result
+        result = self.thorvg_lib.tvg_lottie_animation_get_marker(
+            ctypes.pointer(self._animation),
+            ctypes.c_uint32(idx),
+            ctypes.pointer(name),
+        )
+        if name.value is not None:
+            _name = name.value.decode("utf-8")
+        else:
+            _name = None
+        return result, _name