static bool bInit = false;
#ifndef ECORE_TIMER
+/**
+ * get time in string
+ * @param dwmSec: milliseconds
+ * @return: time as string
+ */
static char *get_time_string(unsigned long dwmSec)
{
static char buffer[30];
get_sys_elapsed_time();
}
+/**
+ * write custom error with time
+ * @param func_name: name of fuction
+ * @param line_num: line number
+ * @param fmt: format to print
+ * @param ap: va_list
+ */
void
_custom_err_trace_fvprintf(const char *func_name, int line_num, const char *fmt, va_list ap)
{
fclose(f);
}
+/**
+ * print custom dlog message
+ * @param debug_msg: debug message
+ * @param msg: message to print
+ */
void __custom_debug_msg(debug_msg_type *debug_msg, const char *msg, ...)
{
va_list va;
}
}
+/**
+ * custom debug message with seconds
+ * @param debug_msg: debug message
+ * @param msg: message to be printed
+ */
void __custom_sec_debug_msg(debug_msg_type *debug_msg, const char *msg, ...)
{
va_list va;
#include <stdlib.h>
+/**
+ * register ivug callback
+ * @return
+ */
callback_handle_t * ivug_callback_register()
{
callback_handle_t *callback_handle = calloc(1, sizeof(callback_handle_t));
return callback_handle;
}
+/**
+ * unregister ivug callback
+ * @param handle: callback handle
+ */
void ivug_callback_unregister(callback_handle_t *handle)
{
IV_ASSERT(handle != NULL);
enum { STATE_FALSE = 0, STATE_TRUE = 1, };
+/**
+ * get repeat state of slide show
+ * @return repeat state
+ */
static bool
_ivug_config_get_slideshow_repeat_state(void)
{
return repeat_state;
}
+/**
+ * get slide show shuffle state
+ * @return: shuffle state
+ */
static bool
_ivug_config_get_slideshow_shuffle_state(void)
{
return shuffle_state;
}
+/**
+ * set interval time
+ * @param index: index
+ */
void
ivug_config_set_interval_time(int index)
{
return;
}
+/**
+ * set slide show interval time
+ * @return: interval time
+ */
int
ivug_config_get_slideshow_interval_time(void)
{
return interval_time;
}
+/**
+ * set transition effect
+ * @param index: input index
+ */
void
ivug_config_set_transition_effect(int index)
{
return;
}
+/**
+ * get slide show effect type
+ * @return: slide show effect type
+ */
char *
ivug_config_get_slideshow_effect_type(void)
{
return effect_str;
}
+/**
+ * get effect type as string
+ * @param effect_str: effect string
+ * @return: effect type
+ */
ivug_effect_type
ivug_config_get_effect_type_by_string(char *effect_str)
{
return type;
}
+/**
+ * get slide show setting
+ * @param mode: mode of the setting
+ * @param interval_time: interval time of slide show
+ * @param effect_type: effect type of slide show
+ */
void
ivug_config_get_slideshow_setting(slide_show_mode *mode,
double *interval_time,
void *data;
} Ivug_DB;
+/**
+ * print db error
+ * @param error: error input string
+ * @return: db error
+ */
static char *_strerror_db(int error)
{
switch (error) {
}
}
+/**
+ * thumbanail callback
+ * @param error: error
+ * @param path: thumbnail path
+ * @param data: db data
+ */
static void _ivug_thumb_cb(media_content_error_e error,
const char *path, void *data)
{
db_h->callback(db_h->m_handle, path, db_h->data);
}
+/**
+ * create db
+ * @return
+ */
bool ivug_db_create(void)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
return true;
}
+/**
+ * destroy db
+ * @return
+ */
bool ivug_db_destroy(void)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
return true;
}
+/**
+ * rename db
+ * @param m_handle: media handle
+ * @param dest: destination name
+ * @return: true or false based on rename operation
+ */
bool ivug_db_rename(media_handle m_handle, const char *dest)
{
media_info_h minfo = (media_info_h)m_handle;
return true;
}
+/**
+ * destory file handle
+ * @param m_handle: media handle
+ * @return: true or false based on destroy operation
+ */
bool ivug_db_destroy_file_handle(media_handle m_handle)
{
media_info_h minfo = (media_info_h)m_handle;
return true;
}
+/**
+ * destroy folder handle
+ * @param m_handle: media handle
+ * @return
+ */
bool ivug_db_destroy_folder_handle(media_handle m_handle)
{
media_folder_h minfo = (media_folder_h)m_handle;
return true;
}
+/**
+ * create db filter
+ * @param filter: filter to be created
+ * @return: true or false
+ */
bool ivug_db_create_filter(filter_handle *filter)
{
filter_h *media_filter = (filter_h *)filter;
return true;
}
+/**
+ * destroy filter
+ * @param filter: filter name
+ * @return
+ */
bool ivug_db_destroy_filter(filter_handle filter)
{
filter_h media_filter = (filter_h)filter;
return true;
}
+/**
+ * set filter condition
+ * @param media_filter: media filter handle
+ * @param condition: condition to be put
+ * @return
+ */
bool ivug_db_set_filter_condition(filter_handle media_filter, const char *condition)
{
IV_ASSERT(condition != NULL);
return true;
}
+/**
+ * set db filter
+ * @param filter: filter handle
+ * @param view_by: view by type
+ * @param mode: mode value
+ * @param media_type: media type
+ * @param condition: condition to be put
+ * @return
+ */
bool ivug_db_set_filter(filter_handle filter, ivug_view_by view_by, int mode, ivug_media_type media_type, char *condition)
{
filter_h media_filter = (filter_h)filter;
return false;
}
+/**
+ * set db filter offset
+ * @param filter: filter to be put
+ * @param stp: start point
+ * @param endp: end point
+ * @return
+ */
bool ivug_db_set_filter_offset(filter_handle filter, int stp, int endp)
{
filter_h media_filter = (filter_h)filter;
return true;
}
+/**
+ * insert file to db
+ * @param filepath: filte path
+ * @return
+ */
media_handle ivug_db_insert_file_to_DB(const char* filepath)
{
IV_ASSERT(filepath != NULL);
return m_handle;
}
+/**
+ * media item callback
+ * @param item: media info item
+ * @param user_data: user data
+ * @return
+ */
bool _media_item_cb(media_info_h item, void *user_data)
{
media_handle *m_handle = (media_handle *)user_data;
return false; //only 1 item
}
+/**
+ * get file handle
+ * @param filepath: file path
+ * @return
+ */
media_handle ivug_db_get_file_handle(const char* filepath)
{
IV_ASSERT(filepath != NULL);
return NULL;
}
+/**
+ * get file handle form media id
+ * @param media_id: media id
+ * @return
+ */
media_handle ivug_db_get_file_handle_from_media_id(UUID media_id)
{
IV_ASSERT(media_id != NULL);
return m_handle;
}
+/**
+ * folder item call back
+ * @param item: media folder item callback
+ * @param user_data: user data
+ * @return
+ */
static bool _media_folder_item_cb(media_folder_h item, void *user_data)
{
media_handle *t_handle = (media_handle *)user_data;
return false; //only 1 item
}
+/**
+ * get folder handle
+ * @param folderpath: path of folder
+ * @return
+ */
media_handle ivug_db_get_folder_handle(const char* folderpath)
{
IV_ASSERT(folderpath != NULL);
return NULL;
}
+/**
+ * get file path
+ * @param media: media handle
+ * @return
+ */
char *ivug_db_get_file_path(media_handle media)
{
media_info_h file_item = (media_info_h)media;
return name;
}
+/**
+ * get file id
+ * @param media: media handle
+ * @return
+ */
UUID ivug_db_get_file_id(media_handle media)
{
media_info_h file_item = (media_info_h)media;
return id;
}
+/**
+ * get thumbnail path
+ * @param media: media handle
+ * @return
+ */
char *ivug_db_get_thumbnail_path(media_handle media)
{
media_info_h file_item = (media_info_h)media;
return name;
}
+/**
+ * get folder id
+ * @param media: media handle
+ * @return
+ */
UUID ivug_db_get_folder_id(media_handle media)
{
media_folder_h folder_item = (media_folder_h)media;
return id;
}
+/**
+ * get tag id
+ * @param media: media handle
+ * @return
+ */
int ivug_db_get_tag_id(tag_handle media)
{
media_tag_h tag_item = (media_tag_h)media;
return id;
}
+/**
+ * destroy tag
+ * @param tag_h: tag handle
+ * @return
+ */
bool ivug_db_destroy_tag(tag_handle tag_h)
{
media_tag_h tag = (media_tag_h)tag_h;
return true;
}
+/**
+ * update db
+ * @param media: media handle
+ * @return
+ */
bool ivug_db_update(media_handle media)
{
media_info_h file_item = (media_info_h)media;
return true;
}
+/**
+ * media tab item cb
+ * @param item: media tag item cb
+ * @param user_data: tag handle data
+ * @return
+ */
static bool _media_tag_item_cb(media_tag_h item, void *user_data)
{
tag_handle *t_handle = (tag_handle *)user_data;
return false; //only 1 item
}
+/**
+ * get tag handle
+ * @param tagname: tag name
+ * @return
+ */
tag_handle ivug_db_get_tag_handle(const char* tagname)
{
IV_ASSERT(tagname != NULL);
return NULL;
}
+/**
+ * set db favourite
+ * @param media: media handle
+ * @param set: true or false
+ * @return
+ */
bool ivug_db_set_favorite(media_handle media, bool set)
{
media_info_h item = (media_info_h)media;
return true;
}
+/**
+ * get favourite db
+ * @param media: media handle
+ * @param bFavorite: bool value
+ * @return
+ */
bool ivug_db_get_favorite(media_handle media, bool *bFavorite)
{
media_info_h item = (media_info_h)media;
return true;
}
+
+
+/**
+ * cancel thumbnail
+ * @param db_h: db data
+ * @return
+ */
bool ivug_db_cancel_thumbnail(Ivug_DB_h *db_h)
{
media_info_h item = (media_info_h)db_h->m_handle;
return true;
}
+/**
+ * get db time line
+ * @param media: media handle
+ * @param time: time_t structure
+ * @return
+ */
bool ivug_db_get_time(media_handle media, time_t *time)
{
media_info_h item = (media_info_h)media;
return true;
}
+/**
+ * get db mime type
+ * @param media: media handle
+ * @return
+ */
char *ivug_db_get_mime_type(media_handle media)
{
media_info_h item = (media_info_h)media;
return mime;
}
+/**
+ * unset db callback
+ * @param db_h: db data
+ * @return
+ */
bool ivug_db_unset_updated_callback(Ivug_DB_h *db_h)
{
MSG_ERROR("nhande 1 0x%08x", db_h->n_handle);
return false;
}
+/**
+ * get db location
+ * @param media: media handle
+ * @param location: location poiter
+ * @return
+ */
bool ivug_db_get_location(media_handle media, char **location)
{
MSG_ASSERT(location != NULL);
return true;
}
+/**
+ * get longitute
+ * @param media: media handle
+ * @param longitude: longitude pointer
+ * @return
+ */
bool ivug_db_get_get_longitude(media_handle media, double * longitude)
{
media_info_h item = (media_info_h)media;
return true;
}
+/**
+ * get latitude
+ * @param media: media handle
+ * @param latitude: latitude pointer
+ * @return
+ */
bool ivug_db_get_get_latitude(media_handle media, double * latitude)
{
media_info_h item = (media_info_h)media;
return true;
}
+/**
+ * get wheather a file type is supported by db or not
+ * @param media: media handle
+ * @return
+ */
bool ivug_db_is_supported_file_type(media_handle media)
{
bool ret = false;
#include "ivug-debug.h"
#include "ivug-dir.h"
+/**
+ * files in dir
+ * @param dir: directory path
+ * @param pFunc: function pointer
+ * @param data: user data
+ * @return
+ */
bool EnumFilesInDir(const char *dir, EnumFilesCB pFunc, void *data)
{
struct dirent ent_struct;
return ret;
}
+/**
+ * read write exif data
+ * @param fd: file object
+ * @param file_path: file path
+ * @param orientation: orientation value
+ * @param b_write: bool value
+ * @return
+ */
static int __ivug_exif_rw_jfif(FILE *fd, const char *file_path,
unsigned int *orientation, bool b_write)
{
return ret;
}
+/**
+ * read write exif data
+ * @param file_path: file path
+ * @param orient: orientation
+ * @param b_write: bool value
+ * @param is_camera: bool value of camera
+ * @return
+ */
static int __ivug_exif_rw_orient(const char *file_path, unsigned int *orient, bool b_write, bool *is_camera)
{
IV_CHECK_VAL(file_path, -1);
#define BUF_LEN (255)
+/**
+ * return error as per input error code
+ * @param err: error code
+ * @return
+ */
static const char *_conver_error(int err)
{
switch (err) {
return NULL;
}
+/**
+ * get video gps info
+ * @param filepath: file path
+ * @param latitude: latitude value
+ * @param longitude: longitute value
+ * @return
+ */
bool _get_video_gps_info(const char *filepath, double *latitude, double *longitude)
{
IV_ASSERT(filepath != NULL);
return true;
}
+/**
+ * get video resolution
+ * @param path: file path
+ * @param pWidth: width value
+ * @param pHeight: height value
+ * @return
+ */
static bool
_get_video_resolution(const char *path, int * /* OUT */ pWidth, int * /* OUT */pHeight)
{
return true;
}
+/**
+ * get image resolution
+ * @param path: file path
+ * @param pWidth: width value
+ * @param pHeight: height value
+ * @return
+ */
bool ivug_fileinfo_get_image_resolution(const char *path, int * /* OUT */ pWidth, int * /* OUT */pHeight)
{
if (path == NULL) {
return false;
}
-
+/**
+ * get video resolution
+ * @param path: file path
+ * @param pWidth: width value
+ * @param pHeight: height value
+ * @return
+ */
bool ivug_fileinfo_get_video_resolution(const char *path, int * /* OUT */ pWidth, int * /* OUT */pHeight)
{
if (path == NULL) {
return _get_video_resolution(path, pWidth, pHeight);
}
+/**
+ * get gps info of video
+ * @param path: file path
+ * @param latitude: latitude value
+ * @param longitude: longitute value
+ * @return
+ */
bool ivug_fileinfo_get_video_gps_info(const char *path, double *latitude, double *longitude)
{
if (path == NULL) {
return _get_video_gps_info(path, latitude, longitude);
}
-
+/**
+ * get gps of image file
+ * @param path: file path
+ * @param latitude: latitude value
+ * @param longitude: longitute value
+ * @return
+ */
bool ivug_fileinfo_get_image_gps_info(const char* path, double *latitude, double *longitude)
{
if (path == NULL) {
return false;
}
-
+/**
+ * get file extension
+ * @param path: file path
+ * @return
+ */
char *ivug_fileinfo_get_file_extension(const char *path)
{
if (path == NULL) {
}
+
+/**
+ * get mime type
+ * @param path: file path
+ * @return
+ */
char *ivug_fileinfo_get_mime_type(const char *path)
{
if (path == NULL) {
#define BUF_MAX 16384
static mode_t default_mode = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
+/**
+ * get file path
+ * @param path: input path
+ * @return
+ */
const char* ivug_file_get(const char path[])
{
char *file = NULL;
return file;
}
+/**
+ * get directory path
+ * @param path: input path
+ * @return
+ */
char* ivug_dir_get(const char path[])
{
char *p = NULL;
return strdup(buf);
}
+/**
+ * get file exist or not
+ * @param path: file path
+ * @return
+ */
int ivug_file_exists(const char *path)
{
struct stat info = {0,};
}
}
+/**
+ * get directory exist or not
+ * @param path: input path
+ * @return
+ */
int ivug_is_dir(const char *path)
{
struct stat info = {0,};
return 0;
}
+/**
+ * get is directory empty
+ * @param path: directory path
+ * @return
+ */
int ivug_is_dir_empty(const char *path)
{
struct stat info = {0,};
return 1;
}
+/**
+ * create directory
+ * @param dir: directory path to be created
+ * @return
+ */
int ivug_mkdir(const char *dir)
{
if (!dir) {
}
}
+/**
+ * create directory from given path if not exist
+ * @param path: input path
+ * @return
+ */
char *ivug_strip_ext(const char *path)
{
char *p = NULL;
return file;
}
+/**
+ * unlink file
+ * @param filename: file path
+ * @return
+ */
int ivug_file_unlink(const char *filename)
{
if (!filename) {
}
}
+/**
+ * remove directory
+ * @param filename: file name
+ * @return
+ */
int ivug_file_rmdir(const char *filename)
{
if (!filename) {
}
}
+/**
+ * recursively remove directory
+ * @param dir: directory path
+ * @return
+ */
int ivug_file_recursive_rm(const char *dir)
{
char buf[PATH_MAX_SIZE] = {0,};
}
}
+/**
+ * copy file
+ * @param src: source path
+ * @param dst: destination path
+ * @return
+ */
int ivug_file_cp(const char *src, const char *dst)
{
FILE *f1 = NULL;
l = g_list_next(l), \
data = g_list_nth_data(l, 0))
-
+/**
+ * delete object callback
+ * @param data: object data
+ * @param e: Evas
+ * @param eo: Evas Object
+ * @param event_info: event
+ */
static void __obj_del_cb(void *data, Evas * e, Evas_Object * eo, void *event_info)
{
obj_data *item = data;
free(item);
}
+/**
+ *
+ * @param data
+ */
static void __glist_free(void *data)
{
obj_data *item = data;
free(item);
}
+/**
+ * get text
+ * @param ID: char *id
+ * @return
+ */
static char *__get_text(const char *ID)
{
ivug_retv_if(ID == NULL, NULL);
return str;
}
+/**
+ * create language mgr
+ * @param handle: language handle
+ * @return
+ */
int ivug_language_mgr_create(language_handle_t *handle)
{
MSG_HIGH("ivug_language_mgr_create 0x%x", *handle);
return 0;
}
+/**
+ * destroy language mg
+ * @param handle: laguage handle
+ * @return
+ */
int ivug_language_mgr_destroy(language_handle_t handle)
{
lang_mgr mgr = (lang_mgr)handle;
return 0;
}
+/**
+ * language mgr register to object
+ * @param handle: laguage handle
+ * @param obj: Evas Object
+ * @param type: object type
+ * @param part: part
+ * @param text_id: text id
+ */
void ivug_language_mgr_register_object(language_handle_t handle, Evas_Object *obj, obj_type type, const char *part, const char *text_id)
{
lang_mgr mgr = (lang_mgr)handle;
mgr->objs = g_list_append(mgr->objs, item);
}
+/**
+ * register genlist item to language manager
+ * @param handle: laguage handle
+ * @param item: Elm object item
+ */
void ivug_language_mgr_register_genlist_item(language_handle_t handle, Elm_Object_Item *item)
{
lang_mgr mgr = (lang_mgr)handle;
g_list_append(mgr->glist_items, item);
}
+/**
+ * text set to elm object
+ * @param handle: laguage handle
+ * @param obj: Evas Object
+ * @param text_id: text id
+ */
void ivug_elm_object_text_set(language_handle_t handle, Evas_Object *obj, const char *text_id)
{
char *text = __get_text(text_id);
ivug_language_mgr_register_object(handle, obj, OBJ_TYPE_ELM_OBJECT, NULL, text_id);
}
+/**
+ * text set to elm object in given part
+ * @param handle: laguage handle
+ * @param obj: Evas Object
+ * @param part: part name
+ * @param text_id: text id
+ */
void ivug_elm_object_part_text_set(language_handle_t handle, Evas_Object *obj, const char *part, const char *text_id)
{
char *text = __get_text(text_id);
ivug_language_mgr_register_object(handle, obj, OBJ_TYPE_ELM_OBJECT, part, text_id);
}
+/**
+ * get string
+ * @param ID: char *id
+ * @return
+ */
char * GET_STR(const char *ID)
{
return __get_text(ID);
}
+/**
+ * get text domain
+ * @param ID: char *id
+ * @return
+ */
char * ivug_language_mgr_get_text_domain(const char *ID)
{
ivug_retv_if(ID == NULL, NULL);
return true;
}
+/**
+ * rename file
+ * @param src: source path
+ * @param dst: destination path
+ * @return
+ */
bool ivug_rename_file(const char *src, const char *dst)
{
if (!src) {
return true;
}
+/**
+ * copy file
+ * @param filename: file path
+ * @param dest: destination path
+ * @return
+ */
bool ivug_copy_file(const char *filename, const char *dest)
{
#define DIR_MASK_DEFAULT 0775
return false;
}
+/**
+ * covert string to lower
+ * @param str: string input
+ */
static void _ivug__lower_string(char *str)
{
int i = 0;
}
}
+/**
+ * get all supported storage
+ * @param storageId: storage id
+ * @param type: storage type
+ * @param state: storage state
+ * @param path: storage path
+ * @param userData: user data
+ * @return
+ */
static bool _ivug_get_all_supported_storage_cb(int storageId, storage_type_e type, storage_state_e state, const char *path, void *userData)
{
if (path == NULL) {
return true;
}
+/**
+ * get storage name
+ * @param smode: storage location mode
+ * @return
+ */
char *ivug_get_storage_name(storage_loc_e smode)
{
char *path = NULL;
return ivug_file_get(filepath);
}
+/**
+ *
+ * @param number: char * value
+ * @return
+ */
long int ivug_atox(const char *number)
{
char *endptr = NULL;
return (long int)val;
}
+/**
+ * ascii to integer
+ * @param number: char *value
+ * @return
+ */
int ivug_atoi(const char *number)
{
char *endptr = NULL;
return (int)val;
}
+/**
+ * ascii to decimal
+ * @param number: char *value
+ * @return
+ */
double ivug_atod(const char *number)
{
char *endptr = NULL;
return val;
}
+/**
+ * generate file name
+ * @param filepath: file path
+ * @param extension: extension of file
+ * @param dest_dir: new file path
+ * @param hide: hide or not
+ * @return
+ */
char * ivug_generate_file_name(const char *filepath, const char *extension, const char *dest_dir, bool hide)
{
IV_ASSERT(filepath != NULL);
return strdup(tempname);
}
+/**
+ * strip string
+ * @param name: input string
+ * @return
+ */
char * ivug_strip_string(char* name)
{
MSG_UTIL_HIGH("Input name: %s", name);
return name;
}
+/**
+ * generator pattern according to a given value
+ * @param locale: locale value
+ * @param custom_format: custom format
+ * @param timezone: time zone
+ * @param date: date
+ * @return
+ */
static char*
_get_icu_time_string(const char *locale, const char *custom_format, const char *timezone, i18n_udate date)
{
return strdup(result);
}
+/**
+ * get icu date
+ * @param mtime: time_t value
+ * @return
+ */
char *
ivug_get_icu_date(time_t mtime)
{
return datestr;
}
+/**
+ * get Is file type supported
+ * @param fname: file name
+ * @return
+ */
bool ivug_is_supported_file_type(const char *fname)
{
bool ret = false;
#include "ivug-uuid.h"
+/**
+ * assing uuid
+ * @param id: uuid to be assigned
+ * @return
+ */
inline UUID uuid_assign(UUID id)
{
if (id == NULL) {
return strdup(id);
}
+/**
+ * free uuid
+ * @param id: uuid to be freed
+ */
inline void uuid_free(UUID id)
{
if (id != NULL) {
}
}
+/**
+ * get uuid as char*
+ * @param id: uuid
+ * @return
+ */
inline const char *uuid_getchar(UUID id)
{
if (id == NULL) {
return id;
}
+/**
+ * get uuid using char *value
+ * @param szID: value
+ * @return
+ */
inline UUID uuid_getuuid(const char *szID)
{
if (szID == NULL) {
return strdup(szID);
}
+/**
+ * get Is uuid valid or not
+ * @param id: uuid
+ * @return
+ */
inline bool uuid_is_valid(UUID id)
{
return (id != INVALID_UUID) ? true : false;
} iv_ta_accum_item;
+/**
+ * print log
+ * @param file: file name
+ * @param line: line number
+ * @param msg: message to be printed
+ */
static void PrintLog(const char *file, int line, const char *msg, ...)
{
va_list va;
static int g_accum_longest_name = 0;
static unsigned long long g_accum_first_time = MAX_UINT64; // jmlee
+/**
+ * get accum index
+ * @param lvl: level input
+ * @param name: name input
+ * @return
+ */
static int __get_accum_index(int lvl, const char* name)
{
int i;
return -1;
}
+/**
+ * free accums
+ */
static void __free_accums(void)
{
int i = 0;
g_accums = NULL;
}
+/**
+ * print info
+ * @param fp: file object
+ */
void __print_some_info(FILE* fp)
{
// General infomation
static Eina_List *ContextList = NULL;
+/**
+ * get system theme
+ * @return
+ */
Elm_Theme*
gGetSystemTheme(void)
{
return ugContext->th;
}
+/**
+ * get rotation degree
+ * @return
+ */
int
gGetRotationDegree(void)
{
return elm_win_rotation_get(ugContext->parent_win);
}
+/**
+ * get current window
+ * @return
+ */
Evas_Object *
gGetCurrentWindow(void)
{
return ugContext->parent_win;
}
+/**
+ * get current conformant
+ * @return
+ */
Evas_Object *
gGetCurrentConformant(void)
{
return ugContext->conform;
}
+/**
+ * set indicator overlap mode
+ * @param bOverlap: overlap vlaue
+ */
static
void ivug_set_indicator_overlap_mode(bool bOverlap)
{
}
}
+/**
+ * get language handle
+ * @return
+ */
language_handle_t
gGetLanguageHandle(void)
{
return ugContext->language_handle;
}
+/**
+ * get album index
+ * @param val: char* value
+ */
void gSetAlbumIndex(const char* val)
{
AppData *ugContext;
}
}
+/**
+ * get Is destroying
+ * @return
+ */
bool gGetDestroying()
{
AppData *ugContext;
return ugContext->bDestroying;
}
+/**
+ * get service handle
+ * @return
+ */
app_control_h gGetServiceHandle()
{
AppData *ugContext;
return ugContext->app_control_handle;
}
+/**
+ * set service handle
+ * @param service: app control data
+ */
void gSetServiceHandle(app_control_h service)
{
AppData *ugContext;
"Overlap",
};
+/**
+ * context initiate
+ * @param win: Evas object window
+ * @param conform: evas conformant
+ * @return
+ */
bool
ivug_context_init(Evas_Object *win, Evas_Object *conform)
{
return false;
}
-
+/**
+ * context de-initiate
+ * @return
+ */
bool
ivug_context_deinit()
{
return true;
}
-
+/**
+ * destroy context
+ * @param file: file name
+ * @param line: line number
+ */
void ivug_context_destroy_me(const char *file, int line)
{
AppData *Context = NULL;
crop_win_s* global_crop = NULL;
int screen_height = 0, screen_width = 0;
+/**
+ * initiate crop window
+ * @param local: crop window data
+ */
inline static void
init_crop_window(crop_win_s* local)
{
}
}
+/**
+ * draw crop window
+ * @param global_crop: crop window data
+ */
inline static void
draw_crop_window(crop_win_s* global_crop)
{
evas_object_line_xy_set(global_crop->line_left, global_crop->top_left_x, global_crop->top_left_y + global_crop->length, global_crop->top_left_x, global_crop->top_left_y);
}
+/**
+ * set limits
+ * @param local: crop window data
+ */
inline static void
set_limits(crop_win_s *local)
{
MSG_IMAGEVIEW_ERROR("Limits set");
}
+/**
+ * set limits to small circle
+ * @param data: crop window data
+ * @param evas: Evas Object input
+ * @param obj: Evas object
+ * @param event_info: event
+ */
static void small_circle_tl_md_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
crop_win_s* global_crop = (crop_win_s*) data;
}
}
+/**
+ * draw small circle
+ * @param data: crop window data
+ * @param evas: Evas Object input
+ * @param obj: Evas obj
+ * @param event_info: event info
+ */
static void small_circle_tl_mm_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
crop_win_s* global_crop = (crop_win_s*) data;
}
}
+/**
+ * set small circle value
+ * @param data: crop window data
+ * @param evas: evas object obj
+ * @param obj: evas obj
+ * @param event_info: event info
+ */
static void small_circle_tl_mu_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
crop_win_s* global_crop = (crop_win_s*) data;
global_crop->mouse_down = 0;
}
+/**
+ * small circle mouse down callback
+ * @param data: crop window data
+ * @param evas: evas object obj
+ * @param obj: evas obj
+ * @param event_info: event info
+ */
static void small_circle_tr_md_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
crop_win_s* global_crop = (crop_win_s*) data;
}
}
+/**
+ * small circle mouse move callback
+ * @param data: crop window data
+ * @param evas: evas object obj
+ * @param obj: evas obj
+ * @param event_info: event info
+ */
static void small_circle_tr_mm_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
crop_win_s* global_crop = (crop_win_s*) data;
}
}
+/**
+ * small circle mouse up callback
+ * @param data: crop window data
+ * @param evas: evas object obj
+ * @param obj: evas obj
+ * @param event_info: event info
+ */
static void small_circle_tr_mu_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
crop_win_s* global_crop = (crop_win_s*) data;
global_crop->mouse_down = 0;
}
+/**
+ * small circle mouse down callback
+ * @param data: crop window data
+ * @param evas: evas object obj
+ * @param obj: evas obj
+ * @param event_info: event info
+ */
static void small_circle_br_md_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
crop_win_s* global_crop = (crop_win_s*) data;
}
}
+/**
+ * small circle mouse move callback
+ * @param data: crop window data
+ * @param evas: evas object obj
+ * @param obj: evas obj
+ * @param event_info: event info
+ */
static void small_circle_br_mm_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
crop_win_s* global_crop = (crop_win_s*) data;
}
}
+/**
+ * small circle mouse up callback
+ * @param data: crop window data
+ * @param evas: evas object obj
+ * @param obj: evas obj
+ * @param event_info: event info
+ */
static void small_circle_br_mu_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
crop_win_s* global_crop = (crop_win_s*) data;
global_crop->mouse_down = 0;
}
+/**
+ *
+ * @param data: crop window data
+ * @param evas: evas object obj
+ * @param obj: evas obj
+ * @param event_info: event info
+ */
static void small_circle_bl_md_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
crop_win_s* global_crop = (crop_win_s*) data;
MSG_IMAGEVIEW_HIGH("Bottom right x - %d ", global_crop->bottom_right_x);
}
+/**
+ * small circle mouse move callback
+ * @param data: crop window data
+ * @param evas: evas object obj
+ * @param obj: evas obj
+ * @param event_info: event info
+ */
static void small_circle_bl_mm_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
crop_win_s* global_crop = (crop_win_s*) data;
}
}
+/**
+ * small circle below left move move callback
+ * @param data: crop window data
+ * @param evas: evas object obj
+ * @param obj: evas obj
+ * @param event_info: event info
+ */
static void small_circle_bl_mu_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
crop_win_s* global_crop = (crop_win_s*) data;
global_crop->mouse_down = 0;
}
+/**
+ * circle mouse down callback
+ * @param data: crop window data
+ * @param evas: evas object obj
+ * @param obj: evas obj
+ * @param event_info: event info
+ */
static void
circle_md_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
MSG_IMAGEVIEW_HIGH("Mouse,down Here co-ord are -(%d,%d) top and bottom diff are %d %d", ev->cur.canvas.x, ev->cur.canvas.y, global_crop->top_diff, global_crop->bottom_diff);
}
}
+
+/**
+ * circle mouse move callback
+ * @param data: crop window data
+ * @param evas: evas object obj
+ * @param obj: evas obj
+ * @param event_info: event info
+ */
static void
circle_mm_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
}
}
+/**
+ * circle mouse up callback
+ * @param data: crop window data
+ * @param evas: evas object obj
+ * @param obj: evas obj
+ * @param event_info: event info
+ */
static void
circle_mu_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
global_crop->mouse_down = 0;
}
+/**
+ * storage callback
+ * @param storage_id: storage id
+ * @param type: storage type
+ * @param state: storage state
+ * @param path: storage path
+ * @param user_data: user data
+ * @return
+ */
static bool _storage_cb(int storage_id, storage_type_e type, storage_state_e state, const char *path, void *user_data)
{
if (STORAGE_TYPE_INTERNAL == type) {
}
}
+/**
+ * colorspace callback
+ * @param colorspace: image util colorspace data
+ * @param user_data: user data
+ * @return
+ */
static bool colorspace_callback(image_util_colorspace_e colorspace, void *user_data)
{
crop_win_s* global_crop = (crop_win_s*) user_data;
return true;
}
+/**
+ * get supported mime type
+ * @param mimetype: mime type input
+ * @param global_crop: crop win data
+ * @return
+ */
static bool ivug_get_supported_mimetype(media_format_mimetype_e &mimetype, crop_win_s *global_crop)
{
switch (global_crop->colorspace) {
return false;
}
+/**
+ * roatation complete callback
+ * @param dst: media packet data
+ * @param error_code: error code
+ * @param user_data: user data
+ */
static void rotation_complete_cb(media_packet_h *dst, int error_code, void *user_data)
{
if (error_code != IMAGE_UTIL_ERROR_NONE || dst == NULL) {
}
+/**
+ * set rotation data
+ * @param angle: angle input
+ * @return
+ */
static image_util_rotation_e ivug_set_rotation_angle(int angle)
{
switch (angle) {
return IMAGE_UTIL_ROTATION_NONE;
}
}
-
+ /**
+ * rotate image
+ * @param name: image path
+ * @param degree: input degree to rotate
+ */
static void ivug_rotate_image(char *name, int degree)
{
if (global_crop == NULL) {
}
}
-
+ /**
+ * image_util_transform_run callback
+ * @param dst: media packet dst
+ * @param error_code: error code
+ * @param user_data: user data
+ */
static void callback_cb(media_packet_h *dst, int error_code, void *user_data)
{
int width = 0, height = 0, ret = 0;
ivug_rotate_image(image_util_filename_encoded, global_crop->rotation);
}
+/**
+ * crop circle covered data
+ * @param data: user data
+ * @param obj: Evas Object obj
+ * @param emission: emission
+ * @param source: source path
+ */
void ivug_crop_circular_on_save_btn_clicked(void *data, Evas_Object *obj, const char *emission, const char *source)
{
MSG_IMAGEVIEW_HIGH("Cropping the Image");
}
}
+/**
+ * draw ui for crop
+ * @param pMainView: main view dta
+ * @param image_path: image path
+ */
void ivug_crop_ug_create_circular_ui(struct _Ivug_MainView *pMainView, char *image_path)
{
MSG_IMAGEVIEW_HIGH("Creating Circular UI");
rect_crop_win_s* global_rect = NULL;
+/**
+ * initiate rectangle
+ * @param rect_win: rect win
+ */
inline static void init_rect(rect_crop_win_s *rect_win)
{
Evas_Coord init_x, init_y;
rect_win->limits_set = 0;
}
+/**
+ * draw rectangle
+ * @param global_rect: rect crop data
+ */
inline static void draw_rect(rect_crop_win_s *global_rect)
{
}
+/**
+ * set rect draw limits
+ * @param local: rect crop data
+ */
inline static void set_limits(rect_crop_win_s *local)
{
double zoom = elm_photocam_zoom_get(local->photo);
local->limits_set = 1;
}
+/**
+ * top left circle mouse down callback
+ * @param data: rect crop data
+ * @param evas: evas object obj
+ * @param obj: evas obj
+ * @param event_info: event info
+ */
static void small_circle_tl_md_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
rect_crop_win_s* global_rect = (rect_crop_win_s*) data;
}
}
+/**
+ * top left circle mouse move callback
+ * @param data: rect crop data
+ * @param evas: evas object obj
+ * @param obj: evas obj
+ * @param event_info: event info
+ */
static void small_circle_tl_mm_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
rect_crop_win_s* global_rect = (rect_crop_win_s*) data;
}
}
+/**
+ * top left circle mouse up callback
+ * @param data: rect crop data
+ * @param evas: evas object obj
+ * @param obj: evas obj
+ * @param event_info: event info
+ */
static void small_circle_tl_mu_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
rect_crop_win_s* global_rect = (rect_crop_win_s*) data;
global_rect->last_mouse_up_y = y;
}
+/**
+ * top right circle mouse down callback
+ * @param data: rect crop data
+ * @param evas: evas object obj
+ * @param obj: evas obj
+ * @param event_info: event info
+ */
static void small_circle_tr_md_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
rect_crop_win_s* global_rect = (rect_crop_win_s*) data;
}
}
+/**
+ * top right circle mouse move callback
+ * @param data: rect crop data
+ * @param evas: evas object obj
+ * @param obj: evas obj
+ * @param event_info: event info
+ */
static void small_circle_tr_mm_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
rect_crop_win_s* global_rect = (rect_crop_win_s*) data;
}
}
+/**
+ * top right circle mouse up callback
+ * @param data: rect crop data
+ * @param evas: evas object obj
+ * @param obj: evas obj
+ * @param event_info: event info
+ */
static void small_circle_tr_mu_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
rect_crop_win_s* global_rect = (rect_crop_win_s*) data;
global_rect->last_mouse_up_y = y;
}
+/**
+ * top right circle mouse down callback
+ * @param data: rect crop data
+ * @param evas: evas object obj
+ * @param obj: evas obj
+ * @param event_info: event info
+ */
static void small_circle_br_md_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
rect_crop_win_s* global_rect = (rect_crop_win_s*) data;
}
}
+/**
+ * below right circle mouse move callback
+ * @param data: rect crop data
+ * @param evas: evas object obj
+ * @param obj: evas obj
+ * @param event_info: event info
+ */
static void small_circle_br_mm_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
rect_crop_win_s* global_rect = (rect_crop_win_s*) data;
}
}
+/**
+ * below right circle mouse up callback
+ * @param data: rect crop data
+ * @param evas: evas object obj
+ * @param obj: evas obj
+ * @param event_info: event info
+ */
static void small_circle_br_mu_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
rect_crop_win_s* global_rect = (rect_crop_win_s*) data;
global_rect->last_mouse_up_y = y;
}
+/**
+ * below left circle mouse down callback
+ * @param data: rect crop data
+ * @param evas: evas object obj
+ * @param obj: evas obj
+ * @param event_info: event info
+ */
static void small_circle_bl_md_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
rect_crop_win_s* global_rect = (rect_crop_win_s*) data;
}
}
+/**
+ * below left circle mouse move callback
+ * @param data: rect crop data
+ * @param evas: evas object obj
+ * @param obj: evas obj
+ * @param event_info: event info
+ */
static void small_circle_bl_mm_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
rect_crop_win_s* global_rect = (rect_crop_win_s*) data;
}
}
+/**
+ * below lef circle mouse up callback
+ * @param data: rect crop data
+ * @param evas: evas object obj
+ * @param obj: evas obj
+ * @param event_info: event info
+ */
static void small_circle_bl_mu_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
rect_crop_win_s* global_rect = (rect_crop_win_s*) data;
global_rect->last_mouse_up_y = y;
}
+/**
+ * rect mouse down callback
+ * @param data: rect crop data
+ * @param evas: evas object obj
+ * @param obj: evas obj
+ * @param event_info: event info
+ */
static void rect_md_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
rect_crop_win_s* global_rect = (rect_crop_win_s*) data;
}
}
+/**
+ * rect mouse move callback
+ * @param data: rect crop data
+ * @param evas: evas object obj
+ * @param obj: evas obj
+ * @param event_info: event info
+ */
static void rect_mm_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
rect_crop_win_s* global_rect = (rect_crop_win_s*) data;
}
}
+/**
+ * rect mouse up callback
+ * @param data: rect crop data
+ * @param evas: evas object obj
+ * @param obj: evas obj
+ * @param event_info: event info
+ */
static void rect_mu_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
rect_crop_win_s* global_rect = (rect_crop_win_s*) data;
global_rect->last_mouse_up_y = y;
}
+/**
+ * storage callback
+ * @param storage_id: storage id
+ * @param type: storage type
+ * @param state: storage state
+ * @param path: path
+ * @param user_data: user data
+ * @return
+ */
static bool _storage_cb(int storage_id, storage_type_e type, storage_state_e state, const char *path, void *user_data)
{
if (STORAGE_TYPE_INTERNAL == type) {
}
}
+/**
+ * get supported mime type
+ * @param mimetype: media format mime type
+ * @param global_rect: rect crop data
+ * @return
+ */
static bool ivug_get_supported_mimetype(media_format_mimetype_e &mimetype, rect_crop_win_s *global_rect)
{
switch (global_rect->colorspace) {
return false;
}
-
+/**
+ * colorspace callback
+ * @param colorspace: colorspace
+ * @param user_data: rect crop data
+ * @return
+ */
static bool colorspace_callback(image_util_colorspace_e colorspace, void *user_data)
{
rect_crop_win_s* global_rect = (rect_crop_win_s*) user_data;
return true;
}
+/**
+ * rotation callback
+ * @param dst: media packet data
+ * @param error_code: error code
+ * @param user_data: user data
+ */
static void rotation_complete_cb(media_packet_h *dst, int error_code, void *user_data)
{
if (error_code != IMAGE_UTIL_ERROR_NONE || dst == NULL) {
}
+/**
+ * set rotation angle
+ * @param angle: angle input
+ * @return
+ */
static image_util_rotation_e ivug_set_rotation_angle(int angle)
{
switch (angle) {
}
}
+/**
+ * rotate image
+ * @param name: name input
+ * @param degree: input degree
+ */
static void ivug_rotate_image(char *name, int degree)
{
if (global_rect == NULL) {
}
+/**
+ * image_util_transform_run callback
+ * @param dst: media packet data
+ * @param error_code: error code
+ * @param user_data: user data
+ */
static void callback_cb(media_packet_h *dst, int error_code, void *user_data)
{
if (error_code != IMAGE_UTIL_ERROR_NONE || dst == NULL) {
}
}
+/**
+ * on save button click callback
+ * @param data: user data
+ * @param obj: evas object obj
+ * @param emission: emission
+ * @param source: source
+ */
void ivug_crop_on_save_btn_clicked(void *data, Evas_Object *obj, const char *emission, const char *source)
{
if (global_rect == NULL) {
}
}
+/**
+ * create rectangle
+ * @param pMainView: main view data
+ * @param image_path: image path
+ */
void ivug_crop_ug_create_rectangle(struct _Ivug_MainView *pMainView, char *image_path)
{
MSG_IMAGEVIEW_HIGH("Creating Crop Rectangle");
#include "ivug-string.h"
#include "ivug-language-mgr.h"
+/**
+ * app control reply callback
+ * @param request: app control requested data
+ * @param reply: reply
+ * @param result: result data
+ * @param user_data: user data
+ */
void ivug_ext_app_control_reply_cb(app_control_h request, app_control_h reply, app_control_result_e result, void *user_data)
{
MSG_IMAGEVIEW_HIGH("ivug_ext_app_control_reply_cb");
}
}
+/**
+ * launch gallery
+ * @return
+ */
bool ivug_ext_launch_gallery()
{
int ret = -1;
return (ret == APP_CONTROL_ERROR_NONE ? true : false);
}
+/**
+ * launch video player
+ * @param uri: uri data
+ * @param isLockScreen: lockscreen locked or not
+ * @return
+ */
bool ivug_ext_launch_videoplayer(const char *uri, bool isLockScreen)
{
MSG_IMAGEVIEW_HIGH("URI = %s", uri);
*val = NULL;
}
+/**
+ * get view mode
+ * @param data: image viewer parameter data
+ * @param val: input value
+ * @return
+ */
static ivug_mode
_get_view_mode(ivug_parameter* data, const char* val)
{
return IVUG_MODE_INVAILD;
}
-
+/**
+ * get view by given value
+ * @param val: input value
+ * @return
+ */
static ivug_view_by
_get_view_by(const char* val)
{
}
-
+/**
+ * get setas type
+ * @param val: input value
+ * @return
+ */
static ivug_setas_type
_get_setas_type(const char* val)
{
return IVUG_SET_AS_UG_TYPE_INVALID;
}
+/**
+ * get media type
+ * @param val: input value
+ * @return
+ */
static ivug_media_type
_get_media_type(const char* val)
{
return IVUG_MEDIA_TYPE_MAX;
}
+/**
+ * print data
+ * @param service: app control data
+ * @param key: input key
+ * @param user_data: user data
+ * @return
+ */
static bool _data_print(app_control_h service, const char *key, void *user_data)
{
char *value;
return true;
}
+/**
+ * print app control data
+ * @param service: app control data
+ */
static void _print_app_control_data(app_control_h service)
{
int ret = app_control_foreach_extra_data(service, _data_print, NULL);
}
}
+/**
+ * send result to caller
+ */
static void _send_result_to_caller()
{
int ret = 0;
MSG_IMAGEVIEW_HIGH("Send load started event to caller");
}
+/**
+ * launch image viewer
+ * @param service: app control data
+ * @param ugd: ug data
+ */
static void launch_image_viewer(app_control_h service, ug_data *ugd)
{
MSG_IMAGEVIEW_HIGH("Image Viewer BEGIN %s, ", __func__);
}
}
+/**
+ * set indicator visibility
+ * @param win: evas window
+ * @param bShow: is show or not
+ */
void ivug_set_indicator_visibility(Evas_Object *win, bool bShow)
{
IV_ASSERT(win != NULL);
}
}
+/**
+ * set indicator overlap mode
+ * @param bOverlap: overlap or not
+ */
static
void ivug_set_indicator_overlap_mode(bool bOverlap)
{
}
}
+/**
+ * update language
+ * @param ugd: ug data
+ * @return
+ */
static int _iv_lang_update(ug_data *ugd)
{
IV_ASSERT(ugd != NULL);
return 1;
}
+/**
+ * language change callback
+ * @param event_info: event info
+ * @param data: user data
+ */
void image_viewer_lang_changed_cb(app_event_info_h event_info, void *data)
{
if (!data) {
}
//parsing bundle
+/**
+ * parsing bundle
+ * @param service: app control data
+ * @param ugdata: ug data
+ */
void
ivug_param_create_from_bundle(app_control_h service, void *ugdata)
{
return;
}
+/**
+ * delete parameters
+ * @param data: parameter data
+ */
void
ivug_param_delete(ivug_parameter* data)
{
}
-
+/**
+ * create parameter filter
+ * @param param: parameter data
+ * @return
+ */
Filter_struct *ivug_param_create_filter(const ivug_parameter *param)
{
IV_ASSERT(param != NULL);
Elm_Object_Item *item;
} ivug_radio_popup_item;
+/**
+ * create popup
+ * @return
+ */
static Ivug_Popup * ivug_popup_create()
{
Ivug_Popup *iv_popup = calloc(1, sizeof(Ivug_Popup));
return iv_popup;
}
+/**
+ * delete popup
+ * @param iv_popup
+ */
static void ivug_popup_delete(Ivug_Popup *iv_popup)
{
if (iv_popup->popup) {
}
+/**
+ * back button click callback
+ * @param data: popup data
+ * @param obj: evas object
+ * @param event_info: event info
+ */
static void _on_btn_back_clicked(void *data, Evas_Object *obj, void *event_info)
{
IV_ASSERT(data != NULL);
ivug_popup_delete(iv_popup);
}
+/**
+ * on popup button click
+ * @param data: popup data
+ * @param obj: evas object
+ * @param event_info: event info
+ */
static void _on_popup_response(void *data, Evas_Object *obj, void *event_info)
{
IV_ASSERT(data != NULL);
ivug_popup_delete(iv_popup);
}
-
+/**
+ * popup dismissed callback
+ * @param data: popup data
+ * @param obj: evas object
+ * @param event_info: event info
+ */
static void _on_ctxpopup_dismissed(void *data, Evas_Object *obj, void *event_info)
{
// Triggered when clicked outside ctxpopup
ivug_popup_delete(iv_popup);
}
+/**
+ * add button
+ * @param parent: parent evas object
+ * @param style: style type
+ * @param hLang: language handle
+ * @param caption_id: caption id
+ * @param icon: evas object
+ * @param pFunc: fuction callback
+ * @param data: popup data
+ * @return
+ */
static Evas_Object *ivug_button_add(Evas_Object *parent, const char *style, language_handle_t hLang, const char *caption_id, Evas_Object *icon, Evas_Smart_Cb pFunc, const void * data)
{
IV_ASSERT(parent != NULL);
return btn;
}
+/**
+ * delete popup
+ * @param parent: parent evas object
+ * @param file_type: file type
+ * @param response: response callback
+ * @param user_data: popup data
+ * @return
+ */
Evas_Object*
ivug_deletepopup_show(Evas_Object* parent, const char* file_type,
Evas_Smart_Cb response, void* user_data)
return popup;
}
+/**
+ * timeout show popup
+ * @param parent: parent evas object
+ * @param response: response callback
+ * @param data: user data
+ * @param sztitle_id: title string
+ * @param content_id: content string
+ * @return
+ */
Evas_Object *ivug_timeout_popup_show(Evas_Object *parent,
Evas_Smart_Cb response, void *data, const char *sztitle_id, const char *content_id)
}
+/**
+ * longpress popup show
+ * @param parent: parent evas object
+ * @param x: x co-ordinate
+ * @param y: x co-ordinate
+ * @param bUseExtMenu: bool value
+ * @param response: response callback
+ * @param data: user data
+ * @return
+ */
Evas_Object*
ivug_longpress_popup_show(Evas_Object *parent, int x, int y, bool bUseExtMenu, Evas_Smart_Cb response, void *data)
{
projects / profile / mobile / apps / native / ug-image-viewer-efl.git / commitdiff