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