setting-display/src/setting-display.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 #include <setting-display.h>
  20 #include <Ecore_X.h>
  21 #include <devman.h>
  22
  23 #define SETTING_BRIGHTNESS_LEVEL_FOR_EMUL 24
  24
  25 #ifndef UG_MODULE_API
  26 #define UG_MODULE_API __attribute__ ((visibility("default")))
  27 #endif
  28
  29 setting_view *__get_display_view_to_load(bundle *data)
  30 {
  31         SETTING_TRACE_BEGIN;
  32         setting_retvm_if(NULL == data, NULL, "NULL == data");
  33         const char *viewtype = bundle_get_val(data, "viewtype");
  34         SETTING_TRACE("viewtype:%s", viewtype);
  35
  36         if (!safeStrCmp(viewtype, "brightness")) {
  37                 return &setting_view_display_brightness;
  38         } else if (!safeStrCmp(viewtype, "wallpaper")) {
  39                 return &setting_view_display_wallpaper;
  40         } else {
  41                 return &setting_view_display_main;
  42         }
  43
  44 }
  45
  46 Evas_Object *__get_display_layout_to_return(bundle *data, void *priv)
  47 {
  48         SETTING_TRACE_BEGIN;
  49         SettingDisplayUG *displayUG = priv;
  50         const char *viewtype = bundle_get_val(data, "viewtype");
  51         SETTING_TRACE("viewtype:%s", viewtype);
  52
  53         if (!safeStrCmp(viewtype, "wallpaper")) {
  54                 return displayUG->ly_wall;
  55         } else {
  56                 return displayUG->ly_main;
  57         }
  58
  59 }
  60
  61 static void setting_display_ug_cb_resize(void *data, Evas *e,
  62                                          Evas_Object *obj, void *event_info)
  63 {
  64         SettingDisplayUG *ad = (SettingDisplayUG *) data;
  65         setting_view_update(ad->view_to_load, ad);
  66 }
  67
  68 static void *setting_display_ug_on_create(struct ui_gadget *ug,
  69                                           enum ug_mode mode, bundle *data,
  70                                           void *priv)
  71 {
  72         setting_retvm_if((!ug || !priv), NULL, "!ug || !priv");
  73
  74         SettingDisplayUG *displayUG = priv;
  75         displayUG->ug = ug;
  76         bindtextdomain(SETTING_PACKAGE, SETTING_LOCALEDIR);
  77         textdomain(SETTING_PACKAGE);
  78
  79         displayUG->win_main_layout = (Evas_Object *) ug_get_parent_layout(ug);
  80         displayUG->win_get = (Evas_Object *) ug_get_window();
  81
  82         evas_object_show(displayUG->win_main_layout);
  83         displayUG->evas = evas_object_evas_get(displayUG->win_main_layout);
  84
  85         setting_retvm_if(displayUG->win_main_layout == NULL, NULL,
  86                          "cannot get main window ");
  87
  88
  89         /* register view node table */
  90         setting_view_node_table_intialize();
  91         setting_view_node_table_register(&setting_view_display_main, NULL);
  92         setting_view_node_table_register(&setting_view_display_brightness,
  93                                          &setting_view_display_main);
  94         setting_view_node_table_register(&setting_view_display_wallpaper, NULL);
  95
  96         setting_create_Gendial_itc("dialogue/2text.3",
  97                                    &(displayUG->itc_2text_2));
  98         setting_create_Gendial_itc("dialogue/1text.1icon",
  99                                    &(displayUG->itc_1text_1icon));
 100         setting_create_Gendial_itc("dialogue/1icon", &(displayUG->itc_layout));
 101         setting_create_Gendial_itc("dialogue/2text.3/expandable",
 102                                    &(displayUG->itc_2text_3_parent));
 103         setting_create_Gendial_itc("dialogue/1text.1icon/expandable2",
 104                                    &(displayUG->itc_1icon_1text_sub));
 105         displayUG->itc_seperator.item_style = "dialogue/separator/21/with_line";
 106         displayUG->itc_seperator.func.text_get = NULL;
 107         displayUG->itc_seperator.func.content_get = NULL;
 108         displayUG->itc_seperator.func.state_get = NULL;
 109         displayUG->itc_seperator.func.del = NULL;
 110         setting_create_Gendial_itc("dialogue/1text", &(displayUG->itc_1text));
 111
 112         /*  creating a view. */
 113         displayUG->view_to_load = __get_display_view_to_load(data);
 114         setting_retvm_if(NULL == displayUG->view_to_load, NULL,
 115                          "NULL == displayUG->view_to_load");
 116         setting_view_node_set_cur_view(displayUG->view_to_load);
 117         setting_view_create(displayUG->view_to_load, (void *)displayUG);
 118         evas_object_event_callback_add(displayUG->win_main_layout,
 119                                        EVAS_CALLBACK_RESIZE,
 120                                        setting_display_ug_cb_resize, displayUG);
 121         return __get_display_layout_to_return(data, displayUG);
 122 }
 123
 124 static void setting_display_ug_on_start(struct ui_gadget *ug, bundle *data,
 125                                         void *priv)
 126 {
 127 }
 128
 129 static void setting_display_ug_on_pause(struct ui_gadget *ug, bundle *data,
 130                                         void *priv)
 131 {
 132 }
 133
 134 static void setting_display_ug_on_resume(struct ui_gadget *ug, bundle *data,
 135                                          void *priv)
 136 {
 137 }
 138
 139 static void setting_display_ug_on_destroy(struct ui_gadget *ug, bundle *data,
 140                                           void *priv)
 141 {
 142         SETTING_TRACE_BEGIN;
 143         setting_retm_if((!ug || !priv), "!ug || !priv");
 144         SettingDisplayUG *displayUG = priv;
 145
 146         /* fix flash issue for gallery */
 147         evas_object_event_callback_del(displayUG->win_main_layout, EVAS_CALLBACK_RESIZE, setting_display_ug_cb_resize);
 148         displayUG->ug = ug;
 149
 150         /*  called when this shared gadget is terminated. similar with app_exit */
 151         if (&setting_view_display_main == displayUG->view_to_load) {
 152                 setting_view_destroy(&setting_view_display_brightness,
 153                                      displayUG);
 154                 setting_view_destroy(&setting_view_display_main, displayUG);
 155         } else if (&setting_view_display_wallpaper == displayUG->view_to_load) {
 156                 setting_view_destroy(&setting_view_display_wallpaper,
 157                                      displayUG);
 158         }
 159
 160         if (NULL != ug_get_layout(displayUG->ug)) {
 161                 evas_object_hide((Evas_Object *) ug_get_layout(displayUG->ug));
 162                 evas_object_del((Evas_Object *) ug_get_layout(displayUG->ug));
 163         }
 164
 165         SETTING_TRACE_END;
 166 }
 167
 168 static void setting_display_ug_on_message(struct ui_gadget *ug, bundle *msg,
 169                                           bundle *data, void *priv)
 170 {
 171         SETTING_TRACE_BEGIN;
 172 }
 173
 174 static void setting_display_ug_on_event(struct ui_gadget *ug,
 175                                         enum ug_event event, bundle *data,
 176                                         void *priv)
 177 {
 178         SETTING_TRACE_BEGIN;
 179         switch (event) {
 180         case UG_EVENT_LOW_MEMORY:
 181                 break;
 182         case UG_EVENT_LOW_BATTERY:
 183                 break;
 184         case UG_EVENT_LANG_CHANGE:
 185                 break;
 186         case UG_EVENT_ROTATE_PORTRAIT:
 187                 break;
 188         case UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN:
 189                 break;
 190         case UG_EVENT_ROTATE_LANDSCAPE:
 191                 break;
 192         case UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN:
 193                 break;
 194         case UG_EVENT_REGION_CHANGE:
 195                 break;
 196         default:
 197                 break;
 198         }
 199 }
 200
 201 static void setting_display_ug_on_key_event(struct ui_gadget *ug,
 202                                             enum ug_key_event event,
 203                                             bundle *data, void *priv)
 204 {
 205         SETTING_TRACE_BEGIN;
 206         SettingDisplayUG *ad = (SettingDisplayUG *) priv;
 207         if (!ug)
 208                 return;
 209
 210         switch (event) {
 211         case UG_KEY_EVENT_END:
 212                 {
 213                         if (elm_naviframe_top_item_get(ad->navi_bar) ==
 214                            elm_naviframe_bottom_item_get(ad->navi_bar)) {
 215                                 ug_destroy_me(ug);
 216                         } else {
 217                                 if (&setting_view_display_brightness ==
 218                                     setting_view_node_get_cur_view()) {
 219                                 }
 220                                 setting_view_cb_at_endKey(ad);
 221                         }
 222                 }
 223                 break;
 224         default:
 225                 break;
 226         }
 227 }
 228
 229 UG_MODULE_API int UG_MODULE_INIT(struct ug_module_ops *ops)
 230 {
 231         SETTING_TRACE_BEGIN;
 232         SettingDisplayUG *displayUG = calloc(1, sizeof(SettingDisplayUG));
 233         setting_retvm_if(!displayUG, -1, "Create SettingDisplayUG obj failed");
 234
 235         ops->create = setting_display_ug_on_create;
 236         ops->start = setting_display_ug_on_start;
 237         ops->pause = setting_display_ug_on_pause;
 238         ops->resume = setting_display_ug_on_resume;
 239         ops->destroy = setting_display_ug_on_destroy;
 240         ops->message = setting_display_ug_on_message;
 241         ops->event = setting_display_ug_on_event;
 242         ops->key_event = setting_display_ug_on_key_event;
 243         ops->priv = displayUG;
 244         ops->opt = UG_OPT_INDICATOR_ENABLE;
 245
 246         return 0;
 247 }
 248
 249 UG_MODULE_API void UG_MODULE_EXIT(struct ug_module_ops *ops)
 250 {
 251         SETTING_TRACE_BEGIN;
 252         struct SettingDisplayUG *displayUG;
 253         setting_retm_if(!ops, "ops == NULL");
 254
 255         displayUG = ops->priv;
 256         if (displayUG) {
 257                 FREE(displayUG);
 258         }
 259 }
 260
 261 /* ***************************************************
 262  *
 263  *general func
 264  *
 265  ***************************************************/
 266
 267 void setting_display_layout_ug_cb(struct ui_gadget *ug, enum ug_mode mode,
 268                                   void *priv)
 269 {
 270         SettingDisplayUG *ad = (SettingDisplayUG *) priv;
 271         Evas_Object *base;
 272
 273         if (!ug || !priv)
 274                 return;
 275         SETTING_TRACE_BEGIN;
 276
 277         base = (Evas_Object *) ug_get_layout(ug);
 278         if (!base)
 279                 return;
 280
 281         switch (mode) {
 282         case UG_MODE_FULLVIEW:
 283                 evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND,
 284                                                  EVAS_HINT_EXPAND);
 285                 elm_win_resize_object_add(ad->win_get, base);
 286                 evas_object_show(base);
 287                 break;
 288         default:
 289                 break;
 290         }
 291
 292         SETTING_TRACE_END;
 293 }
 294
 295 /*  NESTED*/
 296 static int setting_reset_display_brightness(void)
 297 {
 298         SETTING_TRACE_BEGIN;
 299         int ret = 0;
 300
 301         ret += vconf_set_bool(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_BOOL, FALSE);
 302         ret += vconf_set_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, SETTING_BRIGHTNESS_LEVEL_FOR_EMUL);
 303 #if USE_DEVICE_SET_DISPLAY_BRT
 304         ret += device_set_display_brt(DEV_MAIN_DISPLAY, SETTING_BRIGHTNESS_LEVEL_FOR_EMUL);
 305 #endif
 306         SETTING_TRACE_END;
 307         return ret;
 308 }
 309
 310 /*  NESTED*/
 311 static int setting_reset_display_backlight(void)
 312 {
 313         SETTING_TRACE_BEGIN;
 314         int ret = 0;
 315
 316         if (isEmulBin()) {
 317                 ret += vconf_set_int(VCONFKEY_SYSMAN_LCD_TIMEOUT_NORMAL,
 318                                 SETTING_BACKLIGHT_TIME_10MIN);
 319         }
 320         else {
 321                 ret += vconf_set_int(VCONFKEY_SYSMAN_LCD_TIMEOUT_NORMAL,
 322                                 SETTING_BACKLIGHT_TIME_30SEC);
 323         }
 324         SETTING_TRACE_END;
 325         return ret;
 326 }
 327
 328 /*  NESTED*/
 329 static int setting_reset_home_wallpaper(void)
 330 {
 331         SETTING_TRACE_BEGIN;
 332         int ret = 0;
 333         ret += vconf_set_str(VCONFKEY_BGSET, IMG_DEFAULT_HOME_SCREEN);
 334         SETTING_TRACE_END;
 335         return ret;
 336 }
 337
 338 /*  NESTED*/
 339 static int setting_reset_display_lc_screen(void)
 340 {
 341         SETTING_TRACE_BEGIN;
 342         int ret = 0;
 343         ret += vconf_set_str(VCONFKEY_IDLE_LOCK_BGSET, IMG_DEFAULT_HOME_SCREEN);
 344         ret += setting_invoke_reset_function("/opt/ug/lib/libug-setting-lock.so", NULL, NULL);
 345         return ret;
 346 }
 347
 348 static void setting_reset_launch_effect()
 349 {
 350         SETTING_TRACE_BEGIN;
 351         Evas_Object *win_main = ug_get_window();
 352         Ecore_X_Window xwin = elm_win_xwindow_get(win_main);
 353         Ecore_X_Window root = 0;
 354         if (0 != xwin)
 355         {
 356             root = ecore_x_window_root_get(xwin);
 357         }
 358         if (0 != root)
 359         {
 360                 Ecore_X_Atom effect_enable_atom = ecore_x_atom_get("_NET_CM_EFFECT_ENABLE");
 361                 ret_if(!effect_enable_atom);
 362                 unsigned int is_enable = 0;
 363                 ecore_x_window_prop_card32_set(root, effect_enable_atom, &is_enable, 1);
 364         }
 365
 366 }
 367
 368 /*  NESTED*/
 369 /** @todo setting_display_main_effect_set_value work? */
 370 static int setting_reset_display_main(void)
 371 {
 372         SETTING_TRACE_BEGIN;
 373         int ret = 0;
 374         ret += setting_reset_display_backlight();
 375         ret += setting_reset_display_brightness();
 376
 377         ret += vconf_set_bool(VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL, FALSE);//battery percent
 378         ret += vconf_set_bool(VCONFKEY_LAUNCH_EFFECT, FALSE);//launch image
 379
 380         setting_reset_launch_effect();
 381
 382         return ret;
 383 }
 384
 385
 386
 387 /*****/
 388 UG_MODULE_API int setting_plugin_reset(bundle *data, void *priv)
 389 {
 390         SETTING_TRACE_BEGIN;
 391
 392         int ret = 0;
 393         const char *ug_type = bundle_get_val(data, "viewtype"); /*  usb */
 394         SETTING_TRACE("ug_type:%s", ug_type);
 395         if (0 == safeStrCmp(ug_type, "wallpaper")) {
 396
 397 #if SUPPORT_RUN_SYSTEM_COMMAND
 398                 ret += excuteCmd(SETTING_POSTINST_FILE, 1, "wallpaper");
 399                 ret += setting_invoke_reset_function("/opt/ug/lib/libug-setting-lock.so", NULL, NULL);
 400 #else
 401                 ret += setting_reset_home_wallpaper();
 402                 ret += setting_reset_display_lc_screen();
 403 #endif
 404
 405         } else if (0 == safeStrCmp(ug_type, "main")) {
 406 #if SUPPORT_RUN_SYSTEM_COMMAND
 407                 ret += excuteCmd(SETTING_POSTINST_FILE, 1, "display");
 408                 setting_reset_launch_effect();
 409 #else
 410                 ret +=  setting_reset_display_main();
 411 #endif
 412         }
 413         return ret;
 414 }
 415
 416 /*****/