2013-04-25 22:13:00 -07:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include "elementary_config.h"
|
|
|
|
#endif
|
|
|
|
|
2018-04-03 04:27:30 -07:00
|
|
|
#define EFL_ACCESS_OBJECT_PROTECTED
|
2017-09-11 23:49:29 -07:00
|
|
|
#define EFL_ACCESS_COMPONENT_PROTECTED
|
2016-04-11 09:51:15 -07:00
|
|
|
#define ELM_WIDGET_PROTECTED
|
2014-08-13 06:36:29 -07:00
|
|
|
#define ELM_WIDGET_ITEM_PROTECTED
|
2017-04-12 02:30:22 -07:00
|
|
|
#define EFL_INPUT_EVENT_PROTECTED
|
2018-12-21 14:46:10 -08:00
|
|
|
#define EFL_UI_L10N_PROTECTED
|
2017-11-14 09:56:08 -08:00
|
|
|
#define EFL_UI_FOCUS_OBJECT_PROTECTED
|
2017-11-23 21:41:31 -08:00
|
|
|
#define EFL_UI_WIDGET_PART_BG_PROTECTED
|
2018-05-03 16:34:17 -07:00
|
|
|
#define EFL_PART_PROTECTED
|
2016-06-24 01:17:20 -07:00
|
|
|
|
2008-09-29 23:58:56 -07:00
|
|
|
#include <Elementary.h>
|
2013-04-25 22:13:00 -07:00
|
|
|
|
2008-09-29 23:58:56 -07:00
|
|
|
#include "elm_priv.h"
|
2012-05-03 15:41:26 -07:00
|
|
|
#include "elm_widget_container.h"
|
2012-07-04 14:41:01 -07:00
|
|
|
#include "elm_interface_scrollable.h"
|
2017-06-29 04:02:59 -07:00
|
|
|
#include "elm_part_helper.h"
|
2019-01-17 06:54:24 -08:00
|
|
|
#include "elm_widget_combobox.h"
|
2008-09-29 23:58:56 -07:00
|
|
|
|
2016-06-13 21:43:36 -07:00
|
|
|
/* FIXME: remove this when we don't rely on evas event structs anymore */
|
|
|
|
#define EFL_INTERNAL_UNSTABLE
|
|
|
|
#include "interfaces/efl_common_internal.h"
|
|
|
|
|
2018-01-07 20:55:35 -08:00
|
|
|
#define MY_CLASS EFL_UI_WIDGET_CLASS
|
2012-11-25 22:32:53 -08:00
|
|
|
|
2018-01-07 20:55:35 -08:00
|
|
|
#define MY_CLASS_NAME "Efl_Ui_Widget"
|
2013-11-07 03:44:22 -08:00
|
|
|
#define MY_CLASS_NAME_LEGACY "elm_widget"
|
2012-11-25 22:32:53 -08:00
|
|
|
|
2013-10-13 22:40:35 -07:00
|
|
|
#define ELM_WIDGET_DATA_GET(o, wd) \
|
2016-08-15 06:44:41 -07:00
|
|
|
Elm_Widget_Smart_Data *wd = efl_data_scope_get(o, MY_CLASS)
|
2012-12-05 02:59:36 -08:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
#define API_ENTRY \
|
2017-02-14 20:32:15 -08:00
|
|
|
Elm_Widget_Smart_Data *sd = NULL; \
|
|
|
|
if (!_elm_widget_is(obj) || \
|
|
|
|
(!(sd = efl_data_scope_get(obj, MY_CLASS))))
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
#define INTERNAL_ENTRY \
|
|
|
|
ELM_WIDGET_DATA_GET(obj, sd); \
|
|
|
|
if (!sd) return
|
|
|
|
|
2014-03-31 17:25:21 -07:00
|
|
|
#define ELM_WIDGET_FOCUS_GET(obj) \
|
2018-01-07 20:55:35 -08:00
|
|
|
(efl_isa(obj, EFL_UI_WIDGET_CLASS) && \
|
2014-03-31 17:25:21 -07:00
|
|
|
((_elm_access_auto_highlight_get()) ? (elm_widget_highlight_get(obj)) : \
|
2017-11-29 00:39:42 -08:00
|
|
|
(efl_ui_focus_object_focus_get(obj))))
|
2011-04-02 23:43:17 -07:00
|
|
|
|
2014-01-23 00:24:19 -08:00
|
|
|
const char SIG_WIDGET_FOCUSED[] = "focused";
|
|
|
|
const char SIG_WIDGET_UNFOCUSED[] = "unfocused";
|
2014-01-23 02:30:34 -08:00
|
|
|
const char SIG_WIDGET_LANG_CHANGED[] = "language,changed";
|
2014-02-07 21:05:06 -08:00
|
|
|
const char SIG_WIDGET_ACCESS_CHANGED[] = "access,changed";
|
2014-01-23 00:24:19 -08:00
|
|
|
|
2012-08-30 09:47:10 -07:00
|
|
|
typedef struct _Elm_Event_Cb_Data Elm_Event_Cb_Data;
|
2017-07-16 21:45:08 -07:00
|
|
|
typedef struct _Elm_Label_Data Elm_Label_Data;
|
2011-10-19 07:17:14 -07:00
|
|
|
typedef struct _Elm_Translate_String_Data Elm_Translate_String_Data;
|
2008-09-29 23:58:56 -07:00
|
|
|
|
2011-04-02 23:43:17 -07:00
|
|
|
struct _Elm_Event_Cb_Data
|
|
|
|
{
|
|
|
|
Elm_Event_Cb func;
|
|
|
|
const void *data;
|
2010-11-29 05:56:30 -08:00
|
|
|
};
|
|
|
|
|
2017-07-16 21:45:08 -07:00
|
|
|
struct _Elm_Label_Data
|
|
|
|
{
|
|
|
|
const char *part;
|
|
|
|
const char *text;
|
|
|
|
};
|
|
|
|
|
2011-10-19 07:17:14 -07:00
|
|
|
struct _Elm_Translate_String_Data
|
|
|
|
{
|
2013-07-16 23:05:40 -07:00
|
|
|
EINA_INLIST;
|
2013-04-01 04:50:25 -07:00
|
|
|
Eina_Stringshare *id;
|
|
|
|
Eina_Stringshare *domain;
|
|
|
|
Eina_Stringshare *string;
|
2013-04-23 00:49:49 -07:00
|
|
|
Eina_Bool preset : 1;
|
2011-10-19 07:17:14 -07:00
|
|
|
};
|
|
|
|
|
2018-02-14 12:04:24 -08:00
|
|
|
/* For keeping backward compatibility (EFL 1.18 or older versions).
|
|
|
|
* Since EFL 1.19 which starts to use eolian_gen2, it does not convert
|
|
|
|
* "." to "_" among the class name. */
|
|
|
|
static const char *legacy_type_table[][2] =
|
|
|
|
{
|
efl_ui_bg: remove Efl.Ui.Bg interface and rename Efl.Ui.Bg_Widget class
Summary:
Efl.Ui.Bg interface does not have any new property or method.
Moreover, Efl.Ui.Bg interface is not used by widgets except
Efl.Ui.Bg_Widget and Efl.Ui.Widget_Part_Bg.
Consequently, Efl.Ui.Bg interface can be replaced by other interfaces.
Due to Efl.Ui.Bg interface, the bg widget class name becomes
Efl.UI.Bg_Widget which is not synchronized with other widget names.
Therefore, to keep consistency with other widgets, it would be better to
remove Efl.Ui.Bg interface and rename Efl.Ui.Bg_Widget to Efl.Ui.Bg.
Reviewers: woohyun, segfaultxavi, bu5hm4n, zmike
Reviewed By: segfaultxavi
Subscribers: cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D7304
2018-11-19 17:24:05 -08:00
|
|
|
{ "Efl.Ui.Bg_Legacy", "Elm_Bg" },
|
2018-02-14 12:04:24 -08:00
|
|
|
{ "Efl.Ui.Button_Legacy", "Elm_Button" },
|
|
|
|
{ "Efl.Ui.Check_Legacy", "Elm_Check" },
|
|
|
|
{ "Efl.Ui.Clock_Legacy", "Elm_Datetime" },
|
|
|
|
{ "Efl.Ui.Flip_Legacy", "Elm_Flip" },
|
|
|
|
{ "Efl.Ui.Frame_Legacy", "Elm_Frame" },
|
|
|
|
{ "Efl.Ui.Image_Legacy", "Elm_Image" },
|
|
|
|
{ "Efl.Ui.Image_Zoomable_Legacy", "Elm_Photocam" },
|
|
|
|
{ "Efl.Ui.Layout_Legacy", "Elm_Layout" },
|
|
|
|
{ "Efl.Ui.Panes_Legacy", "Elm_Panes" },
|
|
|
|
{ "Efl.Ui.Progressbar_Legacy", "Elm_Progressbar" },
|
|
|
|
{ "Efl.Ui.Radio_Legacy", "Elm_Radio" },
|
|
|
|
{ "Efl.Ui.Video_Legacy", "Elm_Video" },
|
|
|
|
{ "Efl.Ui.Win_Legacy", "Elm_Win" },
|
2018-05-31 05:39:34 -07:00
|
|
|
{ "Efl.Ui.Win_Socket_Legacy", "Elm_Win" },
|
|
|
|
{ "Efl.Ui.Win_Inlined_Legacy", "Elm_Win" },
|
2018-02-14 12:04:24 -08:00
|
|
|
{ "Elm.Code_Widget_Legacy", "Elm_Code_Widget" },
|
|
|
|
{ "Elm.Ctxpopup", "Elm_Ctxpopup" },
|
|
|
|
{ "Elm.Entry", "Elm_Entry" },
|
|
|
|
{ "Elm.Colorselector", "Elm_Colorselector" },
|
|
|
|
{ "Elm.List", "Elm_List" },
|
|
|
|
{ "Elm.Photo", "Elm_Photo" },
|
|
|
|
{ "Elm.Actionslider", "Elm_Actionslider" },
|
|
|
|
{ "Elm.Box", "Elm_Box" },
|
|
|
|
{ "Elm.Table", "Elm_Table" },
|
|
|
|
{ "Elm.Thumb", "Elm_Thumb" },
|
|
|
|
{ "Elm.Menu", "Elm_Menu" },
|
|
|
|
{ "Elm.Icon", "Elm_Icon" },
|
|
|
|
{ "Elm.Prefs", "Elm_Prefs" },
|
|
|
|
{ "Elm.Map", "Elm_Map" },
|
|
|
|
{ "Elm.Glview", "Elm_Glview" },
|
|
|
|
{ "Elm.Web", "Elm_Web" },
|
|
|
|
{ "Elm.Toolbar", "Elm_Toolbar" },
|
|
|
|
{ "Elm.Grid", "Elm_Grid" },
|
|
|
|
{ "Elm.Diskselector", "Elm_Diskselector" },
|
|
|
|
{ "Elm.Notify", "Elm_Notify" },
|
|
|
|
{ "Elm.Mapbuf", "Elm_Mapbuf" },
|
|
|
|
{ "Elm.Separator", "Elm_Separator" },
|
|
|
|
{ "Elm.Calendar", "Elm_Calendar" },
|
|
|
|
{ "Elm.Inwin", "Elm_Inwin" },
|
|
|
|
{ "Elm.Gengrid", "Elm_Gengrid" },
|
|
|
|
{ "Elm.Scroller", "Elm_Scroller" },
|
|
|
|
{ "Elm.Player", "Elm_Player" },
|
|
|
|
{ "Elm.Segment_Control", "Elm_Segment_Control" },
|
|
|
|
{ "Elm.Fileselector", "Elm_Fileselector" },
|
|
|
|
{ "Elm.Fileselector_Button", "Elm_Fileselector_Button" },
|
|
|
|
{ "Elm.Fileselector_Entry", "Elm_Fileselector_Entry" },
|
|
|
|
{ "Elm.Flipselector", "Elm_Flipselector" },
|
|
|
|
{ "Elm.Hoversel", "Elm_Hoversel" },
|
|
|
|
{ "Elm.Naviframe", "Elm_Naviframe" },
|
|
|
|
{ "Elm.Popup", "Elm_Popup" },
|
|
|
|
{ "Elm.Bubble", "Elm_Bubble" },
|
|
|
|
{ "Elm.Clock", "Elm_Clock" },
|
|
|
|
{ "Elm.Conformant", "Elm_Conformant" },
|
|
|
|
{ "Elm.Dayselector", "Elm_Dayselector" },
|
|
|
|
{ "Elm.Genlist", "Elm_Genlist" },
|
|
|
|
{ "Elm.Hover", "Elm_Hover" },
|
|
|
|
{ "Elm.Index", "Elm_Index" },
|
|
|
|
{ "Elm.Label", "Elm_Label" },
|
|
|
|
{ "Elm.Panel", "Elm_Panel" },
|
2018-05-15 04:13:06 -07:00
|
|
|
{ "Elm.Slider", "Elm_Slider" },
|
2018-02-14 12:04:24 -08:00
|
|
|
{ "Elm.Slideshow", "Elm_Slideshow" },
|
|
|
|
{ "Elm.Spinner", "Elm_Spinner" },
|
|
|
|
{ "Elm.Plug", "Elm_Plug" },
|
2018-02-17 11:12:12 -08:00
|
|
|
{ "Elm.Web.None", "Elm_Web" },
|
2018-04-30 03:42:04 -07:00
|
|
|
{ "Elm.Multibuttonentry", "Elm_Multibuttonentry" },
|
2018-02-14 12:04:24 -08:00
|
|
|
{ NULL, NULL }
|
|
|
|
};
|
|
|
|
|
2008-10-06 18:23:49 -07:00
|
|
|
/* local subsystem globals */
|
2010-09-13 00:56:23 -07:00
|
|
|
static inline Eina_Bool
|
|
|
|
_elm_widget_is(const Evas_Object *obj)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
return efl_isa(obj, MY_CLASS);
|
2010-09-13 00:56:23 -07:00
|
|
|
}
|
|
|
|
|
2010-09-24 07:47:52 -07:00
|
|
|
static inline Eina_Bool
|
|
|
|
_is_focusable(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return EINA_FALSE;
|
2010-10-22 14:41:22 -07:00
|
|
|
return sd->can_focus || (sd->child_can_focus);
|
2010-09-24 07:47:52 -07:00
|
|
|
}
|
|
|
|
|
2016-04-15 21:47:13 -07:00
|
|
|
static inline Eina_Bool
|
|
|
|
_is_focused(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return EINA_FALSE;
|
|
|
|
return sd->focused;
|
|
|
|
}
|
|
|
|
|
2012-07-04 14:41:01 -07:00
|
|
|
static inline Eina_Bool
|
|
|
|
_elm_scrollable_is(const Evas_Object *obj)
|
|
|
|
{
|
2012-09-04 19:37:47 -07:00
|
|
|
INTERNAL_ENTRY EINA_FALSE;
|
2018-05-17 02:17:44 -07:00
|
|
|
if (elm_widget_is_legacy(obj))
|
|
|
|
return
|
|
|
|
efl_isa(obj, ELM_INTERFACE_SCROLLABLE_MIXIN);
|
|
|
|
else
|
|
|
|
return
|
|
|
|
efl_isa(obj, EFL_UI_SCROLLABLE_INTERACTIVE_INTERFACE);
|
2012-07-04 14:41:01 -07:00
|
|
|
}
|
|
|
|
|
2016-08-02 06:38:30 -07:00
|
|
|
static void
|
|
|
|
elm_widget_disabled_internal(Eo *obj, Eina_Bool disabled);
|
2016-06-20 07:31:31 -07:00
|
|
|
static void
|
2016-08-30 05:34:10 -07:00
|
|
|
_on_sub_obj_del(void *data, const Efl_Event *event);
|
2017-08-17 02:14:52 -07:00
|
|
|
static void _propagate_event(void *data, const Efl_Event *eo_event);
|
2017-08-23 01:01:03 -07:00
|
|
|
static void _elm_widget_focus_tree_unfocusable_handle(Eo *obj);
|
2018-01-07 20:55:35 -08:00
|
|
|
static void _elm_widget_shadow_update(Efl_Ui_Widget *obj);
|
2014-07-06 10:08:56 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
EFL_CALLBACKS_ARRAY_DEFINE(elm_widget_subitems_callbacks,
|
2017-09-27 12:20:51 -07:00
|
|
|
{ EFL_EVENT_DEL, _on_sub_obj_del });
|
2016-08-15 06:44:41 -07:00
|
|
|
EFL_CALLBACKS_ARRAY_DEFINE(efl_subitems_callbacks,
|
2016-08-18 23:38:25 -07:00
|
|
|
{ EFL_EVENT_DEL, _on_sub_obj_del });
|
2016-08-15 06:44:41 -07:00
|
|
|
EFL_CALLBACKS_ARRAY_DEFINE(focus_callbacks,
|
2016-06-13 21:43:36 -07:00
|
|
|
{ EFL_EVENT_KEY_DOWN, _propagate_event },
|
|
|
|
{ EFL_EVENT_KEY_UP, _propagate_event },
|
|
|
|
{ EFL_EVENT_POINTER_WHEEL, _propagate_event });
|
2014-07-06 10:08:56 -07:00
|
|
|
|
|
|
|
static inline void
|
|
|
|
_callbacks_add(Eo *widget, void *data)
|
|
|
|
{
|
|
|
|
if (_elm_widget_is(widget))
|
|
|
|
{
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_event_callback_array_add(widget, elm_widget_subitems_callbacks(), data);
|
2014-07-06 10:08:56 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_event_callback_array_add(widget, efl_subitems_callbacks(), data);
|
2014-07-06 10:08:56 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
_callbacks_del(Eo *widget, void *data)
|
|
|
|
{
|
|
|
|
if (_elm_widget_is(widget))
|
|
|
|
{
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_event_callback_array_del(widget, elm_widget_subitems_callbacks(), data);
|
2014-07-06 10:08:56 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_event_callback_array_del(widget, efl_subitems_callbacks(), data);
|
2014-07-06 10:08:56 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-21 11:09:46 -08:00
|
|
|
void
|
2014-08-13 06:36:29 -07:00
|
|
|
_elm_widget_item_highlight_in_theme(Evas_Object *obj, Elm_Object_Item *eo_it)
|
2014-02-21 11:09:46 -08:00
|
|
|
{
|
|
|
|
const char *str;
|
|
|
|
|
2014-08-13 06:36:29 -07:00
|
|
|
if (!eo_it) return;
|
2016-08-15 06:44:41 -07:00
|
|
|
if (efl_isa(eo_it, ELM_WIDGET_ITEM_CLASS))
|
2014-08-13 06:36:29 -07:00
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Elm_Widget_Item_Data *it = efl_data_scope_get(eo_it, ELM_WIDGET_ITEM_CLASS);
|
2015-06-22 16:30:21 -07:00
|
|
|
|
2018-11-16 01:45:05 -08:00
|
|
|
if (efl_isa(it->view, EFL_UI_LAYOUT_CLASS))
|
2015-06-22 16:30:21 -07:00
|
|
|
str = edje_object_data_get(elm_layout_edje_get(it->view), "focus_highlight");
|
|
|
|
else
|
|
|
|
str = edje_object_data_get(it->view, "focus_highlight");
|
2014-08-13 06:36:29 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
str = edje_object_data_get(((Elm_Widget_Item_Data *)eo_it)->view, "focus_highlight");
|
2014-02-21 11:09:46 -08:00
|
|
|
if ((str) && (!strcmp(str, "on")))
|
|
|
|
elm_widget_highlight_in_theme_set(obj, EINA_TRUE);
|
|
|
|
else
|
|
|
|
elm_widget_highlight_in_theme_set(obj, EINA_FALSE);
|
|
|
|
}
|
|
|
|
|
2014-02-18 06:40:48 -08:00
|
|
|
void
|
|
|
|
_elm_widget_focus_highlight_start(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Evas_Object *top = elm_widget_top_get(obj);
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
if (top && efl_isa(top, EFL_UI_WIN_CLASS))
|
2014-02-18 06:40:48 -08:00
|
|
|
_elm_win_focus_highlight_start(top);
|
|
|
|
}
|
|
|
|
|
2015-08-12 21:45:21 -07:00
|
|
|
Evas_Object *
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_focus_highlight_object_get(const Evas_Object *obj)
|
2015-08-12 21:45:21 -07:00
|
|
|
{
|
|
|
|
Evas_Object *top = elm_widget_top_get(obj);
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
if (top && efl_isa(top, EFL_UI_WIN_CLASS))
|
2015-08-12 21:45:21 -07:00
|
|
|
return _elm_win_focus_highlight_object_get(top);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2017-08-30 23:57:53 -07:00
|
|
|
EOLIAN static Eina_Bool
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_focus_highlight_enabled_get(const Eo *obj, Elm_Widget_Smart_Data *sd EINA_UNUSED)
|
2014-02-18 06:40:48 -08:00
|
|
|
{
|
2017-08-30 23:57:53 -07:00
|
|
|
// Forward to closest parent Window
|
2014-02-18 06:40:48 -08:00
|
|
|
const Evas_Object *win = elm_widget_top_get(obj);
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
if (win && efl_isa(win, EFL_UI_WIN_CLASS))
|
2014-02-18 06:40:48 -08:00
|
|
|
return elm_win_focus_highlight_enabled_get(win);
|
2017-08-30 23:57:53 -07:00
|
|
|
|
2014-02-18 06:40:48 -08:00
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2017-08-30 23:57:53 -07:00
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_focus_highlight_enabled_set(Eo *obj, Elm_Widget_Smart_Data *sd EINA_UNUSED, Eina_Bool enable)
|
2017-08-30 23:57:53 -07:00
|
|
|
{
|
|
|
|
// Forward to closest parent Window
|
|
|
|
Evas_Object *win = elm_widget_top_get(obj);
|
|
|
|
|
|
|
|
if (win && efl_isa(win, EFL_UI_WIN_CLASS))
|
|
|
|
elm_win_focus_highlight_enabled_set(win, enable);
|
|
|
|
}
|
|
|
|
|
2017-08-31 00:08:10 -07:00
|
|
|
EOLIAN static Eina_Bool
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_focus_highlight_animate_get(const Eo *obj, Elm_Widget_Smart_Data *sd EINA_UNUSED)
|
2017-08-31 00:08:10 -07:00
|
|
|
{
|
|
|
|
// Forward to closest parent Window
|
|
|
|
const Evas_Object *win = elm_widget_top_get(obj);
|
|
|
|
|
|
|
|
if (win && efl_isa(win, EFL_UI_WIN_CLASS))
|
|
|
|
return elm_win_focus_highlight_animate_get(win);
|
|
|
|
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_focus_highlight_animate_set(Eo *obj, Elm_Widget_Smart_Data *sd EINA_UNUSED, Eina_Bool enable)
|
2017-08-31 00:08:10 -07:00
|
|
|
{
|
|
|
|
// Forward to closest parent Window
|
|
|
|
Evas_Object *win = elm_widget_top_get(obj);
|
|
|
|
|
|
|
|
if (win && efl_isa(win, EFL_UI_WIN_CLASS))
|
|
|
|
elm_win_focus_highlight_animate_set(win, enable);
|
|
|
|
}
|
|
|
|
|
2017-08-31 00:10:43 -07:00
|
|
|
EOLIAN static Eina_Bool
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_focus_highlight_style_set(Eo *obj, Elm_Widget_Smart_Data *sd EINA_UNUSED, const char *style)
|
2017-08-31 00:10:43 -07:00
|
|
|
{
|
|
|
|
// Forward to closest parent Window
|
|
|
|
Evas_Object *win = elm_widget_top_get(obj);
|
|
|
|
|
|
|
|
if (win && efl_isa(win, EFL_UI_WIN_CLASS))
|
2017-10-23 22:03:46 -07:00
|
|
|
return efl_ui_widget_focus_highlight_style_set(win, style);
|
2017-08-31 00:10:43 -07:00
|
|
|
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static const char *
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_focus_highlight_style_get(const Eo *obj, Elm_Widget_Smart_Data *sd EINA_UNUSED)
|
2017-08-31 00:10:43 -07:00
|
|
|
{
|
|
|
|
// Forward to closest parent Window
|
|
|
|
Evas_Object *win = elm_widget_top_get(obj);
|
|
|
|
|
|
|
|
if (win && efl_isa(win, EFL_UI_WIN_CLASS))
|
|
|
|
return elm_win_focus_highlight_style_get(win);
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2017-07-18 07:13:57 -07:00
|
|
|
static Eina_Bool
|
2018-11-20 09:20:36 -08:00
|
|
|
_candidacy_exam(Eo *obj)
|
2017-07-18 07:13:57 -07:00
|
|
|
{
|
2018-11-20 11:57:12 -08:00
|
|
|
Eina_List *lst;
|
2018-11-20 09:20:36 -08:00
|
|
|
Efl_Ui_Widget *wid = obj, *top;
|
2018-11-20 11:57:12 -08:00
|
|
|
Elm_Widget_Smart_Data *wid_pd;
|
2017-07-18 07:13:57 -07:00
|
|
|
|
2018-11-20 11:57:12 -08:00
|
|
|
wid_pd = efl_data_scope_get(wid, MY_CLASS);
|
2017-07-18 07:13:57 -07:00
|
|
|
do {
|
|
|
|
|
|
|
|
if (wid_pd->disabled) return EINA_TRUE;
|
2018-11-19 13:30:25 -08:00
|
|
|
if (wid_pd->tree_unfocusable) return EINA_TRUE;
|
2018-11-20 09:20:36 -08:00
|
|
|
top = wid;
|
2018-11-20 11:57:12 -08:00
|
|
|
|
|
|
|
wid = elm_widget_parent_get(wid);
|
|
|
|
if (!wid) break;
|
|
|
|
wid_pd = efl_data_scope_get(wid, MY_CLASS);
|
|
|
|
|
|
|
|
lst = wid_pd->legacy_focus.custom_chain;
|
|
|
|
if (lst)
|
|
|
|
{
|
|
|
|
if (!eina_list_data_find(lst, top))
|
|
|
|
{
|
|
|
|
WRN("Widget %p disabled due to custom chain of %p", top, wid);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
} while (1);
|
2017-07-18 07:13:57 -07:00
|
|
|
|
2018-11-20 09:20:36 -08:00
|
|
|
return !efl_isa(top, EFL_UI_WIN_CLASS);
|
2017-07-18 07:13:57 -07:00
|
|
|
}
|
2016-12-07 07:59:13 -08:00
|
|
|
|
|
|
|
static void _full_eval(Eo *obj, Elm_Widget_Smart_Data *pd);
|
|
|
|
|
2016-11-19 03:46:21 -08:00
|
|
|
static void
|
2016-12-07 07:59:13 -08:00
|
|
|
_manager_changed_cb(void *data, const Efl_Event *event EINA_UNUSED)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_DATA_GET(data, pd);
|
|
|
|
|
|
|
|
_full_eval(data, pd);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Efl_Ui_Focus_Object*
|
2016-11-19 03:46:21 -08:00
|
|
|
_focus_manager_eval(Eo *obj, Elm_Widget_Smart_Data *pd)
|
|
|
|
{
|
2016-12-07 07:59:13 -08:00
|
|
|
Evas_Object *provider = NULL;
|
|
|
|
Evas_Object *parent;
|
|
|
|
Efl_Ui_Focus_Manager *new = NULL, *old = NULL;
|
2016-11-19 03:46:21 -08:00
|
|
|
|
2016-12-07 07:59:13 -08:00
|
|
|
parent = elm_widget_parent_get(obj);
|
2017-07-05 03:48:52 -07:00
|
|
|
if (efl_isa(parent, EFL_UI_FOCUS_MANAGER_INTERFACE))
|
2016-11-19 03:46:21 -08:00
|
|
|
{
|
2016-12-07 07:59:13 -08:00
|
|
|
new = parent;
|
|
|
|
}
|
2018-01-15 22:12:49 -08:00
|
|
|
else if (parent)
|
2016-12-07 07:59:13 -08:00
|
|
|
{
|
2018-01-16 12:17:11 -08:00
|
|
|
new = efl_ui_focus_object_focus_manager_get(parent);
|
2016-12-07 07:59:13 -08:00
|
|
|
provider = parent;
|
2016-11-19 03:46:21 -08:00
|
|
|
}
|
|
|
|
|
2016-12-07 07:59:13 -08:00
|
|
|
if (new != pd->manager.manager )
|
2016-11-19 03:46:21 -08:00
|
|
|
{
|
2016-12-07 07:59:13 -08:00
|
|
|
old = pd->manager.manager;
|
|
|
|
|
|
|
|
if (pd->manager.provider)
|
2019-02-21 12:35:34 -08:00
|
|
|
efl_event_callback_del(pd->manager.provider, EFL_UI_FOCUS_OBJECT_EVENT_FOCUS_MANAGER_CHANGED, _manager_changed_cb, obj);
|
2016-12-07 07:59:13 -08:00
|
|
|
|
|
|
|
pd->manager.manager = new;
|
|
|
|
pd->manager.provider = provider;
|
|
|
|
|
|
|
|
if (pd->manager.provider)
|
2019-02-21 12:35:34 -08:00
|
|
|
efl_event_callback_add(pd->manager.provider, EFL_UI_FOCUS_OBJECT_EVENT_FOCUS_MANAGER_CHANGED, _manager_changed_cb, obj);
|
2016-11-19 03:46:21 -08:00
|
|
|
}
|
2016-12-07 07:59:13 -08:00
|
|
|
|
|
|
|
return old;
|
|
|
|
}
|
|
|
|
|
2016-12-20 08:31:33 -08:00
|
|
|
EOLIAN static Eina_Bool
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_focus_state_apply(Eo *obj, Elm_Widget_Smart_Data *pd EINA_UNUSED, Efl_Ui_Widget_Focus_State current_state, Efl_Ui_Widget_Focus_State *configured_state, Efl_Ui_Widget *redirect)
|
2016-12-07 07:59:13 -08:00
|
|
|
{
|
2017-09-02 10:08:18 -07:00
|
|
|
Eina_Bool registered = EINA_TRUE;
|
2016-12-20 08:31:33 -08:00
|
|
|
|
2017-09-02 10:08:18 -07:00
|
|
|
//shortcut for having the same configurations
|
|
|
|
if (current_state.manager == configured_state->manager && !current_state.manager)
|
|
|
|
return !!current_state.manager;
|
|
|
|
|
|
|
|
if (configured_state->logical == current_state.logical &&
|
|
|
|
configured_state->manager == current_state.manager &&
|
|
|
|
configured_state->parent == current_state.parent)
|
|
|
|
return !!current_state.manager;
|
2016-11-19 03:46:21 -08:00
|
|
|
|
2017-09-02 10:08:18 -07:00
|
|
|
//this thing doesnt want to be registered, but it is ...
|
|
|
|
if (!configured_state->manager && current_state.manager)
|
|
|
|
{
|
|
|
|
efl_ui_focus_manager_calc_unregister(current_state.manager, obj);
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
//by that point we have always a configured manager
|
|
|
|
|
|
|
|
if (!current_state.manager) registered = EINA_FALSE;
|
|
|
|
|
2018-01-15 22:12:49 -08:00
|
|
|
if ((//check if we have changed the manager
|
|
|
|
(current_state.manager != configured_state->manager) ||
|
|
|
|
//check if we are already registered but in a different state
|
|
|
|
(current_state.logical != configured_state->logical))
|
|
|
|
&& registered)
|
2017-09-02 10:08:18 -07:00
|
|
|
{
|
|
|
|
//we need to unregister here
|
|
|
|
efl_ui_focus_manager_calc_unregister(current_state.manager, obj);
|
|
|
|
registered = EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2017-10-19 04:47:15 -07:00
|
|
|
//the parent may has changed
|
|
|
|
if (current_state.parent != configured_state->parent && registered)
|
|
|
|
{
|
|
|
|
return efl_ui_focus_manager_calc_update_parent(current_state.manager, obj, configured_state->parent);
|
|
|
|
}
|
|
|
|
|
2017-09-02 10:08:18 -07:00
|
|
|
if (!registered)
|
|
|
|
{
|
|
|
|
if (configured_state->logical)
|
|
|
|
return efl_ui_focus_manager_calc_register_logical(configured_state->manager, obj, configured_state->parent, redirect);
|
|
|
|
else
|
|
|
|
return efl_ui_focus_manager_calc_register(configured_state->manager, obj, configured_state->parent, redirect);
|
|
|
|
}
|
|
|
|
ERR("Uncaught focus state consider this as unregistered (%d) \n (%p,%p,%d) \n (%p,%p,%d) ", registered,
|
|
|
|
configured_state->manager, configured_state->parent, configured_state->logical,
|
|
|
|
current_state.manager, current_state.parent, current_state.logical
|
|
|
|
);
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
2016-11-04 09:43:40 -07:00
|
|
|
static void
|
2017-10-17 06:17:50 -07:00
|
|
|
_eval_registration_candidate(Eo *obj, Elm_Widget_Smart_Data *pd, Eina_Bool *should, Eina_Bool *want_full)
|
2016-11-04 09:43:40 -07:00
|
|
|
{
|
2017-10-17 06:17:50 -07:00
|
|
|
*should = *want_full = EINA_FALSE;
|
2017-10-17 07:14:07 -07:00
|
|
|
|
2017-12-05 00:57:44 -08:00
|
|
|
//can focus can be overridden by the following properties
|
2018-11-20 08:49:40 -08:00
|
|
|
if ((!pd->parent_obj) ||
|
|
|
|
(!evas_object_visible_get(obj)) ||
|
2018-11-20 11:57:12 -08:00
|
|
|
(_candidacy_exam(obj)))
|
2017-12-05 00:57:44 -08:00
|
|
|
return;
|
|
|
|
|
2017-10-17 06:17:50 -07:00
|
|
|
if (pd->can_focus)
|
|
|
|
{
|
2017-12-05 00:57:44 -08:00
|
|
|
*should = *want_full = EINA_TRUE;
|
|
|
|
}
|
|
|
|
else if (pd->logical.child_count > 0)
|
|
|
|
{
|
|
|
|
*should = EINA_TRUE;
|
|
|
|
}
|
2017-10-17 06:17:50 -07:00
|
|
|
}
|
2016-11-16 10:01:30 -08:00
|
|
|
|
2017-10-17 06:17:50 -07:00
|
|
|
static void
|
|
|
|
_focus_state_eval(Eo *obj, Elm_Widget_Smart_Data *pd, Eina_Bool should, Eina_Bool want_full)
|
|
|
|
{
|
2017-12-11 19:01:46 -08:00
|
|
|
Efl_Ui_Widget_Focus_State configuration;
|
2017-10-17 06:17:50 -07:00
|
|
|
|
|
|
|
//this would mean we are registering again the root, we dont want that
|
|
|
|
if (pd->manager.manager == obj) return;
|
|
|
|
|
|
|
|
//there are two reasons to be registered, the child count is bigger than 0, or the widget is flagged to be able to handle focus
|
2017-09-02 10:08:18 -07:00
|
|
|
if (should)
|
2016-12-07 07:59:13 -08:00
|
|
|
{
|
2017-09-02 10:08:18 -07:00
|
|
|
configuration.parent = pd->logical.parent;
|
|
|
|
configuration.manager = pd->manager.manager;
|
|
|
|
configuration.logical = !want_full;
|
2016-12-07 07:59:13 -08:00
|
|
|
}
|
2017-09-02 10:08:18 -07:00
|
|
|
else
|
2016-11-04 09:43:40 -07:00
|
|
|
{
|
2017-09-02 10:08:18 -07:00
|
|
|
configuration.parent = NULL;
|
|
|
|
configuration.manager = NULL;
|
|
|
|
configuration.logical = EINA_FALSE;
|
2016-11-04 09:43:40 -07:00
|
|
|
}
|
2017-09-02 10:08:18 -07:00
|
|
|
|
2017-10-23 22:03:46 -07:00
|
|
|
if (!efl_ui_widget_focus_state_apply(obj, pd->focus, &configuration, NULL))
|
2016-11-04 09:43:40 -07:00
|
|
|
{
|
2017-09-02 10:08:18 -07:00
|
|
|
//things went wrong or this thing is unregistered. Purge the current configuration.
|
2016-11-04 09:43:40 -07:00
|
|
|
pd->focus.manager = NULL;
|
2017-07-24 14:35:26 -07:00
|
|
|
pd->focus.parent = NULL;
|
2017-09-02 10:08:18 -07:00
|
|
|
pd->focus.logical = EINA_FALSE;
|
2016-11-04 09:43:40 -07:00
|
|
|
}
|
2017-09-02 10:08:18 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
pd->focus.parent = configuration.parent;
|
|
|
|
pd->focus.manager = configuration.manager;
|
|
|
|
pd->focus.logical = configuration.logical;
|
|
|
|
}
|
|
|
|
|
2016-11-04 09:43:40 -07:00
|
|
|
}
|
|
|
|
|
2016-12-07 07:59:13 -08:00
|
|
|
static Efl_Ui_Focus_Object*
|
2017-10-17 06:57:37 -07:00
|
|
|
_logical_parent_eval(Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *pd, Eina_Bool should)
|
2016-11-19 03:46:21 -08:00
|
|
|
{
|
2018-01-07 20:55:35 -08:00
|
|
|
Efl_Ui_Widget *parent;
|
2017-10-15 06:26:22 -07:00
|
|
|
Efl_Ui_Focus_Parent_Provider *provider;
|
2017-10-12 12:25:49 -07:00
|
|
|
|
2017-10-17 06:57:37 -07:00
|
|
|
if (should)
|
|
|
|
{
|
|
|
|
provider = efl_provider_find(obj, EFL_UI_FOCUS_PARENT_PROVIDER_INTERFACE);
|
2017-10-17 08:19:12 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(provider, NULL);
|
2017-10-17 06:57:37 -07:00
|
|
|
parent = efl_ui_focus_parent_provider_find_logical_parent(provider, obj);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
parent = NULL;
|
2017-10-15 06:26:22 -07:00
|
|
|
|
2017-10-12 12:25:49 -07:00
|
|
|
|
2016-11-19 03:46:21 -08:00
|
|
|
if (pd->logical.parent != parent)
|
|
|
|
{
|
2016-12-07 07:59:13 -08:00
|
|
|
Efl_Ui_Focus_Object *old = NULL;
|
|
|
|
|
2016-11-19 03:46:21 -08:00
|
|
|
//update old logical parent;
|
|
|
|
if (pd->logical.parent)
|
|
|
|
{
|
2018-01-07 20:55:35 -08:00
|
|
|
if (efl_isa(pd->logical.parent, EFL_UI_WIDGET_CLASS))
|
2016-12-07 07:59:13 -08:00
|
|
|
{
|
2017-10-15 06:30:08 -07:00
|
|
|
ELM_WIDGET_DATA_GET(pd->logical.parent, logical_wd);
|
|
|
|
if (!logical_wd)
|
|
|
|
{
|
|
|
|
ERR("Widget parent has the wrong type!");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
logical_wd->logical.child_count --;
|
2016-12-07 07:59:13 -08:00
|
|
|
}
|
|
|
|
old = pd->logical.parent;
|
2017-08-23 21:29:39 -07:00
|
|
|
efl_weak_unref(&pd->logical.parent);
|
2016-11-19 03:46:21 -08:00
|
|
|
pd->logical.parent = NULL;
|
|
|
|
}
|
2016-12-07 07:59:13 -08:00
|
|
|
if (parent)
|
2016-11-19 03:46:21 -08:00
|
|
|
{
|
2018-01-07 20:55:35 -08:00
|
|
|
if (efl_isa(parent, EFL_UI_WIDGET_CLASS))
|
2016-12-07 07:59:13 -08:00
|
|
|
{
|
2017-10-15 06:30:08 -07:00
|
|
|
ELM_WIDGET_DATA_GET(parent, parent_wd);
|
|
|
|
if (!parent_wd)
|
|
|
|
{
|
|
|
|
ERR("Widget parent has the wrong type!");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
parent_wd->logical.child_count ++;
|
2016-12-07 07:59:13 -08:00
|
|
|
}
|
2016-11-19 03:46:21 -08:00
|
|
|
pd->logical.parent = parent;
|
|
|
|
efl_weak_ref(&pd->logical.parent);
|
|
|
|
}
|
2016-12-07 07:59:13 -08:00
|
|
|
return old;
|
2016-11-19 03:46:21 -08:00
|
|
|
}
|
2016-12-07 07:59:13 -08:00
|
|
|
return NULL;
|
2016-11-19 03:46:21 -08:00
|
|
|
}
|
2016-12-07 07:59:13 -08:00
|
|
|
|
|
|
|
static void
|
|
|
|
_full_eval(Eo *obj, Elm_Widget_Smart_Data *pd)
|
|
|
|
{
|
2017-07-26 06:52:12 -07:00
|
|
|
Efl_Ui_Focus_Object *old_parent;
|
2017-07-24 14:35:26 -07:00
|
|
|
Efl_Ui_Focus_Object *old_registered_parent, *old_registered_manager;
|
2017-10-17 06:17:50 -07:00
|
|
|
Eina_Bool should, want_full;
|
|
|
|
|
2017-10-17 06:57:37 -07:00
|
|
|
|
2017-10-17 06:17:50 -07:00
|
|
|
_eval_registration_candidate(obj, pd, &should, &want_full);
|
2016-12-07 07:59:13 -08:00
|
|
|
|
2017-10-17 06:57:37 -07:00
|
|
|
old_parent = _logical_parent_eval(obj, pd, should);
|
2016-12-07 07:59:13 -08:00
|
|
|
|
2018-01-07 20:55:35 -08:00
|
|
|
if (efl_isa(old_parent, EFL_UI_WIDGET_CLASS))
|
2016-12-07 07:59:13 -08:00
|
|
|
{
|
|
|
|
//emit signal and focus eval old and new
|
|
|
|
ELM_WIDGET_DATA_GET(old_parent, old_pd);
|
2017-09-01 08:58:41 -07:00
|
|
|
_full_eval(old_parent, old_pd);
|
2016-12-07 07:59:13 -08:00
|
|
|
}
|
|
|
|
|
2018-01-07 20:55:35 -08:00
|
|
|
if (efl_isa(pd->logical.parent, EFL_UI_WIDGET_CLASS))
|
2016-12-07 07:59:13 -08:00
|
|
|
{
|
|
|
|
ELM_WIDGET_DATA_GET(pd->logical.parent, new_pd);
|
2017-09-01 08:58:41 -07:00
|
|
|
_full_eval(pd->logical.parent, new_pd);
|
2016-12-07 07:59:13 -08:00
|
|
|
}
|
|
|
|
|
2017-09-18 05:23:52 -07:00
|
|
|
_focus_manager_eval(obj, pd);
|
|
|
|
|
2017-07-24 14:35:26 -07:00
|
|
|
old_registered_parent = pd->focus.parent;
|
|
|
|
old_registered_manager = pd->focus.manager;
|
|
|
|
|
2017-10-17 06:17:50 -07:00
|
|
|
_focus_state_eval(obj, pd, should, want_full);
|
2017-07-24 08:58:13 -07:00
|
|
|
|
2017-07-24 14:35:26 -07:00
|
|
|
if (old_registered_parent != pd->focus.parent)
|
2016-12-07 07:59:13 -08:00
|
|
|
{
|
|
|
|
efl_event_callback_call(obj,
|
2019-02-21 12:35:34 -08:00
|
|
|
EFL_UI_FOCUS_OBJECT_EVENT_FOCUS_PARENT_CHANGED, old_registered_parent);
|
2016-12-07 07:59:13 -08:00
|
|
|
}
|
|
|
|
|
2017-07-24 14:35:26 -07:00
|
|
|
if (old_registered_manager != pd->focus.manager)
|
2016-12-07 07:59:13 -08:00
|
|
|
{
|
|
|
|
efl_event_callback_call(obj,
|
2019-02-21 12:35:34 -08:00
|
|
|
EFL_UI_FOCUS_OBJECT_EVENT_FOCUS_MANAGER_CHANGED, old_registered_manager);
|
2016-12-07 07:59:13 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-11-10 06:15:57 -08:00
|
|
|
void
|
|
|
|
_elm_widget_full_eval(Eo *obj)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_DATA_GET(obj, pd);
|
|
|
|
|
|
|
|
_full_eval(obj, pd);
|
|
|
|
}
|
|
|
|
|
2012-08-30 09:47:10 -07:00
|
|
|
/**
|
|
|
|
* @internal
|
2013-01-26 01:55:18 -08:00
|
|
|
*
|
2012-08-30 09:47:10 -07:00
|
|
|
* Resets the mirrored mode from the system mirror mode for widgets that are in
|
|
|
|
* automatic mirroring mode. This function does not call elm_widget_theme.
|
|
|
|
*
|
|
|
|
* @param obj The widget.
|
|
|
|
* @param mirrored EINA_TRUE to set mirrored mode. EINA_FALSE to unset.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
_elm_widget_mirrored_reload(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return;
|
|
|
|
Eina_Bool mirrored = elm_config_mirrored_get();
|
|
|
|
|
2017-06-14 19:12:00 -07:00
|
|
|
if (efl_ui_mirrored_automatic_get(obj) && (sd->is_mirrored != mirrored))
|
2012-08-30 09:47:10 -07:00
|
|
|
{
|
|
|
|
sd->is_mirrored = mirrored;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_parents_focus(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
for (; obj; obj = elm_widget_parent_get(obj))
|
|
|
|
{
|
|
|
|
INTERNAL_ENTRY;
|
|
|
|
if (sd->focused) return;
|
|
|
|
sd->focused = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_parents_unfocus(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
for (; obj; obj = elm_widget_parent_get(obj))
|
|
|
|
{
|
|
|
|
INTERNAL_ENTRY;
|
|
|
|
if (!sd->focused) return;
|
|
|
|
sd->focused = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-20 07:31:31 -07:00
|
|
|
static void
|
2016-08-30 05:34:10 -07:00
|
|
|
_on_sub_obj_del(void *data, const Efl_Event *event)
|
2012-08-30 09:47:10 -07:00
|
|
|
{
|
2016-07-05 06:55:16 -07:00
|
|
|
ELM_WIDGET_DATA_GET_OR_RETURN(data, sd);
|
2012-08-30 09:47:10 -07:00
|
|
|
|
2016-05-18 08:17:36 -07:00
|
|
|
if (_elm_widget_is(event->object))
|
2012-08-30 09:47:10 -07:00
|
|
|
{
|
2016-05-18 08:17:36 -07:00
|
|
|
if (_is_focused(event->object)) _parents_unfocus(sd->obj);
|
2012-08-30 09:47:10 -07:00
|
|
|
}
|
2016-05-18 08:17:36 -07:00
|
|
|
if (event->object == sd->resize_obj)
|
2012-08-30 09:47:10 -07:00
|
|
|
{
|
|
|
|
/* already dels sub object */
|
2017-08-08 05:06:43 -07:00
|
|
|
elm_widget_resize_object_set(sd->obj, NULL);
|
2012-08-30 09:47:10 -07:00
|
|
|
}
|
2016-05-18 08:17:36 -07:00
|
|
|
else if (event->object == sd->hover_obj)
|
2012-08-30 09:47:10 -07:00
|
|
|
{
|
|
|
|
sd->hover_obj = NULL;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-05-18 08:17:36 -07:00
|
|
|
if (!elm_widget_sub_object_del(sd->obj, event->object))
|
|
|
|
ERR("failed to remove sub object %p from %p\n", event->object, sd->obj);
|
2012-08-30 09:47:10 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
static const Evas_Smart_Cb_Description _smart_callbacks[] =
|
|
|
|
{
|
2015-02-08 17:40:29 -08:00
|
|
|
{SIG_WIDGET_FOCUSED, ""},
|
|
|
|
{SIG_WIDGET_UNFOCUSED, ""},
|
|
|
|
{SIG_WIDGET_LANG_CHANGED, ""},
|
|
|
|
{SIG_WIDGET_ACCESS_CHANGED, ""},
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
{NULL, NULL}
|
|
|
|
};
|
|
|
|
|
2013-07-11 01:47:25 -07:00
|
|
|
static void
|
|
|
|
_obj_mouse_down(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas *e EINA_UNUSED,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
2013-07-11 01:47:25 -07:00
|
|
|
void *event_info)
|
|
|
|
{
|
2016-08-26 21:48:35 -07:00
|
|
|
Evas_Object *top;
|
|
|
|
|
2013-07-11 01:47:25 -07:00
|
|
|
ELM_WIDGET_DATA_GET(data, sd);
|
|
|
|
Evas_Event_Mouse_Down *ev = event_info;
|
2016-08-30 17:36:52 -07:00
|
|
|
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return;
|
2016-08-26 21:48:35 -07:00
|
|
|
|
|
|
|
top = elm_widget_top_get(data);
|
|
|
|
if (top && efl_isa(top, EFL_UI_WIN_CLASS)) _elm_win_focus_auto_hide(top);
|
|
|
|
sd->still_in = EINA_TRUE;
|
2013-07-11 01:47:25 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_obj_mouse_move(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas *e EINA_UNUSED,
|
2013-07-11 01:47:25 -07:00
|
|
|
Evas_Object *obj,
|
|
|
|
void *event_info)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_DATA_GET(data, sd);
|
|
|
|
Evas_Event_Mouse_Move *ev = event_info;
|
2014-02-28 22:50:07 -08:00
|
|
|
if (!sd->still_in) return;
|
|
|
|
|
|
|
|
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
|
|
|
|
sd->still_in = EINA_FALSE;
|
|
|
|
else
|
2013-07-11 01:47:25 -07:00
|
|
|
{
|
2014-02-28 22:50:07 -08:00
|
|
|
Evas_Coord x, y, w, h;
|
|
|
|
evas_object_geometry_get(obj, &x, &y, &w, &h);
|
|
|
|
if (ELM_RECTS_POINT_OUT(x, y, w, h, ev->cur.canvas.x, ev->cur.canvas.y))
|
2013-07-11 01:47:25 -07:00
|
|
|
sd->still_in = EINA_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_obj_mouse_up(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas *e EINA_UNUSED,
|
2013-07-11 01:47:25 -07:00
|
|
|
Evas_Object *obj,
|
2016-01-24 07:11:13 -08:00
|
|
|
void *event_info)
|
2013-07-11 01:47:25 -07:00
|
|
|
{
|
|
|
|
ELM_WIDGET_DATA_GET(data, sd);
|
2016-01-24 07:11:13 -08:00
|
|
|
Evas_Event_Mouse_Up *ev = event_info;
|
|
|
|
|
|
|
|
if (sd->still_in && (ev->flags == EVAS_BUTTON_NONE) &&
|
2015-06-01 21:42:00 -07:00
|
|
|
(sd->focus_move_policy == ELM_FOCUS_MOVE_POLICY_CLICK))
|
2017-08-30 19:27:49 -07:00
|
|
|
elm_widget_focus_mouse_up_handle(evas_object_widget_parent_find(obj));
|
2014-03-20 07:50:46 -07:00
|
|
|
|
2013-07-11 01:47:25 -07:00
|
|
|
sd->still_in = EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2014-03-20 07:50:46 -07:00
|
|
|
static void
|
2015-06-01 21:42:00 -07:00
|
|
|
_obj_mouse_in(void *data,
|
2014-03-20 07:50:46 -07:00
|
|
|
Evas *e EINA_UNUSED,
|
|
|
|
Evas_Object *obj,
|
|
|
|
void *event_info EINA_UNUSED)
|
|
|
|
{
|
2015-06-01 21:42:00 -07:00
|
|
|
ELM_WIDGET_DATA_GET(data, sd);
|
|
|
|
if (sd->focus_move_policy == ELM_FOCUS_MOVE_POLICY_IN)
|
2017-08-30 19:27:49 -07:00
|
|
|
elm_widget_focus_mouse_up_handle(evas_object_widget_parent_find(obj));
|
2014-03-20 07:50:46 -07:00
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_efl_canvas_group_group_add(Eo *obj, Elm_Widget_Smart_Data *priv)
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
{
|
2012-05-03 15:41:15 -07:00
|
|
|
|
2012-08-30 09:47:10 -07:00
|
|
|
priv->obj = obj;
|
|
|
|
priv->mirrored_auto_mode = EINA_TRUE; /* will follow system locale
|
|
|
|
* settings */
|
2016-03-18 00:38:26 -07:00
|
|
|
priv->focus_move_policy_auto_mode = EINA_TRUE;
|
2015-08-12 01:25:15 -07:00
|
|
|
priv->focus_region_show_mode = ELM_FOCUS_REGION_SHOW_WIDGET;
|
2012-08-30 09:47:10 -07:00
|
|
|
elm_widget_can_focus_set(obj, EINA_TRUE);
|
2013-12-31 03:33:51 -08:00
|
|
|
priv->is_mirrored = elm_config_mirrored_get();
|
2015-06-01 21:42:00 -07:00
|
|
|
priv->focus_move_policy = _elm_config->focus_move_policy;
|
2012-05-03 15:41:09 -07:00
|
|
|
|
2013-07-11 01:47:25 -07:00
|
|
|
evas_object_event_callback_add(obj, EVAS_CALLBACK_MOUSE_DOWN,
|
|
|
|
_obj_mouse_down, obj);
|
|
|
|
evas_object_event_callback_add(obj, EVAS_CALLBACK_MOUSE_MOVE,
|
|
|
|
_obj_mouse_move, obj);
|
|
|
|
evas_object_event_callback_add(obj, EVAS_CALLBACK_MOUSE_UP,
|
|
|
|
_obj_mouse_up, obj);
|
2014-03-20 07:50:46 -07:00
|
|
|
evas_object_event_callback_add(obj, EVAS_CALLBACK_MOUSE_IN,
|
|
|
|
_obj_mouse_in, obj);
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_efl_canvas_group_group_del(Eo *obj, Elm_Widget_Smart_Data *sd)
|
2008-10-07 23:38:20 -07:00
|
|
|
{
|
2012-08-30 09:47:10 -07:00
|
|
|
Evas_Object *sobj;
|
|
|
|
Elm_Translate_String_Data *ts;
|
|
|
|
Elm_Event_Cb_Data *ecb;
|
2009-10-17 23:03:03 -07:00
|
|
|
|
2012-08-30 09:47:10 -07:00
|
|
|
if (sd->hover_obj)
|
2012-05-22 00:05:07 -07:00
|
|
|
{
|
2012-08-30 09:47:10 -07:00
|
|
|
/* detach it from us */
|
2014-07-06 10:08:56 -07:00
|
|
|
_callbacks_del(sd->hover_obj, obj);
|
2012-08-30 09:47:10 -07:00
|
|
|
sd->hover_obj = NULL;
|
2012-05-22 00:05:07 -07:00
|
|
|
}
|
2012-08-30 09:47:10 -07:00
|
|
|
|
|
|
|
while (sd->subobjs)
|
2012-05-22 00:05:07 -07:00
|
|
|
{
|
2012-08-30 09:47:10 -07:00
|
|
|
sobj = eina_list_data_get(sd->subobjs);
|
|
|
|
|
|
|
|
/* let the objects clean-up themselves and get rid of this list */
|
|
|
|
if (!elm_widget_sub_object_del(obj, sobj))
|
|
|
|
{
|
|
|
|
ERR("failed to remove sub object %p from %p\n", sobj, obj);
|
|
|
|
sd->subobjs = eina_list_remove_list
|
|
|
|
(sd->subobjs, sd->subobjs);
|
|
|
|
}
|
2018-05-07 15:16:29 -07:00
|
|
|
// FIXME: is that a legacy or a new object ?
|
2012-08-30 09:47:10 -07:00
|
|
|
evas_object_del(sobj);
|
2012-05-22 00:05:07 -07:00
|
|
|
}
|
2012-08-30 09:47:10 -07:00
|
|
|
sd->tooltips = eina_list_free(sd->tooltips); /* should be empty anyway */
|
|
|
|
sd->cursors = eina_list_free(sd->cursors); /* should be empty anyway */
|
2013-07-16 23:05:40 -07:00
|
|
|
while (sd->translate_strings)
|
2012-05-03 15:41:09 -07:00
|
|
|
{
|
2013-07-16 23:05:40 -07:00
|
|
|
ts = EINA_INLIST_CONTAINER_GET(sd->translate_strings,
|
|
|
|
Elm_Translate_String_Data);
|
2012-08-30 09:47:10 -07:00
|
|
|
eina_stringshare_del(ts->id);
|
|
|
|
eina_stringshare_del(ts->domain);
|
|
|
|
eina_stringshare_del(ts->string);
|
2013-07-16 23:05:40 -07:00
|
|
|
sd->translate_strings = eina_inlist_remove(sd->translate_strings,
|
|
|
|
sd->translate_strings);
|
2012-08-30 09:47:10 -07:00
|
|
|
free(ts);
|
2012-05-03 15:41:09 -07:00
|
|
|
}
|
2008-10-07 23:38:20 -07:00
|
|
|
|
2013-03-08 20:23:42 -08:00
|
|
|
EINA_LIST_FREE(sd->event_cb, ecb)
|
2014-01-21 23:24:25 -08:00
|
|
|
free(ecb);
|
2012-08-30 09:47:10 -07:00
|
|
|
|
2017-11-14 01:42:48 -08:00
|
|
|
eina_stringshare_del(sd->klass);
|
|
|
|
eina_stringshare_del(sd->group);
|
2014-01-21 17:12:44 -08:00
|
|
|
eina_stringshare_del(sd->style);
|
2012-08-30 09:47:10 -07:00
|
|
|
if (sd->theme) elm_theme_free(sd->theme);
|
2014-01-21 17:12:44 -08:00
|
|
|
eina_stringshare_del(sd->access_info);
|
2016-11-09 17:58:41 -08:00
|
|
|
eina_stringshare_del(sd->accessible_name);
|
2012-08-30 09:47:10 -07:00
|
|
|
evas_object_smart_data_set(obj, NULL);
|
2017-02-15 03:07:11 -08:00
|
|
|
efl_canvas_group_del(efl_super(obj, MY_CLASS));
|
2012-08-30 09:47:10 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_smart_reconfigure(Elm_Widget_Smart_Data *sd)
|
2011-03-19 08:13:14 -07:00
|
|
|
{
|
2012-08-30 09:47:10 -07:00
|
|
|
if (sd->resize_obj)
|
|
|
|
{
|
2018-11-21 07:33:49 -08:00
|
|
|
evas_object_geometry_set(sd->resize_obj, sd->x, sd->y, sd->w, sd->h);
|
2012-08-30 09:47:10 -07:00
|
|
|
}
|
|
|
|
if (sd->hover_obj)
|
|
|
|
{
|
2018-11-21 07:33:49 -08:00
|
|
|
evas_object_geometry_set(sd->hover_obj, sd->x, sd->y, sd->w, sd->h);
|
2012-08-30 09:47:10 -07:00
|
|
|
}
|
2017-11-23 21:41:31 -08:00
|
|
|
if (sd->bg)
|
|
|
|
{
|
2018-11-21 07:33:49 -08:00
|
|
|
evas_object_geometry_set(sd->bg, sd->x, sd->y, sd->w, sd->h);
|
2017-11-23 21:41:31 -08:00
|
|
|
}
|
2017-12-14 00:25:37 -08:00
|
|
|
if (sd->has_shadow)
|
|
|
|
_elm_widget_shadow_update(sd->obj);
|
2012-08-30 09:47:10 -07:00
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static void
|
2018-04-05 01:47:26 -07:00
|
|
|
_efl_ui_widget_efl_gfx_entity_position_set(Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *sd, Eina_Position2D pos)
|
2012-08-30 09:47:10 -07:00
|
|
|
{
|
2017-09-14 20:14:32 -07:00
|
|
|
if (_evas_object_intercept_call(obj, EVAS_OBJECT_INTERCEPT_CB_MOVE, 0, pos.x, pos.y))
|
2016-10-10 20:39:05 -07:00
|
|
|
return;
|
|
|
|
|
2017-09-14 20:14:32 -07:00
|
|
|
sd->x = pos.x;
|
|
|
|
sd->y = pos.y;
|
2012-08-30 09:47:10 -07:00
|
|
|
_smart_reconfigure(sd);
|
evas/elm: Remove function group_resize
This is an override of efl_gfx_size_set. Same as before, the
order of operations matter so it is possible that a corner
case will break. In particular, legacy code was:
- intercept
- smart resize (do stuff), super, super, super
- evas object resize
The new code is more like:
- intercept
- super, super, super, evas object resize
- do stuff
But unfortunately this broke elm_widget (read: all widgets) as
the internal resize was done before the object resize. So,
inside the resize event cb, the resize_obj size would not match
the smart object size. >_<
2016-10-11 00:54:31 -07:00
|
|
|
|
2018-04-05 01:47:26 -07:00
|
|
|
efl_gfx_entity_position_set(efl_super(obj, MY_CLASS), pos);
|
2012-08-30 09:47:10 -07:00
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static void
|
2018-04-05 01:47:26 -07:00
|
|
|
_efl_ui_widget_efl_gfx_entity_size_set(Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *sd, Eina_Size2D sz)
|
2012-08-30 09:47:10 -07:00
|
|
|
{
|
2017-09-15 02:37:25 -07:00
|
|
|
if (_evas_object_intercept_call(obj, EVAS_OBJECT_INTERCEPT_CB_RESIZE, 0, sz.w, sz.h))
|
evas/elm: Remove function group_resize
This is an override of efl_gfx_size_set. Same as before, the
order of operations matter so it is possible that a corner
case will break. In particular, legacy code was:
- intercept
- smart resize (do stuff), super, super, super
- evas object resize
The new code is more like:
- intercept
- super, super, super, evas object resize
- do stuff
But unfortunately this broke elm_widget (read: all widgets) as
the internal resize was done before the object resize. So,
inside the resize event cb, the resize_obj size would not match
the smart object size. >_<
2016-10-11 00:54:31 -07:00
|
|
|
return;
|
|
|
|
|
2017-09-15 02:37:25 -07:00
|
|
|
sd->w = sz.w;
|
|
|
|
sd->h = sz.h;
|
2012-08-30 09:47:10 -07:00
|
|
|
_smart_reconfigure(sd);
|
evas/elm: Remove function group_resize
This is an override of efl_gfx_size_set. Same as before, the
order of operations matter so it is possible that a corner
case will break. In particular, legacy code was:
- intercept
- smart resize (do stuff), super, super, super
- evas object resize
The new code is more like:
- intercept
- super, super, super, evas object resize
- do stuff
But unfortunately this broke elm_widget (read: all widgets) as
the internal resize was done before the object resize. So,
inside the resize event cb, the resize_obj size would not match
the smart object size. >_<
2016-10-11 00:54:31 -07:00
|
|
|
|
2018-04-05 01:47:26 -07:00
|
|
|
efl_gfx_entity_size_set(efl_super(obj, MY_CLASS), sz);
|
2012-08-30 09:47:10 -07:00
|
|
|
}
|
|
|
|
|
2018-04-21 09:54:50 -07:00
|
|
|
void
|
|
|
|
_elm_widget_full_eval_children(Eo *obj, Elm_Widget_Smart_Data *sd)
|
2017-10-10 12:23:42 -07:00
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
Eo *child;
|
|
|
|
|
|
|
|
_full_eval(obj, sd);
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(sd->subobjs , l, child)
|
|
|
|
{
|
|
|
|
Elm_Widget_Smart_Data *sd_child;
|
|
|
|
|
2018-01-07 20:55:35 -08:00
|
|
|
if (!efl_isa(child, EFL_UI_WIDGET_CLASS)) continue;
|
2017-10-10 12:23:42 -07:00
|
|
|
|
2018-01-07 20:55:35 -08:00
|
|
|
sd_child = efl_data_scope_get(child, EFL_UI_WIDGET_CLASS);
|
2018-04-21 09:54:50 -07:00
|
|
|
_elm_widget_full_eval_children(child, sd_child);
|
2017-10-10 12:23:42 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static void
|
2018-04-05 01:47:26 -07:00
|
|
|
_efl_ui_widget_efl_gfx_entity_visible_set(Eo *obj, Elm_Widget_Smart_Data *pd, Eina_Bool vis)
|
2012-08-30 09:47:10 -07:00
|
|
|
{
|
2013-09-05 01:16:42 -07:00
|
|
|
Eina_Iterator *it;
|
2012-08-30 09:47:10 -07:00
|
|
|
Evas_Object *o;
|
|
|
|
|
2016-10-10 02:59:42 -07:00
|
|
|
if (_evas_object_intercept_call(obj, EVAS_OBJECT_INTERCEPT_CB_VISIBLE, 0, vis))
|
2017-09-18 05:21:38 -07:00
|
|
|
{
|
2018-04-21 09:54:50 -07:00
|
|
|
_elm_widget_full_eval_children(obj, pd);
|
2017-09-18 05:21:38 -07:00
|
|
|
return;
|
|
|
|
}
|
2016-10-10 02:59:42 -07:00
|
|
|
|
2018-04-05 01:47:26 -07:00
|
|
|
efl_gfx_entity_visible_set(efl_super(obj, MY_CLASS), vis);
|
2016-10-10 02:59:42 -07:00
|
|
|
|
2018-04-21 09:54:50 -07:00
|
|
|
_elm_widget_full_eval_children(obj, pd);
|
2016-12-20 08:31:33 -08:00
|
|
|
|
2017-09-18 05:21:38 -07:00
|
|
|
|
2013-09-05 01:16:42 -07:00
|
|
|
it = evas_object_smart_iterator_new(obj);
|
|
|
|
EINA_ITERATOR_FOREACH(it, o)
|
2012-08-30 09:47:10 -07:00
|
|
|
{
|
2013-09-05 01:16:42 -07:00
|
|
|
if (evas_object_data_get(o, "_elm_leaveme")) continue;
|
2018-04-05 01:47:26 -07:00
|
|
|
efl_gfx_entity_visible_set(o, vis);
|
2012-08-30 09:47:10 -07:00
|
|
|
}
|
2013-09-05 01:16:42 -07:00
|
|
|
eina_iterator_free(it);
|
2015-09-03 05:07:23 -07:00
|
|
|
|
2016-10-10 02:59:42 -07:00
|
|
|
if (!_elm_config->atspi_mode || pd->on_destroy)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (vis)
|
2015-09-03 05:07:23 -07:00
|
|
|
{
|
2017-10-18 18:13:54 -07:00
|
|
|
efl_access_added(obj);
|
2016-10-10 02:59:42 -07:00
|
|
|
if (_elm_widget_onscreen_is(obj))
|
2017-10-18 18:13:54 -07:00
|
|
|
efl_access_state_changed_signal_emit(obj, EFL_ACCESS_STATE_SHOWING, EINA_TRUE);
|
2015-09-03 05:07:23 -07:00
|
|
|
}
|
2016-10-10 02:59:42 -07:00
|
|
|
else
|
2012-08-30 09:47:10 -07:00
|
|
|
{
|
2017-10-18 18:13:54 -07:00
|
|
|
efl_access_state_changed_signal_emit(obj, EFL_ACCESS_STATE_SHOWING, EINA_FALSE);
|
2012-08-30 09:47:10 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_efl_gfx_color_color_set(Eo *obj, Elm_Widget_Smart_Data *pd, int r, int g, int b, int a)
|
2012-08-30 09:47:10 -07:00
|
|
|
{
|
2013-09-05 01:16:42 -07:00
|
|
|
Eina_Iterator *it;
|
2012-08-30 09:47:10 -07:00
|
|
|
Evas_Object *o;
|
|
|
|
|
2016-10-07 00:25:49 -07:00
|
|
|
if (_evas_object_intercept_call(obj, EVAS_OBJECT_INTERCEPT_CB_COLOR_SET, 0, r, g, b, a))
|
|
|
|
return;
|
|
|
|
|
2018-05-25 10:08:21 -07:00
|
|
|
efl_gfx_color_set(efl_super(obj, MY_CLASS), r, g, b, a);
|
|
|
|
|
2013-09-05 01:16:42 -07:00
|
|
|
it = evas_object_smart_iterator_new(obj);
|
|
|
|
EINA_ITERATOR_FOREACH(it, o)
|
2012-08-30 09:47:10 -07:00
|
|
|
{
|
2017-11-23 21:41:31 -08:00
|
|
|
if (pd->bg == o) continue;
|
2013-09-05 01:16:42 -07:00
|
|
|
if (evas_object_data_get(o, "_elm_leaveme")) continue;
|
|
|
|
evas_object_color_set(o, r, g, b, a);
|
2012-08-30 09:47:10 -07:00
|
|
|
}
|
2013-09-05 01:16:42 -07:00
|
|
|
eina_iterator_free(it);
|
2012-08-30 09:47:10 -07:00
|
|
|
}
|
|
|
|
|
2016-03-28 01:47:02 -07:00
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_efl_canvas_object_no_render_set(Eo *obj, Elm_Widget_Smart_Data *_pd EINA_UNUSED, Eina_Bool hide)
|
2016-03-28 01:47:02 -07:00
|
|
|
{
|
|
|
|
Eina_Iterator *it;
|
|
|
|
Evas_Object *o;
|
|
|
|
|
2016-09-06 04:02:34 -07:00
|
|
|
hide = !!hide;
|
|
|
|
if (efl_canvas_object_no_render_get(obj) == hide)
|
|
|
|
return;
|
|
|
|
|
2016-03-28 01:47:02 -07:00
|
|
|
it = evas_object_smart_iterator_new(obj);
|
|
|
|
EINA_ITERATOR_FOREACH(it, o)
|
|
|
|
{
|
|
|
|
if (evas_object_data_get(o, "_elm_leaveme")) continue;
|
2016-06-20 21:26:15 -07:00
|
|
|
efl_canvas_object_no_render_set(o, hide);
|
2016-03-28 01:47:02 -07:00
|
|
|
}
|
|
|
|
eina_iterator_free(it);
|
2016-09-06 04:02:34 -07:00
|
|
|
|
|
|
|
// bypass implementation in Efl.Canvas.Group
|
|
|
|
efl_canvas_object_no_render_set(efl_super(obj, EFL_CANVAS_GROUP_CLASS), hide);
|
2016-03-28 01:47:02 -07:00
|
|
|
}
|
|
|
|
|
2016-11-28 01:26:39 -08:00
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_efl_canvas_object_is_frame_object_set(Eo *obj, Elm_Widget_Smart_Data *pd, Eina_Bool frame)
|
2016-11-28 01:26:39 -08:00
|
|
|
{
|
|
|
|
Evas_Object *o;
|
|
|
|
Eina_List *li;
|
|
|
|
|
|
|
|
frame = !!frame;
|
|
|
|
efl_canvas_object_is_frame_object_set(efl_super(obj, MY_CLASS), frame);
|
|
|
|
EINA_LIST_FOREACH(pd->subobjs, li, o)
|
|
|
|
{
|
|
|
|
if (evas_object_data_get(o, "_elm_leaveme")) continue;
|
|
|
|
efl_canvas_object_is_frame_object_set(o, frame);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_efl_canvas_object_clip_set(Eo *obj, Elm_Widget_Smart_Data *_pd EINA_UNUSED, Evas_Object *clip)
|
2012-08-30 09:47:10 -07:00
|
|
|
{
|
2013-09-05 01:16:42 -07:00
|
|
|
Eina_Iterator *it;
|
2012-08-30 09:47:10 -07:00
|
|
|
Evas_Object *o;
|
|
|
|
|
2016-10-10 00:44:48 -07:00
|
|
|
if (_evas_object_intercept_call(obj, EVAS_OBJECT_INTERCEPT_CB_CLIP_SET, 0, clip))
|
|
|
|
return;
|
2012-08-30 09:47:10 -07:00
|
|
|
|
2016-10-10 00:44:48 -07:00
|
|
|
efl_canvas_object_clip_set(efl_super(obj, MY_CLASS), clip);
|
2012-08-30 09:47:10 -07:00
|
|
|
|
2013-09-05 01:16:42 -07:00
|
|
|
it = evas_object_smart_iterator_new(obj);
|
|
|
|
EINA_ITERATOR_FOREACH(it, o)
|
2012-08-30 09:47:10 -07:00
|
|
|
{
|
2013-09-05 01:16:42 -07:00
|
|
|
if (evas_object_data_get(o, "_elm_leaveme")) continue;
|
2016-10-10 00:44:48 -07:00
|
|
|
evas_object_clip_set(o, clip);
|
2012-08-30 09:47:10 -07:00
|
|
|
}
|
2013-09-05 01:16:42 -07:00
|
|
|
eina_iterator_free(it);
|
2012-08-30 09:47:10 -07:00
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_efl_canvas_group_group_calculate(Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *_pd EINA_UNUSED)
|
2012-08-30 09:47:10 -07:00
|
|
|
{
|
|
|
|
/* a NO-OP, on the base */
|
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_efl_canvas_group_group_member_add(Eo *obj, Elm_Widget_Smart_Data *pd, Evas_Object *child)
|
2012-08-30 09:47:10 -07:00
|
|
|
{
|
|
|
|
int r, g, b, a;
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_canvas_group_member_add(efl_super(obj, MY_CLASS), child);
|
2012-08-30 09:47:10 -07:00
|
|
|
|
|
|
|
if (evas_object_data_get(child, "_elm_leaveme")) return;
|
|
|
|
|
2017-11-23 21:41:31 -08:00
|
|
|
if (pd->bg != child)
|
|
|
|
{
|
|
|
|
evas_object_color_get(obj, &r, &g, &b, &a);
|
|
|
|
evas_object_color_set(child, r, g, b, a);
|
|
|
|
}
|
2012-08-30 09:47:10 -07:00
|
|
|
|
2016-06-20 21:26:15 -07:00
|
|
|
efl_canvas_object_no_render_set(child, efl_canvas_object_no_render_get(obj));
|
2012-08-30 09:47:10 -07:00
|
|
|
evas_object_clip_set(child, evas_object_clip_get(obj));
|
|
|
|
|
|
|
|
if (evas_object_visible_get(obj))
|
|
|
|
evas_object_show(child);
|
|
|
|
else
|
|
|
|
evas_object_hide(child);
|
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_efl_canvas_group_group_member_del(Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *_pd EINA_UNUSED, Evas_Object *child)
|
2012-08-30 09:47:10 -07:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
if (!evas_object_data_get(child, "_elm_leaveme"))
|
|
|
|
evas_object_clip_unset(child);
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_canvas_group_member_del(efl_super(obj, MY_CLASS), child);
|
2012-08-30 09:47:10 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// internal funcs
|
2010-09-13 00:56:23 -07:00
|
|
|
static void
|
2011-04-02 23:43:17 -07:00
|
|
|
_propagate_x_drag_lock(Evas_Object *obj,
|
2012-08-30 09:47:10 -07:00
|
|
|
int dir)
|
2010-09-13 00:56:23 -07:00
|
|
|
{
|
2011-12-27 21:51:10 -08:00
|
|
|
INTERNAL_ENTRY;
|
2011-04-02 23:43:17 -07:00
|
|
|
if (sd->parent_obj)
|
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
ELM_WIDGET_DATA_GET(sd->parent_obj, sd2);
|
2011-04-02 23:43:17 -07:00
|
|
|
if (sd2)
|
|
|
|
{
|
|
|
|
sd2->child_drag_x_locked += dir;
|
|
|
|
_propagate_x_drag_lock(sd->parent_obj, dir);
|
|
|
|
}
|
|
|
|
}
|
2010-09-13 00:56:23 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-04-02 23:43:17 -07:00
|
|
|
_propagate_y_drag_lock(Evas_Object *obj,
|
2012-08-30 09:47:10 -07:00
|
|
|
int dir)
|
2010-09-13 00:56:23 -07:00
|
|
|
{
|
2011-12-27 21:51:10 -08:00
|
|
|
INTERNAL_ENTRY;
|
2011-04-02 23:43:17 -07:00
|
|
|
if (sd->parent_obj)
|
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
ELM_WIDGET_DATA_GET(sd->parent_obj, sd2);
|
2011-04-02 23:43:17 -07:00
|
|
|
if (sd2)
|
|
|
|
{
|
|
|
|
sd2->child_drag_y_locked += dir;
|
|
|
|
_propagate_y_drag_lock(sd->parent_obj, dir);
|
|
|
|
}
|
|
|
|
}
|
2010-09-13 00:56:23 -07:00
|
|
|
}
|
|
|
|
|
2017-08-17 02:14:52 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_propagate_event_legacy(Eo *parent, const Efl_Event *event, Eo *obj, Elm_Event_Cb_Data *ecd)
|
2010-09-20 19:02:24 -07:00
|
|
|
{
|
2014-07-06 10:08:56 -07:00
|
|
|
Evas_Callback_Type type;
|
2017-04-12 02:30:22 -07:00
|
|
|
Evas_Event_Flags *event_flags, prev_flags;
|
2016-06-13 21:43:36 -07:00
|
|
|
union {
|
2017-04-12 02:30:22 -07:00
|
|
|
Evas_Event_Key_Down *down;
|
|
|
|
Evas_Event_Key_Up *up;
|
|
|
|
Evas_Event_Mouse_Wheel *wheel;
|
|
|
|
void *any;
|
|
|
|
} event_info;
|
2016-06-13 21:43:36 -07:00
|
|
|
|
|
|
|
if (event->desc == EFL_EVENT_KEY_DOWN)
|
2010-09-20 19:02:24 -07:00
|
|
|
{
|
2017-04-12 02:30:22 -07:00
|
|
|
event_info.down = efl_input_legacy_info_get(event->info);
|
2017-08-17 02:14:52 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(event_info.down, EINA_FALSE);
|
2014-07-06 10:08:56 -07:00
|
|
|
type = EVAS_CALLBACK_KEY_DOWN;
|
2017-04-12 02:30:22 -07:00
|
|
|
event_flags = &event_info.down->event_flags;
|
2014-07-06 10:08:56 -07:00
|
|
|
}
|
2016-06-13 21:43:36 -07:00
|
|
|
else if (event->desc == EFL_EVENT_KEY_UP)
|
2014-07-06 10:08:56 -07:00
|
|
|
{
|
2017-04-12 02:30:22 -07:00
|
|
|
event_info.up = efl_input_legacy_info_get(event->info);
|
2017-08-17 02:14:52 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(event_info.up, EINA_FALSE);
|
2014-07-06 10:08:56 -07:00
|
|
|
type = EVAS_CALLBACK_KEY_UP;
|
2017-04-12 02:30:22 -07:00
|
|
|
event_flags = &event_info.up->event_flags;
|
2014-07-06 10:08:56 -07:00
|
|
|
}
|
2016-06-13 21:43:36 -07:00
|
|
|
else if (event->desc == EFL_EVENT_POINTER_WHEEL)
|
2014-07-06 10:08:56 -07:00
|
|
|
{
|
2017-04-12 02:30:22 -07:00
|
|
|
event_info.wheel = efl_input_legacy_info_get(event->info);
|
2017-08-17 02:14:52 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(event_info.wheel, EINA_FALSE);
|
2016-06-29 23:20:28 -07:00
|
|
|
type = EVAS_CALLBACK_MOUSE_WHEEL;
|
2017-04-12 02:30:22 -07:00
|
|
|
event_flags = &event_info.wheel->event_flags;
|
2010-09-20 19:02:24 -07:00
|
|
|
}
|
2014-07-06 10:08:56 -07:00
|
|
|
else
|
2017-08-17 02:14:52 -07:00
|
|
|
return EINA_FALSE;
|
2010-10-08 09:27:04 -07:00
|
|
|
|
2017-04-12 02:30:22 -07:00
|
|
|
prev_flags = *event_flags;
|
2017-08-17 02:14:52 -07:00
|
|
|
if (ecd->func((void *)ecd->data, parent, obj, type, event_info.any) ||
|
2017-09-28 17:09:04 -07:00
|
|
|
((*event_flags) & EVAS_EVENT_FLAG_ON_HOLD))
|
2017-08-17 02:14:52 -07:00
|
|
|
{
|
2017-09-28 17:09:04 -07:00
|
|
|
if (prev_flags != *event_flags)
|
|
|
|
efl_input_event_flags_set(event->info, *event_flags);
|
2017-08-17 02:14:52 -07:00
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return EINA_FALSE;
|
2010-09-20 19:02:24 -07:00
|
|
|
}
|
|
|
|
|
2012-10-17 03:09:52 -07:00
|
|
|
/**
|
2013-01-26 01:55:18 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2017-08-29 19:29:08 -07:00
|
|
|
* If elm_widget_focus_region_get() returns an empty rect (w or h <= 0),
|
|
|
|
* this function will ignore region show action.
|
2012-10-17 03:09:52 -07:00
|
|
|
*/
|
2017-10-12 02:16:42 -07:00
|
|
|
EAPI void
|
|
|
|
elm_widget_focus_region_show(Eo *obj)
|
2010-09-13 00:56:23 -07:00
|
|
|
{
|
2017-08-28 22:29:45 -07:00
|
|
|
Evas_Coord ox, oy;
|
2017-09-13 19:59:44 -07:00
|
|
|
Eina_Rect r;
|
2012-08-30 09:47:10 -07:00
|
|
|
Evas_Object *o;
|
2010-09-21 11:55:32 -07:00
|
|
|
|
2012-08-30 09:47:10 -07:00
|
|
|
o = elm_widget_parent_get(obj);
|
|
|
|
if (!o) return;
|
2010-10-22 11:29:51 -07:00
|
|
|
|
2017-08-29 19:29:08 -07:00
|
|
|
r = elm_widget_focus_region_get(obj);
|
2017-09-13 19:59:44 -07:00
|
|
|
if (eina_rectangle_is_empty(&r.rect)) return;
|
2012-10-17 03:09:52 -07:00
|
|
|
|
2010-10-22 11:29:51 -07:00
|
|
|
evas_object_geometry_get(obj, &ox, &oy, NULL, NULL);
|
2012-08-30 09:47:16 -07:00
|
|
|
|
2010-10-22 11:29:51 -07:00
|
|
|
while (o)
|
|
|
|
{
|
|
|
|
Evas_Coord px, py;
|
2015-11-04 16:16:11 -08:00
|
|
|
evas_object_geometry_get(o, &px, &py, NULL, NULL);
|
2012-08-30 09:47:16 -07:00
|
|
|
|
2013-11-07 05:34:57 -08:00
|
|
|
if (_elm_scrollable_is(o) && !elm_widget_disabled_get(o))
|
2010-10-22 11:29:51 -07:00
|
|
|
{
|
2015-11-04 16:16:11 -08:00
|
|
|
Evas_Coord sx, sy;
|
2016-03-02 04:10:48 -08:00
|
|
|
elm_interface_scrollable_content_region_get(o, &sx, &sy, NULL, NULL);
|
2015-11-04 16:16:11 -08:00
|
|
|
|
2016-12-07 07:59:13 -08:00
|
|
|
// Get the object's on_focus_region position relative to the scroller.
|
2015-11-04 16:16:11 -08:00
|
|
|
Evas_Coord rx, ry;
|
2017-08-28 22:29:45 -07:00
|
|
|
rx = ox + r.x - px + sx;
|
|
|
|
ry = oy + r.y - py + sy;
|
2015-11-04 16:16:11 -08:00
|
|
|
|
2014-05-11 06:42:45 -07:00
|
|
|
switch (_elm_config->focus_autoscroll_mode)
|
|
|
|
{
|
|
|
|
case ELM_FOCUS_AUTOSCROLL_MODE_SHOW:
|
2017-08-28 22:29:45 -07:00
|
|
|
elm_interface_scrollable_content_region_show(o, rx, ry, r.w, r.h);
|
2014-05-11 06:42:45 -07:00
|
|
|
break;
|
|
|
|
case ELM_FOCUS_AUTOSCROLL_MODE_BRING_IN:
|
2017-08-28 22:29:45 -07:00
|
|
|
elm_interface_scrollable_region_bring_in(o, rx, ry, r.w, r.h);
|
2014-05-11 06:42:45 -07:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2014-06-24 21:49:44 -07:00
|
|
|
|
2017-08-29 19:29:08 -07:00
|
|
|
r = elm_widget_focus_region_get(o);
|
2016-12-16 15:24:00 -08:00
|
|
|
evas_object_geometry_get(o, &ox, &oy, NULL, NULL);
|
2010-10-22 11:29:51 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2017-08-28 22:29:45 -07:00
|
|
|
r.x += ox - px;
|
|
|
|
r.y += oy - py;
|
2010-10-22 11:29:51 -07:00
|
|
|
ox = px;
|
|
|
|
oy = py;
|
|
|
|
}
|
|
|
|
o = elm_widget_parent_get(o);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_widget_parent_set(Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *_pd EINA_UNUSED, Evas_Object *parent EINA_UNUSED)
|
2012-12-06 09:49:19 -08:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_widget_api_check(int ver)
|
|
|
|
{
|
|
|
|
if (ver != ELM_INTERNAL_API_VERSION)
|
|
|
|
{
|
2013-12-25 20:03:55 -08:00
|
|
|
CRI("Elementary widget api versions do not match");
|
2010-09-13 00:56:23 -07:00
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
2012-07-03 05:09:34 -07:00
|
|
|
EAPI Eina_Bool
|
2012-08-30 09:47:10 -07:00
|
|
|
elm_widget_access(Evas_Object *obj,
|
|
|
|
Eina_Bool is_access)
|
2012-07-03 05:09:34 -07:00
|
|
|
{
|
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *child;
|
|
|
|
Eina_Bool ret = EINA_TRUE;
|
|
|
|
|
|
|
|
API_ENTRY return EINA_FALSE;
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(sd->subobjs, l, child)
|
2014-03-18 03:02:04 -07:00
|
|
|
{
|
|
|
|
if (elm_widget_is(child))
|
|
|
|
ret &= elm_widget_access(child, is_access);
|
|
|
|
}
|
2012-07-03 05:09:34 -07:00
|
|
|
|
2017-10-23 22:03:46 -07:00
|
|
|
efl_ui_widget_on_access_update(obj, is_access);
|
2017-10-23 22:29:16 -07:00
|
|
|
efl_event_callback_legacy_call(obj, EFL_UI_WIDGET_EVENT_ACCESS_CHANGED, NULL);
|
2012-07-03 05:09:34 -07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_on_access_update(Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *_pd EINA_UNUSED, Eina_Bool is_access EINA_UNUSED)
|
2012-12-06 09:49:19 -08:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2018-11-19 20:56:37 -08:00
|
|
|
EAPI Efl_Ui_Theme_Apply_Result
|
2008-11-14 22:09:04 -08:00
|
|
|
elm_widget_theme(Evas_Object *obj)
|
|
|
|
{
|
2009-02-25 11:50:45 -08:00
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *child;
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
Elm_Tooltip *tt;
|
2010-09-25 15:01:19 -07:00
|
|
|
Elm_Cursor *cur;
|
2018-11-19 20:56:37 -08:00
|
|
|
Efl_Ui_Theme_Apply_Result ret = EFL_UI_THEME_APPLY_RESULT_SUCCESS;
|
2009-02-25 11:50:45 -08:00
|
|
|
|
2018-11-19 20:56:37 -08:00
|
|
|
API_ENTRY return EFL_UI_THEME_APPLY_RESULT_FAIL;
|
2012-09-28 07:08:00 -07:00
|
|
|
|
|
|
|
EINA_LIST_FOREACH(sd->subobjs, l, child)
|
2014-03-18 03:02:04 -07:00
|
|
|
if (_elm_widget_is(child))
|
|
|
|
ret &= elm_widget_theme(child);
|
|
|
|
|
2012-03-06 11:06:02 -08:00
|
|
|
if (sd->hover_obj) ret &= elm_widget_theme(sd->hover_obj);
|
2012-09-28 07:08:00 -07:00
|
|
|
|
|
|
|
EINA_LIST_FOREACH(sd->tooltips, l, tt)
|
2012-08-30 09:47:10 -07:00
|
|
|
elm_tooltip_theme(tt);
|
2012-09-28 07:08:00 -07:00
|
|
|
EINA_LIST_FOREACH(sd->cursors, l, cur)
|
2012-08-30 09:47:10 -07:00
|
|
|
elm_cursor_theme(cur);
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2017-10-23 22:03:46 -07:00
|
|
|
ret &= efl_ui_widget_theme_apply(obj);
|
2012-03-06 10:39:53 -08:00
|
|
|
|
2012-03-06 11:06:02 -08:00
|
|
|
return ret;
|
2010-11-05 01:37:31 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_theme_specific(Evas_Object *obj,
|
2012-08-30 09:47:10 -07:00
|
|
|
Elm_Theme *th,
|
|
|
|
Eina_Bool force)
|
2010-11-05 01:37:31 -07:00
|
|
|
{
|
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *child;
|
|
|
|
Elm_Tooltip *tt;
|
|
|
|
Elm_Cursor *cur;
|
2011-01-10 23:48:02 -08:00
|
|
|
Elm_Theme *th2, *thdef;
|
2010-11-05 01:37:31 -07:00
|
|
|
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2011-01-11 01:40:03 -08:00
|
|
|
thdef = elm_theme_default_get();
|
|
|
|
if (!th) th = thdef;
|
2010-11-05 01:37:31 -07:00
|
|
|
if (!force)
|
|
|
|
{
|
|
|
|
th2 = sd->theme;
|
2011-01-10 23:48:02 -08:00
|
|
|
if (!th2) th2 = thdef;
|
2010-11-05 01:37:31 -07:00
|
|
|
while (th2)
|
|
|
|
{
|
|
|
|
if (th2 == th)
|
|
|
|
{
|
2011-01-11 01:40:03 -08:00
|
|
|
force = EINA_TRUE;
|
|
|
|
break;
|
2010-11-05 01:37:31 -07:00
|
|
|
}
|
2011-01-10 23:48:02 -08:00
|
|
|
if (th2 == thdef) break;
|
2011-01-11 01:40:03 -08:00
|
|
|
th2 = th2->ref_theme;
|
|
|
|
if (!th2) th2 = thdef;
|
2010-11-05 01:37:31 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!force) return;
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(sd->subobjs, l, child)
|
2014-03-18 03:02:04 -07:00
|
|
|
{
|
|
|
|
if (elm_widget_is(child))
|
|
|
|
elm_widget_theme_specific(child, th, force);
|
|
|
|
}
|
2008-11-14 22:09:04 -08:00
|
|
|
if (sd->hover_obj) elm_widget_theme(sd->hover_obj);
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(sd->tooltips, l, tt)
|
2012-08-30 09:47:10 -07:00
|
|
|
elm_tooltip_theme(tt);
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(sd->cursors, l, cur)
|
2012-08-30 09:47:10 -07:00
|
|
|
elm_cursor_theme(cur);
|
2017-10-23 22:03:46 -07:00
|
|
|
efl_ui_widget_theme_apply(obj);
|
2008-11-14 22:09:04 -08:00
|
|
|
}
|
|
|
|
|
2018-11-19 20:56:37 -08:00
|
|
|
EOLIAN static Efl_Ui_Theme_Apply_Result
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_theme_apply(Eo *obj, Elm_Widget_Smart_Data *_pd EINA_UNUSED)
|
2012-12-06 09:49:19 -08:00
|
|
|
{
|
|
|
|
_elm_widget_mirrored_reload(obj);
|
2016-08-04 00:34:40 -07:00
|
|
|
if (elm_widget_disabled_get(obj))
|
2016-08-04 00:44:06 -07:00
|
|
|
elm_widget_disabled_internal(obj, elm_widget_disabled_get(obj));
|
2012-12-06 09:49:19 -08:00
|
|
|
|
2018-11-19 20:56:37 -08:00
|
|
|
return EFL_UI_THEME_APPLY_RESULT_SUCCESS;
|
2012-12-06 09:49:19 -08:00
|
|
|
}
|
|
|
|
|
2011-02-03 07:52:49 -08:00
|
|
|
/**
|
2013-01-26 01:55:18 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2011-02-03 07:52:49 -08:00
|
|
|
* Returns the widget's mirrored mode.
|
|
|
|
*
|
|
|
|
* @param obj The widget.
|
|
|
|
* @return mirrored mode of the object.
|
|
|
|
*
|
|
|
|
**/
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static Eina_Bool
|
2018-12-21 14:13:40 -08:00
|
|
|
_efl_ui_widget_efl_ui_i18n_mirrored_get(const Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *sd)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2014-03-14 02:13:29 -07:00
|
|
|
return sd->is_mirrored;
|
2011-02-03 07:52:49 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2013-01-26 01:55:18 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2011-02-03 07:52:49 -08:00
|
|
|
* Sets the widget's mirrored mode.
|
|
|
|
*
|
|
|
|
* @param obj The widget.
|
|
|
|
* @param mirrored EINA_TRUE to set mirrored mode. EINA_FALSE to unset.
|
|
|
|
*/
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static void
|
2018-12-21 14:13:40 -08:00
|
|
|
_efl_ui_widget_efl_ui_i18n_mirrored_set(Eo *obj, Elm_Widget_Smart_Data *sd, Eina_Bool mirrored)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-05-25 12:53:59 -07:00
|
|
|
mirrored = !!mirrored;
|
|
|
|
|
|
|
|
if (sd->is_mirrored == mirrored) return;
|
|
|
|
|
|
|
|
sd->is_mirrored = mirrored;
|
|
|
|
elm_widget_theme(obj);
|
2011-02-03 07:52:49 -08:00
|
|
|
}
|
|
|
|
|
2011-02-09 08:13:58 -08:00
|
|
|
/**
|
|
|
|
* Returns the widget's mirrored mode setting.
|
|
|
|
*
|
|
|
|
* @param obj The widget.
|
|
|
|
* @return mirrored mode setting of the object.
|
|
|
|
*
|
|
|
|
**/
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static Eina_Bool
|
2018-12-21 14:13:40 -08:00
|
|
|
_efl_ui_widget_efl_ui_i18n_mirrored_automatic_get(const Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *sd)
|
2011-02-09 08:13:58 -08:00
|
|
|
{
|
2014-03-14 02:13:29 -07:00
|
|
|
return sd->mirrored_auto_mode;
|
2011-02-09 08:13:58 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2013-01-26 01:55:18 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2011-02-09 08:13:58 -08:00
|
|
|
* Sets the widget's mirrored mode setting.
|
|
|
|
* When widget in automatic mode, it follows the system mirrored mode set by
|
|
|
|
* elm_mirrored_set().
|
|
|
|
* @param obj The widget.
|
|
|
|
* @param automatic EINA_TRUE for auto mirrored mode. EINA_FALSE for manual.
|
|
|
|
*/
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static void
|
2018-12-21 14:13:40 -08:00
|
|
|
_efl_ui_widget_efl_ui_i18n_mirrored_automatic_set(Eo *obj, Elm_Widget_Smart_Data *sd, Eina_Bool automatic)
|
2011-02-09 08:13:58 -08:00
|
|
|
{
|
|
|
|
if (sd->mirrored_auto_mode != automatic)
|
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
sd->mirrored_auto_mode = automatic;
|
2011-02-09 08:13:58 -08:00
|
|
|
|
|
|
|
if (automatic)
|
|
|
|
{
|
2017-06-13 03:41:15 -07:00
|
|
|
efl_ui_mirrored_set(obj, elm_config_mirrored_get());
|
2011-02-09 08:13:58 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_on_show_region_hook_set(Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *sd, void *data, Efl_Ui_Scrollable_On_Show_Region func, Eina_Free_Cb func_free_cb)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2017-08-21 23:16:54 -07:00
|
|
|
if ((sd->on_show_region_data == data) && (sd->on_show_region == func))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (sd->on_show_region_data && sd->on_show_region_data_free)
|
|
|
|
sd->on_show_region_data_free(sd->on_show_region_data);
|
|
|
|
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
sd->on_show_region = func;
|
2008-10-17 07:40:54 -07:00
|
|
|
sd->on_show_region_data = data;
|
2017-08-21 23:16:54 -07:00
|
|
|
sd->on_show_region_data_free = func_free_cb;
|
2008-10-17 07:40:54 -07:00
|
|
|
}
|
|
|
|
|
2013-12-20 02:08:38 -08:00
|
|
|
/*
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Add myself as a sub object of parent object
|
|
|
|
*
|
|
|
|
* @see elm_widget_sub_object_add()
|
|
|
|
*/
|
2013-09-24 21:33:39 -07:00
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_widget_sub_object_parent_add(Evas_Object *sobj)
|
|
|
|
{
|
2014-04-03 09:21:05 -07:00
|
|
|
Eo *parent = NULL;
|
2013-09-24 21:33:39 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
parent = efl_parent_get(sobj);
|
2018-01-07 20:55:35 -08:00
|
|
|
if (!efl_isa(parent, EFL_UI_WIDGET_CLASS))
|
2014-11-25 05:09:32 -08:00
|
|
|
{
|
|
|
|
ERR("You passed a wrong parent parameter (%p %s). "
|
|
|
|
"Elementary widget's parent should be an elementary widget.", parent, evas_object_type_get(parent));
|
2016-08-04 03:37:56 -07:00
|
|
|
return EINA_FALSE;
|
2014-11-25 05:09:32 -08:00
|
|
|
}
|
|
|
|
|
2017-08-23 04:41:37 -07:00
|
|
|
return elm_widget_sub_object_add(parent, sobj);
|
2013-09-24 21:33:39 -07:00
|
|
|
}
|
|
|
|
|
2013-12-20 02:08:38 -08:00
|
|
|
/*
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Add sobj to obj's sub object.
|
|
|
|
*
|
|
|
|
* What does elementary sub object mean? This is unique in elementary, it
|
|
|
|
* handles overall elementary policies between parent and sub objects.
|
|
|
|
* focus, access, deletion, theme, scale, mirror, scrollable child get,
|
|
|
|
* translate, name find, display mode set, orientation set, tree dump
|
|
|
|
* AUTOMATICALLY.
|
|
|
|
*
|
|
|
|
* @see elm_widget_sub_object_parent_add()
|
|
|
|
*/
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static Eina_Bool
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_widget_sub_object_add(Eo *obj, Elm_Widget_Smart_Data *sd, Evas_Object *sobj)
|
2012-12-06 09:49:19 -08:00
|
|
|
{
|
2017-06-13 03:41:15 -07:00
|
|
|
Eina_Bool mirrored, pmirrored = efl_ui_mirrored_get(obj);
|
2019-01-18 11:39:46 -08:00
|
|
|
Elm_Widget_Smart_Data *sdc = NULL;
|
2012-12-06 09:49:19 -08:00
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EINA_SAFETY_ON_TRUE_RETURN_VAL(obj == sobj, EINA_FALSE);
|
2012-12-06 09:49:19 -08:00
|
|
|
|
2019-01-18 11:39:46 -08:00
|
|
|
if (_elm_widget_is(sobj))
|
|
|
|
sdc = efl_data_scope_get(sobj, MY_CLASS);
|
|
|
|
|
2012-12-06 09:49:19 -08:00
|
|
|
if (sobj == sd->parent_obj)
|
|
|
|
{
|
|
|
|
/* in this case, sobj must be an elm widget, or something
|
|
|
|
* very wrong is happening */
|
2019-01-18 11:39:46 -08:00
|
|
|
if (!sdc) return EINA_FALSE;
|
2012-12-06 09:49:19 -08:00
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
if (!elm_widget_sub_object_del(sobj, obj)) return EINA_FALSE;
|
2012-12-06 09:49:19 -08:00
|
|
|
WRN("You passed a parent object of obj = %p as the sub object = %p!",
|
|
|
|
obj, sobj);
|
|
|
|
}
|
|
|
|
|
2019-01-18 11:39:46 -08:00
|
|
|
if (sdc)
|
2012-12-06 09:49:19 -08:00
|
|
|
{
|
2013-01-02 22:12:51 -08:00
|
|
|
if (sdc->parent_obj == obj) goto end;
|
2012-12-06 09:49:19 -08:00
|
|
|
if (sdc->parent_obj)
|
|
|
|
{
|
|
|
|
if (!elm_widget_sub_object_del(sdc->parent_obj, sobj))
|
2014-03-14 02:13:29 -07:00
|
|
|
return EINA_FALSE;
|
2012-12-06 09:49:19 -08:00
|
|
|
}
|
|
|
|
sdc->parent_obj = obj;
|
2014-05-08 23:18:49 -07:00
|
|
|
|
2016-12-07 07:59:13 -08:00
|
|
|
_full_eval(sobj, sdc);
|
2016-11-19 03:46:21 -08:00
|
|
|
|
2014-05-08 23:18:49 -07:00
|
|
|
if (!sdc->on_create)
|
2017-10-23 22:03:46 -07:00
|
|
|
efl_ui_widget_on_orientation_update(sobj, sd->orient_mode);
|
2014-05-08 23:18:49 -07:00
|
|
|
else
|
|
|
|
sdc->orient_mode = sd->orient_mode;
|
|
|
|
|
2015-01-07 23:06:34 -08:00
|
|
|
if (!sdc->on_create)
|
|
|
|
{
|
|
|
|
if (!sdc->disabled && (elm_widget_disabled_get(obj)))
|
|
|
|
{
|
2017-10-23 22:03:46 -07:00
|
|
|
efl_ui_widget_on_disabled_update(sobj, EINA_TRUE);
|
2015-01-07 23:06:34 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-06 09:49:19 -08:00
|
|
|
_elm_widget_top_win_focused_set(sobj, sd->top_win_focused);
|
|
|
|
|
|
|
|
/* update child focusable-ness on self and parents, now that a
|
|
|
|
* focusable child got in */
|
|
|
|
if (!sd->child_can_focus && (_is_focusable(sobj)))
|
|
|
|
{
|
|
|
|
Elm_Widget_Smart_Data *sdp = sd;
|
|
|
|
|
|
|
|
sdp->child_can_focus = EINA_TRUE;
|
|
|
|
while (sdp->parent_obj)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
sdp = efl_data_scope_get(sdp->parent_obj, MY_CLASS);
|
2012-12-06 09:49:19 -08:00
|
|
|
|
|
|
|
if (sdp->child_can_focus) break;
|
|
|
|
|
|
|
|
sdp->child_can_focus = EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
void *data = evas_object_data_get(sobj, "elm-parent");
|
|
|
|
|
|
|
|
if (data)
|
|
|
|
{
|
|
|
|
if (data == obj) goto end;
|
2014-03-14 02:13:29 -07:00
|
|
|
if (!elm_widget_sub_object_del(data, sobj)) return EINA_FALSE;
|
2012-12-06 09:49:19 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
sd->subobjs = eina_list_append(sd->subobjs, sobj);
|
|
|
|
evas_object_data_set(sobj, "elm-parent", obj);
|
2014-07-06 10:08:56 -07:00
|
|
|
|
|
|
|
_callbacks_add(sobj, obj);
|
2019-01-18 11:39:46 -08:00
|
|
|
if (sdc)
|
2012-12-06 09:49:19 -08:00
|
|
|
{
|
2014-03-13 06:24:08 -07:00
|
|
|
/* NOTE: In the following two lines, 'sobj' is correct. Do not change it.
|
|
|
|
* Due to elementary's scale policy, scale and pscale can be different in
|
|
|
|
* some cases. This happens when sobj's previous parent and new parent have
|
|
|
|
* different scale value.
|
|
|
|
* For example, if sobj's previous parent's scale is 5 and new parent's scale
|
|
|
|
* is 2 while sobj's scale is 0. Then 'pscale' is 5 and 'scale' is 2. So we
|
|
|
|
* need to reset sobj's scale to 5.
|
|
|
|
* Note that each widget's scale is 0 by default.
|
|
|
|
*/
|
2018-04-05 01:47:26 -07:00
|
|
|
double scale, pscale = efl_gfx_entity_scale_get(sobj);
|
2014-03-13 06:24:08 -07:00
|
|
|
Elm_Theme *th, *pth = elm_widget_theme_get(sobj);
|
|
|
|
|
2018-04-05 01:47:26 -07:00
|
|
|
scale = efl_gfx_entity_scale_get(sobj);
|
2012-12-06 09:49:19 -08:00
|
|
|
th = elm_widget_theme_get(sobj);
|
2017-06-13 03:41:15 -07:00
|
|
|
mirrored = efl_ui_mirrored_get(sobj);
|
2012-12-06 09:49:19 -08:00
|
|
|
|
2014-01-02 21:38:27 -08:00
|
|
|
if (!sdc->on_create)
|
|
|
|
{
|
|
|
|
if ((scale != pscale) || (th != pth) || (pmirrored != mirrored))
|
|
|
|
elm_widget_theme(sobj);
|
|
|
|
}
|
2012-12-06 09:49:19 -08:00
|
|
|
|
2016-04-15 21:47:13 -07:00
|
|
|
if (_is_focused(sobj)) _parents_focus(obj);
|
2014-03-13 06:24:08 -07:00
|
|
|
|
|
|
|
elm_widget_display_mode_set(sobj,
|
|
|
|
evas_object_size_hint_display_mode_get(obj));
|
2015-12-01 07:55:12 -08:00
|
|
|
if (_elm_config->atspi_mode && !sd->on_create)
|
2015-10-08 03:23:15 -07:00
|
|
|
{
|
2018-04-03 04:27:30 -07:00
|
|
|
Efl_Access_Object *aparent;
|
|
|
|
aparent = efl_provider_find(efl_parent_get(sobj), EFL_ACCESS_OBJECT_MIXIN);
|
2015-12-01 07:55:12 -08:00
|
|
|
if (aparent)
|
2017-10-18 18:13:54 -07:00
|
|
|
efl_access_children_changed_added_signal_emit(aparent, sobj);
|
2015-10-08 03:23:15 -07:00
|
|
|
}
|
2012-12-06 09:49:19 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
end:
|
2014-03-14 02:13:29 -07:00
|
|
|
return EINA_TRUE;
|
2012-05-02 18:19:05 -07:00
|
|
|
}
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70627
2012-05-02 09:57:38 -07:00
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static Eina_Bool
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_widget_sub_object_del(Eo *obj, Elm_Widget_Smart_Data *sd, Evas_Object *sobj)
|
2012-12-06 09:49:19 -08:00
|
|
|
{
|
|
|
|
Evas_Object *sobj_parent;
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
if (!sobj) return EINA_FALSE;
|
2012-12-06 09:49:19 -08:00
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EINA_SAFETY_ON_TRUE_RETURN_VAL(obj == sobj, EINA_FALSE);
|
2012-12-06 09:49:19 -08:00
|
|
|
|
|
|
|
sobj_parent = evas_object_data_del(sobj, "elm-parent");
|
2014-12-15 00:47:05 -08:00
|
|
|
if (sobj_parent && sobj_parent != obj)
|
2012-12-06 09:49:19 -08:00
|
|
|
{
|
|
|
|
static int abort_on_warn = -1;
|
|
|
|
|
|
|
|
ERR("removing sub object %p (%s) from parent %p (%s), "
|
|
|
|
"but elm-parent is different %p (%s)!",
|
|
|
|
sobj, elm_widget_type_get(sobj), obj, elm_widget_type_get(obj),
|
|
|
|
sobj_parent, elm_widget_type_get(sobj_parent));
|
|
|
|
|
|
|
|
if (EINA_UNLIKELY(abort_on_warn == -1))
|
|
|
|
{
|
|
|
|
if (getenv("ELM_ERROR_ABORT")) abort_on_warn = 1;
|
|
|
|
else abort_on_warn = 0;
|
|
|
|
}
|
|
|
|
if (abort_on_warn == 1) abort();
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
return EINA_FALSE;
|
2012-12-06 09:49:19 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (_elm_widget_is(sobj))
|
|
|
|
{
|
2016-04-15 21:47:13 -07:00
|
|
|
if (_is_focused(sobj))
|
2012-12-06 09:49:19 -08:00
|
|
|
{
|
|
|
|
elm_widget_tree_unfocusable_set(sobj, EINA_TRUE);
|
|
|
|
elm_widget_tree_unfocusable_set(sobj, EINA_FALSE);
|
|
|
|
}
|
|
|
|
if ((sd->child_can_focus) && (_is_focusable(sobj)))
|
|
|
|
{
|
|
|
|
Evas_Object *parent = obj;
|
|
|
|
|
|
|
|
/* update child focusable-ness on self and parents, now that a
|
|
|
|
* focusable child is gone */
|
|
|
|
while (parent)
|
|
|
|
{
|
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *subobj;
|
|
|
|
|
|
|
|
ELM_WIDGET_DATA_GET(parent, sdp);
|
|
|
|
|
|
|
|
sdp->child_can_focus = EINA_FALSE;
|
|
|
|
EINA_LIST_FOREACH(sdp->subobjs, l, subobj)
|
|
|
|
{
|
|
|
|
if ((subobj != sobj) && (_is_focusable(subobj)))
|
|
|
|
{
|
|
|
|
sdp->child_can_focus = EINA_TRUE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* break again, child_can_focus went back to
|
|
|
|
* original value */
|
|
|
|
if (sdp->child_can_focus) break;
|
|
|
|
parent = sdp->parent_obj;
|
|
|
|
}
|
|
|
|
}
|
2015-10-08 03:23:15 -07:00
|
|
|
if (_elm_config->atspi_mode && !sd->on_destroy)
|
|
|
|
{
|
2018-04-03 04:27:30 -07:00
|
|
|
Efl_Access_Object *aparent;
|
|
|
|
aparent = efl_provider_find(efl_parent_get(sobj), EFL_ACCESS_OBJECT_MIXIN);
|
2015-12-01 07:55:12 -08:00
|
|
|
if (aparent)
|
2017-10-18 18:13:54 -07:00
|
|
|
efl_access_children_changed_del_signal_emit(aparent, sobj);
|
2015-10-08 03:23:15 -07:00
|
|
|
}
|
2012-12-06 09:49:19 -08:00
|
|
|
|
|
|
|
ELM_WIDGET_DATA_GET(sobj, sdc);
|
2016-05-29 17:47:39 -07:00
|
|
|
sdc->parent_obj = NULL;
|
2016-11-19 03:46:21 -08:00
|
|
|
|
2016-12-07 07:59:13 -08:00
|
|
|
_full_eval(sobj, sdc);
|
2012-12-06 09:49:19 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (sd->resize_obj == sobj) sd->resize_obj = NULL;
|
|
|
|
|
|
|
|
sd->subobjs = eina_list_remove(sd->subobjs, sobj);
|
|
|
|
|
2014-07-06 10:08:56 -07:00
|
|
|
_callbacks_del(sobj, obj);
|
2012-12-06 09:49:19 -08:00
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
return EINA_TRUE;
|
2012-12-06 09:49:19 -08:00
|
|
|
}
|
|
|
|
|
2017-08-08 05:06:43 -07:00
|
|
|
/* protected function - for widget developers only */
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_resize_object_set(Eo *obj, Elm_Widget_Smart_Data *sd, Eo *sobj)
|
2008-09-29 23:58:56 -07:00
|
|
|
{
|
2012-05-03 15:41:09 -07:00
|
|
|
Evas_Object *parent;
|
|
|
|
|
|
|
|
if (sd->resize_obj == sobj) return;
|
2017-08-08 05:06:43 -07:00
|
|
|
EINA_SAFETY_ON_TRUE_RETURN(sobj && !efl_isa(sobj, EFL_CANVAS_OBJECT_CLASS));
|
2012-05-03 15:41:09 -07:00
|
|
|
|
2010-10-14 23:04:33 -07:00
|
|
|
// orphan previous resize obj
|
2017-08-08 05:06:43 -07:00
|
|
|
if (sd->resize_obj)
|
2008-10-07 23:38:20 -07:00
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
evas_object_clip_unset(sd->resize_obj);
|
|
|
|
evas_object_smart_member_del(sd->resize_obj);
|
2012-02-15 01:02:07 -08:00
|
|
|
|
2010-09-28 22:27:42 -07:00
|
|
|
if (_elm_widget_is(sd->resize_obj))
|
|
|
|
{
|
2016-04-15 21:47:13 -07:00
|
|
|
if (_is_focused(sd->resize_obj)) _parents_unfocus(obj);
|
2010-09-28 22:27:42 -07:00
|
|
|
}
|
2013-10-18 03:52:55 -07:00
|
|
|
elm_widget_sub_object_del(obj, sd->resize_obj);
|
2008-10-07 23:38:20 -07:00
|
|
|
}
|
2011-10-19 10:07:15 -07:00
|
|
|
|
2011-10-19 10:36:51 -07:00
|
|
|
sd->resize_obj = sobj;
|
2013-07-11 01:47:25 -07:00
|
|
|
if (!sobj) return;
|
2011-10-19 10:07:15 -07:00
|
|
|
|
2010-10-14 23:04:33 -07:00
|
|
|
// orphan new resize obj
|
2012-05-03 15:41:09 -07:00
|
|
|
parent = evas_object_data_get(sobj, "elm-parent");
|
|
|
|
if (parent && parent != obj)
|
2012-05-02 18:19:05 -07:00
|
|
|
{
|
2012-05-03 15:41:09 -07:00
|
|
|
ELM_WIDGET_DATA_GET(parent, sdp);
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2012-05-03 15:41:09 -07:00
|
|
|
/* should be there, just being paranoid */
|
|
|
|
if (sdp)
|
|
|
|
{
|
|
|
|
if (sdp->resize_obj == sobj)
|
2017-08-08 05:06:43 -07:00
|
|
|
elm_widget_resize_object_set(parent, NULL);
|
|
|
|
else
|
2012-05-03 15:41:09 -07:00
|
|
|
elm_widget_sub_object_del(parent, sobj);
|
|
|
|
}
|
2012-05-02 18:19:05 -07:00
|
|
|
}
|
2012-05-03 15:41:09 -07:00
|
|
|
|
2017-08-08 05:06:43 -07:00
|
|
|
elm_widget_sub_object_add(obj, sobj);
|
|
|
|
evas_object_smart_member_add(sobj, obj);
|
2011-10-19 10:07:15 -07:00
|
|
|
_smart_reconfigure(sd);
|
2008-10-07 23:38:20 -07:00
|
|
|
}
|
|
|
|
|
2013-01-26 01:55:18 -08:00
|
|
|
/*
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* WARNING: the programmer is responsible, in the scenario of
|
2012-05-03 15:41:09 -07:00
|
|
|
* exchanging a hover object, of cleaning the old hover "target"
|
|
|
|
* before
|
|
|
|
*/
|
2017-08-23 01:54:49 -07:00
|
|
|
EAPI void
|
|
|
|
elm_widget_hover_object_set(Eo *obj, Evas_Object *sobj)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2017-08-23 01:54:49 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
if (!sd) return;
|
|
|
|
|
2008-10-07 23:38:20 -07:00
|
|
|
if (sd->hover_obj)
|
2009-10-22 15:10:23 -07:00
|
|
|
{
|
2014-07-06 10:08:56 -07:00
|
|
|
_callbacks_del(sd->hover_obj, obj);
|
2009-10-22 15:10:23 -07:00
|
|
|
}
|
2008-10-07 23:38:20 -07:00
|
|
|
sd->hover_obj = sobj;
|
|
|
|
if (sd->hover_obj)
|
|
|
|
{
|
2014-07-06 10:08:56 -07:00
|
|
|
_callbacks_add(sobj, obj);
|
2011-04-01 04:20:18 -07:00
|
|
|
_smart_reconfigure(sd);
|
2008-10-07 23:38:20 -07:00
|
|
|
}
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_focus_allow_set(Eo *obj, Elm_Widget_Smart_Data *sd, Eina_Bool can_focus)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-02-21 04:36:54 -08:00
|
|
|
can_focus = !!can_focus;
|
|
|
|
|
|
|
|
if (sd->can_focus == can_focus) return;
|
2012-02-22 20:09:05 -08:00
|
|
|
sd->can_focus = can_focus;
|
|
|
|
if (sd->can_focus)
|
2010-09-20 19:02:24 -07:00
|
|
|
{
|
2013-05-07 04:41:32 -07:00
|
|
|
/* update child_can_focus of parents */
|
|
|
|
Evas_Object *o = obj;
|
|
|
|
|
|
|
|
for (;;)
|
|
|
|
{
|
|
|
|
o = elm_widget_parent_get(o);
|
|
|
|
if (!o) break;
|
2017-05-20 12:03:15 -07:00
|
|
|
ELM_WIDGET_DATA_GET(o, sdp);
|
|
|
|
if (!sdp || sdp->child_can_focus) break;
|
|
|
|
sdp->child_can_focus = EINA_TRUE;
|
2013-05-07 04:41:32 -07:00
|
|
|
}
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_event_callback_array_add(obj, focus_callbacks(), NULL);
|
2010-09-20 19:02:24 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-10-29 23:22:05 -07:00
|
|
|
// update child_can_focus of parents */
|
|
|
|
Evas_Object *parent = elm_widget_parent_get(obj);
|
|
|
|
while (parent)
|
|
|
|
{
|
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *subobj;
|
|
|
|
|
|
|
|
ELM_WIDGET_DATA_GET(parent, sdp);
|
|
|
|
|
|
|
|
sdp->child_can_focus = EINA_FALSE;
|
|
|
|
EINA_LIST_FOREACH(sdp->subobjs, l, subobj)
|
|
|
|
{
|
|
|
|
if (_is_focusable(subobj))
|
|
|
|
{
|
|
|
|
sdp->child_can_focus = EINA_TRUE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* break again, child_can_focus went back to
|
|
|
|
* original value */
|
|
|
|
if (sdp->child_can_focus) break;
|
|
|
|
parent = sdp->parent_obj;
|
|
|
|
}
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_event_callback_array_del(obj, focus_callbacks(), NULL);
|
2010-09-20 19:02:24 -07:00
|
|
|
}
|
2016-11-04 09:43:40 -07:00
|
|
|
if (efl_finalized_get(obj))
|
2017-07-24 14:35:26 -07:00
|
|
|
_full_eval(obj, sd);
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static Eina_Bool
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_focus_allow_get(const Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *sd)
|
2010-09-24 07:47:52 -07:00
|
|
|
{
|
2014-03-14 02:13:29 -07:00
|
|
|
return sd->can_focus;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2017-08-23 03:39:19 -07:00
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_widget_child_can_focus_get(const Eo *obj)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2017-08-23 03:39:19 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
if (!sd) return EINA_FALSE;
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
return sd->child_can_focus;
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
2011-07-27 23:58:29 -07:00
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* This API makes the widget object and its children to be unfocusable.
|
|
|
|
*
|
|
|
|
* This API can be helpful for an object to be deleted.
|
2011-07-28 01:14:30 -07:00
|
|
|
* When an object will be deleted soon, it and its children may not
|
2011-07-27 23:58:29 -07:00
|
|
|
* want to get focus (by focus reverting or by other focus controls).
|
|
|
|
* Then, just use this API before deleting.
|
|
|
|
*
|
|
|
|
* @param obj The widget root of sub-tree
|
|
|
|
* @param tree_unfocusable If true, set the object sub-tree as unfocusable
|
|
|
|
*
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
2017-08-23 01:27:04 -07:00
|
|
|
EAPI void
|
|
|
|
elm_widget_tree_unfocusable_set(Eo *obj, Eina_Bool tree_unfocusable)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2017-08-23 01:27:04 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
if (!sd) return;
|
|
|
|
|
2012-02-21 04:36:54 -08:00
|
|
|
tree_unfocusable = !!tree_unfocusable;
|
2011-07-27 23:58:29 -07:00
|
|
|
if (sd->tree_unfocusable == tree_unfocusable) return;
|
2012-02-21 04:36:54 -08:00
|
|
|
sd->tree_unfocusable = tree_unfocusable;
|
2017-08-23 01:01:03 -07:00
|
|
|
_elm_widget_focus_tree_unfocusable_handle(obj);
|
2016-12-21 02:41:55 -08:00
|
|
|
|
|
|
|
//focus state eval on all children
|
2018-04-21 09:54:50 -07:00
|
|
|
_elm_widget_full_eval_children(obj, sd);
|
2011-07-27 23:58:29 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* This returns true, if the object sub-tree is unfocusable.
|
|
|
|
*
|
|
|
|
* @param obj The widget root of sub-tree
|
|
|
|
* @return EINA_TRUE if the object sub-tree is unfocusable
|
|
|
|
*
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
2017-08-23 01:27:04 -07:00
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_widget_tree_unfocusable_get(const Eo *obj)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2017-08-23 01:27:04 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
if (!sd) return EINA_FALSE;
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
return sd->tree_unfocusable;
|
2011-07-27 23:58:29 -07:00
|
|
|
}
|
|
|
|
|
2011-08-05 01:25:07 -07:00
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Get the list of focusable child objects.
|
|
|
|
*
|
2018-08-31 01:45:31 -07:00
|
|
|
* This function returns list of child objects which can get focus.
|
2011-08-05 01:25:07 -07:00
|
|
|
*
|
|
|
|
* @param obj The parent widget
|
2018-08-31 01:45:31 -07:00
|
|
|
* @return list of focusable child objects.
|
2011-08-05 01:25:07 -07:00
|
|
|
*
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
2017-08-23 03:51:49 -07:00
|
|
|
EAPI Eina_List*
|
|
|
|
elm_widget_can_focus_child_list_get(const Eo *obj)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2017-08-23 03:51:49 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
|
2011-08-05 01:25:07 -07:00
|
|
|
const Eina_List *l;
|
|
|
|
Eina_List *child_list = NULL;
|
|
|
|
Evas_Object *child;
|
|
|
|
|
2017-08-23 03:51:49 -07:00
|
|
|
if (!sd) return NULL;
|
2014-03-18 03:04:56 -07:00
|
|
|
EINA_LIST_FOREACH(sd->subobjs, l, child)
|
2011-08-05 01:25:07 -07:00
|
|
|
{
|
2014-03-18 03:04:56 -07:00
|
|
|
if (!_elm_widget_is(child)) continue;
|
|
|
|
if ((elm_widget_can_focus_get(child)) &&
|
|
|
|
(evas_object_visible_get(child)) &&
|
|
|
|
(!elm_widget_disabled_get(child)))
|
|
|
|
child_list = eina_list_append(child_list, child);
|
|
|
|
else
|
2011-08-05 01:25:07 -07:00
|
|
|
{
|
2014-03-18 03:04:56 -07:00
|
|
|
Eina_List *can_focus_list;
|
|
|
|
can_focus_list = elm_widget_can_focus_child_list_get(child);
|
|
|
|
if (can_focus_list)
|
|
|
|
child_list = eina_list_merge(child_list, can_focus_list);
|
2011-08-05 01:25:07 -07:00
|
|
|
}
|
|
|
|
}
|
2014-03-18 03:04:56 -07:00
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
return child_list;
|
2011-08-05 01:25:07 -07:00
|
|
|
}
|
|
|
|
|
2017-08-23 04:12:47 -07:00
|
|
|
/** @internal */
|
|
|
|
EAPI void
|
|
|
|
elm_widget_highlight_ignore_set(Eo *obj, Eina_Bool ignore)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2017-08-23 04:12:47 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
if (!sd) return;
|
|
|
|
|
Begins highlight on focused object.
There's still work to do here, particularly in the theme, but it has
something nice and fun to see the code working.
The idea behind this:
Window tracks focused object and sends the highlight object(s) to it. These
are simple edje objects, one on top, one below the focused widget for nice
effects. Widgets can choose to ignore the highlight and this will be sent to
the parent object, if it doesn't ignore it as well.
About the bottom object, it doesn't work now. For the most part, focused
widget will always be a member of some smart object, so stacking won't work
and the desired effect is nowhere to be seen. This will be worked out later.
To be done now:
- Let the theme for a widget define its own highlight, disabling if needed
the standard one for those objects.
- Needed base in code to allow animations when switching focus. All in theme.
- Properly test all widgets and fix some things that will most likely work
in weird ways, given the nature of Evas/Edje and how Elementary makes use
of them.
- Forgot the rest, stay tuned, test, report, give ideas, plant a tree.
Work started by glima, continued with some refactors by me when he
decided he needed vacations.
SVN revision: 52524
2010-09-20 15:18:58 -07:00
|
|
|
sd->highlight_ignore = !!ignore;
|
|
|
|
}
|
|
|
|
|
2017-08-23 04:12:47 -07:00
|
|
|
/** @internal */
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_widget_highlight_ignore_get(const Eo *obj)
|
2010-09-22 15:33:57 -07:00
|
|
|
{
|
2017-08-23 04:12:47 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
if (!sd) return EINA_FALSE;
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
return sd->highlight_ignore;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2017-08-23 03:25:44 -07:00
|
|
|
/** @internal */
|
|
|
|
EAPI void
|
|
|
|
elm_widget_highlight_in_theme_set(Eo *obj, Eina_Bool highlight)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2017-08-23 03:25:44 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
if (!sd) return;
|
|
|
|
|
2010-09-22 15:33:57 -07:00
|
|
|
sd->highlight_in_theme = !!highlight;
|
|
|
|
/* FIXME: if focused, it should switch from one mode to the other */
|
|
|
|
}
|
|
|
|
|
2014-05-11 09:04:25 -07:00
|
|
|
void
|
|
|
|
_elm_widget_highlight_in_theme_update(Eo *obj)
|
|
|
|
{
|
|
|
|
Evas_Object *top = elm_widget_top_get(obj);
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
if (top && efl_isa(top, EFL_UI_WIN_CLASS))
|
2014-05-11 09:04:25 -07:00
|
|
|
{
|
|
|
|
_elm_win_focus_highlight_in_theme_update(
|
|
|
|
top, elm_widget_highlight_in_theme_get(obj));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-23 03:25:44 -07:00
|
|
|
/** @internal */
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_widget_highlight_in_theme_get(const Eo *obj)
|
2010-09-22 15:33:57 -07:00
|
|
|
{
|
2017-08-23 03:25:44 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
if (!sd) return EINA_FALSE;
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
return sd->highlight_in_theme;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2017-08-23 03:25:44 -07:00
|
|
|
/** @internal */
|
|
|
|
EAPI void
|
|
|
|
elm_widget_access_highlight_in_theme_set(Eo *obj, Eina_Bool highlight)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2017-08-23 03:25:44 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
if (!sd) return;
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
sd->access_highlight_in_theme = !!highlight;
|
2010-09-22 15:33:57 -07:00
|
|
|
}
|
|
|
|
|
2017-08-23 03:25:44 -07:00
|
|
|
/** @internal */
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_widget_access_highlight_in_theme_get(const Eo *obj)
|
2014-02-07 19:27:41 -08:00
|
|
|
{
|
2017-08-23 03:25:44 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
if (!sd) return EINA_FALSE;
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
return sd->access_highlight_in_theme;
|
2014-02-07 19:27:41 -08:00
|
|
|
}
|
|
|
|
|
2017-08-23 03:51:49 -07:00
|
|
|
/** @internal */
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_widget_highlight_get(const Eo *obj)
|
2014-02-07 19:27:41 -08:00
|
|
|
{
|
2017-08-23 03:51:49 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
if (!sd) return EINA_FALSE;
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
return sd->highlighted;
|
2014-02-07 19:27:41 -08:00
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static Evas_Object*
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_widget_top_get(const Eo *obj, Elm_Widget_Smart_Data *sd EINA_UNUSED)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2018-01-07 20:55:35 -08:00
|
|
|
Efl_Ui_Widget *parent = elm_widget_parent_get(obj);
|
2017-11-21 07:12:12 -08:00
|
|
|
if (parent)
|
2014-03-14 02:13:29 -07:00
|
|
|
{
|
2018-01-07 20:55:35 -08:00
|
|
|
if (!efl_isa(parent, EFL_UI_WIDGET_CLASS)) return NULL;
|
2017-11-21 07:12:12 -08:00
|
|
|
return efl_ui_widget_top_get(parent);
|
2014-03-14 02:13:29 -07:00
|
|
|
}
|
2018-04-17 11:09:44 -07:00
|
|
|
/* XXX const */
|
|
|
|
return (Evas_Object *)obj;
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
2013-01-28 03:13:18 -08:00
|
|
|
EAPI Eina_Bool
|
2014-03-14 02:13:29 -07:00
|
|
|
elm_widget_is(const Evas_Object *obj)
|
2013-01-28 03:13:18 -08:00
|
|
|
{
|
2014-03-14 02:13:29 -07:00
|
|
|
return _elm_widget_is(obj);
|
2013-01-28 03:13:18 -08:00
|
|
|
}
|
|
|
|
|
2008-10-06 18:23:49 -07:00
|
|
|
EAPI Evas_Object *
|
2014-03-14 02:13:29 -07:00
|
|
|
elm_widget_parent_widget_get(const Evas_Object *obj)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2014-03-14 02:13:29 -07:00
|
|
|
Evas_Object *parent;
|
2010-03-22 14:36:59 -07:00
|
|
|
|
|
|
|
if (_elm_widget_is(obj))
|
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
ELM_WIDGET_DATA_GET(obj, sd);
|
2011-04-01 04:20:18 -07:00
|
|
|
if (!sd) return NULL;
|
|
|
|
parent = sd->parent_obj;
|
2010-03-22 14:36:59 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
parent = evas_object_data_get(obj, "elm-parent");
|
|
|
|
if (!parent) parent = evas_object_smart_parent_get(obj);
|
2010-03-22 14:36:59 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
while (parent)
|
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
Evas_Object *elm_parent;
|
|
|
|
if (_elm_widget_is(parent)) break;
|
|
|
|
elm_parent = evas_object_data_get(parent, "elm-parent");
|
2010-09-13 00:56:23 -07:00
|
|
|
if (elm_parent) parent = elm_parent;
|
2011-04-01 04:20:18 -07:00
|
|
|
else parent = evas_object_smart_parent_get(parent);
|
2010-03-22 14:36:59 -07:00
|
|
|
}
|
|
|
|
return parent;
|
|
|
|
}
|
|
|
|
|
2017-05-16 18:52:26 -07:00
|
|
|
EAPI void
|
|
|
|
elm_widget_event_callback_add(Eo *obj, Elm_Event_Cb func, const void *data)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2017-05-16 18:52:26 -07:00
|
|
|
API_ENTRY return;
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(func);
|
2012-11-25 22:32:53 -08:00
|
|
|
|
2010-11-29 05:56:30 -08:00
|
|
|
Elm_Event_Cb_Data *ecb = ELM_NEW(Elm_Event_Cb_Data);
|
2015-06-11 03:05:52 -07:00
|
|
|
if (!ecb)
|
|
|
|
{
|
|
|
|
ERR("Failed to allocate memory");
|
|
|
|
return;
|
|
|
|
}
|
2010-11-29 05:56:30 -08:00
|
|
|
ecb->func = func;
|
|
|
|
ecb->data = data;
|
|
|
|
sd->event_cb = eina_list_append(sd->event_cb, ecb);
|
|
|
|
}
|
|
|
|
|
2017-05-16 18:52:26 -07:00
|
|
|
EAPI void *
|
|
|
|
elm_widget_event_callback_del(Eo *obj, Elm_Event_Cb func, const void *data)
|
2010-11-29 05:56:30 -08:00
|
|
|
{
|
2017-05-16 18:52:26 -07:00
|
|
|
API_ENTRY return NULL;
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(func, NULL);
|
2010-11-29 05:56:30 -08:00
|
|
|
Eina_List *l;
|
|
|
|
Elm_Event_Cb_Data *ecd;
|
2017-05-16 18:52:26 -07:00
|
|
|
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(sd->event_cb, l, ecd)
|
2011-04-02 23:43:17 -07:00
|
|
|
if ((ecd->func == func) && (ecd->data == data))
|
|
|
|
{
|
|
|
|
free(ecd);
|
|
|
|
sd->event_cb = eina_list_remove_list(sd->event_cb, l);
|
2014-03-14 02:13:29 -07:00
|
|
|
return (void *)data;
|
2011-04-02 23:43:17 -07:00
|
|
|
}
|
2010-11-29 05:56:30 -08:00
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
return NULL;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2017-08-17 02:14:52 -07:00
|
|
|
static void
|
|
|
|
_propagate_event(void *data EINA_UNUSED, const Efl_Event *eo_event)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2017-08-17 02:14:52 -07:00
|
|
|
Evas_Object *obj = eo_event->object;
|
2010-11-29 05:56:30 -08:00
|
|
|
Evas_Object *parent = obj;
|
|
|
|
Elm_Event_Cb_Data *ecd;
|
|
|
|
Eina_List *l, *l_prev;
|
2010-10-08 09:27:04 -07:00
|
|
|
|
2017-08-17 02:14:52 -07:00
|
|
|
if ((evas_focus_get(evas_object_evas_get(obj)) != elm_widget_top_get(obj)) &&
|
|
|
|
efl_isa(obj, EFL_UI_WIN_CLASS))
|
|
|
|
return;
|
2010-11-29 05:56:30 -08:00
|
|
|
|
2017-08-17 02:14:52 -07:00
|
|
|
while (parent && !efl_input_processed_get(eo_event->info))
|
|
|
|
{
|
|
|
|
Elm_Widget_Smart_Data *sd = efl_data_scope_safe_get(parent, MY_CLASS);
|
|
|
|
if (!sd) return;
|
2014-04-15 18:59:43 -07:00
|
|
|
|
|
|
|
if (elm_widget_disabled_get(obj))
|
|
|
|
{
|
|
|
|
parent = sd->parent_obj;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2017-10-23 22:03:46 -07:00
|
|
|
if (efl_ui_widget_event(parent, eo_event, obj))
|
2017-08-17 02:14:52 -07:00
|
|
|
return;
|
2010-11-29 05:56:30 -08:00
|
|
|
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH_SAFE(sd->event_cb, l, l_prev, ecd)
|
2010-11-29 05:56:30 -08:00
|
|
|
{
|
2017-08-17 02:14:52 -07:00
|
|
|
if (_propagate_event_legacy(parent, eo_event, obj, ecd))
|
|
|
|
return;
|
2010-11-29 05:56:30 -08:00
|
|
|
}
|
2017-08-17 02:14:52 -07:00
|
|
|
|
2010-09-20 19:02:24 -07:00
|
|
|
parent = sd->parent_obj;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-08-12 21:45:21 -07:00
|
|
|
double
|
|
|
|
_elm_widget_focus_direction_weight_get(const Evas_Object *obj1,
|
2012-08-30 09:47:10 -07:00
|
|
|
const Evas_Object *obj2,
|
|
|
|
double degree)
|
2012-05-02 20:02:54 -07:00
|
|
|
{
|
2012-08-30 09:47:10 -07:00
|
|
|
Evas_Coord obj_x1, obj_y1, w1, h1, obj_x2, obj_y2, w2, h2;
|
|
|
|
double x1, yy1, x2, yy2, xx1, yyy1, xx2, yyy2;
|
|
|
|
double ax, ay, cx, cy;
|
|
|
|
double weight = -1.0, g = 0.0;
|
2012-05-02 20:02:54 -07:00
|
|
|
|
2012-08-30 09:47:10 -07:00
|
|
|
if (obj1 == obj2) return 0.0;
|
2012-05-02 20:02:54 -07:00
|
|
|
|
2012-08-30 09:47:10 -07:00
|
|
|
degree -= 90.0;
|
|
|
|
while (degree >= 360.0)
|
|
|
|
degree -= 360.0;
|
|
|
|
while (degree < 0.0)
|
|
|
|
degree += 360.0;
|
2012-05-02 20:02:54 -07:00
|
|
|
|
2012-08-30 09:47:10 -07:00
|
|
|
evas_object_geometry_get(obj1, &obj_x1, &obj_y1, &w1, &h1);
|
|
|
|
cx = obj_x1 + (w1 / 2.0);
|
|
|
|
cy = obj_y1 + (h1 / 2.0);
|
|
|
|
evas_object_geometry_get(obj2, &obj_x2, &obj_y2, &w2, &h2);
|
2012-05-02 20:02:54 -07:00
|
|
|
|
2012-08-30 09:47:10 -07:00
|
|
|
/* For overlapping cases. */
|
|
|
|
if (ELM_RECTS_INTERSECT(obj_x1, obj_y1, w1, h1, obj_x2, obj_y2, w2, h2))
|
|
|
|
return 0.0;
|
|
|
|
|
|
|
|
/* Change all points to relative one. */
|
|
|
|
x1 = obj_x1 - cx;
|
|
|
|
xx1 = x1 + w1;
|
|
|
|
yy1 = obj_y1 - cy;
|
|
|
|
yyy1 = yy1 + h1;
|
|
|
|
x2 = obj_x2 - cx;
|
|
|
|
xx2 = x2 + w2;
|
|
|
|
yy2 = obj_y2 - cy;
|
|
|
|
yyy2 = yy2 + h2;
|
2012-05-02 20:02:54 -07:00
|
|
|
|
2012-08-30 09:47:10 -07:00
|
|
|
/* Get crossing points (ax, ay) between obj1 and a line extending
|
|
|
|
* to the direction of current degree. */
|
|
|
|
if (degree == 0.0)
|
2012-05-02 20:02:54 -07:00
|
|
|
{
|
2012-08-30 09:47:10 -07:00
|
|
|
ax = xx1;
|
|
|
|
ay = 0.0;
|
|
|
|
}
|
|
|
|
else if (degree == 90.0)
|
|
|
|
{
|
|
|
|
ax = 0.0;
|
|
|
|
ay = yyy1;
|
|
|
|
}
|
|
|
|
else if (degree == 180.0)
|
|
|
|
{
|
|
|
|
ax = x1;
|
|
|
|
ay = 0.0;
|
|
|
|
}
|
|
|
|
else if (degree == 270.0)
|
|
|
|
{
|
|
|
|
ax = 0.0;
|
|
|
|
ay = yy1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
g = tan(degree * (M_PI / 180.0));
|
|
|
|
if ((degree > 0.0) && (degree < 90.0))
|
2012-05-02 20:02:54 -07:00
|
|
|
{
|
2012-08-30 09:47:10 -07:00
|
|
|
ay = g * xx1;
|
|
|
|
if (ay <= yyy1) ax = xx1;
|
|
|
|
else
|
2012-05-02 20:02:54 -07:00
|
|
|
{
|
2012-08-30 09:47:10 -07:00
|
|
|
ax = yyy1 / g;
|
|
|
|
ay = yyy1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if ((degree > 90.0) && (degree < 180.0))
|
|
|
|
{
|
|
|
|
ay = g * x1;
|
|
|
|
if (ay <= yyy1) ax = x1;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ax = yyy1 / g;
|
|
|
|
ay = yyy1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if ((degree > 180.0) && (degree < 270.0))
|
|
|
|
{
|
|
|
|
ay = g * x1;
|
|
|
|
if (ay >= yy1) ax = x1;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ax = yy1 / g;
|
|
|
|
ay = yy1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ay = g * xx1;
|
|
|
|
if (ay >= yy1) ax = xx1;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ax = yy1 / g;
|
|
|
|
ay = yy1;
|
2012-05-02 20:02:54 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-30 09:47:10 -07:00
|
|
|
/* Filter obj2, if it is not in the specific derection. */
|
|
|
|
int i = 0;
|
|
|
|
double rx[4] = {0.0, 0.0, 0.0, 0.0}, ry[4] = {0.0, 0.0, 0.0, 0.0};
|
|
|
|
double t1, t2, u1, v1, u2, v2;
|
|
|
|
|
|
|
|
if ((degree == 45.0) || (degree == 225.0) || (degree == 135.0) ||
|
|
|
|
(degree == 315.0))
|
|
|
|
{
|
|
|
|
u1 = 1.0;
|
|
|
|
v1 = 0.0;
|
|
|
|
u2 = 0.0;
|
|
|
|
v2 = 1.0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
double g2 = tan((degree + 45.0) * (M_PI / 180.0));
|
|
|
|
u1 = (-1.0 * g2);
|
|
|
|
u2 = (1.0 / g2);
|
|
|
|
v1 = v2 = 1.0;
|
|
|
|
}
|
|
|
|
t1 = (u1 * ax) + (v1 * ay);
|
|
|
|
t2 = (u2 * ax) + (v2 * ay);
|
|
|
|
|
|
|
|
#define _R(x) (int)((x + 0.05) * 10.0)
|
|
|
|
|
|
|
|
if ((_R(t1 * ((u1 * x2) + (v1 * yy2))) > 0) && (_R(t2 * ((u2 * x2) +
|
|
|
|
(v2 * yy2))) > 0))
|
|
|
|
{
|
|
|
|
rx[i] = x2;
|
|
|
|
ry[i++] = yy2;
|
|
|
|
}
|
|
|
|
if ((_R(t1 * ((u1 * x2) + (v1 * yyy2))) > 0) && (_R(t2 * ((u2 * x2) +
|
|
|
|
(v2 * yyy2))) > 0))
|
|
|
|
{
|
|
|
|
rx[i] = x2;
|
|
|
|
ry[i++] = yyy2;
|
|
|
|
}
|
|
|
|
if ((_R(t1 * ((u1 * xx2) + (v1 * yy2))) > 0) && (_R(t2 * ((u2 * xx2) +
|
|
|
|
(v2 * yy2))) > 0))
|
|
|
|
{
|
|
|
|
rx[i] = xx2;
|
|
|
|
ry[i++] = yy2;
|
|
|
|
}
|
|
|
|
if ((_R(t1 * ((u1 * xx2) + (v1 * yyy2))) > 0) &&
|
|
|
|
(_R(t2 * ((u2 * xx2) + (v2 * yyy2))) > 0))
|
|
|
|
{
|
|
|
|
rx[i] = xx2;
|
|
|
|
ry[i++] = yyy2;
|
|
|
|
}
|
|
|
|
if (i == 0)
|
|
|
|
{
|
|
|
|
if (degree == 0.0)
|
|
|
|
{
|
|
|
|
if ((_R(xx2) < 0) || (_R(yy2) > 0) || (_R(yyy2) < 0)) return 0.0;
|
|
|
|
}
|
|
|
|
else if (degree == 90.0)
|
|
|
|
{
|
|
|
|
if ((_R(yyy2) < 0) || (_R(x2) > 0) || (_R(xx2) < 0)) return 0.0;
|
|
|
|
}
|
|
|
|
else if (degree == 180.0)
|
|
|
|
{
|
|
|
|
if ((_R(x2) > 0) || (_R(yy2) > 0) || (_R(yyy2) < 0)) return 0.0;
|
|
|
|
}
|
|
|
|
else if (degree == 270.0)
|
|
|
|
{
|
|
|
|
if ((_R(yy2) > 0) || (_R(x2) > 0) || (_R(xx2) < 0)) return 0.0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if ((_R(g * x2) >= _R(yy2)) && (_R((g * x2)) <= _R(yyy2)))
|
|
|
|
{
|
|
|
|
if (!((_R(ax * x2) > 0) && (_R(ay * (g * x2)) > 0)))
|
|
|
|
return 0.0;
|
|
|
|
}
|
|
|
|
else if ((_R(g * xx2) >= _R(yy2)) && (_R((g * xx2)) <= _R(yyy2)))
|
|
|
|
{
|
|
|
|
if (!((_R(ax * xx2) > 0) && (_R(ay * (g * xx2)) > 0)))
|
|
|
|
return 0.0;
|
|
|
|
}
|
|
|
|
else if ((_R((1.0 / g) * yy2) >= _R(xx2)) && (_R((1.0 / g) * yy2)
|
|
|
|
<= _R(xx2)))
|
|
|
|
{
|
|
|
|
if (!((_R(ax * ((1.0 / g) * yy2)) > 0)
|
|
|
|
&& (_R(ay * yy2) > 0)))
|
|
|
|
return 0.0;
|
|
|
|
}
|
|
|
|
else if ((_R((1.0 / g) * yyy2) >= _R(xx2)) &&
|
|
|
|
(_R((1.0 / g) * yyy2) <= _R(xx2)))
|
|
|
|
{
|
|
|
|
if (!((_R(ax * ((1.0 / g) * yyy2)) > 0)
|
|
|
|
&& (_R(ay * yyy2) > 0))) return 0.0;
|
|
|
|
}
|
|
|
|
else return 0.0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Calculate the weight for obj2. */
|
|
|
|
if (degree == 0.0)
|
|
|
|
{
|
|
|
|
if (_R(xx1) > _R(x2)) weight = -1.0;
|
|
|
|
else if ((_R(yy2) >= _R(yy1)) && (_R(yyy2) <= _R(yyy1)))
|
|
|
|
weight = (x2 - xx1) * (x2 - xx1);
|
|
|
|
else if (_R(yy2) > 0)
|
|
|
|
weight = ((x2 - xx1) * (x2 - xx1)) + (yy2 * yy2);
|
|
|
|
else if (_R(yyy2) < 0)
|
|
|
|
weight = ((x2 - xx1) * (x2 - xx1)) + (yyy2 * yyy2);
|
|
|
|
else weight = (x2 - xx1) * (x2 - xx1);
|
|
|
|
}
|
|
|
|
else if (degree == 90.0)
|
|
|
|
{
|
|
|
|
if (_R(yyy1) > _R(yy2)) weight = -1.0;
|
|
|
|
else if ((_R(x2) >= _R(x1)) && (_R(xx2) <= _R(xx1)))
|
|
|
|
weight = (yy2 - yyy1) * (yy2 - yyy1);
|
|
|
|
else if (_R(x2) > 0)
|
|
|
|
weight = (x2 * x2) + ((yy2 - yyy1) * (yy2 - yyy1));
|
|
|
|
else if (_R(xx2) < 0)
|
|
|
|
weight = (xx2 * xx2) + ((yy2 - yyy1) * (yy2 - yyy1));
|
|
|
|
else weight = (yy2 - yyy1) * (yy2 - yyy1);
|
|
|
|
}
|
|
|
|
else if (degree == 180.0)
|
|
|
|
{
|
|
|
|
if (_R(x1) < _R(xx2)) weight = -1.0;
|
|
|
|
else if ((_R(yy2) >= _R(yy1)) && (_R(yyy2) <= _R(yyy1)))
|
|
|
|
weight = (x1 - xx2) * (x1 - xx2);
|
|
|
|
else if (_R(yy2) > 0)
|
|
|
|
weight = ((x1 - xx2) * (x1 - xx2)) + (yy2 * yy2);
|
|
|
|
else if (_R(yyy2) < 0)
|
|
|
|
weight = ((x1 - xx2) * (x1 - xx2)) + (yyy2 * yyy2);
|
|
|
|
else weight = (x1 - xx2) * (x1 - xx2);
|
|
|
|
}
|
|
|
|
else if (degree == 270.0)
|
|
|
|
{
|
|
|
|
if (_R(yy1) < _R(yyy2)) weight = -1.0;
|
|
|
|
else if ((_R(x2) >= _R(x1)) && (_R(xx2) <= _R(xx1)))
|
|
|
|
weight = (yy1 - yyy2) * (yy1 - yyy2);
|
|
|
|
else if (_R(x2) > 0)
|
|
|
|
weight = (x2 * x2) + ((yy1 - yyy2) * (yy1 - yyy2));
|
|
|
|
else if (_R(xx2) < 0)
|
|
|
|
weight = (xx2 * xx2) + ((yy1 - yyy2) * (yy1 - yyy2));
|
|
|
|
else weight = (yy1 - yyy2) * (yy1 - yyy2);
|
2017-09-27 12:20:51 -07:00
|
|
|
}
|
|
|
|
else
|
2012-11-08 01:10:13 -08:00
|
|
|
{
|
2017-09-27 12:20:51 -07:00
|
|
|
int j = 0, k = 0;
|
|
|
|
double sx[4] = {0.0, 0.0, 0.0, 0.0}, sy[4] = {0.0, 0.0, 0.0, 0.0};
|
|
|
|
double t_weight[4] = {-1.0, -1.0, -1.0, -1.0};
|
|
|
|
if ((_R(g * x2) >= _R(yy2)) && (_R(g * x2) <= _R(yyy2)))
|
2012-11-08 01:10:13 -08:00
|
|
|
{
|
2017-09-27 12:20:51 -07:00
|
|
|
sx[j] = x2;
|
|
|
|
sy[j] = g * x2;
|
|
|
|
t_weight[j++] = ((ax - x2) * (ax - x2)) +
|
|
|
|
((ay - (g * x2)) * (ay - (g * x2)));
|
2012-11-08 01:10:13 -08:00
|
|
|
}
|
2017-09-27 12:20:51 -07:00
|
|
|
if ((_R(g * xx2) >= _R(yy2)) && (_R(g * xx2) <= _R(yyy2)))
|
2011-08-06 00:39:31 -07:00
|
|
|
{
|
2017-09-27 12:20:51 -07:00
|
|
|
sx[j] = xx2;
|
|
|
|
sy[j] = g * xx2;
|
|
|
|
t_weight[j++] = ((ax - xx2) * (ax - xx2)) +
|
|
|
|
((ay - (g * xx2)) * (ay - (g * xx2)));
|
2011-08-05 01:25:07 -07:00
|
|
|
}
|
2017-09-27 12:20:51 -07:00
|
|
|
if ((_R((1.0 / g) * yy2) >= _R(x2)) && (_R((1.0 / g) * yy2) <= _R(xx2)))
|
2013-03-22 17:36:21 -07:00
|
|
|
{
|
2017-09-27 12:20:51 -07:00
|
|
|
sx[j] = (1.0 / g) * yy2;
|
|
|
|
sy[j] = yy2;
|
|
|
|
t_weight[j++] =
|
|
|
|
((ax - ((1.0 / g) * yy2)) * (ax - ((1.0 / g) * yy2))) +
|
|
|
|
((ay - yy2) * (ay - yy2));
|
2013-03-22 17:36:21 -07:00
|
|
|
}
|
2017-09-27 12:20:51 -07:00
|
|
|
if ((_R((1.0 / g) * yyy2) >= _R(x2)) && (_R((1.0 / g) * yyy2)
|
|
|
|
<= _R(xx2)))
|
2015-09-15 03:41:51 -07:00
|
|
|
{
|
2017-09-27 12:20:51 -07:00
|
|
|
sx[j] = (1.0 / g) * yyy2;
|
|
|
|
sy[j] = yyy2;
|
|
|
|
t_weight[j++] =
|
|
|
|
((ax - ((1.0 / g) * yyy2)) * (ax - ((1.0 / g) * yyy2))) +
|
|
|
|
((ay - yyy2) * (ay - yyy2));
|
2015-09-15 03:41:51 -07:00
|
|
|
}
|
2011-08-06 00:39:31 -07:00
|
|
|
|
2017-09-27 12:20:51 -07:00
|
|
|
if ((j > 2) || ((j == 2) && ((_R(sx[0]) != _R(sx[1])) ||
|
|
|
|
(_R(sy[0]) != _R(sy[1])))))
|
2010-10-06 13:24:09 -07:00
|
|
|
{
|
2017-09-27 12:20:51 -07:00
|
|
|
for (; k < j; k++)
|
|
|
|
{
|
|
|
|
if (_R(t_weight[k]) == 0) return -1.0;
|
|
|
|
if ((1 / weight) < (1 / t_weight[k])) weight = t_weight[k];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
for (; k < i; k++)
|
|
|
|
{
|
|
|
|
double ccx, ccy, t1_weight, x_diff, y_diff;
|
|
|
|
ccx = ((1.0 / g) * rx[k] + ry[k]) / (g + (1.0 / g));
|
|
|
|
ccy = g * ccx;
|
|
|
|
x_diff = rx[k] - ccx;
|
|
|
|
if (x_diff < 0) x_diff *= -1.0;
|
|
|
|
y_diff = ry[k] - ccy;
|
|
|
|
if (y_diff < 0) y_diff *= -1.0;
|
|
|
|
t1_weight =
|
|
|
|
(((ax - ccx) * (ax - ccx)) + ((ay - ccy) * (ay - ccy))) +
|
|
|
|
((x_diff * x_diff * x_diff) + (y_diff * y_diff * y_diff));
|
|
|
|
if ((_R(t1_weight) != 0) && ((1 / weight) < (1 / t1_weight)))
|
|
|
|
weight = t1_weight;
|
|
|
|
}
|
2010-10-06 13:24:09 -07:00
|
|
|
}
|
|
|
|
}
|
2017-09-27 12:20:51 -07:00
|
|
|
/* Return the current object's weight. */
|
|
|
|
if (weight == -1.0) return 0.0;
|
|
|
|
if (_R(weight) == 0) return -1.0;
|
2010-09-24 07:47:59 -07:00
|
|
|
|
2017-09-27 12:20:51 -07:00
|
|
|
#undef _R
|
2015-09-15 03:41:51 -07:00
|
|
|
|
2017-09-27 12:20:51 -07:00
|
|
|
return 1.0 / weight;
|
2015-09-15 03:41:51 -07:00
|
|
|
}
|
|
|
|
|
2017-08-23 03:39:19 -07:00
|
|
|
/** @internal */
|
|
|
|
EAPI void
|
|
|
|
elm_widget_parent_highlight_set(Eo *obj, Eina_Bool highlighted)
|
2013-01-28 03:13:18 -08:00
|
|
|
{
|
2017-08-23 03:39:19 -07:00
|
|
|
Elm_Widget_Smart_Data *sd =efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
if (!sd) return;
|
|
|
|
|
2013-01-28 03:13:18 -08:00
|
|
|
highlighted = !!highlighted;
|
|
|
|
|
|
|
|
Evas_Object *o = elm_widget_parent_get(obj);
|
|
|
|
|
|
|
|
if (o) elm_widget_parent_highlight_set(o, highlighted);
|
|
|
|
|
|
|
|
sd->highlighted = highlighted;
|
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static Evas_Object*
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_widget_parent_get(const Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *sd)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
2014-03-14 02:13:29 -07:00
|
|
|
return sd->parent_obj;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2015-09-10 02:29:24 -07:00
|
|
|
void
|
|
|
|
_elm_widget_focus_auto_show(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Evas_Object *top = elm_widget_top_get(obj);
|
2016-08-15 06:44:41 -07:00
|
|
|
if (top && efl_isa(top, EFL_UI_WIN_CLASS)) _elm_win_focus_auto_show(top);
|
2015-09-10 02:29:24 -07:00
|
|
|
}
|
|
|
|
|
2011-09-06 23:15:55 -07:00
|
|
|
void
|
2012-08-30 09:47:10 -07:00
|
|
|
_elm_widget_top_win_focused_set(Evas_Object *obj,
|
|
|
|
Eina_Bool top_win_focused)
|
2011-09-06 23:15:55 -07:00
|
|
|
{
|
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *child;
|
|
|
|
API_ENTRY return;
|
|
|
|
|
|
|
|
if (sd->top_win_focused == top_win_focused) return;
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(sd->subobjs, l, child)
|
2014-03-18 03:02:04 -07:00
|
|
|
{
|
|
|
|
if (elm_widget_is(child))
|
|
|
|
_elm_widget_top_win_focused_set(child, top_win_focused);
|
|
|
|
}
|
2011-09-06 23:15:55 -07:00
|
|
|
sd->top_win_focused = top_win_focused;
|
2016-04-15 21:47:13 -07:00
|
|
|
|
|
|
|
if (sd->focused && !sd->top_win_focused)
|
2018-01-19 00:25:47 -08:00
|
|
|
efl_ui_focus_object_on_focus_update(obj);
|
2011-09-06 23:15:55 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
Eina_Bool
|
|
|
|
_elm_widget_top_win_focused_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return EINA_FALSE;
|
|
|
|
return sd->top_win_focused;
|
|
|
|
}
|
|
|
|
|
2015-01-07 23:06:34 -08:00
|
|
|
static void
|
|
|
|
_elm_widget_disabled_eval(const Evas_Object *obj, Eina_Bool disabled)
|
|
|
|
{
|
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *child;
|
|
|
|
ELM_WIDGET_DATA_GET(obj, sd);
|
|
|
|
|
2017-08-23 22:06:32 -07:00
|
|
|
EINA_LIST_FOREACH(sd->subobjs, l, child)
|
2015-01-07 23:06:34 -08:00
|
|
|
{
|
2017-08-23 22:06:32 -07:00
|
|
|
if (elm_widget_is(child))
|
2015-01-07 23:06:34 -08:00
|
|
|
{
|
2017-10-23 22:03:46 -07:00
|
|
|
efl_ui_widget_on_disabled_update(child, disabled);
|
2017-08-23 22:06:32 -07:00
|
|
|
_elm_widget_disabled_eval(child, disabled);
|
2015-01-07 23:06:34 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-02 06:38:30 -07:00
|
|
|
static void
|
|
|
|
elm_widget_disabled_internal(Eo *obj, Eina_Bool disabled)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2017-08-23 22:06:32 -07:00
|
|
|
if (!disabled && elm_widget_disabled_get(elm_widget_parent_get(obj)))
|
|
|
|
return;
|
2015-01-07 23:06:34 -08:00
|
|
|
|
2017-10-23 22:03:46 -07:00
|
|
|
efl_ui_widget_on_disabled_update(obj, disabled);
|
2017-08-23 22:06:32 -07:00
|
|
|
_elm_widget_disabled_eval(obj, disabled);
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2016-08-02 06:38:30 -07:00
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_disabled_set(Eo *obj, Elm_Widget_Smart_Data *sd, Eina_Bool disabled)
|
2016-08-02 06:38:30 -07:00
|
|
|
{
|
|
|
|
if (sd->disabled == disabled) return;
|
|
|
|
sd->disabled = !!disabled;
|
|
|
|
|
|
|
|
elm_widget_disabled_internal(obj, disabled);
|
2016-11-19 03:46:21 -08:00
|
|
|
|
|
|
|
if (efl_finalized_get(obj))
|
2018-04-21 09:54:50 -07:00
|
|
|
_elm_widget_full_eval_children(obj, sd);
|
2016-08-02 06:38:30 -07:00
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static Eina_Bool
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_disabled_get(const Eo *obj, Elm_Widget_Smart_Data *sd)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2018-01-15 22:12:49 -08:00
|
|
|
Eo *parent;
|
|
|
|
|
2017-08-23 22:06:32 -07:00
|
|
|
if (sd->disabled) return EINA_TRUE;
|
2018-01-15 22:12:49 -08:00
|
|
|
if ((parent = elm_widget_parent_get(obj)) != NULL)
|
|
|
|
return elm_widget_disabled_get(parent);
|
|
|
|
return EINA_FALSE;
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_show_region_set(Eo *obj, Elm_Widget_Smart_Data *sd, Eina_Rect sr, Eina_Bool forceshow)
|
2008-10-17 07:40:54 -07:00
|
|
|
{
|
2010-12-16 01:53:25 -08:00
|
|
|
Evas_Object *parent_obj, *child_obj;
|
2014-04-03 09:21:05 -07:00
|
|
|
Evas_Coord px, py, cx, cy, nx = 0, ny = 0;
|
2010-12-16 01:53:25 -08:00
|
|
|
|
2012-02-20 04:23:46 -08:00
|
|
|
evas_smart_objects_calculate(evas_object_evas_get(obj));
|
2012-03-28 02:02:22 -07:00
|
|
|
|
2017-09-13 19:59:44 -07:00
|
|
|
if (!forceshow && eina_rectangle_equal(&sr.rect, &sd->show_region.rect)) return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2017-08-29 21:39:16 -07:00
|
|
|
sd->show_region = sr;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
if (sd->on_show_region)
|
2013-04-23 01:01:25 -07:00
|
|
|
{
|
2017-08-29 21:39:16 -07:00
|
|
|
sd->on_show_region(sd->on_show_region_data, obj, sr);
|
2013-04-23 01:01:25 -07:00
|
|
|
|
2013-04-23 03:23:16 -07:00
|
|
|
if (_elm_scrollable_is(obj))
|
|
|
|
{
|
2018-11-27 21:32:39 -08:00
|
|
|
if (elm_widget_is_legacy(obj))
|
|
|
|
{
|
|
|
|
elm_interface_scrollable_content_pos_get(obj, &nx, &ny);
|
|
|
|
sr.x -= nx;
|
|
|
|
sr.y -= ny;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Eina_Position2D pos;
|
|
|
|
pos = efl_ui_scrollable_content_pos_get(obj);
|
|
|
|
sr.x -= pos.x;
|
|
|
|
sr.y -= pos.y;
|
|
|
|
}
|
2013-04-23 03:23:16 -07:00
|
|
|
}
|
2013-04-23 01:01:25 -07:00
|
|
|
}
|
2010-12-16 01:53:25 -08:00
|
|
|
|
|
|
|
do
|
2010-10-08 05:50:40 -07:00
|
|
|
{
|
2011-03-09 23:22:22 -08:00
|
|
|
parent_obj = sd->parent_obj;
|
2011-03-23 00:15:01 -07:00
|
|
|
child_obj = sd->obj;
|
2011-03-17 05:10:02 -07:00
|
|
|
if ((!parent_obj) || (!_elm_widget_is(parent_obj))) break;
|
2016-08-15 06:44:41 -07:00
|
|
|
sd = efl_data_scope_get(parent_obj, MY_CLASS);
|
2011-03-17 05:10:02 -07:00
|
|
|
if (!sd) break;
|
2010-12-16 01:53:25 -08:00
|
|
|
|
|
|
|
evas_object_geometry_get(parent_obj, &px, &py, NULL, NULL);
|
|
|
|
evas_object_geometry_get(child_obj, &cx, &cy, NULL, NULL);
|
|
|
|
|
2017-08-29 21:39:16 -07:00
|
|
|
sr.x += (cx - px);
|
|
|
|
sr.y += (cy - py);
|
|
|
|
sd->show_region = sr;
|
2010-12-16 01:53:25 -08:00
|
|
|
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
if (sd->on_show_region)
|
2017-08-29 21:39:16 -07:00
|
|
|
sd->on_show_region(sd->on_show_region_data, parent_obj, sr);
|
2010-10-08 05:50:40 -07:00
|
|
|
}
|
2010-12-16 01:53:25 -08:00
|
|
|
while (parent_obj);
|
2008-10-17 07:40:54 -07:00
|
|
|
}
|
|
|
|
|
2017-09-13 19:59:44 -07:00
|
|
|
EOLIAN static Eina_Rect
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_show_region_get(const Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *sd)
|
2008-10-17 07:40:54 -07:00
|
|
|
{
|
2017-09-13 19:59:44 -07:00
|
|
|
return (Eina_Rect) sd->show_region;
|
2008-10-17 07:40:54 -07:00
|
|
|
}
|
|
|
|
|
2010-10-22 11:29:51 -07:00
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2010-10-22 11:29:51 -07:00
|
|
|
* Get the focus region of the given widget.
|
|
|
|
*
|
2017-08-29 19:29:08 -07:00
|
|
|
* @return The region to show. If it's not a valid rectangle it will not show.
|
2012-10-17 03:09:52 -07:00
|
|
|
*
|
2010-10-22 11:29:51 -07:00
|
|
|
* The focus region is the area of a widget that should brought into the
|
|
|
|
* visible area when the widget is focused. Mostly used to show the part of
|
|
|
|
* an entry where the cursor is, for example. The area returned is relative
|
|
|
|
* to the object @p obj.
|
|
|
|
*
|
|
|
|
* @param obj The widget object
|
2017-08-29 19:29:08 -07:00
|
|
|
* @return The region to show, in relative coordinates. If it's not a valid
|
|
|
|
* rectangle (i.e. w or h <= 0) it will be ignored.
|
2010-10-22 11:29:51 -07:00
|
|
|
*
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
2017-09-13 19:59:44 -07:00
|
|
|
EOLIAN static Eina_Rect
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_interest_region_get(const Eo *obj, Elm_Widget_Smart_Data *_pd EINA_UNUSED)
|
2010-10-22 11:29:51 -07:00
|
|
|
{
|
2017-09-13 19:59:44 -07:00
|
|
|
Eina_Rect r = {};
|
2018-04-05 01:47:26 -07:00
|
|
|
r.size = efl_gfx_entity_size_get(obj);
|
2017-08-29 19:29:08 -07:00
|
|
|
return r;
|
2010-10-22 11:29:51 -07:00
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_scroll_hold_push(Eo *obj, Elm_Widget_Smart_Data *sd)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2008-11-18 02:11:57 -08:00
|
|
|
sd->scroll_hold++;
|
2009-03-20 08:08:33 -07:00
|
|
|
if (sd->scroll_hold == 1)
|
2012-07-04 14:41:01 -07:00
|
|
|
{
|
|
|
|
if (_elm_scrollable_is(obj))
|
2018-05-17 02:17:44 -07:00
|
|
|
{
|
|
|
|
if (elm_widget_is_legacy(obj))
|
|
|
|
elm_interface_scrollable_hold_set(obj, EINA_TRUE);
|
|
|
|
else
|
|
|
|
efl_ui_scrollable_scroll_hold_set(obj, EINA_TRUE);
|
|
|
|
}
|
2012-08-30 09:45:34 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
Evas_Object *child;
|
2017-08-08 06:53:58 -07:00
|
|
|
Eina_List *l;
|
2012-08-30 09:45:34 -07:00
|
|
|
|
2017-08-08 06:53:58 -07:00
|
|
|
EINA_LIST_FOREACH(sd->subobjs, l, child)
|
2012-08-30 09:45:34 -07:00
|
|
|
{
|
2017-08-08 06:53:58 -07:00
|
|
|
if (elm_widget_is(child) && _elm_scrollable_is(child))
|
2018-06-22 01:11:32 -07:00
|
|
|
{
|
|
|
|
if (elm_widget_is_legacy(obj))
|
|
|
|
elm_interface_scrollable_hold_set(child, EINA_TRUE);
|
|
|
|
else
|
|
|
|
efl_ui_scrollable_scroll_hold_set(child, EINA_TRUE);
|
|
|
|
}
|
2012-08-30 09:45:34 -07:00
|
|
|
}
|
|
|
|
}
|
2012-07-04 14:41:01 -07:00
|
|
|
}
|
2017-10-23 22:03:46 -07:00
|
|
|
if (sd->parent_obj) efl_ui_widget_scroll_hold_push(sd->parent_obj);
|
2009-09-07 21:41:36 -07:00
|
|
|
// FIXME: on delete/reparent hold pop
|
2008-11-18 02:11:57 -08:00
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_scroll_hold_pop(Eo *obj, Elm_Widget_Smart_Data *sd)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2008-11-18 02:11:57 -08:00
|
|
|
sd->scroll_hold--;
|
2010-10-22 14:41:27 -07:00
|
|
|
if (!sd->scroll_hold)
|
2012-07-04 14:41:01 -07:00
|
|
|
{
|
|
|
|
if (_elm_scrollable_is(obj))
|
2018-05-17 02:17:44 -07:00
|
|
|
{
|
|
|
|
if (elm_widget_is_legacy(obj))
|
|
|
|
elm_interface_scrollable_hold_set(obj, EINA_FALSE);
|
|
|
|
else
|
|
|
|
efl_ui_scrollable_scroll_hold_set(obj, EINA_FALSE);
|
|
|
|
}
|
2012-08-30 09:45:34 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
Evas_Object *child;
|
2017-08-08 06:53:58 -07:00
|
|
|
Eina_List *l;
|
2012-08-30 09:45:34 -07:00
|
|
|
|
2017-08-08 06:53:58 -07:00
|
|
|
EINA_LIST_FOREACH(sd->subobjs, l, child)
|
2012-08-30 09:45:34 -07:00
|
|
|
{
|
2017-08-08 06:53:58 -07:00
|
|
|
if (elm_widget_is(child) && _elm_scrollable_is(child))
|
2018-06-22 01:11:32 -07:00
|
|
|
{
|
|
|
|
if (elm_widget_is_legacy(obj))
|
|
|
|
elm_interface_scrollable_hold_set(child, EINA_FALSE);
|
|
|
|
else
|
|
|
|
efl_ui_scrollable_scroll_hold_set(child, EINA_FALSE);
|
|
|
|
}
|
2012-08-30 09:45:34 -07:00
|
|
|
}
|
|
|
|
}
|
2012-07-04 14:41:01 -07:00
|
|
|
}
|
2017-10-23 22:03:46 -07:00
|
|
|
if (sd->parent_obj) efl_ui_widget_scroll_hold_pop(sd->parent_obj);
|
2012-01-08 23:03:28 -08:00
|
|
|
if (sd->scroll_hold < 0) sd->scroll_hold = 0;
|
2008-11-18 02:11:57 -08:00
|
|
|
}
|
|
|
|
|
2017-08-29 02:15:33 -07:00
|
|
|
EAPI int
|
|
|
|
elm_widget_scroll_hold_get(const Eo *obj)
|
2008-11-18 02:11:57 -08:00
|
|
|
{
|
2017-08-29 02:15:33 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
|
|
|
|
if (!sd) return 0;
|
2014-03-14 02:13:29 -07:00
|
|
|
return sd->scroll_hold;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_scroll_freeze_push(Eo *obj, Elm_Widget_Smart_Data *sd)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2009-03-20 08:08:33 -07:00
|
|
|
sd->scroll_freeze++;
|
|
|
|
if (sd->scroll_freeze == 1)
|
2012-07-04 14:41:01 -07:00
|
|
|
{
|
|
|
|
if (_elm_scrollable_is(obj))
|
2018-05-17 02:17:44 -07:00
|
|
|
{
|
|
|
|
if (elm_widget_is_legacy(obj))
|
|
|
|
elm_interface_scrollable_freeze_set(obj, EINA_TRUE);
|
|
|
|
else
|
|
|
|
efl_ui_scrollable_scroll_freeze_set(obj, EINA_TRUE);
|
|
|
|
}
|
2012-08-30 09:45:34 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
Evas_Object *child;
|
2017-08-08 06:53:58 -07:00
|
|
|
Eina_List *l;
|
2012-08-30 09:45:34 -07:00
|
|
|
|
2017-08-08 06:53:58 -07:00
|
|
|
EINA_LIST_FOREACH(sd->subobjs, l, child)
|
2012-08-30 09:45:34 -07:00
|
|
|
{
|
2017-08-08 06:53:58 -07:00
|
|
|
if (elm_widget_is(child) && _elm_scrollable_is(child))
|
2018-06-22 01:11:32 -07:00
|
|
|
{
|
|
|
|
if (elm_widget_is_legacy(obj))
|
|
|
|
elm_interface_scrollable_freeze_set(child, EINA_TRUE);
|
|
|
|
else
|
|
|
|
efl_ui_scrollable_scroll_freeze_set(child, EINA_TRUE);
|
|
|
|
}
|
2012-08-30 09:45:34 -07:00
|
|
|
}
|
|
|
|
}
|
2012-07-04 14:41:01 -07:00
|
|
|
}
|
2017-10-23 22:03:46 -07:00
|
|
|
if (sd->parent_obj) efl_ui_widget_scroll_freeze_push(sd->parent_obj);
|
2009-09-07 21:41:36 -07:00
|
|
|
// FIXME: on delete/reparent freeze pop
|
2009-03-20 08:08:33 -07:00
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_scroll_freeze_pop(Eo *obj, Elm_Widget_Smart_Data *sd)
|
2009-03-20 08:08:33 -07:00
|
|
|
{
|
|
|
|
sd->scroll_freeze--;
|
2010-10-22 14:41:27 -07:00
|
|
|
if (!sd->scroll_freeze)
|
2012-07-04 14:41:01 -07:00
|
|
|
{
|
|
|
|
if (_elm_scrollable_is(obj))
|
2018-05-17 02:17:44 -07:00
|
|
|
{
|
|
|
|
if (elm_widget_is_legacy(obj))
|
|
|
|
elm_interface_scrollable_freeze_set(obj, EINA_FALSE);
|
|
|
|
else
|
|
|
|
efl_ui_scrollable_scroll_freeze_set(obj, EINA_FALSE);
|
|
|
|
}
|
2012-08-30 09:45:34 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
Evas_Object *child;
|
2017-08-08 06:53:58 -07:00
|
|
|
Eina_List *l;
|
2012-08-30 09:45:34 -07:00
|
|
|
|
2017-08-08 06:53:58 -07:00
|
|
|
EINA_LIST_FOREACH(sd->subobjs, l, child)
|
2012-08-30 09:45:34 -07:00
|
|
|
{
|
2017-08-08 06:53:58 -07:00
|
|
|
if (elm_widget_is(child) && _elm_scrollable_is(child))
|
2018-06-22 01:11:32 -07:00
|
|
|
{
|
|
|
|
if (elm_widget_is_legacy(obj))
|
|
|
|
elm_interface_scrollable_freeze_set(child, EINA_FALSE);
|
|
|
|
else
|
|
|
|
efl_ui_scrollable_scroll_freeze_set(child, EINA_FALSE);
|
|
|
|
}
|
2012-08-30 09:45:34 -07:00
|
|
|
}
|
|
|
|
}
|
2012-07-04 14:41:01 -07:00
|
|
|
}
|
2017-10-23 22:03:46 -07:00
|
|
|
if (sd->parent_obj) efl_ui_widget_scroll_freeze_pop(sd->parent_obj);
|
2012-01-08 22:59:33 -08:00
|
|
|
if (sd->scroll_freeze < 0) sd->scroll_freeze = 0;
|
2009-03-20 08:08:33 -07:00
|
|
|
}
|
|
|
|
|
2017-08-29 02:15:33 -07:00
|
|
|
EAPI int
|
|
|
|
elm_widget_scroll_freeze_get(const Eo *obj)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2017-08-29 02:15:33 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
|
|
|
|
if (!sd) return 0;
|
2014-03-14 02:13:29 -07:00
|
|
|
return sd->scroll_freeze;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2017-06-09 00:51:43 -07:00
|
|
|
EOLIAN static void
|
2018-04-05 01:47:26 -07:00
|
|
|
_efl_ui_widget_efl_gfx_entity_scale_set(Eo *obj, Elm_Widget_Smart_Data *sd, double scale)
|
2009-03-20 08:08:33 -07:00
|
|
|
{
|
2014-07-02 10:12:21 -07:00
|
|
|
if (scale < 0.0) scale = 0.0;
|
2009-02-02 21:09:03 -08:00
|
|
|
if (sd->scale != scale)
|
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
sd->scale = scale;
|
|
|
|
elm_widget_theme(obj);
|
2009-02-02 21:09:03 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static double
|
2018-04-05 01:47:26 -07:00
|
|
|
_efl_ui_widget_efl_gfx_entity_scale_get(const Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *sd)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2010-06-21 00:39:49 -07:00
|
|
|
// FIXME: save walking up the tree by storing/caching parent scale
|
2009-06-12 15:55:06 -07:00
|
|
|
if (sd->scale == 0.0)
|
|
|
|
{
|
2014-03-13 06:24:08 -07:00
|
|
|
if (sd->parent_obj && elm_widget_is(sd->parent_obj))
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2018-04-05 01:47:26 -07:00
|
|
|
return efl_gfx_entity_scale_get(sd->parent_obj);
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
2011-04-01 04:20:18 -07:00
|
|
|
else
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2014-03-14 02:13:29 -07:00
|
|
|
return 1.0;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
2009-06-12 15:55:06 -07:00
|
|
|
}
|
2014-03-14 02:13:29 -07:00
|
|
|
return sd->scale;
|
2009-02-02 21:09:03 -08:00
|
|
|
}
|
|
|
|
|
2017-11-17 00:24:39 -08:00
|
|
|
EAPI void
|
|
|
|
elm_widget_theme_set(Evas_Object *obj, Elm_Theme *th)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2018-05-08 18:19:38 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
if (!sd) return;
|
|
|
|
|
2013-08-22 01:00:36 -07:00
|
|
|
Eina_Bool apply = EINA_FALSE;
|
2010-05-11 18:03:46 -07:00
|
|
|
if (sd->theme != th)
|
|
|
|
{
|
2013-08-22 01:00:36 -07:00
|
|
|
if (elm_widget_theme_get(obj) != th) apply = EINA_TRUE;
|
2010-05-11 18:03:46 -07:00
|
|
|
if (sd->theme) elm_theme_free(sd->theme);
|
|
|
|
sd->theme = th;
|
2018-11-19 20:56:37 -08:00
|
|
|
if (th) efl_ref(th->eo_theme);
|
2013-08-22 01:00:36 -07:00
|
|
|
if (apply) elm_widget_theme(obj);
|
2010-05-11 18:03:46 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-30 02:14:29 -07:00
|
|
|
EAPI void
|
|
|
|
elm_widget_part_text_set(Eo *obj, const char *part, const char *label)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2017-08-30 02:14:29 -07:00
|
|
|
/* legacy support: combobox was special (internal entry is text object). */
|
|
|
|
if (efl_isa(obj, ELM_COMBOBOX_CLASS))
|
|
|
|
_elm_combobox_part_text_set(obj, part, label);
|
2018-11-16 01:45:05 -08:00
|
|
|
else if (efl_isa(obj, EFL_UI_LAYOUT_CLASS))
|
2012-05-03 15:41:26 -07:00
|
|
|
elm_layout_text_set(obj, part, label);
|
2011-06-28 23:40:59 -07:00
|
|
|
}
|
|
|
|
|
2017-08-30 02:14:29 -07:00
|
|
|
EAPI const char*
|
|
|
|
elm_widget_part_text_get(const Eo *obj, const char *part)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2017-08-30 02:14:29 -07:00
|
|
|
/* legacy support: combobox was special (internal entry is text object). */
|
|
|
|
if (efl_isa(obj, ELM_COMBOBOX_CLASS))
|
|
|
|
return _elm_combobox_part_text_get(obj, part);
|
2018-11-16 01:45:05 -08:00
|
|
|
else if (efl_isa(obj, EFL_UI_LAYOUT_CLASS))
|
2014-03-14 02:13:29 -07:00
|
|
|
return elm_layout_text_get(obj, part);
|
2011-06-28 23:40:59 -07:00
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
return NULL;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2013-04-23 00:49:49 -07:00
|
|
|
static Elm_Translate_String_Data *
|
2013-07-16 23:05:40 -07:00
|
|
|
_translate_string_data_get(Eina_Inlist *translate_strings, const char *part)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2013-04-23 00:49:49 -07:00
|
|
|
Elm_Translate_String_Data *ts;
|
|
|
|
Eina_Stringshare *str;
|
|
|
|
|
2013-07-16 23:05:40 -07:00
|
|
|
if (!translate_strings) return NULL;
|
2011-10-19 07:17:14 -07:00
|
|
|
|
|
|
|
str = eina_stringshare_add(part);
|
2013-07-16 23:05:40 -07:00
|
|
|
EINA_INLIST_FOREACH(translate_strings, ts)
|
2013-02-12 05:00:37 -08:00
|
|
|
{
|
|
|
|
if (ts->id == str) break;
|
|
|
|
}
|
2013-07-23 21:02:39 -07:00
|
|
|
|
2013-04-23 00:49:49 -07:00
|
|
|
eina_stringshare_del(str);
|
2011-10-19 07:17:14 -07:00
|
|
|
|
2013-04-23 00:49:49 -07:00
|
|
|
return ts;
|
|
|
|
}
|
2011-10-19 07:17:14 -07:00
|
|
|
|
2013-04-23 00:49:49 -07:00
|
|
|
static Elm_Translate_String_Data *
|
2013-07-16 23:05:40 -07:00
|
|
|
_part_text_translatable_set(Eina_Inlist **translate_strings, const char *part, Eina_Bool translatable, Eina_Bool preset)
|
2013-04-23 00:49:49 -07:00
|
|
|
{
|
2013-07-16 23:05:40 -07:00
|
|
|
Eina_Inlist *t;
|
2013-04-23 00:49:49 -07:00
|
|
|
Elm_Translate_String_Data *ts;
|
|
|
|
t = *translate_strings;
|
|
|
|
ts = _translate_string_data_get(t, part);
|
|
|
|
|
|
|
|
if (translatable)
|
2011-10-19 07:17:14 -07:00
|
|
|
{
|
2013-04-23 00:49:49 -07:00
|
|
|
if (!ts)
|
2011-10-19 07:17:14 -07:00
|
|
|
{
|
2013-04-23 00:49:49 -07:00
|
|
|
ts = ELM_NEW(Elm_Translate_String_Data);
|
|
|
|
if (!ts) return NULL;
|
|
|
|
|
|
|
|
ts->id = eina_stringshare_add(part);
|
2013-07-16 23:05:40 -07:00
|
|
|
t = eina_inlist_append(t, (Eina_Inlist*) ts);
|
2011-10-19 07:17:14 -07:00
|
|
|
}
|
2013-04-23 00:49:49 -07:00
|
|
|
if (preset) ts->preset = EINA_TRUE;
|
|
|
|
}
|
|
|
|
//Delete this exist one if this part has been not preset.
|
|
|
|
//see elm_widget_part_text_translatable_set()
|
2014-10-18 22:55:02 -07:00
|
|
|
else if (ts && ((preset) || (!ts->preset)))
|
2013-04-23 00:49:49 -07:00
|
|
|
{
|
2014-10-18 22:55:02 -07:00
|
|
|
t = eina_inlist_remove(t, EINA_INLIST_GET(ts));
|
|
|
|
eina_stringshare_del(ts->id);
|
|
|
|
eina_stringshare_del(ts->domain);
|
|
|
|
eina_stringshare_del(ts->string);
|
|
|
|
ELM_SAFE_FREE(ts, free);
|
2011-10-19 07:17:14 -07:00
|
|
|
}
|
|
|
|
|
2013-02-12 05:00:37 -08:00
|
|
|
*translate_strings = t;
|
2013-04-23 00:49:49 -07:00
|
|
|
|
|
|
|
return ts;
|
2013-02-12 05:00:37 -08:00
|
|
|
}
|
|
|
|
|
2017-09-24 23:33:31 -07:00
|
|
|
/* internal */
|
|
|
|
void
|
|
|
|
elm_widget_part_translatable_text_set(Eo *obj, const char *part, const char *label, const char *domain)
|
2013-02-12 05:00:37 -08:00
|
|
|
{
|
2013-04-23 00:49:49 -07:00
|
|
|
Elm_Translate_String_Data *ts;
|
2017-09-24 23:33:31 -07:00
|
|
|
Elm_Widget_Smart_Data *sd;
|
|
|
|
|
|
|
|
sd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
if (!sd) return;
|
2013-02-12 05:00:37 -08:00
|
|
|
|
2013-04-23 00:49:49 -07:00
|
|
|
if (!label)
|
|
|
|
{
|
|
|
|
_part_text_translatable_set(&sd->translate_strings, part, EINA_FALSE,
|
|
|
|
EINA_FALSE);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ts = _part_text_translatable_set(&sd->translate_strings, part,
|
|
|
|
EINA_TRUE, EINA_FALSE);
|
|
|
|
if (!ts) return;
|
|
|
|
if (!ts->string) ts->string = eina_stringshare_add(label);
|
|
|
|
else eina_stringshare_replace(&ts->string, label);
|
|
|
|
if (!ts->domain) ts->domain = eina_stringshare_add(domain);
|
|
|
|
else eina_stringshare_replace(&ts->domain, domain);
|
2011-10-19 07:17:14 -07:00
|
|
|
#ifdef HAVE_GETTEXT
|
2014-03-14 02:13:29 -07:00
|
|
|
if (label[0]) label = dgettext(domain, label);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
sd->on_translate = EINA_TRUE;
|
2017-08-30 02:14:29 -07:00
|
|
|
elm_widget_part_text_set(obj, part, label);
|
2014-03-14 02:13:29 -07:00
|
|
|
sd->on_translate = EINA_FALSE;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2017-09-24 23:47:03 -07:00
|
|
|
/* legacy only */
|
|
|
|
EAPI void
|
|
|
|
elm_widget_domain_part_text_translatable_set(Eo *obj, const char *part, const char *domain, Eina_Bool translatable)
|
2013-02-12 05:00:37 -08:00
|
|
|
{
|
2013-04-23 00:49:49 -07:00
|
|
|
Elm_Translate_String_Data *ts;
|
2017-09-24 23:47:03 -07:00
|
|
|
Elm_Widget_Smart_Data *sd;
|
2014-04-03 09:21:05 -07:00
|
|
|
const char *text = NULL;
|
2013-04-23 00:49:49 -07:00
|
|
|
|
2017-09-24 23:47:03 -07:00
|
|
|
sd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
if (!sd) return;
|
|
|
|
|
2013-04-23 00:49:49 -07:00
|
|
|
ts = _part_text_translatable_set(&sd->translate_strings, part,
|
|
|
|
translatable, EINA_TRUE);
|
|
|
|
if (!ts) return;
|
|
|
|
if (!ts->domain) ts->domain = eina_stringshare_add(domain);
|
|
|
|
else eina_stringshare_replace(&ts->domain, domain);
|
|
|
|
|
2017-08-30 02:14:29 -07:00
|
|
|
text = elm_widget_part_text_get(obj, part);
|
2013-04-23 00:49:49 -07:00
|
|
|
if (!text || !text[0]) return;
|
|
|
|
|
|
|
|
if (!ts->string) ts->string = eina_stringshare_add(text);
|
|
|
|
|
|
|
|
//Try to translate text since we don't know the text is already translated.
|
|
|
|
#ifdef HAVE_GETTEXT
|
|
|
|
text = dgettext(domain, text);
|
|
|
|
#endif
|
|
|
|
sd->on_translate = EINA_TRUE;
|
2017-08-30 02:14:29 -07:00
|
|
|
elm_widget_part_text_set(obj, part, text);
|
2013-04-23 00:49:49 -07:00
|
|
|
sd->on_translate = EINA_FALSE;
|
2011-10-19 07:17:14 -07:00
|
|
|
}
|
|
|
|
|
2017-09-24 23:33:31 -07:00
|
|
|
/* internal */
|
|
|
|
const char *
|
|
|
|
elm_widget_part_translatable_text_get(const Eo *obj, const char *part, const char **domain)
|
2013-04-23 00:49:49 -07:00
|
|
|
{
|
2017-09-24 23:33:31 -07:00
|
|
|
Elm_Widget_Smart_Data *sd;
|
2013-04-23 00:49:49 -07:00
|
|
|
Elm_Translate_String_Data *ts;
|
|
|
|
|
2017-09-24 23:33:31 -07:00
|
|
|
if (domain) *domain = NULL;
|
2013-04-23 00:49:49 -07:00
|
|
|
|
2017-09-24 23:33:31 -07:00
|
|
|
sd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
if (!sd) return NULL;
|
|
|
|
|
|
|
|
ts = _translate_string_data_get(sd->translate_strings, part);
|
|
|
|
if (!ts) return NULL;
|
2013-04-23 00:49:49 -07:00
|
|
|
|
2017-09-24 23:33:31 -07:00
|
|
|
if (domain) *domain = ts->domain;
|
|
|
|
return ts->string;
|
2013-04-23 00:49:49 -07:00
|
|
|
}
|
|
|
|
|
2017-08-30 02:47:21 -07:00
|
|
|
EOLIAN static void
|
2018-12-21 14:46:10 -08:00
|
|
|
_efl_ui_widget_efl_ui_l10n_translation_update(Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *sd)
|
2011-10-19 07:17:14 -07:00
|
|
|
{
|
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *child;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(sd->subobjs, l, child)
|
2014-03-18 03:02:04 -07:00
|
|
|
{
|
|
|
|
if (elm_widget_is(child))
|
2018-12-21 14:46:10 -08:00
|
|
|
efl_ui_l10n_translation_update(child);
|
2014-03-18 03:02:04 -07:00
|
|
|
}
|
|
|
|
|
2018-12-21 14:46:10 -08:00
|
|
|
if (sd->hover_obj) efl_ui_l10n_translation_update(sd->hover_obj);
|
2013-04-23 00:49:49 -07:00
|
|
|
|
2011-10-19 07:17:14 -07:00
|
|
|
#ifdef HAVE_GETTEXT
|
2013-04-23 00:49:49 -07:00
|
|
|
Elm_Translate_String_Data *ts;
|
2013-07-16 23:05:40 -07:00
|
|
|
EINA_INLIST_FOREACH(sd->translate_strings, ts)
|
2011-10-19 07:17:14 -07:00
|
|
|
{
|
2013-04-23 00:49:49 -07:00
|
|
|
if (!ts->string) continue;
|
2011-10-19 07:17:14 -07:00
|
|
|
const char *s = dgettext(ts->domain, ts->string);
|
2013-04-23 00:49:49 -07:00
|
|
|
sd->on_translate = EINA_TRUE;
|
2017-08-30 02:14:29 -07:00
|
|
|
elm_widget_part_text_set(obj, ts->id, s);
|
2013-04-23 00:49:49 -07:00
|
|
|
sd->on_translate = EINA_FALSE;
|
2011-10-19 07:17:14 -07:00
|
|
|
}
|
|
|
|
#endif
|
2017-10-23 22:29:16 -07:00
|
|
|
efl_event_callback_legacy_call(obj, EFL_UI_WIDGET_EVENT_LANGUAGE_CHANGED, NULL);
|
2011-10-19 07:17:14 -07:00
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_access_info_set(Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *sd, const char *txt)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2017-08-23 23:31:05 -07:00
|
|
|
eina_stringshare_replace(&sd->access_info, txt);
|
2011-08-19 04:47:30 -07:00
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static const char*
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_access_info_get(const Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *sd)
|
2010-05-11 18:03:46 -07:00
|
|
|
{
|
2014-03-14 02:13:29 -07:00
|
|
|
return sd->access_info;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2017-11-17 00:24:39 -08:00
|
|
|
EAPI Elm_Theme *
|
|
|
|
elm_widget_theme_get(const Evas_Object *obj)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2018-05-08 18:19:38 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
if (!sd) return NULL;
|
2017-11-17 00:24:39 -08:00
|
|
|
|
2010-05-11 18:03:46 -07:00
|
|
|
if (!sd->theme)
|
|
|
|
{
|
2014-03-13 06:24:08 -07:00
|
|
|
if (sd->parent_obj && elm_widget_is(sd->parent_obj))
|
2014-03-14 02:13:29 -07:00
|
|
|
return elm_widget_theme_get(sd->parent_obj);
|
|
|
|
else return NULL;
|
2010-05-11 18:03:46 -07:00
|
|
|
}
|
2014-03-14 02:13:29 -07:00
|
|
|
return sd->theme;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
2011-03-09 23:22:22 -08:00
|
|
|
|
2018-11-19 20:56:37 -08:00
|
|
|
EOLIAN static Efl_Ui_Theme_Apply_Result
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_style_set(Eo *obj, Elm_Widget_Smart_Data *sd, const char *style)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2017-11-06 21:00:43 -08:00
|
|
|
if (!elm_widget_is_legacy(obj) && efl_finalized_get(obj))
|
2017-08-09 00:22:48 -07:00
|
|
|
{
|
|
|
|
ERR("Efl.Ui.Widget.style can only be set before finalize!");
|
2018-11-19 20:56:37 -08:00
|
|
|
return EFL_UI_THEME_APPLY_RESULT_FAIL;
|
2017-08-09 00:22:48 -07:00
|
|
|
}
|
|
|
|
|
2010-03-13 13:01:26 -08:00
|
|
|
if (eina_stringshare_replace(&sd->style, style))
|
2014-03-14 02:13:29 -07:00
|
|
|
return elm_widget_theme(obj);
|
2012-03-06 10:39:53 -08:00
|
|
|
|
2018-11-19 20:56:37 -08:00
|
|
|
return EFL_UI_THEME_APPLY_RESULT_SUCCESS;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static const char*
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_style_get(const Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *sd)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2014-03-14 02:13:29 -07:00
|
|
|
const char *ret;
|
|
|
|
ret = "default";
|
|
|
|
if (sd->style) ret = sd->style;
|
2009-04-22 21:03:27 -07:00
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
return ret;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2017-08-23 00:04:49 -07:00
|
|
|
EAPI void
|
|
|
|
elm_widget_tooltip_add(Eo *obj, Elm_Tooltip *tt)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2017-08-23 00:04:49 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
if (!sd) return;
|
|
|
|
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
sd->tooltips = eina_list_append(sd->tooltips, tt);
|
|
|
|
}
|
|
|
|
|
2017-08-23 00:04:49 -07:00
|
|
|
EAPI void
|
|
|
|
elm_widget_tooltip_del(Eo *obj, Elm_Tooltip *tt)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2017-08-23 00:04:49 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
if (!sd) return;
|
|
|
|
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
sd->tooltips = eina_list_remove(sd->tooltips, tt);
|
2010-09-10 17:52:33 -07:00
|
|
|
}
|
2010-05-07 06:21:45 -07:00
|
|
|
|
2017-06-14 04:17:29 -07:00
|
|
|
EAPI void
|
|
|
|
elm_widget_cursor_add(Eo *obj, Elm_Cursor *cur)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2017-06-14 04:17:29 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
if (!sd) return;
|
|
|
|
|
2010-09-25 15:01:19 -07:00
|
|
|
sd->cursors = eina_list_append(sd->cursors, cur);
|
|
|
|
}
|
|
|
|
|
2017-06-14 04:17:29 -07:00
|
|
|
EAPI void
|
|
|
|
elm_widget_cursor_del(Eo *obj, Elm_Cursor *cur)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2017-06-14 04:17:29 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
if (!sd) return;
|
|
|
|
|
2010-09-25 15:01:19 -07:00
|
|
|
sd->cursors = eina_list_remove(sd->cursors, cur);
|
|
|
|
}
|
|
|
|
|
2017-08-29 02:15:33 -07:00
|
|
|
EAPI void
|
|
|
|
elm_widget_scroll_lock_set(Eo *obj, Efl_Ui_Scroll_Block block)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2017-08-29 02:15:33 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
Eina_Bool lx, ly;
|
2010-05-07 06:21:45 -07:00
|
|
|
|
2017-08-29 02:15:33 -07:00
|
|
|
if (!sd) return;
|
|
|
|
lx = !!(block & EFL_UI_SCROLL_BLOCK_HORIZONTAL);
|
|
|
|
ly = !!(block & EFL_UI_SCROLL_BLOCK_VERTICAL);
|
|
|
|
if (sd->scroll_x_locked != lx)
|
|
|
|
{
|
|
|
|
sd->scroll_x_locked = lx;
|
|
|
|
_propagate_x_drag_lock(obj, lx ? 1 : -1);
|
|
|
|
}
|
|
|
|
if (sd->scroll_y_locked != ly)
|
|
|
|
{
|
|
|
|
sd->scroll_y_locked = ly;
|
|
|
|
_propagate_y_drag_lock(obj, ly ? 1 : -1);
|
|
|
|
}
|
2010-05-07 06:21:45 -07:00
|
|
|
}
|
|
|
|
|
2017-08-29 02:15:33 -07:00
|
|
|
EAPI Efl_Ui_Scroll_Block
|
|
|
|
elm_widget_scroll_lock_get(const Eo *obj)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2017-08-29 02:15:33 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
Efl_Ui_Scroll_Block block = EFL_UI_SCROLL_BLOCK_NONE;
|
2010-05-07 06:21:45 -07:00
|
|
|
|
2017-08-29 02:15:33 -07:00
|
|
|
if (!sd) return block;
|
|
|
|
if (sd->scroll_x_locked) block |= EFL_UI_SCROLL_BLOCK_HORIZONTAL;
|
|
|
|
if (sd->scroll_y_locked) block |= EFL_UI_SCROLL_BLOCK_VERTICAL;
|
|
|
|
|
|
|
|
return block;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2017-08-29 00:46:12 -07:00
|
|
|
EAPI int
|
2017-08-29 00:49:43 -07:00
|
|
|
elm_widget_scroll_child_locked_x_get(const Eo *obj)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2017-08-29 00:46:12 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
if (!sd) return EINA_FALSE;
|
2014-03-14 02:13:29 -07:00
|
|
|
return sd->child_drag_x_locked;
|
2010-05-07 06:21:45 -07:00
|
|
|
}
|
|
|
|
|
2017-08-29 00:46:12 -07:00
|
|
|
EAPI int
|
2017-08-29 00:49:43 -07:00
|
|
|
elm_widget_scroll_child_locked_y_get(const Eo *obj)
|
2010-09-13 00:56:23 -07:00
|
|
|
{
|
2017-08-29 00:46:12 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
if (!sd) return EINA_FALSE;
|
2014-03-14 02:13:29 -07:00
|
|
|
return sd->child_drag_y_locked;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2018-11-19 20:56:37 -08:00
|
|
|
EAPI Efl_Ui_Theme_Apply_Result
|
2017-11-17 00:24:39 -08:00
|
|
|
elm_widget_theme_object_set(Evas_Object *obj, Evas_Object *edj, const char *wname, const char *welement, const char *wstyle)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2018-05-08 18:19:38 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
|
2018-11-19 20:56:37 -08:00
|
|
|
if (!sd) return EFL_UI_THEME_APPLY_RESULT_FAIL;
|
2017-11-17 00:24:39 -08:00
|
|
|
|
2017-11-14 02:59:42 -08:00
|
|
|
if (eina_streq(welement, "base"))
|
|
|
|
welement = NULL;
|
|
|
|
if (eina_streq(wstyle, "default"))
|
|
|
|
wstyle = NULL;
|
2018-11-19 20:56:37 -08:00
|
|
|
Efl_Ui_Theme_Apply_Result ret = _elm_theme_object_set(obj, edj, wname, welement, wstyle);
|
theme: return enum from elm_widget_style_set instead of bool
Summary:
if trying to apply incorrect theme, widget apply default theme and return TRUE.
so there is no way to check it really apply correct theme.
To resolve this problem, _elm_theme_set return three type enum
* related history : 4ca3ef45146e05908a13d1010909abeba9693ad6
* elm_object_style_set is public api, so I didn't change it.
* typedef name [ Theme_Apply ] is temporarily, please suggest better one.
@fix
Reviewers: singh.amitesh, herb, Hermet, cedric, jpeg, raster
Subscribers: cedric, jpeg
Differential Revision: https://phab.enlightenment.org/D4073
2016-06-30 23:09:42 -07:00
|
|
|
if (!ret)
|
2013-02-25 20:46:27 -08:00
|
|
|
{
|
2018-11-19 20:56:37 -08:00
|
|
|
return EFL_UI_THEME_APPLY_RESULT_FAIL;
|
2013-02-25 20:46:27 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (sd->orient_mode != -1)
|
2013-02-15 03:06:19 -08:00
|
|
|
{
|
2013-02-19 00:22:15 -08:00
|
|
|
char buf[128];
|
2018-04-26 04:24:09 -07:00
|
|
|
|
|
|
|
if (elm_widget_is_legacy(obj))
|
|
|
|
{
|
|
|
|
snprintf(buf, sizeof(buf), "elm,state,orient,%d", sd->orient_mode);
|
|
|
|
elm_widget_signal_emit(obj, buf, "elm");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
snprintf(buf, sizeof(buf), "efl,state,orient,%d", sd->orient_mode);
|
|
|
|
elm_widget_signal_emit(obj, buf, "efl");
|
|
|
|
}
|
2013-02-15 03:06:19 -08:00
|
|
|
}
|
2013-02-16 03:11:25 -08:00
|
|
|
|
theme: return enum from elm_widget_style_set instead of bool
Summary:
if trying to apply incorrect theme, widget apply default theme and return TRUE.
so there is no way to check it really apply correct theme.
To resolve this problem, _elm_theme_set return three type enum
* related history : 4ca3ef45146e05908a13d1010909abeba9693ad6
* elm_object_style_set is public api, so I didn't change it.
* typedef name [ Theme_Apply ] is temporarily, please suggest better one.
@fix
Reviewers: singh.amitesh, herb, Hermet, cedric, jpeg, raster
Subscribers: cedric, jpeg
Differential Revision: https://phab.enlightenment.org/D4073
2016-06-30 23:09:42 -07:00
|
|
|
return ret;
|
2010-09-13 00:56:23 -07:00
|
|
|
}
|
2010-05-07 06:21:45 -07:00
|
|
|
|
2016-11-04 09:43:40 -07:00
|
|
|
static void
|
2016-11-16 09:58:57 -08:00
|
|
|
_convert(Efl_Dbg_Info *info, Eina_Iterator *ptr_list)
|
2016-11-04 09:43:40 -07:00
|
|
|
{
|
|
|
|
void *p;
|
|
|
|
int i = 0;
|
|
|
|
|
2016-11-16 09:58:57 -08:00
|
|
|
EINA_ITERATOR_FOREACH(ptr_list, p)
|
2016-11-04 09:43:40 -07:00
|
|
|
{
|
|
|
|
char name[100];
|
|
|
|
|
|
|
|
snprintf(name, sizeof(name), "Candidate %d", i);
|
|
|
|
|
|
|
|
EFL_DBG_INFO_APPEND(info, name, EINA_VALUE_TYPE_UINT64, p);
|
|
|
|
i++;
|
|
|
|
}
|
2016-11-16 09:58:57 -08:00
|
|
|
|
|
|
|
eina_iterator_free(ptr_list);
|
2016-11-04 09:43:40 -07:00
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_efl_object_dbg_info_get(Eo *eo_obj, Elm_Widget_Smart_Data *_pd EINA_UNUSED, Efl_Dbg_Info *root)
|
2013-01-28 22:37:01 -08:00
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_dbg_info_get(efl_super(eo_obj, MY_CLASS), root);
|
2016-11-04 09:43:40 -07:00
|
|
|
Efl_Ui_Focus_Relations *rel = NULL;
|
|
|
|
Efl_Dbg_Info *focus, *group = EFL_DBG_INFO_LIST_APPEND(root, MY_CLASS_NAME);
|
2013-01-28 22:37:01 -08:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
EFL_DBG_INFO_APPEND(group, "Wid-Type", EINA_VALUE_TYPE_STRING, elm_widget_type_get(eo_obj));
|
|
|
|
EFL_DBG_INFO_APPEND(group, "Style", EINA_VALUE_TYPE_STRING, elm_widget_style_get(eo_obj));
|
|
|
|
EFL_DBG_INFO_APPEND(group, "Layer", EINA_VALUE_TYPE_INT,
|
2013-01-28 22:37:01 -08:00
|
|
|
(int) evas_object_layer_get(eo_obj));
|
2016-08-15 06:44:41 -07:00
|
|
|
EFL_DBG_INFO_APPEND(group, "Scale", EINA_VALUE_TYPE_DOUBLE,
|
2013-01-28 22:37:01 -08:00
|
|
|
evas_object_scale_get(eo_obj));
|
2016-08-15 06:44:41 -07:00
|
|
|
EFL_DBG_INFO_APPEND(group, "Has focus", EINA_VALUE_TYPE_CHAR,
|
2013-01-28 22:37:01 -08:00
|
|
|
elm_object_focus_get(eo_obj));
|
2016-11-04 09:43:40 -07:00
|
|
|
EFL_DBG_INFO_APPEND(group, "Can focus", EINA_VALUE_TYPE_CHAR,
|
|
|
|
elm_widget_can_focus_get(eo_obj));
|
2016-08-15 06:44:41 -07:00
|
|
|
EFL_DBG_INFO_APPEND(group, "Disabled", EINA_VALUE_TYPE_CHAR,
|
2013-01-28 22:37:01 -08:00
|
|
|
elm_widget_disabled_get(eo_obj));
|
2016-08-15 06:44:41 -07:00
|
|
|
EFL_DBG_INFO_APPEND(group, "Mirrored", EINA_VALUE_TYPE_CHAR,
|
2017-06-13 03:41:15 -07:00
|
|
|
efl_ui_mirrored_get(eo_obj));
|
2016-12-21 12:40:52 -08:00
|
|
|
EFL_DBG_INFO_APPEND(group, "Tree Unfocusable", EINA_VALUE_TYPE_CHAR,
|
|
|
|
elm_widget_tree_unfocusable_get(eo_obj));
|
2016-08-15 06:44:41 -07:00
|
|
|
EFL_DBG_INFO_APPEND(group, "Automatic mirroring", EINA_VALUE_TYPE_CHAR,
|
2017-06-14 19:12:00 -07:00
|
|
|
efl_ui_mirrored_automatic_get(eo_obj));
|
2016-11-04 09:43:40 -07:00
|
|
|
|
|
|
|
rel = efl_ui_focus_manager_fetch(_pd->focus.manager, eo_obj);
|
|
|
|
if (rel)
|
|
|
|
{
|
|
|
|
focus = EFL_DBG_INFO_LIST_APPEND(group, "Focus");
|
|
|
|
|
2017-11-01 07:24:36 -07:00
|
|
|
EFL_DBG_INFO_APPEND(focus, "logical", EINA_VALUE_TYPE_CHAR, rel->logical );
|
2016-11-16 09:58:57 -08:00
|
|
|
EFL_DBG_INFO_APPEND(focus, "manager", EINA_VALUE_TYPE_UINT64, _pd->focus.manager);
|
2016-12-20 08:31:33 -08:00
|
|
|
EFL_DBG_INFO_APPEND(focus, "parent", EINA_VALUE_TYPE_UINT64, rel->parent);
|
2016-11-16 09:58:57 -08:00
|
|
|
EFL_DBG_INFO_APPEND(focus, "next", EINA_VALUE_TYPE_UINT64 , rel->next);
|
|
|
|
EFL_DBG_INFO_APPEND(focus, "prev", EINA_VALUE_TYPE_UINT64 , rel->prev);
|
2016-12-20 08:31:33 -08:00
|
|
|
|
2016-11-16 09:58:57 -08:00
|
|
|
EFL_DBG_INFO_APPEND(focus, "redirect", EINA_VALUE_TYPE_UINT64 , rel->redirect);
|
2016-11-04 09:43:40 -07:00
|
|
|
|
|
|
|
#define ADD_PTR_LIST(name) \
|
2016-11-16 09:58:57 -08:00
|
|
|
Efl_Dbg_Info* name = EFL_DBG_INFO_LIST_APPEND(focus, ""#name""); \
|
|
|
|
_convert(name, eina_list_iterator_new(rel->name));
|
2016-11-04 09:43:40 -07:00
|
|
|
|
|
|
|
ADD_PTR_LIST(top)
|
|
|
|
ADD_PTR_LIST(down)
|
|
|
|
ADD_PTR_LIST(right)
|
|
|
|
ADD_PTR_LIST(left)
|
|
|
|
|
|
|
|
#undef ADD_PTR_LIST
|
|
|
|
|
|
|
|
}
|
2016-11-16 09:58:57 -08:00
|
|
|
|
2017-06-05 10:58:01 -07:00
|
|
|
//if thats a focus manager, give useful information like the border elements
|
2017-07-05 03:48:52 -07:00
|
|
|
if (efl_isa(eo_obj, EFL_UI_FOCUS_MANAGER_INTERFACE))
|
2016-11-16 09:58:57 -08:00
|
|
|
{
|
|
|
|
Efl_Dbg_Info *border;
|
|
|
|
|
|
|
|
focus = EFL_DBG_INFO_LIST_APPEND(group, "Focus Manager");
|
|
|
|
border = EFL_DBG_INFO_LIST_APPEND(focus, "Border Elements");
|
|
|
|
|
|
|
|
_convert(border,
|
|
|
|
efl_ui_focus_manager_border_elements_get(eo_obj)
|
|
|
|
);
|
|
|
|
|
|
|
|
EFL_DBG_INFO_APPEND(focus, "redirect", EINA_VALUE_TYPE_UINT64,
|
|
|
|
efl_ui_focus_manager_redirect_get(eo_obj));
|
|
|
|
}
|
2013-01-28 22:37:01 -08:00
|
|
|
}
|
|
|
|
|
2011-08-28 07:12:38 -07:00
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_widget_is_check(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
static int abort_on_warn = -1;
|
|
|
|
if (elm_widget_is(obj))
|
2012-08-30 09:47:10 -07:00
|
|
|
return EINA_TRUE;
|
2011-08-28 07:12:38 -07:00
|
|
|
|
|
|
|
ERR("Passing Object: %p.", obj);
|
|
|
|
if (abort_on_warn == -1)
|
|
|
|
{
|
|
|
|
if (getenv("ELM_ERROR_ABORT")) abort_on_warn = 1;
|
|
|
|
else abort_on_warn = 0;
|
|
|
|
}
|
|
|
|
if (abort_on_warn == 1) abort();
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2018-02-14 12:04:24 -08:00
|
|
|
/* If you changed a legacy widget's class name,
|
|
|
|
* please update the "legacy_type_table". */
|
2012-08-30 09:46:59 -07:00
|
|
|
EAPI const char *
|
|
|
|
elm_widget_type_get(const Evas_Object *obj)
|
|
|
|
{
|
2018-02-14 12:04:24 -08:00
|
|
|
const char *ret;
|
|
|
|
int i;
|
|
|
|
|
2012-08-30 09:46:59 -07:00
|
|
|
API_ENTRY return NULL;
|
|
|
|
|
2018-02-14 12:04:24 -08:00
|
|
|
ret = efl_class_name_get(efl_class_get(obj));
|
|
|
|
|
|
|
|
/* If the given widget is created for legacy,
|
|
|
|
* convert type name to legacy. */
|
|
|
|
if (elm_widget_is_legacy(obj))
|
|
|
|
{
|
|
|
|
for (i = 0; legacy_type_table[i][0] ; i++)
|
|
|
|
{
|
|
|
|
if (eina_streq(ret, legacy_type_table[i][0]))
|
|
|
|
return legacy_type_table[i][1];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
2012-08-30 09:46:59 -07:00
|
|
|
}
|
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
EAPI Eina_Bool
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_type_check(const Evas_Object *obj,
|
2012-08-30 09:47:10 -07:00
|
|
|
const char *type,
|
|
|
|
const char *func)
|
2008-09-29 23:58:56 -07:00
|
|
|
{
|
2010-09-13 00:56:23 -07:00
|
|
|
const char *provided, *expected = "(unknown)";
|
|
|
|
static int abort_on_warn = -1;
|
2012-08-30 09:46:59 -07:00
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
provided = elm_widget_type_get(obj);
|
2012-05-03 15:41:26 -07:00
|
|
|
/* TODO: eventually migrate to check_ptr version */
|
2012-08-30 09:46:59 -07:00
|
|
|
if (evas_object_smart_type_check(obj, type)) return EINA_TRUE;
|
2010-09-13 00:56:23 -07:00
|
|
|
if (type) expected = type;
|
2010-10-22 14:41:27 -07:00
|
|
|
if ((!provided) || (!provided[0]))
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
2010-09-13 00:56:23 -07:00
|
|
|
provided = evas_object_type_get(obj);
|
2010-10-22 14:41:27 -07:00
|
|
|
if ((!provided) || (!provided[0]))
|
2011-04-01 04:20:18 -07:00
|
|
|
provided = "(unknown)";
|
2008-10-07 23:38:20 -07:00
|
|
|
}
|
2012-08-30 09:47:10 -07:00
|
|
|
ERR("Passing Object: %p in function: %s, of type: '%s' when expecting"
|
|
|
|
" type: '%s'", obj, func, provided, expected);
|
2010-09-13 00:56:23 -07:00
|
|
|
if (abort_on_warn == -1)
|
2008-10-07 23:38:20 -07:00
|
|
|
{
|
2010-09-13 00:56:23 -07:00
|
|
|
if (getenv("ELM_ERROR_ABORT")) abort_on_warn = 1;
|
|
|
|
else abort_on_warn = 0;
|
2008-10-07 23:38:20 -07:00
|
|
|
}
|
2010-09-13 00:56:23 -07:00
|
|
|
if (abort_on_warn == 1) abort();
|
|
|
|
return EINA_FALSE;
|
2008-09-29 23:58:56 -07:00
|
|
|
}
|
|
|
|
|
2017-08-23 04:32:58 -07:00
|
|
|
/** @internal */
|
|
|
|
EAPI Evas_Object *
|
|
|
|
elm_widget_name_find(const Eo *obj, const char *name, int recurse)
|
2011-12-27 21:51:10 -08:00
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
Evas_Object *child;
|
|
|
|
const char *s;
|
|
|
|
INTERNAL_ENTRY NULL;
|
2012-03-28 02:02:22 -07:00
|
|
|
|
2017-08-23 04:32:58 -07:00
|
|
|
if (!name) return NULL;
|
2011-12-27 21:51:10 -08:00
|
|
|
if (!_elm_widget_is(obj)) return NULL;
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(sd->subobjs, l, child)
|
2011-12-27 21:51:10 -08:00
|
|
|
{
|
|
|
|
s = evas_object_name_get(child);
|
|
|
|
if ((s) && (!strcmp(s, name))) return child;
|
2012-03-28 02:02:22 -07:00
|
|
|
if ((recurse != 0) &&
|
2017-08-23 04:32:58 -07:00
|
|
|
((child = elm_widget_name_find(child, name, recurse - 1))))
|
2011-12-27 21:51:10 -08:00
|
|
|
return child;
|
|
|
|
}
|
|
|
|
if (sd->hover_obj)
|
|
|
|
{
|
|
|
|
s = evas_object_name_get(sd->hover_obj);
|
|
|
|
if ((s) && (!strcmp(s, name))) return sd->hover_obj;
|
2012-03-28 02:02:22 -07:00
|
|
|
if ((recurse != 0) &&
|
2017-08-23 04:32:58 -07:00
|
|
|
((child = elm_widget_name_find(sd->hover_obj, name, recurse - 1))))
|
2011-12-27 21:51:10 -08:00
|
|
|
return child;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-10-21 11:58:40 -07:00
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2010-10-21 11:58:40 -07:00
|
|
|
* Split string in words
|
|
|
|
*
|
|
|
|
* @param str Source string
|
|
|
|
* @return List of const words
|
|
|
|
*
|
|
|
|
* @see elm_widget_stringlist_free()
|
2010-12-07 11:17:50 -08:00
|
|
|
* @ingroup Widget
|
2010-10-21 11:58:40 -07:00
|
|
|
*/
|
2010-09-13 00:56:23 -07:00
|
|
|
EAPI Eina_List *
|
|
|
|
elm_widget_stringlist_get(const char *str)
|
2010-06-21 00:39:49 -07:00
|
|
|
{
|
2010-09-13 00:56:23 -07:00
|
|
|
Eina_List *list = NULL;
|
|
|
|
const char *s, *b;
|
|
|
|
if (!str) return NULL;
|
|
|
|
for (b = s = str; 1; s++)
|
2010-06-21 00:39:49 -07:00
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
if ((*s == ' ') || (!*s))
|
|
|
|
{
|
|
|
|
char *t = malloc(s - b + 1);
|
|
|
|
if (t)
|
|
|
|
{
|
|
|
|
strncpy(t, b, s - b);
|
|
|
|
t[s - b] = 0;
|
|
|
|
list = eina_list_append(list, eina_stringshare_add(t));
|
|
|
|
free(t);
|
|
|
|
}
|
|
|
|
b = s + 1;
|
|
|
|
}
|
|
|
|
if (!*s) break;
|
2010-06-21 00:39:49 -07:00
|
|
|
}
|
2010-09-13 00:56:23 -07:00
|
|
|
return list;
|
2010-06-21 00:39:49 -07:00
|
|
|
}
|
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
EAPI void
|
|
|
|
elm_widget_stringlist_free(Eina_List *list)
|
2010-06-23 19:54:03 -07:00
|
|
|
{
|
2010-09-13 00:56:23 -07:00
|
|
|
const char *s;
|
2013-03-08 20:23:42 -08:00
|
|
|
EINA_LIST_FREE(list, s)
|
2012-08-30 09:47:10 -07:00
|
|
|
eina_stringshare_del(s);
|
2010-06-23 19:54:03 -07:00
|
|
|
}
|
|
|
|
|
2017-10-10 02:53:43 -07:00
|
|
|
/* internal */
|
|
|
|
EAPI void
|
|
|
|
elm_widget_focus_mouse_up_handle(Eo *obj)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2017-10-10 02:53:43 -07:00
|
|
|
Elm_Widget_Smart_Data *pd = efl_data_scope_get(obj, MY_CLASS);
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
if (!_is_focusable(obj)) return;
|
2016-08-26 21:48:35 -07:00
|
|
|
|
2016-12-20 08:31:33 -08:00
|
|
|
if (pd->focus.manager && !pd->focus.logical)
|
|
|
|
{
|
2019-02-09 09:45:27 -08:00
|
|
|
efl_ui_focus_util_focus(obj);
|
2016-12-20 08:31:33 -08:00
|
|
|
}
|
2011-04-14 05:47:16 -07:00
|
|
|
}
|
|
|
|
|
2017-08-23 01:01:03 -07:00
|
|
|
static void
|
2017-09-27 12:20:51 -07:00
|
|
|
_elm_widget_focus_tree_unfocusable_handle(Eo *obj EINA_UNUSED)
|
2013-03-07 23:23:34 -08:00
|
|
|
{
|
2017-09-27 12:20:51 -07:00
|
|
|
//FIXME
|
2013-03-07 23:23:34 -08:00
|
|
|
}
|
|
|
|
|
2014-03-09 03:17:30 -07:00
|
|
|
/*
|
|
|
|
* @internal
|
|
|
|
*
|
2017-04-23 01:02:14 -07:00
|
|
|
* Get the focus highlight geometry of a widget.
|
2014-03-09 03:17:30 -07:00
|
|
|
*
|
|
|
|
* @param obj Widget object for the focus highlight
|
|
|
|
* @param x Focus highlight x coordinate
|
|
|
|
* @param y Focus highlight y coordinate
|
|
|
|
* @param w Focus highlight object width
|
|
|
|
* @param h Focus highlight object height
|
|
|
|
* @param is_next @c EINA_TRUE if this request is for the new focused object,
|
|
|
|
* @c EINA_FALSE if this request is for the previously focused object. This
|
|
|
|
* information becomes important when the focus highlight is changed inside one
|
|
|
|
* widget.
|
|
|
|
*
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
|
|
|
/*
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Get the 'focus_part' geometry if there is any
|
|
|
|
*
|
|
|
|
* This queries if there is a 'focus_part' request from the edc style. If edc
|
|
|
|
* style offers 'focus_part' edje data item, this function requests for the
|
|
|
|
* geometry of a specific part which is described in 'focus_part' edje data.
|
|
|
|
*
|
|
|
|
* @param obj Widget object for the focus highlight
|
|
|
|
* @param x Focus highlight x coordinate
|
|
|
|
* @param y Focus highlight y coordinate
|
|
|
|
* @param w Focus highlight object width
|
|
|
|
* @param h Focus highlight object height
|
|
|
|
*
|
|
|
|
* x, y, w, h already contain the object's geometry. If there is a 'focus_part'
|
|
|
|
* support, these values will be updated accordingly or the values will be
|
|
|
|
* remained as they were.
|
|
|
|
*
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
2014-02-18 06:40:48 -08:00
|
|
|
EAPI void
|
|
|
|
elm_widget_focus_highlight_focus_part_geometry_get(const Evas_Object *obj,
|
|
|
|
Evas_Coord *x,
|
|
|
|
Evas_Coord *y,
|
|
|
|
Evas_Coord *w,
|
|
|
|
Evas_Coord *h)
|
2014-02-09 02:53:54 -08:00
|
|
|
{
|
|
|
|
Evas_Coord tx = 0, ty = 0, tw = 0, th = 0;
|
|
|
|
const char *target_hl_part = NULL;
|
2014-02-18 06:40:48 -08:00
|
|
|
const Evas_Object *edje_obj = NULL;
|
2014-02-09 02:53:54 -08:00
|
|
|
|
2017-12-05 19:15:39 -08:00
|
|
|
if (obj && efl_isa(obj, EFL_CANVAS_LAYOUT_CLASS))
|
2014-02-09 02:53:54 -08:00
|
|
|
{
|
2014-02-18 06:40:48 -08:00
|
|
|
edje_obj = obj;
|
2014-02-09 02:53:54 -08:00
|
|
|
if (!(target_hl_part = edje_object_data_get(edje_obj, "focus_part")))
|
|
|
|
return;
|
|
|
|
}
|
2018-11-16 01:45:05 -08:00
|
|
|
else if (obj && efl_isa(obj, EFL_UI_LAYOUT_CLASS))
|
2014-02-09 02:53:54 -08:00
|
|
|
{
|
2014-02-18 06:40:48 -08:00
|
|
|
edje_obj = elm_layout_edje_get(obj);
|
|
|
|
if (!(target_hl_part = elm_layout_data_get(obj, "focus_part")))
|
2014-02-09 02:53:54 -08:00
|
|
|
return;
|
|
|
|
}
|
2014-02-18 06:40:48 -08:00
|
|
|
else
|
|
|
|
return;
|
2014-02-09 02:53:54 -08:00
|
|
|
|
2014-02-18 06:40:48 -08:00
|
|
|
edje_object_part_geometry_get(edje_obj, target_hl_part,
|
|
|
|
&tx, &ty, &tw, &th);
|
|
|
|
*x += tx;
|
|
|
|
*y += ty;
|
|
|
|
if (tw != *w) *w = tw;
|
|
|
|
if (th != *h) *h = th;
|
|
|
|
}
|
|
|
|
|
2017-09-13 19:59:44 -07:00
|
|
|
EOLIAN static Eina_Rect
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_focus_highlight_geometry_get(const Eo *obj, Elm_Widget_Smart_Data *sd)
|
2014-02-18 06:40:48 -08:00
|
|
|
{
|
2014-05-17 03:43:44 -07:00
|
|
|
Evas_Coord ox = 0, oy = 0, ow = 0, oh = 0;
|
2015-06-25 04:21:00 -07:00
|
|
|
Evas_Object *scroller = (Evas_Object *)obj;
|
2017-09-13 19:59:44 -07:00
|
|
|
Eina_Rect r = {};
|
2014-05-17 03:43:44 -07:00
|
|
|
|
2017-08-28 23:59:40 -07:00
|
|
|
evas_object_geometry_get(obj, &r.x, &r.y, &r.w, &r.h);
|
|
|
|
elm_widget_focus_highlight_focus_part_geometry_get(sd->resize_obj, &r.x, &r.y, &r.w, &r.h);
|
2014-05-17 03:43:44 -07:00
|
|
|
|
2014-05-17 04:20:52 -07:00
|
|
|
if (_elm_config->focus_autoscroll_mode != ELM_FOCUS_AUTOSCROLL_MODE_BRING_IN)
|
2017-08-28 23:59:40 -07:00
|
|
|
return r;
|
2014-05-17 03:43:44 -07:00
|
|
|
|
|
|
|
while (scroller)
|
|
|
|
{
|
|
|
|
if (_elm_scrollable_is(scroller))
|
|
|
|
{
|
2016-03-02 04:10:48 -08:00
|
|
|
elm_interface_scrollable_content_viewport_geometry_get(scroller, &ox, &oy, &ow, &oh);
|
2014-05-17 03:43:44 -07:00
|
|
|
|
2017-08-28 23:59:40 -07:00
|
|
|
if (r.y < oy)
|
|
|
|
r.y = oy;
|
|
|
|
else if ((oy + oh) < (r.y + r.h))
|
|
|
|
r.y = (oy + oh - r.h);
|
|
|
|
else if (r.x < ox)
|
|
|
|
r.x = ox;
|
|
|
|
else if ((ox + ow) < (r.x + r.w))
|
|
|
|
r.x = (ox + ow - r.w);
|
2014-05-17 03:43:44 -07:00
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
scroller = elm_widget_parent_get(scroller);
|
|
|
|
}
|
2017-08-28 23:59:40 -07:00
|
|
|
|
|
|
|
return r;
|
2014-02-18 06:40:48 -08:00
|
|
|
}
|
|
|
|
|
2015-08-12 01:25:15 -07:00
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_interest_region_mode_set(Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *_pd, Elm_Focus_Region_Show_Mode mode)
|
2015-08-12 01:25:15 -07:00
|
|
|
{
|
|
|
|
_pd->focus_region_show_mode = mode;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Elm_Focus_Region_Show_Mode
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_interest_region_mode_get(const Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *_pd)
|
2015-08-12 01:25:15 -07:00
|
|
|
{
|
|
|
|
return _pd->focus_region_show_mode;
|
|
|
|
}
|
|
|
|
|
2012-09-16 20:01:46 -07:00
|
|
|
EAPI void
|
2017-10-15 21:33:52 -07:00
|
|
|
elm_widget_activate(Evas_Object *obj, Efl_Ui_Activate act)
|
2012-09-03 01:49:45 -07:00
|
|
|
{
|
2012-09-16 20:01:46 -07:00
|
|
|
Evas_Object *parent;
|
|
|
|
Eina_Bool ret;
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
ELM_WIDGET_CHECK(obj);
|
2012-09-03 01:49:45 -07:00
|
|
|
|
2012-09-16 20:01:46 -07:00
|
|
|
ret = EINA_FALSE;
|
2012-11-25 22:32:53 -08:00
|
|
|
|
2017-10-23 22:03:46 -07:00
|
|
|
ret = efl_ui_widget_on_access_activate(obj, act);
|
2012-09-03 01:49:45 -07:00
|
|
|
|
2012-09-16 20:01:46 -07:00
|
|
|
if (ret) return;
|
|
|
|
|
|
|
|
parent = elm_widget_parent_get(obj);
|
|
|
|
if (parent)
|
|
|
|
elm_widget_activate(parent, act);
|
|
|
|
|
|
|
|
return;
|
2012-09-03 01:49:45 -07:00
|
|
|
}
|
|
|
|
|
2012-10-14 07:48:02 -07:00
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Sets the widget and child widget's Evas_Display_Mode.
|
|
|
|
*
|
|
|
|
* @param obj The widget.
|
|
|
|
* @param dispmode Evas_Display_Mode to set widget's mode.
|
|
|
|
*
|
|
|
|
* Widgets are resized by several reasons.
|
2012-10-14 18:22:12 -07:00
|
|
|
* Evas_Display_Mode can help for widgets to get one more reason of resize.
|
|
|
|
* For example, elm conform widget resizes it's contents when keypad state changed.
|
2012-10-14 07:48:02 -07:00
|
|
|
* After keypad showing, conform widget can change child's Evas_Display_Mode.
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
2017-05-31 01:58:14 -07:00
|
|
|
/* Legacy only */
|
|
|
|
EAPI void
|
|
|
|
elm_widget_display_mode_set(Evas_Object *obj, Evas_Display_Mode dispmode)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2013-05-24 02:34:37 -07:00
|
|
|
Evas_Display_Mode prev_dispmode;
|
2012-10-14 07:48:02 -07:00
|
|
|
Evas_Object *child;
|
|
|
|
Eina_List *l;
|
|
|
|
|
2017-05-31 01:58:14 -07:00
|
|
|
API_ENTRY return;
|
2013-05-24 02:34:37 -07:00
|
|
|
prev_dispmode = evas_object_size_hint_display_mode_get(obj);
|
|
|
|
|
|
|
|
if ((prev_dispmode == dispmode) ||
|
|
|
|
(prev_dispmode == EVAS_DISPLAY_MODE_DONT_CHANGE)) return;
|
|
|
|
|
2012-10-14 07:48:02 -07:00
|
|
|
evas_object_size_hint_display_mode_set(obj, dispmode);
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH (sd->subobjs, l, child)
|
2014-03-13 06:24:08 -07:00
|
|
|
{
|
|
|
|
if (elm_widget_is(child))
|
2014-03-18 03:02:04 -07:00
|
|
|
elm_widget_display_mode_set(child, dispmode);
|
2014-03-13 06:24:08 -07:00
|
|
|
}
|
2012-10-14 07:48:02 -07:00
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static void
|
2018-01-18 22:55:19 -08:00
|
|
|
_efl_ui_widget_orientation_mode_set(Eo *obj, Elm_Widget_Smart_Data *sd, Efl_Ui_Widget_Orientation_Mode mode)
|
2013-02-13 21:38:26 -08:00
|
|
|
{
|
2018-01-18 22:55:19 -08:00
|
|
|
int rotation = -1;
|
2013-02-14 20:45:53 -08:00
|
|
|
|
2018-01-18 22:55:19 -08:00
|
|
|
if (mode != EFL_UI_WIDGET_ORIENTATION_MODE_DISABLED)
|
2013-02-14 20:45:53 -08:00
|
|
|
{
|
2013-02-16 03:11:25 -08:00
|
|
|
//Get current orient mode from it's parent otherwise, 0.
|
2013-02-14 20:45:53 -08:00
|
|
|
sd->orient_mode = 0;
|
|
|
|
ELM_WIDGET_DATA_GET(sd->parent_obj, sd_parent);
|
2018-01-18 22:55:19 -08:00
|
|
|
if (!sd_parent) rotation = 0;
|
|
|
|
else rotation = sd_parent->orient_mode;
|
2013-02-14 20:45:53 -08:00
|
|
|
}
|
2018-01-18 22:55:19 -08:00
|
|
|
efl_ui_widget_on_orientation_update(obj, rotation);
|
2013-02-13 21:38:26 -08:00
|
|
|
}
|
|
|
|
|
2018-01-18 22:55:19 -08:00
|
|
|
EOLIAN static Efl_Ui_Widget_Orientation_Mode
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_orientation_mode_get(const Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *sd)
|
2013-02-13 21:38:26 -08:00
|
|
|
{
|
2018-01-18 22:55:19 -08:00
|
|
|
if (sd->orient_mode == -1) return EFL_UI_WIDGET_ORIENTATION_MODE_DISABLED;
|
|
|
|
else return EFL_UI_WIDGET_ORIENTATION_MODE_DEFAULT;
|
2013-02-13 21:38:26 -08:00
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_on_orientation_update(Eo *obj, Elm_Widget_Smart_Data *sd, int orient_mode)
|
2013-02-13 21:38:26 -08:00
|
|
|
{
|
|
|
|
Evas_Object *child;
|
|
|
|
Eina_List *l;
|
2013-02-14 20:45:53 -08:00
|
|
|
|
|
|
|
sd->orient_mode = orient_mode;
|
2013-02-13 21:38:26 -08:00
|
|
|
|
|
|
|
EINA_LIST_FOREACH (sd->subobjs, l, child)
|
2014-03-18 03:02:04 -07:00
|
|
|
{
|
|
|
|
if (elm_widget_is(child))
|
2017-10-23 22:03:46 -07:00
|
|
|
efl_ui_widget_on_orientation_update(child, orient_mode);
|
2014-03-18 03:02:04 -07:00
|
|
|
}
|
2013-02-16 03:11:25 -08:00
|
|
|
|
2013-02-25 20:46:27 -08:00
|
|
|
if (orient_mode != -1)
|
2013-02-25 20:26:22 -08:00
|
|
|
{
|
|
|
|
char buf[128];
|
2018-04-26 04:24:09 -07:00
|
|
|
|
|
|
|
if (elm_widget_is_legacy(obj))
|
|
|
|
{
|
|
|
|
snprintf(buf, sizeof(buf), "elm,state,orient,%d", orient_mode);
|
|
|
|
elm_widget_signal_emit(obj, buf, "elm");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
snprintf(buf, sizeof(buf), "efl,state,orient,%d", orient_mode);
|
|
|
|
elm_widget_signal_emit(obj, buf, "efl");
|
|
|
|
}
|
2013-02-25 20:26:22 -08:00
|
|
|
}
|
2013-02-13 21:38:26 -08:00
|
|
|
}
|
|
|
|
|
2015-06-01 21:42:00 -07:00
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Returns the widget's focus move policy.
|
|
|
|
*
|
|
|
|
* @param obj The widget.
|
|
|
|
* @return focus move policy of the object.
|
|
|
|
*
|
|
|
|
**/
|
|
|
|
EOLIAN static Elm_Focus_Move_Policy
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_focus_move_policy_get(const Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *sd)
|
2015-06-01 21:42:00 -07:00
|
|
|
{
|
|
|
|
return sd->focus_move_policy;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Sets the widget's focus move policy.
|
|
|
|
*
|
|
|
|
* @param obj The widget.
|
2015-06-01 22:46:55 -07:00
|
|
|
* @param policy Elm_Focus_Move_Policy to set object's focus move policy.
|
2015-06-01 21:42:00 -07:00
|
|
|
*/
|
|
|
|
|
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_focus_move_policy_set(Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *sd, Elm_Focus_Move_Policy policy)
|
2015-06-01 21:42:00 -07:00
|
|
|
{
|
|
|
|
if (sd->focus_move_policy == policy) return;
|
|
|
|
sd->focus_move_policy = policy;
|
|
|
|
}
|
2016-03-18 00:38:26 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the widget's focus_move_policy mode setting.
|
|
|
|
*
|
|
|
|
* @param obj The widget.
|
|
|
|
* @return focus_move_policy mode setting of the object.
|
|
|
|
*
|
|
|
|
**/
|
|
|
|
EOLIAN static Eina_Bool
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_focus_move_policy_automatic_get(const Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *sd)
|
2016-03-18 00:38:26 -07:00
|
|
|
{
|
|
|
|
return sd->focus_move_policy_auto_mode;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Sets the widget's focus_move_policy mode setting.
|
|
|
|
* When widget in automatic mode, it follows the system focus_move_policy mode set by
|
|
|
|
* elm_config_focus_move_policy_set().
|
|
|
|
* @param obj The widget.
|
|
|
|
* @param automatic EINA_TRUE for auto focus_move_policy mode. EINA_FALSE for manual.
|
|
|
|
*/
|
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_focus_move_policy_automatic_set(Eo *obj, Elm_Widget_Smart_Data *sd, Eina_Bool automatic)
|
2016-03-18 00:38:26 -07:00
|
|
|
{
|
|
|
|
if (sd->focus_move_policy_auto_mode != automatic)
|
|
|
|
{
|
|
|
|
sd->focus_move_policy_auto_mode = automatic;
|
|
|
|
|
|
|
|
if (automatic)
|
|
|
|
{
|
2017-10-23 22:03:46 -07:00
|
|
|
efl_ui_widget_focus_move_policy_set(obj, elm_config_focus_move_policy_get());
|
2016-03-18 00:38:26 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-11-14 01:42:48 -08:00
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Sets the klass name of a widget.
|
|
|
|
* @param obj The widget.
|
|
|
|
* @param name Name of the klass to use.
|
|
|
|
* @return Whether the name was different and thus replaced.
|
|
|
|
*/
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_widget_theme_klass_set(Evas_Object *obj, const char *name)
|
|
|
|
{
|
2018-05-08 18:19:38 -07:00
|
|
|
Elm_Widget_Smart_Data *pd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
if (!pd) return EINA_FALSE;
|
|
|
|
|
2017-11-14 01:42:48 -08:00
|
|
|
return eina_stringshare_replace(&(pd->klass), name);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Gets the klass name of a widget.
|
|
|
|
* @param obj The widget.
|
|
|
|
* @return The current klass name of internal canvas object.
|
|
|
|
*/
|
|
|
|
EAPI const char *
|
|
|
|
elm_widget_theme_klass_get(const Evas_Object *obj)
|
|
|
|
{
|
2018-05-08 18:19:38 -07:00
|
|
|
Elm_Widget_Smart_Data *pd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
if (!pd) return NULL;
|
|
|
|
|
2017-11-14 01:42:48 -08:00
|
|
|
return (const char *)pd->klass;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Sets the element name of a widget.
|
|
|
|
*
|
|
|
|
* @param obj The widget.
|
|
|
|
* @param name Name of the element to use.
|
|
|
|
* @return Whether the name was different and thus replaced.
|
|
|
|
*/
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_widget_theme_element_set(Evas_Object *obj, const char *name)
|
|
|
|
{
|
2018-05-08 18:19:38 -07:00
|
|
|
Elm_Widget_Smart_Data *pd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
if (!pd) return EINA_FALSE;
|
|
|
|
|
2017-11-14 02:59:42 -08:00
|
|
|
if (eina_streq(name, "base"))
|
|
|
|
name = NULL;
|
|
|
|
|
2017-11-14 01:42:48 -08:00
|
|
|
return eina_stringshare_replace(&(pd->group), name);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Gets the element name of a widget.
|
|
|
|
* @param obj The widget.
|
|
|
|
* @return The current element name of internal canvas object.
|
|
|
|
*/
|
|
|
|
EAPI const char *
|
|
|
|
elm_widget_theme_element_get(const Evas_Object *obj)
|
|
|
|
{
|
2018-05-08 18:19:38 -07:00
|
|
|
Elm_Widget_Smart_Data *pd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
if (!pd) return NULL;
|
|
|
|
|
2017-11-14 01:42:48 -08:00
|
|
|
return (const char *)pd->group;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Sets the style name of a widget.
|
|
|
|
*
|
|
|
|
* @param obj The widget.
|
|
|
|
* @param name Name of the style to use.
|
|
|
|
* @return Whether the name was different and thus replaced.
|
|
|
|
*/
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_widget_theme_style_set(Evas_Object *obj, const char *name)
|
|
|
|
{
|
2018-05-08 18:19:38 -07:00
|
|
|
Elm_Widget_Smart_Data *pd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
if (!pd) return EINA_FALSE;
|
|
|
|
|
2017-11-14 02:59:42 -08:00
|
|
|
if (eina_streq(name, "default"))
|
|
|
|
name = NULL;
|
|
|
|
|
2017-11-14 01:42:48 -08:00
|
|
|
return eina_stringshare_replace(&(pd->style), name);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Gets the style name of a widget.
|
|
|
|
* @param obj The widget.
|
|
|
|
* @return The current style name of internal canvas object.
|
|
|
|
*/
|
|
|
|
EAPI const char *
|
|
|
|
elm_widget_theme_style_get(const Evas_Object *obj)
|
|
|
|
{
|
2018-05-08 18:19:38 -07:00
|
|
|
Elm_Widget_Smart_Data *pd = efl_data_scope_safe_get(obj, MY_CLASS);
|
|
|
|
if (!pd) return NULL;
|
|
|
|
|
2017-11-14 01:42:48 -08:00
|
|
|
return (const char *)pd->style;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Register sub object as a group of a widget and re-apply its theme.
|
|
|
|
* @param obj The widget.
|
|
|
|
* @param component A sub object to be added as an element of the widget.
|
|
|
|
* @param name An element name of sub object.
|
|
|
|
* @return Whether the style was successfully applied or not.
|
|
|
|
*/
|
2018-11-19 20:56:37 -08:00
|
|
|
EAPI Efl_Ui_Theme_Apply_Result
|
2017-11-14 01:42:48 -08:00
|
|
|
elm_widget_element_update(Evas_Object *obj, Evas_Object *component, const char *name)
|
|
|
|
{
|
2018-11-19 20:56:37 -08:00
|
|
|
Efl_Ui_Theme_Apply_Result ret = EFL_UI_THEME_APPLY_RESULT_SUCCESS;
|
2017-11-14 01:42:48 -08:00
|
|
|
Eina_Bool changed = EINA_FALSE;
|
|
|
|
const char *obj_group;
|
|
|
|
Eina_Stringshare *group;
|
|
|
|
|
|
|
|
obj_group = elm_widget_theme_element_get(obj);
|
|
|
|
if (!obj_group)
|
|
|
|
group = eina_stringshare_add(name);
|
|
|
|
else
|
|
|
|
group = eina_stringshare_printf("%s/%s", elm_widget_theme_element_get(obj), name);
|
2018-01-07 20:55:35 -08:00
|
|
|
if (efl_isa(component, EFL_UI_WIDGET_CLASS))
|
2017-11-14 01:42:48 -08:00
|
|
|
{
|
|
|
|
changed |= elm_widget_theme_klass_set(component, elm_widget_theme_klass_get(obj));
|
|
|
|
changed |= elm_widget_theme_element_set(component, (const char *)group);
|
|
|
|
changed |= elm_widget_theme_style_set(component, elm_widget_theme_style_get(obj));
|
|
|
|
if (changed)
|
|
|
|
ret = efl_ui_widget_theme_apply(component);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2017-11-17 00:24:39 -08:00
|
|
|
ret = elm_widget_theme_object_set(obj, component,
|
2017-11-14 01:42:48 -08:00
|
|
|
elm_widget_theme_klass_get(obj),
|
|
|
|
(const char *)group,
|
|
|
|
elm_widget_theme_style_get(obj));
|
|
|
|
}
|
|
|
|
eina_stringshare_del(group);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-07-16 21:45:08 -07:00
|
|
|
static void
|
|
|
|
_track_obj_del(void *data, Evas *e, Evas_Object *obj, void *event_info);
|
|
|
|
|
|
|
|
static void
|
|
|
|
_track_obj_update(Evas_Object *track, Evas_Object *obj)
|
|
|
|
{
|
|
|
|
//Geometry
|
|
|
|
Evas_Coord x, y, w, h;
|
|
|
|
evas_object_geometry_get(obj, &x, &y, &w, &h);
|
2018-11-21 07:33:49 -08:00
|
|
|
evas_object_geometry_set(track, x, y, w, h);
|
2017-07-16 21:45:08 -07:00
|
|
|
|
|
|
|
//Visibility
|
|
|
|
if (evas_object_visible_get(obj)) evas_object_show(track);
|
|
|
|
else evas_object_hide(track);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_track_obj_view_update(void *data, const Efl_Event *event)
|
|
|
|
{
|
|
|
|
Elm_Widget_Item_Data *item = data;
|
|
|
|
_track_obj_update(item->track_obj, event->object);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_track_obj_view_del(void *data, const Efl_Event *event);
|
|
|
|
|
|
|
|
EFL_CALLBACKS_ARRAY_DEFINE(tracker_callbacks,
|
2019-02-21 10:01:56 -08:00
|
|
|
{ EFL_GFX_ENTITY_EVENT_SIZE_CHANGED, _track_obj_view_update },
|
|
|
|
{ EFL_GFX_ENTITY_EVENT_POSITION_CHANGED, _track_obj_view_update },
|
2018-04-05 01:47:26 -07:00
|
|
|
{ EFL_GFX_ENTITY_EVENT_SHOW, _track_obj_view_update },
|
|
|
|
{ EFL_GFX_ENTITY_EVENT_HIDE, _track_obj_view_update },
|
2017-07-16 21:45:08 -07:00
|
|
|
{ EFL_EVENT_DEL, _track_obj_view_del });
|
|
|
|
|
|
|
|
static void
|
|
|
|
_track_obj_view_del(void *data, const Efl_Event *event EINA_UNUSED)
|
|
|
|
{
|
|
|
|
Elm_Widget_Item_Data *item = data;
|
|
|
|
|
|
|
|
while (evas_object_ref_get(item->track_obj) > 0)
|
|
|
|
evas_object_unref(item->track_obj);
|
|
|
|
|
|
|
|
evas_object_event_callback_del(item->track_obj, EVAS_CALLBACK_DEL,
|
|
|
|
_track_obj_del);
|
|
|
|
evas_object_del(item->track_obj);
|
|
|
|
item->track_obj = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_track_obj_del(void *data, Evas *e EINA_UNUSED,
|
|
|
|
Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
|
|
|
|
{
|
|
|
|
Elm_Widget_Item_Data *item = data;
|
|
|
|
item->track_obj = NULL;
|
|
|
|
|
|
|
|
if (!item->view) return;
|
|
|
|
|
|
|
|
efl_event_callback_array_del(item->view, tracker_callbacks(), item);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_widget_item_signal_cb(void *data, Evas_Object *obj EINA_UNUSED, const char *emission,
|
|
|
|
const char *source)
|
|
|
|
{
|
|
|
|
Elm_Widget_Item_Signal_Data *wisd = data;
|
|
|
|
wisd->func(wisd->data, wisd->item, emission, source);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *
|
|
|
|
_elm_widget_item_signal_callback_list_get(Elm_Widget_Item_Data *item, Eina_List *position)
|
|
|
|
{
|
|
|
|
Elm_Widget_Item_Signal_Data *wisd = eina_list_data_get(position);
|
|
|
|
void *data;
|
|
|
|
|
|
|
|
item->signals = eina_list_remove_list(item->signals, position);
|
|
|
|
data = wisd->data;
|
|
|
|
|
|
|
|
if (_elm_widget_is(item->view))
|
|
|
|
elm_object_signal_callback_del(item->view,
|
|
|
|
wisd->emission, wisd->source,
|
|
|
|
_elm_widget_item_signal_cb);
|
2017-12-05 19:15:39 -08:00
|
|
|
else if (efl_isa(item->view, EFL_CANVAS_LAYOUT_CLASS))
|
2017-07-16 21:45:08 -07:00
|
|
|
edje_object_signal_callback_del_full(item->view,
|
|
|
|
wisd->emission, wisd->source,
|
|
|
|
_elm_widget_item_signal_cb, wisd);
|
|
|
|
|
|
|
|
eina_stringshare_del(wisd->emission);
|
|
|
|
eina_stringshare_del(wisd->source);
|
|
|
|
free(wisd);
|
|
|
|
|
|
|
|
return data;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define ERR_NOT_SUPPORTED(item, method) ERR("%s does not support %s API.", elm_widget_type_get(item->widget), method);
|
|
|
|
|
|
|
|
static void
|
|
|
|
_efl_del_cb(void *data EINA_UNUSED, const Efl_Event *event)
|
|
|
|
{
|
|
|
|
Elm_Widget_Item_Data *item = efl_data_scope_get(event->object, ELM_WIDGET_ITEM_CLASS);
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
if (item->del_func)
|
|
|
|
item->del_func((void *) WIDGET_ITEM_DATA_GET(event->object), item->widget, item->eo_obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Allocate a new Elm_Widget_Item-derived structure.
|
|
|
|
*
|
|
|
|
* The goal of this structure is to provide common ground for actions
|
|
|
|
* that a widget item have, such as the owner widget, callback to
|
|
|
|
* notify deletion, data pointer and maybe more.
|
|
|
|
*
|
|
|
|
* @param widget the owner widget that holds this item, must be an elm_widget!
|
|
|
|
* @param alloc_size any number greater than sizeof(Elm_Widget_Item) that will
|
|
|
|
* be used to allocate memory.
|
|
|
|
*
|
|
|
|
* @return allocated memory that is already zeroed out, or NULL on errors.
|
|
|
|
*
|
|
|
|
* @see elm_widget_item_new() convenience macro.
|
|
|
|
* @see elm_widget_item_del() to release memory.
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
|
|
|
EOLIAN static Eo *
|
|
|
|
_elm_widget_item_efl_object_constructor(Eo *eo_item, Elm_Widget_Item_Data *item)
|
|
|
|
{
|
|
|
|
Evas_Object *widget;
|
|
|
|
widget = efl_parent_get(eo_item);
|
|
|
|
|
|
|
|
if (!_elm_widget_is(widget))
|
|
|
|
{
|
|
|
|
ERR("Failed");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
eo_item = efl_constructor(efl_super(eo_item, ELM_WIDGET_ITEM_CLASS));
|
|
|
|
|
|
|
|
EINA_MAGIC_SET(item, ELM_WIDGET_ITEM_MAGIC);
|
|
|
|
|
|
|
|
item->widget = widget;
|
|
|
|
item->eo_obj = eo_item;
|
|
|
|
efl_event_callback_add(eo_item, EFL_EVENT_DEL, _efl_del_cb, NULL);
|
|
|
|
|
|
|
|
return eo_item;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_efl_object_destructor(Eo *eo_item, Elm_Widget_Item_Data *item)
|
|
|
|
{
|
|
|
|
Elm_Translate_String_Data *ts;
|
|
|
|
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
|
2018-02-15 10:07:01 -08:00
|
|
|
eina_stringshare_del(item->style);
|
2017-07-16 21:45:08 -07:00
|
|
|
eina_stringshare_del(item->access_info);
|
|
|
|
eina_stringshare_del(item->accessible_name);
|
|
|
|
|
|
|
|
while (item->signals)
|
|
|
|
_elm_widget_item_signal_callback_list_get(item, item->signals);
|
|
|
|
|
|
|
|
while (item->translate_strings)
|
|
|
|
{
|
|
|
|
ts = EINA_INLIST_CONTAINER_GET(item->translate_strings,
|
|
|
|
Elm_Translate_String_Data);
|
|
|
|
eina_stringshare_del(ts->id);
|
|
|
|
eina_stringshare_del(ts->domain);
|
|
|
|
eina_stringshare_del(ts->string);
|
|
|
|
item->translate_strings = eina_inlist_remove(item->translate_strings,
|
|
|
|
item->translate_strings);
|
|
|
|
free(ts);
|
|
|
|
}
|
|
|
|
eina_hash_free(item->labels);
|
|
|
|
|
2018-04-03 04:27:30 -07:00
|
|
|
efl_access_object_attributes_clear(eo_item);
|
2017-10-18 18:13:54 -07:00
|
|
|
efl_access_removed(eo_item);
|
2017-07-16 21:45:08 -07:00
|
|
|
|
|
|
|
EINA_MAGIC_SET(item, EINA_MAGIC_NONE);
|
|
|
|
|
|
|
|
efl_destructor(efl_super(eo_item, ELM_WIDGET_ITEM_CLASS));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Releases widget item memory, calling back item_del_pre_hook() and
|
|
|
|
* item_del_cb() if they exist.
|
|
|
|
*
|
|
|
|
* @param item a valid #Elm_Widget_Item to be deleted.
|
|
|
|
*
|
|
|
|
* If there is an Elm_Widget_Item::del_cb, then it will be called prior
|
|
|
|
* to memory release. Note that elm_widget_item_pre_notify_del() calls
|
|
|
|
* this function and then unset it, thus being useful for 2 step
|
|
|
|
* cleanup whenever the del_cb may use any of the data that must be
|
|
|
|
* deleted from item.
|
|
|
|
*
|
|
|
|
* The Elm_Widget_Item::view will be deleted (evas_object_del()) if it
|
|
|
|
* is presented!
|
|
|
|
*
|
|
|
|
* Note that if item_del_pre_hook() returns @c EINA_TRUE, item free will be
|
|
|
|
* deferred, or item will be freed here if it returns @c EINA_FALSE.
|
|
|
|
*
|
|
|
|
* @see elm_widget_item_del() convenience macro.
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
|
|
|
EOLIAN static void
|
2018-04-17 09:54:30 -07:00
|
|
|
_elm_widget_item_efl_object_invalidate(Eo *eo_item, Elm_Widget_Item_Data *item)
|
2017-07-16 21:45:08 -07:00
|
|
|
{
|
2018-05-07 15:16:29 -07:00
|
|
|
Evas_Object *view;
|
2017-07-16 21:45:08 -07:00
|
|
|
|
|
|
|
//Widget item delete callback
|
2018-04-16 16:56:23 -07:00
|
|
|
elm_wdg_item_del_pre(item->eo_obj);
|
2018-05-07 15:16:29 -07:00
|
|
|
|
|
|
|
view = item->view;
|
|
|
|
if (item->view) efl_wref_del(item->view, &item->view);
|
|
|
|
// FIXME: Is view an Efl.Ui or a legacy object ?
|
|
|
|
evas_object_del(view);
|
|
|
|
item->view = NULL;
|
|
|
|
|
2018-04-17 09:54:30 -07:00
|
|
|
efl_invalidate(efl_super(eo_item, ELM_WIDGET_ITEM_CLASS));
|
2017-07-16 21:45:08 -07:00
|
|
|
}
|
|
|
|
|
2018-04-16 16:56:23 -07:00
|
|
|
EOLIAN static void
|
2017-07-16 21:45:08 -07:00
|
|
|
_elm_widget_item_del_pre(Eo *eo_item EINA_UNUSED, Elm_Widget_Item_Data *item EINA_UNUSED)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Notify object will be deleted without actually deleting it.
|
|
|
|
*
|
|
|
|
* This function will callback Elm_Widget_Item::del_cb if it is set
|
|
|
|
* and then unset it so it is not called twice (ie: from
|
|
|
|
* elm_widget_item_del()).
|
|
|
|
*
|
|
|
|
* @param item a valid #Elm_Widget_Item to be notified
|
|
|
|
* @see elm_widget_item_pre_notify_del() convenience macro.
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_pre_notify_del(Eo *eo_item, Elm_Widget_Item_Data *item)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
if (!item->del_func) return;
|
|
|
|
item->del_func((void *)WIDGET_ITEM_DATA_GET(eo_item), item->widget, item->eo_obj);
|
|
|
|
item->del_func = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Set the function to notify when item is being deleted.
|
|
|
|
*
|
|
|
|
* This function will complain if there was a callback set already,
|
|
|
|
* however it will set the new one.
|
|
|
|
*
|
|
|
|
* The callback will be called from elm_widget_item_pre_notify_del()
|
|
|
|
* or elm_widget_item_del() will be called with:
|
|
|
|
* - data: the Elm_Widget_Item::data value.
|
|
|
|
* - obj: the Elm_Widget_Item::widget evas object.
|
|
|
|
* - event_info: the item being deleted.
|
|
|
|
*
|
|
|
|
* @param item a valid #Elm_Widget_Item to be notified
|
|
|
|
* @see elm_widget_item_del_cb_set() convenience macro.
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_del_cb_set(Eo *eo_item EINA_UNUSED,
|
|
|
|
Elm_Widget_Item_Data *item,
|
|
|
|
Evas_Smart_Cb func)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
ELM_WIDGET_ITEM_RETURN_IF_ONDEL(item);
|
|
|
|
|
|
|
|
if ((item->del_func) && (item->del_func != func))
|
|
|
|
WRN("You're replacing a previously set del_cb %p of item %p with %p",
|
|
|
|
item->del_func, item->eo_obj, func);
|
|
|
|
|
|
|
|
item->del_func = func;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Get owner widget of this item.
|
|
|
|
*
|
|
|
|
* @param item a valid #Elm_Widget_Item to get data from.
|
|
|
|
* @return owner widget of this item.
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
|
|
|
EOLIAN static Evas_Object *
|
|
|
|
_elm_widget_item_widget_get(const Eo *eo_item EINA_UNUSED, Elm_Widget_Item_Data *item)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item, NULL);
|
|
|
|
ELM_WIDGET_ITEM_RETURN_IF_ONDEL(item, NULL);
|
|
|
|
|
|
|
|
return item->widget;
|
|
|
|
}
|
|
|
|
|
2015-05-19 04:33:19 -07:00
|
|
|
EAPI Eina_Bool
|
2018-04-17 11:09:44 -07:00
|
|
|
_elm_widget_onscreen_is(const Evas_Object *widget)
|
2015-05-19 04:33:19 -07:00
|
|
|
{
|
2018-04-17 11:09:44 -07:00
|
|
|
Evas_Object *parent = (Evas_Object *)widget;
|
2016-12-01 03:56:32 -08:00
|
|
|
Eina_Rectangle r1, r2;
|
2015-05-19 04:33:19 -07:00
|
|
|
|
|
|
|
Evas *evas = evas_object_evas_get(widget);
|
|
|
|
if (!evas) return EINA_FALSE;
|
|
|
|
|
2016-12-01 03:56:32 -08:00
|
|
|
evas_object_geometry_get(widget, &r1.x, &r1.y, &r1.w, &r1.h);
|
|
|
|
if (eina_rectangle_is_empty(&r1))
|
|
|
|
return EINA_FALSE;
|
|
|
|
|
2017-12-05 18:53:06 -08:00
|
|
|
// window does not have to check viewport and geometry
|
2017-12-05 21:54:49 -08:00
|
|
|
if (efl_isa(widget, EFL_UI_WIN_CLASS))
|
2017-12-05 18:53:06 -08:00
|
|
|
return EINA_TRUE;
|
|
|
|
|
2015-05-19 04:33:19 -07:00
|
|
|
// check if on canvas
|
2016-12-01 03:56:32 -08:00
|
|
|
evas_output_viewport_get(evas, &r2.x, &r2.y, &r2.w, &r2.h);
|
|
|
|
if (!eina_rectangles_intersect(&r1, &r2))
|
2015-05-19 04:33:19 -07:00
|
|
|
return EINA_FALSE;
|
|
|
|
|
|
|
|
// check if inside scrollable parent viewport
|
|
|
|
do {
|
|
|
|
parent = elm_widget_parent_get(parent);
|
|
|
|
if (parent && !evas_object_visible_get(parent))
|
|
|
|
return EINA_FALSE;
|
2016-08-15 06:44:41 -07:00
|
|
|
if (parent && efl_isa(parent, ELM_INTERFACE_SCROLLABLE_MIXIN))
|
2015-05-19 04:33:19 -07:00
|
|
|
{
|
2016-12-01 03:56:32 -08:00
|
|
|
evas_object_geometry_get(parent, &r2.x, &r2.y, &r2.w, &r2.h);
|
|
|
|
if (!eina_rectangles_intersect(&r1, &r2))
|
2015-05-19 04:33:19 -07:00
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
} while (parent && (parent != elm_widget_top_get(widget)));
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
2018-04-17 11:09:44 -07:00
|
|
|
_elm_widget_item_onscreen_is(const Elm_Object_Item *item)
|
2015-05-19 04:33:19 -07:00
|
|
|
{
|
2016-12-01 03:56:32 -08:00
|
|
|
Eina_Rectangle r1, r2;
|
2016-08-15 06:44:41 -07:00
|
|
|
Elm_Widget_Item_Data *id = efl_data_scope_get(item, ELM_WIDGET_ITEM_CLASS);
|
2015-05-19 04:33:19 -07:00
|
|
|
if (!id || !id->view) return EINA_FALSE;
|
|
|
|
|
2015-07-16 01:51:59 -07:00
|
|
|
if (!evas_object_visible_get(id->view))
|
|
|
|
return EINA_FALSE;
|
|
|
|
|
2015-05-19 04:33:19 -07:00
|
|
|
if (!_elm_widget_onscreen_is(id->widget))
|
|
|
|
return EINA_FALSE;
|
|
|
|
|
2016-12-01 03:56:32 -08:00
|
|
|
evas_object_geometry_get(id->view, &r1.x, &r1.y, &r1.w, &r1.h);
|
|
|
|
if (eina_rectangle_is_empty(&r1))
|
|
|
|
return EINA_FALSE;
|
|
|
|
|
|
|
|
evas_object_geometry_get(id->widget, &r2.x, &r2.y, &r2.w, &r2.h);
|
|
|
|
if (!eina_rectangles_intersect(&r1, &r2))
|
2015-05-19 04:33:19 -07:00
|
|
|
return EINA_FALSE;
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
2017-09-06 03:54:59 -07:00
|
|
|
const char*
|
2018-04-17 11:09:44 -07:00
|
|
|
_elm_widget_accessible_plain_name_get(const Evas_Object *obj, const char* name)
|
2017-09-06 03:54:59 -07:00
|
|
|
{
|
|
|
|
char *accessible_plain_name;
|
|
|
|
|
|
|
|
API_ENTRY return NULL;
|
|
|
|
|
|
|
|
accessible_plain_name = _elm_util_mkup_to_text(name);
|
|
|
|
eina_stringshare_del(sd->accessible_name);
|
|
|
|
sd->accessible_name = eina_stringshare_add(accessible_plain_name);
|
|
|
|
free(accessible_plain_name);
|
|
|
|
return sd->accessible_name;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char*
|
2018-04-17 11:09:44 -07:00
|
|
|
_elm_widget_item_accessible_plain_name_get(const Elm_Object_Item *item, const char* name)
|
2017-09-06 03:54:59 -07:00
|
|
|
{
|
|
|
|
char *accessible_plain_name;
|
|
|
|
|
|
|
|
Elm_Widget_Item_Data *id = efl_data_scope_get(item, ELM_WIDGET_ITEM_CLASS);
|
|
|
|
if (!id) return NULL;
|
|
|
|
|
|
|
|
accessible_plain_name = _elm_util_mkup_to_text(name);
|
|
|
|
eina_stringshare_del(id->accessible_name);
|
|
|
|
id->accessible_name = eina_stringshare_add(accessible_plain_name);
|
|
|
|
free(accessible_plain_name);
|
|
|
|
return id->accessible_name;
|
|
|
|
}
|
|
|
|
|
2017-10-18 18:13:54 -07:00
|
|
|
EOLIAN static Efl_Access_State_Set
|
2018-04-03 04:27:30 -07:00
|
|
|
_elm_widget_item_efl_access_object_state_set_get(const Eo *eo_item,
|
|
|
|
Elm_Widget_Item_Data *item EINA_UNUSED)
|
2014-09-29 06:34:34 -07:00
|
|
|
{
|
2017-10-18 18:13:54 -07:00
|
|
|
Efl_Access_State_Set states = 0;
|
2014-09-29 06:34:34 -07:00
|
|
|
|
2017-10-18 18:13:54 -07:00
|
|
|
STATE_TYPE_SET(states, EFL_ACCESS_STATE_FOCUSABLE);
|
2014-10-02 07:44:02 -07:00
|
|
|
|
2017-07-16 21:45:08 -07:00
|
|
|
if (elm_object_item_focus_get(eo_item))
|
2017-10-18 18:13:54 -07:00
|
|
|
STATE_TYPE_SET(states, EFL_ACCESS_STATE_FOCUSED);
|
2017-07-16 21:45:08 -07:00
|
|
|
if (!elm_object_item_disabled_get(eo_item))
|
2014-10-02 07:44:02 -07:00
|
|
|
{
|
2017-10-18 18:13:54 -07:00
|
|
|
STATE_TYPE_SET(states, EFL_ACCESS_STATE_ENABLED);
|
|
|
|
STATE_TYPE_SET(states, EFL_ACCESS_STATE_SENSITIVE);
|
|
|
|
STATE_TYPE_SET(states, EFL_ACCESS_STATE_VISIBLE);
|
2014-10-02 07:44:02 -07:00
|
|
|
}
|
2017-07-16 21:45:08 -07:00
|
|
|
if (_elm_widget_item_onscreen_is(eo_item))
|
2017-10-18 18:13:54 -07:00
|
|
|
STATE_TYPE_SET(states, EFL_ACCESS_STATE_SHOWING);
|
2017-07-16 21:45:08 -07:00
|
|
|
|
|
|
|
return states;
|
2014-09-29 06:34:34 -07:00
|
|
|
}
|
2014-02-07 01:09:46 -08:00
|
|
|
|
2017-07-16 21:45:08 -07:00
|
|
|
EAPI void
|
|
|
|
elm_object_item_data_set(Elm_Object_Item *it, void *data)
|
2014-09-14 04:51:26 -07:00
|
|
|
{
|
2017-07-16 21:45:08 -07:00
|
|
|
WIDGET_ITEM_DATA_SET(it, data);
|
|
|
|
}
|
2017-07-16 19:22:46 -07:00
|
|
|
|
2017-07-16 21:45:08 -07:00
|
|
|
EAPI void *
|
|
|
|
elm_object_item_data_get(const Elm_Object_Item *it)
|
|
|
|
{
|
|
|
|
return (void *) WIDGET_ITEM_DATA_GET(it);
|
|
|
|
}
|
2017-07-16 19:22:46 -07:00
|
|
|
|
2017-07-16 21:45:08 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_disabled_set(Eo *eo_item EINA_UNUSED,
|
|
|
|
Elm_Widget_Item_Data *item,
|
|
|
|
Eina_Bool disabled)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
ELM_WIDGET_ITEM_RETURN_IF_ONDEL(item);
|
2017-07-16 19:22:46 -07:00
|
|
|
|
2017-07-16 21:45:08 -07:00
|
|
|
if (item->disabled == disabled) return;
|
|
|
|
item->disabled = !!disabled;
|
|
|
|
elm_wdg_item_disable(item->eo_obj);
|
|
|
|
}
|
2017-07-16 19:22:46 -07:00
|
|
|
|
2017-07-16 21:45:08 -07:00
|
|
|
EOLIAN static Eina_Bool
|
2018-04-17 11:09:44 -07:00
|
|
|
_elm_widget_item_disabled_get(const Eo *eo_item EINA_UNUSED, Elm_Widget_Item_Data *item)
|
2017-07-16 21:45:08 -07:00
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item, EINA_FALSE);
|
|
|
|
return item->disabled;
|
2014-08-13 06:36:29 -07:00
|
|
|
}
|
|
|
|
|
2017-07-16 21:45:08 -07:00
|
|
|
EOLIAN static void
|
2018-02-15 10:07:01 -08:00
|
|
|
_elm_widget_item_style_set(Eo *eo_item EINA_UNUSED, Elm_Widget_Item_Data *item, const char *style)
|
2017-07-16 21:45:08 -07:00
|
|
|
{
|
2018-02-15 10:07:01 -08:00
|
|
|
eina_stringshare_replace(&item->style, style);
|
2017-07-16 21:45:08 -07:00
|
|
|
}
|
2017-07-16 19:22:46 -07:00
|
|
|
|
2017-07-16 21:45:08 -07:00
|
|
|
EOLIAN static const char *
|
2018-04-17 11:09:44 -07:00
|
|
|
_elm_widget_item_style_get(const Eo *eo_item EINA_UNUSED, Elm_Widget_Item_Data *item)
|
2014-08-13 06:36:29 -07:00
|
|
|
{
|
2018-02-15 10:07:01 -08:00
|
|
|
return item->style;
|
2014-08-13 06:36:29 -07:00
|
|
|
}
|
|
|
|
|
2017-07-16 21:45:08 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_disable(Eo *eo_item EINA_UNUSED, Elm_Widget_Item_Data *item EINA_UNUSED)
|
2014-08-13 06:36:29 -07:00
|
|
|
{
|
2011-04-14 05:47:16 -07:00
|
|
|
}
|
2012-11-25 22:32:53 -08:00
|
|
|
|
2017-07-16 21:45:08 -07:00
|
|
|
EOLIAN static void
|
2018-02-14 18:14:52 -08:00
|
|
|
_elm_widget_item_item_focus_set(Eo *eo_item EINA_UNUSED, Elm_Widget_Item_Data *item, Eina_Bool focused EINA_UNUSED)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2017-07-16 21:45:08 -07:00
|
|
|
ERR_NOT_SUPPORTED(item, "elm_object_item_focus_set");
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Eina_Bool
|
2018-04-17 11:09:44 -07:00
|
|
|
_elm_widget_item_item_focus_get(const Eo *eo_item EINA_UNUSED, Elm_Widget_Item_Data *item)
|
2017-07-16 21:45:08 -07:00
|
|
|
{
|
|
|
|
ERR_NOT_SUPPORTED(item, "elm_object_item_focus_get");
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_domain_translatable_part_text_set(Eo *eo_item EINA_UNUSED,
|
|
|
|
Elm_Widget_Item_Data *item,
|
|
|
|
const char *part,
|
|
|
|
const char *domain,
|
|
|
|
const char *label)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
ELM_WIDGET_ITEM_RETURN_IF_ONDEL(item);
|
|
|
|
Elm_Translate_String_Data *ts;
|
|
|
|
|
|
|
|
if (!label)
|
|
|
|
{
|
|
|
|
_part_text_translatable_set(&item->translate_strings, part, EINA_FALSE,
|
|
|
|
EINA_FALSE);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ts = _part_text_translatable_set(&item->translate_strings, part,
|
|
|
|
EINA_TRUE, EINA_FALSE);
|
|
|
|
if (!ts) return;
|
|
|
|
if (!ts->string) ts->string = eina_stringshare_add(label);
|
|
|
|
else eina_stringshare_replace(&ts->string, label);
|
|
|
|
if (!ts->domain) ts->domain = eina_stringshare_add(domain);
|
|
|
|
else eina_stringshare_replace(&ts->domain, domain);
|
|
|
|
#ifdef HAVE_GETTEXT
|
|
|
|
if (label[0]) label = dgettext(domain, label);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
item->on_translate = EINA_TRUE;
|
|
|
|
elm_wdg_item_part_text_set(item->eo_obj, part, label);
|
|
|
|
item->on_translate = EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static const char *
|
|
|
|
_elm_widget_item_translatable_part_text_get(const Eo *eo_item EINA_UNUSED,
|
|
|
|
Elm_Widget_Item_Data *item,
|
|
|
|
const char *part)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item, NULL);
|
|
|
|
ELM_WIDGET_ITEM_RETURN_IF_ONDEL(item, NULL);
|
|
|
|
|
|
|
|
Elm_Translate_String_Data *ts;
|
|
|
|
ts = _translate_string_data_get(item->translate_strings, part);
|
|
|
|
if (ts) return ts->string;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_domain_part_text_translatable_set(Eo *eo_item EINA_UNUSED,
|
|
|
|
Elm_Widget_Item_Data *item,
|
|
|
|
const char *part,
|
|
|
|
const char *domain,
|
|
|
|
Eina_Bool translatable)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
ELM_WIDGET_ITEM_RETURN_IF_ONDEL(item);
|
|
|
|
Elm_Translate_String_Data *ts;
|
|
|
|
const char *text;
|
|
|
|
|
|
|
|
ts = _part_text_translatable_set(&item->translate_strings, part,
|
|
|
|
translatable, EINA_TRUE);
|
|
|
|
if (!ts) return;
|
|
|
|
if (!ts->domain) ts->domain = eina_stringshare_add(domain);
|
|
|
|
else eina_stringshare_replace(&ts->domain, domain);
|
|
|
|
|
|
|
|
text = elm_wdg_item_part_text_get(item->eo_obj, part);
|
|
|
|
|
|
|
|
if (!text || !text[0]) return;
|
|
|
|
|
|
|
|
if (!ts->string) ts->string = eina_stringshare_add(text);
|
|
|
|
|
|
|
|
//Try to translate text since we don't know the text is already translated.
|
|
|
|
#ifdef HAVE_GETTEXT
|
|
|
|
text = dgettext(domain, text);
|
|
|
|
#endif
|
|
|
|
item->on_translate = EINA_TRUE;
|
|
|
|
elm_wdg_item_part_text_set(item->eo_obj, part, text);
|
|
|
|
item->on_translate = EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_track_cancel(Eo *eo_item EINA_UNUSED, Elm_Widget_Item_Data *item)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
ELM_WIDGET_ITEM_RETURN_IF_ONDEL(item);
|
|
|
|
|
|
|
|
if (!item->track_obj) return;
|
|
|
|
|
|
|
|
while (evas_object_ref_get(item->track_obj) > 0)
|
|
|
|
evas_object_unref(item->track_obj);
|
|
|
|
|
|
|
|
evas_object_del(item->track_obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Evas_Object *
|
|
|
|
_elm_widget_item_track(Eo *eo_item EINA_UNUSED, Elm_Widget_Item_Data *item)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item, NULL);
|
|
|
|
ELM_WIDGET_ITEM_RETURN_IF_ONDEL(item, NULL);
|
|
|
|
|
|
|
|
if (item->track_obj)
|
|
|
|
{
|
|
|
|
evas_object_ref(item->track_obj);
|
|
|
|
return item->track_obj;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!item->view)
|
|
|
|
{
|
|
|
|
WRN("view obj of the item(%p) is invalid. Please make sure the view obj is created!", item);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
Evas_Object *track =
|
|
|
|
evas_object_rectangle_add(evas_object_evas_get(item->widget));
|
|
|
|
evas_object_color_set(track, 0, 0, 0, 0);
|
|
|
|
evas_object_pass_events_set(track, EINA_TRUE);
|
|
|
|
_track_obj_update(track, item->view);
|
|
|
|
evas_object_event_callback_add(track, EVAS_CALLBACK_DEL, _track_obj_del,
|
|
|
|
item);
|
|
|
|
|
|
|
|
efl_event_callback_array_add(item->view, tracker_callbacks(), item);
|
|
|
|
|
|
|
|
evas_object_ref(track);
|
|
|
|
|
|
|
|
item->track_obj = track;
|
|
|
|
|
|
|
|
return track;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_untrack(Eo *eo_item EINA_UNUSED, Elm_Widget_Item_Data *item)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
ELM_WIDGET_ITEM_RETURN_IF_ONDEL(item);
|
|
|
|
|
|
|
|
if (!item->track_obj) return;
|
|
|
|
evas_object_unref(item->track_obj);
|
|
|
|
|
|
|
|
if (evas_object_ref_get(item->track_obj) == 0)
|
|
|
|
evas_object_del(item->track_obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static int
|
|
|
|
_elm_widget_item_track_get(const Eo *eo_item EINA_UNUSED, Elm_Widget_Item_Data *item)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item, 0);
|
|
|
|
ELM_WIDGET_ITEM_RETURN_IF_ONDEL(item, 0);
|
|
|
|
|
|
|
|
if (!item->track_obj) return 0;
|
|
|
|
return evas_object_ref_get(item->track_obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
typedef struct _Elm_Widget_Item_Tooltip Elm_Widget_Item_Tooltip;
|
|
|
|
|
|
|
|
struct _Elm_Widget_Item_Tooltip
|
|
|
|
{
|
|
|
|
Elm_Widget_Item_Data *item;
|
|
|
|
Elm_Tooltip_Item_Content_Cb func;
|
|
|
|
Evas_Smart_Cb del_cb;
|
|
|
|
const void *data;
|
|
|
|
};
|
|
|
|
|
|
|
|
static Evas_Object *
|
|
|
|
_elm_widget_item_tooltip_label_create(void *data,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
Evas_Object *tooltip,
|
|
|
|
void *item EINA_UNUSED)
|
|
|
|
{
|
|
|
|
Evas_Object *label = elm_label_add(tooltip);
|
|
|
|
if (!label)
|
|
|
|
return NULL;
|
|
|
|
elm_object_style_set(label, "tooltip");
|
|
|
|
elm_object_text_set(label, data);
|
|
|
|
return label;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Evas_Object *
|
|
|
|
_elm_widget_item_tooltip_trans_label_create(void *data,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
Evas_Object *tooltip,
|
|
|
|
void *item EINA_UNUSED)
|
|
|
|
{
|
|
|
|
Evas_Object *label = elm_label_add(tooltip);
|
|
|
|
if (!label)
|
|
|
|
return NULL;
|
|
|
|
elm_object_style_set(label, "tooltip");
|
|
|
|
elm_object_translatable_text_set(label, data);
|
|
|
|
return label;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_widget_item_tooltip_label_del_cb(void *data,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
void *event_info EINA_UNUSED)
|
|
|
|
{
|
|
|
|
eina_stringshare_del(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Set the text to be shown in the widget item.
|
|
|
|
*
|
|
|
|
* @param item Target item
|
|
|
|
* @param text The text to set in the content
|
|
|
|
*
|
|
|
|
* Setup the text as tooltip to object. The item can have only one tooltip,
|
|
|
|
* so any previous tooltip data is removed.
|
|
|
|
*
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_tooltip_text_set(Eo *eo_item EINA_UNUSED,
|
|
|
|
Elm_Widget_Item_Data *item EINA_UNUSED,
|
|
|
|
const char *text)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
ELM_WIDGET_ITEM_RETURN_IF_ONDEL(item);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(text);
|
|
|
|
|
|
|
|
text = eina_stringshare_add(text);
|
|
|
|
elm_wdg_item_tooltip_content_cb_set(item->eo_obj, _elm_widget_item_tooltip_label_create, text, _elm_widget_item_tooltip_label_del_cb);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_tooltip_translatable_text_set(Eo *eo_item EINA_UNUSED,
|
|
|
|
Elm_Widget_Item_Data *item EINA_UNUSED,
|
|
|
|
const char *text)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
ELM_WIDGET_ITEM_RETURN_IF_ONDEL(item);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(text);
|
|
|
|
|
|
|
|
text = eina_stringshare_add(text);
|
|
|
|
elm_wdg_item_tooltip_content_cb_set(item->eo_obj, _elm_widget_item_tooltip_trans_label_create, text, _elm_widget_item_tooltip_label_del_cb);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Evas_Object *
|
|
|
|
_elm_widget_item_tooltip_create(void *data,
|
|
|
|
Evas_Object *obj,
|
|
|
|
Evas_Object *tooltip)
|
|
|
|
{
|
|
|
|
Elm_Widget_Item_Tooltip *wit = data;
|
|
|
|
return wit->func((void *)wit->data, obj, tooltip, wit->item->eo_obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_widget_item_tooltip_del_cb(void *data,
|
|
|
|
Evas_Object *obj,
|
|
|
|
void *event_info EINA_UNUSED)
|
|
|
|
{
|
|
|
|
Elm_Widget_Item_Tooltip *wit = data;
|
|
|
|
if (wit->del_cb) wit->del_cb((void *)wit->data, obj, wit->item->eo_obj);
|
|
|
|
free(wit);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Set the content to be shown in the tooltip item
|
|
|
|
*
|
|
|
|
* Setup the tooltip to item. The item can have only one tooltip,
|
|
|
|
* so any previous tooltip data is removed. @p func(with @p data) will
|
|
|
|
* be called every time that need show the tooltip and it should
|
|
|
|
* return a valid Evas_Object. This object is then managed fully by
|
|
|
|
* tooltip system and is deleted when the tooltip is gone.
|
|
|
|
*
|
|
|
|
* @param item the widget item being attached a tooltip.
|
|
|
|
* @param func the function used to create the tooltip contents.
|
|
|
|
* @param data what to provide to @a func as callback data/context.
|
|
|
|
* @param del_cb called when data is not needed anymore, either when
|
|
|
|
* another callback replaces @func, the tooltip is unset with
|
|
|
|
* elm_widget_item_tooltip_unset() or the owner @a item
|
|
|
|
* dies. This callback receives as the first parameter the
|
|
|
|
* given @a data, and @c event_info is the item.
|
|
|
|
*
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_tooltip_content_cb_set(Eo *eo_item EINA_UNUSED,
|
|
|
|
Elm_Widget_Item_Data *item,
|
|
|
|
Elm_Tooltip_Item_Content_Cb func,
|
|
|
|
const void *data,
|
|
|
|
Evas_Smart_Cb del_cb)
|
|
|
|
{
|
|
|
|
Elm_Widget_Item_Tooltip *wit;
|
|
|
|
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_GOTO(item, error_noitem);
|
|
|
|
//ELM_WIDGET_ITEM_RETURN_IF_GOTO(item, error_noitem);
|
|
|
|
|
|
|
|
if (!func)
|
|
|
|
{
|
|
|
|
elm_wdg_item_tooltip_unset(item->eo_obj);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
wit = ELM_NEW(Elm_Widget_Item_Tooltip);
|
|
|
|
if (!wit) goto error;
|
|
|
|
wit->item = item;
|
|
|
|
wit->func = func;
|
|
|
|
wit->data = data;
|
|
|
|
wit->del_cb = del_cb;
|
|
|
|
|
|
|
|
elm_object_sub_tooltip_content_cb_set
|
|
|
|
(item->view, item->widget, _elm_widget_item_tooltip_create, wit,
|
|
|
|
_elm_widget_item_tooltip_del_cb);
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
error_noitem:
|
|
|
|
if (del_cb) del_cb((void *)data, NULL, item);
|
|
|
|
return;
|
|
|
|
error:
|
|
|
|
if (del_cb) del_cb((void *)data, item->widget, item);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Unset tooltip from item
|
|
|
|
*
|
|
|
|
* @param item widget item to remove previously set tooltip.
|
|
|
|
*
|
|
|
|
* Remove tooltip from item. The callback provided as del_cb to
|
|
|
|
* elm_widget_item_tooltip_content_cb_set() will be called to notify
|
|
|
|
* it is not used anymore.
|
|
|
|
*
|
|
|
|
* @see elm_widget_item_tooltip_content_cb_set()
|
|
|
|
*
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_tooltip_unset(Eo *eo_item EINA_UNUSED, Elm_Widget_Item_Data *item)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
ELM_WIDGET_ITEM_RETURN_IF_ONDEL(item);
|
|
|
|
|
|
|
|
elm_object_tooltip_unset(item->view);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Sets a different style for this item tooltip.
|
|
|
|
*
|
|
|
|
* @note before you set a style you should define a tooltip with
|
|
|
|
* elm_widget_item_tooltip_content_cb_set() or
|
|
|
|
* elm_widget_item_tooltip_text_set()
|
|
|
|
*
|
|
|
|
* @param item widget item with tooltip already set.
|
|
|
|
* @param style the theme style to use (default, transparent, ...)
|
|
|
|
*
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_tooltip_style_set(Eo *eo_item EINA_UNUSED,
|
|
|
|
Elm_Widget_Item_Data *item,
|
|
|
|
const char *style)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
ELM_WIDGET_ITEM_RETURN_IF_ONDEL(item);
|
|
|
|
|
|
|
|
elm_object_tooltip_style_set(item->view, style);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_widget_item_tooltip_window_mode_set(Eo *eo_item EINA_UNUSED,
|
|
|
|
Elm_Widget_Item_Data *item,
|
|
|
|
Eina_Bool disable)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item, EINA_FALSE);
|
|
|
|
ELM_WIDGET_ITEM_RETURN_IF_ONDEL(item, EINA_FALSE);
|
|
|
|
|
|
|
|
return elm_object_tooltip_window_mode_set(item->view, disable);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Eina_Bool
|
2018-04-17 11:09:44 -07:00
|
|
|
_elm_widget_item_tooltip_window_mode_get(const Eo *eo_item EINA_UNUSED, Elm_Widget_Item_Data *item)
|
2017-07-16 21:45:08 -07:00
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item, EINA_FALSE);
|
|
|
|
ELM_WIDGET_ITEM_RETURN_IF_ONDEL(item, EINA_FALSE);
|
|
|
|
|
|
|
|
return elm_object_tooltip_window_mode_get(item->view);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Get the style for this item tooltip.
|
|
|
|
*
|
|
|
|
* @param item widget item with tooltip already set.
|
|
|
|
* @return style the theme style in use, defaults to "default". If the
|
|
|
|
* object does not have a tooltip set, then NULL is returned.
|
|
|
|
*
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
|
|
|
EOLIAN static const char *
|
2018-04-17 11:09:44 -07:00
|
|
|
_elm_widget_item_tooltip_style_get(const Eo *eo_item EINA_UNUSED, Elm_Widget_Item_Data *item)
|
2017-07-16 21:45:08 -07:00
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item, NULL);
|
|
|
|
|
|
|
|
return elm_object_tooltip_style_get(item->view);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_cursor_set(Eo *eo_item EINA_UNUSED,
|
|
|
|
Elm_Widget_Item_Data *item,
|
|
|
|
const char *cursor)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
ELM_WIDGET_ITEM_RETURN_IF_ONDEL(item);
|
|
|
|
|
|
|
|
elm_object_sub_cursor_set(item->view, item->widget, cursor);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static const char *
|
2018-04-17 11:09:44 -07:00
|
|
|
_elm_widget_item_cursor_get(const Eo *eo_item EINA_UNUSED, Elm_Widget_Item_Data *item)
|
2017-07-16 21:45:08 -07:00
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item, NULL);
|
2018-05-18 09:13:43 -07:00
|
|
|
return elm_object_sub_cursor_get(item->view);
|
2017-07-16 21:45:08 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_cursor_unset(Eo *eo_item EINA_UNUSED, Elm_Widget_Item_Data *item)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
ELM_WIDGET_ITEM_RETURN_IF_ONDEL(item);
|
|
|
|
|
|
|
|
elm_object_cursor_unset(item->view);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Sets a different style for this item cursor.
|
|
|
|
*
|
|
|
|
* @note before you set a style you should define a cursor with
|
|
|
|
* elm_widget_item_cursor_set()
|
|
|
|
*
|
|
|
|
* @param item widget item with cursor already set.
|
|
|
|
* @param style the theme style to use (default, transparent, ...)
|
|
|
|
*
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_cursor_style_set(Eo *eo_item EINA_UNUSED,
|
|
|
|
Elm_Widget_Item_Data *item,
|
|
|
|
const char *style)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
ELM_WIDGET_ITEM_RETURN_IF_ONDEL(item);
|
|
|
|
|
2018-05-18 09:13:43 -07:00
|
|
|
elm_object_sub_cursor_style_set(item->view, style);
|
2017-07-16 21:45:08 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Get the style for this item cursor.
|
|
|
|
*
|
|
|
|
* @param item widget item with cursor already set.
|
|
|
|
* @return style the theme style in use, defaults to "default". If the
|
|
|
|
* object does not have a cursor set, then NULL is returned.
|
|
|
|
*
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
|
|
|
EOLIAN static const char *
|
2018-04-17 11:09:44 -07:00
|
|
|
_elm_widget_item_cursor_style_get(const Eo *eo_item EINA_UNUSED,
|
2017-07-16 21:45:08 -07:00
|
|
|
Elm_Widget_Item_Data *item)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item, NULL);
|
2018-05-18 09:13:43 -07:00
|
|
|
return elm_object_sub_cursor_style_get(item->view);
|
2017-07-16 21:45:08 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Set if the cursor set should be searched on the theme or should use
|
|
|
|
* the provided by the engine, only.
|
|
|
|
*
|
|
|
|
* @note before you set if should look on theme you should define a cursor
|
|
|
|
* with elm_object_cursor_set(). By default it will only look for cursors
|
|
|
|
* provided by the engine.
|
|
|
|
*
|
|
|
|
* @param item widget item with cursor already set.
|
|
|
|
* @param engine_only boolean to define it cursors should be looked only
|
|
|
|
* between the provided by the engine or searched on widget's theme as well.
|
|
|
|
*
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_cursor_engine_only_set(Eo *eo_item EINA_UNUSED,
|
|
|
|
Elm_Widget_Item_Data *item,
|
|
|
|
Eina_Bool engine_only)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
ELM_WIDGET_ITEM_RETURN_IF_ONDEL(item);
|
|
|
|
|
2018-05-18 09:13:43 -07:00
|
|
|
elm_object_sub_cursor_theme_search_enabled_set(item->view, !engine_only);
|
2017-07-16 21:45:08 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Get the cursor engine only usage for this item cursor.
|
|
|
|
*
|
|
|
|
* @param item widget item with cursor already set.
|
|
|
|
* @return engine_only boolean to define it cursors should be looked only
|
|
|
|
* between the provided by the engine or searched on widget's theme as well. If
|
|
|
|
* the object does not have a cursor set, then EINA_FALSE is returned.
|
|
|
|
*
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
|
|
|
EOLIAN static Eina_Bool
|
2018-04-17 11:09:44 -07:00
|
|
|
_elm_widget_item_cursor_engine_only_get(const Eo *eo_item EINA_UNUSED, Elm_Widget_Item_Data *item)
|
2017-07-16 21:45:08 -07:00
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item, EINA_FALSE);
|
2018-05-18 09:13:43 -07:00
|
|
|
return !elm_object_sub_cursor_theme_search_enabled_get(item->view);
|
2017-07-16 21:45:08 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_part_content_set(Eo *eo_item EINA_UNUSED,
|
|
|
|
Elm_Widget_Item_Data *item,
|
|
|
|
const char *part EINA_UNUSED,
|
|
|
|
Evas_Object *content EINA_UNUSED)
|
|
|
|
{
|
|
|
|
ERR_NOT_SUPPORTED(item, "elm_object_part_content_set()");
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Evas_Object *
|
2018-04-17 11:09:44 -07:00
|
|
|
_elm_widget_item_part_content_get(const Eo *eo_item EINA_UNUSED,
|
2017-07-16 21:45:08 -07:00
|
|
|
Elm_Widget_Item_Data *item,
|
|
|
|
const char *part EINA_UNUSED)
|
|
|
|
{
|
|
|
|
ERR_NOT_SUPPORTED(item, "elm_object_part_content_get()");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Evas_Object *
|
|
|
|
_elm_widget_item_part_content_unset(Eo *eo_item EINA_UNUSED,
|
|
|
|
Elm_Widget_Item_Data *item,
|
|
|
|
const char *part EINA_UNUSED)
|
|
|
|
{
|
|
|
|
ERR_NOT_SUPPORTED(item, "elm_object_part_content_unset()");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_part_text_set(Eo *eo_item EINA_UNUSED,
|
|
|
|
Elm_Widget_Item_Data *item,
|
|
|
|
const char *part EINA_UNUSED,
|
|
|
|
const char *label EINA_UNUSED)
|
|
|
|
{
|
|
|
|
ERR_NOT_SUPPORTED(item, "elm_object_part_text_set()");
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static const char *
|
2018-04-17 11:09:44 -07:00
|
|
|
_elm_widget_item_part_text_get(const Eo *eo_item EINA_UNUSED,
|
2017-07-16 21:45:08 -07:00
|
|
|
Elm_Widget_Item_Data *item,
|
|
|
|
const char *part EINA_UNUSED)
|
|
|
|
{
|
|
|
|
ERR_NOT_SUPPORTED(item, "elm_object_part_text_get()");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_widget_item_part_text_custom_free(void *data)
|
|
|
|
{
|
|
|
|
Elm_Label_Data *label;
|
|
|
|
label = data;
|
|
|
|
eina_stringshare_del(label->part);
|
|
|
|
eina_stringshare_del(label->text);
|
|
|
|
free(label);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_part_text_custom_set(Eo *eo_item EINA_UNUSED,
|
|
|
|
Elm_Widget_Item_Data *item,
|
|
|
|
const char *part,
|
|
|
|
const char *text)
|
|
|
|
{
|
|
|
|
Elm_Label_Data *label;
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
ELM_WIDGET_ITEM_RETURN_IF_ONDEL(item);
|
|
|
|
|
|
|
|
if (!item->labels)
|
|
|
|
item->labels =
|
|
|
|
eina_hash_stringshared_new(_elm_widget_item_part_text_custom_free);
|
|
|
|
label = eina_hash_find(item->labels, part);
|
|
|
|
if (!label)
|
|
|
|
{
|
|
|
|
label = malloc(sizeof(Elm_Label_Data));
|
|
|
|
if (!label)
|
|
|
|
{
|
|
|
|
ERR("Failed to allocate memory");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
label->part = eina_stringshare_add(part);
|
|
|
|
label->text = eina_stringshare_add(text);
|
|
|
|
eina_hash_add(item->labels, part, label);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
eina_stringshare_replace(&label->text, text);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static const char *
|
2018-04-17 11:09:44 -07:00
|
|
|
_elm_widget_item_part_text_custom_get(const Eo *eo_item EINA_UNUSED,
|
2017-07-16 21:45:08 -07:00
|
|
|
Elm_Widget_Item_Data *item,
|
|
|
|
const char *part)
|
|
|
|
{
|
|
|
|
Elm_Label_Data *label;
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item, NULL);
|
|
|
|
label = eina_hash_find(item->labels, part);
|
|
|
|
return label ? label->text : NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_elm_widget_item_part_text_custom_foreach(const Eina_Hash *labels EINA_UNUSED,
|
|
|
|
const void *key EINA_UNUSED,
|
|
|
|
void *data,
|
|
|
|
void *func_data)
|
|
|
|
{
|
|
|
|
Elm_Label_Data *label;
|
|
|
|
Elm_Widget_Item_Data *item;
|
|
|
|
label = data;
|
|
|
|
item = func_data;
|
|
|
|
|
|
|
|
elm_wdg_item_part_text_set(item->eo_obj, label->part, label->text);
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_part_text_custom_update(Eo *eo_item EINA_UNUSED, Elm_Widget_Item_Data *item)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
ELM_WIDGET_ITEM_RETURN_IF_ONDEL(item);
|
|
|
|
if (item->labels)
|
|
|
|
eina_hash_foreach(item->labels,
|
|
|
|
_elm_widget_item_part_text_custom_foreach, item);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_signal_emit(Eo *eo_item EINA_UNUSED,
|
|
|
|
Elm_Widget_Item_Data *item EINA_UNUSED,
|
|
|
|
const char *emission EINA_UNUSED,
|
|
|
|
const char *source EINA_UNUSED)
|
|
|
|
{
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_signal_callback_add(Eo *eo_item,
|
|
|
|
Elm_Widget_Item_Data *item,
|
|
|
|
const char *emission,
|
|
|
|
const char *source,
|
|
|
|
Elm_Object_Item_Signal_Cb func,
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
ELM_WIDGET_ITEM_RETURN_IF_ONDEL(item);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(func);
|
|
|
|
|
|
|
|
Elm_Widget_Item_Signal_Data *wisd;
|
|
|
|
|
|
|
|
wisd = malloc(sizeof(Elm_Widget_Item_Signal_Data));
|
|
|
|
if (!wisd) return;
|
|
|
|
|
|
|
|
wisd->item = eo_item;
|
|
|
|
wisd->func = (Elm_Widget_Item_Signal_Cb)func;
|
|
|
|
wisd->data = data;
|
|
|
|
wisd->emission = eina_stringshare_add(emission);
|
|
|
|
wisd->source = eina_stringshare_add(source);
|
|
|
|
|
|
|
|
if (_elm_widget_is(item->view))
|
|
|
|
elm_object_signal_callback_add(item->view, emission, source, _elm_widget_item_signal_cb, wisd);
|
2017-12-05 19:15:39 -08:00
|
|
|
else if (efl_isa(item->view, EFL_CANVAS_LAYOUT_CLASS))
|
2017-07-16 21:45:08 -07:00
|
|
|
edje_object_signal_callback_add(item->view, emission, source, _elm_widget_item_signal_cb, wisd);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
WRN("The %s widget item doesn't support signal callback add!",
|
|
|
|
efl_class_name_get(efl_class_get(item->widget)));
|
|
|
|
free(wisd);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
item->signals = eina_list_append(item->signals, wisd);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void *
|
|
|
|
_elm_widget_item_signal_callback_del(Eo *eo_item EINA_UNUSED,
|
|
|
|
Elm_Widget_Item_Data *item,
|
|
|
|
const char *emission,
|
|
|
|
const char *source,
|
|
|
|
Elm_Object_Item_Signal_Cb func)
|
|
|
|
{
|
|
|
|
Elm_Widget_Item_Signal_Data *wisd;
|
|
|
|
Eina_List *l;
|
|
|
|
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item, NULL);
|
|
|
|
ELM_WIDGET_ITEM_RETURN_IF_ONDEL(item, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(func, NULL);
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(item->signals, l, wisd)
|
|
|
|
{
|
|
|
|
if ((wisd->func == (Elm_Widget_Item_Signal_Cb)func) &&
|
|
|
|
!strcmp(wisd->emission, emission) &&
|
|
|
|
!strcmp(wisd->source, source))
|
|
|
|
return _elm_widget_item_signal_callback_list_get(item, l);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_access_info_set(Eo *eo_item EINA_UNUSED,
|
|
|
|
Elm_Widget_Item_Data *item,
|
|
|
|
const char *txt)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
ELM_WIDGET_ITEM_RETURN_IF_ONDEL(item);
|
|
|
|
|
|
|
|
eina_stringshare_del(item->access_info);
|
|
|
|
if (!txt) item->access_info = NULL;
|
|
|
|
else item->access_info = eina_stringshare_add(txt);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_translate(Eo *eo_item EINA_UNUSED, Elm_Widget_Item_Data *item)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
ELM_WIDGET_ITEM_RETURN_IF_ONDEL(item);
|
|
|
|
|
|
|
|
#ifdef HAVE_GETTEXT
|
|
|
|
Elm_Translate_String_Data *ts;
|
|
|
|
EINA_INLIST_FOREACH(item->translate_strings, ts)
|
|
|
|
{
|
|
|
|
if (!ts->string) continue;
|
|
|
|
const char *s = dgettext(ts->domain, ts->string);
|
|
|
|
item->on_translate = EINA_TRUE;
|
|
|
|
elm_wdg_item_part_text_set(item->eo_obj, ts->id, s);
|
|
|
|
item->on_translate = EINA_FALSE;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_access_order_set(Eo *eo_item EINA_UNUSED,
|
|
|
|
Elm_Widget_Item_Data *item,
|
|
|
|
Eina_List *objs)
|
|
|
|
{
|
|
|
|
_elm_access_widget_item_access_order_set(item, objs);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static const Eina_List *
|
|
|
|
_elm_widget_item_access_order_get(Eo *eo_item EINA_UNUSED, Elm_Widget_Item_Data *item)
|
|
|
|
{
|
|
|
|
return _elm_access_widget_item_access_order_get(item);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_access_order_unset(Eo *eo_item EINA_UNUSED, Elm_Widget_Item_Data *item)
|
|
|
|
{
|
|
|
|
_elm_access_widget_item_access_order_unset(item);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Evas_Object*
|
|
|
|
_elm_widget_item_access_register(Eo *eo_item EINA_UNUSED, Elm_Widget_Item_Data *item)
|
|
|
|
{
|
|
|
|
_elm_access_widget_item_register(item);
|
|
|
|
return item->access_obj;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_access_unregister(Eo *eo_item EINA_UNUSED, Elm_Widget_Item_Data *item)
|
|
|
|
{
|
|
|
|
_elm_access_widget_item_unregister(item);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Evas_Object*
|
|
|
|
_elm_widget_item_access_object_get(const Eo *eo_item EINA_UNUSED, Elm_Widget_Item_Data *item)
|
|
|
|
{
|
|
|
|
return item->access_obj;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Evas_Object *
|
|
|
|
_elm_widget_item_focus_next_object_get(const Eo *eo_item EINA_UNUSED, Elm_Widget_Item_Data *item, Elm_Focus_Direction dir)
|
|
|
|
{
|
|
|
|
Evas_Object *ret = NULL;
|
|
|
|
|
|
|
|
if (dir == ELM_FOCUS_PREVIOUS)
|
|
|
|
ret = item->focus_previous;
|
|
|
|
else if (dir == ELM_FOCUS_NEXT)
|
|
|
|
ret = item->focus_next;
|
|
|
|
else if (dir == ELM_FOCUS_UP)
|
|
|
|
ret = item->focus_up;
|
|
|
|
else if (dir == ELM_FOCUS_DOWN)
|
|
|
|
ret = item->focus_down;
|
|
|
|
else if (dir == ELM_FOCUS_RIGHT)
|
|
|
|
ret = item->focus_right;
|
|
|
|
else if (dir == ELM_FOCUS_LEFT)
|
|
|
|
ret = item->focus_left;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_focus_next_object_set(Eo *eo_item EINA_UNUSED, Elm_Widget_Item_Data *item, Evas_Object *next, Elm_Focus_Direction dir)
|
|
|
|
{
|
|
|
|
if (dir == ELM_FOCUS_PREVIOUS)
|
|
|
|
item->focus_previous = next;
|
|
|
|
else if (dir == ELM_FOCUS_NEXT)
|
|
|
|
item->focus_next = next;
|
|
|
|
else if (dir == ELM_FOCUS_UP)
|
|
|
|
item->focus_up = next;
|
|
|
|
else if (dir == ELM_FOCUS_DOWN)
|
|
|
|
item->focus_down = next;
|
|
|
|
else if (dir == ELM_FOCUS_RIGHT)
|
|
|
|
item->focus_right = next;
|
|
|
|
else if (dir == ELM_FOCUS_LEFT)
|
|
|
|
item->focus_left = next;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Elm_Object_Item*
|
|
|
|
_elm_widget_item_focus_next_item_get(const Eo *eo_item EINA_UNUSED, Elm_Widget_Item_Data *item, Elm_Focus_Direction dir)
|
|
|
|
{
|
|
|
|
Elm_Object_Item *ret = NULL;
|
|
|
|
|
|
|
|
if (dir == ELM_FOCUS_PREVIOUS)
|
|
|
|
ret = item->item_focus_previous;
|
|
|
|
else if (dir == ELM_FOCUS_NEXT)
|
|
|
|
ret = item->item_focus_next;
|
|
|
|
else if (dir == ELM_FOCUS_UP)
|
|
|
|
ret = item->item_focus_up;
|
|
|
|
else if (dir == ELM_FOCUS_DOWN)
|
|
|
|
ret = item->item_focus_down;
|
|
|
|
else if (dir == ELM_FOCUS_RIGHT)
|
|
|
|
ret = item->item_focus_right;
|
|
|
|
else if (dir == ELM_FOCUS_LEFT)
|
|
|
|
ret = item->item_focus_left;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_widget_item_focus_next_item_set(Eo *eo_item EINA_UNUSED, Elm_Widget_Item_Data *item, Elm_Object_Item *next_item, Elm_Focus_Direction dir)
|
|
|
|
{
|
|
|
|
if (dir == ELM_FOCUS_PREVIOUS)
|
|
|
|
item->item_focus_previous = next_item;
|
|
|
|
else if (dir == ELM_FOCUS_NEXT)
|
|
|
|
item->item_focus_next = next_item;
|
|
|
|
else if (dir == ELM_FOCUS_UP)
|
|
|
|
item->item_focus_up = next_item;
|
|
|
|
else if (dir == ELM_FOCUS_DOWN)
|
|
|
|
item->item_focus_down = next_item;
|
|
|
|
else if (dir == ELM_FOCUS_RIGHT)
|
|
|
|
item->item_focus_right = next_item;
|
|
|
|
else if (dir == ELM_FOCUS_LEFT)
|
|
|
|
item->item_focus_left = next_item;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* happy debug functions */
|
|
|
|
#ifdef ELM_DEBUG
|
|
|
|
static void
|
|
|
|
_sub_obj_tree_dump(const Evas_Object *obj,
|
|
|
|
int lvl)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < lvl * 3; i++)
|
|
|
|
putchar(' ');
|
|
|
|
|
|
|
|
if (_elm_widget_is(obj))
|
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
INTERNAL_ENTRY;
|
|
|
|
DBG("+ %s(%p)\n",
|
|
|
|
elm_widget_type_get(obj),
|
|
|
|
obj);
|
|
|
|
EINA_LIST_FOREACH(sd->subobjs, l, obj)
|
|
|
|
_sub_obj_tree_dump(obj, lvl + 1);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
DBG("+ %s(%p)\n", evas_object_type_get(obj), obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_sub_obj_tree_dot_dump(const Evas_Object *obj,
|
|
|
|
FILE *output)
|
|
|
|
{
|
|
|
|
if (!_elm_widget_is(obj))
|
|
|
|
return;
|
|
|
|
INTERNAL_ENTRY;
|
|
|
|
|
|
|
|
Eina_Bool visible = evas_object_visible_get(obj);
|
|
|
|
Eina_Bool disabled = elm_widget_disabled_get(obj);
|
2017-11-29 00:39:42 -08:00
|
|
|
Eina_Bool focused = efl_ui_focus_object_focus_get(obj);
|
2017-07-16 21:45:08 -07:00
|
|
|
Eina_Bool can_focus = elm_widget_can_focus_get(obj);
|
|
|
|
|
|
|
|
if (sd->parent_obj)
|
|
|
|
{
|
|
|
|
fprintf(output, "\"%p\" -- \"%p\" [ color=black", sd->parent_obj, obj);
|
|
|
|
|
|
|
|
if (focused)
|
|
|
|
fprintf(output, ", style=bold");
|
|
|
|
|
|
|
|
if (!visible)
|
|
|
|
fprintf(output, ", color=gray28");
|
|
|
|
|
|
|
|
fprintf(output, " ];\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
fprintf(output, "\"%p\" [ label = \"{%p|%s|%s|visible: %d|"
|
|
|
|
"disabled: %d|focused: %d/%d|focus order:%d}\"",
|
|
|
|
obj, obj, elm_widget_type_get(obj),
|
|
|
|
evas_object_name_get(obj), visible, disabled, focused, can_focus,
|
|
|
|
sd->focus_order);
|
|
|
|
|
|
|
|
if (focused)
|
|
|
|
fprintf(output, ", style=bold");
|
|
|
|
|
|
|
|
if (!visible)
|
|
|
|
fprintf(output, ", fontcolor=gray28");
|
|
|
|
|
|
|
|
if ((disabled) || (!visible))
|
|
|
|
fprintf(output, ", color=gray");
|
|
|
|
|
|
|
|
fprintf(output, " ];\n");
|
|
|
|
|
|
|
|
Eina_List *l;
|
|
|
|
Evas_Object *o;
|
|
|
|
EINA_LIST_FOREACH(sd->subobjs, l, o)
|
|
|
|
_sub_obj_tree_dot_dump(o, output);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_widget_tree_dump(const Evas_Object *top)
|
|
|
|
{
|
|
|
|
#ifdef ELM_DEBUG
|
|
|
|
if (!_elm_widget_is(top))
|
|
|
|
return;
|
|
|
|
_sub_obj_tree_dump(top, 0);
|
|
|
|
#else
|
|
|
|
(void)top;
|
|
|
|
return;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_widget_tree_dot_dump(const Evas_Object *top,
|
|
|
|
FILE *output)
|
|
|
|
{
|
|
|
|
#ifdef ELM_DEBUG
|
|
|
|
if (!_elm_widget_is(top))
|
|
|
|
return;
|
|
|
|
fprintf(output, "graph " " { node [shape=record];\n");
|
|
|
|
_sub_obj_tree_dot_dump(top, output);
|
|
|
|
fprintf(output, "}\n");
|
|
|
|
#else
|
|
|
|
(void)top;
|
|
|
|
(void)output;
|
|
|
|
return;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Eo *
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_efl_object_constructor(Eo *obj, Elm_Widget_Smart_Data *sd EINA_UNUSED)
|
2017-07-16 21:45:08 -07:00
|
|
|
{
|
|
|
|
Eo *parent = NULL;
|
2013-08-22 01:00:36 -07:00
|
|
|
|
|
|
|
sd->on_create = EINA_TRUE;
|
2018-11-23 00:49:55 -08:00
|
|
|
_efl_ui_focus_event_redirector(obj, obj);
|
2017-09-05 20:13:58 -07:00
|
|
|
efl_canvas_group_clipped_set(obj, EINA_FALSE);
|
2016-08-15 06:44:41 -07:00
|
|
|
obj = efl_constructor(efl_super(obj, MY_CLASS));
|
2016-06-20 21:26:15 -07:00
|
|
|
efl_canvas_object_type_set(obj, MY_CLASS_NAME_LEGACY);
|
2016-06-16 22:12:02 -07:00
|
|
|
evas_object_smart_callbacks_descriptions_set(obj, _smart_callbacks);
|
2016-08-10 07:23:04 -07:00
|
|
|
parent = efl_parent_get(obj);
|
2017-10-23 22:03:46 -07:00
|
|
|
efl_ui_widget_parent_set(obj, parent);
|
2013-08-22 01:00:36 -07:00
|
|
|
sd->on_create = EINA_FALSE;
|
2014-10-21 05:46:35 -07:00
|
|
|
|
2018-04-03 04:27:30 -07:00
|
|
|
efl_access_object_role_set(obj, EFL_ACCESS_ROLE_UNKNOWN);
|
2016-11-04 09:43:40 -07:00
|
|
|
|
2015-05-19 05:34:07 -07:00
|
|
|
return obj;
|
2014-10-21 05:46:35 -07:00
|
|
|
}
|
|
|
|
|
2016-11-04 09:43:40 -07:00
|
|
|
EOLIAN static Efl_Object*
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_efl_object_finalize(Eo *obj, Elm_Widget_Smart_Data *pd)
|
2016-11-04 09:43:40 -07:00
|
|
|
{
|
|
|
|
Eo *eo;
|
|
|
|
|
|
|
|
eo = efl_finalize(efl_super(obj, MY_CLASS));
|
|
|
|
|
2017-07-24 14:35:26 -07:00
|
|
|
_full_eval(obj, pd);
|
2016-11-04 09:43:40 -07:00
|
|
|
|
|
|
|
return eo;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-10-21 05:46:35 -07:00
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_efl_object_destructor(Eo *obj, Elm_Widget_Smart_Data *sd)
|
2014-10-21 05:46:35 -07:00
|
|
|
{
|
2016-12-07 07:59:13 -08:00
|
|
|
if (sd->manager.provider)
|
2017-07-20 02:00:15 -07:00
|
|
|
{
|
2019-02-21 12:35:34 -08:00
|
|
|
efl_event_callback_del(sd->manager.provider, EFL_UI_FOCUS_OBJECT_EVENT_FOCUS_MANAGER_CHANGED, _manager_changed_cb, obj);
|
2017-07-20 02:00:15 -07:00
|
|
|
sd->manager.provider = NULL;
|
|
|
|
}
|
2018-04-03 04:27:30 -07:00
|
|
|
efl_access_object_attributes_clear(obj);
|
2017-10-18 18:13:54 -07:00
|
|
|
efl_access_removed(obj);
|
2017-04-20 23:58:04 -07:00
|
|
|
if (sd->logical.parent)
|
|
|
|
{
|
|
|
|
efl_weak_unref(&sd->logical.parent);
|
|
|
|
sd->logical.parent = NULL;
|
|
|
|
}
|
2017-07-20 02:00:15 -07:00
|
|
|
|
|
|
|
sd->on_destroy = EINA_TRUE;
|
2018-01-07 20:55:35 -08:00
|
|
|
efl_destructor(efl_super(obj, EFL_UI_WIDGET_CLASS));
|
2017-07-20 02:00:15 -07:00
|
|
|
sd->on_destroy = EINA_FALSE;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2017-08-09 00:22:48 -07:00
|
|
|
/* internal eo */
|
|
|
|
|
2017-10-12 18:54:54 -07:00
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_efl_object_debug_name_override(Eo *obj, Elm_Widget_Smart_Data *sd EINA_UNUSED, Eina_Strbuf *sb)
|
2017-07-14 00:55:10 -07:00
|
|
|
{
|
2017-07-20 23:24:08 -07:00
|
|
|
const char *focus = "";
|
2017-07-14 00:55:10 -07:00
|
|
|
|
2017-11-29 00:39:42 -08:00
|
|
|
if (efl_ui_focus_object_focus_get(obj)) focus = ":focused";
|
2017-10-12 18:54:54 -07:00
|
|
|
efl_debug_name_override(efl_super(obj, MY_CLASS), sb);
|
2017-07-20 23:24:08 -07:00
|
|
|
eina_strbuf_append_printf(sb, "%s", focus);
|
2017-07-14 00:55:10 -07:00
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static Eina_Bool
|
2018-01-19 00:25:47 -08:00
|
|
|
_efl_ui_widget_efl_ui_focus_object_on_focus_update(Eo *obj, Elm_Widget_Smart_Data *sd)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2016-01-20 00:06:22 -08:00
|
|
|
Eina_Bool focused;
|
|
|
|
|
|
|
|
if (!elm_widget_can_focus_get(obj))
|
2014-03-14 02:13:29 -07:00
|
|
|
return EINA_FALSE;
|
2013-06-06 09:13:37 -07:00
|
|
|
|
2017-11-29 00:39:42 -08:00
|
|
|
focused = efl_ui_focus_object_focus_get(obj);
|
2016-01-20 00:06:22 -08:00
|
|
|
|
|
|
|
if (!sd->resize_obj)
|
|
|
|
evas_object_focus_set(obj, focused);
|
|
|
|
|
|
|
|
if (_elm_config->atspi_mode && !elm_widget_child_can_focus_get(obj))
|
2017-10-18 18:13:54 -07:00
|
|
|
efl_access_state_changed_signal_emit(obj, EFL_ACCESS_STATE_FOCUSED, focused);
|
2016-01-20 00:06:22 -08:00
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
return EINA_TRUE;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static Eina_Bool
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_on_disabled_update(Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *_pd EINA_UNUSED, Eina_Bool disabled EINA_UNUSED)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2014-03-14 02:13:29 -07:00
|
|
|
return EINA_FALSE;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static Eina_Bool
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_widget_event(Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *_pd EINA_UNUSED, const Efl_Event *eo_event EINA_UNUSED, Evas_Object *source EINA_UNUSED)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2014-03-14 02:13:29 -07:00
|
|
|
return EINA_FALSE;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static Eina_Bool
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_on_access_activate(Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *_pd EINA_UNUSED, Efl_Ui_Activate act EINA_UNUSED)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
|
|
|
WRN("The %s widget does not implement the \"activate\" functions.",
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_class_name_get(efl_class_get(obj)));
|
2014-03-14 02:13:29 -07:00
|
|
|
return EINA_TRUE;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_class_constructor(Efl_Class *klass)
|
2014-03-14 02:13:29 -07:00
|
|
|
{
|
2013-11-07 03:44:22 -08:00
|
|
|
evas_smart_legacy_type_register(MY_CLASS_NAME_LEGACY, klass);
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-10-21 05:46:35 -07:00
|
|
|
EOLIAN static Eina_Bool
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_efl_access_component_focus_grab(Eo *obj, Elm_Widget_Smart_Data *pd EINA_UNUSED)
|
2014-10-21 05:46:35 -07:00
|
|
|
{
|
|
|
|
if (elm_object_focus_allow_get(obj))
|
|
|
|
{
|
|
|
|
Ecore_Evas *ee = ecore_evas_ecore_evas_get(evas_object_evas_get(obj));
|
|
|
|
if (!ee) return EINA_FALSE;
|
|
|
|
ecore_evas_activate(ee);
|
|
|
|
elm_object_focus_set(obj, EINA_TRUE);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2016-11-09 17:58:41 -08:00
|
|
|
EOLIAN static const char*
|
2018-04-03 04:27:30 -07:00
|
|
|
_efl_ui_widget_efl_access_object_i18n_name_get(const Eo *obj, Elm_Widget_Smart_Data *_pd EINA_UNUSED)
|
2014-10-21 05:46:35 -07:00
|
|
|
{
|
2016-11-09 17:58:41 -08:00
|
|
|
const char *ret, *name;
|
2018-04-03 04:27:30 -07:00
|
|
|
name = efl_access_object_i18n_name_get(efl_super(obj, EFL_UI_WIDGET_CLASS));
|
2015-10-06 06:38:09 -07:00
|
|
|
|
|
|
|
if (name) return name;
|
|
|
|
|
2014-10-21 05:46:35 -07:00
|
|
|
ret = elm_object_text_get(obj);
|
2014-10-09 02:37:35 -07:00
|
|
|
if (!ret) return NULL;
|
|
|
|
|
2017-09-06 03:54:59 -07:00
|
|
|
return _elm_widget_accessible_plain_name_get(obj, ret);
|
2014-10-21 05:46:35 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Eina_List*
|
2018-04-03 04:27:30 -07:00
|
|
|
_efl_ui_widget_efl_access_object_access_children_get(const Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *pd)
|
2014-10-21 05:46:35 -07:00
|
|
|
{
|
|
|
|
Eina_List *l, *accs = NULL;
|
|
|
|
Evas_Object *widget;
|
2017-10-18 18:13:54 -07:00
|
|
|
Efl_Access_Type type;
|
2014-10-21 05:46:35 -07:00
|
|
|
|
2015-11-26 07:53:32 -08:00
|
|
|
EINA_LIST_FOREACH(pd->subobjs, l, widget)
|
2014-10-21 05:46:35 -07:00
|
|
|
{
|
|
|
|
if (!elm_object_widget_check(widget)) continue;
|
2018-04-03 04:27:30 -07:00
|
|
|
if (!efl_isa(widget, EFL_ACCESS_OBJECT_MIXIN)) continue;
|
|
|
|
type = efl_access_object_access_type_get(widget);
|
2017-10-18 18:13:54 -07:00
|
|
|
if (type == EFL_ACCESS_TYPE_DISABLED) continue;
|
|
|
|
if (type == EFL_ACCESS_TYPE_SKIPPED)
|
2015-11-26 07:53:32 -08:00
|
|
|
{
|
|
|
|
Eina_List *children;
|
2018-04-03 04:27:30 -07:00
|
|
|
children = efl_access_object_access_children_get(widget);
|
2015-11-26 07:53:32 -08:00
|
|
|
accs = eina_list_merge(accs, children);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
accs = eina_list_append(accs, widget);
|
2014-10-21 05:46:35 -07:00
|
|
|
}
|
|
|
|
return accs;
|
|
|
|
}
|
|
|
|
|
2017-10-18 18:13:54 -07:00
|
|
|
EOLIAN static Efl_Access_State_Set
|
2018-04-03 04:27:30 -07:00
|
|
|
_efl_ui_widget_efl_access_object_state_set_get(const Eo *obj, Elm_Widget_Smart_Data *pd EINA_UNUSED)
|
2014-10-21 05:46:35 -07:00
|
|
|
{
|
2017-10-18 18:13:54 -07:00
|
|
|
Efl_Access_State_Set states = 0;
|
2014-10-21 05:46:35 -07:00
|
|
|
|
2018-04-03 04:27:30 -07:00
|
|
|
states = efl_access_object_state_set_get(efl_super(obj, EFL_UI_WIDGET_CLASS));
|
2014-10-21 05:46:35 -07:00
|
|
|
|
|
|
|
if (evas_object_visible_get(obj))
|
|
|
|
{
|
2017-10-18 18:13:54 -07:00
|
|
|
STATE_TYPE_SET(states, EFL_ACCESS_STATE_VISIBLE);
|
2015-05-19 04:33:19 -07:00
|
|
|
if (_elm_widget_onscreen_is(obj))
|
2017-10-18 18:13:54 -07:00
|
|
|
STATE_TYPE_SET(states, EFL_ACCESS_STATE_SHOWING);
|
2014-10-21 05:46:35 -07:00
|
|
|
}
|
2015-05-13 02:38:20 -07:00
|
|
|
if (!elm_widget_child_can_focus_get(obj))
|
|
|
|
{
|
|
|
|
if (elm_object_focus_allow_get(obj))
|
2017-10-18 18:13:54 -07:00
|
|
|
STATE_TYPE_SET(states, EFL_ACCESS_STATE_FOCUSABLE);
|
2015-05-13 02:38:20 -07:00
|
|
|
if (elm_object_focus_get(obj))
|
2017-10-18 18:13:54 -07:00
|
|
|
STATE_TYPE_SET(states, EFL_ACCESS_STATE_FOCUSED);
|
2015-05-13 02:38:20 -07:00
|
|
|
}
|
2014-10-21 05:46:35 -07:00
|
|
|
if (!elm_object_disabled_get(obj))
|
|
|
|
{
|
2017-10-18 18:13:54 -07:00
|
|
|
STATE_TYPE_SET(states, EFL_ACCESS_STATE_ENABLED);
|
|
|
|
STATE_TYPE_SET(states, EFL_ACCESS_STATE_SENSITIVE);
|
2014-10-21 05:46:35 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return states;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Eina_List*
|
2018-04-03 04:27:30 -07:00
|
|
|
_efl_ui_widget_efl_access_object_attributes_get(const Eo *obj, Elm_Widget_Smart_Data *pd EINA_UNUSED)
|
2014-10-21 05:46:35 -07:00
|
|
|
{
|
2018-02-02 01:56:58 -08:00
|
|
|
const char *type = NULL;
|
|
|
|
const char *style = NULL;
|
2017-11-21 18:54:44 -08:00
|
|
|
Eina_List *attr_list = NULL;
|
2018-02-02 01:56:58 -08:00
|
|
|
Efl_Access_Attribute *attr = NULL;
|
2014-10-21 05:46:35 -07:00
|
|
|
|
2018-04-03 04:27:30 -07:00
|
|
|
attr_list = efl_access_object_attributes_get(efl_super(obj, EFL_UI_WIDGET_CLASS));
|
2014-10-21 05:46:35 -07:00
|
|
|
|
2017-11-21 18:54:44 -08:00
|
|
|
//Add type and style information in addition.
|
2018-02-02 01:56:58 -08:00
|
|
|
type = elm_widget_type_get(obj);
|
|
|
|
if (type)
|
2017-11-21 18:54:44 -08:00
|
|
|
{
|
2018-02-02 01:56:58 -08:00
|
|
|
attr = calloc(1, sizeof(Efl_Access_Attribute));
|
|
|
|
if (attr)
|
|
|
|
{
|
|
|
|
attr->key = eina_stringshare_add("type");
|
|
|
|
attr->value = eina_stringshare_add(type);
|
|
|
|
attr_list = eina_list_append(attr_list, attr);
|
|
|
|
}
|
2017-11-21 18:54:44 -08:00
|
|
|
}
|
|
|
|
|
2018-02-02 01:56:58 -08:00
|
|
|
style = elm_widget_style_get(obj);
|
|
|
|
if (style)
|
2017-11-21 18:54:44 -08:00
|
|
|
{
|
2018-02-02 01:56:58 -08:00
|
|
|
attr = calloc(1, sizeof(Efl_Access_Attribute));
|
|
|
|
if (attr)
|
|
|
|
{
|
|
|
|
attr->key = eina_stringshare_add("style");
|
|
|
|
attr->value = eina_stringshare_add(style);
|
|
|
|
attr_list = eina_list_append(attr_list, attr);
|
|
|
|
}
|
2017-11-21 18:54:44 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
return attr_list;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Eina_List *
|
2018-04-03 04:27:30 -07:00
|
|
|
_elm_widget_item_efl_access_object_attributes_get(const Eo *eo_item, Elm_Widget_Item_Data *pd EINA_UNUSED)
|
2017-11-21 18:54:44 -08:00
|
|
|
{
|
2018-02-02 01:56:58 -08:00
|
|
|
const char *style = NULL;
|
2017-11-21 18:54:44 -08:00
|
|
|
Eina_List *attr_list = NULL;
|
|
|
|
Efl_Access_Attribute *attr = NULL;
|
2018-02-02 01:56:58 -08:00
|
|
|
|
2018-04-03 04:27:30 -07:00
|
|
|
attr_list = efl_access_object_attributes_get(efl_super(eo_item, ELM_WIDGET_ITEM_CLASS));
|
2018-02-02 01:56:58 -08:00
|
|
|
|
|
|
|
style = elm_object_item_style_get(eo_item);
|
|
|
|
if (style)
|
2017-11-21 18:54:44 -08:00
|
|
|
{
|
2018-02-02 01:56:58 -08:00
|
|
|
attr = calloc(1, sizeof(Efl_Access_Attribute));
|
|
|
|
if (attr)
|
|
|
|
{
|
|
|
|
attr->key = eina_stringshare_add("style");
|
|
|
|
attr->value = eina_stringshare_add(style);
|
|
|
|
attr_list = eina_list_append(attr_list, attr);
|
|
|
|
}
|
2017-11-21 18:54:44 -08:00
|
|
|
}
|
|
|
|
return attr_list;
|
2014-10-21 05:46:35 -07:00
|
|
|
}
|
|
|
|
|
2017-09-13 19:59:44 -07:00
|
|
|
EOLIAN static Eina_Rect
|
2018-04-17 11:09:44 -07:00
|
|
|
_elm_widget_item_efl_access_component_extents_get(const Eo *obj EINA_UNUSED, Elm_Widget_Item_Data *sd EINA_UNUSED, Eina_Bool screen_coords)
|
2017-07-16 21:45:08 -07:00
|
|
|
{
|
2017-09-13 19:59:44 -07:00
|
|
|
Eina_Rect r = EINA_RECT(-1, -1, -1, -1);
|
2017-07-16 21:45:08 -07:00
|
|
|
int ee_x, ee_y;
|
|
|
|
|
2017-09-13 01:32:35 -07:00
|
|
|
if (!sd->view) return r;
|
2017-07-16 21:45:08 -07:00
|
|
|
|
2018-04-05 01:47:26 -07:00
|
|
|
r = efl_gfx_entity_geometry_get(sd->view);
|
2017-07-16 21:45:08 -07:00
|
|
|
if (screen_coords)
|
|
|
|
{
|
|
|
|
Ecore_Evas *ee = ecore_evas_ecore_evas_get(evas_object_evas_get(sd->view));
|
2017-09-13 01:32:35 -07:00
|
|
|
if (ee)
|
|
|
|
{
|
|
|
|
ecore_evas_geometry_get(ee, &ee_x, &ee_y, NULL, NULL);
|
|
|
|
r.x += ee_x;
|
|
|
|
r.y += ee_y;
|
|
|
|
}
|
2017-07-16 21:45:08 -07:00
|
|
|
}
|
2017-09-13 01:32:35 -07:00
|
|
|
return r;
|
2017-07-16 21:45:08 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Eina_Bool
|
2017-09-13 19:59:44 -07:00
|
|
|
_elm_widget_item_efl_access_component_extents_set(Eo *obj EINA_UNUSED, Elm_Widget_Item_Data *sd EINA_UNUSED, Eina_Bool screen_coords EINA_UNUSED, Eina_Rect r EINA_UNUSED)
|
2017-07-16 21:45:08 -07:00
|
|
|
{
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Eina_Bool
|
2017-09-11 23:49:29 -07:00
|
|
|
_elm_widget_item_efl_access_component_focus_grab(Eo *obj EINA_UNUSED, Elm_Widget_Item_Data *_pd EINA_UNUSED)
|
2017-07-16 21:45:08 -07:00
|
|
|
{
|
|
|
|
elm_object_item_focus_set(obj, EINA_TRUE);
|
|
|
|
return elm_object_item_focus_get(obj);
|
|
|
|
}
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
EOLIAN static Efl_Object *
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_efl_object_provider_find(const Eo *obj, Elm_Widget_Smart_Data *pd, const Efl_Object *klass)
|
2016-06-02 12:47:54 -07:00
|
|
|
{
|
2016-08-10 07:23:04 -07:00
|
|
|
Efl_Object *lookup = NULL;
|
2016-06-02 12:47:54 -07:00
|
|
|
|
2016-06-23 05:29:55 -07:00
|
|
|
if ((klass == EFL_CONFIG_INTERFACE) || (klass == EFL_CONFIG_GLOBAL_CLASS))
|
2016-06-21 01:54:56 -07:00
|
|
|
return _efl_config_obj;
|
|
|
|
|
2018-04-03 04:27:30 -07:00
|
|
|
if (klass == EFL_ACCESS_OBJECT_MIXIN)
|
2018-02-14 18:14:52 -08:00
|
|
|
{
|
2018-04-03 04:27:30 -07:00
|
|
|
Efl_Access_Type type = efl_access_object_access_type_get(obj);
|
2018-02-14 18:14:52 -08:00
|
|
|
if (type != EFL_ACCESS_TYPE_SKIPPED)
|
|
|
|
return (Eo*)obj;
|
|
|
|
}
|
|
|
|
|
2016-06-02 12:47:54 -07:00
|
|
|
if (pd->provider_lookup) return NULL;
|
|
|
|
pd->provider_lookup = EINA_TRUE;
|
|
|
|
|
2018-01-15 22:12:49 -08:00
|
|
|
if (pd->parent_obj) lookup = efl_provider_find(pd->parent_obj, klass);
|
2016-08-15 06:44:41 -07:00
|
|
|
if (!lookup) lookup = efl_provider_find(efl_super(obj, MY_CLASS), klass);
|
2016-06-02 12:47:54 -07:00
|
|
|
|
|
|
|
pd->provider_lookup = EINA_FALSE;
|
|
|
|
|
|
|
|
return lookup;
|
|
|
|
}
|
|
|
|
|
2016-11-04 09:43:40 -07:00
|
|
|
EOLIAN static Efl_Ui_Focus_Manager*
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_efl_ui_focus_object_focus_parent_get(const Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *pd EINA_UNUSED)
|
2016-11-04 09:43:40 -07:00
|
|
|
{
|
2017-07-24 14:35:26 -07:00
|
|
|
return pd->focus.parent;
|
2016-11-19 03:46:21 -08:00
|
|
|
}
|
2016-11-04 09:43:40 -07:00
|
|
|
|
2016-11-19 03:46:21 -08:00
|
|
|
EOLIAN static Efl_Ui_Focus_Manager*
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_efl_ui_focus_object_focus_manager_get(const Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *pd EINA_UNUSED)
|
2016-11-19 03:46:21 -08:00
|
|
|
{
|
2017-07-24 14:35:26 -07:00
|
|
|
return pd->focus.manager;
|
2016-11-04 09:43:40 -07:00
|
|
|
}
|
|
|
|
|
2017-09-13 19:59:44 -07:00
|
|
|
EOLIAN static Eina_Rect
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_efl_ui_focus_object_focus_geometry_get(const Eo *obj, Elm_Widget_Smart_Data *pd EINA_UNUSED)
|
2016-11-04 09:43:40 -07:00
|
|
|
{
|
2018-04-05 01:47:26 -07:00
|
|
|
return efl_gfx_entity_geometry_get(obj);
|
2016-11-04 09:43:40 -07:00
|
|
|
}
|
|
|
|
|
2016-12-07 07:59:13 -08:00
|
|
|
EOLIAN static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_efl_ui_widget_efl_ui_focus_object_focus_set(Eo *obj, Elm_Widget_Smart_Data *pd, Eina_Bool focus)
|
2016-12-07 07:59:13 -08:00
|
|
|
{
|
|
|
|
pd->focused = focus;
|
2016-12-20 08:31:33 -08:00
|
|
|
|
|
|
|
efl_ui_focus_object_focus_set(efl_super(obj, MY_CLASS), focus);
|
2017-10-20 02:45:07 -07:00
|
|
|
|
2018-01-19 00:25:47 -08:00
|
|
|
efl_ui_focus_object_on_focus_update(obj);
|
2016-12-07 07:59:13 -08:00
|
|
|
}
|
|
|
|
|
2017-06-29 04:02:59 -07:00
|
|
|
/* Legacy APIs */
|
|
|
|
|
|
|
|
/* elm_object_content_xxx APIs are supposed to work on all objects for which
|
|
|
|
* elm_object_widget_check() returns true. The below checks avoid printing out
|
|
|
|
* undesired ERR messages. */
|
|
|
|
EAPI void
|
2017-09-19 23:16:12 -07:00
|
|
|
elm_widget_content_part_set(Evas_Object *obj, const char *part, Evas_Object *content)
|
2017-06-29 04:02:59 -07:00
|
|
|
{
|
|
|
|
ELM_WIDGET_CHECK(obj);
|
2018-11-16 01:45:05 -08:00
|
|
|
if (efl_isa(obj, EFL_UI_LAYOUT_CLASS))
|
2017-09-19 23:16:12 -07:00
|
|
|
{
|
|
|
|
elm_layout_content_set(obj, part, content);
|
|
|
|
return;
|
|
|
|
}
|
2017-06-29 04:02:59 -07:00
|
|
|
if (!efl_isa(obj, EFL_PART_INTERFACE)) return;
|
|
|
|
if (!part)
|
|
|
|
{
|
2018-01-07 20:55:35 -08:00
|
|
|
part = efl_ui_widget_default_content_part_get(obj);
|
2017-06-29 04:02:59 -07:00
|
|
|
if (!part) return;
|
|
|
|
}
|
|
|
|
efl_content_set(efl_part(obj, part), content);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Evas_Object *
|
2017-09-19 23:16:12 -07:00
|
|
|
elm_widget_content_part_get(const Evas_Object *obj, const char *part)
|
2017-06-29 04:02:59 -07:00
|
|
|
{
|
|
|
|
ELM_WIDGET_CHECK(obj) NULL;
|
2018-11-16 01:45:05 -08:00
|
|
|
if (efl_isa(obj, EFL_UI_LAYOUT_CLASS))
|
2017-09-19 23:16:12 -07:00
|
|
|
return elm_layout_content_get(obj, part);
|
2017-06-29 04:02:59 -07:00
|
|
|
if (!efl_isa(obj, EFL_PART_INTERFACE)) return NULL;
|
|
|
|
if (!part)
|
|
|
|
{
|
2018-01-07 20:55:35 -08:00
|
|
|
part = efl_ui_widget_default_content_part_get(obj);
|
2017-06-29 04:02:59 -07:00
|
|
|
if (!part) return NULL;
|
|
|
|
}
|
|
|
|
return efl_content_get(efl_part(obj, part));
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Evas_Object *
|
2017-09-19 23:16:12 -07:00
|
|
|
elm_widget_content_part_unset(Evas_Object *obj, const char *part)
|
2017-06-29 04:02:59 -07:00
|
|
|
{
|
|
|
|
ELM_WIDGET_CHECK(obj) NULL;
|
2018-11-16 01:45:05 -08:00
|
|
|
if (efl_isa(obj, EFL_UI_LAYOUT_CLASS))
|
2017-09-19 23:16:12 -07:00
|
|
|
return elm_layout_content_unset(obj, part);
|
2017-06-29 04:02:59 -07:00
|
|
|
if (!efl_isa(obj, EFL_PART_INTERFACE)) return NULL;
|
|
|
|
if (!part)
|
|
|
|
{
|
2018-01-07 20:55:35 -08:00
|
|
|
part = efl_ui_widget_default_content_part_get(obj);
|
2017-06-29 04:02:59 -07:00
|
|
|
if (!part) return NULL;
|
|
|
|
}
|
|
|
|
return efl_content_unset(efl_part(obj, part));
|
|
|
|
}
|
|
|
|
|
2017-08-08 01:53:55 -07:00
|
|
|
EAPI void
|
|
|
|
elm_widget_signal_emit(Eo *obj, const char *emission, const char *source)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_CHECK(obj);
|
2018-06-05 04:22:04 -07:00
|
|
|
|
2018-11-16 01:45:05 -08:00
|
|
|
if (efl_isa(obj, EFL_UI_LAYOUT_CLASS))
|
2017-08-08 01:53:55 -07:00
|
|
|
elm_layout_signal_emit(obj, emission, source);
|
|
|
|
else if (evas_object_smart_type_check(obj, "elm_icon"))
|
|
|
|
{
|
|
|
|
WRN("Deprecated function. This functionality on icon objects"
|
|
|
|
" will be dropped on a next release.");
|
|
|
|
_elm_icon_signal_emit(obj, emission, source);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_widget_signal_callback_add(Eo *obj, const char *emission, const char *source, Edje_Signal_Cb func, void *data)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_CHECK(obj);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(func);
|
|
|
|
if (evas_object_smart_type_check(obj, "elm_layout"))
|
|
|
|
elm_layout_signal_callback_add(obj, emission, source, func, data);
|
|
|
|
else if (evas_object_smart_type_check(obj, "elm_icon"))
|
|
|
|
{
|
|
|
|
WRN("Deprecated function. This functionality on icon objects"
|
|
|
|
" will be dropped on a next release.");
|
|
|
|
|
|
|
|
_elm_icon_signal_callback_add(obj, emission, source, func, data);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void *
|
|
|
|
elm_widget_signal_callback_del(Eo *obj, const char *emission, const char *source, Edje_Signal_Cb func)
|
|
|
|
{
|
|
|
|
void *data = NULL;
|
|
|
|
|
|
|
|
ELM_WIDGET_CHECK(obj) NULL;
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(func, NULL);
|
|
|
|
if (evas_object_smart_type_check(obj, "elm_layout"))
|
|
|
|
data = elm_layout_signal_callback_del(obj, emission, source, func);
|
|
|
|
else if (evas_object_smart_type_check(obj, "elm_icon"))
|
|
|
|
{
|
|
|
|
WRN("Deprecated function. This functionality on icon objects"
|
|
|
|
" will be dropped on a next release.");
|
|
|
|
|
|
|
|
data = _elm_icon_signal_callback_del(obj, emission, source, func);
|
|
|
|
}
|
|
|
|
|
|
|
|
return data;
|
|
|
|
}
|
|
|
|
|
2017-06-29 04:02:59 -07:00
|
|
|
|
2017-12-14 00:25:37 -08:00
|
|
|
/* Widget Shadow Begin */
|
|
|
|
|
|
|
|
typedef struct _Widget_Shadow
|
|
|
|
{
|
|
|
|
Eo *widget;
|
|
|
|
Eo *surface;
|
|
|
|
struct {
|
|
|
|
double rx, ry, ox, oy, grow;
|
|
|
|
int r, g, b, a;
|
|
|
|
} props;
|
|
|
|
Eina_Stringshare *code, *name;
|
|
|
|
} Widget_Shadow;
|
|
|
|
|
|
|
|
static void _widget_shadow_update(Widget_Shadow *shadow);
|
|
|
|
|
|
|
|
static void
|
|
|
|
_widget_shadow_del_cb(void *data, const Efl_Event *ev EINA_UNUSED)
|
|
|
|
{
|
|
|
|
Widget_Shadow *shadow = data;
|
|
|
|
|
|
|
|
efl_del(shadow->surface);
|
|
|
|
free(shadow);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_widget_shadow_event_cb(void *data, const Efl_Event *ev EINA_UNUSED)
|
|
|
|
{
|
|
|
|
Widget_Shadow *shadow = data;
|
|
|
|
_widget_shadow_update(shadow);
|
|
|
|
}
|
|
|
|
|
|
|
|
EFL_CALLBACKS_ARRAY_DEFINE(widget_shadow_cb,
|
|
|
|
{ EFL_EVENT_DEL, _widget_shadow_del_cb },
|
2019-02-21 10:01:56 -08:00
|
|
|
{ EFL_GFX_ENTITY_EVENT_POSITION_CHANGED, _widget_shadow_event_cb },
|
|
|
|
{ EFL_GFX_ENTITY_EVENT_SIZE_CHANGED, _widget_shadow_event_cb },
|
2019-02-21 11:09:41 -08:00
|
|
|
{ EFL_GFX_ENTITY_EVENT_STACKING_CHANGED, _widget_shadow_event_cb },
|
2018-04-05 01:47:26 -07:00
|
|
|
{ EFL_GFX_ENTITY_EVENT_HIDE, _widget_shadow_event_cb },
|
|
|
|
{ EFL_GFX_ENTITY_EVENT_SHOW, _widget_shadow_event_cb })
|
2017-12-14 00:25:37 -08:00
|
|
|
|
|
|
|
static Widget_Shadow *
|
2018-04-17 11:09:44 -07:00
|
|
|
_widget_shadow_part_get(const Eo *part_obj)
|
2017-12-14 00:25:37 -08:00
|
|
|
{
|
|
|
|
Elm_Part_Data *pd = efl_data_scope_get(part_obj, EFL_UI_WIDGET_PART_CLASS);
|
|
|
|
Widget_Shadow *shadow;
|
|
|
|
Eo *widget = pd->obj;
|
|
|
|
|
|
|
|
shadow = efl_key_data_get(widget, "__elm_shadow");
|
|
|
|
if (!shadow)
|
|
|
|
{
|
|
|
|
shadow = calloc(1, sizeof(*shadow));
|
2019-01-29 06:23:44 -08:00
|
|
|
if (!shadow) return NULL;
|
2017-12-14 00:25:37 -08:00
|
|
|
shadow->widget = pd->obj;
|
|
|
|
efl_key_data_set(widget, "__elm_shadow", shadow);
|
|
|
|
efl_event_callback_array_add(widget, widget_shadow_cb(), shadow);
|
|
|
|
}
|
|
|
|
return shadow;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_widget_shadow_update(Widget_Shadow *ws)
|
|
|
|
{
|
|
|
|
int l = 0, r = 0, t = 0, b = 0;
|
2017-12-15 19:09:12 -08:00
|
|
|
Eina_Rect srect, wrect;
|
2017-12-14 00:25:37 -08:00
|
|
|
char filter[1024];
|
|
|
|
|
|
|
|
#define FILTER_FMT \
|
|
|
|
"a = buffer { 'alpha' }" \
|
|
|
|
"grow { %f, dst = a, alphaonly = true }" \
|
|
|
|
"blur { src = a, rx = %f, ry = %f, color = color(%d,%d,%d,%d) }"
|
|
|
|
|
|
|
|
if (!ws->surface)
|
|
|
|
{
|
|
|
|
ws->surface = efl_add(EFL_CANVAS_PROXY_CLASS, ws->widget);
|
|
|
|
efl_gfx_fill_auto_set(ws->surface, 1);
|
|
|
|
efl_canvas_proxy_source_clip_set(ws->surface, EINA_FALSE);
|
|
|
|
efl_canvas_proxy_source_events_set(ws->surface, EINA_FALSE);
|
|
|
|
efl_canvas_proxy_source_set(ws->surface, ws->widget);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ws->code)
|
|
|
|
{
|
|
|
|
snprintf(filter, sizeof(filter), FILTER_FMT,
|
|
|
|
ws->props.grow, ws->props.rx, ws->props.ry,
|
|
|
|
ws->props.r, ws->props.g, ws->props.b, ws->props.a);
|
|
|
|
}
|
|
|
|
|
|
|
|
efl_gfx_filter_program_set(ws->surface,
|
|
|
|
ws->code ? ws->code : filter,
|
|
|
|
ws->name ? ws->name : "shadow");
|
|
|
|
efl_gfx_filter_padding_get(ws->surface, &l, &r, &t, &b);
|
|
|
|
|
2018-04-05 01:47:26 -07:00
|
|
|
wrect = efl_gfx_entity_geometry_get(ws->widget);
|
2017-12-14 00:25:37 -08:00
|
|
|
srect.x = wrect.x + (int) (-l + ws->props.ox);
|
|
|
|
srect.y = wrect.y + (int) (-t + ws->props.oy);
|
|
|
|
srect.w = wrect.w + (int) (l + r);
|
|
|
|
srect.h = wrect.h + (int) (t + b);
|
|
|
|
|
|
|
|
if ((!ws->props.a && !ws->code) ||
|
2018-04-05 01:47:26 -07:00
|
|
|
!efl_gfx_entity_visible_get(ws->widget))
|
2017-12-14 00:25:37 -08:00
|
|
|
{
|
2018-04-05 01:47:26 -07:00
|
|
|
efl_gfx_entity_visible_set(ws->surface, EINA_FALSE);
|
2017-12-14 00:25:37 -08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
efl_canvas_object_clip_set(ws->surface, efl_canvas_object_clip_get(ws->widget));
|
|
|
|
efl_canvas_group_member_add(efl_canvas_object_render_parent_get(ws->widget), ws->surface);
|
2018-04-05 01:47:26 -07:00
|
|
|
efl_gfx_entity_geometry_set(ws->surface, srect);
|
2017-12-14 00:25:37 -08:00
|
|
|
efl_gfx_stack_below(ws->surface, ws->widget);
|
2018-04-05 01:47:26 -07:00
|
|
|
efl_gfx_entity_visible_set(ws->surface, EINA_TRUE);
|
2017-12-14 00:25:37 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2018-01-07 20:55:35 -08:00
|
|
|
_elm_widget_shadow_update(Efl_Ui_Widget *obj)
|
2017-12-14 00:25:37 -08:00
|
|
|
{
|
|
|
|
Widget_Shadow *shadow = _widget_shadow_part_get(obj);
|
|
|
|
_widget_shadow_update(shadow);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
|
|
|
_efl_ui_widget_part_shadow_efl_gfx_blur_offset_set(Eo *obj, void *_pd EINA_UNUSED, double ox, double oy)
|
|
|
|
{
|
|
|
|
Widget_Shadow *shadow = _widget_shadow_part_get(obj);
|
|
|
|
shadow->props.ox = ox;
|
|
|
|
shadow->props.oy = oy;
|
|
|
|
_widget_shadow_update(shadow);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_part_shadow_efl_gfx_blur_offset_get(const Eo *obj, void *_pd EINA_UNUSED, double *ox, double *oy)
|
2017-12-14 00:25:37 -08:00
|
|
|
{
|
|
|
|
Widget_Shadow *shadow = _widget_shadow_part_get(obj);
|
|
|
|
if (ox) *ox = shadow->props.ox;
|
|
|
|
if (oy) *oy = shadow->props.oy;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
|
|
|
_efl_ui_widget_part_shadow_efl_gfx_blur_radius_set(Eo *obj, void *_pd EINA_UNUSED, double rx, double ry)
|
|
|
|
{
|
|
|
|
Widget_Shadow *shadow = _widget_shadow_part_get(obj);
|
|
|
|
shadow->props.rx = rx;
|
|
|
|
shadow->props.ry = ry;
|
|
|
|
_widget_shadow_update(shadow);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_part_shadow_efl_gfx_blur_radius_get(const Eo *obj, void *_pd EINA_UNUSED, double *rx, double *ry)
|
2017-12-14 00:25:37 -08:00
|
|
|
{
|
|
|
|
Widget_Shadow *shadow = _widget_shadow_part_get(obj);
|
|
|
|
if (rx) *rx = shadow->props.rx;
|
|
|
|
if (ry) *ry = shadow->props.ry;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
2017-12-19 23:34:01 -08:00
|
|
|
_efl_ui_widget_part_shadow_efl_gfx_color_color_set(Eo *obj, void *_pd EINA_UNUSED, int r, int g, int b, int a)
|
2017-12-14 00:25:37 -08:00
|
|
|
{
|
|
|
|
Widget_Shadow *shadow = _widget_shadow_part_get(obj);
|
|
|
|
shadow->props.r = r;
|
|
|
|
shadow->props.g = g;
|
|
|
|
shadow->props.b = b;
|
|
|
|
shadow->props.a = a;
|
|
|
|
_widget_shadow_update(shadow);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_part_shadow_efl_gfx_color_color_get(const Eo *obj, void *_pd EINA_UNUSED, int *r, int *g, int *b, int *a)
|
2017-12-14 00:25:37 -08:00
|
|
|
{
|
|
|
|
Widget_Shadow *shadow = _widget_shadow_part_get(obj);
|
|
|
|
if (r) *r = shadow->props.r;
|
|
|
|
if (g) *g = shadow->props.g;
|
|
|
|
if (b) *b = shadow->props.b;
|
|
|
|
if (a) *a = shadow->props.a;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
|
|
|
_efl_ui_widget_part_shadow_efl_gfx_blur_grow_set(Eo *obj, void *_pd EINA_UNUSED, double radius)
|
|
|
|
{
|
|
|
|
Widget_Shadow *shadow = _widget_shadow_part_get(obj);
|
|
|
|
shadow->props.grow = radius;
|
|
|
|
_widget_shadow_update(shadow);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static double
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_part_shadow_efl_gfx_blur_grow_get(const Eo *obj, void *_pd EINA_UNUSED)
|
2017-12-14 00:25:37 -08:00
|
|
|
{
|
|
|
|
Widget_Shadow *shadow = _widget_shadow_part_get(obj);
|
|
|
|
return shadow->props.grow;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
|
|
|
_efl_ui_widget_part_shadow_efl_gfx_filter_filter_program_set(Eo *obj, void *_pd EINA_UNUSED, const char *code, const char *name)
|
|
|
|
{
|
|
|
|
Widget_Shadow *ws = _widget_shadow_part_get(obj);
|
|
|
|
eina_stringshare_replace(&ws->code, code);
|
|
|
|
eina_stringshare_replace(&ws->name, name);
|
|
|
|
_widget_shadow_update(ws);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_part_shadow_efl_gfx_filter_filter_program_get(const Eo *obj, void *_pd EINA_UNUSED, const char **code, const char **name)
|
2017-12-14 00:25:37 -08:00
|
|
|
{
|
|
|
|
Widget_Shadow *ws = _widget_shadow_part_get(obj);
|
|
|
|
efl_gfx_filter_program_get(ws->surface, code, name);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
2018-04-05 01:47:26 -07:00
|
|
|
_efl_ui_widget_part_shadow_efl_gfx_filter_filter_source_set(Eo *obj, void *_pd EINA_UNUSED, const char *name, Efl_Gfx_Entity *source)
|
2017-12-14 00:25:37 -08:00
|
|
|
{
|
|
|
|
Widget_Shadow *ws = _widget_shadow_part_get(obj);
|
|
|
|
_widget_shadow_update(ws);
|
|
|
|
efl_gfx_filter_source_set(ws->surface, name, source);
|
|
|
|
}
|
|
|
|
|
2018-04-05 01:47:26 -07:00
|
|
|
EOLIAN static Efl_Gfx_Entity *
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_part_shadow_efl_gfx_filter_filter_source_get(const Eo *obj, void *_pd EINA_UNUSED, const char *name)
|
2017-12-14 00:25:37 -08:00
|
|
|
{
|
|
|
|
Widget_Shadow *ws = _widget_shadow_part_get(obj);
|
|
|
|
return efl_gfx_filter_source_get(ws->surface, name);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
|
|
|
_efl_ui_widget_part_shadow_efl_gfx_filter_filter_data_set(Eo *obj, void *_pd EINA_UNUSED, const char *name, const char *value, Eina_Bool execute)
|
|
|
|
{
|
|
|
|
Widget_Shadow *ws = _widget_shadow_part_get(obj);
|
|
|
|
_widget_shadow_update(ws);
|
|
|
|
efl_gfx_filter_data_set(ws->surface, name, value, execute);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_part_shadow_efl_gfx_filter_filter_data_get(const Eo *obj, void *_pd EINA_UNUSED, const char *name, const char **value, Eina_Bool *execute)
|
2017-12-14 00:25:37 -08:00
|
|
|
{
|
|
|
|
Widget_Shadow *ws = _widget_shadow_part_get(obj);
|
|
|
|
efl_gfx_filter_data_get(ws->surface, name, value, execute);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_part_shadow_efl_gfx_filter_filter_padding_get(const Eo *obj, void *_pd EINA_UNUSED, int *l, int *r, int *t, int *b)
|
2017-12-14 00:25:37 -08:00
|
|
|
{
|
|
|
|
Widget_Shadow *ws = _widget_shadow_part_get(obj);
|
|
|
|
efl_gfx_filter_padding_get(ws->surface, l, r, t, b);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
|
|
|
_efl_ui_widget_part_shadow_efl_gfx_filter_filter_state_set(Eo *obj, void *_pd EINA_UNUSED, const char *cur_state, double cur_val, const char *next_state, double next_val, double pos)
|
|
|
|
{
|
|
|
|
Widget_Shadow *ws = _widget_shadow_part_get(obj);
|
|
|
|
efl_gfx_filter_state_set(ws->surface, cur_state, cur_val, next_state, next_val, pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_part_shadow_efl_gfx_filter_filter_state_get(const Eo *obj, void *_pd EINA_UNUSED, const char **cur_state, double *cur_val, const char **next_state, double *next_val, double *pos)
|
2017-12-14 00:25:37 -08:00
|
|
|
{
|
|
|
|
Widget_Shadow *ws = _widget_shadow_part_get(obj);
|
|
|
|
efl_gfx_filter_state_get(ws->surface, cur_state, cur_val, next_state, next_val, pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
#include "efl_ui_widget_part_shadow.eo.c"
|
|
|
|
|
|
|
|
/* Widget Shadow End */
|
|
|
|
|
|
|
|
|
2017-09-19 04:02:26 -07:00
|
|
|
/* Efl.Part implementation */
|
|
|
|
|
2017-09-19 05:46:59 -07:00
|
|
|
EOLIAN static Efl_Object *
|
2018-05-03 16:34:17 -07:00
|
|
|
_efl_ui_widget_efl_part_part_get(const Eo *obj, Elm_Widget_Smart_Data *wd EINA_UNUSED, const char *part)
|
2017-09-19 04:02:26 -07:00
|
|
|
{
|
2017-11-23 21:41:31 -08:00
|
|
|
if (eina_streq(part, "background"))
|
|
|
|
return ELM_PART_IMPLEMENT(EFL_UI_WIDGET_PART_BG_CLASS, obj, part);
|
2017-12-14 00:25:37 -08:00
|
|
|
else if (eina_streq(part, "shadow"))
|
|
|
|
return ELM_PART_IMPLEMENT(EFL_UI_WIDGET_PART_SHADOW_CLASS, obj, part);
|
2017-10-23 22:43:43 -07:00
|
|
|
return ELM_PART_IMPLEMENT(EFL_UI_WIDGET_PART_CLASS, obj, part);
|
2017-09-19 04:02:26 -07:00
|
|
|
}
|
|
|
|
|
2017-09-19 05:46:59 -07:00
|
|
|
EOLIAN static void \
|
2017-09-19 04:02:26 -07:00
|
|
|
_efl_ui_widget_part_efl_object_destructor(Eo *obj, Elm_Part_Data *pd)
|
|
|
|
{
|
|
|
|
ELM_PART_HOOK;
|
|
|
|
eina_tmpstr_del(pd->part);
|
|
|
|
efl_destructor(efl_super(obj, EFL_UI_WIDGET_PART_CLASS));
|
|
|
|
}
|
|
|
|
|
|
|
|
#include "efl_ui_widget_part.eo.c"
|
|
|
|
|
|
|
|
/* Efl.Part end */
|
|
|
|
|
2017-11-23 21:41:31 -08:00
|
|
|
/* Efl.Part Bg implementation */
|
|
|
|
|
2017-11-23 22:17:05 -08:00
|
|
|
Efl_Canvas_Object *
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_bg_get(const Efl_Ui_Widget *obj)
|
2017-11-23 21:41:31 -08:00
|
|
|
{
|
2017-11-23 22:17:05 -08:00
|
|
|
Elm_Widget_Smart_Data *sd = efl_data_scope_get(obj, MY_CLASS);
|
2017-11-23 21:41:31 -08:00
|
|
|
Evas_Object *bg_obj = sd->bg;
|
|
|
|
|
|
|
|
if (!bg_obj)
|
|
|
|
{
|
2018-04-17 11:09:44 -07:00
|
|
|
/* XXX const */
|
efl_ui_bg: remove Efl.Ui.Bg interface and rename Efl.Ui.Bg_Widget class
Summary:
Efl.Ui.Bg interface does not have any new property or method.
Moreover, Efl.Ui.Bg interface is not used by widgets except
Efl.Ui.Bg_Widget and Efl.Ui.Widget_Part_Bg.
Consequently, Efl.Ui.Bg interface can be replaced by other interfaces.
Due to Efl.Ui.Bg interface, the bg widget class name becomes
Efl.UI.Bg_Widget which is not synchronized with other widget names.
Therefore, to keep consistency with other widgets, it would be better to
remove Efl.Ui.Bg interface and rename Efl.Ui.Bg_Widget to Efl.Ui.Bg.
Reviewers: woohyun, segfaultxavi, bu5hm4n, zmike
Reviewed By: segfaultxavi
Subscribers: cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D7304
2018-11-19 17:24:05 -08:00
|
|
|
bg_obj = efl_add(EFL_UI_BG_CLASS, (Eo *)obj);
|
2017-11-23 22:17:05 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(bg_obj, NULL);
|
|
|
|
sd->bg = bg_obj;
|
2018-04-17 11:09:44 -07:00
|
|
|
efl_canvas_group_member_add((Eo *)obj, sd->bg);
|
2017-11-23 22:17:05 -08:00
|
|
|
evas_object_stack_below(sd->bg, sd->resize_obj);
|
|
|
|
_smart_reconfigure(sd);
|
2017-11-23 21:41:31 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
return bg_obj;
|
|
|
|
}
|
|
|
|
|
2017-11-23 22:17:05 -08:00
|
|
|
static inline Efl_Canvas_Object *
|
2018-04-17 11:09:44 -07:00
|
|
|
efl_ui_widget_part_bg_get(const Eo *part_obj)
|
2017-11-23 22:17:05 -08:00
|
|
|
{
|
|
|
|
Elm_Part_Data *pd = efl_data_scope_get(part_obj, EFL_UI_WIDGET_PART_CLASS);
|
|
|
|
return _efl_ui_widget_bg_get(pd->obj);
|
|
|
|
}
|
|
|
|
|
2017-11-23 21:41:31 -08:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_efl_ui_widget_part_bg_efl_file_file_set(Eo *obj, void *pd EINA_UNUSED, const char *file, const char *key)
|
|
|
|
{
|
|
|
|
Evas_Object *bg_obj = efl_ui_widget_part_bg_get(obj);
|
|
|
|
|
|
|
|
return efl_file_set(bg_obj, file, key);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_part_bg_efl_file_file_get(const Eo *obj, void *pd EINA_UNUSED, const char **file, const char **key)
|
2017-11-23 21:41:31 -08:00
|
|
|
{
|
|
|
|
Evas_Object *bg_obj = efl_ui_widget_part_bg_get(obj);
|
|
|
|
|
|
|
|
efl_file_get(bg_obj, file, key);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
2017-12-19 23:34:01 -08:00
|
|
|
_efl_ui_widget_part_bg_efl_gfx_color_color_set(Eo *obj, void *pd EINA_UNUSED, int r, int g, int b, int a)
|
2017-11-23 21:41:31 -08:00
|
|
|
{
|
|
|
|
Evas_Object *bg_obj = efl_ui_widget_part_bg_get(obj);
|
|
|
|
|
|
|
|
efl_gfx_color_set(bg_obj, r, g, b, a);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_ui_widget_part_bg_efl_gfx_color_color_get(const Eo *obj, void *pd EINA_UNUSED, int *r, int *g, int *b, int *a)
|
2017-11-23 21:41:31 -08:00
|
|
|
{
|
|
|
|
Evas_Object *bg_obj = efl_ui_widget_part_bg_get(obj);
|
|
|
|
|
|
|
|
efl_gfx_color_get(bg_obj, r, g, b, a);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
2018-04-19 04:26:59 -07:00
|
|
|
_efl_ui_widget_part_bg_efl_gfx_image_scale_type_set(Eo *obj, void *pd EINA_UNUSED, Efl_Gfx_Image_Scale_Type scale_type)
|
2017-11-23 21:41:31 -08:00
|
|
|
{
|
|
|
|
Evas_Object *bg_obj = efl_ui_widget_part_bg_get(obj);
|
|
|
|
|
2018-04-19 04:26:59 -07:00
|
|
|
efl_gfx_image_scale_type_set(bg_obj, scale_type);
|
2017-11-23 21:41:31 -08:00
|
|
|
}
|
|
|
|
|
2018-04-19 04:26:59 -07:00
|
|
|
EOLIAN static Efl_Gfx_Image_Scale_Type
|
|
|
|
_efl_ui_widget_part_bg_efl_gfx_image_scale_type_get(const Eo *obj, void *pd EINA_UNUSED)
|
2017-11-23 21:41:31 -08:00
|
|
|
{
|
|
|
|
Evas_Object *bg_obj = efl_ui_widget_part_bg_get(obj);
|
|
|
|
|
2018-04-19 04:26:59 -07:00
|
|
|
return efl_gfx_image_scale_type_get(bg_obj);
|
2017-11-23 21:41:31 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
#include "efl_ui_widget_part_bg.eo.c"
|
|
|
|
|
|
|
|
/* Efl.Part Bg end */
|
|
|
|
|
2017-09-19 04:02:26 -07:00
|
|
|
|
2017-05-18 01:52:17 -07:00
|
|
|
/* Internal EO APIs and hidden overrides */
|
|
|
|
|
2018-01-07 20:55:35 -08:00
|
|
|
EFL_FUNC_BODY_CONST(efl_ui_widget_default_content_part_get, const char *, NULL)
|
|
|
|
EFL_FUNC_BODY_CONST(efl_ui_widget_default_text_part_get, const char *, NULL)
|
2017-06-29 04:02:59 -07:00
|
|
|
|
2018-01-07 20:55:35 -08:00
|
|
|
ELM_PART_CONTENT_DEFAULT_GET(efl_ui_widget, NULL)
|
|
|
|
ELM_PART_TEXT_DEFAULT_GET(efl_ui_widget, NULL)
|
2017-06-29 04:02:59 -07:00
|
|
|
|
2018-01-07 20:55:35 -08:00
|
|
|
#define EFL_UI_WIDGET_EXTRA_OPS \
|
|
|
|
EFL_CANVAS_GROUP_ADD_DEL_OPS(efl_ui_widget), \
|
|
|
|
ELM_PART_CONTENT_DEFAULT_OPS(efl_ui_widget), \
|
|
|
|
ELM_PART_TEXT_DEFAULT_OPS(efl_ui_widget), \
|
2019-02-23 05:22:11 -08:00
|
|
|
EFL_OBJECT_OP_FUNC(efl_canvas_object_is_frame_object_set, _efl_ui_widget_efl_canvas_object_is_frame_object_set), \
|
2018-01-07 20:55:35 -08:00
|
|
|
EFL_OBJECT_OP_FUNC(efl_dbg_info_get, _efl_ui_widget_efl_object_dbg_info_get)
|
2016-12-07 07:59:13 -08:00
|
|
|
|
2017-07-16 21:45:08 -07:00
|
|
|
#include "elm_widget_item.eo.c"
|
2019-02-24 01:57:01 -08:00
|
|
|
#include "elm_widget_item_container.eo.c"
|
2018-01-07 20:55:35 -08:00
|
|
|
#include "efl_ui_widget.eo.c"
|
2017-09-21 23:13:16 -07:00
|
|
|
|
|
|
|
/* Others */
|
2018-12-21 14:46:10 -08:00
|
|
|
#include "efl_ui_l10n.eo.c"
|