src/lib/elm_segment_control.c

   1 #include <Elementary.h>
   2 #include "elm_priv.h"
   3
   4 /**
   5  * @defgroup SegmentControl SegmentControl
   6  * @ingroup Elementary
   7  *
   8  * SegmentControl Widget is a horizontal control made of multiple segment items,
   9  * each segment item functioning similar to discrete two state button. A segment
  10  * control groups the the items together and provides compact single button with
  11  * multiple equal size segments. Segment item size is determined by base widget
  12  * size and the number of items added.
  13  * Only one Segment item can be at selected state. A segment item can display
  14  * combination of Text and any Evas_Object like Images or other widget.
  15  *
  16  * Signals that you can add callbacks for are:
  17  *
  18  * "changed" -when the user clicks on a segment item which is not previously
  19  *            selected and get selected. The event_info parameter is the
  20  *            segment item index.
  21  */
  22 typedef struct _Widget_Data Widget_Data;
  23
  24 struct _Widget_Data
  25 {
  26    Evas_Object *obj;
  27    Evas_Object *base;
  28    Eina_List *seg_items;
  29    int item_count;
  30    Elm_Segment_Item *selected_item;
  31    int item_width;
  32 };
  33
  34 struct _Elm_Segment_Item
  35 {
  36    Elm_Widget_Item base;
  37    Evas_Object *icon;
  38    const char *label;
  39    int seg_index;
  40 };
  41
  42 static const char *widtype = NULL;
  43 static void _sizing_eval(Evas_Object *obj);
  44 static void _del_hook(Evas_Object *obj);
  45 static void _theme_hook(Evas_Object *obj);
  46 static void _disable_hook(Evas_Object *obj);
  47 static void _item_free(Elm_Segment_Item *it);
  48 static void _segment_off(Elm_Segment_Item *it);
  49 static void _segment_on(Elm_Segment_Item *it);
  50 static void _position_items(Widget_Data *wd);
  51 static void _on_move_resize(void *data, Evas *e __UNUSED__, Evas_Object *obj
  52                             __UNUSED__, void *event_info __UNUSED__);
  53 static void _mouse_up(void *data, Evas *e __UNUSED__, Evas_Object *obj
  54                       __UNUSED__, void *event_info __UNUSED__);
  55 static void _mouse_down(void *data, Evas *e __UNUSED__, Evas_Object *obj
  56                         __UNUSED__, void *event_info __UNUSED__);
  57 static void _swallow_item_objects(Elm_Segment_Item *it);
  58 static void _update_list(Widget_Data *wd);
  59 static Elm_Segment_Item * _item_find(const Evas_Object *obj, int index);
  60 static Elm_Segment_Item* _item_new(Evas_Object *obj, Evas_Object *icon,
  61                                    const char *label);
  62
  63 static const char SIG_CHANGED[] = "changed";
  64
  65 static const Evas_Smart_Cb_Description _signals[] = {
  66    {SIG_CHANGED, ""},
  67    {NULL, NULL}
  68 };
  69
  70 static void
  71 _sizing_eval(Evas_Object *obj)
  72 {
  73    Widget_Data *wd;
  74    Evas_Coord minw = -1, minh = -1;
  75    Evas_Coord w, h;
  76
  77    wd = elm_widget_data_get(obj);
  78    if (!wd) return;
  79
  80    elm_coords_finger_size_adjust(wd->item_count, &minw, 1, &minh);
  81    edje_object_size_min_restricted_calc(wd->base, &minw, &minh, minw, minh);
  82    elm_coords_finger_size_adjust(wd->item_count, &minw, 1, &minh);
  83
  84    evas_object_size_hint_min_get(obj, &w, &h);
  85    if (w > minw) minw = w;
  86    if (h > minh) minh = h;
  87    evas_object_size_hint_min_set(obj, minw, minh);
  88 }
  89
  90 static void
  91 _del_hook(Evas_Object *obj)
  92 {
  93    Elm_Segment_Item *it;
  94    Widget_Data *wd;
  95
  96    wd = elm_widget_data_get(obj);
  97    if (!wd) return;
  98
  99    EINA_LIST_FREE(wd->seg_items, it) _item_free(it);
 100
 101    free(wd);
 102 }
 103
 104 static void
 105 _theme_hook(Evas_Object *obj)
 106 {
 107    Eina_List *l;
 108    Eina_Bool rtl;
 109    Elm_Segment_Item *it;
 110    Widget_Data *wd;
 111
 112    wd = elm_widget_data_get(obj);
 113    if (!wd) return;
 114
 115    _elm_widget_mirrored_reload(obj);
 116    rtl = elm_widget_mirrored_get(obj);
 117    edje_object_mirrored_set(wd->base, rtl);
 118
 119    _elm_theme_object_set(obj, wd->base, "segment_control", "base",
 120                          elm_widget_style_get(obj));
 121    edje_object_scale_set(wd->base, elm_widget_scale_get(wd->base)
 122                          *_elm_config->scale);
 123
 124    EINA_LIST_FOREACH(wd->seg_items, l, it)
 125      {
 126         _elm_theme_object_set(obj, it->base.view, "segment_control",
 127                               "item", elm_widget_style_get(obj));
 128         edje_object_scale_set(it->base.view, elm_widget_scale_get(it->base.view)
 129                               *_elm_config->scale);
 130         edje_object_mirrored_set(it->base.view, rtl);
 131      }
 132
 133    _update_list(wd);
 134 }
 135
 136 static void
 137 _disable_hook(Evas_Object *obj)
 138 {
 139    Widget_Data *wd;
 140
 141    wd = elm_widget_data_get(obj);
 142    if (!wd) return;
 143    _update_list(wd);
 144 }
 145
 146 // TODO:  Elm_widget elm_widget_focus_list_next_get  supports only Elm_widget list,
 147 // Not the Elm_Widget_item. Focus switching with in widget not supported until
 148 // it is supported in elm_widget
 149 #if 0
 150 static void *
 151 _elm_list_data_get(const Eina_List *list)
 152 {
 153    Elm_Segment_Item *it = eina_list_data_get(list);
 154
 155    if (it) return NULL;
 156
 157    edje_object_signal_emit(it->base.view, "elm,state,segment,selected", "elm");
 158    return it->base.view;
 159 }
 160
 161 static Eina_Bool
 162 _focus_next_hook(const Evas_Object *obj, Elm_Focus_Direction dir,
 163                  Evas_Object **next)
 164 {
 165    static int count=0;
 166    Widget_Data *;
 167    const Eina_List *items;
 168    void *(*list_data_get) (const Eina_List *list);
 169
 170    wd = elm_widget_data_get(obj);
 171    if ((!wd)) return EINA_FALSE;
 172
 173    /* Focus chain */
 174    /* TODO: Change this to use other chain */
 175    if ((items = elm_widget_focus_custom_chain_get(obj)))
 176      list_data_get = eina_list_data_get;
 177    else
 178      {
 179         items = wd->seg_items;
 180         list_data_get = _elm_list_data_get;
 181         if (!items) return EINA_FALSE;
 182      }
 183    return elm_widget_focus_list_next_get(obj, items, list_data_get, dir, next);
 184 }
 185 #endif
 186
 187 static void
 188 _item_free(Elm_Segment_Item *it)
 189 {
 190    Widget_Data *wd;
 191
 192    if (!it) return;
 193
 194    wd = elm_widget_item_data_get(it);
 195    if (!wd) return;
 196
 197    if (wd->selected_item == it) wd->selected_item = NULL;
 198    if (wd->seg_items) wd->seg_items = eina_list_remove(wd->seg_items, it);
 199
 200    elm_widget_item_pre_notify_del(it);
 201
 202    if (it->icon) evas_object_del(it->icon);
 203    if (it->label) eina_stringshare_del(it->label);
 204
 205    elm_widget_item_del(it);
 206 }
 207
 208 static void
 209 _segment_off(Elm_Segment_Item *it)
 210 {
 211    Widget_Data *wd;
 212
 213    if (!it) return;
 214
 215    wd = elm_widget_item_data_get(it);
 216    if (!wd) return;
 217
 218    edje_object_signal_emit(it->base.view, "elm,state,segment,normal", "elm");
 219
 220    if (wd->selected_item == it) wd->selected_item = NULL;
 221 }
 222
 223 static void
 224 _segment_on(Elm_Segment_Item *it)
 225 {
 226    Widget_Data *wd;
 227
 228    if (!it) return;
 229
 230    wd = elm_widget_item_data_get(it);
 231    if (!wd) return;
 232    if (it == wd->selected_item) return;
 233
 234    if (wd->selected_item) _segment_off(wd->selected_item);
 235
 236    edje_object_signal_emit(it->base.view, "elm,state,segment,selected", "elm");
 237
 238    wd->selected_item = it;
 239    evas_object_smart_callback_call(wd->obj, SIG_CHANGED,
 240                                    (void *)(unsigned long)it->seg_index);
 241 }
 242
 243 static void
 244 _position_items(Widget_Data *wd)
 245 {
 246    Eina_List *l;
 247    Elm_Segment_Item *it;
 248    Eina_Bool rtl;
 249    int bx, by, bw, bh, pos;
 250
 251    wd->item_count = eina_list_count(wd->seg_items);
 252    if (wd->item_count <= 0) return;
 253
 254    evas_object_geometry_get(wd->base, &bx, &by, &bw, &bh);
 255    wd->item_width = bw / wd->item_count;
 256    rtl = elm_widget_mirrored_get(wd->obj);
 257
 258    if (rtl)
 259      pos = bx + bw - wd->item_width;
 260    else
 261      pos = bx;
 262
 263    EINA_LIST_FOREACH(wd->seg_items, l, it)
 264      {
 265         evas_object_move(it->base.view, pos, by);
 266         evas_object_resize(it->base.view, wd->item_width, bh);
 267         if (rtl)
 268           pos -= wd->item_width;
 269         else
 270           pos += wd->item_width;
 271      }
 272    _sizing_eval(wd->obj);
 273 }
 274
 275 static void
 276 _on_move_resize(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__,
 277                 void *event_info __UNUSED__)
 278 {
 279    Widget_Data *wd;
 280
 281    wd = elm_widget_data_get(data);
 282    if (!wd) return;
 283
 284    _position_items(wd);
 285
 286 }
 287
 288 static void
 289 _mouse_up(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__,
 290           void *event_info)
 291 {
 292    Widget_Data *wd;
 293    Elm_Segment_Item *it;
 294    Evas_Event_Mouse_Up *ev;
 295    Evas_Coord x, y, w, h;
 296
 297    it = data;
 298    if (!it) return;
 299
 300    wd = elm_widget_item_data_get(it);
 301    if (!wd) return;
 302
 303    if (elm_widget_disabled_get(wd->obj)) return;
 304
 305    if (it == wd->selected_item) return;
 306
 307    ev = event_info;
 308    evas_object_geometry_get(it->base.view, &x, &y, &w, &h);
 309
 310    if ((ev->canvas.x >= x) && (ev->output.x <= (x + w)) && (ev->canvas.y >= y)
 311        && (ev->canvas.y <= (y + h)))
 312      _segment_on(it);
 313    else
 314      edje_object_signal_emit(it->base.view, "elm,state,segment,normal", "elm");
 315 }
 316
 317 static void
 318 _mouse_down(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__,
 319             void *event_info __UNUSED__)
 320 {
 321    Widget_Data *wd;
 322    Elm_Segment_Item *it;
 323
 324    it = data;
 325    if (!it) return;
 326
 327    wd = elm_widget_item_data_get(it);
 328    if (!wd) return;
 329
 330    if (elm_widget_disabled_get(wd->obj)) return;
 331
 332    if (it == wd->selected_item) return;
 333
 334    edje_object_signal_emit(it->base.view, "elm,state,segment,pressed", "elm");
 335 }
 336
 337 static void
 338 _swallow_item_objects(Elm_Segment_Item *it)
 339 {
 340    if (!it) return;
 341
 342    if (it->icon)
 343      {
 344         edje_object_part_swallow(it->base.view, "elm.swallow.icon", it->icon);
 345         edje_object_signal_emit(it->base.view, "elm,state,icon,visible", "elm");
 346      }
 347    else
 348      edje_object_signal_emit(it->base.view, "elm,state,icon,hidden", "elm");
 349
 350    if (it->label)
 351      {
 352         edje_object_part_text_set(it->base.view, "elm.text", it->label);
 353         edje_object_signal_emit(it->base.view, "elm,state,text,visible", "elm");
 354      }
 355    else
 356      edje_object_signal_emit(it->base.view, "elm,state,text,hidden", "elm");
 357    edje_object_message_signal_process(it->base.view);
 358 }
 359
 360 static void
 361 _update_list(Widget_Data *wd)
 362 {
 363    Eina_List *l;
 364    Elm_Segment_Item *it;
 365    Eina_Bool rtl;
 366    int idx = 0;
 367
 368    _position_items(wd);
 369
 370    if (wd->item_count == 1)
 371      {
 372         it = eina_list_nth(wd->seg_items, 0);
 373         it->seg_index = 0;
 374
 375         //Set the segment type
 376         edje_object_signal_emit(it->base.view,
 377                                 "elm,type,segment,single", "elm");
 378
 379         //Set the segment state
 380         if (wd->selected_item == it)
 381           edje_object_signal_emit(it->base.view,
 382                                   "elm,state,segment,selected", "elm");
 383         else
 384           edje_object_signal_emit(it->base.view,
 385                                   "elm,state,segment,normal", "elm");
 386
 387         if (elm_widget_disabled_get(wd->obj))
 388           edje_object_signal_emit(it->base.view, "elm,state,disabled", "elm");
 389         else
 390           edje_object_signal_emit(it->base.view, "elm,state,enabled", "elm");
 391
 392         _swallow_item_objects(it);
 393         return;
 394      }
 395
 396    rtl = elm_widget_mirrored_get(wd->obj);
 397    EINA_LIST_FOREACH(wd->seg_items, l, it)
 398      {
 399         it->seg_index = idx;
 400
 401         //Set the segment type
 402         if (idx == 0)
 403           {
 404              if (rtl)
 405                edje_object_signal_emit(it->base.view,
 406                                        "elm,type,segment,right", "elm");
 407              else
 408                edje_object_signal_emit(it->base.view,
 409                                        "elm,type,segment,left", "elm");
 410           }
 411         else if (idx == (wd->item_count - 1))
 412           {
 413              if (rtl)
 414                edje_object_signal_emit(it->base.view,
 415                                        "elm,type,segment,left", "elm");
 416              else
 417                edje_object_signal_emit(it->base.view,
 418                                        "elm,type,segment,right", "elm");
 419           }
 420         else
 421           edje_object_signal_emit(it->base.view,
 422                                   "elm,type,segment,middle", "elm");
 423
 424         //Set the segment state
 425         if (wd->selected_item == it)
 426           edje_object_signal_emit(it->base.view,
 427                                   "elm,state,segment,selected", "elm");
 428         else
 429           edje_object_signal_emit(it->base.view,
 430                                   "elm,state,segment,normal", "elm");
 431
 432         if (elm_widget_disabled_get(wd->obj))
 433           edje_object_signal_emit(it->base.view, "elm,state,disabled", "elm");
 434         else
 435           edje_object_signal_emit(it->base.view, "elm,state,enabled", "elm");
 436
 437         _swallow_item_objects(it);
 438         idx++;
 439      }
 440 }
 441
 442 static Elm_Segment_Item *
 443 _item_find(const Evas_Object *obj, int idx)
 444 {
 445    Widget_Data *wd;
 446    Elm_Segment_Item *it;
 447
 448    wd = elm_widget_data_get(obj);
 449    if (!wd) return NULL;
 450
 451    it = eina_list_nth(wd->seg_items, idx);
 452    return it;
 453 }
 454
 455 static Elm_Segment_Item*
 456 _item_new(Evas_Object *obj, Evas_Object *icon, const char *label)
 457 {
 458    Elm_Segment_Item *it;
 459    Widget_Data *wd;
 460
 461    wd = elm_widget_data_get(obj);
 462    if (!wd) return NULL;
 463
 464    it = elm_widget_item_new(obj, Elm_Segment_Item);
 465    if (!it) return NULL;
 466    elm_widget_item_data_set(it, wd);
 467
 468    it->base.view = edje_object_add(evas_object_evas_get(obj));
 469    edje_object_scale_set(it->base.view, elm_widget_scale_get(it->base.view)
 470                          *_elm_config->scale);
 471    evas_object_smart_member_add(it->base.view, obj);
 472    elm_widget_sub_object_add(obj, it->base.view);
 473    evas_object_clip_set(it->base.view, evas_object_clip_get(obj));
 474
 475    _elm_theme_object_set(obj, it->base.view, "segment_control", "item",
 476                          elm_object_style_get(obj));
 477    edje_object_mirrored_set(it->base.view,
 478                             elm_widget_mirrored_get(it->base.widget));
 479
 480    if (label)
 481      eina_stringshare_replace(&it->label, label);
 482    if (it->label)
 483      edje_object_signal_emit(it->base.view, "elm,state,text,visible", "elm");
 484    else
 485      edje_object_signal_emit(it->base.view, "elm,state,text,hidden", "elm");
 486    edje_object_message_signal_process(it->base.view);
 487    edje_object_part_text_set(it->base.view, "elm.text", label);
 488
 489    it->icon = icon;
 490    if (it->icon) elm_widget_sub_object_add(it->base.view, it->icon);
 491    evas_object_event_callback_add(it->base.view, EVAS_CALLBACK_MOUSE_DOWN,
 492                                   _mouse_down, it);
 493    evas_object_event_callback_add(it->base.view, EVAS_CALLBACK_MOUSE_UP,
 494                                   _mouse_up, it);
 495    evas_object_show(it->base.view);
 496
 497    return it;
 498 }
 499
 500 /**
 501  * Create new SegmentControl.
 502  * @param [in] parent The parent object
 503  * @return The new object or NULL if it cannot be created
 504  *
 505  * @ingroup SegmentControl
 506  */
 507 EAPI Evas_Object *
 508 elm_segment_control_add(Evas_Object *parent)
 509 {
 510    Evas_Object *obj;
 511    Evas *e;
 512    Widget_Data *wd;
 513
 514    ELM_WIDGET_STANDARD_SETUP(wd, Widget_Data, parent, e, obj, NULL);
 515
 516    ELM_SET_WIDTYPE(widtype, "segment_control");
 517    elm_widget_type_set(obj, "segment_control");
 518    elm_widget_sub_object_add(parent, obj);
 519    elm_widget_data_set(obj, wd);
 520    elm_widget_del_hook_set(obj, _del_hook);
 521    elm_widget_theme_hook_set(obj, _theme_hook);
 522    elm_widget_disable_hook_set(obj, _disable_hook);
 523
 524    // TODO: Focus switch support to Elm_widget_Item not supported yet.
 525 #if 0
 526    elm_widget_focus_next_hook_set(obj, _focus_next_hook);
 527 #endif
 528
 529    wd->obj = obj;
 530
 531    wd->base = edje_object_add(e);
 532    edje_object_scale_set(wd->base, elm_widget_scale_get(wd->base)
 533                          *_elm_config->scale);
 534    _elm_theme_object_set(obj, wd->base, "segment_control", "base", "default");
 535    elm_widget_resize_object_set(obj, wd->base);
 536
 537    evas_object_event_callback_add(obj, EVAS_CALLBACK_RESIZE,
 538                                   _on_move_resize, obj);
 539    evas_object_event_callback_add(obj, EVAS_CALLBACK_MOVE,
 540                                   _on_move_resize, obj);
 541
 542    evas_object_smart_callbacks_descriptions_set(obj, _signals);
 543
 544    return obj;
 545 }
 546
 547 /**
 548  * Add new segment item to SegmentControl.
 549  * @param [in] obj The SegmentControl object
 550  * @param [in] icon Any Objects like icon, Label, layout etc
 551  * @param [in] label The label for added segment item.
 552  *             Note that, NULL is different from empty string "".
 553  * @return The new segment item or NULL if it cannot be created
 554  *
 555  * @ingroup SegmentControl
 556  */
 557 EAPI Elm_Segment_Item *
 558 elm_segment_control_item_add(Evas_Object *obj, Evas_Object *icon,
 559                              const char *label)
 560 {
 561    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 562    Elm_Segment_Item *it;
 563    Widget_Data *wd;
 564
 565    wd = elm_widget_data_get(obj);
 566    if (!wd) return NULL;
 567
 568    it = _item_new(obj, icon, label);
 569    if (!it) return NULL;
 570
 571    wd->seg_items = eina_list_append(wd->seg_items, it);
 572    _update_list(wd);
 573
 574    return it;
 575 }
 576
 577 /**
 578  * Insert a new segment item to SegmentControl.
 579  * @param [in] obj The SegmentControl object
 580  * @param [in] icon Any Objects like icon, Label, layout etc
 581  * @param [in] label The label for added segment item.
 582  *        Note that, NULL is different from empty string "".
 583  * @param [in] index Segment item location. Value should be between 0 and
 584  *        Existing total item count( @see elm_segment_control_item_count_get() )
 585  * @return The new segment item or NULL if it cannot be created
 586  *
 587  * @ingroup SegmentControl
 588  */
 589 EAPI Elm_Segment_Item *
 590 elm_segment_control_item_insert_at(Evas_Object *obj, Evas_Object *icon,
 591                                    const char *label, int idx)
 592 {
 593    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 594    Elm_Segment_Item *it, *it_rel;
 595    Widget_Data *wd;
 596
 597    wd = elm_widget_data_get(obj);
 598    if (!wd) return NULL;
 599    if (idx < 0) idx = 0;
 600
 601    it = _item_new(obj, icon, label);
 602    if (!it) return NULL;
 603
 604    it_rel = _item_find(obj, idx);
 605
 606    if (it_rel)
 607      wd->seg_items = eina_list_prepend_relative(wd->seg_items, it, it_rel);
 608    else
 609      wd->seg_items = eina_list_append(wd->seg_items, it);
 610
 611    _update_list(wd);
 612    return it;
 613 }
 614
 615 /**
 616  * Delete a segment item from SegmentControl
 617  * @param [in] obj The SegmentControl object
 618  * @param [in] it The segment item to be deleted
 619  *
 620  * @ingroup SegmentControl
 621  */
 622 EAPI void
 623 elm_segment_control_item_del(Elm_Segment_Item *it)
 624 {
 625    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
 626    Widget_Data *wd;
 627
 628    wd = elm_widget_item_data_get(it);
 629    if (!wd) return;
 630
 631    _item_free(it);
 632    _update_list(wd);
 633 }
 634
 635 /**
 636  * Delete a segment item of given index from SegmentControl
 637  * @param [in] obj The SegmentControl object
 638  * @param [in] index The position at which segment item to be deleted.
 639  *
 640  * @ingroup SegmentControl
 641  */
 642 EAPI void
 643 elm_segment_control_item_del_at(Evas_Object *obj, int idx)
 644 {
 645    ELM_CHECK_WIDTYPE(obj, widtype);
 646    Elm_Segment_Item *it;
 647    Widget_Data *wd;
 648
 649    wd = elm_widget_data_get(obj);
 650    if (!wd) return;
 651
 652    it = _item_find(obj, idx);
 653
 654    if (!it) return;
 655    _item_free(it);
 656    _update_list(wd);
 657 }
 658
 659 /**
 660  * Get the label of a segment item.
 661  * @param [in] obj The SegmentControl object
 662  * @param [in] index The index of the segment item
 663  * @return The label of the segment item
 664  *
 665  * @ingroup SegmentControl
 666  */
 667 EAPI const char*
 668 elm_segment_control_item_label_get(const Evas_Object *obj, int idx)
 669 {
 670    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 671    Elm_Segment_Item *it;
 672
 673    it = _item_find(obj, idx);
 674
 675    if (it) return it->label;
 676
 677    return NULL;
 678 }
 679
 680 /**
 681  * Set the label of a segment item.
 682  * @param [in] it The SegmentControl Item
 683  * @param [in] label New label text.
 684  *
 685  * @ingroup SegmentControl
 686  */
 687 EAPI void
 688 elm_segment_control_item_label_set(Elm_Segment_Item* it, const char* label)
 689 {
 690    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
 691    Widget_Data *wd;
 692
 693    wd = elm_widget_item_data_get(it);
 694    if (!wd) return;
 695
 696    eina_stringshare_replace(&it->label, label);
 697    if (it->label)
 698      edje_object_signal_emit(it->base.view, "elm,state,text,visible", "elm");
 699    else
 700      edje_object_signal_emit(it->base.view, "elm,state,text,hidden", "elm");
 701    edje_object_message_signal_process(it->base.view);
 702    //label can be NULL also.
 703    edje_object_part_text_set(it->base.view, "elm.text", it->label);
 704 }
 705
 706 /**
 707  * Get the icon of a segment item of SegmentControl
 708  * @param [in] obj The SegmentControl object
 709  * @param [in] index The index of the segment item
 710  * @return The icon object.
 711  *
 712  * @ingroup SegmentControl
 713  */
 714 EAPI Evas_Object *
 715 elm_segment_control_item_icon_get(const Evas_Object *obj, int idx)
 716 {
 717    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 718    Elm_Segment_Item *it;
 719
 720    it = _item_find(obj, idx);
 721
 722    if (it) return it->icon;
 723
 724    return NULL;
 725 }
 726
 727 /**
 728  * Set the Icon to the segment item
 729  * @param [in] it The SegmentControl Item
 730  * @param [in] icon Objects like Layout, Icon, Label etc...
 731  *
 732  * @ingroup SegmentControl
 733  */
 734 EAPI void
 735 elm_segment_control_item_icon_set(Elm_Segment_Item *it, Evas_Object *icon)
 736 {
 737    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
 738
 739    //Remove the existing icon
 740    if (it->icon)
 741      {
 742         edje_object_part_unswallow(it->base.view, it->icon);
 743         evas_object_del(it->icon);
 744         it->icon = NULL;
 745      }
 746
 747    it->icon = icon;
 748    if (it->icon)
 749      {
 750         elm_widget_sub_object_add(it->base.view, it->icon);
 751         edje_object_part_swallow(it->base.view, "elm.swallow.icon", it->icon);
 752         edje_object_signal_emit(it->base.view, "elm,state,icon,visible", "elm");
 753      }
 754    else
 755      edje_object_signal_emit(it->base.view, "elm,state,icon,hidden", "elm");
 756 }
 757
 758 /**
 759  * Get the Segment items count from SegmentControl
 760  * @param [in] obj The SegmentControl object
 761  * @return Segment items count.
 762  *
 763  * @ingroup SegmentControl
 764  */
 765 EAPI int
 766 elm_segment_control_item_count_get(const Evas_Object *obj)
 767 {
 768    ELM_CHECK_WIDTYPE(obj, widtype) 0;
 769    Widget_Data *wd;
 770
 771    wd = elm_widget_data_get(obj);
 772    if (!wd) return 0;
 773
 774    return eina_list_count(wd->seg_items);
 775 }
 776
 777 /**
 778  * Get the base object of segment item.
 779  * @param [in] it The Segment item
 780  * @return obj The base object of the segment item.
 781  *
 782  * @ingroup SegmentControl
 783  */
 784 EAPI Evas_Object*
 785 elm_segment_control_item_object_get(const Elm_Segment_Item *it)
 786 {
 787    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, NULL);
 788
 789    return it->base.view;
 790 }
 791
 792 /**
 793  * Get the selected segment item in the SegmentControl
 794  * @param [in] obj The SegmentControl object
 795  * @return Selected Segment Item. NULL if none of segment item is selected.
 796  *
 797  * @ingroup SegmentControl
 798  */
 799 EAPI Elm_Segment_Item*
 800 elm_segment_control_item_selected_get(const Evas_Object *obj)
 801 {
 802    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 803    Widget_Data *wd;
 804
 805    wd = elm_widget_data_get(obj);
 806    if (!wd) return NULL;
 807
 808    return wd->selected_item;
 809 }
 810
 811 /**
 812  * Select/unselect a particular segment item of SegmentControl
 813  * @param [in] it The Segment item that is to be selected or unselected.
 814  * @param [in] select Passing EINA_TRUE will select the segment item and
 815  *             EINA_FALSE will unselect.
 816  *
 817  * @ingroup SegmentControl
 818  */
 819 EAPI void
 820 elm_segment_control_item_selected_set(Elm_Segment_Item *it, Eina_Bool selected)
 821 {
 822    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
 823    Widget_Data *wd;
 824
 825    wd = elm_widget_item_data_get(it);
 826    if (!wd) return;
 827
 828    if (it == wd->selected_item)
 829      {
 830         //already in selected state.
 831         if (selected) return;
 832
 833         //unselect case
 834         _segment_off(it);
 835      }
 836    else if (selected)
 837      _segment_on(it);
 838
 839    return;
 840 }
 841
 842 /**
 843  * Get the Segment Item from the specified Index.
 844  * @param [in] obj The Segment Control object.
 845  * @param [in] index The index of the segment item.
 846  * @return The Segment item.
 847  *
 848  * @ingroup SegmentControl
 849  */
 850 EAPI Elm_Segment_Item *
 851 elm_segment_control_item_get(const Evas_Object *obj, int idx)
 852 {
 853    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 854    Elm_Segment_Item *it;
 855
 856    it = _item_find(obj, idx);
 857
 858    return it;
 859 }
 860
 861 /**
 862  * Get the index of a Segment item in the SegmentControl
 863  * @param [in] it The Segment Item.
 864  * @return Segment Item index.
 865  *
 866  * @ingroup SegmentControl
 867  */
 868 EAPI int
 869 elm_segment_control_item_index_get(const Elm_Segment_Item *it)
 870 {
 871    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, -1);
 872
 873    return it->seg_index;
 874 }