src/cst-forwarding.c

   1 /*
   2  * Copyright 2012  Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.tizenopensource.org/license
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <Elementary.h>
  18
  19 #include "cst-common-string.h"
  20 #include "cst-call-setting.h"
  21
  22 #include "cst-forwarding.h"
  23 #include "cst-forwarding-ime.h"
  24 #include "cst-widget.h"
  25 #include "cst-common.h"
  26 #include "cst-tapi-request.h"
  27 #include "cst-util.h"
  28
  29 enum {
  30         CST_CF_ALWAYS_SEL = 0,
  31         CST_CF_IF_BUSY_SEL,
  32         CST_CF_IF_NO_REPLY_SEL,
  33         CST_CF_IF_OUT_OF_REACH_SEL,
  34         CST_CF_FORWARD_TO_TEXT,
  35         CST_CF_WAITING_TIME_SEL,
  36
  37         CST_CF_NONE,
  38 };
  39
  40 enum {
  41         CST_CF_WAIT_TIME_5_SEC = 5,
  42         CST_CF_WAIT_TIME_10_SEC = 10,
  43         CST_CF_WAIT_TIME_15_SEC = 15,
  44         CST_CF_WAIT_TIME_20_SEC = 20,
  45         CST_CF_WAIT_TIME_25_SEC = 25,
  46         CST_CF_WAIT_TIME_30_SEC = 30,
  47
  48         CST_CF_WAIT_TIME_NONE,
  49 };
  50
  51 enum {
  52         CST_CF_WAIT_TIME_IDX_5_SEC = 0,
  53         CST_CF_WAIT_TIME_IDX_10_SEC,
  54         CST_CF_WAIT_TIME_IDX_15_SEC,
  55         CST_CF_WAIT_TIME_IDX_20_SEC,
  56         CST_CF_WAIT_TIME_IDX_25_SEC,
  57         CST_CF_WAIT_TIME_IDX_30_SEC,
  58
  59         CST_CF_WAIT_TIME_IDX_NONE,
  60 };
  61
  62 typedef struct
  63 {
  64         Elm_Genlist_Item_Class *itc_2text_1icon;
  65         Elm_Genlist_Item_Class *itc_forwarding;
  66         Elm_Genlist_Item_Class *itc_forward_to;
  67         Elm_Genlist_Item_Class *itc_waiting_time;
  68         Elm_Genlist_Item_Class *itc_waiting_time_expand;
  69         Elm_Object_Item *ec_item[3];
  70         Evas_Object *onoff_screen_genlist;
  71         CstGlItemData_t *cf_sel_item;
  72         CstGlItemData_t *forwarding_item;
  73         CstGlItemData_t *forwardto_item;
  74         CstGlItemData_t *waitingtime_item;
  75         Evas_Object *waitingtime_radio_btn;
  76         int cf_wait_time_index;
  77         int cf_wait_time;
  78 }CstCallForward_info_t;
  79
  80 static void __cst_on_click_cf_onoff(void *data, Evas *evas, Evas_Object *obj, void *event_info);
  81 static void __cst_on_click_show_cf_onoff_screen(void *data, Evas *evas, Evas_Object *obj, void *event_info);
  82 static Evas_Object *__cst_create_genlist_cf_onoff_screen(void *data);
  83 static void __cst_on_click_cf_onoff_screen_back_button(void *data, Evas_Object *obj, void *event_info);
  84 static Evas_Object *__cst_gl_cf_onoff_get_icon(void *data, Evas_Object *obj, const char *part);
  85 static char *__cst_gl_cf_onoff_get_forwarding_label(void *data, Evas_Object *obj, const char *part);
  86 static char *__cst_gl_cf_onoff_get_forward_to_label(void *data, Evas_Object *obj, const char *part);
  87 static char *__cst_gl_cf_onoff_get_waiting_time_label(void *data, Evas_Object *obj, const char *part);
  88 static void __cst_gl_cf_onoff_forwarding_sel(void *data, Evas_Object *obj, void *event_info);
  89 static void __cst_gl_cf_onoff_waitingtime_sel(void *data, Evas_Object *obj, void *event_info);
  90 static void __cst_gl_cf_onoff_forwardto_sel(void *data, Evas_Object *obj, void *event_info);
  91 static void __cst_gl_cf_onoff_screen_show_remove_forwardto_item(Eina_Bool show_item, char *number);
  92 static void __cst_gl_cf_onoff_screen_show_remove_waitingtime_item(Eina_Bool show_item);
  93 static void __cst_cf_clear_onoff_screen_data(void);
  94 static void __cst_gl_on_click_waitingtime_expand(void *data, Evas *evas, Evas_Object *obj, void *event_info);
  95 static void __cst_gl_collapse_req(void *data, Evas_Object *obj, void *event_info);
  96 static void __cst_gl_collapse(int selected_time, Evas_Object *obj, void *event_info);
  97 static void __cst_gl_expand_req(void *data, Evas_Object *obj, void *event_info);
  98 static void __cst_gl_expand(void *data, Evas_Object *obj, void *event_info);
  99 static void __cst_gl_sel_waiting_time(void *data, Evas_Object *obj, void *event_info);
 100 static char *__cst_gl_get_wait_time_sub_exp_label(void *data, Evas_Object *obj, const char *part);
 101 static Evas_Object *__cst_gl_get_wait_time_sub_exp_icon(void *data, Evas_Object *obj, const char *part);
 102 static Evas_Object *__cst_gl_create_wait_time_radio_icon(Evas_Object *obj, Evas_Object *rdg, int value, int offset);
 103 static void __cst_update_wait_time_and_index(int wait_time_index, int wait_time);
 104 static void __cst_gl_update_waiting_time_ss_request(void);
 105 static void __cst_update_cf_onoff_screen_state(int call_type, int cf_flavour, Eina_Bool cf_state, char *number, int error, int req_action, void *data, int waiting_time);
 106 static void __cst_on_click_cf_onoff_forward_to(void *data, Evas *evas, Evas_Object *obj, void *event_info);
 107
 108 static CstCallForward_info_t cst_forward_data = {0, };
 109
 110 static CstGlItemDisplayInfo_t list_call_forwarding[] = {
 111         {1, CST_STR_ALWAYS, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_2TEXT_ONOFF_PROGRESS, __cst_on_click_show_cf_onoff_screen},
 112         {1, CST_STR_IF_BUSY, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_2TEXT_ONOFF_PROGRESS, __cst_on_click_show_cf_onoff_screen},
 113         {1, CST_STR_IF_NO_REPLY, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_2TEXT_ONOFF_PROGRESS, __cst_on_click_show_cf_onoff_screen},
 114         {1, CST_STR_IF_OUT_OF_REACH, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_2TEXT_ONOFF_PROGRESS, __cst_on_click_show_cf_onoff_screen},
 115
 116         {1, -1, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_NONE, NULL},
 117 };
 118
 119 static CstGlItemDisplayInfo_t list_call_forwarding_status[] = {
 120         {1, CST_STR_FORWARDING, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_1TEXT_ONOFF, __cst_on_click_cf_onoff},
 121         {1, CST_STR_FORWARD_TO, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_2TEXT, __cst_on_click_cf_onoff_forward_to},
 122         {1, CST_STR_WAITING_TIME, ELM_GENLIST_ITEM_TREE, CST_GL_ITEM_2TEXT_EXPANDABLE, __cst_gl_on_click_waitingtime_expand},
 123
 124         {1, -1, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_NONE, NULL},
 125 };
 126
 127 static CstGlItemDisplayInfo_t list_call_forwarding_dep2_waiting_time[] = {
 128         {2, CST_STR_WAITING_TIME_5_SEC, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_RADIO_1TEXT, (void *)CST_CF_WAIT_TIME_IDX_5_SEC},
 129         {2, CST_STR_WAITING_TIME_10_SEC, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_RADIO_1TEXT, (void *)CST_CF_WAIT_TIME_IDX_10_SEC},
 130         {2, CST_STR_WAITING_TIME_15_SEC, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_RADIO_1TEXT, (void *)CST_CF_WAIT_TIME_IDX_15_SEC},
 131         {2, CST_STR_WAITING_TIME_20_SEC, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_RADIO_1TEXT, (void *)CST_CF_WAIT_TIME_IDX_20_SEC},
 132         {2, CST_STR_WAITING_TIME_25_SEC, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_RADIO_1TEXT, (void *)CST_CF_WAIT_TIME_IDX_25_SEC},
 133         {2, CST_STR_WAITING_TIME_30_SEC, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_RADIO_1TEXT, (void *)CST_CF_WAIT_TIME_IDX_30_SEC},
 134
 135         {2, -1, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_NONE, NULL},
 136 };
 137
 138 static void __cst_on_click_cf_back_button(void *data, Evas_Object *obj, void *event_info)
 139 {
 140         ENTER(__cst_on_click_cf_back_button);
 141
 142         retm_if(data == NULL, "NULL UgData");
 143
 144         CstUgData_t *ugd = (CstUgData_t *)data;
 145
 146         ugd->back_button = _cst_get_navifr_prev_btn(ugd->nf);
 147         _cst_cancel_all_ss_request(ugd);
 148 }
 149
 150 static void __cst_update_cf_state(int call_type, int cf_flavour,
 151                 Eina_Bool cf_state, char *number,
 152                 int error, int req_action, void *data, int waiting_time)
 153 {
 154         ret_if(NULL == data);
 155         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 156         CstUgData_t *ugd = item_data->ugd;
 157         ret_if((call_type != ugd->call_type && call_type != CST_CALLTYPE_ALL));
 158         DBG("call_type=%d (0:voice 1:video)", call_type);
 159         DBG("cf_flavour=%d item_data->index=%d(0:CFU 1:CFB 2:CFNR 3:CFOR)", cf_flavour, item_data->index);
 160         DBG("cf_state=%d (1:on 0:off)", cf_state);
 161         DBG("number=%s, error=%d", number, error);
 162         DBG("req_action=%d(0: Act, 1:Deact, 2:Query)", req_action);
 163         DBG("waiting_time=%d", waiting_time);
 164
 165         if (error == CST_ERROR_NONE) {
 166                 if (cf_state == EINA_TRUE) {
 167                         ugd->cf_state[item_data->index] = CST_SS_STATE_ON;
 168                         if (strlen(number) > 0) {
 169                                 snprintf(item_data->number, sizeof(item_data->number), "%s", number);
 170                         } else {
 171                                 snprintf(item_data->number, sizeof(item_data->number), "%s", T_(CST_STR_UNKNOWN));
 172                         }
 173
 174                         if (cf_flavour == CST_SSTYPE_CF_UNCONDITIONAL) {
 175                                 int cf_index = 0;
 176                                 for (cf_index = CST_SSTYPE_CF_BUSY; cf_index <= CST_SSTYPE_CF_NOT_REACHABLE; cf_index++) {
 177                                         if (ugd->cf_state[cf_index] == CST_SS_STATE_ON) {
 178                                                 ugd->cf_state[cf_index] = CST_SS_STATE_OFF;
 179                                                 elm_genlist_item_update(ugd->cf_gl_item[cf_index]);
 180                                         }
 181                                 }
 182                         } else {
 183                                 if (ugd->cf_state[CST_SSTYPE_CF_UNCONDITIONAL] == CST_SS_STATE_ON) {
 184                                         ugd->cf_state[CST_SSTYPE_CF_UNCONDITIONAL] = CST_SS_STATE_OFF;
 185                                         elm_genlist_item_update(ugd->cf_gl_item[CST_SSTYPE_CF_UNCONDITIONAL]);
 186                                 }
 187                         }
 188                 } else {
 189                         strcpy(item_data->number, "");
 190                         ugd->cf_state[item_data->index] = CST_SS_STATE_OFF;
 191                 }
 192                 elm_genlist_item_update(item_data->gl_item);
 193         } else {
 194                 if (req_action != CST_ACTION_QUERY) {
 195                         if (error != CST_ERROR_SERVICE_UNAVAILABLE &&
 196                                 error != CST_ERROR_REJECTED_BY_NETWORK &&
 197                                 error != CST_ERROR_UNKNOWN) {
 198                                 DBG("User error : %d(Restore previous state)", error);
 199                                 if (req_action == CST_ACTION_DEACTIVATE)
 200                                         ugd->cf_state[item_data->index] = CST_SS_STATE_ON;
 201                                 else
 202                                         ugd->cf_state[item_data->index] = CST_SS_STATE_OFF;
 203                         } else {
 204                                 DBG("Network error : %d", error);
 205                                 if ((strlen(item_data->number) > 0) &&
 206                                                 (strncmp(item_data->number, T_(CST_STR_UNKNOWN), strlen(T_(CST_STR_UNKNOWN))) != 0)) {
 207                                         ugd->cf_state[item_data->index] = CST_SS_STATE_ON;
 208                                 } else {
 209                                         ugd->cf_state[item_data->index] = CST_SS_STATE_OFF;
 210                                 }
 211                         }
 212                         elm_genlist_item_update(item_data->gl_item);
 213                         ugd->popup = (Evas_Object *)_cst_create_error_popup(ugd->nf, error);
 214                         evas_object_show(ugd->popup);
 215                 } else {
 216                         ugd->cf_state[item_data->index] = CST_SS_STATE_OFF;
 217                         elm_genlist_item_update(item_data->gl_item);
 218                 }
 219         }
 220         __cst_update_cf_onoff_screen_state(call_type, cf_flavour, cf_state, number, error, req_action, data, waiting_time);
 221         return;
 222 }
 223
 224 static void __cst_update_cf_onoff_screen_state(int call_type, int cf_flavour, Eina_Bool cf_state, char *number, int error, int req_action, void *data, int waiting_time)
 225 {
 226         ret_if(NULL == data);
 227         ret_if(cst_forward_data.onoff_screen_genlist == NULL);
 228         ret_if(cst_forward_data.forwarding_item == NULL);
 229         ret_if(cst_forward_data.forwardto_item == NULL);
 230         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 231
 232         ENTER(__cst_update_cf_onoff_screen_state);
 233         if ((cf_flavour != item_data->index) || (req_action == CST_ACTION_QUERY)
 234                         || (cf_flavour != cst_forward_data.forwarding_item->index)) {  /* Ensuring the response is for the requested item only */
 235                 return;
 236         }
 237
 238         if (error == CST_ERROR_NONE) {
 239                 if (cf_state == EINA_TRUE) {
 240                         if (strlen(number) > 0) {
 241                                 snprintf(cst_forward_data.forwarding_item->number, sizeof(cst_forward_data.forwarding_item->number), "%s", number);
 242                         } else {
 243                                 snprintf(cst_forward_data.forwarding_item->number, sizeof(cst_forward_data.forwarding_item->number), "%s", T_(CST_STR_UNKNOWN));
 244                         }
 245
 246                         __cst_gl_cf_onoff_screen_show_remove_forwardto_item(EINA_TRUE, number);
 247                         if (cf_flavour == CST_SSTYPE_CF_NO_REPLY) { /* If no reply then show the Waiting time item also */
 248                                 __cst_gl_cf_onoff_screen_show_remove_waitingtime_item(EINA_TRUE);
 249                                 if (waiting_time > 0) {
 250                                         cst_forward_data.cf_wait_time = waiting_time;
 251                                         __cst_update_wait_time_and_index(CST_CF_WAIT_TIME_IDX_NONE, cst_forward_data.cf_wait_time);
 252                                 }
 253                         }
 254                 } else {
 255                         strcpy(cst_forward_data.forwarding_item->number, "");
 256                         __cst_gl_cf_onoff_screen_show_remove_forwardto_item(EINA_FALSE, NULL);
 257                         if (cf_flavour == CST_SSTYPE_CF_NO_REPLY) { /* If no reply then show the Waiting time item also */
 258                                 __cst_gl_cf_onoff_screen_show_remove_waitingtime_item(EINA_FALSE);
 259                         }
 260                 }
 261         }
 262         elm_genlist_item_update(cst_forward_data.forwarding_item->gl_item);
 263         return;
 264 }
 265
 266 static void __cst_query_cf_status(CstGlItemData_t *item_data)
 267 {
 268         ret_if(NULL == item_data);
 269         CstUgData_t *ugd = (CstUgData_t *)item_data->ugd;
 270         int cf_flavour = -1;
 271
 272         ugd->original_state = EINA_FALSE;
 273         switch (item_data->index) {
 274         case 0:
 275                 cf_flavour = CST_SSTYPE_CF_UNCONDITIONAL;
 276                 DBG("CST_SSTYPE_CF_UNCONDITIONAL");
 277                 break;
 278         case 1:
 279                 cf_flavour = CST_SSTYPE_CF_BUSY;
 280                 DBG("CST_SSTYPE_CF_BUSY");
 281                 break;
 282         case 2:
 283                 cf_flavour = CST_SSTYPE_CF_NO_REPLY;
 284                 DBG("CST_SSTYPE_CF_NO_REPLY");
 285                 break;
 286         case 3:
 287                 cf_flavour = CST_SSTYPE_CF_NOT_REACHABLE;
 288                 DBG("CST_SSTYPE_CF_NOT_REACHABLE");
 289                 break;
 290         default:
 291                 DBG("Error type");
 292                 break;
 293         }
 294         _cst_add_ss_request(&ugd->req_queue, CST_ACTION_QUERY,
 295                 ugd->call_type, cf_flavour, NULL,
 296                 __cst_update_cf_state, item_data, -1, ugd);
 297 }
 298
 299 static void __cst_on_click_cf_ime_done_btn(void *data, Evas_Object *obj, void *event_info)
 300 {
 301         ENTER(__cst_on_click_cf_ime_done_btn);
 302         ret_if(!data);
 303
 304         CallSettingSSReq_t *req = (CallSettingSSReq_t *)data;
 305         CstGlItemData_t *item_data = (CstGlItemData_t *)req->data;
 306         CstUgData_t *ugd = (CstUgData_t *)item_data->ugd;
 307         Ecore_IMF_Context *imf_context = elm_entry_imf_context_get(ugd->dg_entry);
 308         char buffer[CST_MAX_PHONE_NUMBER_LEN];
 309         if (_cst_get_input_number(buffer, ugd) > 0) {
 310                 ugd->cf_state[item_data->index] = CST_SS_STATE_PROGRESS;
 311                 elm_genlist_item_update(item_data->gl_item);
 312                 DBG("activate CF num=%s", buffer);
 313                 snprintf(req->number, CST_MAX_PHONE_NUMBER_LEN, "%s", buffer);
 314                 _cst_add_ss_request(&ugd->req_queue, req->action,
 315                         req->call_type, req->flavour, req->number,
 316                         __cst_update_cf_state, cst_forward_data.cf_sel_item, cst_forward_data.cf_wait_time, ugd);
 317                 memset(ugd->c_item, 0, sizeof(ugd->c_item));
 318                 elm_naviframe_item_pop(ugd->nf);
 319                 ugd->back_button = _cst_get_navifr_prev_btn(ugd->nf);
 320         }
 321
 322         if (imf_context) {
 323                 ecore_imf_context_input_panel_event_callback_del (imf_context, ECORE_IMF_INPUT_PANEL_STATE_EVENT, _cst_call_forwarding_input_panel_event_callback);
 324         }
 325         evas_object_smart_callback_del(ugd->dg_entry, "changed", _cst_call_forward_entry_changed_cb);
 326         free(req);
 327 }
 328
 329 static void __cst_on_click_cf_ime_cancel_btn(void *data, Evas_Object *obj, void *event_info)
 330 {
 331         ENTER(__cst_on_click_cf_ime_cancel_btn);
 332         ret_if(!data);
 333
 334         CallSettingSSReq_t *req = (CallSettingSSReq_t *)data;
 335         CstGlItemData_t *item_data = (CstGlItemData_t *)req->data;
 336         CstUgData_t *ugd = item_data->ugd;
 337         Ecore_IMF_Context *imf_context = elm_entry_imf_context_get(ugd->dg_entry);
 338
 339         DBG("original state : %d", req->original_state);
 340         if (req->original_state == CST_SS_STATE_ON)
 341                 ugd->cf_state[item_data->index] = CST_SS_STATE_ON;
 342         else
 343                 ugd->cf_state[item_data->index] = CST_SS_STATE_OFF;
 344         elm_genlist_item_update(item_data->gl_item);
 345
 346         if (imf_context) {
 347                 ecore_imf_context_input_panel_event_callback_del (imf_context, ECORE_IMF_INPUT_PANEL_STATE_EVENT, _cst_call_forwarding_input_panel_event_callback);
 348         }
 349         evas_object_smart_callback_del(ugd->dg_entry, "changed", _cst_call_forward_entry_changed_cb);
 350
 351         memset(ugd->c_item, 0, sizeof(ugd->c_item));
 352         elm_naviframe_item_pop(ugd->nf);
 353         ugd->back_button = _cst_get_navifr_prev_btn(ugd->nf);
 354
 355         free(req);
 356 }
 357
 358 static char *__cst_gl_label_get_cf(void *data, Evas_Object *obj, const char *part)
 359 {
 360         retv_if(NULL == data, NULL);
 361         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 362         CstUgData_t *ugd = (CstUgData_t *)item_data->ugd;
 363
 364         if (strcmp(part, "elm.text.1") == 0) {
 365                 if (list_call_forwarding[item_data->index].str_id != -1)
 366                         return strdup(T_(list_call_forwarding[item_data->index].str_id));
 367         } else if (strcmp(part, "elm.text.2") == 0) {
 368                 switch (ugd->cf_state[item_data->index]) {
 369                 case CST_SS_STATE_PROGRESS:
 370                 case CST_SS_STATE_OFF:
 371                         return strdup(T_(CST_STR_DEACTIVATED));
 372                 case CST_SS_STATE_ON:
 373                         return strdup(item_data->number);
 374                 default:
 375                         return NULL;
 376                 }
 377         }
 378         return NULL;
 379 }
 380
 381 static void __cst_gl_del_cf(void *data, Evas_Object *obj)
 382 {
 383         ret_if(NULL == data);
 384         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 385         if (item_data)
 386                 free(item_data);
 387         return;
 388 }
 389
 390 static void __cst_update_change_cf_req(CstGlItemData_t *item_data, Eina_Bool req_state)
 391 {
 392         ret_if(NULL == item_data);
 393         CstUgData_t *ugd = (CstUgData_t *)item_data->ugd;
 394         Evas_Object *eo;
 395         Elm_Object_Item *navi_it;
 396         Evas_Object *btn;
 397
 398         CallSettingSSReq_t *req = NULL;
 399         req = (CallSettingSSReq_t *)calloc(1, sizeof(CallSettingSSReq_t));
 400         ret_if(req == NULL);
 401
 402         ugd->popup = NULL;
 403         req->data = item_data;
 404         req->call_type = ugd->call_type;
 405         req->flavour = item_data->index;
 406         DBG("req->flavour = %d", req->flavour);
 407
 408         ugd->original_state = !req_state;
 409         if (req_state == EINA_TRUE) {
 410                 req->action = CST_ACTION_ACTIVATE;
 411                 char *edit_string = NULL;
 412                 Eina_Bool check_state = elm_check_state_get(item_data->eo_check);
 413                 if (check_state == EINA_TRUE) {
 414                         req->original_state = CST_SS_STATE_ON;
 415                         edit_string = item_data->number;
 416                 } else {
 417                         req->original_state = CST_SS_STATE_OFF;
 418                 }
 419                 eo = _cst_create_cf_ime(ugd->nf, edit_string, ugd);
 420
 421                 _cst_remove_naviframe(ugd->nf);
 422                 navi_it = elm_naviframe_item_push(ugd->nf,
 423                         T_(CST_STR_FORWARD_TO), NULL, NULL, eo, "1line");
 424                 elm_object_item_data_set(navi_it, req);
 425
 426                 btn = _cst_create_title_btn(ugd->nf, (char *)T_(CST_STR_CANCEL),
 427                         __cst_on_click_cf_ime_cancel_btn, (void *)req);
 428                 elm_object_item_part_content_set(navi_it, "title_right_btn", btn);
 429
 430                 btn = _cst_create_title_btn(ugd->nf, (char *)T_(CST_STR_DONE),
 431                         __cst_on_click_cf_ime_done_btn, (void *)req);
 432                 elm_object_item_part_content_set(navi_it, "title_left_btn", btn);
 433
 434                 elm_object_disabled_set(btn, EINA_TRUE);
 435         } else {
 436                 ugd->cf_state[item_data->index] = CST_SS_STATE_PROGRESS;
 437                 elm_genlist_item_update(item_data->gl_item);
 438                 _cst_add_ss_request(&ugd->req_queue, CST_ACTION_DEACTIVATE,
 439                         ugd->call_type, req->flavour, NULL,
 440                         __cst_update_cf_state, cst_forward_data.cf_sel_item, -1, ugd);
 441                 free(req);
 442         }
 443 }
 444
 445 static void __cst_on_click_cf_onoff(void *data, Evas *evas, Evas_Object *obj, void *event_info)
 446 {
 447         ret_if(NULL == data);
 448         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 449         CstUgData_t *ugd = item_data->ugd;
 450
 451         if (ugd->cf_state[cst_forward_data.forwarding_item->index] == CST_SS_STATE_PROGRESS) { /* Ignore as another SS request is already active */
 452                 return;
 453         }
 454
 455         Eina_Bool check_state = elm_check_state_get(item_data->eo_check);
 456         __cst_update_change_cf_req(item_data, !check_state);
 457 }
 458
 459 static void __cst_on_click_cf_onoff_forward_to(void *data, Evas *evas, Evas_Object *obj, void *event_info)
 460 {
 461         ret_if(NULL == data);
 462         ret_if(NULL == cst_forward_data.forwarding_item);
 463         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 464         CstUgData_t *ugd = item_data->ugd;
 465
 466         if (ugd->cf_state[cst_forward_data.forwarding_item->index] == CST_SS_STATE_PROGRESS) { /* Ignore as another SS request is already active */
 467                 return;
 468         }
 469         __cst_update_change_cf_req(cst_forward_data.forwarding_item, EINA_TRUE);
 470 }
 471
 472 static void __cst_gl_sel_cf(void *data, Evas_Object *obj, void *event_info)
 473 {
 474         ret_if(data == NULL);
 475         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 476         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 477         if (list_call_forwarding[item_data->index].func)
 478                 list_call_forwarding[item_data->index].func((void *)item_data, NULL, obj, event_info);
 479         return;
 480 }
 481
 482 static void __cst_on_changed_cf_check(void *data, Evas_Object *obj, void *event_info)
 483 {
 484         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 485
 486         Eina_Bool check_state = elm_check_state_get(obj);
 487         if (elm_object_item_disabled_get(item_data->gl_item) == EINA_TRUE) {
 488                 elm_check_state_set(obj, !check_state);
 489                 return;
 490         }
 491         elm_check_state_set(obj, !check_state);
 492         __cst_update_change_cf_req(item_data, check_state);
 493 }
 494
 495 static Evas_Object *__cst_gl_icon_get_cf(void *data, Evas_Object *obj, const char *part)
 496 {
 497         ENTER(__cst_gl_icon_get_cf);
 498         retv_if(NULL == data, NULL);
 499         Evas_Object *icon = NULL;
 500         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 501         CstUgData_t *ugd = (CstUgData_t *)item_data->ugd;
 502
 503         if (!strcmp(part, "elm.icon")) {
 504                 switch (ugd->cf_state[item_data->index]) {
 505                 case CST_SS_STATE_PROGRESS:
 506                         icon = _cst_create_progressbar(obj);
 507                         break;
 508                 default:
 509                         return NULL;
 510                 }
 511         }
 512         return icon;
 513 }
 514
 515 static Evas_Object *__cst_create_genlist_cf(void *data)
 516 {
 517         retv_if(NULL == data, NULL);
 518         CstUgData_t *ugd = (CstUgData_t *)data;
 519         int index = 0;
 520         Evas_Object *genlist;
 521         CstGlItemData_t *item_data;
 522
 523         cst_forward_data.itc_2text_1icon = NULL;
 524         cst_forward_data.itc_forwarding = NULL;
 525         cst_forward_data.itc_forward_to = NULL;
 526         cst_forward_data.itc_waiting_time = NULL;
 527         cst_forward_data.itc_waiting_time_expand = NULL;
 528         cst_forward_data.onoff_screen_genlist = NULL;
 529         cst_forward_data.forwardto_item = NULL;
 530         cst_forward_data.waitingtime_item = NULL;
 531         cst_forward_data.waitingtime_radio_btn = NULL;
 532         cst_forward_data.cf_sel_item = NULL;
 533
 534         if (!cst_forward_data.itc_2text_1icon)
 535                 cst_forward_data.itc_2text_1icon = elm_genlist_item_class_new();
 536         if (!cst_forward_data.itc_forwarding)
 537                 cst_forward_data.itc_forwarding = elm_genlist_item_class_new();
 538         if (!cst_forward_data.itc_forward_to)
 539                 cst_forward_data.itc_forward_to = elm_genlist_item_class_new();
 540         if (!cst_forward_data.itc_waiting_time)
 541                 cst_forward_data.itc_waiting_time = elm_genlist_item_class_new();
 542         if (!cst_forward_data.itc_waiting_time_expand)
 543                 cst_forward_data.itc_waiting_time_expand = elm_genlist_item_class_new();
 544
 545         cst_forward_data.itc_2text_1icon->item_style = "dialogue/2text.1icon.6";
 546         cst_forward_data.itc_2text_1icon->func.text_get = __cst_gl_label_get_cf;
 547         cst_forward_data.itc_2text_1icon->func.content_get = __cst_gl_icon_get_cf;
 548         cst_forward_data.itc_2text_1icon->func.state_get = NULL;
 549         cst_forward_data.itc_2text_1icon->func.del = __cst_gl_del_cf;
 550
 551         genlist = elm_genlist_add(ugd->nf);
 552         elm_object_style_set(genlist, "dialogue");
 553
 554         _cst_create_genlist_separator(genlist, EINA_FALSE);
 555         for (index = 0; list_call_forwarding[index].style != CST_GL_ITEM_NONE; ++index) {
 556                 item_data = (CstGlItemData_t *)calloc(1, sizeof(CstGlItemData_t));
 557                 retv_if(item_data == NULL, NULL);
 558                 item_data->index = index;
 559                 item_data->ugd = ugd;
 560                 if (list_call_forwarding[index].style == CST_GL_ITEM_2TEXT_ONOFF_PROGRESS) {
 561                         ugd->cf_state[index] = CST_SS_STATE_PROGRESS;
 562                         item_data->gl_item = elm_genlist_item_append(genlist, cst_forward_data.itc_2text_1icon,
 563                                 (const void *)item_data, NULL, list_call_forwarding[index].flags,
 564                                 __cst_gl_sel_cf, item_data);
 565                         __cst_query_cf_status(item_data);
 566                 } else {
 567                         DBG("No style");
 568                         free(item_data);
 569                         item_data = NULL;
 570                         return NULL;
 571                 }
 572                 ugd->cf_gl_item[index] = item_data->gl_item;
 573         }
 574         _cst_create_genlist_separator_no_line(genlist);
 575
 576         return genlist;
 577 }
 578
 579 static Evas_Object *__cst_gl_cf_onoff_get_icon(void *data, Evas_Object *obj, const char *part)
 580 {
 581         retv_if(NULL == data, NULL);
 582         Evas_Object *icon = NULL;
 583         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 584         CstUgData_t *ugd = (CstUgData_t *)item_data->ugd;
 585         Eina_Bool check_state = EINA_FALSE;
 586
 587         if (!strcmp(part, "elm.icon")) {
 588                 switch (ugd->cf_state[item_data->index]) {
 589                 case CST_SS_STATE_ON:
 590                 case CST_SS_STATE_OFF:
 591                         DBG("ugd->cf_state : %d(%d)",
 592                                 ugd->cf_state[item_data->index], item_data->index);
 593                         if (ugd->cf_state[item_data->index] == CST_SS_STATE_ON)
 594                                 check_state = EINA_TRUE;
 595                         item_data->eo_check = icon = _cst_create_onoff_button(obj, check_state,
 596                                         __cst_on_changed_cf_check, item_data);
 597                         break;
 598                 case CST_SS_STATE_PROGRESS:
 599                         icon = _cst_create_progressbar(obj);
 600                         break;
 601                 default:
 602                         return NULL;
 603                 }
 604         }
 605         return icon;
 606 }
 607
 608 static char *__cst_gl_cf_onoff_get_forwarding_label(void *data, Evas_Object *obj, const char *part)
 609 {
 610         retv_if(NULL == data, NULL);
 611
 612         if (!strcmp(part, "elm.text")) {
 613                 return strdup(T_(list_call_forwarding_status[0].str_id));
 614         }
 615         return NULL;
 616 }
 617
 618 static char *__cst_gl_cf_onoff_get_forward_to_label(void *data, Evas_Object *obj, const char *part)
 619 {
 620         retv_if(NULL == data, NULL);
 621         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 622
 623         if (strcmp(part, "elm.text.1") == 0) {
 624                 return strdup(T_(list_call_forwarding_status[1].str_id));
 625         } else if (strcmp(part, "elm.text.2") == 0) {
 626                 if (strlen(item_data->number) > 0) {
 627                         return strdup(item_data->number);
 628                 } else {
 629                         return strdup(T_(CST_STR_UNKNOWN));
 630                 }
 631         }
 632         return NULL;
 633 }
 634
 635 static char *__cst_gl_cf_onoff_get_waiting_time_label(void *data, Evas_Object *obj, const char *part)
 636 {
 637         retv_if(NULL == data, NULL);
 638
 639         if (strcmp(part, "elm.text.1") == 0) {
 640                 return strdup(T_(list_call_forwarding_status[2].str_id));
 641         } else if (strcmp(part, "elm.text.2") == 0) {
 642                 if (list_call_forwarding_dep2_waiting_time[cst_forward_data.cf_wait_time_index].str_id != -1)
 643                         return strdup(T_(list_call_forwarding_dep2_waiting_time[cst_forward_data.cf_wait_time_index].str_id));
 644         }
 645         return NULL;
 646 }
 647
 648 static void __cst_on_click_cf_onoff_screen_back_button(void *data, Evas_Object *obj, void *event_info)
 649 {
 650         ENTER(__cst_on_click_cf_onoff_screen_back_button);
 651         retm_if(data == NULL, "NULL");
 652         CstUgData_t *ugd = (CstUgData_t *)data;
 653         __cst_cf_clear_onoff_screen_data();
 654         ugd->back_button = _cst_get_navifr_prev_btn(ugd->nf);
 655 }
 656
 657 static void __cst_gl_cf_onoff_forwarding_sel(void *data, Evas_Object *obj, void *event_info)
 658 {
 659         ret_if(data == NULL);
 660         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 661         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 662         if (list_call_forwarding_status[0].func)
 663                 list_call_forwarding_status[0].func((void *)item_data, NULL, obj, event_info);
 664         return;
 665 }
 666
 667 static void __cst_gl_cf_onoff_forwardto_sel(void *data, Evas_Object *obj, void *event_info)
 668 {
 669         ret_if(data == NULL);
 670         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 671         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 672         if (list_call_forwarding_status[1].func)
 673                 list_call_forwarding_status[1].func((void *)item_data, NULL, obj, event_info);
 674         return;
 675 }
 676
 677 static void __cst_gl_cf_onoff_waitingtime_sel(void *data, Evas_Object *obj, void *event_info)
 678 {
 679         ret_if(data == NULL);
 680         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 681         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 682         if (list_call_forwarding_status[2].func)
 683                 list_call_forwarding_status[2].func((void *)item_data, NULL, obj, event_info);
 684         return;
 685 }
 686
 687 static void __cst_gl_cf_onoff_screen_show_remove_forwardto_item(Eina_Bool show_item, char *number)
 688 {
 689         ENTER(__cst_gl_cf_onoff_screen_show_remove_forwardto_item);
 690         ret_if(cst_forward_data.onoff_screen_genlist == NULL);
 691         ret_if(cst_forward_data.forwardto_item == NULL);
 692
 693         /* Remove the Forwardto item */
 694         if (cst_forward_data.forwardto_item->gl_item) {
 695                 elm_object_item_del(cst_forward_data.forwardto_item->gl_item);
 696                 cst_forward_data.forwardto_item->gl_item = NULL;
 697                 strcpy(cst_forward_data.forwardto_item->number, "");
 698         }
 699
 700         if(show_item == EINA_TRUE) {
 701                 if (strlen(number) > 0) {
 702                         snprintf(cst_forward_data.forwardto_item->number, sizeof(cst_forward_data.forwardto_item->number), "%s", number);
 703                 } else {
 704                         snprintf(cst_forward_data.forwardto_item->number, sizeof(cst_forward_data.forwardto_item->number), "%s", T_(CST_STR_UNKNOWN));
 705                 }
 706                 cst_forward_data.forwardto_item->gl_item = elm_genlist_item_append(cst_forward_data.onoff_screen_genlist, cst_forward_data.itc_forward_to,
 707                         (const void *)cst_forward_data.forwardto_item, NULL, list_call_forwarding_status[1].flags,
 708                         __cst_gl_cf_onoff_forwardto_sel, cst_forward_data.forwardto_item);
 709         }
 710 }
 711
 712 static void __cst_gl_cf_onoff_screen_show_remove_waitingtime_item(Eina_Bool show_item)
 713 {
 714         ENTER(__cst_gl_cf_onoff_screen_show_remove_waitingtime_item);
 715         ret_if(cst_forward_data.onoff_screen_genlist == NULL);
 716         ret_if(cst_forward_data.waitingtime_item == NULL);
 717
 718         /* Remove the Waiting time item */
 719         if (cst_forward_data.waitingtime_item->gl_item) {
 720                 elm_object_item_del(cst_forward_data.waitingtime_item->gl_item);
 721                 cst_forward_data.waitingtime_item->gl_item = NULL;
 722         }
 723
 724         if(show_item == EINA_TRUE) {
 725                 cst_forward_data.waitingtime_item->gl_item = elm_genlist_item_append(cst_forward_data.onoff_screen_genlist, cst_forward_data.itc_waiting_time,
 726                         (const void *)cst_forward_data.waitingtime_item, NULL, list_call_forwarding_status[2].flags,
 727                         __cst_gl_cf_onoff_waitingtime_sel, cst_forward_data.waitingtime_item);
 728         }
 729 }
 730
 731 static void __cst_gl_on_click_waitingtime_expand(void *data, Evas *evas, Evas_Object *obj, void *event_info)
 732 {
 733         ENTER(__cst_gl_on_click_waitingtime_expand);
 734         ret_if(NULL == data);
 735         Elm_Object_Item *item = (Elm_Object_Item *)event_info;
 736         static int selected_waittime = -1;
 737         CstUgData_t *ugd = (CstUgData_t *)((CstGlItemData_t *)data)->ugd;
 738
 739         if (ugd->cf_state[cst_forward_data.forwarding_item->index] == CST_SS_STATE_PROGRESS) { /* Ignore as another SS request is already active */
 740                 return;
 741         }
 742
 743         if (elm_genlist_item_expanded_get(item)) {
 744                 __cst_gl_collapse_req(data, obj, event_info);
 745                 __cst_gl_collapse(selected_waittime, obj, event_info);
 746         } else {
 747                 selected_waittime = cst_forward_data.cf_wait_time_index;
 748                 __cst_gl_expand_req(data, obj, event_info);
 749                 __cst_gl_expand(data, obj, event_info);
 750         }
 751 }
 752
 753 static void __cst_gl_collapse_req(void *data, Evas_Object *obj, void *event_info)
 754 {
 755         ENTER(__cst_gl_collapse_req);
 756         Elm_Object_Item *item = (Elm_Object_Item *)event_info;
 757         elm_genlist_item_expanded_set(item, 0);
 758 }
 759
 760 static void __cst_gl_collapse(int selected_time, Evas_Object *obj, void *event_info)
 761 {
 762         ENTER(__cst_gl_collapse);
 763         Elm_Object_Item *item = event_info;
 764         elm_genlist_item_subitems_clear(item);
 765
 766         if (selected_time != cst_forward_data.cf_wait_time_index) {
 767                 __cst_update_wait_time_and_index(cst_forward_data.cf_wait_time_index, CST_CF_WAIT_TIME_NONE);
 768                 __cst_gl_update_waiting_time_ss_request();
 769         }
 770 }
 771
 772 static void __cst_gl_expand_req(void *data, Evas_Object *obj, void *event_info)
 773 {
 774         ENTER(__cst_gl_expand_req);
 775         Elm_Object_Item *item = event_info;
 776         elm_genlist_item_expanded_set(item, 1);
 777 }
 778
 779 static void __cst_gl_expand(void *data, Evas_Object *obj, void *event_info)
 780 {
 781         ENTER(__cst_gl_expand);
 782         ret_if(NULL == data);
 783         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 784         CstUgData_t *ugd = (CstUgData_t *)item_data->ugd;
 785         Elm_Object_Item *it = (Elm_Object_Item *)event_info;
 786         ret_if(NULL == it);
 787         Evas_Object *genlist = elm_object_item_widget_get(it);
 788         ret_if(NULL == genlist);
 789         CstGlItemData_t *sub_item_data;
 790         int i = 0;
 791
 792         cst_forward_data.waitingtime_radio_btn = NULL;
 793         cst_forward_data.waitingtime_radio_btn = elm_radio_add(genlist);
 794         elm_radio_value_set(cst_forward_data.waitingtime_radio_btn, -1);
 795         for (i = 0; list_call_forwarding_dep2_waiting_time[i].style != CST_GL_ITEM_NONE; ++i) {
 796                 sub_item_data = (CstGlItemData_t *)calloc(1, sizeof(CstGlItemData_t));
 797                 ret_if(sub_item_data == NULL);
 798                 sub_item_data->index = i;
 799                 sub_item_data->ugd = ugd;
 800                 sub_item_data->parent_gl_item = it;
 801                 elm_genlist_item_append(genlist, cst_forward_data.itc_waiting_time_expand,
 802                         (const void *)sub_item_data, it,
 803                         list_call_forwarding_dep2_waiting_time[i].flags,
 804                         __cst_gl_sel_waiting_time, sub_item_data);
 805         }
 806 }
 807
 808 static void __cst_gl_update_waiting_time_ss_request(void)
 809 {
 810         ENTER("__cst_gl_update_waiting_time_ss_request");
 811         CstGlItemData_t *item_data = (CstGlItemData_t *)cst_forward_data.forwarding_item;
 812         CstUgData_t *ugd = (CstUgData_t *)item_data->ugd;
 813         CallSettingSSReq_t *req = NULL;
 814
 815         req = (CallSettingSSReq_t *)calloc(1, sizeof(CallSettingSSReq_t));
 816         ret_if(req == NULL);
 817         ugd->popup = NULL;
 818         req->data = (void *)item_data->gl_item;
 819         req->call_type = ugd->call_type;
 820         req->flavour = CST_SSTYPE_CF_NO_REPLY;
 821         req->action = CST_ACTION_ACTIVATE;
 822         req->original_state = CST_SS_STATE_ON;
 823         ugd->cf_state[item_data->index] = CST_SS_STATE_PROGRESS;
 824         elm_genlist_item_update(item_data->gl_item);
 825         snprintf(req->number, CST_MAX_PHONE_NUMBER_LEN, "%s", cst_forward_data.forwardto_item->number);
 826         _cst_add_ss_request(&ugd->req_queue, req->action,
 827                 req->call_type, req->flavour, req->number,
 828                 __cst_update_cf_state, cst_forward_data.cf_sel_item, cst_forward_data.cf_wait_time, ugd);
 829         free(req);
 830 }
 831
 832 static void __cst_gl_sel_waiting_time(void *data, Evas_Object *obj, void *event_info)
 833 {
 834         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 835         ret_if(NULL == data);
 836         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 837
 838         cst_forward_data.cf_wait_time_index = (int)list_call_forwarding_dep2_waiting_time[item_data->index].func;
 839         if (cst_forward_data.waitingtime_radio_btn) {
 840                 elm_radio_value_set(cst_forward_data.waitingtime_radio_btn,
 841                         (int)list_call_forwarding_dep2_waiting_time[item_data->index].func);
 842                 elm_genlist_item_update(item_data->parent_gl_item);
 843         }
 844         return;
 845 }
 846
 847 static char *__cst_gl_get_wait_time_sub_exp_label(void *data, Evas_Object *obj, const char *part)
 848 {
 849         retv_if(NULL == data, NULL);
 850         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 851         if (strcmp(part, "elm.text") == 0) {
 852                 return strdup(T_(list_call_forwarding_dep2_waiting_time[item_data->index].str_id));
 853         }
 854         return NULL;
 855 }
 856
 857 static Evas_Object *__cst_gl_get_wait_time_sub_exp_icon(void *data, Evas_Object *obj, const char *part)
 858 {
 859         retv_if(NULL == data, NULL);
 860         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 861
 862         if (!strcmp(part, "elm.icon")) {
 863                 Evas_Object *radio = NULL;
 864                 if (NULL == cst_forward_data.waitingtime_radio_btn) {
 865                         cst_forward_data.waitingtime_radio_btn = elm_radio_add(obj);
 866                         elm_radio_value_set(cst_forward_data.waitingtime_radio_btn, -1);
 867                 }
 868                 radio = __cst_gl_create_wait_time_radio_icon(obj, cst_forward_data.waitingtime_radio_btn,
 869                                                         (int)list_call_forwarding_dep2_waiting_time[item_data->index].func, 0);
 870                 return radio;
 871         }
 872         return NULL;
 873 }
 874
 875 static Evas_Object *__cst_gl_create_wait_time_radio_icon(Evas_Object *obj, Evas_Object *rdg, int value, int offset)
 876 {
 877         retv_if(NULL == obj, NULL);
 878
 879         int rd_value = 0;
 880         Evas_Object *radio = elm_radio_add(obj);
 881         elm_radio_state_value_set(radio, value);
 882         elm_radio_group_add(radio, rdg);
 883
 884         rd_value = cst_forward_data.cf_wait_time_index;
 885         elm_radio_value_set(rdg, (rd_value + offset));
 886         return radio;
 887 }
 888
 889 static void __cst_update_wait_time_and_index(int wait_time_index, int wait_time)
 890 {
 891         ENTER(__cst_update_wait_time_and_index);
 892
 893         if (wait_time_index != CST_CF_WAIT_TIME_IDX_NONE) { /* Update the waiting time from the index */
 894                 if (wait_time_index == CST_CF_WAIT_TIME_IDX_5_SEC) {
 895                         cst_forward_data.cf_wait_time = CST_CF_WAIT_TIME_5_SEC;
 896                 } else if (wait_time_index == CST_CF_WAIT_TIME_IDX_10_SEC) {
 897                         cst_forward_data.cf_wait_time = CST_CF_WAIT_TIME_10_SEC;
 898                 } else if (wait_time_index == CST_CF_WAIT_TIME_IDX_15_SEC) {
 899                         cst_forward_data.cf_wait_time = CST_CF_WAIT_TIME_15_SEC;
 900                 } else if (wait_time_index == CST_CF_WAIT_TIME_IDX_20_SEC) {
 901                         cst_forward_data.cf_wait_time = CST_CF_WAIT_TIME_20_SEC;
 902                 } else if (wait_time_index == CST_CF_WAIT_TIME_IDX_25_SEC) {
 903                         cst_forward_data.cf_wait_time = CST_CF_WAIT_TIME_25_SEC;
 904                 } else if (wait_time_index == CST_CF_WAIT_TIME_IDX_30_SEC) {
 905                         cst_forward_data.cf_wait_time = CST_CF_WAIT_TIME_30_SEC;
 906                 }
 907         } else if(wait_time != CST_CF_WAIT_TIME_NONE) { /* Update the waiting time index from the time */
 908                 if (wait_time == CST_CF_WAIT_TIME_5_SEC) {
 909                         cst_forward_data.cf_wait_time_index = CST_CF_WAIT_TIME_IDX_5_SEC;
 910                 } else if (wait_time == CST_CF_WAIT_TIME_10_SEC) {
 911                         cst_forward_data.cf_wait_time_index = CST_CF_WAIT_TIME_IDX_10_SEC;
 912                 } else if (wait_time == CST_CF_WAIT_TIME_15_SEC) {
 913                         cst_forward_data.cf_wait_time_index = CST_CF_WAIT_TIME_IDX_15_SEC;
 914                 } else if (wait_time == CST_CF_WAIT_TIME_20_SEC) {
 915                         cst_forward_data.cf_wait_time_index = CST_CF_WAIT_TIME_IDX_20_SEC;
 916                 }  else if (wait_time == CST_CF_WAIT_TIME_25_SEC) {
 917                         cst_forward_data.cf_wait_time_index = CST_CF_WAIT_TIME_IDX_25_SEC;
 918                 }  else if (wait_time == CST_CF_WAIT_TIME_30_SEC) {
 919                         cst_forward_data.cf_wait_time_index = CST_CF_WAIT_TIME_IDX_30_SEC;
 920                 }
 921         }
 922
 923         if (cst_forward_data.waitingtime_item) {
 924                 elm_genlist_item_update(cst_forward_data.waitingtime_item->gl_item);
 925         }
 926         return;
 927 }
 928
 929 static Evas_Object *__cst_create_genlist_cf_onoff_screen(void *data)
 930 {
 931         DBG("__cst_create_genlist_cf_onoff_screen");
 932         retv_if(NULL == data, NULL);
 933         CstUgData_t *ugd = (CstUgData_t *)data;
 934
 935         cst_forward_data.onoff_screen_genlist = elm_genlist_add(ugd->nf);
 936         elm_object_style_set(cst_forward_data.onoff_screen_genlist, "dialogue");
 937         _cst_create_genlist_separator(cst_forward_data.onoff_screen_genlist, EINA_FALSE);
 938
 939         /* Forwarding Item */
 940         cst_forward_data.itc_forwarding->item_style = "dialogue/1text.1icon";
 941         cst_forward_data.itc_forwarding->func.text_get = __cst_gl_cf_onoff_get_forwarding_label;
 942         cst_forward_data.itc_forwarding->func.content_get = __cst_gl_cf_onoff_get_icon;
 943         cst_forward_data.itc_forwarding->func.state_get = NULL;
 944         cst_forward_data.itc_forwarding->func.del = __cst_gl_del_cf;
 945
 946         cst_forward_data.forwarding_item = (CstGlItemData_t *)calloc(1, sizeof(CstGlItemData_t));
 947         retv_if(cst_forward_data.forwarding_item == NULL, NULL);
 948         cst_forward_data.forwarding_item->index = cst_forward_data.cf_sel_item->index; /* This is the index of the selected item from the previous screen */
 949         cst_forward_data.forwarding_item->ugd = ugd;
 950         if (strlen(cst_forward_data.cf_sel_item->number) > 0) {
 951                 snprintf(cst_forward_data.forwarding_item->number, sizeof(cst_forward_data.forwarding_item->number), "%s", cst_forward_data.cf_sel_item->number);
 952         }
 953         cst_forward_data.forwarding_item->gl_item = elm_genlist_item_append(cst_forward_data.onoff_screen_genlist, cst_forward_data.itc_forwarding,
 954                 (const void *)cst_forward_data.forwarding_item, NULL, list_call_forwarding_status[0].flags,
 955                 __cst_gl_cf_onoff_forwarding_sel, cst_forward_data.forwarding_item);
 956
 957         /* Forward to Item displayed only when the selected item is on */
 958         cst_forward_data.itc_forward_to->item_style = "ciss/2text_call_forward";
 959         cst_forward_data.itc_forward_to->func.text_get = __cst_gl_cf_onoff_get_forward_to_label;
 960         cst_forward_data.itc_forward_to->func.content_get = NULL;
 961         cst_forward_data.itc_forward_to->func.state_get = NULL;
 962         cst_forward_data.itc_forward_to->func.del = NULL;
 963
 964         cst_forward_data.forwardto_item = (CstGlItemData_t *)calloc(1, sizeof(CstGlItemData_t));
 965         retv_if(cst_forward_data.forwardto_item == NULL, NULL);
 966         cst_forward_data.forwardto_item->index = CST_CF_FORWARD_TO_TEXT;
 967         cst_forward_data.forwardto_item->ugd = ugd;
 968         cst_forward_data.forwardto_item->gl_item = NULL;
 969         if (ugd->cf_state[cst_forward_data.forwarding_item->index] == CST_SS_STATE_ON) {
 970                 __cst_gl_cf_onoff_screen_show_remove_forwardto_item(EINA_TRUE, cst_forward_data.cf_sel_item->number);
 971         }
 972
 973         /* Waiting time Item displayed only when the selected item is on and is of type "If no reply"*/
 974         if (cst_forward_data.cf_sel_item->index == CST_CF_IF_NO_REPLY_SEL) {
 975                 cst_forward_data.itc_waiting_time->item_style = "dialogue/2text.3/expandable";
 976                 cst_forward_data.itc_waiting_time->func.text_get = __cst_gl_cf_onoff_get_waiting_time_label;
 977                 cst_forward_data.itc_waiting_time->func.content_get = NULL;
 978                 cst_forward_data.itc_waiting_time->func.state_get = NULL;
 979                 cst_forward_data.itc_waiting_time->func.del = NULL;
 980
 981                 cst_forward_data.itc_waiting_time_expand->item_style = "dialogue/1text.1icon/expandable2";
 982                 cst_forward_data.itc_waiting_time_expand->func.text_get = __cst_gl_get_wait_time_sub_exp_label;
 983                 cst_forward_data.itc_waiting_time_expand->func.content_get = __cst_gl_get_wait_time_sub_exp_icon;
 984                 cst_forward_data.itc_waiting_time_expand->func.state_get = NULL;
 985                 cst_forward_data.itc_waiting_time_expand->func.del = __cst_gl_del_cf;
 986                 cst_forward_data.waitingtime_item = (CstGlItemData_t *)calloc(1, sizeof(CstGlItemData_t));
 987                 retv_if(cst_forward_data.waitingtime_item == NULL, NULL);
 988                 cst_forward_data.waitingtime_item->index = CST_CF_WAITING_TIME_SEL;
 989                 cst_forward_data.waitingtime_item->ugd = ugd;
 990                 cst_forward_data.waitingtime_item->gl_item = NULL;
 991                 if (ugd->cf_state[cst_forward_data.forwarding_item->index] == CST_SS_STATE_ON) {
 992                         __cst_gl_cf_onoff_screen_show_remove_waitingtime_item(EINA_TRUE);
 993                 }
 994         }
 995         return cst_forward_data.onoff_screen_genlist;
 996 }
 997
 998 static void __cst_on_click_show_cf_onoff_screen(void *data, Evas *evas, Evas_Object *obj, void *event_info)
 999 {
1000         ENTER(__cst_on_click_show_cf_onoff_screen);
1001         ret_if(NULL == data);
1002         CstGlItemData_t *sel_data = (CstGlItemData_t *)data;
1003         CstUgData_t *ugd = sel_data->ugd;
1004         Evas_Object *back_btn = NULL;
1005         Elm_Object_Item *navi_it;
1006
1007         if (ugd->cf_state[sel_data->index] == CST_SS_STATE_PROGRESS)
1008                 return;
1009
1010         cst_forward_data.cf_sel_item = sel_data;
1011         __cst_create_genlist_cf_onoff_screen(ugd);
1012
1013         back_btn = elm_button_add(ugd->nf);
1014         navi_it = elm_naviframe_item_push(ugd->nf, T_(list_call_forwarding[sel_data->index].str_id),
1015                 NULL, NULL, cst_forward_data.onoff_screen_genlist, NULL);
1016         back_btn = elm_object_item_part_content_get(navi_it, "prev_btn");
1017         evas_object_smart_callback_add(back_btn, "clicked",
1018                         __cst_on_click_cf_onoff_screen_back_button, ugd);
1019 }
1020
1021 static void __cst_cf_clear_onoff_screen_data(void)
1022 {
1023         ENTER(__cst_cf_clear_onoff_screen_data);
1024         if (cst_forward_data.forwardto_item) {
1025                 if (cst_forward_data.forwardto_item->gl_item) {
1026                         elm_object_item_del(cst_forward_data.forwardto_item->gl_item);
1027                         cst_forward_data.forwardto_item->gl_item = NULL;
1028                 }
1029                 free(cst_forward_data.forwardto_item);
1030                 cst_forward_data.forwardto_item = NULL;
1031         }
1032         if (cst_forward_data.waitingtime_item) {
1033                 if (cst_forward_data.waitingtime_item->gl_item) {
1034                         elm_object_item_del(cst_forward_data.waitingtime_item->gl_item);
1035                         cst_forward_data.waitingtime_item->gl_item = NULL;
1036                 }
1037                 free(cst_forward_data.waitingtime_item);
1038                 cst_forward_data.waitingtime_item = NULL;
1039         }
1040         if (cst_forward_data.onoff_screen_genlist) {
1041                 cst_forward_data.onoff_screen_genlist = NULL;
1042         }
1043 }
1044
1045 void _cst_on_click_call_forwarding(void *data, Evas *evas, Evas_Object *obj, void *event_info)
1046 {
1047         ENTER(_cst_on_click_call_forwarding);
1048         ret_if(NULL == data);
1049         CstUgData_t *ugd = (CstUgData_t *)data;
1050         Evas_Event_Mouse_Up *ev = (Evas_Event_Mouse_Up *)event_info;
1051         Evas_Object *back_btn = NULL;
1052         Elm_Object_Item *navi_it;
1053
1054         if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) {
1055                 return;
1056         }
1057
1058         if (_cst_check_flight_mode()) {
1059                 ugd->popup = _cst_create_error_popup(ugd->nf,
1060                         CST_ERROR_CHANGE_FLIGHT_MODE);
1061                 evas_object_show(ugd->popup);
1062                 return;
1063         }
1064
1065         if (!_cst_check_sim_status()) {
1066                 ugd->popup = _cst_create_error_popup(ugd->nf,
1067                         CST_ERROR_INSERT_SIM_CARD);
1068                 evas_object_show(ugd->popup);
1069                 return;
1070         }
1071
1072         ugd->call_type = CST_CALLTYPE_VOICE;
1073         ugd->popup = NULL;
1074
1075         Evas_Object *genlist = __cst_create_genlist_cf(ugd);
1076
1077         back_btn = elm_button_add(ugd->nf);
1078         navi_it = elm_naviframe_item_push(ugd->nf, T_(CST_STR_CALL_FORWARDING),
1079                 NULL, NULL, genlist, NULL);
1080         back_btn = elm_object_item_part_content_get(navi_it, "prev_btn");
1081         evas_object_smart_callback_add(back_btn, "clicked",
1082                 __cst_on_click_cf_back_button, ugd);
1083 }
1084
1085 void _cst_call_forwarding_input_panel_event_callback(void *data, Ecore_IMF_Context *imf_context, int value)
1086 {
1087         ENTER(_cst_call_forwarding_input_panel_event_callback);
1088         ret_if(!data);
1089         CstUgData_t *ugd = (CstUgData_t *)data;
1090         Evas_Object *btn = NULL;
1091         CallSettingSSReq_t *req = NULL;
1092         const char *entry_input = NULL;
1093
1094         Elm_Object_Item *top_it = elm_naviframe_top_item_get(ugd->nf);
1095         ret_if(!top_it);
1096         req = (CallSettingSSReq_t *)elm_object_item_data_get(top_it);
1097         ret_if(!req);
1098
1099         entry_input = elm_entry_entry_get(ugd->dg_entry);
1100         if(value == ECORE_IMF_INPUT_PANEL_STATE_SHOW) {
1101                 DBG("ECORE_IMF_INPUT_PANEL_STATE_SHOW");
1102
1103                 btn = _cst_create_title_btn(ugd->nf, (char *)T_(CST_STR_CANCEL),
1104                         __cst_on_click_cf_ime_cancel_btn, (void *)req);
1105                 elm_object_item_part_content_set(top_it, "title_right_btn", btn);
1106
1107                 btn = _cst_create_title_btn(ugd->nf, (char *)T_(CST_STR_DONE),
1108                         __cst_on_click_cf_ime_done_btn, (void *)req);
1109                 elm_object_item_part_content_set(top_it, "title_left_btn", btn);
1110                 if (entry_input && strlen(entry_input) > 0) {
1111                         elm_object_disabled_set(btn, EINA_FALSE);
1112                 } else {
1113                         elm_object_disabled_set(btn, EINA_TRUE);
1114                 }
1115         } else if(value == ECORE_IMF_INPUT_PANEL_STATE_HIDE) {
1116                 Evas_Object *cbar = NULL;
1117                 DBG("ECORE_IMF_INPUT_PANEL_STATE_HIDE");
1118                 elm_object_item_part_content_set(top_it, "title_right_btn", NULL);
1119                 elm_object_item_part_content_set(top_it, "title_left_btn", NULL);
1120                 cbar = _cst_create_navi_control_bar(ugd->nf,
1121                         (char *)T_(CST_STR_DONE), NULL,
1122                         __cst_on_click_cf_ime_done_btn,
1123                         (char *)T_(CST_STR_CANCEL), NULL,
1124                         __cst_on_click_cf_ime_cancel_btn,
1125                         (void *)req, top_it,
1126                         cst_forward_data.ec_item);
1127                 if (entry_input && strlen(entry_input) > 0) {
1128                         elm_object_item_disabled_set(cst_forward_data.ec_item[0], EINA_FALSE);
1129                 } else {
1130                         elm_object_item_disabled_set(cst_forward_data.ec_item[0], EINA_TRUE);
1131                 }
1132         }
1133 }
1134
1135 void _cst_call_forward_entry_changed_cb(void *data, Evas_Object *obj, void *event_info)
1136 {
1137         DBG("_cst_call_forward_entry_changed_cb calling");
1138         ret_if(!data);
1139         CstUgData_t *ugd = (CstUgData_t *)data;
1140         Evas_Object *btn = NULL;
1141         const char *entry_input = NULL;
1142
1143         Elm_Object_Item *top_it = elm_naviframe_top_item_get(ugd->nf);
1144         ret_if(!top_it);
1145
1146         entry_input = elm_entry_entry_get(ugd->dg_entry);
1147         if((btn = elm_object_item_part_content_get(top_it, "title_left_btn")) != NULL) {
1148                 if (entry_input && strlen(entry_input) > 0) {
1149                         elm_object_disabled_set(btn, EINA_FALSE);
1150                 } else {
1151                         elm_object_disabled_set(btn, EINA_TRUE);
1152                 }
1153         } else {
1154                 if (entry_input && strlen(entry_input) > 0) {
1155                         elm_object_item_disabled_set(cst_forward_data.ec_item[0], EINA_FALSE);
1156                 } else {
1157                         elm_object_item_disabled_set(cst_forward_data.ec_item[0], EINA_TRUE);
1158                 }
1159         }
1160 }
1161