src/lib/elm_controlbar.c

   1 /**
   2  * @defgroup Controlbar Controlbar
   3  * @ingroup Elementary
   4  *
   5  * This is a Controlbar. It can contain label and icon objects.
   6  * In edit mode, you can change the location of items.
   7  */
   8
   9 #include <string.h>
  10 #include <math.h>
  11
  12 #include <Elementary.h>
  13 #include "elm_priv.h"
  14
  15 #ifndef EAPI
  16 #define EAPI __attribute__ ((visibility("default")))
  17 #endif
  18
  19 #define ELM_MAX(v1, v2)    (((v1) > (v2)) ? (v1) : (v2))
  20 #define _EDJ(x) (Evas_Object *)elm_layout_edje_get(x)
  21
  22 #define TABBAR 0
  23 #define TOOLBAR 1
  24 #define OBJECT 2
  25
  26 typedef struct _Animation_Data Animation_Data;
  27
  28 struct _Animation_Data
  29 {
  30    Evas_Object * obj;
  31    Evas_Coord fx;
  32    Evas_Coord fy;
  33    Evas_Coord fw;
  34    Evas_Coord fh;
  35    Evas_Coord tx;
  36    Evas_Coord ty;
  37    Evas_Coord tw;
  38    Evas_Coord th;
  39    double start_time;
  40    double time;
  41    void (*func) (void *data, Evas_Object * obj);
  42    void *data;
  43    Ecore_Animator * timer;
  44 };
  45
  46 // internal data structure of controlbar object
  47 typedef struct _Widget_Data Widget_Data;
  48
  49 struct _Widget_Data
  50 {
  51    Evas_Object * object;
  52    Evas_Object * parent;
  53    Evas_Object * view;
  54    Evas_Object * edje;
  55    Evas_Object * bg;
  56    Evas_Object * box;
  57
  58    Elm_Controlbar_Item * more_item;
  59    Elm_Controlbar_Item * pre_item;
  60    Elm_Controlbar_Item * cur_item;
  61    Evas_Coord x, y, w, h;
  62    Eina_Bool disabled;
  63    Eina_Bool vertical;
  64    Eina_Bool auto_align;
  65    int mode;
  66    int alpha;
  67    int num;
  68    int animating;
  69    Eina_List * items;
  70    Eina_List * visible_items;
  71
  72    void (*ani_func) (void *data, Evas_Object * obj, void *event_info);
  73    void *ani_data;
  74    Ecore_Timer *effect_timer;
  75    Eina_Bool selected_animation;
  76    Animation_Data *ad;
  77
  78    const char *pressed_signal;
  79    const char *selected_signal;
  80 };
  81
  82 struct _Elm_Controlbar_Item
  83 {
  84    Widget_Data * wd;
  85    Evas_Object * obj;
  86    Evas_Object * base;
  87    Evas_Object * base_item;
  88    Evas_Object * view;
  89    Evas_Object * icon;
  90    const char *icon_path;
  91    const char *text;
  92    void (*func) (void *data, Evas_Object * obj, void *event_info);
  93    void *data;
  94    int order;
  95    int sel;
  96    int style;
  97    Eina_Bool selected;
  98    Eina_Bool disabled;
  99 };
 100
 101 static const char *widtype = NULL;
 102 // prototype
 103 static void _sizing_eval(Evas_Object * obj);
 104 static int _check_bar_item_number(Widget_Data *wd);
 105 static void _select_box(Elm_Controlbar_Item * it);
 106 static void _cancel_selected_box(Widget_Data *wd);
 107 static void _check_toolbar_line(Widget_Data *wd);
 108 static Eina_Bool _press_box(Elm_Controlbar_Item * it);
 109
 110 ///////////////////////////////////////////////////////////////////
 111 //
 112 //  Smart Object basic function
 113 //
 114 ////////////////////////////////////////////////////////////////////
 115
 116 static void
 117 _controlbar_move(void *data, Evas_Object * obj __UNUSED__)
 118 {
 119    Widget_Data * wd;
 120    Evas_Coord x, y, x_, y_, width;
 121    if (!data) return;
 122    wd = elm_widget_data_get((Evas_Object *) data);
 123    if (!wd) return;
 124    evas_object_geometry_get(wd->edje, &x, &y, NULL, NULL);
 125    wd->x = x;
 126    wd->y = y;
 127    evas_object_move(wd->edje, x, y);
 128    evas_object_geometry_get(elm_object_content_part_get(wd->edje, "bg_image"), NULL, NULL, &width, NULL);
 129    evas_object_geometry_get(wd->edje, &x_, &y_, NULL, NULL);
 130 }
 131
 132 static void
 133 _controlbar_resize(void *data, Evas_Object * obj __UNUSED__)
 134 {
 135    Widget_Data * wd;
 136    Evas_Coord x, y, x_, y_, w, h, width, height;
 137    if (!data) return;
 138    wd = elm_widget_data_get((Evas_Object *) data);
 139    if (!wd) return;
 140    evas_object_geometry_get(wd->edje, &x, &y, &w, &h);
 141    wd->w = w;
 142    wd->h = h;
 143    evas_object_resize(wd->edje, w, h);
 144    evas_object_geometry_get(elm_object_content_part_get(wd->edje, "bg_image"), NULL, NULL, &width, &height);
 145    evas_object_geometry_get(wd->edje, &x_, &y_, NULL, NULL);
 146 }
 147
 148 static void
 149 _controlbar_object_move(void *data, Evas * e __UNUSED__, Evas_Object * obj,
 150                         void *event_info __UNUSED__)
 151 {
 152    _controlbar_move(data, obj);
 153 }
 154
 155 static void
 156 _controlbar_object_resize(void *data, Evas * e __UNUSED__, Evas_Object * obj,
 157                           void *event_info __UNUSED__)
 158 {
 159    _controlbar_resize(data, obj);
 160 }
 161
 162 static void
 163 _controlbar_object_show(void *data, Evas * e __UNUSED__, Evas_Object * obj __UNUSED__,
 164                         void *event_info __UNUSED__)
 165 {
 166    Widget_Data * wd;
 167    if (!data) return;
 168    wd = elm_widget_data_get((Evas_Object *) data);
 169    if (!wd) return;
 170    evas_object_show(wd->edje);
 171    evas_object_show(wd->box);
 172 }
 173
 174 static void
 175 _controlbar_object_hide(void *data, Evas * e __UNUSED__, Evas_Object * obj __UNUSED__,
 176                         void *event_info __UNUSED__)
 177 {
 178    Widget_Data * wd;
 179    if (!data) return;
 180    wd = elm_widget_data_get((Evas_Object *) data);
 181    if (!wd) return;
 182    evas_object_hide(wd->edje);
 183    evas_object_hide(wd->box);
 184
 185    _cancel_selected_box(wd);
 186 }
 187
 188 static void
 189 _item_del(Elm_Controlbar_Item *it)
 190 {
 191    if (!it) return;
 192    Widget_Data *wd = elm_widget_data_get(it->obj);
 193    if (!wd) return;
 194
 195    if (it->text)
 196      eina_stringshare_del(it->text);
 197    if (it->icon_path)
 198      eina_stringshare_del(it->icon_path);
 199    if (it->icon)
 200      evas_object_del(it->icon);
 201    if (it->base)
 202      evas_object_del(it->base);
 203    if (it->base_item)
 204      evas_object_del(it->base_item);
 205    if (it->view)
 206      evas_object_del(it->view);
 207 }
 208
 209 static void
 210 _del_hook(Evas_Object * obj)
 211 {
 212    Widget_Data * wd = elm_widget_data_get(obj);
 213    Elm_Controlbar_Item * item;
 214    if (!wd) return;
 215
 216    EINA_LIST_FREE(wd->items, item)
 217      {
 218         _item_del(item);
 219         free(item);
 220         item = NULL;
 221      }
 222    if (wd->bg)
 223      {
 224         evas_object_del(wd->bg);
 225         wd->bg = NULL;
 226      }
 227    if (wd->box)
 228      {
 229         evas_object_del(wd->box);
 230         wd->box = NULL;
 231      }
 232    if (wd->edje)
 233      {
 234         evas_object_del(wd->edje);
 235         wd->edje = NULL;
 236      }
 237    if (wd->effect_timer)
 238      {
 239         ecore_timer_del(wd->effect_timer);
 240         wd->effect_timer = NULL;
 241      }
 242    if (wd->ad)
 243      {
 244         if (wd->ad->timer) ecore_animator_del(wd->ad->timer);
 245         wd->ad->timer = NULL;
 246         free(wd->ad);
 247         wd->ad = NULL;
 248      }
 249
 250    free(wd);
 251    wd = NULL;
 252 }
 253
 254 static void
 255 _theme_hook(Evas_Object * obj)
 256 {
 257    const Eina_List *l;
 258
 259    Elm_Controlbar_Item * item;
 260    int r, g, b;
 261
 262    Widget_Data * wd = elm_widget_data_get(obj);
 263    if (!wd) return;
 264    elm_layout_theme_set(wd->edje, "controlbar", "base",
 265                          elm_widget_style_get(obj));
 266    elm_layout_theme_set(wd->bg, "controlbar", "background",
 267                          elm_widget_style_get(obj));
 268    evas_object_color_get(wd->bg, &r, &g, &b, NULL);
 269    evas_object_color_set(wd->bg, r, g, b, (int)(255 * wd->alpha / 100));
 270    EINA_LIST_FOREACH(wd->items, l, item)
 271      {
 272         elm_layout_theme_set(item->base, "controlbar", "item_bg", elm_widget_style_get(obj));
 273         if (item->selected)
 274           _select_box(item);
 275      }
 276    elm_controlbar_mode_set(obj, wd->mode);
 277    _check_toolbar_line(wd);
 278 }
 279
 280 static void
 281 _disable_hook(Evas_Object * obj)
 282 {
 283    Widget_Data * wd = elm_widget_data_get(obj);
 284    if (!wd) return;
 285    const Eina_List *l;
 286    Elm_Controlbar_Item * item;
 287    Eina_Bool disabled;
 288
 289    wd->disabled = elm_widget_disabled_get(obj);
 290
 291    EINA_LIST_FOREACH(wd->items, l, item)
 292      {
 293         if (wd->disabled)
 294           disabled = wd->disabled;
 295         else
 296           disabled = item->disabled;
 297
 298         if (item->base_item) elm_widget_disabled_set(item->base_item, disabled);
 299      }
 300 }
 301
 302 static void
 303 _sub_del(void *data __UNUSED__, Evas_Object * obj, void *event_info)
 304 {
 305 }
 306
 307 static void
 308 _sizing_eval(Evas_Object * obj)
 309 {
 310    Widget_Data * wd = elm_widget_data_get(obj);
 311    if (!wd) return;
 312    _controlbar_move(obj, obj);
 313    _controlbar_resize(obj, obj);
 314 }
 315
 316 /////////////////////////////////////////////////////////////
 317 //
 318 // animation function
 319 //
 320 /////////////////////////////////////////////////////////////
 321
 322 static Eina_Bool
 323 _move_evas_object(void *data)
 324 {
 325    const Evas_Object *bg_image;
 326    double t = 0.0, vx = 0.0, vy = 0.0, vw = 0.0, vh = 0.0;
 327    int dx = 0 , dy = 0, dw = 0, dh = 0;
 328    int px = 0, py = 0, pw = 0, ph = 0;
 329    int ox = 0, oy = 0, ow = 0, oh = 0;
 330    int x = 0, y = 0, w = 0, h = 0;
 331
 332    Animation_Data * ad = (Animation_Data *) data;
 333    bg_image = edje_object_part_object_get(_EDJ(ad->obj), "bg_image");
 334    if (bg_image) evas_object_geometry_get(bg_image, &ox, &oy, &ow, &oh);
 335    t = ELM_MAX(0.0, ecore_loop_time_get() - ad->start_time);
 336    dx = ad->tx - ad->fx;
 337    dy = ad->ty - ad->fy;
 338    dw = ad->tw - ad->fw;
 339    dh = ad->th - ad->fh;
 340    if (t <= ad->time)
 341      {
 342         x = (1 * sin((t / ad->time) * (M_PI / 2)) * dx);
 343         y = (1 * sin((t / ad->time) * (M_PI / 2)) * dy);
 344         w = (1 * sin((t / ad->time) * (M_PI / 2)) * dw);
 345         h = (1 * sin((t / ad->time) * (M_PI / 2)) * dh);
 346      }
 347    else
 348      {
 349         x = dx;
 350         y = dy;
 351         w = dw;
 352         h = dh;
 353      }
 354    px = ad->fx + x;
 355    py = ad->fy + y;
 356    pw = ad->fw + w;
 357    ph = ad->fh + h;
 358
 359    if ((ow - pw) == 0)
 360      vx = 0;
 361    else
 362      vx = (double)(px - ox) / (double)(ow - pw);
 363    if ((oh - ph) == 0)
 364      vy = 0;
 365    else
 366      vy = (double)(py - oy) / (double)(oh - ph);
 367    vw = (double)pw / (double)ow;
 368    vh = (double)ph / (double)oh;
 369
 370    if ((x == dx) && (y == dy) && (w == dw) && (h == dh))
 371      {
 372         if (ad->timer) ecore_animator_del(ad->timer);
 373         ad->timer = NULL;
 374         edje_object_part_drag_size_set(_EDJ(ad->obj), "elm.dragable.box", vw, vh);
 375         edje_object_part_drag_value_set(_EDJ(ad->obj), "elm.dragable.box", vx, vy);
 376         if (ad->func != NULL)
 377           ad->func(ad->data, ad->obj);
 378         return ECORE_CALLBACK_CANCEL;
 379      }
 380    else
 381      {
 382         edje_object_part_drag_size_set(_EDJ(ad->obj), "elm.dragable.box", vw, vh);
 383         edje_object_part_drag_value_set(_EDJ(ad->obj), "elm.dragable.box", vx, vy);
 384      }
 385    return ECORE_CALLBACK_RENEW;
 386 }
 387
 388 static Animation_Data*
 389 _move_object_with_animation(Evas_Object * obj, Evas_Coord x, Evas_Coord y,
 390                            Evas_Coord w, Evas_Coord h, Evas_Coord x_,
 391                            Evas_Coord y_, Evas_Coord w_, Evas_Coord h_,
 392                            double time, Eina_Bool (*mv_func) (void *data),
 393                            void (*func) (void *data,
 394                                          Evas_Object * obj), void *data)
 395 {
 396    Animation_Data * ad = (Animation_Data *) malloc(sizeof(Animation_Data));
 397    if (!ad) return NULL;
 398    ad->obj = obj;
 399    ad->fx = x;
 400    ad->fy = y;
 401    ad->fw = w;
 402    ad->fh = h;
 403    ad->tx = x_;
 404    ad->ty = y_;
 405    ad->tw = w_;
 406    ad->th = h_;
 407    ad->start_time = ecore_loop_time_get();
 408    ad->time = time;
 409    ad->func = func;
 410    ad->data = data;
 411    ad->timer = ecore_animator_add(mv_func, ad);
 412
 413    return ad;
 414 }
 415
 416 /////////////////////////////////////////////////////////////
 417 //
 418 // callback function
 419 //
 420 /////////////////////////////////////////////////////////////
 421
 422 static int
 423 _sort_cb(const void *d1, const void *d2)
 424 {
 425    Elm_Controlbar_Item * item1, *item2;
 426    item1 = (Elm_Controlbar_Item *) d1;
 427    item2 = (Elm_Controlbar_Item *) d2;
 428    if (item1->order <= 0) return 1;
 429    if (item2->order <= 0) return -1;
 430    return item1->order > item2->order ? 1 : -1;
 431 }
 432
 433 ///////////////////////////////////////////////////////////////////
 434 //
 435 //  basic utility function
 436 //
 437 ////////////////////////////////////////////////////////////////////
 438
 439 static Eina_Bool
 440 _check_item(Widget_Data *wd, Elm_Controlbar_Item *item)
 441 {
 442    const Eina_List *l;
 443    Elm_Controlbar_Item *it;
 444
 445    if (!wd) return EINA_FALSE;
 446    if (!wd->items) return EINA_FALSE;
 447
 448    EINA_LIST_FOREACH(wd->items, l, it)
 449       if (it == item) return EINA_TRUE;
 450
 451    return EINA_FALSE;
 452 }
 453
 454 static void
 455 _check_background(Widget_Data *wd)
 456 {
 457    if (!wd) return;
 458    Eina_List *l;
 459    Elm_Controlbar_Item *it;
 460
 461    EINA_LIST_FOREACH(wd->items, l, it)
 462      {
 463         if (it->style == TABBAR)
 464           {
 465              if (wd->mode == ELM_CONTROLBAR_MODE_LEFT)
 466                edje_object_signal_emit(_EDJ(wd->bg), "elm,state,tabbar_left", "elm");
 467              else if (wd->mode == ELM_CONTROLBAR_MODE_RIGHT)
 468                edje_object_signal_emit(_EDJ(wd->bg), "elm,state,tabbar_right", "elm");
 469              else
 470                edje_object_signal_emit(_EDJ(wd->bg), "elm,state,tabbar", "elm");
 471              return;
 472           }
 473      }
 474    edje_object_signal_emit(_EDJ(wd->bg), "elm,state,toolbar", "elm");
 475 }
 476
 477 static void
 478 _check_toolbar_line(Widget_Data *wd)
 479 {
 480    if (!wd) return;
 481    Eina_List *l;
 482    Elm_Controlbar_Item *it, *it2;
 483
 484    EINA_LIST_FOREACH(wd->items, l, it)
 485      {
 486         it2 = elm_controlbar_item_prev(it);
 487         if (!it2) continue;
 488         if (it->style != TOOLBAR || it2->style != TOOLBAR) continue;
 489
 490         if (wd->vertical)
 491           {
 492              edje_object_signal_emit(_EDJ(it2->base), "elm,state,right_line_hide", "elm");
 493              edje_object_signal_emit(_EDJ(it->base), "elm,state,left_line_hide", "elm");
 494
 495              if ((it->icon || it->text) && (it2->icon || it2->text))
 496                {
 497                   edje_object_signal_emit(_EDJ(it2->base), "elm,state,bottom_line_show", "elm");
 498                   edje_object_signal_emit(_EDJ(it->base), "elm,state,top_line_show", "elm");
 499                }
 500              else
 501                {
 502                   edje_object_signal_emit(_EDJ(it2->base), "elm,state,bottom_line_hide", "elm");
 503                   edje_object_signal_emit(_EDJ(it->base), "elm,state,top_line_hide", "elm");
 504                }
 505           }
 506         else
 507           {
 508              edje_object_signal_emit(_EDJ(it2->base), "elm,state,bottom_line_hide", "elm");
 509              edje_object_signal_emit(_EDJ(it->base), "elm,state,top_line_hide", "elm");
 510
 511              if ((it->icon || it->text) && (it2->icon || it2->text))
 512                {
 513                   edje_object_signal_emit(_EDJ(it2->base), "elm,state,right_line_show", "elm");
 514                   edje_object_signal_emit(_EDJ(it->base), "elm,state,left_line_show", "elm");
 515                }
 516              else
 517                {
 518                   edje_object_signal_emit(_EDJ(it2->base), "elm,state,right_line_hide", "elm");
 519                   edje_object_signal_emit(_EDJ(it->base), "elm,state,left_line_hide", "elm");
 520                }
 521           }
 522      }
 523 }
 524
 525 static int
 526 _check_bar_item_number(Widget_Data *wd)
 527 {
 528    const Eina_List *l;
 529    Elm_Controlbar_Item * item;
 530    int num = 0;
 531
 532    EINA_LIST_FOREACH(wd->items, l, item)
 533       if (item->order > 0) num++;
 534
 535    return num;
 536 }
 537
 538 static void
 539 _insert_item_in_bar(Elm_Controlbar_Item * it, int order)
 540 {
 541    const Eina_List *l;
 542    Elm_Controlbar_Item * item;
 543    Widget_Data * wd = elm_widget_data_get(it->obj);
 544    if (!wd) return;
 545    int check = 0;
 546
 547    if (order == 0) return;
 548
 549    EINA_LIST_FOREACH(wd->items, l, item)
 550      {
 551         if ((item->order == order) && (item != it))
 552           check = 1;
 553      }
 554    if (check)
 555      {
 556         EINA_LIST_FOREACH(wd->items, l, item)
 557           {
 558              if (item->order > 0)
 559                elm_table_unpack(wd->box, item->base);
 560           }
 561         EINA_LIST_FOREACH(wd->items, l, item)
 562           {
 563              if (item->order > 0)
 564                {
 565                   if (item->order >= order)
 566                     item->order += 1;
 567                   if (!wd->vertical)
 568                     elm_table_pack(wd->box, item->base, item->order - 1, 0, 1, 1);
 569                   else
 570                     elm_table_pack(wd->box, item->base, 0, item->order - 1, 1, 1);
 571                   evas_object_show(item->base);
 572                }
 573           }
 574      }
 575    it->order = order;
 576    if (!wd->vertical)
 577      elm_table_pack(wd->box, it->base, it->order - 1, 0, 1, 1);
 578    else
 579      elm_table_pack(wd->box, it->base, 0, it->order - 1, 1, 1);
 580    evas_object_show(it->base);
 581 }
 582
 583 static void
 584 _delete_item_in_bar(Elm_Controlbar_Item * it)
 585 {
 586    const Eina_List *l;
 587    Elm_Controlbar_Item * item;
 588    Widget_Data * wd = elm_widget_data_get(it->obj);
 589    if (!wd) return;
 590    int i = 0;
 591
 592    EINA_LIST_FOREACH(wd->items, l, item)
 593      {
 594         if (item == it)
 595           {
 596              i = it->order;
 597              it->order = 0;
 598              elm_table_unpack(wd->box, it->base);
 599              evas_object_hide(it->base);
 600           }
 601      }
 602    if (i)
 603      {
 604         EINA_LIST_FOREACH(wd->items, l, item)
 605           {
 606              if (item->order > i)
 607                {
 608                   item->order--;
 609                   elm_table_unpack(wd->box, item->base);
 610                   if (!wd->vertical)
 611                     elm_table_pack(wd->box, item->base, item->order - 1, 0, 1, 1);
 612                   else
 613                     elm_table_pack(wd->box, item->base, 0, item->order - 1, 1, 1);
 614                }
 615           }
 616      }
 617 }
 618
 619 static void
 620 _set_item_visible(Elm_Controlbar_Item *it, Eina_Bool visible)
 621 {
 622    Elm_Controlbar_Item *item;
 623    Eina_Bool check = EINA_TRUE;
 624
 625    if (!it) return;
 626    if (it->obj == NULL) return;
 627    Widget_Data * wd = elm_widget_data_get(it->obj);
 628    if (!wd || !wd->items) return;
 629    if (it->order <= 0) check = EINA_FALSE;
 630    if (check == visible) return;
 631    if (visible)
 632      {
 633         item = elm_controlbar_last_item_get(it->obj);
 634         if (!item) return;
 635         while (!elm_controlbar_item_visible_get(item)){
 636              item = elm_controlbar_item_prev(item);
 637         }
 638         _insert_item_in_bar(it, item->order + 1);
 639      }
 640    else
 641      {
 642         _delete_item_in_bar(it);
 643      }
 644    wd->items = eina_list_sort(wd->items, eina_list_count(wd->items), _sort_cb);
 645    _sizing_eval(it->obj);
 646 }
 647
 648 static Eina_Bool
 649 _hide_selected_box(void *data)
 650 {
 651    Evas_Object *base = (Evas_Object *)data;
 652
 653    edje_object_part_drag_size_set(_EDJ(base), "elm.dragable.box", 0.0, 0.0);
 654
 655    return ECORE_CALLBACK_CANCEL;
 656 }
 657
 658 static void
 659 _end_selected_box(void *data, Evas_Object *obj __UNUSED__)
 660 {
 661    Widget_Data * wd = (Widget_Data *)data;
 662
 663    if (_check_item(wd, wd->cur_item))
 664      {
 665         edje_object_signal_emit(_EDJ(wd->cur_item->base), wd->selected_signal, "elm");
 666      }
 667
 668    wd->animating--;
 669    if (wd->animating < 0)
 670      {
 671         printf("animation error\n");
 672         wd->animating = 0;
 673      }
 674
 675    ecore_idler_add(_hide_selected_box, wd->edje);
 676 }
 677
 678 static void
 679 _move_selected_box(Widget_Data *wd, Elm_Controlbar_Item * fit, Elm_Controlbar_Item * tit)
 680 {
 681    Evas_Coord fx, fy, fw, fh, tx, ty, tw, th;
 682    Evas_Object *from, *to;
 683
 684    if ((fit->order <= 0) && (wd->auto_align))
 685      fit = wd->more_item;
 686
 687    from = (Evas_Object *) edje_object_part_object_get(_EDJ(fit->base), "bg_img");
 688    evas_object_geometry_get(from, &fx, &fy, &fw, &fh);
 689
 690    to = (Evas_Object *) edje_object_part_object_get(_EDJ(tit->base), "bg_img");
 691    evas_object_geometry_get(to, &tx, &ty, &tw, &th);
 692
 693    if (_check_item(wd, wd->pre_item))
 694      {
 695         edje_object_signal_emit(_EDJ(wd->pre_item->base), "elm,state,unselected", "elm");
 696      }
 697    if (_check_item(wd, wd->cur_item))
 698      edje_object_signal_emit(_EDJ(wd->cur_item->base), "elm,state,unselected", "elm");
 699
 700    wd->animating++;
 701    if (wd->ad)
 702      {
 703         if (wd->ad->timer) ecore_animator_del(wd->ad->timer);
 704         wd->ad->timer = NULL;
 705         free(wd->ad);
 706         wd->ad = NULL;
 707      }
 708    wd->ad = _move_object_with_animation(wd->edje, fx, fy, fw, fh, tx, ty, tw, th,
 709                                        0.3, _move_evas_object, _end_selected_box, wd);
 710 }
 711
 712 static void
 713 _select_box(Elm_Controlbar_Item * it)
 714 {
 715    if (!it) return;
 716    Widget_Data * wd = elm_widget_data_get(it->obj);
 717    if (!wd) return;
 718    const Eina_List *l;
 719    Elm_Controlbar_Item * item, *fit = NULL;
 720    Evas_Object * content;
 721
 722    if (wd->animating) return;
 723
 724    wd->cur_item = it;
 725
 726    if (it->style == TABBAR)
 727      {
 728         content = elm_object_content_part_unset(wd->edje, "elm.swallow.view");
 729         if (content) evas_object_hide(content);
 730
 731         EINA_LIST_FOREACH(wd->items, l, item){
 732              if (item->selected) {
 733                   fit = item;
 734                   wd->pre_item = fit;
 735              }
 736              item->selected = EINA_FALSE;
 737         }
 738         it->selected = EINA_TRUE;
 739
 740         if ((fit != NULL) && (fit != it))
 741           {
 742              _move_selected_box(wd, fit, it);
 743           }
 744         else
 745           {
 746              edje_object_signal_emit(_EDJ(it->base), wd->selected_signal, "elm");
 747           }
 748
 749         if (fit != it)
 750           {
 751              if (wd->more_item != it)
 752                evas_object_smart_callback_call(it->obj, "view,change,before", it);
 753           }
 754
 755         elm_object_content_part_set(wd->edje, "elm.swallow.view", it->view);
 756      }
 757    else if (it->style == TOOLBAR)
 758      {
 759         edje_object_signal_emit(_EDJ(it->base), "elm,state,text_unselected", "elm");
 760         if (it->func)
 761           it->func(it->data, it->obj, it);
 762      }
 763 }
 764
 765 static void
 766 _cancel_selected_box(Widget_Data *wd)
 767 {
 768    const Eina_List *l;
 769    Elm_Controlbar_Item * item;
 770
 771    EINA_LIST_FOREACH(wd->items, l, item)
 772      {
 773         if (item->style == TABBAR)
 774           {
 775              if (item->selected)
 776                {
 777                   edje_object_signal_emit(_EDJ(item->base), wd->selected_signal, "elm");
 778                }
 779              else
 780                {
 781                   edje_object_signal_emit(_EDJ(item->base), "elm,state,unselected", "elm");
 782                }
 783           }
 784         else if (item->style == TOOLBAR)
 785           {
 786              edje_object_signal_emit(_EDJ(item->base), "elm,state,unselected", "elm");
 787           }
 788      }
 789 }
 790
 791 static void
 792 _unpress_box_cb(void *data, Evas_Object *obj, void *event_info)
 793 {
 794    Widget_Data * wd = (Widget_Data *) data;
 795    if (!wd) return;
 796
 797    _cancel_selected_box(wd);
 798 }
 799
 800 static void
 801 _clicked_box_cb(void *data, Evas_Object *obj, void *event_info)
 802 {
 803    Widget_Data * wd = (Widget_Data *) data;
 804    if (!wd) return;
 805
 806    _select_box(wd->pre_item);
 807 }
 808
 809 static Eina_Bool
 810 _press_box(Elm_Controlbar_Item * it)
 811 {
 812    Widget_Data * wd = elm_widget_data_get(it->obj);
 813    if (!wd) return EINA_FALSE;
 814    int check = 0;
 815    const Eina_List *l;
 816    Elm_Controlbar_Item * item;
 817
 818    if (wd->animating) return EINA_FALSE;
 819
 820    if (wd->disabled || it->disabled) return EINA_FALSE;
 821
 822    EINA_LIST_FOREACH(wd->items, l, item)
 823      {
 824         if (it == item)
 825           {
 826              if (it->style == TABBAR)
 827                {
 828                   edje_object_signal_emit(_EDJ(it->base), wd->pressed_signal, "elm");
 829                }
 830              else if (it->style == TOOLBAR)
 831                {
 832                   edje_object_signal_emit(_EDJ(it->base), "elm,state,toolbar_pressed", "elm");
 833                }
 834
 835              check = EINA_TRUE;
 836           }
 837      }
 838    if (!check)
 839      return EINA_FALSE;
 840
 841    wd->pre_item = it;
 842
 843    return EINA_TRUE;
 844 }
 845
 846 static Evas_Object *
 847 _create_item_icon(Evas_Object *obj, Elm_Controlbar_Item * it, char *part)
 848 {
 849
 850    Evas_Object *icon;
 851    icon = elm_icon_add(obj);
 852    if (!elm_icon_standard_set(icon, it->icon_path))
 853      {
 854         elm_icon_file_set(icon, it->icon_path, NULL);
 855      }
 856
 857    evas_object_size_hint_min_set(icon, 40, 40);
 858    evas_object_size_hint_max_set(icon, 100, 100);
 859    evas_object_show(icon);
 860    if (obj && part)
 861      elm_object_content_set(obj, icon);
 862
 863    return icon;
 864 }
 865
 866 static Evas_Object *
 867 _create_item_layout(Evas_Object * parent, Elm_Controlbar_Item * it, Evas_Object **item, Evas_Object **icon)
 868 {
 869
 870    Evas_Object * obj;
 871    obj = elm_layout_add(parent);
 872    if (obj == NULL)
 873      {
 874         fprintf(stderr, "Cannot load bg edj\n");
 875         return NULL;
 876      }
 877    elm_layout_theme_set(obj, "controlbar", "item_bg",
 878                         elm_widget_style_get(it->obj));
 879    evas_object_size_hint_weight_set(obj, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 880    evas_object_size_hint_align_set(obj, EVAS_HINT_FILL, EVAS_HINT_FILL);
 881
 882    *item = elm_button_add(parent);
 883    if (*item == NULL) return NULL;
 884    elm_object_style_set(*item, "controlbar/vertical");
 885    elm_object_content_part_set(obj, "item", *item);
 886
 887    if (it->text)
 888      elm_object_text_set(*item, it->text);
 889    if (it->icon_path)
 890      *icon = _create_item_icon(*item, it, "elm.swallow.icon");
 891
 892    return obj;
 893 }
 894
 895 static void
 896 _bar_item_down_cb(void *data, Evas_Object * obj, void *event_info __UNUSED__)
 897 {
 898    Widget_Data * wd = (Widget_Data *) data;
 899    const Eina_List *l;
 900    Elm_Controlbar_Item * item;
 901    if (wd->animating) return;
 902
 903    EINA_LIST_FOREACH(wd->items, l, item)
 904       if (item->base_item == obj) break;
 905
 906    if (item == NULL) return;
 907
 908    _press_box(item);
 909 }
 910
 911 static Elm_Controlbar_Item *
 912 _create_tab_item(Evas_Object * obj, const char *icon_path, const char *label,
 913                 Evas_Object * view)
 914 {
 915    Elm_Controlbar_Item * it;
 916    Widget_Data * wd;
 917    if (obj == NULL)
 918      {
 919         fprintf(stderr, "Invalid argument: controlbar object is NULL\n");
 920         return NULL;
 921      }
 922    wd = elm_widget_data_get(obj);
 923    if (!wd)
 924      {
 925         fprintf(stderr, "Cannot get smart data\n");
 926         return NULL;
 927      }
 928    it = ELM_NEW(Elm_Controlbar_Item);
 929    if (!it) return NULL;
 930    it->wd = wd;
 931    it->obj = obj;
 932    it->text = eina_stringshare_add(label);
 933    it->icon_path = eina_stringshare_add(icon_path);
 934    it->selected = EINA_FALSE;
 935    it->sel = 1;
 936    it->view = view;
 937    it->style = TABBAR;
 938    it->base = _create_item_layout(wd->edje, it, &(it->base_item), &(it->icon));
 939    evas_object_smart_callback_add(it->base_item, "pressed",
 940                                   _bar_item_down_cb, wd);
 941    evas_object_smart_callback_add(it->base_item, "unpressed", _unpress_box_cb, wd);
 942    evas_object_smart_callback_add(it->base_item, "clicked", _clicked_box_cb, wd);
 943    evas_object_show(it->base);
 944
 945    return it;
 946 }
 947
 948 static Elm_Controlbar_Item *
 949 _create_tool_item(Evas_Object * obj, const char *icon_path, const char *label,
 950                  void (*func) (void *data, Evas_Object * obj,
 951                                void *event_info), void *data)
 952 {
 953
 954    Elm_Controlbar_Item * it;
 955    Widget_Data * wd;
 956    if (obj == NULL)
 957      {
 958         fprintf(stderr, "Invalid argument: controlbar object is NULL\n");
 959         return NULL;
 960      }
 961    wd = elm_widget_data_get(obj);
 962    if (!wd)
 963      {
 964         fprintf(stderr, "Cannot get smart data\n");
 965         return NULL;
 966      }
 967    it = ELM_NEW(Elm_Controlbar_Item);
 968    if (!it)
 969      return NULL;
 970    it->wd = wd;
 971    it->obj = obj;
 972    it->text = eina_stringshare_add(label);
 973    it->icon_path = eina_stringshare_add(icon_path);
 974    it->selected = EINA_FALSE;
 975    it->sel = 1;
 976    it->func = func;
 977    it->data = data;
 978    it->style = TOOLBAR;
 979    it->base = _create_item_layout(wd->edje, it, &(it->base_item), &(it->icon));
 980    evas_object_smart_callback_add(it->base_item, "pressed",
 981                                   _bar_item_down_cb, wd);
 982    evas_object_smart_callback_add(it->base_item, "unpressed", _unpress_box_cb, wd);
 983    evas_object_smart_callback_add(it->base_item, "clicked", _clicked_box_cb, wd);
 984    evas_object_show(it->base);
 985
 986    return it;
 987 }
 988
 989 static Elm_Controlbar_Item *
 990 _create_object_item(Evas_Object * obj, Evas_Object * obj_item, const int sel)
 991 {
 992    Elm_Controlbar_Item * it;
 993    Widget_Data * wd;
 994    if (obj == NULL)
 995      {
 996         fprintf(stderr, "Invalid argument: controlbar object is NULL\n");
 997         return NULL;
 998      }
 999    wd = elm_widget_data_get(obj);
1000    if (!wd)
1001      {
1002         fprintf(stderr, "Cannot get smart data\n");
1003         return NULL;
1004      }
1005    it = ELM_NEW(Elm_Controlbar_Item);
1006    if (!it)
1007      return NULL;
1008    it->wd = wd;
1009    it->obj = obj;
1010    it->sel = sel;
1011    it->style = OBJECT;
1012    it->base = elm_layout_add(wd->edje);
1013    elm_layout_theme_set(it->base, "controlbar", "item_bg",
1014                         elm_widget_style_get(it->obj));
1015    evas_object_size_hint_weight_set(it->base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1016    evas_object_size_hint_align_set(it->base, EVAS_HINT_FILL, EVAS_HINT_FILL);
1017    it->base_item = obj_item;
1018    elm_object_content_part_set(it->base, "item", it->base_item);
1019    evas_object_show(it->base);
1020    return it;
1021 }
1022
1023 static void
1024 _repack_items(Widget_Data *wd)
1025 {
1026    const Eina_List *l;
1027    Elm_Controlbar_Item * item;
1028
1029    EINA_LIST_FOREACH(wd->items, l, item)
1030      {
1031         if (item->order > 0)
1032           {
1033              elm_table_unpack(wd->box, item->base);
1034              if (!wd->vertical)
1035                elm_table_pack(wd->box, item->base, item->order - 1, 0, item->sel, 1);
1036              else
1037                elm_table_pack(wd->box, item->base, 0, item->order - 1, item->sel, 1);
1038           }
1039      }
1040 }
1041
1042 static void
1043 _set_items_position(Evas_Object * obj, Elm_Controlbar_Item * it,
1044                    Elm_Controlbar_Item * mit, Eina_Bool bar)
1045 {
1046    Widget_Data * wd;
1047    const Eina_List *l;
1048    Elm_Controlbar_Item * item;
1049    int check = EINA_FALSE;
1050    int order = 1;
1051
1052    if (obj == NULL)
1053      {
1054         fprintf(stderr, "Invalid argument: controlbar object is NULL\n");
1055         return;
1056      }
1057    wd = elm_widget_data_get(obj);
1058    if (!wd)
1059      {
1060         fprintf(stderr, "Cannot get smart data\n");
1061         return;
1062      }
1063
1064    EINA_LIST_FOREACH(wd->items, l, item)
1065      {
1066         if ((item == mit) && (item->order > 0))
1067           {
1068              check = EINA_TRUE;
1069              it->order = mit->order;
1070           }
1071         if (check)
1072           {
1073              if (item->order > 0)
1074                {
1075                   elm_table_unpack(wd->box, item->base);
1076                   item->order += it->sel;
1077                   if (!wd->vertical)
1078                     elm_table_pack(wd->box, item->base, item->order - 1, 0, item->sel, 1);
1079                   else
1080                     elm_table_pack(wd->box, item->base, 0, item->order - 1, item->sel, 1);
1081                }
1082           }
1083         if (item->order > 0) order += item->sel;
1084      }
1085    if (!check)
1086      {
1087         if (bar)
1088           it->order = order;
1089         else
1090           it->order = 0;
1091      }
1092    wd->num++;
1093
1094    if (bar)
1095      {
1096         if (!wd->vertical)
1097           elm_table_pack(wd->box, it->base, it->order - 1, 0, it->sel, 1);
1098         else
1099           elm_table_pack(wd->box, it->base, 0, it->order - 1, it->sel, 1);
1100      }
1101    else
1102      evas_object_hide(it->base);
1103 }
1104
1105 static void
1106 _list_clicked(void *data, Evas_Object *obj, void *event_info __UNUSED__)
1107 {
1108    Elm_Controlbar_Item *item = (Elm_Controlbar_Item *)data;
1109    Elm_Controlbar_Item *it;
1110    const Eina_List *l;
1111    Widget_Data *wd;
1112    Evas_Object *content;
1113    Elm_List_Item *lit = (Elm_List_Item *) elm_list_selected_item_get(obj);
1114    if (!lit) return;
1115
1116    elm_list_item_selected_set(lit, 0);
1117
1118    if (!item) return;
1119
1120    wd = elm_widget_data_get(item->obj);
1121    if (!wd) return;
1122
1123    EINA_LIST_FOREACH(wd->items, l, it)
1124      {
1125         it->selected = EINA_FALSE;
1126      }
1127
1128    if (item->style == TABBAR)
1129      {
1130         content = elm_object_content_part_unset(wd->edje, "elm.swallow.view");
1131         evas_object_hide(content);
1132         item->selected = EINA_TRUE;
1133         evas_object_smart_callback_call(item->obj, "view,change,before", item);
1134         elm_object_content_part_set(wd->edje, "elm.swallow.view", item->view);
1135      }
1136
1137    if ((item->style == TOOLBAR) && (item->func))
1138      item->func(item->data, item->obj, item);
1139 }
1140
1141 static Evas_Object *
1142 _create_more_view(Widget_Data *wd)
1143 {
1144    Evas_Object *list;
1145    Elm_Controlbar_Item *item;
1146    const Eina_List *l;
1147    Evas_Object *icon;
1148
1149    list = elm_list_add( wd->object );
1150    elm_list_mode_set( list, ELM_LIST_COMPRESS );
1151
1152    EINA_LIST_FOREACH(wd->items, l, item)
1153      {
1154         if (item->order <= 0)
1155           {
1156              icon = NULL;
1157              if (item->icon_path)
1158                {
1159                   icon = _create_item_icon(list, item, NULL);
1160                   evas_object_color_set(icon, 0, 0, 0, 255);
1161                }
1162              elm_list_item_append(list, item->text, icon, NULL, _list_clicked, item);
1163           }
1164      }
1165
1166    elm_list_go( list );
1167
1168    return list;
1169 }
1170
1171 static void _ctxpopup_cb(void *data, Evas_Object *obj, void *event_info)
1172 {
1173    Elm_Controlbar_Item *it;
1174    const Eina_List *l;
1175    Evas_Object *ctxpopup = obj;
1176    const char *label;
1177    Widget_Data *wd = (Widget_Data *)data;
1178
1179    EINA_LIST_FOREACH(wd->items, l, it)
1180      {
1181         label = elm_ctxpopup_item_label_get((Elm_Ctxpopup_Item *) event_info);
1182         if ((label) && (!strcmp(it->text, label))) break;
1183      }
1184
1185    if (it->func)
1186      it->func(it->data, it->obj, it);
1187
1188    if (_check_item(wd, it)) evas_object_smart_callback_call(it->obj, "clicked", it);
1189
1190    evas_object_del(ctxpopup);
1191    ctxpopup = NULL;
1192 }
1193
1194 static void _ctxpopup_dismissed_cb(void *data __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
1195 {
1196    Evas_Object *ctxpopup = obj;
1197
1198    evas_object_del(ctxpopup);
1199    ctxpopup = NULL;
1200 }
1201
1202 static void
1203 _create_more_func(void *data __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
1204 {
1205    Evas_Object *ctxpopup;
1206    Elm_Controlbar_Item *item;
1207    const Eina_List *l;
1208    Evas_Object *icon;
1209    Evas_Coord x, y, w, h;
1210    Widget_Data *wd = elm_widget_data_get(obj);
1211    if (!wd) return;
1212
1213    ctxpopup = elm_ctxpopup_add(wd->parent);
1214    evas_object_smart_callback_add( ctxpopup, "dismissed", _ctxpopup_dismissed_cb, wd);
1215
1216    EINA_LIST_FOREACH(wd->items, l, item)
1217      {
1218         if (item->order <= 0)
1219           {
1220              icon = NULL;
1221              if (item->icon_path)
1222                {
1223                   icon = _create_item_icon(ctxpopup, item, NULL);
1224                   evas_object_color_set(icon, 0, 0, 0, 255);
1225                }
1226              elm_ctxpopup_item_append(ctxpopup, item->text, icon, _ctxpopup_cb, wd);
1227           }
1228      }
1229
1230    evas_object_geometry_get(wd->more_item->base, &x, &y, &w, &h);
1231    evas_object_move(ctxpopup, x + w/2, y + h/2);
1232
1233    evas_object_show(ctxpopup);
1234 }
1235
1236 static Elm_Controlbar_Item *
1237 _create_more_item(Widget_Data *wd, int style)
1238 {
1239    Elm_Controlbar_Item * it;
1240
1241    it = ELM_NEW(Elm_Controlbar_Item);
1242    if (!it) return NULL;
1243    it->obj = wd->object;
1244    it->text = eina_stringshare_add("more");
1245    it->icon_path = eina_stringshare_add(CONTROLBAR_SYSTEM_ICON_MORE);
1246    it->selected = EINA_FALSE;
1247    it->sel = 1;
1248    it->view = _create_more_view(wd);
1249    it->func = _create_more_func;
1250    it->style = style;
1251    it->base = _create_item_layout(wd->edje, it, &(it->base_item), &(it->icon));
1252    evas_object_smart_callback_add(it->base_item, "pressed",
1253                                   _bar_item_down_cb, wd);
1254    evas_object_smart_callback_add(it->base_item, "unpressed", _unpress_box_cb, wd);
1255    evas_object_smart_callback_add(it->base_item, "clicked", _clicked_box_cb, wd);
1256    evas_object_show(it->base);
1257
1258    _set_items_position(it->obj, it, NULL, EINA_TRUE);
1259    wd->items = eina_list_append(wd->items, it);
1260    wd->more_item = it;
1261    wd->items = eina_list_sort(wd->items, eina_list_count(wd->items), _sort_cb);
1262
1263    return it;
1264 }
1265
1266 ///////////////////////////////////////////////////////////////////
1267 //
1268 //  API function
1269 //
1270 ////////////////////////////////////////////////////////////////////
1271
1272 /**
1273  * Add a new controlbar object
1274  *
1275  * @param parent The parent object
1276  * @return The new object or NULL if it cannot be created
1277  *
1278  * @ingroup Controlbar
1279  */
1280 EAPI Evas_Object * elm_controlbar_add(Evas_Object * parent)
1281 {
1282    if (parent == NULL) return NULL;
1283    Evas_Object * obj = NULL;
1284    Evas_Object * bg = NULL;
1285    Widget_Data * wd = NULL;
1286    Evas_Coord x, y, w, h;
1287    Evas *e;
1288    ELM_WIDGET_STANDARD_SETUP(wd, Widget_Data, parent, e, obj, NULL);
1289    ELM_SET_WIDTYPE(widtype, "controlbar");
1290    elm_widget_type_set(obj, "controlbar");
1291    elm_widget_sub_object_add(parent, obj);
1292    elm_widget_data_set(obj, wd);
1293    elm_widget_del_hook_set(obj, _del_hook);
1294    elm_widget_can_focus_set(obj, EINA_FALSE);
1295    elm_widget_theme_hook_set(obj, _theme_hook);
1296    elm_widget_disable_hook_set(obj, _disable_hook);
1297
1298    // initialization
1299    wd->parent = parent;
1300    evas_object_geometry_get(parent, &x, &y, &w, &h);
1301    wd->object = obj;
1302    wd->x = x;
1303    wd->y = y;
1304    wd->w = w;
1305    wd->h = h;
1306    wd->mode = ELM_CONTROLBAR_MODE_DEFAULT;
1307    wd->alpha = 100;
1308    wd->num = 0;
1309    wd->animating = 0;
1310    wd->vertical = EINA_FALSE;
1311    wd->auto_align = EINA_FALSE;
1312    wd->selected_animation = EINA_FALSE;
1313    wd->pressed_signal = eina_stringshare_add("elm,state,pressed");
1314    wd->selected_signal = eina_stringshare_add("elm,state,selected");
1315
1316    /* load background edj */
1317    wd->edje = elm_layout_add(obj);
1318    elm_layout_theme_set(wd->edje, "controlbar", "base", "default");
1319    if (wd->edje == NULL)
1320      {
1321         printf("Cannot load base edj\n");
1322         return NULL;
1323      }
1324    evas_object_show(wd->edje);
1325
1326    wd->bg = elm_layout_add(wd->edje);
1327    elm_layout_theme_set(wd->bg, "controlbar", "background", "default");
1328    if (wd->bg == NULL)
1329      {
1330         printf("Cannot load bg edj\n");
1331         return NULL;
1332      }
1333    elm_object_content_part_set(wd->edje, "bg_image", wd->bg);
1334
1335    // initialization
1336    evas_object_event_callback_add(wd->edje, EVAS_CALLBACK_RESIZE,
1337                                   _controlbar_object_resize, obj);
1338    evas_object_event_callback_add(wd->edje, EVAS_CALLBACK_MOVE,
1339                                   _controlbar_object_move, obj);
1340    evas_object_event_callback_add(wd->edje, EVAS_CALLBACK_SHOW,
1341                                   _controlbar_object_show, obj);
1342    evas_object_event_callback_add(wd->edje, EVAS_CALLBACK_HIDE,
1343                                   _controlbar_object_hide, obj);
1344
1345    bg = elm_object_content_part_get(wd->edje, "bg_image");
1346    evas_object_event_callback_add(bg, EVAS_CALLBACK_MOVE, _controlbar_object_move, obj);
1347    evas_object_event_callback_add(bg, EVAS_CALLBACK_RESIZE, _controlbar_object_resize, obj);
1348
1349    // items container
1350    wd->box = elm_table_add(wd->edje);
1351    elm_table_homogeneous_set(wd->box, EINA_TRUE);
1352    evas_object_size_hint_weight_set(wd->box, EVAS_HINT_EXPAND,
1353                                     EVAS_HINT_EXPAND);
1354    evas_object_size_hint_align_set(wd->box, EVAS_HINT_FILL, EVAS_HINT_FILL);
1355    elm_object_content_part_set(wd->edje, "elm.swallow.items", wd->box);
1356    evas_object_show(wd->box);
1357
1358    evas_object_smart_callback_add(obj, "sub-object-del", _sub_del, obj);
1359
1360    elm_widget_resize_object_set(obj, wd->edje);
1361
1362    _sizing_eval(obj);
1363
1364    return obj;
1365 }
1366
1367 /**
1368  * Append new tab item
1369  *
1370  * @param       obj The controlbar object
1371  * @param       icon_path The icon path of item
1372  * @param       label The label of item
1373  * @param       view The view of item
1374  * @return      The item of controlbar
1375  *
1376  * @ingroup Controlbar
1377  */
1378 EAPI Elm_Controlbar_Item * elm_controlbar_tab_item_append(Evas_Object * obj,
1379                                                           const char
1380                                                           *icon_path,
1381                                                           const char *label,
1382                                                           Evas_Object *
1383                                                           view)
1384 {
1385    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1386    Elm_Controlbar_Item * it;
1387    Elm_Controlbar_Item * lit;
1388    Widget_Data * wd;
1389    it = _create_tab_item(obj, icon_path, label, view);
1390    if (!it) return NULL;
1391    wd = elm_widget_data_get(obj);
1392    if ((_check_bar_item_number(wd) >= 5) && (wd->auto_align))
1393      {
1394         if (!wd->more_item) {
1395              lit = elm_controlbar_last_item_get(obj);
1396              _set_item_visible(lit, EINA_FALSE);
1397              _create_more_item(wd, TABBAR);
1398         }
1399         _set_items_position(obj, it, NULL, EINA_FALSE);
1400    }
1401    else{
1402         _set_items_position(obj, it, NULL, EINA_TRUE);
1403    }
1404    wd->items = eina_list_append(wd->items, it);
1405    if (wd->more_item)
1406      elm_controlbar_item_view_set(wd->more_item, _create_more_view(wd));
1407
1408    _check_background(wd);
1409    _sizing_eval(obj);
1410    return it;
1411 }
1412
1413 /**
1414  * Prepend new tab item
1415  *
1416  * @param       obj The controlbar object
1417  * @param       icon_path The icon path of item
1418  * @param       label The label of item
1419  * @param       view The view of item
1420  * @return      The item of controlbar
1421  *
1422  * @ingroup Controlbar
1423  */
1424 EAPI Elm_Controlbar_Item * elm_controlbar_tab_item_prepend(Evas_Object *
1425                                                            obj,
1426                                                            const char
1427                                                            *icon_path,
1428                                                            const char
1429                                                            *label,
1430                                                            Evas_Object *
1431                                                            view)
1432 {
1433    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1434    Widget_Data * wd;
1435    Elm_Controlbar_Item * it;
1436    Elm_Controlbar_Item * lit;
1437    Elm_Controlbar_Item * item;
1438    it = _create_tab_item(obj, icon_path, label, view);
1439    if (!it) return NULL;
1440    wd = elm_widget_data_get(obj);
1441    item = eina_list_data_get(wd->items);
1442    if ((_check_bar_item_number(wd) >= 5) && (wd->auto_align))
1443      {
1444         if (!wd->more_item) {
1445              lit = elm_controlbar_last_item_get(obj);
1446              _set_item_visible(lit, EINA_FALSE);
1447              _create_more_item(wd, TABBAR);
1448         }
1449         lit = elm_controlbar_item_prev(wd->more_item);
1450         _set_item_visible(lit, EINA_FALSE);
1451         _set_items_position(obj, it, item, EINA_TRUE);
1452    }
1453    else{
1454         _set_items_position(obj, it, item, EINA_TRUE);
1455    }
1456    wd->items = eina_list_prepend(wd->items, it);
1457    if (wd->more_item)
1458      elm_controlbar_item_view_set(wd->more_item, _create_more_view(wd));
1459
1460    _check_background(wd);
1461    _sizing_eval(obj);
1462    return it;
1463 }
1464
1465 /**
1466  * Insert new tab item before given item
1467  *
1468  * @param       obj The controlbar object
1469  * @param       before The given item
1470  * @param       icon_path The icon path of item
1471  * @param       label The label of item
1472  * @param       view The view of item
1473  * @return      The item of controlbar
1474  *
1475  * @ingroup Controlbar
1476  */
1477 EAPI Elm_Controlbar_Item *
1478 elm_controlbar_tab_item_insert_before(Evas_Object * obj,
1479                                       Elm_Controlbar_Item * before,
1480                                       const char *icon_path,
1481                                       const char *label, Evas_Object * view)
1482 {
1483    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1484    Widget_Data * wd;
1485    Elm_Controlbar_Item * it;
1486    Elm_Controlbar_Item * lit;
1487    if (!before) return NULL;
1488    it = _create_tab_item(obj, icon_path, label, view);
1489    if (!it) return NULL;
1490    wd = elm_widget_data_get(obj);
1491    if ((_check_bar_item_number(wd) >= 5) && (wd->auto_align))
1492      {
1493         if (!wd->more_item)
1494           {
1495              lit = elm_controlbar_last_item_get(obj);
1496              _set_item_visible(lit, EINA_FALSE);
1497              _create_more_item(wd, TABBAR);
1498           }
1499         before = wd->more_item;
1500         if (before->order > 0)
1501           {
1502              lit = elm_controlbar_item_prev(wd->more_item);
1503              _set_item_visible(lit, EINA_FALSE);
1504              _set_items_position(obj, it, before, EINA_TRUE);
1505           }
1506         else
1507           {
1508              _set_items_position(obj, it, before, EINA_FALSE);
1509           }
1510    }
1511    else{
1512         _set_items_position(obj, it, before, EINA_TRUE);
1513    }
1514    wd->items = eina_list_prepend_relative(wd->items, it, before);
1515    if (wd->more_item)
1516      elm_controlbar_item_view_set(wd->more_item, _create_more_view(wd));
1517
1518    _check_background(wd);
1519    _sizing_eval(obj);
1520    return it;
1521 }
1522
1523 /**
1524  * Insert new tab item after given item
1525  *
1526  * @param       obj The controlbar object
1527  * @param       after The given item
1528  * @param       icon_path The icon path of item
1529  * @param       label The label of item
1530  * @param       view The view of item
1531  * @return      The item of controlbar
1532  *
1533  * @ingroup Controlbar
1534  */
1535 EAPI Elm_Controlbar_Item *
1536 elm_controlbar_tab_item_insert_after(Evas_Object * obj,
1537                                      Elm_Controlbar_Item * after,
1538                                      const char *icon_path, const char *label,
1539                                      Evas_Object * view)
1540 {
1541    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1542    Widget_Data * wd;
1543    Elm_Controlbar_Item * it;
1544    Elm_Controlbar_Item * lit;
1545    Elm_Controlbar_Item * item;
1546    if (!after) return NULL;
1547    it = _create_tab_item(obj, icon_path, label, view);
1548    if (!it) return NULL;
1549    wd = elm_widget_data_get(obj);
1550    item = elm_controlbar_item_next(after);
1551    if ((_check_bar_item_number(wd) >= 5) && (wd->auto_align))
1552      {
1553         if (!wd->more_item)
1554           {
1555              lit = elm_controlbar_last_item_get(obj);
1556              _set_item_visible(lit, EINA_FALSE);
1557              _create_more_item(wd, TABBAR);
1558           }
1559         lit = elm_controlbar_item_prev(wd->more_item);
1560         if ((lit != after) && (item->order > 0))
1561           {
1562              _set_item_visible(lit, EINA_FALSE);
1563              _set_items_position(obj, it, item, EINA_TRUE);
1564           }
1565         else
1566           {
1567              _set_items_position(obj, it, NULL, EINA_FALSE);
1568           }
1569    }
1570    else{
1571         _set_items_position(obj, it, item, EINA_TRUE);
1572    }
1573    wd->items = eina_list_append_relative(wd->items, it, after);
1574    if (wd->more_item)
1575      elm_controlbar_item_view_set(wd->more_item, _create_more_view(wd));
1576
1577    _check_background(wd);
1578    _sizing_eval(obj);
1579    return it;
1580 }
1581
1582 /**
1583  * Append new tool item
1584  *
1585  * @param       obj The controlbar object
1586  * @param       icon_path The icon path of item
1587  * @param       label The label of item
1588  * @param       func Callback function of item
1589  * @param       data The data of callback function
1590  * @return      The item of controlbar
1591  *
1592  * @ingroup Controlbar
1593  */
1594 EAPI Elm_Controlbar_Item * elm_controlbar_tool_item_append(Evas_Object *
1595                                                            obj,
1596                                                            const char
1597                                                            *icon_path,
1598                                                            const char
1599                                                            *label,
1600                                                            void (*func)
1601                                                            (void *data,
1602                                                             Evas_Object *
1603                                                             obj,
1604                                                             void
1605                                                             *event_info),
1606                                                            void *data)
1607
1608 {
1609    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1610    Elm_Controlbar_Item * it;
1611    Elm_Controlbar_Item * lit;
1612    Widget_Data * wd;
1613    it = _create_tool_item(obj, icon_path, label, func, data);
1614    if (!it) return NULL;
1615    wd = elm_widget_data_get(obj);
1616    if ((_check_bar_item_number(wd) >= 5) && (wd->auto_align))
1617      {
1618         if (!wd->more_item) {
1619              lit = elm_controlbar_last_item_get(obj);
1620              _set_item_visible(lit, EINA_FALSE);
1621              _create_more_item(wd, TOOLBAR);
1622         }
1623         _set_items_position(obj, it, NULL, EINA_FALSE);
1624    }
1625    else{
1626         _set_items_position(obj, it, NULL, EINA_TRUE);
1627    }
1628    wd->items = eina_list_append(wd->items, it);
1629    _check_toolbar_line(wd);
1630    _sizing_eval(obj);
1631    return it;
1632 }
1633
1634 /**
1635  * Prepend new tool item
1636  *
1637  * @param       obj The controlbar object
1638  * @param       icon_path The icon path of item
1639  * @param       label The label of item
1640  * @param       func Callback function of item
1641  * @param       data The data of callback function
1642  * @return      The item of controlbar
1643  *
1644  * @ingroup Controlbar
1645  */
1646 EAPI Elm_Controlbar_Item * elm_controlbar_tool_item_prepend(Evas_Object *
1647                                                             obj,
1648                                                             const char
1649                                                             *icon_path,
1650                                                             const char
1651                                                             *label,
1652                                                             void (*func)
1653                                                             (void
1654                                                              *data,
1655                                                              Evas_Object *
1656                                                              obj,
1657                                                              void
1658                                                              *event_info),
1659                                                             void
1660                                                             *data)
1661 {
1662    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1663    Widget_Data * wd;
1664    Elm_Controlbar_Item * it;
1665    Elm_Controlbar_Item * lit;
1666    Elm_Controlbar_Item * item;
1667    it = _create_tool_item(obj, icon_path, label, func, data);
1668    if (!it) return NULL;
1669    wd = elm_widget_data_get(obj);
1670    item = eina_list_data_get(wd->items);
1671    if ((_check_bar_item_number(wd) >= 5) && (wd->auto_align))
1672      {
1673         if (!wd->more_item) {
1674              lit = elm_controlbar_last_item_get(obj);
1675              _set_item_visible(lit, EINA_FALSE);
1676              _create_more_item(wd, TOOLBAR);
1677         }
1678         lit = elm_controlbar_item_prev(wd->more_item);
1679         _set_item_visible(lit, EINA_FALSE);
1680         _set_items_position(obj, it, item, EINA_TRUE);
1681    }
1682    else{
1683         _set_items_position(obj, it, item, EINA_TRUE);
1684    }
1685    wd->items = eina_list_prepend(wd->items, it);
1686    _check_toolbar_line(wd);
1687    _sizing_eval(obj);
1688    return it;
1689 }
1690
1691 /**
1692  * Insert new tool item before given item
1693  *
1694  * @param       obj The controlbar object
1695  * @param       before The given item
1696  * @param       icon_path The icon path of item
1697  * @param       label The label of item
1698  * @param       func Callback function of item
1699  * @param       data The data of callback function
1700  * @return      The item of controlbar
1701  *
1702  * @ingroup Controlbar
1703  */
1704 EAPI Elm_Controlbar_Item *
1705 elm_controlbar_tool_item_insert_before(Evas_Object * obj,
1706                                        Elm_Controlbar_Item * before,
1707                                        const char *icon_path,
1708                                        const char *label,
1709                                        void (*func) (void *data,
1710                                                      Evas_Object * obj,
1711                                                      void *event_info),
1712                                        void *data)
1713 {
1714    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1715    Widget_Data * wd;
1716    Elm_Controlbar_Item * it;
1717    Elm_Controlbar_Item * lit;
1718    if (!before) return NULL;
1719    it = _create_tool_item(obj, icon_path, label, func, data);
1720    if (!it) return NULL;
1721    wd = elm_widget_data_get(obj);
1722    if ((_check_bar_item_number(wd) >= 5) && (wd->auto_align))
1723      {
1724         if (!wd->more_item)
1725           {
1726              lit = elm_controlbar_last_item_get(obj);
1727              _set_item_visible(lit, EINA_FALSE);
1728              _create_more_item(wd, TOOLBAR);
1729           }
1730         before = wd->more_item;
1731         if (before->order > 0)
1732           {
1733              lit = elm_controlbar_item_prev(wd->more_item);
1734              _set_item_visible(lit, EINA_FALSE);
1735              _set_items_position(obj, it, before, EINA_TRUE);
1736           }
1737         else
1738           {
1739              _set_items_position(obj, it, before, EINA_FALSE);
1740           }
1741    }
1742    else{
1743         _set_items_position(obj, it, before, EINA_TRUE);
1744    }
1745    wd->items = eina_list_prepend_relative(wd->items, it, before);
1746    _check_toolbar_line(wd);
1747    _sizing_eval(obj);
1748    return it;
1749 }
1750
1751 /**
1752  * Insert new tool item after given item
1753  *
1754  * @param       obj The controlbar object
1755  * @param       after The given item
1756  * @param       icon_path The icon path of item
1757  * @param       label The label of item
1758  * @param       func Callback function of item
1759  * @param       data The data of callback function
1760  * @return      The item of controlbar
1761  *
1762  * @ingroup Controlbar
1763  */
1764 EAPI Elm_Controlbar_Item *
1765 elm_controlbar_tool_item_insert_after(Evas_Object * obj,
1766                                       Elm_Controlbar_Item * after,
1767                                       const char *icon_path,
1768                                       const char *label,
1769                                       void (*func) (void *data,
1770                                                     Evas_Object * obj,
1771                                                     void *event_info),
1772                                       void *data)
1773 {
1774    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1775    Widget_Data * wd;
1776    Elm_Controlbar_Item * it;
1777    Elm_Controlbar_Item * lit;
1778    Elm_Controlbar_Item * item;
1779    if (!after) return NULL;
1780    it = _create_tool_item(obj, icon_path, label, func, data);
1781    if (!it) return NULL;
1782    wd = elm_widget_data_get(obj);
1783    item = elm_controlbar_item_next(after);
1784    if ((_check_bar_item_number(wd) >= 5) && (wd->auto_align))
1785      {
1786         if (!wd->more_item)
1787           {
1788              lit = elm_controlbar_last_item_get(obj);
1789              _set_item_visible(lit, EINA_FALSE);
1790              _create_more_item(wd, TOOLBAR);
1791           }
1792         lit = elm_controlbar_item_prev(wd->more_item);
1793         if ((lit != after) && (item->order > 0))
1794           {
1795              _set_item_visible(lit, EINA_FALSE);
1796              _set_items_position(obj, it, item, EINA_TRUE);
1797           }
1798         else
1799           {
1800              _set_items_position(obj, it, NULL, EINA_FALSE);
1801           }
1802    }
1803    else{
1804         _set_items_position(obj, it, item, EINA_TRUE);
1805    }
1806    wd->items = eina_list_append_relative(wd->items, it, after);
1807    _check_toolbar_line(wd);
1808    _sizing_eval(obj);
1809    return it;
1810 }
1811
1812 /**
1813  * Append new object item
1814  *
1815  * @param       obj The controlbar object
1816  * @param       obj_item The object of item
1817  * @param       sel The number of sel occupied
1818  * @return  The item of controlbar
1819  *
1820  * @ingroup Controlbar
1821  */
1822 EAPI Elm_Controlbar_Item * elm_controlbar_object_item_append(Evas_Object *
1823                                                              obj,
1824                                                              Evas_Object *
1825                                                              obj_item,
1826                                                              const int sel)
1827 {
1828    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1829    Widget_Data * wd;
1830    Elm_Controlbar_Item * it;
1831    wd = elm_widget_data_get(obj);
1832    if (!wd) return NULL;
1833    it = _create_object_item(obj, obj_item, sel);
1834    if (!it) return NULL;
1835    _set_items_position(obj, it, NULL, EINA_TRUE);
1836    wd->items = eina_list_append(wd->items, it);
1837    _sizing_eval(obj);
1838    return it;
1839 }
1840
1841 /**
1842  * Prepend new object item
1843  *
1844  * @param       obj The controlbar object
1845  * @param       obj_item The object of item
1846  * @param       sel The number of sel occupied
1847  * @return  The item of controlbar
1848  *
1849  * @ingroup Controlbar
1850  */
1851 EAPI Elm_Controlbar_Item * elm_controlbar_object_item_prepend(Evas_Object *
1852                                                               obj,
1853                                                               Evas_Object *
1854                                                               obj_item,
1855                                                               const int sel)
1856 {
1857    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1858    Widget_Data * wd;
1859    Elm_Controlbar_Item * it;
1860    Elm_Controlbar_Item * item;
1861    wd = elm_widget_data_get(obj);
1862    if (!wd) return NULL;
1863    it = _create_object_item(obj, obj_item, sel);
1864    if (!it) return NULL;
1865    item = eina_list_data_get(wd->items);
1866    _set_items_position(obj, it, item, EINA_TRUE);
1867    wd->items = eina_list_prepend(wd->items, it);
1868    _sizing_eval(obj);
1869    return it;
1870 }
1871
1872 /**
1873  * Insert new object item before given item
1874  *
1875  * @param       obj The controlbar object
1876  * @param       before The given item
1877  * @param       obj_item The object of item
1878  * @param       sel The number of sel occupied
1879  * @return  The item of controlbar
1880  *
1881  * @ingroup Controlbar
1882  */
1883 EAPI Elm_Controlbar_Item *
1884 elm_controlbar_object_item_insert_before(Evas_Object * obj,
1885                                          Elm_Controlbar_Item * before,
1886                                          Evas_Object * obj_item, const int sel)
1887 {
1888    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1889    Widget_Data * wd;
1890    Elm_Controlbar_Item * it;
1891    wd = elm_widget_data_get(obj);
1892    if (!wd) return NULL;
1893    if (!before) return NULL;
1894    it = _create_object_item(obj, obj_item, sel);
1895    if (!it) return NULL;
1896    _set_items_position(obj, it, before, EINA_TRUE);
1897    wd->items = eina_list_prepend_relative(wd->items, it, before);
1898    _sizing_eval(obj);
1899    return it;
1900 }
1901
1902 /**
1903  * Insert new object item after given item
1904  *
1905  * @param       obj The controlbar object
1906  * @param       after The given item
1907  * @param       obj_item The object of item
1908  * @param       sel The number of sel occupied
1909  * @return  The item of controlbar
1910  *
1911  * @ingroup Controlbar
1912  */
1913 EAPI Elm_Controlbar_Item *
1914 elm_controlbar_object_item_insert_after(Evas_Object * obj,
1915                                         Elm_Controlbar_Item * after,
1916                                         Evas_Object * obj_item, const int sel)
1917 {
1918    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1919    Widget_Data * wd;
1920    Elm_Controlbar_Item * it;
1921    Elm_Controlbar_Item * item;
1922    wd = elm_widget_data_get(obj);
1923    if (!wd) return NULL;
1924    if (!after) return NULL;
1925    it = _create_object_item(obj, obj_item, sel);
1926    if (!it) return NULL;
1927    item = elm_controlbar_item_next(after);
1928    _set_items_position(obj, it, item, EINA_TRUE);
1929    wd->items = eina_list_append_relative(wd->items, it, after);
1930    _sizing_eval(obj);
1931    return it;
1932 }
1933
1934 /**
1935  * Get the object of the object item
1936  *
1937  * @param       it The item of controlbar
1938  * @return      The object of the object item
1939  *
1940  * @ingroup Controlbar
1941  */
1942 EAPI Evas_Object *
1943 elm_controlbar_object_item_object_get(const Elm_Controlbar_Item * it)
1944 {
1945    if (!it) return NULL;
1946    if (it->style != OBJECT) return NULL;
1947    if (!it->base_item) return NULL;
1948    return it->base_item;
1949 }
1950
1951 /**
1952  * Delete item from controlbar
1953  *
1954  * @param       it The item of controlbar
1955
1956  * @ingroup Controlbar
1957  */
1958 EAPI void
1959 elm_controlbar_item_del(Elm_Controlbar_Item * it)
1960 {
1961    Evas_Object * obj;
1962    Widget_Data * wd;
1963    const Eina_List *l;
1964
1965    Elm_Controlbar_Item * item;
1966
1967    int sel = 1;
1968
1969    if (!it) return;
1970
1971    obj = it->obj;
1972    if (it->obj == NULL)
1973      {
1974         printf("Invalid argument: controlbar object is NULL\n");
1975         return;
1976      }
1977    wd = elm_widget_data_get(it->obj);
1978    if (!wd)
1979      {
1980         printf("Cannot get smart data\n");
1981         return;
1982      }
1983
1984    // unpack base item
1985    if (it->order > 0)
1986      {
1987         if (it->base)
1988           elm_table_unpack(wd->box, it->base);
1989         sel = it->sel;
1990         EINA_LIST_FOREACH(wd->items, l, item)
1991           {
1992              if (it != item)
1993                {
1994                   if (item->order > it->order)
1995                     {
1996                        if (item->base)
1997                          elm_table_unpack(wd->box, item->base);
1998                        item->order -= sel;
1999                        if (!wd->vertical)
2000                          elm_table_pack(wd->box, item->base, item->order - 1, 0, item->sel, 1);
2001                        else
2002                          elm_table_pack(wd->box, item->base, 0, item->order - 1, item->sel, 1);
2003                     }
2004                }
2005           }
2006      }
2007
2008    // delete item in list
2009    _item_del(it);
2010    wd->items = eina_list_remove(wd->items, it);
2011    free(it);
2012    it = NULL;
2013    wd->num = wd->num - 1;
2014    _sizing_eval(obj);
2015 }
2016
2017 /**
2018  * Select item in controlbar
2019  *
2020  * @param       it The item of controlbar
2021
2022  * @ingroup Controlbar
2023  */
2024 EAPI void
2025 elm_controlbar_item_select(Elm_Controlbar_Item * it)
2026 {
2027    if (!it) return;
2028    if (it->obj == NULL) return;
2029    Widget_Data * wd = elm_widget_data_get(it->obj);
2030    if (!wd) return;
2031
2032    _select_box(it);
2033 }
2034
2035 /**
2036  * Set the icon of item
2037  *
2038  * @param       it The item of controlbar
2039  * @param       icon_path The icon path of the item
2040  * @return      The icon object
2041  *
2042  * @ingroup Controlbar
2043  */
2044 EAPI void
2045 elm_controlbar_item_icon_set(Elm_Controlbar_Item * it, const char *icon_path)
2046 {
2047    if (!it) return;
2048    if (it->style == OBJECT) return;
2049    if (it->icon_path)
2050      {
2051         eina_stringshare_del(it->icon_path);
2052         it->icon_path = NULL;
2053      }
2054    if (it->icon)
2055      {
2056         evas_object_del(it->icon);
2057         it->icon = NULL;
2058      }
2059    if (icon_path != NULL)
2060      {
2061         it->icon_path = eina_stringshare_add(icon_path);
2062         it->icon = _create_item_icon(it->base_item, it, "elm.swallow.icon");
2063      }
2064    if (it->wd->disabled || it->disabled)
2065      elm_widget_disabled_set(it->base_item, EINA_TRUE);
2066    else
2067      elm_widget_disabled_set(it->base_item, EINA_FALSE);
2068 }
2069
2070 /**
2071  * Get the icon of item
2072  *
2073  * @param       it The item of controlbar
2074  * @return      The icon object
2075  *
2076  * @ingroup Controlbar
2077  */
2078 EAPI Evas_Object *
2079 elm_controlbar_item_icon_get(const Elm_Controlbar_Item * it)
2080 {
2081    if (!it) return NULL;
2082    return it->icon;
2083 }
2084
2085 /**
2086  * Set the label of item
2087  *
2088  * @param       it The item of controlbar
2089  * @param       label The label of item
2090  *
2091  * @ingroup Controlbar
2092  */
2093 EAPI void
2094 elm_controlbar_item_label_set(Elm_Controlbar_Item * it, const char *label)
2095 {
2096    if (!it) return;
2097    if (it->style == OBJECT) return;
2098    if (it->text)
2099      {
2100         eina_stringshare_del(it->text);
2101         it->text = NULL;
2102      }
2103    if (label != NULL)
2104      {
2105         it->text = eina_stringshare_add(label);
2106         elm_object_text_set(it->base_item, it->text);
2107      }
2108    if (it->wd->disabled || it->disabled)
2109      elm_widget_disabled_set(it->base_item, EINA_TRUE);
2110    else
2111      elm_widget_disabled_set(it->base_item, EINA_FALSE);
2112 }
2113
2114 /**
2115  * Get the label of item
2116  *
2117  * @param       it The item of controlbar
2118  * @return The label of item
2119  *
2120  * @ingroup Controlbar
2121  */
2122 EAPI const char *
2123 elm_controlbar_item_label_get(const Elm_Controlbar_Item * it)
2124 {
2125    if (!it) return NULL;
2126    return it->text;
2127 }
2128
2129 /**
2130  * Get the selected item
2131  *
2132  * @param       obj The controlbar object
2133  * @return              The item of controlbar
2134  *
2135  * @ingroup Controlbar
2136  */
2137 EAPI Elm_Controlbar_Item * elm_controlbar_selected_item_get(const Evas_Object *
2138                                                             obj)
2139 {
2140    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
2141    const Eina_List *l;
2142
2143    Elm_Controlbar_Item * item;
2144    if (obj == NULL) return NULL;
2145    Widget_Data * wd = elm_widget_data_get(obj);
2146    if (!wd || !wd->items) return NULL;
2147    EINA_LIST_FOREACH(wd->items, l, item)
2148      {
2149         if (item->selected) return item;
2150      }
2151    return NULL;
2152 }
2153
2154 /**
2155  * Get the first item
2156  *
2157  * @param       obj The controlbar object
2158  * @return              The item of controlbar
2159  *
2160  * @ingroup Controlbar
2161  */
2162 EAPI Elm_Controlbar_Item * elm_controlbar_first_item_get(const Evas_Object * obj)
2163 {
2164    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
2165    Widget_Data * wd = elm_widget_data_get(obj);
2166    if (!wd || !wd->items) return NULL;
2167    return eina_list_data_get(wd->items);
2168 }
2169
2170 /**
2171  * Get the last item
2172  *
2173  * @param       obj The controlbar object
2174  * @return              The item of controlbar
2175  *
2176  * @ingroup Controlbar
2177  */
2178 EAPI Elm_Controlbar_Item * elm_controlbar_last_item_get(const Evas_Object * obj)
2179 {
2180    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
2181    Widget_Data * wd = elm_widget_data_get(obj);
2182    if (!wd || !wd->items) return NULL;
2183    return eina_list_data_get(eina_list_last(wd->items));
2184 }
2185
2186 /**
2187  * Get the items
2188  *
2189  * @param       obj The controlbar object
2190  * @return      The list of the items
2191  *
2192  * @ingroup Controlbar
2193  */
2194 EAPI const Eina_List * elm_controlbar_items_get(const Evas_Object * obj)
2195 {
2196    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
2197    Widget_Data * wd = elm_widget_data_get(obj);
2198    if (!wd || !wd->items) return NULL;
2199    return wd->items;
2200 }
2201
2202 /**
2203  * Get the previous item
2204  *
2205  * @param       it The item of controlbar
2206  * @return      The previous item of the parameter item
2207  *
2208  * @ingroup Controlbar
2209  */
2210 EAPI Elm_Controlbar_Item * elm_controlbar_item_prev(Elm_Controlbar_Item *
2211                                                     it)
2212 {
2213    if (!it) return NULL;
2214    const Eina_List *l;
2215
2216    Elm_Controlbar_Item * item;
2217    if (it->obj == NULL) return NULL;
2218    Widget_Data * wd = elm_widget_data_get(it->obj);
2219    if (!wd || !wd->items) return NULL;
2220    EINA_LIST_FOREACH(wd->items, l, item)
2221      {
2222         if (it == item)
2223           {
2224              l = eina_list_prev(l);
2225              if (!l) return NULL;
2226              return eina_list_data_get(l);
2227           }
2228      }
2229    return NULL;
2230 }
2231
2232 /**
2233  * Get the next item
2234  *
2235  * @param       obj The controlbar object
2236  * @return      The next item of the parameter item
2237  *
2238  * @ingroup Controlbar
2239  */
2240 EAPI Elm_Controlbar_Item * elm_controlbar_item_next(Elm_Controlbar_Item *
2241                                                     it)
2242 {
2243    if (!it) return NULL;
2244    const Eina_List *l;
2245
2246    Elm_Controlbar_Item * item;
2247    if (it->obj == NULL) return NULL;
2248    Widget_Data * wd = elm_widget_data_get(it->obj);
2249    if (!wd || !wd->items) return NULL;
2250    EINA_LIST_FOREACH(wd->items, l, item)
2251      {
2252         if (it == item)
2253           {
2254              l = eina_list_next(l);
2255              if (!l) return NULL;
2256              return eina_list_data_get(l);
2257           }
2258      }
2259    return NULL;
2260 }
2261
2262 /**
2263  * Set the visible status of item in bar
2264  *
2265  * @param       it The item of controlbar
2266  * @param       bar EINA_TRUE or EINA_FALSE
2267  *
2268  * @ingroup Controlbar
2269  */
2270 EAPI void
2271 elm_controlbar_item_visible_set(Elm_Controlbar_Item * it, Eina_Bool visible)
2272 {
2273    if (!it) return;
2274    if (it->obj == NULL) return;
2275    Widget_Data * wd = elm_widget_data_get(it->obj);
2276    if (!wd) return;
2277
2278    if (!wd->auto_align)
2279      _set_item_visible(it, visible);
2280 }
2281
2282 /**
2283  * Get the result which or not item is visible in bar
2284  *
2285  * @param       it The item of controlbar
2286  * @return      EINA_TRUE or EINA_FALSE
2287  *
2288  * @ingroup Controlbar
2289  */
2290 EAPI Eina_Bool
2291 elm_controlbar_item_visible_get(const Elm_Controlbar_Item * it)
2292 {
2293    if (!it) return EINA_FALSE;
2294    if (it->obj == NULL) return EINA_FALSE;
2295    Widget_Data * wd = elm_widget_data_get(it->obj);
2296    if (!wd) return EINA_FALSE;
2297    if (it->order <= 0) return EINA_FALSE;
2298
2299    return EINA_TRUE;
2300 }
2301
2302 /**
2303  * Set item disable
2304  *
2305  * @param       it The item of controlbar
2306  * @param       bar EINA_TRUE or EINA_FALSE
2307  *
2308  * @ingroup Controlbar
2309  */
2310 EAPI void
2311 elm_controlbar_item_disabled_set(Elm_Controlbar_Item * it, Eina_Bool disabled)
2312 {
2313    if (!it) return;
2314
2315    if (it->disabled == disabled) return;
2316
2317    it->disabled = disabled;
2318
2319    if ((it->wd) && (it->wd->disabled)) return;
2320
2321    if (it->base_item) elm_widget_disabled_set(it->base_item, disabled);
2322 }
2323
2324 /**
2325  * Get item disable
2326  *
2327  * @param       it The item of controlbar
2328  * @return      EINA_TRUE or EINA_FALSE
2329  *
2330  * @ingroup Controlbar
2331  */
2332 EAPI Eina_Bool
2333 elm_controlbar_item_disabled_get(const Elm_Controlbar_Item * it)
2334 {
2335    if (!it) return EINA_FALSE;
2336
2337    return it->disabled;
2338 }
2339
2340 /**
2341  * Set the view of the item
2342  *
2343  * @param       it The item of controlbar
2344  * @param       view The view for the item
2345  *
2346  * @ingroup Controlbar
2347  */
2348 EAPI void
2349 elm_controlbar_item_view_set(Elm_Controlbar_Item *it, Evas_Object * view)
2350 {
2351    if (!it) return;
2352    if (it->view == view) return;
2353
2354    evas_object_del(it->view);
2355    it->view = view;
2356 }
2357
2358 /**
2359  * Get the view of the item
2360  *
2361  * @param       it The item of controlbar
2362  * @return      The view for the item
2363  *
2364  * @ingroup Controlbar
2365  */
2366 EAPI Evas_Object *
2367 elm_controlbar_item_view_get(const Elm_Controlbar_Item *it)
2368 {
2369    if (!it) return NULL;
2370
2371    return it->view;
2372 }
2373
2374 /**
2375  * Unset the view of the item
2376  *
2377  * @param       it The item of controlbar
2378  * @return      The view for the item
2379  *
2380  * @ingroup Controlbar
2381  */
2382 EAPI Evas_Object *
2383 elm_controlbar_item_view_unset(Elm_Controlbar_Item *it)
2384 {
2385    if (!it) return NULL;
2386    if (it->obj == NULL) return NULL;
2387    Widget_Data * wd = elm_widget_data_get(it->obj);
2388    if (!wd) return NULL;
2389    Evas_Object *content;
2390
2391    if (it->view == elm_object_content_part_get(wd->edje, "elm.swallow.view"))
2392      {
2393         content = elm_object_content_part_unset(wd->edje, "elm.swallow.view");
2394         if (content) evas_object_hide(content);
2395      }
2396    else
2397      content = it->view;
2398
2399    it->view = NULL;
2400
2401    return content;
2402 }
2403
2404 /**
2405  * Set the mode of the controlbar
2406  *
2407  * @param       obj The object of the controlbar
2408  * @param       mode The mode of the controlbar
2409  *
2410  * @ingroup Controlbar
2411  */
2412 EAPI void
2413 elm_controlbar_mode_set(Evas_Object *obj, int mode)
2414 {
2415    ELM_CHECK_WIDTYPE(obj, widtype);
2416    Widget_Data *wd = elm_widget_data_get(obj);
2417    if (!wd)
2418      {
2419         fprintf(stderr, "Cannot get smart data\n");
2420         return;
2421      }
2422    Evas_Object *selected_box;
2423
2424    wd->mode = mode;
2425
2426    switch(wd->mode)
2427      {
2428       case ELM_CONTROLBAR_MODE_DEFAULT:
2429          edje_object_signal_emit(_EDJ(wd->edje), "elm,state,default", "elm");
2430          break;
2431       case ELM_CONTROLBAR_MODE_TRANSLUCENCE:
2432          elm_controlbar_alpha_set(obj, 85);
2433          break;
2434       case ELM_CONTROLBAR_MODE_TRANSPARENCY:
2435          elm_controlbar_alpha_set(obj, 0);
2436          break;
2437       case ELM_CONTROLBAR_MODE_LARGE:
2438          edje_object_signal_emit(_EDJ(wd->edje), "elm,state,large", "elm");
2439          break;
2440       case ELM_CONTROLBAR_MODE_SMALL:
2441          edje_object_signal_emit(_EDJ(wd->edje), "elm,state,small", "elm");
2442          break;
2443       case ELM_CONTROLBAR_MODE_LEFT:
2444          selected_box = elm_object_content_part_get(wd->edje, "elm.dragable.box");
2445          if (selected_box) edje_object_signal_emit(_EDJ(selected_box), "elm,state,left", "elm");
2446          wd->selected_signal = eina_stringshare_add("elm,state,selected_left");
2447          wd->pressed_signal = eina_stringshare_add("elm,state,pressed_left");
2448          edje_object_signal_emit(_EDJ(wd->edje), "elm,state,left", "elm");
2449          _check_background(wd);
2450          _sizing_eval(obj);
2451          return;
2452       case ELM_CONTROLBAR_MODE_RIGHT:
2453          selected_box = elm_object_content_part_get(wd->edje, "elm.dragable.box");
2454          if (selected_box) edje_object_signal_emit(_EDJ(selected_box), "elm,state,right", "elm");
2455          wd->selected_signal = eina_stringshare_add("elm,state,selected_right");
2456          wd->pressed_signal = eina_stringshare_add("elm,state,pressed_right");
2457          edje_object_signal_emit(_EDJ(wd->edje), "elm,state,right", "elm");
2458          _check_background(wd);
2459          _sizing_eval(obj);
2460          return;
2461       default:
2462          break;
2463      }
2464    selected_box = elm_object_content_part_get(wd->edje, "elm.dragable.box");
2465    if (selected_box) edje_object_signal_emit(_EDJ(selected_box), "elm,state,default", "elm");
2466    wd->selected_signal = eina_stringshare_add("elm,state,selected");
2467    wd->pressed_signal = eina_stringshare_add("elm,state,pressed");
2468    _check_background(wd);
2469    _sizing_eval(obj);
2470 }
2471
2472 /**
2473  * Set the alpha of the controlbar
2474  *
2475  * @param       obj The object of the controlbar
2476  * @param       alpha The alpha value of the controlbar (0-100)
2477  *
2478  * @ingroup Controlbar
2479  */
2480 EAPI void
2481 elm_controlbar_alpha_set(Evas_Object *obj, int alpha)
2482 {
2483    ELM_CHECK_WIDTYPE(obj, widtype);
2484    int r, g, b;
2485    Widget_Data *wd = elm_widget_data_get(obj);
2486    if (!wd)
2487      {
2488         fprintf(stderr, "Cannot get smart data\n");
2489         return;
2490      }
2491
2492    if (alpha < 0) wd->alpha = 0;
2493    else if (alpha > 100) wd->alpha = 100;
2494    else wd->alpha = alpha;
2495
2496    evas_object_color_get(wd->bg, &r, &g, &b, NULL);
2497    evas_object_color_set(wd->bg, r, g, b, (int)(255 * wd->alpha / 100));
2498 }
2499
2500
2501 /**
2502  * Set auto-align mode of the controlbar(It's not prepared yet)
2503  * If you set the auto-align and add items more than 5,
2504  * the "more" item will be made and the items more than 5 will be unvisible.
2505  *
2506  * @param       obj The object of the controlbar
2507  * @param       auto_align The dicision that the controlbar use the auto-align
2508  *
2509  * @ingroup Controlbar
2510  */
2511 EAPI void
2512 elm_controlbar_item_auto_align_set(Evas_Object *obj, Eina_Bool auto_align)
2513 {
2514    ELM_CHECK_WIDTYPE(obj, widtype);
2515    Widget_Data *wd = elm_widget_data_get(obj);
2516    Elm_Controlbar_Item *item;
2517    const Eina_List *l;
2518    int i;
2519    if (!wd)
2520      {
2521         fprintf(stderr, "Cannot get smart data\n");
2522         return;
2523      }
2524
2525    if (wd->auto_align == auto_align) return;
2526
2527    if (auto_align)
2528      {
2529         if ((_check_bar_item_number(wd)) >= 5 && (!wd->more_item))
2530           {
2531              i = 0;
2532              EINA_LIST_FOREACH(wd->items, l, item)
2533                {
2534                   if (elm_controlbar_item_visible_get(item))
2535                     i++;
2536                   if (i >= 5){
2537                        _delete_item_in_bar(item);
2538                   }
2539                }
2540              item = elm_controlbar_last_item_get(obj);
2541              while (!elm_controlbar_item_visible_get(item)){
2542                   item = elm_controlbar_item_prev(item);
2543              }
2544              _create_more_item(wd, item->style);
2545           }
2546      }
2547    else
2548      {
2549         if (wd->more_item)
2550           {
2551              // delete more item
2552              if (wd->more_item->view)
2553                evas_object_del(wd->more_item->view);
2554              wd->items = eina_list_remove(wd->items, wd->more_item);
2555              eina_stringshare_del(wd->more_item->text);
2556              if (wd->more_item->icon)
2557                evas_object_del(wd->more_item->icon);
2558              if (wd->more_item->base)
2559                evas_object_del(wd->more_item->base);
2560              if (wd->more_item->base_item)
2561                evas_object_del(wd->more_item->base_item);
2562              free(wd->more_item);
2563              wd->more_item = NULL;
2564
2565              // make all item is visible
2566              i = 1;
2567              EINA_LIST_FOREACH(wd->items, l, item)
2568                {
2569                   if (!elm_controlbar_item_visible_get(item))
2570                     _insert_item_in_bar(item, i);
2571                   i++;
2572                }
2573           }
2574      }
2575    wd->auto_align = auto_align;
2576    _sizing_eval(obj);
2577 }
2578
2579 /**
2580  * Set the vertical mode of the controlbar
2581  *
2582  * @param       obj The object of the controlbar
2583  * @param       vertical The vertical mode of the controlbar (TRUE = vertical, FALSE = horizontal)
2584  *
2585  * @ingroup Controlbar
2586  */
2587 EAPI void
2588 elm_controlbar_vertical_set(Evas_Object *obj, Eina_Bool vertical)
2589 {
2590    ELM_CHECK_WIDTYPE(obj, widtype);
2591    Widget_Data *wd = elm_widget_data_get(obj);
2592    if (!wd)
2593      {
2594         fprintf(stderr, "Cannot get smart data\n");
2595         return;
2596      }
2597
2598    if (wd->vertical == vertical) return;
2599    wd->vertical = vertical;
2600
2601    if (_check_bar_item_number(wd) > 1)
2602      {
2603         _repack_items(wd);
2604      }
2605    _check_toolbar_line(wd);
2606 }
2607
2608 /**
2609  * Get the button object of the item
2610  *
2611  * @param       it The item of controlbar
2612  * @return  button object of the item
2613  *
2614  * @ingroup Controlbar
2615  */
2616 EAPI Evas_Object *
2617 elm_controlbar_item_button_get(const Elm_Controlbar_Item *it)
2618 {
2619    if (!it) return NULL;
2620    if (it->style == OBJECT) return NULL;
2621
2622    if (it->base_item) return it->base_item;
2623
2624    return NULL;
2625 }