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