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