src/lib/elm_segment_control.c

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