src/lib/elm_controlbar.c

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