aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorKai Huuhko <kai.huuhko@gmail.com>2014-05-29 20:17:14 +0300
committerKai Huuhko <kai.huuhko@gmail.com>2014-05-29 20:17:14 +0300
commit6404b0506686659e676baedf7e7574ee8202cc7b (patch)
treef53ae47f0f257b7795a3a384c5189c08aee1855b
parentElementary: Add more signals to web example (diff)
downloadpython-efl-devs/kuuko/eet.tar.gz
Add Python bindings for eetdevs/kuuko/eet
-rw-r--r--doc/eet/cipher.rst6
-rw-r--r--doc/eet/data.rst10
-rw-r--r--doc/eet/eet.rst17
-rw-r--r--doc/eet/file.rst21
-rw-r--r--doc/index.rst5
-rw-r--r--efl/eet/connection.pxi140
-rw-r--r--efl/eet/data_descriptor.pxi653
-rw-r--r--efl/eet/data_descriptor_class.pxi176
-rw-r--r--efl/eet/data_utils.pxi622
-rw-r--r--efl/eet/dictionary.pxi45
-rw-r--r--efl/eet/eet.pxd309
-rw-r--r--efl/eet/eet.pyx197
-rw-r--r--efl/eet/enums.pxd50
-rw-r--r--efl/eet/file.pxi1356
-rw-r--r--efl/eet/key.pxi80
-rw-r--r--efl/eet/node.pxi328
-rw-r--r--include/efl.eet.enums.pxd50
-rwxr-xr-xsetup.py10
18 files changed, 4075 insertions, 0 deletions
diff --git a/doc/eet/cipher.rst b/doc/eet/cipher.rst
new file mode 100644
index 0000000..44d83f3
--- /dev/null
+++ b/doc/eet/cipher.rst
@@ -0,0 +1,6 @@
+.. currentmodule:: efl.eet
+
+.. _Eet_Cipher_Group:
+
+Cipher, Identity and Protection Mechanisms
+==========================================
diff --git a/doc/eet/data.rst b/doc/eet/data.rst
new file mode 100644
index 0000000..b40f020
--- /dev/null
+++ b/doc/eet/data.rst
@@ -0,0 +1,10 @@
+.. currentmodule:: efl.eet
+
+.. _Eet_Data_Group:
+
+Eet Data Serialization
+=======================
+
+.. autoclass:: EetDataDescriptor
+
+.. autoclass:: EetDataDescriptorClass
diff --git a/doc/eet/eet.rst b/doc/eet/eet.rst
new file mode 100644
index 0000000..a300777
--- /dev/null
+++ b/doc/eet/eet.rst
@@ -0,0 +1,17 @@
+:mod:`efl.eet` Module
+=======================
+
+.. automodule:: efl.eet
+
+.. autofunction:: init
+
+.. autofunction:: shutdown
+
+.. autofunction:: clearcache
+
+.. autoexception:: EetError
+
+.. toctree::
+
+ file
+ cipher
diff --git a/doc/eet/file.rst b/doc/eet/file.rst
new file mode 100644
index 0000000..2572f2b
--- /dev/null
+++ b/doc/eet/file.rst
@@ -0,0 +1,21 @@
+.. currentmodule:: efl.eet
+
+.. _Eet_File_Group:
+
+Eet File Main Functions
+=======================
+
+:class:`efl.eet.EetDictionary` Class
+------------------------------------
+
+.. autoclass:: EetDictionary
+
+:class:`efl.eet.EetEntry` Class
+--------------------------------
+
+.. autoclass:: EetEntry
+
+:class:`efl.eet.EetFile` Class
+-------------------------------
+
+.. autoclass:: EetFile
diff --git a/doc/index.rst b/doc/index.rst
index ac42901..b4c68e4 100644
--- a/doc/index.rst
+++ b/doc/index.rst
@@ -42,6 +42,11 @@ EO
.. toctree:: eo/eo.rst
+Eet
+---
+
+.. toctree:: eet/eet
+
Ecore
-----
diff --git a/efl/eet/connection.pxi b/efl/eet/connection.pxi
new file mode 100644
index 0000000..eb5946f
--- /dev/null
+++ b/efl/eet/connection.pxi
@@ -0,0 +1,140 @@
+"""
+
+@typedef Eet_Connection
+Opaque handle to track paquet for a specific connection.
+
+
+"""
+typedef struct _Eet_Connection Eet_Connection;
+
+"""
+
+@typedef Eet_Read_Cb
+Called back when an :ref:`Eet_Data_Group` has been received completely and could be used.
+
+
+"""
+typedef Eina_Bool Eet_Read_Cb (const void *eet_data, size_t size, void *user_data);
+
+"""
+
+@typedef Eet_Write_Cb
+Called back when a packet containing :ref:`Eet_Data_Group` data is ready to be send.
+
+
+"""
+typedef Eina_Bool Eet_Write_Cb (const void *data, size_t size, void *user_data);
+
+"""
+
+Instanciate a new connection to track.
+:param eet_read_cb: Function to call when one Eet_Data packet has been fully assemble.
+:param eet_write_cb: Function to call when one Eet_Data packet is ready to be send over the wire.
+:param user_data: Pointer provided to both functions to be used as a context handler.
+:return: NULL on failure, or a valid Eet_Connection handler.
+
+For every connection to track you will need a separate Eet_Connection provider.
+
+:since: 1.2.4
+
+"""
+EAPI Eet_Connection *
+eet_connection_new(Eet_Read_Cb *eet_read_cb,
+ Eet_Write_Cb *eet_write_cb,
+ const void *user_data);
+
+"""
+
+Process a raw packet received over the link
+:param conn: Connection handler to track.
+:param data: Raw data packet.
+:param size: The size of that packet.
+:return: 0 on complete success, any other value indicate where in the stream it got wrong (It could be before that packet).
+
+Every time you receive a packet related to your connection, you should pass
+it to that function so that it could process and assemble packet has you
+receive it. It will automatically call Eet_Read_Cb when one is fully received.
+
+:since: 1.2.4
+
+"""
+EAPI int
+eet_connection_received(Eet_Connection *conn,
+ const void *data,
+ size_t size);
+
+"""
+
+Tell if the Eet_Connection as received some partial data.
+:param conn: Connection handler to request.
+:return: EINA_TRUE if there is some data pending inside, EINA_FALSE otherwise.
+
+Eet_Connection buffer data until the received data can be unserialized correctly. This
+function let you know if there is some data inside that buffer waiting for more data to
+be received before being processed.
+
+:since: 1.7
+
+"""
+EAPI Eina_Bool eet_connection_empty(Eet_Connection *conn);
+
+"""
+
+Convert a complex structure and prepare it to be send.
+:param conn: Connection handler to track.
+:param edd: The data descriptor to use when encoding.
+:param data_in: The pointer to the struct to encode into data.
+:param cipher_key: The key to use as cipher.
+:return: EINA_TRUE if the data where correctly send, EINA_FALSE if they don't.
+
+This function serialize data_in with edd, assemble the packet and call
+Eet_Write_Cb when ready. The data passed Eet_Write_Cb are temporary allocated
+and will vanish just after the return of the callback.
+
+:see: eet_data_descriptor_encode_cipher
+
+:since: 1.2.4
+
+"""
+EAPI Eina_Bool
+eet_connection_send(Eet_Connection *conn,
+ Eet_Data_Descriptor *edd,
+ const void *data_in,
+ const char *cipher_key);
+
+"""
+
+Convert a Eet_Node tree and prepare it to be send.
+:param conn: Connection handler to track.
+:param node: The data tree to use when encoding.
+:param cipher_key: The key to use as cipher.
+:return: EINA_TRUE if the data where correctly send, EINA_FALSE if they don't.
+
+This function serialize node, assemble the packet and call
+Eet_Write_Cb when ready. The data passed Eet_Write_Cb are temporary allocated
+and will vanish just after the return of the callback.
+
+:see: eet_data_node_encode_cipher
+
+:since: 1.2.4
+
+"""
+EAPI Eina_Bool
+eet_connection_node_send(Eet_Connection *conn,
+ Eet_Node *node,
+ const char *cipher_key);
+
+"""
+
+Close a connection and lost its track.
+:param conn: Connection handler to close.
+:param on_going: Signal if a partial packet wasn't completed.
+:return: the user_data passed to both callback.
+
+:since: 1.2.4
+
+"""
+EAPI void *
+eet_connection_close(Eet_Connection *conn,
+ Eina_Bool *on_going);
+
diff --git a/efl/eet/data_descriptor.pxi b/efl/eet/data_descriptor.pxi
new file mode 100644
index 0000000..97b76e2
--- /dev/null
+++ b/efl/eet/data_descriptor.pxi
@@ -0,0 +1,653 @@
+
+
+#define EET_T_UNKNOW 0 # Unknown data encoding type
+#define EET_T_CHAR 1 # Data type: char
+#define EET_T_SHORT 2 # Data type: short
+#define EET_T_INT 3 # Data type: int
+#define EET_T_LONG_LONG 4 # Data type: long long
+#define EET_T_FLOAT 5 # Data type: float
+#define EET_T_DOUBLE 6 # Data type: double
+#define EET_T_UCHAR 7 # Data type: unsigned char
+#define EET_T_USHORT 8 # Data type: unsigned short
+#define EET_T_UINT 9 # Data type: unsigned int
+#define EET_T_ULONG_LONG 10 # Data type: unsigned long long
+#define EET_T_STRING 11 # Data type: char *
+#define EET_T_INLINED_STRING 12 # Data type: char * (but compressed inside the resulting eet)
+#define EET_T_NULL 13 # Data type: (void *) (only use it if you know why)
+#define EET_T_F32P32 14 # Data type: fixed point 32.32
+#define EET_T_F16P16 15 # Data type: fixed point 16.16
+#define EET_T_F8P24 16 # Data type: fixed point 8.24
+#define EET_T_VALUE 17 # Data type: pointer to Eina_Value :since: 1.8
+#define EET_T_LAST 18 # Last data type
+
+#define EET_G_UNKNOWN 100 # Unknown group data encoding type
+#define EET_G_ARRAY 101 # Fixed size array group type
+#define EET_G_VAR_ARRAY 102 # Variable size array group type
+#define EET_G_LIST 103 # Linked list group type
+#define EET_G_HASH 104 # Hash table group type
+#define EET_G_UNION 105 # Union group type
+#define EET_G_VARIANT 106 # Selectable subtype group
+#define EET_G_UNKNOWN_NESTED 107 # Unknown nested group type. :since: 1.8
+#define EET_G_LAST 108 # Last group type
+
+#define EET_I_LIMIT 128 # Other type exist but are reserved for internal purpose.
+
+
+cdef class EetDataDescriptor(object):
+
+ """
+
+ Opaque handle that have information on a type members.
+
+ Descriptors are created using an #Eet_Data_Descriptor_Class, and they
+ describe the contents of the structure that will be serialized by Eet.
+ Not all members need be described by it, just those that should be handled
+ by Eet. This way it's possible to have one structure with both data to be
+ saved to a file, like application configuration, and runtime information
+ that would be meaningless to store, but is appropriate to keep together
+ during the program execution.
+ The members are added by means of
+ EET_DATA_DESCRIPTOR_ADD_BASIC(), EET_DATA_DESCRIPTOR_ADD_SUB(),
+ EET_DATA_DESCRIPTOR_ADD_LIST(), EET_DATA_DESCRIPTOR_ADD_HASH()
+ or eet_data_descriptor_element_add().
+
+ :see: eet_data_descriptor_stream_new()
+ :see: eet_data_descriptor_file_new()
+ :see: eet_data_descriptor_free()
+
+ """
+
+ cdef Eet_Data_Descriptor *edd
+
+ def __init__(self, cls):
+ """
+
+ This function creates a new data descriptor and returns a handle to the
+ new data descriptor. On creation it will be empty, containing no
+ contents describing anything other than the shell of the data structure.
+ :param eddc: The class from where to create the data descriptor.
+ :return: A handle to the new data descriptor.
+
+ You add structure members to the data descriptor using the macros
+ EET_DATA_DESCRIPTOR_ADD_BASIC(), EET_DATA_DESCRIPTOR_ADD_SUB() and
+ EET_DATA_DESCRIPTOR_ADD_LIST(), depending on what type of member you are
+ adding to the description.
+
+ Once you have described all the members of a struct you want loaded or
+ saved, eet can load and save those members for you, encode them into
+ endian-independent serialised data chunks for transmission across a
+ network or more.
+
+ This function specially ignores str_direct_alloc and str_direct_free. It
+ is useful when the eet_data you are reading doesn't have a dictionary,
+ like network stream or IPC. It also mean that all string will be
+ allocated and duplicated in memory.
+
+ :since: 1.2.3
+
+ """
+ self.edd = eet_data_descriptor_stream_new(cls.eddc)
+
+ def file_new(self, cls):
+ """
+
+ This function creates a new data descriptor and returns a handle to the
+ new data descriptor. On creation it will be empty, containing no
+ contents describing anything other than the shell of the data structure.
+ :param eddc: The class from where to create the data descriptor.
+ :return: A handle to the new data descriptor.
+
+ You add structure members to the data descriptor using the macros
+ EET_DATA_DESCRIPTOR_ADD_BASIC(), EET_DATA_DESCRIPTOR_ADD_SUB() and
+ EET_DATA_DESCRIPTOR_ADD_LIST(), depending on what type of member you are
+ adding to the description.
+
+ Once you have described all the members of a struct you want loaded or
+ saved, eet can load and save those members for you, encode them into
+ endian-independent serialised data chunks for transmission across a
+ a network or more.
+
+ This function uses str_direct_alloc and str_direct_free. It is useful
+ when the eet_data you are reading come from a file and have a
+ dictionary. This will reduce memory use and improve the possibility for
+ the OS to page this string out.
+
+ However, the load speed and memory saving comes with some drawbacks to
+ keep in mind. If you never modify the contents of the structures loaded
+ from the file, all you need to remember is that closing the eet file
+ will make the strings go away. On the other hand, should you need to
+ free a string, before doing so you have to verify that it's not part of
+ the eet dictionary. You can do this in the following way, assuming @p ef
+ is a valid Eet_File and @p str is a string loaded from said file.
+
+ @code
+ void eet_string_free(Eet_File *ef, const char *str)
+ {
+ Eet_Dictionary *dict = eet_dictionary_get(ef);
+ if (dict && eet_dictionary_string_check(dict, str))
+ {
+ // The file contains a dictionary and the given string is a part of
+ // of it, so we can't free it, just return.
+ return;
+ }
+ // We assume eina_stringshare was used on the descriptor
+ eina_stringshare_del(str);
+ }
+ @endcode
+
+ :since: 1.2.3
+
+ """
+ self.edd = eet_data_descriptor_file_new(cls.eddc)
+
+ def free(self):
+ """
+
+ This function frees a data descriptor when it is not needed anymore.
+ :param edd: The data descriptor to free.
+
+ This function takes a data descriptor handle as a parameter and frees all
+ data allocated for the data descriptor and the handle itself. After this
+ call the descriptor is no longer valid.
+
+ :since: 1.0.0
+
+ """
+ eet_data_descriptor_free(self.edd)
+
+ property name:
+ """
+
+ This function returns the name of a data descriptor.
+
+ :since: 1.8.0
+
+ """
+ return _ctouni(eet_data_descriptor_name_get(self.edd)
+
+
+ def decode(self, data_in, size_in):
+ """
+
+ Decode a data structure from an arbitrary location in memory.
+ :param edd: The data descriptor to use when decoding.
+ :param data_in: The pointer to the data to decode into a struct.
+ :param size_in: The size of the data pointed to in bytes.
+ :return: NULL on failure, or a valid decoded struct pointer on success.
+
+ This function will decode a data structure that has been encoded using
+ eet_data_descriptor_encode(), and return a data structure with all its
+ elements filled out, if successful, or NULL on failure.
+
+ The data to be decoded is stored at the memory pointed to by @p data_in,
+ and is described by the descriptor pointed to by @p edd. The data size is
+ passed in as the value to @p size_in, ande must be greater than 0 to
+ succeed.
+
+ This function is useful for decoding data structures delivered to the
+ application by means other than an eet file, such as an IPC or socket
+ connection, raw files, shared memory etc.
+
+ Please see eet_data_read() for more information.
+
+ @see eet_data_descriptor_decode_cipher()
+
+ :since: 1.0.0
+
+ """
+ EAPI void *
+ eet_data_descriptor_decode(Eet_Data_Descriptor *edd,
+ const void *data_in,
+ int size_in);
+
+ def encode(self, data_in):
+ """
+
+ Encode a dsata struct to memory and return that encoded data.
+ :param edd: The data descriptor to use when encoding.
+ :param data_in: The pointer to the struct to encode into data.
+ :param size_ret: pointer to the an int to be filled with the decoded size.
+ :return: NULL on failure, or a valid encoded data chunk on success.
+
+ This function takes a data structutre in memory and encodes it into a
+ serialised chunk of data that can be decoded again by
+ eet_data_descriptor_decode(). This is useful for being able to transmit
+ data structures across sockets, pipes, IPC or shared file mechanisms,
+ without having to worry about memory space, machine type, endianness etc.
+
+ The parameter @p edd must point to a valid data descriptor, and
+ @p data_in must point to the right data structure to encode. If not, the
+ encoding may fail.
+
+ On success a non NULL valid pointer is returned and what @p size_ret
+ points to is set to the size of this decoded data, in bytes. When the
+ encoded data is no longer needed, call free() on it. On failure NULL is
+ returned and what @p size_ret points to is set to 0.
+
+ Please see eet_data_write() for more information.
+
+ @see eet_data_descriptor_encode_cipher()
+
+ :since: 1.0.0
+
+ """
+ EAPI void *
+ eet_data_descriptor_encode(Eet_Data_Descriptor *edd,
+ const void *data_in,
+ int *size_ret);
+
+ def decode_cipher(self, data_in, cipher_key, size_in):
+ """
+
+ Decode a data structure from an arbitrary location in memory
+ using a cipher.
+ :param edd: The data descriptor to use when decoding.
+ :param data_in: The pointer to the data to decode into a struct.
+ :param cipher_key: The key to use as cipher.
+ :param size_in: The size of the data pointed to in bytes.
+ :return: NULL on failure, or a valid decoded struct pointer on success.
+
+ This function will decode a data structure that has been encoded using
+ eet_data_descriptor_encode(), and return a data structure with all its
+ elements filled out, if successful, or NULL on failure.
+
+ The data to be decoded is stored at the memory pointed to by @p data_in,
+ and is described by the descriptor pointed to by @p edd. The data size is
+ passed in as the value to @p size_in, ande must be greater than 0 to
+ succeed.
+
+ This function is useful for decoding data structures delivered to the
+ application by means other than an eet file, such as an IPC or socket
+ connection, raw files, shared memory etc.
+
+ Please see eet_data_read() for more information.
+
+ @see eet_data_descriptor_decode()
+
+ :since: 1.0.0
+
+ """
+ EAPI void *
+ eet_data_descriptor_decode_cipher(Eet_Data_Descriptor *edd,
+ const void *data_in,
+ const char *cipher_key,
+ int size_in);
+
+ def encode_cipher(self, data_in, cipher_key):
+ """
+
+ Encode a data struct to memory and return that encoded data
+ using a cipher.
+ :param edd: The data descriptor to use when encoding.
+ :param data_in: The pointer to the struct to encode into data.
+ :param cipher_key: The key to use as cipher.
+ :param size_ret: pointer to the an int to be filled with the decoded size.
+ :return: NULL on failure, or a valid encoded data chunk on success.
+
+ This function takes a data structutre in memory and encodes it into a
+ serialised chunk of data that can be decoded again by
+ eet_data_descriptor_decode(). This is useful for being able to transmit
+ data structures across sockets, pipes, IPC or shared file mechanisms,
+ without having to worry about memory space, machine type, endianess etc.
+
+ The parameter @p edd must point to a valid data descriptor, and
+ @p data_in must point to the right data structure to encode. If not, the
+ encoding may fail.
+
+ On success a non NULL valid pointer is returned and what @p size_ret
+ points to is set to the size of this decoded data, in bytes. When the
+ encoded data is no longer needed, call free() on it. On failure NULL is
+ returned and what @p size_ret points to is set to 0.
+
+ Please see eet_data_write() for more information.
+
+ @see eet_data_descriptor_encode()
+
+ :since: 1.0.0
+
+ """
+ EAPI void *
+ eet_data_descriptor_encode_cipher(Eet_Data_Descriptor *edd,
+ const void *data_in,
+ const char *cipher_key,
+ int *size_ret);
+
+
+ def add_basic(self, struct_type, name, member, type):
+ """
+
+ Add a basic data element to a data descriptor.
+ :param edd: The data descriptor to add the type to.
+ :param struct_type: The type of the struct.
+ :param name: The string name to use to encode/decode this member
+ (must be a constant global and never change).
+ :param member: The struct member itself to be encoded.
+ :param type: The type of the member to encode.
+
+ This macro is a convenience macro provided to add a member to
+ the data descriptor @p edd. The type of the structure is
+ provided as the @p struct_type parameter (for example: struct
+ my_struct). The @p name parameter defines a string that will be
+ used to uniquely name that member of the struct (it is suggested
+ to use the struct member itself). The @p member parameter is
+ the actual struct member itself (for example: values), and @p type is the
+ basic data type of the member which must be one of: EET_T_CHAR, EET_T_SHORT,
+ EET_T_INT, EET_T_LONG_LONG, EET_T_FLOAT, EET_T_DOUBLE, EET_T_UCHAR,
+ EET_T_USHORT, EET_T_UINT, EET_T_ULONG_LONG or EET_T_STRING.
+
+ :since: 1.0.0
+
+ """
+ EET_DATA_DESCRIPTOR_ADD_BASIC(edd, struct_type, name, member, type)
+
+ def add_sub(self, struct_type, name, member, subtype):
+ """
+
+ Add a sub-element type to a data descriptor
+ :param edd: The data descriptor to add the type to.
+ :param struct_type: The type of the struct.
+ :param name: The string name to use to encode/decode this member
+ (must be a constant global and never change).
+ :param member: The struct member itself to be encoded.
+ :param subtype: The type of sub-type struct to add.
+
+ This macro lets you easily add a sub-type (a struct that's pointed to
+ by this one). All the parameters are the same as for
+ EET_DATA_DESCRIPTOR_ADD_BASIC(), with the @p subtype being the exception.
+ This must be the data descriptor of the struct that is pointed to by
+ this element.
+
+ :since: 1.0.0
+
+ """
+ EET_DATA_DESCRIPTOR_ADD_SUB(edd, struct_type, name, member, subtype)
+
+ def add_sub_nested(self, struct_type, name, member, subtype):
+ """
+
+ Add a nested sub-element type to a data descriptor
+ :param edd: The data descriptor to add the type to.
+ :param struct_type: The type of the struct.
+ :param name: The string name to use to encode/decode this member
+ (must be a constant global and never change).
+ :param member: The struct member itself to be encoded.
+ :param subtype: The type of sub-type struct to add.
+
+ This macro lets you easily add a sub-type: a struct that is nested into
+ this one. If your data is pointed by this element instead of being nested,
+ you should use EET_DATA_DESCRIPTOR_ADD_SUB().
+ All the parameters are the same as for EET_DATA_DESCRIPTOR_ADD_SUB().
+
+ :since: 1.8.0
+
+ """
+ EET_DATA_DESCRIPTOR_ADD_SUB_NESTED(edd, struct_type, name, member, subtype)
+
+ def add_list(self, struct_type, name, member, subtype):
+ """
+
+ Add a linked list type to a data descriptor
+ :param edd: The data descriptor to add the type to.
+ :param struct_type: The type of the struct.
+ :param name: The string name to use to encode/decode this member
+ (must be a constant global and never change).
+ :param member: The struct member itself to be encoded.
+ :param subtype: The type of linked list member to add.
+
+ This macro lets you easily add a linked list of other data types. All the
+ parameters are the same as for EET_DATA_DESCRIPTOR_ADD_BASIC(), with the
+ @p subtype being the exception. This must be the data descriptor of the
+ element that is in each member of the linked list to be stored.
+
+ :since: 1.0.0
+
+ """
+ EET_DATA_DESCRIPTOR_ADD_LIST(edd, struct_type, name, member, subtype)
+
+ def add_list_string(self, struct_type, name, member):
+ """
+
+ Add a linked list of string to a data descriptor
+ :param edd: The data descriptor to add the type to.
+ :param struct_type: The type of the struct.
+ :param name: The string name to use to encode/decode this member
+ (must be a constant global and never change).
+ :param member: The struct member itself to be encoded.
+
+ This macro lets you easily add a linked list of char *. All the
+ parameters are the same as for EET_DATA_DESCRIPTOR_ADD_BASIC().
+
+ :since: 1.5.0
+
+ """
+ EET_DATA_DESCRIPTOR_ADD_LIST_STRING(edd, struct_type, name, member)
+
+ def add_hash(self, struct_type, name, member, subtype):
+ """
+
+ Add a hash type to a data descriptor
+ :param edd: The data descriptor to add the type to.
+ :param struct_type: The type of the struct.
+ :param name: The string name to use to encode/decode this member
+ (must be a constant global and never change).
+ :param member: The struct member itself to be encoded.
+ :param subtype: The type of hash member to add.
+
+ This macro lets you easily add a hash of other data types. All the
+ parameters are the same as for EET_DATA_DESCRIPTOR_ADD_BASIC(), with the
+ @p subtype being the exception. This must be the data descriptor of the
+ element that is in each member of the hash to be stored.
+ The hash keys must be strings.
+
+ :since: 1.0.0
+
+ """
+ EET_DATA_DESCRIPTOR_ADD_HASH(edd, struct_type, name, member, subtype)
+
+ def add_hash_string(self, struct_type, name, member):
+ """
+
+ Add a hash of string to a data descriptor
+ :param edd: The data descriptor to add the type to.
+ :param struct_type: The type of the struct.
+ :param name: The string name to use to encode/decode this member
+ (must be a constant global and never change).
+ :param member: The struct member itself to be encoded.
+
+ This macro lets you easily add a hash of string elements. All the
+ parameters are the same as for EET_DATA_DESCRIPTOR_ADD_HASH().
+
+ :since: 1.3.4
+
+ """
+ EET_DATA_DESCRIPTOR_ADD_HASH_STRING(edd, struct_type, name, member)
+
+ def add_basic_array(self, struct_type, name, member, type):
+ """
+
+ Add an array of basic data elements to a data descriptor.
+ :param edd: The data descriptor to add the type to.
+ :param struct_type: The type of the struct.
+ :param name: The string name to use to encode/decode this member
+ (must be a constant global and never change).
+ :param member: The struct member itself to be encoded.
+ :param type: The type of the member to encode.
+
+ This macro lets you easily add a fixed size array of basic data
+ types. All the parameters are the same as for
+ EET_DATA_DESCRIPTOR_ADD_BASIC().
+ The array must be defined with a fixed size in the declaration of the
+ struct containing it.
+
+ :since: 1.5.0
+
+ """
+ EET_DATA_DESCRIPTOR_ADD_BASIC_ARRAY(edd, struct_type, name, member, type)
+
+ def add_basic_var_array(self, struct_type, name, member, type):
+ """
+
+ Add a variable array of basic data elements to a data descriptor.
+ :param edd: The data descriptor to add the type to.
+ :param struct_type: The type of the struct.
+ :param name: The string name to use to encode/decode this member
+ (must be a constant global and never change).
+ :param member: The struct member itself to be encoded.
+ :param type: The type of the member to encode.
+
+ This macro lets you easily add a variable size array of basic data
+ types. All the parameters are the same as for
+ EET_DATA_DESCRIPTOR_ADD_BASIC(). This assumes you have
+ a struct member (of type EET_T_INT) called member_count (note the
+ _count appended to the member) that holds the number of items in
+ the array. This array will be allocated separately to the struct it
+ is in.
+
+ :since: 1.6.0
+
+ """
+ EET_DATA_DESCRIPTOR_ADD_BASIC_VAR_ARRAY(edd, struct_type, name, member, type)
+
+ def add_array(self, struct_type, name, member, subtype):
+ """
+
+ Add a fixed size array type to a data descriptor
+ :param edd: The data descriptor to add the type to.
+ :param struct_type: The type of the struct.
+ :param name: The string name to use to encode/decode this member
+ (must be a constant global and never change).
+ :param member: The struct member itself to be encoded.
+ :param subtype: The type of hash member to add.
+
+ This macro lets you easily add a fixed size array of other data
+ types. All the parameters are the same as for
+ EET_DATA_DESCRIPTOR_ADD_BASIC(), with the @p subtype being the
+ exception. This must be the data descriptor of the element that
+ is in each member of the array to be stored.
+ The array must be defined with a fixed size in the declaration of the
+ struct containing it.
+
+ :since: 1.0.2
+
+ """
+ EET_DATA_DESCRIPTOR_ADD_ARRAY(edd, struct_type, name, member, subtype)
+
+ def add_var_array(self, struct_type, name, member, subtype):
+ """
+
+ Add a variable size array type to a data descriptor
+ :param edd: The data descriptor to add the type to.
+ :param struct_type: The type of the struct.
+ :param name: The string name to use to encode/decode this member
+ (must be a constant global and never change).
+ :param member: The struct member itself to be encoded.
+ :param subtype: The type of hash member to add.
+
+ This macro lets you easily add a variable size array of other data
+ types. All the parameters are the same as for
+ EET_DATA_DESCRIPTOR_ADD_BASIC(), with the @p subtype being the
+ exception. This must be the data descriptor of the element that
+ is in each member of the array to be stored. This assumes you have
+ a struct member (of type EET_T_INT) called member_count (note the
+ _count appended to the member) that holds the number of items in
+ the array. This array will be allocated separately to the struct it
+ is in.
+
+ :since: 1.0.2
+
+ """
+ EET_DATA_DESCRIPTOR_ADD_VAR_ARRAY(edd, struct_type, name, member, subtype)
+
+ def add_var_array_string(self, struct_type, name, member):
+ """
+
+ Add a variable size array type to a data descriptor
+ :param edd: The data descriptor to add the type to.
+ :param struct_type: The type of the struct.
+ :param name: The string name to use to encode/decode this member
+ (must be a constant global and never change).
+ :param member: The struct member itself to be encoded.
+
+ This macro lets you easily add a variable size array of strings. All
+ the parameters are the same as for EET_DATA_DESCRIPTOR_ADD_BASIC().
+
+ :since: 1.4.0
+
+ """
+ EET_DATA_DESCRIPTOR_ADD_VAR_ARRAY_STRING(edd, struct_type, name, member)
+
+ def add_union(self, struct_type, name, member, type_member, unified_type):
+ """
+
+ Add an union type to a data descriptor
+ :param edd: The data descriptor to add the type to.
+ :param struct_type: The type of the struct.
+ :param name: The string name to use to encode/decode this member
+ (must be a constant global and never change).
+ :param member: The struct member itself to be encoded.
+ :param type_member: The member that give hints on what is in the union.
+ :param unified_type: Describe all possible type the union could handle.
+
+ This macro lets you easily add an union with a member that specify what is inside.
+ The @p unified_type is an Eet_Data_Descriptor, but only the entry that match the name
+ returned by type_get will be used for each serialized data. The type_get and type_set
+ callback of unified_type should be defined.
+
+ :since: 1.2.4
+ :see: Eet_Data_Descriptor_Class
+
+ """
+ EET_DATA_DESCRIPTOR_ADD_UNION(edd, struct_type, name, member, type_member, unified_type)
+
+ def add_variant(self, struct_type, name, member, type_member, unified_type):
+ """
+
+ Add a automatically selectable type to a data descriptor
+ :param edd: The data descriptor to add the type to.
+ :param struct_type: The type of the struct.
+ :param name: The string name to use to encode/decode this member
+ (must be a constant global and never change).
+ :param member: The struct member itself to be encoded.
+ :param type_member: The member that give hints on what is in the union.
+ :param unified_type: Describe all possible type the union could handle.
+
+ This macro lets you easily define what the content of @p member points to depending of
+ the content of @p type_member. The type_get and type_set callback of unified_type should
+ be defined. If the the type is not know at the time of restoring it, eet will still call
+ type_set of @p unified_type but the pointer will be set to a serialized binary representation
+ of what eet know. This make it possible, to save this pointer again by just returning the string
+ given previously and telling it by setting unknow to EINA_TRUE.
+
+ :since: 1.2.4
+ :see: Eet_Data_Descriptor_Class
+
+ """
+ EET_DATA_DESCRIPTOR_ADD_VARIANT(edd, struct_type, name, member, type_member, unified_type)
+
+ def add_mapping(self, name, subtype):
+ """
+
+ Add a mapping to a data descriptor that will be used by union, variant or inherited type
+ :param unified_type: The data descriptor to add the mapping to.
+ :param name: The string name to get/set type.
+ :param subtype: The matching data descriptor.
+
+ :since: 1.2.4
+ :see: Eet_Data_Descriptor_Class
+
+ """
+ EET_DATA_DESCRIPTOR_ADD_MAPPING(unified_type, name, subtype)
+
+ def add_mapping_basic(self, name, basic_type):
+ """
+
+ Add a mapping of a basic type to a data descriptor that will be used by a union type.
+ :param unified_type: The data descriptor to add the mapping to.
+ :param name: The string name to get/set type.
+ :param basic_type: The matching basic type.
+
+ :since: 1.8
+ :see: Eet_Data_Descriptor_Class
+
+ """
+ EET_DATA_DESCRIPTOR_ADD_MAPPING_BASIC(unified_type, name, basic_type)
diff --git a/efl/eet/data_descriptor_class.pxi b/efl/eet/data_descriptor_class.pxi
new file mode 100644
index 0000000..a32fbeb
--- /dev/null
+++ b/efl/eet/data_descriptor_class.pxi
@@ -0,0 +1,176 @@
+
+
+"""
+
+@def EET_DATA_DESCRIPTOR_CLASS_VERSION
+The version of #Eet_Data_Descriptor_Class at the time of the
+distribution of the sources. One should define this to its
+version member so it is compatible with abi changes, or at least
+will not crash with them.
+
+"""
+#define EET_DATA_DESCRIPTOR_CLASS_VERSION 4
+
+
+
+"""
+
+@typedef Eet_Data_Descriptor_Class
+
+Instructs Eet about memory management for different needs under
+serialization and parse process.
+
+"""
+typedef struct _Eet_Data_Descriptor_Class Eet_Data_Descriptor_Class;
+
+typedef int (*Eet_Descriptor_Hash_Foreach_Callback_Callback)(void *h, const char *k, void *dt, void *fdt);
+
+typedef void * (*Eet_Descriptor_Mem_Alloc_Callback)(size_t size);
+typedef void (*Eet_Descriptor_Mem_Free_Callback)(void *mem);
+typedef char * (*Eet_Descriptor_Str_Alloc_Callback)(const char *str);
+typedef void (*Eet_Descriptor_Str_Free_Callback)(const char *str);
+typedef void * (*Eet_Descriptor_List_Next_Callback)(void *l);
+typedef void * (*Eet_Descriptor_List_Append_Callback)(void *l, void *d);
+typedef void * (*Eet_Descriptor_List_Data_Callback)(void *l);
+typedef void * (*Eet_Descriptor_List_Free_Callback)(void *l);
+typedef void (*Eet_Descriptor_Hash_Foreach_Callback)(void *h, Eet_Descriptor_Hash_Foreach_Callback_Callback func, void *fdt);
+typedef void * (*Eet_Descriptor_Hash_Add_Callback)(void *h, const char *k, void *d);
+typedef void (*Eet_Descriptor_Hash_Free_Callback)(void *h);
+typedef char * (*Eet_Descriptor_Str_Direct_Alloc_Callback)(const char *str);
+typedef void (*Eet_Descriptor_Str_Direct_Free_Callback)(const char *str);
+typedef const char * (*Eet_Descriptor_Type_Get_Callback)(const void *data, Eina_Bool *unknow);
+typedef Eina_Bool (*Eet_Descriptor_Type_Set_Callback)(const char *type, void *data, Eina_Bool unknow);
+typedef void * (*Eet_Descriptor_Array_Alloc_Callback)(size_t size);
+typedef void (*Eet_Descriptor_Array_Free_Callback)(void *mem);
+"""
+
+@struct _Eet_Data_Descriptor_Class
+
+Instructs Eet about memory management for different needs under
+serialization and parse process.
+
+The list and hash methods match the Eina API, so for a more detailed
+reference on them, look at the Eina_List and Eina_Hash documentation,
+respectively.
+For the most part these will be used with the standard Eina functions,
+so using EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET() and
+EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET() will set up everything
+accordingly.
+
+"""
+struct _Eet_Data_Descriptor_Class
+{
+ int version; # ABI version. Should always be set to #EET_DATA_DESCRIPTOR_CLASS_VERSION
+ const char *name; # Name of the user data type to be serialized
+ int size; # Size in bytes of the user data type to be serialized
+ struct
+ {
+ Eet_Descriptor_Mem_Alloc_Callback mem_alloc; # how to allocate memory (usually malloc())
+ Eet_Descriptor_Mem_Free_Callback mem_free; # how to free memory (usually free())
+ Eet_Descriptor_Str_Alloc_Callback str_alloc; # how to allocate a string
+ Eet_Descriptor_Str_Free_Callback str_free; # how to free a string
+ Eet_Descriptor_List_Next_Callback list_next; # how to iterate to the next element of a list. Receives and should return the list node.
+ Eet_Descriptor_List_Append_Callback list_append; # how to append data @p d to list which head node is @p l
+ Eet_Descriptor_List_Data_Callback list_data; # retrieves the data from node @p l
+ Eet_Descriptor_List_Free_Callback list_free; # free all the nodes from the list which head node is @p l
+ Eet_Descriptor_Hash_Foreach_Callback hash_foreach; # iterates over all elements in the hash @p h in no specific order
+ Eet_Descriptor_Hash_Add_Callback hash_add; # add a new data @p d with key @p k in hash @p h
+ Eet_Descriptor_Hash_Free_Callback hash_free; # free all entries from the hash @p h
+ Eet_Descriptor_Str_Direct_Alloc_Callback str_direct_alloc; # how to allocate a string directly from file backed/mmaped region pointed by @p str
+ Eet_Descriptor_Str_Direct_Free_Callback str_direct_free; # how to free a string returned by str_direct_alloc
+ Eet_Descriptor_Type_Get_Callback type_get; # get the type, as used in the union or variant mapping, that should be used to store the given data into the eet file.
+ Eet_Descriptor_Type_Set_Callback type_set; # called when loading a mapped type with the given @p type used to describe the type in the descriptor
+ Eet_Descriptor_Array_Alloc_Callback array_alloc; # how to allocate memory for array (usually malloc())
+ Eet_Descriptor_Array_Free_Callback array_free; # how to free memory for array (usually free())
+ } func;
+};
+
+
+
+
+"""
+
+This function is an helper that set all the parameters of an
+Eet_Data_Descriptor_Class correctly when you use Eina data type
+with a stream.
+:param eddc: The Eet_Data_Descriptor_Class you want to set.
+:param eddc_size: The size of the Eet_Data_Descriptor_Class at the compilation time.
+:param name: The name of the structure described by this class.
+:param size: The size of the structure described by this class.
+:return: EINA_TRUE if the structure was correctly set (The only
+ reason that could make it fail is if you did give wrong
+ parameter).
+
+@note Unless there's a very specific reason to use this function directly,
+the EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET macro is recommended.
+
+:since: 1.2.3
+
+"""
+EAPI Eina_Bool
+eet_eina_stream_data_descriptor_class_set(Eet_Data_Descriptor_Class *eddc,
+ unsigned int eddc_size,
+ const char *name,
+ int size);
+
+"""
+
+This macro is an helper that set all the parameter of an
+Eet_Data_Descriptor_Class correctly when you use Eina data type
+with stream.
+:param clas: The Eet_Data_Descriptor_Class you want to set.
+:param type: The type of the structure described by this class.
+:return: EINA_TRUE if the structure was correctly set (The only
+ reason that could make it fail is if you did give wrong
+ parameter).
+
+:see: eet_data_descriptor_stream_new
+:since: 1.2.3
+
+"""
+#define EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(clas, type) \
+ (eet_eina_stream_data_descriptor_class_set(clas, sizeof (*(clas)), # type, sizeof(type)))
+
+"""
+
+This function is an helper that set all the parameter of an
+Eet_Data_Descriptor_Class correctly when you use Eina data type
+with a file.
+:param eddc: The Eet_Data_Descriptor_Class you want to set.
+:param eddc_size: The size of the Eet_Data_Descriptor_Class at the compilation time.
+:param name: The name of the structure described by this class.
+:param size: The size of the structure described by this class.
+:return: EINA_TRUE if the structure was correctly set (The only
+ reason that could make it fail is if you did give wrong
+ parameter).
+
+@note Unless there's a very specific reason to use this function directly,
+the EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET macro is recommended.
+
+:since: 1.2.3
+
+"""
+EAPI Eina_Bool
+eet_eina_file_data_descriptor_class_set(Eet_Data_Descriptor_Class *eddc,
+ unsigned int eddc_size,
+ const char *name,
+ int size);
+
+"""
+
+This macro is an helper that set all the parameter of an
+Eet_Data_Descriptor_Class correctly when you use Eina data type
+with file.
+:param clas: The Eet_Data_Descriptor_Class you want to set.
+:param type: The type of the structure described by this class.
+:return: EINA_TRUE if the structure was correctly set (The only
+ reason that could make it fail is if you did give wrong
+ parameter).
+
+:see: eet_data_descriptor_file_new
+:since: 1.2.3
+
+"""
+#define EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(clas, type) \
+ (eet_eina_file_data_descriptor_class_set(clas, sizeof (*(clas)), # type, sizeof(type)))
+
diff --git a/efl/eet/data_utils.pxi b/efl/eet/data_utils.pxi
new file mode 100644
index 0000000..06263b9
--- /dev/null
+++ b/efl/eet/data_utils.pxi
@@ -0,0 +1,622 @@
+"""
+
+Decode Image data header only to get information.
+:param data: The encoded pixel data.
+:param size: The size, in bytes, of the encoded pixel data.
+:param w: A pointer to the unsigned int to hold the width in pixels.
+:param h: A pointer to the unsigned int to hold the height in pixels.
+:param alpha: A pointer to the int to hold the alpha flag.
+:param compress: A pointer to the int to hold the compression amount.
+:param quality: A pointer to the int to hold the quality amount.
+:param lossy: A pointer to the int to hold the lossiness flag.
+:return: 1 on success, 0 on failure.
+
+This function works exactly like eet_data_image_header_read(), but instead
+of reading from an Eet file, it takes the buffer of size @p size pointed
+by @p data, which must be a valid Eet encoded image.
+
+On success the function returns 1 indicating the header was read and
+decoded properly, or 0 on failure.
+
+@see eet_data_image_header_read()
+@see eet_data_image_header_decode_cipher()
+
+:since: 1.0.0
+
+"""
+EAPI int
+eet_data_image_header_decode(const void *data,
+ int size,
+ unsigned int *w,
+ unsigned int *h,
+ int *alpha,
+ int *compress,
+ int *quality,
+ int *lossy);
+
+"""
+
+Decode Image data into pixel data.
+:param data: The encoded pixel data.
+:param size: The size, in bytes, of the encoded pixel data.
+:param w: A pointer to the unsigned int to hold the width in pixels.
+:param h: A pointer to the unsigned int to hold the height in pixels.
+:param alpha: A pointer to the int to hold the alpha flag.
+:param compress: A pointer to the int to hold the compression amount.
+:param quality: A pointer to the int to hold the quality amount.
+:param lossy: A pointer to the int to hold the lossiness flag.
+:return: The image pixel data decoded
+
+This function takes encoded pixel data and decodes it into raw RGBA
+pixels on success.
+
+It works exactly like eet_data_image_read(), but it takes the encoded
+data in the @p data buffer of size @p size, instead of reading from a file.
+All the others parameters are also the same.
+
+On success the function returns a pointer to the image data decoded. The
+calling application is responsible for calling free() on the image data
+when it is done with it. On failure NULL is returned and the parameter
+values may not contain any sensible data.
+
+@see eet_data_image_read()
+@see eet_data_image_decode_cipher()
+
+:since: 1.0.0
+
+"""
+EAPI void *
+eet_data_image_decode(const void *data,
+ int size,
+ unsigned int *w,
+ unsigned int *h,
+ int *alpha,
+ int *compress,
+ int *quality,
+ int *lossy);
+
+"""
+
+Decode Image data into pixel data and stores in the given buffer.
+:param data: The encoded pixel data.
+:param size: The size, in bytes, of the encoded pixel data.
+:param src_x: The starting x coordinate from where to dump the stream.
+:param src_y: The starting y coordinate from where to dump the stream.
+:param d: A pointer to the pixel surface.
+:param w: The expected width in pixels of the pixel surface to decode.
+:param h: The expected height in pixels of the pixel surface to decode.
+:param row_stride: The length of a pixels line in the destination surface.
+:param alpha: A pointer to the int to hold the alpha flag.
+:param compress: A pointer to the int to hold the compression amount.
+:param quality: A pointer to the int to hold the quality amount.
+:param lossy: A pointer to the int to hold the lossiness flag.
+:return: 1 on success, 0 otherwise.
+
+Like eet_data_image_read_to_surface(), but reading the given @p data buffer
+instead of a file.
+
+On success the function returns 1, and 0 on failure. On failure the
+parameter values may not contain any sensible data.
+
+@see eet_data_image_read_to_surface()
+@see eet_data_image_decode_to_surface_cipher()
+
+:since: 1.0.2
+
+"""
+EAPI int
+eet_data_image_decode_to_surface(const void *data,
+ int size,
+ unsigned int src_x,
+ unsigned int src_y,
+ unsigned int *d,
+ unsigned int w,
+ unsigned int h,
+ unsigned int row_stride,
+ int *alpha,
+ int *compress,
+ int *quality,
+ int *lossy);
+
+"""
+
+Encode image data for storage or transmission.
+:param data: A pointer to the image pixel data.
+:param size_ret: A pointer to an int to hold the size of the returned data.
+:param w: The width of the image in pixels.
+:param h: The height of the image in pixels.
+:param alpha: The alpha channel flag.
+:param compress: The compression amount.
+:param quality: The quality encoding amount.
+:param lossy: The lossiness flag.
+:return: The encoded image data.
+
+This function stakes image pixel data and encodes it with compression and
+possible loss of quality (as a trade off for size) for storage or
+transmission to another system.
+
+It works like eet_data_image_write(), but instead of writing the encoded
+image into an Eet file, it allocates a new buffer of the size required and
+returns the encoded data in it.
+
+On success this function returns a pointer to the encoded data that you
+can free with free() when no longer needed.
+
+@see eet_data_image_write()
+@see eet_data_image_read()
+@see eet_data_image_encode_cipher()
+
+:since: 1.0.0
+
+"""
+EAPI void *
+eet_data_image_encode(const void *data,
+ int *size_ret,
+ unsigned int w,
+ unsigned int h,
+ int alpha,
+ int compress,
+ int quality,
+ int lossy);
+
+
+"""
+
+Decode Image data header only to get information using a cipher.
+:param data: The encoded pixel data.
+:param cipher_key: The key to use as cipher.
+:param size: The size, in bytes, of the encoded pixel data.
+:param w: A pointer to the unsigned int to hold the width in pixels.
+:param h: A pointer to the unsigned int to hold the height in pixels.
+:param alpha: A pointer to the int to hold the alpha flag.
+:param compress: A pointer to the int to hold the compression amount.
+:param quality: A pointer to the int to hold the quality amount.
+:param lossy: A pointer to the int to hold the lossiness flag.
+:return: 1 on success, 0 on failure.
+
+This function takes encoded pixel data and decodes it into raw RGBA
+pixels on success.
+
+The other parameters of the image (width, height etc.) are placed into
+the values pointed to (they must be supplied). The pixel data is a linear
+array of pixels starting from the top-left of the image scanning row by
+row from left to right. Each pixel is a 32bit value, with the high byte
+being the alpha channel, the next being red, then green, and the low byte
+being blue. The width and height are measured in pixels and will be
+greater than 0 when returned. The alpha flag is either 0 or 1. 0 denotes
+that the alpha channel is not used. 1 denotes that it is significant.
+Compress is filled with the compression value/amount the image was
+stored with. The quality value is filled with the quality encoding of
+the image file (0 - 100). The lossy flags is either 0 or 1 as to if
+the image was encoded lossily or not.
+
+On success the function returns 1 indicating the header was read and
+decoded properly, or 0 on failure.
+
+@see eet_data_image_header_decode()
+
+:since: 1.0.0
+
+"""
+EAPI int
+eet_data_image_header_decode_cipher(const void *data,
+ const char *cipher_key,
+ int size,
+ unsigned int *w,
+ unsigned int *h,
+ int *alpha,
+ int *compress,
+ int *quality,
+ int *lossy);
+
+"""
+
+Decode Image data into pixel data using a cipher.
+:param data: The encoded pixel data.
+:param cipher_key: The key to use as cipher.
+:param size: The size, in bytes, of the encoded pixel data.
+:param w: A pointer to the unsigned int to hold the width in pixels.
+:param h: A pointer to the unsigned int to hold the height in pixels.
+:param alpha: A pointer to the int to hold the alpha flag.
+:param compress: A pointer to the int to hold the compression amount.
+:param quality: A pointer to the int to hold the quality amount.
+:param lossy: A pointer to the int to hold the lossiness flag.
+:return: The image pixel data decoded
+
+This function takes encoded pixel data and decodes it into raw RGBA
+pixels on success.
+
+The other parameters of the image (width, height etc.) are placed into
+the values pointed to (they must be supplied). The pixel data is a linear
+array of pixels starting from the top-left of the image scanning row by
+row from left to right. Each pixel is a 32bit value, with the high byte
+being the alpha channel, the next being red, then green, and the low byte
+being blue. The width and height are measured in pixels and will be
+greater than 0 when returned. The alpha flag is either 0 or 1. 0 denotes
+that the alpha channel is not used. 1 denotes that it is significant.
+Compress is filled with the compression value/amount the image was
+stored with. The quality value is filled with the quality encoding of
+the image file (0 - 100). The lossy flags is either 0 or 1 as to if
+the image was encoded lossily or not.
+
+On success the function returns a pointer to the image data decoded. The
+calling application is responsible for calling free() on the image data
+when it is done with it. On failure NULL is returned and the parameter
+values may not contain any sensible data.
+
+@see eet_data_image_decode()
+
+:since: 1.0.0
+
+"""
+EAPI void *
+eet_data_image_decode_cipher(const void *data,
+ const char *cipher_key,
+ int size,
+ unsigned int *w,
+ unsigned int *h,
+ int *alpha,
+ int *compress,
+ int *quality,
+ int *lossy);
+
+"""
+
+Decode Image data into pixel data using a cipher.
+:param data: The encoded pixel data.
+:param cipher_key: The key to use as cipher.
+:param size: The size, in bytes, of the encoded pixel data.
+:param src_x: The starting x coordinate from where to dump the stream.
+:param src_y: The starting y coordinate from where to dump the stream.
+:param d: A pointer to the pixel surface.
+:param w: The expected width in pixels of the pixel surface to decode.
+:param h: The expected height in pixels of the pixel surface to decode.
+:param row_stride: The length of a pixels line in the destination surface.
+:param alpha: A pointer to the int to hold the alpha flag.
+:param compress: A pointer to the int to hold the compression amount.
+:param quality: A pointer to the int to hold the quality amount.
+:param lossy: A pointer to the int to hold the lossiness flag.
+:return: 1 on success, 0 otherwise.
+
+This function takes encoded pixel data and decodes it into raw RGBA
+pixels on success.
+
+The other parameters of the image (alpha, compress etc.) are placed into
+the values pointed to (they must be supplied). The pixel data is a linear
+array of pixels starting from the top-left of the image scanning row by
+row from left to right. Each pixel is a 32bit value, with the high byte
+being the alpha channel, the next being red, then green, and the low byte
+being blue. The width and height are measured in pixels and will be
+greater than 0 when returned. The alpha flag is either 0 or 1. 0 denotes
+that the alpha channel is not used. 1 denotes that it is significant.
+Compress is filled with the compression value/amount the image was
+stored with. The quality value is filled with the quality encoding of
+the image file (0 - 100). The lossy flags is either 0 or 1 as to if
+the image was encoded lossily or not.
+
+On success the function returns 1, and 0 on failure. On failure the
+parameter values may not contain any sensible data.
+
+@see eet_data_image_decode_to_surface()
+
+:since: 1.0.2
+
+"""
+EAPI int
+eet_data_image_decode_to_surface_cipher(const void *data,
+ const char *cipher_key,
+ int size,
+ unsigned int src_x,
+ unsigned int src_y,
+ unsigned int *d,
+ unsigned int w,
+ unsigned int h,
+ unsigned int row_stride,
+ int *alpha,
+ int *compress,
+ int *quality,
+ int *lossy);
+
+"""
+
+Encode image data for storage or transmission using a cipher.
+:param data: A pointer to the image pixel data.
+:param cipher_key: The key to use as cipher.
+:param size_ret: A pointer to an int to hold the size of the returned data.
+:param w: The width of the image in pixels.
+:param h: The height of the image in pixels.
+:param alpha: The alpha channel flag.
+:param compress: The compression amount.
+:param quality: The quality encoding amount.
+:param lossy: The lossiness flag.
+:return: The encoded image data.
+
+This function stakes image pixel data and encodes it with compression and
+possible loss of quality (as a trade off for size) for storage or
+transmission to another system.
+
+The data expected is the same format as returned by eet_data_image_read.
+If this is not the case weird things may happen. Width and height must
+be between 1 and 8000 pixels. The alpha flags can be 0 or 1 (0 meaning
+the alpha values are not useful and 1 meaning they are). Compress can
+be from 0 to 9 (0 meaning no compression, 9 meaning full compression).
+This is only used if the image is not lossily encoded. Quality is used on
+lossy compression and should be a value from 0 to 100. The lossy flag
+can be 0 or 1. 0 means encode losslessly and 1 means to encode with
+image quality loss (but then have a much smaller encoding).
+
+On success this function returns a pointer to the encoded data that you
+can free with free() when no longer needed.
+
+@see eet_data_image_encode()
+
+:since: 1.0.0
+
+"""
+EAPI void *
+eet_data_image_encode_cipher(const void *data,
+ const char *cipher_key,
+ unsigned int w,
+ unsigned int h,
+ int alpha,
+ int compress,
+ int quality,
+ int lossy,
+ int *size_ret);
+
+
+
+
+typedef void (*Eet_Dump_Callback)(void *data, const char *str);
+
+"""
+
+Dump an eet encoded data structure into ascii text
+:param data_in: The pointer to the data to decode into a struct.
+:param size_in: The size of the data pointed to in bytes.
+:param dumpfunc: The function to call passed a string when new
+ data is converted to text
+:param dumpdata: The data to pass to the @p dumpfunc callback.
+:return: 1 on success, 0 on failure
+
+This function will take a chunk of data encoded by
+eet_data_descriptor_encode() and convert it into human readable
+ascii text. It does this by calling the @p dumpfunc callback
+for all new text that is generated. This callback should append
+to any existing text buffer and will be passed the pointer @p
+dumpdata as a parameter as well as a string with new text to be
+appended.
+
+Example:
+
+@code
+void output(void *data, const char *string)
+{
+ printf("%s", string);
+}
+
+void dump(const char *file)
+{
+ FILE *f;
+ int len;
+ void *data;
+
+ f = fopen(file, "r");
+ fseek(f, 0, SEEK_END);
+ len = ftell(f);
+ rewind(f);
+ data = malloc(len);
+ fread(data, len, 1, f);
+ fclose(f);
+ eet_data_text_dump(data, len, output, NULL);
+}
+@endcode
+
+:see: eet_data_text_dump_cipher()
+
+:since: 1.0.0
+
+"""
+EAPI int
+eet_data_text_dump(const void *data_in,
+ int size_in,
+ Eet_Dump_Callback dumpfunc,
+ void *dumpdata);
+
+"""
+
+Take an ascii encoding from eet_data_text_dump() and re-encode in binary.
+:param text: The pointer to the string data to parse and encode.
+:param textlen: The size of the string in bytes (not including 0
+ byte terminator).
+:param size_ret: This gets filled in with the encoded data blob
+ size in bytes.
+:return: The encoded data on success, NULL on failure.
+
+This function will parse the string pointed to by @p text and return
+an encoded data lump the same way eet_data_descriptor_encode() takes an
+in-memory data struct and encodes into a binary blob. @p text is a normal
+C string.
+
+:see: eet_data_text_undump_cipher()
+
+:since: 1.0.0
+
+"""
+EAPI void *
+eet_data_text_undump(const char *text,
+ int textlen,
+ int *size_ret);
+
+
+
+
+"""
+
+Read a data structure from an eet extended attribute and decodes it using a cipher.
+:param filename: The file to extract the extended attribute from.
+:param attribute: The attribute to get the data from.
+:param edd: The data descriptor handle to use when decoding.
+:param cipher_key: The key to use as cipher.
+:return: A pointer to the decoded data structure.
+
+This function decodes a data structure stored in an eet extended attribute,
+returning a pointer to it if it decoded successfully, or NULL on failure.
+Eet can handle members being added or deleted from the data in
+storage and safely zero-fills unfilled members if they were not found
+in the data. It checks sizes and headers whenever it reads data, allowing
+the programmer to not worry about corrupt data.
+
+Once a data structure has been described by the programmer with the
+fields they wish to save or load, storing or retrieving a data structure
+from an eet file, from a chunk of memory or from an extended attribute
+is as simple as a single function call.
+
+:since: 1.5.0
+
+"""
+EAPI void *
+eet_data_xattr_cipher_get(const char *filename,
+ const char *attribute,
+ Eet_Data_Descriptor *edd,
+ const char *cipher_key);
+
+
+"""
+
+Write a data structure from memory and store in an eet extended attribute
+using a cipher.
+:param filename: The file to write the extended attribute to.
+:param attribute: The attribute to store the data to.
+:param edd: The data descriptor to use when encoding.
+:param cipher_key: The key to use as cipher.
+:param data: A pointer to the data structure to save and encode.
+:param flags: The policy to use when setting the data.
+:return: EINA_TRUE on success, EINA_FALSE on failure.
+
+This function is the reverse of eet_data_xattr_cipher_get(), saving a data structure
+to an eet extended attribute.
+
+:since: 1.5.0
+
+"""
+EAPI Eina_Bool
+eet_data_xattr_cipher_set(const char *filename,
+ const char *attribute,
+ Eet_Data_Descriptor *edd,
+ const char *cipher_key,
+ const void *data,
+ Eina_Xattr_Flags flags);
+
+"""
+
+Dump an eet encoded data structure into ascii text using a cipher.
+:param data_in: The pointer to the data to decode into a struct.
+:param cipher_key: The key to use as cipher.
+:param size_in: The size of the data pointed to in bytes.
+:param dumpfunc: The function to call passed a string when new
+ data is converted to text
+:param dumpdata: The data to pass to the @p dumpfunc callback.
+:return: 1 on success, 0 on failure
+
+This function will take a chunk of data encoded by
+eet_data_descriptor_encode() and convert it into human readable
+ascii text. It does this by calling the @p dumpfunc callback
+for all new text that is generated. This callback should append
+to any existing text buffer and will be passed the pointer @p
+dumpdata as a parameter as well as a string with new text to be
+appended.
+
+Example:
+
+@code
+void output(void *data, const char *string)
+{
+ printf("%s", string);
+}
+
+void dump(const char *file)
+{
+ FILE *f;
+ int len;
+ void *data;
+
+ f = fopen(file, "r");
+ fseek(f, 0, SEEK_END);
+ len = ftell(f);
+ rewind(f);
+ data = malloc(len);
+ fread(data, len, 1, f);
+ fclose(f);
+ eet_data_text_dump_cipher(data, cipher_key, len, output, NULL);
+}
+@endcode
+
+:see: eet_data_text_dump()
+
+:since: 1.0.0
+
+"""
+EAPI int
+eet_data_text_dump_cipher(const void *data_in,
+ const char *cipher_key,
+ int size_in,
+ Eet_Dump_Callback dumpfunc,
+ void *dumpdata);
+
+"""
+
+Take an ascii encoding from eet_data_text_dump() and re-encode
+in binary using a cipher.
+:param text: The pointer to the string data to parse and encode.
+:param cipher_key: The key to use as cipher.
+:param textlen: The size of the string in bytes (not including 0
+ byte terminator).
+:param size_ret: This gets filled in with the encoded data blob
+ size in bytes.
+:return: The encoded data on success, NULL on failure.
+
+This function will parse the string pointed to by @p text and return
+an encoded data lump the same way eet_data_descriptor_encode() takes an
+in-memory data struct and encodes into a binary blob. @p text is a normal
+C string.
+
+:see: eet_data_text_undump()
+
+:since: 1.0.0
+
+"""
+EAPI void *
+eet_data_text_undump_cipher(const char *text,
+ const char *cipher_key,
+ int textlen,
+ int *size_ret);
+
+
+"""
+
+TODO FIX ME
+
+"""
+EAPI Eet_Node *
+eet_data_node_decode_cipher(const void *data_in,
+ const char *cipher_key,
+ int size_in);
+
+
+"""
+
+Display the x509 der certificate to out.
+
+:param certificate: the x509 certificate to print
+:param der_length: The length the certificate.
+:param out: where to print.
+
+@warning You need to compile signature support in EET.
+:since: 1.2.0
+
+"""
+EAPI void
+eet_identity_certificate_print(const unsigned char *certificate,
+ int der_length,
+ FILE *out);
diff --git a/efl/eet/dictionary.pxi b/efl/eet/dictionary.pxi
new file mode 100644
index 0000000..d660c39
--- /dev/null
+++ b/efl/eet/dictionary.pxi
@@ -0,0 +1,45 @@
+
+from cpython cimport PyUnicode_AsUTF8String
+from efl.utils.conversions cimport _ctouni
+
+
+cdef class EetDictionary(object):
+
+ """
+
+ Opaque handle that defines a file-backed (mmaped) dictionary of strings.
+
+ """
+
+ cdef Eet_Dictionary *ed
+
+ def string_check(self, string):
+ """
+
+ Check if a given string comes from a given dictionary
+
+ :param string: A valid 0 byte terminated C string
+ :return: 1 if it is in the dictionary, 0 otherwise
+
+ This checks the given dictionary to see if the given string is actually
+ inside that dictionary (i.e. comes from it) and returns 1 if it does.
+ If the dictionary handle is invalid, the string is None or the string is
+ not in the dictionary, 0 is returned.
+
+ :since: 1.0.0
+
+ """
+ if isinstance(string, unicode): string = PyUnicode_AsUTF8String(string)
+ return bool(eet_dictionary_string_check(self.ed, string))
+
+ def count(self):
+ """
+
+ Return the number of strings inside a dictionary
+
+ :return int: the number of strings inside a dictionary
+
+ :since: 1.6.0
+
+ """
+ return eet_dictionary_count(self.ed)
diff --git a/efl/eet/eet.pxd b/efl/eet/eet.pxd
new file mode 100644
index 0000000..90a5ceb
--- /dev/null
+++ b/efl/eet/eet.pxd
@@ -0,0 +1,309 @@
+from libc.string cimport const_char
+from libc.stdlib cimport const_void
+
+from efl.eina cimport Eina_Bool, Eina_List
+
+from efl.eet.enums cimport Eet_Error, Eet_Compression, Eet_File_Mode
+
+cdef extern from *:
+ ctypedef unsigned char const_unsigned_char "const unsigned char"
+
+cdef extern from "Eet.h":
+
+ enum:
+ EET_VERSION_MAJOR
+ EET_VERSION_MINOR
+
+ ctypedef struct Eet_Version:
+ int major # major (binary or source incompatible changes)
+ int minor # minor (new features, bugfixes, major improvements version)
+ int micro # micro (bugfix, internal improvements, no new features version)
+ int revision # svn revision (0 if a proper release or the svn revision number Eet is built from)
+
+ extern Eet_Version *eet_version
+
+ int eet_init()
+ int eet_shutdown()
+ void eet_clearcache()
+
+ ctypedef struct Eet_File
+
+ ctypedef struct Eet_Dictionary
+ ctypedef Eet_Dictionary const_Eet_Dictionary "const Eet_Dictionary"
+
+ ctypedef _Eet_Entry Eet_Entry
+ struct _Eet_Entry:
+ const_char *name # The entry name
+
+ int offset # Where it start in the file
+ int size # The size on disk
+ int data_size # The decompressed size if relevant
+
+ Eina_Bool compression # Is this data compressed ?
+ Eina_Bool ciphered # Is it ciphered ?
+ Eina_Bool alias # Is it an alias ?
+
+ Eet_File * eet_open(const_char *file, Eet_File_Mode mode)
+ # Eet_File * eet_mmap(const_Eina_File *file)
+ # Eet_File * eet_memopen_read(const_void *data, size_t size)
+ Eet_File_Mode eet_mode_get(Eet_File *ef)
+ Eet_Error eet_close(Eet_File *ef)
+ Eet_Error eet_sync(Eet_File *ef)
+ Eet_Dictionary *eet_dictionary_get(Eet_File *ef)
+ int eet_dictionary_string_check(Eet_Dictionary *ed, const_char *string)
+ int eet_dictionary_count(const_Eet_Dictionary *ed)
+ void * eet_read(Eet_File *ef, const_char *name, int *size_ret)
+ const_void * eet_read_direct(Eet_File *ef, const_char *name, int *size_ret)
+ int eet_write(Eet_File *ef, const_char *name, const_void *data, int size, int compress)
+ int eet_delete(Eet_File *ef, const_char *name)
+ Eina_Bool eet_alias(Eet_File *ef, const_char *name, const_char *destination, int compress)
+ const_char * eet_file_get(Eet_File *ef)
+ const_char * eet_alias_get(Eet_File *ef, const_char *name)
+ char ** eet_list(Eet_File *ef, const_char *glob, int *count_ret)
+ # Eina_Iterator * eet_list_entries(Eet_File *ef)
+ int eet_num_entries(Eet_File *ef)
+ # void * eet_read_cipher(Eet_File *ef, const_char *name, int *size_ret, const_char *cipher_key)
+ # int eet_write_cipher(Eet_File *ef, const_char *name, const_void *data, int size, int compress, const_char *cipher_key)
+ # int eet_data_image_header_read(Eet_File *ef, const_char *name, unsigned int *w, unsigned int *h, int *alpha, int *compress, int *quality, int *lossy)
+ # void * eet_data_image_read(Eet_File *ef, const_char *name, unsigned int *w, unsigned int *h, int *alpha, int *compress, int *quality, int *lossy)
+ # int eet_data_image_read_to_surface(Eet_File *ef, const_char *name, unsigned int src_x, unsigned int src_y, unsigned int *d, unsigned int w, unsigned int h, unsigned int row_stride, int *alpha, int *compress, int *quality, int *lossy)
+ # int eet_data_image_write(Eet_File *ef, const_char *name, const_void *data, unsigned int w, unsigned int h, int alpha, int compress, int quality, int lossy)
+ # int eet_data_image_header_decode(const_void *data, int size, unsigned int *w, unsigned int *h, int *alpha, int *compress, int *quality, int *lossy)
+ # void * eet_data_image_decode(const_void *data, int size, unsigned int *w, unsigned int *h, int *alpha, int *compress, int *quality, int *lossy)
+ # int eet_data_image_decode_to_surface(const_void *data, int size, unsigned int src_x, unsigned int src_y, unsigned int *d, unsigned int w, unsigned int h, unsigned int row_stride, int *alpha, int *compress, int *quality, int *lossy)
+ # void * eet_data_image_encode(const_void *data, int *size_ret, unsigned int w, unsigned int h, int alpha, int compress, int quality, int lossy)
+ # int eet_data_image_header_read_cipher(Eet_File *ef, const_char *name, const_char *cipher_key, unsigned int *w, unsigned int *h, int *alpha, int *compress, int *quality, int *lossy)
+ # void * eet_data_image_read_cipher(Eet_File *ef, const_char *name, const_char *cipher_key, unsigned int *w, unsigned int *h, int *alpha, int *compress, int *quality, int *lossy)
+ # int eet_data_image_read_to_surface_cipher(Eet_File *ef, const_char *name, const_char *cipher_key, unsigned int src_x, unsigned int src_y, unsigned int *d, unsigned int w, unsigned int h, unsigned int row_stride, int *alpha, int *compress, int *quality, int *lossy)
+ # int eet_data_image_write_cipher(Eet_File *ef, const_char *name, const_char *cipher_key, const_void *data, unsigned int w, unsigned int h, int alpha, int compress, int quality, int lossy)
+ # int eet_data_image_header_decode_cipher(const_void *data, const_char *cipher_key, int size, unsigned int *w, unsigned int *h, int *alpha, int *compress, int *quality, int *lossy)
+ # void * eet_data_image_decode_cipher(const_void *data, const_char *cipher_key, int size, unsigned int *w, unsigned int *h, int *alpha, int *compress, int *quality, int *lossy)
+ # int eet_data_image_decode_to_surface_cipher(const_void *data, const_char *cipher_key, int size, unsigned int src_x, unsigned int src_y, unsigned int *d, unsigned int w, unsigned int h, unsigned int row_stride, int *alpha, int *compress, int *quality, int *lossy)
+ # void * eet_data_image_encode_cipher(const_void *data, const_char *cipher_key, unsigned int w, unsigned int h, int alpha, int compress, int quality, int lossy, int *size_ret)
+
+ # ctypedef struct Eet_Key
+
+ # ctypedef int (*Eet_Key_Password_Callback)(char *buffer, int size, int rwflag, void *data)
+
+ # Eet_Key * eet_identity_open(const_char *certificate_file, const_char *private_key_file, Eet_Key_Password_Callback cb)
+ # void eet_identity_close(Eet_Key *key)
+ # Eet_Error eet_identity_set(Eet_File *ef, Eet_Key *key)
+ # void eet_identity_print(Eet_Key *key, FILE *out)
+ # const_void * eet_identity_x509(Eet_File *ef, int *der_length)
+ # const_void * eet_identity_signature(Eet_File *ef, int *signature_length)
+ # const_void * eet_identity_sha1(Eet_File *ef, int *sha1_length)
+ # void eet_identity_certificate_print(const_unsigned_char *certificate, int der_length, FILE *out)
+
+ # enum:
+ # EET_T_UNKNOW # Unknown data encoding type
+ # EET_T_CHAR # Data type: char
+ # EET_T_SHORT # Data type: short
+ # EET_T_INT # Data type: int
+ # EET_T_LONG_LONG # Data type: long long
+ # EET_T_FLOAT # Data type: float
+ # EET_T_DOUBLE # Data type: double
+ # EET_T_UCHAR # Data type: unsigned char
+ # EET_T_USHORT # Data type: unsigned short
+ # EET_T_UINT # Data type: unsigned int
+ # EET_T_ULONG_LONG # Data type: unsigned long long
+ # EET_T_STRING # Data type: char *
+ # EET_T_INLINED_STRING # Data type: char * (but compressed inside the resulting eet)
+ # EET_T_NULL # Data type: (void *) (only use it if you know why)
+ # EET_T_F32P32 # Data type: fixed point 32.32
+ # EET_T_F16P16 # Data type: fixed point 16.16
+ # EET_T_F8P24 # Data type: fixed point 8.24
+ # EET_T_VALUE # Data type: pointer to Eina_Value @since 1.8
+ # EET_T_LAST # Last data type
+
+ # enum:
+ # EET_G_UNKNOWN # Unknown group data encoding type
+ # EET_G_ARRAY # Fixed size array group type
+ # EET_G_VAR_ARRAY # Variable size array group type
+ # EET_G_LIST # Linked list group type
+ # EET_G_HASH # Hash table group type
+ # EET_G_UNION # Union group type
+ # EET_G_VARIANT # Selectable subtype group
+ # EET_G_UNKNOWN_NESTED # Unknown nested group type. @since 1.8
+ # EET_G_LAST # Last group type
+
+ # enum:
+ # EET_I_LIMIT # Other type exist but are reserved for internal purpose.
+
+ # ctypedef struct Eet_Data_Descriptor
+
+ # enum:
+ # EET_DATA_DESCRIPTOR_CLASS_VERSION
+
+ # ctypedef _Eet_Data_Descriptor_Class Eet_Data_Descriptor_Class
+
+ # ctypedef int (*Eet_Descriptor_Hash_Foreach_Callback_Callback)(void *h, const_char *k, void *dt, void *fdt)
+
+ # ctypedef void * (*Eet_Descriptor_Mem_Alloc_Callback)(size_t size)
+ # ctypedef void (*Eet_Descriptor_Mem_Free_Callback)(void *mem)
+ # ctypedef char * (*Eet_Descriptor_Str_Alloc_Callback)(const_char *str)
+ # ctypedef void (*Eet_Descriptor_Str_Free_Callback)(const_char *str)
+ # ctypedef void * (*Eet_Descriptor_List_Next_Callback)(void *l)
+ # ctypedef void * (*Eet_Descriptor_List_Append_Callback)(void *l, void *d)
+ # ctypedef void * (*Eet_Descriptor_List_Data_Callback)(void *l)
+ # ctypedef void * (*Eet_Descriptor_List_Free_Callback)(void *l)
+ # ctypedef void (*Eet_Descriptor_Hash_Foreach_Callback)(void *h, Eet_Descriptor_Hash_Foreach_Callback_Callback func, void *fdt)
+ # ctypedef void * (*Eet_Descriptor_Hash_Add_Callback)(void *h, const_char *k, void *d)
+ # ctypedef void (*Eet_Descriptor_Hash_Free_Callback)(void *h)
+ # ctypedef char * (*Eet_Descriptor_Str_Direct_Alloc_Callback)(const_char *str)
+ # ctypedef void (*Eet_Descriptor_Str_Direct_Free_Callback)(const_char *str)
+ # ctypedef const_char * (*Eet_Descriptor_Type_Get_Callback)(const_void *data, Eina_Bool *unknow)
+ # ctypedef Eina_Bool (*Eet_Descriptor_Type_Set_Callback)(const_char *type, void *data, Eina_Bool unknow)
+ # ctypedef void * (*Eet_Descriptor_Array_Alloc_Callback)(size_t size)
+ # ctypedef void (*Eet_Descriptor_Array_Free_Callback)(void *mem)
+
+
+ # ctypedef struct _Eet_Data_Descriptor_Class_func:
+ # Eet_Descriptor_Mem_Alloc_Callback mem_alloc # how to allocate memory (usually malloc())
+ # Eet_Descriptor_Mem_Free_Callback mem_free # how to free memory (usually free())
+ # Eet_Descriptor_Str_Alloc_Callback str_alloc # how to allocate a string
+ # Eet_Descriptor_Str_Free_Callback str_free # how to free a string
+ # Eet_Descriptor_List_Next_Callback list_next # how to iterate to the next element of a list. Receives and should return the list node.
+ # Eet_Descriptor_List_Append_Callback list_append # how to append data @p d to list which head node is @p l
+ # Eet_Descriptor_List_Data_Callback list_data # retrieves the data from node @p l
+ # Eet_Descriptor_List_Free_Callback list_free # free all the nodes from the list which head node is @p l
+ # Eet_Descriptor_Hash_Foreach_Callback hash_foreach # iterates over all elements in the hash @p h in no specific order
+ # Eet_Descriptor_Hash_Add_Callback hash_add # add a new data @p d with key @p k in hash @p h
+ # Eet_Descriptor_Hash_Free_Callback hash_free # free all entries from the hash @p h
+ # Eet_Descriptor_Str_Direct_Alloc_Callback str_direct_alloc # how to allocate a string directly from file backed/mmaped region pointed by @p str
+ # Eet_Descriptor_Str_Direct_Free_Callback str_direct_free # how to free a string returned by str_direct_alloc
+ # Eet_Descriptor_Type_Get_Callback type_get # get the type, as used in the union or variant mapping, that should be used to store the given data into the eet file.
+ # Eet_Descriptor_Type_Set_Callback type_set # called when loading a mapped type with the given @p type used to describe the type in the descriptor
+ # Eet_Descriptor_Array_Alloc_Callback array_alloc # how to allocate memory for array (usually malloc())
+ # Eet_Descriptor_Array_Free_Callback array_free # how to free memory for array (usually free())
+
+ # struct _Eet_Data_Descriptor_Class:
+ # int version # ABI version. Should always be set to #EET_DATA_DESCRIPTOR_CLASS_VERSION
+ # const_char *name # Name of the user data type to be serialized
+ # int size # Size in bytes of the user data type to be serialized
+ # _Eet_Data_Descriptor_Class func
+
+
+ # Eet_Data_Descriptor * eet_data_descriptor_stream_new(const_Eet_Data_Descriptor_Class *eddc)
+ # Eet_Data_Descriptor * eet_data_descriptor_file_new(const_Eet_Data_Descriptor_Class *eddc)
+
+ # Eina_Bool eet_eina_stream_data_descriptor_class_set(Eet_Data_Descriptor_Class *eddc, unsigned int eddc_size, const_char *name, int size)
+ # Eina_Bool EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(Eet_Data_Descriptor_Class *clas, void *type)
+
+ # Eina_Bool eet_eina_file_data_descriptor_class_set(Eet_Data_Descriptor_Class *eddc, unsigned int eddc_size, const_char *name, int size)
+ # Eina_Bool EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(Eet_Data_Descriptor_Class *clas, void *type)
+
+
+ # void eet_data_descriptor_free(Eet_Data_Descriptor *edd)
+ # const_char * eet_data_descriptor_name_get(const_Eet_Data_Descriptor *edd)
+ # void eet_data_descriptor_element_add(Eet_Data_Descriptor *edd, const_char *name, int type, int group_type, int offset, int count, const_char *counter_name, Eet_Data_Descriptor *subtype)
+ # void * eet_data_read(Eet_File *ef, Eet_Data_Descriptor *edd, const_char *name)
+ # int eet_data_write(Eet_File *ef, Eet_Data_Descriptor *edd, const_char *name, const_void *data, int compress)
+
+
+ # ctypedef void (*Eet_Dump_Callback)(void *data, const_char *str)
+
+
+ # int eet_data_text_dump(const_void *data_in, int size_in, Eet_Dump_Callback dumpfunc, void *dumpdata)
+ # void * eet_data_text_undump(const_char *text, int textlen, int *size_ret)
+ # int eet_data_dump(Eet_File *ef, const_char *name, Eet_Dump_Callback dumpfunc, void *dumpdata)
+ # int eet_data_undump(Eet_File *ef, const_char *name, const_char *text, int textlen, int compress)
+ # void * eet_data_descriptor_decode(Eet_Data_Descriptor *edd, const_void *data_in, int size_in)
+ # void * eet_data_descriptor_encode(Eet_Data_Descriptor *edd, const_void *data_in, int *size_ret)
+
+ # void EET_DATA_DESCRIPTOR_ADD_BASIC(Eet_Data_Descriptor *edd, void *struct_type, const_char *name, void *member, int type)
+ # void EET_DATA_DESCRIPTOR_ADD_SUB(Eet_Data_Descriptor *edd, void *struct_type, const_char *name, void *member, Eet_Data_Descriptor *subtype)
+ # void EET_DATA_DESCRIPTOR_ADD_SUB_NESTED(Eet_Data_Descriptor *edd, void *struct_type, const_char *name, void *member, Eet_Data_Descriptor *subtype)
+ # void EET_DATA_DESCRIPTOR_ADD_SUB_LIST(Eet_Data_Descriptor *edd, void *struct_type, const_char *name, void *member, Eet_Data_Descriptor *subtype)
+ # void EET_DATA_DESCRIPTOR_ADD_LIST_STRING(Eet_Data_Descriptor *edd, void *struct_type, const_char *name, void *member)
+ # void EET_DATA_DESCRIPTOR_ADD_HASH(Eet_Data_Descriptor *edd, void *struct_type, const_char *name, void *member, Eet_Data_Descriptor *subtype)
+ # void EET_DATA_DESCRIPTOR_ADD_HASH_STRING(Eet_Data_Descriptor *edd, void *struct_type, const_char *name, void *member)
+ # void EET_DATA_DESCRIPTOR_ADD_BASIC_ARRAY(Eet_Data_Descriptor *edd, void *struct_type, const_char *name, void *member, int type)
+ # void EET_DATA_DESCRIPTOR_ADD_BASIC_VAR_ARRAY(Eet_Data_Descriptor *edd, void *struct_type, const_char *name, void *member, int type)
+ # void EET_DATA_DESCRIPTOR_ADD_ARRAY(Eet_Data_Descriptor *edd, void *struct_type, const_char *name, void *member, Eet_Data_Descriptor *subtype)
+ # void EET_DATA_DESCRIPTOR_ADD_VAR_ARRAY(Eet_Data_Descriptor *edd, void *struct_type, const_char *name, void *member, Eet_Data_Descriptor *subtype)
+ # void EET_DATA_DESCRIPTOR_ADD_VAR_ARRAY_STRING(Eet_Data_Descriptor *edd, void *struct_type, const_char *name, void *member)
+ # void EET_DATA_DESCRIPTOR_ADD_UNION(Eet_Data_Descriptor *edd, void *struct_type, const_char *name, void *member, void *type_member, Eet_Data_Descriptor *unified_type)
+ # void EET_DATA_DESCRIPTOR_ADD_VARIANT(Eet_Data_Descriptor *edd, void *struct_type, const_char *name, void *member, void *type_member, Eet_Data_Descriptor *unified_type)
+ # void EET_DATA_DESCRIPTOR_ADD_MAPPING(Eet_Data_Descriptor *unified_type, const_char *name, Eet_Data_Descriptor *subtype)
+ # void EET_DATA_DESCRIPTOR_ADD_MAPPING_BASIC(Eet_Data_Descriptor *unified_type, const_char *name, int basic_type)
+
+ # void * eet_data_read_cipher(Eet_File *ef, Eet_Data_Descriptor *edd, const_char *name, const_char *cipher_key)
+ # void * eet_data_xattr_cipher_get(const_char *filename, const_char *attribute, Eet_Data_Descriptor *edd, const_char *cipher_key)
+ # int eet_data_write_cipher(Eet_File *ef, Eet_Data_Descriptor *edd, const_char *name, const_char *cipher_key, const_void *data, int compress)
+ # Eina_Bool eet_data_xattr_cipher_set(const_char *filename, const_char *attribute, Eet_Data_Descriptor *edd, const_char *cipher_key, const_void *data, Eina_Xattr_Flags flags)
+ # int eet_data_text_dump_cipher(const_void *data_in, const_char *cipher_key, int size_in, Eet_Dump_Callback dumpfunc, void *dumpdata)
+ # void * eet_data_text_undump_cipher(const_char *text, const_char *cipher_key, int textlen, int *size_ret)
+ # int eet_data_dump_cipher(Eet_File *ef, const_char *name, const_char *cipher_key, Eet_Dump_Callback dumpfunc, void *dumpdata)
+ # int eet_data_undump_cipher(Eet_File *ef, const_char *name, const_char *cipher_key, const_char *text, int textlen, int compress)
+ # void * eet_data_descriptor_decode_cipher(Eet_Data_Descriptor *edd, const_void *data_in, const_char *cipher_key, int size_in)
+ # void * eet_data_descriptor_encode_cipher(Eet_Data_Descriptor *edd, const_void *data_in, const_char *cipher_key, int *size_ret)
+
+ ctypedef struct Eet_Node
+
+ ctypedef _Eet_Node_Data Eet_Node_Data
+
+ ctypedef union _Eet_Node_Data_value:
+ char c
+ short s
+ int i
+ long long l
+ float f
+ double d
+ unsigned char uc
+ unsigned short us
+ unsigned int ui
+ unsigned long long ul
+ const_char *str
+
+ struct _Eet_Node_Data:
+ _Eet_Node_Data_value value
+
+ Eet_Node * eet_node_char_new(const_char *name, char c)
+ Eet_Node * eet_node_short_new(const_char *name, short s)
+ Eet_Node * eet_node_int_new(const_char *name, int i)
+ Eet_Node * eet_node_long_long_new(const_char *name, long long l)
+ Eet_Node * eet_node_float_new(const_char *name, float f)
+ Eet_Node * eet_node_double_new(const_char *name, double d)
+ Eet_Node * eet_node_unsigned_char_new(const_char *name, unsigned char uc)
+ Eet_Node * eet_node_unsigned_short_new(const_char *name, unsigned short us)
+ Eet_Node * eet_node_unsigned_int_new(const_char *name, unsigned int ui)
+ Eet_Node * eet_node_unsigned_long_long_new(const_char *name, unsigned long long l)
+ Eet_Node * eet_node_string_new(const_char *name, const_char *str)
+ Eet_Node * eet_node_inlined_string_new(const_char *name, const_char *str)
+ Eet_Node * eet_node_null_new(const_char *name)
+ Eet_Node * eet_node_list_new(const_char *name, Eina_List *nodes)
+ Eet_Node * eet_node_array_new(const_char *name, int count, Eina_List *nodes)
+ Eet_Node * eet_node_var_array_new(const_char *name, Eina_List *nodes)
+ Eet_Node * eet_node_hash_new(const_char *name, const_char *key, Eet_Node *node)
+ Eet_Node * eet_node_struct_new(const_char *name, Eina_List *nodes)
+ Eet_Node * eet_node_struct_child_new(const_char *parent, Eet_Node *child)
+
+ Eet_Node * eet_node_children_get(Eet_Node *node)
+ Eet_Node * eet_node_next_get(Eet_Node *node)
+ Eet_Node * eet_node_parent_get(Eet_Node *node)
+ void eet_node_list_append(Eet_Node *parent, const_char *name, Eet_Node *child)
+ void eet_node_struct_append(Eet_Node *parent, const_char *name, Eet_Node *child)
+ void eet_node_hash_add(Eet_Node *parent, const_char *name, const_char *key, Eet_Node *child)
+ # void eet_node_dump(Eet_Node *n, int dumplevel, Eet_Dump_Callback dumpfunc, void *dumpdata)
+ int eet_node_type_get(Eet_Node *node)
+ Eet_Node_Data * eet_node_value_get(Eet_Node *node)
+ void eet_node_del(Eet_Node *n)
+ # void * eet_data_node_encode_cipher(Eet_Node *node, const_char *cipher_key, int *size_ret)
+ # Eet_Node * eet_data_node_decode_cipher(const_void *data_in, const_char *cipher_key, int size_in)
+ # Eet_Node * eet_data_node_read_cipher(Eet_File *ef, const_char *name, const_char *cipher_key)
+ # int eet_data_node_write_cipher(Eet_File *ef, const_char *name, const_char *cipher_key, Eet_Node *node, int compress)
+
+
+ # ctypedef struct Eet_Connection
+
+ # ctypedef Eina_Bool Eet_Read_Cb (const_void *eet_data, size_t size, void *user_data)
+
+ # ctypedef Eina_Bool Eet_Write_Cb (const_void *data, size_t size, void *user_data)
+
+
+ # Eet_Connection * eet_connection_new(Eet_Read_Cb *eet_read_cb, Eet_Write_Cb *eet_write_cb, const_void *user_data)
+ # int eet_connection_received(Eet_Connection *conn, const_void *data, size_t size)
+ # Eina_Bool eet_connection_empty(Eet_Connection *conn)
+ # Eina_Bool eet_connection_send(Eet_Connection *conn, Eet_Data_Descriptor *edd, const_void *data_in, const_char *cipher_key)
+ # Eina_Bool eet_connection_node_send(Eet_Connection *conn, Eet_Node *node, const_char *cipher_key)
+ # void * eet_connection_close(Eet_Connection *conn, Eina_Bool *on_going)
diff --git a/efl/eet/eet.pyx b/efl/eet/eet.pyx
new file mode 100644
index 0000000..55146e1
--- /dev/null
+++ b/efl/eet/eet.pyx
@@ -0,0 +1,197 @@
+# Copyright (C) 2007-2014 various contributors (see AUTHORS)
+#
+# This file is part of Python-EFL.
+#
+# Python-EFL is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# Python-EFL is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this Python-EFL. If not, see <http://www.gnu.org/licenses/>.
+
+"""
+
+Eet Data Handling Library
+=========================
+
+These routines are used for Eet Library interaction
+
+.. _eet_main_intro:
+
+Introduction
+------------
+
+It is a tiny library designed to write an arbitrary set of chunks of data
+to a file and optionally compress each chunk (very much like a zip file)
+and allow fast random-access reading of the file later on. It does not
+do zip as a zip itself has more complexity than is needed, and it was much
+simpler to implement this once here.
+
+Eet is extremely fast, small and simple. Eet files can be very small and
+highly compressed, making them very optimal for just sending across the
+internet without having to archive, compress or decompress and install them.
+They allow for lightning-fast random-access reads once created, making them
+perfect for storing data that is written once (or rarely) and read many
+times, but the program does not want to have to read it all in at once.
+
+It also can encode and decode data structures in memory, as well as image
+data for saving to Eet files or sending across the network to other
+machines, or just writing to arbitrary files on the system. All data is
+encoded in a platform independent way and can be written and read by any
+architecture.
+
+.. _eet_main_next_steps:
+
+Next Steps
+----------
+
+After you understood what Eet is and installed it in your system
+you should proceed understanding the programming interface. We'd
+recommend you to take a while to learn Eina as it is very
+convenient and optimized, and Eet provides integration with it.
+
+.. _Eet_File_Image_Group:
+
+Image Store and Load
+--------------------
+
+Eet efficiently stores and loads images, including alpha
+channels and lossy compressions.
+
+Eet can handle both lossy compression with different levels of quality and
+non-lossy compression with different compression levels. It's also possible,
+given an image data, to only read its header to get the image information
+without decoding the entire content for it.
+
+The encode family of functions will take an image raw buffer and its
+parameters and compress it in memory, returning the new buffer.
+Likewise, the decode functions will read from the given location in memory
+and return the uncompressed image.
+
+The read and write functions will, respectively, encode and decode to or
+from an Eet file, under the specified key.
+
+These functions are fairly low level and the same functionality can be
+achieved using Evas and Edje, making it much easier to work with images
+as well as not needing to worry about things like scaling them.
+
+
+.. _Eet_Data_Group:
+
+Eet Data Serialization
+----------------------
+
+Convenience functions to serialize and parse complex data
+structures to binary blobs.
+
+While Eet core just handles binary blobs, it is often required
+to save some structured data of different types, such as
+strings, integers, lists, hashes and so on.
+
+Eet can serialize and then parse data types given some
+construction instructions. These are defined in two levels:
+
+- :ref:`Eet_Data_Descriptor_Class` to tell generic memory handling,
+ such as the size of the type, how to allocate memory, strings,
+ lists, hashes and so on.
+
+- :ref:`Eet_Data_Descriptor` to tell inside such type, the members and
+ their offsets inside the memory blob, their types and
+ names. These members can be simple types or other
+ #Eet_Data_Descriptor, allowing hierarchical types to be
+ defined.
+
+Given that C provides no introspection, this process can be
+quite cumbersome, so we provide lots of macros and convenience
+functions to aid creating the types.
+
+"""
+
+def init():
+ """
+
+ Initialize the EET library.
+
+ The first time this function is called, it will perform all the internal
+ initialization required for the library to function properly and increment
+ the initialization counter. Any subsequent call only increment this counter
+ and return its new value, so it's safe to call this function more than once.
+
+ :return: The new init count. Will be 0 if initialization failed.
+
+ :since: 1.0.0
+
+ """
+ return eet_init()
+
+def shutdown():
+ """
+
+ Shut down the EET library.
+
+ If eet_init() was called more than once for the running application,
+ eet_shutdown() will decrement the initialization counter and return its
+ new value, without doing anything else. When the counter reaches 0, all
+ of the internal elements will be shutdown and any memory used freed.
+
+ :return: The new init count.
+
+ :since: 1.0.0
+
+ """
+ return eet_shutdown()
+
+def clearcache():
+ """
+
+ Clear eet cache
+
+ For a faster access to previously accessed data, Eet keeps an internal
+ cache of files. These files will be freed automatically only when
+ they are unused and the cache gets full, in order based on the last time
+ they were used.
+ On systems with little memory this may present an unnecessary constraint,
+ so eet_clearcache() is available for users to reclaim the memory used by
+ files that are no longer needed. Those that were open using
+ EET_FILE_MODE_WRITE or EET_FILE_MODE_READ_WRITE and have modifications,
+ will be written down to disk before flushing them from memory.
+
+ :since: 1.0.0
+
+ """
+ eet_clearcache()
+
+cdef list eet_errors = [
+ "No error, it's all fine!",
+ "Given object or handle is NULL or invalid",
+ "There was nothing to do",
+ "Could not write to file or file is #EET_FILE_MODE_READ",
+ "Could not allocate memory",
+ "Failed to write data to destination",
+ "Failed to write file since it is too big",
+ "Failed to write due a generic Input/Output error",
+ "Failed to write due out of space",
+ "Failed to write because file was closed",
+ "Could not mmap file",
+ "Could not encode using X509",
+ "Could not validate signature",
+ "Signature is invalid",
+ "File or contents are not signed",
+ "Function is not implemented",
+ "Could not introduce random seed",
+ "Could not encrypt contents",
+ "Could not decrypt contents",
+]
+
+class EetError(Exception):
+ def __init__(self, code):
+ Exception.__init__(self, eet_errors[code])
+
+include "dictionary.pxi"
+include "file.pxi"
diff --git a/efl/eet/enums.pxd b/efl/eet/enums.pxd
new file mode 100644
index 0000000..ea4a9ab
--- /dev/null
+++ b/efl/eet/enums.pxd
@@ -0,0 +1,50 @@
+
+cdef extern from "Eet.h":
+
+ enum _Eet_Error:
+ EET_ERROR_NONE #No error, it's all fine!
+ EET_ERROR_BAD_OBJECT #Given object or handle is NULL or invalid
+ EET_ERROR_EMPTY #There was nothing to do
+ EET_ERROR_NOT_WRITABLE #Could not write to file or file is #EET_FILE_MODE_READ
+ EET_ERROR_OUT_OF_MEMORY #Could not allocate memory
+ EET_ERROR_WRITE_ERROR #Failed to write data to destination
+ EET_ERROR_WRITE_ERROR_FILE_TOO_BIG #Failed to write file since it is too big
+ EET_ERROR_WRITE_ERROR_IO_ERROR #Failed to write due a generic Input/Output error
+ EET_ERROR_WRITE_ERROR_OUT_OF_SPACE #Failed to write due out of space
+ EET_ERROR_WRITE_ERROR_FILE_CLOSED #Failed to write because file was closed
+ EET_ERROR_MMAP_FAILED #Could not mmap file
+ EET_ERROR_X509_ENCODING_FAILED #Could not encode using X509
+ EET_ERROR_SIGNATURE_FAILED #Could not validate signature
+ EET_ERROR_INVALID_SIGNATURE #Signature is invalid
+ EET_ERROR_NOT_SIGNED #File or contents are not signed
+ EET_ERROR_NOT_IMPLEMENTED #Function is not implemented
+ EET_ERROR_PRNG_NOT_SEEDED #Could not introduce random seed
+ EET_ERROR_ENCRYPT_FAILED #Could not encrypt contents
+ EET_ERROR_DECRYPT_FAILED #Could not decrypt contents
+
+ ctypedef _Eet_Error Eet_Error
+
+ ctypedef enum _Eet_Compression:
+ EET_COMPRESSION_NONE #No compression at all @since 1.7
+ EET_COMPRESSION_DEFAULT #Default compression (Zlib) @since 1.7
+ EET_COMPRESSION_LOW #Fast but minimal compression (Zlib) @since 1.7
+ EET_COMPRESSION_MED #Medium compression level (Zlib) @since 1.7
+ EET_COMPRESSION_HI #Slow but high compression level (Zlib) @since 1.7
+ EET_COMPRESSION_VERYFAST #Very fast, but lower compression ratio (LZ4HC) @since 1.7
+ EET_COMPRESSION_SUPERFAST #Very fast, but lower compression ratio (faster to compress than EET_COMPRESSION_VERYFAST) (LZ4) @since 1.7
+
+ EET_COMPRESSION_LOW2 #Space filler for compatibility. Don't use it @since 1.7
+ EET_COMPRESSION_MED1 #Space filler for compatibility. Don't use it @since 1.7
+ EET_COMPRESSION_MED2 #Space filler for compatibility. Don't use it @since 1.7
+ EET_COMPRESSION_HI1 #Space filler for compatibility. Don't use it @since 1.7
+ EET_COMPRESSION_HI2 #Space filler for compatibility. Don't use it @since 1.7
+
+ ctypedef _Eet_Compression Eet_Compression
+
+ ctypedef enum _Eet_File_Mode:
+ EET_FILE_MODE_INVALID
+ EET_FILE_MODE_READ #File is read-only.
+ EET_FILE_MODE_WRITE #File is write-only.
+ EET_FILE_MODE_READ_WRITE #File is for both read and write
+
+ ctypedef _Eet_File_Mode Eet_File_Mode
diff --git a/efl/eet/file.pxi b/efl/eet/file.pxi
new file mode 100644
index 0000000..b13a61f
--- /dev/null
+++ b/efl/eet/file.pxi
@@ -0,0 +1,1356 @@
+from libc.stdlib cimport free
+from cpython cimport PyUnicode_AsUTF8String
+from efl.utils.conversions cimport _ctouni, array_of_strings_to_python_list
+
+cimport efl.eet.enums as enums
+
+EET_FILE_MODE_INVALID = enums.EET_FILE_MODE_INVALID
+EET_FILE_MODE_READ = enums.EET_FILE_MODE_READ
+EET_FILE_MODE_WRITE = enums.EET_FILE_MODE_WRITE
+EET_FILE_MODE_READ_WRITE = enums.EET_FILE_MODE_READ_WRITE
+
+
+cdef class EetEntry(object):
+ """
+
+ Eet files may contains multiple Entries per file, this handle describe them. You can get that handle from an iterator given by eet_list_entries().
+
+ :see: eet_list_entries()
+ :since: 1.8.0
+
+ """
+
+ cdef Eet_Entry *ee
+
+ property name:
+ """The entry name"""
+ def __get__(self):
+ return _ctouni(self.ee.name)
+
+ def __set__(self, value):
+ if isinstance(value, unicode): value = PyUnicode_AsUTF8String(value)
+ self.ee.name = value
+
+ property offset:
+ """Where it start in the file"""
+ def __get__(self):
+ return self.ee.offset
+
+ def __set__(self, int value):
+ self.ee.offset = value
+
+ property size:
+ """The size on disk"""
+ def __get__(self):
+ return self.ee.size
+
+ def __set__(self, int value):
+ self.ee.size = value
+
+ property data_size:
+ """The decompressed size if relevant"""
+ def __get__(self):
+ return self.ee.data_size
+
+ def __set__(self, int value):
+ self.ee.data_size = value
+
+ property compression:
+ """Is this data compressed ?"""
+ def __get__(self):
+ return bool(self.ee.compression)
+
+ def __set__(self, bint value):
+ self.ee.compression = value
+
+ property ciphered:
+ """Is it ciphered ?"""
+ def __get__(self):
+ return bool(self.ee.ciphered)
+
+ def __set__(self, bint value):
+ self.ee.ciphered = value
+
+ property alias:
+ """Is it an alias ?"""
+ def __get__(self):
+ return bool(self.ee.alias)
+
+ def __set__(self, bint value):
+ self.ee.alias = value
+
+
+cdef class EetFile(object):
+
+ """
+
+ Opaque handle that defines an Eet file (or memory).
+
+ This handle will be returned by the functions eet_open() and
+ eet_memopen_read() and is used by every other function that affects the
+ file in any way. When you are done with it, call eet_close() to close it
+ and, if the file was open for writing, write down to disk any changes made
+ to it.
+
+ """
+
+ cdef:
+ Eet_File *ef
+
+ def __init__(self, filename, Eet_File_Mode mode):
+ """
+
+ Open an eet file on disk, and returns a handle to it.
+
+ :param file: The file path to the eet file. eg: @c "/tmp/file.eet".
+ :param mode: The mode for opening. Either #EET_FILE_MODE_READ,
+ #EET_FILE_MODE_WRITE or #EET_FILE_MODE_READ_WRITE.
+
+ :return: An opened eet file handle.
+
+ This function will open an exiting eet file for reading, and build
+ the directory table in memory and return a handle to the file, if it
+ exists and can be read, and no memory errors occur on the way, otherwise
+ NULL will be returned.
+
+ It will also open an eet file for writing. This will, if successful,
+ delete the original file and replace it with a new empty file, till
+ the eet file handle is closed or flushed. If it cannot be opened for
+ writing or a memory error occurs, NULL is returned.
+
+ You can also open the file for read/write. If you then write a key that
+ does not exist it will be created, if the key exists it will be replaced
+ by the new data.
+
+ If the same file is opened multiple times, then the same file handle will
+ be returned as eet maintains an internal list of all currently open
+ files. Note that it considers files opened for read only and those opened
+ for read/write and write only as 2 separate sets. Those that do not write
+ to the file and those that do. Eet will allow 2 handles to the same file
+ if they are in the 2 separate lists/groups. That means opening a file for
+ read only looks in the read only set, and returns a handle to that file
+ handle and increments its reference count. If you open a file for read/write
+ or write only it looks in the write set and returns a handle after
+ incrementing the reference count. You need to close an eet file handle
+ as many times as it has been opened to maintain correct reference counts.
+ Files whose modified timestamp or size do not match those of the existing
+ referenced file handles will not be returned and a new handle will be
+ returned instead.
+
+ :since: 1.0.0
+
+ """
+ if isinstance(filename, unicode): PyUnicode_AsUTF8String(filename)
+ self.ef = eet_open(filename, mode)
+
+ # @classmethod
+ # def mmap(self, file):
+ # """
+
+ # Open an eet file on disk from an Eina_File handle, and returns a handle to it.
+
+ # :param file: The Eina_File handle to map to an eet file.
+ # :return: An opened eet file handle.
+
+ # This function will open an exiting eet file for reading, and build
+ # the directory table in memory and return a handle to the file, if it
+ # exists and can be read, and no memory errors occur on the way, otherwise
+ # NULL will be returned.
+
+ # This function can't open file for writing only read only mode is supported for now.
+
+ # If the same file is opened multiple times, then the same file handle will
+ # be returned as eet maintains an internal list of all currently open
+ # files. That means opening a file for read only looks in the read only set,
+ # and returns a handle to that file handle and increments its reference count.
+ # You need to close an eet file handle as many times as it has been opened to
+ # maintain correct reference counts.
+
+ # :since: 1.8.0
+
+ # """
+ # Eet_File *eet_mmap(const Eina_File *file)
+
+ # @classmethod
+ # def memopen_read(self, data, size):
+ # """
+
+ # Open an eet file directly from a memory location. The data is not copied,
+ # so you must keep it around as long as the eet file is open. There is
+ # currently no cache for this kind of Eet_File, so it's reopened every time
+ # you use eet_memopen_read.
+
+ # :param data: Address of file in memory.
+ # :param size: Size of memory to be read.
+ # :return: A handle to the file.
+
+ # Files opened this way will always be in read-only mode.
+
+ # :since: 1.1.0
+
+ # """
+ # Eet_File *eet_memopen_read(const void *data, size_t size)
+
+ property mode:
+ """
+
+ Get the mode an Eet_File was opened with.
+
+ :type: Eet_File_Mode
+
+ :since: 1.0.0
+
+ """
+ def __get__(self):
+ return eet_mode_get(self.ef)
+
+ def close(self):
+ """
+
+ Close an eet file handle and flush pending writes.
+
+ :return: An eet error identifier.
+
+ This function will flush any pending writes to disk if the eet file
+ was opened for write, and free all data associated with the file handle
+ and file, and close the file. If it was opened for read (or read/write),
+ the file handle may still be held open internally for caching purposes.
+ To flush speculatively held eet file handles use eet_clearcache().
+
+ If the eet file handle is not valid nothing will be done.
+
+ :since: 1.0.0
+
+ :see: eet_clearcache()
+
+ """
+ cdef Eet_Error ret = eet_close(self.ef)
+ if ret != enums.EET_ERROR_NONE:
+ raise EetError(ret)
+
+ def sync(self):
+ """
+
+ Sync content of an eet file handle, flushing pending writes.
+
+ :return: An eet error identifier.
+
+ This function will flush any pending writes to disk. The eet file must
+ be opened for write.
+
+ If the eet file handle is not valid nothing will be done.
+
+ :since: 1.2.4
+
+ """
+ cdef Eet_Error ret = eet_sync(self.ef)
+ if ret != enums.EET_ERROR_NONE:
+ raise EetError(ret)
+
+ property dictionary:
+ """
+
+ Return a handle to the shared string dictionary of the Eet file
+
+ :return: A handle to the dictionary of the file
+
+ This function returns a handle to the dictionary of an Eet file whose
+ handle is @p ef, if a dictionary exists. NULL is returned otherwise or
+ if the file handle is known to be invalid.
+
+ :see: eet_dictionary_string_check() to know if given string came
+ from the dictionary or it was dynamically allocated using
+ the #Eet_Data_Descriptor_Class instructions.
+
+ :since: 1.0.0
+
+ """
+ def __get__(self):
+ cdef EetDictionary ret = EetDictionary.__new__(EetDictionary)
+ ret.ed = eet_dictionary_get(self.ef)
+ return ret
+
+ def read_string(self, name):
+ """
+
+ Read a specified entry from an eet file and return data
+
+ :param name: Name of the entry. eg: "/base/file_i_want".
+ :param size_ret: Number of bytes read from entry and returned.
+ :return: The data stored in that entry in the eet file.
+
+ This function finds an entry in the eet file that is stored under the
+ name specified, and returns that data, decompressed, if successful.
+ NULL is returned if the lookup fails or if memory errors are
+ encountered. It is the job of the calling program to call free() on
+ the returned data. The number of bytes in the returned data chunk are
+ placed in size_ret.
+
+ If the eet file handle is not valid NULL is returned and size_ret is
+ filled with 0.
+
+ :see: eet_read_cipher()
+
+ :since: 1.0.0
+
+ """
+ cdef:
+ void *buf
+ int size_ret
+
+ if isinstance(name, unicode): name = PyUnicode_AsUTF8String(name)
+
+ buf = eet_read(self.ef, name, &size_ret)
+
+ ret = <char *>buf
+
+ free(buf)
+
+ return ret
+
+ # def read_direct(self, name):
+ # """
+
+ # Read a specified entry from an eet file and return data
+
+ # :param name: Name of the entry. eg: "/base/file_i_want".
+ # :param size_ret: Number of bytes read from entry and returned.
+ # :return: The data stored in that entry in the eet file.
+
+ # This function finds an entry in the eet file that is stored under the
+ # name specified, and returns that data if not compressed and successful.
+ # NULL is returned if the lookup fails or if memory errors are
+ # encountered or if the data is compressed. The calling program must never
+ # call free() on the returned data. The number of bytes in the returned
+ # data chunk are placed in size_ret.
+
+ # If the eet file handle is not valid NULL is returned and size_ret is
+ # filled with 0.
+
+ # :since: 1.0.0
+
+ # """
+ # cdef:
+ # const_void *ret
+ # int size_ret
+
+ # if isinstance(name, unicode): name = PyUnicode_AsUTF8String(name)
+ # ret = eet_read_direct(self.ef, name, &size_ret)
+
+ # def write(self, name, data, int size, bint compress):
+ # """
+
+ # Write a specified entry to an eet file handle
+
+ # :param name: Name of the entry. eg: "/base/file_i_want".
+ # :param data: Pointer to the data to be stored.
+ # :param size: Length in bytes in the data to be stored.
+ # :param compress: Compression flags (1 == compress, 0 = don't compress).
+ # :return: bytes written on successful write, 0 on failure.
+
+ # This function will write the specified chunk of data to the eet file
+ # and return greater than 0 on success. 0 will be returned on failure.
+
+ # The eet file handle must be a valid file handle for an eet file opened
+ # for writing. If it is not, 0 will be returned and no action will be
+ # performed.
+
+ # Name, and data must not be NULL, and size must be > 0. If these
+ # conditions are not met, 0 will be returned.
+
+ # The data will be copied (and optionally compressed) in ram, pending
+ # a flush to disk (it will stay in ram till the eet file handle is
+ # closed though).
+
+ # :see: eet_write_cipher()
+
+ # :since: 1.0.0
+
+ # """
+ # cdef:
+ # const_void *ret
+ # int size_ret
+
+ # if isinstance(name, unicode): name = PyUnicode_AsUTF8String(name)
+
+ # ret = eet_write(self.ef, name, data, size, compress)
+ # if ret == 0:
+ # raise RuntimeError
+
+ def delete(self, name):
+ """
+
+ Delete a specified entry from an Eet file being written or re-written
+
+ :param name: Name of the entry. eg: "/base/file_i_want".
+ :return: Success or failure of the delete.
+
+ This function will delete the specified chunk of data from the eet file
+ and return greater than 0 on success. 0 will be returned on failure.
+
+ The eet file handle must be a valid file handle for an eet file opened
+ for writing. If it is not, 0 will be returned and no action will be
+ performed.
+
+ Name, must not be NULL, otherwise 0 will be returned.
+
+ :since: 1.0.0
+
+ """
+ if isinstance(name, unicode): name = PyUnicode_AsUTF8String(name)
+ if not eet_delete(self.ef, name):
+ raise RuntimeError
+
+ def alias(self, name, destination, int compress):
+ """
+
+ Alias a specific section to another one. Destination may exist or not,
+ no checks are done.
+
+ :param name: Name of the new entry. eg: "/base/file_i_want".
+ :param destination: Actual source of the aliased entry eg: "/base/the_real_stuff_i_want".
+ :param compress: Compression flags (1 == compress, 0 = don't compress).
+ :return: EINA_TRUE on success, EINA_FALSE on failure.
+
+ Name and Destination must not be NULL, otherwise EINA_FALSE will be returned.
+ The equivalent of this would be calling 'ln -s destination name'
+
+ :since: 1.3.3
+
+ """
+ if isinstance(name, unicode): name = PyUnicode_AsUTF8String(name)
+ if isinstance(destination, unicode):
+ destination = PyUnicode_AsUTF8String(destination)
+
+ if not eet_alias(self.ef, name, destination, compress):
+ raise RuntimeError
+
+ property filename:
+ """
+
+ Retrieve the filename of an Eet_File
+
+ :type: string
+
+ .. note::
+
+ This function will return None for files opened with
+ :py:meth:`memopen_read`
+
+ :since: 1.6
+
+ """
+ def __get__(self):
+ return _ctouni(eet_file_get(self.ef))
+
+ def alias_get(self, name):
+ """
+
+ Retrieve the destination name of an alias
+
+ :param name: Name of the entry. eg: "/base/file_i_want"
+ :return: Destination of the alias. eg: "/base/the_real_stuff_i_want", NULL on failure
+
+ Name must not be NULL, otherwise NULL will be returned.
+
+ :since: 1.5
+
+ """
+ if isinstance(name, unicode): name = PyUnicode_AsUTF8String(name)
+ return _ctouni(eet_alias_get(self.ef, name))
+
+ def list(self, glob):
+ """
+
+ List all entries in eet file matching shell glob.
+
+ :param glob: A shell glob to match against.
+ :param count_ret: Number of entries found to match.
+ :return: Pointer to an array of strings.
+
+ This function will list all entries in the eet file matching the
+ supplied shell glob and return an allocated list of their names, if
+ there are any, and if no memory errors occur.
+
+ The eet file handle must be valid and glob must not be NULL, or NULL
+ will be returned and count_ret will be filled with 0.
+
+ The calling program must call free() on the array returned, but NOT
+ on the string pointers in the array. They are taken as read-only
+ internals from the eet file handle. They are only valid as long as
+ the file handle is not closed. When it is closed those pointers in the
+ array are now not valid and should not be used.
+
+ On success the array returned will have a list of string pointers
+ that are the names of the entries that matched, and count_ret will have
+ the number of entries in this array placed in it.
+
+ Hint: an easy way to list all entries in an eet file is to use a glob
+ value of "*".
+
+ :since: 1.0.0
+
+ """
+ cdef:
+ int count_ret
+ char **cret
+ list ret
+
+ if isinstance(glob, unicode): glob = PyUnicode_AsUTF8String(glob)
+
+ cret = eet_list(self.ef, glob, &count_ret)
+ ret = array_of_strings_to_python_list(cret, count_ret)
+ free(cret)
+ return ret
+
+ # def list_entries(self):
+ # """
+
+ # Return an iterator that will describe each entry of an Eet_File.
+
+ # :return: An interator of Eet_Entry.
+
+ # :since: 1.8.0
+
+ # """
+
+ # Eina_Iterator *eet_list_entries(self.ef)
+
+ property num_entries:
+ """
+
+ Return the number of entries in the specified eet file.
+
+ :return: Number of entries in ef or -1 if the number of entries
+ cannot be read due to open mode restrictions.
+
+ :since: 1.0.0
+
+ """
+ def __get__(self):
+ return eet_num_entries(self.ef)
+
+ # def read_cipher(self, name, cipher_key):
+ # """
+
+ # Read a specified entry from an eet file and return data using a cipher.
+
+ # :param name: Name of the entry. eg: "/base/file_i_want".
+ # :param size_ret: Number of bytes read from entry and returned.
+ # :param cipher_key: The key to use as cipher.
+ # :return: The data stored in that entry in the eet file.
+
+ # This function finds an entry in the eet file that is stored under the
+ # name specified, and returns that data, decompressed, if successful.
+ # NULL is returned if the lookup fails or if memory errors are
+ # encountered. It is the job of the calling program to call free() on
+ # the returned data. The number of bytes in the returned data chunk are
+ # placed in size_ret.
+
+ # If the eet file handle is not valid NULL is returned and size_ret is
+ # filled with 0.
+
+ # :see: eet_read()
+
+ # :since: 1.0.0
+
+ # """
+ # void *
+ # eet_read_cipher(self.ef,
+ # const char *name,
+ # int *size_ret,
+ # const char *cipher_key)
+
+ # def write_cipher(self, name, data, size, compress, cipher_key):
+ # """
+
+ # Write a specified entry to an eet file handle using a cipher.
+
+ # :param name: Name of the entry. eg: "/base/file_i_want".
+ # :param data: Pointer to the data to be stored.
+ # :param size: Length in bytes in the data to be stored.
+ # :param compress: Compression flags (1 == compress, 0 = don't compress).
+ # :param cipher_key: The key to use as cipher.
+ # :return: bytes written on successful write, 0 on failure.
+
+ # This function will write the specified chunk of data to the eet file
+ # and return greater than 0 on success. 0 will be returned on failure.
+
+ # The eet file handle must be a valid file handle for an eet file opened
+ # for writing. If it is not, 0 will be returned and no action will be
+ # performed.
+
+ # Name, and data must not be NULL, and size must be > 0. If these
+ # conditions are not met, 0 will be returned.
+
+ # The data will be copied (and optionally compressed) in ram, pending
+ # a flush to disk (it will stay in ram till the eet file handle is
+ # closed though).
+
+ # :see: eet_write()
+
+ # :since: 1.0.0
+
+ # """
+ # int
+ # eet_write_cipher(self.ef,
+ # const char *name,
+ # const void *data,
+ # int size,
+ # int compress,
+ # const char *cipher_key)
+
+ # def data_image_header_read(self, name, w, h, alpha, compress, quality, lossy):
+ # """
+
+ # Read just the header data for an image and dont decode the pixels.
+
+ # :param name: Name of the entry. eg: "/base/file_i_want".
+ # :param w: A pointer to the unsigned int to hold the width in pixels.
+ # :param h: A pointer to the unsigned int to hold the height in pixels.
+ # :param alpha: A pointer to the int to hold the alpha flag.
+ # :param compress: A pointer to the int to hold the compression amount.
+ # :param quality: A pointer to the int to hold the quality amount.
+ # :param lossy: A pointer to the int to hold the lossiness flag.
+ # :return: 1 on successful decode, 0 otherwise
+
+ # Reads and decodes the image header data stored under the given key and
+ # Eet file.
+
+ # The information decoded is placed in each of the parameters, which must be
+ # provided. The width and height, measured in pixels, will be stored under
+ # the variables pointed by @p w and @p h, respectively. If the read or
+ # decode of the header fails, this values will be 0. The @p alpha parameter
+ # will be 1 or 0, denoting if the alpha channel of the image is used or not.
+ # If the image was losslessly compressed, the @p compress parameter will hold
+ # the compression amount used, ranging from 0 to 9 and @p lossy will be 0.
+ # In the case of lossy compression, @p lossy will be 1, and the compression
+ # quality will be placed under @p quality, with a value ranging from 0 to 100.
+
+ # :see: eet_data_image_header_decode()
+ # :see: eet_data_image_header_read_cipher()
+
+ # :since: 1.0.0
+
+ # """
+ # int
+ # eet_data_image_header_read(self.ef,
+ # const char *name,
+ # unsigned int *w,
+ # unsigned int *h,
+ # int *alpha,
+ # int *compress,
+ # int *quality,
+ # int *lossy)
+
+ # def data_image_read(self, name, w, h, alpha, compress, quality, lossy):
+ # """
+
+ # Read image data from the named key in the eet file.
+
+ # :param name: Name of the entry. eg: "/base/file_i_want".
+ # :param w: A pointer to the unsigned int to hold the width in pixels.
+ # :param h: A pointer to the unsigned int to hold the height in pixels.
+ # :param alpha: A pointer to the int to hold the alpha flag.
+ # :param compress: A pointer to the int to hold the compression amount.
+ # :param quality: A pointer to the int to hold the quality amount.
+ # :param lossy: A pointer to the int to hold the lossiness flag.
+ # :return: The image pixel data decoded
+
+ # Reads and decodes the image stored in the given Eet file under the named
+ # key.
+
+ # The returned pixel data is a linear array of pixels starting from the
+ # top-left of the image, scanning row by row from left to right. Each pile
+ # is a 32bit value, with the high byte being the alpha channel, the next being
+ # red, then green, and the low byte being blue.
+
+ # The rest of the parameters are the same as in eet_data_image_header_read().
+
+ # On success the function returns a pointer to the image data decoded. The
+ # calling application is responsible for calling free() on the image data
+ # when it is done with it. On failure NULL is returned and the parameter
+ # values may not contain any sensible data.
+
+ # :see: eet_data_image_header_read()
+ # :see: eet_data_image_decode()
+ # :see: eet_data_image_read_cipher()
+ # :see: eet_data_image_read_to_surface()
+
+ # :since: 1.0.0
+
+ # """
+ # void *
+ # eet_data_image_read(self.ef,
+ # const char *name,
+ # unsigned int *w,
+ # unsigned int *h,
+ # int *alpha,
+ # int *compress,
+ # int *quality,
+ # int *lossy)
+
+ # def data_image_read_to_surface(self, name, src_x, src_y, d, w, h, row_stride, alpha, compress, quality, lossy):
+ # """
+
+ # Read image data from the named key in the eet file and store it in the given buffer.
+
+ # :param name: Name of the entry. eg: "/base/file_i_want".
+ # :param src_x: The starting x coordinate from where to dump the stream.
+ # :param src_y: The starting y coordinate from where to dump the stream.
+ # :param d: A pointer to the pixel surface.
+ # :param w: The expected width in pixels of the pixel surface to decode.
+ # :param h: The expected height in pixels of the pixel surface to decode.
+ # :param row_stride: The length of a pixels line in the destination surface.
+ # :param alpha: A pointer to the int to hold the alpha flag.
+ # :param compress: A pointer to the int to hold the compression amount.
+ # :param quality: A pointer to the int to hold the quality amount.
+ # :param lossy: A pointer to the int to hold the lossiness flag.
+ # :return: 1 on success, 0 otherwise.
+
+ # Reads and decodes the image stored in the given Eet file, placing the
+ # resulting pixel data in the buffer pointed by the user.
+
+ # Like eet_data_image_read(), it takes the image data stored under the
+ # @p name key in the @p ef file, but instead of returning a new buffer with
+ # the pixel data, it places the result in the buffer pointed by @p d, which
+ # must be provided by the user and of sufficient size to hold the requested
+ # portion of the image.
+
+ # The @p src_x and @p src_y parameters indicate the top-left corner of the
+ # section of the image to decode. These have to be higher or equal than 0 and
+ # less than the respective total width and height of the image. The width
+ # and height of the section of the image to decode are given in @p w and @p h
+ # and also can't be higher than the total width and height of the image.
+
+ # The @p row_stride parameter indicates the length in bytes of each line in
+ # the destination buffer and it has to be at least @p w * 4.
+
+ # All the other parameters are the same as in eet_data_image_read().
+
+ # On success the function returns 1, and 0 on failure. On failure the
+ # parameter values may not contain any sensible data.
+
+ # :see: eet_data_image_read()
+ # :see: eet_data_image_decode()
+ # :see: eet_data_image_decode_to_surface()
+ # :see: eet_data_image_read_to_surface_cipher()
+
+ # :since: 1.0.2
+
+ # """
+ # int
+ # eet_data_image_read_to_surface(self.ef,
+ # const char *name,
+ # unsigned int src_x,
+ # unsigned int src_y,
+ # unsigned int *d,
+ # unsigned int w,
+ # unsigned int h,
+ # unsigned int row_stride,
+ # int *alpha,
+ # int *compress,
+ # int *quality,
+ # int *lossy)
+
+ # def data_image_write(self, name, data, w, h, alpha, compress, quality, lossy):
+ # """
+
+ # Write image data to the named key in an eet file.
+
+ # :param name: Name of the entry. eg: "/base/file_i_want".
+ # :param data: A pointer to the image pixel data.
+ # :param w: The width of the image in pixels.
+ # :param h: The height of the image in pixels.
+ # :param alpha: The alpha channel flag.
+ # :param compress: The compression amount.
+ # :param quality: The quality encoding amount.
+ # :param lossy: The lossiness flag.
+ # :return: Success if the data was encoded and written or not.
+
+ # This function takes image pixel data and encodes it in an eet file
+ # stored under the supplied name key, and returns how many bytes were
+ # actually written to encode the image data.
+
+ # The data expected is the same format as returned by eet_data_image_read.
+ # If this is not the case weird things may happen. Width and height must
+ # be between 1 and 8000 pixels. The alpha flags can be 0 or 1 (0 meaning
+ # the alpha values are not useful and 1 meaning they are). Compress can
+ # be from 0 to 9 (0 meaning no compression, 9 meaning full compression).
+ # This is only used if the image is not lossily encoded. Quality is used on
+ # lossy compression and should be a value from 0 to 100. The lossy flag
+ # can be 0 or 1. 0 means encode losslessly and 1 means to encode with
+ # image quality loss (but then have a much smaller encoding).
+
+ # On success this function returns the number of bytes that were required
+ # to encode the image data, or on failure it returns 0.
+
+ # :see: eet_data_image_read()
+ # :see: eet_data_image_encode()
+ # :see: eet_data_image_write_cipher()
+
+ # :since: 1.0.0
+
+ # """
+ # int
+ # eet_data_image_write(self.ef,
+ # const char *name,
+ # const void *data,
+ # unsigned int w,
+ # unsigned int h,
+ # int alpha,
+ # int compress,
+ # int quality,
+ # int lossy)
+
+ # def data_image_header_read_cipher(self, name, cipher_key, w, h, alpha, compress, quality, lossy):
+ # """
+
+ # Read just the header data for an image and dont decode the pixels using a cipher.
+
+ # :param name: Name of the entry. eg: "/base/file_i_want".
+ # :param cipher_key: The key to use as cipher.
+ # :param w: A pointer to the unsigned int to hold the width in pixels.
+ # :param h: A pointer to the unsigned int to hold the height in pixels.
+ # :param alpha: A pointer to the int to hold the alpha flag.
+ # :param compress: A pointer to the int to hold the compression amount.
+ # :param quality: A pointer to the int to hold the quality amount.
+ # :param lossy: A pointer to the int to hold the lossiness flag.
+ # :return: 1 on successful decode, 0 otherwise
+
+ # This function reads an image from an eet file stored under the named
+ # key in the eet file and return a pointer to the decompressed pixel data.
+
+ # The other parameters of the image (width, height etc.) are placed into
+ # the values pointed to (they must be supplied). The pixel data is a linear
+ # array of pixels starting from the top-left of the image scanning row by
+ # row from left to right. Each pixel is a 32bit value, with the high byte
+ # being the alpha channel, the next being red, then green, and the low byte
+ # being blue. The width and height are measured in pixels and will be
+ # greater than 0 when returned. The alpha flag is either 0 or 1. 0 denotes
+ # that the alpha channel is not used. 1 denotes that it is significant.
+ # Compress is filled with the compression value/amount the image was
+ # stored with. The quality value is filled with the quality encoding of
+ # the image file (0 - 100). The lossy flags is either 0 or 1 as to if
+ # the image was encoded lossily or not.
+
+ # On success the function returns 1 indicating the header was read and
+ # decoded properly, or 0 on failure.
+
+ # :see: eet_data_image_header_read()
+
+ # :since: 1.0.0
+
+ # """
+ # int
+ # eet_data_image_header_read_cipher(self.ef,
+ # const char *name,
+ # const char *cipher_key,
+ # unsigned int *w,
+ # unsigned int *h,
+ # int *alpha,
+ # int *compress,
+ # int *quality,
+ # int *lossy)
+
+ # def data_image_read_cipher(self, name, cipher_key, w, h, alpha, compress, quality, lossy):
+ # """
+
+ # Read image data from the named key in the eet file using a cipher.
+
+ # :param name: Name of the entry. eg: "/base/file_i_want".
+ # :param cipher_key: The key to use as cipher.
+ # :param w: A pointer to the unsigned int to hold the width in pixels.
+ # :param h: A pointer to the unsigned int to hold the height in pixels.
+ # :param alpha: A pointer to the int to hold the alpha flag.
+ # :param compress: A pointer to the int to hold the compression amount.
+ # :param quality: A pointer to the int to hold the quality amount.
+ # :param lossy: A pointer to the int to hold the lossiness flag.
+ # :return: The image pixel data decoded
+
+ # This function reads an image from an eet file stored under the named
+ # key in the eet file and return a pointer to the decompressed pixel data.
+
+ # The other parameters of the image (width, height etc.) are placed into
+ # the values pointed to (they must be supplied). The pixel data is a linear
+ # array of pixels starting from the top-left of the image scanning row by
+ # row from left to right. Each pixel is a 32bit value, with the high byte
+ # being the alpha channel, the next being red, then green, and the low byte
+ # being blue. The width and height are measured in pixels and will be
+ # greater than 0 when returned. The alpha flag is either 0 or 1. 0 denotes
+ # that the alpha channel is not used. 1 denotes that it is significant.
+ # Compress is filled with the compression value/amount the image was
+ # stored with. The quality value is filled with the quality encoding of
+ # the image file (0 - 100). The lossy flags is either 0 or 1 as to if
+ # the image was encoded lossily or not.
+
+ # On success the function returns a pointer to the image data decoded. The
+ # calling application is responsible for calling free() on the image data
+ # when it is done with it. On failure NULL is returned and the parameter
+ # values may not contain any sensible data.
+
+ # :see: eet_data_image_read()
+
+ # :since: 1.0.0
+
+ # """
+ # void *
+ # eet_data_image_read_cipher(self.ef,
+ # const char *name,
+ # const char *cipher_key,
+ # unsigned int *w,
+ # unsigned int *h,
+ # int *alpha,
+ # int *compress,
+ # int *quality,
+ # int *lossy)
+
+ # def data_image_read_to_surface_cipher(self, name, cipher_key, src_x, src_y, d, w, h, row_stride, alpha, compress, quality, lossy):
+ # """
+
+ # Read image data from the named key in the eet file using a cipher.
+
+ # :param name: Name of the entry. eg: "/base/file_i_want".
+ # :param cipher_key: The key to use as cipher.
+ # :param src_x: The starting x coordinate from where to dump the stream.
+ # :param src_y: The starting y coordinate from where to dump the stream.
+ # :param d: A pointer to the pixel surface.
+ # :param w: The expected width in pixels of the pixel surface to decode.
+ # :param h: The expected height in pixels of the pixel surface to decode.
+ # :param row_stride: The length of a pixels line in the destination surface.
+ # :param alpha: A pointer to the int to hold the alpha flag.
+ # :param compress: A pointer to the int to hold the compression amount.
+ # :param quality: A pointer to the int to hold the quality amount.
+ # :param lossy: A pointer to the int to hold the lossiness flag.
+ # :return: 1 on success, 0 otherwise.
+
+ # This function reads an image from an eet file stored under the named
+ # key in the eet file and return a pointer to the decompressed pixel data.
+
+ # The other parameters of the image (width, height etc.) are placed into
+ # the values pointed to (they must be supplied). The pixel data is a linear
+ # array of pixels starting from the top-left of the image scanning row by
+ # row from left to right. Each pixel is a 32bit value, with the high byte
+ # being the alpha channel, the next being red, then green, and the low byte
+ # being blue. The width and height are measured in pixels and will be
+ # greater than 0 when returned. The alpha flag is either 0 or 1. 0 denotes
+ # that the alpha channel is not used. 1 denotes that it is significant.
+ # Compress is filled with the compression value/amount the image was
+ # stored with. The quality value is filled with the quality encoding of
+ # the image file (0 - 100). The lossy flags is either 0 or 1 as to if
+ # the image was encoded lossily or not.
+
+ # On success the function returns 1, and 0 on failure. On failure the
+ # parameter values may not contain any sensible data.
+
+ # :see: eet_data_image_read_to_surface()
+
+ # :since: 1.0.2
+
+ # """
+ # int
+ # eet_data_image_read_to_surface_cipher(self.ef,
+ # const char *name,
+ # const char *cipher_key,
+ # unsigned int src_x,
+ # unsigned int src_y,
+ # unsigned int *d,
+ # unsigned int w,
+ # unsigned int h,
+ # unsigned int row_stride,
+ # int *alpha,
+ # int *compress,
+ # int *quality,
+ # int *lossy)
+
+ # def data_image_write_cipher(self, name, cipher_key, data, w, h, alpha, compress, quality, lossy):
+ # """
+
+ # Write image data to the named key in an eet file using a cipher.
+
+ # :param name: Name of the entry. eg: "/base/file_i_want".
+ # :param cipher_key: The key to use as cipher.
+ # :param data: A pointer to the image pixel data.
+ # :param w: The width of the image in pixels.
+ # :param h: The height of the image in pixels.
+ # :param alpha: The alpha channel flag.
+ # :param compress: The compression amount.
+ # :param quality: The quality encoding amount.
+ # :param lossy: The lossiness flag.
+ # :return: Success if the data was encoded and written or not.
+
+ # This function takes image pixel data and encodes it in an eet file
+ # stored under the supplied name key, and returns how many bytes were
+ # actually written to encode the image data.
+
+ # The data expected is the same format as returned by eet_data_image_read.
+ # If this is not the case weird things may happen. Width and height must
+ # be between 1 and 8000 pixels. The alpha flags can be 0 or 1 (0 meaning
+ # the alpha values are not useful and 1 meaning they are). Compress can
+ # be from 0 to 9 (0 meaning no compression, 9 meaning full compression).
+ # This is only used if the image is not lossily encoded. Quality is used on
+ # lossy compression and should be a value from 0 to 100. The lossy flag
+ # can be 0 or 1. 0 means encode losslessly and 1 means to encode with
+ # image quality loss (but then have a much smaller encoding).
+
+ # On success this function returns the number of bytes that were required
+ # to encode the image data, or on failure it returns 0.
+
+ # :see: eet_data_image_write()
+
+ # :since: 1.0.0
+
+ # """
+ # int
+ # eet_data_image_write_cipher(self.ef,
+ # const char *name,
+ # const char *cipher_key,
+ # const void *data,
+ # unsigned int w,
+ # unsigned int h,
+ # int alpha,
+ # int compress,
+ # int quality,
+ # int lossy)
+
+ # property identity:
+ # """
+
+ # Set a key to sign a file
+
+
+ # :param key: the key handle to set as identity.
+ # :return: #EET_ERROR_BAD_OBJECT if @p ef is invalid or
+ # #enums.EET_ERROR_NONE on success.
+
+ # :since: 1.2.0
+
+ # """
+ # def __set__(self, key):
+ # Eet_Error eet_identity_set(self.ef, Eet_Key *key)
+
+ # property identity_x509:
+ # """
+
+ # Get the x509 der certificate associated with an Eet_File. Will return NULL
+ # if the file is not signed.
+
+
+ # :param der_length: The length of returned data, may be @c NULL.
+ # :return: the x509 certificate or @c NULL on error.
+
+ # :since: 1.2.0
+
+ # """
+ # def __get__(self):
+ # const void *eet_identity_x509(self.ef, int *der_length)
+
+ # property identity_signature:
+ # """
+
+ # Get the raw signature associated with an Eet_File. Will return NULL
+ # if the file is not signed.
+
+
+ # :param signature_length: The length of returned data, may be @c NULL.
+ # :return: the raw signature or @c NULL on error.
+
+
+ # """
+ # const void *
+ # eet_identity_signature(self.ef,
+ # int *signature_length)
+
+ # property identity_sha1:
+ # """
+
+ # Get the SHA1 associated with a file. Could be the one used to
+ # sign the data or if the data where not signed, it will be the
+ # SHA1 of the file.
+
+
+ # :param sha1_length: The length of returned data, may be @c NULL.
+ # :return: the associated SHA1 or @c NULL on error.
+
+ # :since: 1.2.0
+
+ # """
+ # const void *
+ # eet_identity_sha1(self.ef,
+ # int *sha1_length)
+
+ # def data_read(self, EetDataDecriptor edd, name):
+ # """
+
+ # Read a data structure from an eet file and decodes it.
+
+ # :param edd: The data descriptor handle to use when decoding.
+ # :param name: The key the data is stored under in the eet file.
+ # :return: A pointer to the decoded data structure.
+
+ # This function decodes a data structure stored in an eet file, returning
+ # a pointer to it if it decoded successfully, or NULL on failure. This
+ # can save a programmer dozens of hours of work in writing configuration
+ # file parsing and writing code, as eet does all that work for the program
+ # and presents a program-friendly data structure, just as the programmer
+ # likes. Eet can handle members being added or deleted from the data in
+ # storage and safely zero-fills unfilled members if they were not found
+ # in the data. It checks sizes and headers whenever it reads data, allowing
+ # the programmer to not worry about corrupt data.
+
+ # Once a data structure has been described by the programmer with the
+ # fields they wish to save or load, storing or retrieving a data structure
+ # from an eet file, or from a chunk of memory is as simple as a single
+ # function call.
+
+ # :see: eet_data_read_cipher()
+
+ # :since: 1.0.0
+
+ # """
+ # cdef:
+ # void *ret
+ # if isinstance(name, unicode): name = PyUnicode_AsUTF8String(name)
+ # ret = eet_data_read(self.ef, edd.edd, name)
+
+ # def data_write(self, EetDataDecriptor edd, name, data, int compress):
+ # """
+
+ # Write a data structure from memory and store in an eet file.
+
+ # :param edd: The data descriptor to use when encoding.
+ # :param name: The key to store the data under in the eet file.
+ # :param data: A pointer to the data structure to save and encode.
+ # :param compress: Compression flags for storage.
+ # :return: bytes written on successful write, 0 on failure.
+
+ # This function is the reverse of eet_data_read(), saving a data structure
+ # to an eet file. The file must have been opening in write mode and the data
+ # will be kept in memory until the file is either closed or eet_sync() is
+ # called to flush any unwritten changes.
+
+ # :see: eet_data_write_cipher()
+
+ # :since: 1.0.0
+
+ # """
+ # cdef void *cdata
+ # if isinstance(name, unicode): name = PyUnicode_AsUTF8String(name)
+ # int eet_data_write(self.ef, edd.edd, name, cdata, compress)
+
+ # def data_dump(self, name, dumpfunc, dumpdata):
+ # """
+
+ # Dump an eet encoded data structure from an eet file into ascii text
+
+ # :param name: Name of the entry. eg: "/base/file_i_want".
+ # :param dumpfunc: The function to call passed a string when new
+ # data is converted to text
+ # :param dumpdata: The data to pass to the @p dumpfunc callback.
+ # :return: 1 on success, 0 on failure
+
+ # This function will take an open and valid eet file from
+ # eet_open() request the data encoded by
+ # eet_data_descriptor_encode() corresponding to the key @p name
+ # and convert it into human readable ascii text. It does this by
+ # calling the @p dumpfunc callback for all new text that is
+ # generated. This callback should append to any existing text
+ # buffer and will be passed the pointer @p dumpdata as a parameter
+ # as well as a string with new text to be appended.
+
+ # :see: eet_data_dump_cipher()
+
+ # :since: 1.0.0
+
+ # """
+ # int
+ # eet_data_dump(self.ef,
+ # const char *name,
+ # Eet_Dump_Callback dumpfunc,
+ # void *dumpdata)
+
+ # def data_undump(self, name, text, textlen, compress):
+ # """
+
+ # Take an ascii encoding from eet_data_dump() and re-encode in binary.
+
+ # :param name: Name of the entry. eg: "/base/file_i_want".
+ # :param text: The pointer to the string data to parse and encode.
+ # :param textlen: The size of the string in bytes (not including 0
+ # byte terminator).
+ # :param compress: Compression flags (1 == compress, 0 = don't compress).
+ # :return: 1 on success, 0 on failure
+
+ # This function will parse the string pointed to by @p text,
+ # encode it the same way eet_data_descriptor_encode() takes an
+ # in-memory data struct and encodes into a binary blob.
+
+ # The data (optionally compressed) will be in ram, pending a flush to
+ # disk (it will stay in ram till the eet file handle is closed though).
+
+ # :see: eet_data_undump_cipher()
+
+ # :since: 1.0.0
+
+ # """
+ # int
+ # eet_data_undump(self.ef,
+ # const char *name,
+ # const char *text,
+ # int textlen,
+ # int compress)
+
+ # def data_read_cipher(self, edd, name, cipher_key):
+ # """
+
+ # Read a data structure from an eet file and decodes it using a cipher.
+
+ # :param edd: The data descriptor handle to use when decoding.
+ # :param name: The key the data is stored under in the eet file.
+ # :param cipher_key: The key to use as cipher.
+ # :return: A pointer to the decoded data structure.
+
+ # This function decodes a data structure stored in an eet file, returning
+ # a pointer to it if it decoded successfully, or NULL on failure. This
+ # can save a programmer dozens of hours of work in writing configuration
+ # file parsing and writing code, as eet does all that work for the program
+ # and presents a program-friendly data structure, just as the programmer
+ # likes. Eet can handle members being added or deleted from the data in
+ # storage and safely zero-fills unfilled members if they were not found
+ # in the data. It checks sizes and headers whenever it reads data, allowing
+ # the programmer to not worry about corrupt data.
+
+ # Once a data structure has been described by the programmer with the
+ # fields they wish to save or load, storing or retrieving a data structure
+ # from an eet file, or from a chunk of memory is as simple as a single
+ # function call.
+
+ # :see: eet_data_read()
+
+ # :since: 1.0.0
+
+ # """
+ # void *
+ # eet_data_read_cipher(self.ef,
+ # Eet_Data_Descriptor *edd,
+ # const char *name,
+ # const char *cipher_key)
+
+ # def data_write_cipher(self, edd, name, cipher_key, data, compress):
+ # """
+
+ # Write a data structure from memory and store in an eet file
+ # using a cipher.
+
+ # :param edd: The data descriptor to use when encoding.
+ # :param name: The key to store the data under in the eet file.
+ # :param cipher_key: The key to use as cipher.
+ # :param data: A pointer to the data structure to save and encode.
+ # :param compress: Compression flags for storage.
+ # :return: bytes written on successful write, 0 on failure.
+
+ # This function is the reverse of eet_data_read_cipher(), saving a data structure
+ # to an eet file.
+
+ # :since: 1.0.0
+
+ # """
+ # int
+ # eet_data_write_cipher(self.ef,
+ # Eet_Data_Descriptor *edd,
+ # const char *name,
+ # const char *cipher_key,
+ # const void *data,
+ # int compress)
+
+ # def data_dump_cipher(self, name, cipher_key, dumpfunc, dumpdata):
+ # """
+
+ # Dump an eet encoded data structure from an eet file into ascii
+ # text using a cipher.
+
+ # :param name: Name of the entry. eg: "/base/file_i_want".
+ # :param cipher_key: The key to use as cipher.
+ # :param dumpfunc: The function to call passed a string when new
+ # data is converted to text
+ # :param dumpdata: The data to pass to the @p dumpfunc callback.
+ # :return: 1 on success, 0 on failure
+
+ # This function will take an open and valid eet file from
+ # eet_open() request the data encoded by
+ # eet_data_descriptor_encode() corresponding to the key @p name
+ # and convert it into human readable ascii text. It does this by
+ # calling the @p dumpfunc callback for all new text that is
+ # generated. This callback should append to any existing text
+ # buffer and will be passed the pointer @p dumpdata as a parameter
+ # as well as a string with new text to be appended.
+
+ # :see: eet_data_dump()
+
+ # :since: 1.0.0
+
+ # """
+ # int
+ # eet_data_dump_cipher(self.ef,
+ # const char *name,
+ # const char *cipher_key,
+ # Eet_Dump_Callback dumpfunc,
+ # void *dumpdata)
+
+ # def data_undump_cipher(self, name, cipher_key, dumpfunc, dumpdata):
+ # """
+
+ # Take an ascii encoding from eet_data_dump() and re-encode in
+ # binary using a cipher.
+
+ # :param name: Name of the entry. eg: "/base/file_i_want".
+ # :param cipher_key: The key to use as cipher.
+ # :param text: The pointer to the string data to parse and encode.
+ # :param textlen: The size of the string in bytes (not including 0
+ # byte terminator).
+ # :param compress: Compression flags (1 == compress, 0 = don't compress).
+ # :return: 1 on success, 0 on failure
+
+ # This function will parse the string pointed to by @p text,
+ # encode it the same way eet_data_descriptor_encode() takes an
+ # in-memory data struct and encodes into a binary blob.
+
+ # The data (optionally compressed) will be in ram, pending a flush to
+ # disk (it will stay in ram till the eet file handle is closed though).
+
+ # :see: eet_data_undump()
+
+ # :since: 1.0.0
+
+ # """
+ # int
+ # eet_data_undump_cipher(self.ef,
+ # const char *name,
+ # const char *cipher_key,
+ # const char *text,
+ # int textlen,
+ # int compress)
+
+ # def data_node_read_cipher(self, name, cipher_key):
+ # """
+
+ # TODO FIX ME
+
+ # """
+ # Eet_Node *
+ # eet_data_node_read_cipher(self.ef,
+ # const char *name,
+ # const char *cipher_key)
+
+ # def data_node_write_cipher(self, name, cipher_key, node, compress):
+ # """
+
+ # TODO FIX ME
+
+ # """
+ # int
+ # eet_data_node_write_cipher(self.ef,
+ # const char *name,
+ # const char *cipher_key,
+ # Eet_Node *node,
+ # int compress)
diff --git a/efl/eet/key.pxi b/efl/eet/key.pxi
new file mode 100644
index 0000000..5451077
--- /dev/null
+++ b/efl/eet/key.pxi
@@ -0,0 +1,80 @@
+
+
+
+"""
+
+@typedef Eet_Key
+Opaque handle that defines an identity (also known as key)
+in Eet's cipher system.
+
+"""
+typedef struct _Eet_Key Eet_Key;
+
+
+"""
+
+Callback used to request if needed the password of a private key.
+
+:param buffer: the buffer where to store the password.
+:param size: the maximum password size (size of buffer, including '@\0').
+:param rwflag: if the buffer is also readable or just writable.
+:param data: currently unused, may contain some context in future.
+:return: 1 on success and password was set to @p buffer, 0 on failure.
+
+:since: 1.2.0
+
+"""
+typedef int (*Eet_Key_Password_Callback)(char *buffer, int size, int rwflag, void *data);
+
+"""
+
+Create an Eet_Key needed for signing an eet file.
+
+The certificate should provide the public that match the private key.
+No verification is done to ensure that.
+
+:param certificate_file: The file where to find the certificate.
+:param private_key_file: The file that contains the private key.
+:param cb: Function to callback if password is required to unlock
+ private key.
+:return: A key handle to use, or @c NULL on failure.
+
+@see eet_identity_close()
+
+@warning You need to compile signature support in EET.
+:since: 1.2.0
+
+"""
+EAPI Eet_Key *
+eet_identity_open(const char *certificate_file,
+ const char *private_key_file,
+ Eet_Key_Password_Callback cb);
+
+"""
+
+Close and release all resource used by an Eet_Key. An
+reference counter prevent it from being freed until all file
+using it are also closed.
+
+:param key: the key handle to close and free resources.
+
+:since: 1.2.0
+
+"""
+EAPI void
+eet_identity_close(Eet_Key *key);
+
+"""
+
+Display both private and public key of an Eet_Key.
+
+:param key: the handle to print.
+:param out: where to print.
+
+@warning You need to compile signature support in EET.
+:since: 1.2.0
+
+"""
+EAPI void
+eet_identity_print(Eet_Key *key,
+ FILE *out);
diff --git a/efl/eet/node.pxi b/efl/eet/node.pxi
new file mode 100644
index 0000000..182d5e2
--- /dev/null
+++ b/efl/eet/node.pxi
@@ -0,0 +1,328 @@
+"""
+
+@typedef Eet_Node
+Opaque handle to manage serialization node.
+
+"""
+typedef struct _Eet_Node Eet_Node;
+
+"""
+
+@typedef Eet_Node_Data
+Contains an union that can fit any kind of node.
+
+"""
+typedef struct _Eet_Node_Data Eet_Node_Data;
+
+"""
+
+@struct _Eet_Node_Data
+Contains an union that can fit any kind of node.
+
+"""
+struct _Eet_Node_Data
+{
+ union {
+ char c;
+ short s;
+ int i;
+ long long l;
+ float f;
+ double d;
+ unsigned char uc;
+ unsigned short us;
+ unsigned int ui;
+ unsigned long long ul;
+ const char *str;
+ } value;
+};
+
+
+"""
+
+TODO FIX ME
+
+"""
+EAPI Eet_Node *
+eet_node_char_new(const char *name,
+ char c);
+
+"""
+
+TODO FIX ME
+
+"""
+EAPI Eet_Node *
+eet_node_short_new(const char *name,
+ short s);
+
+"""
+
+TODO FIX ME
+
+"""
+EAPI Eet_Node *
+eet_node_int_new(const char *name,
+ int i);
+
+"""
+
+TODO FIX ME
+
+"""
+EAPI Eet_Node *
+eet_node_long_long_new(const char *name,
+ long long l);
+
+"""
+
+TODO FIX ME
+
+"""
+EAPI Eet_Node *
+eet_node_float_new(const char *name,
+ float f);
+
+"""
+
+TODO FIX ME
+
+"""
+EAPI Eet_Node *
+eet_node_double_new(const char *name,
+ double d);
+
+"""
+
+TODO FIX ME
+
+"""
+EAPI Eet_Node *
+eet_node_unsigned_char_new(const char *name,
+ unsigned char uc);
+
+"""
+
+TODO FIX ME
+
+"""
+EAPI Eet_Node *
+eet_node_unsigned_short_new(const char *name,
+ unsigned short us);
+
+"""
+
+TODO FIX ME
+
+"""
+EAPI Eet_Node *
+eet_node_unsigned_int_new(const char *name,
+ unsigned int ui);
+
+"""
+
+TODO FIX ME
+
+"""
+EAPI Eet_Node *
+eet_node_unsigned_long_long_new(const char *name,
+ unsigned long long l);
+
+"""
+
+TODO FIX ME
+
+"""
+EAPI Eet_Node *
+eet_node_string_new(const char *name,
+ const char *str);
+
+"""
+
+TODO FIX ME
+
+"""
+EAPI Eet_Node *
+eet_node_inlined_string_new(const char *name,
+ const char *str);
+
+"""
+
+TODO FIX ME
+
+"""
+EAPI Eet_Node *
+eet_node_null_new(const char *name);
+
+"""
+
+TODO FIX ME
+
+"""
+EAPI Eet_Node *
+eet_node_list_new(const char *name,
+ Eina_List *nodes);
+
+"""
+
+TODO FIX ME
+
+"""
+EAPI Eet_Node *
+eet_node_array_new(const char *name,
+ int count,
+ Eina_List *nodes);
+
+"""
+
+TODO FIX ME
+
+"""
+EAPI Eet_Node *
+eet_node_var_array_new(const char *name,
+ Eina_List *nodes);
+
+"""
+
+TODO FIX ME
+
+"""
+EAPI Eet_Node *
+eet_node_hash_new(const char *name,
+ const char *key,
+ Eet_Node *node);
+
+"""
+
+TODO FIX ME
+
+"""
+EAPI Eet_Node *
+eet_node_struct_new(const char *name,
+ Eina_List *nodes);
+
+"""
+
+TODO FIX ME
+
+"""
+EAPI Eet_Node *
+eet_node_struct_child_new(const char *parent,
+ Eet_Node *child);
+
+"""
+
+@brief Get a node's child nodes
+:param node: The node
+:return: The first child node which contains a pointer to the
+next child node and the parent.
+:since: 1.5
+
+"""
+EAPI Eet_Node *
+eet_node_children_get(Eet_Node *node);
+
+"""
+
+@brief Get the next node in a list of nodes
+:param node: The node
+:return: A node which contains a pointer to the
+next child node and the parent.
+:since: 1.5
+
+"""
+EAPI Eet_Node *
+eet_node_next_get(Eet_Node *node);
+
+"""
+
+@brief Get the parent node of a node
+:param node: The node
+:return: The parent node of @p node
+:since: 1.5
+
+"""
+EAPI Eet_Node *
+eet_node_parent_get(Eet_Node *node);
+
+"""
+
+TODO FIX ME
+
+"""
+EAPI void
+eet_node_list_append(Eet_Node *parent,
+ const char *name,
+ Eet_Node *child);
+
+"""
+
+TODO FIX ME
+
+"""
+EAPI void
+eet_node_struct_append(Eet_Node *parent,
+ const char *name,
+ Eet_Node *child);
+
+"""
+
+TODO FIX ME
+
+"""
+EAPI void
+eet_node_hash_add(Eet_Node *parent,
+ const char *name,
+ const char *key,
+ Eet_Node *child);
+
+"""
+
+TODO FIX ME
+
+"""
+EAPI void
+eet_node_dump(Eet_Node *n,
+ int dumplevel,
+ Eet_Dump_Callback dumpfunc,
+ void *dumpdata);
+
+"""
+
+@brief Return the type of a node
+:param node: The node
+:return: The node's type (EET_T_$TYPE)
+:since: 1.5
+
+"""
+EAPI int
+eet_node_type_get(Eet_Node *node);
+
+"""
+
+@brief Return the node's data
+:param node: The node
+:return: The data contained in the node
+:since: 1.5
+
+"""
+EAPI Eet_Node_Data *
+eet_node_value_get(Eet_Node *node);
+
+"""
+
+TODO FIX ME
+
+"""
+EAPI void
+eet_node_del(Eet_Node *n);
+
+"""
+
+TODO FIX ME
+
+"""
+EAPI void *
+eet_data_node_encode_cipher(Eet_Node *node,
+ const char *cipher_key,
+ int *size_ret);
diff --git a/include/efl.eet.enums.pxd b/include/efl.eet.enums.pxd
new file mode 100644
index 0000000..ea4a9ab
--- /dev/null
+++ b/include/efl.eet.enums.pxd
@@ -0,0 +1,50 @@
+
+cdef extern from "Eet.h":
+
+ enum _Eet_Error:
+ EET_ERROR_NONE #No error, it's all fine!
+ EET_ERROR_BAD_OBJECT #Given object or handle is NULL or invalid
+ EET_ERROR_EMPTY #There was nothing to do
+ EET_ERROR_NOT_WRITABLE #Could not write to file or file is #EET_FILE_MODE_READ
+ EET_ERROR_OUT_OF_MEMORY #Could not allocate memory
+ EET_ERROR_WRITE_ERROR #Failed to write data to destination
+ EET_ERROR_WRITE_ERROR_FILE_TOO_BIG #Failed to write file since it is too big
+ EET_ERROR_WRITE_ERROR_IO_ERROR #Failed to write due a generic Input/Output error
+ EET_ERROR_WRITE_ERROR_OUT_OF_SPACE #Failed to write due out of space
+ EET_ERROR_WRITE_ERROR_FILE_CLOSED #Failed to write because file was closed
+ EET_ERROR_MMAP_FAILED #Could not mmap file
+ EET_ERROR_X509_ENCODING_FAILED #Could not encode using X509
+ EET_ERROR_SIGNATURE_FAILED #Could not validate signature
+ EET_ERROR_INVALID_SIGNATURE #Signature is invalid
+ EET_ERROR_NOT_SIGNED #File or contents are not signed
+ EET_ERROR_NOT_IMPLEMENTED #Function is not implemented
+ EET_ERROR_PRNG_NOT_SEEDED #Could not introduce random seed
+ EET_ERROR_ENCRYPT_FAILED #Could not encrypt contents
+ EET_ERROR_DECRYPT_FAILED #Could not decrypt contents
+
+ ctypedef _Eet_Error Eet_Error
+
+ ctypedef enum _Eet_Compression:
+ EET_COMPRESSION_NONE #No compression at all @since 1.7
+ EET_COMPRESSION_DEFAULT #Default compression (Zlib) @since 1.7
+ EET_COMPRESSION_LOW #Fast but minimal compression (Zlib) @since 1.7
+ EET_COMPRESSION_MED #Medium compression level (Zlib) @since 1.7
+ EET_COMPRESSION_HI #Slow but high compression level (Zlib) @since 1.7
+ EET_COMPRESSION_VERYFAST #Very fast, but lower compression ratio (LZ4HC) @since 1.7
+ EET_COMPRESSION_SUPERFAST #Very fast, but lower compression ratio (faster to compress than EET_COMPRESSION_VERYFAST) (LZ4) @since 1.7
+
+ EET_COMPRESSION_LOW2 #Space filler for compatibility. Don't use it @since 1.7
+ EET_COMPRESSION_MED1 #Space filler for compatibility. Don't use it @since 1.7
+ EET_COMPRESSION_MED2 #Space filler for compatibility. Don't use it @since 1.7
+ EET_COMPRESSION_HI1 #Space filler for compatibility. Don't use it @since 1.7
+ EET_COMPRESSION_HI2 #Space filler for compatibility. Don't use it @since 1.7
+
+ ctypedef _Eet_Compression Eet_Compression
+
+ ctypedef enum _Eet_File_Mode:
+ EET_FILE_MODE_INVALID
+ EET_FILE_MODE_READ #File is read-only.
+ EET_FILE_MODE_WRITE #File is write-only.
+ EET_FILE_MODE_READ_WRITE #File is for both read and write
+
+ ctypedef _Eet_File_Mode Eet_File_Mode
diff --git a/setup.py b/setup.py
index ec82c75..a8cde0d 100755
--- a/setup.py
+++ b/setup.py
@@ -189,6 +189,16 @@ if set(("build", "build_ext", "install", "bdist", "sdist")) & set(sys.argv):
)
modules.append(eo_ext)
+ # === Eet ===
+ eet_cflags, eet_libs = pkg_config('Eet', 'eet', EFL_MIN_VERSION)
+ eet_ext = Extension(
+ "eet", ["efl/eet/eet"+module_suffix],
+ include_dirs=['include/'],
+ extra_compile_args=eet_cflags,
+ extra_link_args=eet_libs + eina_libs
+ )
+ modules.append(eet_ext)
+
# === Utilities ===
utils_ext = [
Extension(