include/livebox.h

   1 /*
   2  * Copyright 2012  Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.tizenopensource.org/license
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #ifndef __LIVEBOX_H
  18 #define __LIVEBOX_H
  19
  20 #ifdef __cplusplus
  21 extern "C" {
  22 #endif
  23
  24 struct livebox;
  25
  26 /*!
  27  * \note size list
  28  * 172x172
  29  * 348x172
  30  * 348x348
  31  * 700x348
  32  * 700x172
  33  * 700x700
  34  */
  35 #define DEFAULT_PERIOD -1.0f
  36
  37 enum content_event_type {
  38         CONTENT_EVENT_MOUSE_DOWN        = 0x00000001, /*!< LB mouse down event for livebox */
  39         CONTENT_EVENT_MOUSE_UP          = 0x00000002, /*!< LB mouse up event for livebox */
  40         CONTENT_EVENT_MOUSE_MOVE        = 0x00000004, /*!< LB mouse move event for livebox */
  41         CONTENT_EVENT_MOUSE_ENTER       = 0x00000008, /*!< LB mouse enter event for livebox */
  42         CONTENT_EVENT_MOUSE_LEAVE       = 0x00000010, /*!< LB mouse leave event for livebox */
  43
  44         CONTENT_EVENT_ACCESS_READ       = 0x00000100, /*!< LB accessibility read for livebox */
  45         CONTENT_EVENT_ACCESS_READ_NEXT  = 0x00000200, /*!< LB accessibility read next for livebox */
  46         CONTENT_EVENT_ACCESS_READ_PREV  = 0x00000400, /*!< LB accessibility read prev for livebox */
  47         CONTENT_EVENT_ACCESS_ACTIVATE   = 0x00000800, /*!< LB accessibility activate */
  48         CONTENT_EVENT_ACCESS_UP         = 0x00001000, /*!< LB accessibility up */
  49         CONTENT_EVENT_ACCESS_DOWN       = 0x00002000, /*!< LB accessibility down */
  50
  51         CONTENT_EVENT_KEY_DOWN          = 0x00100000, /*!< LB key press */
  52         CONTENT_EVENT_KEY_UP            = 0x00200000, /*!< LB key release */
  53
  54         CONTENT_EVENT_KEY_MASK          = 0x80000000,
  55         CONTENT_EVENT_ACCESS_MASK       = 0x40000000,
  56         CONTENT_EVENT_MOUSE_MASK        = 0x20000000,
  57         CONTENT_EVENT_PD_MASK           = 0x10000000,
  58         CONTENT_EVENT_LB_MASK           = 0x00000000,
  59
  60         LB_MOUSE_DOWN                   = CONTENT_EVENT_LB_MASK | CONTENT_EVENT_MOUSE_MASK | CONTENT_EVENT_MOUSE_DOWN,
  61         LB_MOUSE_UP                     = CONTENT_EVENT_LB_MASK | CONTENT_EVENT_MOUSE_MASK | CONTENT_EVENT_MOUSE_UP,
  62         LB_MOUSE_MOVE                   = CONTENT_EVENT_LB_MASK | CONTENT_EVENT_MOUSE_MASK | CONTENT_EVENT_MOUSE_MOVE,
  63         LB_MOUSE_ENTER                  = CONTENT_EVENT_LB_MASK | CONTENT_EVENT_MOUSE_MASK | CONTENT_EVENT_MOUSE_ENTER,
  64         LB_MOUSE_LEAVE                  = CONTENT_EVENT_LB_MASK | CONTENT_EVENT_MOUSE_MASK | CONTENT_EVENT_MOUSE_LEAVE,
  65
  66         PD_MOUSE_DOWN                   = CONTENT_EVENT_PD_MASK | CONTENT_EVENT_MOUSE_MASK | CONTENT_EVENT_MOUSE_DOWN,
  67         PD_MOUSE_UP                     = CONTENT_EVENT_PD_MASK | CONTENT_EVENT_MOUSE_MASK | CONTENT_EVENT_MOUSE_UP,
  68         PD_MOUSE_MOVE                   = CONTENT_EVENT_PD_MASK | CONTENT_EVENT_MOUSE_MASK | CONTENT_EVENT_MOUSE_MOVE,
  69         PD_MOUSE_ENTER                  = CONTENT_EVENT_PD_MASK | CONTENT_EVENT_MOUSE_MASK | CONTENT_EVENT_MOUSE_ENTER,
  70         PD_MOUSE_LEAVE                  = CONTENT_EVENT_PD_MASK | CONTENT_EVENT_MOUSE_MASK | CONTENT_EVENT_MOUSE_LEAVE,
  71
  72         LB_ACCESS_READ                  = CONTENT_EVENT_LB_MASK | CONTENT_EVENT_ACCESS_MASK | CONTENT_EVENT_ACCESS_READ,
  73         LB_ACCESS_READ_NEXT             = CONTENT_EVENT_LB_MASK | CONTENT_EVENT_ACCESS_MASK | CONTENT_EVENT_ACCESS_READ_NEXT,
  74         LB_ACCESS_READ_PREV             = CONTENT_EVENT_LB_MASK | CONTENT_EVENT_ACCESS_MASK | CONTENT_EVENT_ACCESS_READ_PREV,
  75         LB_ACCESS_ACTIVATE              = CONTENT_EVENT_LB_MASK | CONTENT_EVENT_ACCESS_MASK | CONTENT_EVENT_ACCESS_ACTIVATE,
  76         LB_ACCESS_UP                    = CONTENT_EVENT_LB_MASK | CONTENT_EVENT_ACCESS_MASK | CONTENT_EVENT_ACCESS_UP,
  77         LB_ACCESS_DOWN                  = CONTENT_EVENT_LB_MASK | CONTENT_EVENT_ACCESS_MASK | CONTENT_EVENT_ACCESS_DOWN,
  78
  79         PD_ACCESS_READ                  = CONTENT_EVENT_PD_MASK | CONTENT_EVENT_ACCESS_MASK | CONTENT_EVENT_ACCESS_READ,
  80         PD_ACCESS_READ_NEXT             = CONTENT_EVENT_PD_MASK | CONTENT_EVENT_ACCESS_MASK | CONTENT_EVENT_ACCESS_READ_NEXT,
  81         PD_ACCESS_READ_PREV             = CONTENT_EVENT_PD_MASK | CONTENT_EVENT_ACCESS_MASK | CONTENT_EVENT_ACCESS_READ_PREV,
  82         PD_ACCESS_ACTIVATE              = CONTENT_EVENT_PD_MASK | CONTENT_EVENT_ACCESS_MASK | CONTENT_EVENT_ACCESS_ACTIVATE,
  83         PD_ACCESS_UP                    = CONTENT_EVENT_PD_MASK | CONTENT_EVENT_ACCESS_MASK | CONTENT_EVENT_ACCESS_UP,
  84         PD_ACCESS_DOWN                  = CONTENT_EVENT_PD_MASK | CONTENT_EVENT_ACCESS_MASK | CONTENT_EVENT_ACCESS_DOWN,
  85
  86         LB_KEY_DOWN                     = CONTENT_EVENT_LB_MASK | CONTENT_EVENT_KEY_MASK | CONTENT_EVENT_KEY_DOWN,
  87         LB_KEY_UP                       = CONTENT_EVENT_LB_MASK | CONTENT_EVENT_KEY_MASK | CONTENT_EVENT_KEY_UP,
  88
  89         PD_KEY_DOWN                     = CONTENT_EVENT_PD_MASK | CONTENT_EVENT_KEY_MASK | CONTENT_EVENT_KEY_DOWN,
  90         PD_KEY_UP                       = CONTENT_EVENT_PD_MASK | CONTENT_EVENT_KEY_MASK | CONTENT_EVENT_KEY_UP,
  91
  92         CONTENT_EVENT_MAX       = 0xFFFFFFFF,
  93 };
  94
  95 /* Exported to user app */
  96 enum livebox_lb_type {
  97         LB_TYPE_IMAGE = 0x01, /*!< Contents of a livebox is based on the image file */
  98         LB_TYPE_BUFFER = 0x02, /*!< Contents of a livebox is based on canvas buffer(shared) */
  99         LB_TYPE_TEXT = 0x04, /*!< Contents of a livebox is based on formatted text file */
 100         LB_TYPE_PIXMAP = 0x08, /*!< Contens of a livebox is shared by the pixmap(depends on X) */
 101
 102         LB_TYPE_INVALID = 0xFF,
 103 };
 104
 105 enum livebox_pd_type {
 106         PD_TYPE_BUFFER = 0x01, /*!< Contents of a PD is based on canvas buffer(shared) */
 107         PD_TYPE_TEXT = 0x02, /*!< Contents of a PD is based on formatted text file */
 108         PD_TYPE_PIXMAP = 0x04, /*!< Contents of a livebox is shared by the pixmap(depends on X) */
 109
 110         PD_TYPE_INVALID = 0xFF,
 111 };
 112
 113 enum livebox_event_type { /*!< livebox_event_handler_set Event list */
 114         LB_EVENT_LB_UPDATED, /*!< Contents of the given livebox is updated */
 115         LB_EVENT_PD_UPDATED, /*!< Contents of the given pd is updated */
 116
 117         LB_EVENT_CREATED, /*!< A new livebox is created */
 118         LB_EVENT_DELETED, /*!< A livebox is deleted */
 119
 120         LB_EVENT_GROUP_CHANGED, /*!< Group (Cluster/Sub-cluster) information is changed */
 121         LB_EVENT_PINUP_CHANGED, /*!< PINUP status is changed */
 122         LB_EVENT_PERIOD_CHANGED, /*!< Update period is changed */
 123
 124         LB_EVENT_LB_SIZE_CHANGED, /*!< Livebox size is changed */
 125         LB_EVENT_PD_SIZE_CHANGED, /*!< PD size is changed */
 126
 127         LB_EVENT_PD_CREATED, /*!< If a PD is created even if you didn't call the livebox_create_pd API */
 128         LB_EVENT_PD_DESTROYED, /*!< If a PD is destroyed even if you didn't call the livebox_destroy_pd API */
 129
 130         LB_EVENT_IGNORED, /*!< Request is ignored */
 131 };
 132
 133 enum livebox_fault_type {
 134         LB_FAULT_DEACTIVATED, /*!< Livebox is deactivated by its fault operation */
 135         LB_FAULT_PROVIDER_DISCONNECTED, /*!< Provider is disconnected */
 136 };
 137
 138 enum livebox_visible_state { /*!< Must be sync'd with the provider */
 139         LB_SHOW = 0x00, /*!< Livebox is showed. Default state */
 140         LB_HIDE = 0x01, /*!< Livebox is hide, Update timer is not be freezed. but you cannot receive any updates events. you should refresh(reload) the content of a livebox when you make this show again */
 141
 142         LB_HIDE_WITH_PAUSE = 0x02, /*!< Livebix is hide, it will paused the update timer, but if a livebox update its contents, update event will come to you */
 143
 144         LB_VISIBLE_ERROR = 0xFFFFFFFF, /* To enlarge the size of this enumeration type */
 145 };
 146
 147 /*!
 148  * \note
 149  * TEXT type livebox contents handling opertators.
 150  */
 151 struct livebox_script_operators {
 152         int (*update_begin)(struct livebox *handle); /*!< Content parser is started */
 153         int (*update_end)(struct livebox *handle); /*!< Content parser is stopped */
 154
 155         /*!
 156          * \brief
 157          * Listed functions will be called when parser meets each typed component
 158          */
 159         int (*update_text)(struct livebox *handle, const char *id, const char *part, const char *data); /*!< Update text content */
 160         int (*update_image)(struct livebox *handle, const char *id, const char *part, const char *data); /*!< Update image content */
 161         int (*update_script)(struct livebox *handle, const char *id, const char *part, const char *file, const char *group); /*!< Update script content */
 162         int (*update_signal)(struct livebox *handle, const char *id, const char *emission, const char *signal); /*!< Update signal */
 163         int (*update_drag)(struct livebox *handle, const char *id, const char *part, double dx, double dy); /*!< Update drag info */
 164         int (*update_info_size)(struct livebox *handle, const char *id, int w, int h); /*!< Update content size */
 165         int (*update_info_category)(struct livebox *handle, const char *id, const char *category); /*!< Update content category info */
 166 };
 167
 168 /*!
 169  * \brief Prototype of the return callback of every async functions.
 170  * \param[in] handle
 171  * \param[in] ret
 172  * \param[in] data
 173  * \return void
 174  */
 175 typedef void (*ret_cb_t)(struct livebox *handle, int ret, void *data);
 176
 177 /*!
 178  * \brief Initialize the livebox system
 179  * \param[in] disp
 180  * \return int
 181  */
 182 extern int livebox_init(void *disp);
 183
 184 /*!
 185  * \brief Finalize the livebox system
 186  * \return int
 187  */
 188 extern int livebox_fini(void);
 189
 190 /*!
 191  * \brief Add a new livebox
 192  * \param[in] pkgname
 193  * \param[in] content
 194  * \param[in] cluster
 195  * \param[in] category
 196  * \param[in] period
 197  * \param[in] cb
 198  * \param[in] data
 199  * \return handle
 200  */
 201 extern struct livebox *livebox_add(const char *pkgname, const char *content, const char *cluster, const char *category, double period, ret_cb_t cb, void *data);
 202 extern struct livebox *livebox_add_with_size(const char *pkgname, const char *content, const char *cluster, const char *category, double period, int type, ret_cb_t cb, void *data);
 203
 204 /*!
 205  * \brief Delete a livebox
 206  * \param[in] handle
 207  * \param[in] ret_cb_t return callback
 208  * \param[in] data user data for return callback
 209  * \return int
 210  */
 211 extern int livebox_del(struct livebox *handler, ret_cb_t cb, void *data);
 212
 213 /*!
 214  * \brief Set a livebox events callback
 215  * \param[in] cb Event handler
 216  * \param[in] data User data for the event handler
 217  * \return int
 218  * \sa livebox_unset_event_handler
 219  */
 220
 221 extern int livebox_set_event_handler(int (*cb)(struct livebox *handler, enum livebox_event_type event, void *data), void *data);
 222
 223 /*!
 224  * \brief Unset the livebox event handler
 225  * \param[in] cb
 226  * \return void * pointer of 'data' which is registered from the livebox_event_handler_set
 227  * \sa livebox_set_event_handler
 228  */
 229 extern void *livebox_unset_event_handler(int (*cb)(struct livebox *handler, enum livebox_event_type event, void *data));
 230
 231 /*!
 232  * \note
 233  *   argument list
 234  *      event, pkgname, filename, funcname
 235  *
 236  * \brief Live box fault event handler registeration function
 237  * \param[in] cb
 238  * \param[in] data
 239  * \return int
 240  * \sa livebox_unset_fault_handler
 241  */
 242 extern int livebox_set_fault_handler(int (*cb)(enum livebox_fault_type, const char *, const char *, const char *, void *), void *data);
 243
 244 /*!
 245  * \brief Unset the live box fault event handler
 246  * \param[in] cb
 247  * \return pointer of 'data'
 248  * \sa livebox_set_fault_handler
 249  */
 250 extern void *livebox_unset_fault_handler(int (*cb)(enum livebox_fault_type, const char *, const char *, const char *, void *));
 251
 252 /*!
 253  * \brief Activate the faulted livebox.
 254  * \param[in] pkgname
 255  * \param[in] cb
 256  * \param[in] data
 257  * \return int
 258  */
 259 extern int livebox_activate(const char *pkgname, ret_cb_t cb, void *data);
 260
 261 /*!
 262  * \brief Resize the livebox
 263  * \param[in] handler Handler of a livebox
 264  * \param[in] type Type of a livebox size, LB_SIZE_TYPE_1x1, ...
 265  * \param[in] cb Result callback of the resize operation.
 266  * \param[in] data User data for return callback
 267  * \return int
 268  */
 269 extern int livebox_resize(struct livebox *handler, int type, ret_cb_t cb, void *data);
 270
 271 /*!
 272  * \brief Send the click event for a livebox.
 273  * \param[in] handler Handler of a livebox
 274  * \param[in] x Rational X of the content width.
 275  * \param[in] y Rational Y of the content height.
 276  * \return int
 277  */
 278 extern int livebox_click(struct livebox *handler, double x, double y);
 279
 280 /*!
 281  * \brief Change the cluster/sub-cluster name of given livebox handler
 282  * \param[in] handler Handler of a livebox
 283  * \param[in] cluster New cluster of a livebox
 284  * \param[in] category New category of a livebox
 285  * \param[in] cb Result callback for changing the cluster/category of a livebox
 286  * \param[in] data User data for the result callback
 287  * \return int
 288  */
 289 extern int livebox_set_group(struct livebox *handler, const char *cluster, const char *category, ret_cb_t cb, void *data);
 290
 291 /*!
 292  * \brief Get the cluster and category(sub-cluster) name of given livebox (It is not I18N format, only english)
 293  * \param[in] handler Handler of a livebox
 294  * \param[out] cluster Storage(memory) for containing the cluster name
 295  * \param[out] category Storage(memory) for containing the category name
 296  * \return int
 297  */
 298 extern int livebox_get_group(struct livebox *handler, char ** const cluster, char ** const category);
 299
 300 /*!
 301  * \brief Get the period of this livebox handler
 302  * \param[in] handler Handler of a livebox
 303  * \return double Current update period of a livebox
 304  */
 305 extern double livebox_period(struct livebox *handler);
 306
 307 /*!
 308  * \brief Change the update period
 309  * \param[in] handler Handler of a livebox
 310  * \param[in] period New update period of a livebox
 311  * \param[in] cb Result callback of changing the update period of this livebox
 312  * \param[in] data User data for the result callback
 313  * \return int
 314  */
 315 extern int livebox_set_period(struct livebox *handler, double period, ret_cb_t cb, void *data);
 316
 317 /*!
 318  * \brief Is this an text type livebox?
 319  * \param[in] handler
 320  * \return content_type
 321  */
 322 extern enum livebox_lb_type livebox_lb_type(struct livebox *handler);
 323
 324 /*!
 325  * \brief Is this livebox is created by a user?
 326  * \param[in] handler
 327  * \return int
 328  */
 329 extern int livebox_is_user(struct livebox *handler);
 330
 331 /*!
 332  * \brief Get the content information string of given livebox
 333  * \param[in] handler
 334  * \return content
 335  */
 336 extern const char *livebox_content(struct livebox *handler);
 337
 338 /*!
 339  * \brief Get the sub cluster title string of given livebox
 340  * \param[in] handler
 341  * \return sub cluster title
 342  */
 343 extern const char *livebox_category_title(struct livebox *handler);
 344
 345 /*!
 346  * \brief Get the filename of given livebox, if it is an IMAGE type livebox
 347  * \param[in] handler
 348  * \return filename
 349  */
 350 extern const char *livebox_filename(struct livebox *handler);
 351
 352 /*!
 353  * \brief Get the package name of given livebox handler
 354  * \param[in] handler
 355  * \return pkgname
 356  */
 357 extern const char *livebox_pkgname(struct livebox *handler);
 358
 359 /*!
 360  * \brief Get the priority of a current content.
 361  * \param[in] handler
 362  * \return priority
 363  */
 364 extern double livebox_priority(struct livebox *handler);
 365
 366 /*!
 367  * \brief Acquire the buffer of given livebox (Only for the buffer type)
 368  * \param[in] handler
 369  * \return address of a FB
 370  */
 371 extern void *livebox_acquire_fb(struct livebox *handler);
 372
 373 /*!
 374  * \brief Release the buffer of a livebox (Only for the buffer type)
 375  * \param[in] buffer
 376  * \return int
 377  */
 378 extern int livebox_release_fb(void *buffer);
 379
 380 /*!
 381  * \brief Get the reference count of Livebox buffer (Only for the buffer type)
 382  * \param[in] buffer
 383  * \return int
 384  */
 385 extern int livebox_fb_refcnt(void *buffer);
 386
 387 /*!
 388  * \brief Acquire the buffer of a PD frame (Only for the buffer type)
 389  * \param[in] handler
 390  * \return int
 391  */
 392 extern void *livebox_acquire_pdfb(struct livebox *handler);
 393
 394 /*!
 395  * \brief Release the acquired buffer of the PD Frame (Only for the buffer type)
 396  * \param[in] buffer
 397  * \return int
 398  */
 399 extern int livebox_release_pdfb(void *buffer);
 400
 401 /*!
 402  * \brief Reference count of given PD buffer (Only for the buffer type)
 403  * \param[in] buffer
 404  * \return int
 405  */
 406 extern int livebox_pdfb_refcnt(void *buffer);
 407
 408 /*!
 409  * \brief Get the size of the Livebox
 410  * \param[in] handler
 411  * \param[out] w
 412  * \param[out] h
 413  * \return int
 414  */
 415 extern int livebox_size(struct livebox *handler);
 416
 417 /*!
 418  * \brief Get the size of the Progressive Disclosure
 419  * \param[in] handler
 420  * \param[out] w
 421  * \param[out] h
 422  * \return int
 423  */
 424 extern int livebox_get_pdsize(struct livebox *handler, int *w, int *h);
 425
 426 /*!
 427  * \brief List of supported sizes of given handler
 428  * \param[in] handler
 429  * \param[out] cnt
 430  * \param[out] w
 431  * \param[out] h
 432  * \return int
 433  */
 434 extern int livebox_get_supported_sizes(struct livebox *handler, int *cnt, int *size_list);
 435
 436 /*!
 437  * \brief BUFFER SIZE of the livebox if it is a buffer type
 438  * \param[in] handler
 439  * \return int
 440  */
 441 extern int livebox_lbfb_bufsz(struct livebox *handler);
 442
 443 /*!
 444  * \brief BUFFER SIZE of the progiressive disclosure if it is a buffer type
 445  * \param[in] handler
 446  * \return int
 447  */
 448 extern int livebox_pdfb_bufsz(struct livebox *handler);
 449
 450 /*!
 451  * \brief Send the content event (for buffer type) to provider(livebox)
 452  * \param[in] handler
 453  * \param[in] type
 454  * \param[in] x
 455  * \param[in] y
 456  */
 457 extern int livebox_content_event(struct livebox *handler, enum content_event_type type, double x, double y);
 458
 459 /*!
 460  * \brief Do pin up or not.
 461  * \param[in] handler
 462  * \param[in] flag
 463  * \param[in] cb
 464  * \param[in] data
 465  * \return int
 466  */
 467 extern int livebox_set_pinup(struct livebox *handler, int flag, ret_cb_t cb, void *data);
 468
 469 /*!
 470  * \brief Check the PIN-UP status of given handler
 471  * \param[in] handler
 472  * \return int
 473  */
 474 extern int livebox_is_pinned_up(struct livebox *handler);
 475
 476 /*!
 477  * \brief Check the PINUP feature availability of the given handler
 478  * \param[in] handler
 479  * \return int
 480  */
 481 extern int livebox_has_pinup(struct livebox *handler);
 482
 483 /*!
 484  * \brief Check the PD existence of given handler
 485  * \param[in] handler
 486  * \return int
 487  */
 488 extern int livebox_has_pd(struct livebox *handler);
 489
 490 /*!
 491  * \brief Create the PD of given handler
 492  * \param[in] handler
 493  * \param[in] cb
 494  * \param[in] data
 495  * \return int
 496  */
 497 extern int livebox_create_pd(struct livebox *handler, ret_cb_t cb, void *data);
 498
 499 /*!
 500  * \brief Create the PD of given handler with the relative position from livebox
 501  * \param[in] handler
 502  * \param[in] x 0.0 ~ 1.0
 503  * \param[in] y 0.0 ~ 1.0
 504  * \param[in] cb
 505  * \param[in] data
 506  * \return int
 507  */
 508 extern int livebox_create_pd_with_position(struct livebox *handler, double x, double y, ret_cb_t cb, void *data);
 509
 510 /*!
 511  * \brief Destroy the PD of given handler if it is created.
 512  * \param[in] handler
 513  * \param[in] cb
 514  * \param[in] data
 515  * \return int
 516  */
 517 extern int livebox_destroy_pd(struct livebox *handler, ret_cb_t cb, void *data);
 518
 519 /*!
 520  * \brief Check the create status of given livebox handler
 521  * \param[in] handler
 522  * \return int
 523  */
 524 extern int livebox_pd_is_created(struct livebox *handler);
 525
 526 /*!
 527  * \brief Check the content type of the progressive disclosure of given handler
 528  * \param[in] handler
 529  * \return int
 530  */
 531 extern enum livebox_pd_type livebox_pd_type(struct livebox *handler);
 532
 533 /*!
 534  * \brief Check the existence of a livebox about given package name
 535  * \param[in] pkgname
 536  * \return int
 537  */
 538 extern int livebox_is_exists(const char *pkgname);
 539
 540 /*!
 541  * \brief Set function table for parsing the text content of a livebox
 542  * \param[in] handler
 543  * \param[in] ops
 544  * \return int
 545  */
 546 extern int livebox_set_text_handler(struct livebox *handler, struct livebox_script_operators *ops);
 547
 548 /*!
 549  * \brief Set function table for parsing the text content of a Progressive Disclosure
 550  * \param[in] handler
 551  * \param[in] ops
 552  * \return int
 553  */
 554 extern int livebox_set_pd_text_handler(struct livebox *handler, struct livebox_script_operators *ops);
 555
 556 /*!
 557  * \brief Emit a text signal to given livebox only if it is a text type.
 558  * \param[in] handler
 559  * \param[in] emission
 560  * \param[in] source
 561  * \param[in] sx
 562  * \param[in] sy
 563  * \param[in] ex
 564  * \param[in] ey
 565  * \param[in] cb
 566  * \param[in] data
 567  */
 568 extern int livebox_emit_text_signal(struct livebox *handler, const char *emission, const char *source, double sx, double sy, double ex, double ey, ret_cb_t cb, void *data);
 569
 570 /*!
 571  * \brief Set a private data pointer to carry it using given handler
 572  * \param[in] handler
 573  * \param[in] data
 574  * \return int
 575  */
 576 extern int livebox_set_data(struct livebox *handler, void *data);
 577
 578 /*!
 579  * \brief Get private data pointer which is carried by given handler
 580  * \param[in] handler
 581  * \return int
 582  */
 583 extern void *livebox_get_data(struct livebox *handler);
 584
 585 /*!
 586  * \brief Subscribe the event for liveboxes only in given cluster and sub-cluster
 587  * \param[in] cluster   "*" can be used for subscribe all cluster's liveboxes event.
 588  *                      If you use the "*", value in the category will be ignored.
 589  * \param[in] category  "*" can be used for subscribe liveboxes events of all category(sub-cluster) in given "cluster"
 590  * \return int Success 0, fails error code
 591  */
 592 extern int livebox_subscribe_group(const char *cluster, const char *category);
 593
 594 /*!
 595  * \brief Unsubscribe the event for the liveboxes, but you will receive already added liveboxes event.
 596  * \param[in] cluster   "*" can be used for subscribe all cluster's liveboxes event.
 597  *                      If you use the "*", value in the category will be ignored.
 598  * \param[in] category  "*" can be used for subscribe all sub-cluster's liveboxes event in given "cluster"
 599  * \return int Success 0, fails error code
 600  */
 601 extern int livebox_unsubscribe_group(const char *cluster, const char *category);
 602
 603 /*!
 604  * \brief Refresh the group(cluster/sub-cluser(aka. category))
 605  * \param[in] cluster Cluster ID
 606  * \param[in] category Sub-cluster ID
 607  * \return int Success 0 or negative value
 608  */
 609 extern int livebox_refresh_group(const char *cluster, const char *category);
 610
 611 /*!
 612  * \brief Refresh a livebox
 613  * \param[in] handler
 614  * \return int Success 0 or negative value
 615  */
 616 extern int livebox_refresh(struct livebox *handler);
 617
 618 /*!
 619  * \brief Pixmap Id of a livebox content
 620  * \param[in] handler
 621  * \return int
 622  * \sa livebox_pd_pixmap
 623  */
 624 extern int livebox_lb_pixmap(const struct livebox *handler);
 625
 626 /*!
 627  * \brief Pixmap Id of a PD content
 628  * \param[in] handler
 629  * \return int
 630  * \sa livebox_lb_pixmap
 631  */
 632 extern int livebox_pd_pixmap(const struct livebox *handler);
 633
 634 /*!
 635  * \brief
 636  * \param[in] handler
 637  * \param[in] cb
 638  * \param[in] data
 639  * \return int
 640  * \sa livebox_release_pd_pixmap
 641  * \sa livebox_acquire_lb_pixmap
 642  */
 643 extern int livebox_acquire_pd_pixmap(struct livebox *handler, ret_cb_t cb, void *data);
 644
 645 /*!
 646  * \brief Release the acquired pixmap ID
 647  * \param[in] handler
 648  * \param[in] pixmap
 649  * \return int
 650  * \sa livebox_acquire_pd_pixmap
 651  * \sa livebox_release_lb_pixmap
 652  */
 653 extern int livebox_release_pd_pixmap(struct livebox *handler, int pixmap);
 654
 655 /*!
 656  * \brief
 657  * \param[in] handler
 658  * \param[in] cb
 659  * \param[in] data
 660  * \return int
 661  * \sa livebox_release_lb_pixmap
 662  * \sa livebox_acquire_pd_pixmap
 663  */
 664 extern int livebox_acquire_lb_pixmap(struct livebox *handler, ret_cb_t cb, void *data);
 665
 666 /*!
 667  * \brief
 668  * \param[in] handler
 669  * \param[in] pixmap
 670  * \return int
 671  * \sa livebox_acquire_lb_pixmap
 672  * \sa livebox_release_pd_pixmap
 673  */
 674 extern int livebox_release_lb_pixmap(struct livebox *handler, int pixmap);
 675
 676 /*!
 677  * \brief Update the visible state of a livebox
 678  * \param[in] handler Handler of a livebox
 679  * \param[in] state Configure the current visible state of a livebox
 680  * \return int
 681  */
 682 extern int livebox_set_visibility(struct livebox *handler, enum livebox_visible_state state);
 683
 684 /*!
 685  * \brief Current visible state of a livebox
 686  * \param[in] handler Handler of a livebox
 687  * \return enum visible state
 688  */
 689 extern enum livebox_visible_state livebox_visibility(struct livebox *handler);
 690
 691 #ifdef __cplusplus
 692 }
 693 #endif
 694
 695 #endif
 696 /* End of a file */