src/setting-plugin.c

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