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