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 object is a horizontal control made of multiple segments,
   9  * each segment functioning as a discrete button. A segmented control affords a compact means to group together a number of controls.
  10  * A segmented control can display a title or an image. The UISegmentedControl object automatically resizes segments to fit proportionally
  11  * within their superview unless they have a specific width set. When you add and remove segments,
  12  * you can request that the action be animated with sliding and fading effects.
  13  */
  14 typedef struct _Widget_Data Widget_Data;
  15 struct _Widget_Data
  16 {
  17    Evas_Object *box;
  18    Evas_Object *base;
  19    Eina_List *seg_ctrl;
  20    int width, height;
  21    int id;
  22    int item_width;
  23
  24    Elm_Segment_Item *ani_it;
  25    Ecore_Animator *ani;
  26    unsigned int count;
  27    unsigned int insert_index;
  28    unsigned int del_index;
  29    unsigned int cur_seg_id;
  30    double scale_factor;
  31 //   Eina_Bool longpressed : 1;
  32    Eina_Bool selected : 1;
  33 };
  34
  35 struct _Elm_Segment_Item
  36 {
  37    Evas_Object *obj;
  38    Evas_Object *base;
  39    Evas_Object *icon;
  40    const char *label;
  41    Eina_Bool delete_me : 1;
  42    int segment_id;
  43 //   Ecore_Timer *long_timer;
  44 };
  45
  46 static void _mouse_down(void *data, Evas *evas, Evas_Object *obj, void *event_info);
  47 static void _mouse_up(void *data, Evas *e, Evas_Object *obj, void *event_info);
  48 static void _signal_segment_on(void *data);
  49 static void _theme_hook(Evas_Object *obj);
  50 static void _item_free(Evas_Object *obj, Elm_Segment_Item *it);
  51 static void _del_hook(Evas_Object *obj);
  52 static void _layout(Evas_Object *o, Evas_Object_Box_Data *priv, void *data);
  53 static void _update_list(Evas_Object *obj);
  54 static void _refresh_segment_ids(Evas_Object *obj);
  55 static void _state_value_set(Evas_Object *obj);
  56
  57 static Elm_Segment_Item* _item_new(Evas_Object *obj, const char *label, Evas_Object *icon);
  58 static Elm_Segment_Item *_item_find(Evas_Object *obj, unsigned int index);
  59
  60 static int * _animator_animate_add_cb(Evas_Object *obj);
  61 static int * _animator_animate_del_cb(Evas_Object *obj);
  62
  63 static void
  64 _on_focus_hook(void *data, Evas_Object *obj)
  65 {
  66    Widget_Data *wd = elm_widget_data_get(obj);
  67    if (!wd) return;
  68
  69    if (elm_widget_focus_get(obj))
  70      evas_object_focus_set((Evas_Object *)wd->seg_ctrl, 1);
  71    else
  72      evas_object_focus_set((Evas_Object *)wd->seg_ctrl, 0);
  73 }
  74
  75 static void
  76 _signal_segment_on(void *data)
  77 {
  78    Elm_Segment_Item *item = (Elm_Segment_Item *) data;
  79    Widget_Data *wd = elm_widget_data_get(item->obj);
  80
  81    if (!wd) return;
  82
  83    wd->selected = EINA_TRUE;
  84
  85  /*  if (item->long_timer)
  86      {
  87        ecore_timer_del(item->long_timer);
  88        item->long_timer = NULL;
  89      }*/
  90    //wd->longpressed = EINA_TRUE;
  91    edje_object_signal_emit(item->base, "elm,state,segment,on", "elm");
  92    edje_object_signal_emit(item->base, "elm,state,text,change", "elm");
  93
  94    Elm_Segment_Item *it;
  95    Eina_List *l;
  96
  97    if (item->segment_id == wd->cur_seg_id)
  98      {
  99         wd->cur_seg_id = item->segment_id;
 100         evas_object_smart_callback_call(item->obj, "changed", (void*)wd->cur_seg_id);
 101         return;
 102      }
 103    EINA_LIST_FOREACH(wd->seg_ctrl, l, it)
 104      {
 105         if (it->segment_id == wd->cur_seg_id)
 106           {
 107              edje_object_signal_emit(it->base, "elm,action,unfocus", "elm");
 108              edje_object_signal_emit(it->base, "elm,state,segment,off", "elm");
 109              edje_object_signal_emit(it->base, "elm,state,text,visible", "elm");
 110              break;
 111           }
 112      }
 113    wd->cur_seg_id = item->segment_id;
 114    evas_object_smart_callback_call(item->obj, "changed", (void*)wd->cur_seg_id);
 115    return;
 116 }
 117
 118 static void
 119 _mouse_up(void *data, Evas *e, Evas_Object *obj, void *event_info)
 120 {
 121    Elm_Segment_Item *item = (Elm_Segment_Item *) data;
 122    Widget_Data *wd = elm_widget_data_get(item->obj);
 123    Evas_Event_Mouse_Up * ev = event_info;
 124    Evas_Coord x, y, w, h;
 125
 126    if (!wd) return;
 127
 128    evas_object_geometry_get(obj, &x, &y, &w, &h);
 129    if(ev->output.x > x && ev->output.x < x+w && ev->output.y > y && ev->output.y < y+h && wd->selected == EINA_FALSE)
 130      {
 131         _signal_segment_on(item);
 132      }
 133    else
 134      {
 135          wd->selected = EINA_FALSE;
 136          return;
 137      }
 138
 139   // if(wd->longpressed == EINA_FALSE)
 140      {
 141        edje_object_signal_emit(item->base, "elm,action,unfocus", "elm");
 142        edje_object_signal_emit(item->base, "elm,state,text,visible", "elm");
 143      }
 144   /* if (item->long_timer)
 145      {
 146        ecore_timer_del(item->long_timer);
 147        item->long_timer = NULL;
 148      }*/
 149 }
 150
 151 static void
 152 _mouse_move(void *data, Evas *evas, Evas_Object *obj, void *event_info)
 153 {
 154    Elm_Segment_Item *item = (Elm_Segment_Item *) data;
 155    Widget_Data *wd = elm_widget_data_get(item->obj);
 156    Evas_Event_Mouse_Move * ev = event_info;
 157    Evas_Coord x, y, w, h;
 158
 159    if (!wd) return;
 160
 161    evas_object_geometry_get(obj, &x, &y, &w, &h);
 162    if(ev->cur.output.x > x && ev->cur.output.x < x+w && ev->cur.output.y > y && ev->cur.output.y < y+h)
 163      {
 164         return;
 165      }
 166
 167 //      if(wd->longpressed == EINA_FALSE)
 168      {
 169        edje_object_signal_emit(item->base, "elm,action,unfocus", "elm");
 170        edje_object_signal_emit(item->base, "elm,state,text,visible", "elm");
 171      }
 172   /* if (item->long_timer)
 173      {
 174        ecore_timer_del(item->long_timer);
 175        item->long_timer = NULL;
 176      }*/
 177 }
 178
 179 static void
 180 _mouse_down(void *data, Evas *evas, Evas_Object *obj, void *event_info)
 181 {
 182    Elm_Segment_Item *item = (Elm_Segment_Item *) data;
 183    Widget_Data *wd = elm_widget_data_get(item->obj);
 184
 185    if (!wd) return;
 186    //wd->longpressed = EINA_FALSE;
 187
 188    if (item->segment_id == wd->cur_seg_id)
 189      {
 190         wd->selected = EINA_TRUE;
 191         return;
 192      }
 193
 194    edje_object_signal_emit(item->base, "elm,action,focus", "elm");
 195    edje_object_signal_emit(item->base, "elm,state,text,visible", "elm");
 196
 197    _signal_segment_on(item);
 198
 199 /*   if (item->long_timer) ecore_timer_del(item->long_timer);
 200    item->long_timer = ecore_timer_add(0.3, _signal_segment_on, item);*/
 201 }
 202
 203 static void
 204 _theme_hook(Evas_Object *obj)
 205 {
 206    _elm_theme_object_set(obj, obj, "segmented-control", "base", elm_widget_style_get(obj));
 207
 208    return;
 209 }
 210
 211 static void
 212 _item_free(Evas_Object *obj, Elm_Segment_Item *it)
 213 {
 214    Widget_Data *wd = elm_widget_data_get(obj);
 215    if (!wd) return;
 216
 217    if(wd->seg_ctrl)
 218      wd->seg_ctrl = eina_list_remove(wd->seg_ctrl, it);
 219
 220    if(it->icon) evas_object_del(it->icon);
 221    if(it->base) evas_object_del(it->base);
 222    if(it->label) eina_stringshare_del(it->label);
 223 //   if (it->long_timer) ecore_timer_del(it->long_timer);
 224
 225    if(it)
 226      free(it);
 227    it = NULL;
 228    return;
 229 }
 230
 231 static void
 232 _del_hook(Evas_Object *obj)
 233 {
 234    Widget_Data *wd = elm_widget_data_get(obj);
 235    Elm_Segment_Item *it;
 236    Eina_List *l, *clear = NULL;
 237
 238    EINA_LIST_FOREACH(wd->seg_ctrl, l, it) clear = eina_list_append(clear, it);
 239    EINA_LIST_FREE(clear, it) _item_free(obj, it);
 240
 241    if(wd) free(wd);
 242    wd = NULL;
 243
 244    return;
 245 }
 246
 247
 248 static void
 249 _layout(Evas_Object *o, Evas_Object_Box_Data *priv, void *data)
 250 {
 251    Widget_Data *wd = data;
 252    if (!wd) return;
 253    _els_box_layout(o, priv, 1, 0); /* making box layout non homogenous */
 254
 255    return;
 256 }
 257
 258 static void
 259 _segment_resizing(void *data)
 260 {
 261    Widget_Data *wd = elm_widget_data_get((Evas_Object *)data);
 262    if (!wd) return;
 263    Evas_Coord w = 0, h = 0;
 264
 265    evas_object_geometry_get(wd->base, NULL, NULL, &w, &h);
 266    wd->item_width = wd->width = w;
 267    wd->height = h;
 268    _state_value_set((Evas_Object *)data);
 269 }
 270
 271 static void _object_resize(void *data, Evas *e, Evas_Object *obj, void *event_info)
 272 {
 273    Widget_Data *wd;
 274    if(!data) return;
 275    wd = elm_widget_data_get((Evas_Object *)data);
 276    if(!wd) return;
 277
 278    ecore_job_add(_segment_resizing, (Evas_Object *)data);
 279 }
 280
 281 /**
 282  * Add a new segmentcontrol to the parent
 283  * @param parent The parent object
 284  * @return The new object or NULL if it cannot be created
 285  *
 286  * @ingroup SegmentControl SegmentControl
 287  */
 288 EAPI Evas_Object *
 289 elm_segment_control_add(Evas_Object *parent)
 290 {
 291    Evas_Object *obj;
 292    Evas *e;
 293    Widget_Data *wd;
 294
 295    wd = ELM_NEW(Widget_Data);
 296    e = evas_object_evas_get(parent);
 297    obj = elm_widget_add(e);
 298    elm_widget_type_set(obj, "segmented-control");
 299    elm_widget_sub_object_add(parent, obj);
 300    elm_widget_on_focus_hook_set( obj, _on_focus_hook, NULL );
 301    elm_widget_data_set(obj, wd);
 302    elm_widget_del_hook_set(obj, _del_hook);
 303    elm_widget_theme_hook_set(obj, _theme_hook);
 304
 305    wd->base = edje_object_add(e);
 306    _elm_theme_object_set(obj, wd->base, "segmented-control", "base", "default");
 307    elm_widget_resize_object_set(obj, wd->base);
 308    wd->box = evas_object_box_add(e);
 309    evas_object_box_layout_set(wd->box, _layout, wd, NULL);
 310    elm_widget_sub_object_add(obj, wd->box);
 311    edje_object_part_swallow(wd->base, "elm.swallow.content", wd->box);
 312    evas_object_show(wd->box);
 313
 314    evas_object_event_callback_add(obj, EVAS_CALLBACK_RESIZE, _object_resize, obj);
 315    wd->id = 0;
 316    wd->del_index = 0;
 317    wd->insert_index = 0;
 318    wd->cur_seg_id = -1;
 319    wd->selected = EINA_FALSE;
 320
 321    return obj;
 322 }
 323
 324 static Elm_Segment_Item*
 325 _item_new(Evas_Object *obj, const char *label, Evas_Object *icon)
 326 {
 327    Widget_Data *wd = elm_widget_data_get(obj);
 328    if (!wd) return NULL;
 329
 330    Elm_Segment_Item *it;
 331    it = calloc(1, sizeof(   Elm_Segment_Item));
 332    if (!it) return NULL;
 333
 334    Evas_Coord mw, mh;
 335
 336    if(obj) it->obj = obj;
 337    it->delete_me = EINA_FALSE;
 338    it->segment_id = wd->id;
 339
 340    it->base = edje_object_add(evas_object_evas_get(obj));
 341    _elm_theme_object_set(obj, it->base, "segment", "base", elm_object_style_get(it->base));
 342
 343    if (it->label) eina_stringshare_del(it->label);
 344    if (label)
 345      {
 346         it->label = eina_stringshare_add(label);
 347      }
 348    else
 349      {
 350          it->label = NULL;
 351      }
 352
 353    if ((it->icon != icon) && (it->icon))
 354       elm_widget_sub_object_del(obj, it->icon);
 355    it->icon = icon;
 356    if (icon)
 357      {
 358         elm_widget_sub_object_add(obj, icon);
 359         Evas_Coord minw = -1, minh = -1, maxw = -1, maxh = -1;
 360         elm_coords_finger_size_adjust(1, &minw, 1, &minh);
 361         elm_coords_finger_size_adjust(1, &minw, 1, &minh);
 362
 363         evas_object_size_hint_weight_set(it->base, 1.0, -1.0);
 364         evas_object_size_hint_align_set(it->base, 1.0, -1.0);
 365         evas_object_size_hint_min_set(it->base, -1, -1);
 366         evas_object_size_hint_max_set(it->base, maxw, maxh);
 367      }
 368
 369    edje_object_size_min_restricted_calc(obj, &mw, &mh, 0, 0);
 370    evas_object_size_hint_weight_set(obj, 1.0, 1.0);
 371    evas_object_size_hint_align_set(obj, -1.0, -1.0);
 372
 373    return it;
 374 }
 375
 376
 377 static void _update_list(Evas_Object *obj)
 378 {
 379    Widget_Data *wd = elm_widget_data_get(obj);
 380    if (!wd) return;
 381
 382    Elm_Segment_Item *it;
 383    Eina_List *l;
 384    int i = 0;
 385    wd->count = eina_list_count(wd->seg_ctrl);
 386
 387    if(wd->count == 1)
 388      {
 389         it = _item_find(obj, 0);
 390         _elm_theme_object_set(obj, it->base, "segment", "base", "single");              edje_object_signal_emit(it->base, "elm,state,segment,on", "elm");
 391         edje_object_signal_emit(it->base, "elm,state,text,visible", "elm");
 392         edje_object_signal_emit(it->base, "elm,state,text,change", "elm");
 393         edje_object_message_signal_process(it->base);
 394
 395         edje_object_part_text_set(it->base, "elm.text", it->label);
 396
 397         edje_object_part_swallow(it->base, "elm.swallow.content", it->icon);
 398         edje_object_signal_emit(it->base, "elm,state,icon,visible", "elm");
 399         return;
 400      }
 401
 402    EINA_LIST_FOREACH(wd->seg_ctrl, l, it)
 403      {
 404         if(i==0)
 405           {
 406              _elm_theme_object_set(obj, it->base, "segment", "base", "first");
 407           }
 408         else if(i==wd->count-1)
 409           {
 410              _elm_theme_object_set(obj, it->base, "segment", "base", "last");
 411           }
 412         else
 413           {
 414              _elm_theme_object_set(obj, it->base, "segment", "base", "default");
 415           }
 416
 417         edje_object_signal_emit(it->base, "elm,state,text,visible", "elm");
 418         edje_object_message_signal_process(it->base);
 419
 420         edje_object_part_text_set(it->base, "elm.text", it->label);
 421
 422         edje_object_part_swallow(it->base, "elm.swallow.content", it->icon);
 423         edje_object_signal_emit(it->base, "elm,state,icon,visible", "elm");
 424
 425         i++;
 426      }
 427 }
 428
 429
 430 static void _refresh_segment_ids(Evas_Object *obj)
 431 {
 432    Widget_Data *wd = elm_widget_data_get(obj);
 433    if (!wd) return;
 434    Elm_Segment_Item *it;
 435    Eina_List *l;
 436    if (wd->insert_index && wd->cur_seg_id >= wd->insert_index)
 437      {
 438         ++wd->cur_seg_id;
 439         wd->insert_index = 0;
 440      }
 441    if (wd->del_index)
 442      {
 443         if (wd->cur_seg_id >= wd->del_index)
 444            --wd->cur_seg_id;
 445            wd->del_index =0;
 446      }
 447    int i = 0;
 448    EINA_LIST_FOREACH(wd->seg_ctrl, l, it)
 449      {
 450         it->segment_id = i;
 451         i++;
 452      }
 453 }
 454
 455 static void _state_value_set(Evas_Object *obj)
 456 {
 457    Widget_Data *wd = elm_widget_data_get(obj);
 458    if (!wd) return;
 459    Elm_Segment_Item *it;
 460    Eina_List *l;
 461    Evas_Coord mw, mh, x, y;
 462    int w1=0, w2;
 463    unsigned int count = eina_list_count(wd->seg_ctrl);
 464    if (count > 0)
 465      wd->item_width = wd->width/count;
 466    if (wd->ani_it)
 467      {
 468         evas_object_geometry_get(wd->ani_it->base, &x, &y, &w1, NULL);
 469         if (wd->ani_it->delete_me)
 470           {
 471              w1-=(wd->item_width/15);
 472              if( w1< 0) w1 = 0;
 473           }
 474         else
 475         {
 476            w1+=(wd->item_width/15);
 477            if( w1 > wd->item_width )
 478               w1 = wd->item_width;
 479         }
 480         w2 = (wd->width-w1)/(count -1);
 481      }
 482    else
 483       w2 = wd->item_width;
 484
 485    int i=0;
 486
 487    EINA_LIST_FOREACH(wd->seg_ctrl, l, it)
 488     {
 489        edje_object_size_min_restricted_calc(it->base, &mw, &mh, 0, 0);
 490        evas_object_size_hint_weight_set(it->base, 1.0, 1.0);
 491        evas_object_size_hint_align_set(it->base, -1.0, -1.0);
 492
 493        if(wd->ani_it  && it == wd->ani_it)
 494          {
 495             evas_object_resize(it->base, w1, wd->height);
 496             evas_object_size_hint_min_set(it->base, w1, wd->height);
 497             evas_object_size_hint_max_set(it->base, w1, wd->height);
 498          }
 499        else
 500          {
 501             evas_object_resize(it->base, w2, wd->height);
 502             evas_object_size_hint_min_set(it->base, w2, wd->height);
 503             evas_object_size_hint_max_set(it->base, w2, wd->height);
 504          }
 505        ++i;
 506     }
 507
 508     return;
 509 }
 510
 511
 512 static int *
 513 _animator_animate_add_cb(Evas_Object *obj)
 514 {
 515    Widget_Data *wd = elm_widget_data_get(obj);
 516    if (!wd) return 0;
 517
 518    int w;
 519    evas_object_geometry_get(wd->ani_it->base, NULL, NULL, &w, NULL);
 520    if( w <  wd->item_width )
 521      {
 522          _state_value_set(obj);
 523          evas_object_geometry_get(wd->ani_it->base, NULL, NULL, &w, NULL);
 524          return ECORE_CALLBACK_RENEW;
 525      }
 526    else
 527      {
 528         ecore_animator_del(wd->ani);
 529         wd->ani = NULL;
 530         wd->ani_it = NULL;
 531         return ECORE_CALLBACK_CANCEL;
 532      }
 533 }
 534
 535
 536 static int *
 537 _animator_animate_del_cb(Evas_Object *obj)
 538 {
 539    Widget_Data *wd = elm_widget_data_get(obj);
 540    if (!wd) return 0;
 541    int w;
 542    evas_object_geometry_get(wd->ani_it->base, NULL, NULL, &w, NULL);
 543    if( w >  0 )
 544      {
 545         _state_value_set(obj);
 546         evas_object_geometry_get(wd->ani_it->base, NULL, NULL, &w, NULL);
 547         return ECORE_CALLBACK_RENEW;
 548      }
 549    else
 550      {
 551         _item_free(obj, wd->ani_it );
 552         _refresh_segment_ids(obj);
 553         ecore_animator_del(wd->ani);
 554         wd->ani = NULL;
 555         wd->ani_it = NULL;
 556         _update_list(obj);
 557         wd->id = eina_list_count(wd->seg_ctrl);
 558         return ECORE_CALLBACK_CANCEL;
 559      }
 560 }
 561
 562 /**
 563  * Add a new segment to segmentcontrol
 564  * @param obj The SegmentControl object
 565  * @param icon The icon object for added segment
 566  * @param label The label for added segment
 567  * @param animate If 1 the action be animated with sliding effects default 0.
 568  * @return The new segment or NULL if it cannot be created
 569  *
 570  * @ingroup SegmentControl SegmentControl
 571  */
 572
 573 EAPI Elm_Segment_Item *
 574 elm_segment_control_add_segment(Evas_Object *obj, Evas_Object *icon, const char *label, Eina_Bool animate)
 575 {
 576    Widget_Data *wd = elm_widget_data_get(obj);
 577    if(!wd) return NULL;
 578
 579    Elm_Segment_Item *it;
 580
 581    it = _item_new(obj, label, icon);
 582    if(!it) return NULL;
 583
 584    wd->seg_ctrl = eina_list_append(wd->seg_ctrl, it);
 585    wd->id = eina_list_count(wd->seg_ctrl);
 586    _update_list(obj);
 587    evas_object_event_callback_add(it->base, EVAS_CALLBACK_MOUSE_DOWN, _mouse_down, it);
 588    evas_object_event_callback_add(it->base, EVAS_CALLBACK_MOUSE_MOVE, _mouse_move, it);
 589    evas_object_event_callback_add(it->base, EVAS_CALLBACK_MOUSE_UP, _mouse_up, it);
 590    wd->insert_index = 0;
 591    wd->del_index = 0;
 592    _refresh_segment_ids(obj);
 593
 594    if(animate && it->segment_id && wd->ani_it == NULL)
 595      {
 596         evas_object_resize(it->base, 1, wd->height);
 597         wd->ani_it = it;
 598         wd->ani = ecore_animator_add( _animator_animate_add_cb, obj );
 599      }
 600    else
 601       _state_value_set(obj);
 602    evas_object_show( it->base);
 603
 604    evas_object_box_append(wd->box, it->base);
 605    evas_object_smart_calculate(wd->box);
 606
 607    return it;
 608 }
 609
 610
 611 static Elm_Segment_Item *
 612 _item_find(Evas_Object *obj, unsigned int index)
 613 {
 614    Widget_Data *wd = elm_widget_data_get(obj);
 615    if (!wd) return NULL;
 616
 617    Elm_Segment_Item *it;
 618    Eina_List *l;
 619    int i = 0;
 620    EINA_LIST_FOREACH(wd->seg_ctrl, l, it)
 621      {
 622         if (i == index) {
 623            return it;
 624         }
 625         i++;
 626      }
 627      return NULL;
 628 }
 629
 630
 631 static Elm_Segment_Item *
 632 _item_search(Evas_Object *obj, Elm_Segment_Item *item)
 633 {
 634    Widget_Data *wd = elm_widget_data_get(obj);
 635    if (!wd)
 636    return NULL;
 637
 638    Elm_Segment_Item *it;
 639    Eina_List *l;
 640    EINA_LIST_FOREACH(wd->seg_ctrl, l, it)
 641      {
 642         if (it == item) {
 643            return it;
 644         }
 645      }
 646    return NULL;
 647 }
 648
 649 /**
 650  * Insert a new segment to segmentcontrol
 651  * @param obj The SegmentControl object
 652  * @param icon The icon object for added segment
 653  * @param label The label for added segment
 654  * @param index The position at which segment to be inserted
 655  * @param animate If 1 the action be animated with sliding effects default 0.
 656  * @return The new segment or NULL if it cannot be created
 657  *
 658  * @ingroup SegmentControl SegmentControl
 659  */
 660 EAPI void
 661 elm_segment_control_insert_segment_at(Evas_Object *obj, Evas_Object *icon, const char *label, unsigned int index, Eina_Bool animate)
 662 {
 663    Widget_Data *wd = elm_widget_data_get(obj);
 664    if(!wd) return;
 665
 666    Elm_Segment_Item *it, *it_rel;
 667
 668    it = _item_new(obj, label, icon);
 669    it_rel = _item_find(obj, index);
 670    if (!it_rel)
 671      {
 672       wd->seg_ctrl = eina_list_append(wd->seg_ctrl, it);
 673      }
 674    else
 675      {
 676         if (!it) return;
 677         wd->seg_ctrl = eina_list_prepend_relative(wd->seg_ctrl, it, it_rel);
 678      }
 679    evas_object_event_callback_add(it->base, EVAS_CALLBACK_MOUSE_DOWN, _mouse_down, it);
 680    evas_object_event_callback_add(it->base, EVAS_CALLBACK_MOUSE_UP, _mouse_up, it);
 681    wd->insert_index = index;
 682    wd->id = eina_list_count(wd->seg_ctrl);
 683    _refresh_segment_ids(obj);
 684
 685    _update_list(obj);
 686    if(animate && it->segment_id && wd->ani_it == NULL)
 687      {
 688         wd->ani_it = it;
 689         evas_object_resize(it->base, 1, wd->height);
 690         wd->ani = ecore_animator_add( _animator_animate_add_cb, obj );
 691      }
 692    else
 693       _state_value_set(obj);
 694
 695    evas_object_show( it->base);
 696
 697    if(index >= wd->id-1)
 698      {
 699         evas_object_box_append(wd->box,  it->base);
 700      }
 701    else
 702      {
 703         evas_object_box_insert_at(wd->box,  it->base, index);
 704      }
 705
 706    evas_object_smart_calculate(wd->box);
 707    return;
 708 }
 709
 710 /**
 711  * Delete a segment to segmentcontrol
 712  * @param obj The SegmentControl object
 713  * @param item The Segment to be deleted
 714  * @param animate If 1 the action be animated with sliding effects default 0.
 715  *
 716  * @ingroup SegmentControl SegmentControl
 717  */
 718 EAPI void
 719 elm_segment_control_delete_segment(Evas_Object *obj, Elm_Segment_Item *item, Eina_Bool animate)
 720 {
 721    Widget_Data *wd = elm_widget_data_get(obj);
 722    if(!wd) return;
 723
 724    if(!item) return;
 725
 726    Elm_Segment_Item *it;
 727    it = _item_search(obj, item);
 728
 729    if(!it) return;
 730    wd->del_index = it->segment_id;
 731    if(animate && it->segment_id && wd->ani_it == NULL)
 732      {
 733         it->delete_me = EINA_TRUE;
 734         wd->ani_it = it;
 735         wd->ani = ecore_animator_add( _animator_animate_del_cb, obj );
 736      }
 737    else
 738      {
 739         evas_object_box_remove(wd->box, it->base);
 740         evas_object_smart_calculate(wd->box);
 741         _item_free(obj, it);
 742         _refresh_segment_ids(obj);
 743         _state_value_set(obj);
 744         _update_list(obj);
 745      }
 746    wd->id = eina_list_count(wd->seg_ctrl);
 747    return;
 748 }
 749
 750 /**
 751  * Delete a segment to segmentcontrol
 752  * @param obj The SegmentControl object
 753  * @param index The position at which segment to be deleted
 754  * @param animate If 1 the action be animated with sliding effects default 0.
 755  *
 756  * @ingroup SegmentControl SegmentControl
 757  */
 758
 759 EAPI void
 760 elm_segment_control_delete_segment_at(Evas_Object *obj,  unsigned int index, Eina_Bool animate)
 761 {
 762    Widget_Data *wd = elm_widget_data_get(obj);
 763    if(!wd) return;
 764    Elm_Segment_Item *it;
 765
 766    it = _item_find(obj, index);
 767
 768    if(!it) return;
 769
 770    wd->del_index = index;
 771    if(animate && it->segment_id)
 772      {
 773         if(wd->ani_it == NULL)
 774         {
 775            wd->ani_it = it;
 776            it->delete_me = EINA_TRUE;
 777            wd->ani = ecore_animator_add( _animator_animate_del_cb, obj );
 778         }
 779      }
 780    else
 781      {
 782         evas_object_box_remove(wd->box, it->base);
 783         evas_object_smart_calculate(wd->box);
 784         _item_free(obj, it);
 785         _refresh_segment_ids(obj);
 786         _state_value_set(obj);
 787         _update_list(obj);
 788      }
 789    wd->id = eina_list_count(wd->seg_ctrl);
 790    return;
 791 }
 792
 793 /**
 794  * Get the label of a segment of segmentcontrol
 795  * @param obj The SegmentControl object
 796  * @param index The index of the segment
 797  * @return The label
 798  *
 799  * @ingroup SegmentControl SegmentControl
 800  */
 801
 802 EAPI const char *
 803 elm_segment_control_get_segment_label_at(Evas_Object *obj, unsigned int index)
 804 {
 805    Elm_Segment_Item *it_rel;
 806    Widget_Data *wd = elm_widget_data_get(obj);
 807    if(!wd) return NULL;
 808
 809    it_rel = _item_find(obj, index);
 810
 811    if(it_rel) return it_rel->label;
 812
 813    return NULL;
 814 }
 815
 816 /**
 817  * Get the icon of a segment of segmentcontrol
 818  * @param obj The SegmentControl object
 819  * @param index The index of the segment
 820  * @return The icon object
 821  *
 822  * @ingroup SegmentControl SegmentControl
 823  */
 824
 825 EAPI Evas_Object *
 826 elm_segment_control_get_segment_icon_at(Evas_Object *obj, unsigned int index)
 827 {
 828    Elm_Segment_Item *seg_rel;
 829    Widget_Data *wd = elm_widget_data_get(obj);
 830    if(!wd) return NULL;
 831
 832    seg_rel = _item_find(obj, index);
 833
 834    if(seg_rel) return seg_rel->icon;
 835
 836    return NULL;
 837 }
 838
 839 /**
 840  * Get the currently selected segment of segmentcontrol
 841  * @param obj The SegmentControl object
 842  * @param value The current segment id
 843  * @return The selected Segment
 844  *
 845  * @ingroup SegmentControl SegmentControl
 846  */
 847
 848 EAPI Elm_Segment_Item *
 849 elm_segment_control_selected_segment_get(const Evas_Object *obj, int *value)
 850 {
 851    Widget_Data *wd = elm_widget_data_get(obj);
 852    if(!wd || !wd->seg_ctrl) return NULL;
 853
 854    Elm_Segment_Item *it;
 855    Eina_List *l;
 856
 857    EINA_LIST_FOREACH(wd->seg_ctrl, l, it)
 858      {
 859         if(it->segment_id == wd->cur_seg_id)
 860           {
 861              *value = wd->cur_seg_id;
 862              return it;
 863           }
 864      }
 865    return NULL;
 866 }
 867
 868 /**
 869  * Get the count of segments of segmentcontrol
 870  * @param obj The SegmentControl object
 871  * @return The count of Segments
 872  *
 873  * @ingroup SegmentControl SegmentControl
 874  */
 875
 876 EAPI int
 877 elm_segment_control_get_segment_count(Evas_Object *obj)
 878 {
 879    Widget_Data *wd = elm_widget_data_get(obj);
 880    if(!wd) return 0;
 881
 882    return wd->id;
 883 }
 884