src/setting-plugin.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 <unistd.h>
  23 #include <eina_list.h>
  24 #include <glib.h>
  25
  26
  27 #include <setting-debug.h>
  28 #include <setting-common-general-func.h>
  29 #include <setting-common-draw-widget.h>
  30
  31 #include <setting-plugin.h>
  32
  33
  34
  35 static Setting_GenGroupItem_Data *g_list_item;  /*TEST*/
  36
  37
  38
  39 /*
  40  * UI draw handler table : _g_draw_list
  41  *  - contains Object_Drawer typed object.
  42  */
  43 Eina_List *_g_drawer_list = NULL;
  44
  45 /**
  46  * @return Evas_Object * obj
  47  */
  48 static void* navigationbar_func(void *data, xmlNode *xmlObj);
  49
  50
  51 /*
  52  * @return void
  53  */
  54 static void* group_func(void *data, xmlNode *xmlObj);
  55
  56 /*
  57  * @return Setting_GenGroupItem_Data* ptr
  58  */
  59 static void* link_func(void *data, xmlNode *xmlObj);
  60
  61 /*
  62  * @return Setting_GenGroupItem_Data* ptr
  63  */
  64 static void* slider_func(void *data, xmlNode *xmlObj);
  65
  66 /*
  67  * @return Setting_GenGroupItem_Data* ptr
  68  */
  69 static void* label_func(void *data, xmlNode *xmlObj);
  70
  71 /*
  72  * @return Setting_GenGroupItem_Data* ptr
  73  */
  74 static void* checkbox_func(void *data, xmlNode *xmlObj);
  75
  76 /*
  77  * @return Setting_GenGroupItem_Data* ptr
  78  */
  79 static void* editbox_func(void *data, xmlNode *xmlObj);
  80
  81 /*
  82  * @return Setting_GenGroupItem_Data* ptr
  83  */
  84 static void* expandlist_func(void *data, xmlNode *xmlObj);
  85
  86 /**
  87  * @return nothing
  88  */
  89 static void* expanditem_func(void *data, xmlNode *xmlObj);
  90
  91 /**
  92  * do nothing
  93  */
  94 static void* settings_func(void *data, xmlNode *xmlObj);
  95
  96
  97 static void* launch_func(void *data, xmlNode *xmlObj);
  98
  99 /**
 100  * do nothing
 101  */
 102 static void* setting_func(void *data, xmlNode *xmlObj);
 103
 104 static int __node_walker(PluginNode* context, xmlNode* cur);
 105
 106 static int __node_finder(PluginNode* context, xmlNode* cur, char* id_str, char* value, bool* is_end);
 107
 108
 109 static void __drawer_add(const char *type, drawer_fp draw)
 110 {
 111         Object_Drawer *node = calloc(1, sizeof(Object_Drawer));
 112         if (node && type && draw)
 113         {
 114                 node->type = type;
 115                 node->draw = draw;
 116
 117                 _g_drawer_list = eina_list_append(_g_drawer_list, node);
 118         }
 119 }
 120
 121
 122 static drawer_fp __drawer_find(char* type)
 123 {
 124         SETTING_TRACE_BEGIN;
 125         SETTING_TRACE("node type:%s", type);
 126         Eina_List *check_list = _g_drawer_list;
 127         Object_Drawer *list_item = NULL;
 128
 129         while (check_list) {
 130                 list_item = (Object_Drawer *) eina_list_data_get(check_list);
 131                 if (NULL == list_item)
 132                         continue;
 133
 134                 if (0 == safeStrCmp(list_item->type, type))
 135                 {
 136                         //SETTING_TRACE("list_item->type:%s", list_item->type);
 137                         break;
 138                 }
 139                 //if not matched,to check next node.
 140                 check_list = eina_list_next(check_list);
 141                 list_item = NULL;
 142         }
 143         //SETTING_TRACE("list_item:%p", list_item);
 144         return list_item ? list_item->draw : NULL;
 145 }
 146 void setting_drawer_list_init()
 147 {
 148         SETTING_TRACE_BEGIN;
 149 #if 0
 150         /* <navigationbar> */__drawer_add("navigationbar", navigationbar_func);
 151 #endif
 152         /* <bool>          */__drawer_add("bool", checkbox_func);
 153         /* <string>        */__drawer_add("string", editbox_func);
 154         /* <group>         */__drawer_add("group", group_func);
 155         /* <integer>       */__drawer_add("integer", slider_func);
 156         /* <label>         */__drawer_add("label", label_func);
 157         /* <link>          */__drawer_add("link", link_func);
 158         /* <launch>        */__drawer_add("launch", launch_func);
 159         /* <extendlist>    */__drawer_add("expandlist", expandlist_func);
 160         /* <extenditem>    */__drawer_add("expanditem", expanditem_func);
 161         /* <settings>      */__drawer_add("settings", settings_func);
 162         /* <setting>       */__drawer_add("setting", setting_func);
 163 }
 164
 165 void setting_drawer_list_fini()
 166 {
 167         if (_g_drawer_list)
 168         {
 169                 Object_Drawer *node = NULL;
 170                 Eina_List *li = _g_drawer_list;
 171                 while (li) {
 172                         node = (Object_Drawer *) eina_list_data_get(li);
 173                         if (node)
 174                         {
 175                                 //SETTING_TRACE("Deregister %s", node->type);
 176                                 FREE(node);
 177                         }
 178                         li = eina_list_next(li);
 179                 }
 180                 _g_drawer_list = eina_list_free(_g_drawer_list);
 181                 _g_drawer_list = NULL;
 182         }
 183 }
 184
 185 /////////////////////////
 186 /////////////////////////
 187 /////////////////////////
 188
 189 #define MAX_CONTENT_LEN 512
 190 #define MAX_LOCAL_BUFSIZE 128
 191 #define DBUS_PATH "/setting/dbus_handler"
 192 #define DBUS_SIGNAL_INTERFACE "org.tizen.setting.signal"
 193
 194 #define APPID_LENGTH 10
 195 #define APPID_POS_FROM_PATH 10
 196
 197 static char* s_pkg_name;
 198
 199 static char* substring(const char* str, size_t begin, size_t len)
 200 {
 201   if (str == 0 || strlen(str) == 0 || strlen(str) < begin || strlen(str) < (begin+len))
 202     return 0;
 203
 204   return strndup(str + begin, len);
 205 }
 206
 207 /**
 208  * package ID
 209  *
 210  * ncbyusjryr.AppSetting --> package ID is ncbyusjryr
 211  * "Update_" "ncbyusjryr"
 212  */
 213 static char* get_app_string(char* path)
 214 {
 215         SETTING_TRACE_BEGIN;
 216         char* temp = substring(path, APPID_POS_FROM_PATH, APPID_LENGTH/*string size*/);
 217         SETTING_TRACE("package ID : >>> %s ",temp );
 218         return temp;
 219 }
 220
 221 //------------------------------------------------------
 222 // for client - bus
 223 static DBusConnection *bus;
 224 //------------------------------------------------------
 225 static DBusHandlerResult __signal_filter(DBusConnection* conn, DBusMessage* message, void* user_data)
 226 {
 227     int my_pid = getpid();
 228     int sender_pid = 0;
 229     char* key = NULL;
 230     char* value = NULL;
 231
 232     DBusError error;
 233     dbus_error_init(&error);
 234
 235         setting_main_appdata *ad = user_data;
 236
 237         char* pkg_name = get_app_string(ad->plugin_path);
 238
 239         char str_buf[MAX_COMMON_BUFFER_LEN];
 240         snprintf(str_buf, MAX_COMMON_BUFFER_LEN, "Update_%s", pkg_name);
 241         s_pkg_name = strdup(str_buf);
 242
 243         if (pkg_name)
 244         {
 245                 free(pkg_name);
 246                 pkg_name = NULL;
 247         }
 248
 249         if (s_pkg_name == NULL)
 250         {
 251                 SETTING_TRACE("s_pkg_name is NULL - it's abnormal operation");
 252                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 253         }
 254         SETTING_TRACE("s_pkg_name : %s ", s_pkg_name);
 255     if (dbus_message_is_signal(message, DBUS_SIGNAL_INTERFACE, s_pkg_name))
 256     {
 257         if (dbus_message_get_args(message, &error,
 258                 DBUS_TYPE_UINT32, &sender_pid,
 259                 DBUS_TYPE_STRING, &key,
 260                 DBUS_TYPE_STRING, &value,
 261                 DBUS_TYPE_INVALID) == FALSE)
 262         {
 263             SETTING_TRACE_ERROR("Fail to get data : %s", error.message);
 264             dbus_error_free(&error);
 265             return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 266         }
 267     }
 268
 269     if (sender_pid != 0 && my_pid != sender_pid)
 270     {
 271         SETTING_TRACE("received key : %s , value : %s", key, value);
 272                 //-------------------------------------------------------------
 273                 // received key : checkbox1|N/A , value : INT|1
 274                 //-------------------------------------------------------------
 275                 //char* key = "checkbox1|N/A";
 276                 char* ptr = strchr(key, '|');
 277
 278                 xmlDocPtr doc = NULL;
 279                 if (ptr && key)
 280                 {
 281                         //parsing for : checkbox1|N/A  -> checkbox1
 282                         char* key_name = substring(key, 0, strlen(key)-strlen(ptr));
 283                         char* val_name = strchr(value, '|');
 284                         val_name++;
 285
 286                         // ad->plugin_path
 287                         // access xml file
 288                         doc = xmlParseFile(ad->plugin_path);
 289                         // generate xml tree
 290                         xmlNode *root = xmlDocGetRootElement(doc);
 291                         // find a node
 292                         bool is_end = false;
 293                         __node_finder((PluginNode*)ad->plugin_node, root, key_name ,val_name, &is_end);
 294                 }
 295                 // update the node
 296                 GError *error = NULL;
 297
 298 #if 0
 299                 if(doc != NULL)
 300                 {
 301                         xmlSaveFormatFile(ad->plugin_path, doc, 1);
 302                         // TODO: make sure this is right
 303                         xmlFreeDoc(doc);
 304                         doc = NULL;
 305                         SETTING_TRACE("__cfg_file_write successful");
 306                 }
 307 #endif
 308
 309                 // update UI
 310     }
 311
 312     return DBUS_HANDLER_RESULT_HANDLED;
 313 }
 314
 315 static int __send_msg(char* key, char* value)
 316 {
 317         DBusMessage* message;
 318
 319         int sender_pid = getpid();
 320
 321         if (bus == NULL)
 322                 return -1;
 323
 324         if (s_pkg_name == NULL)
 325         {
 326                 SETTING_TRACE("s_pkg_name is NULL - it's abnormal operation");
 327                 return -1;
 328         }
 329
 330         message = dbus_message_new_signal(DBUS_PATH, DBUS_SIGNAL_INTERFACE, s_pkg_name);
 331
 332         SETTING_TRACE("Sending message[%s:%s] via dbus", key ,value);
 333         if (dbus_message_append_args(message,
 334                                 DBUS_TYPE_UINT32, &sender_pid,
 335                                 DBUS_TYPE_STRING, &key,
 336                                 DBUS_TYPE_STRING, &value,
 337                                 DBUS_TYPE_INVALID) == FALSE)
 338         {
 339                 SETTING_TRACE("Fail to load data error");
 340                 return -1;
 341         }
 342
 343         if (dbus_connection_send(bus, message, NULL) == FALSE)
 344         {
 345                 SETTING_TRACE("Fail to send message");
 346                 return -1;
 347         }
 348
 349         dbus_connection_flush(bus);
 350         dbus_message_unref(message);
 351
 352         SETTING_TRACE("[CLIENT] send data signal done");
 353
 354     return 0;
 355 }
 356
 357
 358 static void __send_int_msg(xmlNode* xmlObj, int val)
 359 {
 360         const char *id = (char*)xmlGetProp(xmlObj, "id");
 361         const char *title = (char*)xmlGetProp(xmlObj, "title");
 362         char key[MAX_CONTENT_LEN] = {0,};
 363         snprintf(key, sizeof(key), "%s|%s", id, title);
 364
 365         char value[MAX_CONTENT_LEN] = {0,};
 366         snprintf(value, sizeof(value), "INT|%d", val);
 367         __send_msg(key, value);
 368 }
 369
 370
 371 static void __send_string_msg(xmlNode* xmlObj, char *string)
 372 {
 373         const char *id = (char*)xmlGetProp(xmlObj, "id");
 374         const char *title = (char*)xmlGetProp(xmlObj, "title");
 375         char key[MAX_CONTENT_LEN] = {0,};
 376         snprintf(key, sizeof(key), "%s|%s", id, title);
 377
 378         char value[MAX_CONTENT_LEN] = {0,};
 379         snprintf(value, sizeof(value), "STRING|%s", string);
 380         __send_msg(key, value);
 381 }
 382
 383
 384 int setting_dbus_handler_init(void* user_data)
 385 {
 386         SETTING_TRACE_BEGIN;
 387         if (bus)
 388         {
 389                 SETTING_TRACE("already get a bus, need release first.");
 390                 setting_dbus_handler_fini();
 391         }
 392         DBusError error;
 393         memset(&error, 0, sizeof(DBusError));
 394         char rule[MAX_LOCAL_BUFSIZE + 1] = {0,};
 395         dbus_error_init(&error);
 396         bus = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error);
 397         if (!bus)
 398         {
 399                 SETTING_TRACE("Fail to connect to the D-BUS daemon: %s", error.message);
 400                 dbus_error_free(&error);
 401                 return -1;
 402         }
 403
 404         dbus_connection_setup_with_g_main(bus, NULL);
 405         snprintf(rule, MAX_LOCAL_BUFSIZE, "path='%s',type='signal',interface='%s'", DBUS_PATH, DBUS_SIGNAL_INTERFACE);
 406
 407         dbus_bus_add_match(bus, rule, &error);
 408         if (dbus_error_is_set(&error))
 409         {
 410                 SETTING_TRACE("Fail to rule set; %s", error.message);
 411                 dbus_bus_remove_match(bus, rule, &error);
 412                 dbus_error_free(&error);
 413                 dbus_connection_close(bus);
 414                 bus = NULL;
 415                 return -1;
 416         }
 417
 418         if (dbus_connection_add_filter(bus, __signal_filter, user_data, NULL) == FALSE)
 419         {
 420                 dbus_bus_remove_match(bus, rule, &error);
 421                 dbus_error_free(&error);
 422                 dbus_connection_close(bus);
 423                 bus = NULL;
 424                 return -1;
 425         }
 426
 427         SETTING_TRACE("app signal initialized");
 428         return 0;
 429 }
 430
 431 int setting_dbus_handler_fini(void)
 432 {
 433         //do safty checking first.
 434         setting_retvm_if(!bus, 0, "!bus");
 435         DBusError error;
 436         memset(&error, 0, sizeof(DBusError));
 437         char rule[MAX_LOCAL_BUFSIZE + 1] = {0, };
 438
 439         dbus_error_init(&error);
 440         //dbus_connection_remove_filter(bus, __signal_filter, NULL);
 441         snprintf(rule, MAX_LOCAL_BUFSIZE, "path='%s',type='signal',interface='%s'", DBUS_PATH, DBUS_SIGNAL_INTERFACE);
 442         dbus_bus_remove_match(bus, rule, &error);
 443
 444         if (dbus_error_is_set(&error))
 445         {
 446                 SETTING_TRACE("Fail to rule unset: %s", error.message);
 447                 dbus_error_free(&error);
 448                 //return -1;
 449         }
 450
 451         dbus_connection_close(bus);
 452         bus = NULL;
 453         SETTING_TRACE("app signal finalized");
 454         return 0;
 455 }
 456
 457 /////////////////////////////
 458 /////////////////////////////
 459 /////////////////////////////
 460
 461 Elm_Genlist_Item_Class itc_layout;
 462
 463 // write -> update
 464 static int __cfg_file_write(Draw_Data *pd)
 465 {
 466         SETTING_TRACE_BEGIN;
 467
 468         GError *error = NULL;
 469         if(pd->doc != NULL)
 470         {
 471                 xmlSaveFormatFile(pd->cfg_file, pd->doc, 1);
 472                 //xmlFreeDoc(pd->doc);
 473                 //pd->doc = NULL;
 474                 SETTING_TRACE("__cfg_file_write successful");
 475         }
 476
 477         return TRUE;
 478 }
 479
 480
 481 static void ___click_softkey_back_cb(void *data, Evas_Object *obj,
 482                                           void *event_info)
 483 {
 484         SETTING_TRACE_BEGIN;
 485         ret_if(!data);
 486
 487         PluginNode* node = (PluginNode*)data;
 488         Draw_Data *pd = node->pd;
 489         if (pd->ly_main) {
 490                 evas_object_del(pd->ly_main);
 491                 pd->ly_main = NULL;
 492         }
 493
 494         setting_plugin_destroy(node);
 495
 496         pd->scroller = NULL;
 497         pd->navi_bar = NULL;
 498         pd->cfg_file = NULL;
 499
 500         pd->root = NULL;
 501 }
 502
 503
 504 static void* group_func(void *data, xmlNode *xmlObj)
 505 {
 506         SETTING_TRACE_BEGIN;
 507         ret_if(!data || !xmlObj);
 508
 509         PluginNode* node = (PluginNode*)data;
 510         Draw_Data *pd = node->pd;
 511
 512         // original code is non-recursive
 513 #if 0
 514         const char *title = (char*)json_object_get_string_member(jsonObj, "title");
 515         (void)setting_create_Gendial_field_titleItem(pd->scroller,
 516                                                      &(itc_group_item),
 517                                                      title, NULL);
 518
 519         // non recursive method
 520         if (json_object_has_member(jsonObj, "elements"))
 521         {
 522                 JsonNode* elements_node = json_object_get_member(jsonObj, "elements");
 523                 int i;
 524                 JsonObject* tempobj;
 525                 char* type;
 526                 for (i=0; i < json_array_get_length(json_node_get_array(elements_node)); i++)
 527                 {
 528                         tempobj  = json_array_get_object_element(json_node_get_array(elements_node), i);
 529                         type = (char*)json_object_get_string_member(tempobj, "type");
 530                         drawer_fp  fp = __drawer_find(type);
 531                         if (fp) fp(pd, tempobj); // draw it
 532                 }
 533         }
 534 #else
 535         // new code is recursive
 536         const char *title = (char*)xmlGetProp(xmlObj, "title");
 537         SETTING_TRACE (" >>> GROUP NAME : %s \n", title);
 538         (void)setting_create_Gendial_field_titleItem(pd->scroller, &(itc_group_item), title, NULL);
 539 #endif
 540
 541         return NULL;
 542 };
 543
 544
 545 static void* __link_list_cb(void *data, Evas_Object *obj, void *event_info)
 546 {
 547         SETTING_TRACE_BEGIN;
 548         ret_if(data == NULL);
 549         retm_if(event_info == NULL, "Invalid argument: event info is NULL");
 550         Elm_Object_Item *item = (Elm_Object_Item *) event_info;
 551         elm_genlist_item_selected_set(item, 0);
 552         Setting_GenGroupItem_Data *list_item =
 553             (Setting_GenGroupItem_Data *) elm_object_item_data_get(item);
 554
 555         xmlNode* xmlObj = data;
 556         ret_if(!xmlObj);
 557         const char *link_file = (char*)xmlGetProp(xmlObj, "value");
 558
 559         if(!link_file)
 560         {
 561                 SETTING_TRACE_ERROR("Invalidate liked file");
 562                 return;
 563         }
 564         char file[1024] = {0,};
 565         snprintf(file, sizeof(file), "%s/%s", PLUGIN_CFG_DIR, link_file);
 566         SETTING_TRACE("file:%s", file);
 567
 568         PluginNode* plugin_node = setting_plugin_create();
 569         setting_plugin_load(plugin_node, (const char *)file);
 570
 571         //setting_plugin_load(NULL, file);
 572
 573         return NULL;
 574 }
 575
 576 static void* __launch_list_cb(void *data, Evas_Object *obj, void *event_info)
 577 {
 578         SETTING_TRACE_BEGIN;
 579         ret_if(data == NULL);
 580         retm_if(event_info == NULL, "Invalid argument: event info is NULL");
 581         Elm_Object_Item *item = (Elm_Object_Item *) event_info;
 582         elm_genlist_item_selected_set(item, 0);
 583         Setting_GenGroupItem_Data *list_item =
 584             (Setting_GenGroupItem_Data *) elm_object_item_data_get(item);
 585
 586         xmlNode* xmlObj = data;
 587         ret_if(!xmlObj);
 588         const char *key_str = (char*)xmlGetProp(xmlObj, "id");
 589         const char *title_str = (char*)xmlGetProp(xmlObj, "title");
 590         const char *appid_str = (char*)xmlGetProp(xmlObj, "appid");
 591         const char *operation_str = (char*)xmlGetProp(xmlObj, "operation");
 592
 593
 594         service_h svc = NULL;
 595         service_create(&svc);
 596         service_set_app_id(svc, appid_str);                                                     // xml property – appid
 597         service_set_operation(svc, operation_str);                                              // property : operation
 598         service_send_launch_request(svc, NULL, NULL);
 599         service_destroy(svc);
 600
 601         return NULL;
 602 }
 603
 604 static void* label_func(void *data, xmlNode *xmlObj)
 605 {
 606         SETTING_TRACE_BEGIN;
 607         ret_if(!data || !xmlObj);
 608         PluginNode* node = (PluginNode*)data;
 609         Draw_Data *pd = node->pd;
 610
 611         const char *title = (char*)xmlGetProp(xmlObj, "title");
 612
 613         Setting_GenGroupItem_Data *obj =
 614                 setting_create_Gendial_field_def(pd->scroller, &(itc_1text),
 615                                                  NULL,
 616                                                  xmlObj, SWALLOW_Type_INVALID, NULL, NULL,
 617                                                  0, title, NULL, NULL);
 618
 619         return obj;
 620 }
 621
 622 static void* link_func(void *data, xmlNode *xmlObj)
 623 {
 624         SETTING_TRACE_BEGIN;
 625         ret_if(!data || !xmlObj);
 626         PluginNode* node = (PluginNode*)data;
 627         Draw_Data *pd = node->pd;
 628
 629         const char *key_str = (char*)xmlGetProp(xmlObj, "id");
 630         Setting_GenGroupItem_Data * obj =
 631                 setting_create_Gendial_field_def(pd->scroller, &(itc_1text),
 632                                                  __link_list_cb,
 633                                                  xmlObj, SWALLOW_Type_INVALID, NULL, NULL,
 634                                                  0, key_str, NULL, NULL);
 635
 636         return (void*)obj;
 637 };
 638
 639 static void* launch_func(void *data, xmlNode *xmlObj)
 640 {
 641         SETTING_TRACE_BEGIN;
 642         ret_if(!data || !xmlObj);
 643         PluginNode* node = (PluginNode*)data;
 644         Draw_Data *pd = node->pd;
 645
 646         const char *title_str = (char*)xmlGetProp(xmlObj, "title");
 647
 648         Setting_GenGroupItem_Data * obj =
 649                 setting_create_Gendial_field_def(pd->scroller, &(itc_1text),
 650                                                  __launch_list_cb,
 651                                                  xmlObj, SWALLOW_Type_INVALID, NULL, NULL,
 652                                                  0, title_str, NULL, NULL);
 653
 654         return (void*)obj;
 655 };
 656
 657 static void __slider_stop_cb(void *data, Evas_Object *obj,
 658                                     void *event_info)
 659 {
 660         ret_if(data == NULL || obj == NULL);
 661         double val = elm_slider_value_get(obj);
 662         SETTING_TRACE("val = %f", val);
 663         Setting_GenGroupItem_Data *list_item = data;
 664         ret_if(list_item->userdata == NULL);
 665
 666         xmlNode* xmlObj = list_item->userdata;
 667         ret_if(!xmlObj);
 668
 669         //apply the vconf changes after stopping moving slider..
 670         list_item->chk_status = (int)(val + 0.5);
 671         elm_slider_value_set(obj, list_item->chk_status);
 672
 673         SETTING_TRACE(" slider after ---> val = %d", (int) list_item->chk_status);
 674
 675         // int -> double -> xmlChar*
 676         xmlAttrPtr newattr;
 677         char buf[10];
 678         sprintf(buf, "%d", (int) list_item->chk_status);
 679         newattr = xmlSetProp(xmlObj, "value", buf);
 680
 681         __send_int_msg(xmlObj, list_item->chk_status);
 682         __cfg_file_write((Draw_Data *)list_item->belongs_to);
 683 }
 684
 685
 686 static void* slider_func(void *data, xmlNode *xmlObj)
 687 {
 688         SETTING_TRACE_BEGIN;
 689         ret_if(!data || !xmlObj);
 690         PluginNode* node = (PluginNode*)data;
 691         Draw_Data *pd = node->pd;
 692
 693         // type casting
 694         const char *title = (char*)xmlGetProp(xmlObj, "title");
 695
 696         SETTING_TRACE (" >>> [slider input] min=%s max=%s value=%s ",(char*)xmlGetProp(xmlObj, "min"), (char*)xmlGetProp(xmlObj, "max"), (char*)xmlGetProp(xmlObj, "value"));
 697
 698         int value = atoi((char*)xmlGetProp(xmlObj, "value"));
 699         int min = atoi((char*)xmlGetProp(xmlObj, "min"));
 700         int max = atoi((char*)xmlGetProp(xmlObj, "max"));
 701
 702         SETTING_TRACE ("[slider input] min=%d max=%d value=%d ", min, max, value);
 703
 704         setting_create_Gendial_itc("dialogue/1text.1icon.5", &(itc_layout));
 705         Setting_GenGroupItem_Data *list_item =
 706             setting_create_Gendial_field_def(pd->scroller, &(itc_layout), NULL,
 707                                              NULL,
 708                                              SWALLOW_Type_LAYOUT_SLIDER,
 709                                              IMG_SENSITIVITY_ICON_01,
 710                                              IMG_SENSITIVITY_ICON_02, value,
 711                                              title, NULL, NULL);
 712         if (list_item) {
 713                 list_item->win_main = NULL;
 714                 list_item->evas = NULL;
 715                 list_item->isIndicatorVisible = true;
 716                 list_item->slider_min = min;
 717                 list_item->slider_max = max;
 718                 list_item->userdata = xmlObj;
 719                 list_item->stop_change_cb = __slider_stop_cb;
 720                 list_item->belongs_to = (int)pd;
 721         }
 722
 723         g_list_item = list_item;
 724
 725         return (void*)list_item;
 726 };
 727
 728 /*
 729   elm_object_item_data_set(item_to_update->item, item_to_update);
 730   elm_genlist_item_update(item_to_update->item);
 731 */
 732 static void* navigationbar_func(void *data, xmlNode *xmlObj)
 733 {
 734 #if 1
 735         SETTING_TRACE_BEGIN;
 736         ret_if(!data || !xmlObj);
 737
 738         PluginNode* node = (PluginNode*)data;
 739         Draw_Data *pd = node->pd;
 740
 741         //----------------------------------------------------------------
 742         // [DATA] title, btn[0], btn[1]
 743         const char *title = (char*)xmlGetProp(xmlObj, "title");
 744         char *btn[2] = {0, };
 745
 746         // find child nodes named 'elements'
 747         if (xmlObj->children) {
 748                 xmlNode* cur = xmlObj->children;
 749                 int i =0;
 750                 while (cur != NULL)
 751                 {
 752                         if (!xmlStrcmp(cur->name, (const xmlChar*)"button")) {
 753                                 btn[i] = xmlGetProp(cur, "title");
 754                                 SETTING_TRACE("------>>> node type : Element, name=%s id=%s / btn[%d] = %s ",
 755                                                                 cur->name,xmlGetProp(cur, "id"),
 756                                                                 i,
 757                                                                 btn[i]);
 758                                 i++;
 759                         }
 760                         cur = cur->next;
 761                 }
 762         }
 763         //----------------------------------------------------------------
 764         // [UI] with DATA
 765         pd->ly_main = setting_create_layout_navi_bar_genlist(pd->win_get,
 766                                                    pd->win_get,
 767                                                    _(title),
 768                                                    _(btn[1]), _(btn[0]),
 769                                                    ___click_softkey_back_cb,
 770                                                    ___click_softkey_back_cb, data, &pd->scroller,
 771                                                    &(pd->navi_bar));
 772
 773 #endif
 774         return NULL;
 775 };
 776
 777
 778 static void __check_mouse_up_cb(void *data, Evas_Object *obj,
 779                                              void *event_info)
 780 {
 781         /* error check */
 782         SETTING_TRACE_BEGIN;
 783         setting_retm_if(data == NULL, "Data parameter is NULL");
 784
 785         retm_if(event_info == NULL, "Invalid argument: event info is NULL");
 786         Elm_Object_Item *item = (Elm_Object_Item *) event_info;
 787         elm_genlist_item_selected_set(item, 0);
 788         Setting_GenGroupItem_Data *list_item =
 789             (Setting_GenGroupItem_Data *) elm_object_item_data_get(item);
 790
 791         SETTING_TRACE("clicking item[%s]", _(list_item->keyStr));
 792
 793         int old_status = elm_check_state_get(list_item->eo_check);
 794         list_item->chk_status = !old_status;
 795         elm_check_state_set(list_item->eo_check, list_item->chk_status);
 796
 797         xmlNode *xmlObj = data;
 798         xmlAttrPtr newattr;
 799         newattr = xmlSetProp(xmlObj, "state", xmlXPathCastNumberToString(list_item->chk_status));
 800
 801         __send_int_msg(xmlObj, list_item->chk_status);
 802         __cfg_file_write((Draw_Data *)list_item->belongs_to);
 803 }
 804
 805
 806 static void __chk_btn_cb(void *data, Evas_Object *obj,
 807                                              void *event_info)
 808 {
 809         SETTING_TRACE_BEGIN;
 810         /* error check */
 811         retm_if(data == NULL, "Data parameter is NULL");
 812         Setting_GenGroupItem_Data *list_item = (Setting_GenGroupItem_Data *) data;
 813
 814         xmlNode* xmlObj = list_item->userdata;
 815         ret_if(!xmlObj);
 816         list_item->chk_status = elm_check_state_get(obj);       /*  for genlist update status */
 817
 818         xmlAttrPtr newattr;
 819         if (list_item->chk_status == 1) {
 820                 newattr = xmlSetProp(xmlObj, "value", "true");
 821         } else if (list_item->chk_status == 0) {
 822                 newattr = xmlSetProp(xmlObj, "value", "false");
 823         } else {
 824                 newattr = xmlSetProp(xmlObj, "value", "false");
 825         }
 826
 827         const char *id = (char*)xmlGetProp(xmlObj, "id");
 828         const char *title = (char*)xmlGetProp(xmlObj, "title");
 829         //SETTING_TRACE(" >>>> id:%s , title:%s", id, title);
 830         __send_int_msg(xmlObj, list_item->chk_status);
 831         __cfg_file_write((Draw_Data *)list_item->belongs_to);
 832         return;
 833 }
 834
 835
 836 static void* checkbox_func(void *data, xmlNode *xmlObj)
 837 {
 838         SETTING_TRACE_BEGIN;
 839         ret_if(!data || !xmlObj);
 840
 841         PluginNode* node = (PluginNode*)data;
 842         Draw_Data *pd = node->pd;
 843
 844         // [DATA] title, value
 845         const char *title = (char*)xmlGetProp(xmlObj, "title");
 846
 847         // true / false
 848         char* value = (char*)xmlGetProp(xmlObj, "value");
 849
 850         int ival = -1;
 851
 852         if ( 0 == safeStrCmp(value, "true")) {
 853                 ival = 1;
 854         } else if ( 0 == safeStrCmp(value, "false"))  {
 855                 ival = 0;
 856         } else {
 857                 ival = 0;       // default : false (0)
 858         }
 859
 860         // title, value, xmlObj
 861         Setting_GenGroupItem_Data *list_item =
 862                 setting_create_Gendial_field_def(pd->scroller,
 863                                           &(itc_1text_1icon),
 864                                           __check_mouse_up_cb,
 865                                           xmlObj,
 866                                           SWALLOW_Type_1TOGGLE,
 867                                           NULL, NULL,
 868                                           ival,
 869                                           title,
 870                                           NULL,
 871                                           __chk_btn_cb);
 872         if(list_item) {
 873                 list_item->userdata = xmlObj;
 874                 list_item->belongs_to = (int) pd;
 875                 SETTING_TRACE("pd:%p,list_item->belongs_to:%d", pd, list_item->belongs_to);
 876         }
 877
 878         return list_item;
 879 }
 880
 881
 882 static void __entry_unfocus_cb(void *data, Evas_Object *obj, void *event_info)
 883 {
 884         SETTING_TRACE_BEGIN;
 885         retm_if(!data || !obj, "Data parameter is NULL");
 886
 887         setting_hide_input_pannel_cb(obj);
 888         const char *entry_str = elm_entry_entry_get(obj);
 889         char *entry_str_utf8 = NULL;
 890         entry_str_utf8 = elm_entry_markup_to_utf8(entry_str);
 891
 892         Setting_GenGroupItem_Data *list_item = data;
 893
 894         xmlNode* xmlObj = list_item->userdata;
 895         ret_if(!xmlObj);
 896         xmlAttrPtr newattr;
 897         const char *title = (char*)xmlSetProp(xmlObj, "value",entry_str_utf8);
 898
 899         __send_string_msg(xmlObj, entry_str_utf8);
 900         __cfg_file_write((Draw_Data *)list_item->belongs_to);
 901
 902         FREE(entry_str_utf8);
 903 }
 904
 905
 906 static void __editbox_list_cb(void *data, Evas_Object *obj,
 907                                             void *event_info)
 908 {
 909         SETTING_TRACE_BEGIN;
 910         /* error check */
 911
 912         retm_if(event_info == NULL, "Invalid argument: event info is NULL");
 913         Elm_Object_Item *item = (Elm_Object_Item *) event_info;
 914         elm_genlist_item_selected_set(item, 0);
 915         Setting_GenGroupItem_Data *list_item = (Setting_GenGroupItem_Data *) elm_object_item_data_get(item);
 916
 917         SETTING_TRACE("clicking item[%s]", _(list_item->keyStr));
 918         if (!elm_object_focus_get(list_item->eo_check)) {
 919                 elm_object_focus_set(list_item->eo_check, EINA_TRUE);
 920         }
 921
 922         Ecore_IMF_Context *imf_context = (Ecore_IMF_Context *)elm_entry_imf_context_get(list_item->eo_check);
 923         setting_retm_if(imf_context == NULL, "imf_context is NULL");
 924         ecore_imf_context_input_panel_show(imf_context);
 925 }
 926
 927
 928 static void __editbox_changed_cb(void *data, Evas_Object *obj,
 929                                        void *event_info)
 930 {
 931         SETTING_TRACE_BEGIN;
 932         retm_if(!data || !obj, "Data parameter is NULL");
 933         retm_if(!elm_object_focus_get(obj), "Entry is not focused");
 934
 935         Setting_GenGroupItem_Data *list_item =
 936             (Setting_GenGroupItem_Data *) data;
 937
 938         const char *entry_str = elm_entry_entry_get(obj);
 939         int entry_len = safeStrLen(entry_str);
 940         SETTING_TRACE("entry_str:[%s], lenght:%d", entry_str, entry_len);
 941
 942         G_FREE(list_item->sub_desc);//release first
 943         list_item->sub_desc = (char *)g_strdup(entry_str);
 944 }
 945
 946
 947 static void* editbox_func(void *data, xmlNode *xmlObj)
 948 {
 949         SETTING_TRACE_BEGIN;
 950         ret_if(!data || !xmlObj);
 951
 952         PluginNode* node = (PluginNode*)data;
 953         Draw_Data *pd = node->pd;
 954
 955         const char *title = (char*)xmlGetProp(xmlObj, "title");
 956         const char *key_str= (char*)xmlGetProp(xmlObj, "value");
 957
 958         // TODO: minlength
 959         // TODO: maxlength
 960         Setting_GenGroupItem_Data *list_item =
 961             setting_create_Gendial_field_def(pd->scroller, &(itc_1icon),
 962                                              __editbox_list_cb,
 963                                              pd, SWALLOW_Type_LAYOUT_ENTRY,
 964                                              NULL, NULL, 0, title, key_str,
 965                                              __editbox_changed_cb);
 966         if (list_item) {
 967                 list_item->userdata = xmlObj;
 968                 list_item->stop_change_cb = __entry_unfocus_cb;
 969                 list_item->belongs_to = (int)pd;
 970         }
 971
 972         return list_item;
 973 };
 974
 975
 976 static void __expanditem_func_sel_cb(void *data, Evas_Object *obj, void *event_info)
 977 {
 978         SETTING_TRACE_BEGIN;
 979         /* error check */
 980         retm_if(event_info == NULL, "Invalid argument: event info is NULL");
 981         Elm_Object_Item *subitem = (Elm_Object_Item *) event_info;
 982         Elm_Object_Item *parentItem = elm_genlist_item_parent_get(subitem);
 983         elm_genlist_item_selected_set(subitem, 0);
 984         Setting_GenGroupItem_Data *data_subItem = elm_object_item_data_get(subitem);
 985         Setting_GenGroupItem_Data *data_parentItem = elm_object_item_data_get(parentItem);      /* parent data */
 986         ret_if(NULL == data_subItem || NULL == data_parentItem);
 987
 988         elm_radio_value_set(data_subItem->rgd, data_subItem->chk_status);
 989
 990         data_parentItem->sub_desc = (char *)g_strdup(_(data_subItem->keyStr));
 991         elm_object_item_data_set(data_parentItem->item, data_parentItem);
 992         elm_genlist_item_update(data_parentItem->item);
 993
 994         xmlNode* xmlObj = data_parentItem->userdata;
 995         ret_if(!xmlObj);
 996
 997         xmlAttrPtr newattr;
 998         //newattr = xmlSetProp(xmlObj, "string", data_parentItem->sub_desc);
 999         newattr = xmlSetProp(xmlObj, "value", data_parentItem->sub_desc);
1000
1001         __send_string_msg(xmlObj, data_parentItem->sub_desc);
1002         __cfg_file_write((Draw_Data *)data_parentItem->belongs_to);
1003 }
1004
1005
1006 static void __expanditem_func_exp_cb(void *data, Evas_Object *obj, void *event_info)
1007 {
1008         ret_if(NULL == data || NULL == event_info);
1009         SETTING_TRACE_BEGIN;
1010
1011         PluginNode* node = (PluginNode*)data;
1012         Draw_Data *pd = node->pd;
1013
1014         Elm_Object_Item *parentItem = event_info;       /* parent item */
1015         Setting_GenGroupItem_Data *data_parentItem = elm_object_item_data_get(parentItem);      /* parent data */
1016         Evas_Object *scroller = elm_object_item_widget_get(parentItem);
1017
1018
1019         xmlNode *xmlObj = data_parentItem->userdata;
1020         //char *value = (char*)xmlGetProp(xmlObj, "string");
1021         char *value = (char*)xmlGetProp(xmlObj, "value");
1022         SETTING_TRACE(">>> value = %s", value);
1023         int i=0;
1024         Evas_Object *rgd = NULL;
1025
1026         if (xmlObj->children && !data_parentItem->rgd) {//to protect from entering repeatly
1027                 xmlNode* cur = xmlObj->children;
1028
1029                 rgd = elm_radio_add(scroller);
1030                 elm_radio_value_set(rgd, -1);
1031
1032                 int i;
1033                 char *type;
1034                 char *subitem_title = NULL;
1035                 int subitem_index = 0;
1036                 int sel_idx = -1;
1037
1038                 while (cur != NULL) {
1039                         if (!xmlStrcmp(cur->name, (const xmlChar*)"expanditem")) {
1040                                 type = (char*)xmlGetProp(cur, "type");
1041                                 if (0 == safeStrCmp(type, "radio")) {
1042                                         subitem_title = (char*)xmlGetProp(cur, "title");
1043                                         Setting_GenGroupItem_Data *list_item =
1044                                                                                         setting_create_Gendial_exp_sub_field(scroller,
1045                                                                                                         &(itc_1icon_1text_sub),
1046                                                                                                         __expanditem_func_sel_cb, NULL, parentItem,
1047                                                                                                         SWALLOW_Type_1RADIO, rgd,
1048                                                                                                         subitem_index,
1049                                                                                                         subitem_title, NULL);
1050
1051                                         // SETTING_TRACE(">>> value = %s, subitem_title = %s ", value, subitem_title);
1052
1053                                         if (0 == safeStrCmp(value, subitem_title)) {
1054                                                 sel_idx = subitem_index;
1055                                                 SETTING_TRACE("%d is selected in Radio Group", sel_idx);
1056                                         }
1057                                         data_parentItem->childs = eina_list_append(data_parentItem->childs, list_item);
1058                                         subitem_index++;
1059
1060                                 } else {
1061                                         SETTING_TRACE("invalid type[:%s]", type);
1062                                 }
1063
1064                                 i++;
1065                         }
1066                         cur = cur->next;
1067                 }
1068
1069                 // value set
1070                 elm_radio_value_set(rgd, sel_idx);
1071                 data_parentItem->rgd = rgd;//protecting condition
1072         }
1073 }
1074
1075
1076 static void __expanditem_func_smart_cb(void *data, Evas_Object *obj, void *event_info)
1077 {
1078         ret_if(data == NULL || event_info == NULL);
1079         Elm_Object_Item *item = (Elm_Object_Item *) event_info;
1080         Setting_GenGroupItem_Data *data_item = elm_object_item_data_get(item);
1081         char *cb_type = data;
1082
1083         if (0 == safeStrCmp(cb_type, "contracted")) {
1084                 data_item->rgd = NULL;
1085                 elm_genlist_item_subitems_clear(item);
1086         }
1087 }
1088
1089
1090 static void* settings_func(void *data, xmlNode *xmlObj)
1091 {
1092         return NULL;
1093 }
1094
1095 // <setting>
1096 static void* setting_func(void *data, xmlNode *xmlObj)
1097 {
1098         SETTING_TRACE_BEGIN;
1099         ret_if(!data || !xmlObj);
1100
1101 #if 1/*{{{*/
1102         //Draw_Data *pd = node->pd;
1103         PluginNode* node = (PluginNode*)data;
1104         Draw_Data *pd = node->pd;
1105
1106         //----------------------------------------------------------------
1107         // [DATA] title, btn[0], btn[1]
1108         const char *title = (char*)xmlGetProp(xmlObj, "title");
1109         char *btn[2] = {/* 0 */"OK", /* 1 */"NO"};
1110
1111         // find child nodes named 'elements'
1112         #if 0
1113         if (xmlObj->children) {
1114                 xmlNode* cur = xmlObj->children;
1115                 int i =0;
1116                 while (cur != NULL)
1117                 {
1118                         if (!xmlStrcmp(cur->name, (const xmlChar*)"button")) {
1119                                 btn[i] = xmlGetProp(cur, "title");
1120                                 SETTING_TRACE("------>>> node type : Element, name=%s id=%s / btn[%d] = %s ",
1121                                                                 cur->name,xmlGetProp(cur, "id"),
1122                                                                 i,
1123                                                                 btn[i]);
1124                                 i++;
1125                         }
1126                         cur = cur->next;
1127                 }
1128         }
1129         #endif
1130         //----------------------------------------------------------------
1131         SETTING_TRACE("before setting_create_layout_navi_bar_genlist");
1132         // [UI] with DATA
1133         pd->scroller = elm_genlist_add(pd->win_get);
1134         retvm_if(pd->scroller == NULL, NULL,
1135                  "Cannot set scroller object  as contento of layout");
1136         elm_object_style_set(pd->scroller, "dialogue");
1137         elm_genlist_clear(pd->scroller);        /* first to clear list */
1138
1139         /*  Enabling illume notification property for window */
1140         elm_win_conformant_set(pd->win_get, 1);
1141         Evas_Object *conformant = elm_conformant_add(pd->win_get);
1142         elm_object_style_set(conformant, "internal_layout");    /*  By Kollus. 2011-01-04 */
1143         evas_object_show(conformant);
1144         elm_object_content_set(conformant, pd->scroller);
1145
1146         SETTING_TRACE("_(title):%s", _(title));
1147         pd->ly_main =
1148             setting_create_layout_navi_bar(pd->win_get, pd->win_get,
1149                                            _(title),
1150                                            _("IDS_COM_BODY_BACK"), NULL, NULL,
1151                                            ___click_softkey_back_cb,
1152                                            NULL, NULL,
1153                                            data, conformant,
1154                                            &(pd->navi_bar), NULL);
1155         SETTING_TRACE("after setting_create_layout_navi_bar_genlist");
1156
1157 #endif/*}}}*/
1158         return NULL;
1159 }
1160
1161
1162 static void* expanditem_func(void *data, xmlNode *xmlObj)
1163 {
1164         // DO NOTHING - expandlist draws this area
1165         return NULL;
1166 }
1167
1168 static void* expandlist_func(void *data, xmlNode *xmlObj)
1169 {
1170         SETTING_TRACE_BEGIN;
1171         ret_if(!data || !xmlObj);
1172
1173         PluginNode* node = (PluginNode*)data;
1174         Draw_Data *pd = node->pd;
1175
1176         const char *key_str = (char*)xmlGetProp(xmlObj, "title");
1177         const char *value = (char*)xmlGetProp(xmlObj, "value"); // string -> value
1178
1179         setting_enable_expandable_genlist(pd->scroller, data, __expanditem_func_exp_cb, __expanditem_func_smart_cb);
1180         Setting_GenGroupItem_Data *list_item =
1181             setting_create_Gendial_exp_parent_field(pd->scroller,
1182                                                     &(itc_2text_3_parent),
1183                                                     NULL, NULL,
1184                                                     SWALLOW_Type_INVALID,
1185                                                     key_str,
1186                                                     value);
1187         if (list_item) {
1188                 list_item->userdata = xmlObj;
1189                 list_item->belongs_to = (int)pd;
1190         }
1191
1192         return list_item;
1193 }
1194
1195
1196
1197 static int __node_walker(PluginNode* context, xmlNode* cur)
1198 {
1199         //SETTING_TRACE_BEGIN;
1200         Draw_Data *pd = context->pd;
1201
1202         retv_if(!pd, -1);
1203         xmlNode *cur_node = NULL;
1204         for (cur_node = cur; cur_node;cur_node = cur_node->next) {
1205                 if (cur_node->type == XML_ELEMENT_NODE) {
1206                         SETTING_TRACE("node type : %s id= %s", cur_node->name,xmlGetProp(cur_node, "id"));
1207
1208                         drawer_fp  fp = __drawer_find(cur_node->name);
1209                         if (fp)
1210                         {
1211                                 // type check
1212                                 void* vret = fp(context, cur_node); // draw it
1213
1214                                 if (vret)
1215                                 {
1216                                         Setting_GenGroupItem_Data* genlist_node = (Setting_GenGroupItem_Data* )vret;
1217                                         //SETTING_TRACE("add node to Eina List name : %s, id : ", cur_node->name, xmlGetProp(cur_node, "id"));
1218                                         // add it to the hash table create before.
1219                                         // id, object
1220                                         // add list
1221                                         char* key_name = xmlGetProp(cur_node, "id");
1222                                         eina_hash_add(context->ui_list, strdup(key_name),(void*)genlist_node);
1223                                 }
1224                         }
1225                 }
1226                 __node_walker(context, cur_node->children);     /* RECURSIVE */
1227         }
1228         return 0;
1229 }
1230
1231 /**
1232  * @param id_str [in] "id"
1233  * @param value [in] value to be udpated
1234  * @see __expanditem_func_sel_cb
1235  */
1236 static int __node_finder(PluginNode* context, xmlNode* cur, char* id_str, char* value, bool* is_end)
1237 {
1238         SETTING_TRACE_BEGIN;
1239         xmlNode *cur_node = NULL;
1240
1241         if (*is_end == true) return 0;
1242
1243         for (cur_node = cur; cur_node;cur_node = cur_node->next) {
1244                 if (cur_node->type == XML_ELEMENT_NODE) {
1245
1246                         char* id_name = (char*)xmlGetProp(cur_node, "id");
1247                         if ( id_name && 0 == strcmp(id_str, id_name))
1248                         {
1249                                 SETTING_TRACE("FOUND >>>> %s", id_name);
1250                                 // cur_node     - update xml code
1251                                 xmlAttrPtr newattr = xmlSetProp(cur_node, "value", value);
1252
1253                                 //-----------------------------------------------------------
1254                                 // UI UPDATE
1255                                 // case : slider
1256                                 if ( 0 == strcmp (cur_node->name, "integer"))
1257                                 {
1258                                         SETTING_TRACE(">>>>> UPDATE SLIDER CONTROL %x --- %s ",context->ui_list, id_name);
1259                                         Setting_GenGroupItem_Data* item_to_update = (Setting_GenGroupItem_Data*)eina_hash_find(context->ui_list, id_name);
1260                                         if      (item_to_update)
1261                                         {
1262                                                 item_to_update->chk_status = atoi(value);
1263                                                 SETTING_TRACE(">>>   o-------------0 SLIDER VALUE = %d ", item_to_update->chk_status);
1264
1265                                                 elm_object_item_data_set(item_to_update->item, item_to_update);
1266                                                 elm_genlist_item_update(item_to_update->item);
1267                                         } else {
1268                                                 SETTING_TRACE("item_to_update is NULL");
1269                                         }
1270                                 }
1271                                 // case : toggle
1272                                 if ( 0 == strcmp (cur_node->name, "bool"))
1273                                 {
1274                                         SETTING_TRACE(">>>>> UPDATE TOGGLE CONTROL %x --- %s ",context->ui_list, id_name);
1275                                         Setting_GenGroupItem_Data* item_to_update = (Setting_GenGroupItem_Data*)eina_hash_find(context->ui_list, id_name);
1276                                         if      (item_to_update)
1277                                         {
1278                                                 item_to_update->chk_status = atoi(value);
1279                                                 SETTING_TRACE(">>>   o-------------0 TOGGLE VALUE = %d ", item_to_update->chk_status);
1280
1281                                                 elm_object_item_data_set(item_to_update->item, item_to_update);
1282                                                 elm_genlist_item_update(item_to_update->item);
1283                                         } else {
1284                                                 SETTING_TRACE("item_to_update is NULL");
1285                                         }
1286                                 }
1287                                 // case : edit control
1288                                 if ( 0 == strcmp (cur_node->name, "string"))
1289                                 {
1290                                         SETTING_TRACE(">>>>> UPDATE EDIT CONTROL CONTROL %x --- %s ",context->ui_list, id_name);
1291                                         Setting_GenGroupItem_Data* item_to_update = (Setting_GenGroupItem_Data*)eina_hash_find(context->ui_list, id_name);
1292                                         if      (item_to_update)
1293                                         {
1294                                                 char* old_string = item_to_update->sub_desc;
1295                                                 item_to_update->sub_desc = strdup(value);
1296                                                 SETTING_TRACE(">>>   o-------------0 STRING VALUE = %s ", value);
1297
1298                                                 // free old string
1299
1300                                                 elm_object_item_data_set(item_to_update->item, item_to_update);
1301                                                 elm_genlist_item_update(item_to_update->item);
1302
1303                                         } else {
1304                                                 SETTING_TRACE("item_to_update is NULL");
1305                                         }
1306                                 }
1307                                 // case : expand list
1308                                 // parent
1309                                 //    child1
1310                                 //    child2
1311                                 //    child3
1312                                 //    child4
1313                                 //-----------------------------------------------------------
1314                                 if ( 0 == strcmp (cur_node->name, "expandlist"))
1315                                 {
1316                                         SETTING_TRACE(">>>>> UPDATE EXPAND LIST CONTROL %x --- %s ",context->ui_list, id_name);
1317                                         Setting_GenGroupItem_Data* item_to_update = (Setting_GenGroupItem_Data*)eina_hash_find(context->ui_list, id_name);
1318                                         if      (item_to_update)
1319                                         {
1320                                                 char* old_string = item_to_update->sub_desc;
1321                                                 item_to_update->sub_desc = strdup(value);
1322                                                 SETTING_TRACE(">>>   o-------------0 EXPAND LIST VALUE = %s ", value);
1323
1324                                                 // free old string
1325                                                 // string update
1326                                                 elm_object_item_data_set(item_to_update->item, item_to_update);
1327                                                 elm_genlist_item_update(item_to_update->item);
1328
1329                                                 // TODO: need to update child elements
1330                                                 // item_to_update->childs ---> expanded list
1331                                                 if (item_to_update->childs)
1332                                                 {
1333                                                         Eina_List *li = item_to_update->childs;
1334                                                         int radio_index = 0;
1335                                                         while(li)
1336                                                         {
1337                                                                 Setting_GenGroupItem_Data* node = eina_list_data_get(li);
1338                                                                 // do something more
1339                                                                 // SETTING_TRACE(">>> RADIO LIST STRING VALUE = %s ", node->keyStr);
1340                                                                 // set position of radio button
1341                                                                 if (strcmp(node->keyStr, value) == 0)
1342                                                                 {
1343                                                                         elm_radio_value_set(node->rgd, radio_index);
1344                                                                 }
1345                                                                 elm_object_item_data_set(item_to_update->item, item_to_update);
1346                                                                 elm_genlist_item_update(item_to_update->item);
1347
1348                                                                 // go next
1349                                                                 li = eina_list_next(li);
1350                                                                 radio_index++;
1351                                                         }
1352
1353                                                 }
1354                                         } else {
1355                                                 SETTING_TRACE("item_to_update is NULL");
1356                                         }
1357                                 }
1358
1359                                 *is_end = true;
1360                         }
1361                 }
1362                 __node_finder(context, cur_node->children, id_str, value, is_end);      /* RECURSIVE */
1363         }
1364         return 0;
1365 }
1366
1367 static unsigned int _plugin_string_key_length(const char*key)
1368 {
1369         if (!key)
1370                 return 0;
1371
1372         return (int)strlen(key) + 1;
1373 }
1374
1375 static int _plugin_string_key_cmp(const char* key1, int key1_length,
1376                                                                         const char* key2, int key2_length)
1377 {
1378         return strcmp(key1, key2);
1379 }
1380
1381 static void _plugin_entry_free_cb(void* data)
1382 {
1383     Setting_GenGroupItem_Data* node = (Setting_GenGroupItem_Data*) data;
1384         if (node->childs)
1385         {
1386                 eina_list_free(node->childs);
1387                 node->childs = NULL;
1388         }
1389 }
1390
1391 //static PluginNode* g_context;
1392
1393 PluginNode* setting_plugin_create()
1394 {
1395         PluginNode *node = calloc(1, sizeof(PluginNode));
1396
1397         Draw_Data *pd = calloc(1, sizeof(Draw_Data));
1398         setting_retvm_if(!pd, -1, "Create Draw_Data obj failed");
1399         //eina_init();
1400
1401         node->pd = pd;
1402         node->ui_list = eina_hash_new(EINA_KEY_LENGTH(_plugin_string_key_length),
1403                                                                   EINA_KEY_CMP(_plugin_string_key_cmp),
1404                                                                   EINA_KEY_HASH(eina_hash_superfast),
1405                                                                   _plugin_entry_free_cb,
1406                                                                   5); // 2^5
1407
1408         return node;
1409 }
1410
1411 void setting_plugin_destroy(PluginNode* node)
1412 {
1413         SETTING_TRACE_BEGIN;
1414         if (node) {
1415                 SETTING_TRACE("node is NOT NULL")
1416                 if (node->pd) {
1417                         SETTING_TRACE("node->pd is NOT NULL")
1418                         if(node->pd->doc != NULL) {
1419                                 xmlSaveFormatFile(node->plugin_path, node->pd->doc, 1);
1420                                 xmlFreeDoc(node->pd->doc);
1421                                 node->pd->doc = NULL;
1422                                 SETTING_TRACE("__cfg_file_write successful");
1423                         }
1424
1425                         free(node->pd);
1426                         node->pd = NULL;
1427                 }
1428
1429                 if (node->ui_list) {
1430                         eina_hash_free(node->ui_list);
1431                         node->ui_list = NULL;
1432                 }
1433                 free(node);
1434                 node = NULL;
1435         }
1436 }
1437
1438
1439 static Eina_Bool _plugin_foreach_cb(const Eina_Hash *hash, const void*key, void* data, void* fdata)
1440 {
1441     Setting_GenGroupItem_Data* node = (Setting_GenGroupItem_Data*) data;
1442         SETTING_TRACE("%s --- %s ", (char*)key, node->keyStr);
1443         return EINA_TRUE;
1444 }
1445
1446
1447 void setting_plugin_debug(PluginNode* context)
1448 {
1449 //      SETTING_TRACE("HASH TABLE -------------------------------------");
1450         eina_hash_foreach(context->ui_list,_plugin_foreach_cb, NULL);
1451 //      SETTING_TRACE("HASH TABLE -------------------------------------");
1452
1453 }
1454
1455 void setting_plugin_update(PluginNode* context)
1456 {
1457     Eina_List *li = context->ui_list;
1458
1459     while (li) {
1460         Setting_GenGroupItem_Data* node = (Setting_GenGroupItem_Data*) eina_list_data_get(li);
1461         if (node) {
1462             // SETTING_TRACE(" ---> keyStr : %s , swallow type : %d  ", node->keyStr, node->swallow_type);
1463                         Setting_GenGroupItem_Data* item_to_update = NULL;
1464                         item_to_update = node;
1465                         elm_object_item_data_set(item_to_update->item, item_to_update);
1466                         elm_genlist_item_update(item_to_update->item);
1467         }
1468         li = eina_list_next(li);
1469         }
1470 }
1471
1472
1473 bool setting_plugin_load(PluginNode* context, const char *cfg_file)
1474 {
1475         SETTING_TRACE("cfg_file:%s", cfg_file)
1476         if (isEmptyStr(cfg_file) || 0 != access(cfg_file, R_OK|W_OK|F_OK ))
1477         {
1478                 SETTING_TRACE_ERROR(" error occured : access \n");
1479                 return FALSE;
1480         }
1481         context->pd->cfg_file = cfg_file;
1482         context->pd->win_get = (Evas_Object *) ug_get_window();
1483
1484         GError *error = NULL;
1485
1486         context->pd->doc = xmlParseFile(cfg_file);
1487         context->pd->root = xmlDocGetRootElement(context->pd->doc);
1488
1489         // TODO: error handler here
1490         __node_walker(context, context->pd->root);
1491
1492         // debug message
1493         setting_plugin_debug(context);
1494         return true;
1495 }
1496
1497