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    Elm_Segment_Item *ani_it;
  21    Ecore_Animator *ani;
  22    int width, height;
  23    int id;
  24    int item_width;
  25    int cur_fontsize;
  26    int max_height, w_pad, h_pad;
  27    unsigned int count;
  28    int insert_index;
  29    int del_index;
  30    int cur_seg_id;
  31    double scale_factor;
  32    unsigned int def_color[4];
  33    unsigned int press_color[4];
  34    unsigned int sel_color[4];
  35 };
  36
  37 struct _Elm_Segment_Item
  38 {
  39    Evas_Object *obj;
  40    Evas_Object *base;
  41    Evas_Object *icon;
  42    Evas_Object *label_wd;
  43    const char *label;
  44    int segment_id;
  45    Eina_Bool delete_me : 1;
  46    Eina_Bool sel : 1;
  47 };
  48
  49 #define MAXTOKENS 5
  50
  51 char **_split(const char *string, char *delim);
  52 static void _mouse_down(void *data, Evas *evas, Evas_Object *obj, void *event_info);
  53 static void _mouse_up(void *data, Evas *e, Evas_Object *obj, void *event_info);
  54 static void _signal_segment_on(void *data);
  55 static void _signal_segment_off(void *data);
  56 static void _theme_hook(Evas_Object *obj);
  57 static void _item_free(Evas_Object *obj, Elm_Segment_Item *it);
  58 static void _del_hook(Evas_Object *obj);
  59 static void _layout(Evas_Object *o, Evas_Object_Box_Data *priv, void *data);
  60 static void _segment_resizing(void *data, Evas *e, Evas_Object *obj, void *event_info);
  61 static void _segment_item_resizing(void *data, Evas *e, Evas_Object *obj, void *event_info);
  62 #if 0
  63 static void _object_resize(void *data, Evas *e, Evas_Object *obj, void *event_info);
  64 #endif
  65 static void _update_list(Evas_Object *obj);
  66 static void _refresh_segment_ids(Evas_Object *obj);
  67 static void _state_value_set(Evas_Object *obj);
  68 static void _color_value_get(Evas_Object *obj);
  69
  70 static Elm_Segment_Item* _item_new(Evas_Object *obj, const char *label, Evas_Object *icon);
  71 static Elm_Segment_Item *_item_find(Evas_Object *obj, unsigned int index);
  72
  73 static Eina_Bool _animator_animate_add_cb(void *data);
  74 static Eina_Bool _animator_animate_del_cb(void *data);
  75
  76 static void
  77 _signal_segment_off(void *data)
  78 {
  79     Elm_Segment_Item *item = (Elm_Segment_Item *) data;
  80     Widget_Data *wd = elm_widget_data_get(item->obj);
  81     if (!wd) return;
  82
  83 //    item->sel = EINA_FALSE;
  84     edje_object_signal_emit(item->base, "elm,action,unfocus", "elm");
  85     edje_object_signal_emit(item->base, "elm,state,segment,release", "elm");
  86     if(!item->label_wd && item->label)
  87       edje_object_signal_emit(item->base, "elm,state,text,visible", "elm");
  88     if(item->label_wd)
  89       elm_label_text_color_set(item->label_wd, wd->def_color[0], wd->def_color[1], wd->def_color[2], wd->def_color[3]);
  90
  91     return;
  92 }
  93
  94
  95 static void
  96 _signal_segment_on(void *data)
  97 {
  98    Elm_Segment_Item *item = (Elm_Segment_Item *) data;
  99    Elm_Segment_Item *it;
 100    Eina_List *l;
 101
 102    Widget_Data *wd = elm_widget_data_get(item->obj);
 103    if (!wd) return;
 104
 105 //   item->sel = EINA_TRUE;
 106    if (item->segment_id == wd->cur_seg_id) return;
 107
 108    EINA_LIST_FOREACH(wd->seg_ctrl, l, it)
 109      {
 110         if (it->segment_id == wd->cur_seg_id)
 111           {
 112              _signal_segment_off (it);
 113           }
 114      }
 115    edje_object_signal_emit(item->base, "elm,action,focus", "elm");
 116    if(!item->label_wd)
 117      edje_object_signal_emit(item->base, "elm,state,text,change", "elm");
 118    if(item->label_wd)
 119      elm_label_text_color_set(item->label_wd, wd->sel_color[0],wd->sel_color[1], wd->sel_color[1], wd->sel_color[3]);
 120
 121    wd->cur_seg_id = item->segment_id;
 122    evas_object_smart_callback_call(item->obj, "changed", (void*)wd->cur_seg_id);
 123
 124    return;
 125 }
 126
 127 static void
 128 _mouse_up(void *data, Evas *e, Evas_Object *obj, void *event_info)
 129 {
 130    Elm_Segment_Item *item = (Elm_Segment_Item *) data;
 131    Widget_Data *wd = elm_widget_data_get(item->obj);
 132    if (!wd) return;
 133    if (item->segment_id == wd->cur_seg_id)
 134      {
 135         if(!item->label_wd)
 136           edje_object_signal_emit(item->base, "elm,state,text,change", "elm");
 137 //        item->sel = EINA_TRUE;
 138         return;
 139      }
 140     _signal_segment_on((void*)item);
 141
 142     return;
 143 }
 144
 145 static void
 146 _mouse_down(void *data, Evas *evas, Evas_Object *obj, void *event_info)
 147 {
 148    Elm_Segment_Item *item = (Elm_Segment_Item *) data;
 149    Widget_Data *wd = elm_widget_data_get(item->obj);
 150
 151    if (!wd) return;
 152
 153    if(!item->label_wd && wd->cur_seg_id != item->segment_id)
 154      {
 155         edje_object_signal_emit(item->base, "elm,state,text,pressed", "elm");
 156      }
 157    if(item->label_wd && wd->cur_seg_id != item->segment_id)
 158      elm_label_text_color_set(item->label_wd, wd->press_color[0], wd->press_color[1], wd->press_color[2], wd->press_color[3]);
 159
 160    edje_object_signal_emit(item->base, "elm,state,segment,press", "elm");
 161    return;
 162 }
 163
 164 static void
 165 _theme_hook(Evas_Object *obj)
 166 {
 167    _elm_theme_object_set(obj, obj, "segmented-control", "base", elm_widget_style_get(obj));
 168
 169    return;
 170 }
 171
 172 static void
 173 _item_free(Evas_Object *obj, Elm_Segment_Item *it)
 174 {
 175    Widget_Data *wd = elm_widget_data_get(obj);
 176    if (!wd) return;
 177
 178    if(wd->seg_ctrl)
 179      wd->seg_ctrl = eina_list_remove(wd->seg_ctrl, it);
 180
 181    if(it->icon) evas_object_del(it->icon);
 182    if(it->label_wd)
 183      {
 184         evas_object_del(it->label_wd);
 185         it->label_wd = NULL;
 186         if (edje_object_part_swallow_get(it->base, "elm.swallow.label.content") == NULL)
 187           {
 188              edje_object_part_unswallow(it->base, it->label_wd);
 189           }
 190      }
 191    if(it->base) evas_object_del(it->base);
 192    if(it->label) eina_stringshare_del(it->label);
 193
 194    if(it)
 195      free(it);
 196    it = NULL;
 197
 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, Evas *e, Evas_Object *obj, void *event_info)
 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
 239    _state_value_set((Evas_Object *)data);
 240 }
 241 #if 0
 242 static void
 243 _object_resize(void *data, Evas *e, Evas_Object *obj, void *event_info)
 244 {
 245    Widget_Data *wd;
 246    if(!data) return;
 247    wd = elm_widget_data_get((Evas_Object *)data);
 248    if(!wd) return;
 249
 250    ecore_job_add(_segment_resizing, (Evas_Object *)data);
 251 }
 252 #endif
 253
 254 static void
 255 _segment_item_resizing(void *data, Evas *e, Evas_Object *obj, void *event_info)
 256 {
 257    Widget_Data *wd;
 258    Elm_Segment_Item *it = (Elm_Segment_Item *)data;
 259    wd = elm_widget_data_get(it->obj);
 260
 261    if(!wd) return;
 262    Evas_Coord w = 0, h = 0;
 263    _update_list(it->obj);
 264
 265    evas_object_geometry_get(it->base, NULL, NULL, &w, &h);
 266
 267    if(wd->max_height == 1) wd->max_height = h;
 268
 269    if(it->label_wd)
 270      {
 271         elm_label_wrap_width_set(it->label_wd, w-wd->w_pad);
 272         elm_label_wrap_height_set(it->label_wd, wd->max_height-wd->h_pad);
 273
 274         if (edje_object_part_swallow_get(it->base, "elm.swallow.label.content") == NULL)
 275           {
 276              edje_object_part_unswallow(it->base, it->label_wd);
 277           }
 278         edje_object_part_swallow(it->base, "elm.swallow.label.content", it->label_wd);
 279         edje_object_signal_emit(it->base, "elm,state,label,visible", "elm");
 280         if (it->segment_id == wd->cur_seg_id)
 281           {
 282             elm_label_text_color_set(it->label_wd, wd->sel_color[0], wd->sel_color[1], wd->sel_color[2], wd->sel_color[3]);
 283           }
 284         else
 285           elm_label_text_color_set(it->label_wd, wd->def_color[0], wd->def_color[1], wd->def_color[2], wd->def_color[3]);
 286      }
 287 }
 288 #if 0
 289 static void
 290 _object_item_resize(void *data, Evas *e, Evas_Object *obj, void *event_info)
 291 {
 292    ecore_job_add(_segment_item_resizing, (Evas_Object *)data);
 293 }
 294 #endif
 295
 296 static Elm_Segment_Item*
 297 _item_new(Evas_Object *obj, const char *label, Evas_Object *icon)
 298 {
 299    Elm_Segment_Item *it;
 300    Evas_Coord mw, mh;
 301    Widget_Data *wd = elm_widget_data_get(obj);
 302    if (!wd) return NULL;
 303
 304    it = calloc(1, sizeof(   Elm_Segment_Item));
 305    if (!it) return NULL;
 306
 307    if(obj) it->obj = obj;
 308    it->delete_me = EINA_FALSE;
 309    it->segment_id = wd->id;
 310    it->label_wd = NULL;
 311 //   it->sel = EINA_FALSE;
 312
 313    it->base = edje_object_add(evas_object_evas_get(obj));
 314    _elm_theme_object_set(obj, it->obj, "segment", "base/default", elm_object_style_get(obj));
 315
 316    if (it->label) eina_stringshare_del(it->label);
 317    if (label)
 318      {
 319         it->label = eina_stringshare_add(label);
 320      }
 321
 322    if ((it->icon != icon) && (it->icon))
 323      elm_widget_sub_object_del(obj, it->icon);
 324    it->icon = icon;
 325    if (it->icon)
 326      {
 327         elm_widget_sub_object_add(obj, icon);
 328         Evas_Coord minw = -1, minh = -1, maxw = -1, maxh = -1;
 329         elm_coords_finger_size_adjust(1, &minw, 1, &minh);
 330         elm_coords_finger_size_adjust(1, &minw, 1, &minh);
 331
 332         evas_object_size_hint_weight_set(it->base, 1.0, -1.0);
 333         evas_object_size_hint_align_set(it->base, 1.0, -1.0);
 334         evas_object_size_hint_min_set(it->base, -1, -1);
 335         evas_object_size_hint_max_set(it->base, maxw, maxh);
 336      }
 337
 338    edje_object_size_min_restricted_calc(obj, &mw, &mh, 0, 0);
 339    evas_object_size_hint_weight_set(obj, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 340    evas_object_size_hint_align_set(obj, EVAS_HINT_FILL, EVAS_HINT_FILL);
 341
 342    return it;
 343 }
 344
 345
 346 static void
 347 _update_list(Evas_Object *obj)
 348 {
 349    Elm_Segment_Item *it = NULL;
 350    Elm_Segment_Item *del_it = NULL;
 351    Elm_Segment_Item *next_sel_it = NULL;
 352    Elm_Segment_Item *seg_it;
 353    Eina_List *l;
 354    int i = 0;
 355
 356    Widget_Data *wd = elm_widget_data_get(obj);
 357    if (!wd) return;
 358
 359    wd->count = eina_list_count(wd->seg_ctrl);
 360    if(wd->count == 1)
 361      {
 362         it = _item_find(obj, 0);
 363         _elm_theme_object_set(obj, it->base, "segment", "base/single", elm_object_style_get(obj));\r
 364         edje_object_signal_emit(it->base, "elm,state,segment,on", "elm");
 365         if(it->label && !it->label_wd)
 366           {
 367              edje_object_signal_emit(it->base, "elm,state,text,change", "elm");
 368              edje_object_part_text_set(it->base, "elm.text", it->label);
 369           }
 370         else
 371        edje_object_signal_emit(it->base, "elm,state,text,hidden", "elm");
 372
 373         if (it->icon && edje_object_part_swallow_get(it->base, "elm.swallow.content") == NULL)
 374           {
 375              if(it->icon)
 376                {
 377                   edje_object_part_swallow(it->base, "elm.swallow.content", it->icon);
 378                   edje_object_signal_emit(it->base, "elm,state,icon,visible", "elm");
 379                }
 380              else
 381                edje_object_signal_emit(it->base, "elm,state,icon,hidden", "elm");
 382           }
 383         if(it->label_wd)
 384           {
 385              edje_object_signal_emit(it->base, "elm,state,label,visible", "elm");
 386              elm_label_text_color_set(it->label_wd, wd->sel_color[0], wd->sel_color[1], wd->sel_color[2], wd->sel_color[3]);
 387           }
 388
 389         return;
 390      }
 391
 392    EINA_LIST_FOREACH(wd->seg_ctrl, l, it)
 393      {
 394         if(i==0)
 395           {
 396              _elm_theme_object_set(obj, it->base, "segment", "base/first", elm_object_style_get(obj));
 397           }
 398         else if(i==wd->count-1)
 399           {
 400              _elm_theme_object_set(obj, it->base, "segment", "base/last", elm_object_style_get(obj));
 401           }
 402         else
 403           {
 404              _elm_theme_object_set(obj, it->base, "segment", "base/default", elm_object_style_get(obj));
 405
 406           }
 407
 408         if(it->label && !it->label_wd)
 409           {
 410              edje_object_signal_emit(it->base, "elm,state,text,visible", "elm");
 411              edje_object_part_text_set(it->base, "elm.text", it->label);
 412           }
 413         else
 414           edje_object_signal_emit(it->base, "elm,state,text,hidden", "elm");
 415
 416         if (it->icon && edje_object_part_swallow_get(it->base, "elm.swallow.content") == NULL)
 417           {
 418              if(it->icon)
 419                {
 420                   edje_object_part_swallow(it->base, "elm.swallow.content", it->icon);
 421                   edje_object_signal_emit(it->base, "elm,state,icon,visible", "elm");
 422                }
 423              else
 424                edje_object_signal_emit(it->base, "elm,state,icon,hidden", "elm");
 425           }
 426         if(it->label_wd)
 427           {
 428              edje_object_signal_emit(it->base, "elm,state,label,visible", "elm");
 429           }
 430
 431         i++;
 432      }
 433
 434      i = 0;
 435      EINA_LIST_FOREACH(wd->seg_ctrl, l, seg_it)
 436        {
 437           if(wd->del_index == 0)
 438             {
 439               if (i == 0)
 440                 {
 441                    next_sel_it = seg_it;
 442                    _signal_segment_on((void*)next_sel_it);
 443                    break;
 444                 }
 445             }
 446           else
 447             {
 448                if (i == wd->del_index-1)
 449                  next_sel_it = seg_it;
 450                if (i == wd->del_index)
 451                  {
 452                     del_it = seg_it;
 453                     break;
 454                  }
 455              }
 456           i++;
 457        }
 458      if(next_sel_it && del_it && del_it->sel)
 459        _signal_segment_on((void*)next_sel_it);
 460 }
 461
 462
 463 static void
 464 _refresh_segment_ids(Evas_Object *obj)
 465 {
 466    Elm_Segment_Item *it;
 467    Eina_List *l;
 468    int i = 0;
 469    Widget_Data *wd = elm_widget_data_get(obj);
 470    if (!wd) return;
 471
 472    if ((wd->insert_index > 0) && wd->cur_seg_id >= wd->insert_index)
 473      {
 474         ++wd->cur_seg_id;
 475         wd->insert_index = 0;
 476      }
 477    if (wd->del_index > 0)
 478      {
 479         if (wd->cur_seg_id >= wd->del_index)
 480           --wd->cur_seg_id;
 481         wd->del_index = -1;
 482      }
 483
 484    EINA_LIST_FOREACH(wd->seg_ctrl, l, it)
 485      {
 486         it->segment_id = i;
 487         i++;
 488      }
 489 }
 490
 491 static void
 492 _state_value_set(Evas_Object *obj)
 493 {
 494    Elm_Segment_Item *it;
 495    Eina_List *l;
 496    Evas_Coord mw, mh, x, y;
 497
 498    int w1=0, w2, i=0;
 499    unsigned int count ;
 500    Widget_Data *wd = elm_widget_data_get(obj);
 501    if (!wd) return;
 502
 503    count = eina_list_count(wd->seg_ctrl);
 504    if (count > 0)
 505      wd->item_width = wd->width/count;
 506    if (wd->ani_it)
 507      {
 508         evas_object_geometry_get(wd->ani_it->base, &x, &y, &w1, NULL);
 509         if (wd->ani_it->delete_me)
 510           {
 511              w1-=(wd->item_width/5);
 512              if( w1< 0) w1 = 0;
 513           }
 514         else
 515         {
 516            w1+=(wd->item_width/5);
 517            if( w1 > wd->item_width )
 518              w1 = wd->item_width;
 519         }
 520         w2 = (wd->width-w1)/(count -1);
 521      }
 522    else
 523       w2 = wd->item_width;
 524
 525    EINA_LIST_FOREACH(wd->seg_ctrl, l, it)
 526     {
 527        edje_object_size_min_restricted_calc(it->base, &mw, &mh, 0, 0);
 528        evas_object_size_hint_weight_set(it->base, 1.0, 1.0);
 529        evas_object_size_hint_align_set(it->base, -1.0, -1.0);
 530
 531
 532        if(wd->ani_it  && it == wd->ani_it)
 533          {
 534             evas_object_resize(it->base, w1, wd->height);
 535             evas_object_size_hint_min_set(it->base, w1, wd->height);
 536             evas_object_size_hint_max_set(it->base, w1, wd->height);
 537          }
 538        else
 539          {
 540             evas_object_resize(it->base, w2, wd->height);
 541             evas_object_size_hint_min_set(it->base, w2, wd->height);
 542             evas_object_size_hint_max_set(it->base, w2, wd->height);
 543         }
 544        ++i;
 545     }
 546
 547     return;
 548 }
 549
 550 /* split string into tokens, return token array */
 551 char **
 552 _split(const char *string, char *delim)
 553 {
 554    char **tokens = NULL;
 555    char *working = NULL;
 556    char *token = NULL;
 557    int idx = 0;
 558
 559    tokens  = malloc(sizeof(char *) * MAXTOKENS);
 560    if(tokens == NULL)
 561      return NULL;
 562    working = malloc(sizeof(char) * strlen(string) + 1);
 563    if(working == NULL)
 564      return NULL;
 565
 566 /* to make sure, copy string to a safe place */
 567    strcpy(working, string);
 568    for(idx = 0; idx < MAXTOKENS; idx++)
 569      tokens[idx] = NULL;
 570
 571    token = strtok(working, delim);
 572    idx = 0;
 573
 574 /* always keep the last entry NULL terminated */
 575    while((idx < (MAXTOKENS - 1)) && (token != NULL)) {
 576      tokens[idx] = malloc(sizeof(char) * strlen(token) + 1);
 577      if(tokens[idx] != NULL) {
 578        strcpy(tokens[idx], token);
 579        idx++;
 580        token = strtok(NULL, delim);
 581      }
 582    }
 583
 584  free(working);
 585  return tokens;
 586 }
 587
 588 static void _color_value_get(Evas_Object *obj)
 589 {
 590    Widget_Data *wd = (Widget_Data *)obj;
 591    if (!wd) return;
 592
 593    const char *def_color;
 594    const char *press_color;
 595    const char *sel_color;
 596
 597    char *delim = " ";
 598    char **tokens = NULL;
 599    int i = 0;
 600
 601    def_color = edje_object_data_get(wd->base, "def_rgb");
 602    if(def_color)
 603      {
 604         tokens = _split(def_color, delim);
 605         for(i = 0; tokens[i] != NULL; i++)
 606           {
 607              if (tokens[i]) wd->def_color[i] = atoi(tokens[i]);
 608              else wd->def_color[i] = 0xFF;
 609           }
 610         for(i = 0; tokens[i] != NULL; i++)
 611           free(tokens[i]);
 612         free(tokens);
 613         tokens = NULL;
 614      }
 615    else
 616      {
 617         for(i = 0; i<(MAXTOKENS - 1); i++)
 618           wd->def_color[i] = 0xFF;
 619      }
 620    press_color = edje_object_data_get(wd->base, "press_rgb");
 621    if(press_color)
 622      {
 623         tokens = _split(press_color, delim);
 624         for(i = 0; tokens[i] != NULL; i++)
 625           {
 626              if (tokens[i]) wd->press_color[i] = atoi(tokens[i]);
 627              else wd->press_color[i] = 0xFF;
 628           }
 629         for(i = 0; tokens[i] != NULL; i++)
 630           free(tokens[i]);
 631         free(tokens);
 632         tokens = NULL;
 633      }
 634    else
 635      {
 636         for(i = 0; i<(MAXTOKENS - 1); i++)
 637           wd->press_color[i] = 0xFF;
 638      }
 639
 640    sel_color = edje_object_data_get(wd->base, "sel_rgb");
 641    if(sel_color)
 642      {
 643        tokens = _split(sel_color, delim);
 644        for(i = 0; tokens[i] != NULL; i++)
 645          {
 646             if (tokens[i]) wd->sel_color[i] = atoi(tokens[i]);
 647             else wd->sel_color[i] = 0xFF;
 648          }
 649        for(i = 0; tokens[i] != NULL; i++)
 650          free(tokens[i]);
 651
 652        free(tokens);
 653        tokens = NULL;
 654      }
 655    else
 656      {
 657         for(i = 0; i<(MAXTOKENS - 1); i++)
 658           wd->sel_color[i] = 0xFF;
 659      }
 660 }
 661
 662 static Eina_Bool
 663 _animator_animate_add_cb(void *data)
 664 {
 665    int w;
 666    Evas_Object *obj = (Evas_Object *)data;
 667    Widget_Data *wd = elm_widget_data_get(obj);
 668    if (!wd) return 0;
 669
 670    evas_object_geometry_get(wd->ani_it->base, NULL, NULL, &w, NULL);
 671    if( w <  wd->item_width )
 672      {
 673          _state_value_set(obj);
 674          evas_object_geometry_get(wd->ani_it->base, NULL, NULL, &w, NULL);
 675          return ECORE_CALLBACK_RENEW;
 676      }
 677    else
 678      {
 679         ecore_animator_del(wd->ani);
 680         wd->ani = NULL;
 681         wd->ani_it = NULL;
 682         return ECORE_CALLBACK_CANCEL;
 683      }
 684 }
 685
 686
 687 static Eina_Bool
 688 _animator_animate_del_cb(void *data)
 689 {
 690    int w;
 691    Evas_Object *obj = (Evas_Object *)data;
 692    Widget_Data *wd = elm_widget_data_get(obj);
 693    if (!wd) return 0;\r
 694
 695    evas_object_geometry_get(wd->ani_it->base, NULL, NULL, &w, NULL);
 696    if( w >  0 )
 697      {
 698         _state_value_set(obj);
 699         evas_object_geometry_get(wd->ani_it->base, NULL, NULL, &w, NULL);
 700         return ECORE_CALLBACK_RENEW;
 701      }
 702    else
 703      {
 704         _item_free(obj, wd->ani_it );
 705         _refresh_segment_ids(obj);
 706         ecore_animator_del(wd->ani);
 707         wd->ani = NULL;
 708         wd->ani_it = NULL;
 709         _update_list(obj);
 710         wd->id = eina_list_count(wd->seg_ctrl);
 711         return ECORE_CALLBACK_CANCEL;
 712      }
 713 }
 714
 715 static Elm_Segment_Item *
 716 _item_find(Evas_Object *obj, unsigned int index)
 717 {
 718    Elm_Segment_Item *it;
 719    Eina_List *l;
 720    int i = 0;
 721    Widget_Data *wd = elm_widget_data_get(obj);
 722    if (!wd) return NULL;
 723
 724    EINA_LIST_FOREACH(wd->seg_ctrl, l, it)
 725      {
 726         if (i == index) return it;
 727         i++;
 728      }
 729      return NULL;
 730 }
 731
 732 /**
 733  * Add a new segmentcontrol to the parent
 734  * @param parent The parent object
 735  * @return The new object or NULL if it cannot be created
 736  *
 737  * @ingroup SegmentControl SegmentControl
 738  */
 739 EAPI Evas_Object *
 740 elm_segment_control_add(Evas_Object *parent)
 741 {
 742    Evas_Object *obj;
 743    Evas *e;
 744    Widget_Data *wd;
 745
 746    const char *deffont, *maxheight, *wpad, *hpad;
 747
 748    wd = ELM_NEW(Widget_Data);
 749    e = evas_object_evas_get(parent);
 750    if(!e) return NULL;
 751    obj = elm_widget_add(e);
 752    elm_widget_type_set(obj, "segmented-control");
 753    elm_widget_sub_object_add(parent, obj);
 754    elm_widget_data_set(obj, wd);
 755    elm_widget_del_hook_set(obj, _del_hook);
 756    elm_widget_theme_hook_set(obj, _theme_hook);
 757
 758    wd->base = edje_object_add(e);
 759    _elm_theme_object_set(obj, wd->base, "segmented-control", "base", "default");
 760    elm_widget_resize_object_set(obj, wd->base);
 761    wd->box = evas_object_box_add(e);
 762    evas_object_box_layout_set(wd->box, _layout, wd, NULL);
 763    elm_widget_sub_object_add(obj, wd->box);
 764    edje_object_part_swallow(wd->base, "elm.swallow.content", wd->box);
 765    evas_object_show(wd->box);
 766
 767    evas_object_event_callback_add(obj, EVAS_CALLBACK_RESIZE, _segment_resizing, obj);
 768    wd->id = 0;
 769    wd->del_index = -1;
 770    wd->insert_index = -1;
 771    wd->cur_seg_id = -1;
 772
 773    deffont = edje_object_data_get(wd->base, "default_font_size");
 774    if (deffont) wd->cur_fontsize = atoi(deffont);
 775    else wd->cur_fontsize = 1;
 776
 777    maxheight = edje_object_data_get(wd->base, "max_height");
 778    if (maxheight) wd->max_height = atoi(maxheight);
 779    else wd->max_height = 1;
 780
 781    wpad = edje_object_data_get(wd->base, "w_pad");
 782    if (wpad) wd->w_pad = atoi(wpad);
 783    else wd->w_pad = 1;
 784
 785    hpad = edje_object_data_get(wd->base, "h_pad");
 786    if (hpad) wd->h_pad = atoi(hpad);
 787    else wd->h_pad = 1;
 788
 789    _color_value_get((Evas_Object *)wd);
 790
 791    return obj;
 792 }
 793
 794 EAPI Elm_Segment_Item *
 795 elm_segment_control_item_add(Evas_Object *obj, Evas_Object *icon, const char *label, Eina_Bool animate)
 796 {
 797    Elm_Segment_Item *it;
 798    Widget_Data *wd = elm_widget_data_get(obj);
 799    if(!wd) return NULL;
 800
 801    it = _item_new(obj, label, icon);
 802    if(!it) return NULL;
 803
 804    wd->seg_ctrl = eina_list_append(wd->seg_ctrl, it);
 805    wd->id = eina_list_count(wd->seg_ctrl);
 806
 807    evas_object_event_callback_add(it->base, EVAS_CALLBACK_MOUSE_DOWN, _mouse_down, it);
 808    evas_object_event_callback_add(it->base, EVAS_CALLBACK_MOUSE_UP, _mouse_up, it);
 809    evas_object_event_callback_add(it->base, EVAS_CALLBACK_RESIZE, _segment_item_resizing, it);
 810    wd->insert_index = -1;
 811    wd->del_index = -1;
 812    _refresh_segment_ids(obj);
 813
 814    if(animate && it->segment_id && wd->ani_it == NULL)
 815      {
 816         evas_object_resize(it->base, 1, wd->height);
 817         wd->ani_it = it;
 818         wd->ani = ecore_animator_add( _animator_animate_add_cb, obj );
 819      }
 820    else
 821    {
 822      _state_value_set(obj);
 823      _update_list(obj);
 824    }
 825    evas_object_show( it->base);
 826
 827    evas_object_box_append(wd->box, it->base);
 828    evas_object_smart_calculate(wd->box);
 829
 830    return it;
 831 }
 832
 833 /**
 834  * Add a new segment item to segmentcontrol
 835  * @param obj The SegmentControl object
 836  * @param icon The icon object for added segment item
 837  * @param label The label for added segment item
 838  * @param animate If EINA_TRUE the action be animated with sliding effects default EINA_FALSE.
 839  * @return The new segment item or NULL if it cannot be created
 840  *
 841  * @ingroup SegmentControl SegmentControl
 842  */
 843 EAPI Elm_Segment_Item *
 844 elm_segment_control_add_segment(Evas_Object *obj, Evas_Object *icon, const char *label, Eina_Bool animate)
 845 {
 846    Elm_Segment_Item * it;
 847    it = elm_segment_control_item_add(obj, icon, label, animate);
 848 \r
 849     return it;\r
 850 }
 851
 852 EAPI Elm_Segment_Item *
 853 elm_segment_control_item_insert_at(Evas_Object *obj, Evas_Object *icon, const char *label, unsigned int index, Eina_Bool animate)
 854 {
 855    Elm_Segment_Item *it, *it_rel;
 856    Widget_Data *wd = elm_widget_data_get(obj);
 857    if(!wd) return NULL;
 858
 859    it = _item_new(obj, label, icon);
 860    it_rel = _item_find(obj, index);
 861    if (!it_rel)
 862      {
 863         wd->seg_ctrl = eina_list_append(wd->seg_ctrl, it);
 864      }
 865    else
 866      {
 867         if (!it) return NULL;
 868         wd->seg_ctrl = eina_list_prepend_relative(wd->seg_ctrl, it, it_rel);
 869      }
 870    evas_object_event_callback_add(it->base, EVAS_CALLBACK_MOUSE_DOWN, _mouse_down, it);
 871    evas_object_event_callback_add(it->base, EVAS_CALLBACK_MOUSE_UP, _mouse_up, it);
 872    evas_object_event_callback_add(it->base, EVAS_CALLBACK_RESIZE, _segment_item_resizing, it);
 873    wd->insert_index = index;
 874    wd->id = eina_list_count(wd->seg_ctrl);
 875    _refresh_segment_ids(obj);
 876
 877    if(animate && it->segment_id && wd->ani_it == NULL)
 878      {
 879         wd->ani_it = it;
 880         evas_object_resize(it->base, 1, wd->height);
 881         wd->ani = ecore_animator_add( _animator_animate_add_cb, obj );
 882      }
 883    else
 884    {
 885      _state_value_set(obj);
 886      _update_list(obj);
 887    }
 888
 889    evas_object_show( it->base);
 890
 891    if(index >= wd->id-1)
 892      {
 893         evas_object_box_append(wd->box,  it->base);
 894      }
 895    else
 896      {
 897         evas_object_box_insert_at(wd->box,  it->base, index);
 898      }
 899
 900    evas_object_smart_calculate(wd->box);
 901
 902    return it ;
 903 }
 904 /**
 905  * Insert a new segment item to segmentcontrol
 906  * @param obj The SegmentControl object
 907  * @param icon The icon object for added segment item
 908  * @param label The label for added segment item
 909  * @param index The position at which segment item to be inserted
 910  * @param animate If 1EINA_TRUE the action be animated with sliding effects default EINA_FALSE.
 911  * @return The new segment item or NULL if it cannot be created
 912  *
 913  * @ingroup SegmentControl SegmentControl
 914  */
 915 EAPI void
 916 elm_segment_control_insert_segment_at(Evas_Object *obj, Evas_Object *icon, const char *label, unsigned int index, Eina_Bool animate)
 917 {
 918    Elm_Segment_Item *it;
 919    it = elm_segment_control_item_insert_at(obj, icon, label, index, animate);
 920
 921    return;
 922 }
 923
 924 EAPI void
 925 elm_segment_control_item_del(Evas_Object *obj, Elm_Segment_Item *item, Eina_Bool animate)
 926 {
 927    Elm_Segment_Item *it;
 928    Widget_Data *wd = elm_widget_data_get(obj);
 929    if(!wd) return;
 930
 931
 932    it = item;
 933    if(!it) return;
 934
 935    wd->del_index = it->segment_id;
 936    if(animate && it->segment_id && wd->ani_it == NULL)
 937      {
 938         it->delete_me = EINA_TRUE;
 939         wd->ani_it = it;
 940         wd->ani = ecore_animator_add( _animator_animate_del_cb, obj );
 941      }
 942    else
 943      {
 944         evas_object_box_remove(wd->box, it->base);
 945         evas_object_smart_calculate(wd->box);
 946
 947         _item_free(obj, it);
 948         _refresh_segment_ids(obj);
 949         _state_value_set(obj);
 950      }
 951    wd->id = eina_list_count(wd->seg_ctrl);
 952    return;
 953 }
 954
 955 /**
 956  * Delete a segment item to segmentcontrol
 957  * @param obj The SegmentControl object
 958  * @param item The  segment item to be deleted
 959  * @param animate If EINA_TRUE the action be animated with sliding effects default EINA_FALSE.
 960  *
 961  * @ingroup SegmentControl SegmentControl
 962  */
 963 EAPI void
 964 elm_segment_control_delete_segment(Evas_Object *obj, Elm_Segment_Item *item, Eina_Bool animate)
 965 {
 966    elm_segment_control_item_del(obj, item, animate);
 967
 968    return;
 969 }
 970
 971 EAPI void
 972 elm_segment_control_item_del_at(Evas_Object *obj,  unsigned int index, Eina_Bool animate)
 973 {
 974    Elm_Segment_Item *it;
 975    Widget_Data *wd = elm_widget_data_get(obj);
 976    if(!wd) return;
 977
 978    it = _item_find(obj, index);
 979
 980    if(!it) return;
 981
 982    wd->del_index = index;
 983    if(animate && it->segment_id)
 984      {
 985         if(wd->ani_it == NULL)
 986         {
 987            wd->ani_it = it;
 988            it->delete_me = EINA_TRUE;
 989            wd->ani = ecore_animator_add( _animator_animate_del_cb, obj );
 990         }
 991      }
 992    else
 993      {
 994         evas_object_box_remove(wd->box, it->base);
 995         evas_object_smart_calculate(wd->box);
 996         _item_free(obj, it);
 997         _refresh_segment_ids(obj);
 998         _state_value_set(obj);
 999      }
1000    wd->id = eina_list_count(wd->seg_ctrl);
1001    return;
1002 }
1003
1004 /**
1005  * Delete a segment item of given index to segmentcontrol
1006  * @param obj The SegmentControl object
1007  * @param index The position at which segment item to be deleted
1008  * @param animate If EINA_TRUE the action be animated with sliding effects default EINA_FALSE.
1009  *
1010  * @ingroup SegmentControl SegmentControl
1011  */
1012 EAPI void
1013 elm_segment_control_delete_segment_at(Evas_Object *obj,  unsigned int index, Eina_Bool animate)
1014 {
1015    elm_segment_control_item_del_at( obj, index, animate);
1016
1017    return;
1018 }
1019
1020
1021 EAPI const char *
1022 elm_segment_control_item_label_get(Evas_Object *obj, unsigned int index)
1023 {
1024    Elm_Segment_Item *it_rel;
1025    Widget_Data *wd = elm_widget_data_get(obj);
1026    if(!wd) return NULL;
1027
1028    it_rel = _item_find(obj, index);
1029
1030    if(it_rel) return it_rel->label;
1031
1032    return NULL;
1033 }
1034
1035 /**
1036  * Get the label of a segment item of segmentcontrol
1037  * @param obj The SegmentControl object
1038  * @param index The index of the segment item
1039  * @return The label of the segment item
1040  *
1041  * @ingroup SegmentControl SegmentControl
1042  */
1043 EAPI const char *
1044 elm_segment_control_get_segment_label_at(Evas_Object *obj, unsigned int index)
1045 {
1046    const char *label;
1047    label = elm_segment_control_item_label_get( obj, index);
1048
1049    return label;
1050 }
1051
1052 EAPI Evas_Object *
1053 elm_segment_control_item_icon_get(Evas_Object *obj, unsigned int index)
1054 {
1055    Elm_Segment_Item *seg_rel;
1056    Widget_Data *wd = elm_widget_data_get(obj);
1057    if(!wd) return NULL;
1058
1059    seg_rel = _item_find(obj, index);
1060
1061    if(seg_rel) return seg_rel->icon;
1062
1063    return NULL;
1064 }
1065
1066 /**
1067  * Get the icon of a segment item of segmentcontrol
1068  * @param obj The SegmentControl object
1069  * @param index The index of the segment item
1070  * @return The icon object or NULL if it is not found.
1071  *
1072  * @ingroup SegmentControl SegmentControl
1073  */
1074 EAPI Evas_Object *
1075 elm_segment_control_get_segment_icon_at(Evas_Object *obj, unsigned int index)
1076 {
1077    Evas_Object *icon;
1078    icon = elm_segment_control_item_icon_get( obj, index);
1079
1080    return icon;
1081 }
1082
1083 EAPI Elm_Segment_Item *
1084 elm_segment_control_item_selected_get(const Evas_Object *obj)
1085 {
1086    Elm_Segment_Item *it;
1087    Eina_List *l;
1088    Widget_Data *wd = elm_widget_data_get(obj);
1089    if(!wd || !wd->seg_ctrl) return NULL;
1090
1091    EINA_LIST_FOREACH(wd->seg_ctrl, l, it)
1092      {
1093         if(it->segment_id == wd->cur_seg_id)
1094           return it;
1095      }
1096     return NULL;
1097  }
1098
1099 /**
1100  * Get the currently selected segment item of segmentcontrol
1101  * @param obj The SegmentControl object
1102  * @param value The Selected Segment id.
1103  * @return The selected Segment item
1104  *
1105  * @ingroup SegmentControl SegmentControl
1106  */
1107 EAPI Elm_Segment_Item *
1108 elm_segment_control_selected_segment_get(const Evas_Object *obj, int *value)
1109 {
1110    Elm_Segment_Item *it;
1111    it = elm_segment_control_item_selected_get(obj);
1112    if(!it) return NULL;
1113       *value = it->segment_id;
1114    return it;
1115  }
1116
1117
1118 EAPI int
1119 elm_segment_control_item_count_get(Evas_Object *obj)
1120 {
1121    Widget_Data *wd = elm_widget_data_get(obj);
1122    if(!wd) return 0;
1123
1124    return wd->id;
1125 }
1126
1127 /**
1128  * Get the count of segments of segmentcontrol
1129  * @param obj The SegmentControl object
1130  * @return The count of Segment items
1131  *
1132  * @ingroup SegmentControl SegmentControl
1133  */
1134 EAPI int
1135 elm_segment_control_get_segment_count(Evas_Object *obj)
1136 {
1137    int id;
1138    id = elm_segment_control_item_count_get( obj);
1139
1140    return id;
1141 }
1142
1143 /**
1144  * Get the base object of segment item in segmentcontrol
1145  * @param it The Segment item
1146  * @return obj The base object of the segment item.
1147  *
1148  * @ingroup SegmentControl SegmentControl
1149  */
1150 EAPI Evas_Object *
1151 elm_segment_control_item_object_get(Elm_Segment_Item *it)
1152 {
1153    if (!it) return NULL;
1154
1155    return it->base;
1156 }
1157
1158 /**
1159  * Select/unselect a particular segment item of segmentcontrol
1160  * @param item The Segment item that is to be selected or unselected.
1161  * @param select If 1 the segment item is selected and if 0 it will be unselected.
1162  *
1163  * @ingroup SegmentControl SegmentControl
1164  */
1165 EAPI void
1166 elm_segment_control_item_selected_set( Elm_Segment_Item *item, Eina_Bool select)
1167 {
1168    if(!item) return;
1169    Widget_Data *wd = elm_widget_data_get(item->obj);
1170    if(!wd) return;
1171
1172    if(select)
1173      {
1174         if(item->segment_id == wd->cur_seg_id && wd->cur_seg_id) return;
1175 //        item->sel = EINA_TRUE;
1176         _signal_segment_on(item);
1177      }
1178    else if(item->segment_id == wd->cur_seg_id)
1179      {
1180 //        item->sel = EINA_FALSE;
1181         wd->cur_seg_id = -1;
1182         _signal_segment_off(item);
1183      }
1184
1185    return;
1186 }
1187
1188 /**
1189  * Get a particular indexed segment item of segmentcontrol
1190  * @param obj The Segment control object.
1191  * @param index The index of the segment item.
1192  * @return The corresponding Segment item.
1193  *
1194  * @ingroup SegmentControl SegmentControl
1195  */
1196 EAPI Elm_Segment_Item *
1197 elm_segment_control_item_get_at(Evas_Object *obj, unsigned int index)
1198 {
1199    Elm_Segment_Item *it;
1200    it = _item_find(obj, index);
1201
1202    return it;
1203 }
1204 \r
1205 /**
1206  * Get the index of a Segment item of Segmentcontrol
1207  * @param item The Segment item.
1208  * @return The corresponding index of the Segment item.
1209  *
1210  * @ingroup SegmentControl SegmentControl
1211  */
1212 EAPI int
1213 elm_segment_control_item_index_get(Elm_Segment_Item *item)
1214 {
1215    if(!item) return -1;
1216    Widget_Data *wd = elm_widget_data_get(item->obj);
1217    if(!wd) return -1;
1218
1219    return item->segment_id;
1220 }
1221
1222 /**
1223  * Set The Label widget to a Segment item of Segmentcontrol
1224  * @param item The Segment item.
1225  * @param label The Label.
1226  * @return Evas_Object The Label widget.
1227  *
1228  * @ingroup SegmentControl SegmentControl
1229  */
1230 EAPI Evas_Object *
1231 elm_segment_control_item_label_object_set(Elm_Segment_Item *item, char *label)
1232 {
1233    if(!item) return NULL;
1234    Widget_Data *wd = elm_widget_data_get(item->obj);
1235    if(!wd) return NULL;
1236    if(!label) return NULL;
1237
1238    item->label_wd = elm_label_add(item->obj);
1239    elm_object_style_set(item->label_wd, "segment");
1240    elm_label_label_set(item->label_wd, label);
1241    elm_label_text_align_set(item->label_wd, "middle");
1242    elm_label_ellipsis_set(item->label_wd, 1);
1243    eina_stringshare_replace(&item->label, label);
1244
1245    return item->label_wd;
1246 }
1247