src/lib/elc_naviframe.c

   1 #ifdef HAVE_CONFIG_H
   2 # include "elementary_config.h"
   3 #endif
   4
   5 #define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
   6 #define ELM_INTERFACE_ATSPI_WIDGET_ACTION_PROTECTED
   7 #define ELM_WIDGET_ITEM_PROTECTED
   8
   9 #include <Elementary.h>
  10 #include "elm_priv.h"
  11 #include "elm_widget_naviframe.h"
  12 #include "elm_widget_container.h"
  13
  14 #define MY_CLASS ELM_NAVIFRAME_CLASS
  15
  16 #define MY_CLASS_NAME "Elm_Naviframe"
  17 #define MY_CLASS_NAME_LEGACY "elm_naviframe"
  18
  19 static const char CONTENT_PART[] = "elm.swallow.content";
  20 static const char PREV_BTN_PART[] = "elm.swallow.prev_btn";
  21 static const char NEXT_BTN_PART[] = "elm.swallow.next_btn";
  22 static const char ICON_PART[] = "elm.swallow.icon";
  23 static const char TITLE_PART[] = "elm.text.title";
  24 static const char SUBTITLE_PART[] = "elm.text.subtitle";
  25 static const char TITLE_ACCESS_PART[] = "access.title";
  26
  27 static const char SIG_TRANSITION_FINISHED[] = "transition,finished";
  28 static const char SIG_TITLE_TRANSITION_FINISHED[] = "title,transition,finished";
  29 static const char SIG_TITLE_CLICKED[] = "title,clicked";
  30 static const char SIG_ITEM_ACTIVATED[] = "item,activated";
  31 //TIZEN_ONLY(20161213): apply screen_reader_changed callback
  32 static const char SIG_ATSPI_SCREEN_READER_CHANGED[] = "atspi,screen,reader,changed";
  33 //
  34 static const Evas_Smart_Cb_Description _smart_callbacks[] = {
  35    {SIG_TRANSITION_FINISHED, ""},
  36    {SIG_TITLE_TRANSITION_FINISHED, ""},
  37    {SIG_TITLE_CLICKED, ""},
  38    {SIG_WIDGET_LANG_CHANGED, ""}, /**< handled by elm_widget */
  39    {SIG_WIDGET_ACCESS_CHANGED, ""}, /**< handled by elm_widget */
  40    {SIG_LAYOUT_FOCUSED, ""}, /**< handled by elm_layout */
  41    {SIG_LAYOUT_UNFOCUSED, ""}, /**< handled by elm_layout */
  42    {SIG_ITEM_ACTIVATED, ""},
  43    //TIZEN_ONLY(20161213): apply screen_reader_changed callback
  44    {SIG_ATSPI_SCREEN_READER_CHANGED, ""},
  45    //
  46    {NULL, NULL}
  47 };
  48
  49 //TIZEN ONLY(20160829): Support tizen transition
  50 static int initted = 0;
  51 static Elm_Naviframe_Mod_Api *nf_mod = NULL;
  52
  53 static void
  54 _nf_mod_init(void)
  55 {
  56    Elm_Module *mod;
  57
  58    initted++;
  59    if (initted > 1) return;
  60    if (!(mod = _elm_module_find_as("naviframe/api"))) return;
  61
  62    mod->api = malloc(sizeof(Elm_Naviframe_Mod_Api));
  63    if (!mod->api) return;
  64
  65    ((Elm_Naviframe_Mod_Api *)(mod->api))->tizen_push_effect =
  66       _elm_module_symbol_get(mod, "tizen_push_effect");
  67    ((Elm_Naviframe_Mod_Api *)(mod->api))->tizen_pop_effect =
  68       _elm_module_symbol_get(mod, "tizen_pop_effect");
  69    ((Elm_Naviframe_Mod_Api *)(mod->api))->tizen_push_deferred_effect =
  70       _elm_module_symbol_get(mod, "tizen_push_deferred_effect");
  71    ((Elm_Naviframe_Mod_Api *)(mod->api))->tizen_pop_deferred_effect =
  72       _elm_module_symbol_get(mod, "tizen_pop_deferred_effect");
  73    ((Elm_Naviframe_Mod_Api *)(mod->api))->tizen_effect_enabled_get =
  74       _elm_module_symbol_get(mod, "tizen_effect_enabled_get");
  75    ((Elm_Naviframe_Mod_Api *)(mod->api))->tizen_effect_cancel =
  76       _elm_module_symbol_get(mod, "tizen_effect_cancel");
  77
  78    nf_mod = mod->api;
  79 }
  80 //
  81
  82 //TIZEN ONLY(20161208): Support tizen transition
  83 static Eina_Bool
  84 _tizen_effect_enabled_get(Elm_Naviframe_Item_Data *it)
  85 {
  86    if (!it) return EINA_FALSE;
  87    if (nf_mod &&
  88        nf_mod->tizen_effect_enabled_get &&
  89        nf_mod->tizen_effect_enabled_get(VIEW(it)))
  90      {
  91         return EINA_TRUE;
  92      }
  93
  94    return EINA_FALSE;
  95 }
  96 //
  97
  98 static Eina_Bool _on_item_back_btn_clicked(void *data,
  99       Eo *obj EINA_UNUSED, const Eo_Event_Description *desc EINA_UNUSED, void *event_info EINA_UNUSED);
 100
 101 static Eina_Bool _key_action_top_item_get(Evas_Object *obj, const char *params);
 102 static Eina_Bool _key_action_item_pop(Evas_Object *obj, const char *params);
 103
 104 static char *_access_info_cb(void *data, Evas_Object *obj EINA_UNUSED);
 105
 106 static const Elm_Action key_actions[] = {
 107    {"top_item_get", _key_action_top_item_get},
 108    {"item_pop", _key_action_item_pop},
 109    {NULL, NULL}
 110 };
 111
 112 static void
 113 _resize_object_reset(Evas_Object *obj, Elm_Naviframe_Item_Data *it)
 114 {
 115    if (it)
 116      {
 117         elm_widget_resize_object_set(obj, VIEW(it), EINA_FALSE);
 118         evas_object_raise(VIEW(it));
 119      }
 120 }
 121
 122 static void
 123 _prev_page_focus_recover(Elm_Naviframe_Item_Data *it)
 124 {
 125    Evas_Object *newest;
 126    unsigned int order = 0;
 127
 128    newest = elm_widget_newest_focus_order_get(VIEW(it), &order, EINA_TRUE);
 129    if (newest)
 130      elm_object_focus_set(newest, EINA_TRUE);
 131    else
 132      {
 133         if (elm_object_focus_allow_get(VIEW(it)))
 134           elm_object_focus_set(VIEW(it), EINA_TRUE);
 135         else
 136           elm_object_focus_set(WIDGET(it), EINA_TRUE);
 137      }
 138 }
 139
 140 EOLIAN static Eina_Bool
 141 _elm_naviframe_elm_widget_translate(Eo *obj EINA_UNUSED, Elm_Naviframe_Data *sd)
 142 {
 143    Elm_Naviframe_Item_Data *it;
 144
 145    EINA_INLIST_FOREACH(sd->stack, it)
 146      eo_do(EO_OBJ(it), elm_wdg_item_translate());
 147
 148    eo_do_super(obj, MY_CLASS, elm_obj_widget_translate());
 149
 150    return EINA_TRUE;
 151 }
 152
 153 static void
 154 _item_content_del_cb(void *data,
 155                      Evas *e EINA_UNUSED,
 156                      Evas_Object *obj EINA_UNUSED,
 157                      void *event_info EINA_UNUSED)
 158 {
 159    Elm_Naviframe_Item_Data *it = data;
 160
 161    it->content = NULL;
 162    elm_object_signal_emit(VIEW(it), "elm,state,content,hide", "elm");
 163 }
 164
 165 static void
 166 _item_title_prev_btn_del_cb(void *data,
 167                             Evas *e EINA_UNUSED,
 168                             Evas_Object *obj EINA_UNUSED,
 169                             void *event_info EINA_UNUSED)
 170 {
 171    Elm_Naviframe_Item_Data *it = data;
 172
 173    it->title_prev_btn = NULL;
 174    if (it->auto_pushed_btn) it->auto_pushed_btn = NULL;
 175    elm_object_signal_emit(VIEW(it), "elm,state,prev_btn,hide", "elm");
 176 }
 177
 178 static void
 179 _item_title_next_btn_del_cb(void *data,
 180                             Evas *e EINA_UNUSED,
 181                             Evas_Object *obj EINA_UNUSED,
 182                             void *event_info EINA_UNUSED)
 183 {
 184    Elm_Naviframe_Item_Data *it = data;
 185
 186    it->title_next_btn = NULL;
 187    elm_object_signal_emit(VIEW(it), "elm,state,next_btn,hide", "elm");
 188 }
 189
 190 static void
 191 _item_title_icon_del_cb(void *data,
 192                         Evas *e EINA_UNUSED,
 193                         Evas_Object *obj EINA_UNUSED,
 194                         void *event_info EINA_UNUSED)
 195 {
 196    Elm_Naviframe_Item_Data *it = data;
 197
 198    it->title_icon = NULL;
 199    elm_object_signal_emit(VIEW(it), "elm,state,icon,hide", "elm");
 200 }
 201
 202 static void
 203 _title_content_del(void *data,
 204                    Evas *e EINA_UNUSED,
 205                    Evas_Object *obj EINA_UNUSED,
 206                    void *event_info EINA_UNUSED)
 207 {
 208    char buf[1024];
 209    Elm_Naviframe_Content_Item_Pair *pair = data;
 210    Elm_Naviframe_Item_Data *it = pair->it;
 211    snprintf(buf, sizeof(buf), "elm,state,%s,hide", pair->part);
 212    elm_object_signal_emit(VIEW(it), buf, "elm");
 213    it->content_list = eina_inlist_remove(it->content_list,
 214                                          EINA_INLIST_GET(pair));
 215    eina_stringshare_del(pair->part);
 216    free(pair);
 217 }
 218
 219 static void
 220 _item_free(Elm_Naviframe_Item_Data *it)
 221 {
 222    Eina_Inlist *l;
 223    Elm_Naviframe_Content_Item_Pair *content_pair;
 224    Elm_Naviframe_Text_Item_Pair *text_pair;
 225
 226    ELM_NAVIFRAME_DATA_GET(WIDGET(it), sd);
 227
 228    eina_stringshare_del(it->style);
 229    eina_stringshare_del(it->title_label);
 230    eina_stringshare_del(it->subtitle_label);
 231
 232    EINA_INLIST_FOREACH_SAFE(it->content_list, l, content_pair)
 233      {
 234         if (content_pair->content)
 235           {
 236              evas_object_event_callback_del(content_pair->content,
 237                                             EVAS_CALLBACK_DEL,
 238                                             _title_content_del);
 239              evas_object_del(content_pair->content);
 240           }
 241         eina_stringshare_del(content_pair->part);
 242         free(content_pair);
 243      }
 244    EINA_INLIST_FOREACH_SAFE(it->text_list, l, text_pair)
 245      {
 246         eina_stringshare_del(text_pair->part);
 247         free(text_pair);
 248      }
 249
 250    if (it->content)
 251      {
 252         if ((sd->preserve) && (!sd->on_deletion))
 253           {
 254              /* so that elm does not delete the contents with the item's
 255               * view after the destructor */
 256              elm_object_part_content_unset(VIEW(it), CONTENT_PART);
 257              evas_object_event_callback_del
 258                 (it->content, EVAS_CALLBACK_DEL, _item_content_del_cb);
 259              evas_object_hide(it->content);
 260           }
 261      }
 262 }
 263
 264 static void
 265 _item_content_signals_emit(Elm_Naviframe_Item_Data *it)
 266 {
 267    Elm_Naviframe_Content_Item_Pair *content_pair;
 268    char buf[1024];
 269    //content
 270    if (it->content)
 271      elm_object_signal_emit(VIEW(it), "elm,state,content,show", "elm");
 272    else
 273      elm_object_signal_emit(VIEW(it), "elm,state,content,hide", "elm");
 274
 275    //prev button
 276    if (it->title_prev_btn)
 277      elm_object_signal_emit(VIEW(it), "elm,state,prev_btn,show", "elm");
 278    else
 279      elm_object_signal_emit(VIEW(it), "elm,state,prev_btn,hide", "elm");
 280
 281    //next button
 282    if (it->title_next_btn)
 283      elm_object_signal_emit(VIEW(it), "elm,state,next_btn,show", "elm");
 284    else
 285      elm_object_signal_emit(VIEW(it), "elm,state,next_btn,hide", "elm");
 286
 287    if (it->title_icon)
 288      elm_object_signal_emit(VIEW(it), "elm,state,icon,show", "elm");
 289    else
 290      elm_object_signal_emit(VIEW(it), "elm,state,icon,hide", "elm");
 291
 292    EINA_INLIST_FOREACH(it->content_list, content_pair)
 293      {
 294         if (content_pair->content)
 295           snprintf(buf, sizeof(buf), "elm,state,%s,show", content_pair->part);
 296         else
 297           snprintf(buf, sizeof(buf), "elm,state,%s,hide", content_pair->part);
 298         elm_object_signal_emit(VIEW(it), buf, "elm");
 299      }
 300 }
 301
 302 static void
 303 _item_text_signals_emit(Elm_Naviframe_Item_Data *it)
 304 {
 305    Elm_Naviframe_Text_Item_Pair *text_pair;
 306    char buf[1024];
 307
 308    if ((it->title_label) && (it->title_label[0]))
 309      elm_object_signal_emit(VIEW(it), "elm,state,title_label,show", "elm");
 310    else
 311      elm_object_signal_emit(VIEW(it), "elm,state,title_label,hide", "elm");
 312
 313    if ((it->subtitle_label) && (it->subtitle_label[0]))
 314      elm_object_signal_emit(VIEW(it), "elm,state,subtitle,show", "elm");
 315    else
 316      elm_object_signal_emit(VIEW(it), "elm,state,subtitle,hide", "elm");
 317
 318    EINA_INLIST_FOREACH(it->text_list, text_pair)
 319      {
 320         if (elm_object_part_text_get(VIEW(it), text_pair->part))
 321           snprintf(buf, sizeof(buf), "elm,state,%s,show", text_pair->part);
 322         else
 323           snprintf(buf, sizeof(buf), "elm,state,%s,hide", text_pair->part);
 324         elm_object_signal_emit(VIEW(it), buf, "elm");
 325      }
 326 }
 327
 328 static Evas_Object *
 329 _access_object_get(Elm_Naviframe_Item_Data *it, const char* part)
 330 {
 331    Evas_Object *po, *ao;
 332
 333    po = (Evas_Object *)edje_object_part_object_get
 334           (elm_layout_edje_get(VIEW(it)), part);
 335    ao = evas_object_data_get(po, "_part_access_obj");
 336
 337    return ao;
 338 }
 339
 340 static Eina_Bool
 341 _access_info_has(Evas_Object *obj, int type)
 342 {
 343    Elm_Access_Info *ac;
 344    Elm_Access_Item *ai;
 345    Eina_List *l;
 346
 347    ac = _elm_access_info_get(obj);
 348    if (!ac) return EINA_FALSE;
 349
 350    EINA_LIST_FOREACH(ac->items, l, ai)
 351      {
 352         if (ai->type == type)
 353           {
 354              if (ai->func || ai->data) return EINA_TRUE;
 355           }
 356      }
 357
 358    return EINA_FALSE;
 359 }
 360
 361 static void
 362 _item_signals_emit(Elm_Naviframe_Item_Data *it)
 363 {
 364    _item_text_signals_emit(it);
 365    _item_content_signals_emit(it);
 366 }
 367
 368 //TIZEN ONLY(20151012): expose title as at-spi object
 369 static void
 370 _atspi_expose_title(Elm_Naviframe_Item_Data *it, Eina_Bool is_atspi)
 371 {
 372    Evas_Object *part = NULL;
 373    Evas_Object *access = NULL;
 374    part = (Evas_Object*)edje_object_part_object_get(elm_layout_edje_get(VIEW(it)),
 375                                                     TITLE_ACCESS_PART);
 376    if (!part) return;
 377    if (is_atspi)
 378      {
 379         access = elm_access_object_register(part, VIEW(it));
 380         _elm_access_callback_set(_elm_access_info_get(access),
 381                                  ELM_ACCESS_INFO, _access_info_cb, it);
 382         elm_atspi_accessible_role_set(access, ELM_ATSPI_ROLE_HEADING);
 383      }
 384    else
 385      elm_access_object_unregister(part);
 386 }
 387 //
 388
 389 /* FIXME: we need to handle the case when this function is called
 390  * during a transition */
 391 static void
 392 _item_style_set(Elm_Naviframe_Item_Data *it,
 393                 const char *item_style)
 394 {
 395    char buf[256];
 396
 397    ELM_NAVIFRAME_DATA_GET(WIDGET(it), sd);
 398
 399    if (!item_style)
 400      {
 401         strcpy(buf, "item/basic");
 402         eina_stringshare_replace(&it->style, "basic");
 403      }
 404    else
 405      {
 406         snprintf(buf, sizeof(buf), "item/%s", item_style);
 407         eina_stringshare_replace(&it->style, item_style);
 408      }
 409
 410    if (!elm_layout_theme_set(VIEW(it), "naviframe", buf,
 411                              elm_widget_style_get(WIDGET(it))))
 412      CRI("Failed to set layout!");
 413
 414    if (sd->freeze_events)
 415      evas_object_freeze_events_set(VIEW(it), EINA_FALSE);
 416
 417    //TIZEN ONLY(20151012): expose title as at-spi object
 418    if (elm_atspi_bridge_utils_is_screen_reader_enabled())
 419      _atspi_expose_title(it, EINA_TRUE);
 420    //
 421 }
 422
 423 static void
 424 _on_item_title_transition_finished(void *data,
 425                                    Evas_Object *obj EINA_UNUSED,
 426                                    const char *emission EINA_UNUSED,
 427                                    const char *source EINA_UNUSED)
 428 {
 429    Elm_Naviframe_Item_Data *it = data;
 430
 431    eo_do(WIDGET(it), eo_event_callback_call
 432          (ELM_NAVIFRAME_EVENT_TITLE_TRANSITION_FINISHED, EO_OBJ(it)));
 433 }
 434
 435 static void
 436 _item_title_enabled_update(Elm_Naviframe_Item_Data *nit, Eina_Bool transition)
 437 {
 438    transition = !!transition;
 439    if (transition)
 440      {
 441         if (nit->title_enabled)
 442           elm_object_signal_emit(VIEW(nit), "elm,action,title,show", "elm");
 443         else
 444           elm_object_signal_emit(VIEW(nit), "elm,action,title,hide", "elm");
 445      }
 446    else
 447      {
 448         if (nit->title_enabled)
 449           elm_object_signal_emit(VIEW(nit), "elm,state,title,show", "elm");
 450         else
 451           elm_object_signal_emit(VIEW(nit), "elm,state,title,hide", "elm");
 452      }
 453    edje_object_message_signal_process(elm_layout_edje_get(VIEW(nit)));
 454 }
 455
 456 EOLIAN static Elm_Theme_Apply
 457 _elm_naviframe_elm_widget_theme_apply(Eo *obj, Elm_Naviframe_Data *sd)
 458 {
 459    Elm_Naviframe_Item_Data *it;
 460    const char *style = NULL, *sstyle = NULL;
 461
 462    eo_do(obj, style = elm_obj_widget_style_get());
 463
 464    EINA_INLIST_FOREACH(sd->stack, it)
 465      {
 466         eo_do(VIEW(it), sstyle = elm_obj_widget_style_get());
 467         if ((style && sstyle) && strcmp(style, sstyle))
 468           _item_style_set(it, it->style);
 469         _item_signals_emit(it);
 470         _item_title_enabled_update(it, EINA_FALSE);
 471      }
 472
 473    elm_layout_sizing_eval(obj);
 474    return ELM_THEME_APPLY_SUCCESS;
 475 }
 476
 477 static char *
 478 _access_info_cb(void *data, Evas_Object *obj EINA_UNUSED)
 479 {
 480    Elm_Naviframe_Item_Data *nit;
 481    Evas_Object *layout;
 482    Eina_Strbuf *buf;
 483    const char *info;
 484    char *ret;
 485
 486    nit = data;
 487    if (!nit->title_enabled) return NULL;
 488
 489    layout = VIEW(nit);
 490    info = elm_object_part_text_get(layout, TITLE_PART);
 491    if (!info) return NULL;
 492
 493    buf = eina_strbuf_new();
 494    eina_strbuf_append(buf, info);
 495    //TIZEN ONLY(20160530): Read title after reading actual title
 496    eina_strbuf_append_printf(buf, ", %s", N_("Title"));
 497    //
 498
 499    info = elm_object_part_text_get(layout, SUBTITLE_PART);
 500    if (!info) goto end;
 501    //TIZEN ONLY(20160530): do not read subtitle even if text is empty
 502    if (!strcmp(info, "")) goto end;
 503    //
 504
 505    eina_strbuf_append_printf(buf, ", %s", info);
 506    //TIZEN ONLY(20160530): Read subtitle after reading actual subtitle
 507    eina_strbuf_append_printf(buf, ", %s", N_("Subtitle"));
 508    //
 509
 510 end:
 511    ret = eina_strbuf_string_steal(buf);
 512    eina_strbuf_free(buf);
 513    return ret;
 514 }
 515
 516 static void
 517 _access_obj_process(Elm_Naviframe_Item_Data *it, Eina_Bool is_access)
 518 {
 519    Evas_Object *ao, *eo;
 520
 521    if (is_access && (it->title_label || it->subtitle_label))
 522      {
 523         if (!_access_object_get(it, TITLE_ACCESS_PART))
 524           {
 525              eo = elm_layout_edje_get(VIEW(it));
 526              ao =_elm_access_edje_object_part_object_register(WIDGET(it), eo,
 527                                                             TITLE_ACCESS_PART);
 528             _elm_access_text_set(_elm_access_info_get(ao),
 529                                 ELM_ACCESS_TYPE, E_("Title"));
 530             _elm_access_callback_set(_elm_access_info_get(ao),
 531                                      ELM_ACCESS_INFO, _access_info_cb, it);
 532             /* to access title access object, any idea? */
 533             it->base->access_obj = ao;
 534          }
 535      }
 536    else
 537      {
 538         /* to access title access object, any idea? */
 539         ao = it->base->access_obj;
 540         if (!ao) return;
 541
 542         if (it->title_label || it->subtitle_label)
 543           _elm_access_edje_object_part_object_unregister
 544              (WIDGET(it), elm_layout_edje_get(VIEW(it)), TITLE_ACCESS_PART);
 545         evas_object_del(ao);
 546      }
 547 }
 548
 549 EOLIAN static void
 550 _elm_naviframe_item_elm_widget_item_part_text_set(Eo *eo_it EINA_UNUSED,
 551                                                   Elm_Naviframe_Item_Data *it,
 552                                                   const char *part,
 553                                                   const char *label)
 554 {
 555    Elm_Naviframe_Item_Data *nit = it;
 556    Elm_Naviframe_Text_Item_Pair *pair = NULL;
 557    char buf[1024];
 558
 559    if ((!part) || (!strcmp(part, "default")) ||
 560        (!strcmp(part, TITLE_PART)))
 561      {
 562         eina_stringshare_replace(&nit->title_label, label);
 563         if (label)
 564           elm_object_signal_emit(VIEW(it), "elm,state,title_label,show", "elm");
 565         else
 566           elm_object_signal_emit(VIEW(it), "elm,state,title_label,hide", "elm");
 567         elm_object_part_text_set(VIEW(it), TITLE_PART, label);
 568      }
 569    else if ((!strcmp(part, "subtitle")) || (!strcmp(part, SUBTITLE_PART)))
 570      {
 571         eina_stringshare_replace(&nit->subtitle_label, label);
 572         if (label)
 573           elm_object_signal_emit(VIEW(it), "elm,state,subtitle,show", "elm");
 574         else
 575           elm_object_signal_emit(VIEW(it), "elm,state,subtitle,hide", "elm");
 576         elm_object_part_text_set(VIEW(it), SUBTITLE_PART, label);
 577      }
 578    else
 579      {
 580         EINA_INLIST_FOREACH(nit->text_list, pair)
 581           if (!strcmp(part, pair->part)) break;
 582
 583         if (!pair)
 584           {
 585              pair = ELM_NEW(Elm_Naviframe_Text_Item_Pair);
 586              if (!pair)
 587                {
 588                   ERR("Failed to allocate new text part of the item! : naviframe=%p",
 589                   WIDGET(it));
 590                   return;
 591                }
 592              eina_stringshare_replace(&pair->part, part);
 593              nit->text_list = eina_inlist_append(nit->text_list,
 594                                                  EINA_INLIST_GET(pair));
 595           }
 596         if (label)
 597           snprintf(buf, sizeof(buf), "elm,state,%s,show", part);
 598         else
 599           snprintf(buf, sizeof(buf), "elm,state,%s,hide", part);
 600         elm_object_signal_emit(VIEW(it), buf, "elm");
 601         elm_object_part_text_set(VIEW(it), part, label);
 602      }
 603
 604    /* access */
 605    if (_elm_config->access_mode)
 606      _access_obj_process(nit, EINA_TRUE);
 607
 608    memset(buf, 0x0, sizeof(buf));
 609    if (nit->title_label)
 610      strncat(buf, nit->title_label, sizeof(buf) - 1);
 611    if (nit->subtitle_label)
 612      {
 613         if (nit->title_label) strncat(buf, " ", 1);
 614         strncat(buf, nit->subtitle_label, sizeof(buf) - strlen(buf) - 2);
 615      }
 616    char *plain_text = _elm_util_mkup_to_text(buf);
 617    eo_do(VIEW(it), elm_interface_atspi_accessible_name_set(plain_text));
 618    free(plain_text);
 619
 620    elm_layout_sizing_eval(WIDGET(nit));
 621 }
 622
 623 EOLIAN static const char *
 624 _elm_naviframe_item_elm_widget_item_part_text_get(Eo *nit EINA_UNUSED,
 625                                              Elm_Naviframe_Item_Data *it,
 626                                              const char *part)
 627 {
 628    char buf[1024];
 629
 630    if (!part || !strcmp(part, "default"))
 631      snprintf(buf, sizeof(buf), TITLE_PART);
 632    else if (!strcmp("subtitle", part))
 633      snprintf(buf, sizeof(buf), SUBTITLE_PART);
 634    else
 635      snprintf(buf, sizeof(buf), "%s", part);
 636
 637    return elm_object_part_text_get(VIEW(it), buf);
 638 }
 639
 640 EOLIAN static void
 641 _elm_naviframe_item_eo_base_destructor(Eo *eo_item, Elm_Naviframe_Item_Data *it)
 642 {
 643    Eina_List *l;
 644    Elm_Naviframe_Op *nfo;
 645    Elm_Naviframe_Item_Data *nit = it, *prev_it = NULL;
 646    Eina_Bool top;
 647
 648    ELM_NAVIFRAME_DATA_GET(WIDGET(nit), sd);
 649
 650    nit->delete_me = EINA_TRUE;
 651
 652    top = (eo_item == elm_naviframe_top_item_get(WIDGET(nit)));
 653    if (evas_object_data_get(VIEW(nit), "out_of_list"))
 654      goto end;
 655
 656    sd->stack = eina_inlist_remove(sd->stack, EINA_INLIST_GET(nit));
 657
 658    if (top && !sd->on_deletion) /* must raise another one */
 659      {
 660         if (sd->stack && sd->stack->last)
 661           prev_it = EINA_INLIST_CONTAINER_GET(sd->stack->last,
 662                                               Elm_Naviframe_Item_Data);
 663         if (!prev_it)
 664           {
 665              elm_widget_tree_unfocusable_set(VIEW(nit), EINA_TRUE);
 666              goto end;
 667           }
 668
 669         elm_widget_tree_unfocusable_set(VIEW(prev_it), EINA_FALSE);
 670         elm_widget_tree_unfocusable_set(VIEW(nit), EINA_TRUE);
 671
 672         if (sd->freeze_events)
 673           evas_object_freeze_events_set(VIEW(prev_it), EINA_FALSE);
 674         _resize_object_reset(WIDGET(prev_it), prev_it);
 675         evas_object_show(VIEW(prev_it));
 676
 677         _prev_page_focus_recover(prev_it);
 678
 679         //TIZEN ONLY(20161208): Support tizen transition
 680         //elm_object_signal_emit(VIEW(prev_it), "elm,state,visible", "elm");
 681         if (_tizen_effect_enabled_get(nit))
 682           nf_mod->tizen_effect_cancel(VIEW(nit));
 683
 684         if (_tizen_effect_enabled_get(prev_it))
 685           nf_mod->tizen_effect_cancel(VIEW(prev_it));
 686         else
 687           elm_object_signal_emit(VIEW(prev_it), "elm,state,visible", "elm");
 688         //
 689
 690         //TIZEN_ONLY(20171019): add state_notify api
 691         if (_elm_atspi_enabled())
 692            eo_do(VIEW(prev_it), elm_interface_atspi_accessible_state_notify(
 693                  ATSPI_STATE(ELM_ATSPI_STATE_SHOWING) | ATSPI_STATE(ELM_ATSPI_STATE_VISIBLE), EINA_TRUE));
 694         //
 695
 696         eo_do(WIDGET(prev_it), eo_event_callback_call(ELM_NAVIFRAME_EVENT_ITEM_ACTIVATED, EO_OBJ(prev_it)));
 697      }
 698
 699 end:
 700    // This should not happen, but just in case and by security
 701    // make sure there is no more reference to this item.
 702    EINA_LIST_FOREACH(sd->ops, l, nfo)
 703      {
 704         /* If an item is newly pushed and then deleted by elm_object_item_del()
 705          * before item push transition is not started, then the item push
 706          * transitions for both new item and current item should be cancelled.
 707          * Otherwise, the current item becomes invisible due to the item push
 708          * transition. */
 709         if ((nit->pushing) && (nfo->self == nit))
 710           {
 711              nfo->self = NULL;
 712              nfo->related = NULL;
 713           }
 714         else
 715           {
 716              if (nfo->self == nit)
 717                nfo->self = NULL;
 718              if (nfo->related == nit)
 719                nfo->related = NULL;
 720           }
 721      }
 722
 723    _item_free(nit);
 724
 725    eo_do_super(eo_item, ELM_NAVIFRAME_ITEM_CLASS, eo_destructor());
 726 }
 727
 728 static void
 729 _item_content_set(Elm_Naviframe_Item_Data *it,
 730                   Evas_Object *content)
 731 {
 732    if (it->content == content) return;
 733
 734    evas_object_del(it->content);
 735    it->content = content;
 736
 737    if (!content) return;
 738
 739    elm_object_part_content_set(VIEW(it), CONTENT_PART, content);
 740    elm_object_signal_emit(VIEW(it), "elm,state,content,show", "elm");
 741
 742    evas_object_event_callback_add
 743      (content, EVAS_CALLBACK_DEL, _item_content_del_cb, it);
 744 }
 745
 746 static void
 747 _item_title_prev_btn_set(Elm_Naviframe_Item_Data *it,
 748                          Evas_Object *btn)
 749 {
 750    if (it->title_prev_btn == btn) return;
 751    evas_object_del(it->title_prev_btn);
 752    it->title_prev_btn = btn;
 753    if (it->auto_pushed_btn && (it->auto_pushed_btn != btn))
 754      it->auto_pushed_btn = NULL;
 755    if (!btn) return;
 756
 757    elm_object_part_content_set(VIEW(it), PREV_BTN_PART, btn);
 758    elm_object_signal_emit(VIEW(it), "elm,state,prev_btn,show", "elm");
 759    evas_object_event_callback_add
 760      (btn, EVAS_CALLBACK_DEL, _item_title_prev_btn_del_cb, it);
 761
 762    //TIZEN ONLY(20161207): add reading text of back button
 763    if (!elm_layout_text_get(btn, NULL))
 764      {
 765         if(_elm_config->atspi_mode)
 766           eo_do(btn, elm_interface_atspi_accessible_name_set(N_("Navigate back")));
 767      }
 768    //
 769
 770    //FIXME: set back button callback here after elm 2.0
 771 }
 772
 773 static void
 774 _item_title_next_btn_set(Elm_Naviframe_Item_Data *it,
 775                          Evas_Object *btn)
 776 {
 777    if (it->title_next_btn == btn) return;
 778    evas_object_del(it->title_next_btn);
 779    it->title_next_btn = btn;
 780    if (!btn) return;
 781
 782    elm_object_part_content_set(VIEW(it), NEXT_BTN_PART, btn);
 783    elm_object_signal_emit(VIEW(it), "elm,state,next_btn,show", "elm");
 784
 785    evas_object_event_callback_add
 786      (btn, EVAS_CALLBACK_DEL, _item_title_next_btn_del_cb, it);
 787 }
 788
 789 static void
 790 _item_title_icon_set(Elm_Naviframe_Item_Data *it,
 791                      Evas_Object *icon)
 792 {
 793    if (it->title_icon == icon) return;
 794    evas_object_del(it->title_icon);
 795    it->title_icon = icon;
 796    if (!icon) return;
 797
 798    elm_object_part_content_set(VIEW(it), ICON_PART, icon);
 799    elm_object_signal_emit(VIEW(it), "elm,state,icon,show", "elm");
 800
 801    evas_object_event_callback_add
 802      (icon, EVAS_CALLBACK_DEL, _item_title_icon_del_cb, it);
 803 }
 804
 805 static Evas_Object *
 806 _item_content_unset(Elm_Naviframe_Item_Data *it)
 807 {
 808    Evas_Object *content = it->content;
 809
 810    if (!content) return NULL;
 811
 812    elm_object_part_content_unset(VIEW(it), CONTENT_PART);
 813    elm_object_signal_emit(VIEW(it), "elm,state,content,hide", "elm");
 814
 815    evas_object_event_callback_del
 816      (content, EVAS_CALLBACK_DEL, _item_content_del_cb);
 817
 818    it->content = NULL;
 819    return content;
 820 }
 821
 822 static Evas_Object *
 823 _item_title_prev_btn_unset(Elm_Naviframe_Item_Data *it)
 824 {
 825    Evas_Object *content = it->title_prev_btn;
 826
 827    if (!content) return NULL;
 828
 829    elm_object_part_content_unset(VIEW(it), PREV_BTN_PART);
 830    elm_object_signal_emit(VIEW(it), "elm,state,prev_btn,hide", "elm");
 831
 832    evas_object_event_callback_del
 833      (content, EVAS_CALLBACK_DEL, _item_title_prev_btn_del_cb);
 834    Eo* parent = eo_do_ret(content, parent, eo_parent_get());
 835    eo_do(content, eo_event_callback_del(
 836             EVAS_CLICKABLE_INTERFACE_EVENT_CLICKED, _on_item_back_btn_clicked,
 837             parent));
 838    it->title_prev_btn = NULL;
 839    if (it->auto_pushed_btn) it->auto_pushed_btn = NULL;
 840    return content;
 841 }
 842
 843 static Evas_Object *
 844 _item_title_next_btn_unset(Elm_Naviframe_Item_Data *it)
 845 {
 846    Evas_Object *content = it->title_next_btn;
 847
 848    if (!content) return NULL;
 849
 850    elm_object_part_content_unset(VIEW(it), NEXT_BTN_PART);
 851    elm_object_signal_emit(VIEW(it), "elm,state,next_btn,hide", "elm");
 852
 853    evas_object_event_callback_del
 854      (content, EVAS_CALLBACK_DEL, _item_title_next_btn_del_cb);
 855
 856    it->title_next_btn = NULL;
 857    return content;
 858 }
 859
 860 static Evas_Object *
 861 _item_title_icon_unset(Elm_Naviframe_Item_Data *it)
 862 {
 863    Evas_Object *content = it->title_icon;
 864
 865    if (!content) return NULL;
 866
 867    elm_object_part_content_unset(VIEW(it), ICON_PART);
 868    elm_object_signal_emit(VIEW(it), "elm,state,icon,hide", "elm");
 869
 870    evas_object_event_callback_del
 871      (content, EVAS_CALLBACK_DEL, _item_title_icon_del_cb);
 872
 873    it->title_icon = NULL;
 874    return content;
 875 }
 876
 877 /* since we have each item as layout, we can't reusing the layout's
 878  * aliasing, so let's do it ourselves */
 879 static void
 880 _part_aliasing_eval(const char **part)
 881 {
 882    if (!*part || !strcmp(*part, "default"))
 883      *part = CONTENT_PART;
 884    else if (!strcmp(*part, "prev_btn"))
 885      *part = PREV_BTN_PART;
 886    else if (!strcmp(*part, "next_btn"))
 887      *part = NEXT_BTN_PART;
 888    else if (!strcmp(*part, "icon"))
 889      *part = ICON_PART;
 890 }
 891
 892 static void
 893 _title_content_set(Elm_Naviframe_Item_Data *it,
 894                    const char *part,
 895                    Evas_Object *content)
 896 {
 897    Elm_Naviframe_Content_Item_Pair *pair = NULL;
 898    char buf[1024];
 899
 900    EINA_INLIST_FOREACH(it->content_list, pair)
 901      if (!strcmp(part, pair->part)) break;
 902    if (pair)
 903      {
 904         if (pair->content == content) return;
 905         if (pair->content)
 906           evas_object_event_callback_del(pair->content,
 907                                          EVAS_CALLBACK_DEL,
 908                                          _title_content_del);
 909         if (content) elm_object_part_content_set(VIEW(it), part, content);
 910      }
 911    else
 912      {
 913         if (!content) return;
 914
 915         //Remove the pair if new content was swallowed into other part.
 916         EINA_INLIST_FOREACH(it->content_list, pair)
 917           {
 918              if (pair->content == content)
 919                {
 920                   eina_stringshare_del(pair->part);
 921                   it->content_list = eina_inlist_remove(it->content_list,
 922                                                         EINA_INLIST_GET(pair));
 923                   evas_object_event_callback_del(pair->content,
 924                                                  EVAS_CALLBACK_DEL,
 925                                                  _title_content_del);
 926                   free(pair);
 927                   break;
 928                }
 929           }
 930
 931         //New pair
 932         pair = ELM_NEW(Elm_Naviframe_Content_Item_Pair);
 933         if (!pair)
 934           {
 935              ERR("Failed to allocate new content part of the item! : naviframe=%p",
 936              WIDGET(it));
 937              return;
 938           }
 939         pair->it = it;
 940         eina_stringshare_replace(&pair->part, part);
 941         it->content_list = eina_inlist_append(it->content_list,
 942                                               EINA_INLIST_GET(pair));
 943         elm_object_part_content_set(VIEW(it), part, content);
 944         snprintf(buf, sizeof(buf), "elm,state,%s,show", part);
 945         elm_object_signal_emit(VIEW(it), buf, "elm");
 946      }
 947    pair->content = content;
 948    evas_object_event_callback_add(content,
 949                                   EVAS_CALLBACK_DEL,
 950                                   _title_content_del,
 951                                   pair);
 952 }
 953
 954 EOLIAN static void
 955 _elm_naviframe_item_elm_widget_item_part_content_set(Eo *eo_nit EINA_UNUSED,
 956                                                      Elm_Naviframe_Item_Data *nit,
 957                                                      const char *part,
 958                                                      Evas_Object *content)
 959 {
 960    _part_aliasing_eval(&part);
 961
 962    //specified parts
 963    if (!strcmp(part, CONTENT_PART))
 964      _item_content_set(nit, content);
 965    else if (!strcmp(part, PREV_BTN_PART))
 966      _item_title_prev_btn_set(nit, content);
 967    else if (!strcmp(part, NEXT_BTN_PART))
 968      _item_title_next_btn_set(nit, content);
 969    else if (!strcmp(part, ICON_PART))
 970      _item_title_icon_set(nit, content);
 971    else
 972      _title_content_set(nit, part, content);
 973
 974    elm_layout_sizing_eval(WIDGET(nit));
 975 }
 976
 977 EOLIAN static Evas_Object *
 978 _elm_naviframe_item_elm_widget_item_part_content_get(Eo *eo_nit EINA_UNUSED,
 979                                                      Elm_Naviframe_Item_Data *nit,
 980                                                      const char *part)
 981 {
 982    _part_aliasing_eval(&part);
 983
 984    //specified parts
 985    if (!strcmp(part, CONTENT_PART))
 986      return nit->content;
 987    else if (!strcmp(part, PREV_BTN_PART))
 988      return nit->title_prev_btn;
 989    else if (!strcmp(part, NEXT_BTN_PART))
 990      return nit->title_next_btn;
 991    else if (!strcmp(part, ICON_PART))
 992      return nit->title_icon;
 993
 994    //common parts
 995    return elm_object_part_content_get(VIEW(nit), part);
 996 }
 997
 998 static Evas_Object *
 999 _title_content_unset(Elm_Naviframe_Item_Data *it, const char *part)
1000 {
1001    Elm_Naviframe_Content_Item_Pair *pair = NULL;
1002    char buf[1028];
1003    Evas_Object *content = NULL;
1004
1005    EINA_INLIST_FOREACH(it->content_list, pair)
1006      {
1007         if (!strcmp(part, pair->part))
1008           {
1009              content = pair->content;
1010              eina_stringshare_del(pair->part);
1011              it->content_list = eina_inlist_remove(it->content_list,
1012                                                    EINA_INLIST_GET(pair));
1013              free(pair);
1014              break;
1015           }
1016      }
1017
1018    if (!content) return NULL;
1019
1020    elm_object_part_content_unset(VIEW(it), part);
1021    snprintf(buf, sizeof(buf), "elm,state,%s,hide", part);
1022    elm_object_signal_emit(VIEW(it), buf, "elm");
1023    evas_object_event_callback_del(content,
1024                                   EVAS_CALLBACK_DEL,
1025                                   _title_content_del);
1026    return content;
1027 }
1028
1029 EOLIAN static Evas_Object *
1030 _elm_naviframe_item_elm_widget_item_part_content_unset(Eo *eo_nit EINA_UNUSED,
1031                                                   Elm_Naviframe_Item_Data *nit,
1032                                                   const char *part)
1033 {
1034    Evas_Object *o = NULL;
1035
1036    _part_aliasing_eval(&part);
1037
1038    //specified parts
1039    if (!strcmp(part, CONTENT_PART))
1040      o = _item_content_unset(nit);
1041    else if (!strcmp(part, PREV_BTN_PART))
1042      o = _item_title_prev_btn_unset(nit);
1043    else if (!strcmp(part, NEXT_BTN_PART))
1044      o = _item_title_next_btn_unset(nit);
1045    else if (!strcmp(part, ICON_PART))
1046      o = _item_title_icon_unset(nit);
1047    else
1048      o = _title_content_unset(nit, part);
1049
1050    elm_layout_sizing_eval(WIDGET(nit));
1051
1052    return o;
1053 }
1054
1055 EOLIAN static void
1056 _elm_naviframe_item_elm_widget_item_signal_emit(Eo *eo_it EINA_UNUSED,
1057                                                 Elm_Naviframe_Item_Data *it,
1058                                                 const char *emission,
1059                                                 const char *source)
1060 {
1061    elm_object_signal_emit(VIEW(it), emission, source);
1062 }
1063
1064 EOLIAN static void
1065 _elm_naviframe_elm_layout_sizing_eval(Eo *obj, Elm_Naviframe_Data *sd)
1066 {
1067    Evas_Coord minw = -1, minh = -1;
1068    Elm_Naviframe_Item_Data *it, *top;
1069    Evas_Coord x, y, w, h;
1070
1071    if (sd->on_deletion) return;
1072    if (!sd->stack) return;
1073
1074    top = (EINA_INLIST_CONTAINER_GET(sd->stack->last, Elm_Naviframe_Item_Data));
1075    evas_object_geometry_get(obj, &x, &y, &w, &h);
1076    EINA_INLIST_FOREACH(sd->stack, it)
1077      {
1078         evas_object_move(VIEW(it), x, y);
1079         evas_object_resize(VIEW(it), w, h);
1080
1081         if (it == top)
1082           {
1083              edje_object_size_min_calc(elm_layout_edje_get(VIEW(it)),
1084                                        &it->minw, &it->minh);
1085              minw = it->minw;
1086              minh = it->minh;
1087           }
1088      }
1089
1090    evas_object_size_hint_min_set(obj, minw, minh);
1091    evas_object_size_hint_max_set(obj, -1, -1);
1092 }
1093
1094 static Eina_Bool
1095 _on_item_back_btn_clicked(void *data,
1096       Eo *obj EINA_UNUSED, const Eo_Event_Description *desc EINA_UNUSED, void *event_info EINA_UNUSED)
1097 {
1098    /* Since edje has the event queue, clicked event could be happened
1099       multiple times on some heavy environment. This callback del will
1100       prevent those scenario and guarantee only one clicked for it's own
1101       page. */
1102    eo_do(obj, eo_event_callback_del(
1103             EVAS_CLICKABLE_INTERFACE_EVENT_CLICKED,  _on_item_back_btn_clicked,
1104             data));
1105    elm_naviframe_item_pop(data);
1106
1107    return EINA_TRUE;
1108 }
1109
1110 static Evas_Object *
1111 _back_btn_new(Evas_Object *obj, const char *title_label)
1112 {
1113    Evas_Object *btn, *ed;
1114    char buf[1024];
1115
1116    btn = elm_button_add(obj);
1117
1118    if (!btn) return NULL;
1119    eo_do(btn, eo_event_callback_add
1120          (EVAS_CLICKABLE_INTERFACE_EVENT_CLICKED, _on_item_back_btn_clicked, obj));
1121    snprintf
1122      (buf, sizeof(buf), "naviframe/back_btn/%s", elm_widget_style_get(obj));
1123    elm_object_style_set(btn, buf);
1124    if (title_label)
1125      elm_layout_text_set(btn, NULL, title_label);
1126    else
1127      elm_object_domain_translatable_text_set(btn, PACKAGE, N_("Back"));
1128
1129    /* HACK NOTE: this explicit check only exists to avoid an ERR()
1130     * message from elm_layout_content_set().
1131     *
1132     * The button was ALWAYS supposed to support an elm.swallow.content, but
1133     * default naviframe/back_btn/default theme did not provide such, then
1134     * old themes would emit such error message.
1135     *
1136     * Once we can break the theme API, remove this check and always
1137     * set an icon.
1138     */
1139    ed = elm_layout_edje_get(btn);
1140    if (edje_object_part_exists(ed, CONTENT_PART))
1141      {
1142         Evas_Object *ico = elm_icon_add(btn);
1143         elm_icon_standard_set(ico, "arrow_left");
1144         elm_layout_content_set(btn, CONTENT_PART, ico);
1145      }
1146
1147    if(_elm_config->atspi_mode)
1148      eo_do(btn, elm_interface_atspi_accessible_name_set(N_("Navigate back")));
1149
1150    return btn;
1151 }
1152
1153 EOLIAN static void
1154 _elm_naviframe_elm_layout_signal_emit(Eo *obj, Elm_Naviframe_Data *sd EINA_UNUSED, const char *emission, const char *source)
1155 {
1156    Elm_Object_Item *eo_top_it;
1157
1158    eo_top_it = elm_naviframe_top_item_get(obj);
1159    if (!eo_top_it) return;
1160    ELM_NAVIFRAME_ITEM_DATA_GET(eo_top_it, top_it);
1161
1162    eo_do(VIEW(top_it), elm_obj_layout_signal_emit(emission, source));
1163 }
1164
1165 /* content/text smart functions proxying things to the top item, which
1166  * is the resize object of the layout */
1167 EOLIAN static Eina_Bool
1168 _elm_naviframe_elm_layout_text_set(Eo *obj, Elm_Naviframe_Data *sd EINA_UNUSED, const char *part, const char *label)
1169 {
1170    Elm_Object_Item *it;
1171    const char *text = NULL;
1172
1173    it = elm_naviframe_top_item_get(obj);
1174    if (!it) return EINA_FALSE;
1175
1176    elm_object_item_part_text_set(it, part, label);
1177    text = elm_object_item_part_text_get(it, part);
1178    if ((text) && !strcmp(text, label))
1179      return EINA_TRUE;
1180    return EINA_FALSE;
1181 }
1182
1183 EOLIAN static const char*
1184 _elm_naviframe_elm_layout_text_get(const Eo *obj, Elm_Naviframe_Data *sd EINA_UNUSED, const char *part)
1185 {
1186    Elm_Object_Item *it = elm_naviframe_top_item_get(obj);
1187    if (!it) return NULL;
1188
1189    return elm_object_item_part_text_get(it, part);
1190 }
1191
1192 /* we have to keep a "manual" set here because of the callbacks on the
1193  * children */
1194 EOLIAN static Eina_Bool
1195 _elm_naviframe_elm_container_content_set(Eo *obj, Elm_Naviframe_Data *sd EINA_UNUSED, const char *part, Evas_Object *content)
1196 {
1197    Elm_Object_Item *it;
1198
1199    it = elm_naviframe_top_item_get(obj);
1200    if (!it) return EINA_FALSE;
1201
1202    elm_object_item_part_content_set(it, part, content);
1203
1204    if (content == elm_object_item_part_content_get(it, part))
1205      return EINA_TRUE;
1206
1207    return EINA_FALSE;
1208 }
1209
1210 EOLIAN static Evas_Object*
1211 _elm_naviframe_elm_container_content_get(Eo *obj, Elm_Naviframe_Data *sd EINA_UNUSED, const char *part)
1212 {
1213    Elm_Object_Item *it = elm_naviframe_top_item_get(obj);
1214
1215    if (!it) return NULL;
1216
1217    return elm_object_item_part_content_get(it, part);
1218 }
1219
1220 EOLIAN static Evas_Object*
1221 _elm_naviframe_elm_container_content_unset(Eo *obj, Elm_Naviframe_Data *sd EINA_UNUSED, const char *part)
1222 {
1223    Elm_Object_Item *it = elm_naviframe_top_item_get(obj);
1224
1225    if (!it) return NULL;
1226
1227    return elm_object_item_part_content_unset(it, part);
1228 }
1229
1230 static void
1231 _on_item_title_clicked(void *data,
1232                        Evas_Object *obj EINA_UNUSED,
1233                        const char *emission EINA_UNUSED,
1234                        const char *source EINA_UNUSED)
1235 {
1236    Elm_Naviframe_Item_Data *it = data;
1237
1238    eo_do(WIDGET(it), eo_event_callback_call(ELM_NAVIFRAME_EVENT_TITLE_CLICKED,  EO_OBJ(it)));
1239 }
1240
1241 /* "elm,state,cur,pushed"
1242  */
1243 static void
1244 _on_item_push_finished(void *data,
1245                        Evas_Object *obj EINA_UNUSED,
1246                        const char *emission EINA_UNUSED,
1247                        const char *source EINA_UNUSED)
1248 {
1249    Elm_Naviframe_Item_Data *it = data;
1250
1251    if (!it) return;
1252
1253    ELM_NAVIFRAME_DATA_GET(WIDGET(it), sd);
1254
1255    evas_object_hide(VIEW(it));
1256    //TIZEN_ONLY(20161122): add state_notify api
1257    if (_elm_atspi_enabled())
1258       eo_do(VIEW(it), elm_interface_atspi_accessible_state_notify(
1259             ATSPI_STATE(ELM_ATSPI_STATE_SHOWING) | ATSPI_STATE(ELM_ATSPI_STATE_VISIBLE), EINA_TRUE));
1260    //
1261
1262    //TIZEN ONLY(20161208): Support tizen transition
1263    //elm_object_signal_emit(VIEW(it), "elm,state,invisible", "elm");
1264    if (!_tizen_effect_enabled_get(it))
1265      elm_object_signal_emit(VIEW(it), "elm,state,invisible", "elm");
1266    //
1267
1268    if (sd->freeze_events)
1269      evas_object_freeze_events_set(VIEW(it), EINA_FALSE);
1270 }
1271
1272 /* "elm,state,cur,popped"
1273  */
1274 static void
1275 _on_item_pop_finished(void *data,
1276                       Evas_Object *obj EINA_UNUSED,
1277                       const char *emission EINA_UNUSED,
1278                       const char *source EINA_UNUSED)
1279 {
1280    Elm_Naviframe_Item_Data *it = data;
1281    Elm_Naviframe_Item_Data *prev_it = NULL;
1282    Eo *widget = WIDGET(it);
1283
1284    ELM_NAVIFRAME_DATA_GET(widget, sd);
1285
1286    if (sd->stack && sd->stack->last)
1287      {
1288         prev_it = EINA_INLIST_CONTAINER_GET
1289            (sd->stack->last, Elm_Naviframe_Item_Data);
1290         /* TIZEN_ONLY(20161229): resize prev item before raise.
1291         _resize_object_reset(WIDGET(it), prev_it);
1292          */
1293         evas_object_raise(VIEW(prev_it));
1294         /*   END   */
1295      }
1296
1297    if (sd->preserve)
1298      elm_widget_tree_unfocusable_set(VIEW(it), EINA_FALSE);
1299    sd->popping = eina_list_remove(sd->popping, it);
1300
1301    eo_do(EO_OBJ(it), elm_wdg_item_del());
1302 }
1303
1304 /* "elm,state,new,pushed",
1305  * "elm,state,prev,popped
1306  */
1307 static void
1308 _on_item_show_finished(void *data,
1309                        Evas_Object *obj EINA_UNUSED,
1310                        const char *emission EINA_UNUSED,
1311                        const char *source EINA_UNUSED)
1312 {
1313    Elm_Naviframe_Item_Data *it = data;
1314
1315    ELM_NAVIFRAME_DATA_GET(WIDGET(it), sd);
1316
1317    //TIZEN ONLY(20161208): Support tizen transition
1318    //elm_object_signal_emit(VIEW(it), "elm,state,visible", "elm");
1319    if (!_tizen_effect_enabled_get(it))
1320      elm_object_signal_emit(VIEW(it), "elm,state,visible", "elm");
1321    //
1322
1323    /* TIZEN_ONLY(20170811): Set focus to new item view immediately when new item is pushed to show keypad fast. */
1324    //elm_widget_tree_unfocusable_set(VIEW(it), EINA_FALSE);
1325    if (!it->pushing)
1326      elm_widget_tree_unfocusable_set(VIEW(it), EINA_FALSE);
1327    /* END */
1328    _prev_page_focus_recover(it);
1329
1330    if (sd->freeze_events)
1331      evas_object_freeze_events_set(VIEW(it), EINA_FALSE);
1332
1333    it->pushing = EINA_FALSE;
1334    //TIZEN_ONLY(20161122): add state_notify api
1335    if (EO_OBJ(it) == elm_naviframe_top_item_get(WIDGET(it)))
1336      {
1337         _elm_win_default_label_obj_append(VIEW(it));
1338
1339         if (_elm_atspi_enabled())
1340           {
1341              eo_do(VIEW(it), elm_interface_atspi_accessible_state_notify(
1342                    ATSPI_STATE(ELM_ATSPI_STATE_SHOWING) | ATSPI_STATE(ELM_ATSPI_STATE_VISIBLE), EINA_TRUE));
1343           }
1344      }
1345    //
1346
1347    eo_do(WIDGET(it), eo_event_callback_call(ELM_NAVIFRAME_EVENT_TRANSITION_FINISHED, EO_OBJ(it)));
1348
1349    if (EO_OBJ(it) == elm_naviframe_top_item_get(WIDGET(it)))
1350      eo_do(WIDGET(it), eo_event_callback_call(ELM_NAVIFRAME_EVENT_ITEM_ACTIVATED, EO_OBJ(it)));
1351 }
1352
1353 static void
1354 _on_item_size_hints_changed(void *data,
1355                             Evas *e EINA_UNUSED,
1356                             Evas_Object *obj EINA_UNUSED,
1357                             void *event_info EINA_UNUSED)
1358 {
1359    elm_layout_sizing_eval(data);
1360 }
1361
1362 static void
1363 _item_dispmode_set(Elm_Naviframe_Item_Data *it, Evas_Display_Mode dispmode)
1364 {
1365    if (it->dispmode == dispmode) return;
1366    switch (dispmode)
1367      {
1368       case EVAS_DISPLAY_MODE_COMPRESS:
1369          elm_object_signal_emit(VIEW(it), "elm,state,display,compress", "elm");
1370          break;
1371       default:
1372          elm_object_signal_emit(VIEW(it), "elm,state,display,default", "elm");
1373          break;
1374      }
1375    it->dispmode = dispmode;
1376 }
1377
1378 static char *
1379 _access_prev_btn_info_cb(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED)
1380 {
1381    return strdup(E_("Back"));
1382 }
1383
1384 EOLIAN static Eo *
1385 _elm_naviframe_item_eo_base_constructor(Eo *eo_item, Elm_Naviframe_Item_Data *it)
1386 {
1387    eo_item = eo_do_super_ret(eo_item, ELM_NAVIFRAME_ITEM_CLASS, eo_item, eo_constructor());
1388    it->base = eo_data_scope_get(eo_item, ELM_WIDGET_ITEM_CLASS);
1389
1390    return eo_item;
1391 }
1392
1393 static Elm_Object_Item *
1394 _item_new(Evas_Object *obj,
1395           const Elm_Object_Item *eo_prev_it,
1396           const char *title_label,
1397           Evas_Object *prev_btn,
1398           Evas_Object *next_btn,
1399           Evas_Object *content,
1400           const char *item_style)
1401 {
1402    Eo *eo_item;
1403
1404    ELM_NAVIFRAME_DATA_GET(obj, sd);
1405
1406    eo_item = eo_add(ELM_NAVIFRAME_ITEM_CLASS, obj);
1407
1408    if (!eo_item)
1409      {
1410         ERR("Failed to allocate new item! : naviframe=%p", obj);
1411         return NULL;
1412      }
1413
1414    ELM_NAVIFRAME_ITEM_DATA_GET(eo_item, it);
1415
1416    //item base layout
1417    VIEW(it) = elm_layout_add(obj);
1418    eo_do(VIEW(it), elm_interface_atspi_accessible_role_set(ELM_ATSPI_ROLE_PAGE_TAB));
1419    char *plain_text = _elm_util_mkup_to_text((char*)title_label);
1420    eo_do(VIEW(it), elm_interface_atspi_accessible_name_set(plain_text));
1421    free(plain_text);
1422
1423    evas_object_smart_member_add(VIEW(it), obj);
1424
1425    if (!elm_widget_sub_object_add(obj, VIEW(it)))
1426      ERR("could not add %p as sub object of %p", VIEW(it), obj);
1427
1428    evas_object_event_callback_add
1429      (VIEW(it), EVAS_CALLBACK_CHANGED_SIZE_HINTS,
1430      _on_item_size_hints_changed, obj);
1431
1432    elm_object_signal_callback_add
1433      (VIEW(it), "elm,action,show,finished", "*", _on_item_show_finished, it);
1434    elm_object_signal_callback_add
1435      (VIEW(it), "elm,action,pushed,finished", "*", _on_item_push_finished, it);
1436    elm_object_signal_callback_add
1437      (VIEW(it), "elm,action,popped,finished", "*", _on_item_pop_finished, it);
1438    elm_object_signal_callback_add
1439      (VIEW(it), "elm,action,title,transition,finished", "*", _on_item_title_transition_finished, it);
1440    elm_object_signal_callback_add
1441      (VIEW(it), "elm,action,title,clicked", "*", _on_item_title_clicked, it);
1442
1443    _item_style_set(it, item_style);
1444
1445    if (title_label)
1446      eo_do(eo_item, elm_wdg_item_part_text_set(TITLE_PART, title_label));
1447
1448    //title buttons
1449    if ((!prev_btn) && sd->auto_pushed && eo_prev_it)
1450      {
1451         ELM_NAVIFRAME_ITEM_DATA_GET(eo_prev_it, prev_it);
1452         const char *prev_title = prev_it->title_label;
1453         prev_btn = _back_btn_new(obj, prev_title);
1454         it->auto_pushed_btn = prev_btn;
1455         /* TIZEN_ONLY(20161031): apply color_class parent-child relationship to all widgets */
1456         _elm_widget_color_class_parent_set(it->auto_pushed_btn, VIEW(it));
1457         /* END */
1458      }
1459
1460    if (prev_btn)
1461      {
1462         eo_do(eo_item, elm_wdg_item_part_content_set(PREV_BTN_PART, prev_btn));
1463         if (!elm_layout_text_get(prev_btn, NULL))
1464           {
1465              if (!_access_info_has(prev_btn, ELM_ACCESS_INFO))
1466                {
1467                   /* set access info */
1468                   _elm_access_callback_set
1469                      (_elm_access_info_get(prev_btn), ELM_ACCESS_INFO,
1470                       _access_prev_btn_info_cb, it);
1471                }
1472           }
1473         //TIZEN ONLY(20161207): add reading text of back button
1474         if(_elm_config->atspi_mode)
1475           eo_do(prev_btn, elm_interface_atspi_accessible_name_set(N_("Navigate back")));
1476         //
1477      }
1478
1479    if (next_btn)
1480      {
1481         eo_do(eo_item, elm_wdg_item_part_content_set(NEXT_BTN_PART, next_btn));
1482
1483         if (!elm_layout_text_get(next_btn, NULL))
1484           {
1485              if (!_access_info_has(next_btn, ELM_ACCESS_INFO))
1486                {
1487                   /* set access info */
1488                   _elm_access_text_set
1489                      (_elm_access_info_get(next_btn), ELM_ACCESS_INFO, E_("Next"));
1490                }
1491           }
1492      }
1493
1494    _item_content_set(it, content);
1495    _item_dispmode_set(it, sd->dispmode);
1496
1497    it->title_enabled = EINA_TRUE;
1498
1499    return EO_OBJ(it);
1500 }
1501
1502 static void
1503 _on_obj_size_hints_changed(void *data EINA_UNUSED, Evas *e EINA_UNUSED,
1504                            Evas_Object *obj, void *event_info EINA_UNUSED)
1505 {
1506    Elm_Naviframe_Item_Data *it;
1507    Evas_Display_Mode dispmode;
1508
1509    ELM_NAVIFRAME_DATA_GET(obj, sd);
1510
1511    dispmode = evas_object_size_hint_display_mode_get(obj);
1512    if (sd->dispmode == dispmode) return;
1513
1514    sd->dispmode = dispmode;
1515
1516    EINA_INLIST_FOREACH(sd->stack, it)
1517      _item_dispmode_set(it, dispmode);
1518 }
1519
1520 EOLIAN static Eina_Bool
1521 _elm_naviframe_elm_widget_focus_next(Eo *obj, Elm_Naviframe_Data *sd EINA_UNUSED, Elm_Focus_Direction dir, Evas_Object **next, Elm_Object_Item **next_item)
1522 {
1523    Evas_Object *ao;
1524
1525    Eina_List *l = NULL;
1526    Elm_Object_Item *eo_top_it;
1527    void *(*list_data_get)(const Eina_List *list);
1528
1529    Eina_Bool int_ret = EINA_FALSE;
1530
1531    eo_top_it = elm_naviframe_top_item_get(obj);
1532    if (!eo_top_it) goto end;
1533
1534    list_data_get = eina_list_data_get;
1535
1536    ELM_NAVIFRAME_ITEM_DATA_GET(eo_top_it, top_it);
1537    l = eina_list_append(l, VIEW(top_it));
1538
1539    /* access */
1540    if (_elm_config->access_mode)
1541      {
1542         ao = _access_object_get(top_it, TITLE_ACCESS_PART);
1543         if (ao) l = eina_list_append(l, ao);
1544      }
1545
1546    int_ret = elm_widget_focus_list_next_get(obj, l, list_data_get, dir, next, next_item);
1547    eina_list_free(l);
1548
1549 end:
1550    if (!int_ret)
1551      {
1552         *next = obj;
1553         int_ret = !elm_widget_focus_get(obj);
1554      }
1555
1556    return int_ret;
1557 }
1558
1559 EOLIAN static Eina_Bool
1560 _elm_naviframe_elm_widget_focus_direction_manager_is(Eo *obj EINA_UNUSED, Elm_Naviframe_Data *sd EINA_UNUSED)
1561 {
1562    return EINA_TRUE;
1563 }
1564
1565 EOLIAN static Eina_Bool
1566 _elm_naviframe_elm_widget_focus_direction(Eo *obj EINA_UNUSED, Elm_Naviframe_Data *sd EINA_UNUSED, const Evas_Object *base, double degree, Evas_Object **direction, Elm_Object_Item **direction_item, double *weight)
1567 {
1568    Eina_Bool int_ret;
1569
1570    Eina_List *l = NULL;
1571    Elm_Object_Item *eo_top_it;
1572    void *(*list_data_get)(const Eina_List *list);
1573
1574    eo_top_it = elm_naviframe_top_item_get(obj);
1575    if (!eo_top_it) return EINA_FALSE;
1576
1577    list_data_get = eina_list_data_get;
1578
1579    ELM_NAVIFRAME_ITEM_DATA_GET(eo_top_it, top_it);
1580    l = eina_list_append(l, VIEW(top_it));
1581
1582    int_ret = elm_widget_focus_list_direction_get
1583             (obj, base, l, list_data_get, degree, direction, direction_item, weight);
1584
1585    eina_list_free(l);
1586
1587    return int_ret;
1588 }
1589
1590 //TIZEN_ONLY(20161208): add API elm_object_part_access_object_get
1591 EOLIAN static Evas_Object*
1592 _elm_naviframe_elm_widget_part_access_object_get(const Eo *obj, Elm_Naviframe_Data *_pd EINA_UNUSED, const char *part)
1593 {
1594    Elm_Object_Item *eo_top_it = NULL;
1595    eo_do(obj, eo_top_it = elm_obj_naviframe_top_item_get());
1596    if (!eo_top_it) return NULL;
1597
1598    ELM_NAVIFRAME_ITEM_DATA_GET(eo_top_it, top_it);
1599    return _access_object_get(top_it, part);
1600 }
1601 //
1602
1603 EOLIAN static void
1604 _elm_naviframe_evas_object_smart_add(Eo *obj, Elm_Naviframe_Data *priv)
1605 {
1606    ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
1607    //TIZEN ONLY(20160829): Support tizen transition
1608    _nf_mod_init();
1609
1610    eo_do_super(obj, MY_CLASS, evas_obj_smart_add());
1611    elm_widget_sub_object_parent_add(obj);
1612
1613    priv->dummy_edje = wd->resize_obj;
1614    evas_object_smart_member_add(priv->dummy_edje, obj);
1615
1616    priv->auto_pushed = _elm_config->naviframe_prev_btn_auto_pushed;
1617    priv->freeze_events = EINA_TRUE;
1618
1619    evas_object_event_callback_add(obj, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
1620                                   _on_obj_size_hints_changed, obj);
1621    elm_widget_can_focus_set(obj, EINA_TRUE);
1622 }
1623
1624 static void
1625 _send_signal(Elm_Naviframe_Item_Data *it, const char *sig)
1626 {
1627    if (!it) return ;
1628    elm_object_signal_emit(VIEW(it), sig, "elm");
1629    edje_object_message_signal_process(elm_layout_edje_get(VIEW(it)));
1630 }
1631
1632 static Eina_Bool
1633 _deferred(void *data)
1634 {
1635    Elm_Naviframe_Data *nfd = data;
1636    Elm_Naviframe_Op *nfo;
1637
1638    EINA_LIST_FREE(nfd->ops, nfo)
1639      {
1640         const char *signals_cur[] = {
1641           "elm,state,cur,popped,deferred",
1642           "elm,state,cur,pushed,deferred"
1643         };
1644         const char *signals_prev = "elm,state,prev,popped,deferred";
1645         const char *signals_new = "elm,state,new,pushed,deferred";
1646         Elm_Naviframe_Item_Data *cur;
1647         Elm_Naviframe_Item_Data *other;
1648
1649         cur = nfo->push ? nfo->related : nfo->self;
1650         other = nfo->push ? nfo->self : nfo->related;
1651
1652         //TIZEN ONLY(20161208): Support tizen transition
1653         //_send_signal(cur, signals_cur[nfo->push]);
1654         //_send_signal(other, nfo->push ? signals_new : signals_prev);
1655         if (_tizen_effect_enabled_get(cur))
1656           {
1657              if (nfo->push)
1658                {
1659                   if (nf_mod->tizen_push_deferred_effect)
1660                     nf_mod->tizen_push_deferred_effect(WIDGET(cur), VIEW(cur),
1661                                                        EINA_TRUE);
1662                }
1663              else
1664                {
1665                   if (nf_mod->tizen_pop_deferred_effect)
1666                     nf_mod->tizen_pop_deferred_effect(WIDGET(cur), VIEW(cur),
1667                                                       EINA_TRUE);
1668                }
1669           }
1670         else
1671           _send_signal(cur, signals_cur[nfo->push]);
1672
1673         if (_tizen_effect_enabled_get(other))
1674           {
1675              if (nfo->push)
1676                {
1677                   if (nf_mod->tizen_push_deferred_effect)
1678                     nf_mod->tizen_push_deferred_effect(WIDGET(other),
1679                                                        VIEW(other), EINA_FALSE);
1680                }
1681              else
1682                {
1683                   if (nf_mod->tizen_pop_deferred_effect)
1684                     nf_mod->tizen_pop_deferred_effect(WIDGET(other),
1685                                                       VIEW(other), EINA_FALSE);
1686                }
1687           }
1688         else
1689           _send_signal(other, nfo->push ? signals_new : signals_prev);
1690         //
1691
1692         free(nfo);
1693      }
1694
1695    nfd->animator = NULL;
1696    return ECORE_CALLBACK_CANCEL;
1697 }
1698
1699 EOLIAN static void
1700 _elm_naviframe_evas_object_smart_del(Eo *obj, Elm_Naviframe_Data *sd)
1701 {
1702    Elm_Naviframe_Item_Data *it;
1703    Elm_Naviframe_Op *nfo;
1704
1705    sd->on_deletion = EINA_TRUE;
1706
1707    while (sd->stack)
1708      {
1709         it = EINA_INLIST_CONTAINER_GET(sd->stack, Elm_Naviframe_Item_Data);
1710         eo_do(EO_OBJ(it), elm_wdg_item_del());
1711      }
1712
1713    //All popping items which are not called yet by animator.
1714    if (sd->animator) ecore_animator_del(sd->animator);
1715    EINA_LIST_FREE(sd->ops, nfo)
1716      free(nfo);
1717    EINA_LIST_FREE(sd->popping, it)
1718      eo_do(EO_OBJ(it), elm_wdg_item_del());
1719
1720    evas_object_del(sd->dummy_edje);
1721
1722    eo_do_super(obj, MY_CLASS, evas_obj_smart_del());
1723 }
1724
1725 //Show only the top item view
1726 EOLIAN static void
1727 _elm_naviframe_evas_object_smart_show(Eo *obj, Elm_Naviframe_Data *sd EINA_UNUSED)
1728 {
1729    Elm_Object_Item *eo_top;
1730
1731    eo_top = elm_naviframe_top_item_get(obj);
1732    ELM_NAVIFRAME_ITEM_DATA_GET(eo_top, top);
1733
1734    if (top && !top->delete_me)
1735      evas_object_show(VIEW(top));
1736 }
1737
1738 static Eina_Bool
1739 _key_action_top_item_get(Evas_Object *obj, const char *params EINA_UNUSED)
1740 {
1741    Elm_Object_Item *eo_item = NULL;
1742    eo_do(obj, eo_item = elm_obj_naviframe_top_item_get());
1743    if (!eo_item) return EINA_FALSE;
1744
1745    //FIXME: Replace this below code to elm_naviframe_item_pop() at elm 2.0.
1746    ///Leave for compatibility.
1747    ELM_NAVIFRAME_ITEM_DATA_GET(eo_item, it);
1748    if (it->title_prev_btn)
1749      eo_do(it->title_prev_btn, eo_event_callback_call(EVAS_CLICKABLE_INTERFACE_EVENT_CLICKED, NULL));
1750
1751    return EINA_TRUE;
1752 }
1753
1754 static Eina_Bool
1755 _key_action_item_pop(Evas_Object *obj, const char *params EINA_UNUSED)
1756 {
1757    Elm_Object_Item *eo_item = NULL;
1758    eo_item = elm_naviframe_top_item_get(obj);
1759    if (!eo_item) return EINA_FALSE;
1760
1761    ELM_NAVIFRAME_ITEM_DATA_GET(eo_item, it);
1762
1763    if (it->pushing || it->popping) return EINA_FALSE;
1764
1765    elm_naviframe_item_pop(obj);
1766
1767    return EINA_TRUE;
1768 }
1769
1770 EOLIAN static Eina_Bool
1771 _elm_naviframe_elm_widget_event(Eo *obj, Elm_Naviframe_Data *sd EINA_UNUSED, Evas_Object *src, Evas_Callback_Type type, void *event_info)
1772 {
1773    (void)src;
1774    Evas_Event_Key_Down *ev = event_info;
1775
1776    if (type != EVAS_CALLBACK_KEY_DOWN) return EINA_FALSE;
1777    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return EINA_FALSE;
1778    if (!_elm_config_key_binding_call(obj, ev, key_actions)) return EINA_FALSE;
1779
1780    ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
1781    return EINA_TRUE;
1782 }
1783
1784 EOLIAN static void
1785 _elm_naviframe_elm_widget_access(Eo *obj EINA_UNUSED, Elm_Naviframe_Data *sd, Eina_Bool is_access)
1786 {
1787    Elm_Naviframe_Item_Data *it;
1788
1789    EINA_INLIST_FOREACH(sd->stack, it)
1790      _access_obj_process(it, is_access);
1791 }
1792
1793 //TIZEN_ONLY(20160822): When atspi mode is dynamically switched on/off,
1794 //register/unregister access objects accordingly.
1795 // TIZEN_ONLY(20170516): connect to at-spi dbus based on org.a11y.Status.IsEnabled property
1796 EOLIAN static void
1797 _elm_naviframe_elm_widget_screen_reader(Eo *obj EINA_UNUSED, Elm_Naviframe_Data *sd, Eina_Bool is_screen_reader)
1798 {
1799    Elm_Naviframe_Item_Data *it;
1800
1801    EINA_INLIST_FOREACH(sd->stack, it)
1802      _atspi_expose_title(it, is_screen_reader);
1803
1804    //TIZEN_ONLY(20161213): apply screen_reader_changed callback
1805    evas_object_smart_callback_call(obj, SIG_ATSPI_SCREEN_READER_CHANGED, &is_screen_reader);
1806    //
1807 }
1808 //
1809 //
1810
1811 static void
1812 _item_push_helper(Elm_Naviframe_Item_Data *item)
1813 {
1814    Elm_Object_Item *eo_top_item;
1815    Evas_Object *obj = WIDGET(item);
1816    ELM_NAVIFRAME_DATA_GET(obj, sd);
1817    eo_top_item = elm_naviframe_top_item_get(obj);
1818    evas_object_show(VIEW(item));
1819
1820    ELM_NAVIFRAME_ITEM_DATA_GET(eo_top_item, top_item);
1821    if (top_item) elm_widget_focused_object_clear(VIEW(top_item));
1822    _resize_object_reset(obj, item);
1823    if (top_item)
1824      {
1825         Elm_Naviframe_Op *nfo = calloc(1, sizeof (Elm_Naviframe_Op));
1826
1827         /* TIZEN_ONLY(20170811): Set focus to new item view immediately when new item is pushed to show keypad fast. */
1828         //elm_widget_tree_unfocusable_set(VIEW(item), EINA_TRUE);
1829         elm_widget_tree_unfocusable_set(VIEW(item), EINA_FALSE);
1830         /* END */
1831         elm_widget_tree_unfocusable_set(VIEW(top_item), EINA_TRUE);
1832
1833         if (sd->freeze_events)
1834           {
1835              evas_object_freeze_events_set(VIEW(item), EINA_TRUE);
1836              evas_object_freeze_events_set(VIEW(top_item), EINA_TRUE);
1837           }
1838
1839         //TIZEN ONLY(20161208): Support tizen transition
1840         //elm_object_signal_emit(VIEW(top_item), "elm,state,cur,pushed", "elm");
1841         //elm_object_signal_emit(VIEW(item), "elm,state,new,pushed", "elm");
1842         //edje_object_message_signal_process(elm_layout_edje_get(VIEW(top_item)));
1843         //edje_object_message_signal_process(elm_layout_edje_get(VIEW(item)));
1844         if (_tizen_effect_enabled_get(top_item))
1845           {
1846              if (nf_mod->tizen_push_effect)
1847                nf_mod->tizen_push_effect(obj, VIEW(top_item), EINA_TRUE);
1848           }
1849         else
1850           {
1851              elm_object_signal_emit(VIEW(top_item), "elm,state,cur,pushed", "elm");
1852              edje_object_message_signal_process(elm_layout_edje_get(VIEW(top_item)));
1853           }
1854
1855         if (_tizen_effect_enabled_get(item))
1856           {
1857              if (nf_mod->tizen_push_effect)
1858                nf_mod->tizen_push_effect(obj, VIEW(item), EINA_FALSE);
1859           }
1860         else
1861           {
1862              elm_object_signal_emit(VIEW(item), "elm,state,new,pushed", "elm");
1863              edje_object_message_signal_process(elm_layout_edje_get(VIEW(item)));
1864           }
1865         //
1866
1867         nfo->self = item;
1868         nfo->related = top_item;
1869         nfo->push = EINA_TRUE;
1870
1871         sd->ops = eina_list_append(sd->ops, nfo);
1872         if (!sd->animator) sd->animator = ecore_animator_add(_deferred, sd);
1873
1874         if (top_item) top_item->pushing = EINA_FALSE;
1875         item->pushing = EINA_TRUE;
1876      }
1877    else
1878      {
1879         if (elm_object_focus_allow_get(VIEW(item)))
1880           elm_object_focus_set(VIEW(item), EINA_TRUE);
1881         else
1882           elm_object_focus_set(WIDGET(item), EINA_TRUE);
1883      }
1884
1885    sd->stack = eina_inlist_append(sd->stack, EINA_INLIST_GET(item));
1886
1887    if (!top_item)
1888      //TIZEN ONLY(20161208): Support tizen transition
1889      //elm_object_signal_emit(VIEW(item), "elm,state,visible", "elm");
1890      {
1891         if (!_tizen_effect_enabled_get(item))
1892           elm_object_signal_emit(VIEW(item), "elm,state,visible", "elm");
1893      }
1894    //
1895
1896    elm_layout_sizing_eval(obj);
1897
1898    if (!top_item)
1899      {
1900        //TIZEN_ONLY(20170919): Handle default label object
1901        _elm_win_default_label_obj_append(VIEW(item));
1902        //
1903         eo_do(obj, eo_event_callback_call(ELM_NAVIFRAME_EVENT_ITEM_ACTIVATED, EO_OBJ(item)));
1904      }
1905 }
1906
1907 EAPI Evas_Object *
1908 elm_naviframe_add(Evas_Object *parent)
1909 {
1910    EINA_SAFETY_ON_NULL_RETURN_VAL(parent, NULL);
1911    Evas_Object *obj = eo_add(MY_CLASS, parent);
1912    return obj;
1913 }
1914
1915 EOLIAN static Eo *
1916 _elm_naviframe_eo_base_constructor(Eo *obj, Elm_Naviframe_Data *sd EINA_UNUSED)
1917 {
1918    obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
1919    eo_do(obj,
1920          evas_obj_type_set(MY_CLASS_NAME_LEGACY),
1921          evas_obj_smart_callbacks_descriptions_set(_smart_callbacks),
1922          elm_interface_atspi_accessible_role_set(ELM_ATSPI_ROLE_PAGE_TAB_LIST));
1923
1924    return obj;
1925 }
1926
1927 EOLIAN static Elm_Object_Item*
1928 _elm_naviframe_item_push(Eo *obj, Elm_Naviframe_Data *sd EINA_UNUSED, const char *title_label, Evas_Object *prev_btn, Evas_Object *next_btn, Evas_Object *content, const char *item_style)
1929 {
1930    Elm_Object_Item *top_item, *eo_item;
1931
1932    top_item = elm_naviframe_top_item_get(obj);
1933    eo_item = _item_new(obj, top_item,
1934                   title_label, prev_btn, next_btn, content, item_style);
1935    ELM_NAVIFRAME_ITEM_DATA_GET(eo_item, item);
1936    if (!item) return NULL;
1937
1938    /* TIZEN_ONLY(20160523): give the new item's view to decorate it */
1939    evas_object_smart_callback_call(obj, "item,pushed,internal", VIEW(item));
1940    /* END */
1941
1942    _item_push_helper(item);
1943    return eo_item;
1944 }
1945
1946 EOLIAN static Elm_Object_Item*
1947 _elm_naviframe_item_insert_before(Eo *obj, Elm_Naviframe_Data *sd, Elm_Object_Item *eo_before, const char *title_label, Evas_Object *prev_btn, Evas_Object *next_btn, Evas_Object *content, const char *item_style)
1948 {
1949    Elm_Object_Item *eo_it;
1950    Elm_Naviframe_Item_Data *prev_it = NULL;
1951
1952    EINA_SAFETY_ON_NULL_RETURN_VAL(eo_before, NULL);
1953    ELM_NAVIFRAME_ITEM_DATA_GET(eo_before, before);
1954
1955    ELM_NAVIFRAME_ITEM_CHECK_OR_RETURN(before, NULL);
1956
1957    eo_it = eo_before;
1958    ELM_NAVIFRAME_ITEM_DATA_GET(eo_it, it);
1959    if (EINA_INLIST_GET(it)->prev)
1960      prev_it = EINA_INLIST_CONTAINER_GET(EINA_INLIST_GET(it)->prev,
1961                                          Elm_Naviframe_Item_Data);
1962    eo_it = _item_new(obj, EO_OBJ(prev_it),
1963                   title_label, prev_btn, next_btn, content, item_style);
1964    if (!eo_it) return NULL;
1965
1966    it = eo_data_scope_get(eo_it, ELM_NAVIFRAME_ITEM_CLASS);
1967
1968    /* TIZEN_ONLY(20160523): give the new item's view to decorate it */
1969    evas_object_smart_callback_call(obj, "item,pushed,internal", VIEW(it));
1970    /* END */
1971
1972    sd->stack = eina_inlist_prepend_relative
1973        (sd->stack, EINA_INLIST_GET(it),
1974        EINA_INLIST_GET(before));
1975
1976    elm_widget_tree_unfocusable_set(VIEW(it), EINA_TRUE);
1977    evas_object_hide(VIEW(it));
1978    //TIZEN ONLY(20161208): Support tizen transition
1979    //elm_object_signal_emit(VIEW(it), "elm,state,invisible", "elm");
1980    if (!_tizen_effect_enabled_get(it))
1981      elm_object_signal_emit(VIEW(it), "elm,state,invisible", "elm");
1982    //
1983
1984    elm_layout_sizing_eval(obj);
1985
1986    return eo_it;
1987 }
1988
1989 EOLIAN static Elm_Object_Item*
1990 _elm_naviframe_item_insert_after(Eo *obj, Elm_Naviframe_Data *sd, Elm_Object_Item *eo_after, const char *title_label, Evas_Object *prev_btn, Evas_Object *next_btn, Evas_Object *content, const char *item_style)
1991 {
1992    Elm_Object_Item *eo_item;
1993    Eina_Bool top_inserted = EINA_FALSE;
1994
1995    EINA_SAFETY_ON_NULL_RETURN_VAL(eo_after, NULL);
1996    ELM_NAVIFRAME_ITEM_DATA_GET(eo_after, after);
1997
1998    ELM_NAVIFRAME_ITEM_CHECK_OR_RETURN(after, NULL);
1999
2000    eo_item = _item_new(obj, eo_after,
2001                   title_label, prev_btn, next_btn, content, item_style);
2002    if (!eo_item) return NULL;
2003
2004    ELM_NAVIFRAME_ITEM_DATA_GET(eo_item, it);
2005
2006    /* TIZEN_ONLY(20160523): give the new item's view to decorate it */
2007    evas_object_smart_callback_call(obj, "item,pushed,internal", VIEW(it));
2008    /* END */
2009
2010    if (elm_naviframe_top_item_get(obj) == eo_after) top_inserted = EINA_TRUE;
2011
2012    sd->stack = eina_inlist_append_relative
2013        (sd->stack, EINA_INLIST_GET(it),
2014        EINA_INLIST_GET(after));
2015
2016
2017    if (top_inserted)
2018      {
2019         elm_widget_focused_object_clear(VIEW(after));
2020         elm_widget_tree_unfocusable_set(VIEW(after), EINA_TRUE);
2021         _resize_object_reset(obj, it);
2022         evas_object_show(VIEW(it));
2023         evas_object_hide(VIEW(after));
2024         //TIZEN_ONLY(20171019): add state_notify api
2025         if (_elm_atspi_enabled())
2026            eo_do(VIEW(after), elm_interface_atspi_accessible_state_notify(
2027                  ATSPI_STATE(ELM_ATSPI_STATE_SHOWING) | ATSPI_STATE(ELM_ATSPI_STATE_VISIBLE), EINA_TRUE));
2028         //
2029         if (elm_object_focus_allow_get(VIEW(it)))
2030           elm_object_focus_set(VIEW(it), EINA_TRUE);
2031         else
2032           elm_object_focus_set(WIDGET(it), EINA_TRUE);
2033         //TIZEN ONLY(20161208): Support tizen transition
2034         //elm_object_signal_emit(VIEW(it), "elm,state,visible", "elm");
2035         //elm_object_signal_emit(VIEW(after), "elm,state,invisible", "elm");
2036         if (!_tizen_effect_enabled_get(it))
2037           elm_object_signal_emit(VIEW(it), "elm,state,visible", "elm");
2038
2039         if (!_tizen_effect_enabled_get(after))
2040           elm_object_signal_emit(VIEW(after), "elm,state,invisible", "elm");
2041         //
2042      }
2043    else
2044    //TIZEN ONLY(20161208): Support tizen transition
2045      //elm_object_signal_emit(VIEW(it), "elm,state,invisible", "elm");
2046      {
2047         if (!_tizen_effect_enabled_get(it))
2048           elm_object_signal_emit(VIEW(it), "elm,state,invisible", "elm");
2049      }
2050    //
2051
2052    elm_layout_sizing_eval(obj);
2053
2054    if (top_inserted)
2055      {
2056         //TIZEN_ONLY(20171019): Handle default label object
2057         _elm_win_default_label_obj_append(VIEW(it));
2058         if (_elm_atspi_enabled())
2059            eo_do(VIEW(it), elm_interface_atspi_accessible_state_notify(
2060                  ATSPI_STATE(ELM_ATSPI_STATE_SHOWING) | ATSPI_STATE(ELM_ATSPI_STATE_VISIBLE), EINA_TRUE));
2061         //
2062         eo_do(obj, eo_event_callback_call(ELM_NAVIFRAME_EVENT_ITEM_ACTIVATED, eo_item));
2063      }
2064
2065    return eo_item;
2066 }
2067
2068 EOLIAN static Evas_Object*
2069 _elm_naviframe_item_pop(Eo *obj, Elm_Naviframe_Data *sd)
2070 {
2071    Elm_Object_Item *eo_item;
2072    Elm_Naviframe_Item_Data *prev_it = NULL;
2073    Evas_Object *content = NULL;
2074
2075    if (sd->freeze_events && sd->popping) return NULL;
2076
2077    eo_item = elm_naviframe_top_item_get(obj);
2078    if (!eo_item) return NULL;
2079
2080    ELM_NAVIFRAME_ITEM_DATA_GET(eo_item, it);
2081
2082    if (it->pushing || it->popping) return NULL;
2083    it->popping = EINA_TRUE;
2084
2085    evas_object_ref(obj);
2086    if (it->pop_cb)
2087      {
2088         eo_ref(eo_item);
2089         if (!it->pop_cb(it->pop_data, eo_item))
2090           {
2091              eo_unref(eo_item);
2092              if (it->delete_me)
2093                eo_do(eo_item, elm_wdg_item_del());
2094              else
2095                {
2096                   /* To avoid multiple item pops, the auto pushed button deletes
2097                      its clicked callback once it is called.
2098                      Since the item is not popped or deleted here, the deleted
2099                      callback of the auto pushed button should be restored. */
2100                   if (it->auto_pushed_btn)
2101                     eo_do(it->auto_pushed_btn, eo_event_callback_add
2102                           (EVAS_CLICKABLE_INTERFACE_EVENT_CLICKED,
2103                            _on_item_back_btn_clicked, obj));
2104                   it->popping = EINA_FALSE;
2105                }
2106              evas_object_unref(obj);
2107              return NULL;
2108           }
2109         eo_unref(eo_item);
2110      }
2111    evas_object_unref(obj);
2112
2113    if (sd->preserve)
2114      content = it->content;
2115
2116    evas_object_data_set(VIEW(it), "out_of_list", (void *)1);
2117
2118    if (sd->stack->last->prev)
2119      prev_it = EINA_INLIST_CONTAINER_GET
2120          (sd->stack->last->prev, Elm_Naviframe_Item_Data);
2121
2122    sd->stack = eina_inlist_remove(sd->stack, EINA_INLIST_GET(it));
2123
2124    if (prev_it)
2125      {
2126         Elm_Naviframe_Op *nfo = calloc(1, sizeof (Elm_Naviframe_Op));
2127
2128         elm_widget_tree_unfocusable_set(VIEW(it), EINA_TRUE);
2129
2130         if (sd->freeze_events)
2131           {
2132              evas_object_freeze_events_set(VIEW(it), EINA_TRUE);
2133              evas_object_freeze_events_set(VIEW(prev_it), EINA_TRUE);
2134           }
2135
2136         // TIZEN_ONLY(20161229): resize prev item before raise.
2137         elm_widget_resize_object_set(obj, VIEW(prev_it), EINA_FALSE);
2138         //
2139
2140         //TIZEN ONLY(20161208): Support tizen transition
2141         /* these 2 signals MUST take place simultaneously */
2142         //elm_object_signal_emit(VIEW(it), "elm,state,cur,popped", "elm");
2143         //elm_object_signal_emit(VIEW(prev_it), "elm,state,prev,popped", "elm");
2144         //edje_object_message_signal_process(elm_layout_edje_get(VIEW(it)));
2145         //edje_object_message_signal_process(elm_layout_edje_get(VIEW(prev_it)));
2146         if (_tizen_effect_enabled_get(it))
2147           {
2148              if (nf_mod->tizen_pop_effect)
2149                nf_mod->tizen_pop_effect(obj, VIEW(it), EINA_TRUE);
2150           }
2151         else
2152           {
2153              elm_object_signal_emit(VIEW(it), "elm,state,cur,popped", "elm");
2154              edje_object_message_signal_process(elm_layout_edje_get(VIEW(it)));
2155           }
2156
2157         if (_tizen_effect_enabled_get(prev_it))
2158           {
2159              if (nf_mod->tizen_pop_effect)
2160                nf_mod->tizen_pop_effect(obj, VIEW(prev_it), EINA_FALSE);
2161           }
2162         else
2163           {
2164              elm_object_signal_emit(VIEW(prev_it), "elm,state,prev,popped", "elm");
2165              edje_object_message_signal_process(elm_layout_edje_get(VIEW(prev_it)));
2166           }
2167         //
2168
2169         //Show hidden previous view when pop transition begins.
2170         evas_object_show(VIEW(prev_it));
2171
2172         if (!nfo) goto on_error;
2173
2174         nfo->self = it;
2175         nfo->related = prev_it;
2176         nfo->push = EINA_FALSE;
2177
2178         sd->popping = eina_list_append(sd->popping, it);
2179         sd->ops = eina_list_append(sd->ops, nfo);
2180         if (!sd->animator) sd->animator = ecore_animator_add(_deferred, sd);
2181      }
2182    else
2183      eo_do(eo_item, elm_wdg_item_del());
2184
2185  on_error:
2186    return content;
2187 }
2188
2189 EOLIAN static void
2190 _elm_naviframe_item_pop_to(Eo *eo_it, Elm_Naviframe_Item_Data *it)
2191 {
2192    Eina_Inlist *l;
2193
2194    ELM_NAVIFRAME_DATA_GET(WIDGET(it), sd);
2195
2196    if (eo_it == elm_naviframe_top_item_get(WIDGET(it))) return;
2197
2198    l = sd->stack->last->prev;
2199
2200    sd->on_deletion = EINA_TRUE;
2201
2202    while (l)
2203      {
2204         Elm_Naviframe_Item_Data *iit = EINA_INLIST_CONTAINER_GET
2205             (l, Elm_Naviframe_Item_Data);
2206
2207         if (iit == it) break;
2208
2209         l = l->prev;
2210
2211         eo_do(EO_OBJ(iit), elm_wdg_item_del());
2212      }
2213
2214    sd->on_deletion = EINA_FALSE;
2215
2216    elm_naviframe_item_pop(WIDGET(it));
2217 }
2218
2219 EOLIAN static void
2220 _elm_naviframe_item_promote(Eo *eo_it, Elm_Naviframe_Item_Data *it)
2221 {
2222    Elm_Object_Item *eo_prev_top;
2223    Elm_Naviframe_Item_Data *nit = it;
2224
2225    ELM_NAVIFRAME_DATA_GET(WIDGET(nit), sd);
2226
2227    eo_prev_top = elm_naviframe_top_item_get(WIDGET(nit));
2228    if (eo_it == eo_prev_top) return;
2229
2230    sd->stack = eina_inlist_remove(sd->stack, EINA_INLIST_GET(nit));
2231    _item_push_helper(nit);
2232 }
2233
2234 EOLIAN static void
2235 _elm_naviframe_item_simple_promote(Eo *obj EINA_UNUSED, Elm_Naviframe_Data *sd, Evas_Object *content)
2236 {
2237    Elm_Naviframe_Item_Data *itr;
2238
2239    EINA_INLIST_FOREACH(sd->stack, itr)
2240      {
2241         if (elm_object_item_content_get(EO_OBJ(itr)) == content)
2242           {
2243              elm_naviframe_item_promote(EO_OBJ(itr));
2244              break;
2245           }
2246      }
2247 }
2248
2249 EOLIAN static void
2250 _elm_naviframe_content_preserve_on_pop_set(Eo *obj EINA_UNUSED, Elm_Naviframe_Data *sd, Eina_Bool preserve)
2251 {
2252    sd->preserve = !!preserve;
2253 }
2254
2255 EOLIAN static Eina_Bool
2256 _elm_naviframe_content_preserve_on_pop_get(Eo *obj EINA_UNUSED, Elm_Naviframe_Data *sd)
2257 {
2258    return sd->preserve;
2259 }
2260
2261 EOLIAN static Elm_Object_Item*
2262 _elm_naviframe_top_item_get(Eo *obj EINA_UNUSED, Elm_Naviframe_Data *sd)
2263 {
2264    if (!sd->stack) return NULL;
2265    Elm_Naviframe_Item_Data *ret_it = EINA_INLIST_CONTAINER_GET
2266                                 (sd->stack->last, Elm_Naviframe_Item_Data);
2267    return EO_OBJ(ret_it);
2268 }
2269
2270 EOLIAN static Elm_Object_Item*
2271 _elm_naviframe_bottom_item_get(Eo *obj EINA_UNUSED, Elm_Naviframe_Data *sd)
2272 {
2273    if (!sd->stack) return NULL;
2274    Elm_Naviframe_Item_Data *ret_it = EINA_INLIST_CONTAINER_GET
2275                                 (sd->stack, Elm_Naviframe_Item_Data);
2276    return EO_OBJ(ret_it);
2277 }
2278
2279 EOLIAN static void
2280 _elm_naviframe_item_style_set(Eo *eo_item EINA_UNUSED,
2281                               Elm_Naviframe_Item_Data *nit,
2282                               const char *item_style)
2283 {
2284    if (item_style && !strcmp(item_style, nit->style)) return;
2285
2286    if (!item_style)
2287      if (!strcmp("basic", nit->style)) return;
2288
2289    _item_style_set(nit, item_style);
2290    _item_signals_emit(nit);
2291    _item_title_enabled_update(nit, EINA_FALSE);
2292 }
2293
2294 EOLIAN static const char *
2295 _elm_naviframe_item_style_get(Eo *eo_item EINA_UNUSED,
2296                               Elm_Naviframe_Item_Data *nit)
2297 {
2298    return nit->style;
2299 }
2300
2301 EINA_DEPRECATED EAPI void
2302 elm_naviframe_item_title_visible_set(Elm_Object_Item *it,
2303                                      Eina_Bool visible)
2304 {
2305    elm_naviframe_item_title_enabled_set(it, visible, EINA_FALSE);
2306 }
2307
2308 EINA_DEPRECATED EAPI Eina_Bool
2309 elm_naviframe_item_title_visible_get(const Elm_Object_Item *it)
2310 {
2311    return elm_naviframe_item_title_enabled_get(it);
2312 }
2313
2314 EOLIAN static void
2315 _elm_naviframe_item_title_enabled_set(Eo *eo_item EINA_UNUSED,
2316                                       Elm_Naviframe_Item_Data *nit,
2317                                       Eina_Bool enabled,
2318                                       Eina_Bool transition)
2319 {
2320    enabled = !!enabled;
2321    if (nit->title_enabled == enabled) return;
2322
2323    nit->title_enabled = enabled;
2324
2325    transition = !!transition;
2326    _item_title_enabled_update(nit, transition);
2327 }
2328
2329 EOLIAN static Eina_Bool
2330 _elm_naviframe_item_title_enabled_get(const Eo *eo_item EINA_UNUSED, Elm_Naviframe_Item_Data *nit)
2331 {
2332    return nit->title_enabled;
2333 }
2334
2335 EOLIAN static void
2336 _elm_naviframe_item_pop_cb_set(Eo *eo_item EINA_UNUSED,
2337                                Elm_Naviframe_Item_Data *nit,
2338                                Elm_Naviframe_Item_Pop_Cb func,
2339                                void *data)
2340 {
2341    nit->pop_cb = func;
2342    nit->pop_data = data;
2343 }
2344
2345 EOLIAN static void
2346 _elm_naviframe_prev_btn_auto_pushed_set(Eo *obj EINA_UNUSED, Elm_Naviframe_Data *sd, Eina_Bool auto_pushed)
2347 {
2348    sd->auto_pushed = !!auto_pushed;
2349 }
2350
2351 EOLIAN static Eina_Bool
2352 _elm_naviframe_prev_btn_auto_pushed_get(Eo *obj EINA_UNUSED, Elm_Naviframe_Data *sd)
2353 {
2354    return sd->auto_pushed;
2355 }
2356
2357 EOLIAN static Eina_List*
2358 _elm_naviframe_items_get(Eo *obj EINA_UNUSED, Elm_Naviframe_Data *sd)
2359 {
2360    Eina_List *ret = NULL;
2361    Elm_Naviframe_Item_Data *itr;
2362
2363    EINA_INLIST_FOREACH(sd->stack, itr)
2364      ret = eina_list_append(ret, EO_OBJ(itr));
2365
2366    return ret;
2367 }
2368
2369 EOLIAN static void
2370 _elm_naviframe_event_enabled_set(Eo *obj EINA_UNUSED, Elm_Naviframe_Data *sd, Eina_Bool enabled)
2371 {
2372    enabled = !!enabled;
2373    if (sd->freeze_events == !enabled) return;
2374    sd->freeze_events = !enabled;
2375 }
2376
2377 EOLIAN static Eina_Bool
2378 _elm_naviframe_event_enabled_get(Eo *obj EINA_UNUSED, Elm_Naviframe_Data *sd)
2379 {
2380    return !sd->freeze_events;
2381 }
2382
2383 EOLIAN static Eina_Bool
2384 _elm_naviframe_elm_widget_focus_next_manager_is(Eo *obj EINA_UNUSED, Elm_Naviframe_Data *sd EINA_UNUSED)
2385 {
2386    return EINA_TRUE;
2387 }
2388
2389 static void
2390 _elm_naviframe_class_constructor(Eo_Class *klass)
2391 {
2392    evas_smart_legacy_type_register(MY_CLASS_NAME_LEGACY, klass);
2393 }
2394
2395 EOLIAN const Elm_Atspi_Action *
2396 _elm_naviframe_elm_interface_atspi_widget_action_elm_actions_get(Eo *obj EINA_UNUSED, Elm_Naviframe_Data *pd EINA_UNUSED)
2397 {
2398    static Elm_Atspi_Action atspi_actions[] = {
2399           { "top_item_get", "top_item_get", NULL, _key_action_top_item_get },
2400           { "item_pop", "item_pop", NULL, _key_action_item_pop },
2401           { NULL, NULL, NULL, NULL }
2402    };
2403    return &atspi_actions[0];
2404 }
2405
2406 //TIZEN_ONLY(20161213) Using VIEW(item) for naviframe, naviframe item accessible information
2407 EOLIAN const char*
2408 _elm_naviframe_elm_interface_atspi_accessible_name_get(Eo *eo, Elm_Naviframe_Data *pd EINA_UNUSED)
2409 {
2410    const char *ret = NULL;
2411    Elm_Object_Item *eo_top_it = NULL;
2412
2413    eo_top_it = elm_naviframe_top_item_get(eo);
2414    if (eo_top_it)
2415      {
2416         eo_do(eo_top_it, ret = elm_interface_atspi_accessible_name_get());
2417      }
2418
2419    return ret;
2420 }
2421
2422 EOLIAN const char*
2423 _elm_naviframe_elm_interface_atspi_accessible_description_get(Eo *eo, Elm_Naviframe_Data *pd EINA_UNUSED)
2424 {
2425    const char *ret = NULL;
2426    Elm_Object_Item *eo_top_it = NULL;
2427
2428    eo_top_it = elm_naviframe_top_item_get(eo);
2429    if (eo_top_it)
2430      {
2431         eo_do(eo_top_it, ret = elm_interface_atspi_accessible_description_get());
2432      }
2433
2434    return ret;
2435 }
2436
2437 EOLIAN void
2438 _elm_naviframe_item_elm_interface_atspi_accessible_name_set(Eo *eo_item EINA_UNUSED, Elm_Naviframe_Item_Data* nit, const char *name)
2439 {
2440    eo_do(VIEW(nit), elm_interface_atspi_accessible_name_set(name));
2441 }
2442
2443 EOLIAN const char*
2444 _elm_naviframe_item_elm_interface_atspi_accessible_name_get(Eo *eo_item, Elm_Naviframe_Item_Data *nit)
2445 {
2446    const char *ret = NULL;
2447    eo_do_super(eo_item, ELM_NAVIFRAME_ITEM_CLASS, ret = elm_interface_atspi_accessible_name_get());
2448    if (ret) return ret;
2449
2450    eo_do(VIEW(nit), ret = elm_interface_atspi_accessible_name_get());
2451    return ret;
2452 }
2453
2454 EOLIAN void
2455 _elm_naviframe_item_elm_interface_atspi_accessible_description_set(Eo *eo_item EINA_UNUSED, Elm_Naviframe_Item_Data* nit, const char *description)
2456 {
2457    eo_do(VIEW(nit), elm_interface_atspi_accessible_description_set(description));
2458 }
2459
2460 EOLIAN const char*
2461 _elm_naviframe_item_elm_interface_atspi_accessible_description_get(Eo *eo_item, Elm_Naviframe_Item_Data *nit)
2462 {
2463    const char *ret = NULL;
2464    eo_do_super(eo_item, ELM_NAVIFRAME_ITEM_CLASS, ret = elm_interface_atspi_accessible_description_get());
2465    if (ret) return ret;
2466
2467    eo_do(VIEW(nit), ret = elm_interface_atspi_accessible_description_get());
2468    return ret;
2469 }
2470
2471 EOLIAN static void
2472 _elm_naviframe_item_elm_interface_atspi_accessible_translation_domain_set(Eo *eo_item EINA_UNUSED, Elm_Naviframe_Item_Data* nit, const char *domain)
2473 {
2474    eo_do(VIEW(nit), elm_interface_atspi_accessible_translation_domain_set(domain));
2475 }
2476
2477 EOLIAN static const char*
2478 _elm_naviframe_item_elm_interface_atspi_accessible_translation_domain_get(Eo *eo_item EINA_UNUSED, Elm_Naviframe_Item_Data* nit)
2479 {
2480    const char *ret = NULL;
2481    eo_do(VIEW(nit), ret = elm_interface_atspi_accessible_translation_domain_get());
2482    return ret;
2483 }
2484
2485 EOLIAN static void
2486 _elm_naviframe_item_elm_interface_atspi_accessible_name_cb_set(Eo *eo_item EINA_UNUSED, Elm_Naviframe_Item_Data* nit, Elm_Atspi_Reading_Info_Cb name_cb, const void *data)
2487 {
2488    eo_do(VIEW(nit), elm_interface_atspi_accessible_name_cb_set(name_cb, data));
2489 }
2490
2491 EOLIAN static void
2492 _elm_naviframe_item_elm_interface_atspi_accessible_description_cb_set(Eo *eo_item EINA_UNUSED, Elm_Naviframe_Item_Data* nit, Elm_Atspi_Reading_Info_Cb description_cb, const void *data)
2493 {
2494    eo_do(VIEW(nit), elm_interface_atspi_accessible_description_cb_set(description_cb, data));
2495 }
2496 //
2497
2498 #include "elm_naviframe_item.eo.c"
2499 #include "elm_naviframe.eo.c"