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