setting-common/src/setting-common-plugin.c

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