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