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 #include <setting-display.h>
  23 #include <Ecore_X.h>
  24 #include <utilX.h>
  25
  26 #include <Eina.h>
  27
  28 #include <setting-cfg.h>
  29
  30 #define SETTING_BRIGHTNESS_DEFAULT_LEVEL 60
  31
  32 #ifndef UG_MODULE_API
  33 #define UG_MODULE_API __attribute__ ((visibility("default")))
  34 #endif
  35
  36 /**
  37  * view selection by service variable
  38  *
  39  * viewtype == 'brightness' --> setting_view_display_brightness
  40  * viewtype != NULL && viewtype --> setting_view_display_main
  41  */
  42 setting_view *__get_display_view_to_load(void *data, app_control_h service)
  43 {
  44         SETTING_TRACE_BEGIN;
  45         setting_retvm_if((!data), NULL, "!data");
  46
  47         SettingDisplayUG *displayUG = (SettingDisplayUG *)data;
  48         char *viewtype = NULL;
  49         char *uri = NULL;
  50         int ret = 0;
  51         ret = app_control_get_uri(service, &uri);
  52         if (!ret && uri) {
  53                 SETTING_TRACE("uri:%s", uri);
  54                 if (!safeStrCmp(uri, URI_SMART_STAY)) {
  55                         /*setting_view_node_table_register(&setting_view_display_smart_screen_smart_stay, NULL); */
  56                         FREE(uri);
  57                         return NULL;
  58                 } else if (!safeStrCmp(uri, URI_SMART_ROTATION)) {
  59                         /*setting_view_node_table_register(&setting_view_display_smart_screen_smart_rotation, NULL); */
  60                         FREE(uri);
  61                         return NULL;
  62                 }
  63         } else {
  64                 app_control_get_extra_data(service, "viewtype", &viewtype);
  65                 if (!viewtype) {
  66                         return NULL;
  67                 }
  68
  69                 SETTING_TRACE_DEBUG("viewtype:%s", viewtype);
  70
  71                 if (!safeStrCmp(viewtype, "brightness")) {
  72                         setting_view_node_table_register(&setting_view_display_brightness, NULL);
  73                         FREE(viewtype);
  74                         return &setting_view_display_brightness;
  75                 } else if (!safeStrCmp(viewtype, "backlight")) {
  76                         setting_view_node_table_register(&setting_view_display_backlight, NULL);
  77                         FREE(viewtype);
  78                         return &setting_view_display_backlight;
  79 #if SUPPORT_SMARTSCREEN
  80                 } else if (!safeStrCmp(viewtype, "smartscreen")) {
  81                         setting_view_node_table_register(&setting_view_display_smart_screen, NULL);
  82                         setting_view_node_table_register(&setting_view_display_smart_screen_help,
  83                                                          &setting_view_display_smart_screen);
  84                         FREE(viewtype);
  85                         return &setting_view_display_smart_screen;
  86                 } else if (!safeStrCmp(viewtype, "screenmode")) {
  87                         setting_view_node_table_register(&setting_view_display_screen_mode, NULL);
  88                         FREE(viewtype);
  89                         return &setting_view_display_screen_mode;
  90 #endif
  91                 } else {
  92                         if (!safeStrCmp(viewtype, "frontpage_backlight")) {
  93                                 displayUG->display_expand_state = DISPLAY_EXPAND_BACKLIGHT;
  94                         } else if (!safeStrCmp(viewtype, "frontpage_duration")) {
  95                                 displayUG->display_expand_state = DISPLAY_EXPAND_TOUCH_KEY_LIGHT_DURATION;
  96                         } else {
  97                                 displayUG->display_expand_state = DISPLAY_EXPAND_NONE;
  98                         }
  99                         setting_view_node_table_register(&setting_view_display_main, NULL);
 100                         setting_view_node_table_register(&setting_view_display_brightness,
 101                                                          &setting_view_display_main);
 102 #if SUPPORT_SMARTSCREEN
 103                         setting_view_node_table_register(&setting_view_display_screen_mode,
 104                                                          &setting_view_display_main);
 105                         setting_view_node_table_register(&setting_view_display_smart_screen,
 106                                                          &setting_view_display_main);
 107                         setting_view_node_table_register(&setting_view_display_smart_screen_smart_stay,
 108                                                          &setting_view_display_smart_screen);
 109                         setting_view_node_table_register(&setting_view_display_smart_screen_smart_rotation,
 110                                                          &setting_view_display_smart_screen);
 111 #endif
 112                         FREE(viewtype);
 113                         return &setting_view_display_main;
 114                 }
 115         }
 116         return NULL;
 117 }
 118
 119 /**
 120  * return view layout
 121  *
 122  * viewtype != 'wallpaper' --> ly_main
 123  */
 124 Evas_Object *__get_display_layout_to_return(app_control_h service, void *priv)
 125 {
 126         SETTING_TRACE_BEGIN;
 127         SettingDisplayUG *displayUG = priv;
 128         char *viewtype = NULL;
 129         char *uri = NULL;
 130         int ret = 0;
 131         ret = app_control_get_uri(service, &uri);
 132         if (!ret && uri) {
 133                 return displayUG->ly_main;
 134         }
 135         app_control_get_extra_data(service, "viewtype", &viewtype);
 136         if (!viewtype) {
 137                 return NULL;
 138         }
 139
 140         SETTING_TRACE("viewtype:%s", viewtype);
 141
 142         FREE(viewtype);
 143         return displayUG->ly_main;
 144
 145 }
 146
 147
 148 static void setting_display_ug_cb_resize(void *data, Evas *e,
 149                                          Evas_Object *obj, void *event_info)
 150 {
 151         SettingDisplayUG *ad = (SettingDisplayUG *) data;
 152         setting_view_update(ad->view_to_load, ad);
 153 }
 154 /*help smart scren popup*/
 155 Eina_Bool __show_smartstay_guide_popup(void *data)
 156 {
 157         SETTING_TRACE_BEGIN;
 158         /* error check */
 159         setting_retvm_if(data == NULL, ECORE_CALLBACK_CANCEL,
 160                          "[Setting > Display] Data parameter is NULL");
 161
 162         SettingDisplayUG *ad = (SettingDisplayUG *) data;
 163         setting_retvm_if(ad->smart_stay_sublayout == NULL, ECORE_CALLBACK_CANCEL,
 164                          "[Setting > Display] Dad->smart_stay_sublayout parameter is NULL");
 165
 166         /*hide top popup*/
 167         elm_object_signal_emit(ad->smart_stay_sublayout, "elm,state,top,hide", "elm");
 168         /*show center popup*/
 169         elm_object_signal_emit(ad->smart_stay_sublayout, "elm,state,center,show", "elm");
 170         return ECORE_CALLBACK_CANCEL;
 171 }
 172 Eina_Bool __show_smartrotation_guide_popup(void *data)
 173 {
 174         SETTING_TRACE_BEGIN;
 175         /* error check */
 176         setting_retvm_if(data == NULL, ECORE_CALLBACK_CANCEL,
 177                          "[Setting > Display] Data parameter is NULL");
 178
 179         SettingDisplayUG *ad = (SettingDisplayUG *) data;
 180         setting_retvm_if(ad->smart_rotation_sublayout == NULL, ECORE_CALLBACK_CANCEL,
 181                          "[Setting > Display] ad->smart_rotation_sublayout parameter is NULL");
 182         /*hide top popup*/
 183         elm_object_signal_emit(ad->smart_rotation_sublayout, "elm,state,top,hide", "elm");
 184         /*show center popup*/
 185         elm_object_signal_emit(ad->smart_rotation_sublayout, "elm,state,center,show", "elm");
 186         return ECORE_CALLBACK_CANCEL;
 187 }
 188
 189 static void
 190 __help_popup_on_resp_cb(void *data, Evas_Object *obj, void *event_info)
 191 {
 192         SETTING_TRACE_BEGIN;
 193         int response_type = btn_type(obj);
 194         SettingDisplayUG *ad = (SettingDisplayUG *) data;
 195
 196         /* prevent CID35750 (by sunyeop.hwang@20131109) */
 197         /*const char *btnstr = elm_entry_markup_to_utf8(elm_object_text_get(obj)); */
 198
 199         if (POPUP_RESPONSE_OK == response_type) {       /*need set vconf */
 200 #if SUPPORT_SMARTSCREEN
 201                 SETTING_TRACE("need to set vconf");
 202                 int ret = 0;
 203                 if (!safeStrCmp(ad->uri, URI_SMART_STAY)) {
 204                         ret += vconf_set_int(VCONFKEY_SETAPPL_SMARTSCREEN_SMARTSTAY_STATUS, 1);
 205                         SETTING_TRACE("ret:%d", ret);
 206                         if (ad->smart_stay_sublayout) {
 207                                 elm_object_signal_emit(ad->smart_stay_sublayout, "elm,state,top,show", "elm");
 208                                 ad->timer_show_guide = ecore_timer_add(3, (Ecore_Task_Cb)__show_smartstay_guide_popup, ad);
 209                         }
 210                 } else if (!safeStrCmp(ad->uri, URI_SMART_ROTATION)) {
 211                         ret += vconf_set_bool(VCONFKEY_SETAPPL_SMARTSCREEN_SMART_ROTATION, TRUE);
 212                         if (ad->smart_rotation_sublayout) {
 213                                 elm_object_signal_emit(ad->smart_rotation_sublayout, "elm,state,top,show", "elm");
 214                                 ad->timer_show_guide = ecore_timer_add(3, (Ecore_Task_Cb)__show_smartrotation_guide_popup, ad);
 215                         }
 216                 }
 217 #endif
 218                 if (ad->help_popup) {
 219                         evas_object_del(ad->help_popup);
 220                         ad->help_popup = NULL;
 221                 }
 222         } else if (POPUP_RESPONSE_CANCEL == response_type) {    /*need rollback */
 223                 evas_object_hide(ad->help_popup);
 224                 SETTING_TRACE("ad->ug:%p", ad->ug);
 225                 ug_destroy_me(ad->ug);
 226         }
 227 }
 228
 229 static Eina_Bool __help_key_press_cb(void *data, int type, void *event)
 230 {
 231         SETTING_TRACE_BEGIN;
 232         Evas_Event_Key_Down *ev = event;
 233         if (!ev || !data) {
 234                 SETTING_TRACE("Invalid event object");
 235                 return ECORE_CALLBACK_RENEW;
 236         }
 237         SETTING_TRACE("Pressed %s", ev->keyname);
 238         SettingDisplayUG *ad = (SettingDisplayUG *) data;
 239
 240         if (!strcmp(ev->keyname, KEY_BACK)) {
 241                 /*evas_object_hide(obj); // you can call evas_object_del(obj); to remove popup if you want */
 242                 if (ad->help_popup) {
 243                         popup_handle_hardkey(ad, ad->help_popup);
 244                 }
 245         }
 246
 247         return ECORE_CALLBACK_RENEW;
 248 }
 249
 250 static void *___help_popup_view(ui_gadget_h ug,
 251                                 enum ug_mode mode, app_control_h service,
 252                                 void *priv)
 253
 254 {
 255         SETTING_TRACE_BEGIN;
 256         SettingDisplayUG *ad = priv;
 257         int sub_value = 0;
 258
 259         char buf[MAX_COMMON_BUFFER_LEN] = {0,};
 260
 261         int ret = app_control_get_uri(service, &ad->uri);
 262         if (!ret && ad->uri) {
 263 #if SUPPORT_SMARTSCREEN
 264                 if (!safeStrCmp(ad->uri, URI_SMART_STAY)) {
 265                         vconf_get_int(VCONFKEY_SETAPPL_SMARTSCREEN_SMARTSTAY_STATUS, &sub_value);
 266                         snprintf(buf, sizeof(buf) , "%s", SETTING_DISPLAY_SMART_SCREEN_TURN_ON_SMART_STAY_POPUP);
 267                 } else if (!safeStrCmp(ad->uri, URI_SMART_ROTATION)) {
 268                         vconf_get_bool(VCONFKEY_SETAPPL_SMARTSCREEN_SMART_ROTATION, &sub_value);
 269                         snprintf(buf, sizeof(buf) , "%s", SETTING_DISPLAY_SMART_SCREEN_TURN_ON_SMART_ROATION_POPUP);
 270                 }
 271 #endif
 272
 273                 ad->help_event_handler = ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, __help_key_press_cb, ad);
 274
 275                 if (!sub_value) {
 276                         SETTING_TRACE("uri:%s", ad->uri);
 277                         if (ad->help_popup) {
 278                                 evas_object_del(ad->help_popup);
 279                                 ad->help_popup = NULL;
 280                         }
 281
 282                         ad->help_popup =
 283                             setting_create_popup_with_btn(ad, ad->win_main_layout,
 284                                                           NULL, buf,
 285                                                           __help_popup_on_resp_cb, 0,
 286                                                           2, POPUP_TURN_ON_STR, "IDS_COM_SK_CANCEL");
 287                         /*evas_object_data_set(ad->popup, "text0", MOTION_DISABLED_DSC); */
 288                         /*evas_object_data_set(ad->popup, "text", USE_MOTION_TO_TRY_TUTORIAL); */
 289
 290                         return ad->help_popup;
 291                 } else {
 292
 293                 }
 294         }
 295
 296         return NULL;
 297 }
 298
 299 static void *setting_display_ug_on_create(ui_gadget_h ug,
 300                                           enum ug_mode mode, app_control_h service,
 301                                           void *priv)
 302 {
 303         setting_retvm_if((!priv), NULL, "!priv");
 304         SETTING_TRACE_BEGIN;
 305
 306         SettingDisplayUG *displayUG = priv;
 307         displayUG->ug = ug;
 308         setting_set_i18n(SETTING_PACKAGE, SETTING_LOCALEDIR);
 309
 310         displayUG->win_main_layout = (Evas_Object *) ug_get_parent_layout(ug);
 311         displayUG->win_get = (Evas_Object *) ug_get_window();
 312
 313         /*evas_object_show(displayUG->win_main_layout); */
 314         displayUG->evas = evas_object_evas_get(displayUG->win_main_layout);
 315
 316         setting_retvm_if(displayUG->win_main_layout == NULL, NULL,
 317                          "cannot get main window ");
 318
 319         (void)___help_popup_view(ug, mode, service, priv);
 320         /* register view node table */
 321         setting_view_node_table_intialize();
 322
 323         setting_create_Gendial_itc("2line.top", &(displayUG->itc_2text_2));
 324         setting_create_Gendial_itc("1line", &(displayUG->itc_1text_1icon));
 325
 326         setting_create_Gendial_itc("1line", &(displayUG->itc_1icon_1text_sub));
 327
 328         setting_create_Gendial_itc("1line", &(displayUG->itc_1text));
 329         setting_create_Gendial_itc("1line", &(displayUG->itc_2text_3));
 330         setting_create_Gendial_itc("1line", &(displayUG->itc_1text_1icon_divider));
 331
 332         /*  creating a view. */
 333         displayUG->view_to_load = __get_display_view_to_load(displayUG, service);
 334         setting_retvm_if(NULL == displayUG->view_to_load, NULL,
 335                          "NULL == displayUG->view_to_load");
 336         setting_view_node_set_cur_view(displayUG->view_to_load);
 337         setting_view_create(displayUG->view_to_load, (void *)displayUG);
 338         evas_object_event_callback_add(displayUG->win_main_layout,
 339                                        EVAS_CALLBACK_RESIZE,
 340                                        setting_display_ug_cb_resize, displayUG);
 341         return __get_display_layout_to_return(service, displayUG);
 342 }
 343
 344 static void setting_display_ug_on_start(ui_gadget_h ug, app_control_h service,
 345                                         void *priv)
 346 {
 347 }
 348
 349 static void setting_display_ug_on_pause(ui_gadget_h ug, app_control_h service,
 350                                         void *priv)
 351 {
 352         SETTING_TRACE_BEGIN;
 353         setting_retm_if((!priv), "!priv");
 354         SettingDisplayUG *displayUG = priv;
 355 }
 356
 357 static void setting_display_ug_on_resume(ui_gadget_h ug, app_control_h service,
 358                                          void *priv)
 359 {
 360 }
 361
 362 static void setting_display_ug_on_destroy(ui_gadget_h ug, app_control_h service,
 363                                           void *priv)
 364 {
 365         SETTING_TRACE_BEGIN;
 366         setting_retm_if((!priv), "!priv");
 367         SettingDisplayUG *displayUG = priv;
 368
 369         /* fix flash issue for gallery */
 370         evas_object_event_callback_del(displayUG->win_main_layout, EVAS_CALLBACK_RESIZE, setting_display_ug_cb_resize);
 371         displayUG->ug = ug;
 372
 373         FREE(displayUG->uri);
 374         if (displayUG->help_popup) {
 375                 evas_object_del(displayUG->help_popup);
 376                 displayUG->help_popup = NULL;
 377         }
 378
 379         /*  called when this shared gadget is terminated. similar with app_exit */
 380         if (&setting_view_display_main == displayUG->view_to_load) {
 381                 setting_view_destroy(&setting_view_display_brightness, displayUG);
 382 #if SUPPORT_SMARTSCREEN
 383                 setting_view_destroy(&setting_view_display_smart_screen_smart_rotation, displayUG);
 384                 setting_view_destroy(&setting_view_display_smart_screen_smart_stay, displayUG);
 385                 setting_view_destroy(&setting_view_display_screen_mode, displayUG);
 386                 setting_view_destroy(&setting_view_display_smart_screen, displayUG);
 387 #endif
 388                 setting_view_destroy(&setting_view_display_main, displayUG);
 389         } else if (&setting_view_display_brightness == displayUG->view_to_load) {
 390                 setting_view_destroy(&setting_view_display_brightness, displayUG);
 391         } else if (&setting_view_display_backlight == displayUG->view_to_load) {
 392                 setting_view_destroy(&setting_view_display_backlight, displayUG);
 393 #if SUPPORT_SMARTSCREEN
 394         } else if (&setting_view_display_screen_mode == displayUG->view_to_load) {
 395                 setting_view_destroy(&setting_view_display_screen_mode, displayUG);
 396         } else if (&setting_view_display_smart_screen == displayUG->view_to_load) {
 397                 setting_view_destroy(&setting_view_display_smart_screen_smart_rotation, displayUG);
 398                 setting_view_destroy(&setting_view_display_smart_screen_smart_stay, displayUG);
 399                 setting_view_destroy(&setting_view_display_smart_screen, displayUG);
 400         } else if (&setting_view_display_smart_screen_smart_stay == displayUG->view_to_load) {
 401                 setting_view_destroy(&setting_view_display_smart_screen_smart_stay, displayUG);
 402         } else if (&setting_view_display_smart_screen_smart_rotation == displayUG->view_to_load) {
 403                 setting_view_destroy(&setting_view_display_smart_screen_smart_rotation, displayUG);
 404 #endif
 405         }
 406
 407         if (NULL != ug_get_layout(displayUG->ug)) {
 408                 evas_object_hide((Evas_Object *) ug_get_layout(displayUG->ug));
 409                 evas_object_del((Evas_Object *) ug_get_layout(displayUG->ug));
 410         }
 411
 412         SETTING_TRACE_END;
 413 }
 414
 415 static void setting_display_ug_on_message(ui_gadget_h ug, app_control_h msg,
 416                                           app_control_h service, void *priv)
 417 {
 418         SETTING_TRACE_BEGIN;
 419 }
 420
 421 static void setting_display_ug_on_event(ui_gadget_h ug,
 422                                         enum ug_event event, app_control_h service,
 423                                         void *priv)
 424 {
 425         SETTING_TRACE_BEGIN;
 426         SettingDisplayUG *ad = priv;
 427         setting_retm_if(NULL == ad, "ad is NULL");
 428         switch (event) {
 429                 case UG_EVENT_LOW_MEMORY:
 430                         break;
 431                 case UG_EVENT_LOW_BATTERY:
 432                         break;
 433                 case UG_EVENT_LANG_CHANGE:
 434                         setting_navi_items_update(ad->navi_bar);
 435                         break;
 436                 case UG_EVENT_ROTATE_PORTRAIT:
 437                 case UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN: {
 438
 439                                 int h = 0;
 440                                 int w = 0;
 441 #if 0
 442                                 app_device_orientation_e m = elm_win_rotation_get(ad->win_get);
 443
 444                                 if (APP_DEVICE_ORIENTATION_90 == m || APP_DEVICE_ORIENTATION_270 == m) {
 445                                         ecore_x_window_size_get(ecore_x_window_root_first_get(), &h, &w);
 446
 447                                 } else {
 448                                         ecore_x_window_size_get(ecore_x_window_root_first_get(), &w, &h);
 449                                         h = h - 60;
 450                                 }
 451                                 SETTING_TRACE("m:%d", m);
 452 #endif
 453                                 h = SAMRT_SCREEN_TRY_IT_IAMGE_PORTRAIT_H;
 454                                 w = SAMRT_SCREEN_TRY_IT_IAMGE_PORTRAIT_W;
 455                                 if (ad->smart_rotation_image) {
 456                                         elm_win_indicator_opacity_set(ad->win_get, ELM_WIN_INDICATOR_TRANSPARENT);
 457                                         /*elm_win_indicator_mode_set(ad->win_get,ELM_WIN_INDICATOR_HIDE); */
 458                                         SETTING_TRACE("indicator is in TRANSPARENT mode");
 459                                         evas_object_image_file_set(ad->smart_rotation_image, SMART_SCREEN_TRY_IT_IMAGE_P, NULL);
 460                                         evas_object_size_hint_weight_set(ad->smart_rotation_image, 0.0, EVAS_HINT_EXPAND);
 461                                         evas_object_image_fill_set(ad->smart_rotation_image, 0, 0, w, h);
 462                                         evas_object_image_border_set(ad->smart_rotation_image, 16, 16, 16, 16); /*for round corner */
 463                                         evas_object_image_filled_set(ad->smart_rotation_image, 1); /*to full fill */
 464                                         evas_object_size_hint_min_set(ad->smart_rotation_image, ELM_SCALE_SIZE(w), ELM_SCALE_SIZE(h));
 465                                         evas_object_size_hint_max_set(ad->smart_rotation_image, w, h);
 466                                 }
 467                                 if (ad->smart_stay_image) {
 468                                         SETTING_TRACE("indicator is in TRANSPARENT mode");
 469                                         elm_win_indicator_opacity_set(ad->win_get, ELM_WIN_INDICATOR_TRANSPARENT);
 470                                         /*elm_win_indicator_mode_set(ad->win_get,ELM_WIN_INDICATOR_HIDE); */
 471                                         evas_object_image_file_set(ad->smart_stay_image, SMART_SCREEN_TRY_IT_IMAGE_P, NULL);
 472                                         evas_object_size_hint_weight_set(ad->smart_stay_image, 0.0, EVAS_HINT_EXPAND);
 473                                         evas_object_image_fill_set(ad->smart_stay_image, 0, 0, w, h);
 474                                         evas_object_image_border_set(ad->smart_stay_image, 16, 16, 16, 16); /*for round corner */
 475                                         evas_object_image_filled_set(ad->smart_stay_image, 1); /*to full fill */
 476                                         evas_object_size_hint_min_set(ad->smart_stay_image, ELM_SCALE_SIZE(w), ELM_SCALE_SIZE(h));
 477                                         evas_object_size_hint_max_set(ad->smart_stay_image, w, h);
 478                                 }
 479                         }
 480                         break;
 481                 case UG_EVENT_ROTATE_LANDSCAPE:
 482                 case UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN: {
 483                                 int h = 0;
 484                                 int w = 0;
 485 #if 0
 486                                 app_device_orientation_e m = elm_win_rotation_get(ad->win_get);
 487
 488                                 if (APP_DEVICE_ORIENTATION_90 == m || APP_DEVICE_ORIENTATION_270 == m) {
 489                                         ecore_x_window_size_get(ecore_x_window_root_first_get(), &h, &w);
 490
 491                                 } else {
 492                                         ecore_x_window_size_get(ecore_x_window_root_first_get(), &w, &h);
 493
 494                                 }
 495                                 SETTING_TRACE("m:%d", m);
 496 #endif
 497                                 h = SAMRT_SCREEN_TRY_IT_IAMGE_LANDSCAPE_H;
 498                                 w = SAMRT_SCREEN_TRY_IT_IAMGE_LANDSCAPE_W;
 499                                 if (ad->smart_rotation_image) {
 500                                         /*elm_win_indicator_opacity_set(win, ELM_WIN_INDICATOR_OPAQUE) */
 501                                         evas_object_image_file_set(ad->smart_rotation_image, SMART_SCREEN_TRY_IT_IMAGE_L, NULL);
 502                                         evas_object_size_hint_weight_set(ad->smart_rotation_image, 0.0, EVAS_HINT_EXPAND);
 503                                         evas_object_image_fill_set(ad->smart_rotation_image, 0, 0, w, h);
 504                                         evas_object_image_border_set(ad->smart_rotation_image, 16, 16, 16, 16); /*for round corner */
 505                                         evas_object_image_filled_set(ad->smart_rotation_image, 1); /*to full fill */
 506                                         evas_object_size_hint_min_set(ad->smart_rotation_image, ELM_SCALE_SIZE(w), ELM_SCALE_SIZE(h));
 507                                         evas_object_size_hint_max_set(ad->smart_rotation_image, w, h);
 508                                 }
 509                                 if (ad->smart_stay_image) {
 510                                         evas_object_image_file_set(ad->smart_stay_image, SMART_SCREEN_TRY_IT_IMAGE_L, NULL);
 511                                         evas_object_size_hint_weight_set(ad->smart_stay_image, 0.0, EVAS_HINT_EXPAND);
 512                                         evas_object_image_fill_set(ad->smart_stay_image, 0, 0, w, h);
 513                                         evas_object_image_border_set(ad->smart_stay_image, 16, 16, 16, 16); /*for round corner */
 514                                         evas_object_image_filled_set(ad->smart_stay_image, 1); /*to full fill */
 515                                         evas_object_size_hint_min_set(ad->smart_stay_image, ELM_SCALE_SIZE(w), ELM_SCALE_SIZE(h));
 516                                         evas_object_size_hint_max_set(ad->smart_stay_image, w, h);
 517                                 }
 518
 519                         }
 520                         break;
 521                 case UG_EVENT_REGION_CHANGE:
 522                         break;
 523                 default:
 524                         break;
 525         }
 526 }
 527
 528 static void setting_display_ug_on_key_event(ui_gadget_h ug,
 529                                             enum ug_key_event event,
 530                                             app_control_h service, void *priv)
 531 {
 532         SETTING_TRACE_BEGIN;
 533         SettingDisplayUG *ad = (SettingDisplayUG *) priv;
 534
 535         switch (event) {
 536                 case UG_KEY_EVENT_END: {
 537                                 if (elm_naviframe_top_item_get(ad->navi_bar) ==
 538                                     elm_naviframe_bottom_item_get(ad->navi_bar)) {
 539                                         ug_destroy_me(ug);
 540                                 } else {
 541                                         if (&setting_view_display_brightness ==
 542                                             setting_view_node_get_cur_view()) {
 543                                         }
 544                                         setting_view_cb_at_endKey(ad);
 545                                 }
 546                         }
 547                         break;
 548                 default:
 549                         break;
 550         }
 551 }
 552
 553 UG_MODULE_API int UG_MODULE_INIT(struct ug_module_ops *ops)
 554 {
 555         SETTING_TRACE_BEGIN;
 556         SettingDisplayUG *displayUG = calloc(1, sizeof(SettingDisplayUG));
 557         setting_retvm_if(!displayUG, -1, "Create SettingDisplayUG obj failed");
 558
 559         memset(displayUG, 0x00, sizeof(SettingDisplayUG));
 560
 561         ops->create = setting_display_ug_on_create;
 562         ops->start = setting_display_ug_on_start;
 563         ops->pause = setting_display_ug_on_pause;
 564         ops->resume = setting_display_ug_on_resume;
 565         ops->destroy = setting_display_ug_on_destroy;
 566         ops->message = setting_display_ug_on_message;
 567         ops->event = setting_display_ug_on_event;
 568         ops->key_event = setting_display_ug_on_key_event;
 569         ops->priv = displayUG;
 570         ops->opt = UG_OPT_INDICATOR_ENABLE;
 571
 572         return 0;
 573 }
 574
 575 UG_MODULE_API void UG_MODULE_EXIT(struct ug_module_ops *ops)
 576 {
 577         SETTING_TRACE_BEGIN;
 578         struct SettingDisplayUG *displayUG;
 579         setting_retm_if(!ops, "ops == NULL");
 580
 581         displayUG = ops->priv;
 582         if (displayUG) {
 583                 FREE(displayUG);
 584         }
 585 }
 586
 587 /* ***************************************************
 588  *
 589  *general func
 590  *
 591  ***************************************************/
 592
 593 #define BUS_NAME                                "org.tizen.system.deviced"
 594 #define INTERFACE_NAME                          BUS_NAME
 595 #define OBJECT_PATH                             "/Org/Tizen/System/DeviceD"
 596 #define DEVICED_PATH_DISPLAY        OBJECT_PATH"/Display"
 597 #define DEVICED_INTERFACE_DISPLAY   INTERFACE_NAME".display"
 598 #define DBUS_REPLY_TIMEOUT                      (120 * 1000)
 599
 600 static int __append_param(DBusMessage *msg, const char *sig, char *param[])
 601 {
 602         DBusMessageIter iter;
 603         /*DBusMessageIter cont_iter; */
 604         char *ch;
 605         char *str_type;
 606         int int_type;
 607         int i;
 608         if (sig == NULL || param == NULL) {
 609                 return 0;
 610         }
 611
 612         dbus_message_iter_init_append(msg, &iter);
 613         for (ch = (char *)sig, i = 0; *ch != '\0'; ++i, ++ch) {
 614                 SETTING_TRACE_DEBUG("sig : %c", *ch);
 615                 switch (*ch) {
 616                         case 'i':
 617                                 int_type = atoi(param[i]);
 618                                 SETTING_TRACE_DEBUG("param[%2d] : %d", i, int_type);
 619                                 dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &int_type);
 620                                 break;
 621                         case 's':
 622                                 str_type = param[i];
 623                                 SETTING_TRACE_DEBUG("param[%2d] : %s", i, str_type);
 624                                 dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &str_type);
 625                                 break;
 626                         default:
 627                                 break;
 628                 }
 629         }
 630         return 0;
 631 }
 632
 633 static DBusMessage *__invoke_dbus_method(const char *dest, const char *path,
 634                                          const char *interface, const char *method,
 635                                          const char *sig, char *param[])
 636 {
 637         DBusError err;
 638         DBusConnection *conn;
 639         DBusMessage *reply;
 640         DBusMessage *msg;
 641         int r;
 642
 643         conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
 644         if (conn == NULL) {
 645                 SETTING_TRACE_DEBUG("dbus_bus_get error");
 646                 return NULL;
 647         }
 648         msg = dbus_message_new_method_call(dest, path, interface, method);
 649         if (msg == NULL) {
 650                 SETTING_TRACE_DEBUG("dbus_message_new_method_call error");
 651                 return NULL;
 652         }
 653         r = __append_param(msg, sig, param);
 654         if (r < 0) {
 655                 SETTING_TRACE_DEBUG("append_param error");
 656                 return NULL;
 657         }
 658         dbus_error_init(&err);
 659         reply = dbus_connection_send_with_reply_and_block(conn, msg, DBUS_REPLY_TIMEOUT, &err);
 660         dbus_message_unref(msg);
 661         if (dbus_error_is_set(&err)) {
 662                 SETTING_TRACE_DEBUG("dbus_connection_send_with_reply_and_block error");
 663                 SETTING_TRACE_DEBUG("error [%s:%s]", err.name, err.message);
 664                 dbus_error_free(&err);
 665                 return NULL;
 666         }
 667         return reply;
 668 }
 669
 670 int setting_display_set_auto_adjust_tone(int value)
 671 {
 672         SETTING_TRACE_BEGIN;
 673         if (value < 0 || value > 1) {
 674                 SETTING_TRACE_DEBUG("value has invalid range. [0 or 1]");
 675                 return SETTING_RETURN_FAIL;
 676         }
 677
 678         int ret = 0;
 679         int state;
 680         DBusMessage *msg;
 681         DBusError err;
 682         char *arr[4] = {0,};
 683         char temp[2] = {0,};
 684
 685         e_dbus_init();
 686         dbus_error_init(&err);
 687
 688         snprintf(temp, 2, "%1d", value);
 689         temp[1] = '\0';
 690         SETTING_TRACE_DEBUG("set as [%s]", temp);
 691         arr[0] = temp;
 692         msg = __invoke_dbus_method(BUS_NAME, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, "setautotone", "i", arr);
 693         if (msg) {
 694                 if (!dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID)) {
 695                         SETTING_TRACE_DEBUG("no message : [%s:%s]", err.name, err.message);
 696                         ret = SETTING_RETURN_FAIL;
 697                 } else {
 698                         SETTING_TRACE_DEBUG("%s-%s : %d", DEVICED_INTERFACE_DISPLAY, "setautotone", state);
 699                 }
 700                 dbus_message_unref(msg);
 701         }
 702         e_dbus_shutdown();
 703
 704         return ret;
 705 }
 706
 707 void setting_display_layout_ug_cb(ui_gadget_h ug, enum ug_mode mode,
 708                                   void *priv)
 709 {
 710         /*SettingDisplayUG *ad = (SettingDisplayUG *) priv; */
 711         Evas_Object *base;
 712
 713         if (!priv) {
 714                 return;
 715         }
 716         SETTING_TRACE_BEGIN;
 717
 718         base = (Evas_Object *) ug_get_layout(ug);
 719         if (!base) {
 720                 return;
 721         }
 722
 723         switch (mode) {
 724                 case UG_MODE_FULLVIEW:
 725                         evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND,
 726                                                          EVAS_HINT_EXPAND);
 727                         evas_object_show(base);
 728                         break;
 729                 default:
 730                         break;
 731         }
 732
 733         SETTING_TRACE_END;
 734 }
 735
 736 /*  NESTED*/
 737 static int setting_reset_display_brightness(void)
 738 {
 739         SETTING_TRACE_BEGIN;
 740         int ret = 0;
 741
 742         ret += vconf_set_int(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, SETTING_BRIGHTNESS_AUTOMATIC_OFF);
 743
 744         if (isEmulBin()) {
 745                 ret += vconf_set_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, SETTING_BRIGHTNESS_DEFAULT_LEVEL);
 746 #if USE_DEVICE_SET_DISPLAY_BRT
 747                 ret +=  device_display_set_brightness(0, SETTING_BRIGHTNESS_DEFAULT_LEVEL);
 748 #endif
 749         } else {
 750                 ret += vconf_set_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, SETTING_BRIGHTNESS_DEFAULT_LEVEL);
 751 #if USE_DEVICE_SET_DISPLAY_BRT
 752                 ret +=  device_display_set_brightness(0, SETTING_BRIGHTNESS_DEFAULT_LEVEL);
 753 #endif
 754         }
 755         ret += vconf_set_int(VCONFKEY_SETAPPL_LCD_AUTOMATIC_BRIGHTNESS, SETTING_BRIGHTNESS_DEFAULT_LEVEL);
 756         SETTING_TRACE_END;
 757         return ret;
 758 }
 759
 760 /*  NESTED*/
 761 static int setting_reset_display_backlight(void)
 762 {
 763         SETTING_TRACE_BEGIN;
 764         int ret = 0;
 765 #if SUPPORT_LCD_TIMEOUT_KEEPING
 766         ret += vconf_set_int(VCONFKEY_LCD_TIMEOUT_NORMAL_BACKUP, 0);
 767 #else
 768         if (isEmulBin()) {
 769                 ret += vconf_set_int(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, 0);
 770         } else {
 771                 ret += vconf_set_int(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, 30);
 772         }
 773 #endif
 774         SETTING_TRACE_END;
 775         return ret;
 776 }
 777
 778 /*  NESTED*/
 779 static int setting_reset_display_lc_screen(void)
 780 {
 781         SETTING_TRACE_BEGIN;
 782         int ret = 0;
 783         ret += vconf_set_str(VCONFKEY_IDLE_LOCK_BGSET, IMG_DEFAULT_HOME_SCREEN);
 784         ret += setting_invoke_reset_function("setting-lock", 0, NULL);
 785         return ret;
 786 }
 787
 788 static void setting_reset_launch_effect()
 789 {
 790         SETTING_TRACE_BEGIN;
 791         Evas_Object *win_main = ug_get_window();
 792         Ecore_X_Window xwin = elm_win_xwindow_get(win_main);
 793         Ecore_X_Window root = 0;
 794         if (0 != xwin) {
 795                 root = ecore_x_window_root_get(xwin);
 796         }
 797         if (0 != root) {
 798                 Ecore_X_Atom effect_enable_atom = ecore_x_atom_get("_NET_CM_EFFECT_ENABLE");
 799                 ret_if(!effect_enable_atom);
 800                 unsigned int is_enable = 0;
 801                 ecore_x_window_prop_card32_set(root, effect_enable_atom, &is_enable, 1);
 802         }
 803
 804 }
 805
 806 /*  NESTED*/
 807 /** @todo setting_display_main_effect_set_value work? */
 808 static int setting_reset_display_main(void)
 809 {
 810         SETTING_TRACE_BEGIN;
 811         int ret = 0;
 812         ret += setting_reset_display_backlight();
 813         /*ret += setting_reset_display_brightness(); */
 814 #if !SUPPOR_SEPARATE_BRIGHTNESS
 815         ret += setting_reset_display_brightness();
 816 #endif
 817
 818         /*reset Font */
 819         /*ret = setting_invoke_reset_function("setting-font-efl", NULL, NULL); */
 820         /*SETTING_TRACE("reset libug-%s.so[ret:%d]", "setting-font-efl", ret); */
 821
 822         ret += vconf_set_bool(VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL, FALSE);/*battery percent */
 823         setting_reset_launch_effect();
 824 #if SUPPORT_AUTO_ADJUST_SCREEN_TONE
 825         ret += vconf_set_bool(VCONFKEY_SETAPPL_BOOL_AUTO_ADJUST_SCREEN_TONE, TRUE);
 826 #endif
 827
 828         ret += vconf_set_bool(VCONFKEY_SETAPPL_AUTO_ROTATE_SCREEN_BOOL, TRUE);
 829 #if SUPPORT_SMARTSCREEN
 830         /* smart screen */
 831         ret += vconf_set_int(VCONFKEY_SETAPPL_SMARTSCREEN_SMARTSTAY_STATUS, 0);
 832         ret += vconf_set_bool(VCONFKEY_SETAPPL_SMARTSCREEN_SMART_ROTATION, FALSE);
 833 #endif
 834         /* screen mode */
 835         ret += vconf_set_str(VCONFKEY_SETAPPL_SCREENMODE_SELNAME, "Dynamic");
 836         display_set_image_enhance(ENHANCE_MODE, MODE_DYNAMIC);  /* 0 => Dynamic */
 837
 838         /*touch key light duration */
 839         ret += vconf_set_int(VCONFKEY_SETAPPL_TOUCHKEY_LIGHT_DURATION, 90);
 840         return ret;
 841 }
 842
 843 #define SUBINDEX_NAME "Display"
 844
 845 #if 1
 846 static Setting_Cfg_Node_T s_cfg_node_array[] = {
 847         {"IDS_COM_OPT_BRIGHTNESS", IMG_Display, "viewtype:brightness",  Cfg_Item_Pos_Level0, 0, 0, Cfg_Item_View_Node, NULL, SUBINDEX_NAME, NULL, NULL},
 848         {"IDS_ST_BODY_BACKLIGHT_TIME", IMG_Display, "viewtype:frontpage_backlight", Cfg_Item_Pos_Level0, 0, 0, Cfg_Item_View_Node, NULL, SUBINDEX_NAME, NULL, NULL},
 849         {"IDS_ST_HEADER_TOUCH_KEY_LIGHT_DURATION", IMG_Display, "viewtype:frontpage_duration", Cfg_Item_Pos_Level0, 0, 0, Cfg_Item_View_Node, NULL, SUBINDEX_NAME, NULL, NULL},
 850         {"IDS_ST_MBODY_AUTO_ADJUST_SCREEN_TONE", IMG_Display, "viewtype:frontpage", Cfg_Item_Pos_Level0, 0, 0, Cfg_Item_View_Node_Toggle, NULL, SUBINDEX_NAME, NULL, NULL},
 851         /* TEST HERE --------------*/
 852         {"IDS_ST_HEADER_AUTO_ROTATE_SCREEN_ABB", IMG_Display, "viewtype:frontpage", Cfg_Item_Pos_Level0, 0, 0, Cfg_Item_View_Node_Toggle, NULL, SUBINDEX_NAME, NULL, NULL},
 853         /* TEST HERE --------------*/
 854         {"IDS_ST_BODY_DISPLAY_BATTERY_PERCENTAGE_ABB", IMG_Display, "viewtype:frontpage", Cfg_Item_Pos_Level0, 0, 0, Cfg_Item_View_Node_Toggle, NULL, SUBINDEX_NAME, NULL, NULL},
 855         {"IDS_ST_BODY_DYNAMIC_STATUS_BAR", IMG_Display, "viewtype:frontpage", Cfg_Item_Pos_Level0, 0, 0, Cfg_Item_View_Node_Toggle, NULL, SUBINDEX_NAME, NULL, NULL},
 856         {"IDS_ST_MBODY_EDIT_AFTER_SCREEN_CAPTURE", IMG_Display, "viewtype:frontpage", Cfg_Item_Pos_Level0, 0, 0, Cfg_Item_View_Node_Toggle, NULL, SUBINDEX_NAME, NULL, NULL},
 857         {"IDS_COM_BODY_AUTOMATIC", IMG_Display, "viewtype:brightness", Cfg_Item_Pos_Level0, 0, 0, Cfg_Item_View_Node, NULL, SUBINDEX_NAME, NULL, NULL},
 858         {"IDS_ST_MBODY_SMART_STAY", IMG_SmartScreen, "viewtype:smartscreen", Cfg_Item_Pos_Level0, 0, 0, Cfg_Item_View_Node_Toggle, NULL, SUBINDEX_NAME, NULL, NULL},
 859         {"IDS_ST_MBODY_SMART_ROTATION", IMG_SmartScreen, "viewtype:smartscreen", Cfg_Item_Pos_Level0, 0, 0, Cfg_Item_View_Node_Toggle, NULL, SUBINDEX_NAME, NULL, NULL},
 860 };
 861 #endif
 862
 863 UG_MODULE_API int setting_plugin_search_init(app_control_h service, void *priv, char **applocale)
 864 {
 865         SETTING_TRACE_BEGIN;
 866         SETTING_TRACE(">> setting-display-efl DB search code");
 867         setting_retvm_if(!priv || !applocale, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER, "pplist/applocale is NULL");
 868
 869         *applocale = strdup("setting:/usr/apps/org.tizen.setting/res/locale");
 870
 871         Eina_List **pplist = (Eina_List **)priv;
 872         int i;
 873         int size = sizeof(s_cfg_node_array) / sizeof(s_cfg_node_array[0]);
 874         for (i = 0; i < size; i++) {
 875                 Setting_Cfg_Node_T *node = setting_plugin_search_item_subindex_add(s_cfg_node_array[i].key_name, s_cfg_node_array[i].ug_args, s_cfg_node_array[i].icon_path, s_cfg_node_array[i].item_type, s_cfg_node_array[i].data, s_cfg_node_array[i].sub_index);
 876                 *pplist = eina_list_append(*pplist, node);
 877         }
 878         return 0;
 879 }
 880
 881 EXPORT_PUBLIC
 882 int get_display_ug_state(Cfg_Item_State *stat, void *data)
 883 {
 884         SETTING_TRACE_BEGIN;
 885
 886
 887         int value = -1;
 888         int ret = vconf_get_bool(VCONFKEY_SETAPPL_AUTO_ROTATE_SCREEN_BOOL, &value);
 889
 890         if (value == 1) {
 891                 *stat = Cfg_Item_On;
 892         } else {
 893                 *stat = Cfg_Item_Off;
 894         }
 895         return ret;
 896 }
 897
 898 /**************************************************************
 899  toggle state get/set function for "auto rotate screen"
 900 ************************************************************/
 901 EXPORT_PUBLIC
 902 int set_display_ug_state(Cfg_Item_State stat, void *item, void *data)
 903 {
 904         SETTING_TRACE_BEGIN;
 905         int value = -1;
 906
 907         if (stat == Cfg_Item_On) {
 908                 value = 1;
 909         } else if (stat == Cfg_Item_Off) {
 910                 value = 0;
 911         } else {
 912                 value = 0;
 913         }
 914         int ret = vconf_set_bool(VCONFKEY_SETAPPL_AUTO_ROTATE_SCREEN_BOOL, value);
 915         return ret;
 916 }
 917
 918 EXPORT_PUBLIC
 919 int set_display_ug_update_ui(Cfg_Item_State stat, void *data)
 920 {
 921         SETTING_TRACE_BEGIN;
 922
 923         return 0;
 924 }
 925
 926 /**************************************************************
 927  toggle state get/set function for "auto adjust screen tone"
 928 ************************************************************/
 929 EXPORT_PUBLIC
 930 int get_display_ug_auto_adjust_state(Cfg_Item_State *stat, void *data)
 931 {
 932         SETTING_TRACE_BEGIN;
 933
 934         int value = -1;
 935         int ret = vconf_get_bool(VCONFKEY_SETAPPL_LCD_AUTO_DISPLAY_ADJUSTMENT, &value);
 936
 937         if (value == 1) {
 938                 *stat = Cfg_Item_On;
 939         } else {
 940                 *stat = Cfg_Item_Off;
 941         }
 942         return ret;
 943 }
 944
 945 EXPORT_PUBLIC
 946 int set_display_ug_auto_adjust_state(Cfg_Item_State stat, void *item, void *data)
 947 {
 948         SETTING_TRACE_BEGIN;
 949         int value = -1;
 950
 951         if (stat == Cfg_Item_On) {
 952                 value = 1;
 953         } else if (stat == Cfg_Item_Off) {
 954                 value = 0;
 955         } else {
 956                 value = 0;
 957         }
 958         int ret = vconf_set_bool(VCONFKEY_SETAPPL_LCD_AUTO_DISPLAY_ADJUSTMENT, value);
 959         return ret;
 960 }
 961
 962 EXPORT_PUBLIC
 963 int set_display_ug_auto_adjust_update_ui(Cfg_Item_State stat, void *data)
 964 {
 965         SETTING_TRACE_BEGIN;
 966
 967         return 0;
 968 }
 969
 970 /**************************************************************
 971  toggle state get/set function for "show battery pecentage"
 972 ************************************************************/
 973 EXPORT_PUBLIC
 974 int get_display_ug_battery_state(Cfg_Item_State *stat, void *data)
 975 {
 976         SETTING_TRACE_BEGIN;
 977
 978         int value = -1;
 979         int ret = vconf_get_bool(VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL, &value);
 980
 981         if (value == 1) {
 982                 *stat = Cfg_Item_On;
 983         } else {
 984                 *stat = Cfg_Item_Off;
 985         }
 986         return ret;
 987 }
 988
 989 EXPORT_PUBLIC
 990 int set_display_ug_battery_state(Cfg_Item_State stat, void *item, void *data)
 991 {
 992         SETTING_TRACE_BEGIN;
 993         int value = -1;
 994
 995         if (stat == Cfg_Item_On) {
 996                 value = 1;
 997         } else if (stat == Cfg_Item_Off) {
 998                 value = 0;
 999         } else {
1000                 value = 0;
1001         }
1002         int ret = vconf_set_bool(VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL, value);
1003         return ret;
1004 }
1005
1006 EXPORT_PUBLIC
1007 int set_display_ug_battery_update_ui(Cfg_Item_State stat, void *data)
1008 {
1009         SETTING_TRACE_BEGIN;
1010
1011         return 0;
1012 }
1013
1014 /**************************************************************
1015  toggle state get/set function for "dynamic status bar"
1016 ************************************************************/
1017 EXPORT_PUBLIC
1018 int get_display_ug_dynamic_status_state(Cfg_Item_State *stat, void *data)
1019 {
1020         SETTING_TRACE_BEGIN;
1021
1022         int value = -1;
1023         int ret = vconf_get_bool(VCONFKEY_SETAPPL_DYNAMIC_STATUS_BAR, &value);
1024
1025         if (value == 1) {
1026                 *stat = Cfg_Item_On;
1027         } else {
1028                 *stat = Cfg_Item_Off;
1029         }
1030         return ret;
1031 }
1032
1033 EXPORT_PUBLIC
1034 int set_display_ug_dynamic_status_state(Cfg_Item_State stat, void *item, void *data)
1035 {
1036         SETTING_TRACE_BEGIN;
1037         int value = -1;
1038
1039         if (stat == Cfg_Item_On) {
1040                 value = 1;
1041         } else if (stat == Cfg_Item_Off) {
1042                 value = 0;
1043         } else {
1044                 value = 0;
1045         }
1046         int ret = vconf_set_bool(VCONFKEY_SETAPPL_DYNAMIC_STATUS_BAR, value);
1047         return ret;
1048 }
1049
1050 EXPORT_PUBLIC
1051 int set_display_ug_dynamic_status_update_ui(Cfg_Item_State stat, void *data)
1052 {
1053         SETTING_TRACE_BEGIN;
1054
1055         return 0;
1056 }
1057
1058 /**************************************************************
1059  toggle state get/set function for "edit after screen capture"
1060 ************************************************************/
1061 EXPORT_PUBLIC
1062 int get_display_ug_edit_screen_state(Cfg_Item_State *stat, void *data)
1063 {
1064         SETTING_TRACE_BEGIN;
1065
1066         int value = -1;
1067         int ret = vconf_get_bool(VCONFKEY_SETAPPL_SCREEN_CAPTURE_EDIT_AFTER_CAPTURE, &value);
1068
1069         if (value == 1) {
1070                 *stat = Cfg_Item_On;
1071         } else {
1072                 *stat = Cfg_Item_Off;
1073         }
1074         return ret;
1075 }
1076
1077 EXPORT_PUBLIC
1078 int set_display_ug_edit_screen_state(Cfg_Item_State stat, void *item, void *data)
1079 {
1080         SETTING_TRACE_BEGIN;
1081         int value = -1;
1082
1083         if (stat == Cfg_Item_On) {
1084                 value = 1;
1085         } else if (stat == Cfg_Item_Off) {
1086                 value = 0;
1087         } else {
1088                 value = 0;
1089         }
1090         int ret = vconf_set_bool(VCONFKEY_SETAPPL_SCREEN_CAPTURE_EDIT_AFTER_CAPTURE, value);
1091         return ret;
1092 }
1093
1094 EXPORT_PUBLIC
1095 int set_display_ug_edit_screen_update_ui(Cfg_Item_State stat, void *data)
1096 {
1097         SETTING_TRACE_BEGIN;
1098
1099         return 0;
1100 }
1101
1102 EXPORT_PUBLIC
1103 cfg_func_table opt_tab_rotation = {
1104         .get_item_state = get_display_ug_state,
1105         .set_item_state = set_display_ug_state,
1106         .set_item_update_ui = set_display_ug_update_ui,
1107 };
1108
1109 EXPORT_PUBLIC
1110 cfg_func_table opt_tab_auto_adjust = {
1111         .get_item_state = get_display_ug_auto_adjust_state,
1112         .set_item_state = set_display_ug_auto_adjust_state,
1113         .set_item_update_ui = set_display_ug_auto_adjust_update_ui,
1114 };
1115 EXPORT_PUBLIC
1116 cfg_func_table opt_tab_battery = {
1117         .get_item_state = get_display_ug_battery_state,
1118         .set_item_state = set_display_ug_battery_state,
1119         .set_item_update_ui = set_display_ug_battery_update_ui,
1120 };
1121
1122 EXPORT_PUBLIC
1123 cfg_func_table opt_tab_dynamic_status = {
1124         .get_item_state = get_display_ug_dynamic_status_state,
1125         .set_item_state = set_display_ug_dynamic_status_state,
1126         .set_item_update_ui = set_display_ug_dynamic_status_update_ui,
1127 };
1128 EXPORT_PUBLIC
1129 cfg_func_table opt_tab_edit_screen = {
1130         .get_item_state = get_display_ug_edit_screen_state,
1131         .set_item_state = set_display_ug_edit_screen_state,
1132         .set_item_update_ui = set_display_ug_edit_screen_update_ui,
1133 };
1134
1135 /* cfg_func_table* tfunc; */
1136 UG_MODULE_API int setting_plugin_search_query_ops(char *str_id, void **tfunc_obj)
1137 {
1138         SETTING_TRACE_BEGIN;
1139         SETTING_TRACE(">> get tfunc operation via plugin-model 1");
1140         if (str_id && !safeStrCmp(str_id, _("IDS_ST_HEADER_AUTO_ROTATE_SCREEN_ABB"))) {
1141                 *tfunc_obj = (void *)&opt_tab_rotation;
1142         } else if (str_id && !safeStrCmp(str_id, _("IDS_ST_MBODY_AUTO_ADJUST_SCREEN_TONE"))) {
1143                 *tfunc_obj = (void *)&opt_tab_auto_adjust;
1144         } else if (str_id && !safeStrCmp(str_id, _("IDS_ST_BODY_DISPLAY_BATTERY_PERCENTAGE_ABB"))) {
1145                 *tfunc_obj = (void *)&opt_tab_battery;
1146         } else if (str_id && !safeStrCmp(str_id, _("IDS_ST_BODY_DYNAMIC_STATUS_BAR"))) {
1147                 *tfunc_obj = (void *)&opt_tab_dynamic_status;
1148         }
1149         if (str_id && !safeStrCmp(str_id, _("IDS_ST_MBODY_EDIT_AFTER_SCREEN_CAPTURE"))) {
1150                 *tfunc_obj = (void *)&opt_tab_edit_screen;
1151         }
1152         SETTING_TRACE(">> get tfunc operation via plugin-model 2");
1153         return 0;
1154 }
1155
1156 /*****/