src/cst-widget.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 <stdio.h>
  18 #include <appcore-efl.h>
  19 #include <Elementary.h>
  20 #include <Evas.h>
  21
  22 #include "cst-common.h"
  23 #include "cst-widget.h"
  24 #include "cst-common-string.h"
  25 #include "cst-debug.h"
  26
  27 static Elm_Genlist_Item_Class *itc_seperator = NULL;
  28 static Elm_Genlist_Item_Class *itc_underline = NULL;
  29
  30 /* This callback is for showing(hiding) X marked button. */
  31 static void _changed_cb(void *data, Evas_Object *obj, void *event_info)
  32 {
  33         if (elm_object_focus_get(data)) {
  34                 if (elm_entry_is_empty(obj))
  35                         elm_object_signal_emit(data, "elm,state,eraser,hide", "elm");
  36                 else
  37                         elm_object_signal_emit(data, "elm,state,eraser,show", "elm");
  38         }
  39 }
  40
  41 /* Focused callback will show X marked button and hide guidetext. */
  42 static void _focused_cb(void *data, Evas_Object *obj, void *event_info)
  43 {
  44         if (!elm_entry_is_empty(obj))
  45                 elm_object_signal_emit(data, "elm,state,eraser,show", "elm");
  46         elm_object_signal_emit(data, "elm,state,guidetext,hide", "elm");
  47 }
  48
  49 /* Unfocused callback will show guidetext and hide X marked button. */
  50 static void _unfocused_cb(void *data, Evas_Object *obj, void *event_info)
  51 {
  52         if (elm_entry_is_empty(obj))
  53                 elm_object_signal_emit(data, "elm,state,guidetext,show", "elm");
  54         elm_object_signal_emit(data, "elm,state,eraser,hide", "elm");
  55 }
  56
  57 /* When X marked button clicked, make string as empty. */
  58 static void _eraser_clicked_cb(void *data, Evas_Object *obj, const char *emission, const char *source)
  59 {
  60         elm_entry_entry_set(data, "");
  61 }
  62
  63 Evas_Object *_cst_create_progressbar(Evas_Object *parent)
  64 {
  65         ENTER(_cst_create_progressbar);
  66         retv_if(NULL == parent, NULL);
  67         Evas_Object *progressbar;
  68         progressbar = elm_progressbar_add(parent);
  69         elm_object_style_set(progressbar, "list_process");
  70         evas_object_size_hint_align_set(progressbar, EVAS_HINT_FILL, 0.5);
  71         evas_object_size_hint_weight_set(progressbar, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
  72         evas_object_show(progressbar);
  73         elm_progressbar_pulse(progressbar, EINA_TRUE);
  74
  75         return progressbar;
  76 }
  77
  78 static void __cst_get_error_string(int error, char *msg)
  79 {
  80         switch (error) {
  81         case CST_ERROR_INCORRECT_OPERATION:
  82                 snprintf(msg, 100, "%s", T_(CST_STR_INCORRECT_OPERATION));
  83                 break;
  84         case CST_ERROR_INVALID_PASSWORD:
  85                 snprintf(msg, 100, "%s", T_(CST_STR_INVALID_PASSWORD));
  86                 break;
  87         case CST_ERROR_PASSWORD_BLOCKED:
  88                 snprintf(msg, 100, "%s", T_(CST_STR_PASSWORD_BLOCKED));
  89                 break;
  90         case CST_ERROR_SERVICE_UNAVAILABLE:
  91                 snprintf(msg, 100, "%s", T_(CST_STR_SERVICE_UNAVAILABLE));
  92                 break;
  93         case CST_ERROR_UNKNOWN:
  94                 snprintf(msg, 100, "%s", T_(CST_STR_REJECTED_BY_NETWORK));
  95                 break;
  96         case CST_ERROR_ENTER_NUMBER:
  97                 snprintf(msg, 100, "%s", T_(CST_STR_ENTER_NUMBER));
  98                 break;
  99         case CST_ERROR_ENTER_MESSAGE:
 100                 snprintf(msg, 100, "%s", T_(CST_STR_ENTER_MESSAGE));
 101                 break;
 102         case CST_ERROR_SELECT_VALID_ENTRY:
 103                 snprintf(msg, 100, "%s", T_(CST_STR_SELECT_VALID_ENTRY));
 104                 break;
 105         case CST_ERROR_REJECTED_BY_NETWORK:
 106                 snprintf(msg, 100, "%s", T_(CST_STR_REJECTED_BY_NETWORK));
 107                 break;
 108         case CST_ERROR_DUPLICATE_MESSAGE:
 109                 snprintf(msg, 100, "%s", T_(CST_STR_ENTER_DUPLICATE_MESSAGE));
 110                 break;
 111         case CST_ERROR_INSERT_SIM_CARD:
 112                 snprintf(msg, 100, "%s", T_(CST_STR_INSERT_SIM_CARD));
 113                 break;
 114         case CST_ERROR_CHANGE_FLIGHT_MODE:
 115                 snprintf(msg, 100, "%s", T_(CST_STR_CHNAGE_FLIGHT_MODE_MESSAGE));
 116                 break;
 117         case CST_ERROR_AUL_LAUNCH_ERROR:
 118                 snprintf(msg, 100, "%s", T_(CST_STR_APP_NOT_INSTALLED));
 119                 break;
 120         default:
 121                 snprintf(msg, 100, "%s", T_(CST_STR_UNKNOWN_OPERATION));
 122                 break;
 123         }
 124 }
 125
 126 Evas_Object *_cst_create_error_popup(Evas_Object *parent, int error)
 127 {
 128         retv_if(error < 0, NULL);
 129
 130         char error_msg[100];
 131         __cst_get_error_string(error, error_msg);
 132         DBG("Error message=%s", error_msg);
 133
 134         Evas_Object *popup;
 135         popup = elm_popup_add(parent);
 136         elm_popup_timeout_set(popup, 1.5);
 137         elm_object_text_set(popup, error_msg);
 138         evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 139
 140         return popup;
 141 }
 142
 143 Evas_Object *_cst_get_navifr_prev_btn(Evas_Object *nf)
 144 {
 145         ENTER(_cst_get_navifr_prev_btn);
 146         Elm_Object_Item *top_it = elm_naviframe_top_item_get(nf);
 147         retv_if(top_it == NULL, NULL);
 148         Evas_Object *btn = elm_object_item_part_content_get(top_it, "prev_btn");
 149         retv_if(btn == NULL, NULL);
 150
 151         return btn;
 152 }
 153
 154 Evas_Object *_cst_create_navi_control_bar(Evas_Object *parent,
 155                         char *label1, const char *icon1, Evas_Smart_Cb cb1,
 156                         char *label2, const char *icon2, Evas_Smart_Cb cb2,
 157                         void *data, Elm_Object_Item *navi_it,
 158                         Elm_Object_Item ** c_item)
 159 {
 160         ENTER(_cst_create_navi_control_bar);
 161         retv_if(NULL == parent, NULL);
 162         Elm_Object_Item *item;
 163         Evas_Object *cbar = elm_toolbar_add(parent);
 164         elm_toolbar_shrink_mode_set(cbar, ELM_TOOLBAR_SHRINK_EXPAND);
 165
 166         retv_if(cbar == NULL, NULL);
 167         retv_if(label1 == NULL, NULL);
 168
 169         if (label2) {
 170                 Evas_Object *btn = elm_object_item_part_content_get(navi_it,
 171                         "prev_btn");
 172                 if (btn) {
 173                         Elm_Object_Item *temp_it = NULL;
 174                         temp_it = elm_toolbar_item_append(cbar, NULL, NULL, NULL, NULL);
 175                         elm_object_item_disabled_set(temp_it, EINA_TRUE);
 176                         if (label1) {
 177                                 c_item[0] = elm_toolbar_item_append(cbar,
 178                                         icon1, label1, cb1, data);
 179                         }
 180                         temp_it = elm_toolbar_item_append(cbar, NULL, NULL, NULL, NULL);
 181                         elm_object_item_disabled_set(temp_it, EINA_TRUE);
 182                 } else {
 183                         if (label1) {
 184                                 c_item[0] = elm_toolbar_item_append(cbar,
 185                                         icon1, label1, cb1, data);
 186                         }
 187                         item = elm_toolbar_item_append(cbar, NULL, NULL, NULL, NULL);
 188                         elm_object_item_part_content_set(item, "object", NULL);
 189                 }
 190                 c_item[1] = elm_toolbar_item_append(cbar,
 191                         icon2, label2, cb2, data);
 192         } else {
 193                 item = elm_toolbar_item_append(cbar, NULL, NULL, NULL, NULL);
 194                 elm_object_item_part_content_set(item, "object", NULL);
 195
 196                 c_item[0] = elm_toolbar_item_append(cbar,
 197                         icon1, label1, cb1, data);
 198         }
 199
 200         elm_object_item_part_content_set(navi_it, "controlbar", cbar);
 201         return cbar;
 202 }
 203
 204 static void __cst_gl_del_seperator(void *data, Evas_Object *obj)
 205 {
 206         ret_if(data == NULL);
 207         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 208         if (item_data)
 209                 free(item_data);
 210         return;
 211 }
 212
 213 void _cst_create_genlist_seperator(Evas_Object *genlist, Eina_Bool need_item_data)
 214 {
 215         Elm_Object_Item *item = NULL;
 216
 217         if (!itc_seperator)
 218                 itc_seperator = elm_genlist_item_class_new();
 219
 220         itc_seperator->item_style = "dialogue/separator/21/with_line";
 221         itc_seperator->func.text_get = NULL;
 222         itc_seperator->func.content_get = NULL;
 223         itc_seperator->func.state_get = NULL;
 224
 225         if (need_item_data) {
 226                 CstGlItemData_t *item_data;
 227                 itc_seperator->func.del = __cst_gl_del_seperator;
 228                 item_data = calloc(1, sizeof(CstGlItemData_t));
 229                 ret_if(NULL == item_data);
 230                 item_data->index = -1;
 231                 item = elm_genlist_item_append(genlist, itc_seperator, item_data, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 232                 item_data->gl_item = item;
 233         } else {
 234                 itc_seperator->func.del = NULL;
 235                 item = elm_genlist_item_append(genlist, itc_seperator, NULL, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 236         }
 237         elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 238 }
 239
 240 void _cst_create_genlist_underline(Evas_Object *genlist)
 241 {
 242         ret_if(NULL == genlist);
 243         Elm_Object_Item *item = NULL;
 244
 245         if (!itc_underline)
 246                 itc_underline = elm_genlist_item_class_new();
 247
 248         itc_underline->item_style = "dialogue/separator/1/with_line";
 249         itc_underline->func.text_get = NULL;
 250         itc_underline->func.content_get = NULL;
 251         itc_underline->func.state_get = NULL;
 252         itc_underline->func.del = NULL;
 253
 254         item = elm_genlist_item_append(genlist, itc_underline, NULL, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 255         elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 256 }
 257
 258 Elm_Object_Item *_cst_create_genlist_update_underline(Evas_Object *genlist)
 259 {
 260         retv_if(NULL == genlist, NULL);
 261         Elm_Object_Item *item = NULL;
 262
 263         if (!itc_underline)
 264                 itc_underline = elm_genlist_item_class_new();
 265
 266         itc_underline->item_style = "dialogue/separator/1/with_line";
 267         itc_underline->func.text_get = NULL;
 268         itc_underline->func.content_get = NULL;
 269         itc_underline->func.state_get = NULL;
 270         itc_underline->func.del = NULL;
 271
 272         item = elm_genlist_item_append(genlist, itc_underline, NULL, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 273         elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 274         return item;
 275 }
 276
 277 static void __cst_hide_selectinfo_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
 278 {
 279         ENTER(__cst_hide_selectinfo_cb);
 280         ret_if(data == NULL || obj == NULL);
 281
 282         CstUgData_t *ugd = (CstUgData_t *)data;
 283         ret_if(obj != ugd->selectinfo);
 284
 285         if (ugd->selectinfo && ugd->select_backup)
 286                 edje_object_signal_emit(_EDJ(ugd->select_backup),
 287                         DEFAULT_CONTENT_SIGNAL, BOTTOM_PADDING_CONTENT_SOURCE);
 288         ugd->select_backup = NULL;
 289         ugd->selectinfo = NULL;
 290 }
 291
 292 void _cst_create_selectinfo(CstUgData_t *ugd, Evas_Object *layout, const char *label)
 293 {
 294         ENTER(_cst_create_selectinfo);
 295         ret_if(ugd == NULL);
 296         if (!ugd->selectinfo) {
 297                 ugd->select_backup = layout;
 298                 ugd->selectinfo = elm_notify_add(ugd->select_backup);
 299                 elm_notify_orient_set(ugd->selectinfo, ELM_NOTIFY_ORIENT_BOTTOM);
 300
 301                 evas_object_event_callback_add(ugd->selectinfo,
 302                         EVAS_CALLBACK_HIDE, __cst_hide_selectinfo_cb, ugd);
 303
 304                 ugd->selectinfo_layout = elm_layout_add(ugd->select_backup);
 305
 306                 elm_layout_theme_set(ugd->selectinfo_layout,
 307                         "standard", "selectioninfo", "vertical/bottom_12");
 308
 309                 elm_object_content_set(ugd->selectinfo, ugd->selectinfo_layout);
 310         }
 311
 312         if (label == NULL) {
 313                 evas_object_hide(ugd->selectinfo);
 314                 return;
 315         }
 316
 317         DBG("Input label : %s", label);
 318         edje_object_part_text_set(_EDJ(ugd->selectinfo_layout), "elm.text", label);
 319         elm_notify_timeout_set(ugd->selectinfo, 2);
 320         evas_object_show(ugd->selectinfo);
 321 }
 322
 323 void _cst_del_selectinfo(CstUgData_t *ugd)
 324 {
 325         ret_if(ugd == NULL);
 326
 327         if (ugd->selectinfo_layout)
 328                 evas_object_del(ugd->selectinfo_layout);
 329         if (ugd->selectinfo)
 330                 evas_object_del(ugd->selectinfo);
 331
 332         ugd->selectinfo_layout = NULL;
 333         ugd->selectinfo = NULL;
 334 }
 335
 336 Evas_Object *_cst_create_onoff_button(Evas_Object *obj,
 337         int state_value, Evas_Smart_Cb cb_func, void *cb_data)
 338 {
 339         retv_if(NULL == obj, NULL);
 340
 341         Evas_Object *icon = elm_check_add(obj);
 342         elm_object_style_set(icon, "on&off");
 343         elm_check_state_set(icon, state_value);
 344         if (cb_func) {
 345                 evas_object_smart_callback_add(icon, "changed",
 346                         cb_func, cb_data);
 347         }
 348         evas_object_propagate_events_set(icon, EINA_FALSE);
 349
 350         return icon;
 351 }
 352
 353 Evas_Object *_cst_create_radio_icon(Evas_Object *obj,
 354         Evas_Object *rdg, int value, int offset, const char *vconf_key)
 355 {
 356         retv_if((NULL == obj) || (NULL == vconf_key), NULL);
 357
 358         int rd_value = 0;
 359         Evas_Object *radio = elm_radio_add(obj);
 360         elm_radio_state_value_set(radio,        value);
 361         elm_radio_group_add(radio, rdg);
 362         _cst_vconf_get_int(vconf_key, &rd_value);
 363         elm_radio_value_set(rdg, (rd_value + offset));
 364
 365         return radio;
 366 }
 367
 368 Evas_Object *_cst_create_title_btn(Evas_Object *parent,
 369                 const char *text, Evas_Smart_Cb func, void *data)
 370 {
 371         retv_if(NULL == parent, NULL);
 372
 373         Evas_Object *btn = elm_button_add(parent);
 374         if (!btn) return NULL;
 375         elm_object_style_set(btn, "naviframe/title/default");
 376         elm_object_text_set(btn, text);
 377         evas_object_smart_callback_add(btn, "clicked", func, data);
 378         return btn;
 379 }
 380
 381 static void __cst_trans_finished(void *data, Evas_Object *obj, void *event_info)
 382 {
 383         ret_if(NULL == obj);
 384         elm_naviframe_prev_btn_auto_pushed_set(obj, EINA_TRUE);
 385         evas_object_smart_callback_del(obj, "transition,finished", __cst_trans_finished);
 386 }
 387
 388 void _cst_remove_naviframe(Evas_Object *nf)
 389 {
 390         ret_if(NULL == nf);
 391         elm_naviframe_prev_btn_auto_pushed_set(nf, EINA_FALSE);
 392         evas_object_smart_callback_add(nf, "transition,finished",
 393                 __cst_trans_finished, NULL);
 394 }
 395
 396 static void __cst_changed_editfield_cb(void *data, Evas_Object *obj, void *event_info)
 397 {
 398         ret_if(NULL == data);
 399         CstUgData_t *ugd = (CstUgData_t *)data;
 400         const char *entry_str = elm_entry_entry_get(obj);
 401
 402         Elm_Object_Item *navi_it = elm_naviframe_top_item_get(ugd->nf);
 403         ret_if(!navi_it);
 404         Evas_Object *btn = elm_object_item_part_content_get(navi_it,
 405                 "title_right_btn");
 406
 407         if (btn != NULL) {
 408                 if (NULL == entry_str || '\0' == entry_str[0])
 409                         elm_object_disabled_set(btn, EINA_TRUE);
 410                 else
 411                         elm_object_disabled_set(btn, EINA_FALSE);
 412         }
 413 }
 414
 415 Evas_Object *_cst_create_ime_editfield(CstUgData_t *ugd,
 416         Evas_Object *parent, CstImeType_t ime_type, char *input_string)
 417 {
 418         retv_if((NULL == ugd || NULL == parent), NULL);
 419
 420         Ecore_IMF_Input_Panel_Layout panel_layout;
 421         Evas_Object *layout = elm_layout_add(parent);
 422         elm_layout_theme_set(layout, "layout", "editfield", "default");
 423         Elm_Entry_Filter_Limit_Size limit_filter_data;
 424         Elm_Entry_Filter_Accept_Set digits_filter_data;
 425
 426         ugd->dg_entry = elm_entry_add(parent);
 427         elm_object_part_content_set(layout, "elm.swallow.content", ugd->dg_entry);
 428
 429         evas_object_smart_callback_add(ugd->dg_entry, "changed", _changed_cb, layout);
 430         evas_object_smart_callback_add(ugd->dg_entry, "focused", _focused_cb, layout);
 431         evas_object_smart_callback_add(ugd->dg_entry, "unfocused", _unfocused_cb, layout);
 432         elm_object_signal_callback_add(layout, "elm,eraser,clicked", "elm", _eraser_clicked_cb, ugd->dg_entry);
 433
 434         if (input_string != NULL)
 435                 elm_entry_entry_set(ugd->dg_entry, input_string);
 436         elm_entry_cursor_end_set(ugd->dg_entry);
 437
 438         switch (ime_type) {
 439         case CST_IME_PREFIX_DIAL:
 440                 elm_entry_single_line_set(ugd->dg_entry, EINA_TRUE);
 441                 elm_entry_scrollable_set(ugd->dg_entry, EINA_TRUE);
 442                 elm_object_part_text_set(layout, "elm.text", T_(CST_STR_ENTER_NUMBER));
 443                 panel_layout = ECORE_IMF_INPUT_PANEL_LAYOUT_PHONENUMBER;
 444                 elm_entry_input_panel_layout_set(ugd->dg_entry, panel_layout);
 445                 limit_filter_data.max_char_count = 0;
 446                 limit_filter_data.max_byte_count = CST_MAX_PREFIX_NUMBER_LEN;
 447                 digits_filter_data.accepted = "0123456789+*#";
 448                 digits_filter_data.rejected = NULL;
 449                 elm_entry_markup_filter_append(ugd->dg_entry,
 450                         elm_entry_filter_accept_set, &digits_filter_data);
 451                 break;
 452         case CST_IME_CALL_FORWARD:
 453                 elm_entry_single_line_set(ugd->dg_entry, EINA_TRUE);
 454                 elm_entry_scrollable_set(ugd->dg_entry, EINA_TRUE);
 455                 elm_object_part_text_set(layout, "elm.text", T_(CST_STR_ENTER_NUMBER));
 456                 panel_layout = ECORE_IMF_INPUT_PANEL_LAYOUT_PHONENUMBER;
 457                 elm_entry_input_panel_layout_set(ugd->dg_entry, panel_layout);
 458                 limit_filter_data.max_char_count = 0;
 459                 limit_filter_data.max_byte_count = CST_MAX_PHONE_NUMBER_LEN;
 460                 digits_filter_data.accepted = "0123456789+*#";
 461                 digits_filter_data.rejected = NULL;
 462                 elm_entry_markup_filter_append(ugd->dg_entry,
 463                         elm_entry_filter_accept_set, &digits_filter_data);
 464                 break;
 465         case CST_IME_CALL_BAR:
 466                 elm_entry_single_line_set(ugd->dg_entry, EINA_TRUE);
 467                 elm_entry_scrollable_set(ugd->dg_entry, EINA_TRUE);
 468                 elm_object_part_text_set(layout, "elm.text", T_(CST_STR_ENTER_PASSWORD));
 469                 panel_layout = ECORE_IMF_INPUT_PANEL_LAYOUT_NUMBERONLY;
 470                 elm_entry_input_panel_layout_set(ugd->dg_entry, panel_layout);
 471                 elm_entry_password_set(ugd->dg_entry, EINA_TRUE);
 472                 limit_filter_data.max_char_count = 0;
 473                 limit_filter_data.max_byte_count = CST_MAX_PASSWORD_LEN;
 474                 break;
 475         default:
 476                 ERR("Invalid ime type.");
 477                 return NULL;
 478         }
 479
 480         elm_entry_markup_filter_append(ugd->dg_entry,
 481                 elm_entry_filter_limit_size, &limit_filter_data);
 482         evas_object_show(ugd->dg_entry);
 483         elm_object_focus_set(ugd->dg_entry, EINA_TRUE);
 484         evas_object_smart_callback_add(ugd->dg_entry, "changed",
 485                 __cst_changed_editfield_cb,
 486                 ugd);
 487
 488         return layout;
 489 }