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
 390         _swallow_item_objects(it);
 391         return;
 392      }
 393
 394    rtl = elm_widget_mirrored_get(wd->obj);
 395    EINA_LIST_FOREACH(wd->seg_items, l, it)
 396      {
 397         it->seg_index = idx;
 398
 399         //Set the segment type
 400         if (idx == 0)
 401           {
 402              if (rtl)
 403                edje_object_signal_emit(it->base.view,
 404                                        "elm,type,segment,right", "elm");
 405              else
 406                edje_object_signal_emit(it->base.view,
 407                                        "elm,type,segment,left", "elm");
 408           }
 409         else if (idx == (wd->item_count - 1))
 410           {
 411              if (rtl)
 412                edje_object_signal_emit(it->base.view,
 413                                        "elm,type,segment,left", "elm");
 414              else
 415                edje_object_signal_emit(it->base.view,
 416                                        "elm,type,segment,right", "elm");
 417           }
 418         else
 419           edje_object_signal_emit(it->base.view,
 420                                   "elm,type,segment,middle", "elm");
 421
 422         //Set the segment state
 423         if (wd->selected_item == it)
 424           edje_object_signal_emit(it->base.view,
 425                                   "elm,state,segment,selected", "elm");
 426         else
 427           edje_object_signal_emit(it->base.view,
 428                                   "elm,state,segment,normal", "elm");
 429
 430         if (elm_widget_disabled_get(wd->obj))
 431           edje_object_signal_emit(it->base.view, "elm,state,disabled", "elm");
 432
 433         _swallow_item_objects(it);
 434         idx++;
 435      }
 436 }
 437
 438 static Elm_Segment_Item *
 439 _item_find(const Evas_Object *obj, int idx)
 440 {
 441    Widget_Data *wd;
 442    Elm_Segment_Item *it;
 443
 444    wd = elm_widget_data_get(obj);
 445    if (!wd) return NULL;
 446
 447    it = eina_list_nth(wd->seg_items, idx);
 448    return it;
 449 }
 450
 451 static Elm_Segment_Item*
 452 _item_new(Evas_Object *obj, Evas_Object *icon, const char *label)
 453 {
 454    Elm_Segment_Item *it;
 455    Widget_Data *wd;
 456
 457    wd = elm_widget_data_get(obj);
 458    if (!wd) return NULL;
 459
 460    it = elm_widget_item_new(obj, Elm_Segment_Item);
 461    if (!it) return NULL;
 462    elm_widget_item_data_set(it, wd);
 463
 464    it->base.view = edje_object_add(evas_object_evas_get(obj));
 465    edje_object_scale_set(it->base.view, elm_widget_scale_get(it->base.view)
 466                          *_elm_config->scale);
 467    evas_object_smart_member_add(it->base.view, obj);
 468    elm_widget_sub_object_add(obj, it->base.view);
 469    evas_object_clip_set(it->base.view, evas_object_clip_get(obj));
 470
 471    _elm_theme_object_set(obj, it->base.view, "segment_control", "item",
 472                          elm_object_style_get(obj));
 473    edje_object_mirrored_set(it->base.view,
 474                             elm_widget_mirrored_get(it->base.widget));
 475
 476    if (label)
 477      eina_stringshare_replace(&it->label, label);
 478    if (it->label)
 479      edje_object_signal_emit(it->base.view, "elm,state,text,visible", "elm");
 480    else
 481      edje_object_signal_emit(it->base.view, "elm,state,text,hidden", "elm");
 482    edje_object_message_signal_process(it->base.view);
 483    edje_object_part_text_set(it->base.view, "elm.text", label);
 484
 485    it->icon = icon;
 486    if (it->icon) elm_widget_sub_object_add(it->base.view, it->icon);
 487    evas_object_event_callback_add(it->base.view, EVAS_CALLBACK_MOUSE_DOWN,
 488                                   _mouse_down, it);
 489    evas_object_event_callback_add(it->base.view, EVAS_CALLBACK_MOUSE_UP,
 490                                   _mouse_up, it);
 491    evas_object_show(it->base.view);
 492
 493    return it;
 494 }
 495
 496 /**
 497  * Create new SegmentControl.
 498  * @param [in] parent The parent object
 499  * @return The new object or NULL if it cannot be created
 500  *
 501  * @ingroup SegmentControl
 502  */
 503 EAPI Evas_Object *
 504 elm_segment_control_add(Evas_Object *parent)
 505 {
 506    Evas_Object *obj;
 507    Evas *e;
 508    Widget_Data *wd;
 509
 510    ELM_WIDGET_STANDARD_SETUP(wd, Widget_Data, parent, e, obj, NULL);
 511
 512    ELM_SET_WIDTYPE(widtype, "segment_control");
 513    elm_widget_type_set(obj, "segment_control");
 514    elm_widget_sub_object_add(parent, obj);
 515    elm_widget_data_set(obj, wd);
 516    elm_widget_del_hook_set(obj, _del_hook);
 517    elm_widget_theme_hook_set(obj, _theme_hook);
 518    elm_widget_disable_hook_set(obj, _disable_hook);
 519
 520    // TODO: Focus switch support to Elm_widget_Item not supported yet.
 521 #if 0
 522    elm_widget_focus_next_hook_set(obj, _focus_next_hook);
 523 #endif
 524
 525    wd->obj = obj;
 526
 527    wd->base = edje_object_add(e);
 528    edje_object_scale_set(wd->base, elm_widget_scale_get(wd->base)
 529                          *_elm_config->scale);
 530    _elm_theme_object_set(obj, wd->base, "segment_control", "base", "default");
 531    elm_widget_resize_object_set(obj, wd->base);
 532
 533    evas_object_event_callback_add(obj, EVAS_CALLBACK_RESIZE,
 534                                   _on_move_resize, obj);
 535    evas_object_event_callback_add(obj, EVAS_CALLBACK_MOVE,
 536                                   _on_move_resize, obj);
 537
 538    evas_object_smart_callbacks_descriptions_set(obj, _signals);
 539
 540    return obj;
 541 }
 542
 543 /**
 544  * Add new segment item to SegmentControl.
 545  * @param [in] obj The SegmentControl object
 546  * @param [in] icon Any Objects like icon, Label, layout etc
 547  * @param [in] label The label for added segment item.
 548  *             Note that, NULL is different from empty string "".
 549  * @return The new segment item or NULL if it cannot be created
 550  *
 551  * @ingroup SegmentControl
 552  */
 553 EAPI Elm_Segment_Item *
 554 elm_segment_control_item_add(Evas_Object *obj, Evas_Object *icon,
 555                              const char *label)
 556 {
 557    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 558    Elm_Segment_Item *it;
 559    Widget_Data *wd;
 560
 561    wd = elm_widget_data_get(obj);
 562    if (!wd) return NULL;
 563
 564    it = _item_new(obj, icon, label);
 565    if (!it) return NULL;
 566
 567    wd->seg_items = eina_list_append(wd->seg_items, it);
 568    _update_list(wd);
 569
 570    return it;
 571 }
 572
 573 /**
 574  * Insert a new segment item to SegmentControl.
 575  * @param [in] obj The SegmentControl object
 576  * @param [in] icon Any Objects like icon, Label, layout etc
 577  * @param [in] label The label for added segment item.
 578  *        Note that, NULL is different from empty string "".
 579  * @param [in] index Segment item location. Value should be between 0 and
 580  *        Existing total item count( @see elm_segment_control_item_count_get() )
 581  * @return The new segment item or NULL if it cannot be created
 582  *
 583  * @ingroup SegmentControl
 584  */
 585 EAPI Elm_Segment_Item *
 586 elm_segment_control_item_insert_at(Evas_Object *obj, Evas_Object *icon,
 587                                    const char *label, int idx)
 588 {
 589    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 590    Elm_Segment_Item *it, *it_rel;
 591    Widget_Data *wd;
 592
 593    wd = elm_widget_data_get(obj);
 594    if (!wd) return NULL;
 595    if (idx < 0) idx = 0;
 596
 597    it = _item_new(obj, icon, label);
 598    if (!it) return NULL;
 599
 600    it_rel = _item_find(obj, idx);
 601
 602    if (it_rel)
 603      wd->seg_items = eina_list_prepend_relative(wd->seg_items, it, it_rel);
 604    else
 605      wd->seg_items = eina_list_append(wd->seg_items, it);
 606
 607    _update_list(wd);
 608    return it;
 609 }
 610
 611 /**
 612  * Delete a segment item from SegmentControl
 613  * @param [in] obj The SegmentControl object
 614  * @param [in] it The segment item to be deleted
 615  *
 616  * @ingroup SegmentControl
 617  */
 618 EAPI void
 619 elm_segment_control_item_del(Elm_Segment_Item *it)
 620 {
 621    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
 622    Widget_Data *wd;
 623
 624    wd = elm_widget_item_data_get(it);
 625    if (!wd) return;
 626
 627    _item_free(it);
 628    _update_list(wd);
 629 }
 630
 631 /**
 632  * Delete a segment item of given index from SegmentControl
 633  * @param [in] obj The SegmentControl object
 634  * @param [in] index The position at which segment item to be deleted.
 635  *
 636  * @ingroup SegmentControl
 637  */
 638 EAPI void
 639 elm_segment_control_item_del_at(Evas_Object *obj, int idx)
 640 {
 641    ELM_CHECK_WIDTYPE(obj, widtype);
 642    Elm_Segment_Item *it;
 643    Widget_Data *wd;
 644
 645    wd = elm_widget_data_get(obj);
 646    if (!wd) return;
 647
 648    it = _item_find(obj, idx);
 649
 650    if (!it) return;
 651    _item_free(it);
 652    _update_list(wd);
 653 }
 654
 655 /**
 656  * Get the label of a segment item.
 657  * @param [in] obj The SegmentControl object
 658  * @param [in] index The index of the segment item
 659  * @return The label of the segment item
 660  *
 661  * @ingroup SegmentControl
 662  */
 663 EAPI const char*
 664 elm_segment_control_item_label_get(const Evas_Object *obj, int idx)
 665 {
 666    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 667    Elm_Segment_Item *it;
 668
 669    it = _item_find(obj, idx);
 670
 671    if (it) return it->label;
 672
 673    return NULL;
 674 }
 675
 676 /**
 677  * Set the label of a segment item.
 678  * @param [in] it The SegmentControl Item
 679  * @param [in] label New label text.
 680  *
 681  * @ingroup SegmentControl
 682  */
 683 EAPI void
 684 elm_segment_control_item_label_set(Elm_Segment_Item* it, const char* label)
 685 {
 686    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
 687    Widget_Data *wd;
 688
 689    wd = elm_widget_item_data_get(it);
 690    if (!wd) return;
 691
 692    eina_stringshare_replace(&it->label, label);
 693    if (it->label)
 694      edje_object_signal_emit(it->base.view, "elm,state,text,visible", "elm");
 695    else
 696      edje_object_signal_emit(it->base.view, "elm,state,text,hidden", "elm");
 697    edje_object_message_signal_process(it->base.view);
 698    //label can be NULL also.
 699    edje_object_part_text_set(it->base.view, "elm.text", it->label);
 700 }
 701
 702 /**
 703  * Get the icon of a segment item of SegmentControl
 704  * @param [in] obj The SegmentControl object
 705  * @param [in] index The index of the segment item
 706  * @return The icon object.
 707  *
 708  * @ingroup SegmentControl
 709  */
 710 EAPI Evas_Object *
 711 elm_segment_control_item_icon_get(const Evas_Object *obj, int idx)
 712 {
 713    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 714    Elm_Segment_Item *it;
 715
 716    it = _item_find(obj, idx);
 717
 718    if (it) return it->icon;
 719
 720    return NULL;
 721 }
 722
 723 /**
 724  * Set the Icon to the segment item
 725  * @param [in] it The SegmentControl Item
 726  * @param [in] icon Objects like Layout, Icon, Label etc...
 727  *
 728  * @ingroup SegmentControl
 729  */
 730 EAPI void
 731 elm_segment_control_item_icon_set(Elm_Segment_Item *it, Evas_Object *icon)
 732 {
 733    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
 734
 735    //Remove the existing icon
 736    if (it->icon)
 737      {
 738         edje_object_part_unswallow(it->base.view, it->icon);
 739         evas_object_del(it->icon);
 740         it->icon = NULL;
 741      }
 742
 743    it->icon = icon;
 744    if (it->icon)
 745      {
 746         elm_widget_sub_object_add(it->base.view, it->icon);
 747         edje_object_part_swallow(it->base.view, "elm.swallow.icon", it->icon);
 748         edje_object_signal_emit(it->base.view, "elm,state,icon,visible", "elm");
 749      }
 750    else
 751      edje_object_signal_emit(it->base.view, "elm,state,icon,hidden", "elm");
 752 }
 753
 754 /**
 755  * Get the Segment items count from SegmentControl
 756  * @param [in] obj The SegmentControl object
 757  * @return Segment items count.
 758  *
 759  * @ingroup SegmentControl
 760  */
 761 EAPI int
 762 elm_segment_control_item_count_get(const Evas_Object *obj)
 763 {
 764    ELM_CHECK_WIDTYPE(obj, widtype) 0;
 765    Widget_Data *wd;
 766
 767    wd = elm_widget_data_get(obj);
 768    if (!wd) return 0;
 769
 770    return eina_list_count(wd->seg_items);
 771 }
 772
 773 /**
 774  * Get the base object of segment item.
 775  * @param [in] it The Segment item
 776  * @return obj The base object of the segment item.
 777  *
 778  * @ingroup SegmentControl
 779  */
 780 EAPI Evas_Object*
 781 elm_segment_control_item_object_get(const Elm_Segment_Item *it)
 782 {
 783    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, NULL);
 784
 785    return it->base.view;
 786 }
 787
 788 /**
 789  * Get the selected segment item in the SegmentControl
 790  * @param [in] obj The SegmentControl object
 791  * @return Selected Segment Item. NULL if none of segment item is selected.
 792  *
 793  * @ingroup SegmentControl
 794  */
 795 EAPI Elm_Segment_Item*
 796 elm_segment_control_item_selected_get(const Evas_Object *obj)
 797 {
 798    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 799    Widget_Data *wd;
 800
 801    wd = elm_widget_data_get(obj);
 802    if (!wd) return NULL;
 803
 804    return wd->selected_item;
 805 }
 806
 807 /**
 808  * Select/unselect a particular segment item of SegmentControl
 809  * @param [in] it The Segment item that is to be selected or unselected.
 810  * @param [in] select Passing EINA_TRUE will select the segment item and
 811  *             EINA_FALSE will unselect.
 812  *
 813  * @ingroup SegmentControl
 814  */
 815 EAPI void
 816 elm_segment_control_item_selected_set(Elm_Segment_Item *it, Eina_Bool selected)
 817 {
 818    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
 819    Widget_Data *wd;
 820
 821    wd = elm_widget_item_data_get(it);
 822    if (!wd) return;
 823
 824    if (it == wd->selected_item)
 825      {
 826         //already in selected state.
 827         if (selected) return;
 828
 829         //unselect case
 830         _segment_off(it);
 831      }
 832    else if (selected)
 833      _segment_on(it);
 834
 835    return;
 836 }
 837
 838 /**
 839  * Get the Segment Item from the specified Index.
 840  * @param [in] obj The Segment Control object.
 841  * @param [in] index The index of the segment item.
 842  * @return The Segment item.
 843  *
 844  * @ingroup SegmentControl
 845  */
 846 EAPI Elm_Segment_Item *
 847 elm_segment_control_item_get(const Evas_Object *obj, int idx)
 848 {
 849    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 850    Elm_Segment_Item *it;
 851
 852    it = _item_find(obj, idx);
 853
 854    return it;
 855 }
 856
 857 /**
 858  * Get the index of a Segment item in the SegmentControl
 859  * @param [in] it The Segment Item.
 860  * @return Segment Item index.
 861  *
 862  * @ingroup SegmentControl
 863  */
 864 EAPI int
 865 elm_segment_control_item_index_get(const Elm_Segment_Item *it)
 866 {
 867    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, -1);
 868
 869    return it->seg_index;
 870 }