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