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