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