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