spire-pdf 11.6.1__py3-none-manylinux_2_31_x86_64.whl

spire/pdf/PdfSectionPageNumberField.py

@@ -0,0 +1,64 @@
+from enum import Enum
+from plum import dispatch
+from typing import TypeVar, Union, Generic, List, Tuple
+from spire.pdf.common import *
+from spire.pdf import *
+from ctypes import *
+import abc
+
+class PdfSectionPageNumberField(PdfMultipleNumberValueField):
+    """
+    Represents automatic field to display page number within a section.
+    """
+
+    @dispatch
+    def __init__(self):
+        """
+        Initializes a new instance of the PdfSectionPageNumberField class.
+        """
+        GetDllLibPdf().PdfSectionPageNumberField_CreatePdfSectionPageNumberField.restype = c_void_p
+        intPtr = CallCFunction(GetDllLibPdf().PdfSectionPageNumberField_CreatePdfSectionPageNumberField)
+        super(PdfSectionPageNumberField, self).__init__(intPtr)
+
+    @dispatch
+    def __init__(self, font: PdfFontBase):
+        """
+        Initializes a new instance of the PdfSectionPageNumberField class with the specified font.
+
+        :param font: The font to use for the field.
+        """
+        ptrFont: c_void_p = font.Ptr
+        GetDllLibPdf().PdfSectionPageNumberField_CreatePdfSectionPageNumberFieldF.argtypes = [c_void_p]
+        GetDllLibPdf().PdfSectionPageNumberField_CreatePdfSectionPageNumberFieldF.restype = c_void_p
+        intPtr = CallCFunction(GetDllLibPdf().PdfSectionPageNumberField_CreatePdfSectionPageNumberFieldF,ptrFont)
+        super(PdfSectionPageNumberField, self).__init__(intPtr)
+
+    @dispatch
+    def __init__(self, font: PdfFontBase, brush: PdfBrush):
+        """
+        Initializes a new instance of the PdfSectionPageNumberField class with the specified font and brush.
+
+        :param font: The font to use for the field.
+        :param brush: The brush to use for the field.
+        """
+        ptrFont: c_void_p = font.Ptr
+        ptrBrush: c_void_p = brush.Ptr
+        GetDllLibPdf().PdfSectionPageNumberField_CreatePdfSectionPageNumberFieldFB.argtypes = [c_void_p, c_void_p]
+        GetDllLibPdf().PdfSectionPageNumberField_CreatePdfSectionPageNumberFieldFB.restype = c_void_p
+        intPtr = CallCFunction(GetDllLibPdf().PdfSectionPageNumberField_CreatePdfSectionPageNumberFieldFB,ptrFont, ptrBrush)
+        super(PdfSectionPageNumberField, self).__init__(intPtr)
+
+    @dispatch
+    def __init__(self, font: PdfFontBase, bounds: RectangleF):
+        """
+        Initializes a new instance of the PdfSectionPageNumberField class with the specified font and bounds.
+
+        :param font: The font to use for the field.
+        :param bounds: The bounds of the field.
+        """
+        ptrFont: c_void_p = font.Ptr
+        ptrBounds: c_void_p = bounds.Ptr
+        GetDllLibPdf().PdfSectionPageNumberField_CreatePdfSectionPageNumberFieldFBs.argtypes = [c_void_p, c_void_p]
+        GetDllLibPdf().PdfSectionPageNumberField_CreatePdfSectionPageNumberFieldFBs.restype = c_void_p
+        intPtr = CallCFunction(GetDllLibPdf().PdfSectionPageNumberField_CreatePdfSectionPageNumberFieldFBs,ptrFont, ptrBounds)
+        super(PdfSectionPageNumberField, self).__init__(intPtr)

spire/pdf/PdfSectionTemplate.py

@@ -0,0 +1,102 @@
+from enum import Enum
+from plum import dispatch
+from typing import TypeVar, Union, Generic, List, Tuple
+from spire.pdf.common import *
+from spire.pdf import *
+from ctypes import *
+import abc
+
+class PdfSectionTemplate(PdfDocumentTemplate):
+    """
+    Encapsulates a page template for all the pages in the section.
+    """
+
+    @property
+    def ApplyDocumentLeftTemplate(self) -> bool:
+        """
+        Gets or sets value indicating whether parent Left page template should be used or not.
+        """
+        GetDllLibPdf().PdfSectionTemplate_get_ApplyDocumentLeftTemplate.argtypes = [c_void_p]
+        GetDllLibPdf().PdfSectionTemplate_get_ApplyDocumentLeftTemplate.restype = c_bool
+        ret = CallCFunction(GetDllLibPdf().PdfSectionTemplate_get_ApplyDocumentLeftTemplate,self.Ptr)
+        return ret
+
+    @ApplyDocumentLeftTemplate.setter
+    def ApplyDocumentLeftTemplate(self, value: bool):
+        """
+        Sets value indicating whether parent Left page template should be used or not.
+        """
+        GetDllLibPdf().PdfSectionTemplate_set_ApplyDocumentLeftTemplate.argtypes = [c_void_p, c_bool]
+        CallCFunction(GetDllLibPdf().PdfSectionTemplate_set_ApplyDocumentLeftTemplate,self.Ptr, value)
+
+    @property
+    def ApplyDocumentTopTemplate(self) -> bool:
+        """
+        Gets or sets value indicating whether parent Top page template should be used or not.
+        """
+        GetDllLibPdf().PdfSectionTemplate_get_ApplyDocumentTopTemplate.argtypes = [c_void_p]
+        GetDllLibPdf().PdfSectionTemplate_get_ApplyDocumentTopTemplate.restype = c_bool
+        ret = CallCFunction(GetDllLibPdf().PdfSectionTemplate_get_ApplyDocumentTopTemplate,self.Ptr)
+        return ret
+
+    @ApplyDocumentTopTemplate.setter
+    def ApplyDocumentTopTemplate(self, value: bool):
+        """
+        Sets value indicating whether parent Top page template should be used or not.
+        """
+        GetDllLibPdf().PdfSectionTemplate_set_ApplyDocumentTopTemplate.argtypes = [c_void_p, c_bool]
+        CallCFunction(GetDllLibPdf().PdfSectionTemplate_set_ApplyDocumentTopTemplate,self.Ptr, value)
+
+    @property
+    def ApplyDocumentRightTemplate(self) -> bool:
+        """
+        Gets or sets value indicating whether parent Right page template should be used or not.
+        """
+        GetDllLibPdf().PdfSectionTemplate_get_ApplyDocumentRightTemplate.argtypes = [c_void_p]
+        GetDllLibPdf().PdfSectionTemplate_get_ApplyDocumentRightTemplate.restype = c_bool
+        ret = CallCFunction(GetDllLibPdf().PdfSectionTemplate_get_ApplyDocumentRightTemplate,self.Ptr)
+        return ret
+
+    @ApplyDocumentRightTemplate.setter
+    def ApplyDocumentRightTemplate(self, value: bool):
+        """
+        Sets value indicating whether parent Right page template should be used or not.
+        """
+        GetDllLibPdf().PdfSectionTemplate_set_ApplyDocumentRightTemplate.argtypes = [c_void_p, c_bool]
+        CallCFunction(GetDllLibPdf().PdfSectionTemplate_set_ApplyDocumentRightTemplate,self.Ptr, value)
+
+    @property
+    def ApplyDocumentBottomTemplate(self) -> bool:
+        """
+        Gets or sets value indicating whether parent Bottom page template should be used or not.
+        """
+        GetDllLibPdf().PdfSectionTemplate_get_ApplyDocumentBottomTemplate.argtypes = [c_void_p]
+        GetDllLibPdf().PdfSectionTemplate_get_ApplyDocumentBottomTemplate.restype = c_bool
+        ret = CallCFunction(GetDllLibPdf().PdfSectionTemplate_get_ApplyDocumentBottomTemplate,self.Ptr)
+        return ret
+
+    @ApplyDocumentBottomTemplate.setter
+    def ApplyDocumentBottomTemplate(self, value: bool):
+        """
+        Sets value indicating whether parent Bottom page template should be used or not.
+        """
+        GetDllLibPdf().PdfSectionTemplate_set_ApplyDocumentBottomTemplate.argtypes = [c_void_p, c_bool]
+        CallCFunction(GetDllLibPdf().PdfSectionTemplate_set_ApplyDocumentBottomTemplate,self.Ptr, value)
+
+    @property
+    def ApplyDocumentStamps(self) -> bool:
+        """
+        Gets or sets value indicating whether the parent stamp elements should be used or not.
+        """
+        GetDllLibPdf().PdfSectionTemplate_get_ApplyDocumentStamps.argtypes = [c_void_p]
+        GetDllLibPdf().PdfSectionTemplate_get_ApplyDocumentStamps.restype = c_bool
+        ret = CallCFunction(GetDllLibPdf().PdfSectionTemplate_get_ApplyDocumentStamps,self.Ptr)
+        return ret
+
+    @ApplyDocumentStamps.setter
+    def ApplyDocumentStamps(self, value: bool):
+        """
+        Sets value indicating whether the parent stamp elements should be used or not.
+        """
+        GetDllLibPdf().PdfSectionTemplate_set_ApplyDocumentStamps.argtypes = [c_void_p, c_bool]
+        CallCFunction(GetDllLibPdf().PdfSectionTemplate_set_ApplyDocumentStamps,self.Ptr, value)

spire/pdf/PdfSecurity.py

@@ -0,0 +1,158 @@
+from enum import Enum
+from plum import dispatch
+from typing import TypeVar, Union, Generic, List, Tuple
+from spire.pdf.common import *
+from spire.pdf import *
+from ctypes import *
+import abc
+
+class PdfSecurity(SpireObject):
+    """
+    Represents the security settings of the PDF document.
+    """
+
+    @property
+    def OwnerPassword(self) -> str:
+        """
+        Gets the owner password.
+        """
+        GetDllLibPdf().PdfSecurity_get_OwnerPassword.argtypes = [c_void_p]
+        GetDllLibPdf().PdfSecurity_get_OwnerPassword.restype = c_void_p
+        ret = PtrToStr(CallCFunction(GetDllLibPdf().PdfSecurity_get_OwnerPassword,self.Ptr))
+        return ret
+
+    @property
+    def UserPassword(self) -> str:
+        """
+        Gets the user password.
+        """
+        GetDllLibPdf().PdfSecurity_get_UserPassword.argtypes = [c_void_p]
+        GetDllLibPdf().PdfSecurity_get_UserPassword.restype = c_void_p
+        ret = PtrToStr(CallCFunction(GetDllLibPdf().PdfSecurity_get_UserPassword,self.Ptr))
+        return ret
+
+    @property
+    def OriginalEncrypt(self) -> bool:
+        """
+        Indicate whether this pdf document was encrypted originally or not. 
+        """
+        GetDllLibPdf().PdfSecurity_get_OriginalEncrypt.argtypes = [c_void_p]
+        GetDllLibPdf().PdfSecurity_get_OriginalEncrypt.restype = c_bool
+        ret = CallCFunction(GetDllLibPdf().PdfSecurity_get_OriginalEncrypt,self.Ptr)
+        return ret
+
+    @dispatch
+    def DecryptUserPassWord(self):
+        """
+        Decrypt user password
+        """
+        GetDllLibPdf().PdfSecurity_DecryptUserPassWord.argtypes = [c_void_p]
+        CallCFunction(GetDllLibPdf().PdfSecurity_DecryptUserPassWord,self.Ptr)
+
+    @dispatch
+    def DecryptUserPassWord(self, ownerPassword: str):
+        """
+        Decrypt user password.
+        :param ownerPassword: The ownerPassword
+        """
+        GetDllLibPdf().PdfSecurity_DecryptUserPassWordO.argtypes = [c_void_p, c_wchar_p]
+        CallCFunction(GetDllLibPdf().PdfSecurity_DecryptUserPassWordO,self.Ptr, ownerPassword)
+
+    def DecryptOwnerPassWord(self, ownerPassword: str):
+        """
+        Decrypt all password.
+        :param ownerPassword: The ownerPassword
+        """
+        GetDllLibPdf().PdfSecurity_DecryptOwnerPassWord.argtypes = [c_void_p, c_wchar_p]
+        CallCFunction(GetDllLibPdf().PdfSecurity_DecryptOwnerPassWord,self.Ptr, ownerPassword)
+
+    @dispatch
+    def Encrypt(self, openPassword: str):
+        """
+        To Encrypt the PDF document with open password.
+        Note: If set empty string value to open password, it indicates that the PDF document can be operated without providing corresponding password.
+        Note: the document owner password should not be exist.
+        :param openPassword: The open password
+        """
+        GetDllLibPdf().PdfSecurity_Encrypt.argtypes = [c_void_p, c_wchar_p]
+        CallCFunction(GetDllLibPdf().PdfSecurity_Encrypt,self.Ptr, openPassword)
+
+    @dispatch
+    def Encrypt(self, permissionPassword: str, permissions: PdfPermissionsFlags):
+        """
+        To Encrypt the PDF document with permission password and permissions.
+        Note: The Permission password can't be empty string.
+        :param permissionPassword: The permission password
+        :param permissions: A set of flags specifying which operations are permitted when the document is opened with user access
+        """
+        enumpermissions: c_int = permissions.value
+        GetDllLibPdf().PdfSecurity_EncryptPP.argtypes = [c_void_p, c_wchar_p, c_int]
+        CallCFunction(GetDllLibPdf().PdfSecurity_EncryptPP,self.Ptr, permissionPassword, enumpermissions)
+
+    @dispatch
+    def Encrypt(self, openPassword: str, permissionPassword: str, permissions: PdfPermissionsFlags, keySize: PdfEncryptionKeySize):
+        """
+        To Encrypt the PDF document and set the encryption key size and permissions.
+        Note: If set empty string value to open password or permission password, it indicates that the PDF document can be operated without providing corresponding password.
+        :param openPassword: The open password
+        :param permissionPassword: The permission password
+        :param permissions: A set of flags specifying which operations are permitted when the document is opened with user access
+        :param keySize: The bit length of the encryption key
+        :returns:
+        """
+        enumpermissions: c_int = permissions.value
+        enumkeySize: c_int = keySize.value
+        GetDllLibPdf().PdfSecurity_EncryptOPPK.argtypes = [c_void_p, c_wchar_p, c_wchar_p, c_int, c_int]
+        CallCFunction(GetDllLibPdf().PdfSecurity_EncryptOPPK,self.Ptr, openPassword, permissionPassword, enumpermissions, enumkeySize)
+    @dispatch
+    def Encrypt(self, openPassword: str, permissionPassword: str, permissionsInt: int, keySize: PdfEncryptionKeySize):
+        """
+        To Encrypt the PDF document and set the encryption key size and permissions.
+        Note: If set empty string value to open password or permission password, it indicates that the PDF document can be operated without providing corresponding password.
+        :param openPassword: The open password
+        :param permissionPassword: The permission password
+        :param permissions: A set of flags specifying which operations are permitted when the document is opened with user access
+        :param keySize: The bit length of the encryption key
+        :returns:
+        """
+        enumkeySize: c_int = keySize.value
+        GetDllLibPdf().PdfSecurity_EncryptOPPK.argtypes = [c_void_p, c_wchar_p, c_wchar_p, c_int, c_int]
+        CallCFunction(GetDllLibPdf().PdfSecurity_EncryptOPPK,self.Ptr, openPassword, permissionPassword, permissionsInt, enumkeySize)
+
+    @dispatch
+    def Encrypt(self, openPassword: str, permissionPassword: str, permissions: PdfPermissionsFlags, keySize: PdfEncryptionKeySize, originalPermissionPassword: str):
+        """
+        To Encrypt the PDF document with open password and permission password, and set the encryption key size and permissions.
+        Note: If set empty string value to open password or permission password, it indicates that the PDF document can be operated without providing corresponding password.
+        :param openPassword: The open password
+        :param permissionPassword: The permission password
+        :param permissions: A set of flags specifying which operations are permitted when the document is opened with user access
+        :param keySize: The bit length of the encryption key
+        :param originalPermissionPassword: The original permissionPassword of the document
+        """
+        enumpermissions: c_int = permissions.value
+        enumkeySize: c_int = keySize.value
+        GetDllLibPdf().PdfSecurity_EncryptOPPKO.argtypes = [c_void_p, c_wchar_p, c_wchar_p, c_int, c_int, c_wchar_p]
+        CallCFunction(GetDllLibPdf().PdfSecurity_EncryptOPPKO,self.Ptr, openPassword, permissionPassword, enumpermissions, enumkeySize, originalPermissionPassword)
+
+    @property
+    def Permissions(self) -> 'PdfPermissionsFlags':
+        """
+        Gets the document's permission flags
+        """
+        GetDllLibPdf().PdfSecurity_get_Permissions.argtypes = [c_void_p]
+        GetDllLibPdf().PdfSecurity_get_Permissions.restype = c_int
+        ret = CallCFunction(GetDllLibPdf().PdfSecurity_get_Permissions,self.Ptr)
+        objwrapped = PdfPermissionsFlags(ret)
+        return objwrapped
+
+    @property
+    def KeySize(self) -> 'PdfEncryptionKeySize':
+        """
+        Gets the size of the key.
+        """
+        GetDllLibPdf().PdfSecurity_get_KeySize.argtypes = [c_void_p]
+        GetDllLibPdf().PdfSecurity_get_KeySize.restype = c_int
+        ret = CallCFunction(GetDllLibPdf().PdfSecurity_get_KeySize,self.Ptr)
+        objwrapped = PdfEncryptionKeySize(ret)
+        return objwrapped

spire/pdf/PdfSecurityPolicy.py

@@ -0,0 +1,59 @@
+from enum import Enum
+from plum import dispatch
+from typing import TypeVar,Union,Generic,List,Tuple,overload
+from spire.pdf.common import *
+from spire.pdf import *
+from ctypes import *
+import abc
+
+class PdfSecurityPolicy(SpireObject):
+    @property
+    def EncryptMetadata(self)->bool:
+        """
+        Gets or sets the value indicating whether to encrypt metadata.
+        """
+        GetDllLibPdf().PdfSecurityPolicy_get_EncryptMetadata.argtypes=[c_void_p]
+        GetDllLibPdf().PdfSecurityPolicy_get_EncryptMetadata.restype=c_bool
+        ret = CallCFunction(GetDllLibPdf().PdfSecurityPolicy_get_EncryptMetadata,self.Ptr)
+        return ret
+
+    @EncryptMetadata.setter
+    def EncryptMetadata(self, value:bool):
+        GetDllLibPdf().PdfSecurityPolicy_set_EncryptMetadata.argtypes=[c_void_p, c_bool]
+        CallCFunction(GetDllLibPdf().PdfSecurityPolicy_set_EncryptMetadata,self.Ptr, value) 
+        
+    @property
+    def EncryptionAlgorithm(self)->'PdfEncryptionAlgorithm':
+        """
+        Gets the sets encryption algorithm.
+        """
+        GetDllLibPdf().PdfSecurityPolicy_get_PdfEncryptionAlgorithm.argtypes=[c_void_p]
+        GetDllLibPdf().PdfSecurityPolicy_get_PdfEncryptionAlgorithm.restype=c_int
+        ret = CallCFunction(GetDllLibPdf().PdfSecurityPolicy_get_PdfEncryptionAlgorithm,self.Ptr)
+        objEncryptionAlgorithm = PdfEncryptionAlgorithm(ret)
+        return objEncryptionAlgorithm
+    @EncryptionAlgorithm.setter
+    def EncryptionAlgorithm(self, EncryptionAlgorithm:PdfEncryptionAlgorithm):
+        enumEncryptionAlgorithm:c_int = EncryptionAlgorithm.value
+        GetDllLibPdf().PdfSecurityPolicy_set_PdfEncryptionAlgorithm.argtypes=[c_void_p, c_int]
+        CallCFunction(GetDllLibPdf().PdfSecurityPolicy_set_PdfEncryptionAlgorithm,self.Ptr, enumEncryptionAlgorithm) 
+
+    @property
+    def DocumentPrivilege(self)->'PdfDocumentPrivilege':
+        """
+        Gets or sets the document's permission flags
+        """
+        GetDllLibPdf().PdfSecurityPolicy_get_PdfDocumentPrivilege.argtypes=[c_void_p]
+        GetDllLibPdf().PdfSecurityPolicy_get_PdfDocumentPrivilege.restype=c_void_p
+        intPtr = CallCFunction(GetDllLibPdf().PdfSecurityPolicy_get_PdfDocumentPrivilege,self.Ptr)
+        ret = None if intPtr==None else PdfDocumentPrivilege(intPtr)
+        return ret
+
+
+    @DocumentPrivilege.setter
+    def DocumentPrivilege(self, value):
+        intPtrDocumentPrivilege:c_void_p = value.Ptr
+        GetDllLibPdf().PdfSecurityPolicy_set_PdfDocumentPrivilege.argtypes=[c_void_p, c_void_p]
+        CallCFunction(GetDllLibPdf().PdfSecurityPolicy_set_PdfDocumentPrivilege,self.Ptr, intPtrDocumentPrivilege)
+
+

spire/pdf/PdfSeparationColor.py

@@ -0,0 +1,36 @@
+from enum import Enum
+from plum import dispatch
+from typing import TypeVar,Union,Generic,List,Tuple
+from spire.pdf.common import *
+from spire.pdf import *
+from ctypes import *
+import abc
+
+class PdfSeparationColor (  PdfComplexColor) :
+    """
+    Represents a separation color, based on a separation colorspace. 
+    """
+    @dispatch
+    def __init__(self, colorspace:PdfColorSpaces,tint:float):
+        ptrColor:c_void_p = colorspace.Ptr
+
+        GetDllLibPdf().PdfSeparationColor_CreatePdfSeparationColorCT.argtypes=[c_void_p,c_float]
+        GetDllLibPdf().PdfSeparationColor_CreatePdfSeparationColorCT.restype = c_void_p
+        intPtr = CallCFunction(GetDllLibPdf().PdfSeparationColor_CreatePdfSeparationColorCT,ptrColor,tint)
+        super(PdfSeparationColor, self).__init__(intPtr)
+
+    @property
+    def Tint(self)->float:
+        """
+        The acceptable range for this value is [0.0 1.0]. 0.0 means the lightest color that can be achieved, and 1.0 means the darkest color.
+        """
+        GetDllLibPdf().PdfSeparationColor_get_Tint.argtypes=[c_void_p]
+        GetDllLibPdf().PdfSeparationColor_get_Tint.restype=c_float
+        ret = CallCFunction(GetDllLibPdf().PdfSeparationColor_get_Tint,self.Ptr)
+        return ret
+
+    @Tint.setter
+    def Tint(self, value:float):
+        GetDllLibPdf().PdfSeparationColor_set_Tint.argtypes=[c_void_p, c_float]
+        CallCFunction(GetDllLibPdf().PdfSeparationColor_set_Tint,self.Ptr, value)
+

spire/pdf/PdfSeparationColorSpace.py

@@ -0,0 +1,69 @@
+from enum import Enum
+from plum import dispatch
+from typing import TypeVar,Union,Generic,List,Tuple
+from spire.pdf.common import *
+from spire.pdf import *
+from ctypes import *
+import abc
+
+class PdfSeparationColorSpace (  PdfColorSpaces) :
+    """
+    Represents a separation colorspace
+    """
+    @dispatch
+    def __init__(self, colorant:str,baseColor:PdfRGBColor):
+        ptrColor:c_void_p = baseColor.Ptr
+
+        GetDllLibPdf().PdfSeparationColorSpace_CreatePdfSeparationColorSpaceCB.argtypes=[c_wchar_p,c_void_p]
+        GetDllLibPdf().PdfSeparationColorSpace_CreatePdfSeparationColorSpaceCB.restype = c_void_p
+        intPtr = CallCFunction(GetDllLibPdf().PdfSeparationColorSpace_CreatePdfSeparationColorSpaceCB,colorant,ptrColor)
+        super(PdfSeparationColorSpace, self).__init__(intPtr)
+
+    @property
+
+    def BaseColor(self)->'PdfRGBColor':
+        """
+        The base color to be used.
+        """
+        GetDllLibPdf().PdfSeparationColorSpace_get_BaseColor.argtypes=[c_void_p]
+        GetDllLibPdf().PdfSeparationColorSpace_get_BaseColor.restype=c_void_p
+        intPtr = CallCFunction(GetDllLibPdf().PdfSeparationColorSpace_get_BaseColor,self.Ptr)
+        ret = None if intPtr==None else PdfRGBColor(intPtr)
+        return ret
+
+
+    @BaseColor.setter
+    def BaseColor(self, value:'PdfRGBColor'):
+        GetDllLibPdf().PdfSeparationColorSpace_set_BaseColor.argtypes=[c_void_p, c_void_p]
+        CallCFunction(GetDllLibPdf().PdfSeparationColorSpace_set_BaseColor,self.Ptr, value.Ptr)
+
+    @property
+
+    def Colorant(self)->str:
+        """
+        The name of the colorant.
+        """
+        GetDllLibPdf().PdfSeparationColorSpace_get_Colorant.argtypes=[c_void_p]
+        GetDllLibPdf().PdfSeparationColorSpace_get_Colorant.restype=c_void_p
+        ret = PtrToStr(CallCFunction(GetDllLibPdf().PdfSeparationColorSpace_get_Colorant,self.Ptr))
+        return ret
+
+
+    @Colorant.setter
+    def Colorant(self, value:str):
+        GetDllLibPdf().PdfSeparationColorSpace_set_Colorant.argtypes=[c_void_p, c_wchar_p]
+        CallCFunction(GetDllLibPdf().PdfSeparationColorSpace_set_Colorant,self.Ptr, value)
+
+#
+#    def GetProfileData(self)->List['Byte']:
+#        """
+#        Get the profile data.
+#    <returns>The profile data</returns>
+#        """
+#        GetDllLibPdf().PdfSeparationColorSpace_GetProfileData.argtypes=[c_void_p]
+#        GetDllLibPdf().PdfSeparationColorSpace_GetProfileData.restype=IntPtrArray
+#        intPtrArray = CallCFunction(GetDllLibPdf().PdfSeparationColorSpace_GetProfileData,self.Ptr)
+#        ret = GetVectorFromArray(intPtrArray, Byte)
+#        return ret
+
+

spire/pdf/PdfShapeWidget.py

@@ -0,0 +1,25 @@
+from enum import Enum
+from plum import dispatch
+from typing import TypeVar, Union, Generic, List, Tuple
+from spire.pdf.common import *
+from spire.pdf import *
+from ctypes import *
+import abc
+
+class PdfShapeWidget(PdfLayoutWidget):
+    """
+    Base class for the main shapes.
+    """
+
+    def GetBounds(self) -> 'RectangleF':
+        """
+        Gets the bounds.
+
+        Returns:
+            rect: The bounds of the shape.
+        """
+        GetDllLibPdf().PdfShapeWidget_GetBounds.argtypes = [c_void_p]
+        GetDllLibPdf().PdfShapeWidget_GetBounds.restype = c_void_p
+        intPtr = CallCFunction(GetDllLibPdf().PdfShapeWidget_GetBounds,self.Ptr)
+        ret = None if intPtr == None else RectangleF(intPtr)
+        return ret

spire/pdf/PdfSignature.py

@@ -0,0 +1,97 @@
+from enum import Enum
+from plum import dispatch
+from typing import TypeVar, Union, Generic, List, Tuple
+from spire.pdf.common import *
+from spire.pdf import *
+from ctypes import *
+import abc
+
+class PdfSignature(SpireObject):
+    """
+    The pdf signature.
+    """
+
+    @property
+    def Filter(self) -> str:
+        """
+        The name of the preferred signature handler to use when validating this signature.
+        """
+        GetDllLibPdf().PdfSignature_get_Filter.argtypes = [c_void_p]
+        GetDllLibPdf().PdfSignature_get_Filter.restype = c_void_p
+        ret = PtrToStr(CallCFunction(GetDllLibPdf().PdfSignature_get_Filter,self.Ptr))
+        return ret
+
+    @property
+    def SubFilter(self) -> str:
+        """
+        A name that describes the encoding of the signature value.
+        """
+        GetDllLibPdf().PdfSignature_get_SubFilter.argtypes = [c_void_p]
+        GetDllLibPdf().PdfSignature_get_SubFilter.restype = c_void_p
+        ret = PtrToStr(CallCFunction(GetDllLibPdf().PdfSignature_get_SubFilter,self.Ptr))
+        return ret
+
+    @property
+    def Name(self) -> str:
+        """
+        The name of the person or authority signing the document.
+        This value should be used only when it is not possible to extract the name from the signature,
+        for example, from the certificate of the signer.
+        """
+        GetDllLibPdf().PdfSignature_get_Name.argtypes = [c_void_p]
+        GetDllLibPdf().PdfSignature_get_Name.restype = c_void_p
+        ret = PtrToStr(CallCFunction(GetDllLibPdf().PdfSignature_get_Name,self.Ptr))
+        return ret
+
+    @Name.setter
+    def Name(self, value: str):
+        GetDllLibPdf().PdfSignature_set_Name.argtypes = [c_void_p, c_wchar_p]
+        CallCFunction(GetDllLibPdf().PdfSignature_set_Name,self.Ptr, value)
+
+    @property
+    def Location(self) -> str:
+        """
+        Gets or sets the physical location of the signing.
+        """
+        GetDllLibPdf().PdfSignature_get_Location.argtypes = [c_void_p]
+        GetDllLibPdf().PdfSignature_get_Location.restype = c_void_p
+        ret = PtrToStr(CallCFunction(GetDllLibPdf().PdfSignature_get_Location,self.Ptr))
+        return ret
+
+    @Location.setter
+    def Location(self, value: str):
+        GetDllLibPdf().PdfSignature_set_Location.argtypes = [c_void_p, c_wchar_p]
+        CallCFunction(GetDllLibPdf().PdfSignature_set_Location,self.Ptr, value)
+
+    @property
+    def Reason(self) -> str:
+        """
+        Gets or sets reason of signing.
+        The reason for the signing, such as "I agree...".
+        """
+        GetDllLibPdf().PdfSignature_get_Reason.argtypes = [c_void_p]
+        GetDllLibPdf().PdfSignature_get_Reason.restype = c_void_p
+        ret = PtrToStr(CallCFunction(GetDllLibPdf().PdfSignature_get_Reason,self.Ptr))
+        return ret
+
+    @Reason.setter
+    def Reason(self, value: str):
+        GetDllLibPdf().PdfSignature_set_Reason.argtypes = [c_void_p, c_wchar_p]
+        CallCFunction(GetDllLibPdf().PdfSignature_set_Reason,self.Ptr, value)
+
+    @property
+    def ContactInfo(self) -> str:
+        """
+        Gets or sets a phone number of signer.
+        Information provided by the signer to enable a recipient to contact the signer to verify the signature;
+        for example, a phone number.
+        """
+        GetDllLibPdf().PdfSignature_get_ContactInfo.argtypes = [c_void_p]
+        GetDllLibPdf().PdfSignature_get_ContactInfo.restype = c_void_p
+        ret = PtrToStr(CallCFunction(GetDllLibPdf().PdfSignature_get_ContactInfo,self.Ptr))
+        return ret
+
+    @ContactInfo.setter
+    def ContactInfo(self, value: str):
+        GetDllLibPdf().PdfSignature_set_ContactInfo.argtypes = [c_void_p, c_wchar_p]
+        CallCFunction(GetDllLibPdf().PdfSignature_set_ContactInfo,self.Ptr, value)