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