merge ethumb.

This one was a painful bitch. The edbus2 port was quite broken, mainly
leaking eina_stringshare and also not adding the '\0' to the strings
that are represented as bytearray (paths cannot be utf8 to avoid
translations).

Emotion plugin was also quite bogus and the video thumbnail as edje
(animated) is not working yet due bug in Edje_Edit api -- someone
needs to investigate this, seems strange.

Emotion plugin also had a bug that it was deleting the object from
inside object callback.

Now it seems to work. Please report if it does not.



SVN revision: 82675

8 files changed, 4972 insertions, 0 deletions

diff --git a/src/lib/ethumb/Ethumb.h b/src/lib/ethumb/Ethumb.h
new file mode 100644
index 0000000000..fd4dff708a
--- /dev/null
+++ b/src/lib/ethumb/Ethumb.h
@@ -0,0 +1,279 @@
+#ifndef __ETHUMB_H__
+#define __ETHUMB_H__ 1
+
+#include <Eina.h>
+
+#ifdef EAPI
+# undef EAPI
+#endif
+
+#ifdef _WIN32
+# ifdef EFL_ETHUMB_BUILD
+#  ifdef DLL_EXPORT
+#   define EAPI __declspec(dllexport)
+#  else
+#   define EAPI
+#  endif /* ! DLL_EXPORT */
+# else
+#  define EAPI __declspec(dllimport)
+# endif /* ! EFL_ETHUMB_BUILD */
+#else
+# ifdef __GNUC__
+#  if __GNUC__ >= 4
+#   define EAPI __attribute__ ((visibility("default")))
+#  else
+#   define EAPI
+#  endif
+# else
+#  define EAPI
+# endif
+#endif /* ! _WIN32 */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ETHUMB_VERSION_MAJOR 1
+#define ETHUMB_VERSION_MINOR 8
+   
+   typedef struct _Ethumb_Version
+     {
+        int major;
+        int minor;
+        int micro;
+        int revision;
+     } Ethumb_Version;
+
+   EAPI extern Ethumb_Version *ethumb_version;
+
+/**
+ * @page ethumb_main Ethumb
+ *
+ * @date 2009 (created)
+ *
+ * @section toc Table of Contents
+ *
+ * @li @ref ethumb_main_intro
+ * @li @ref ethumb_main_compiling
+ * @li @ref ethumb_main_next_steps
+ *
+ * @section ethumb_main_intro Introduction
+ *
+ * Ethumb will use @ref Evas to generate thumbnail images of given
+ * files. The API allows great customization of the generated files
+ * and also helps compling to FreeDesktop.Org Thumbnail Specification
+ * (http://specifications.freedesktop.org/thumbnail-spec/thumbnail-spec-latest.html)
+ *
+ * However, thumbnailing can be an expensive process that will impact
+ * your application experience, blocking animations and user
+ * interaction during the generation. Another problem is that one
+ * should try to cache the thumbnails in a place that other
+ * applications can benefit from the file.
+ *
+ * @ref Ethumb_Client exists to solve this. It will communicate with a
+ * server using standard D-Bus protocol. The server will use @ref
+ * Ethumb itself to generate the thumbnail images and cache them using
+ * FreeDesktop.Org standard. It is recommended that most applications
+ * use @ref Ethumb_Client instead of @ref Ethumb directly.
+ *
+ * @section ethumb_main_compiling How to compile
+ *
+ * Ethumb is a library your application links to. The procedure for
+ * this is very simple. Note that usually you want the D-Bus client
+ * library. You simply have to compile your application with the
+ * appropriate compiler flags that the @c pkg-config script
+ * outputs. For example:
+ *
+ * Compiling C or C++ files into object files:
+ *
+ * @verbatim
+   gcc -c -o main.o main.c `pkg-config --cflags ethumb_client`
+   @endverbatim
+ *
+ * Linking object files into a binary executable:
+ *
+ * @verbatim
+   gcc -o my_application main.o `pkg-config --libs ethumb_client`
+   @endverbatim
+ *
+ * See @ref pkgconfig
+ *
+ * @section ethumb_main_next_steps Next Steps
+ *
+ * After you understood what Ethumb is and installed it in your system
+ * you should proceed understanding the programming interface.
+ *
+ * Recommended reading:
+ *
+ * @li @ref Ethumb_Client to generate thumbnails using a server
+ *     (recommended).
+ * @li @ref Ethumb to generate thumbnails in the local process.
+ *
+ */
+
+/**
+ * @defgroup Ethumb Ethumb
+ *
+ * @{
+ */
+/**
+ * @defgroup Ethumb_Basics Ethumb Basics
+ *
+ * Functions that all users must know of to use Ethumb.
+ *
+ * @{
+ */
+
+/**
+ * @brief thumbnailer handle.
+ *
+ * The handle is returned by ethumb_new() and destroyed by ethumb_free().
+ */
+typedef struct _Ethumb Ethumb;
+
+/**
+ * @brief reports results of ethumb_generate().
+ *
+ * @param data extra context given to ethumb_generate().
+ * @param e handle of the current thumbnailer.
+ * @param success @c EINA_TRUE if generated or @c EINA_FALSE on errors.
+ */
+typedef void (*Ethumb_Generate_Cb)(void *data, Ethumb *e, Eina_Bool success);
+
+EAPI int ethumb_init(void);
+EAPI int ethumb_shutdown(void);
+
+EAPI Ethumb * ethumb_new(void) EINA_MALLOC EINA_WARN_UNUSED_RESULT;
+EAPI void ethumb_free(Ethumb *e);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup Ethumb_Setup Ethumb Fine Tune Setup
+ *
+ * How to fine tune thumbnail generation, setting size, aspect,
+ * frames, quality and so on.
+ *
+ * @{
+ */
+
+EAPI Eina_Bool    ethumb_frame_set(Ethumb *e, const char *theme_file, const char *group, const char *swallow) EINA_ARG_NONNULL(1);
+EAPI void         ethumb_frame_get(const Ethumb *e, const char **theme_file, const char **group, const char **swallow) EINA_ARG_NONNULL(1);
+
+EAPI void         ethumb_thumb_dir_path_set(Ethumb *e, const char *path) EINA_ARG_NONNULL(1);
+EAPI const char  *ethumb_thumb_dir_path_get(const Ethumb *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1) EINA_PURE;
+
+EAPI void         ethumb_thumb_category_set(Ethumb *e, const char *category) EINA_ARG_NONNULL(1);
+EAPI const char  *ethumb_thumb_category_get(const Ethumb *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1) EINA_PURE;
+
+EAPI void         ethumb_thumb_path_set(Ethumb *e, const char *path, const char *key) EINA_ARG_NONNULL(1);
+EAPI void         ethumb_thumb_path_get(Ethumb *e, const char **path, const char **key) EINA_ARG_NONNULL(1);
+EAPI void         ethumb_thumb_hash(Ethumb *e) EINA_ARG_NONNULL(1);
+EAPI void         ethumb_thumb_hash_copy(Ethumb *dst, const Ethumb *src) EINA_ARG_NONNULL(1, 2);
+
+typedef enum _Ethumb_Thumb_FDO_Size
+{
+  ETHUMB_THUMB_NORMAL, /**< 128x128 as defined by FreeDesktop.Org standard */
+  ETHUMB_THUMB_LARGE   /**< 256x256 as defined by FreeDesktop.Org standard */
+} Ethumb_Thumb_FDO_Size;
+
+typedef enum _Ethumb_Thumb_Format
+{
+   ETHUMB_THUMB_FDO,   /**< PNG as defined by FreeDesktop.Org standard */
+   ETHUMB_THUMB_JPEG,  /**< JPEGs are often smaller and faster to read/write */
+   ETHUMB_THUMB_EET    /**< EFL's own storage system, supports key parameter */
+} Ethumb_Thumb_Format;
+
+typedef enum _Ethumb_Thumb_Aspect
+{
+  ETHUMB_THUMB_KEEP_ASPECT, /**< keep original proportion between width and height */
+  ETHUMB_THUMB_IGNORE_ASPECT, /**< ignore aspect and foce it to match thumbnail's width and height */
+  ETHUMB_THUMB_CROP /**< keep aspect but crop (cut) the largest dimension */
+} Ethumb_Thumb_Aspect;
+
+typedef enum _Ethumb_Thumb_Orientation
+{
+  ETHUMB_THUMB_ORIENT_NONE,     /**< keep orientation as pixel data is */
+  ETHUMB_THUMB_ROTATE_90_CW,    /**< rotate 90° clockwise */
+  ETHUMB_THUMB_ROTATE_180,      /**< rotate 180° */
+  ETHUMB_THUMB_ROTATE_90_CCW,   /**< rotate 90° counter-clockwise */
+  ETHUMB_THUMB_FLIP_HORIZONTAL, /**< flip horizontally */
+  ETHUMB_THUMB_FLIP_VERTICAL,   /**< flip vertically */
+  ETHUMB_THUMB_FLIP_TRANSPOSE,  /**< transpose */
+  ETHUMB_THUMB_FLIP_TRANSVERSE, /**< transverse */
+  ETHUMB_THUMB_ORIENT_ORIGINAL  /**< use orientation from metadata (EXIF-only currently) */
+} Ethumb_Thumb_Orientation;
+
+EAPI void ethumb_thumb_fdo_set(Ethumb *e, Ethumb_Thumb_FDO_Size s) EINA_ARG_NONNULL(1);
+
+EAPI void ethumb_thumb_size_set(Ethumb *e, int tw, int th) EINA_ARG_NONNULL(1);
+EAPI void ethumb_thumb_size_get(const Ethumb *e, int *tw, int *th) EINA_ARG_NONNULL(1);
+
+EAPI void                     ethumb_thumb_format_set(Ethumb *e, Ethumb_Thumb_Format f) EINA_ARG_NONNULL(1);
+EAPI Ethumb_Thumb_Format      ethumb_thumb_format_get(const Ethumb *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1) EINA_PURE;
+
+EAPI void                     ethumb_thumb_aspect_set(Ethumb *e, Ethumb_Thumb_Aspect a) EINA_ARG_NONNULL(1);
+EAPI Ethumb_Thumb_Aspect      ethumb_thumb_aspect_get(const Ethumb *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1) EINA_PURE;
+
+EAPI void                     ethumb_thumb_orientation_set(Ethumb *e, Ethumb_Thumb_Orientation o) EINA_ARG_NONNULL(1);
+EAPI Ethumb_Thumb_Orientation ethumb_thumb_orientation_get(const Ethumb *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1) EINA_PURE;
+
+EAPI void         ethumb_thumb_crop_align_set(Ethumb *e, float x, float y) EINA_ARG_NONNULL(1);
+EAPI void         ethumb_thumb_crop_align_get(const Ethumb *e, float *x, float *y) EINA_ARG_NONNULL(1);
+
+EAPI void         ethumb_thumb_quality_set(Ethumb *e, int quality) EINA_ARG_NONNULL(1);
+EAPI int          ethumb_thumb_quality_get(const Ethumb *e) EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT EINA_PURE;
+
+EAPI void         ethumb_thumb_compress_set(Ethumb *e, int compress) EINA_ARG_NONNULL(1);
+EAPI int          ethumb_thumb_compress_get(const Ethumb *e) EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT EINA_PURE;
+
+EAPI void         ethumb_video_start_set(Ethumb *e, float start) EINA_ARG_NONNULL(1);
+EAPI float        ethumb_video_start_get(const Ethumb *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1) EINA_PURE;
+EAPI void         ethumb_video_time_set(Ethumb *e, float time) EINA_ARG_NONNULL(1);
+EAPI float        ethumb_video_time_get(const Ethumb *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1) EINA_PURE;
+EAPI void         ethumb_video_interval_set(Ethumb *e, float interval) EINA_ARG_NONNULL(1);
+EAPI float        ethumb_video_interval_get(const Ethumb *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1) EINA_PURE;
+EAPI void         ethumb_video_ntimes_set(Ethumb *e, unsigned int ntimes) EINA_ARG_NONNULL(1);
+EAPI unsigned int ethumb_video_ntimes_get(const Ethumb *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1) EINA_PURE;
+EAPI void         ethumb_video_fps_set(Ethumb *e, unsigned int fps) EINA_ARG_NONNULL(1);
+EAPI unsigned int ethumb_video_fps_get(const Ethumb *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1) EINA_PURE;
+
+
+EAPI void         ethumb_document_page_set(Ethumb *e, unsigned int page) EINA_ARG_NONNULL(1);
+EAPI unsigned int ethumb_document_page_get(const Ethumb *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1) EINA_PURE;
+/**
+ * @}
+ */
+
+/**
+ * @addtogroup Ethumb_Basics Ethumb Basics
+ * @{
+ */
+EAPI Eina_Bool ethumb_file_set(Ethumb *e, const char *path, const char *key) EINA_ARG_NONNULL(1, 2);
+EAPI void      ethumb_file_get(const Ethumb *e, const char **path, const char **key) EINA_ARG_NONNULL(1);
+EAPI void      ethumb_file_free(Ethumb *e) EINA_ARG_NONNULL(1);
+
+EAPI Eina_Bool ethumb_generate(Ethumb *e, Ethumb_Generate_Cb finished_cb, const void *data, Eina_Free_Cb free_data) EINA_ARG_NONNULL(1, 2);
+EAPI Eina_Bool ethumb_exists(Ethumb *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1) EINA_PURE;
+
+EAPI Ethumb *ethumb_dup(const Ethumb *e) EINA_ARG_NONNULL(1);
+EAPI Eina_Bool ethumb_cmp(const Ethumb *e1, const Ethumb *e2) EINA_ARG_NONNULL(1, 2) EINA_WARN_UNUSED_RESULT EINA_PURE;
+EAPI int ethumb_hash(const void *key, int key_length) EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT EINA_PURE;
+EAPI int ethumb_key_cmp(const void *key1, int key1_length,
+                        const void *key2, int key2_length) EINA_ARG_NONNULL(1, 3) EINA_WARN_UNUSED_RESULT EINA_PURE;
+EAPI unsigned int ethumb_length(const void *key) EINA_PURE EINA_WARN_UNUSED_RESULT;
+
+  /**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __ETHUMB_H__ */
diff --git a/src/lib/ethumb/Ethumb_Plugin.h b/src/lib/ethumb/Ethumb_Plugin.h
new file mode 100644
index 0000000000..3eb6f020cd
--- /dev/null
+++ b/src/lib/ethumb/Ethumb_Plugin.h
@@ -0,0 +1,27 @@
+#ifndef _ETHUMB_PLUGIN_H_
+#define _ETHUMB_PLUGIN_H_
+
+#include <Evas.h>
+#include <Ecore_Evas.h>
+#include <Ethumb.h>
+
+typedef struct _Ethumb_Plugin Ethumb_Plugin;
+
+struct _Ethumb_Plugin
+{
+   const char **extensions;
+   void *(*thumb_generate)(Ethumb *);
+   void (*thumb_cancel)(Ethumb *, void *);
+};
+
+EAPI void ethumb_calculate_aspect_from_ratio(Ethumb *e, float ia, int *w, int *h);
+EAPI void ethumb_calculate_aspect(Ethumb *e, int iw, int ih, int *w, int *h);
+EAPI void ethumb_calculate_fill_from_ratio(Ethumb *e, float ia, int *fx, int *fy, int *fw, int *fh);
+EAPI void ethumb_calculate_fill(Ethumb *e, int iw, int ih, int *fx, int *fy, int *fw, int *fh);
+EAPI Eina_Bool ethumb_plugin_image_resize(Ethumb *e, int w, int h);
+EAPI Eina_Bool ethumb_image_save(Ethumb *e);
+EAPI void ethumb_finished_callback_call(Ethumb *e, int result);
+EAPI Evas * ethumb_evas_get(const Ethumb *e);
+EAPI Ecore_Evas * ethumb_ecore_evas_get(const Ethumb *e);
+
+#endif /* _ETHUMB_PLUGIN_H_ */
diff --git a/src/lib/ethumb/client/Ethumb_Client.h b/src/lib/ethumb/client/Ethumb_Client.h
new file mode 100644
index 0000000000..3c3f95d87e
--- /dev/null
+++ b/src/lib/ethumb/client/Ethumb_Client.h
@@ -0,0 +1,220 @@
+#ifndef __ETHUMB_CLIENT_H__
+#define __ETHUMB_CLIENT_H__ 1
+
+#include <Ethumb.h>
+
+#ifdef EAPI
+# undef EAPI
+#endif
+
+#ifdef _WIN32
+# ifdef EFL_ETHUMB_CLIENT_BUILD
+#  ifdef DLL_EXPORT
+#   define EAPI __declspec(dllexport)
+#  else
+#   define EAPI
+#  endif /* ! DLL_EXPORT */
+# else
+#  define EAPI __declspec(dllimport)
+# endif /* ! EFL_ETHUMB_CLIENT_BUILD */
+#else
+# ifdef __GNUC__
+#  if __GNUC__ >= 4
+#   define EAPI __attribute__ ((visibility("default")))
+#  else
+#   define EAPI
+#  endif
+# else
+#  define EAPI
+# endif
+#endif /* ! _WIN32 */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup Ethumb_Client Ethumb Client
+ * @ingroup Ethumb
+ *
+ * @{
+ */
+
+/**
+ * @defgroup Ethumb_Client_Basics Ethumb Client Basics
+ *
+ * Functions that all users must know of to use Ethumb_Client.
+ *
+ * @{
+ */
+
+/**
+ * @brief client handle.
+ *
+ * The client handle is created by ethumb_client_connect() and
+ * destroyed by ethumb_client_disconnect(). The connection and
+ * requests are asynchronous and callbacks should be used to report
+ * both success and failure of calls.
+ */
+typedef struct _Ethumb_Client Ethumb_Client;
+
+/**
+ * @brief client exists request handle.
+ *
+ * The exists request handle is created by ethumb_client_thumb_exists(),
+ * automatically destroyed when it end and cancelled when requested by
+ * ethumb_client_thumb_exists_cancel().
+ */
+typedef struct _Ethumb_Exists Ethumb_Exists;
+
+/**
+ * @brief reports results of ethumb_client_connect()
+ *
+ * @param data extra context given to ethumb_client_connect().
+ * @param client handle of the current connection to server.
+ * @param success @c EINA_TRUE if connected or @c EINA_FALSE if it was
+ *        not possible.
+ */
+typedef void (*Ethumb_Client_Connect_Cb)(void *data, Ethumb_Client *client, Eina_Bool success);
+
+/**
+ * @brief reports server connection ended.
+ *
+ * Functions of this type may be called if they are set with
+ * ethumb_client_on_server_die_callback_set().
+ *
+ * @param data extra context given to ethumb_client_on_server_die_callback_set().
+ * @param client handle of the current connection to server.
+ */
+typedef void (*Ethumb_Client_Die_Cb)(void *data, Ethumb_Client *client);
+
+/**
+ * @brief reports results of ethumb_client_generate().
+ *
+ * @param data extra context given to ethumb_client_generate().
+ * @param client handle of the current connection to server.
+ * @param id identifier returned by ethumb_client_generate().
+ * @param file path set with ethumb_client_file_set().
+ * @param key value set with ethumb_client_file_set() or @c NULL.
+ * @param thumb_path where thumbnail was stored, either set with
+ *        ethumb_client_thumb_path_set() or automatically calculated
+ *        using parameters.
+ * @param thumb_key key inside thumb_path where thumbnail was stored or @c NULL.
+ * @param success @c EINA_TRUE if generated or @c EINA_FALSE on errors.
+ */
+typedef void (*Ethumb_Client_Generate_Cb)(void *data, Ethumb_Client *client, int id, const char *file, const char *key, const char *thumb_path, const char *thumb_key, Eina_Bool success);
+
+/**
+ * @brief report results of ethumb_client_thumb_exists().
+ *
+ * @param client handle of the current connection to server.
+ * @param exists EINA_TRUE if the thumbnail exists.
+ * @param data extra context given to ethumb_client_thumb_exists().
+ *
+ * During the execution of the callback the state of the @p client is
+ * temporarily realy restored to what it was when the call to
+ * ethumb_client_thumb_exists() was done.
+ */
+typedef void (*Ethumb_Client_Thumb_Exists_Cb)(void *data, Ethumb_Client *client, Ethumb_Exists *thread, Eina_Bool exists);
+
+/**
+ * @brief reports results of ethumb_client_generate_cancel()
+ *
+ * @param data extra context given to ethumb_client_generate_cancel()
+ * @param client handle of the current connection to server.
+ */
+typedef void (*Ethumb_Client_Generate_Cancel_Cb)(void *data, Eina_Bool success);
+
+EAPI int ethumb_client_init(void);
+EAPI int ethumb_client_shutdown(void);
+
+EAPI Ethumb_Client *ethumb_client_connect(Ethumb_Client_Connect_Cb connect_cb, const void *data, Eina_Free_Cb free_data);
+EAPI void ethumb_client_disconnect(Ethumb_Client *client);
+EAPI void ethumb_client_on_server_die_callback_set(Ethumb_Client *client, Ethumb_Client_Die_Cb server_die_cb, const void *data, Eina_Free_Cb free_data);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup Ethumb_Client_Setup Ethumb Client Fine Tune Setup
+ *
+ * How to fine tune thumbnail generation, setting size, aspect, orientation,
+ * frames, quality and so on.
+ *
+ * @{
+ */
+
+EAPI void ethumb_client_fdo_set(Ethumb_Client *client, Ethumb_Thumb_FDO_Size s);
+EAPI void ethumb_client_size_set(Ethumb_Client *client, int tw, int th);
+EAPI void ethumb_client_size_get(const Ethumb_Client *client, int *tw, int *th);
+EAPI void ethumb_client_format_set(Ethumb_Client *client, Ethumb_Thumb_Format f);
+EAPI Ethumb_Thumb_Format ethumb_client_format_get(const Ethumb_Client *client);
+EAPI void ethumb_client_aspect_set(Ethumb_Client *client, Ethumb_Thumb_Aspect a);
+EAPI Ethumb_Thumb_Aspect ethumb_client_aspect_get(const Ethumb_Client *client);
+EAPI void ethumb_client_orientation_set(Ethumb_Client *client, Ethumb_Thumb_Orientation o);
+EAPI Ethumb_Thumb_Orientation ethumb_client_orientation_get(const Ethumb_Client *client);
+EAPI void ethumb_client_crop_align_set(Ethumb_Client *client, float x, float y);
+EAPI void ethumb_client_crop_align_get(const Ethumb_Client *client, float *x, float *y);
+EAPI void ethumb_client_quality_set(Ethumb_Client *client, int quality);
+EAPI int ethumb_client_quality_get(const Ethumb_Client *client);
+EAPI void ethumb_client_compress_set(Ethumb_Client *client, int compress);
+EAPI int ethumb_client_compress_get(const Ethumb_Client *client);
+EAPI Eina_Bool ethumb_client_frame_set(Ethumb_Client *client, const char *file, const char *group, const char *swallow);
+EAPI void ethumb_client_dir_path_set(Ethumb_Client *client, const char *path);
+EAPI const char * ethumb_client_dir_path_get(const Ethumb_Client *client);
+EAPI void ethumb_client_category_set(Ethumb_Client *client, const char *category);
+EAPI const char * ethumb_client_category_get(const Ethumb_Client *client);
+EAPI void ethumb_client_video_time_set(Ethumb_Client *client, float time);
+EAPI void ethumb_client_video_start_set(Ethumb_Client *client, float start);
+EAPI void ethumb_client_video_interval_set(Ethumb_Client *client, float interval);
+EAPI void ethumb_client_video_ntimes_set(Ethumb_Client *client, unsigned int ntimes);
+EAPI void ethumb_client_video_fps_set(Ethumb_Client *client, unsigned int fps);
+EAPI void ethumb_client_document_page_set(Ethumb_Client *client, unsigned int page);
+
+EAPI void ethumb_client_ethumb_setup(Ethumb_Client *client);
+
+EAPI void ethumb_client_thumb_path_set(Ethumb_Client *client, const char *path, const char *key);
+EAPI void ethumb_client_thumb_path_get(Ethumb_Client *client, const char **path, const char **key);
+/**
+ * @}
+ */
+
+/**
+ * @addtogroup Ethumb_Client_Basics Ethumb Client Basics
+ * @{
+ */
+EAPI Eina_Bool ethumb_client_file_set(Ethumb_Client *client, const char *path, const char *key);
+EAPI void ethumb_client_file_get(Ethumb_Client *client, const char **path, const char **key);
+EAPI void ethumb_client_file_free(Ethumb_Client *client);
+
+EAPI Ethumb_Exists *ethumb_client_thumb_exists(Ethumb_Client *client, Ethumb_Client_Thumb_Exists_Cb exists_cb, const void *data);
+EAPI void ethumb_client_thumb_exists_cancel(Ethumb_Exists *exists);
+EAPI Eina_Bool ethumb_client_thumb_exists_check(Ethumb_Exists *exists);
+EAPI int  ethumb_client_generate(Ethumb_Client *client, Ethumb_Client_Generate_Cb generated_cb, const void *data, Eina_Free_Cb free_data);
+EAPI void ethumb_client_generate_cancel(Ethumb_Client *client, int id, Ethumb_Client_Generate_Cancel_Cb cancel_cb, const void *data, Eina_Free_Cb free_data);
+EAPI void ethumb_client_generate_cancel_all(Ethumb_Client *client);
+
+typedef void (*Ethumb_Client_Async_Done_Cb)(Ethumb_Client *ethumbd, const char *thumb_path, const char *thumb_key, void *data);
+typedef void (*Ethumb_Client_Async_Error_Cb)(Ethumb_Client *ethumbd, void *data);
+
+typedef struct _Ethumb_Client_Async Ethumb_Client_Async;
+
+EAPI Ethumb_Client_Async *ethumb_client_thumb_async_get(Ethumb_Client *client,
+                                                        Ethumb_Client_Async_Done_Cb done,
+                                                        Ethumb_Client_Async_Error_Cb error,
+                                                        const void *data);
+EAPI void ethumb_client_thumb_async_cancel(Ethumb_Client *client, Ethumb_Client_Async *request);
+  /**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __ETHUMB_CLIENT_H__ */
diff --git a/src/lib/ethumb/client/ethumb_client.c b/src/lib/ethumb/client/ethumb_client.c
new file mode 100644
index 0000000000..7b9836625f
--- /dev/null
+++ b/src/lib/ethumb/client/ethumb_client.c
@@ -0,0 +1,2251 @@
+/**
+ * @file
+ *
+ * This is the client-server thumbnail library, see @ref
+ * tutorial_ethumb_client.
+ *
+ * Copyright (C) 2009 by ProFUSION embedded systems
+ *
+ * This library 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.
+ *
+ * This library 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 library;
+ * if not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Rafael Antognolli <antognolli@profusion.mobi>
+ * @author Gustavo Sverzut Barbieri <barbieri@profusion.mobi>
+ */
+
+/**
+ * @page tutorial_ethumb_client Client-Server Thumbnailing Tutorial
+ *
+ * @section tutorial_ethumb_client_intro Introduction
+ *
+ * Ethumb provides both in process and client-server generation
+ * methods. The advantage of the client-server method is that current
+ * process will not do the heavy operations that may block, stopping
+ * animations and other user interactions. Instead the client library
+ * will configure a local #Ethumb instance and mirrors/controls a
+ * remote process using DBus. The simple operations like most setters
+ * and getters as well as checking for thumbnail existence
+ * (ethumb_client_thumb_exists()) is done locally, while expensive
+ * (ethumb_client_generate()) are done on server and then reported
+ * back to application when it is finished (both success or failure).
+ *
+ * @section tutorial_ethumb_client_connect Connecting to Server
+ *
+ * TODO
+ *
+ * @section tutorial_ethumb_client_generate Requesting Thumbnail Generation
+ *
+ * TODO
+ *
+ * @section tutorial_ethumb_client_setup Setup Extra Thumbnail Parameters
+ *
+ * TODO
+ *
+ * @section tutorial_ethumb_client_server_died Handle Server Disconnection
+ *
+ * TODO
+ */
+
+/**
+ * @cond LOCAL
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <stdbool.h>
+
+#include <Eina.h>
+#include <eina_safety_checks.h>
+#include <EDBus.h>
+#include <Ethumb.h>
+#include <Ecore.h>
+
+#include "Ethumb_Client.h"
+
+#ifndef PATH_MAX
+#define PATH_MAX 4096
+#endif
+
+#define MAX_ID   2000000
+
+static int _log_dom = -1;
+#define DBG(...)      EINA_LOG_DOM_DBG(_log_dom, __VA_ARGS__)
+#define INF(...)      EINA_LOG_DOM_INFO(_log_dom, __VA_ARGS__)
+#define WRN(...)      EINA_LOG_DOM_WARN(_log_dom, __VA_ARGS__)
+#define ERR(...)      EINA_LOG_DOM_ERR(_log_dom, __VA_ARGS__)
+#define CRITICAL(...) EINA_LOG_DOM_CRIT(_log_dom, __VA_ARGS__)
+
+struct _Ethumb_Client
+{
+   Ethumb                *ethumb;
+   int                    id_count;
+   Ethumb                *old_ethumb_conf;
+   EDBus_Connection      *conn;
+   struct
+   {
+      Ethumb_Client_Connect_Cb cb;
+      void                    *data;
+      Eina_Free_Cb             free_data;
+   } connect;
+   Eina_List             *pending_add;
+   Eina_List             *pending_remove;
+   Eina_List             *pending_gen;
+   struct
+   {
+      Ethumb_Client_Die_Cb cb;
+      void                *data;
+      Eina_Free_Cb         free_data;
+   } die;
+   EDBus_Proxy           *proxy;
+   EINA_REFCOUNT;
+   Eina_Bool              connected : 1;
+   Eina_Bool              server_started : 1;
+};
+
+struct _ethumb_pending_add
+{
+   int32_t                   id;
+   const char               *file;
+   const char               *key;
+   const char               *thumb;
+   const char               *thumb_key;
+   Ethumb_Client_Generate_Cb generated_cb;
+   void                     *data;
+   Eina_Free_Cb              free_data;
+   EDBus_Pending            *pending_call;
+   Ethumb_Client            *client;
+};
+
+struct _ethumb_pending_remove
+{
+   int32_t                          id;
+   Ethumb_Client_Generate_Cancel_Cb cancel_cb;
+   void                            *data;
+   Eina_Free_Cb                     free_data;
+   Ethumb_Client                   *client;
+};
+
+struct _ethumb_pending_gen
+{
+   int32_t                   id;
+   const char               *file;
+   const char               *key;
+   const char               *thumb;
+   const char               *thumb_key;
+   Ethumb_Client_Generate_Cb generated_cb;
+   void                     *data;
+   Eina_Free_Cb              free_data;
+};
+
+typedef struct _Ethumb_Async_Exists Ethumb_Async_Exists;
+
+struct _Ethumb_Async_Exists
+{
+   const char   *path;
+
+   Ethumb       *dup; /* We will work on that one to prevent race and lock */
+
+   Eina_List    *callbacks;
+   Ecore_Thread *thread;
+};
+
+struct _Ethumb_Exists
+{
+   Ethumb_Async_Exists          *parent;
+   Ethumb_Client                *client;
+   Ethumb                       *dup; /* We don't want to loose parameters so keep them around */
+
+   Ethumb_Client_Thumb_Exists_Cb exists_cb;
+   const void                   *data;
+};
+
+static const char _ethumb_dbus_bus_name[] = "org.enlightenment.Ethumb";
+static const char _ethumb_dbus_interface[] = "org.enlightenment.Ethumb";
+static const char _ethumb_dbus_objects_interface[] = "org.enlightenment.Ethumb.objects";
+static const char _ethumb_dbus_path[] = "/org/enlightenment/Ethumb";
+
+static int _initcount = 0;
+static Eina_Hash *_exists_request = NULL;
+
+static void _ethumb_client_generated_cb(void *data, const EDBus_Message *msg);
+static void _ethumb_client_call_new(Ethumb_Client *client);
+static void _ethumb_client_name_owner_changed(void *context, const char *bus, const char *old_id, const char *new_id);
+
+static void
+_ethumb_client_free(Ethumb_Client *client)
+{
+   void *data;
+   EDBus_Object *obj;
+
+   if (!client->connected)
+     goto end_connection;
+
+   EINA_LIST_FREE(client->pending_add, data)
+     {
+        struct _ethumb_pending_add *pending = data;
+        edbus_pending_cancel(pending->pending_call);
+     }
+
+   EINA_LIST_FREE(client->pending_gen, data)
+     {
+        struct _ethumb_pending_gen *pending = data;
+        eina_stringshare_del(pending->file);
+        eina_stringshare_del(pending->key);
+        eina_stringshare_del(pending->thumb);
+        eina_stringshare_del(pending->thumb_key);
+        if (pending->free_data)
+          pending->free_data(pending->data);
+        free(pending);
+     }
+
+   EINA_LIST_FREE(client->pending_remove, data)
+     {
+        struct _ethumb_pending_remove *pending = data;
+        if (pending->free_data)
+          pending->free_data(pending->data);
+        free(pending);
+     }
+
+end_connection:
+   if (client->old_ethumb_conf)
+     ethumb_free(client->old_ethumb_conf);
+
+   ethumb_free(client->ethumb);
+
+   edbus_name_owner_changed_callback_del(client->conn, _ethumb_dbus_bus_name,
+                                         _ethumb_client_name_owner_changed,
+                                         client);
+   obj = edbus_proxy_object_get(client->proxy);
+   edbus_proxy_unref(client->proxy);
+   edbus_object_unref(obj);
+   edbus_connection_unref(client->conn);
+
+   if (client->connect.free_data)
+     client->connect.free_data(client->connect.data);
+   if (client->die.free_data)
+     client->die.free_data(client->die.data);
+
+   free(client);
+}
+
+static void
+_ethumb_async_delete(void *data)
+{
+   Ethumb_Async_Exists *async = data;
+
+   EINA_SAFETY_ON_FALSE_RETURN(async->callbacks == NULL);
+   EINA_SAFETY_ON_FALSE_RETURN(async->thread == NULL);
+
+   ethumb_free(async->dup);
+   eina_stringshare_del(async->path);
+
+   free(async);
+}
+
+static void
+_ethumb_client_name_owner_changed(void *context, const char *bus EINA_UNUSED, const char *old_id, const char *new_id)
+{
+   Ethumb_Client *client = context;
+   DBG("NameOwnerChanged from=[%s] to=[%s]", old_id, new_id);
+   if (new_id[0])
+     {
+        if (client->connected)
+          return;
+
+        client->connected = EINA_TRUE;
+        _ethumb_client_call_new(client);
+        return;
+     }
+   ERR("server exit!!!");
+   client->connected = EINA_FALSE;
+   if (client->die.cb)
+     {
+        client->die.cb(client->die.data, client);
+        client->die.cb = NULL;
+     }
+   if (client->die.free_data)
+     {
+        client->die.free_data(client->die.data);
+        client->die.free_data = NULL;
+        client->die.data = NULL;
+     }
+}
+
+static void
+_ethumb_client_report_connect(Ethumb_Client *client, Eina_Bool success)
+{
+   if (!client->connect.cb)
+     {
+        ERR("already called?!");
+        return;
+     }
+
+   client->connect.cb(client->connect.data, client, success);
+   if (client->connect.free_data)
+     {
+        client->connect.free_data(client->connect.data);
+        client->connect.free_data = NULL;
+     }
+   client->connect.cb = NULL;
+   client->connect.data = NULL;
+}
+
+static void
+_ethumb_client_new_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending EINA_UNUSED)
+{
+   const char *errname, *errmsg;
+   const char *opath;
+   Ethumb_Client *client = data;
+   EDBus_Object *obj;
+
+   if (edbus_message_error_get(msg, &errname, &errmsg))
+     {
+        ERR("Error: %s %s", errname, errmsg);
+        return;
+     }
+
+   if (!edbus_message_arguments_get(msg, "o", &opath))
+     {
+        ERR("Error: could not get entry contents");
+        _ethumb_client_report_connect(client, 0);
+        return;
+     }
+
+   obj = edbus_object_get(client->conn, _ethumb_dbus_bus_name, opath);
+   client->proxy = edbus_proxy_get(obj, _ethumb_dbus_objects_interface);
+   edbus_proxy_signal_handler_add(client->proxy, "generated",
+                                  _ethumb_client_generated_cb, client);
+   _ethumb_client_report_connect(client, 1);
+}
+
+static void
+_ethumb_client_call_new(Ethumb_Client *client)
+{
+   EDBus_Message *msg;
+   msg = edbus_message_method_call_new(_ethumb_dbus_bus_name,
+                                       _ethumb_dbus_path,
+                                       _ethumb_dbus_interface, "new");
+   edbus_connection_send(client->conn, msg, _ethumb_client_new_cb, client, -1);
+   edbus_message_unref(msg);
+}
+
+static void
+_ethumb_client_exists_heavy(void *data, Ecore_Thread *thread EINA_UNUSED)
+{
+   Ethumb_Async_Exists *async = data;
+
+   ethumb_thumb_hash(async->dup);
+}
+
+static void
+_ethumb_client_exists_end(void *data, Ecore_Thread *thread EINA_UNUSED)
+{
+   Ethumb_Async_Exists *async = data;
+   Ethumb_Exists *cb;
+
+   EINA_LIST_FREE(async->callbacks, cb)
+     {
+        Ethumb *tmp;
+
+        ethumb_thumb_hash_copy(cb->dup, async->dup);
+        tmp = cb->client->ethumb;
+        cb->client->ethumb = cb->dup;
+
+        cb->exists_cb((void *)cb->data,
+                      cb->client, cb,
+                      ethumb_exists(cb->client->ethumb));
+
+        cb->client->ethumb = tmp;
+        EINA_REFCOUNT_UNREF(cb->client)
+        _ethumb_client_free(cb->client);
+        ethumb_free(cb->dup);
+        free(cb);
+     }
+
+   async->thread = NULL;
+
+   eina_hash_del(_exists_request, async->path, async);
+}
+
+/**
+ * @endcond
+ */
+
+/**
+ * @brief Initialize the Ethumb_Client library.
+ *
+ * @return 1 or greater on success, 0 on error.
+ *
+ * This function sets up all the Ethumb_Client module dependencies. It
+ * returns 0 on failure (that is, when one of the dependency fails to
+ * initialize), otherwise it returns the number of times it has
+ * already been called.
+ *
+ * When Ethumb_Client is not used anymore, call
+ * ethumb_client_shutdown() to shut down the Ethumb_Client library.
+ *
+ * @see ethumb_client_shutdown()
+ * @see ethumb_client_connect()
+ * @see @ref tutorial_ethumb_client
+ */
+EAPI int
+ethumb_client_init(void)
+{
+   if (_initcount)
+     return ++_initcount;
+
+   if (!eina_init())
+     {
+        fprintf(stderr, "ERROR: Could not initialize log module.\n");
+        return 0;
+     }
+   _log_dom = eina_log_domain_register("ethumb_client", EINA_COLOR_YELLOW);
+   if (_log_dom < 0)
+     {
+        EINA_LOG_ERR("Could not register log domain: ethumb_client");
+        eina_shutdown();
+        return 0;
+     }
+
+   ethumb_init();
+   edbus_init();
+
+   _exists_request = eina_hash_stringshared_new(_ethumb_async_delete);
+
+   return ++_initcount;
+}
+
+/**
+ * @brief Shut down the Ethumb_Client library.
+ *
+ * @return 0 when everything is shut down, 1 or greater if there are
+ *         other users of the Ethumb_Client library pending shutdown.
+ *
+ * This function shuts down the Ethumb_Client library. It returns 0
+ * when it has been called the same number of times than
+ * ethumb_client_init(). In that case it shut down all the
+ * Ethumb_Client modules dependencies.
+ *
+ * Once this function succeeds (that is, @c 0 is returned), you must
+ * not call any of the Eina function anymore. You must call
+ * ethumb_client_init() again to use the Ethumb_Client functions
+ * again.
+ */
+EAPI int
+ethumb_client_shutdown(void)
+{
+   _initcount--;
+   if (_initcount > 0)
+     return _initcount;
+
+   /* should find a non racy solution to closing all pending exists request */
+   eina_hash_free(_exists_request);
+   _exists_request = NULL;
+
+   edbus_shutdown();
+   ethumb_shutdown();
+   eina_log_domain_unregister(_log_dom);
+   _log_dom = -1;
+   eina_shutdown();
+   return _initcount;
+}
+
+/**
+ * Connects to Ethumb server and return the client instance.
+ *
+ * This is the "constructor" of Ethumb_Client, where everything
+ * starts.
+ *
+ * If server was down, it is tried to start it using DBus activation,
+ * then the connection is retried.
+ *
+ * This call is asynchronous and will not block, instead it will be in
+ * "not connected" state until @a connect_cb is called with either
+ * success or failure. On failure, then no methods should be
+ * called. On success you're now able to setup and then ask generation
+ * of thumbnails.
+ *
+ * Usually you should listen for server death/disconenction with
+ * ethumb_client_on_server_die_callback_set().
+ *
+ * @param connect_cb function to call to report connection success or
+ *        failure. Do not call any other ethumb_client method until
+ *        this function returns. The first received parameter is the
+ *        given argument @a data. Must @b not be @c NULL. This
+ *        function will not be called if user explicitly calls
+ *        ethumb_client_disconnect().
+ * @param data context to give back to @a connect_cb. May be @c NULL.
+ * @param free_data function used to release @a data resources, if
+ *        any. May be @c NULL. If this function exists, it will be
+ *        called immediately after @a connect_cb is called or if user
+ *        explicitly calls ethumb_client_disconnect() before such
+ *        (that is, don't rely on @a data after @a connect_cb was
+ *        called!)
+ *
+ * @return client instance or NULL if failed. If @a connect_cb is
+ *         missing it returns @c NULL. If it fail for other
+ *         conditions, @c NULL is also returned and @a connect_cb is
+ *         called with @c success=EINA_FALSE. The client instance is
+ *         not ready to be used until @a connect_cb is called.
+ */
+EAPI Ethumb_Client *
+ethumb_client_connect(Ethumb_Client_Connect_Cb connect_cb, const void *data, Eina_Free_Cb free_data)
+{
+   Ethumb_Client *eclient;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(connect_cb, NULL);
+
+   eclient = calloc(1, sizeof(*eclient));
+   if (!eclient)
+     {
+        ERR("could not allocate Ethumb_Client structure.");
+        goto err;
+     }
+
+   eclient->old_ethumb_conf = NULL;
+   eclient->connect.cb = connect_cb;
+   eclient->connect.data = (void *)data;
+   eclient->connect.free_data = free_data;
+
+   eclient->ethumb = ethumb_new();
+   if (!eclient->ethumb)
+     {
+        ERR("could not create ethumb handler.");
+        goto ethumb_new_err;
+     }
+
+   eclient->conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SESSION);
+   if (!eclient->conn)
+     {
+        ERR("could not connect to session bus.");
+        goto connection_err;
+     }
+
+   edbus_name_start(eclient->conn, _ethumb_dbus_bus_name, 0, NULL, NULL);
+   edbus_name_owner_changed_callback_add(eclient->conn, _ethumb_dbus_bus_name,
+                                         _ethumb_client_name_owner_changed,
+                                         eclient, EINA_TRUE);
+   EINA_REFCOUNT_INIT(eclient);
+
+   return eclient;
+
+connection_err:
+   ethumb_free(eclient->ethumb);
+ethumb_new_err:
+   free(eclient);
+err:
+   connect_cb((void *)data, NULL, EINA_FALSE);
+   if (free_data)
+     free_data((void *)data);
+   return NULL;
+}
+
+/**
+ * Disconnect the client, releasing all client resources.
+ *
+ * This is the destructor of Ethumb_Client, after it's disconnected
+ * the client handle is now gone and should not be used.
+ *
+ * @param client client instance to be destroyed. Must @b not be @c
+ *        NULL.
+ */
+EAPI void
+ethumb_client_disconnect(Ethumb_Client *client)
+{
+   EINA_SAFETY_ON_NULL_RETURN(client);
+
+   EINA_REFCOUNT_UNREF(client)
+   _ethumb_client_free(client);
+}
+
+/**
+ * Sets the callback to report server died.
+ *
+ * When server dies there is nothing you can do, just release
+ * resources with ethumb_client_disconnect() and probably try to
+ * connect again.
+ *
+ * Usually you should set this callback and handle this case, it does
+ * happen!
+ *
+ * @param client the client instance to monitor. Must @b not be @c
+ *        NULL.
+ * @param server_die_cb function to call back when server dies. The
+ *        first parameter will be the argument @a data. May be @c
+ *        NULL.
+ * @param data context to give back to @a server_die_cb. May be @c
+ *        NULL.
+ * @param free_data used to release @a data resources after @a
+ *        server_die_cb is called or user calls
+ *        ethumb_client_disconnect().
+ */
+EAPI void
+ethumb_client_on_server_die_callback_set(Ethumb_Client *client, Ethumb_Client_Die_Cb server_die_cb, const void *data, Eina_Free_Cb free_data)
+{
+   EINA_SAFETY_ON_NULL_RETURN(client);
+
+   if (client->die.free_data)
+     client->die.free_data(client->die.data);
+
+   client->die.cb = server_die_cb;
+   client->die.data = (void *)data;
+   client->die.free_data = free_data;
+}
+
+/**
+ * @cond LOCAL
+ */
+
+static void
+_ethumb_client_ethumb_setup_cb(void *data EINA_UNUSED, const EDBus_Message *msg, EDBus_Pending *pending EINA_UNUSED)
+{
+   const char *errname, *errmsg;
+   Eina_Bool result = 0;
+
+   if (edbus_message_error_get(msg, &errname, &errmsg))
+     {
+        ERR("Error: %s %s\n", errname, errmsg);
+        return;
+     }
+
+   if (!edbus_message_arguments_get(msg, "b", &result))
+     {
+        ERR("Error getting arguments");
+        return;
+     }
+   EINA_SAFETY_ON_FALSE_RETURN(result);
+}
+
+static const char *
+_ethumb_client_dbus_get_bytearray(EDBus_Message_Iter *array)
+{
+   int length;
+   const char *result;
+
+   if (edbus_message_iter_fixed_array_get(array, 'y', &result, &length))
+     return eina_stringshare_add_length(result, length);
+   else
+     {
+        ERR("Not byte array. Signature: %s",
+            edbus_message_iter_signature_get(array));
+        return NULL;
+     }
+}
+
+static void
+_ethumb_client_dbus_append_bytearray(EDBus_Message_Iter *parent, const char *string)
+{
+   int i, size;
+   EDBus_Message_Iter *array;
+
+   if (!string)
+     string = "";
+
+   array = edbus_message_iter_container_new(parent, 'a', "y");
+   size = strlen(string) + 1;
+   for (i = 0; i < size; i++)
+     edbus_message_iter_basic_append(array, 'y', string[i]);
+   edbus_message_iter_container_close(parent, array);
+}
+
+/**
+ * @endcond
+ */
+
+static EDBus_Message_Iter *
+_setup_iterator_open(EDBus_Message_Iter *array, EDBus_Message_Iter **entry, const char *key, const char *type)
+{
+   EDBus_Message_Iter *variant, *_struct;
+   edbus_message_iter_arguments_append(array, "{sv}", &_struct);
+   edbus_message_iter_basic_append(_struct, 's', key);
+   variant = edbus_message_iter_container_new(_struct, 'v', type);
+
+   *entry = _struct;
+   return variant;
+}
+
+static void
+_setup_iterator_close(EDBus_Message_Iter *array, EDBus_Message_Iter *entry, EDBus_Message_Iter *variant)
+{
+   edbus_message_iter_container_close(entry, variant);
+   edbus_message_iter_container_close(array, entry);
+}
+
+/**
+ * Send setup to server.
+ *
+ * This method is called automatically by ethumb_client_generate() if
+ * any property was changed. No need to call it manually.
+ *
+ * @param client client instance. Must @b not be @c NULL and client
+ *        must be connected (after connected_cb is called).
+ */
+EAPI void
+ethumb_client_ethumb_setup(Ethumb_Client *client)
+{
+   EDBus_Message *msg;
+   EDBus_Message_Iter *array, *main_iter;
+   EDBus_Message_Iter *entry, *variant;
+   EDBus_Message_Iter *sub_struct;
+   Ethumb *e = client->ethumb;
+   int tw, th, format, aspect, orientation, quality, compress;
+   float cx, cy;
+   const char *theme_file, *group, *swallow;
+   const char *directory, *category;
+   double video_time, video_start, video_interval;
+   unsigned int video_ntimes, video_fps, document_page;
+
+   EINA_SAFETY_ON_NULL_RETURN(client);
+   EINA_SAFETY_ON_FALSE_RETURN(client->connected);
+
+   msg = edbus_proxy_method_call_new(client->proxy, "ethumb_setup");
+   main_iter = edbus_message_iter_get(msg);
+   edbus_message_iter_arguments_append(main_iter, "a{sv}", &array);
+
+   /* starting array elements */
+   variant = _setup_iterator_open(array, &entry, "size", "(ii)");
+   edbus_message_iter_arguments_append(variant, "(ii)", &sub_struct);
+   ethumb_thumb_size_get(e, &tw, &th);
+   edbus_message_iter_arguments_append(sub_struct, "ii", tw, th);
+   edbus_message_iter_container_close(variant, sub_struct);
+   _setup_iterator_close(array, entry, variant);
+
+   variant = _setup_iterator_open(array, &entry, "format", "i");
+   format = ethumb_thumb_format_get(e);
+   edbus_message_iter_arguments_append(variant, "i", format);
+   _setup_iterator_close(array, entry, variant);
+
+   variant = _setup_iterator_open(array, &entry, "aspect", "i");
+   aspect = ethumb_thumb_aspect_get(e);
+   edbus_message_iter_arguments_append(variant, "i", aspect);
+   _setup_iterator_close(array, entry, variant);
+
+   variant = _setup_iterator_open(array, &entry, "orientation", "i");
+   orientation = ethumb_thumb_orientation_get(e);
+   edbus_message_iter_arguments_append(variant, "i", orientation);
+   _setup_iterator_close(array, entry, variant);
+
+   variant = _setup_iterator_open(array, &entry, "crop", "(dd)");
+   edbus_message_iter_arguments_append(variant, "(dd)", &sub_struct);
+   ethumb_thumb_crop_align_get(e, &cx, &cy);
+   edbus_message_iter_arguments_append(sub_struct, "dd", (double)cx, (double)cy);
+   edbus_message_iter_container_close(variant, sub_struct);
+   _setup_iterator_close(array, entry, variant);
+
+   variant = _setup_iterator_open(array, &entry, "quality", "i");
+   quality = ethumb_thumb_quality_get(e);
+   edbus_message_iter_arguments_append(variant, "i", quality);
+   _setup_iterator_close(array, entry, variant);
+
+   variant = _setup_iterator_open(array, &entry, "compress", "i");
+   compress = ethumb_thumb_quality_get(e);
+   edbus_message_iter_arguments_append(variant, "i", compress);
+   _setup_iterator_close(array, entry, variant);
+
+   variant = _setup_iterator_open(array, &entry, "frame", "(ayayay)");
+   edbus_message_iter_arguments_append(variant, "(ayayay)", &sub_struct);
+   ethumb_frame_get(e, &theme_file, &group, &swallow);
+   _ethumb_client_dbus_append_bytearray(sub_struct, theme_file);
+   _ethumb_client_dbus_append_bytearray(sub_struct, group);
+   _ethumb_client_dbus_append_bytearray(sub_struct, swallow);
+   edbus_message_iter_container_close(variant, sub_struct);
+   _setup_iterator_close(array, entry, variant);
+
+   variant = _setup_iterator_open(array, &entry, "directory", "ay");
+   directory = ethumb_thumb_dir_path_get(e);
+   _ethumb_client_dbus_append_bytearray(variant, directory);
+   _setup_iterator_close(array, entry, variant);
+
+   variant = _setup_iterator_open(array, &entry, "category", "ay");
+   category = ethumb_thumb_category_get(e);
+   _ethumb_client_dbus_append_bytearray(variant, category);
+   _setup_iterator_close(array, entry, variant);
+
+   variant = _setup_iterator_open(array, &entry, "video_time", "d");
+   video_time = ethumb_video_time_get(e);
+   edbus_message_iter_arguments_append(variant, "d", video_time);
+   _setup_iterator_close(array, entry, variant);
+
+   variant = _setup_iterator_open(array, &entry, "video_start", "d");
+   video_start = ethumb_video_start_get(e);
+   edbus_message_iter_arguments_append(variant, "d", video_start);
+   _setup_iterator_close(array, entry, variant);
+
+   variant = _setup_iterator_open(array, &entry, "video_interval", "d");
+   video_interval = ethumb_video_interval_get(e);
+   edbus_message_iter_arguments_append(variant, "d", video_interval);
+   _setup_iterator_close(array, entry, variant);
+
+   variant = _setup_iterator_open(array, &entry, "video_ntimes", "u");
+   video_ntimes = ethumb_video_ntimes_get(e);
+   edbus_message_iter_arguments_append(variant, "u", video_ntimes);
+   _setup_iterator_close(array, entry, variant);
+
+   variant = _setup_iterator_open(array, &entry, "video_fps", "u");
+   video_fps = ethumb_video_fps_get(e);
+   edbus_message_iter_arguments_append(variant, "u", video_fps);
+   _setup_iterator_close(array, entry, variant);
+
+   variant = _setup_iterator_open(array, &entry, "document_page", "u");
+   document_page = ethumb_document_page_get(e);
+   edbus_message_iter_arguments_append(variant, "u", document_page);
+   _setup_iterator_close(array, entry, variant);
+
+   edbus_message_iter_container_close(main_iter, array);
+
+   edbus_proxy_send(client->proxy, msg, _ethumb_client_ethumb_setup_cb,
+                    client, -1);
+   edbus_message_unref(msg);
+}
+
+/**
+ * @cond LOCAL
+ */
+static void
+_ethumb_client_generated_cb(void *data, const EDBus_Message *msg)
+{
+   int id = -1;
+   Ethumb_Client *client = data;
+   EDBus_Message_Iter *thumb_iter;
+   EDBus_Message_Iter *thumb_key_iter;
+   Eina_Bool success;
+   int found;
+   struct _ethumb_pending_gen *pending;
+   Eina_List *l;
+
+   if (!edbus_message_arguments_get(msg, "iayayb", &id, &thumb_iter,
+                                    &thumb_key_iter, &success))
+     {
+        ERR("Error getting data from signal.");
+        return;
+     }
+
+   found = 0;
+   l = client->pending_gen;
+   while (l)
+     {
+        pending = l->data;
+        if (pending->id == id)
+          {
+             found = 1;
+             break;
+          }
+        l = l->next;
+     }
+
+   if (found)
+     {
+        const char *thumb = _ethumb_client_dbus_get_bytearray(thumb_iter);
+        const char *thumb_key = _ethumb_client_dbus_get_bytearray(thumb_key_iter);
+
+        client->pending_gen = eina_list_remove_list(client->pending_gen, l);
+        if (pending->generated_cb)
+          pending->generated_cb(pending->data, client, id,
+                                pending->file, pending->key,
+                                thumb, thumb_key,
+                                success);
+        if (pending->free_data)
+          pending->free_data(pending->data);
+        eina_stringshare_del(pending->file);
+        eina_stringshare_del(pending->key);
+        eina_stringshare_del(pending->thumb);
+        eina_stringshare_del(pending->thumb_key);
+        eina_stringshare_del(thumb);
+        eina_stringshare_del(thumb_key);
+        free(pending);
+     }
+}
+
+static void
+_ethumb_client_queue_add_cb(void *data, const EDBus_Message *msg, EDBus_Pending *edbus_pending EINA_UNUSED)
+{
+   const char *errname, *errmsg;
+   int32_t id;
+   struct _ethumb_pending_add *pending = data;
+   struct _ethumb_pending_gen *generating;
+   Ethumb_Client *client = pending->client;
+
+   client->pending_add = eina_list_remove(client->pending_add, pending);
+
+   //in case of error or when user cancel
+   if (edbus_message_error_get(msg, &errname, &errmsg))
+     {
+        ERR("Error: %s %s\n", errname, errmsg);
+        goto end;
+     }
+
+   if (!edbus_message_arguments_get(msg, "i", &id))
+     {
+        ERR("Error getting arguments.");
+        goto end;
+     }
+
+   generating = calloc(1, sizeof(*generating));
+   generating->id = id;
+   generating->file = pending->file;
+   generating->key = pending->key;
+   generating->thumb = pending->thumb;
+   generating->thumb_key = pending->thumb_key;
+   generating->generated_cb = pending->generated_cb;
+   generating->data = pending->data;
+   generating->free_data = pending->free_data;
+   client->pending_gen = eina_list_append(client->pending_gen, generating);
+
+   free(pending);
+   return;
+
+end:
+   eina_stringshare_del(pending->file);
+   eina_stringshare_del(pending->key);
+   eina_stringshare_del(pending->thumb);
+   eina_stringshare_del(pending->thumb_key);
+   if (pending->free_data)
+     pending->free_data(pending->data);
+   free(pending);
+}
+
+static int
+_ethumb_client_queue_add(Ethumb_Client *client, const char *file, const char *key, const char *thumb, const char *thumb_key, Ethumb_Client_Generate_Cb generated_cb, const void *data, Eina_Free_Cb free_data)
+{
+   EDBus_Message *msg;
+   EDBus_Message_Iter *main_itr;
+   struct _ethumb_pending_add *pending;
+
+   pending = calloc(1, sizeof(*pending));
+   pending->id = client->id_count;
+   pending->file = eina_stringshare_add(file);
+   pending->key = eina_stringshare_add(key);
+   pending->thumb = eina_stringshare_add(thumb);
+   pending->thumb_key = eina_stringshare_add(thumb_key);
+   pending->generated_cb = generated_cb;
+   pending->data = (void *)data;
+   pending->free_data = free_data;
+   pending->client = client;
+
+   client->id_count = (client->id_count + 1) % MAX_ID;
+
+   msg = edbus_proxy_method_call_new(client->proxy, "queue_add");
+   main_itr = edbus_message_iter_get(msg);
+   edbus_message_iter_basic_append(main_itr, 'i', pending->id);
+   _ethumb_client_dbus_append_bytearray(main_itr, file);
+   _ethumb_client_dbus_append_bytearray(main_itr, key);
+   _ethumb_client_dbus_append_bytearray(main_itr, thumb);
+   _ethumb_client_dbus_append_bytearray(main_itr, thumb_key);
+
+   pending->pending_call = edbus_proxy_send(client->proxy, msg,
+                                            _ethumb_client_queue_add_cb,
+                                            pending, -1);
+   client->pending_add = eina_list_append(client->pending_add, pending);
+   edbus_message_unref(msg);
+
+   return pending->id;
+}
+
+static void
+_ethumb_client_queue_remove_cb(void *data, const EDBus_Message *msg, EDBus_Pending *edbus_pending EINA_UNUSED)
+{
+   Eina_Bool success;
+   struct _ethumb_pending_remove *pending = data;
+   Ethumb_Client *client = pending->client;
+   const char *errname, *errmsg;
+
+   client->pending_remove = eina_list_remove(client->pending_remove, pending);
+
+   if (edbus_message_error_get(msg, &errname, &errmsg))
+     {
+        ERR("Error: %s %s\n", errname, errmsg);
+        goto end;
+     }
+
+   if (edbus_message_arguments_get(msg, "b", &success))
+     {
+        ERR("Error getting arguments.");
+        goto end;
+     }
+
+end:
+   if (pending->cancel_cb)
+     pending->cancel_cb(pending->data, success);
+   if (pending->free_data)
+     pending->free_data(pending->data);
+   free(pending);
+}
+
+/**
+ * @endcond
+ */
+
+/**
+ * Ask server to cancel generation of thumbnail.
+ *
+ * @param client client instance. Must @b not be @c NULL and client
+ *        must be connected (after connected_cb is called).
+ * @param id valid id returned by ethumb_client_generate()
+ * @param cancel_cb function to report cancellation results.
+ * @param data context argument to give back to @a cancel_cb. May be
+ *        @c NULL.
+ * @param data context to give back to @a cancel_cb. May be @c
+ *        NULL.
+ * @param free_data used to release @a data resources after @a
+ *        cancel_cb is called or user calls
+ *        ethumb_client_disconnect().
+ */
+EAPI void
+ethumb_client_generate_cancel(Ethumb_Client *client, int id, Ethumb_Client_Generate_Cancel_Cb cancel_cb, const void *data, Eina_Free_Cb free_data)
+{
+   struct _ethumb_pending_remove *pending;
+   Eina_List *l;
+   int found;
+   int32_t id32 = id;
+   EINA_SAFETY_ON_NULL_RETURN(client);
+   EINA_SAFETY_ON_FALSE_RETURN(id >= 0);
+
+   pending = calloc(1, sizeof(*pending));
+   pending->id = id;
+   pending->cancel_cb = cancel_cb;
+   pending->data = (void *)data;
+   pending->free_data = free_data;
+   pending->client = client;
+
+   edbus_proxy_call(client->proxy, "queue_remove",
+                    _ethumb_client_queue_remove_cb, pending, -1, "i", pending->id);
+   client->pending_remove = eina_list_append(client->pending_remove, pending);
+
+   /*
+    * Check if answer was not received yet cancel it
+    * callback of queue_add will be called with a error msg
+    * and data will be freed
+    */
+   found = 0;
+   l = client->pending_add;
+   while (l)
+     {
+        struct _ethumb_pending_add *pending_add = l->data;
+        if (pending_add->id != id32)
+          {
+             l = l->next;
+             continue;
+          }
+        edbus_pending_cancel(pending_add->pending_call);
+        found = 1;
+        break;
+     }
+
+   if (found)
+     return;
+
+   //if already received answer only free memory
+   l = client->pending_gen;
+   while (l)
+     {
+        struct _ethumb_pending_gen *pending_gen = l->data;
+        if (pending_gen->id != id32)
+          {
+             l = l->next;
+             continue;
+          }
+        client->pending_gen = eina_list_remove_list(client->pending_gen, l);
+        eina_stringshare_del(pending_gen->file);
+        eina_stringshare_del(pending_gen->key);
+        eina_stringshare_del(pending_gen->thumb);
+        eina_stringshare_del(pending_gen->thumb_key);
+        if (pending_gen->free_data)
+          pending_gen->free_data(pending_gen->data);
+        free(pending_gen);
+        break;
+     }
+}
+
+/**
+ * @endcond
+ */
+
+/**
+ * Ask server to cancel generation of all thumbnails.
+ *
+ * @param client client instance. Must @b not be @c NULL and client
+ *        must be connected (after connected_cb is called).
+ *
+ * @see ethumb_client_generate_cancel()
+ */
+EAPI void
+ethumb_client_generate_cancel_all(Ethumb_Client *client)
+{
+   void *data;
+   EINA_SAFETY_ON_NULL_RETURN(client);
+
+   EINA_LIST_FREE(client->pending_add, data)
+     {
+        struct _ethumb_pending_add *pending = data;
+        edbus_pending_cancel(pending->pending_call);
+     }
+
+   EINA_LIST_FREE(client->pending_gen, data)
+     {
+        struct _ethumb_pending_gen *pending = data;
+        eina_stringshare_del(pending->file);
+        eina_stringshare_del(pending->key);
+        eina_stringshare_del(pending->thumb);
+        eina_stringshare_del(pending->thumb_key);
+        if (pending->free_data)
+          pending->free_data(pending->data);
+        free(pending);
+     }
+
+   edbus_proxy_call(client->proxy, "queue_clear", NULL, NULL, -1, "");
+}
+
+/**
+ * Configure future requests to use FreeDesktop.Org preset.
+ *
+ * This is a preset to provide freedesktop.org (fdo) standard
+ * compliant thumbnails. That is, files are stored as JPEG under
+ * ~/.thumbnails/SIZE, with size being either normal (128x128) or
+ * large (256x256).
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ * @param s size identifier, either #ETHUMB_THUMB_NORMAL (0) or
+ *        #ETHUMB_THUMB_LARGE (1).
+ *
+ * @see ethumb_client_size_set()
+ * @see ethumb_client_aspect_set()
+ * @see ethumb_client_crop_align_set()
+ * @see ethumb_client_category_set()
+ * @see ethumb_client_dir_path_set()
+ */
+EAPI void
+ethumb_client_fdo_set(Ethumb_Client *client, Ethumb_Thumb_FDO_Size s)
+{
+   EINA_SAFETY_ON_NULL_RETURN(client);
+
+   if (!client->old_ethumb_conf)
+     client->old_ethumb_conf = ethumb_dup(client->ethumb);
+   ethumb_thumb_fdo_set(client->ethumb, s);
+}
+
+/**
+ * Configure future request to use custom size.
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ * @param tw width, default is 128.
+ * @param th height, default is 128.
+ */
+EAPI void
+ethumb_client_size_set(Ethumb_Client *client, int tw, int th)
+{
+   EINA_SAFETY_ON_NULL_RETURN(client);
+
+   if (!client->old_ethumb_conf)
+     client->old_ethumb_conf = ethumb_dup(client->ethumb);
+   ethumb_thumb_size_set(client->ethumb, tw, th);
+}
+
+/**
+ * Retrieve future request to use custom size.
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ * @param tw where to return width. May be @c NULL.
+ * @param th where to return height. May be @c NULL.
+ */
+EAPI void
+ethumb_client_size_get(const Ethumb_Client *client, int *tw, int *th)
+{
+   if (tw) *tw = 0;
+   if (th) *th = 0;
+   EINA_SAFETY_ON_NULL_RETURN(client);
+
+   ethumb_thumb_size_get(client->ethumb, tw, th);
+}
+
+/**
+ * Configure format to use for future requests.
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ * @param f format identifier to use, either #ETHUMB_THUMB_FDO (0),
+ *        #ETHUMB_THUMB_JPEG (1) or #ETHUMB_THUMB_EET (2). Default is FDO.
+ */
+EAPI void
+ethumb_client_format_set(Ethumb_Client *client, Ethumb_Thumb_Format f)
+{
+   EINA_SAFETY_ON_NULL_RETURN(client);
+
+   if (!client->old_ethumb_conf)
+     client->old_ethumb_conf = ethumb_dup(client->ethumb);
+   ethumb_thumb_format_set(client->ethumb, f);
+}
+
+/**
+ * Retrieve format to use for future requests.
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ *
+ * @return format identifier to use, either #ETHUMB_THUMB_FDO (0),
+ *         #ETHUMB_THUMB_JPEG (1) or #ETHUMB_THUMB_EET (2).
+ */
+EAPI Ethumb_Thumb_Format
+ethumb_client_format_get(const Ethumb_Client *client)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(client, 0);
+
+   return ethumb_thumb_format_get(client->ethumb);
+}
+
+/**
+ * Configure aspect mode to use.
+ *
+ * If aspect is kept (#ETHUMB_THUMB_KEEP_ASPECT), then image will be
+ * rescaled so the largest dimension is not bigger than it's specified
+ * size (see ethumb_client_size_get()) and the other dimension is
+ * resized in the same proportion. Example: size is 256x256, image is
+ * 1000x500, resulting thumbnail is 256x128.
+ *
+ * If aspect is ignored (#ETHUMB_THUMB_IGNORE_ASPECT), then image will
+ * be distorted to match required thumbnail size. Example: size is
+ * 256x256, image is 1000x500, resulting thumbnail is 256x256.
+ *
+ * If crop is required (#ETHUMB_THUMB_CROP), then image will be
+ * cropped so the smallest dimension is not bigger than its specified
+ * size (see ethumb_client_size_get()) and the other dimension will
+ * overflow, not being visible in the final image. How it will
+ * overflow is speficied by ethumb_client_crop_align_set()
+ * alignment. Example: size is 256x256, image is 1000x500, crop
+ * alignment is 0.5, 0.5, resulting thumbnail is 256x256 with 250
+ * pixels from left and 250 pixels from right being lost, that is just
+ * the 500x500 central pixels of image will be considered for scaling.
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ * @param a aspect mode identifier, either #ETHUMB_THUMB_KEEP_ASPECT (0),
+ *        #ETHUMB_THUMB_IGNORE_ASPECT (1) or #ETHUMB_THUMB_CROP (2).
+ */
+EAPI void
+ethumb_client_aspect_set(Ethumb_Client *client, Ethumb_Thumb_Aspect a)
+{
+   EINA_SAFETY_ON_NULL_RETURN(client);
+
+   if (!client->old_ethumb_conf)
+     client->old_ethumb_conf = ethumb_dup(client->ethumb);
+   ethumb_thumb_aspect_set(client->ethumb, a);
+}
+
+/**
+ * Get current aspect in use for requests.
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ *
+ * @return aspect in use for future requests.
+ */
+EAPI Ethumb_Thumb_Aspect
+ethumb_client_aspect_get(const Ethumb_Client *client)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(client, 0);
+
+   return ethumb_thumb_aspect_get(client->ethumb);
+}
+
+/**
+ * Configure orientation to use for future requests.
+ *
+ * Default value is #ETHUMB_THUMB_ORIENT_ORIGINAL: metadata from the file
+ * will be used to orient pixel data.
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ * @param o format identifier to use, either #ETHUMB_THUMB_ORIENT_NONE (0),
+ *        #ETHUMB_THUMB_ROTATE_90_CW (1), #ETHUMB_THUMB_ROTATE_180 (2),
+ *        #ETHUMB_THUMB_ROTATE_90_CCW (3), #ETHUMB_THUMB_FLIP_HORIZONTAL (4),
+ *        #ETHUMB_THUMB_FLIP_VERTICAL (5), #ETHUMB_THUMB_FLIP_TRANSPOSE (6),
+ *        #ETHUMB_THUMB_FLIP_TRANSVERSE (7) or #ETHUMB_THUMB_ORIENT_ORIGINAL
+ *        (8). Default is ORIGINAL.
+ */
+EAPI void
+ethumb_client_orientation_set(Ethumb_Client *client, Ethumb_Thumb_Orientation o)
+{
+   EINA_SAFETY_ON_NULL_RETURN(client);
+
+   if (!client->old_ethumb_conf)
+     client->old_ethumb_conf = ethumb_dup(client->ethumb);
+   ethumb_thumb_orientation_set(client->ethumb, o);
+}
+
+/**
+ * Get current orientation in use for requests.
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ *
+ * @return orientation in use for future requests.
+ */
+EAPI Ethumb_Thumb_Orientation
+ethumb_client_orientation_get(const Ethumb_Client *client)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(client, 0);
+
+   return ethumb_thumb_orientation_get(client->ethumb);
+}
+
+/**
+ * Configure crop alignment in use for future requests.
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ * @param x horizontal alignment. 0.0 means left side will be visible
+ *        or right side is being lost. 1.0 means right side will be
+ *        visible or left side is being lost. 0.5 means just center is
+ *        visible, both sides will be lost.  Default is 0.5.
+ * @param y vertical alignment. 0.0 is top visible, 1.0 is bottom
+ *        visible, 0.5 is center visible. Default is 0.5
+ */
+EAPI void
+ethumb_client_crop_align_set(Ethumb_Client *client, float x, float y)
+{
+   EINA_SAFETY_ON_NULL_RETURN(client);
+
+   if (!client->old_ethumb_conf)
+     client->old_ethumb_conf = ethumb_dup(client->ethumb);
+   ethumb_thumb_crop_align_set(client->ethumb, x, y);
+}
+
+/**
+ * Get current crop alignment in use for requests.
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ * @param x where to return horizontal alignment. May be @c NULL.
+ * @param y where to return vertical alignment. May be @c NULL.
+ */
+EAPI void
+ethumb_client_crop_align_get(const Ethumb_Client *client, float *x, float *y)
+{
+   if (x) *x = 0.0;
+   if (y) *y = 0.0;
+   EINA_SAFETY_ON_NULL_RETURN(client);
+
+   ethumb_thumb_crop_align_get(client->ethumb, x, y);
+}
+
+/**
+ * Configure quality to be used in thumbnails.
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ * @param quality value from 0 to 100, default is 80. The effect
+ *        depends on the format being used, PNG will not use it.
+ */
+EAPI void
+ethumb_client_quality_set(Ethumb_Client *client, int quality)
+{
+   EINA_SAFETY_ON_NULL_RETURN(client);
+
+   ethumb_thumb_quality_set(client->ethumb, quality);
+}
+
+/**
+ * Get quality to be used in thumbnails.
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ *
+ * @return quality value from 0 to 100, default is 80. The effect
+ *         depends on the format being used, PNG will not use it.
+ */
+EAPI int
+ethumb_client_quality_get(const Ethumb_Client *client)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(client, 0);
+
+   return ethumb_thumb_quality_get(client->ethumb);
+}
+
+/**
+ * Configure compression level used in requests.
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ * @param compress value from 0 to 9, default is 9. The effect
+ *        depends on the format being used, JPEG will not use it.
+ */
+EAPI void
+ethumb_client_compress_set(Ethumb_Client *client, int compress)
+{
+   EINA_SAFETY_ON_NULL_RETURN(client);
+
+   ethumb_thumb_compress_set(client->ethumb, compress);
+}
+
+/**
+ * Get compression level used in requests.
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ *
+ * @return compress value from 0 to 9, default is 9. The effect
+ *         depends on the format being used, JPEG will not use it.
+ */
+EAPI int
+ethumb_client_compress_get(const Ethumb_Client *client)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(client, 0);
+
+   return ethumb_thumb_compress_get(client->ethumb);
+}
+
+/**
+ * Set frame to apply to future thumbnails.
+ *
+ * This will create an edje object that will have image swallowed
+ * in. This can be used to simulate Polaroid or wood frames in the
+ * generated image. Remeber it is bad to modify the original contents
+ * of thumbnails, but sometimes it's useful to have it composited and
+ * avoid runtime overhead.
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ * @param file file path to edje.
+ * @param group group inside edje to use.
+ * @param swallow name of swallow part.
+ *
+ * @return @c EINA_TRUE on success, @c EINA_FALSE on failure.
+ */
+EAPI Eina_Bool
+ethumb_client_frame_set(Ethumb_Client *client, const char *file, const char *group, const char *swallow)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(client, 0);
+
+   if (!client->old_ethumb_conf)
+     client->old_ethumb_conf = ethumb_dup(client->ethumb);
+   return ethumb_frame_set(client->ethumb, file, group, swallow);
+}
+
+/**
+ * Configure where to store thumbnails in future requests.
+ *
+ * This value will be used to generate thumbnail paths, that is, it
+ * will be used when ethumb_client_thumb_path_set() was not called
+ * after last ethumb_client_file_set().
+ *
+ * Note that this is the base, a category is added to this path as a
+ * sub directory. This is not the final directory where files are
+ * stored, the thumbnail system will account @b category as well, see
+ * ethumb_client_category_set().
+ *
+ * As other options, this value will only be applied to future
+ * requests.
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ * @param path base directory where to store thumbnails. Default is
+ *        ~/.thumbnails
+ *
+ * @see ethumb_client_category_set()
+ */
+EAPI void
+ethumb_client_dir_path_set(Ethumb_Client *client, const char *path)
+{
+   EINA_SAFETY_ON_NULL_RETURN(client);
+
+   if (!client->old_ethumb_conf)
+     client->old_ethumb_conf = ethumb_dup(client->ethumb);
+   ethumb_thumb_dir_path_set(client->ethumb, path);
+}
+
+/**
+ * Get base directory path where to store thumbnails.
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ *
+ * @return pointer to internal string with current path. This string
+ *         should not be modified or freed.
+ *
+ * @see ethumb_client_dir_path_set()
+ */
+EAPI const char *
+ethumb_client_dir_path_get(const Ethumb_Client *client)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(client, NULL);
+
+   return ethumb_thumb_dir_path_get(client->ethumb);
+}
+
+/**
+ * Category directory to store thumbnails.
+ *
+ * This value will be used to generate thumbnail paths, that is, it
+ * will be used when ethumb_client_thumb_path_set() was not called
+ * after last ethumb_client_file_set().
+ *
+ * This is a sub-directory inside base directory
+ * (ethumb_client_dir_path_set()) that creates a namespace to avoid
+ * different options resulting in the same file.
+ *
+ * As other options, this value will only be applied to future
+ * requests.
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ * @param category category sub directory to store thumbnail. Default
+ *        is either "normal" or "large" for FDO compliant thumbnails
+ *        or WIDTHxHEIGHT-ASPECT[-FRAMED]-FORMAT. It can be a string
+ *        or @c NULL to use auto generated names.
+ *
+ * @see ethumb_client_dir_path_set()
+ */
+EAPI void
+ethumb_client_category_set(Ethumb_Client *client, const char *category)
+{
+   EINA_SAFETY_ON_NULL_RETURN(client);
+
+   if (!client->old_ethumb_conf)
+     client->old_ethumb_conf = ethumb_dup(client->ethumb);
+   ethumb_thumb_category_set(client->ethumb, category);
+}
+
+/**
+ * Get category sub-directory  where to store thumbnails.
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ *
+ * @return pointer to internal string with current path. This string
+ *         should not be modified or freed.
+ *
+ * @see ethumb_client_category_set()
+ */
+EAPI const char *
+ethumb_client_category_get(const Ethumb_Client *client)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(client, NULL);
+
+   return ethumb_thumb_category_get(client->ethumb);
+}
+
+/**
+ * Set the video time (duration) in seconds.
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ * @param t duration (in seconds). Defaults to 3 seconds.
+ */
+EAPI void
+ethumb_client_video_time_set(Ethumb_Client *client, float t)
+{
+   EINA_SAFETY_ON_NULL_RETURN(client);
+
+   if (!client->old_ethumb_conf)
+     client->old_ethumb_conf = ethumb_dup(client->ethumb);
+   ethumb_video_time_set(client->ethumb, t);
+}
+
+/**
+ * Set initial video position to start thumbnailing, in percentage.
+ *
+ * This is useful to avoid thumbnailing the company/producer logo or
+ * movie opening.
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ * @param start initial video positon to thumbnail, in percentage (0.0
+ *        to 1.0, inclusive). Defaults to 10% (0.1).
+ */
+EAPI void
+ethumb_client_video_start_set(Ethumb_Client *client, float start)
+{
+   EINA_SAFETY_ON_NULL_RETURN(client);
+   EINA_SAFETY_ON_FALSE_RETURN(start >= 0.0);
+   EINA_SAFETY_ON_FALSE_RETURN(start <= 1.0);
+
+   if (!client->old_ethumb_conf)
+     client->old_ethumb_conf = ethumb_dup(client->ethumb);
+   ethumb_video_start_set(client->ethumb, start);
+}
+
+/**
+ * Set the video frame interval, in seconds.
+ *
+ * This is useful for animated thumbnail and will define skip time
+ * before going to the next frame. Note that video backends might not
+ * be able to precisely skip that amount as it will depend on various
+ * factors, including video encoding.
+ *
+ * Although this seems similar to ethumb_client_video_fps_set(), this
+ * one is the time that will be used to seek. The math is simple, for
+ * each new frame the video position will be set to:
+ * ((video_length * start_time) + (interval * current_frame_number)).
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ * @param interval time between frames, in seconds. Defaults to 0.05
+ *        seconds.
+ */
+EAPI void
+ethumb_client_video_interval_set(Ethumb_Client *client, float interval)
+{
+   EINA_SAFETY_ON_NULL_RETURN(client);
+
+   if (!client->old_ethumb_conf)
+     client->old_ethumb_conf = ethumb_dup(client->ethumb);
+   ethumb_video_interval_set(client->ethumb, interval);
+}
+
+/**
+ * Set the number of frames to thumbnail.
+ *
+ * This is useful for animated thumbnail and will define how many
+ * frames the generated file will have.
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ * @param ntimes number of times, must be greater than zero.
+ *        Defaults to 3.
+ */
+EAPI void
+ethumb_client_video_ntimes_set(Ethumb_Client *client, unsigned int ntimes)
+{
+   EINA_SAFETY_ON_NULL_RETURN(client);
+   EINA_SAFETY_ON_FALSE_RETURN(ntimes > 0);
+
+   if (!client->old_ethumb_conf)
+     client->old_ethumb_conf = ethumb_dup(client->ethumb);
+   ethumb_video_ntimes_set(client->ethumb, ntimes);
+}
+
+/**
+ * Set the number of frames per second to thumbnail the video.
+ *
+ * This configures the number of times per seconds the thumbnail will
+ * use to create thumbnails.
+ *
+ * Although this is similar to ethumb_client_video_interval_set(), it
+ * is the delay used between calling functions thata generates frames,
+ * while the other is the time used to skip inside the video.
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ * @param fps number of frames per second to thumbnail. Must be greater
+ *        than zero. Defaults to 10.
+ */
+EAPI void
+ethumb_client_video_fps_set(Ethumb_Client *client, unsigned int fps)
+{
+   EINA_SAFETY_ON_NULL_RETURN(client);
+   EINA_SAFETY_ON_FALSE_RETURN(fps > 0);
+
+   if (!client->old_ethumb_conf)
+     client->old_ethumb_conf = ethumb_dup(client->ethumb);
+   ethumb_video_fps_set(client->ethumb, fps);
+}
+
+/**
+ * Set the page number to thumbnail in paged documents.
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ * @param page page number, defaults to 0 (first).
+ */
+EAPI void
+ethumb_client_document_page_set(Ethumb_Client *client, unsigned int page)
+{
+   EINA_SAFETY_ON_NULL_RETURN(client);
+
+   if (!client->old_ethumb_conf)
+     client->old_ethumb_conf = ethumb_dup(client->ethumb);
+   ethumb_document_page_set(client->ethumb, page);
+}
+
+/**
+ * Set source file to be thumbnailed.
+ *
+ * Calling this function has the side effect of resetting values set
+ * with ethumb_client_thumb_path_set() or auto-generated with
+ * ethumb_client_thumb_exists().
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ * @param path the filesystem path to use. May be @c NULL.
+ * @param key the extra argument/key inside @a path to read image
+ *        from. This is only used for formats that allow multiple
+ *        resources in one file, like EET or Edje (group name).
+ *
+ * @return @c EINA_TRUE on success, @c EINA_FALSE on failure.
+ */
+EAPI Eina_Bool
+ethumb_client_file_set(Ethumb_Client *client, const char *path, const char *key)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(client, 0);
+
+   return ethumb_file_set(client->ethumb, path, key);
+}
+
+/**
+ * Get values set with ethumb_client_file_get()
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ * @param path where to return configured path. May be @c NULL.  If
+ *        not @c NULL, then it will be a pointer to a stringshared
+ *        instance, but @b no references are added (do it with
+ *        eina_stringshare_ref())!
+ * @param key where to return configured key. May be @c NULL.If not @c
+ *        NULL, then it will be a pointer to a stringshared instance,
+ *        but @b no references are added (do it with
+ *        eina_stringshare_ref())!
+ */
+EAPI void
+ethumb_client_file_get(Ethumb_Client *client, const char **path, const char **key)
+{
+   if (path) *path = NULL;
+   if (key) *key = NULL;
+   EINA_SAFETY_ON_NULL_RETURN(client);
+
+   ethumb_file_get(client->ethumb, path, key);
+}
+
+/**
+ * Reset previously set file to @c NULL.
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ */
+EAPI void
+ethumb_client_file_free(Ethumb_Client *client)
+{
+   EINA_SAFETY_ON_NULL_RETURN(client);
+
+   ethumb_file_free(client->ethumb);
+}
+
+/**
+ * Set a defined path and key to store the thumbnail.
+ *
+ * If not explicitly given, the thumbnail path will be auto-generated
+ * by ethumb_client_thumb_exists() or server using configured
+ * parameters like size, aspect and category.
+ *
+ * Set these to @c NULL to forget previously given values. After
+ * ethumb_client_file_set() these values will be reset to @c NULL.
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ * @param path force generated thumbnail to the exact given path. If
+ *        @c NULL, then reverts back to auto-generation.
+ * @param key force generated thumbnail to the exact given key. If
+ *        @c NULL, then reverts back to auto-generation.
+ */
+EAPI void
+ethumb_client_thumb_path_set(Ethumb_Client *client, const char *path, const char *key)
+{
+   EINA_SAFETY_ON_NULL_RETURN(client);
+
+   ethumb_thumb_path_set(client->ethumb, path, key);
+}
+
+/**
+ * Get the configured thumbnail path.
+ *
+ * This returns the value set with ethumb_client_thumb_path_set() or
+ * auto-generated by ethumb_client_thumb_exists() if it was not set.
+ *
+ * @param client the client instance to use. Must @b not be @c
+ *        NULL. May be pending connected (can be called before @c
+ *        connected_cb)
+ * @param path where to return configured path. May be @c NULL.  If
+ *        there was no path configured with
+ *        ethumb_client_thumb_path_set() and
+ *        ethumb_client_thumb_exists() was not called, then it will
+ *        probably return @c NULL. If not @c NULL, then it will be a
+ *        pointer to a stringshared instance, but @b no references are
+ *        added (do it with eina_stringshare_ref())!
+ * @param key where to return configured key. May be @c NULL.  If
+ *        there was no key configured with
+ *        ethumb_client_thumb_key_set() and
+ *        ethumb_client_thumb_exists() was not called, then it will
+ *        probably return @c NULL. If not @c NULL, then it will be a
+ *        pointer to a stringshared instance, but @b no references are
+ *        added (do it with eina_stringshare_ref())!
+ */
+EAPI void
+ethumb_client_thumb_path_get(Ethumb_Client *client, const char **path, const char **key)
+{
+   if (path) *path = NULL;
+   if (key) *key = NULL;
+   EINA_SAFETY_ON_NULL_RETURN(client);
+
+   ethumb_thumb_path_get(client->ethumb, path, key);
+}
+
+/**
+ * Checks whenever file already exists (locally!)
+ *
+ * This will check locally (not calling server) if thumbnail already
+ * exists or not, also calculating the thumbnail path. See
+ * ethumb_client_thumb_path_get(). Path must be configured with
+ * ethumb_client_file_set() before using it and the last set file will
+ * be used!
+ *
+ * @param client client instance. Must @b not be @c NULL and client
+ *        must be configured with ethumb_client_file_set().
+ *
+ * @return @c EINA_TRUE if it exists, @c EINA_FALSE otherwise.
+ */
+EAPI Ethumb_Exists *
+ethumb_client_thumb_exists(Ethumb_Client *client, Ethumb_Client_Thumb_Exists_Cb exists_cb, const void *data)
+{
+   const char *path = NULL;
+   Ethumb_Async_Exists *async = NULL;
+   Ethumb_Exists *cb = NULL;
+   Ecore_Thread *t;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(client, NULL);
+
+   ethumb_file_get(client->ethumb, &path, NULL);
+   if (!path) goto on_error;
+
+   async = eina_hash_find(_exists_request, path);
+   if (!async)
+     {
+        async = malloc(sizeof (Ethumb_Async_Exists));
+        if (!async) goto on_error;
+
+        async->path = eina_stringshare_ref(path);
+        async->callbacks = NULL;
+        async->dup = ethumb_dup(client->ethumb);
+
+        if (!async->dup) goto on_error;
+
+        cb = malloc(sizeof (Ethumb_Exists));
+        if (!cb) goto on_error;
+
+        EINA_REFCOUNT_REF(client);
+        cb->client = client;
+        cb->dup = ethumb_dup(client->ethumb);
+        cb->exists_cb = exists_cb;
+        cb->data = data;
+        cb->parent = async;
+
+        async->callbacks = eina_list_append(async->callbacks, cb);
+
+        /* spawn a thread here */
+        t = ecore_thread_run(_ethumb_client_exists_heavy,
+                             _ethumb_client_exists_end,
+                             _ethumb_client_exists_end,
+                             async);
+        if (!t) return NULL;
+        async->thread = t;
+
+        eina_hash_direct_add(_exists_request, async->path, async);
+
+        return cb;
+     }
+
+   cb = malloc(sizeof (Ethumb_Exists));
+   if (!cb)
+     {
+        async = NULL;
+        goto on_error;
+     }
+
+   EINA_REFCOUNT_REF(client);
+   cb->client = client;
+   cb->dup = ethumb_dup(client->ethumb);
+   cb->exists_cb = exists_cb;
+   cb->data = data;
+   cb->parent = async;
+
+   async->callbacks = eina_list_append(async->callbacks, cb);
+
+   return cb;
+
+on_error:
+   exists_cb((void *)data, client, NULL, EINA_FALSE);
+
+   if (async)
+     {
+        eina_stringshare_del(async->path);
+        if (async->dup) ethumb_free(async->dup);
+        free(async);
+     }
+   return NULL;
+}
+
+/**
+ * Cancel an ongoing exists request.
+ *
+ * @param exists the request to cancel.
+ */
+EAPI void
+ethumb_client_thumb_exists_cancel(Ethumb_Exists *exists)
+{
+   Ethumb_Async_Exists *async = exists->parent;
+
+   async->callbacks = eina_list_remove(async->callbacks, exists);
+   if (eina_list_count(async->callbacks) <= 0)
+     ecore_thread_cancel(async->thread);
+
+   ethumb_free(exists->dup);
+   EINA_REFCOUNT_UNREF(exists->client)
+   _ethumb_client_free(exists->client);
+   free(exists);
+}
+
+/**
+ * Check if an exists request was cancelled.
+ *
+ * @param exists the request to check.
+ * @result return EINA_TRUE if the request was cancelled.
+ */
+EAPI Eina_Bool
+ethumb_client_thumb_exists_check(Ethumb_Exists *exists)
+{
+   Ethumb_Async_Exists *async = exists->parent;
+
+   if (!async) return EINA_TRUE;
+
+   if (async->callbacks) return EINA_FALSE;
+
+   return ecore_thread_check(async->thread);
+}
+
+/**
+ * Ask server to generate thumbnail.
+ *
+ * This process is asynchronous and will report back from main loop
+ * using @a generated_cb. One can cancel this request by calling
+ * ethumb_client_generate_cancel() or
+ * ethumb_client_generate_cancel_all(), but not that request might be
+ * processed by server already and no generated files will be removed
+ * if that is the case.
+ *
+ * This will not check if file already exists, this should be done by
+ * explicitly calling ethumb_client_thumb_exists(). That is, this
+ * function will override any existing thumbnail.
+ *
+ * @param client client instance. Must @b not be @c NULL and client
+ *        must be connected (after connected_cb is called).
+ * @param generated_cb function to report generation results.
+ * @param data context argument to give back to @a generated_cb. May
+ *        be @c NULL.
+ * @param data context to give back to @a generate_cb. May be @c
+ *        NULL.
+ * @param free_data used to release @a data resources after @a
+ *        generated_cb is called or user calls
+ *        ethumb_client_disconnect().
+ *
+ * @return identifier or -1 on error. If -1 is returned (error) then
+ *         @a free_data is @b not called!
+ *
+ * @see ethumb_client_connect()
+ * @see ethumb_client_file_set()
+ * @see ethumb_client_thumb_exists()
+ * @see ethumb_client_generate_cancel()
+ * @see ethumb_client_generate_cancel_all()
+ */
+EAPI int
+ethumb_client_generate(Ethumb_Client *client, Ethumb_Client_Generate_Cb generated_cb, const void *data, Eina_Free_Cb free_data)
+{
+   const char *file, *key, *thumb, *thumb_key;
+   int id;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(client, -1);
+   EINA_SAFETY_ON_FALSE_RETURN_VAL(client->connected, -1);
+
+   ethumb_file_get(client->ethumb, &file, &key);
+   if (!file)
+     {
+        ERR("no file set.");
+        return -1;
+     }
+
+   ethumb_thumb_path_get(client->ethumb, &thumb, &thumb_key);
+
+   if (client->old_ethumb_conf &&
+       ethumb_cmp(client->old_ethumb_conf, client->ethumb))
+     {
+        ethumb_client_ethumb_setup(client);
+        ethumb_free(client->old_ethumb_conf);
+        client->old_ethumb_conf = NULL;
+     }
+   id = _ethumb_client_queue_add(client, file, key, thumb, thumb_key,
+                                 generated_cb, data, free_data);
+   return id;
+}
+
+struct _Ethumb_Client_Async
+{
+   Ethumb_Exists               *exists;
+   Ethumb_Client               *client;
+   Ethumb                      *dup;
+
+   Ethumb_Client_Async_Done_Cb  done;
+   Ethumb_Client_Async_Error_Cb error;
+   const void                  *data;
+
+   int                          id;
+};
+
+static Ecore_Idler *idler[2] = { NULL, NULL };
+static Eina_List *pending = NULL;
+static Eina_List *idle_tasks[2] = { NULL, NULL };
+
+static void
+_ethumb_client_async_free(Ethumb_Client_Async *async)
+{
+   EINA_REFCOUNT_UNREF(async->client)
+   _ethumb_client_free(async->client);
+   ethumb_free(async->dup);
+   free(async);
+}
+
+static void
+_ethumb_client_thumb_finish(void *data,
+                            Ethumb_Client *client, int id,
+                            const char *file EINA_UNUSED, const char *key EINA_UNUSED,
+                            const char *thumb_path, const char *thumb_key,
+                            Eina_Bool success)
+{
+   Ethumb_Client_Async *async = data;
+
+   EINA_SAFETY_ON_FALSE_RETURN(async->id == id);
+
+   if (success)
+     {
+        async->done(client, thumb_path, thumb_key, (void *)async->data);
+     }
+   else
+     {
+        async->error(client, (void *)async->data);
+     }
+
+   pending = eina_list_remove(pending, async);
+   _ethumb_client_async_free(async);
+}
+
+static Eina_Bool
+_ethumb_client_thumb_generate_idler(void *data EINA_UNUSED)
+{
+   Ethumb_Client_Async *async;
+   Eina_List *l1, *l2;
+
+   EINA_LIST_FOREACH_SAFE (idle_tasks[1], l1, l2, async)
+     {
+        Ethumb *tmp;
+
+        idle_tasks[1] = eina_list_remove_list(idle_tasks[1], l1);
+
+        tmp = async->client->ethumb;
+        async->client->ethumb = async->dup;
+
+        async->id = ethumb_client_generate(async->client, _ethumb_client_thumb_finish, async, NULL);
+        if (async->id == -1)
+          {
+             async->error(async->client, (void *)async->data);
+             async->client->ethumb = tmp;
+             _ethumb_client_async_free(async);
+          }
+        else
+          {
+             async->client->ethumb = tmp;
+          }
+
+        pending = eina_list_append(pending, async);
+
+        if (ecore_time_get() - ecore_loop_time_get() > ecore_animator_frametime_get() * 0.5)
+          return EINA_TRUE;
+     }
+
+   idler[1] = NULL;
+   return EINA_FALSE;
+}
+
+static void
+_ethumb_client_thumb_exists(void *data, Ethumb_Client *client, Ethumb_Exists *request, Eina_Bool exists)
+{
+   Ethumb_Client_Async *async = data;
+
+   if (request == NULL)
+     return;
+
+   EINA_SAFETY_ON_FALSE_RETURN(async->exists == request);
+
+   async->exists = NULL;
+   pending = eina_list_remove(pending, async);
+
+   if (exists)
+     {
+        const char *thumb_path;
+        const char *thumb_key;
+
+        ethumb_client_thumb_path_get(client, &thumb_path, &thumb_key);
+        async->done(client, thumb_path, thumb_key, (void *)async->data);
+        _ethumb_client_async_free(async);
+     }
+   else
+     {
+        idle_tasks[1] = eina_list_append(idle_tasks[1], async);
+
+        if (!idler[1])
+          idler[1] = ecore_idler_add(_ethumb_client_thumb_generate_idler, NULL);
+     }
+}
+
+static Eina_Bool
+_ethumb_client_thumb_exists_idler(void *data EINA_UNUSED)
+{
+   Ethumb_Client_Async *async;
+   Eina_List *l1, *l2;
+
+   EINA_LIST_FOREACH_SAFE (idle_tasks[0], l1, l2, async)
+     {
+        Ethumb *tmp;
+
+        idle_tasks[0] = eina_list_remove_list(idle_tasks[0], l1);
+
+        tmp = async->client->ethumb;
+        async->client->ethumb = async->dup;
+
+        async->exists = ethumb_client_thumb_exists(async->client, _ethumb_client_thumb_exists, async);
+        if (!async->exists)
+          {
+             async->error(async->client, (void *)async->data);
+             async->client->ethumb = tmp;
+             _ethumb_client_async_free(async);
+             continue;
+          }
+
+        async->client->ethumb = tmp;
+
+        pending = eina_list_append(pending, async);
+
+        if (ecore_time_get() - ecore_loop_time_get() > ecore_animator_frametime_get() * 0.5)
+          return EINA_TRUE;
+     }
+
+   idler[0] = NULL;
+   return EINA_FALSE;
+}
+
+EAPI Ethumb_Client_Async *
+ethumb_client_thumb_async_get(Ethumb_Client *client,
+                              Ethumb_Client_Async_Done_Cb done,
+                              Ethumb_Client_Async_Error_Cb error,
+                              const void *data)
+{
+   Ethumb_Client_Async *async;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(client, NULL);
+
+   async = malloc(sizeof (Ethumb_Client_Async));
+   if (!async)
+     {
+        error(client, (void *)data);
+        return NULL;
+     }
+
+   EINA_REFCOUNT_REF(client);
+   async->client = client;
+   async->dup = ethumb_dup(client->ethumb);
+   async->done = done;
+   async->error = error;
+   async->data = data;
+   async->exists = NULL;
+   async->id = -1;
+
+   idle_tasks[0] = eina_list_append(idle_tasks[0], async);
+
+   if (!idler[0])
+     idler[0] = ecore_idler_add(_ethumb_client_thumb_exists_idler, NULL);
+
+   return async;
+}
+
+EAPI void
+ethumb_client_thumb_async_cancel(Ethumb_Client *client, Ethumb_Client_Async *request)
+{
+   const char *path;
+
+   EINA_SAFETY_ON_NULL_RETURN(client);
+   EINA_SAFETY_ON_NULL_RETURN(request);
+
+   ethumb_file_get(request->dup, &path, NULL);
+
+   if (request->exists)
+     {
+        ethumb_client_thumb_exists_cancel(request->exists);
+        request->exists = NULL;
+
+        pending = eina_list_remove(pending, request);
+     }
+   else if (request->id != -1)
+     {
+        Ethumb *tmp = request->client->ethumb;
+        request->client->ethumb = request->dup;
+
+        ethumb_client_generate_cancel(request->client, request->id, NULL, NULL, NULL);
+
+        request->client->ethumb = tmp;
+
+        pending = eina_list_remove(pending, request);
+     }
+   else
+     {
+        idle_tasks[0] = eina_list_remove(idle_tasks[0], request);
+        idle_tasks[1] = eina_list_remove(idle_tasks[1], request);
+     }
+
+   _ethumb_client_async_free(request);
+}
diff --git a/src/lib/ethumb/ethumb.c b/src/lib/ethumb/ethumb.c
new file mode 100644
index 0000000000..65d3b97c84
--- /dev/null
+++ b/src/lib/ethumb/ethumb.c
@@ -0,0 +1,1863 @@
+/**
+ * @file
+ *
+ * Copyright (C) 2009 by ProFUSION embedded systems
+ *
+ * This library 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.
+ *
+ * This library 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 library;
+ * if not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Rafael Antognolli <antognolli@profusion.mobi>
+ */
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef STDC_HEADERS
+# include <stdlib.h>
+# include <stddef.h>
+#else
+# ifdef HAVE_STDLIB_H
+#  include <stdlib.h>
+# endif
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <dlfcn.h>
+#include <ctype.h>
+
+#ifdef HAVE_XATTR
+# include <sys/xattr.h>
+#endif
+
+#ifndef PATH_MAX
+# define PATH_MAX 4096
+#endif
+
+#ifdef HAVE_LIBEXIF
+  #include <libexif/exif-data.h>
+#endif
+
+#ifdef HAVE_EVIL
+# include <Evil.h>
+#endif
+
+#include <Eina.h>
+#include <eina_safety_checks.h>
+#include <Evas.h>
+#include <Ecore.h>
+#include <Ecore_Evas.h>
+#include <Ecore_File.h>
+#include <Edje.h>
+
+#include "Ethumb.h"
+#include "ethumb_private.h"
+#include "Ethumb_Plugin.h"
+#include "md5.h"
+
+static Ethumb_Version _version = { VMAJ, VMIN, VMIC, VREV };
+EAPI Ethumb_Version *ethumb_version = &_version;
+
+static int _log_dom = -1;
+#define DBG(...) EINA_LOG_DOM_DBG(_log_dom, __VA_ARGS__)
+#define INF(...) EINA_LOG_DOM_INFO(_log_dom, __VA_ARGS__)
+#define WRN(...) EINA_LOG_DOM_WARN(_log_dom, __VA_ARGS__)
+#define ERR(...) EINA_LOG_DOM_ERR(_log_dom, __VA_ARGS__)
+
+static int initcount = 0;
+static const char *_home_thumb_dir = NULL;
+static const char *_thumb_category_normal = NULL;
+static const char *_thumb_category_large = NULL;
+
+static const int THUMB_SIZE_NORMAL = 128;
+static const int THUMB_SIZE_LARGE = 256;
+
+static Eina_Hash *_plugins_ext = NULL;
+static Eina_Array *_plugins = NULL;
+static Eina_Prefix *_pfx = NULL;
+
+static Eina_Bool
+_ethumb_plugin_list_cb(Eina_Module *m, void *data EINA_UNUSED)
+{
+   const char *file;
+   const char **ext;
+   Ethumb_Plugin *plugin;
+   Ethumb_Plugin *(*plugin_get)(void);
+
+   file = eina_module_file_get(m);
+   if (!eina_module_load(m))
+     {
+        ERR("could not load module \"%s\": %s",
+            file, eina_error_msg_get(eina_error_get()));
+        return EINA_FALSE;
+     }
+
+   plugin_get = eina_module_symbol_get(m, "ethumb_plugin_get");
+   if (!plugin_get)
+     {
+        ERR("could not find ethumb_plugin_get() in module \"%s\": %s",
+            file, eina_error_msg_get(eina_error_get()));
+        eina_module_unload(m);
+        return EINA_FALSE;
+     }
+
+   plugin = plugin_get();
+   if (!plugin)
+     {
+        ERR("plugin \"%s\" failed to init.", file);
+        eina_module_unload(m);
+        return EINA_FALSE;
+     }
+
+   DBG("loaded plugin \"%s\" (%p) with extensions:", file, plugin);
+   for (ext = plugin->extensions; *ext; ext++)
+     {
+        DBG("   extension \"%s\"", *ext);
+        eina_hash_add(_plugins_ext, *ext, plugin);
+     }
+
+   return EINA_TRUE;
+}
+
+static void
+_ethumb_plugins_load(void)
+{
+   char buf[PATH_MAX];
+
+   _plugins_ext = eina_hash_string_small_new(NULL);
+   EINA_SAFETY_ON_NULL_RETURN(_plugins_ext);
+
+   snprintf(buf, sizeof(buf), "%s/ethumb/modules", eina_prefix_lib_get(_pfx));
+   _plugins = eina_module_list_get(_plugins, buf, 1,
+                                   &_ethumb_plugin_list_cb, NULL);
+}
+
+static void
+_ethumb_plugins_unload(void)
+{
+   eina_hash_free(_plugins_ext);
+   _plugins_ext = NULL;
+   eina_module_list_unload(_plugins);
+   eina_module_list_free(_plugins);
+   eina_array_free(_plugins);
+   _plugins = NULL;
+}
+
+EAPI int
+ethumb_init(void)
+{
+   const char *home;
+   char buf[PATH_MAX];
+
+   if (initcount)
+     return ++initcount;
+
+   if (!eina_init())
+     {
+        fprintf(stderr, "ERROR: Could not initialize eina.\n");
+        return 0;
+     }
+   _log_dom = eina_log_domain_register("ethumb", EINA_COLOR_GREEN);
+   if (_log_dom < 0)
+     {
+        EINA_LOG_ERR("Could not register log domain: ethumb");
+        goto error_log;
+     }
+
+   _pfx = eina_prefix_new(NULL, ethumb_init,
+                          "ETHUMB", "ethumb", "checkme",
+                          PACKAGE_BIN_DIR, PACKAGE_LIB_DIR,
+                          PACKAGE_DATA_DIR, PACKAGE_DATA_DIR);
+   if (!_pfx)
+     {
+        ERR("Could not get ethumb installation prefix.");
+        goto error_pfx;
+     }
+
+   evas_init();
+   ecore_init();
+   ecore_evas_init();
+   edje_init();
+
+   home = getenv("HOME");
+   snprintf(buf, sizeof(buf), "%s/.thumbnails", home);
+
+   _home_thumb_dir = eina_stringshare_add(buf);
+   _thumb_category_normal = eina_stringshare_add("normal");
+   _thumb_category_large = eina_stringshare_add("large");
+
+   _ethumb_plugins_load();
+   return ++initcount;
+
+ error_pfx:
+   eina_log_domain_unregister(_log_dom);
+   _log_dom = -1;
+
+ error_log:
+   eina_shutdown();
+   return 0;
+}
+
+EAPI int
+ethumb_shutdown(void)
+{
+   if (initcount <= 0)
+     {
+        EINA_LOG_ERR("Init count not greater than 0 in shutdown.");
+        return 0;
+     }
+   initcount--;
+   if (initcount == 0)
+     {
+        _ethumb_plugins_unload();
+        eina_stringshare_del(_home_thumb_dir);
+        eina_stringshare_del(_thumb_category_normal);
+        eina_stringshare_del(_thumb_category_large);
+        evas_shutdown();
+        ecore_shutdown();
+        ecore_evas_shutdown();
+        edje_shutdown();
+        eina_prefix_free(_pfx);
+        _pfx = NULL;
+        eina_log_domain_unregister(_log_dom);
+        _log_dom = -1;
+        eina_shutdown();
+     }
+
+   return initcount;
+}
+
+EAPI Ethumb *
+ethumb_new(void)
+{
+   Ethumb *ethumb;
+   Ecore_Evas *ee, *sub_ee;
+   Evas *e, *sub_e;
+   Evas_Object *o, *img;
+
+   ethumb = calloc(1, sizeof(Ethumb));
+   EINA_SAFETY_ON_NULL_RETURN_VAL(ethumb, NULL);
+
+   /* IF CHANGED, UPDATE DOCS in (Ethumb.c, Ethumb_Client.c, python...)!!! */
+   ethumb->tw = THUMB_SIZE_NORMAL;
+   ethumb->th = THUMB_SIZE_NORMAL;
+   ethumb->orientation = ETHUMB_THUMB_ORIENT_ORIGINAL;
+   ethumb->crop_x = 0.5;
+   ethumb->crop_y = 0.5;
+   ethumb->quality = 80;
+   ethumb->compress = 9;
+   ethumb->video.start = 0.1;
+   ethumb->video.time = 3;
+   ethumb->video.interval = 0.05;
+   ethumb->video.ntimes = 3;
+   ethumb->video.fps = 10;
+
+   ee = ecore_evas_buffer_new(1, 1);
+   e = ecore_evas_get(ee);
+   if (!e)
+     {
+        ERR("could not create ecore evas buffer");
+        free(ethumb);
+        return NULL;
+     }
+
+   evas_image_cache_set(e, 0);
+   evas_font_cache_set(e, 0);
+
+   o = ecore_evas_object_image_new(ee);
+   if (!o)
+     {
+        ERR("could not create sub ecore evas buffer");
+        ecore_evas_free(ee);
+        free(ethumb);
+        return NULL;
+     }
+
+   sub_ee = ecore_evas_object_ecore_evas_get(o);
+   sub_e = ecore_evas_object_evas_get(o);
+   ecore_evas_alpha_set(sub_ee, EINA_TRUE);
+
+   evas_image_cache_set(sub_e, 0);
+   evas_font_cache_set(sub_e, 0);
+
+   img = evas_object_image_add(sub_e);
+   if (!img)
+     {
+        ERR("could not create source objects.");
+        ecore_evas_free(ee);
+        free(ethumb);
+        return NULL;
+     }
+
+   ethumb->ee = ee;
+   ethumb->e = e;
+   ethumb->sub_ee = sub_ee;
+   ethumb->sub_e = sub_e;
+   ethumb->o = o;
+   ethumb->img = img;
+
+   DBG("ethumb=%p", ethumb);
+
+   return ethumb;
+}
+
+static void
+_ethumb_frame_free(Ethumb_Frame *frame)
+{
+   Evas_Object *o;
+
+   if (!frame)
+     return;
+
+   if (frame->swallow && frame->edje)
+     {
+        o = edje_object_part_swallow_get(frame->edje, frame->swallow);
+        if (o)
+          edje_object_part_unswallow(frame->edje, o);
+     }
+   eina_stringshare_del(frame->file);
+   eina_stringshare_del(frame->group);
+   eina_stringshare_del(frame->swallow);
+
+   if (frame->edje)
+     evas_object_del(frame->edje);
+
+   free(frame);
+}
+
+EAPI void
+ethumb_free(Ethumb *ethumb)
+{
+   EINA_SAFETY_ON_NULL_RETURN(ethumb);
+
+   DBG("ethumb=%p", ethumb);
+
+   if (ethumb->frame)
+     _ethumb_frame_free(ethumb->frame);
+   ethumb_file_free(ethumb);
+   evas_object_del(ethumb->o);
+   ecore_evas_free(ethumb->ee);
+   eina_stringshare_del(ethumb->thumb_dir);
+   eina_stringshare_del(ethumb->category);
+   if (ethumb->finished_idler)
+     ecore_idler_del(ethumb->finished_idler);
+   free(ethumb);
+}
+
+EAPI void
+ethumb_thumb_fdo_set(Ethumb *e, Ethumb_Thumb_FDO_Size s)
+{
+   EINA_SAFETY_ON_NULL_RETURN(e);
+   EINA_SAFETY_ON_FALSE_RETURN(s == ETHUMB_THUMB_NORMAL ||
+                               s == ETHUMB_THUMB_LARGE);
+   DBG("ethumb=%p, size=%d", e, s);
+
+   if (s == ETHUMB_THUMB_NORMAL)
+     {
+        e->tw = THUMB_SIZE_NORMAL;
+        e->th = THUMB_SIZE_NORMAL;
+     }
+   else
+     {
+        e->tw = THUMB_SIZE_LARGE;
+        e->th = THUMB_SIZE_LARGE;
+     }
+
+   e->format = ETHUMB_THUMB_FDO;
+   e->aspect = ETHUMB_THUMB_KEEP_ASPECT;
+   e->orientation = ETHUMB_THUMB_ORIENT_ORIGINAL;
+   _ethumb_frame_free(e->frame);
+   e->frame = NULL;
+   eina_stringshare_del(e->thumb_dir);
+   eina_stringshare_del(e->category);
+   e->thumb_dir = NULL;
+   e->category = NULL;
+}
+
+EAPI void
+ethumb_thumb_size_set(Ethumb *e, int tw, int th)
+{
+   EINA_SAFETY_ON_NULL_RETURN(e);
+   EINA_SAFETY_ON_FALSE_RETURN(tw > 0);
+   EINA_SAFETY_ON_FALSE_RETURN(th > 0);
+
+   DBG("ethumb=%p, w=%d, h=%d", e, tw, th);
+   e->tw = tw;
+   e->th = th;
+}
+
+EAPI void
+ethumb_thumb_size_get(const Ethumb *e, int *tw, int *th)
+{
+   EINA_SAFETY_ON_NULL_RETURN(e);
+
+   if (tw) *tw = e->tw;
+   if (th) *th = e->th;
+}
+
+EAPI void
+ethumb_thumb_format_set(Ethumb *e, Ethumb_Thumb_Format f)
+{
+   EINA_SAFETY_ON_NULL_RETURN(e);
+   EINA_SAFETY_ON_FALSE_RETURN(f == ETHUMB_THUMB_FDO ||
+                               f == ETHUMB_THUMB_JPEG ||
+                               f == ETHUMB_THUMB_EET);
+
+   DBG("ethumb=%p, format=%d", e, f);
+   e->format = f;
+}
+
+EAPI Ethumb_Thumb_Format
+ethumb_thumb_format_get(const Ethumb *e)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(e, 0);
+   return e->format;
+}
+
+EAPI void
+ethumb_thumb_aspect_set(Ethumb *e, Ethumb_Thumb_Aspect a)
+{
+   EINA_SAFETY_ON_NULL_RETURN(e);
+   EINA_SAFETY_ON_FALSE_RETURN(a == ETHUMB_THUMB_KEEP_ASPECT ||
+                               a == ETHUMB_THUMB_IGNORE_ASPECT ||
+                               a == ETHUMB_THUMB_CROP);
+
+   DBG("ethumb=%p, aspect=%d", e, a);
+   e->aspect = a;
+}
+
+EAPI Ethumb_Thumb_Aspect
+ethumb_thumb_aspect_get(const Ethumb *e)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(e, 0);
+   return e->aspect;
+}
+
+EAPI void
+ethumb_thumb_orientation_set(Ethumb *e, Ethumb_Thumb_Orientation o)
+{
+   EINA_SAFETY_ON_NULL_RETURN(e);
+   EINA_SAFETY_ON_FALSE_RETURN(o == ETHUMB_THUMB_ORIENT_NONE ||
+                               o == ETHUMB_THUMB_ROTATE_90_CW ||
+                               o == ETHUMB_THUMB_ROTATE_180 ||
+                               o == ETHUMB_THUMB_ROTATE_90_CCW ||
+                               o == ETHUMB_THUMB_FLIP_HORIZONTAL ||
+                               o == ETHUMB_THUMB_FLIP_VERTICAL ||
+                               o == ETHUMB_THUMB_FLIP_TRANSPOSE ||
+                               o == ETHUMB_THUMB_FLIP_TRANSVERSE ||
+                               o == ETHUMB_THUMB_ORIENT_ORIGINAL);
+
+   DBG("ethumb=%p, orientation=%d", e, o);
+   e->orientation = o;
+}
+
+EAPI Ethumb_Thumb_Orientation
+ethumb_thumb_orientation_get(const Ethumb *e)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(e, 0);
+   return e->orientation;
+}
+
+EAPI void
+ethumb_thumb_crop_align_set(Ethumb *e, float x, float y)
+{
+   EINA_SAFETY_ON_NULL_RETURN(e);
+
+   DBG("ethumb=%p, x=%f, y=%f", e, x, y);
+   e->crop_x = x;
+   e->crop_y = y;
+}
+
+EAPI void
+ethumb_thumb_crop_align_get(const Ethumb *e, float *x, float *y)
+{
+   EINA_SAFETY_ON_NULL_RETURN(e);
+
+   if (x) *x = e->crop_x;
+   if (y) *y = e->crop_y;
+}
+
+EAPI void
+ethumb_thumb_quality_set(Ethumb *e, int quality)
+{
+   EINA_SAFETY_ON_NULL_RETURN(e);
+
+   DBG("ethumb=%p, quality=%d", e, quality);
+   e->quality = quality;
+}
+
+EAPI int
+ethumb_thumb_quality_get(const Ethumb *e)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(e, 0);
+   return e->quality;
+}
+
+EAPI void
+ethumb_thumb_compress_set(Ethumb *e, int compress)
+{
+   EINA_SAFETY_ON_NULL_RETURN(e);
+
+   DBG("ethumb=%p, compress=%d", e, compress);
+   e->compress = compress;
+}
+
+EAPI int
+ethumb_thumb_compress_get(const Ethumb *e)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(e, 0);
+   return e->compress;
+}
+
+EAPI Eina_Bool
+ethumb_frame_set(Ethumb *e, const char *theme_file, const char *group, const char *swallow)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(e, 0);
+
+   Ethumb_Frame *frame;
+   frame = e->frame;
+
+   DBG("ethumb=%p, theme_file=%s, group=%s, swallow=%s",
+       e, theme_file ? theme_file : "", group ? group : "",
+       swallow ? swallow : "");
+
+   if (frame)
+     {
+        edje_object_part_unswallow(frame->edje, e->img);
+        if (!theme_file)
+          _ethumb_frame_free(frame);
+     }
+
+   if (!theme_file)
+     {
+        e->frame = NULL;
+        return EINA_FALSE;
+     }
+
+   if (!frame)
+     {
+        frame = calloc(1, sizeof(Ethumb_Frame));
+        if (!frame)
+          {
+             ERR("could not allocate Ethumb_Frame structure.");
+             return EINA_FALSE;
+          }
+
+        frame->edje = edje_object_add(e->sub_e);
+        if (!frame->edje)
+          {
+             ERR("could not create edje frame object.");
+             _ethumb_frame_free(frame);
+             e->frame = NULL;
+             return EINA_FALSE;
+          }
+     }
+
+   if (!edje_object_file_set(frame->edje, theme_file, group))
+     {
+        ERR("could not load frame theme.");
+        _ethumb_frame_free(frame);
+        e->frame = NULL;
+        return EINA_FALSE;
+     }
+
+   edje_object_part_swallow(frame->edje, swallow, e->img);
+   if (!edje_object_part_swallow_get(frame->edje, swallow))
+     {
+        ERR("could not swallow image to edje frame.");
+        _ethumb_frame_free(frame);
+        e->frame = NULL;
+        return EINA_FALSE;
+     }
+
+   eina_stringshare_replace(&frame->file, theme_file);
+   eina_stringshare_replace(&frame->group, group);
+   eina_stringshare_replace(&frame->swallow, swallow);
+
+   e->frame = frame;
+
+   return EINA_TRUE;
+}
+
+EAPI void
+ethumb_frame_get(const Ethumb *e, const char **theme_file, const char **group, const char **swallow)
+{
+   EINA_SAFETY_ON_NULL_RETURN(e);
+
+   if (e->frame)
+     {
+        if (theme_file) *theme_file = e->frame->file;
+        if (group) *group = e->frame->group;
+        if (swallow) *swallow = e->frame->swallow;
+     }
+   else
+     {
+        if (theme_file) *theme_file = NULL;
+        if (group) *group = NULL;
+        if (swallow) *swallow = NULL;
+     }
+}
+
+static const char *
+_ethumb_build_absolute_path(const char *path, char buf[PATH_MAX])
+{
+   char *p;
+   int len;
+
+   if (!path)
+     return NULL;
+
+   p = buf;
+
+   if (path[0] == '/')
+     strcpy(p, path);
+   else if (path[0] == '~')
+     {
+        const char *home = getenv("HOME");
+        if (!home)
+          return NULL;
+        strcpy(p, home);
+        len = strlen(p);
+        p += len;
+        p[0] = '/';
+        p++;
+        strcpy(p, path + 2);
+     }
+   else
+     {
+        if (!getcwd(p, PATH_MAX))
+          return NULL;
+        len = strlen(p);
+        p += len;
+        p[0] = '/';
+        p++;
+        strcpy(p, path);
+     }
+
+   return buf;
+}
+
+EAPI void
+ethumb_thumb_dir_path_set(Ethumb *e, const char *path)
+{
+   char buf[PATH_MAX];
+   EINA_SAFETY_ON_NULL_RETURN(e);
+
+   DBG("ethumb=%p, path=%s", e, path ? path : "");
+   path = _ethumb_build_absolute_path(path, buf);
+   eina_stringshare_replace(&e->thumb_dir, path);
+}
+
+EAPI const char *
+ethumb_thumb_dir_path_get(const Ethumb *e)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(e, NULL);
+
+   return e->thumb_dir;
+}
+
+EAPI void
+ethumb_thumb_category_set(Ethumb *e, const char *category)
+{
+   EINA_SAFETY_ON_NULL_RETURN(e);
+
+   DBG("ethumb=%p, category=%s", e, category ? category : "");
+   eina_stringshare_replace(&e->category, category);
+}
+
+EAPI const char *
+ethumb_thumb_category_get(const Ethumb *e)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(e, NULL);
+
+   return e->category;
+}
+
+EAPI void
+ethumb_video_start_set(Ethumb *e, float start)
+{
+   EINA_SAFETY_ON_NULL_RETURN(e);
+   EINA_SAFETY_ON_FALSE_RETURN(start >= 0.0);
+   EINA_SAFETY_ON_FALSE_RETURN(start <= 1.0);
+
+   DBG("ethumb=%p, video_start=%f", e, start);
+   e->video.start = start;
+}
+
+EAPI float
+ethumb_video_start_get(const Ethumb *e)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(e, 0);
+
+   return e->video.start;
+}
+
+EAPI void
+ethumb_video_time_set(Ethumb *e, float t)
+{
+   EINA_SAFETY_ON_NULL_RETURN(e);
+
+   DBG("ethumb=%p, video_start=%f", e, t);
+   e->video.time = t;
+}
+
+EAPI float
+ethumb_video_time_get(const Ethumb *e)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(e, 0);
+
+   return e->video.time;
+}
+
+EAPI void
+ethumb_video_interval_set(Ethumb *e, float interval)
+{
+   EINA_SAFETY_ON_NULL_RETURN(e);
+
+   DBG("ethumb=%p, video_interval=%f", e, interval);
+   e->video.interval = interval;
+}
+
+EAPI float
+ethumb_video_interval_get(const Ethumb *e)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(e, 0);
+
+   return e->video.interval;
+}
+
+EAPI void
+ethumb_video_ntimes_set(Ethumb *e, unsigned int ntimes)
+{
+   EINA_SAFETY_ON_NULL_RETURN(e);
+   EINA_SAFETY_ON_FALSE_RETURN(ntimes > 0);
+
+   DBG("ethumb=%p, video_ntimes=%d", e, ntimes);
+   e->video.ntimes = ntimes;
+}
+
+EAPI unsigned int
+ethumb_video_ntimes_get(const Ethumb *e)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(e, 0);
+
+   return e->video.ntimes;
+}
+
+EAPI void
+ethumb_video_fps_set(Ethumb *e, unsigned int fps)
+{
+   EINA_SAFETY_ON_NULL_RETURN(e);
+   EINA_SAFETY_ON_FALSE_RETURN(fps > 0);
+
+   DBG("ethumb=%p, video_fps=%d", e, fps);
+   e->video.fps = fps;
+}
+
+EAPI unsigned int
+ethumb_video_fps_get(const Ethumb *e)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(e, 0);
+
+   return e->video.fps;
+}
+
+EAPI void
+ethumb_document_page_set(Ethumb *e, unsigned int page)
+{
+   EINA_SAFETY_ON_NULL_RETURN(e);
+
+   DBG("ethumb=%p, document_page=%d", e, page);
+   e->document.page = page;
+}
+
+EAPI unsigned int
+ethumb_document_page_get(const Ethumb *e)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(e, 0);
+
+   return e->document.page;
+}
+
+EAPI Eina_Bool
+ethumb_file_set(Ethumb *e, const char *path, const char *key)
+{
+   char buf[PATH_MAX];
+   EINA_SAFETY_ON_NULL_RETURN_VAL(e, 0);
+
+   eina_stringshare_replace(&e->thumb_path, NULL);
+   eina_stringshare_replace(&e->thumb_key, NULL);
+
+   DBG("ethumb=%p, path=%s, key=%s", e, path ? path : "", key ? key : "");
+   if (path && access(path, R_OK))
+     {
+        ERR("couldn't access file \"%s\"", path);
+        return EINA_FALSE;
+     }
+
+   path = _ethumb_build_absolute_path(path, buf);
+   eina_stringshare_replace(&e->src_hash, NULL);
+   eina_stringshare_replace(&e->src_path, path);
+   eina_stringshare_replace(&e->src_key, key);
+
+   return EINA_TRUE;
+}
+
+EAPI void
+ethumb_file_get(const Ethumb *e, const char **path, const char **key)
+{
+   EINA_SAFETY_ON_NULL_RETURN(e);
+
+   if (path) *path = e->src_path;
+   if (key) *key = e->src_key;
+}
+
+static const char ACCEPTABLE_URI_CHARS[96] = {
+     /*      !    "    #    $    %    &    '    (    )    *    +    ,    -    .    / */ 
+     0x00,0x3F,0x20,0x20,0x28,0x00,0x2C,0x3F,0x3F,0x3F,0x3F,0x2A,0x28,0x3F,0x3F,0x1C,
+     /* 0    1    2    3    4    5    6    7    8    9    :    ;    <    =    >    ? */
+     0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x38,0x20,0x20,0x2C,0x20,0x20,
+     /* @    A    B    C    D    E    F    G    H    I    J    K    L    M    N    O */
+     0x38,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,
+     /* P    Q    R    S    T    U    V    W    X    Y    Z    [    \    ]    ^    _ */
+     0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x20,0x20,0x20,0x20,0x3F,
+     /* `    a    b    c    d    e    f    g    h    i    j    k    l    m    n    o */
+     0x20,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,
+     /* p    q    r    s    t    u    v    w    x    y    z    {    |    }    ~  DEL */
+     0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x20,0x20,0x20,0x3F,0x20
+};
+
+static const char *
+_ethumb_generate_hash(const char *file)
+{
+   int n;
+   MD5_CTX ctx;
+   char md5out[(2 * MD5_HASHBYTES) + 1];
+   unsigned char hash[MD5_HASHBYTES];
+   static const char hex[] = "0123456789abcdef";
+
+   char *uri;
+   char *t;
+   const unsigned char *c;
+
+#ifdef HAVE_XATTR
+   ssize_t length;
+
+   length = getxattr(file, "user.e.md5", NULL, 0);
+
+   if (length > 0)
+     {
+        char *tmp;
+
+        tmp = alloca(length);
+        length = getxattr(file, "user.e.md5", tmp, length);
+
+        /* check if we have at least something that look like a md5 hash */
+        if (length > 0 && (length == MD5_HASHBYTES * 2 + 1))
+          {
+             tmp[length] = '\0';
+             return eina_stringshare_add(tmp);
+          }
+     }
+#endif
+
+#define _check_uri_char(c) \
+   ((c) >= 32 && (c) < 128 && (ACCEPTABLE_URI_CHARS[(c) - 32] & 0x08))
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(file, NULL);
+
+   uri = alloca(3 * strlen(file) + 9);
+   memcpy(uri, "file://", sizeof("file://") - 1);
+   t = uri + sizeof("file://") - 1;
+
+   for (c = (const unsigned char *)file; *c != '\0'; c++)
+     {
+        if (!_check_uri_char(*c))
+          {
+             *t++ = '%';
+             *t++ = hex[*c >> 4];
+             *t++ = hex[*c & 15];
+          }
+        else
+          *t++ = *c;
+     }
+   *t = '\0';
+
+#undef _check_uri_char
+
+   MD5Init (&ctx);
+   MD5Update (&ctx, (unsigned char const*)uri, (unsigned)strlen (uri));
+   MD5Final (hash, &ctx);
+
+   for (n = 0; n < MD5_HASHBYTES; n++)
+     {
+        md5out[2 * n] = hex[hash[n] >> 4];
+        md5out[2 * n + 1] = hex[hash[n] & 0x0f];
+     }
+   md5out[2 * n] = '\0';
+
+#ifdef HAVE_XATTR
+   setxattr(file, "user.e.md5", md5out, 2 * n + 1, 0);
+#endif
+
+   DBG("md5=%s, file=%s", md5out, file);
+   return eina_stringshare_add(md5out);
+}
+
+static int
+_ethumb_file_check_fdo(Ethumb *e)
+{
+   if (!((e->tw == THUMB_SIZE_NORMAL && e->th == THUMB_SIZE_NORMAL) ||
+         (e->tw == THUMB_SIZE_LARGE && e->th == THUMB_SIZE_LARGE)))
+     return 0;
+
+   if (e->format != ETHUMB_THUMB_FDO)
+     return 0;
+
+   if (e->aspect != ETHUMB_THUMB_KEEP_ASPECT)
+     return 0;
+
+   if (e->frame)
+     return 0;
+
+   return 1;
+}
+
+static const char *
+_ethumb_file_generate_custom_category(Ethumb *e)
+{
+   char buf[PATH_MAX];
+   const char *aspect, *format;
+   const char *frame;
+
+   if (e->aspect == ETHUMB_THUMB_KEEP_ASPECT)
+     aspect = "keep_aspect";
+   else if (e->aspect == ETHUMB_THUMB_IGNORE_ASPECT)
+     aspect = "ignore_aspect";
+   else
+     aspect = "crop";
+
+   if (e->format == ETHUMB_THUMB_FDO)
+     format = "png";
+   else if (e->format == ETHUMB_THUMB_JPEG)
+     format = "jpg";
+   else
+     format = "eet";
+
+   if (e->frame)
+     frame = "-framed";
+   else
+     frame = "";
+
+   snprintf(buf, sizeof(buf), "%dx%d-%s%s-%s",
+            e->tw, e->th, aspect, frame, format);
+
+   return eina_stringshare_add(buf);
+}
+
+static void
+_ethumb_file_generate_path(Ethumb *e)
+{
+   char buf[PATH_MAX];
+   const char *thumb_dir, *category;
+   const char *ext;
+   int fdo_format;
+
+   fdo_format = _ethumb_file_check_fdo(e);
+
+   if (e->thumb_dir)
+     thumb_dir = eina_stringshare_ref(e->thumb_dir);
+   else
+     thumb_dir = eina_stringshare_ref(_home_thumb_dir);
+
+   if (e->category)
+     category = eina_stringshare_ref(e->category);
+   else if (!fdo_format)
+     category = _ethumb_file_generate_custom_category(e);
+   else
+     {
+        if (e->tw == THUMB_SIZE_NORMAL)