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    evas_object_smart_member_add(wd->view, obj);
1412    elm_widget_resize_object_set(obj, wd->edje);
1413
1414    _sizing_eval(obj);
1415
1416    return obj;
1417 }
1418
1419 /**
1420  * Append new tab item
1421  *
1422  * @param       obj The controlbar object
1423  * @param       icon_path The icon path of item
1424  * @param       label The label of item
1425  * @param       view The view of item
1426  * @return      The item of controlbar
1427  *
1428  * @ingroup Controlbar
1429  */
1430 EAPI Elm_Controlbar_Item * elm_controlbar_tab_item_append(Evas_Object * obj,
1431                                                           const char
1432                                                           *icon_path,
1433                                                           const char *label,
1434                                                           Evas_Object *
1435                                                           view)
1436 {
1437    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1438    Elm_Controlbar_Item * it;
1439    Elm_Controlbar_Item * lit;
1440    Widget_Data * wd;
1441    it = _create_tab_item(obj, icon_path, label, view);
1442    if (!it) return NULL;
1443    wd = elm_widget_data_get(obj);
1444    if (_check_bar_item_number(wd) >= 5 && wd->auto_align){
1445         if (!wd->more_item) {
1446              lit = elm_controlbar_last_item_get(obj);
1447              _set_item_visible(lit, EINA_FALSE);
1448              _create_more_item(wd, TABBAR);
1449         }
1450         _set_items_position(obj, it, NULL, EINA_FALSE);
1451    }
1452    else{
1453         _set_items_position(obj, it, NULL, EINA_TRUE);
1454    }
1455    wd->items = eina_list_append(wd->items, it);
1456    if (wd->more_item)
1457      elm_controlbar_item_view_set(wd->more_item, _create_more_view(wd));
1458
1459    _check_background(wd);
1460    _sizing_eval(obj);
1461    return it;
1462 }
1463
1464 /**
1465  * Prepend new tab item
1466  *
1467  * @param       obj The controlbar object
1468  * @param       icon_path The icon path of item
1469  * @param       label The label of item
1470  * @param       view The view of item
1471  * @return      The item of controlbar
1472  *
1473  * @ingroup Controlbar
1474  */
1475 EAPI Elm_Controlbar_Item * elm_controlbar_tab_item_prepend(Evas_Object *
1476                                                            obj,
1477                                                            const char
1478                                                            *icon_path,
1479                                                            const char
1480                                                            *label,
1481                                                            Evas_Object *
1482                                                            view)
1483 {
1484    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1485    Widget_Data * wd;
1486    Elm_Controlbar_Item * it;
1487    Elm_Controlbar_Item * lit;
1488    Elm_Controlbar_Item * item;
1489    it = _create_tab_item(obj, icon_path, label, view);
1490    if (!it) return NULL;
1491    wd = elm_widget_data_get(obj);
1492    item = eina_list_data_get(wd->items);
1493    if (_check_bar_item_number(wd) >= 5 && wd->auto_align){
1494         if (!wd->more_item) {
1495              lit = elm_controlbar_last_item_get(obj);
1496              _set_item_visible(lit, EINA_FALSE);
1497              _create_more_item(wd, TABBAR);
1498         }
1499         lit = elm_controlbar_item_prev(wd->more_item);
1500         _set_item_visible(lit, EINA_FALSE);
1501         _set_items_position(obj, it, item, EINA_TRUE);
1502    }
1503    else{
1504         _set_items_position(obj, it, item, EINA_TRUE);
1505    }
1506    wd->items = eina_list_prepend(wd->items, it);
1507    if (wd->more_item)
1508      elm_controlbar_item_view_set(wd->more_item, _create_more_view(wd));
1509
1510    _check_background(wd);
1511    _sizing_eval(obj);
1512    return it;
1513 }
1514
1515 /**
1516  * Insert new tab item before given item
1517  *
1518  * @param       obj The controlbar object
1519  * @param       before The given item
1520  * @param       icon_path The icon path of item
1521  * @param       label The label of item
1522  * @param       view The view of item
1523  * @return      The item of controlbar
1524  *
1525  * @ingroup Controlbar
1526  */
1527 EAPI Elm_Controlbar_Item *
1528 elm_controlbar_tab_item_insert_before(Evas_Object * obj,
1529                                       Elm_Controlbar_Item * before,
1530                                       const char *icon_path,
1531                                       const char *label, Evas_Object * view)
1532 {
1533    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1534    Widget_Data * wd;
1535    Elm_Controlbar_Item * it;
1536    Elm_Controlbar_Item * lit;
1537    if (!before) return NULL;
1538    it = _create_tab_item(obj, icon_path, label, view);
1539    if (!it) return NULL;
1540    wd = elm_widget_data_get(obj);
1541    if (_check_bar_item_number(wd) >= 5 && wd->auto_align){
1542         if (!wd->more_item)
1543           {
1544              lit = elm_controlbar_last_item_get(obj);
1545              _set_item_visible(lit, EINA_FALSE);
1546              _create_more_item(wd, TABBAR);
1547           }
1548         before = wd->more_item;
1549         if (before->order > 0)
1550           {
1551              lit = elm_controlbar_item_prev(wd->more_item);
1552              _set_item_visible(lit, EINA_FALSE);
1553              _set_items_position(obj, it, before, EINA_TRUE);
1554           }
1555         else
1556           {
1557              _set_items_position(obj, it, before, EINA_FALSE);
1558           }
1559    }
1560    else{
1561         _set_items_position(obj, it, before, EINA_TRUE);
1562    }
1563    wd->items = eina_list_prepend_relative(wd->items, it, before);
1564    if (wd->more_item)
1565      elm_controlbar_item_view_set(wd->more_item, _create_more_view(wd));
1566
1567    _check_background(wd);
1568    _sizing_eval(obj);
1569    return it;
1570 }
1571
1572 /**
1573  * Insert new tab item after given item
1574  *
1575  * @param       obj The controlbar object
1576  * @param       after The given item
1577  * @param       icon_path The icon path of item
1578  * @param       label The label of item
1579  * @param       view The view of item
1580  * @return      The item of controlbar
1581  *
1582  * @ingroup Controlbar
1583  */
1584 EAPI Elm_Controlbar_Item *
1585 elm_controlbar_tab_item_insert_after(Evas_Object * obj,
1586                                      Elm_Controlbar_Item * after,
1587                                      const char *icon_path, const char *label,
1588                                      Evas_Object * view)
1589 {
1590    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1591    Widget_Data * wd;
1592    Elm_Controlbar_Item * it;
1593    Elm_Controlbar_Item * lit;
1594    Elm_Controlbar_Item * item;
1595    if (!after) return NULL;
1596    it = _create_tab_item(obj, icon_path, label, view);
1597    if (!it) return NULL;
1598    wd = elm_widget_data_get(obj);
1599    item = elm_controlbar_item_next(after);
1600    if (_check_bar_item_number(wd) >= 5 && wd->auto_align){
1601         if (!wd->more_item)
1602           {
1603              lit = elm_controlbar_last_item_get(obj);
1604              _set_item_visible(lit, EINA_FALSE);
1605              _create_more_item(wd, TABBAR);
1606           }
1607         lit = elm_controlbar_item_prev(wd->more_item);
1608         if (lit != after && item->order > 0)
1609           {
1610              _set_item_visible(lit, EINA_FALSE);
1611              _set_items_position(obj, it, item, EINA_TRUE);
1612           }
1613         else
1614           {
1615              _set_items_position(obj, it, NULL, EINA_FALSE);
1616           }
1617    }
1618    else{
1619         _set_items_position(obj, it, item, EINA_TRUE);
1620    }
1621    wd->items = eina_list_append_relative(wd->items, it, after);
1622    if (wd->more_item)
1623      elm_controlbar_item_view_set(wd->more_item, _create_more_view(wd));
1624
1625    _check_background(wd);
1626    _sizing_eval(obj);
1627    return it;
1628 }
1629
1630 /**
1631  * Append new tool item
1632  *
1633  * @param       obj The controlbar object
1634  * @param       icon_path The icon path of item
1635  * @param       label The label of item
1636  * @param       func Callback function of item
1637  * @param       data The data of callback function
1638  * @return      The item of controlbar
1639  *
1640  * @ingroup Controlbar
1641  */
1642 EAPI Elm_Controlbar_Item * elm_controlbar_tool_item_append(Evas_Object *
1643                                                            obj,
1644                                                            const char
1645                                                            *icon_path,
1646                                                            const char
1647                                                            *label,
1648                                                            void (*func)
1649                                                            (void *data,
1650                                                             Evas_Object *
1651                                                             obj,
1652                                                             void
1653                                                             *event_info),
1654                                                            void *data)
1655
1656 {
1657    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1658    Elm_Controlbar_Item * it;
1659    Elm_Controlbar_Item * lit;
1660    Widget_Data * wd;
1661    it = _create_tool_item(obj, icon_path, label, func, data);
1662    if (!it) return NULL;
1663    wd = elm_widget_data_get(obj);
1664    if (_check_bar_item_number(wd) >= 5 && wd->auto_align){
1665         if (!wd->more_item) {
1666              lit = elm_controlbar_last_item_get(obj);
1667              _set_item_visible(lit, EINA_FALSE);
1668              _create_more_item(wd, TOOLBAR);
1669         }
1670         _set_items_position(obj, it, NULL, EINA_FALSE);
1671    }
1672    else{
1673         _set_items_position(obj, it, NULL, EINA_TRUE);
1674    }
1675    wd->items = eina_list_append(wd->items, it);
1676    _check_toolbar_line(wd);
1677    _sizing_eval(obj);
1678    return it;
1679 }
1680
1681 /**
1682  * Prepend new tool item
1683  *
1684  * @param       obj The controlbar object
1685  * @param       icon_path The icon path of item
1686  * @param       label The label of item
1687  * @param       func Callback function of item
1688  * @param       data The data of callback function
1689  * @return      The item of controlbar
1690  *
1691  * @ingroup Controlbar
1692  */
1693 EAPI Elm_Controlbar_Item * elm_controlbar_tool_item_prepend(Evas_Object *
1694                                                             obj,
1695                                                             const char
1696                                                             *icon_path,
1697                                                             const char
1698                                                             *label,
1699                                                             void (*func)
1700                                                             (void
1701                                                              *data,
1702                                                              Evas_Object *
1703                                                              obj,
1704                                                              void
1705                                                              *event_info),
1706                                                             void
1707                                                             *data)
1708 {
1709    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1710    Widget_Data * wd;
1711    Elm_Controlbar_Item * it;
1712    Elm_Controlbar_Item * lit;
1713    Elm_Controlbar_Item * item;
1714    it = _create_tool_item(obj, icon_path, label, func, data);
1715    if (!it) return NULL;
1716    wd = elm_widget_data_get(obj);
1717    item = eina_list_data_get(wd->items);
1718    if (_check_bar_item_number(wd) >= 5 && wd->auto_align){
1719         if (!wd->more_item) {
1720              lit = elm_controlbar_last_item_get(obj);
1721              _set_item_visible(lit, EINA_FALSE);
1722              _create_more_item(wd, TOOLBAR);
1723         }
1724         lit = elm_controlbar_item_prev(wd->more_item);
1725         _set_item_visible(lit, EINA_FALSE);
1726         _set_items_position(obj, it, item, EINA_TRUE);
1727    }
1728    else{
1729         _set_items_position(obj, it, item, EINA_TRUE);
1730    }
1731    wd->items = eina_list_prepend(wd->items, it);
1732    _check_toolbar_line(wd);
1733    _sizing_eval(obj);
1734    return it;
1735 }
1736
1737 /**
1738  * Insert new tool item before given item
1739  *
1740  * @param       obj The controlbar object
1741  * @param       before The given item
1742  * @param       icon_path The icon path of item
1743  * @param       label The label of item
1744  * @param       func Callback function of item
1745  * @param       data The data of callback function
1746  * @return      The item of controlbar
1747  *
1748  * @ingroup Controlbar
1749  */
1750 EAPI Elm_Controlbar_Item *
1751 elm_controlbar_tool_item_insert_before(Evas_Object * obj,
1752                                        Elm_Controlbar_Item * before,
1753                                        const char *icon_path,
1754                                        const char *label,
1755                                        void (*func) (void *data,
1756                                                      Evas_Object * obj,
1757                                                      void *event_info),
1758                                        void *data)
1759 {
1760    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1761    Widget_Data * wd;
1762    Elm_Controlbar_Item * it;
1763    Elm_Controlbar_Item * lit;
1764    if (!before) return NULL;
1765    it = _create_tool_item(obj, icon_path, label, func, data);
1766    if (!it) return NULL;
1767    wd = elm_widget_data_get(obj);
1768    if (_check_bar_item_number(wd) >= 5 && wd->auto_align){
1769         if (!wd->more_item)
1770           {
1771              lit = elm_controlbar_last_item_get(obj);
1772              _set_item_visible(lit, EINA_FALSE);
1773              _create_more_item(wd, TOOLBAR);
1774           }
1775         before = wd->more_item;
1776         if (before->order > 0)
1777           {
1778              lit = elm_controlbar_item_prev(wd->more_item);
1779              _set_item_visible(lit, EINA_FALSE);
1780              _set_items_position(obj, it, before, EINA_TRUE);
1781           }
1782         else
1783           {
1784              _set_items_position(obj, it, before, EINA_FALSE);
1785           }
1786    }
1787    else{
1788         _set_items_position(obj, it, before, EINA_TRUE);
1789    }
1790    wd->items = eina_list_prepend_relative(wd->items, it, before);
1791    _check_toolbar_line(wd);
1792    _sizing_eval(obj);
1793    return it;
1794 }
1795
1796 /**
1797  * Insert new tool item after given item
1798  *
1799  * @param       obj The controlbar object
1800  * @param       after The given item
1801  * @param       icon_path The icon path of item
1802  * @param       label The label of item
1803  * @param       func Callback function of item
1804  * @param       data The data of callback function
1805  * @return      The item of controlbar
1806  *
1807  * @ingroup Controlbar
1808  */
1809 EAPI Elm_Controlbar_Item *
1810 elm_controlbar_tool_item_insert_after(Evas_Object * obj,
1811                                       Elm_Controlbar_Item * after,
1812                                       const char *icon_path,
1813                                       const char *label,
1814                                       void (*func) (void *data,
1815                                                     Evas_Object * obj,
1816                                                     void *event_info),
1817                                       void *data)
1818 {
1819    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1820    Widget_Data * wd;
1821    Elm_Controlbar_Item * it;
1822    Elm_Controlbar_Item * lit;
1823    Elm_Controlbar_Item * item;
1824    if (!after) return NULL;
1825    it = _create_tool_item(obj, icon_path, label, func, data);
1826    if (!it) return NULL;
1827    wd = elm_widget_data_get(obj);
1828    item = elm_controlbar_item_next(after);
1829    if (_check_bar_item_number(wd) >= 5 && wd->auto_align){
1830         if (!wd->more_item)
1831           {
1832              lit = elm_controlbar_last_item_get(obj);
1833              _set_item_visible(lit, EINA_FALSE);
1834              _create_more_item(wd, TOOLBAR);
1835           }
1836         lit = elm_controlbar_item_prev(wd->more_item);
1837         if (lit != after && item->order > 0)
1838           {
1839              _set_item_visible(lit, EINA_FALSE);
1840              _set_items_position(obj, it, item, EINA_TRUE);
1841           }
1842         else
1843           {
1844              _set_items_position(obj, it, NULL, EINA_FALSE);
1845           }
1846    }
1847    else{
1848         _set_items_position(obj, it, item, EINA_TRUE);
1849    }
1850    wd->items = eina_list_append_relative(wd->items, it, after);
1851    _check_toolbar_line(wd);
1852    _sizing_eval(obj);
1853    return it;
1854 }
1855
1856 /**
1857  * Append new object item
1858  *
1859  * @param       obj The controlbar object
1860  * @param       obj_item The object of item
1861  * @param       sel The number of sel occupied
1862  * @return  The item of controlbar
1863  *
1864  * @ingroup Controlbar
1865  */
1866 EAPI Elm_Controlbar_Item * elm_controlbar_object_item_append(Evas_Object *
1867                                                              obj,
1868                                                              Evas_Object *
1869                                                              obj_item,
1870                                                              const int sel)
1871 {
1872    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1873    Widget_Data * wd;
1874    Elm_Controlbar_Item * it;
1875    it = _create_object_item(obj, obj_item, sel);
1876    if (!it) return NULL;
1877    wd = elm_widget_data_get(obj);
1878    if (!wd) return NULL;
1879    _set_items_position(obj, it, NULL, EINA_TRUE);
1880    wd->items = eina_list_append(wd->items, it);
1881    _sizing_eval(obj);
1882    return it;
1883 }
1884
1885 /**
1886  * Prepend new object item
1887  *
1888  * @param       obj The controlbar object
1889  * @param       obj_item The object of item
1890  * @param       sel The number of sel occupied
1891  * @return  The item of controlbar
1892  *
1893  * @ingroup Controlbar
1894  */
1895 EAPI Elm_Controlbar_Item * elm_controlbar_object_item_prepend(Evas_Object *
1896                                                               obj,
1897                                                               Evas_Object *
1898                                                               obj_item,
1899                                                               const int sel)
1900 {
1901    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1902    Widget_Data * wd;
1903    Elm_Controlbar_Item * it;
1904    Elm_Controlbar_Item * item;
1905    it = _create_object_item(obj, obj_item, sel);
1906    if (!it) return NULL;
1907    wd = elm_widget_data_get(obj);
1908    if (!wd) return NULL;
1909    item = eina_list_data_get(wd->items);
1910    _set_items_position(obj, it, item, EINA_TRUE);
1911    wd->items = eina_list_prepend(wd->items, it);
1912    _sizing_eval(obj);
1913    return it;
1914 }
1915
1916 /**
1917  * Insert new object item before given item
1918  *
1919  * @param       obj The controlbar object
1920  * @param       before The given item
1921  * @param       obj_item The object of item
1922  * @param       sel The number of sel occupied
1923  * @return  The item of controlbar
1924  *
1925  * @ingroup Controlbar
1926  */
1927 EAPI Elm_Controlbar_Item *
1928 elm_controlbar_object_item_insert_before(Evas_Object * obj,
1929                                          Elm_Controlbar_Item * before,
1930                                          Evas_Object * obj_item, const int sel)
1931 {
1932    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1933    Widget_Data * wd;
1934    Elm_Controlbar_Item * it;
1935    if (!before) return NULL;
1936    it = _create_object_item(obj, obj_item, sel);
1937    if (!it) return NULL;
1938    wd = elm_widget_data_get(obj);
1939    if (!wd) return NULL;
1940    _set_items_position(obj, it, before, EINA_TRUE);
1941    wd->items = eina_list_prepend_relative(wd->items, it, before);
1942    _sizing_eval(obj);
1943    return it;
1944 }
1945
1946 /**
1947  * Insert new object item after given item
1948  *
1949  * @param       obj The controlbar object
1950  * @param       after The given item
1951  * @param       obj_item The object of item
1952  * @param       sel The number of sel occupied
1953  * @return  The item of controlbar
1954  *
1955  * @ingroup Controlbar
1956  */
1957 EAPI Elm_Controlbar_Item *
1958 elm_controlbar_object_item_insert_after(Evas_Object * obj,
1959                                         Elm_Controlbar_Item * after,
1960                                         Evas_Object * obj_item, const int sel)
1961 {
1962    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1963    Widget_Data * wd;
1964    Elm_Controlbar_Item * it;
1965    Elm_Controlbar_Item * item;
1966    if (!after) return NULL;
1967    it = _create_object_item(obj, obj_item, sel);
1968    if (!it) return NULL;
1969    wd = elm_widget_data_get(obj);
1970    if (!wd) return NULL;
1971    item = elm_controlbar_item_next(after);
1972    _set_items_position(obj, it, item, EINA_TRUE);
1973    wd->items = eina_list_append_relative(wd->items, it, after);
1974    _sizing_eval(obj);
1975    return it;
1976 }
1977
1978 /**
1979  * Get the object of the object item
1980  *
1981  * @param       it The item of controlbar
1982  * @return      The object of the object item
1983  *
1984  * @ingroup Controlbar
1985  */
1986 EAPI Evas_Object *
1987 elm_controlbar_object_item_object_get(const Elm_Controlbar_Item * it)
1988 {
1989    if (!it) return NULL;
1990    if (it->style != OBJECT) return NULL;
1991    if (!it->base_item) return NULL;
1992    return it->base_item;
1993 }
1994
1995 /**
1996  * Delete item from controlbar
1997  *
1998  * @param       it The item of controlbar
1999
2000  * @ingroup Controlbar
2001  */
2002 EAPI void
2003 elm_controlbar_item_del(Elm_Controlbar_Item * it)
2004 {
2005    if (!it) return;
2006    Evas_Object * obj;
2007    Widget_Data * wd;
2008    const Eina_List *l;
2009
2010    Elm_Controlbar_Item * item;
2011    int check = 0;
2012
2013    //   int i = 1;
2014
2015    int sel = 1;
2016
2017    if (!it) return;
2018
2019    obj = it->obj;
2020    if (it->obj == NULL)
2021      {
2022         printf("Invalid argument: controlbar object is NULL\n");
2023         return;
2024      }
2025    wd = elm_widget_data_get(it->obj);
2026    if (!wd)
2027      {
2028         printf("Cannot get smart data\n");
2029         return;
2030      }
2031
2032    // unpack base item
2033    if (it->order > 0)
2034      {
2035         if (it->base)
2036           elm_table_unpack(wd->box, it->base);
2037         sel = it->sel;
2038         EINA_LIST_FOREACH(wd->items, l, item)
2039           {
2040              if (it != item)
2041                {
2042                   if (item->order > it->order)
2043                     {
2044                        if (item->base)
2045                          elm_table_unpack(wd->box, item->base);
2046                        item->order -= sel;
2047                        if (!wd->vertical)
2048                          elm_table_pack(wd->box, item->base, item->order - 1, 0, item->sel, 1);
2049                        else
2050                          elm_table_pack(wd->box, item->base, 0, item->order - 1, item->sel, 1);
2051                     }
2052                }
2053              if (it == item)
2054                check = 1;
2055           }
2056      }
2057
2058    // delete item in list
2059    _item_del(it);
2060    wd->items = eina_list_remove(wd->items, it);
2061    free(it);
2062    it = NULL;
2063    wd->num = wd->num - 1;
2064    _sizing_eval(obj);
2065 }
2066
2067 /**
2068  * Select item in controlbar
2069  *
2070  * @param       it The item of controlbar
2071
2072  * @ingroup Controlbar
2073  */
2074 EAPI void
2075 elm_controlbar_item_select(Elm_Controlbar_Item * it)
2076 {
2077    if (!it) return;
2078    if (it->obj == NULL) return;
2079    Widget_Data * wd = elm_widget_data_get(it->obj);
2080    if (!wd) return;
2081
2082    _select_box(it);
2083 }
2084
2085 /**
2086  * Set the icon of item
2087  *
2088  * @param       it The item of controlbar
2089  * @param       icon_path The icon path of the item
2090  * @return      The icon object
2091  *
2092  * @ingroup Controlbar
2093  */
2094 EAPI void
2095 elm_controlbar_item_icon_set(Elm_Controlbar_Item * it, const char *icon_path)
2096 {
2097    if (!it) return;
2098    if (it->style == OBJECT) return;
2099    if (it->icon_path)
2100      {
2101         eina_stringshare_del(it->icon_path);
2102         it->icon_path = NULL;
2103      }
2104    if (it->icon)
2105      {
2106         evas_object_del(it->icon);
2107         it->icon = NULL;
2108      }
2109    if (icon_path != NULL)
2110      {
2111         it->icon_path = eina_stringshare_add(icon_path);
2112         it->icon = _create_item_icon(it->base_item, it, "elm.swallow.icon");
2113      }
2114    if (it->wd->disabled || it->disabled)
2115      elm_widget_disabled_set(it->base_item, EINA_TRUE);
2116    else
2117      elm_widget_disabled_set(it->base_item, EINA_FALSE);
2118 }
2119
2120 /**
2121  * Get the icon of item
2122  *
2123  * @param       it The item of controlbar
2124  * @return      The icon object
2125  *
2126  * @ingroup Controlbar
2127  */
2128 EAPI Evas_Object *
2129 elm_controlbar_item_icon_get(const Elm_Controlbar_Item * it)
2130 {
2131    if (!it) return NULL;
2132    return it->icon;
2133 }
2134
2135 /**
2136  * Set the label of item
2137  *
2138  * @param       it The item of controlbar
2139  * @param       label The label of item
2140  *
2141  * @ingroup Controlbar
2142  */
2143 EAPI void
2144 elm_controlbar_item_label_set(Elm_Controlbar_Item * it, const char *label)
2145 {
2146    if (!it) return;
2147    if (it->style == OBJECT) return;
2148    if (it->text)
2149      {
2150         eina_stringshare_del(it->text);
2151         it->text = NULL;
2152      }
2153    if (label != NULL)
2154      {
2155         it->text = eina_stringshare_add(label);
2156         elm_button_label_set(it->base_item, it->text);
2157      }
2158    if (it->wd->disabled || it->disabled)
2159      elm_widget_disabled_set(it->base_item, EINA_TRUE);
2160    else
2161      elm_widget_disabled_set(it->base_item, EINA_FALSE);
2162 }
2163
2164 /**
2165  * Get the label of item
2166  *
2167  * @param       it The item of controlbar
2168  * @return The label of item
2169  *
2170  * @ingroup Controlbar
2171  */
2172 EAPI const char *
2173 elm_controlbar_item_label_get(const Elm_Controlbar_Item * it)
2174 {
2175    if (!it) return NULL;
2176    return it->text;
2177 }
2178
2179 /**
2180  * Get the selected item
2181  *
2182  * @param       obj The controlbar object
2183  * @return              The item of controlbar
2184  *
2185  * @ingroup Controlbar
2186  */
2187 EAPI Elm_Controlbar_Item * elm_controlbar_selected_item_get(const Evas_Object *
2188                                                             obj)
2189 {
2190    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
2191    const Eina_List *l;
2192
2193    Elm_Controlbar_Item * item;
2194    if (obj == NULL) return NULL;
2195    Widget_Data * wd = elm_widget_data_get(obj);
2196    if (!wd || !wd->items) return NULL;
2197    EINA_LIST_FOREACH(wd->items, l, item)
2198      {
2199         if (item->selected) return item;
2200      }
2201    return NULL;
2202 }
2203
2204 /**
2205  * Get the first 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_first_item_get(const 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(wd->items);
2218 }
2219
2220 /**
2221  * Get the last item
2222  *
2223  * @param       obj The controlbar object
2224  * @return              The item of controlbar
2225  *
2226  * @ingroup Controlbar
2227  */
2228 EAPI Elm_Controlbar_Item * elm_controlbar_last_item_get(const 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 eina_list_data_get(eina_list_last(wd->items));
2234 }
2235
2236 /**
2237  * Get the items
2238  *
2239  * @param       obj The controlbar object
2240  * @return      The list of the items
2241  *
2242  * @ingroup Controlbar
2243  */
2244 EAPI const Eina_List * elm_controlbar_items_get(const Evas_Object * obj)
2245 {
2246    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
2247    Widget_Data * wd = elm_widget_data_get(obj);
2248    if (!wd || !wd->items) return NULL;
2249    return wd->items;
2250 }
2251
2252 /**
2253  * Get the previous item
2254  *
2255  * @param       it The item of controlbar
2256  * @return      The previous item of the parameter item
2257  *
2258  * @ingroup Controlbar
2259  */
2260 EAPI Elm_Controlbar_Item * elm_controlbar_item_prev(Elm_Controlbar_Item *
2261                                                     it)
2262 {
2263    if (!it) return NULL;
2264    const Eina_List *l;
2265
2266    Elm_Controlbar_Item * item;
2267    if (it->obj == NULL) return NULL;
2268    Widget_Data * wd = elm_widget_data_get(it->obj);
2269    if (!wd || !wd->items) return NULL;
2270    EINA_LIST_FOREACH(wd->items, l, item)
2271      {
2272         if (it == item)
2273           {
2274              l = eina_list_prev(l);
2275              if (!l) return NULL;
2276              return eina_list_data_get(l);
2277           }
2278      }
2279    return NULL;
2280 }
2281
2282 /**
2283  * Get the next item
2284  *
2285  * @param       obj The controlbar object
2286  * @return      The next item of the parameter item
2287  *
2288  * @ingroup Controlbar
2289  */
2290 EAPI Elm_Controlbar_Item * elm_controlbar_item_next(Elm_Controlbar_Item *
2291                                                     it)
2292 {
2293    if (!it) return NULL;
2294    const Eina_List *l;
2295
2296    Elm_Controlbar_Item * item;
2297    if (it->obj == NULL) return NULL;
2298    Widget_Data * wd = elm_widget_data_get(it->obj);
2299    if (!wd || !wd->items) return NULL;
2300    EINA_LIST_FOREACH(wd->items, l, item)
2301      {
2302         if (it == item)
2303           {
2304              l = eina_list_next(l);
2305              if (!l) return NULL;
2306              return eina_list_data_get(l);
2307           }
2308      }
2309    return NULL;
2310 }
2311
2312 /**
2313  * Set the visible status of item in bar
2314  *
2315  * @param       it The item of controlbar
2316  * @param       bar EINA_TRUE or EINA_FALSE
2317  *
2318  * @ingroup Controlbar
2319  */
2320 EAPI void
2321 elm_controlbar_item_visible_set(Elm_Controlbar_Item * it, Eina_Bool visible)
2322 {
2323    if (!it) return;
2324    if (it->obj == NULL) return;
2325    Widget_Data * wd = elm_widget_data_get(it->obj);
2326    if (!wd) return;
2327
2328    if (!wd->auto_align)
2329      _set_item_visible(it, visible);
2330 }
2331
2332 /**
2333  * Get the result which or not item is visible in bar
2334  *
2335  * @param       it The item of controlbar
2336  * @return      EINA_TRUE or EINA_FALSE
2337  *
2338  * @ingroup Controlbar
2339  */
2340 EAPI Eina_Bool
2341 elm_controlbar_item_visible_get(const Elm_Controlbar_Item * it)
2342 {
2343    if (!it) return EINA_FALSE;
2344    if (it->obj == NULL) return EINA_FALSE;
2345    Widget_Data * wd = elm_widget_data_get(it->obj);
2346    if (!wd) return EINA_FALSE;
2347    if (it->order <= 0) return EINA_FALSE;
2348
2349    return EINA_TRUE;
2350 }
2351
2352 /**
2353  * Set item disable
2354  *
2355  * @param       it The item of controlbar
2356  * @param       bar EINA_TRUE or EINA_FALSE
2357  *
2358  * @ingroup Controlbar
2359  */
2360 EAPI void
2361 elm_controlbar_item_disabled_set(Elm_Controlbar_Item * it, Eina_Bool disabled)
2362 {
2363    if (!it) return;
2364
2365    if (it->disabled == disabled) return;
2366
2367    it->disabled = disabled;
2368
2369    if (it->wd && it->wd->disabled) return;
2370
2371    if (it->base_item) elm_widget_disabled_set(it->base_item, disabled);
2372 }
2373
2374 /**
2375  * Get item disable
2376  *
2377  * @param       it The item of controlbar
2378  * @return      EINA_TRUE or EINA_FALSE
2379  *
2380  * @ingroup Controlbar
2381  */
2382 EAPI Eina_Bool
2383 elm_controlbar_item_disabled_get(const Elm_Controlbar_Item * it)
2384 {
2385    if (!it) return EINA_FALSE;
2386
2387    return it->disabled;
2388 }
2389
2390 /**
2391  * Set the view of the item
2392  *
2393  * @param       it The item of controlbar
2394  * @param       view The view for the item
2395  *
2396  * @ingroup Controlbar
2397  */
2398 EAPI void
2399 elm_controlbar_item_view_set(Elm_Controlbar_Item *it, Evas_Object * view)
2400 {
2401    if (!it) return;
2402    if (it->view == view) return;
2403
2404    evas_object_del(it->view);
2405    it->view = view;
2406 }
2407
2408 /**
2409  * Get the view of the item
2410  *
2411  * @param       it The item of controlbar
2412  * @return      The view for the item
2413  *
2414  * @ingroup Controlbar
2415  */
2416 EAPI Evas_Object *
2417 elm_controlbar_item_view_get(const Elm_Controlbar_Item *it)
2418 {
2419    if (!it) return NULL;
2420
2421    return it->view;
2422 }
2423
2424 /**
2425  * Unset the view of the item
2426  *
2427  * @param       it The item of controlbar
2428  * @return      The view for the item
2429  *
2430  * @ingroup Controlbar
2431  */
2432 EAPI Evas_Object *
2433 elm_controlbar_item_view_unset(Elm_Controlbar_Item *it)
2434 {
2435    if (!it) return NULL;
2436    if (it->obj == NULL) return NULL;
2437    Widget_Data * wd = elm_widget_data_get(it->obj);
2438    if (!wd) return NULL;
2439    Evas_Object *content;
2440
2441    if (it->view == elm_layout_content_get(wd->view, "elm.swallow.view"))
2442      {
2443         content = elm_layout_content_unset(wd->view, "elm.swallow.view");
2444         if (content) evas_object_hide(content);
2445      }
2446    else
2447      content = it->view;
2448
2449    it->view = NULL;
2450
2451    return content;
2452 }
2453
2454 /**
2455  * Set the mode of the controlbar
2456  *
2457  * @param       obj The object of the controlbar
2458  * @param       mode The mode of the controlbar
2459  *
2460  * @ingroup Controlbar
2461  */
2462 EAPI void
2463 elm_controlbar_mode_set(Evas_Object *obj, int mode)
2464 {
2465    ELM_CHECK_WIDTYPE(obj, widtype);
2466    Widget_Data *wd = elm_widget_data_get(obj);
2467    if (!wd)
2468      {
2469         fprintf(stderr, "Cannot get smart data\n");
2470         return;
2471      }
2472
2473    if (wd->mode == mode) return;
2474
2475    wd->mode = mode;
2476
2477    switch(wd->mode)
2478      {
2479       case ELM_CONTROLBAR_MODE_DEFAULT:
2480          edje_object_signal_emit(_EDJ(wd->edje), "elm,state,default", "elm");
2481          break;
2482       case ELM_CONTROLBAR_MODE_TRANSLUCENCE:
2483          elm_controlbar_alpha_set(obj, 85);
2484          break;
2485       case ELM_CONTROLBAR_MODE_TRANSPARENCY:
2486          elm_controlbar_alpha_set(obj, 0);
2487          break;
2488       case ELM_CONTROLBAR_MODE_LARGE:
2489          edje_object_signal_emit(_EDJ(wd->edje), "elm,state,large", "elm");
2490          break;
2491       case ELM_CONTROLBAR_MODE_SMALL:
2492          edje_object_signal_emit(_EDJ(wd->edje), "elm,state,small", "elm");
2493          break;
2494       case ELM_CONTROLBAR_MODE_LEFT:
2495          edje_object_signal_emit(_EDJ(wd->selected_box), "elm,state,left", "elm");
2496          wd->selected_signal = eina_stringshare_add("elm,state,selected_left");
2497          wd->pressed_signal = eina_stringshare_add("elm,state,pressed_left");
2498          edje_object_signal_emit(_EDJ(wd->edje), "elm,state,left", "elm");
2499          _check_background(wd);
2500          _sizing_eval(obj);
2501          return;
2502       case ELM_CONTROLBAR_MODE_RIGHT:
2503          edje_object_signal_emit(_EDJ(wd->selected_box), "elm,state,right", "elm");
2504          wd->selected_signal = eina_stringshare_add("elm,state,selected_right");
2505          wd->pressed_signal = eina_stringshare_add("elm,state,pressed_right");
2506          edje_object_signal_emit(_EDJ(wd->edje), "elm,state,right", "elm");
2507          _check_background(wd);
2508          _sizing_eval(obj);
2509          return;
2510       default:
2511          break;
2512      }
2513
2514    edje_object_signal_emit(_EDJ(wd->selected_box), "elm,state,default", "elm");
2515    wd->selected_signal = eina_stringshare_add("elm,state,selected");
2516    wd->pressed_signal = eina_stringshare_add("elm,state,pressed");
2517    _check_background(wd);
2518    _sizing_eval(obj);
2519 }
2520
2521 /**
2522  * Set the alpha of the controlbar
2523  *
2524  * @param       obj The object of the controlbar
2525  * @param       alpha The alpha value of the controlbar (0-100)
2526  *
2527  * @ingroup Controlbar
2528  */
2529 EAPI void
2530 elm_controlbar_alpha_set(Evas_Object *obj, int alpha)
2531 {
2532    ELM_CHECK_WIDTYPE(obj, widtype);
2533    int r, g, b;
2534    Widget_Data *wd = elm_widget_data_get(obj);
2535    if (!wd)
2536      {
2537         fprintf(stderr, "Cannot get smart data\n");
2538         return;
2539      }
2540
2541    if (alpha < 0) wd->alpha = 0;
2542    else if (alpha > 100) wd->alpha = 100;
2543    else wd->alpha = alpha;
2544
2545    evas_object_color_get(wd->bg, &r, &g, &b, NULL);
2546    evas_object_color_set(wd->bg, r, g, b, (int)(255 * wd->alpha / 100));
2547 }
2548
2549
2550 /**
2551  * Set auto-align mode of the controlbar(It's not prepared yet)
2552  * If you set the auto-align and add items more than 5,
2553  * the "more" item will be made and the items more than 5 will be unvisible.
2554  *
2555  * @param       obj The object of the controlbar
2556  * @param       auto_align The dicision that the controlbar use the auto-align
2557  *
2558  * @ingroup Controlbar
2559  */
2560 EAPI void
2561 elm_controlbar_item_auto_align_set(Evas_Object *obj, Eina_Bool auto_align)
2562 {
2563    ELM_CHECK_WIDTYPE(obj, widtype);
2564    Widget_Data *wd = elm_widget_data_get(obj);
2565    Elm_Controlbar_Item *item;
2566    const Eina_List *l;
2567    int i;
2568    if (!wd)
2569      {
2570         fprintf(stderr, "Cannot get smart data\n");
2571         return;
2572      }
2573
2574    if (wd->auto_align == auto_align) return;
2575
2576    if (auto_align)
2577      {
2578         if (_check_bar_item_number(wd) >= 5 && !wd->more_item)
2579           {
2580              i = 0;
2581              EINA_LIST_FOREACH(wd->items, l, item)
2582                {
2583                   if (elm_controlbar_item_visible_get(item))
2584                     i++;
2585                   if (i >= 5){
2586                        _delete_item_in_bar(item);
2587                   }
2588                }
2589              item = elm_controlbar_last_item_get(obj);
2590              while (!elm_controlbar_item_visible_get(item)){
2591                   item = elm_controlbar_item_prev(item);
2592              }
2593              _create_more_item(wd, item->style);
2594           }
2595      }
2596    else
2597      {
2598         if (wd->more_item)
2599           {
2600              // delete more item
2601              if (wd->more_item->view)
2602                evas_object_del(wd->more_item->view);
2603              wd->items = eina_list_remove(wd->items, wd->more_item);
2604              eina_stringshare_del(wd->more_item->text);
2605              if (wd->more_item->icon)
2606                evas_object_del(wd->more_item->icon);
2607              if (wd->more_item->base)
2608                evas_object_del(wd->more_item->base);
2609              if (wd->more_item->base_item)
2610                evas_object_del(wd->more_item->base_item);
2611              free(wd->more_item);
2612              wd->more_item = NULL;
2613
2614              // make all item is visible
2615              i = 1;
2616              EINA_LIST_FOREACH(wd->items, l, item)
2617                {
2618                   if (!elm_controlbar_item_visible_get(item))
2619                     _insert_item_in_bar(item, i);
2620                   i++;
2621                }
2622           }
2623      }
2624    wd->auto_align = auto_align;
2625    _sizing_eval(obj);
2626 }
2627
2628 /**
2629  * Set the vertical mode of the controlbar
2630  *
2631  * @param       obj The object of the controlbar
2632  * @param       vertical The vertical mode of the controlbar (TRUE = vertical, FALSE = horizontal)
2633  *
2634  * @ingroup Controlbar
2635  */
2636 EAPI void
2637 elm_controlbar_vertical_set(Evas_Object *obj, Eina_Bool vertical)
2638 {
2639    ELM_CHECK_WIDTYPE(obj, widtype);
2640    Widget_Data *wd = elm_widget_data_get(obj);
2641    if (!wd)
2642      {
2643         fprintf(stderr, "Cannot get smart data\n");
2644         return;
2645      }
2646
2647    if (wd->vertical == vertical) return;
2648    wd->vertical = vertical;
2649
2650    if (_check_bar_item_number(wd) > 1)
2651      {
2652         _repack_items(wd);
2653      }
2654    _check_toolbar_line(wd);
2655 }
2656
2657 /**
2658  * Get the button object of the item
2659  *
2660  * @param       it The item of controlbar
2661  * @return  button object of the item
2662  *
2663  * @ingroup Controlbar
2664  */
2665 EAPI Evas_Object *
2666 elm_controlbar_item_button_get(const Elm_Controlbar_Item *it)
2667 {
2668    if (!it) return NULL;
2669    if (it->style == OBJECT) return NULL;
2670
2671    if (it->base_item) return it->base_item;
2672
2673    return NULL;
2674 }