src/ug_worldclock_efl.c

   1 /*
   2  * Copyright 2012  Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.1 (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://floralicense.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 UG_MODULE_API
  18 #define UG_MODULE_API __attribute__ ((visibility("default")))
  19 #endif
  20
  21 #include <vconf.h>
  22 #include <Elementary.h>
  23 #include <ui-gadget-module.h>
  24
  25 #include "worldclock.h"
  26 #include "worldclock_dlog.h"
  27 #include "ug_worldclock_efl.h"
  28 #include "worldclock_add_view.h"
  29
  30 #ifndef _
  31 #define _(s)  dgettext(PACKAGE, s)
  32 #endif
  33 #ifndef S_
  34 #define S_(x) dgettext("sys_string", x)
  35 #endif
  36
  37 struct ug_data {
  38         ui_gadget_h ug;
  39
  40         struct appdata *ad;
  41 };
  42
  43 static struct ug_data *g_ugd;
  44
  45 //Translation Effect Sample
  46 //static void __ug_translation(Evas_Object* evas, Eina_Bool isCreate)
  47 //{
  48 //  Evas_Coord x, y, w, h;
  49 //  evas_object_geometry_get(evas, &x, &y, &w, &h);
  50 //
  51 //  Elm_Transit *transit = elm_transit_add(evas);
  52 //
  53 //  CLK_INFO("\n\tx(%d),y(%d),w(%d),h(%d)\n", x, y, w, h);
  54 //  //Step 1. Translate to left side.
  55 //  Elm_Effect *effect = NULL;
  56 //  if(EINA_TRUE == isCreate) {
  57 //      effect = elm_fx_translation_add(evas, x+w, y, x, y);
  58 //  }
  59 //  else {
  60 //      effect = elm_fx_translation_add(evas, x, y, x+w, y);
  61 //  }
  62 //  elm_transit_fx_insert(transit, effect);
  63 //  elm_transit_completion_callback_set(transit, NULL, NULL);
  64 //  elm_transit_run(transit, 0.5);
  65 //  elm_transit_del(transit);
  66 //}
  67
  68 /**
  69  * Callback func which should be called when exit from this ug.
  70  *
  71  * @param[in]  data         The data which used in this function
  72  *
  73  * @return
  74  */
  75 static void __ug_return_cb(void *data, Eina_Bool isReload)
  76 {
  77         CLK_FUN_BEG();
  78         struct ug_data *ugd = NULL;
  79         Wcl_CitySet *cs = NULL;
  80         service_h service = NULL;
  81
  82         ret_if(!g_ugd);
  83
  84         ugd = g_ugd;
  85         cs = ugd->ad->return_data;
  86
  87         if (cs) {
  88                 // create bundle as return value to ug caller
  89                 service_create(&service);
  90                 // city name
  91                 service_add_extra_data(service, "city", cs->city);
  92                 // country name
  93                 service_add_extra_data(service, "country", cs->country);
  94                 // timezone
  95                 const char *timezone = cs->timezone;
  96                 if (timezone == strstr(timezone, "GMT")) {
  97                         timezone += 3;
  98                 }
  99                 service_add_extra_data(service, "timezone", timezone);
 100                 // tz_path
 101                 service_add_extra_data(service, "tzpath", cs->tz_path);
 102                 CLK_INFO
 103                     ("[Result] city: %s, country: %s, timezone: %s, tzpath: %s\n",
 104                      cs->city, cs->country, timezone, cs->tz_path);
 105                 // send result
 106                 ug_send_result(ugd->ug, service);
 107                 // release data
 108                 service_destroy(service);
 109                 service = NULL;
 110                 free(cs);
 111                 ugd->ad->return_data = cs = NULL;
 112         }
 113         //__ug_translation(ugd->ad->ly_main, EINA_FALSE);
 114
 115         // destory this ug
 116         ug_destroy_me(g_ugd->ug);
 117         g_ugd->ug = NULL;
 118         CLK_FUN_END();
 119 }
 120
 121 /**
 122  * Create main layout
 123  *
 124  * @param[in]  parent  The parent Evas_Object which main layout belong to
 125  *
 126  * @return             NULL if an error occurred
 127  *                     pointer to new main layout otherwise
 128  */
 129 static Evas_Object *__ug_create_main_layout(Evas_Object *parent)
 130 {
 131         CLK_FUN_BEG();
 132         Evas_Object *layout = NULL;
 133
 134         retv_if(parent == NULL, NULL);
 135         // add layout
 136         layout = elm_layout_add(parent);
 137         retvm_if(layout == NULL, NULL, "Failed elm_layout_add.\n");
 138         // theme
 139         elm_layout_theme_set(layout, "layout", "application", "default");
 140         /*elm_layout_theme_set( layout, "standard", "window", "integration" ); */
 141         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND,
 142                                          EVAS_HINT_EXPAND);
 143
 144         /*elm_win_resize_object_add( parent, layout); */
 145         // show indicator & content
 146         /*edje_object_signal_emit(_EDJ(layout), "elm,state,show,indicator", "elm"); */
 147         /*edje_object_signal_emit(_EDJ(layout), "elm,state,show,content", "elm"); */
 148         // show layout
 149         evas_object_show(layout);
 150
 151         CLK_FUN_END();
 152         return layout;
 153 }
 154
 155 Evas_Object *create_bg(Evas_Object *parent)
 156 {
 157         Evas_Object *bg = elm_bg_add(parent);
 158         retvm_if(!bg, NULL, "bg null");
 159         evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND,
 160                                          EVAS_HINT_EXPAND);
 161         evas_object_show(bg);
 162         return bg;
 163 }
 164
 165 /**
 166  * Create navigation layout
 167  *
 168  * @param[in]  parent  The parent Evas_Object which navigation layout belong to
 169  *
 170  * @return             NULL if an error occurred
 171  *                     pointer to new navigation layout otherwise
 172  */
 173 static Evas_Object *__ug_create_navigation_layout(Evas_Object *parent)
 174 {
 175         CLK_FUN_BEG();
 176         Evas_Object *navi_bar = NULL;
 177
 178         retv_if(parent == NULL, NULL);
 179         // add navigationbar
 180         navi_bar = elm_naviframe_add(parent);
 181         // set content
 182         elm_object_part_content_set(parent, "elm.swallow.content", navi_bar);
 183         // show navigationbar
 184         evas_object_show(navi_bar);
 185
 186         CLK_FUN_END();
 187         return navi_bar;
 188 }
 189
 190 static void *on_create(ui_gadget_h ug, enum ug_mode mode, service_h data,
 191                        void *priv)
 192 {
 193         CLK_FUN_BEG();
 194         Evas_Object *win = NULL;
 195         struct ug_data *ugd = NULL;
 196         struct appdata *ad = NULL;
 197         char* caller_name = NULL;
 198
 199         retv_if(ug == NULL || priv == NULL, NULL);
 200
 201         ugd = priv;
 202         ugd->ug = ug;
 203         // get ug window
 204         win = (Evas_Object *)ug_get_window();
 205         retv_if(win == NULL, NULL);
 206         // malloc data
 207         ad = (struct appdata *)malloc(sizeof(struct appdata));
 208         retv_if(ad == NULL, NULL);
 209         memset(ad, 0x0, sizeof(struct appdata));
 210
 211         ad->win = win;
 212         ad->ug = ug;
 213         ad->parent = ug_get_parent_layout(ug);
 214         GOTO_ERROR_IF(!ad->parent);
 215
 216         if (data){
 217                 service_get_extra_data(data, "caller", &caller_name);
 218                 FREEIF(caller_name);
 219         }
 220
 221         if (caller_name && !strcmp("clock", caller_name) ) {
 222                 // set caller flag
 223                 ad->caller = WCL_CALLER_IS_APP_IT_SELF;
 224         } else {
 225                 /* theme setting */
 226                 elm_theme_extension_add(NULL, WCL_THEME_NAME);
 227
 228                 // set caller flag
 229                 ad->caller = WCL_CALLER_IS_UI_GADGET;
 230         }
 231
 232         /* language setting */
 233         bindtextdomain(PACKAGE, LOCALEDIR);
 234         textdomain(PACKAGE);
 235
 236         /* main layout */
 237         ad->ly_main = __ug_create_main_layout(ad->parent);
 238         GOTO_ERROR_IF(ad->ly_main == NULL);
 239         ad->bg = create_bg(ad->ly_main);
 240         elm_object_part_content_set(ad->ly_main, "elm.swallow.bg", ad->bg);
 241
 242         /* navigation bar */
 243         ad->navi_bar = __ug_create_navigation_layout(ad->ly_main);
 244         GOTO_ERROR_IF(ad->navi_bar == NULL);
 245
 246         /* init db */
 247         //GOTO_ERROR_IF(EINA_FALSE == worldclock_ug_data_open_database());
 248
 249         // set selection flag
 250         ad->selectionFlag = WCL_SELECT_IF_HAS_TZPATH;
 251         // create add view for ug
 252         worldclock_ugview_add(ad->navi_bar, ad, __ug_return_cb);
 253
 254         //__ug_translation(ad->ly_main, EINA_TRUE);
 255
 256         ugd->ad = ad;
 257         g_ugd = ugd;
 258
 259         CLK_FUN_END();
 260         return ad->ly_main;
 261
 262  error:
 263         if (ad) {
 264                 // reset navigation bar
 265                 if (ad->navi_bar) {
 266                         evas_object_del(ad->navi_bar);
 267                         ad->navi_bar = NULL;
 268                 }
 269                 // reset layout
 270                 if (ad->ly_main) {
 271                         evas_object_del(ad->ly_main);
 272                         ad->ly_main = NULL;
 273                 }
 274                 if (ad->bg) {
 275                         evas_object_del(ad->bg);
 276                         ad->bg = NULL;
 277                 }
 278                 free(ad);
 279                 ad = NULL;
 280         }
 281         return NULL;
 282 }
 283
 284 static void on_start(ui_gadget_h ug, service_h data, void *priv)
 285 {
 286         CLK_FUN_BEG();
 287 }
 288
 289 static void on_pause(ui_gadget_h ug, service_h data, void *priv)
 290 {
 291         CLK_FUN_BEG();
 292 }
 293
 294 static void on_resume(ui_gadget_h ug, service_h data, void *priv)
 295 {
 296         CLK_FUN_BEG();
 297 }
 298
 299 static void on_destroy(ui_gadget_h ug, service_h data, void *priv)
 300 {
 301         CLK_FUN_BEG();
 302         struct ug_data *ugd;
 303
 304         ret_if(!ug || !priv);
 305
 306         ugd = priv;
 307
 308         if (ugd->ad) {
 309                 struct appdata *ad = ugd->ad;
 310                 worldclock_ugview_free(ad);
 311                 // reset navigation bar
 312                 if (ad->navi_bar) {
 313                         evas_object_del(ad->navi_bar);
 314                         ad->navi_bar = NULL;
 315                 }
 316                 // reset layout
 317                 if (ad->ly_main) {
 318                         evas_object_del(ad->ly_main);
 319                         ad->ly_main = NULL;
 320                 }
 321                 if (ad->bg) {
 322                         evas_object_del(ad->bg);
 323                         ad->bg = NULL;
 324                 }
 325                 free(ugd->ad);
 326                 ugd->ad = NULL;
 327         }
 328
 329         g_ugd = NULL;
 330         CLK_FUN_END();
 331 }
 332
 333 static void on_message(ui_gadget_h ug, service_h msg, service_h data,
 334                        void *priv)
 335 {
 336 }
 337
 338 static void on_event(ui_gadget_h ug, enum ug_event event, service_h data,
 339                      void *priv)
 340 {
 341         CLK_FUN_BEG();
 342         switch (event) {
 343         case UG_EVENT_LOW_MEMORY:
 344                 CLK_INFO("Event : UG_EVENT_LOW_MEMORY");
 345                 break;
 346         case UG_EVENT_LOW_BATTERY:
 347                 CLK_INFO("Event : UG_EVENT_LOW_BATTERY");
 348                 break;
 349         case UG_EVENT_LANG_CHANGE:
 350                 CLK_INFO("Event : UG_EVENT_LANG_CHANGE");
 351                 break;
 352         case UG_EVENT_ROTATE_PORTRAIT:
 353                 CLK_INFO("Event : UG_EVENT_ROTATE_PORTRAIT");
 354                 break;
 355         case UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN:
 356                 CLK_INFO("Event : UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN");
 357                 break;
 358         case UG_EVENT_ROTATE_LANDSCAPE:
 359                 CLK_INFO("Event : UG_EVENT_ROTATE_LANDSCAPE");
 360                 break;
 361         case UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN:
 362                 CLK_INFO("Event : UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN");
 363                 break;
 364         default:
 365                 CLK_INFO("Event : %d", event);
 366                 break;
 367         }
 368         CLK_FUN_END();
 369 }
 370
 371 static void on_key_event(ui_gadget_h ug, enum ug_key_event event,
 372                          service_h data, void *priv)
 373 {
 374         CLK_FUN_BEG();
 375         ret_if(!ug);
 376
 377         switch (event) {
 378         case UG_KEY_EVENT_END:
 379                 ug_destroy_me(ug);
 380                 break;
 381         default:
 382                 break;
 383         }
 384         CLK_FUN_END();
 385 }
 386
 387 UG_MODULE_API int UG_MODULE_INIT(struct ug_module_ops *ops)
 388 {
 389         CLK_FUN_BEG();
 390         struct ug_data *ugd;
 391
 392         retv_if(!ops, -1);
 393
 394         ugd = calloc(1, sizeof(struct ug_data));
 395         retv_if(!ugd, -1);
 396
 397         ops->create = on_create;
 398         ops->start = on_start;
 399         ops->pause = on_pause;
 400         ops->resume = on_resume;
 401         ops->destroy = on_destroy;
 402         ops->message = on_message;
 403         ops->event = on_event;
 404         ops->key_event = on_key_event;
 405         ops->priv = ugd;
 406         ops->opt = UG_OPT_INDICATOR_PORTRAIT_ONLY;
 407
 408         CLK_FUN_END();
 409         return 0;
 410 }
 411
 412 UG_MODULE_API void UG_MODULE_EXIT(struct ug_module_ops *ops)
 413 {
 414         CLK_FUN_BEG();
 415         struct ug_data *ugd;
 416
 417         ret_if(!ops);
 418
 419         ugd = ops->priv;
 420         if (ugd) {
 421                 free(ugd);
 422         }
 423         CLK_FUN_END();
 424 }