setting-display/src/setting-display.c

   1 /*
   2  * setting
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd.
   5  *
   6  * Contact: MyoungJune Park <mj2004.park@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 /**
  23  *@defgroup setting-display
  24  *UG creation code for setting-display
  25  *
  26  *  - Screen Mode
  27  *  - Backlight time
  28  *  - Smart Screen
  29  *  - Battery percentage
  30  */
  31
  32 #include <setting-display.h>
  33 #include <Ecore_X.h>
  34
  35 #define SETTING_BRIGHTNESS_LEVEL_FOR_EMUL 24
  36
  37 #ifndef UG_MODULE_API
  38 #define UG_MODULE_API __attribute__ ((visibility("default")))
  39 #endif
  40
  41 setting_view *__get_display_view_to_load(service_h service)
  42 {
  43         SETTING_TRACE_BEGIN;
  44
  45         char *viewtype = NULL;
  46
  47         service_get_extra_data(service, "viewtype", &viewtype);
  48         if(!viewtype)
  49                 return NULL;
  50
  51         SETTING_TRACE("viewtype:%s", viewtype);
  52
  53         if (!safeStrCmp(viewtype, "brightness")) {
  54                 setting_view_node_table_register(&setting_view_display_brightness,
  55                                                  NULL);
  56                 return &setting_view_display_brightness;
  57         } else if (!safeStrCmp(viewtype, "wallpaper")) {
  58                 setting_view_node_table_register(&setting_view_display_wallpaper, NULL);
  59                 return &setting_view_display_wallpaper;
  60         } else {
  61                 setting_view_node_table_register(&setting_view_display_main, NULL);
  62                 setting_view_node_table_register(&setting_view_display_screen_mode,
  63                                                  &setting_view_display_main);
  64                 setting_view_node_table_register(&setting_view_display_brightness,
  65                                                  &setting_view_display_main);
  66                 setting_view_node_table_register(&setting_view_display_smart_screen,
  67                                                  &setting_view_display_main);
  68                 return &setting_view_display_main;
  69         }
  70
  71 }
  72
  73 Evas_Object *__get_display_layout_to_return(service_h service, void *priv)
  74 {
  75         SETTING_TRACE_BEGIN;
  76         SettingDisplayUG *displayUG = priv;
  77         char *viewtype = NULL;
  78
  79         service_get_extra_data(service, "viewtype", &viewtype);
  80         if(!viewtype)
  81                 return NULL;
  82
  83         SETTING_TRACE("viewtype:%s", viewtype);
  84
  85         if (!safeStrCmp(viewtype, "wallpaper")) {
  86                 return displayUG->ly_wall;
  87         } else {
  88                 return displayUG->ly_main;
  89         }
  90
  91 }
  92
  93 static void setting_display_ug_cb_resize(void *data, Evas *e,
  94                                          Evas_Object *obj, void *event_info)
  95 {
  96         SettingDisplayUG *ad = (SettingDisplayUG *) data;
  97         setting_view_update(ad->view_to_load, ad);
  98 }
  99
 100 static void *setting_display_ug_on_create(ui_gadget_h ug,
 101                                           enum ug_mode mode, service_h service,
 102                                           void *priv)
 103 {
 104         setting_retvm_if((!priv), NULL, "!priv");
 105
 106         SettingDisplayUG *displayUG = priv;
 107         displayUG->ug = ug;
 108         appcore_set_i18n(SETTING_PACKAGE, SETTING_LOCALEDIR);
 109
 110         displayUG->win_main_layout = (Evas_Object *) ug_get_parent_layout(ug);
 111         displayUG->win_get = (Evas_Object *) ug_get_window();
 112
 113         evas_object_show(displayUG->win_main_layout);
 114         displayUG->evas = evas_object_evas_get(displayUG->win_main_layout);
 115
 116         setting_retvm_if(displayUG->win_main_layout == NULL, NULL,
 117                          "cannot get main window ");
 118
 119
 120         /* register view node table */
 121         setting_view_node_table_intialize();
 122
 123         setting_create_Gendial_itc("dialogue/2text.3",
 124                                    &(displayUG->itc_2text_2));
 125         setting_create_Gendial_itc("dialogue/1text.1icon",
 126                                    &(displayUG->itc_1text_1icon));
 127         setting_create_Gendial_itc("dialogue/1icon", &(displayUG->itc_layout));
 128         setting_create_Gendial_itc("dialogue/2text.3/expandable",
 129                                    &(displayUG->itc_2text_3_parent));
 130         setting_create_Gendial_itc("dialogue/1text.1icon/expandable2",
 131                                    &(displayUG->itc_1icon_1text_sub));
 132         setting_create_Gendial_itc("dialogue/1text", &(displayUG->itc_1text));
 133
 134         displayUG->itc_seperator.item_style = "dialogue/separator/21/with_line";
 135         displayUG->itc_seperator.func.text_get = NULL;
 136         displayUG->itc_seperator.func.content_get = NULL;
 137         displayUG->itc_seperator.func.state_get = NULL;
 138         displayUG->itc_seperator.func.del = NULL;
 139
 140         /*  creating a view. */
 141         displayUG->view_to_load = __get_display_view_to_load(service);
 142         setting_retvm_if(NULL == displayUG->view_to_load, NULL,
 143                          "NULL == displayUG->view_to_load");
 144         setting_view_node_set_cur_view(displayUG->view_to_load);
 145         setting_view_create(displayUG->view_to_load, (void *)displayUG);
 146         evas_object_event_callback_add(displayUG->win_main_layout,
 147                                        EVAS_CALLBACK_RESIZE,
 148                                        setting_display_ug_cb_resize, displayUG);
 149         return __get_display_layout_to_return(service, displayUG);
 150 }
 151
 152 static void setting_display_ug_on_start(ui_gadget_h ug, service_h service,
 153                                         void *priv)
 154 {
 155 }
 156
 157 static void setting_display_ug_on_pause(ui_gadget_h ug, service_h service,
 158                                         void *priv)
 159 {
 160 }
 161
 162 static void setting_display_ug_on_resume(ui_gadget_h ug, service_h service,
 163                                          void *priv)
 164 {
 165 }
 166
 167 static void setting_display_ug_on_destroy(ui_gadget_h ug, service_h service,
 168                                           void *priv)
 169 {
 170         SETTING_TRACE_BEGIN;
 171         setting_retm_if((!priv), "!priv");
 172         SettingDisplayUG *displayUG = priv;
 173
 174         /* fix flash issue for gallery */
 175         evas_object_event_callback_del(displayUG->win_main_layout, EVAS_CALLBACK_RESIZE, setting_display_ug_cb_resize);
 176         displayUG->ug = ug;
 177
 178         /*  called when this shared gadget is terminated. similar with app_exit */
 179         if (&setting_view_display_main == displayUG->view_to_load) {
 180                 setting_view_destroy(&setting_view_display_brightness,
 181                                      displayUG);
 182                 setting_view_destroy(&setting_view_display_screen_mode, displayUG);
 183                 setting_view_destroy(&setting_view_display_smart_screen, displayUG);
 184                 setting_view_destroy(&setting_view_display_main, displayUG);
 185         } else if (&setting_view_display_wallpaper == displayUG->view_to_load) {
 186                 setting_view_destroy(&setting_view_display_wallpaper,
 187                                      displayUG);
 188         } else if (&setting_view_display_brightness == displayUG->view_to_load) {
 189                 setting_view_destroy(&setting_view_display_brightness,
 190                                      displayUG);
 191         }
 192
 193         if (NULL != ug_get_layout(displayUG->ug)) {
 194                 evas_object_hide((Evas_Object *) ug_get_layout(displayUG->ug));
 195                 evas_object_del((Evas_Object *) ug_get_layout(displayUG->ug));
 196         }
 197
 198         SETTING_TRACE_END;
 199 }
 200
 201 static void setting_display_ug_on_message(ui_gadget_h ug, service_h msg,
 202                                           service_h service, void *priv)
 203 {
 204         SETTING_TRACE_BEGIN;
 205 }
 206
 207 static void setting_display_ug_on_event(ui_gadget_h ug,
 208                                         enum ug_event event, service_h service,
 209                                         void *priv)
 210 {
 211         SETTING_TRACE_BEGIN;
 212         switch (event) {
 213         case UG_EVENT_LOW_MEMORY:
 214                 break;
 215         case UG_EVENT_LOW_BATTERY:
 216                 break;
 217         case UG_EVENT_LANG_CHANGE:
 218                 break;
 219         case UG_EVENT_ROTATE_PORTRAIT:
 220                 break;
 221         case UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN:
 222                 break;
 223         case UG_EVENT_ROTATE_LANDSCAPE:
 224                 break;
 225         case UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN:
 226                 break;
 227         case UG_EVENT_REGION_CHANGE:
 228                 break;
 229         default:
 230                 break;
 231         }
 232 }
 233
 234 static void setting_display_ug_on_key_event(ui_gadget_h ug,
 235                                             enum ug_key_event event,
 236                                             service_h service, void *priv)
 237 {
 238         SETTING_TRACE_BEGIN;
 239         SettingDisplayUG *ad = (SettingDisplayUG *) priv;
 240
 241         switch (event) {
 242         case UG_KEY_EVENT_END:
 243                 {
 244                         if (elm_naviframe_top_item_get(ad->navi_bar) ==
 245                            elm_naviframe_bottom_item_get(ad->navi_bar)) {
 246                                 ug_destroy_me(ug);
 247                         } else {
 248                                 if (&setting_view_display_brightness ==
 249                                     setting_view_node_get_cur_view()) {
 250                                 }
 251                                 setting_view_cb_at_endKey(ad);
 252                         }
 253                 }
 254                 break;
 255         default:
 256                 break;
 257         }
 258 }
 259
 260 UG_MODULE_API int UG_MODULE_INIT(struct ug_module_ops *ops)
 261 {
 262         SETTING_TRACE_BEGIN;
 263         SettingDisplayUG *displayUG = calloc(1, sizeof(SettingDisplayUG));
 264         setting_retvm_if(!displayUG, -1, "Create SettingDisplayUG obj failed");
 265
 266         ops->create = setting_display_ug_on_create;
 267         ops->start = setting_display_ug_on_start;
 268         ops->pause = setting_display_ug_on_pause;
 269         ops->resume = setting_display_ug_on_resume;
 270         ops->destroy = setting_display_ug_on_destroy;
 271         ops->message = setting_display_ug_on_message;
 272         ops->event = setting_display_ug_on_event;
 273         ops->key_event = setting_display_ug_on_key_event;
 274         ops->priv = displayUG;
 275         ops->opt = UG_OPT_INDICATOR_ENABLE;
 276
 277         return 0;
 278 }
 279
 280 UG_MODULE_API void UG_MODULE_EXIT(struct ug_module_ops *ops)
 281 {
 282         SETTING_TRACE_BEGIN;
 283         struct SettingDisplayUG *displayUG;
 284         setting_retm_if(!ops, "ops == NULL");
 285
 286         displayUG = ops->priv;
 287         if (displayUG) {
 288                 FREE(displayUG);
 289         }
 290 }
 291
 292 /* ***************************************************
 293  *
 294  *general func
 295  *
 296  ***************************************************/
 297
 298 void setting_display_layout_ug_cb(ui_gadget_h ug, enum ug_mode mode,
 299                                   void *priv)
 300 {
 301         SettingDisplayUG *ad = (SettingDisplayUG *) priv;
 302         Evas_Object *base;
 303
 304         if (!priv)
 305                 return;
 306         SETTING_TRACE_BEGIN;
 307
 308         base = (Evas_Object *) ug_get_layout(ug);
 309         if (!base)
 310                 return;
 311
 312         switch (mode) {
 313         case UG_MODE_FULLVIEW:
 314                 evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND,
 315                                                  EVAS_HINT_EXPAND);
 316                 elm_win_resize_object_add(ad->win_get, base);
 317                 evas_object_show(base);
 318                 break;
 319         default:
 320                 break;
 321         }
 322
 323         SETTING_TRACE_END;
 324 }
 325
 326 /*  NESTED*/
 327 static int setting_reset_display_brightness(void)
 328 {
 329         SETTING_TRACE_BEGIN;
 330         int ret = 0;
 331
 332         ret += vconf_set_int(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, SETTING_BRIGHTNESS_AUTOMATIC_OFF);
 333
 334         if(isEmulBin())
 335         {
 336                 ret += vconf_set_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, SETTING_BRIGHTNESS_LEVEL_FOR_EMUL);
 337 #if USE_DEVICE_SET_DISPLAY_BRT
 338                 ret += device_set_brightness(BRIGHTNESS_DISPLAY, SETTING_BRIGHTNESS_LEVEL_FOR_EMUL);
 339 #endif
 340         }
 341         else
 342         {
 343                 ret += vconf_set_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, SETTING_BRIGHTNESS_LEVEL7);
 344 #if USE_DEVICE_SET_DISPLAY_BRT
 345                 ret += device_set_brightness(BRIGHTNESS_DISPLAY, SETTING_BRIGHTNESS_LEVEL7);;
 346 #endif
 347         }
 348         SETTING_TRACE_END;
 349         return ret;
 350 }
 351
 352 /*  NESTED*/
 353 static int setting_reset_display_backlight(void)
 354 {
 355         SETTING_TRACE_BEGIN;
 356         int ret = 0;
 357 #if SUPPORT_LCD_TIMEOUT_KEEPING
 358         ret += vconf_set_int(VCONFKEY_LCD_TIMEOUT_NORMAL_BACKUP, 0);
 359 #else
 360         if(isEmulBin())
 361                 ret += vconf_set_int(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, 0);
 362         else
 363                 ret += vconf_set_int(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, 30);
 364 #endif
 365         SETTING_TRACE_END;
 366         return ret;
 367 }
 368
 369 /*  NESTED*/
 370 static int setting_reset_home_wallpaper(void)
 371 {
 372         SETTING_TRACE_BEGIN;
 373         int ret = 0;
 374         ret += vconf_set_str(VCONFKEY_BGSET, IMG_DEFAULT_HOME_SCREEN);
 375         SETTING_TRACE_END;
 376         return ret;
 377 }
 378
 379 /*  NESTED*/
 380 static int setting_reset_display_lc_screen(void)
 381 {
 382         SETTING_TRACE_BEGIN;
 383         int ret = 0;
 384         ret += vconf_set_str(VCONFKEY_IDLE_LOCK_BGSET, IMG_DEFAULT_HOME_SCREEN);
 385         ret += setting_invoke_reset_function("/opt/ug/lib/libug-setting-lock.so", 0, NULL);
 386         return ret;
 387 }
 388
 389 static void setting_reset_launch_effect()
 390 {
 391         SETTING_TRACE_BEGIN;
 392         Evas_Object *win_main = ug_get_window();
 393         Ecore_X_Window xwin = elm_win_xwindow_get(win_main);
 394         Ecore_X_Window root = 0;
 395         if (0 != xwin)
 396         {
 397             root = ecore_x_window_root_get(xwin);
 398         }
 399         if (0 != root)
 400         {
 401                 Ecore_X_Atom effect_enable_atom = ecore_x_atom_get("_NET_CM_EFFECT_ENABLE");
 402                 ret_if(!effect_enable_atom);
 403                 unsigned int is_enable = 0;
 404                 ecore_x_window_prop_card32_set(root, effect_enable_atom, &is_enable, 1);
 405         }
 406
 407 }
 408
 409 /*  NESTED*/
 410 /** @todo setting_display_main_effect_set_value work? */
 411 static int setting_reset_display_main(void)
 412 {
 413         SETTING_TRACE_BEGIN;
 414         int ret = 0;
 415         ret += setting_reset_display_backlight();
 416         ret += setting_reset_display_brightness();
 417
 418         ret += vconf_set_bool(VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL, FALSE);//battery percent
 419         setting_reset_launch_effect();
 420
 421         // smart screen
 422         ret += vconf_set_int(VCONFKEY_PM_SMARTSTAY_STATUS, 0);
 423         ret += vconf_set_bool(VCONFKEY_SETAPPL_SMARTSCREEN_SMART_ROTATION, FALSE);
 424         return ret;
 425 }
 426
 427
 428
 429 /*****/
 430 UG_MODULE_API int setting_plugin_reset(service_h service, void *priv)
 431 {
 432         SETTING_TRACE_BEGIN;
 433
 434         int ret = 0;
 435         char *ug_type = NULL;
 436
 437         service_get_extra_data(service, "viewtype", &ug_type);
 438         SETTING_TRACE("ug_type:%s", ug_type);
 439         if (0 == safeStrCmp(ug_type, "wallpaper")) {
 440                 /*ret += setting_reset_home_wallpaper();
 441                 ret += setting_reset_display_lc_screen();*/
 442 #if SUPPORT_RUN_SYSTEM_COMMAND
 443                 ret += excuteCmd(SETTING_POSTINST_FILE, 1, "wallpaper");
 444                 ret += setting_invoke_reset_function("/opt/ug/lib/libug-setting-lock.so", service, NULL);
 445 #else
 446                 ret += setting_reset_home_wallpaper();
 447                 ret += setting_reset_display_lc_screen();
 448 #endif
 449
 450         } else if (0 == safeStrCmp(ug_type, "main")) {
 451 #if SUPPORT_RUN_SYSTEM_COMMAND
 452                 ret += excuteCmd(SETTING_POSTINST_FILE, 1, "display");
 453                 setting_reset_launch_effect();
 454 #else
 455                 ret +=  setting_reset_display_main();
 456 #endif
 457         }
 458         return ret;
 459 }
 460
 461 /*****/