src/lib/elc_ctxpopup.c

   1 #include <Elementary.h>
   2 #include "elm_priv.h"
   3 #include "elm_widget_ctxpopup.h"
   4
   5 EAPI Eo_Op ELM_OBJ_CTXPOPUP_BASE_ID = EO_NOOP;
   6
   7 #define MY_CLASS ELM_OBJ_CTXPOPUP_CLASS
   8
   9 #define MY_CLASS_NAME "elm_ctxpopup"
  10
  11 EAPI const char ELM_CTXPOPUP_SMART_NAME[] = "elm_ctxpopup";
  12
  13 static const char SIG_DISMISSED[] = "dismissed";
  14 static const Evas_Smart_Cb_Description _smart_callbacks[] = {
  15    {SIG_DISMISSED, ""},
  16    {NULL, NULL}
  17 };
  18
  19
  20 static void
  21 _elm_ctxpopup_smart_focus_next_manager_is(Eo *obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list)
  22 {
  23    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
  24    *ret = EINA_TRUE;
  25 }
  26
  27 static void
  28 _elm_ctxpopup_smart_focus_direction_manager_is(Eo *obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list)
  29 {
  30    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
  31    *ret = EINA_FALSE;
  32 }
  33
  34 static void
  35 _elm_ctxpopup_smart_focus_next(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
  36 {
  37    Elm_Ctxpopup_Smart_Data *sd = _pd;
  38
  39    Elm_Focus_Direction dir = va_arg(*list, Elm_Focus_Direction);
  40    Evas_Object **next =  va_arg(*list, Evas_Object **);
  41    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
  42    if (ret) *ret = EINA_FALSE;
  43
  44    if (!sd)
  45      return;
  46
  47    if (!elm_widget_focus_next_get(sd->box, dir, next))
  48      {
  49         elm_widget_focused_object_clear(sd->box);
  50         elm_widget_focus_next_get(sd->box, dir, next);
  51      }
  52
  53    if (ret) *ret = EINA_TRUE;
  54 }
  55
  56 static void
  57 _elm_ctxpopup_smart_event(Eo *obj, void *_pd, va_list *list)
  58 {
  59    Evas_Object *src = va_arg(*list, Evas_Object *);
  60    (void)src;
  61    Evas_Callback_Type type = va_arg(*list, Evas_Callback_Type);
  62    void *event_info = va_arg(*list, void *);
  63    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
  64    if (ret) *ret = EINA_FALSE;
  65
  66    Evas_Event_Key_Down *ev = event_info;
  67
  68    Elm_Ctxpopup_Smart_Data *sd = _pd;
  69
  70    if (elm_widget_disabled_get(obj)) return;
  71    if (type != EVAS_CALLBACK_KEY_DOWN) return;
  72    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return;
  73
  74    if (!strcmp(ev->keyname, "Tab"))
  75      {
  76         if (evas_key_modifier_is_set(ev->modifiers, "Shift"))
  77           elm_widget_focus_cycle(sd->box, ELM_FOCUS_PREVIOUS);
  78         else
  79           elm_widget_focus_cycle(sd->box, ELM_FOCUS_NEXT);
  80         if (ret) *ret = EINA_TRUE;
  81         return;
  82      }
  83
  84    if (strcmp(ev->keyname, "Escape")) return;
  85
  86    evas_object_hide(obj);
  87    ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
  88    if (ret) *ret = EINA_TRUE;
  89 }
  90
  91 static void
  92 _x_pos_adjust(Evas_Coord_Point *pos,
  93               Evas_Coord_Point *base_size,
  94               Evas_Coord_Rectangle *hover_area)
  95 {
  96    pos->x -= (base_size->x / 2);
  97
  98    if (pos->x < hover_area->x)
  99      pos->x = hover_area->x;
 100    else if ((pos->x + base_size->x) > (hover_area->x + hover_area->w))
 101      pos->x = (hover_area->x + hover_area->w) - base_size->x;
 102
 103    if (base_size->x > hover_area->w)
 104      base_size->x -= (base_size->x - hover_area->w);
 105
 106    if (pos->x < hover_area->x)
 107      pos->x = hover_area->x;
 108 }
 109
 110 static void
 111 _y_pos_adjust(Evas_Coord_Point *pos,
 112               Evas_Coord_Point *base_size,
 113               Evas_Coord_Rectangle *hover_area)
 114 {
 115    pos->y -= (base_size->y / 2);
 116
 117    if (pos->y < hover_area->y)
 118      pos->y = hover_area->y;
 119    else if ((pos->y + base_size->y) > (hover_area->y + hover_area->h))
 120      pos->y = hover_area->y + hover_area->h - base_size->y;
 121
 122    if (base_size->y > hover_area->h)
 123      base_size->y -= (base_size->y - hover_area->h);
 124
 125    if (pos->y < hover_area->y)
 126      pos->y = hover_area->y;
 127 }
 128
 129 static Elm_Ctxpopup_Direction
 130 _base_geometry_calc(Evas_Object *obj,
 131                     Evas_Coord_Rectangle *rect)
 132 {
 133    Elm_Ctxpopup_Direction dir = ELM_CTXPOPUP_DIRECTION_UNKNOWN;
 134    Evas_Coord_Rectangle hover_area;
 135    Evas_Coord_Point pos = {0, 0};
 136    Evas_Coord_Point arrow_size;
 137    Evas_Coord_Point base_size;
 138    Evas_Coord_Point max_size;
 139    Evas_Coord_Point min_size;
 140    Evas_Coord_Point temp;
 141    int idx;
 142
 143    ELM_CTXPOPUP_DATA_GET(obj, sd);
 144    Elm_Widget_Smart_Data *wd = eo_data_get(obj, ELM_OBJ_WIDGET_CLASS);
 145
 146    if (!rect) return ELM_CTXPOPUP_DIRECTION_DOWN;
 147
 148    edje_object_part_geometry_get
 149      (sd->arrow, "ctxpopup_arrow", NULL, NULL, &arrow_size.x, &arrow_size.y);
 150    evas_object_resize(sd->arrow, arrow_size.x, arrow_size.y);
 151
 152    //Initialize Area Rectangle.
 153    evas_object_geometry_get
 154      (sd->parent, &hover_area.x, &hover_area.y, &hover_area.w,
 155      &hover_area.h);
 156
 157    evas_object_geometry_get(obj, &pos.x, &pos.y, NULL, NULL);
 158
 159    //recalc the edje
 160    edje_object_size_min_calc
 161      (wd->resize_obj, &base_size.x, &base_size.y);
 162    evas_object_smart_calculate(wd->resize_obj);
 163
 164    //Limit to Max Size
 165    evas_object_size_hint_max_get(obj, &max_size.x, &max_size.y);
 166
 167    if ((max_size.y > 0) && (base_size.y > max_size.y))
 168      base_size.y = max_size.y;
 169
 170    if ((max_size.x > 0) && (base_size.x > max_size.x))
 171      base_size.x = max_size.x;
 172
 173    //Limit to Min Size
 174    evas_object_size_hint_min_get(obj, &min_size.x, &min_size.y);
 175
 176    if ((min_size.y > 0) && (base_size.y < min_size.y))
 177      base_size.y = min_size.y;
 178
 179    if ((min_size.x > 0) && (base_size.x < min_size.x))
 180      base_size.x = min_size.x;
 181
 182    //Check the Which direction is available.
 183    //If find a avaialble direction, it adjusts position and size.
 184    for (idx = 0; idx < 4; idx++)
 185      {
 186         switch (sd->dir_priority[idx])
 187           {
 188            case ELM_CTXPOPUP_DIRECTION_UP:
 189              temp.y = (pos.y - base_size.y);
 190              if ((temp.y - arrow_size.y) < hover_area.y)
 191                continue;
 192
 193              _x_pos_adjust(&pos, &base_size, &hover_area);
 194              pos.y -= base_size.y;
 195              dir = ELM_CTXPOPUP_DIRECTION_UP;
 196              break;
 197
 198            case ELM_CTXPOPUP_DIRECTION_LEFT:
 199              temp.x = (pos.x - base_size.x);
 200              if ((temp.x - arrow_size.x) < hover_area.x)
 201                continue;
 202
 203              _y_pos_adjust(&pos, &base_size, &hover_area);
 204              pos.x -= base_size.x;
 205              dir = ELM_CTXPOPUP_DIRECTION_LEFT;
 206              break;
 207
 208            case ELM_CTXPOPUP_DIRECTION_RIGHT:
 209              temp.x = (pos.x + base_size.x);
 210              if ((temp.x + arrow_size.x) >
 211                  (hover_area.x + hover_area.w))
 212                continue;
 213
 214              _y_pos_adjust(&pos, &base_size, &hover_area);
 215              dir = ELM_CTXPOPUP_DIRECTION_RIGHT;
 216              break;
 217
 218            case ELM_CTXPOPUP_DIRECTION_DOWN:
 219              temp.y = (pos.y + base_size.y);
 220              if ((temp.y + arrow_size.y) >
 221                  (hover_area.y + hover_area.h))
 222                continue;
 223
 224              _x_pos_adjust(&pos, &base_size, &hover_area);
 225              dir = ELM_CTXPOPUP_DIRECTION_DOWN;
 226              break;
 227
 228            default:
 229              continue;
 230           }
 231         break;
 232      }
 233
 234    //In this case, all directions are invalid because of lack of space.
 235    if (idx == 4)
 236      {
 237         Evas_Coord length[2];
 238
 239         if (!sd->horizontal)
 240           {
 241              length[0] = pos.y - hover_area.y;
 242              length[1] = (hover_area.y + hover_area.h) - pos.y;
 243
 244              // ELM_CTXPOPUP_DIRECTION_UP
 245              if (length[0] > length[1])
 246                {
 247                   _x_pos_adjust(&pos, &base_size, &hover_area);
 248                   pos.y -= base_size.y;
 249                   dir = ELM_CTXPOPUP_DIRECTION_UP;
 250                   if (pos.y < (hover_area.y + arrow_size.y))
 251                     {
 252                        base_size.y -= ((hover_area.y + arrow_size.y) - pos.y);
 253                        pos.y = hover_area.y + arrow_size.y;
 254                     }
 255                }
 256              //ELM_CTXPOPUP_DIRECTION_DOWN
 257              else
 258                {
 259                   _x_pos_adjust(&pos, &base_size, &hover_area);
 260                   dir = ELM_CTXPOPUP_DIRECTION_DOWN;
 261                   if ((pos.y + arrow_size.y + base_size.y) >
 262                       (hover_area.y + hover_area.h))
 263                     base_size.y -=
 264                       ((pos.y + arrow_size.y + base_size.y) -
 265                        (hover_area.y + hover_area.h));
 266                }
 267           }
 268         else
 269           {
 270              length[0] = pos.x - hover_area.x;
 271              length[1] = (hover_area.x + hover_area.w) - pos.x;
 272
 273              //ELM_CTXPOPUP_DIRECTION_LEFT
 274              if (length[0] > length[1])
 275                {
 276                   _y_pos_adjust(&pos, &base_size, &hover_area);
 277                   pos.x -= base_size.x;
 278                   dir = ELM_CTXPOPUP_DIRECTION_LEFT;
 279                   if (pos.x < (hover_area.x + arrow_size.x))
 280                     {
 281                        base_size.x -= ((hover_area.x + arrow_size.x) - pos.x);
 282                        pos.x = hover_area.x + arrow_size.x;
 283                     }
 284                }
 285              //ELM_CTXPOPUP_DIRECTION_RIGHT
 286              else
 287                {
 288                   _y_pos_adjust(&pos, &base_size, &hover_area);
 289                   dir = ELM_CTXPOPUP_DIRECTION_RIGHT;
 290                   if (pos.x + (arrow_size.x + base_size.x) >
 291                       hover_area.x + hover_area.w)
 292                     base_size.x -=
 293                       ((pos.x + arrow_size.x + base_size.x) -
 294                        (hover_area.x + hover_area.w));
 295                }
 296           }
 297      }
 298
 299    //Final position and size.
 300    rect->x = pos.x;
 301    rect->y = pos.y;
 302    rect->w = base_size.x;
 303    rect->h = base_size.y;
 304
 305    return dir;
 306 }
 307
 308 static void
 309 _arrow_update(Evas_Object *obj,
 310               Elm_Ctxpopup_Direction dir,
 311               Evas_Coord_Rectangle base_size)
 312 {
 313    Evas_Coord_Rectangle arrow_size;
 314    Evas_Coord x, y;
 315    double drag;
 316
 317    ELM_CTXPOPUP_DATA_GET(obj, sd);
 318    Elm_Widget_Smart_Data *wd = eo_data_get(obj, ELM_OBJ_WIDGET_CLASS);
 319
 320    evas_object_geometry_get(obj, &x, &y, NULL, NULL);
 321    evas_object_geometry_get
 322      (sd->arrow, NULL, NULL, &arrow_size.w, &arrow_size.h);
 323
 324    /* arrow is not being kept as sub-object on purpose, here. the
 325     * design of the widget does not help with the contrary */
 326
 327    switch (dir)
 328      {
 329       case ELM_CTXPOPUP_DIRECTION_RIGHT:
 330         edje_object_signal_emit(sd->arrow, "elm,state,left", "elm");
 331         edje_object_part_swallow
 332            (wd->resize_obj,
 333             (elm_widget_mirrored_get(obj) ? "elm.swallow.arrow_right" :
 334              "elm.swallow.arrow_left"), sd->arrow);
 335
 336         if (base_size.h > 0)
 337           {
 338              if (y < ((arrow_size.h * 0.5) + base_size.y))
 339                y = 0;
 340              else if (y > base_size.y + base_size.h - (arrow_size.h * 0.5))
 341                y = base_size.h - arrow_size.h;
 342              else
 343                y = y - base_size.y - (arrow_size.h * 0.5);
 344              drag = (double)(y) / (double)(base_size.h - arrow_size.h);
 345              edje_object_part_drag_value_set
 346                 (wd->resize_obj,
 347                  (elm_widget_mirrored_get(obj) ? "elm.swallow.arrow_right" :
 348                   "elm.swallow.arrow_left"), 1, drag);
 349           }
 350         break;
 351
 352       case ELM_CTXPOPUP_DIRECTION_LEFT:
 353         edje_object_signal_emit(sd->arrow, "elm,state,right", "elm");
 354         edje_object_part_swallow
 355            (wd->resize_obj,
 356             (elm_widget_mirrored_get(obj) ? "elm.swallow.arrow_left" :
 357              "elm.swallow.arrow_right"), sd->arrow);
 358
 359         if (base_size.h > 0)
 360           {
 361              if (y < ((arrow_size.h * 0.5) + base_size.y))
 362                y = 0;
 363              else if (y > (base_size.y + base_size.h - (arrow_size.h * 0.5)))
 364                y = base_size.h - arrow_size.h;
 365              else
 366                y = y - base_size.y - (arrow_size.h * 0.5);
 367              drag = (double)(y) / (double)(base_size.h - arrow_size.h);
 368              edje_object_part_drag_value_set
 369                 (wd->resize_obj,
 370                  (elm_widget_mirrored_get(obj) ? "elm.swallow.arrow_left" :
 371                   "elm.swallow.arrow_right"), 0, drag);
 372           }
 373         break;
 374
 375       case ELM_CTXPOPUP_DIRECTION_DOWN:
 376         edje_object_signal_emit(sd->arrow, "elm,state,top", "elm");
 377         edje_object_part_swallow
 378           (wd->resize_obj, "elm.swallow.arrow_up",
 379           sd->arrow);
 380
 381         if (base_size.w > 0)
 382           {
 383              if (x < ((arrow_size.w * 0.5) + base_size.x))
 384                x = 0;
 385              else if (x > (base_size.x + base_size.w - (arrow_size.w * 0.5)))
 386                x = base_size.w - arrow_size.w;
 387              else
 388                x = x - base_size.x - (arrow_size.w * 0.5);
 389              drag = (double)(x) / (double)(base_size.w - arrow_size.w);
 390              edje_object_part_drag_value_set
 391                (wd->resize_obj, "elm.swallow.arrow_up", drag,
 392                1);
 393           }
 394         break;
 395
 396       case ELM_CTXPOPUP_DIRECTION_UP:
 397         edje_object_signal_emit(sd->arrow, "elm,state,bottom", "elm");
 398         edje_object_part_swallow
 399           (wd->resize_obj, "elm.swallow.arrow_down",
 400           sd->arrow);
 401
 402         if (base_size.w > 0)
 403           {
 404              if (x < ((arrow_size.w * 0.5) + base_size.x))
 405                x = 0;
 406              else if (x > (base_size.x + base_size.w - (arrow_size.w * 0.5)))
 407                x = base_size.w - arrow_size.w;
 408              else x = x - base_size.x - (arrow_size.w * 0.5);
 409              drag = (double)(x) / (double)(base_size.w - arrow_size.w);
 410              edje_object_part_drag_value_set
 411                (wd->resize_obj, "elm.swallow.arrow_down",
 412                drag, 0);
 413           }
 414         break;
 415
 416       default:
 417         break;
 418      }
 419
 420    //should be here for getting accurate geometry value
 421    evas_object_smart_calculate(wd->resize_obj);
 422 }
 423
 424 static void
 425 _show_signals_emit(Evas_Object *obj,
 426                    Elm_Ctxpopup_Direction dir)
 427 {
 428    ELM_CTXPOPUP_DATA_GET(obj, sd);
 429
 430    if (!sd->visible) return;
 431    if ((sd->list) && (!sd->list_visible)) return;
 432
 433    switch (dir)
 434      {
 435       case ELM_CTXPOPUP_DIRECTION_UP:
 436         elm_layout_signal_emit(obj, "elm,state,show,up", "elm");
 437         break;
 438
 439       case ELM_CTXPOPUP_DIRECTION_LEFT:
 440         elm_layout_signal_emit(obj,
 441               (elm_widget_mirrored_get(obj) ? "elm,state,show,right" :
 442                "elm,state,show,left"), "elm");
 443         break;
 444
 445       case ELM_CTXPOPUP_DIRECTION_RIGHT:
 446         elm_layout_signal_emit(obj,
 447               (elm_widget_mirrored_get(obj) ? "elm,state,show,left" :
 448                "elm,state,show,right"), "elm");
 449         break;
 450
 451       case ELM_CTXPOPUP_DIRECTION_DOWN:
 452         elm_layout_signal_emit(obj, "elm,state,show,down", "elm");
 453         break;
 454
 455       default:
 456         break;
 457      }
 458
 459    edje_object_signal_emit(sd->bg, "elm,state,show", "elm");
 460    elm_layout_signal_emit(obj, "elm,state,show", "elm");
 461 }
 462
 463 static void
 464 _hide_signals_emit(Evas_Object *obj,
 465                    Elm_Ctxpopup_Direction dir)
 466 {
 467    ELM_CTXPOPUP_DATA_GET(obj, sd);
 468
 469    if (!sd->visible) return;
 470
 471    switch (dir)
 472      {
 473       case ELM_CTXPOPUP_DIRECTION_UP:
 474         elm_layout_signal_emit(obj, "elm,state,hide,up", "elm");
 475         break;
 476
 477       case ELM_CTXPOPUP_DIRECTION_LEFT:
 478         elm_layout_signal_emit(obj,
 479               (elm_widget_mirrored_get(obj) ? "elm,state,hide,right" :
 480                "elm,state,hide,left"), "elm");
 481         break;
 482
 483       case ELM_CTXPOPUP_DIRECTION_RIGHT:
 484         elm_layout_signal_emit(obj,
 485               (elm_widget_mirrored_get(obj) ? "elm,state,hide,left" :
 486                "elm,state,hide,right"), "elm");
 487         break;
 488
 489       case ELM_CTXPOPUP_DIRECTION_DOWN:
 490         elm_layout_signal_emit(obj, "elm,state,hide,down", "elm");
 491         break;
 492
 493       default:
 494         break;
 495      }
 496
 497    edje_object_signal_emit(sd->bg, "elm,state,hide", "elm");
 498 }
 499
 500 static void
 501 _base_shift_by_arrow(Evas_Object *arrow,
 502                      Elm_Ctxpopup_Direction dir,
 503                      Evas_Coord_Rectangle *rect)
 504 {
 505    Evas_Coord arrow_w, arrow_h;
 506
 507    evas_object_geometry_get(arrow, NULL, NULL, &arrow_w, &arrow_h);
 508    switch (dir)
 509      {
 510       case ELM_CTXPOPUP_DIRECTION_RIGHT:
 511         rect->x += arrow_w;
 512         break;
 513
 514       case ELM_CTXPOPUP_DIRECTION_LEFT:
 515         rect->x -= arrow_w;
 516         break;
 517
 518       case ELM_CTXPOPUP_DIRECTION_DOWN:
 519         rect->y += arrow_h;
 520         break;
 521
 522       case ELM_CTXPOPUP_DIRECTION_UP:
 523         rect->y -= arrow_h;
 524         break;
 525
 526       default:
 527         break;
 528      }
 529 }
 530
 531 static void
 532 _elm_ctxpopup_smart_layout_sub_object_add_enable(Eo *obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list)
 533 {
 534    Eina_Bool *enable = va_arg(*list, Eina_Bool *);
 535    *enable = EINA_FALSE;
 536 }
 537
 538 static void
 539 _elm_ctxpopup_smart_sub_object_add(Eo *obj, void *_pd EINA_UNUSED, va_list *list)
 540 {
 541    Evas_Object *sobj = va_arg(*list, Evas_Object *);
 542    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
 543    Eina_Bool int_ret;
 544
 545    eo_do_super(obj, elm_wdg_sub_object_add(sobj, &int_ret));
 546
 547    if (ret) *ret = int_ret;
 548 }
 549
 550 static void
 551 _elm_ctxpopup_smart_sizing_eval(Eo *obj, void *_pd, va_list *list EINA_UNUSED)
 552 {
 553    Evas_Coord_Rectangle rect = { 0, 0, 1, 1 };
 554    Evas_Coord_Point list_size = { 0, 0 };
 555
 556    Elm_Ctxpopup_Smart_Data *sd = _pd;
 557    Elm_Widget_Smart_Data *wd = eo_data_get(obj, ELM_OBJ_WIDGET_CLASS);
 558
 559    if (!sd->arrow) return;  /* simple way to flag "under deletion" */
 560
 561    //Base
 562    sd->dir = _base_geometry_calc(obj, &rect);
 563
 564    _arrow_update(obj, sd->dir, rect);
 565
 566    _base_shift_by_arrow(sd->arrow, sd->dir, &rect);
 567
 568    if ((sd->list) && (sd->list_visible))
 569      {
 570         evas_object_geometry_get(sd->list, 0, 0, &list_size.x, &list_size.y);
 571         if ((list_size.x >= rect.w) || (list_size.y >= rect.h))
 572           {
 573              elm_list_mode_set(sd->list, ELM_LIST_COMPRESS);
 574              evas_object_size_hint_min_set(sd->box, rect.w, rect.h);
 575              evas_object_size_hint_min_set(obj, rect.w, rect.h);
 576           }
 577      }
 578
 579    evas_object_move(wd->resize_obj, rect.x, rect.y);
 580    evas_object_resize(wd->resize_obj, rect.w, rect.h);
 581
 582    _show_signals_emit(obj, sd->dir);
 583 }
 584
 585 static void
 586 _on_parent_del(void *data,
 587                Evas *e __UNUSED__,
 588                Evas_Object *obj __UNUSED__,
 589                void *event_info __UNUSED__)
 590 {
 591    evas_object_del(data);
 592 }
 593
 594 static void
 595 _on_parent_move(void *data,
 596                 Evas *e __UNUSED__,
 597                 Evas_Object *obj __UNUSED__,
 598                 void *event_info __UNUSED__)
 599 {
 600    ELM_CTXPOPUP_DATA_GET(data, sd);
 601
 602    sd->dir = ELM_CTXPOPUP_DIRECTION_UNKNOWN;
 603
 604    if (sd->visible) elm_layout_sizing_eval(data);
 605 }
 606
 607 static void
 608 _on_parent_resize(void *data,
 609                   Evas *e __UNUSED__,
 610                   Evas_Object *obj __UNUSED__,
 611                   void *event_info __UNUSED__)
 612 {
 613    ELM_CTXPOPUP_DATA_GET(data, sd);
 614
 615    sd->dir = ELM_CTXPOPUP_DIRECTION_UNKNOWN;
 616
 617    evas_object_hide(data);
 618 }
 619
 620 static void
 621 _parent_detach(Evas_Object *obj)
 622 {
 623    ELM_CTXPOPUP_DATA_GET(obj, sd);
 624
 625    if (!sd->parent) return;
 626
 627    evas_object_event_callback_del_full
 628      (sd->parent, EVAS_CALLBACK_DEL, _on_parent_del, obj);
 629    evas_object_event_callback_del_full
 630      (sd->parent, EVAS_CALLBACK_MOVE, _on_parent_move, obj);
 631    evas_object_event_callback_del_full
 632      (sd->parent, EVAS_CALLBACK_RESIZE, _on_parent_resize, obj);
 633 }
 634
 635 static void
 636 _on_content_resized(void *data,
 637                     Evas *e __UNUSED__,
 638                     Evas_Object *obj __UNUSED__,
 639                     void *event_info __UNUSED__)
 640 {
 641    ELM_CTXPOPUP_DATA_GET(data, sd);
 642
 643    elm_box_recalculate(sd->box);
 644    elm_layout_sizing_eval(data);
 645 }
 646
 647 //FIXME: lost the content size when theme hook is called.
 648 static void
 649 _elm_ctxpopup_smart_theme(Eo *obj, void *_pd, va_list *list)
 650 {
 651    Elm_Ctxpopup_Smart_Data *sd = _pd;
 652
 653    Eina_Bool int_ret;
 654    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
 655    if (ret) *ret = EINA_FALSE;
 656
 657    eo_do_super(obj, elm_wdg_theme(&int_ret));
 658    if (!int_ret) return;
 659
 660    elm_widget_theme_object_set
 661      (obj, sd->bg, "ctxpopup", "bg", elm_widget_style_get(obj));
 662    elm_widget_theme_object_set
 663      (obj, sd->arrow, "ctxpopup", "arrow", elm_widget_style_get(obj));
 664
 665    if (sd->list)
 666      {
 667         if (!strncmp(elm_object_style_get(obj), "default", strlen("default")))
 668           elm_object_style_set(sd->list, "ctxpopup");
 669         else
 670           elm_object_style_set(sd->list, elm_object_style_get(obj));
 671      }
 672
 673    sd->dir = ELM_CTXPOPUP_DIRECTION_UNKNOWN;
 674
 675    if (sd->visible) elm_layout_sizing_eval(obj);
 676
 677    if (ret) *ret = EINA_TRUE;
 678 }
 679
 680 /* kind of a big and tricky override here: an internal box will hold
 681  * the actual content. content aliases won't be of much help here */
 682 static void
 683 _elm_ctxpopup_smart_content_set(Eo *obj, void *_pd, va_list *list)
 684 {
 685    Evas_Coord min_w = -1, min_h = -1;
 686
 687    Elm_Ctxpopup_Smart_Data *sd = _pd;
 688    const char *part = va_arg(*list, const char *);
 689    Evas_Object *content = va_arg(*list, Evas_Object *);
 690    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
 691    Eina_Bool int_ret = EINA_TRUE;
 692
 693    if ((part) && (strcmp(part, "default")))
 694      {
 695         eo_do_super(obj, elm_obj_container_content_set(part, content, &int_ret));
 696         goto end;
 697      }
 698
 699    if (!content)
 700      {
 701         int_ret = EINA_FALSE;
 702         goto end;
 703      }
 704
 705    if (content == sd->content) goto end;
 706
 707    if (sd->content) evas_object_del(sd->content);
 708    if (sd->content == sd->list) sd->list = NULL;
 709
 710    evas_object_size_hint_weight_set
 711      (content, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 712    evas_object_size_hint_fill_set
 713      (content, EVAS_HINT_FILL, EVAS_HINT_FILL);
 714
 715    /* since it's going to be a box content, not a layout's... */
 716    evas_object_show(content);
 717
 718    evas_object_size_hint_min_get(content, &min_w, &min_h);
 719    evas_object_size_hint_min_set(sd->box, min_w, min_h);
 720    elm_box_pack_end(sd->box, content);
 721
 722    sd->content = content;
 723    sd->dir = ELM_CTXPOPUP_DIRECTION_UNKNOWN;
 724
 725    if (sd->visible) elm_layout_sizing_eval(obj);
 726
 727 end:
 728    if (ret) *ret = int_ret;
 729 }
 730
 731 static void
 732 _elm_ctxpopup_smart_content_get(Eo *obj, void *_pd, va_list *list)
 733 {
 734    const char *part = va_arg(*list, const char *);
 735    Evas_Object **ret = va_arg(*list, Evas_Object **);
 736    *ret = NULL;
 737
 738    if ((part) && (strcmp(part, "default")))
 739      {
 740         eo_do_super(obj, elm_obj_container_content_get(part, ret));
 741         return;
 742      }
 743
 744    Elm_Ctxpopup_Smart_Data *sd = _pd;
 745
 746    *ret = sd->content;
 747 }
 748
 749 static void
 750 _elm_ctxpopup_smart_content_unset(Eo *obj, void *_pd, va_list *list)
 751 {
 752    Evas_Object *content;
 753
 754    const char *part = va_arg(*list, const char *);
 755    Evas_Object **ret = va_arg(*list, Evas_Object **);
 756
 757    if ((part) && (strcmp(part, "default")))
 758      {
 759         eo_do_super(obj, elm_obj_container_content_unset(part, &content));
 760         goto end;
 761      }
 762
 763    Elm_Ctxpopup_Smart_Data *sd = _pd;
 764    content = sd->content;
 765    if (!content) goto end;
 766
 767    sd->content = NULL;
 768    sd->dir = ELM_CTXPOPUP_DIRECTION_UNKNOWN;
 769
 770    if (sd->visible) elm_layout_sizing_eval(obj);
 771
 772 end:
 773    if (ret) *ret = content;
 774 }
 775
 776 static void
 777 _item_text_set_hook(Elm_Object_Item *it,
 778                     const char *part,
 779                     const char *label)
 780 {
 781    Elm_Ctxpopup_Item *ctxpopup_it;
 782
 783    if ((part) && (strcmp(part, "default"))) return;
 784
 785    ctxpopup_it = (Elm_Ctxpopup_Item *)it;
 786
 787    ELM_CTXPOPUP_DATA_GET(WIDGET(ctxpopup_it), sd);
 788
 789    elm_object_item_part_text_set(ctxpopup_it->list_item, "default", label);
 790    sd->dir = ELM_CTXPOPUP_DIRECTION_UNKNOWN;
 791
 792    if (sd->visible) elm_layout_sizing_eval(WIDGET(ctxpopup_it));
 793 }
 794
 795 static const char *
 796 _item_text_get_hook(const Elm_Object_Item *it,
 797                     const char *part)
 798 {
 799    Elm_Ctxpopup_Item *ctxpopup_it;
 800
 801    if (part && strcmp(part, "default")) return NULL;
 802
 803    ctxpopup_it = (Elm_Ctxpopup_Item *)it;
 804    return elm_object_item_part_text_get(ctxpopup_it->list_item, "default");
 805 }
 806
 807 static void
 808 _item_content_set_hook(Elm_Object_Item *it,
 809                        const char *part,
 810                        Evas_Object *content)
 811 {
 812    Elm_Ctxpopup_Item *ctxpopup_it;
 813
 814    if ((part) && (strcmp(part, "icon"))
 815        && (strcmp(part, "start"))
 816        && (strcmp(part, "end"))) return;
 817
 818    ctxpopup_it = (Elm_Ctxpopup_Item *)it;
 819
 820    ELM_CTXPOPUP_DATA_GET(WIDGET(ctxpopup_it), sd);
 821
 822    if ((part) && (!strcmp(part, "end")))
 823      elm_object_item_part_content_set(ctxpopup_it->list_item, "end", content);
 824    else
 825      elm_object_item_part_content_set
 826        (ctxpopup_it->list_item, "start", content);
 827
 828    sd->dir = ELM_CTXPOPUP_DIRECTION_UNKNOWN;
 829
 830    if (sd->visible) elm_layout_sizing_eval(WIDGET(ctxpopup_it));
 831 }
 832
 833 static Evas_Object *
 834 _item_content_get_hook(const Elm_Object_Item *it,
 835                        const char *part)
 836 {
 837    Elm_Ctxpopup_Item *ctxpopup_it;
 838
 839    if (part && strcmp(part, "icon") && strcmp(part, "start")
 840        && strcmp(part, "end")) return NULL;
 841
 842    ctxpopup_it = (Elm_Ctxpopup_Item *)it;
 843
 844    if (part && !strcmp(part, "end"))
 845      return elm_object_item_part_content_get(ctxpopup_it->list_item, "end");
 846    else
 847      return elm_object_item_part_content_get(ctxpopup_it->list_item, "start");
 848 }
 849
 850 static void
 851 _item_disable_hook(Elm_Object_Item *it)
 852 {
 853    Elm_Ctxpopup_Item *ctxpopup_it = (Elm_Ctxpopup_Item *)it;
 854
 855    elm_object_item_disabled_set
 856      (ctxpopup_it->list_item, elm_widget_item_disabled_get(ctxpopup_it));
 857 }
 858
 859 static void
 860 _item_signal_emit_hook(Elm_Object_Item *it,
 861                        const char *emission,
 862                        const char *source)
 863 {
 864    Elm_Ctxpopup_Item *ctxpopup_it = (Elm_Ctxpopup_Item *)it;
 865
 866    elm_object_item_signal_emit(ctxpopup_it->list_item, emission, source);
 867 }
 868
 869 static void
 870 _bg_clicked_cb(void *data,
 871                Evas_Object *obj __UNUSED__,
 872                const char *emission __UNUSED__,
 873                const char *source __UNUSED__)
 874 {
 875    ELM_CTXPOPUP_DATA_GET(data, sd);
 876
 877    _hide_signals_emit(data, sd->dir);
 878 }
 879
 880 static void
 881 _on_show(void *data __UNUSED__,
 882          Evas *e __UNUSED__,
 883          Evas_Object *obj,
 884          void *event_info __UNUSED__)
 885 {
 886    ELM_CTXPOPUP_DATA_GET(obj, sd);
 887
 888    if (sd->list)
 889      {
 890         elm_list_go(sd->list);
 891         sd->visible = EINA_TRUE;
 892         elm_object_focus_set(obj, EINA_TRUE);
 893         return;
 894      }
 895
 896    if (!sd->content) return;
 897
 898    sd->visible = EINA_TRUE;
 899
 900    evas_object_show(sd->bg);
 901    evas_object_show(sd->arrow);
 902
 903    edje_object_signal_emit(sd->bg, "elm,state,show", "elm");
 904    elm_layout_signal_emit(obj, "elm,state,show", "elm");
 905
 906    elm_layout_sizing_eval(obj);
 907
 908    elm_object_focus_set(obj, EINA_TRUE);
 909 }
 910
 911 static void
 912 _on_hide(void *data __UNUSED__,
 913          Evas *e __UNUSED__,
 914          Evas_Object *obj,
 915          void *event_info __UNUSED__)
 916 {
 917    ELM_CTXPOPUP_DATA_GET(obj, sd);
 918
 919    if (!sd->visible) return;
 920
 921    evas_object_hide(sd->bg);
 922    evas_object_hide(sd->arrow);
 923
 924    sd->visible = EINA_FALSE;
 925    sd->list_visible = EINA_FALSE;
 926 }
 927
 928 static void
 929 _on_move(void *data __UNUSED__,
 930          Evas *e __UNUSED__,
 931          Evas_Object *obj,
 932          void *event_info __UNUSED__)
 933 {
 934    ELM_CTXPOPUP_DATA_GET(obj, sd);
 935
 936    if (sd->visible) evas_object_show(sd->arrow);
 937
 938    elm_layout_sizing_eval(obj);
 939 }
 940
 941 static void
 942 _hide_finished_cb(void *data,
 943                   Evas_Object *obj __UNUSED__,
 944                   const char *emission __UNUSED__,
 945                   const char *source __UNUSED__)
 946 {
 947    evas_object_hide(data);
 948    evas_object_smart_callback_call(data, SIG_DISMISSED, NULL);
 949 }
 950
 951 static void
 952 _list_resize_cb(void *data,
 953                 Evas *e __UNUSED__,
 954                 Evas_Object *obj __UNUSED__,
 955                 void *event_info __UNUSED__)
 956 {
 957    ELM_CTXPOPUP_DATA_GET(data, sd);
 958
 959    if (!sd->visible) return;
 960    if (sd->list_visible) return;
 961
 962    sd->list_visible = EINA_TRUE;
 963
 964    evas_object_show(sd->bg);
 965    evas_object_show(sd->arrow);
 966
 967    elm_layout_sizing_eval(data);
 968 }
 969
 970 static void
 971 _ctxpopup_restack_cb(void *data __UNUSED__,
 972                      Evas *e __UNUSED__,
 973                      Evas_Object *obj,
 974                      void *event_info __UNUSED__)
 975 {
 976    ELM_CTXPOPUP_DATA_GET(obj, sd);
 977
 978    evas_object_layer_set(sd->bg, evas_object_layer_get(obj));
 979 }
 980
 981 static void
 982 _list_del(Elm_Ctxpopup_Smart_Data *sd)
 983 {
 984    if (!sd->list) return;
 985
 986    evas_object_del(sd->list);
 987    sd->list = NULL;
 988 }
 989
 990 static Eina_Bool
 991 _item_del_pre_hook(Elm_Object_Item *it)
 992 {
 993    Evas_Object *list;
 994    Elm_Ctxpopup_Item *ctxpopup_it = (Elm_Ctxpopup_Item *)it;
 995
 996    ELM_CTXPOPUP_DATA_GET(WIDGET(ctxpopup_it), sd);
 997
 998    sd->dir = ELM_CTXPOPUP_DIRECTION_UNKNOWN;
 999
1000    list = elm_object_item_widget_get(ctxpopup_it->list_item);
1001
1002    if (eina_list_count(elm_list_items_get(list)) < 2)
1003      {
1004         elm_object_item_del(ctxpopup_it->list_item);
1005         evas_object_hide(WIDGET(ctxpopup_it));
1006
1007         return EINA_TRUE;
1008      }
1009
1010    elm_object_item_del(ctxpopup_it->list_item);
1011    if (sd->list_visible) elm_layout_sizing_eval(WIDGET(ctxpopup_it));
1012
1013    return EINA_TRUE;
1014 }
1015
1016 static void
1017 _elm_ctxpopup_smart_disable(Eo *obj, void *_pd, va_list *list)
1018 {
1019    Elm_Ctxpopup_Smart_Data *sd = _pd;
1020
1021    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
1022    if (ret) *ret = EINA_FALSE;
1023    Eina_Bool int_ret;
1024
1025    eo_do_super(obj, elm_wdg_disable(&int_ret));
1026    if (!int_ret) return;
1027
1028    elm_object_disabled_set(sd->list, elm_widget_disabled_get(obj));
1029
1030    if (ret) *ret = EINA_TRUE;
1031 }
1032
1033 static void
1034 _elm_ctxpopup_smart_add(Eo *obj, void *_pd, va_list *list EINA_UNUSED)
1035 {
1036    Elm_Ctxpopup_Smart_Data *priv = _pd;
1037
1038    eo_do_super(obj, evas_obj_smart_add());
1039
1040    elm_layout_theme_set(obj, "ctxpopup", "base", elm_widget_style_get(obj));
1041    elm_layout_signal_callback_add
1042      (obj, "elm,action,hide,finished", "", _hide_finished_cb, obj);
1043
1044    //Background
1045    priv->bg = edje_object_add(evas_object_evas_get(obj));
1046    elm_widget_theme_object_set(obj, priv->bg, "ctxpopup", "bg", "default");
1047    edje_object_signal_callback_add
1048      (priv->bg, "elm,action,click", "", _bg_clicked_cb, obj);
1049
1050    evas_object_stack_below(priv->bg, obj);
1051
1052    //Arrow
1053    priv->arrow = edje_object_add(evas_object_evas_get(obj));
1054    elm_widget_theme_object_set
1055      (obj, priv->arrow, "ctxpopup", "arrow", "default");
1056
1057    priv->dir_priority[0] = ELM_CTXPOPUP_DIRECTION_UP;
1058    priv->dir_priority[1] = ELM_CTXPOPUP_DIRECTION_LEFT;
1059    priv->dir_priority[2] = ELM_CTXPOPUP_DIRECTION_RIGHT;
1060    priv->dir_priority[3] = ELM_CTXPOPUP_DIRECTION_DOWN;
1061    priv->dir = ELM_CTXPOPUP_DIRECTION_UNKNOWN;
1062
1063    evas_object_event_callback_add
1064      (obj, EVAS_CALLBACK_RESTACK, _ctxpopup_restack_cb, obj);
1065
1066    priv->box = elm_box_add(obj);
1067    evas_object_size_hint_weight_set
1068      (priv->box, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1069
1070    evas_object_event_callback_add
1071      (priv->box, EVAS_CALLBACK_RESIZE, _on_content_resized, obj);
1072
1073    /* box will be our content placeholder, thus the parent's version call */
1074    Eina_Bool ret;
1075    eo_do_super(obj, elm_obj_container_content_set("elm.swallow.content", priv->box, &ret));
1076
1077    evas_object_event_callback_add(obj, EVAS_CALLBACK_SHOW, _on_show, NULL);
1078    evas_object_event_callback_add(obj, EVAS_CALLBACK_HIDE, _on_hide, NULL);
1079    evas_object_event_callback_add(obj, EVAS_CALLBACK_MOVE, _on_move, NULL);
1080
1081    elm_widget_can_focus_set(obj, EINA_TRUE);
1082 }
1083
1084 static void
1085 _elm_ctxpopup_smart_del(Eo *obj, void *_pd, va_list *list EINA_UNUSED)
1086 {
1087    Elm_Ctxpopup_Smart_Data *sd = _pd;
1088
1089    evas_object_event_callback_del_full
1090      (sd->box, EVAS_CALLBACK_RESIZE, _on_content_resized, obj);
1091    _parent_detach(obj);
1092
1093    elm_ctxpopup_clear(obj);
1094    evas_object_del(sd->arrow);
1095    sd->arrow = NULL; /* stops _sizing_eval() from going on on deletion */
1096
1097    evas_object_del(sd->bg);
1098    sd->bg = NULL;
1099
1100    eo_do_super(obj, evas_obj_smart_del());
1101 }
1102
1103 static void
1104 _elm_ctxpopup_smart_parent_set(Eo *obj, void *_pd EINA_UNUSED, va_list *list)
1105 {
1106    Evas_Object *parent = va_arg(*list, Evas_Object *);
1107    //default parent is to be hover parent
1108    elm_ctxpopup_hover_parent_set(obj, parent);
1109 }
1110
1111 EAPI Evas_Object *
1112 elm_ctxpopup_add(Evas_Object *parent)
1113 {
1114    EINA_SAFETY_ON_NULL_RETURN_VAL(parent, NULL);
1115    Evas_Object *obj = eo_add(MY_CLASS, parent);
1116    eo_unref(obj);
1117    return obj;
1118 }
1119
1120 static void
1121 _constructor(Eo *obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED)
1122 {
1123    eo_do_super(obj, eo_constructor());
1124    eo_do(obj,
1125          evas_obj_type_set(MY_CLASS_NAME),
1126          evas_obj_smart_callbacks_descriptions_set(_smart_callbacks, NULL));
1127
1128    if (!elm_widget_sub_object_add(eo_parent_get(obj), obj))
1129      ERR("could not add %p as sub object of %p", obj, eo_parent_get(obj));
1130 }
1131
1132 EAPI void
1133 elm_ctxpopup_hover_parent_set(Evas_Object *obj,
1134                               Evas_Object *parent)
1135 {
1136    ELM_CTXPOPUP_CHECK(obj);
1137    eo_do(obj, elm_obj_ctxpopup_hover_parent_set(parent));
1138 }
1139
1140 static void
1141 _hover_parent_set(Eo *obj, void *_pd, va_list *list)
1142 {
1143    Evas_Coord x, y, w, h;
1144    Evas_Object *parent = va_arg(*list, Evas_Object *);
1145
1146    Elm_Ctxpopup_Smart_Data *sd = _pd;
1147
1148    if (!parent) return;
1149
1150    _parent_detach(obj);
1151
1152    evas_object_event_callback_add
1153      (parent, EVAS_CALLBACK_DEL, _on_parent_del, obj);
1154    evas_object_event_callback_add
1155      (parent, EVAS_CALLBACK_MOVE, _on_parent_move, obj);
1156    evas_object_event_callback_add
1157      (parent, EVAS_CALLBACK_RESIZE, _on_parent_resize, obj);
1158
1159    sd->parent = parent;
1160
1161    //Update Background
1162    evas_object_geometry_get(parent, &x, &y, &w, &h);
1163    evas_object_move(sd->bg, x, y);
1164    evas_object_resize(sd->bg, w, h);
1165
1166    if (sd->visible) elm_layout_sizing_eval(obj);
1167 }
1168
1169 EAPI Evas_Object *
1170 elm_ctxpopup_hover_parent_get(const Evas_Object *obj)
1171 {
1172    ELM_CTXPOPUP_CHECK(obj) NULL;
1173    Evas_Object *ret = NULL;
1174    eo_do((Eo *) obj, elm_obj_ctxpopup_hover_parent_get(&ret));
1175    return ret;
1176 }
1177
1178 static void
1179 _hover_parent_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
1180 {
1181    Evas_Object **ret = va_arg(*list, Evas_Object **);
1182    Elm_Ctxpopup_Smart_Data *sd = _pd;
1183    *ret = sd->parent;
1184 }
1185
1186 EAPI void
1187 elm_ctxpopup_clear(Evas_Object *obj)
1188 {
1189    ELM_CTXPOPUP_CHECK(obj);
1190    eo_do(obj, elm_obj_ctxpopup_clear());
1191 }
1192
1193 static void
1194 _clear(Eo *obj EINA_UNUSED, void *_pd, va_list *list EINA_UNUSED)
1195 {
1196    Elm_Ctxpopup_Smart_Data *sd = _pd;
1197
1198    _list_del(sd);
1199    sd->dir = ELM_CTXPOPUP_DIRECTION_UNKNOWN;
1200 }
1201
1202 EAPI void
1203 elm_ctxpopup_horizontal_set(Evas_Object *obj,
1204                             Eina_Bool horizontal)
1205 {
1206    ELM_CTXPOPUP_CHECK(obj);
1207    eo_do(obj, elm_obj_ctxpopup_horizontal_set(horizontal));
1208 }
1209
1210 static void
1211 _horizontal_set(Eo *obj, void *_pd, va_list *list)
1212 {
1213    Eina_Bool horizontal = va_arg(*list, int);
1214    Elm_Ctxpopup_Smart_Data *sd = _pd;
1215
1216    sd->horizontal = !!horizontal;
1217
1218    if (!sd->list) return;
1219
1220    elm_list_horizontal_set(sd->list, sd->horizontal);
1221
1222    sd->dir = ELM_CTXPOPUP_DIRECTION_UNKNOWN;
1223
1224    if (sd->visible) elm_layout_sizing_eval(obj);
1225 }
1226
1227 EAPI Eina_Bool
1228 elm_ctxpopup_horizontal_get(const Evas_Object *obj)
1229 {
1230    ELM_CTXPOPUP_CHECK(obj) EINA_FALSE;
1231    Eina_Bool ret = EINA_FALSE;
1232    eo_do((Eo *) obj, elm_obj_ctxpopup_horizontal_get(&ret));
1233    return ret;
1234 }
1235
1236 static void
1237 _horizontal_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
1238 {
1239    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
1240    Elm_Ctxpopup_Smart_Data *sd = _pd;
1241
1242    *ret = sd->horizontal;
1243 }
1244
1245 EAPI Elm_Object_Item *
1246 elm_ctxpopup_item_append(Evas_Object *obj,
1247                          const char *label,
1248                          Evas_Object *icon,
1249                          Evas_Smart_Cb func,
1250                          const void *data)
1251 {
1252
1253    ELM_CTXPOPUP_CHECK(obj) NULL;
1254    Elm_Object_Item *ret = NULL;
1255    eo_do(obj, elm_obj_ctxpopup_item_append(label, icon, func, data, &ret));
1256    return ret;
1257 }
1258
1259 static void
1260 _item_append(Eo *obj, void *_pd, va_list *list)
1261 {
1262    const char *label = va_arg(*list, const char *);
1263    Evas_Object *icon = va_arg(*list, Evas_Object *);
1264    Evas_Smart_Cb func = va_arg(*list, Evas_Smart_Cb);
1265    const void *data = va_arg(*list, const void *);
1266    Elm_Object_Item **ret = va_arg(*list, Elm_Object_Item **);
1267    *ret = NULL;
1268
1269    Elm_Ctxpopup_Item *item;
1270
1271    Elm_Ctxpopup_Smart_Data *sd = _pd;
1272
1273    item = elm_widget_item_new(obj, Elm_Ctxpopup_Item);
1274    if (!item) return;
1275
1276    elm_widget_item_del_pre_hook_set(item, _item_del_pre_hook);
1277    elm_widget_item_disable_hook_set(item, _item_disable_hook);
1278    elm_widget_item_text_set_hook_set(item, _item_text_set_hook);
1279    elm_widget_item_text_get_hook_set(item, _item_text_get_hook);
1280    elm_widget_item_content_set_hook_set(item, _item_content_set_hook);
1281    elm_widget_item_content_get_hook_set(item, _item_content_get_hook);
1282    elm_widget_item_signal_emit_hook_set(item, _item_signal_emit_hook);
1283
1284    if (!sd->list)
1285      {
1286         //The first item is appended.
1287         sd->list = elm_list_add(obj);
1288         elm_list_mode_set(sd->list, ELM_LIST_EXPAND);
1289         elm_list_horizontal_set(sd->list, sd->horizontal);
1290         evas_object_event_callback_add
1291           (sd->list, EVAS_CALLBACK_RESIZE, _list_resize_cb, obj);
1292         elm_layout_content_set(obj, "default", sd->list);
1293      }
1294
1295    item->list_item =
1296      elm_list_item_append(sd->list, label, icon, NULL, func, data);
1297
1298    sd->dir = ELM_CTXPOPUP_DIRECTION_UNKNOWN;
1299
1300    if (sd->visible) elm_layout_sizing_eval(obj);
1301
1302    *ret = (Elm_Object_Item *)item;
1303 }
1304
1305 EAPI void
1306 elm_ctxpopup_direction_priority_set(Evas_Object *obj,
1307                                     Elm_Ctxpopup_Direction first,
1308                                     Elm_Ctxpopup_Direction second,
1309                                     Elm_Ctxpopup_Direction third,
1310                                     Elm_Ctxpopup_Direction fourth)
1311 {
1312    ELM_CTXPOPUP_CHECK(obj);
1313    eo_do(obj, elm_obj_ctxpopup_direction_priority_set(first, second, third, fourth));
1314 }
1315
1316 static void
1317 _direction_priority_set(Eo *obj, void *_pd, va_list *list)
1318 {
1319    Elm_Ctxpopup_Direction first = va_arg(*list, Elm_Ctxpopup_Direction);
1320    Elm_Ctxpopup_Direction second = va_arg(*list, Elm_Ctxpopup_Direction);
1321    Elm_Ctxpopup_Direction third = va_arg(*list, Elm_Ctxpopup_Direction);
1322    Elm_Ctxpopup_Direction fourth = va_arg(*list, Elm_Ctxpopup_Direction);
1323
1324    Elm_Ctxpopup_Smart_Data *sd = _pd;
1325
1326    sd->dir_priority[0] = first;
1327    sd->dir_priority[1] = second;
1328    sd->dir_priority[2] = third;
1329    sd->dir_priority[3] = fourth;
1330
1331    if (sd->visible) elm_layout_sizing_eval(obj);
1332 }
1333
1334 EAPI void
1335 elm_ctxpopup_direction_priority_get(Evas_Object *obj,
1336                                     Elm_Ctxpopup_Direction *first,
1337                                     Elm_Ctxpopup_Direction *second,
1338                                     Elm_Ctxpopup_Direction *third,
1339                                     Elm_Ctxpopup_Direction *fourth)
1340 {
1341    ELM_CTXPOPUP_CHECK(obj);
1342    eo_do(obj, elm_obj_ctxpopup_direction_priority_get(first, second, third, fourth));
1343 }
1344
1345 static void
1346 _direction_priority_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
1347 {
1348    Elm_Ctxpopup_Direction *first = va_arg(*list, Elm_Ctxpopup_Direction *);
1349    Elm_Ctxpopup_Direction *second = va_arg(*list, Elm_Ctxpopup_Direction *);
1350    Elm_Ctxpopup_Direction *third = va_arg(*list, Elm_Ctxpopup_Direction *);
1351    Elm_Ctxpopup_Direction *fourth = va_arg(*list, Elm_Ctxpopup_Direction *);
1352
1353    Elm_Ctxpopup_Smart_Data *sd = _pd;
1354
1355    if (first) *first = sd->dir_priority[0];
1356    if (second) *second = sd->dir_priority[1];
1357    if (third) *third = sd->dir_priority[2];
1358    if (fourth) *fourth = sd->dir_priority[3];
1359 }
1360
1361 EAPI Elm_Ctxpopup_Direction
1362 elm_ctxpopup_direction_get(const Evas_Object *obj)
1363 {
1364    ELM_CTXPOPUP_CHECK(obj) ELM_CTXPOPUP_DIRECTION_UNKNOWN;
1365    Elm_Ctxpopup_Direction ret = ELM_CTXPOPUP_DIRECTION_UNKNOWN;
1366    eo_do((Eo *) obj, elm_obj_ctxpopup_direction_get(&ret));
1367    return ret;
1368 }
1369
1370 static void
1371 _direction_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
1372 {
1373    Elm_Ctxpopup_Direction *ret = va_arg(*list, Elm_Ctxpopup_Direction *);
1374    Elm_Ctxpopup_Smart_Data *sd = _pd;
1375
1376    *ret = sd->dir;
1377 }
1378
1379 EAPI void
1380 elm_ctxpopup_dismiss(Evas_Object *obj)
1381 {
1382    ELM_CTXPOPUP_CHECK(obj);
1383    eo_do(obj, elm_obj_ctxpopup_dismiss());
1384 }
1385
1386 static void
1387 _dismiss(Eo *obj, void *_pd, va_list *list EINA_UNUSED)
1388 {
1389    Elm_Ctxpopup_Smart_Data *sd = _pd;
1390
1391    _hide_signals_emit(obj, sd->dir);
1392 }
1393
1394 static void
1395 _class_constructor(Eo_Class *klass)
1396 {
1397    const Eo_Op_Func_Description func_desc[] = {
1398         EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor),
1399
1400         EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_ADD), _elm_ctxpopup_smart_add),
1401         EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_DEL), _elm_ctxpopup_smart_del),
1402
1403         EO_OP_FUNC(ELM_WIDGET_ID(ELM_WIDGET_SUB_ID_PARENT_SET), _elm_ctxpopup_smart_parent_set),
1404         EO_OP_FUNC(ELM_WIDGET_ID(ELM_WIDGET_SUB_ID_DISABLE), _elm_ctxpopup_smart_disable),
1405         EO_OP_FUNC(ELM_WIDGET_ID(ELM_WIDGET_SUB_ID_EVENT), _elm_ctxpopup_smart_event),
1406         EO_OP_FUNC(ELM_WIDGET_ID(ELM_WIDGET_SUB_ID_THEME), _elm_ctxpopup_smart_theme),
1407         EO_OP_FUNC(ELM_WIDGET_ID(ELM_WIDGET_SUB_ID_SUB_OBJECT_ADD), _elm_ctxpopup_smart_sub_object_add),
1408         EO_OP_FUNC(ELM_WIDGET_ID(ELM_WIDGET_SUB_ID_FOCUS_NEXT_MANAGER_IS), _elm_ctxpopup_smart_focus_next_manager_is),
1409         EO_OP_FUNC(ELM_WIDGET_ID(ELM_WIDGET_SUB_ID_FOCUS_NEXT),  _elm_ctxpopup_smart_focus_next),
1410         EO_OP_FUNC(ELM_WIDGET_ID(ELM_WIDGET_SUB_ID_FOCUS_DIRECTION_MANAGER_IS), _elm_ctxpopup_smart_focus_direction_manager_is),
1411
1412         EO_OP_FUNC(ELM_OBJ_CONTAINER_ID(ELM_OBJ_CONTAINER_SUB_ID_CONTENT_SET), _elm_ctxpopup_smart_content_set),
1413         EO_OP_FUNC(ELM_OBJ_CONTAINER_ID(ELM_OBJ_CONTAINER_SUB_ID_CONTENT_GET), _elm_ctxpopup_smart_content_get),
1414         EO_OP_FUNC(ELM_OBJ_CONTAINER_ID(ELM_OBJ_CONTAINER_SUB_ID_CONTENT_UNSET), _elm_ctxpopup_smart_content_unset),
1415
1416         EO_OP_FUNC(ELM_OBJ_LAYOUT_ID(ELM_OBJ_LAYOUT_SUB_ID_SIZING_EVAL), _elm_ctxpopup_smart_sizing_eval),
1417         EO_OP_FUNC(ELM_OBJ_LAYOUT_ID(ELM_OBJ_LAYOUT_SUB_ID_SUB_OBJECT_ADD_ENABLE), _elm_ctxpopup_smart_layout_sub_object_add_enable),
1418
1419         EO_OP_FUNC(ELM_OBJ_CTXPOPUP_ID(ELM_OBJ_CTXPOPUP_SUB_ID_HOVER_PARENT_SET), _hover_parent_set),
1420         EO_OP_FUNC(ELM_OBJ_CTXPOPUP_ID(ELM_OBJ_CTXPOPUP_SUB_ID_HOVER_PARENT_GET), _hover_parent_get),
1421         EO_OP_FUNC(ELM_OBJ_CTXPOPUP_ID(ELM_OBJ_CTXPOPUP_SUB_ID_CLEAR), _clear),
1422         EO_OP_FUNC(ELM_OBJ_CTXPOPUP_ID(ELM_OBJ_CTXPOPUP_SUB_ID_HORIZONTAL_SET), _horizontal_set),
1423         EO_OP_FUNC(ELM_OBJ_CTXPOPUP_ID(ELM_OBJ_CTXPOPUP_SUB_ID_HORIZONTAL_GET), _horizontal_get),
1424         EO_OP_FUNC(ELM_OBJ_CTXPOPUP_ID(ELM_OBJ_CTXPOPUP_SUB_ID_ITEM_APPEND), _item_append),
1425         EO_OP_FUNC(ELM_OBJ_CTXPOPUP_ID(ELM_OBJ_CTXPOPUP_SUB_ID_DIRECTION_PRIORITY_SET), _direction_priority_set),
1426         EO_OP_FUNC(ELM_OBJ_CTXPOPUP_ID(ELM_OBJ_CTXPOPUP_SUB_ID_DIRECTION_PRIORITY_GET), _direction_priority_get),
1427         EO_OP_FUNC(ELM_OBJ_CTXPOPUP_ID(ELM_OBJ_CTXPOPUP_SUB_ID_DIRECTION_GET), _direction_get),
1428         EO_OP_FUNC(ELM_OBJ_CTXPOPUP_ID(ELM_OBJ_CTXPOPUP_SUB_ID_DISMISS), _dismiss),
1429         EO_OP_FUNC_SENTINEL
1430    };
1431    eo_class_funcs_set(klass, func_desc);
1432 }
1433 static const Eo_Op_Description op_desc[] = {
1434      EO_OP_DESCRIPTION(ELM_OBJ_CTXPOPUP_SUB_ID_HOVER_PARENT_SET, "Set the Ctxpopup's parent."),
1435      EO_OP_DESCRIPTION(ELM_OBJ_CTXPOPUP_SUB_ID_HOVER_PARENT_GET, "Get the Ctxpopup's parent."),
1436      EO_OP_DESCRIPTION(ELM_OBJ_CTXPOPUP_SUB_ID_CLEAR, "Clear all items in the given ctxpopup object."),
1437      EO_OP_DESCRIPTION(ELM_OBJ_CTXPOPUP_SUB_ID_HORIZONTAL_SET, "Change the ctxpopup's orientation to horizontal or vertical."),
1438      EO_OP_DESCRIPTION(ELM_OBJ_CTXPOPUP_SUB_ID_HORIZONTAL_GET, "Get the value of current ctxpopup object's orientation."),
1439      EO_OP_DESCRIPTION(ELM_OBJ_CTXPOPUP_SUB_ID_ITEM_APPEND, "Add a new item to a ctxpopup object."),
1440      EO_OP_DESCRIPTION(ELM_OBJ_CTXPOPUP_SUB_ID_DIRECTION_PRIORITY_SET, "Set the direction priority of a ctxpopup."),
1441      EO_OP_DESCRIPTION(ELM_OBJ_CTXPOPUP_SUB_ID_DIRECTION_PRIORITY_GET, "Get the direction priority of a ctxpopup."),
1442      EO_OP_DESCRIPTION(ELM_OBJ_CTXPOPUP_SUB_ID_DIRECTION_GET, "Get the current direction of a ctxpopup."),
1443      EO_OP_DESCRIPTION(ELM_OBJ_CTXPOPUP_SUB_ID_DISMISS, "Dismiss a ctxpopup object."),
1444      EO_OP_DESCRIPTION_SENTINEL
1445 };
1446 static const Eo_Class_Description class_desc = {
1447      EO_VERSION,
1448      MY_CLASS_NAME,
1449      EO_CLASS_TYPE_REGULAR,
1450      EO_CLASS_DESCRIPTION_OPS(&ELM_OBJ_CTXPOPUP_BASE_ID, op_desc, ELM_OBJ_CTXPOPUP_SUB_ID_LAST),
1451      NULL,
1452      sizeof(Elm_Ctxpopup_Smart_Data),
1453      _class_constructor,
1454      NULL
1455 };
1456 EO_DEFINE_CLASS(elm_obj_ctxpopup_class_get, &class_desc, ELM_OBJ_LAYOUT_CLASS, NULL);