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