/*
- * Copyright 2012 Samsung Electronics Co., Ltd
+ * Copyright 2013 Samsung Electronics Co., Ltd
*
* Licensed under the Flora License, Version 1.0 (the "License");
* you may not use this file except in compliance with the License.
CONTENT_EVENT_MOUSE_SET = 0x00000020, /*!< LB mouse set auto event for livebox */
CONTENT_EVENT_MOUSE_UNSET = 0x00000040, /*!< LB mouse unset auto event for livebox */
- CONTENT_EVENT_ACCESS_READ = 0x00000100, /*!< LB accessibility read for livebox */
- CONTENT_EVENT_ACCESS_READ_NEXT = 0x00000200, /*!< LB accessibility read next for livebox */
- CONTENT_EVENT_ACCESS_READ_PREV = 0x00000400, /*!< LB accessibility read prev for livebox */
- CONTENT_EVENT_ACCESS_ACTIVATE = 0x00000800, /*!< LB accessibility activate */
- CONTENT_EVENT_ACCESS_UP = 0x00001000, /*!< LB accessibility up */
- CONTENT_EVENT_ACCESS_DOWN = 0x00002000, /*!< LB accessibility down */
-
CONTENT_EVENT_KEY_DOWN = 0x00100000, /*!< LB key press */
CONTENT_EVENT_KEY_UP = 0x00200000, /*!< LB key release */
CONTENT_EVENT_KEY_MASK = 0x80000000,
- CONTENT_EVENT_ACCESS_MASK = 0x40000000,
CONTENT_EVENT_MOUSE_MASK = 0x20000000,
CONTENT_EVENT_PD_MASK = 0x10000000,
CONTENT_EVENT_LB_MASK = 0x00000000,
PD_MOUSE_SET = CONTENT_EVENT_PD_MASK | CONTENT_EVENT_MOUSE_MASK | CONTENT_EVENT_MOUSE_SET,
PD_MOUSE_UNSET = CONTENT_EVENT_PD_MASK | CONTENT_EVENT_MOUSE_MASK | CONTENT_EVENT_MOUSE_UNSET,
- LB_ACCESS_READ = CONTENT_EVENT_LB_MASK | CONTENT_EVENT_ACCESS_MASK | CONTENT_EVENT_ACCESS_READ,
- LB_ACCESS_READ_NEXT = CONTENT_EVENT_LB_MASK | CONTENT_EVENT_ACCESS_MASK | CONTENT_EVENT_ACCESS_READ_NEXT,
- LB_ACCESS_READ_PREV = CONTENT_EVENT_LB_MASK | CONTENT_EVENT_ACCESS_MASK | CONTENT_EVENT_ACCESS_READ_PREV,
- LB_ACCESS_ACTIVATE = CONTENT_EVENT_LB_MASK | CONTENT_EVENT_ACCESS_MASK | CONTENT_EVENT_ACCESS_ACTIVATE,
- LB_ACCESS_UP = CONTENT_EVENT_LB_MASK | CONTENT_EVENT_ACCESS_MASK | CONTENT_EVENT_ACCESS_UP,
- LB_ACCESS_DOWN = CONTENT_EVENT_LB_MASK | CONTENT_EVENT_ACCESS_MASK | CONTENT_EVENT_ACCESS_DOWN,
-
- PD_ACCESS_READ = CONTENT_EVENT_PD_MASK | CONTENT_EVENT_ACCESS_MASK | CONTENT_EVENT_ACCESS_READ,
- PD_ACCESS_READ_NEXT = CONTENT_EVENT_PD_MASK | CONTENT_EVENT_ACCESS_MASK | CONTENT_EVENT_ACCESS_READ_NEXT,
- PD_ACCESS_READ_PREV = CONTENT_EVENT_PD_MASK | CONTENT_EVENT_ACCESS_MASK | CONTENT_EVENT_ACCESS_READ_PREV,
- PD_ACCESS_ACTIVATE = CONTENT_EVENT_PD_MASK | CONTENT_EVENT_ACCESS_MASK | CONTENT_EVENT_ACCESS_ACTIVATE,
- PD_ACCESS_UP = CONTENT_EVENT_PD_MASK | CONTENT_EVENT_ACCESS_MASK | CONTENT_EVENT_ACCESS_UP,
- PD_ACCESS_DOWN = CONTENT_EVENT_PD_MASK | CONTENT_EVENT_ACCESS_MASK | CONTENT_EVENT_ACCESS_DOWN,
-
LB_KEY_DOWN = CONTENT_EVENT_LB_MASK | CONTENT_EVENT_KEY_MASK | CONTENT_EVENT_KEY_DOWN,
LB_KEY_UP = CONTENT_EVENT_LB_MASK | CONTENT_EVENT_KEY_MASK | CONTENT_EVENT_KEY_UP,
CONTENT_EVENT_MAX = 0xFFFFFFFF,
};
+enum access_event_type {
+ ACCESS_EVENT_PD_MASK = 0x10000000,
+ ACCESS_EVENT_LB_MASK = 0x00000000,
+
+ ACCESS_EVENT_HIGHLIGHT = 0x00000100, /*!< LB accessibility: Hightlight a object */
+ ACCESS_EVENT_HIGHLIGHT_NEXT = 0x00000200, /*!< LB accessibility: Set highlight to next object */
+ ACCESS_EVENT_HIGHLIGHT_PREV = 0x00000400, /*!< LB accessibility: Set highlight to prev object */
+ ACCESS_EVENT_ACTIVATE = 0x00000800, /*!< LB accessibility activate */
+ ACCESS_EVENT_VALUE_CHANGE = 0x00001000, /*!< LB accessibility value changed */
+ ACCESS_EVENT_UNHIGHLIGHT = 0x00002000, /*!< LB accessibility unhighlight */
+ ACCESS_EVENT_SCROLL_DOWN = 0x00004000, /*!< LB accessibility scroll down */
+ ACCESS_EVENT_SCROLL_MOVE = 0x00008000, /*!< LB accessibility scroll move */
+ ACCESS_EVENT_SCROLL_UP = 0x00010000, /*!< LB accessibility scroll up */
+
+ LB_ACCESS_HIGHLIGHT = ACCESS_EVENT_LB_MASK | ACCESS_EVENT_HIGHLIGHT,
+ LB_ACCESS_HIGHLIGHT_NEXT = ACCESS_EVENT_LB_MASK | ACCESS_EVENT_HIGHLIGHT_NEXT,
+ LB_ACCESS_HIGHLIGHT_PREV = ACCESS_EVENT_LB_MASK | ACCESS_EVENT_HIGHLIGHT_PREV,
+ LB_ACCESS_ACTIVATE = ACCESS_EVENT_LB_MASK | ACCESS_EVENT_ACTIVATE,
+ LB_ACCESS_VALUE_CHANGE = ACCESS_EVENT_LB_MASK | ACCESS_EVENT_VALUE_CHANGE,
+ LB_ACCESS_UNHIGHLIGHT = ACCESS_EVENT_LB_MASK | ACCESS_EVENT_UNHIGHLIGHT,
+ LB_ACCESS_SCROLL_DOWN = ACCESS_EVENT_LB_MASK | ACCESS_EVENT_SCROLL_DOWN,
+ LB_ACCESS_SCROLL_MOVE = ACCESS_EVENT_LB_MASK | ACCESS_EVENT_SCROLL_MOVE,
+ LB_ACCESS_SCROLL_UP = ACCESS_EVENT_LB_MASK | ACCESS_EVENT_SCROLL_UP,
+
+ PD_ACCESS_HIGHLIGHT = ACCESS_EVENT_PD_MASK | ACCESS_EVENT_HIGHLIGHT,
+ PD_ACCESS_HIGHLIGHT_NEXT = ACCESS_EVENT_PD_MASK | ACCESS_EVENT_HIGHLIGHT_NEXT,
+ PD_ACCESS_HIGHLIGHT_PREV = ACCESS_EVENT_PD_MASK | ACCESS_EVENT_HIGHLIGHT_PREV,
+ PD_ACCESS_ACTIVATE = ACCESS_EVENT_PD_MASK | ACCESS_EVENT_ACTIVATE,
+ PD_ACCESS_VALUE_CHANGE = ACCESS_EVENT_PD_MASK | ACCESS_EVENT_VALUE_CHANGE,
+ PD_ACCESS_UNHIGHLIGHT = ACCESS_EVENT_PD_MASK | ACCESS_EVENT_UNHIGHLIGHT,
+ PD_ACCESS_SCROLL_DOWN = ACCESS_EVENT_PD_MASK | ACCESS_EVENT_SCROLL_DOWN,
+ PD_ACCESS_SCROLL_MOVE = ACCESS_EVENT_PD_MASK | ACCESS_EVENT_SCROLL_MOVE,
+ PD_ACCESS_SCROLL_UP = ACCESS_EVENT_PD_MASK | ACCESS_EVENT_SCROLL_UP,
+};
+
/* Exported to user app */
enum livebox_lb_type {
LB_TYPE_IMAGE = 0x01, /*!< Contents of a livebox is based on the image file */
LB_EVENT_PD_CREATED, /*!< If a PD is created even if you didn't call the livebox_create_pd API */
LB_EVENT_PD_DESTROYED, /*!< If a PD is destroyed even if you didn't call the livebox_destroy_pd API */
+ LB_EVENT_HOLD_SCROLL, /*!< If the screen should be freezed */
+ LB_EVENT_RELEASE_SCROLL, /*!< If the screen can be scrolled */
+
+ LB_EVENT_LB_UPDATE_BEGIN,
+ LB_EVENT_LB_UPDATE_END,
+
+ LB_EVENT_PD_UPDATE_BEGIN,
+ LB_EVENT_PD_UPDATE_END,
+
+ LB_EVENT_UPDATE_MODE_CHANGED,
+
LB_EVENT_IGNORED, /*!< Request is ignored */
};
* Listed functions will be called when parser meets each typed component
*/
int (*update_text)(struct livebox *handle, const char *id, const char *part, const char *data); /*!< Update text content */
- int (*update_image)(struct livebox *handle, const char *id, const char *part, const char *data); /*!< Update image content */
+ int (*update_image)(struct livebox *handle, const char *id, const char *part, const char *data, const char *option); /*!< Update image content */
int (*update_script)(struct livebox *handle, const char *id, const char *part, const char *file, const char *group); /*!< Update script content */
int (*update_signal)(struct livebox *handle, const char *id, const char *emission, const char *signal); /*!< Update signal */
int (*update_drag)(struct livebox *handle, const char *id, const char *part, double dx, double dy); /*!< Update drag info */
/*!
* \brief Initialize the livebox system
- * \param[in] disp
- * \return int
+ * \param[in] disp If you have X Display connection object, you can re-use it. but you should care its life cycle.
+ * It must be alive before call the livebox_fini
+ * \return int 0 if success or < 0 (errno)
+ * \sa livebox_fini
*/
extern int livebox_init(void *disp);
/*!
* \brief Finalize the livebox system
- * \return int
+ * \return int 0 if success, -EINVAL if livebox_init is not called.
+ * \sa livebox_init
*/
extern int livebox_fini(void);
/*!
* \brief Client is paused.
- * \return int
+ * \return int 0 if success, -EFAULT if it failed to send state(paused) info
+ * \sa livebox_client_resumed
*/
extern int livebox_client_paused(void);
/*!
* \brief Client is rfesumed.
- * \return int
+ * \return int 0 if success, -EFAULT if it failed to send state(resumed) info
+ * \sa livebox_client_paused
*/
extern int livebox_client_resumed(void);
/*!
* \brief Add a new livebox
- * \param[in] pkgname
- * \param[in] content
+ * \param[in] pkgname Livebox Id
+ * \param[in] content Will be passed to the livebox.
* \param[in] cluster
* \param[in] category
- * \param[in] period
- * \param[in] cb
+ * \param[in] period Update period. if you set DEFAULT_PERIOD, the provider will use the default period which is described in the manifest.
+ * \param[in] cb After send the request to the provider, its result will be passed
* \param[in] data
* \return handle
*/
* \param[in] type
* \param[in] x
* \param[in] y
+ * \return
*/
extern int livebox_content_event(struct livebox *handler, enum content_event_type type, double x, double y);
/*!
+ * \brief Send the access event(for buffer type) to provider(livebox).
+ * \param[in] handler
+ * \param[in] access_event_type
+ * \param[in] x
+ * \param[in] y
+ * \param[in] cb
+ * \param[in] data
+ * \return
+ */
+extern int livebox_access_event(struct livebox *handler, enum access_event_type type, double x, double y, ret_cb_t cb, void *data);
+
+/*!
* \brief Do pin up or not.
* \param[in] handler
* \param[in] flag
*/
extern enum livebox_visible_state livebox_visibility(struct livebox *handler);
+/*!
+ * \brief Set the update mode of current livebox
+ * if you set 1 for active update mode, you should get buffer without updated event from provider.
+ * But is passive mode, you have to update content of a box when you get updated event.
+ * Default is Passive mode.
+ * \param[in] handler Handler of a livebox
+ * \param[in] active_update 1 means active update, 0 means passive update (default)
+ * \param[in] cb Result callback function
+ * \param[in] data Callback data
+ * \return int
+ */
+extern int livebox_set_update_mode(struct livebox *handler, int active_update, ret_cb_t cb, void *data);
+
+/*!
+ * \brief Is this box in the active update mode?
+ * \param[in] handler HAndler of a livebox
+ * \return int 0 if passive mode or 1 if active mode or error code
+ */
+extern int livebox_is_active_update(struct livebox *handler);
+
#ifdef __cplusplus
}
#endif
projects / platform / framework / web / livebox-viewer.git / blobdiff