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 item 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 segment items 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 _signal_segment_off(void *data);
  50 static void _theme_hook(Evas_Object *obj);
  51 static void _item_free(Evas_Object *obj, Elm_Segment_Item *it);
  52 static void _del_hook(Evas_Object *obj);
  53 static void _layout(Evas_Object *o, Evas_Object_Box_Data *priv, void *data);
  54 static void _segment_resizing(void *data);
  55 static void _object_resize(void *data, Evas *e, Evas_Object *obj, void *event_info);
  56 static void _update_list(Evas_Object *obj);
  57 static void _refresh_segment_ids(Evas_Object *obj);
  58 static void _state_value_set(Evas_Object *obj);
  59
  60 static Elm_Segment_Item* _item_new(Evas_Object *obj, const char *label, Evas_Object *icon);
  61 static Elm_Segment_Item *_item_find(Evas_Object *obj, unsigned int index);
  62
  63 static int * _animator_animate_add_cb(Evas_Object *obj);
  64 static int * _animator_animate_del_cb(Evas_Object *obj);
  65
  66 static void
  67 _on_focus_hook(void *data, Evas_Object *obj)
  68 {
  69    Widget_Data *wd = elm_widget_data_get(obj);
  70    if (!wd) return;
  71
  72    if (elm_widget_focus_get(obj))
  73      evas_object_focus_set((Evas_Object *)wd->seg_ctrl, 1);
  74    else
  75      evas_object_focus_set((Evas_Object *)wd->seg_ctrl, 0);
  76 }
  77
  78 static void
  79 _signal_segment_off(void *data)
  80 {
  81     Elm_Segment_Item *item = (Elm_Segment_Item *) data;
  82     Widget_Data *wd = elm_widget_data_get(item->obj);
  83     if (!wd) return;
  84
  85     edje_object_signal_emit(item->base, "elm,action,unfocus", "elm");
  86     edje_object_signal_emit(item->base, "elm,state,segment,off", "elm");
  87     edje_object_signal_emit(item->base, "elm,state,text,visible", "elm");
  88
  89     return;
  90 }
  91
  92 static void
  93 _signal_segment_on(void *data)
  94 {
  95    Elm_Segment_Item *item = (Elm_Segment_Item *) data;
  96    Elm_Segment_Item *it;
  97    Eina_List *l;\r
  98
  99    Widget_Data *wd = elm_widget_data_get(item->obj);
 100    if (!wd) return;
 101
 102    wd->selected = EINA_TRUE;
 103
 104  /*  if (item->long_timer)
 105      {
 106        ecore_timer_del(item->long_timer);
 107        item->long_timer = NULL;
 108      }*/
 109    //wd->longpressed = EINA_TRUE;
 110    edje_object_signal_emit(item->base, "elm,state,segment,on", "elm");
 111    edje_object_signal_emit(item->base, "elm,state,text,change", "elm");
 112
 113    if (item->segment_id == wd->cur_seg_id)
 114         return;\r
 115
 116    EINA_LIST_FOREACH(wd->seg_ctrl, l, it)
 117      {
 118         if (it->segment_id == wd->cur_seg_id)
 119           {
 120            _signal_segment_off (it);
 121              break;
 122           }
 123      }
 124    wd->cur_seg_id = item->segment_id;
 125    evas_object_smart_callback_call(item->obj, "changed", (void*)wd->cur_seg_id);
 126
 127    return;
 128 }
 129
 130 static void
 131 _mouse_up(void *data, Evas *e, Evas_Object *obj, void *event_info)
 132 {
 133    Elm_Segment_Item *item = (Elm_Segment_Item *) data;
 134    Widget_Data *wd = elm_widget_data_get(item->obj);
 135    Evas_Event_Mouse_Up * ev = event_info;
 136    Evas_Coord x, y, w, h;
 137
 138    if (!wd) return;
 139
 140    evas_object_geometry_get(obj, &x, &y, &w, &h);
 141    if(ev->output.x > x && ev->output.x < x+w && ev->output.y > y && ev->output.y < y+h && wd->selected == EINA_FALSE)
 142      {
 143         _signal_segment_on(item);
 144      }
 145    else
 146      {
 147          wd->selected = EINA_FALSE;
 148          return;
 149      }
 150
 151   // if(wd->longpressed == EINA_FALSE)
 152      {
 153        edje_object_signal_emit(item->base, "elm,action,unfocus", "elm");
 154        edje_object_signal_emit(item->base, "elm,state,text,visible", "elm");
 155      }
 156   /* if (item->long_timer)
 157      {
 158        ecore_timer_del(item->long_timer);
 159        item->long_timer = NULL;
 160      }*/
 161 }
 162
 163 static void
 164 _mouse_down(void *data, Evas *evas, Evas_Object *obj, void *event_info)
 165 {
 166    Elm_Segment_Item *item = (Elm_Segment_Item *) data;
 167    Widget_Data *wd = elm_widget_data_get(item->obj);
 168
 169    if (!wd) return;
 170    //wd->longpressed = EINA_FALSE;
 171
 172    if (item->segment_id == wd->cur_seg_id)
 173      {
 174         wd->selected = EINA_TRUE;
 175         return;
 176      }
 177
 178    edje_object_signal_emit(item->base, "elm,action,focus", "elm");
 179    edje_object_signal_emit(item->base, "elm,state,text,visible", "elm");
 180
 181    _signal_segment_on(item);
 182
 183 /*   if (item->long_timer) ecore_timer_del(item->long_timer);
 184    item->long_timer = ecore_timer_add(0.3, _signal_segment_on, item);*/
 185 }
 186
 187 static void
 188 _theme_hook(Evas_Object *obj)
 189 {
 190    _elm_theme_object_set(obj, obj, "segmented-control", "base", elm_widget_style_get(obj));
 191
 192    return;
 193 }
 194
 195 static void
 196 _item_free(Evas_Object *obj, Elm_Segment_Item *it)
 197 {
 198    Widget_Data *wd = elm_widget_data_get(obj);
 199    if (!wd) return;
 200
 201    if(wd->seg_ctrl)
 202      wd->seg_ctrl = eina_list_remove(wd->seg_ctrl, it);
 203
 204    if(it->icon) evas_object_del(it->icon);
 205    if(it->base) evas_object_del(it->base);
 206    if(it->label) eina_stringshare_del(it->label);
 207 //   if (it->long_timer) ecore_timer_del(it->long_timer);
 208
 209    if(it)
 210      free(it);
 211    it = NULL;
 212    return;
 213 }
 214
 215 static void
 216 _del_hook(Evas_Object *obj)
 217 {
 218    Widget_Data *wd = elm_widget_data_get(obj);
 219    Elm_Segment_Item *it;
 220    Eina_List *l, *clear = NULL;
 221
 222    EINA_LIST_FOREACH(wd->seg_ctrl, l, it) clear = eina_list_append(clear, it);
 223    EINA_LIST_FREE(clear, it) _item_free(obj, it);
 224
 225    if(wd) free(wd);
 226    wd = NULL;
 227
 228    return;
 229 }
 230
 231
 232 static void
 233 _layout(Evas_Object *o, Evas_Object_Box_Data *priv, void *data)
 234 {
 235    Widget_Data *wd = data;
 236    if (!wd) return;
 237    _els_box_layout(o, priv, 1, 0); /* making box layout non homogenous */
 238
 239    return;
 240 }
 241
 242 static void
 243 _segment_resizing(void *data)
 244 {
 245    Widget_Data *wd = elm_widget_data_get((Evas_Object *)data);
 246    if (!wd) return;
 247    Evas_Coord w = 0, h = 0;
 248
 249    evas_object_geometry_get(wd->base, NULL, NULL, &w, &h);
 250    wd->item_width = wd->width = w;
 251    wd->height = h;
 252    _state_value_set((Evas_Object *)data);
 253 }
 254
 255 static void
 256 _object_resize(void *data, Evas *e, Evas_Object *obj, void *event_info)
 257 {
 258    Widget_Data *wd;
 259    if(!data) return;
 260    wd = elm_widget_data_get((Evas_Object *)data);
 261    if(!wd) return;
 262
 263    ecore_job_add(_segment_resizing, (Evas_Object *)data);
 264 }
 265
 266 static Elm_Segment_Item*
 267 _item_new(Evas_Object *obj, const char *label, Evas_Object *icon)
 268 {
 269    Elm_Segment_Item *it;
 270    Evas_Coord mw, mh;
 271    Widget_Data *wd = elm_widget_data_get(obj);
 272    if (!wd) return NULL;
 273
 274    it = calloc(1, sizeof(   Elm_Segment_Item));
 275    if (!it) return NULL;
 276
 277    if(obj) it->obj = obj;
 278    it->delete_me = EINA_FALSE;
 279    it->segment_id = wd->id;
 280
 281    it->base = edje_object_add(evas_object_evas_get(obj));
 282    _elm_theme_object_set(obj, it->base, "segment", "base", elm_object_style_get(it->base));
 283
 284    if (it->label) eina_stringshare_del(it->label);
 285    if (label)
 286      {
 287         it->label = eina_stringshare_add(label);
 288      }
 289    else
 290      {
 291          it->label = NULL;
 292      }
 293
 294    if ((it->icon != icon) && (it->icon))
 295       elm_widget_sub_object_del(obj, it->icon);
 296    it->icon = icon;
 297    if (icon)
 298      {
 299         elm_widget_sub_object_add(obj, icon);
 300         Evas_Coord minw = -1, minh = -1, maxw = -1, maxh = -1;
 301         elm_coords_finger_size_adjust(1, &minw, 1, &minh);
 302         elm_coords_finger_size_adjust(1, &minw, 1, &minh);
 303
 304         evas_object_size_hint_weight_set(it->base, 1.0, -1.0);
 305         evas_object_size_hint_align_set(it->base, 1.0, -1.0);
 306         evas_object_size_hint_min_set(it->base, -1, -1);
 307         evas_object_size_hint_max_set(it->base, maxw, maxh);
 308      }
 309
 310    edje_object_size_min_restricted_calc(obj, &mw, &mh, 0, 0);
 311    evas_object_size_hint_weight_set(obj, 1.0, 1.0);
 312    evas_object_size_hint_align_set(obj, -1.0, -1.0);
 313
 314    return it;
 315 }
 316
 317
 318 static void
 319 _update_list(Evas_Object *obj)
 320 {
 321    Elm_Segment_Item *it;
 322    Eina_List *l;
 323    int i = 0;
 324
 325    Widget_Data *wd = elm_widget_data_get(obj);
 326    if (!wd) return;
 327
 328    wd->count = eina_list_count(wd->seg_ctrl);
 329    if(wd->count == 1)
 330      {
 331         it = _item_find(obj, 0);
 332         _elm_theme_object_set(obj, it->base, "segment", "base", "single");\r
 333         edje_object_signal_emit(it->base, "elm,state,segment,on", "elm");
 334         edje_object_signal_emit(it->base, "elm,state,text,visible", "elm");
 335         edje_object_signal_emit(it->base, "elm,state,text,change", "elm");
 336         edje_object_message_signal_process(it->base);
 337
 338         edje_object_part_text_set(it->base, "elm.text", it->label);
 339
 340         edje_object_part_swallow(it->base, "elm.swallow.content", it->icon);
 341         edje_object_signal_emit(it->base, "elm,state,icon,visible", "elm");
 342         return;
 343      }
 344
 345    EINA_LIST_FOREACH(wd->seg_ctrl, l, it)
 346      {
 347         if(i==0)
 348           {
 349              _elm_theme_object_set(obj, it->base, "segment", "base", "first");
 350           }
 351         else if(i==wd->count-1)
 352           {
 353              _elm_theme_object_set(obj, it->base, "segment", "base", "last");
 354           }
 355         else
 356           {
 357              _elm_theme_object_set(obj, it->base, "segment", "base", "default");
 358           }
 359
 360         edje_object_signal_emit(it->base, "elm,state,text,visible", "elm");
 361         edje_object_message_signal_process(it->base);
 362
 363         edje_object_part_text_set(it->base, "elm.text", it->label);
 364
 365         edje_object_part_swallow(it->base, "elm.swallow.content", it->icon);
 366         edje_object_signal_emit(it->base, "elm,state,icon,visible", "elm");
 367
 368         i++;
 369      }
 370 }
 371
 372
 373 static void
 374 _refresh_segment_ids(Evas_Object *obj)
 375 {
 376    Elm_Segment_Item *it;
 377    Eina_List *l;
 378    int i = 0;
 379    Widget_Data *wd = elm_widget_data_get(obj);
 380    if (!wd) return;
 381
 382    if (wd->insert_index && wd->cur_seg_id >= wd->insert_index)
 383      {
 384         ++wd->cur_seg_id;
 385         wd->insert_index = 0;
 386      }
 387    if (wd->del_index)
 388      {
 389         if (wd->cur_seg_id >= wd->del_index)
 390            --wd->cur_seg_id;
 391            wd->del_index =0;
 392      }
 393
 394    EINA_LIST_FOREACH(wd->seg_ctrl, l, it)
 395      {
 396         it->segment_id = i;
 397         i++;
 398      }
 399 }
 400
 401 static void
 402 _state_value_set(Evas_Object *obj)
 403 {
 404    Elm_Segment_Item *it;
 405    Eina_List *l;
 406    Evas_Coord mw, mh, x, y;
 407    int w1=0, w2, i=0;
 408    unsigned int count ;
 409    Widget_Data *wd = elm_widget_data_get(obj);
 410    if (!wd) return;
 411
 412    count = eina_list_count(wd->seg_ctrl);
 413    if (count > 0)
 414      wd->item_width = wd->width/count;
 415    if (wd->ani_it)
 416      {
 417         evas_object_geometry_get(wd->ani_it->base, &x, &y, &w1, NULL);
 418         if (wd->ani_it->delete_me)
 419           {
 420              w1-=(wd->item_width/15);
 421              if( w1< 0) w1 = 0;
 422           }
 423         else
 424         {
 425            w1+=(wd->item_width/15);
 426            if( w1 > wd->item_width )
 427               w1 = wd->item_width;
 428         }
 429         w2 = (wd->width-w1)/(count -1);
 430      }
 431    else
 432       w2 = wd->item_width;
 433
 434    EINA_LIST_FOREACH(wd->seg_ctrl, l, it)
 435     {
 436        edje_object_size_min_restricted_calc(it->base, &mw, &mh, 0, 0);
 437        evas_object_size_hint_weight_set(it->base, 1.0, 1.0);
 438        evas_object_size_hint_align_set(it->base, -1.0, -1.0);
 439
 440        if(wd->ani_it  && it == wd->ani_it)
 441          {
 442             evas_object_resize(it->base, w1, wd->height);
 443             evas_object_size_hint_min_set(it->base, w1, wd->height);
 444             evas_object_size_hint_max_set(it->base, w1, wd->height);
 445          }
 446        else
 447          {
 448             evas_object_resize(it->base, w2, wd->height);
 449             evas_object_size_hint_min_set(it->base, w2, wd->height);
 450             evas_object_size_hint_max_set(it->base, w2, wd->height);
 451          }
 452        ++i;
 453     }
 454
 455     return;
 456 }
 457
 458
 459 static int *
 460 _animator_animate_add_cb(Evas_Object *obj)
 461 {
 462    int w;
 463    Widget_Data *wd = elm_widget_data_get(obj);
 464    if (!wd) return 0;
 465
 466    evas_object_geometry_get(wd->ani_it->base, NULL, NULL, &w, NULL);
 467    if( w <  wd->item_width )
 468      {
 469          _state_value_set(obj);
 470          evas_object_geometry_get(wd->ani_it->base, NULL, NULL, &w, NULL);
 471          return ECORE_CALLBACK_RENEW;
 472      }
 473    else
 474      {
 475         ecore_animator_del(wd->ani);
 476         wd->ani = NULL;
 477         wd->ani_it = NULL;
 478         return ECORE_CALLBACK_CANCEL;
 479      }
 480 }
 481
 482
 483 static int *
 484 _animator_animate_del_cb(Evas_Object *obj)
 485 {
 486    int w;
 487    Widget_Data *wd = elm_widget_data_get(obj);
 488    if (!wd) return 0;\r
 489
 490    evas_object_geometry_get(wd->ani_it->base, NULL, NULL, &w, NULL);
 491    if( w >  0 )
 492      {
 493         _state_value_set(obj);
 494         evas_object_geometry_get(wd->ani_it->base, NULL, NULL, &w, NULL);
 495         return ECORE_CALLBACK_RENEW;
 496      }
 497    else
 498      {
 499         _item_free(obj, wd->ani_it );
 500         _refresh_segment_ids(obj);
 501         ecore_animator_del(wd->ani);
 502         wd->ani = NULL;
 503         wd->ani_it = NULL;
 504         _update_list(obj);
 505         wd->id = eina_list_count(wd->seg_ctrl);
 506         return ECORE_CALLBACK_CANCEL;
 507      }
 508 }
 509
 510 static Elm_Segment_Item *
 511 _item_find(Evas_Object *obj, unsigned int index)
 512 {
 513    Elm_Segment_Item *it;
 514    Eina_List *l;
 515    int i = 0;
 516    Widget_Data *wd = elm_widget_data_get(obj);
 517    if (!wd) return NULL;
 518
 519    EINA_LIST_FOREACH(wd->seg_ctrl, l, it)
 520      {
 521         if (i == index) {
 522            return it;
 523         }
 524         i++;
 525      }
 526      return NULL;
 527 }
 528
 529
 530 static Elm_Segment_Item *
 531 _item_search(Evas_Object *obj, Elm_Segment_Item *item)
 532 {
 533    Elm_Segment_Item *it;
 534    Eina_List *l;
 535    Widget_Data *wd = elm_widget_data_get(obj);
 536    if (!wd)
 537    return NULL;
 538
 539    EINA_LIST_FOREACH(wd->seg_ctrl, l, it)
 540      {
 541         if (it == item) {
 542            return it;
 543         }
 544      }
 545    return NULL;
 546 }
 547
 548
 549 /**
 550  * Add a new segmentcontrol to the parent
 551  * @param parent The parent object
 552  * @return The new object or NULL if it cannot be created
 553  *
 554  * @ingroup SegmentControl SegmentControl
 555  */
 556 EAPI Evas_Object *
 557 elm_segment_control_add(Evas_Object *parent)
 558 {
 559    Evas_Object *obj;
 560    Evas *e;
 561    Widget_Data *wd;
 562
 563    wd = ELM_NEW(Widget_Data);
 564    e = evas_object_evas_get(parent);
 565    obj = elm_widget_add(e);
 566    elm_widget_type_set(obj, "segmented-control");
 567    elm_widget_sub_object_add(parent, obj);
 568    elm_widget_on_focus_hook_set( obj, _on_focus_hook, NULL );
 569    elm_widget_data_set(obj, wd);
 570    elm_widget_del_hook_set(obj, _del_hook);
 571    elm_widget_theme_hook_set(obj, _theme_hook);
 572
 573    wd->base = edje_object_add(e);
 574    _elm_theme_object_set(obj, wd->base, "segmented-control", "base", "default");
 575    elm_widget_resize_object_set(obj, wd->base);
 576    wd->box = evas_object_box_add(e);
 577    evas_object_box_layout_set(wd->box, _layout, wd, NULL);
 578    elm_widget_sub_object_add(obj, wd->box);
 579    edje_object_part_swallow(wd->base, "elm.swallow.content", wd->box);
 580    evas_object_show(wd->box);
 581
 582    evas_object_event_callback_add(obj, EVAS_CALLBACK_RESIZE, _object_resize, obj);
 583    wd->id = 0;
 584    wd->del_index = 0;
 585    wd->insert_index = 0;
 586    wd->cur_seg_id = -1;
 587    wd->selected = EINA_FALSE;
 588
 589    return obj;
 590 }
 591
 592 /**
 593  * Add a new segment item to segmentcontrol
 594  * @param obj The SegmentControl object
 595  * @param icon The icon object for added segment item
 596  * @param label The label for added segment item
 597  * @param animate If 1 the action be animated with sliding effects default 0.
 598  * @return The new segment item or NULL if it cannot be created
 599  *
 600  * @ingroup SegmentControl SegmentControl
 601  */
 602
 603 EAPI Elm_Segment_Item *
 604 elm_segment_control_item_add(Evas_Object *obj, Evas_Object *icon, const char *label, Eina_Bool animate)
 605 {
 606    Elm_Segment_Item *it;
 607    Widget_Data *wd = elm_widget_data_get(obj);
 608    if(!wd) return NULL;
 609
 610    it = _item_new(obj, label, icon);
 611    if(!it) return NULL;
 612
 613    wd->seg_ctrl = eina_list_append(wd->seg_ctrl, it);
 614    wd->id = eina_list_count(wd->seg_ctrl);
 615    _update_list(obj);
 616    evas_object_event_callback_add(it->base, EVAS_CALLBACK_MOUSE_DOWN, _mouse_down, it);
 617    evas_object_event_callback_add(it->base, EVAS_CALLBACK_MOUSE_UP, _mouse_up, it);
 618    wd->insert_index = 0;
 619    wd->del_index = 0;
 620    _refresh_segment_ids(obj);
 621
 622    if(animate && it->segment_id && wd->ani_it == NULL)
 623      {
 624         evas_object_resize(it->base, 1, wd->height);
 625         wd->ani_it = it;
 626         wd->ani = ecore_animator_add( _animator_animate_add_cb, obj );
 627      }
 628    else
 629       _state_value_set(obj);
 630    evas_object_show( it->base);
 631
 632    evas_object_box_append(wd->box, it->base);
 633    evas_object_smart_calculate(wd->box);
 634
 635    return it;
 636 }
 637
 638 /**
 639  * Add a new segment item to segmentcontrol
 640  * @param obj The SegmentControl object
 641  * @param icon The icon object for added segment item
 642  * @param label The label for added segment item
 643  * @param animate If 1 the action be animated with sliding effects default 0.
 644  * @return The new segment item or NULL if it cannot be created
 645  *
 646  * @ingroup SegmentControl SegmentControl
 647  */
 648
 649 EAPI Elm_Segment_Item *
 650 elm_segment_control_add_segment(Evas_Object *obj, Evas_Object *icon, const char *label, Eina_Bool animate)
 651 {
 652    EAPI Elm_Segment_Item * it;
 653    it = elm_segment_control_item_add(obj, icon, label, animate);
 654 \r
 655     return it;\r
 656 }
 657
 658 /**
 659  * Insert a new segment item to segmentcontrol
 660  * @param obj The SegmentControl object
 661  * @param icon The icon object for added segment item
 662  * @param label The label for added segment item
 663  * @param index The position at which segment item to be inserted
 664  * @param animate If 1 the action be animated with sliding effects default 0.
 665  * @return The new segment item or NULL if it cannot be created
 666  *
 667  * @ingroup SegmentControl SegmentControl
 668  */
 669
 670 EAPI Elm_Segment_Item *
 671 elm_segment_control_item_insert_at(Evas_Object *obj, Evas_Object *icon, const char *label, unsigned int index, Eina_Bool animate)
 672 {
 673    Elm_Segment_Item *it, *it_rel;
 674    Widget_Data *wd = elm_widget_data_get(obj);
 675    if(!wd) return;
 676
 677    it = _item_new(obj, label, icon);
 678    it_rel = _item_find(obj, index);
 679    if (!it_rel)
 680      {
 681       wd->seg_ctrl = eina_list_append(wd->seg_ctrl, it);
 682      }
 683    else
 684      {
 685         if (!it) return;
 686         wd->seg_ctrl = eina_list_prepend_relative(wd->seg_ctrl, it, it_rel);
 687      }
 688    evas_object_event_callback_add(it->base, EVAS_CALLBACK_MOUSE_DOWN, _mouse_down, it);
 689    evas_object_event_callback_add(it->base, EVAS_CALLBACK_MOUSE_UP, _mouse_up, it);
 690    wd->insert_index = index;
 691    wd->id = eina_list_count(wd->seg_ctrl);
 692    _refresh_segment_ids(obj);
 693
 694    _update_list(obj);
 695    if(animate && it->segment_id && wd->ani_it == NULL)
 696      {
 697         wd->ani_it = it;
 698         evas_object_resize(it->base, 1, wd->height);
 699         wd->ani = ecore_animator_add( _animator_animate_add_cb, obj );
 700      }
 701    else
 702       _state_value_set(obj);
 703
 704    evas_object_show( it->base);
 705
 706    if(index >= wd->id-1)
 707      {
 708         evas_object_box_append(wd->box,  it->base);
 709      }
 710    else
 711      {
 712         evas_object_box_insert_at(wd->box,  it->base, index);
 713      }
 714
 715    evas_object_smart_calculate(wd->box);
 716
 717    return it ;
 718 }
 719
 720 /**
 721  * Insert a new segment item to segmentcontrol
 722  * @param obj The SegmentControl object
 723  * @param icon The icon object for added segment item
 724  * @param label The label for added segment item
 725  * @param index The position at which segment item to be inserted
 726  * @param animate If 1 the action be animated with sliding effects default 0.
 727  *
 728  * @ingroup SegmentControl SegmentControl
 729  */
 730
 731 EAPI void
 732 elm_segment_control_insert_segment_at(Evas_Object *obj, Evas_Object *icon, const char *label, unsigned int index, Eina_Bool animate)
 733 {
 734    Elm_Segment_Item *it;
 735    it = elm_segment_control_item_insert_at(obj, icon, label, index, animate);
 736
 737    return;
 738 }
 739
 740 /**
 741  * Delete a segment item to segmentcontrol
 742  * @param obj The SegmentControl object
 743  * @param item The Segment item to be deleted
 744  * @param animate If 1 the action be animated with sliding effects default 0.
 745  *
 746  * @ingroup SegmentControl SegmentControl
 747  */
 748 EAPI void
 749 elm_segment_control_item_del(Evas_Object *obj, Elm_Segment_Item *item, Eina_Bool animate)
 750 {
 751    Elm_Segment_Item *it;
 752    Widget_Data *wd = elm_widget_data_get(obj);
 753    if(!wd) return;
 754
 755    if(!item) return;
 756
 757    it = _item_search(obj, item);
 758    if(!it) return;
 759
 760    wd->del_index = it->segment_id;
 761    if(animate && it->segment_id && wd->ani_it == NULL)
 762      {
 763         it->delete_me = EINA_TRUE;
 764         wd->ani_it = it;
 765         wd->ani = ecore_animator_add( _animator_animate_del_cb, obj );
 766      }
 767    else
 768      {
 769         evas_object_box_remove(wd->box, it->base);
 770         evas_object_smart_calculate(wd->box);
 771         _item_free(obj, it);
 772         _refresh_segment_ids(obj);
 773         _state_value_set(obj);
 774         _update_list(obj);
 775      }
 776    wd->id = eina_list_count(wd->seg_ctrl);
 777    return;
 778 }
 779
 780 /**
 781  * Delete a segment item to segmentcontrol
 782  * @param obj The SegmentControl object
 783  * @param item The Segment item to be deleted
 784  * @param animate If 1 the action be animated with sliding effects default 0.
 785  *
 786  * @ingroup SegmentControl SegmentControl
 787  */
 788
 789 EAPI void
 790 elm_segment_control_delete_segment(Evas_Object *obj, Elm_Segment_Item *item, Eina_Bool animate)
 791 {
 792    elm_segment_control_item_del(obj, item, animate);
 793
 794    return;
 795 }
 796
 797 /**
 798  * Delete a segment item to segmentcontrol
 799  * @param obj The SegmentControl object
 800  * @param index The position at which segment item to be deleted
 801  * @param animate If 1 the action be animated with sliding effects default 0.
 802  *
 803  * @ingroup SegmentControl SegmentControl
 804  */
 805
 806 EAPI void
 807 elm_segment_control_item_del_at(Evas_Object *obj,  unsigned int index, Eina_Bool animate)
 808 {
 809    Elm_Segment_Item *it;
 810    Widget_Data *wd = elm_widget_data_get(obj);
 811    if(!wd) return;
 812
 813    it = _item_find(obj, index);
 814
 815    if(!it) return;
 816
 817    wd->del_index = index;
 818    if(animate && it->segment_id)
 819      {
 820         if(wd->ani_it == NULL)
 821         {
 822            wd->ani_it = it;
 823            it->delete_me = EINA_TRUE;
 824            wd->ani = ecore_animator_add( _animator_animate_del_cb, obj );
 825         }
 826      }
 827    else
 828      {
 829         evas_object_box_remove(wd->box, it->base);
 830         evas_object_smart_calculate(wd->box);
 831         _item_free(obj, it);
 832         _refresh_segment_ids(obj);
 833         _state_value_set(obj);
 834         _update_list(obj);
 835      }
 836    wd->id = eina_list_count(wd->seg_ctrl);
 837    return;
 838 }
 839
 840 /**
 841  * Delete a segment item to segmentcontrol
 842  * @param obj The SegmentControl object
 843  * @param index The position at which segment item to be deleted
 844  * @param animate If 1 the action be animated with sliding effects default 0.
 845  *
 846  * @ingroup SegmentControl SegmentControl
 847  */
 848
 849 EAPI void
 850 elm_segment_control_delete_segment_at(Evas_Object *obj,  unsigned int index, Eina_Bool animate)
 851 {
 852    elm_segment_control_item_del_at( obj, index, animate);
 853
 854    return;
 855 }
 856
 857 /**
 858  * Get the label of a segment item of segmentcontrol
 859  * @param obj The SegmentControl object
 860  * @param index The index of the segment item
 861  * @return The label of the segment item
 862  *
 863  * @ingroup SegmentControl SegmentControl
 864  */
 865
 866 EAPI const char *
 867 elm_segment_control_item_label_get(Evas_Object *obj, unsigned int index)
 868 {
 869    Elm_Segment_Item *it_rel;
 870    Widget_Data *wd = elm_widget_data_get(obj);
 871    if(!wd) return NULL;
 872
 873    it_rel = _item_find(obj, index);
 874
 875    if(it_rel) return it_rel->label;
 876
 877    return NULL;
 878 }
 879
 880 /**
 881  * Get the label of a segment item of segmentcontrol
 882  * @param obj The SegmentControl object
 883  * @param index The index of the segment item
 884  * @return The label of the segment item
 885  *
 886  * @ingroup SegmentControl SegmentControl
 887  */
 888
 889 EAPI const char *
 890 elm_segment_control_get_segment_label_at(Evas_Object *obj, unsigned int index)
 891 {
 892    char *label;
 893    label = elm_segment_control_item_label_get( obj, index);
 894
 895    return label;
 896 }
 897
 898 /**
 899  * Get the icon of a segment item of segmentcontrol
 900  * @param obj The SegmentControl object
 901  * @param index The index of the segment item
 902  * @return The icon object or NULL if it is not found.
 903  *
 904  * @ingroup SegmentControl SegmentControl
 905  */
 906
 907 EAPI Evas_Object *
 908 elm_segment_control_item_icon_get(Evas_Object *obj, unsigned int index)
 909 {
 910    Elm_Segment_Item *seg_rel;
 911    Widget_Data *wd = elm_widget_data_get(obj);
 912    if(!wd) return NULL;
 913
 914    seg_rel = _item_find(obj, index);
 915
 916    if(seg_rel) return seg_rel->icon;
 917
 918    return NULL;
 919 }
 920
 921 /**
 922  * Get the icon of a segment item of segmentcontrol
 923  * @param obj The SegmentControl object
 924  * @param index The index of the segment item
 925  * @return The icon object or NULL if it is not found.
 926  *
 927  * @ingroup SegmentControl SegmentControl
 928  */
 929
 930 EAPI Evas_Object *
 931 elm_segment_control_get_segment_icon_at(Evas_Object *obj, unsigned int index)
 932 {
 933    Evas_Object *icon;
 934    icon = elm_segment_control_item_icon_get( obj, index);
 935
 936    return icon;
 937 }
 938
 939 /**
 940  * Get the currently selected segment item of segmentcontrol
 941  * @param obj The SegmentControl object
 942  * @return The selected Segment item
 943  *
 944  * @ingroup SegmentControl SegmentControl
 945  */
 946
 947 EAPI Elm_Segment_Item *
 948 elm_segment_control_item_selected_get(const Evas_Object *obj)
 949 {
 950    Elm_Segment_Item *it;
 951    Eina_List *l;
 952    Widget_Data *wd = elm_widget_data_get(obj);
 953    if(!wd || !wd->seg_ctrl) return NULL;
 954
 955    EINA_LIST_FOREACH(wd->seg_ctrl, l, it)
 956      {
 957        if(it->segment_id == wd->cur_seg_id)
 958        return it;
 959       }
 960     return NULL;
 961  }
 962
 963 /**
 964  * Get the currently selected segment item of segmentcontrol
 965  * @param obj The SegmentControl object
 966  * @param value The current segment item id
 967  * @return The selected Segment item
 968  *
 969  * @ingroup SegmentControl SegmentControl
 970  */
 971
 972 EAPI Elm_Segment_Item *
 973 elm_segment_control_selected_segment_get(const Evas_Object *obj, int *value)
 974 {
 975    Elm_Segment_Item *it;
 976    it = elm_segment_control_item_selected_get( obj);
 977    *value = it->segment_id;
 978    \r
 979     return it;
 980  }
 981
 982 /**
 983  * Get the count of segments of segmentcontrol
 984  * @param obj The SegmentControl object
 985  * @return The count of Segment items
 986  *
 987  * @ingroup SegmentControl SegmentControl
 988  */
 989
 990 EAPI int
 991 elm_segment_control_item_count_get(Evas_Object *obj)
 992 {
 993    Widget_Data *wd = elm_widget_data_get(obj);
 994    if(!wd) return 0;
 995
 996    return wd->id;
 997 }
 998
 999 /**
1000  * Get the count of segments of segmentcontrol
1001  * @param obj The SegmentControl object
1002  * @return The count of Segment items
1003  *
1004  * @ingroup SegmentControl SegmentControl
1005  */
1006
1007 EAPI int
1008 elm_segment_control_get_segment_count(Evas_Object *obj)
1009 {
1010    int id;
1011    id = elm_segment_control_item_count_get( obj);
1012
1013    return id;
1014 }
1015
1016 /**
1017  * Get the base object of segment item in segmentcontrol
1018  * @param obj The Segment item
1019  * @return obj The base object of the segment item
1020  *
1021  * @ingroup SegmentControl SegmentControl
1022  */
1023
1024 EAPI Evas_Object *
1025 elm_segment_control_item_object_get(Elm_Segment_Item *it)
1026 {
1027    if (!it) return NULL;
1028
1029    return it->base;
1030 }
1031
1032 /**
1033  * Select/unselect a particular segment item of segmentcontrol
1034  * @param item The Segment item that is to be selected or unselected.
1035  * @param select If 1 the segment item is selected and if 0 it will be unselected.
1036  *
1037  * @ingroup SegmentControl SegmentControl
1038  */
1039
1040 EAPI void
1041 elm_segment_control_item_selected_set( Elm_Segment_Item *item, Eina_Bool select)
1042 {
1043    Widget_Data *wd = elm_widget_data_get(item->obj);
1044    if(!wd) return NULL;
1045
1046    if(select)
1047      {
1048       if(item->segment_id == wd->cur_seg_id)
1049           return;
1050
1051       edje_object_signal_emit(item->base, "elm,action,focus", "elm");
1052       edje_object_signal_emit(item->base, "elm,state,text,visible", "elm");
1053
1054       _signal_segment_on(item);
1055
1056       }
1057    else if(item->segment_id == wd->cur_seg_id)
1058       {
1059        wd->selected = EINA_FALSE;
1060        wd->cur_seg_id = -1;
1061        _signal_segment_off(item);
1062       }
1063
1064    return;
1065
1066 }
1067
1068 /**
1069  * Get a particular indexed segment item of segmentcontrol
1070  * @param obj The Segment control object.
1071  * @param index The index of the segment item.
1072  * @return The corresponding Segment item.
1073  *
1074  * @ingroup SegmentControl SegmentControl
1075  */
1076
1077 EAPI Elm_Segment_Item *
1078 elm_segment_control_item_get_at(Evas_Object *obj, unsigned int index)
1079 {
1080    Elm_Segment_Item *it;
1081    it = _item_find(obj, index);
1082
1083    return it;
1084 }
1085