src/cst-barring.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-barring.h"
  23 #include "cst-barring-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 static void __cst_on_click_cb_onoff(void *data, Evas *evas, Evas_Object *obj, void *event_info);
  30 static void __cst_on_click_voice_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info);
  31 static void __cst_on_click_video_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info);
  32
  33 static Elm_Genlist_Item_Class *itc_1text_1icon = NULL;
  34 static Elm_Genlist_Item_Class *itc_1text = NULL;
  35 static Elm_Object_Item *ec_item[3];
  36
  37 static CstGlItemDisplayInfo_t list_call_type[] = {
  38         {1, CST_STR_VOICECALL, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_TEXT, __cst_on_click_voice_cb},
  39         {1, CST_STR_VIDEOCALL, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_TEXT, __cst_on_click_video_cb},
  40
  41         {1, -1, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_NONE, NULL},
  42 };
  43
  44 static CstGlItemDisplayInfo_t list_call_barring[] = {
  45         {1, CST_STR_CALL_ALL_OUTGOING_CALLS, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_1TEXT_ONOFF_PROGRESS, __cst_on_click_cb_onoff},
  46         {1, CST_STR_INTL_CALLS, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_1TEXT_ONOFF_PROGRESS, __cst_on_click_cb_onoff},
  47         {1, CST_STR_CALL_INTL_EXCEPT_HOME, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_1TEXT_ONOFF_PROGRESS, __cst_on_click_cb_onoff},
  48         {1, CST_STR_ALL_INCOMING_CALLS, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_1TEXT_ONOFF_PROGRESS, __cst_on_click_cb_onoff},
  49         {1, CST_STR_CALL_INCOMING_WHEN_ROAMING, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_1TEXT_ONOFF_PROGRESS, __cst_on_click_cb_onoff},
  50
  51         {1, -1, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_NONE, NULL},
  52 };
  53
  54 static void __cst_on_click_cb_back_button(void *data, Evas_Object *obj, void *event_info)
  55 {
  56         ENTER(__cst_on_click_cb_back_button);
  57         retm_if(data == NULL, "NULL UgData");
  58
  59         CstUgData_t *ugd = (CstUgData_t *)data;
  60         _cst_cancel_all_ss_request(ugd);
  61
  62         ugd->back_button = _cst_get_navifr_prev_btn(ugd->nf);
  63 }
  64
  65 static void __cst_disable_cb_glitem(CstGlItemData_t *item_data)
  66 {
  67         ENTER(__cst_disable_cb_glitem);
  68         CstUgData_t *ugd = (CstUgData_t *)item_data->ugd;
  69         ugd->cb_state[item_data->index] = CST_SS_STATE_OFF;
  70         elm_genlist_item_update(item_data->gl_item);
  71         elm_object_item_disabled_set(item_data->gl_item, EINA_TRUE);
  72
  73         elm_object_item_disabled_set(ec_item[0], EINA_FALSE);
  74 }
  75
  76 static int __cst_update_cb_state(int call_type, int cb_flavour,
  77                 Eina_Bool cb_state, char *number,
  78                 int error, int req_action, void *data)
  79 {
  80         ret_if(NULL == data);
  81         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
  82         CstUgData_t *ugd = item_data->ugd;
  83         DBG("call_type=%d (0:voice 1:video)", call_type);
  84         DBG("cb_flavour=%d (6:BAOC 7:BAOIC 8:BAOIC exc home 9:BAIC 10:BAIC roaming)", cb_flavour);
  85         DBG("cb_state=%d (1:on 0:off), error=%d", cb_state, error);
  86         DBG("req_action=%d(0: Activate, 1:Deactivate, 2:Query)", req_action);
  87         retv_if((call_type != ugd->call_type && call_type != CST_CALLTYPE_ALL), -1);
  88
  89         if (error == CST_ERROR_NONE) {
  90                 if (cb_state == EINA_TRUE)
  91                         ugd->cb_state[item_data->index] = CST_SS_STATE_ON;
  92                 else
  93                         ugd->cb_state[item_data->index] = CST_SS_STATE_OFF;
  94                 elm_genlist_item_update(item_data->gl_item);
  95         } else {
  96                 if (req_action != CST_ACTION_QUERY) {
  97                         if (error != CST_ERROR_SERVICE_UNAVAILABLE &&
  98                                 error != CST_ERROR_REJECTED_BY_NETWORK &&
  99                                 error != CST_ERROR_UNKNOWN) {
 100                                 if (req_action == CST_ACTION_DEACTIVATE)
 101                                         ugd->cb_state[item_data->index] = CST_SS_STATE_ON;
 102                                 else
 103                                         ugd->cb_state[item_data->index] = CST_SS_STATE_OFF;
 104                         } else
 105                                 ugd->cb_state[item_data->index] = CST_SS_STATE_OFF;
 106
 107                         elm_genlist_item_update(item_data->gl_item);
 108                         ugd->popup = (Evas_Object *)_cst_create_error_popup(ugd->nf, error);
 109                         evas_object_show(ugd->popup);
 110                 } else
 111                         __cst_disable_cb_glitem(item_data);
 112         }
 113         return 0;
 114 }
 115
 116 static void __cst_query_cb_status(CstGlItemData_t *item_data)
 117 {
 118         ENTER(__cst_query_cb_status);
 119         ret_if(NULL == item_data);
 120         CstUgData_t *ugd = (CstUgData_t *)item_data->ugd;
 121         int cb_flavour = -1;
 122
 123         ugd->original_state = EINA_FALSE;
 124         switch (item_data->index) {
 125         case 0:
 126                 cb_flavour = CST_SSTYPE_CB_OC;
 127                 DBG("CST_SSTYPE_CB_OC");
 128                 break;
 129         case 1:
 130                 cb_flavour = CST_SSTYPE_CB_OIC;
 131                 DBG("CST_SSTYPE_CB_OIC");
 132                 break;
 133         case 2:
 134                 cb_flavour = CST_SSTYPE_CB_OICEH;
 135                 DBG("CST_SSTYPE_CB_OICEH");
 136                 break;
 137         case 3:
 138                 cb_flavour = CST_SSTYPE_CB_IC;
 139                 DBG("CST_SSTYPE_CB_IC");
 140                 break;
 141         case 4:
 142                 cb_flavour = CST_SSTYPE_CB_ICR;
 143                 DBG("CST_SSTYPE_CB_ICR");
 144                 break;
 145         default:
 146                 DBG("Error type");
 147                 break;
 148         }
 149
 150         _cst_add_ss_request(&ugd->req_queue,
 151                 CST_ACTION_QUERY, ugd->call_type, cb_flavour,
 152                 NULL, __cst_update_cb_state, item_data);
 153 }
 154
 155 static void __cst_on_click_cb_check_status_btn(void *data, Evas_Object *obj, void *event_info)
 156 {
 157         ENTER(__cst_on_click_cb_check_status_btn);
 158         ret_if(!data);
 159
 160         Evas_Object *genlist = (Evas_Object *)data;
 161         CstGlItemData_t *item_data;
 162         CstUgData_t *ugd;
 163         Eina_List *realized_list;
 164         Elm_Object_Item *it;
 165         Eina_List *l;
 166
 167         realized_list = elm_genlist_realized_items_get(genlist);
 168         EINA_LIST_FOREACH(realized_list, l, it) {
 169                 item_data = (CstGlItemData_t *)elm_object_item_data_get(it);
 170                 if (elm_object_item_disabled_get(it) == EINA_TRUE) {
 171                         ugd = item_data->ugd;
 172                         ugd->cb_state[item_data->index] = CST_SS_STATE_PROGRESS;
 173                         __cst_query_cb_status(item_data);
 174                         elm_object_item_disabled_set(it, EINA_FALSE);
 175                         elm_genlist_item_update(it);
 176                 }
 177         }
 178         elm_object_item_disabled_set(ec_item[0], EINA_TRUE);
 179 }
 180
 181 static void __cst_on_click_cb_ime_done_btn(void *data, Evas_Object *obj, void *event_info)
 182 {
 183         ENTER(__cst_on_click_cb_ime_done_btn);
 184         ret_if(!data);
 185
 186         CallSettingReq_t *req = (CallSettingReq_t *)data;
 187
 188         CstGlItemData_t *item_data = (CstGlItemData_t *)req->data;
 189         CstUgData_t *ugd = item_data->ugd;
 190
 191         char buffer[CST_MAX_PHONE_NUMBER_LEN];
 192
 193         if (_cst_get_cb_input_password(buffer, ugd) > 0) {
 194                 ugd->cb_state[item_data->index] = CST_SS_STATE_PROGRESS;
 195                 elm_genlist_item_update(item_data->gl_item);
 196
 197                 DBG("activate CB pwd=%s", buffer);
 198                 snprintf(req->number, CST_MAX_PHONE_NUMBER_LEN, "%s", buffer);
 199                 _cst_add_ss_request(&ugd->req_queue,
 200                         req->action, req->call_type, req->flavour,
 201                         req->number, __cst_update_cb_state, item_data);
 202
 203                 memset(ugd->c_item, 0, sizeof(ugd->c_item));
 204                 elm_naviframe_item_pop(ugd->nf);
 205                 ugd->back_button = _cst_get_navifr_prev_btn(ugd->nf);
 206         }
 207 }
 208
 209 static void __cst_on_click_cb_ime_cancel_btn(void *data, Evas_Object *obj, void *event_info)
 210 {
 211         ENTER(__cst_on_click_cb_ime_cancel_btn);
 212         ret_if(!data);
 213
 214         CallSettingReq_t *req = (CallSettingReq_t *)data;
 215         CstGlItemData_t *item_data = (CstGlItemData_t *)req->data;
 216         CstUgData_t *ugd = item_data->ugd;
 217
 218         DBG("original state : %d", req->original_state);
 219         if (req->original_state == CST_SS_STATE_ON)
 220                 ugd->cb_state[item_data->index] = CST_SS_STATE_ON;
 221         else
 222                 ugd->cb_state[item_data->index] = CST_SS_STATE_OFF;
 223         elm_genlist_item_update(item_data->gl_item);
 224
 225         memset(ugd->c_item, 0, sizeof(ugd->c_item));
 226         elm_naviframe_item_pop(ugd->nf);
 227         ugd->back_button = _cst_get_navifr_prev_btn(ugd->nf);
 228         if (req)
 229                 free(req);
 230 }
 231
 232 static char *__cst_gl_label_get_cb(void *data, Evas_Object *obj, const char *part)
 233 {
 234         retv_if(NULL == data, NULL);
 235         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 236
 237         if (strcmp(part, "elm.text") == 0) {
 238                 return strdup(T_(list_call_barring[item_data->index].str_id));
 239         }
 240         return NULL;
 241 }
 242
 243 static void __cst_gl_del_cb(void *data, Evas_Object *obj)
 244 {
 245         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 246         if (item_data)
 247                 free(item_data);
 248         return;
 249 }
 250
 251 static void __cst_update_change_cb_req(CstGlItemData_t *item_data, Eina_Bool req_state)
 252 {
 253         ret_if(item_data == NULL);
 254
 255         Evas_Object *eo;
 256         CallSettingReq_t *req = NULL;
 257         CstUgData_t *ugd = item_data->ugd;
 258         Elm_Object_Item *navi_it;
 259         Evas_Object *btn;
 260
 261         req = (CallSettingReq_t *)calloc(1, sizeof(CallSettingReq_t));
 262         ret_if(req == NULL);
 263
 264         ugd->popup = NULL;
 265         req->data = item_data;
 266         req->call_type = ugd->call_type;
 267         req->flavour = -1;
 268
 269         DBG("req_state = %d", req_state);
 270         switch (item_data->index) {
 271         case 0:
 272                 req->flavour = CST_SSTYPE_CB_OC;
 273                 DBG("CST_SSTYPE_CB_OC");
 274                 break;
 275         case 1:
 276                 req->flavour = CST_SSTYPE_CB_OIC;
 277                 DBG("CST_SSTYPE_CB_OIC");
 278                 break;
 279         case 2:
 280                 req->flavour = CST_SSTYPE_CB_OICEH;
 281                 DBG("CST_SSTYPE_CB_OICEH");
 282                 break;
 283         case 3:
 284                 req->flavour = CST_SSTYPE_CB_IC;
 285                 DBG("CST_SSTYPE_CB_IC");
 286                 break;
 287         case 4:
 288                 req->flavour = CST_SSTYPE_CB_ICR;
 289                 DBG("CST_SSTYPE_CB_ICR");
 290                 break;
 291         default:
 292                 DBG("Error type");
 293                 break;
 294         }
 295
 296         ugd->original_state = !req_state;
 297         if (req_state == EINA_TRUE) {
 298                 req->original_state = CST_SS_STATE_OFF;
 299                 req->action = CST_ACTION_ACTIVATE;
 300         } else {
 301                 req->original_state = CST_SS_STATE_ON;
 302                 req->action = CST_ACTION_DEACTIVATE;
 303         }
 304
 305         eo = _cst_create_cb_ime(ugd->nf, NULL, ugd);
 306         _cst_remove_naviframe(ugd->nf);
 307         navi_it = elm_naviframe_item_push(ugd->nf,
 308                 T_(CST_STR_PASSWORD), NULL, NULL, eo, "1line");
 309
 310         btn = _cst_create_title_btn(ugd->nf, (char *)T_(CST_STR_CANCEL),
 311                 __cst_on_click_cb_ime_cancel_btn, (void *)req);
 312         elm_object_item_part_content_set(navi_it, "title_left_btn", btn);
 313
 314         btn = _cst_create_title_btn(ugd->nf, (char *)T_(CST_STR_DONE),
 315                 __cst_on_click_cb_ime_done_btn, (void *)req);
 316         elm_object_item_part_content_set(navi_it, "title_right_btn", btn);
 317         elm_object_disabled_set(btn, EINA_TRUE);
 318 }
 319
 320 static void __cst_on_click_cb_onoff(void *data, Evas *evas, Evas_Object *obj, void *event_info)
 321 {
 322         ret_if(NULL == data);
 323         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 324         CstUgData_t *ugd = item_data->ugd;
 325         if (ugd->cb_state[item_data->index] == CST_SS_STATE_PROGRESS)
 326                 return;
 327
 328         Eina_Bool check_state = elm_check_state_get(item_data->eo_check);
 329
 330         __cst_update_change_cb_req(item_data, !check_state);
 331         elm_genlist_item_update(item_data->gl_item);
 332 }
 333
 334 static void __cst_gl_sel_cb(void *data, Evas_Object *obj, void *event_info)
 335 {
 336         ret_if(data == NULL);
 337         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 338         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 339         if (list_call_barring[item_data->index].func)
 340                 list_call_barring[item_data->index].func((void *)item_data, NULL, obj, event_info);
 341         return;
 342 }
 343
 344 static void __cst_on_changed_cb_check(void *data, Evas_Object *obj, void *event_info)
 345 {
 346         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 347         Eina_Bool check_state = elm_check_state_get(obj);
 348
 349         if (elm_object_item_disabled_get(item_data->gl_item) == EINA_TRUE) {
 350                 elm_check_state_set(obj, EINA_FALSE);
 351                 return;
 352         }
 353
 354         __cst_update_change_cb_req(item_data, check_state);
 355 }
 356
 357 static Evas_Object *__cst_gl_icon_get_cb(void *data, Evas_Object *obj, const char *part)
 358 {
 359         retv_if(NULL == data, NULL);
 360         Evas_Object *icon = NULL;
 361         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 362         CstUgData_t *ugd = (CstUgData_t *)item_data->ugd;
 363         Eina_Bool check_state = EINA_FALSE;
 364
 365         if (!strcmp(part, "elm.icon")) {
 366                 switch (ugd->cb_state[item_data->index]) {
 367                 case CST_SS_STATE_ON:
 368                 case CST_SS_STATE_OFF:
 369                         DBG("ugd->cb_state : %d(%d)",
 370                                 ugd->cb_state[item_data->index], item_data->index);
 371                         if (ugd->cb_state[item_data->index] == CST_SS_STATE_ON)
 372                                 check_state = EINA_TRUE;
 373                         item_data->eo_check = icon = _cst_create_onoff_button(obj, check_state,
 374                                 __cst_on_changed_cb_check, item_data);
 375                         break;
 376                 case CST_SS_STATE_PROGRESS:
 377                         icon = _cst_create_progressbar(obj);
 378                         break;
 379                 default:
 380                         return NULL;
 381                 }
 382         }
 383         return icon;
 384 }
 385
 386 static Evas_Object *__cst_create_genlist_cb(void *data)
 387 {
 388         ENTER(__cst_create_genlist_cb);
 389         retv_if(NULL == data, NULL);
 390         CstUgData_t *ugd = (CstUgData_t *)data;
 391         int index = 0;
 392         Evas_Object *genlist;
 393         CstGlItemData_t *item_data;
 394
 395         itc_1text_1icon->item_style = "dialogue/1text.1icon";
 396         itc_1text_1icon->func.text_get = __cst_gl_label_get_cb;
 397         itc_1text_1icon->func.content_get = __cst_gl_icon_get_cb;
 398         itc_1text_1icon->func.state_get = NULL;
 399         itc_1text_1icon->func.del = __cst_gl_del_cb;
 400
 401         genlist = elm_genlist_add(ugd->nf);
 402
 403         _cst_create_genlist_seperator(genlist, EINA_FALSE);
 404         for (index = 0; list_call_barring[index].style != CST_GL_ITEM_NONE; ++index) {
 405                 item_data = (CstGlItemData_t *)calloc(1, sizeof(CstGlItemData_t));
 406                 retv_if(item_data == NULL, NULL);
 407                 item_data->index = index;
 408                 item_data->ugd = ugd;
 409                 if (list_call_barring[index].style == CST_GL_ITEM_1TEXT_ONOFF_PROGRESS) {
 410                         ugd->cb_state[index] = CST_SS_STATE_PROGRESS;
 411                         item_data->gl_item = elm_genlist_item_append(genlist, itc_1text_1icon,
 412                                 (void *)item_data, NULL, list_call_barring[index].flags,
 413                                 __cst_gl_sel_cb, item_data);
 414                         __cst_query_cb_status(item_data);
 415                 } else {
 416                         DBG("No style");
 417                         free(item_data);
 418                         item_data = NULL;
 419                         return;
 420                 }
 421         }
 422
 423         return genlist;
 424 }
 425
 426 static void __cst_on_click_voice_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
 427 {
 428         ENTER(__cst_on_click_voice_cb);
 429         ret_if(NULL == data);
 430         CstUgData_t *ugd = (CstUgData_t *)data;
 431         Evas_Event_Mouse_Up *ev = (Evas_Event_Mouse_Up *)event_info;
 432         Evas_Object *back_btn = NULL;
 433         Evas_Object *layout, *cbar;
 434         Elm_Object_Item *navi_it;
 435
 436         if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) {
 437                 return;
 438         }
 439
 440         ugd->call_type = CST_CALLTYPE_VOICE;
 441         ugd->popup = NULL;
 442
 443         Evas_Object *genlist = __cst_create_genlist_cb(ugd);
 444
 445         layout = elm_layout_add(ugd->nf);
 446         elm_layout_file_set(layout, EDJ_NAME, "toolbar");
 447         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 448         evas_object_size_hint_align_set(layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
 449         elm_object_part_content_set(layout, "elm.swallow.contents", genlist);
 450         navi_it = elm_naviframe_item_push(ugd->nf, T_(CST_STR_VOICECALL),
 451                 NULL, NULL, layout, "1line");
 452         back_btn = elm_object_item_part_content_get(navi_it, "prev_btn");
 453         evas_object_smart_callback_add(back_btn, "clicked",
 454                 __cst_on_click_cb_back_button, ugd);
 455
 456         cbar = _cst_create_navi_control_bar(ugd->nf,
 457                         (char *)T_(CST_STR_CHECK_STATUS), CST_CTRL_ICON_UPDATE,
 458                         __cst_on_click_cb_check_status_btn,
 459                         NULL, NULL, NULL,
 460                         (void *)genlist, navi_it,
 461                         ec_item);
 462         ret_if((NULL == cbar) || (NULL == ec_item[0]));
 463         elm_object_item_disabled_set(ec_item[0], EINA_TRUE);
 464 }
 465
 466 static void __cst_on_click_video_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
 467 {
 468         ENTER(__cst_on_click_video_cb);
 469         ret_if(NULL == data);
 470         CstUgData_t *ugd = (CstUgData_t *)data;
 471         Evas_Event_Mouse_Up *ev = (Evas_Event_Mouse_Up *)event_info;
 472         Evas_Object *back_btn = NULL;
 473         Evas_Object *layout, *cbar;
 474         Elm_Object_Item *navi_it;
 475
 476         if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) {
 477                 return;
 478         }
 479
 480         ugd->call_type = CST_CALLTYPE_VIDEO;
 481         ugd->popup = NULL;
 482
 483         Evas_Object *genlist = __cst_create_genlist_cb(ugd);
 484
 485         layout = elm_layout_add(ugd->nf);
 486         elm_layout_file_set(layout, EDJ_NAME, "toolbar");
 487         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 488         evas_object_size_hint_align_set(layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
 489         elm_object_part_content_set(layout, "elm.swallow.contents", genlist);
 490         navi_it = elm_naviframe_item_push(ugd->nf, T_(CST_STR_VIDEOCALL),
 491                 NULL, NULL, layout, "1line");
 492         back_btn = elm_object_item_part_content_get(navi_it, "prev_btn");
 493         evas_object_smart_callback_add(back_btn, "clicked",
 494                 __cst_on_click_cb_back_button, ugd);
 495
 496         cbar = _cst_create_navi_control_bar(ugd->nf,
 497                         (char *)T_(CST_STR_CHECK_STATUS), CST_CTRL_ICON_UPDATE,
 498                         __cst_on_click_cb_check_status_btn,
 499                         NULL, NULL, NULL,
 500                         (void *)genlist, navi_it,
 501                         ec_item);
 502         ret_if((NULL == cbar) || (NULL == ec_item[0]));
 503         elm_object_item_disabled_set(ec_item[0], EINA_TRUE);
 504 }
 505
 506 static void __cst_gl_sel_call_type(void *data, Evas_Object *obj, void *event_info)
 507 {
 508         ret_if(data == NULL);
 509         CstUgData_t *ugd = (CstUgData_t *)data;
 510         Elm_Object_Item *item= (Elm_Object_Item *)event_info;
 511         int index = (int)elm_object_item_data_get(item);
 512         elm_genlist_item_selected_set(item, EINA_FALSE);
 513
 514         if (list_call_type[index].func)
 515                 list_call_type[index].func((void *)ugd, NULL, obj, event_info);
 516         return;
 517 }
 518
 519 static char *__cst_gl_label_get_call_type(void *data, Evas_Object *obj, const char *part)
 520 {
 521         int index = (int)data;
 522
 523         if (strcmp(part, "elm.text") == 0)
 524                 return strdup(T_(list_call_type[index].str_id));
 525         return NULL;
 526 }
 527
 528 static Evas_Object *__cst_create_genlist_call_type(void *data)
 529 {
 530         ENTER(__cst_create_genlist_call_type);
 531         retv_if(NULL == data, NULL);
 532         CstUgData_t *ugd = (CstUgData_t *)data;
 533         Evas_Object *genlist;
 534         Elm_Object_Item *git;
 535         int index = 0;
 536
 537         if (!itc_1text_1icon)
 538                 itc_1text_1icon = elm_genlist_item_class_new();
 539
 540         if (!itc_1text)
 541                 itc_1text = elm_genlist_item_class_new();
 542
 543         itc_1text->item_style = "dialogue/1text";
 544         itc_1text->func.text_get = __cst_gl_label_get_call_type;
 545         itc_1text->func.content_get = NULL;
 546         itc_1text->func.state_get = NULL;
 547         itc_1text->func.del = NULL;
 548
 549         genlist = elm_genlist_add(ugd->nf);
 550
 551         _cst_create_genlist_seperator(genlist, EINA_FALSE);
 552         for (index = 0; list_call_type[index].style != CST_GL_ITEM_NONE; index++) {
 553                 git = elm_genlist_item_append(genlist, itc_1text,
 554                         (void *)index, NULL, ELM_GENLIST_ITEM_NONE,
 555                         __cst_gl_sel_call_type, (void *)ugd);
 556         }
 557
 558         return genlist;
 559 }
 560
 561 void _cst_on_click_call_barring(void *data, Evas *evas, Evas_Object *obj, void *event_info)
 562 {
 563         ENTER(_cst_on_click_call_barring);
 564         ret_if(NULL == data);
 565         CstUgData_t *ugd = (CstUgData_t *)data;
 566         Evas_Event_Mouse_Up *ev = (Evas_Event_Mouse_Up *)event_info;
 567         Evas_Object *back_btn = NULL;
 568         Elm_Object_Item *navi_it;
 569
 570         if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) {
 571                 return;
 572         }
 573
 574         if (_cst_check_flight_mode()) {
 575                 ugd->popup = _cst_create_error_popup(ugd->nf,
 576                         CST_ERROR_CHANGE_FLIGHT_MODE);
 577                 evas_object_show(ugd->popup);
 578                 return;
 579         }
 580
 581         if (!_cst_check_sim_status()) {
 582                 ugd->popup = _cst_create_error_popup(ugd->nf,
 583                         CST_ERROR_INSERT_SIM_CARD);
 584                 evas_object_show(ugd->popup);
 585                 return;
 586         }
 587
 588         Evas_Object *genlist = __cst_create_genlist_call_type(ugd);
 589         navi_it = elm_naviframe_item_push(ugd->nf, T_(CST_STR_CALL_BARRING),
 590                 back_btn, NULL, genlist, NULL);
 591         back_btn = elm_object_item_part_content_get(navi_it, "prev_btn");
 592         evas_object_smart_callback_add(back_btn, "clicked",
 593                 __cst_on_click_cb_back_button, ugd);
 594 }