src/ug.c

   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
  18
  19
  20
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <errno.h>
  24 #include <stdio.h>
  25
  26 #include "ug.h"
  27 #include "ug-module.h"
  28 #include "ug-manager.h"
  29 #include "ug-dbg.h"
  30
  31 #ifndef UG_API
  32 #define UG_API __attribute__ ((visibility("default")))
  33 #endif
  34
  35 struct ui_gadget *ug_root_create(void)
  36 {
  37         struct ui_gadget *ug;
  38
  39         ug = calloc(1, sizeof(struct ui_gadget));
  40         if (!ug) {
  41                 _ERR("ug root create failed: Memory allocation failed\n");
  42                 return NULL;
  43         }
  44
  45         ug->mode = UG_MODE_FULLVIEW;
  46         ug->state = UG_STATE_RUNNING;
  47         ug->children = NULL;
  48
  49         return ug;
  50 }
  51
  52 int ug_free(struct ui_gadget *ug)
  53 {
  54         if (!ug) {
  55                 _ERR("ug free failed: Invalid ug\n");
  56                 errno = EINVAL;
  57                 return -1;
  58         }
  59
  60         if (ug->module)
  61                 ug_module_unload(ug->module);
  62         if (ug->name)
  63                 free((void *)ug->name);
  64         if (ug->data)
  65                 bundle_free(ug->data);
  66         free(ug);
  67         return 0;
  68 }
  69
  70 UG_API struct ui_gadget *ug_create(struct ui_gadget *parent,
  71                                    const char *name,
  72                                    enum ug_mode mode,
  73                                    bundle *data, struct ug_cbs *cbs)
  74 {
  75         if (!name) {
  76                 _ERR("ug_create() failed: Invalid name\n");
  77                 errno = EINVAL;
  78                 return NULL;
  79         }
  80
  81         if (mode < UG_MODE_FULLVIEW || mode >= UG_MODE_INVALID) {
  82                 _ERR("ug_create() failed: Invalid mode\n");
  83                 errno = EINVAL;
  84                 return NULL;
  85         }
  86
  87         return ugman_ug_load(parent, name, mode, data, cbs);
  88 }
  89
  90 UG_API int ug_init(Display *disp, Window xid, void *win, enum ug_option opt)
  91 {
  92         if (!win || !xid || !disp) {
  93                 _ERR("ug_init() failed: Invalid arguments\n");
  94                 return -1;
  95         }
  96
  97         if (opt < UG_OPT_INDICATOR_ENABLE || opt >= UG_OPT_MAX) {
  98                 _ERR("ug_init() failed: Invalid option\n");
  99                 return -1;
 100         }
 101
 102         return ugman_init(disp, xid, win, opt);
 103 }
 104
 105 UG_API int ug_pause(void)
 106 {
 107         return ugman_pause();
 108 }
 109
 110 UG_API int ug_resume(void)
 111 {
 112         return ugman_resume();
 113 }
 114
 115 UG_API int ug_destroy(struct ui_gadget *ug)
 116 {
 117         return ugman_ug_del(ug);
 118 }
 119
 120 UG_API int ug_destroy_all(void)
 121 {
 122         return ugman_ug_del_all();
 123 }
 124
 125 UG_API int ug_destroy_me(struct ui_gadget *ug)
 126 {
 127         if (!ug || !ugman_ug_exist(ug)) {
 128                 _ERR("ug_destroy_me() failed: Invalid ug\n");
 129                 errno = EINVAL;
 130                 return -1;
 131         }
 132
 133         if (ug->state == UG_STATE_DESTROYING) {
 134                 _ERR("ug_destory_me() failed:ug is alreay on destroying");
 135                 return -1;
 136         }
 137
 138         if (!ug->cbs.destroy_cb) {
 139                 _ERR("ug_destroy_me() failed: destroy callback does not "
 140                         "exist\n");
 141                 return -1;
 142         }
 143
 144         ug->cbs.destroy_cb(ug, ug->cbs.priv);
 145         return 0;
 146 }
 147
 148 UG_API void *ug_get_layout(struct ui_gadget *ug)
 149 {
 150         if (!ug || !ugman_ug_exist(ug)) {
 151                 _ERR("ug_get_layout() failed: Invalid ug\n");
 152                 errno = EINVAL;
 153                 return NULL;
 154         }
 155         return ug->layout;
 156 }
 157
 158 UG_API void *ug_get_parent_layout(struct ui_gadget *ug)
 159 {
 160         struct ui_gadget *parent;
 161         if (!ug || !ugman_ug_exist(ug)) {
 162                 _ERR("ug_get_parent_layout() failed: Invalid ug\n");
 163                 errno = EINVAL;
 164                 return NULL;
 165         }
 166
 167         parent = ug->parent;
 168
 169         if (parent)
 170                 return parent->layout;
 171         return NULL;
 172 }
 173
 174 UG_API enum ug_mode ug_get_mode(struct ui_gadget *ug)
 175 {
 176         if (!ug || !ugman_ug_exist(ug)) {
 177                 _ERR("ug_get_mode() failed: Invalid ug\n");
 178                 errno = EINVAL;
 179                 return UG_MODE_INVALID;
 180         }
 181
 182         return ug->mode;
 183 }
 184
 185 UG_API void *ug_get_window(void)
 186 {
 187         return ugman_get_window();
 188 }
 189
 190 UG_API int ug_send_event(enum ug_event event)
 191 {
 192         if (event <= UG_EVENT_NONE || event >= UG_EVENT_MAX) {
 193                 _ERR("ug_send_event() failed: Invalid event\n");
 194                 return -1;
 195         }
 196
 197         return ugman_send_event(event);
 198 }
 199
 200 UG_API int ug_send_key_event(enum ug_key_event event)
 201 {
 202         if (event <= UG_KEY_EVENT_NONE || event >= UG_KEY_EVENT_MAX) {
 203                 _ERR("ug_send_key_event() failed: Invalid event\n");
 204                 return -1;
 205         }
 206
 207         return ugman_send_key_event(event);
 208 }
 209
 210 UG_API int ug_send_result(struct ui_gadget *ug, bundle *result)
 211 {
 212         bundle *result_dup = NULL;
 213
 214         if (!ug || !ugman_ug_exist(ug)) {
 215                 _ERR("ug_send_result() failed: Invalid ug\n");
 216                 errno = EINVAL;
 217                 return -1;
 218         }
 219
 220         if (!ug->cbs.result_cb) {
 221                 _ERR("ug_send_result() failed: result callback does not exist\n");
 222                 return -1;
 223         }
 224
 225         if (result) {
 226                 result_dup = bundle_dup(result);
 227                 if (!result_dup) {
 228                         _ERR("ug_send_result() failed: bundle_dup failed\n");
 229                         return -1;
 230                 }
 231         }
 232
 233         ug->cbs.result_cb(ug, result_dup, ug->cbs.priv);
 234
 235         if (result_dup)
 236                 bundle_free(result_dup);
 237
 238         return 0;
 239 }
 240
 241 UG_API int ug_send_message(struct ui_gadget *ug, bundle *msg)
 242 {
 243         int r;
 244
 245         bundle *msg_dup = NULL;
 246         if (msg) {
 247                 msg_dup = bundle_dup(msg);
 248                 if (!msg_dup) {
 249                         _ERR("ug_send_message() failed: bundle_dup failed\n");
 250                         return -1;
 251                 }
 252         }
 253
 254         r = ugman_send_message(ug, msg_dup);
 255
 256         if (msg_dup)
 257                 bundle_free(msg_dup);
 258
 259         return r;
 260 }
 261
 262 UG_API int ug_disable_effect(struct ui_gadget *ug)
 263 {
 264         if (ug->layout_state != UG_LAYOUT_INIT) {
 265                 _ERR("ug_disable_effect() failed: ug has already been shown\n");
 266                 return -1;
 267         }
 268         ug->layout_state = UG_LAYOUT_NOEFFECT;
 269
 270         return 0;
 271 }