2008-09-29 23:58:56 -07:00
|
|
|
#include <Elementary.h>
|
|
|
|
#include "elm_priv.h"
|
|
|
|
|
2010-02-06 09:31:09 -08:00
|
|
|
/**
|
|
|
|
* @defgroup Win Win
|
2010-02-08 19:04:18 -08:00
|
|
|
*
|
2010-04-12 01:12:02 -07:00
|
|
|
* The window class of Elementary. Contains functions to manipulate
|
|
|
|
* windows.
|
2010-02-06 09:31:09 -08:00
|
|
|
*/
|
|
|
|
|
2008-10-06 18:23:49 -07:00
|
|
|
typedef struct _Elm_Win Elm_Win;
|
2008-09-29 23:58:56 -07:00
|
|
|
|
2008-10-06 18:23:49 -07:00
|
|
|
struct _Elm_Win
|
2008-09-29 23:58:56 -07:00
|
|
|
{
|
2009-11-14 17:51:39 -08:00
|
|
|
Ecore_Evas *ee;
|
|
|
|
Evas *evas;
|
|
|
|
Evas_Object *parent, *win_obj;
|
|
|
|
Eina_List *subobjs;
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2009-11-14 17:51:39 -08:00
|
|
|
Ecore_X_Window xwin;
|
2010-04-12 01:27:10 -07:00
|
|
|
Ecore_Event_Handler *client_message_handler;
|
2010-09-24 09:41:25 -07:00
|
|
|
#endif
|
2009-11-14 17:51:39 -08:00
|
|
|
Ecore_Job *deferred_resize_job;
|
|
|
|
Ecore_Job *deferred_child_eval_job;
|
|
|
|
|
|
|
|
Elm_Win_Type type;
|
2008-11-18 02:11:57 -08:00
|
|
|
Elm_Win_Keyboard_Mode kbdmode;
|
2009-11-14 17:51:39 -08:00
|
|
|
Eina_Bool autodel : 1;
|
|
|
|
int *autodel_clear, rot;
|
2009-12-01 03:03:14 -08:00
|
|
|
struct {
|
|
|
|
int x, y;
|
|
|
|
} screen;
|
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
|
|
|
|
|
|
|
struct {
|
2010-09-28 09:54:11 -07:00
|
|
|
Evas_Object *top;
|
2010-10-04 05:48:15 -07:00
|
|
|
|
|
|
|
struct {
|
|
|
|
Evas_Object *target;
|
|
|
|
Eina_Bool visible : 1;
|
|
|
|
Eina_Bool handled : 1;
|
|
|
|
} cur, prev;
|
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
|
|
|
|
2010-10-04 10:34:35 -07:00
|
|
|
const char *style;
|
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
|
|
|
Ecore_Job *reconf_job;
|
|
|
|
|
|
|
|
Eina_Bool enabled : 1;
|
|
|
|
Eina_Bool changed_theme : 1;
|
2010-09-28 09:54:11 -07:00
|
|
|
Eina_Bool top_animate : 1;
|
2010-10-13 11:58:29 -07:00
|
|
|
Eina_Bool geometry_changed : 1;
|
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
|
|
|
} focus_highlight;
|
2008-09-29 23:58:56 -07:00
|
|
|
};
|
|
|
|
|
2010-03-08 22:15:39 -08:00
|
|
|
static const char *widtype = NULL;
|
2008-10-06 18:23:49 -07:00
|
|
|
static void _elm_win_obj_callback_del(void *data, Evas *e, Evas_Object *obj, void *event_info);
|
2010-04-04 21:58:43 -07:00
|
|
|
static void _elm_win_obj_callback_parent_del(void *data, Evas *e, Evas_Object *obj, void *event_info);
|
2009-10-26 01:27:08 -07:00
|
|
|
static void _elm_win_obj_intercept_show(void *data, Evas_Object *obj);
|
2009-12-01 03:03:14 -08:00
|
|
|
static void _elm_win_move(Ecore_Evas *ee);
|
2008-12-19 06:32:59 -08:00
|
|
|
static void _elm_win_resize(Ecore_Evas *ee);
|
2008-10-06 18:23:49 -07:00
|
|
|
static void _elm_win_delete_request(Ecore_Evas *ee);
|
|
|
|
static void _elm_win_resize_job(void *data);
|
2009-07-06 23:46:51 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2008-10-06 18:23:49 -07:00
|
|
|
static void _elm_win_xwin_update(Elm_Win *win);
|
2008-12-09 22:33:24 -08:00
|
|
|
#endif
|
2008-10-06 18:23:49 -07:00
|
|
|
static void _elm_win_eval_subobjs(Evas_Object *obj);
|
|
|
|
static void _elm_win_subobj_callback_del(void *data, Evas *e, Evas_Object *obj, void *event_info);
|
|
|
|
static void _elm_win_subobj_callback_changed_size_hints(void *data, Evas *e, Evas_Object *obj, void *event_info);
|
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
|
|
|
static void _elm_win_focus_highlight_init(Elm_Win *win);
|
|
|
|
static void _elm_win_focus_highlight_shutdown(Elm_Win *win);
|
|
|
|
static void _elm_win_focus_highlight_visible_set(Elm_Win *win, Eina_Bool visible);
|
|
|
|
static void _elm_win_focus_highlight_reconfigure_job_start(Elm_Win *win);
|
|
|
|
static void _elm_win_focus_highlight_reconfigure_job_stop(Elm_Win *win);
|
2010-09-28 09:54:11 -07:00
|
|
|
static void _elm_win_focus_highlight_anim_end(void *data, Evas_Object *obj, const char *emission, const char *source);
|
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
|
|
|
static void _elm_win_focus_highlight_reconfigure(Elm_Win *win);
|
2008-10-06 18:23:49 -07:00
|
|
|
|
2010-04-12 01:27:10 -07:00
|
|
|
Eina_List *_elm_win_list = NULL;
|
2008-10-06 18:23:49 -07:00
|
|
|
|
2009-12-01 03:03:14 -08:00
|
|
|
static void
|
|
|
|
_elm_win_move(Ecore_Evas *ee)
|
|
|
|
{
|
|
|
|
Evas_Object *obj = ecore_evas_object_associate_get(ee);
|
|
|
|
Elm_Win *win;
|
|
|
|
int x, y;
|
2010-09-24 09:41:25 -07:00
|
|
|
|
2010-03-08 23:30:48 -08:00
|
|
|
if (!obj) return;
|
2009-12-01 03:03:14 -08:00
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return;
|
|
|
|
ecore_evas_geometry_get(ee, &x, &y, NULL, NULL);
|
|
|
|
win->screen.x = x;
|
|
|
|
win->screen.y = y;
|
|
|
|
evas_object_smart_callback_call(win->win_obj, "moved", NULL);
|
|
|
|
}
|
|
|
|
|
2008-09-29 23:58:56 -07:00
|
|
|
static void
|
2008-10-06 18:23:49 -07:00
|
|
|
_elm_win_resize(Ecore_Evas *ee)
|
2008-09-29 23:58:56 -07:00
|
|
|
{
|
2009-08-09 15:23:46 -07:00
|
|
|
Evas_Object *obj = ecore_evas_object_associate_get(ee);
|
2009-11-14 17:51:39 -08:00
|
|
|
Elm_Win *win;
|
2010-09-24 09:41:25 -07:00
|
|
|
|
2010-03-08 23:30:48 -08:00
|
|
|
if (!obj) return;
|
2009-08-09 15:23:46 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
2008-10-24 19:11:06 -07:00
|
|
|
if (!win) return;
|
2008-10-06 18:23:49 -07:00
|
|
|
if (win->deferred_resize_job) ecore_job_del(win->deferred_resize_job);
|
|
|
|
win->deferred_resize_job = ecore_job_add(_elm_win_resize_job, win);
|
2008-09-29 23:58:56 -07:00
|
|
|
}
|
|
|
|
|
2009-04-04 09:58:28 -07:00
|
|
|
static void
|
|
|
|
_elm_win_focus_in(Ecore_Evas *ee)
|
|
|
|
{
|
2009-08-09 15:23:46 -07:00
|
|
|
Evas_Object *obj = ecore_evas_object_associate_get(ee);
|
2009-11-14 17:51:39 -08:00
|
|
|
Elm_Win *win;
|
2010-09-24 09:41:25 -07:00
|
|
|
|
2010-03-08 23:30:48 -08:00
|
|
|
if (!obj) return;
|
2009-08-09 15:23:46 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
2009-04-04 09:58:28 -07:00
|
|
|
if (!win) return;
|
2009-11-14 17:51:39 -08:00
|
|
|
/*NB: Why two different "focus signals" here ??? */
|
2009-10-14 01:41:36 -07:00
|
|
|
evas_object_smart_callback_call(win->win_obj, "focus-in", NULL); // FIXME: remove me
|
|
|
|
evas_object_smart_callback_call(win->win_obj, "focus,in", NULL);
|
2010-10-04 05:48:15 -07:00
|
|
|
win->focus_highlight.cur.visible = EINA_TRUE;
|
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
|
|
|
_elm_win_focus_highlight_reconfigure_job_start(win);
|
2009-04-04 09:58:28 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_win_focus_out(Ecore_Evas *ee)
|
|
|
|
{
|
2009-08-09 15:23:46 -07:00
|
|
|
Evas_Object *obj = ecore_evas_object_associate_get(ee);
|
2009-11-14 17:51:39 -08:00
|
|
|
Elm_Win *win;
|
2010-09-24 09:41:25 -07:00
|
|
|
|
2010-03-08 23:30:48 -08:00
|
|
|
if (!obj) return;
|
2009-08-09 15:23:46 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
2009-04-04 09:58:28 -07:00
|
|
|
if (!win) return;
|
2009-10-14 01:41:36 -07:00
|
|
|
evas_object_smart_callback_call(win->win_obj, "focus-out", NULL); // FIXME: remove me
|
|
|
|
evas_object_smart_callback_call(win->win_obj, "focus,out", NULL);
|
2010-10-04 05:48:15 -07:00
|
|
|
win->focus_highlight.cur.visible = EINA_FALSE;
|
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
|
|
|
_elm_win_focus_highlight_reconfigure_job_start(win);
|
2009-04-04 09:58:28 -07:00
|
|
|
}
|
|
|
|
|
2010-09-24 07:47:59 -07:00
|
|
|
static Eina_Bool
|
2010-10-06 13:24:19 -07:00
|
|
|
_elm_win_focus_next_hook(const Evas_Object *obj, Elm_Focus_Direction dir, Evas_Object **next)
|
2010-09-24 07:47:59 -07:00
|
|
|
{
|
|
|
|
Elm_Win *wd = elm_widget_data_get(obj);
|
2010-10-06 13:24:19 -07:00
|
|
|
const Eina_List *items;
|
2010-09-24 07:47:59 -07:00
|
|
|
void *(*list_data_get) (const Eina_List *list);
|
|
|
|
|
2010-10-21 11:58:43 -07:00
|
|
|
if (!wd)
|
2010-09-24 07:47:59 -07:00
|
|
|
return EINA_FALSE;
|
|
|
|
|
|
|
|
/* Focus chain */
|
2010-10-21 11:58:43 -07:00
|
|
|
if (wd->subobjs)
|
2010-10-06 13:24:22 -07:00
|
|
|
{
|
2010-10-21 11:58:43 -07:00
|
|
|
if (!(items = elm_widget_focus_custom_chain_get(obj)))
|
|
|
|
{
|
|
|
|
items = wd->subobjs;
|
|
|
|
if (!items)
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
list_data_get = eina_list_data_get;
|
2010-09-24 07:47:59 -07:00
|
|
|
|
2010-10-21 11:58:43 -07:00
|
|
|
elm_widget_focus_list_next_get(obj, items, list_data_get, dir, next);
|
2010-09-24 07:47:59 -07:00
|
|
|
|
2010-10-21 11:58:43 -07:00
|
|
|
if (*next)
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
*next = (Evas_Object *)obj;
|
2010-10-06 13:24:09 -07:00
|
|
|
return EINA_FALSE;
|
2010-09-24 07:47:59 -07:00
|
|
|
}
|
|
|
|
|
2010-10-21 11:58:43 -07:00
|
|
|
static void
|
|
|
|
_elm_win_on_focus_hook(void *data __UNUSED__, Evas_Object *obj)
|
|
|
|
{
|
|
|
|
if (elm_widget_focus_get(obj))
|
|
|
|
evas_object_focus_set(obj, EINA_TRUE);
|
|
|
|
else
|
|
|
|
evas_object_focus_set(obj, EINA_FALSE);
|
|
|
|
}
|
|
|
|
|
2010-09-24 07:47:59 -07:00
|
|
|
static Eina_Bool
|
2010-10-11 20:42:01 -07:00
|
|
|
_elm_win_event_cb(Evas_Object *obj, Evas_Object *src __UNUSED__, Evas_Callback_Type type, void *event_info)
|
2010-09-24 07:47:59 -07:00
|
|
|
{
|
|
|
|
if (type == EVAS_CALLBACK_KEY_DOWN)
|
|
|
|
{
|
|
|
|
Evas_Event_Key_Down *ev = event_info;
|
|
|
|
if (!strcmp(ev->keyname, "Tab"))
|
|
|
|
{
|
|
|
|
if(evas_key_modifier_is_set(ev->modifiers, "Shift"))
|
2010-10-06 13:24:16 -07:00
|
|
|
elm_widget_focus_cycle(obj, ELM_FOCUS_PREVIOUS);
|
2010-09-24 07:47:59 -07:00
|
|
|
else
|
2010-10-06 13:24:16 -07:00
|
|
|
elm_widget_focus_cycle(obj, ELM_FOCUS_NEXT);
|
2010-10-08 09:27:04 -07:00
|
|
|
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
|
2010-09-24 07:47:59 -07:00
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2008-10-24 19:11:06 -07:00
|
|
|
static void
|
|
|
|
_deferred_ecore_evas_free(void *data)
|
|
|
|
{
|
|
|
|
ecore_evas_free(data);
|
|
|
|
}
|
|
|
|
|
2010-10-21 11:58:43 -07:00
|
|
|
static void
|
|
|
|
_elm_win_obj_callback_show(void *data __UNUSED__, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
|
|
|
|
{
|
|
|
|
elm_object_focus(obj);
|
|
|
|
}
|
|
|
|
|
2008-09-29 23:58:56 -07:00
|
|
|
static void
|
2010-03-09 09:51:30 -08:00
|
|
|
_elm_win_obj_callback_del(void *data, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
|
2008-09-29 23:58:56 -07:00
|
|
|
{
|
2008-10-06 18:23:49 -07:00
|
|
|
Elm_Win *win = data;
|
2009-11-13 14:18:01 -08:00
|
|
|
Evas_Object *child;
|
2008-10-06 18:23:49 -07:00
|
|
|
|
2010-04-04 21:58:43 -07:00
|
|
|
if (win->parent)
|
|
|
|
{
|
|
|
|
evas_object_event_callback_del_full(win->parent, EVAS_CALLBACK_DEL,
|
|
|
|
_elm_win_obj_callback_parent_del, win);
|
|
|
|
win->parent = NULL;
|
|
|
|
}
|
2008-12-19 06:32:59 -08:00
|
|
|
if (win->autodel_clear) *(win->autodel_clear) = -1;
|
2008-10-22 07:11:59 -07:00
|
|
|
_elm_win_list = eina_list_remove(_elm_win_list, win->win_obj);
|
2008-10-06 18:23:49 -07:00
|
|
|
while (win->subobjs) elm_win_resize_object_del(obj, win->subobjs->data);
|
2008-10-24 19:11:06 -07:00
|
|
|
ecore_evas_callback_delete_request_set(win->ee, NULL);
|
|
|
|
ecore_evas_callback_resize_set(win->ee, NULL);
|
2008-10-06 18:23:49 -07:00
|
|
|
if (win->deferred_resize_job) ecore_job_del(win->deferred_resize_job);
|
|
|
|
if (win->deferred_child_eval_job) ecore_job_del(win->deferred_child_eval_job);
|
2010-08-21 06:52:25 -07:00
|
|
|
while (((child = evas_object_bottom_get(win->evas))) &&
|
2009-11-13 14:18:01 -08:00
|
|
|
(child != obj))
|
2009-02-14 18:53:56 -08:00
|
|
|
{
|
2009-11-13 14:18:01 -08:00
|
|
|
evas_object_del(child);
|
2009-02-14 18:53:56 -08:00
|
|
|
}
|
2010-08-21 06:52:25 -07:00
|
|
|
while (((child = evas_object_top_get(win->evas))) &&
|
2009-11-13 14:18:01 -08:00
|
|
|
(child != obj))
|
2009-02-14 18:53:56 -08:00
|
|
|
{
|
2009-11-13 14:18:01 -08:00
|
|
|
evas_object_del(child);
|
2009-02-14 18:53:56 -08:00
|
|
|
}
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
if (win->client_message_handler)
|
|
|
|
ecore_event_handler_del(win->client_message_handler);
|
2010-09-24 09:41:25 -07:00
|
|
|
#endif
|
2009-11-14 17:51:39 -08:00
|
|
|
// FIXME: Why are we flushing edje on every window destroy ??
|
2010-04-04 21:58:43 -07:00
|
|
|
// evas_image_cache_flush(win->evas);
|
|
|
|
// evas_font_cache_flush(win->evas);
|
|
|
|
// edje_file_cache_flush();
|
|
|
|
// edje_collection_cache_flush();
|
2008-12-19 06:32:59 -08:00
|
|
|
// FIXME: we are in the del handler for the object and delete the canvas
|
2010-09-08 17:35:43 -07:00
|
|
|
// that lives under it from the handler... nasty. deferring doesn't help either
|
2008-10-24 19:11:06 -07:00
|
|
|
ecore_job_add(_deferred_ecore_evas_free, win->ee);
|
|
|
|
// ecore_evas_free(win->ee);
|
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
|
|
|
|
|
|
|
_elm_win_focus_highlight_shutdown(win);
|
2010-10-04 10:34:35 -07:00
|
|
|
eina_stringshare_del(win->focus_highlight.style);
|
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
|
|
|
|
2008-10-06 18:23:49 -07:00
|
|
|
free(win);
|
2009-12-01 05:32:48 -08:00
|
|
|
|
|
|
|
if ((!_elm_win_list) &&
|
|
|
|
(elm_policy_get(ELM_POLICY_QUIT) == ELM_POLICY_QUIT_LAST_WINDOW_CLOSED))
|
|
|
|
{
|
2010-04-04 21:58:43 -07:00
|
|
|
evas_image_cache_flush(e);
|
|
|
|
evas_font_cache_flush(e);
|
|
|
|
edje_file_cache_flush();
|
|
|
|
edje_collection_cache_flush();
|
2009-12-01 05:32:48 -08:00
|
|
|
elm_exit();
|
|
|
|
}
|
2008-09-29 23:58:56 -07:00
|
|
|
}
|
2008-10-06 18:23:49 -07:00
|
|
|
|
2010-04-04 21:58:43 -07:00
|
|
|
static void
|
|
|
|
_elm_win_obj_callback_parent_del(void *data, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
|
|
|
|
{
|
|
|
|
Elm_Win *win = data;
|
|
|
|
if (obj == win->parent) win->parent = NULL;
|
|
|
|
}
|
|
|
|
|
2009-10-07 22:26:58 -07:00
|
|
|
static void
|
2010-03-09 09:51:30 -08:00
|
|
|
_elm_win_obj_intercept_show(void *data __UNUSED__, Evas_Object *obj)
|
2009-10-07 22:26:58 -07:00
|
|
|
{
|
|
|
|
// this is called to make sure all smart containers have calculated their
|
|
|
|
// sizes BEFORE we show the window to make sure it initially appears at
|
|
|
|
// our desired size (ie min size is known first)
|
2009-10-26 01:27:08 -07:00
|
|
|
evas_smart_objects_calculate(evas_object_evas_get(obj));
|
|
|
|
evas_object_show(obj);
|
2009-10-07 22:26:58 -07:00
|
|
|
}
|
|
|
|
|
2008-09-29 23:58:56 -07:00
|
|
|
static void
|
|
|
|
_elm_win_delete_request(Ecore_Evas *ee)
|
|
|
|
{
|
2009-08-09 15:23:46 -07:00
|
|
|
Evas_Object *obj = ecore_evas_object_associate_get(ee);
|
2009-11-14 17:51:39 -08:00
|
|
|
Elm_Win *win;
|
2009-11-15 08:03:52 -08:00
|
|
|
if (strcmp(elm_widget_type_get(obj), "win")) return;
|
2010-09-24 09:41:25 -07:00
|
|
|
|
2009-08-09 15:23:46 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
2008-10-24 19:11:06 -07:00
|
|
|
if (!win) return;
|
2008-12-19 06:32:59 -08:00
|
|
|
int autodel = win->autodel;
|
|
|
|
win->autodel_clear = &autodel;
|
2009-10-14 01:41:36 -07:00
|
|
|
evas_object_smart_callback_call(win->win_obj, "delete-request", NULL); // FIXME: remove me
|
|
|
|
evas_object_smart_callback_call(win->win_obj, "delete,request", NULL);
|
2008-12-19 06:32:59 -08:00
|
|
|
// FIXME: if above callback deletes - then the below will be invalid
|
2009-06-17 08:35:19 -07:00
|
|
|
if (autodel) evas_object_del(win->win_obj);
|
|
|
|
else win->autodel_clear = NULL;
|
2008-09-29 23:58:56 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2008-10-06 18:23:49 -07:00
|
|
|
_elm_win_resize_job(void *data)
|
2008-09-29 23:58:56 -07:00
|
|
|
{
|
2008-10-06 18:23:49 -07:00
|
|
|
Elm_Win *win = data;
|
2009-02-25 11:50:45 -08:00
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *obj;
|
2008-09-29 23:58:56 -07:00
|
|
|
int w, h;
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2008-09-29 23:58:56 -07:00
|
|
|
win->deferred_resize_job = NULL;
|
|
|
|
ecore_evas_geometry_get(win->ee, NULL, NULL, &w, &h);
|
2008-10-06 18:23:49 -07:00
|
|
|
evas_object_resize(win->win_obj, w, h);
|
2009-02-25 11:50:45 -08:00
|
|
|
EINA_LIST_FOREACH(win->subobjs, l, obj)
|
2008-09-29 23:58:56 -07:00
|
|
|
{
|
2009-02-25 11:50:45 -08:00
|
|
|
evas_object_move(obj, 0, 0);
|
|
|
|
evas_object_resize(obj, w, h);
|
2008-09-29 23:58:56 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2008-09-29 23:58:56 -07:00
|
|
|
static void
|
2008-11-18 22:23:08 -08:00
|
|
|
_elm_win_xwindow_get(Elm_Win *win)
|
2008-09-29 23:58:56 -07:00
|
|
|
{
|
2008-10-06 18:23:49 -07:00
|
|
|
win->xwin = 0;
|
|
|
|
switch (_elm_config->engine)
|
|
|
|
{
|
|
|
|
case ELM_SOFTWARE_X11:
|
|
|
|
if (win->ee) win->xwin = ecore_evas_software_x11_window_get(win->ee);
|
|
|
|
break;
|
|
|
|
case ELM_SOFTWARE_FB:
|
2010-01-19 07:34:24 -08:00
|
|
|
case ELM_SOFTWARE_DIRECTFB:
|
2008-12-18 16:34:56 -08:00
|
|
|
case ELM_SOFTWARE_16_WINCE:
|
2010-01-13 00:17:15 -08:00
|
|
|
case ELM_SOFTWARE_SDL:
|
|
|
|
case ELM_SOFTWARE_16_SDL:
|
2010-02-04 10:34:44 -08:00
|
|
|
case ELM_OPENGL_SDL:
|
2008-10-06 18:23:49 -07:00
|
|
|
break;
|
|
|
|
case ELM_SOFTWARE_16_X11:
|
|
|
|
if (win->ee) win->xwin = ecore_evas_software_x11_16_window_get(win->ee);
|
|
|
|
break;
|
2010-09-28 15:43:48 -07:00
|
|
|
case ELM_SOFTWARE_8_X11:
|
|
|
|
if (win->ee) win->xwin = ecore_evas_software_x11_8_window_get(win->ee);
|
|
|
|
break;
|
2008-10-06 18:23:49 -07:00
|
|
|
case ELM_XRENDER_X11:
|
|
|
|
if (win->ee) win->xwin = ecore_evas_xrender_x11_window_get(win->ee);
|
|
|
|
break;
|
|
|
|
case ELM_OPENGL_X11:
|
|
|
|
if (win->ee) win->xwin = ecore_evas_gl_x11_window_get(win->ee);
|
|
|
|
break;
|
2009-01-22 13:43:07 -08:00
|
|
|
case ELM_SOFTWARE_WIN32:
|
2009-04-03 14:52:01 -07:00
|
|
|
if (win->ee) win->xwin = (long)ecore_evas_win32_window_get(win->ee);
|
2009-01-22 13:43:07 -08:00
|
|
|
break;
|
2008-10-06 18:23:49 -07:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2008-11-18 22:23:08 -08:00
|
|
|
}
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2008-11-18 22:23:08 -08:00
|
|
|
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2008-11-18 22:23:08 -08:00
|
|
|
static void
|
|
|
|
_elm_win_xwin_update(Elm_Win *win)
|
|
|
|
{
|
|
|
|
_elm_win_xwindow_get(win);
|
2008-10-06 18:23:49 -07:00
|
|
|
if (win->parent)
|
|
|
|
{
|
|
|
|
Elm_Win *win2;
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2008-12-30 08:19:46 -08:00
|
|
|
win2 = elm_widget_data_get(win->parent);
|
2008-10-06 18:23:49 -07:00
|
|
|
if (win2)
|
|
|
|
{
|
|
|
|
if (win->xwin)
|
|
|
|
ecore_x_icccm_transient_for_set(win->xwin, win2->xwin);
|
|
|
|
}
|
|
|
|
}
|
2009-04-14 19:08:07 -07:00
|
|
|
|
|
|
|
if (!win->xwin) return; /* nothing more to do */
|
|
|
|
|
|
|
|
switch (win->type)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
2009-04-14 19:08:07 -07:00
|
|
|
case ELM_WIN_BASIC:
|
|
|
|
ecore_x_netwm_window_type_set(win->xwin, ECORE_X_WINDOW_TYPE_NORMAL);
|
|
|
|
break;
|
|
|
|
case ELM_WIN_DIALOG_BASIC:
|
|
|
|
ecore_x_netwm_window_type_set(win->xwin, ECORE_X_WINDOW_TYPE_DIALOG);
|
|
|
|
break;
|
|
|
|
case ELM_WIN_DESKTOP:
|
|
|
|
ecore_x_netwm_window_type_set(win->xwin, ECORE_X_WINDOW_TYPE_DESKTOP);
|
|
|
|
break;
|
|
|
|
case ELM_WIN_DOCK:
|
|
|
|
ecore_x_netwm_window_type_set(win->xwin, ECORE_X_WINDOW_TYPE_DOCK);
|
|
|
|
break;
|
|
|
|
case ELM_WIN_TOOLBAR:
|
|
|
|
ecore_x_netwm_window_type_set(win->xwin, ECORE_X_WINDOW_TYPE_TOOLBAR);
|
|
|
|
break;
|
|
|
|
case ELM_WIN_MENU:
|
|
|
|
ecore_x_netwm_window_type_set(win->xwin, ECORE_X_WINDOW_TYPE_MENU);
|
|
|
|
break;
|
|
|
|
case ELM_WIN_UTILITY:
|
|
|
|
ecore_x_netwm_window_type_set(win->xwin, ECORE_X_WINDOW_TYPE_UTILITY);
|
|
|
|
break;
|
|
|
|
case ELM_WIN_SPLASH:
|
|
|
|
ecore_x_netwm_window_type_set(win->xwin, ECORE_X_WINDOW_TYPE_SPLASH);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
2009-04-14 19:08:07 -07:00
|
|
|
ecore_x_e_virtual_keyboard_state_set
|
2008-11-18 02:11:57 -08:00
|
|
|
(win->xwin, (Ecore_X_Virtual_Keyboard_State)win->kbdmode);
|
2008-09-29 23:58:56 -07:00
|
|
|
}
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2008-09-29 23:58:56 -07:00
|
|
|
|
2008-10-06 18:23:49 -07:00
|
|
|
static void
|
|
|
|
_elm_win_eval_subobjs(Evas_Object *obj)
|
|
|
|
{
|
2009-02-25 11:50:45 -08:00
|
|
|
const Eina_List *l;
|
|
|
|
const Evas_Object *child;
|
2010-09-24 09:41:25 -07:00
|
|
|
|
2008-12-30 08:19:46 -08:00
|
|
|
Elm_Win *win = elm_widget_data_get(obj);
|
2008-10-06 18:23:49 -07:00
|
|
|
Evas_Coord w, h, minw = -1, minh = -1, maxw = -1, maxh = -1;
|
|
|
|
int xx = 1, xy = 1;
|
|
|
|
double wx, wy;
|
|
|
|
|
2009-02-25 11:50:45 -08:00
|
|
|
EINA_LIST_FOREACH(win->subobjs, l, child)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
2009-02-25 11:50:45 -08:00
|
|
|
evas_object_size_hint_weight_get(child, &wx, &wy);
|
2008-10-06 18:23:49 -07:00
|
|
|
if (wx == 0.0) xx = 0;
|
|
|
|
if (wy == 0.0) xy = 0;
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2009-02-25 11:50:45 -08:00
|
|
|
evas_object_size_hint_min_get(child, &w, &h);
|
2008-10-06 18:23:49 -07:00
|
|
|
if (w < 1) w = -1;
|
|
|
|
if (h < 1) h = -1;
|
|
|
|
if (w > minw) minw = w;
|
|
|
|
if (h > minh) minh = h;
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2009-02-25 11:50:45 -08:00
|
|
|
evas_object_size_hint_max_get(child, &w, &h);
|
2008-10-06 18:23:49 -07:00
|
|
|
if (w < 1) w = -1;
|
|
|
|
if (h < 1) h = -1;
|
|
|
|
if (maxw == -1) maxw = w;
|
2009-03-12 22:50:38 -07:00
|
|
|
else if ((w > 0) && (w < maxw)) maxw = w;
|
2008-10-06 18:23:49 -07:00
|
|
|
if (maxh == -1) maxh = h;
|
2009-03-12 22:50:38 -07:00
|
|
|
else if ((h > 0) && (h < maxh)) maxh = h;
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
if (!xx) maxw = minw;
|
|
|
|
else maxw = 32767;
|
|
|
|
if (!xy) maxh = minh;
|
|
|
|
else maxh = 32767;
|
|
|
|
evas_object_size_hint_min_set(obj, minw, minh);
|
|
|
|
evas_object_size_hint_max_set(obj, maxw, maxh);
|
|
|
|
evas_object_geometry_get(obj, NULL, NULL, &w, &h);
|
|
|
|
if (w < minw) w = minw;
|
|
|
|
if (h < minh) h = minh;
|
|
|
|
if ((maxw >= 0) && (w > maxw)) w = maxw;
|
|
|
|
if ((maxh >= 0) && (h > maxh)) h = maxh;
|
|
|
|
evas_object_resize(obj, w, h);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-03-09 09:51:30 -08:00
|
|
|
_elm_win_subobj_callback_del(void *data, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
2010-09-17 15:10:04 -07:00
|
|
|
Elm_Win *win = elm_widget_data_get(data);
|
|
|
|
win->subobjs = eina_list_remove(win->subobjs, obj);
|
|
|
|
_elm_win_eval_subobjs(win->win_obj);
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-03-09 09:51:30 -08:00
|
|
|
_elm_win_subobj_callback_changed_size_hints(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
|
|
|
_elm_win_eval_subobjs(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
_elm_win_shutdown(void)
|
|
|
|
{
|
2010-02-08 19:04:18 -08:00
|
|
|
while (_elm_win_list)
|
2009-11-14 17:51:39 -08:00
|
|
|
evas_object_del(_elm_win_list->data);
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
2008-11-14 22:09:04 -08:00
|
|
|
void
|
|
|
|
_elm_win_rescale(void)
|
|
|
|
{
|
2009-02-25 11:50:45 -08:00
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *obj;
|
2009-11-14 17:51:39 -08:00
|
|
|
|
2009-02-25 11:50:45 -08:00
|
|
|
EINA_LIST_FOREACH(_elm_win_list, l, obj)
|
|
|
|
elm_widget_theme(obj);
|
2008-11-14 22:09:04 -08:00
|
|
|
}
|
|
|
|
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2010-06-25 02:58:14 -07:00
|
|
|
static Eina_Bool
|
2010-04-12 01:27:10 -07:00
|
|
|
_elm_win_client_message(void *data, int type __UNUSED__, void *event)
|
|
|
|
{
|
|
|
|
Elm_Win *win = data;
|
|
|
|
Ecore_X_Event_Client_Message *e = event;
|
|
|
|
|
2010-06-25 02:58:14 -07:00
|
|
|
if (e->format != 32) return ECORE_CALLBACK_PASS_ON;
|
2010-04-12 01:27:10 -07:00
|
|
|
if (e->message_type == ECORE_X_ATOM_E_COMP_FLUSH)
|
|
|
|
{
|
2010-10-19 11:24:27 -07:00
|
|
|
if ((unsigned)e->data.l[0] == win->xwin)
|
2010-04-12 01:27:10 -07:00
|
|
|
{
|
2010-04-21 00:46:03 -07:00
|
|
|
Evas *evas = evas_object_evas_get(win->win_obj);
|
|
|
|
if (evas)
|
2010-04-12 01:27:10 -07:00
|
|
|
{
|
|
|
|
edje_file_cache_flush();
|
|
|
|
edje_collection_cache_flush();
|
2010-04-21 00:46:03 -07:00
|
|
|
evas_image_cache_flush(evas);
|
|
|
|
evas_font_cache_flush(evas);
|
2010-04-12 01:27:10 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (e->message_type == ECORE_X_ATOM_E_COMP_DUMP)
|
|
|
|
{
|
2010-10-19 11:24:27 -07:00
|
|
|
if ((unsigned)e->data.l[0] == win->xwin)
|
2010-04-12 01:27:10 -07:00
|
|
|
{
|
2010-04-21 00:46:03 -07:00
|
|
|
Evas *evas = evas_object_evas_get(win->win_obj);
|
|
|
|
if (evas)
|
2010-04-12 01:27:10 -07:00
|
|
|
{
|
|
|
|
edje_file_cache_flush();
|
|
|
|
edje_collection_cache_flush();
|
2010-04-21 00:46:03 -07:00
|
|
|
evas_image_cache_flush(evas);
|
|
|
|
evas_font_cache_flush(evas);
|
|
|
|
evas_render_dump(evas);
|
2010-04-12 01:27:10 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2010-06-25 02:58:14 -07:00
|
|
|
return ECORE_CALLBACK_PASS_ON;
|
2010-04-12 01:27:10 -07:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
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
|
|
|
static void
|
|
|
|
_elm_win_focus_target_move(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
|
|
|
|
{
|
|
|
|
Elm_Win *win = data;
|
|
|
|
|
2010-10-13 11:58:29 -07:00
|
|
|
win->focus_highlight.geometry_changed = EINA_TRUE;
|
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
|
|
|
_elm_win_focus_highlight_reconfigure_job_start(win);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_win_focus_target_resize(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
|
|
|
|
{
|
|
|
|
Elm_Win *win = data;
|
|
|
|
|
2010-10-13 11:58:29 -07:00
|
|
|
win->focus_highlight.geometry_changed = EINA_TRUE;
|
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
|
|
|
_elm_win_focus_highlight_reconfigure_job_start(win);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_win_focus_target_del(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
|
|
|
|
{
|
|
|
|
Elm_Win *win = data;
|
|
|
|
|
2010-10-04 05:48:15 -07:00
|
|
|
win->focus_highlight.cur.target = NULL;
|
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
|
|
|
|
|
|
|
_elm_win_focus_highlight_reconfigure_job_start(win);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_win_focus_target_callbacks_add(Elm_Win *win)
|
|
|
|
{
|
2010-10-04 05:48:15 -07:00
|
|
|
Evas_Object *obj = win->focus_highlight.cur.target;
|
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
|
|
|
|
|
|
|
evas_object_event_callback_add(obj, EVAS_CALLBACK_MOVE,
|
|
|
|
_elm_win_focus_target_move, win);
|
|
|
|
evas_object_event_callback_add(obj, EVAS_CALLBACK_RESIZE,
|
|
|
|
_elm_win_focus_target_resize, win);
|
|
|
|
evas_object_event_callback_add(obj, EVAS_CALLBACK_DEL,
|
|
|
|
_elm_win_focus_target_del, win);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_win_focus_target_callbacks_del(Elm_Win *win)
|
|
|
|
{
|
2010-10-04 05:48:15 -07:00
|
|
|
Evas_Object *obj = win->focus_highlight.cur.target;
|
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
|
|
|
|
|
|
|
evas_object_event_callback_del_full(obj, EVAS_CALLBACK_MOVE,
|
|
|
|
_elm_win_focus_target_move, win);
|
|
|
|
evas_object_event_callback_del_full(obj, EVAS_CALLBACK_RESIZE,
|
|
|
|
_elm_win_focus_target_resize, win);
|
|
|
|
evas_object_event_callback_del_full(obj, EVAS_CALLBACK_DEL,
|
|
|
|
_elm_win_focus_target_del, win);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Evas_Object *
|
|
|
|
_elm_win_focus_target_get(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Evas_Object *o = obj;
|
|
|
|
|
|
|
|
do
|
|
|
|
{
|
|
|
|
if (elm_widget_is(o))
|
|
|
|
{
|
|
|
|
if (!elm_widget_highlight_ignore_get(o))
|
|
|
|
break;
|
|
|
|
o = elm_widget_parent_get(o);
|
|
|
|
if (!o)
|
|
|
|
o = evas_object_smart_parent_get(o);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
o = elm_widget_parent_widget_get(o);
|
|
|
|
if (!o)
|
|
|
|
o = evas_object_smart_parent_get(o);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
while (o);
|
|
|
|
|
|
|
|
return o;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-10-11 20:42:01 -07:00
|
|
|
_elm_win_object_focus_in(void *data, Evas *e __UNUSED__, void *event_info)
|
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
|
|
|
{
|
2010-09-22 15:33:57 -07:00
|
|
|
Evas_Object *obj = event_info, *target;
|
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
|
|
|
Elm_Win *win = data;
|
|
|
|
|
2010-10-04 05:48:15 -07:00
|
|
|
if (win->focus_highlight.cur.target == obj)
|
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
|
|
|
return;
|
|
|
|
|
2010-09-22 15:33:57 -07:00
|
|
|
target = _elm_win_focus_target_get(obj);
|
2010-10-04 05:48:15 -07:00
|
|
|
win->focus_highlight.cur.target = target;
|
2010-09-22 15:33:57 -07:00
|
|
|
if (elm_widget_highlight_in_theme_get(target))
|
2010-10-04 05:48:15 -07:00
|
|
|
win->focus_highlight.cur.handled = EINA_TRUE;
|
2010-09-22 15:33:57 -07:00
|
|
|
else
|
|
|
|
_elm_win_focus_target_callbacks_add(win);
|
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
|
|
|
|
|
|
|
_elm_win_focus_highlight_reconfigure_job_start(win);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-10-11 20:42:01 -07:00
|
|
|
_elm_win_object_focus_out(void *data, Evas *e __UNUSED__, void *event_info __UNUSED__)
|
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
|
|
|
{
|
|
|
|
Elm_Win *win = data;
|
|
|
|
|
2010-10-04 05:48:15 -07:00
|
|
|
if (!win->focus_highlight.cur.target)
|
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
|
|
|
return;
|
|
|
|
|
2010-10-04 05:48:15 -07:00
|
|
|
if (!win->focus_highlight.cur.handled)
|
2010-09-22 15:33:57 -07:00
|
|
|
_elm_win_focus_target_callbacks_del(win);
|
2010-10-04 05:48:15 -07:00
|
|
|
win->focus_highlight.cur.target = NULL;
|
|
|
|
win->focus_highlight.cur.handled = EINA_FALSE;
|
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
|
|
|
|
|
|
|
_elm_win_focus_highlight_reconfigure_job_start(win);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_win_focus_highlight_hide(void *data __UNUSED__, Evas_Object *obj, const char *emission __UNUSED__, const char *source __UNUSED__)
|
|
|
|
{
|
|
|
|
evas_object_hide(obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_win_focus_highlight_init(Elm_Win *win)
|
|
|
|
{
|
|
|
|
evas_event_callback_add(win->evas, EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_IN,
|
|
|
|
_elm_win_object_focus_in, win);
|
|
|
|
evas_event_callback_add(win->evas,
|
|
|
|
EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_OUT,
|
|
|
|
_elm_win_object_focus_out, win);
|
|
|
|
|
2010-10-04 05:48:15 -07:00
|
|
|
win->focus_highlight.cur.target = evas_focus_get(win->evas);
|
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
|
|
|
|
|
|
|
win->focus_highlight.top = edje_object_add(win->evas);
|
|
|
|
win->focus_highlight.changed_theme = EINA_TRUE;
|
|
|
|
edje_object_signal_callback_add(win->focus_highlight.top,
|
|
|
|
"elm,action,focus,hide,end", "",
|
|
|
|
_elm_win_focus_highlight_hide, NULL);
|
2010-09-28 09:54:11 -07:00
|
|
|
edje_object_signal_callback_add(win->focus_highlight.top,
|
|
|
|
"elm,action,focus,anim,end", "",
|
|
|
|
_elm_win_focus_highlight_anim_end, win);
|
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
|
|
|
_elm_win_focus_highlight_reconfigure_job_start(win);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_win_focus_highlight_shutdown(Elm_Win *win)
|
|
|
|
{
|
2010-10-06 09:42:46 -07:00
|
|
|
_elm_win_focus_highlight_reconfigure_job_stop(win);
|
2010-10-04 05:48:15 -07:00
|
|
|
if (win->focus_highlight.cur.target)
|
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
|
|
|
{
|
|
|
|
_elm_win_focus_target_callbacks_del(win);
|
2010-10-04 05:48:15 -07:00
|
|
|
win->focus_highlight.cur.target = NULL;
|
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
|
|
|
}
|
|
|
|
if (win->focus_highlight.top)
|
|
|
|
{
|
|
|
|
evas_object_del(win->focus_highlight.top);
|
|
|
|
win->focus_highlight.top = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
evas_event_callback_del_full(win->evas,
|
|
|
|
EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_IN,
|
|
|
|
_elm_win_object_focus_in, win);
|
|
|
|
evas_event_callback_del_full(win->evas,
|
|
|
|
EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_OUT,
|
|
|
|
_elm_win_object_focus_out, win);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_win_focus_highlight_visible_set(Elm_Win *win, Eina_Bool visible)
|
|
|
|
{
|
2010-09-28 09:54:11 -07:00
|
|
|
Evas_Object *top;
|
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
|
|
|
|
|
|
|
top = win->focus_highlight.top;
|
|
|
|
if (visible)
|
|
|
|
{
|
|
|
|
if (top)
|
|
|
|
{
|
|
|
|
evas_object_show(top);
|
|
|
|
edje_object_signal_emit(top, "elm,action,focus,show", "elm");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (top)
|
|
|
|
edje_object_signal_emit(top, "elm,action,focus,hide", "elm");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_win_focus_highlight_reconfigure_job(void *data)
|
|
|
|
{
|
|
|
|
_elm_win_focus_highlight_reconfigure((Elm_Win *)data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_win_focus_highlight_reconfigure_job_start(Elm_Win *win)
|
|
|
|
{
|
|
|
|
if (win->focus_highlight.reconf_job)
|
|
|
|
ecore_job_del(win->focus_highlight.reconf_job);
|
|
|
|
win->focus_highlight.reconf_job = ecore_job_add(
|
|
|
|
_elm_win_focus_highlight_reconfigure_job, win);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_win_focus_highlight_reconfigure_job_stop(Elm_Win *win)
|
|
|
|
{
|
|
|
|
if (win->focus_highlight.reconf_job)
|
|
|
|
ecore_job_del(win->focus_highlight.reconf_job);
|
|
|
|
win->focus_highlight.reconf_job = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-09-28 09:54:11 -07:00
|
|
|
_elm_win_focus_highlight_simple_setup(Elm_Win *win, Evas_Object *obj)
|
|
|
|
{
|
2010-10-04 05:48:15 -07:00
|
|
|
Evas_Object *clip, *target = win->focus_highlight.cur.target;
|
2010-09-28 09:54:11 -07:00
|
|
|
Evas_Coord x, y, w, h;
|
|
|
|
|
|
|
|
clip = evas_object_clip_get(target);
|
|
|
|
evas_object_geometry_get(target, &x, &y, &w, &h);
|
|
|
|
|
|
|
|
evas_object_move(obj, x, y);
|
|
|
|
evas_object_resize(obj, w, h);
|
|
|
|
evas_object_clip_set(obj, clip);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_win_focus_highlight_anim_setup(Elm_Win *win, Evas_Object *obj)
|
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
|
|
|
{
|
|
|
|
Evas_Coord tx, ty, tw, th;
|
2010-09-28 09:54:11 -07:00
|
|
|
Evas_Coord w, h, px, py, pw, ph;
|
|
|
|
Edje_Message_Int_Set *m;
|
2010-10-04 05:48:15 -07:00
|
|
|
Evas_Object *previous = win->focus_highlight.prev.target;
|
|
|
|
Evas_Object *target = win->focus_highlight.cur.target;
|
2010-09-28 09:54:11 -07:00
|
|
|
|
|
|
|
evas_object_geometry_get(win->win_obj, NULL, NULL, &w, &h);
|
|
|
|
evas_object_geometry_get(target, &tx, &ty, &tw, &th);
|
|
|
|
evas_object_geometry_get(previous, &px, &py, &pw, &ph);
|
|
|
|
evas_object_move(obj, 0, 0);
|
|
|
|
evas_object_resize(obj, tw, th);
|
|
|
|
evas_object_clip_unset(obj);
|
|
|
|
|
|
|
|
m = alloca(sizeof(*m) + (sizeof(int) * 8));
|
|
|
|
m->count = 8;
|
|
|
|
m->val[0] = px;
|
|
|
|
m->val[1] = py;
|
|
|
|
m->val[2] = pw;
|
|
|
|
m->val[3] = ph;
|
|
|
|
m->val[4] = tx;
|
|
|
|
m->val[5] = ty;
|
|
|
|
m->val[6] = tw;
|
|
|
|
m->val[7] = th;
|
|
|
|
edje_object_message_send(obj, EDJE_MESSAGE_INT_SET, 1, m);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-10-11 20:42:01 -07:00
|
|
|
_elm_win_focus_highlight_anim_end(void *data, Evas_Object *obj, const char *emission __UNUSED__, const char *source __UNUSED__)
|
2010-09-28 09:54:11 -07:00
|
|
|
{
|
|
|
|
Elm_Win *win = data;
|
|
|
|
_elm_win_focus_highlight_simple_setup(win, obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_win_focus_highlight_reconfigure(Elm_Win *win)
|
|
|
|
{
|
2010-10-04 05:48:15 -07:00
|
|
|
Evas_Object *target = win->focus_highlight.cur.target;
|
|
|
|
Evas_Object *previous = win->focus_highlight.prev.target;
|
2010-09-28 09:54:11 -07:00
|
|
|
Evas_Object *top = win->focus_highlight.top;
|
2010-10-04 05:48:15 -07:00
|
|
|
Eina_Bool visible_changed;
|
2010-09-22 15:33:57 -07:00
|
|
|
Eina_Bool common_visible;
|
|
|
|
const char *sig = NULL;
|
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
|
|
|
|
|
|
|
_elm_win_focus_highlight_reconfigure_job_stop(win);
|
|
|
|
|
2010-10-04 05:48:15 -07:00
|
|
|
visible_changed = (win->focus_highlight.cur.visible !=
|
|
|
|
win->focus_highlight.prev.visible);
|
|
|
|
|
2010-10-22 14:41:22 -07:00
|
|
|
if ((target == previous) && (!visible_changed) &&
|
|
|
|
(!win->focus_highlight.geometry_changed))
|
2010-10-04 05:48:15 -07:00
|
|
|
return;
|
|
|
|
|
2010-10-22 14:41:22 -07:00
|
|
|
if ((previous) && (win->focus_highlight.prev.handled))
|
2010-09-22 15:33:57 -07:00
|
|
|
elm_widget_signal_emit(previous, "elm,action,focus_highlight,hide", "elm");
|
|
|
|
|
2010-09-28 09:54:11 -07:00
|
|
|
if (!target)
|
|
|
|
common_visible = EINA_FALSE;
|
2010-10-04 05:48:15 -07:00
|
|
|
else if (win->focus_highlight.cur.handled)
|
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
|
|
|
{
|
2010-09-22 15:33:57 -07:00
|
|
|
common_visible = EINA_FALSE;
|
2010-10-04 05:48:15 -07:00
|
|
|
if (win->focus_highlight.cur.visible)
|
2010-09-22 15:33:57 -07:00
|
|
|
sig = "elm,action,focus_highlight,show";
|
|
|
|
else
|
|
|
|
sig = "elm,action,focus_highlight,hide";
|
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
|
|
|
}
|
2010-09-22 15:33:57 -07:00
|
|
|
else
|
2010-10-04 05:48:15 -07:00
|
|
|
common_visible = win->focus_highlight.cur.visible;
|
2010-09-22 15:33:57 -07:00
|
|
|
|
|
|
|
_elm_win_focus_highlight_visible_set(win, common_visible);
|
|
|
|
if (sig)
|
|
|
|
elm_widget_signal_emit(target, sig, "elm");
|
|
|
|
|
2010-10-22 14:41:22 -07:00
|
|
|
if ((!target) || (!common_visible) || (win->focus_highlight.cur.handled))
|
2010-09-22 15:33:57 -07:00
|
|
|
goto the_end;
|
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
|
|
|
|
|
|
|
if (win->focus_highlight.changed_theme)
|
|
|
|
{
|
2010-09-28 09:54:11 -07:00
|
|
|
const char *str;
|
2010-10-04 10:34:35 -07:00
|
|
|
if (win->focus_highlight.style)
|
|
|
|
str = win->focus_highlight.style;
|
|
|
|
else
|
|
|
|
str = "default";
|
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
|
|
|
_elm_theme_object_set(win->win_obj, top, "focus_highlight", "top",
|
2010-10-04 10:34:35 -07:00
|
|
|
str);
|
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
|
|
|
win->focus_highlight.changed_theme = EINA_FALSE;
|
|
|
|
|
2010-10-04 09:55:32 -07:00
|
|
|
if (_elm_config->focus_highlight_animate)
|
|
|
|
{
|
|
|
|
str = edje_object_data_get(win->focus_highlight.top, "animate");
|
2010-10-22 14:41:22 -07:00
|
|
|
win->focus_highlight.top_animate = ((str) && (!strcmp(str, "on")));
|
2010-10-04 09:55:32 -07:00
|
|
|
}
|
2010-09-28 09:54:11 -07:00
|
|
|
}
|
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
|
|
|
|
2010-10-22 14:41:22 -07:00
|
|
|
if ((win->focus_highlight.top_animate) && (previous) &&
|
|
|
|
(!win->focus_highlight.prev.handled))
|
2010-09-28 09:54:11 -07:00
|
|
|
_elm_win_focus_highlight_anim_setup(win, top);
|
|
|
|
else
|
|
|
|
_elm_win_focus_highlight_simple_setup(win, top);
|
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
|
|
|
evas_object_raise(top);
|
|
|
|
|
2010-09-22 15:33:57 -07:00
|
|
|
the_end:
|
2010-10-13 11:58:29 -07:00
|
|
|
win->focus_highlight.geometry_changed = EINA_FALSE;
|
2010-10-04 05:48:15 -07:00
|
|
|
win->focus_highlight.prev = win->focus_highlight.cur;
|
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
|
|
|
}
|
|
|
|
|
2010-10-20 05:38:30 -07:00
|
|
|
#ifdef ELM_DEBUG
|
|
|
|
static void
|
|
|
|
_debug_key_down(void *data __UNUSED__, Evas *e __UNUSED__, Evas_Object *obj, void *event_info)
|
|
|
|
{
|
|
|
|
Evas_Event_Key_Down *ev = event_info;
|
|
|
|
|
|
|
|
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
2010-10-22 14:41:22 -07:00
|
|
|
if ((strcmp(ev->keyname, "F12")) ||
|
2010-10-20 05:38:30 -07:00
|
|
|
(!evas_key_modifier_is_set(ev->modifiers, "Control")))
|
|
|
|
return;
|
|
|
|
|
|
|
|
printf("Tree graph generated.\n");
|
|
|
|
elm_object_tree_dot_dump(obj, "./dump.dot");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Adds a window object. If this is the first window created, pass NULL as
|
|
|
|
* @p parent.
|
|
|
|
*
|
|
|
|
* @param parent Parent object to add the window to, or NULL
|
|
|
|
* @param name The name of the window
|
|
|
|
* @param type The window type, one of the following:
|
|
|
|
* ELM_WIN_BASIC
|
|
|
|
* ELM_WIN_DIALOG_BASIC
|
|
|
|
* ELM_WIN_DESKTOP
|
|
|
|
* ELM_WIN_DOCK
|
|
|
|
* ELM_WIN_TOOLBAR
|
|
|
|
* ELM_WIN_MENU
|
|
|
|
* ELM_WIN_UTILITY
|
|
|
|
* ELM_WIN_SPLASH
|
|
|
|
*
|
|
|
|
* @return The created object, or NULL on failure
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2008-10-06 18:23:49 -07:00
|
|
|
EAPI Evas_Object *
|
|
|
|
elm_win_add(Evas_Object *parent, const char *name, Elm_Win_Type type)
|
2008-09-29 23:58:56 -07:00
|
|
|
{
|
|
|
|
Elm_Win *win;
|
2009-02-25 11:50:45 -08:00
|
|
|
const Eina_List *l;
|
|
|
|
const char *fontpath;
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2008-09-29 23:58:56 -07:00
|
|
|
win = ELM_NEW(Elm_Win);
|
|
|
|
switch (_elm_config->engine)
|
|
|
|
{
|
|
|
|
case ELM_SOFTWARE_X11:
|
|
|
|
win->ee = ecore_evas_software_x11_new(NULL, 0, 0, 0, 1, 1);
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
win->client_message_handler = ecore_event_handler_add
|
|
|
|
(ECORE_X_EVENT_CLIENT_MESSAGE, _elm_win_client_message, win);
|
2010-09-24 09:41:25 -07:00
|
|
|
#endif
|
2008-09-29 23:58:56 -07:00
|
|
|
break;
|
|
|
|
case ELM_SOFTWARE_FB:
|
|
|
|
win->ee = ecore_evas_fb_new(NULL, 0, 1, 1);
|
|
|
|
break;
|
2010-01-19 07:34:24 -08:00
|
|
|
case ELM_SOFTWARE_DIRECTFB:
|
|
|
|
win->ee = ecore_evas_directfb_new(NULL, 1, 0, 0, 1, 1);
|
|
|
|
break;
|
2008-09-29 23:58:56 -07:00
|
|
|
case ELM_SOFTWARE_16_X11:
|
|
|
|
win->ee = ecore_evas_software_x11_16_new(NULL, 0, 0, 0, 1, 1);
|
2010-02-16 18:15:52 -08:00
|
|
|
if (!win->ee)
|
|
|
|
{
|
|
|
|
CRITICAL("Software-16 engine create failed. Try software.");
|
|
|
|
win->ee = ecore_evas_software_x11_new(NULL, 0, 0, 0, 1, 1);
|
|
|
|
}
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
win->client_message_handler = ecore_event_handler_add
|
|
|
|
(ECORE_X_EVENT_CLIENT_MESSAGE, _elm_win_client_message, win);
|
2010-09-28 15:43:48 -07:00
|
|
|
#endif
|
|
|
|
break;
|
|
|
|
case ELM_SOFTWARE_8_X11:
|
|
|
|
win->ee = ecore_evas_software_x11_8_new(NULL, 0, 0, 0, 1, 1);
|
|
|
|
if (!win->ee)
|
|
|
|
{
|
|
|
|
CRITICAL("Software-8 engine create failed. Try software.");
|
|
|
|
win->ee = ecore_evas_software_x11_new(NULL, 0, 0, 0, 1, 1);
|
|
|
|
}
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
win->client_message_handler = ecore_event_handler_add
|
|
|
|
(ECORE_X_EVENT_CLIENT_MESSAGE, _elm_win_client_message, win);
|
2010-09-24 09:41:25 -07:00
|
|
|
#endif
|
2008-09-29 23:58:56 -07:00
|
|
|
break;
|
|
|
|
case ELM_XRENDER_X11:
|
|
|
|
win->ee = ecore_evas_xrender_x11_new(NULL, 0, 0, 0, 1, 1);
|
2010-02-16 18:15:52 -08:00
|
|
|
if (!win->ee)
|
|
|
|
{
|
|
|
|
CRITICAL("XRender engine create failed. Try software.");
|
|
|
|
win->ee = ecore_evas_software_x11_new(NULL, 0, 0, 0, 1, 1);
|
|
|
|
}
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
win->client_message_handler = ecore_event_handler_add
|
|
|
|
(ECORE_X_EVENT_CLIENT_MESSAGE, _elm_win_client_message, win);
|
2010-09-24 09:41:25 -07:00
|
|
|
#endif
|
2008-09-29 23:58:56 -07:00
|
|
|
break;
|
|
|
|
case ELM_OPENGL_X11:
|
|
|
|
win->ee = ecore_evas_gl_x11_new(NULL, 0, 0, 0, 1, 1);
|
2010-02-16 18:15:52 -08:00
|
|
|
if (!win->ee)
|
|
|
|
{
|
|
|
|
CRITICAL("OpenGL engine create failed. Try software.");
|
|
|
|
win->ee = ecore_evas_software_x11_new(NULL, 0, 0, 0, 1, 1);
|
|
|
|
}
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
win->client_message_handler = ecore_event_handler_add
|
|
|
|
(ECORE_X_EVENT_CLIENT_MESSAGE, _elm_win_client_message, win);
|
2010-09-24 09:41:25 -07:00
|
|
|
#endif
|
2008-09-29 23:58:56 -07:00
|
|
|
break;
|
2009-01-22 13:43:07 -08:00
|
|
|
case ELM_SOFTWARE_WIN32:
|
2009-06-08 00:07:21 -07:00
|
|
|
win->ee = ecore_evas_software_gdi_new(NULL, 0, 0, 1, 1);
|
2009-01-22 13:43:07 -08:00
|
|
|
break;
|
2008-12-18 16:34:56 -08:00
|
|
|
case ELM_SOFTWARE_16_WINCE:
|
2009-01-10 06:48:30 -08:00
|
|
|
win->ee = ecore_evas_software_wince_gdi_new(NULL, 0, 0, 1, 1);
|
2008-12-18 16:34:56 -08:00
|
|
|
break;
|
2010-01-13 00:17:15 -08:00
|
|
|
case ELM_SOFTWARE_SDL:
|
|
|
|
win->ee = ecore_evas_sdl_new(NULL, 0, 0, 0, 0, 0, 1);
|
2010-02-16 18:15:52 -08:00
|
|
|
if (!win->ee)
|
|
|
|
{
|
|
|
|
CRITICAL("Software SDL engine create failed. Try software.");
|
|
|
|
win->ee = ecore_evas_software_x11_new(NULL, 0, 0, 0, 1, 1);
|
|
|
|
}
|
2010-01-13 00:17:15 -08:00
|
|
|
break;
|
|
|
|
case ELM_SOFTWARE_16_SDL:
|
|
|
|
win->ee = ecore_evas_sdl16_new(NULL, 0, 0, 0, 0, 0, 1);
|
2010-02-16 18:15:52 -08:00
|
|
|
if (!win->ee)
|
|
|
|
{
|
|
|
|
CRITICAL("Sofware-16-SDL engine create failed. Try software.");
|
|
|
|
win->ee = ecore_evas_software_x11_new(NULL, 0, 0, 0, 1, 1);
|
|
|
|
}
|
2010-01-13 00:17:15 -08:00
|
|
|
break;
|
2010-02-04 10:34:44 -08:00
|
|
|
case ELM_OPENGL_SDL:
|
|
|
|
win->ee = ecore_evas_gl_sdl_new(NULL, 1, 1, 0, 0);
|
2010-02-16 18:15:52 -08:00
|
|
|
if (!win->ee)
|
|
|
|
{
|
|
|
|
CRITICAL("OpenGL SDL engine create failed. Try software.");
|
|
|
|
win->ee = ecore_evas_software_x11_new(NULL, 0, 0, 0, 1, 1);
|
|
|
|
}
|
2010-02-04 10:34:44 -08:00
|
|
|
break;
|
2008-09-29 23:58:56 -07:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!win->ee)
|
|
|
|
{
|
2009-09-11 07:21:58 -07:00
|
|
|
ERR("Cannot create window.");
|
2008-10-06 18:23:49 -07:00
|
|
|
free(win);
|
2008-09-29 23:58:56 -07:00
|
|
|
return NULL;
|
|
|
|
}
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2008-11-18 22:23:08 -08:00
|
|
|
_elm_win_xwindow_get(win);
|
2010-09-24 09:41:25 -07:00
|
|
|
#endif
|
2009-11-14 17:51:39 -08:00
|
|
|
if ((_elm_config->bgpixmap) && (!_elm_config->compositing))
|
2008-10-16 07:19:37 -07:00
|
|
|
ecore_evas_avoid_damage_set(win->ee, ECORE_EVAS_AVOID_DAMAGE_EXPOSE);
|
|
|
|
// bg pixmap done by x - has other issues like can be redrawn by x before it
|
2009-07-06 23:46:51 -07:00
|
|
|
// is filled/ready by app
|
2008-10-16 07:19:37 -07:00
|
|
|
// ecore_evas_avoid_damage_set(win->ee, ECORE_EVAS_AVOID_DAMAGE_BUILT_IN);
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2008-10-06 18:23:49 -07:00
|
|
|
win->type = type;
|
|
|
|
win->parent = parent;
|
2010-04-04 21:58:43 -07:00
|
|
|
if (win->parent)
|
|
|
|
evas_object_event_callback_add(win->parent, EVAS_CALLBACK_DEL,
|
|
|
|
_elm_win_obj_callback_parent_del, win);
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2008-09-29 23:58:56 -07:00
|
|
|
win->evas = ecore_evas_get(win->ee);
|
2008-10-06 18:23:49 -07:00
|
|
|
win->win_obj = elm_widget_add(win->evas);
|
2009-05-13 05:21:52 -07:00
|
|
|
elm_widget_type_set(win->win_obj, "win");
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_SET_WIDTYPE(widtype, "win");
|
2008-12-30 08:19:46 -08:00
|
|
|
elm_widget_data_set(win->win_obj, win);
|
2010-09-24 07:47:59 -07:00
|
|
|
elm_widget_event_hook_set(win->win_obj, _elm_win_event_cb);
|
2010-10-21 11:58:43 -07:00
|
|
|
elm_widget_on_focus_hook_set(win->win_obj, _elm_win_on_focus_hook, NULL);
|
2010-09-24 07:47:55 -07:00
|
|
|
elm_widget_can_focus_set(win->win_obj, EINA_TRUE);
|
|
|
|
elm_widget_highlight_ignore_set(win->win_obj, EINA_TRUE);
|
2010-10-06 13:24:13 -07:00
|
|
|
elm_widget_focus_next_hook_set(win->win_obj, _elm_win_focus_next_hook);
|
2008-10-06 18:23:49 -07:00
|
|
|
evas_object_color_set(win->win_obj, 0, 0, 0, 0);
|
|
|
|
evas_object_move(win->win_obj, 0, 0);
|
|
|
|
evas_object_resize(win->win_obj, 1, 1);
|
|
|
|
evas_object_layer_set(win->win_obj, 50);
|
2010-09-27 21:28:14 -07:00
|
|
|
evas_object_pass_events_set(win->win_obj, EINA_TRUE);
|
2008-10-06 18:23:49 -07:00
|
|
|
|
2010-02-08 19:04:18 -08:00
|
|
|
evas_object_intercept_show_callback_add(win->win_obj,
|
2009-10-26 01:27:08 -07:00
|
|
|
_elm_win_obj_intercept_show, win);
|
2008-12-19 06:32:59 -08:00
|
|
|
ecore_evas_object_associate(win->ee, win->win_obj,
|
2009-07-06 23:46:51 -07:00
|
|
|
ECORE_EVAS_OBJECT_ASSOCIATE_BASE |
|
|
|
|
ECORE_EVAS_OBJECT_ASSOCIATE_STACK |
|
|
|
|
ECORE_EVAS_OBJECT_ASSOCIATE_LAYER);
|
2010-10-21 11:58:43 -07:00
|
|
|
evas_object_event_callback_add(win->win_obj, EVAS_CALLBACK_SHOW,
|
|
|
|
_elm_win_obj_callback_show, win);
|
2008-12-19 06:32:59 -08:00
|
|
|
evas_object_event_callback_add(win->win_obj, EVAS_CALLBACK_DEL,
|
2009-07-06 23:46:51 -07:00
|
|
|
_elm_win_obj_callback_del, win);
|
|
|
|
|
2008-10-06 18:23:49 -07:00
|
|
|
ecore_evas_name_class_set(win->ee, name, _elm_appname);
|
2008-09-29 23:58:56 -07:00
|
|
|
ecore_evas_callback_delete_request_set(win->ee, _elm_win_delete_request);
|
|
|
|
ecore_evas_callback_resize_set(win->ee, _elm_win_resize);
|
2009-04-04 09:58:28 -07:00
|
|
|
ecore_evas_callback_focus_in_set(win->ee, _elm_win_focus_in);
|
|
|
|
ecore_evas_callback_focus_out_set(win->ee, _elm_win_focus_out);
|
2009-12-01 03:03:14 -08:00
|
|
|
ecore_evas_callback_move_set(win->ee, _elm_win_move);
|
2009-11-14 17:51:39 -08:00
|
|
|
evas_image_cache_set(win->evas, (_elm_config->image_cache * 1024));
|
|
|
|
evas_font_cache_set(win->evas, (_elm_config->font_cache * 1024));
|
2009-02-25 11:50:45 -08:00
|
|
|
EINA_LIST_FOREACH(_elm_config->font_dirs, l, fontpath)
|
|
|
|
evas_font_path_append(win->evas, fontpath);
|
2009-02-03 02:27:52 -08:00
|
|
|
if (_elm_config->font_hinting == 0)
|
|
|
|
evas_font_hinting_set(win->evas, EVAS_FONT_HINTING_NONE);
|
|
|
|
else if (_elm_config->font_hinting == 1)
|
|
|
|
evas_font_hinting_set(win->evas, EVAS_FONT_HINTING_AUTO);
|
|
|
|
else if (_elm_config->font_hinting == 2)
|
|
|
|
evas_font_hinting_set(win->evas, EVAS_FONT_HINTING_BYTECODE);
|
2008-09-29 23:58:56 -07:00
|
|
|
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2008-10-06 18:23:49 -07:00
|
|
|
_elm_win_xwin_update(win);
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2010-09-24 09:41:25 -07:00
|
|
|
|
2008-10-22 07:11:59 -07:00
|
|
|
_elm_win_list = eina_list_append(_elm_win_list, win->win_obj);
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2008-12-09 22:33:24 -08:00
|
|
|
switch (_elm_config->engine)
|
|
|
|
{
|
2008-12-18 16:34:56 -08:00
|
|
|
case ELM_SOFTWARE_16_WINCE:
|
2008-12-09 22:33:24 -08:00
|
|
|
case ELM_SOFTWARE_FB:
|
2009-07-06 23:46:51 -07:00
|
|
|
ecore_evas_fullscreen_set(win->ee, 1);
|
2008-12-09 22:33:24 -08:00
|
|
|
break;
|
|
|
|
case ELM_SOFTWARE_X11:
|
|
|
|
case ELM_SOFTWARE_16_X11:
|
2010-09-28 15:43:48 -07:00
|
|
|
case ELM_SOFTWARE_8_X11:
|
2008-12-09 22:33:24 -08:00
|
|
|
case ELM_XRENDER_X11:
|
|
|
|
case ELM_OPENGL_X11:
|
2009-01-22 13:43:07 -08:00
|
|
|
case ELM_SOFTWARE_WIN32:
|
2010-01-13 00:17:15 -08:00
|
|
|
case ELM_SOFTWARE_SDL:
|
|
|
|
case ELM_SOFTWARE_16_SDL:
|
2010-02-04 10:34:44 -08:00
|
|
|
case ELM_OPENGL_SDL:
|
2008-12-09 22:33:24 -08:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2010-09-24 09:41:25 -07:00
|
|
|
|
2010-10-04 09:55:32 -07:00
|
|
|
if (_elm_config->focus_highlight_enable)
|
|
|
|
elm_win_focus_highlight_enabled_set(win->win_obj, EINA_TRUE);
|
|
|
|
|
2010-10-20 05:38:30 -07:00
|
|
|
#ifdef ELM_DEBUG
|
|
|
|
Evas_Modifier_Mask mask = evas_key_modifier_mask_get(win->evas, "Control");
|
|
|
|
evas_object_event_callback_add(win->win_obj, EVAS_CALLBACK_KEY_DOWN,
|
|
|
|
_debug_key_down, win);
|
|
|
|
Eina_Bool ret = evas_object_key_grab(win->win_obj, "F12", mask, 0, EINA_TRUE);
|
|
|
|
printf("Key F12 exclusive for dot tree generation. (%d)\n", ret);
|
|
|
|
#endif
|
2008-10-06 18:23:49 -07:00
|
|
|
return win->win_obj;
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Add @p subobj as a resize object of window @p obj.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @param subobj The resize object to add
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2008-10-06 18:23:49 -07:00
|
|
|
EAPI void
|
|
|
|
elm_win_resize_object_add(Evas_Object *obj, Evas_Object *subobj)
|
|
|
|
{
|
2008-12-30 08:19:46 -08:00
|
|
|
Evas_Coord w, h;
|
2009-08-09 15:23:46 -07:00
|
|
|
Elm_Win *win;
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-08-09 15:23:46 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
2008-10-06 18:23:49 -07:00
|
|
|
if (!win) return;
|
2008-10-22 07:11:59 -07:00
|
|
|
win->subobjs = eina_list_append(win->subobjs, subobj);
|
2008-10-06 18:23:49 -07:00
|
|
|
elm_widget_sub_object_add(obj, subobj);
|
2010-02-08 19:04:18 -08:00
|
|
|
evas_object_event_callback_add(subobj, EVAS_CALLBACK_DEL,
|
2009-11-14 17:51:39 -08:00
|
|
|
_elm_win_subobj_callback_del, obj);
|
2010-02-08 19:04:18 -08:00
|
|
|
evas_object_event_callback_add(subobj, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
|
|
|
|
_elm_win_subobj_callback_changed_size_hints,
|
2009-11-14 17:51:39 -08:00
|
|
|
obj);
|
2008-12-30 08:19:46 -08:00
|
|
|
ecore_evas_geometry_get(win->ee, NULL, NULL, &w, &h);
|
|
|
|
evas_object_move(subobj, 0, 0);
|
|
|
|
evas_object_resize(subobj, w, h);
|
2008-10-06 18:23:49 -07:00
|
|
|
_elm_win_eval_subobjs(obj);
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Delete @p subobj as a resize object of window @p obj.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @param subobj The resize object to add
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2008-10-06 18:23:49 -07:00
|
|
|
EAPI void
|
|
|
|
elm_win_resize_object_del(Evas_Object *obj, Evas_Object *subobj)
|
|
|
|
{
|
2009-08-09 15:23:46 -07:00
|
|
|
Elm_Win *win;
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-08-09 15:23:46 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
2008-10-06 18:23:49 -07:00
|
|
|
if (!win) return;
|
2010-02-08 19:04:18 -08:00
|
|
|
evas_object_event_callback_del_full(subobj,
|
|
|
|
EVAS_CALLBACK_CHANGED_SIZE_HINTS,
|
|
|
|
_elm_win_subobj_callback_changed_size_hints,
|
2009-11-14 17:51:39 -08:00
|
|
|
obj);
|
2010-02-08 19:04:18 -08:00
|
|
|
evas_object_event_callback_del_full(subobj, EVAS_CALLBACK_DEL,
|
2009-11-14 17:51:39 -08:00
|
|
|
_elm_win_subobj_callback_del, obj);
|
2008-10-22 07:11:59 -07:00
|
|
|
win->subobjs = eina_list_remove(win->subobjs, subobj);
|
2008-10-06 18:23:49 -07:00
|
|
|
elm_widget_sub_object_del(obj, subobj);
|
|
|
|
_elm_win_eval_subobjs(obj);
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Set the title of the window
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @param title The title to set
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2008-10-06 18:23:49 -07:00
|
|
|
EAPI void
|
|
|
|
elm_win_title_set(Evas_Object *obj, const char *title)
|
|
|
|
{
|
2009-08-09 15:23:46 -07:00
|
|
|
Elm_Win *win;
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-08-09 15:23:46 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
2008-10-06 18:23:49 -07:00
|
|
|
if (!win) return;
|
|
|
|
ecore_evas_title_set(win->ee, title);
|
|
|
|
}
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Set the window's autodel state.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @param autodel If true, the window will automatically delete itself when closed
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2008-10-06 18:23:49 -07:00
|
|
|
EAPI void
|
2009-06-17 08:35:19 -07:00
|
|
|
elm_win_autodel_set(Evas_Object *obj, Eina_Bool autodel)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
2009-08-09 15:23:46 -07:00
|
|
|
Elm_Win *win;
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-08-09 15:23:46 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
2008-10-06 18:23:49 -07:00
|
|
|
if (!win) return;
|
|
|
|
win->autodel = autodel;
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Activate a window object.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2008-10-06 18:23:49 -07:00
|
|
|
EAPI void
|
|
|
|
elm_win_activate(Evas_Object *obj)
|
|
|
|
{
|
2009-08-09 15:23:46 -07:00
|
|
|
Elm_Win *win;
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-08-09 15:23:46 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
2008-10-06 18:23:49 -07:00
|
|
|
if (!win) return;
|
|
|
|
ecore_evas_activate(win->ee);
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Lower a window object.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2009-04-03 14:52:01 -07:00
|
|
|
EAPI void
|
|
|
|
elm_win_lower(Evas_Object *obj)
|
|
|
|
{
|
2009-08-09 15:23:46 -07:00
|
|
|
Elm_Win *win;
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-08-09 15:23:46 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
2009-04-03 14:52:01 -07:00
|
|
|
if (!win) return;
|
|
|
|
ecore_evas_lower(win->ee);
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Raise a window object.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2009-04-03 14:52:01 -07:00
|
|
|
EAPI void
|
|
|
|
elm_win_raise(Evas_Object *obj)
|
|
|
|
{
|
2009-08-09 15:23:46 -07:00
|
|
|
Elm_Win *win;
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-08-09 15:23:46 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
2009-04-03 14:52:01 -07:00
|
|
|
if (!win) return;
|
|
|
|
ecore_evas_raise(win->ee);
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Set the borderless state of a window.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @param borderless If true, the window is borderless
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2008-10-06 18:23:49 -07:00
|
|
|
EAPI void
|
2009-06-17 08:35:19 -07:00
|
|
|
elm_win_borderless_set(Evas_Object *obj, Eina_Bool borderless)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
2009-08-09 15:23:46 -07:00
|
|
|
Elm_Win *win;
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-08-09 15:23:46 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
2008-10-06 18:23:49 -07:00
|
|
|
if (!win) return;
|
|
|
|
ecore_evas_borderless_set(win->ee, borderless);
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2008-10-06 18:23:49 -07:00
|
|
|
_elm_win_xwin_update(win);
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Get the borderless state of a window.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @return If true, the window is borderless
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2009-10-12 02:09:55 -07:00
|
|
|
EAPI Eina_Bool
|
2010-03-23 20:06:00 -07:00
|
|
|
elm_win_borderless_get(const Evas_Object *obj)
|
2009-10-12 02:09:55 -07:00
|
|
|
{
|
|
|
|
Elm_Win *win;
|
2010-03-08 23:30:48 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
|
2009-10-12 02:09:55 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return EINA_FALSE;
|
|
|
|
return ecore_evas_borderless_get(win->ee);
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Set the shaped state of a window.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @param shaped If true, the window is shaped
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2008-10-06 18:23:49 -07:00
|
|
|
EAPI void
|
2009-06-17 08:35:19 -07:00
|
|
|
elm_win_shaped_set(Evas_Object *obj, Eina_Bool shaped)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
2009-08-09 15:23:46 -07:00
|
|
|
Elm_Win *win;
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-08-09 15:23:46 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
2008-10-06 18:23:49 -07:00
|
|
|
if (!win) return;
|
|
|
|
ecore_evas_shaped_set(win->ee, shaped);
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2008-10-06 18:23:49 -07:00
|
|
|
_elm_win_xwin_update(win);
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Get the shaped state of a window.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @return If true, the window is shaped
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2009-10-12 02:09:55 -07:00
|
|
|
EAPI Eina_Bool
|
2010-03-23 20:06:00 -07:00
|
|
|
elm_win_shaped_get(const Evas_Object *obj)
|
2009-10-12 02:09:55 -07:00
|
|
|
{
|
|
|
|
Elm_Win *win;
|
2010-03-08 23:30:48 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
|
2009-10-12 02:09:55 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return EINA_FALSE;
|
|
|
|
return ecore_evas_shaped_get(win->ee);
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Set the alpha channel state of a window.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @param alpha If true, the window has an alpha channel
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2008-10-06 18:23:49 -07:00
|
|
|
EAPI void
|
2009-06-17 08:35:19 -07:00
|
|
|
elm_win_alpha_set(Evas_Object *obj, Eina_Bool alpha)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
2009-08-09 15:23:46 -07:00
|
|
|
Elm_Win *win;
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-08-09 15:23:46 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
2008-10-06 18:23:49 -07:00
|
|
|
if (!win) return;
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2008-10-06 18:23:49 -07:00
|
|
|
if (win->xwin)
|
|
|
|
{
|
|
|
|
if (alpha)
|
|
|
|
{
|
2008-10-16 05:03:01 -07:00
|
|
|
if (!_elm_config->compositing)
|
2008-10-06 18:23:49 -07:00
|
|
|
elm_win_shaped_set(obj, alpha);
|
|
|
|
else
|
|
|
|
ecore_evas_alpha_set(win->ee, alpha);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
ecore_evas_alpha_set(win->ee, alpha);
|
|
|
|
_elm_win_xwin_update(win);
|
|
|
|
}
|
|
|
|
else
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2008-10-06 18:23:49 -07:00
|
|
|
ecore_evas_alpha_set(win->ee, alpha);
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Get the alpha channel state of a window.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @return If true, the window has an alpha channel
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2009-10-12 02:09:55 -07:00
|
|
|
EAPI Eina_Bool
|
2010-03-23 20:06:00 -07:00
|
|
|
elm_win_alpha_get(const Evas_Object *obj)
|
2009-10-12 02:09:55 -07:00
|
|
|
{
|
|
|
|
Elm_Win *win;
|
2010-03-08 23:30:48 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
|
2009-10-12 02:09:55 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return EINA_FALSE;
|
|
|
|
return ecore_evas_alpha_get(win->ee);
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Set the transparency state of a window.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @param transparent If true, the window is transparent
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2010-02-11 21:31:26 -08:00
|
|
|
EAPI void
|
|
|
|
elm_win_transparent_set(Evas_Object *obj, Eina_Bool transparent)
|
|
|
|
{
|
|
|
|
Elm_Win *win;
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2010-02-11 21:31:26 -08:00
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return;
|
2010-09-24 09:41:25 -07:00
|
|
|
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2010-02-11 21:31:26 -08:00
|
|
|
if (win->xwin)
|
|
|
|
{
|
2010-09-24 09:41:25 -07:00
|
|
|
ecore_evas_transparent_set(win->ee, transparent);
|
2010-02-11 21:31:26 -08:00
|
|
|
_elm_win_xwin_update(win);
|
|
|
|
}
|
|
|
|
else
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2010-02-11 21:31:26 -08:00
|
|
|
ecore_evas_transparent_set(win->ee, transparent);
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Get the transparency state of a window.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @return If true, the window is transparent
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2010-02-11 21:31:26 -08:00
|
|
|
EAPI Eina_Bool
|
2010-03-23 20:06:00 -07:00
|
|
|
elm_win_transparent_get(const Evas_Object *obj)
|
2010-02-11 21:31:26 -08:00
|
|
|
{
|
|
|
|
Elm_Win *win;
|
2010-03-08 23:30:48 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
|
2010-02-11 21:31:26 -08:00
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return EINA_FALSE;
|
|
|
|
|
|
|
|
return ecore_evas_transparent_get(win->ee);
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Set the override state of a window.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @param override If true, the window is overridden
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2008-10-06 18:23:49 -07:00
|
|
|
EAPI void
|
2009-06-17 08:35:19 -07:00
|
|
|
elm_win_override_set(Evas_Object *obj, Eina_Bool override)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
2009-08-09 15:23:46 -07:00
|
|
|
Elm_Win *win;
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-08-09 15:23:46 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
2008-10-06 18:23:49 -07:00
|
|
|
if (!win) return;
|
|
|
|
ecore_evas_override_set(win->ee, override);
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2008-10-06 18:23:49 -07:00
|
|
|
_elm_win_xwin_update(win);
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2008-09-29 23:58:56 -07:00
|
|
|
}
|
2008-11-18 02:11:57 -08:00
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Get the override state of a window.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @return If true, the window is overridden
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2009-10-12 02:09:55 -07:00
|
|
|
EAPI Eina_Bool
|
2010-03-23 20:06:00 -07:00
|
|
|
elm_win_override_get(const Evas_Object *obj)
|
2009-10-12 02:09:55 -07:00
|
|
|
{
|
|
|
|
Elm_Win *win;
|
2010-03-08 23:30:48 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
|
2009-10-12 02:09:55 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return EINA_FALSE;
|
|
|
|
return ecore_evas_override_get(win->ee);
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Set the fullscreen state of a window.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @param fullscreen If true, the window is fullscreen
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2009-03-12 22:50:38 -07:00
|
|
|
EAPI void
|
2009-06-17 08:35:19 -07:00
|
|
|
elm_win_fullscreen_set(Evas_Object *obj, Eina_Bool fullscreen)
|
2009-03-12 22:50:38 -07:00
|
|
|
{
|
2009-08-09 15:23:46 -07:00
|
|
|
Elm_Win *win;
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-08-09 15:23:46 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
2009-03-12 22:50:38 -07:00
|
|
|
if (!win) return;
|
2009-03-14 11:03:19 -07:00
|
|
|
switch (_elm_config->engine)
|
|
|
|
{
|
|
|
|
case ELM_SOFTWARE_16_WINCE:
|
|
|
|
case ELM_SOFTWARE_FB:
|
2009-07-06 23:46:51 -07:00
|
|
|
// these engines... can ONLY be fullscreen
|
|
|
|
break;
|
2009-03-14 11:03:19 -07:00
|
|
|
default:
|
2009-07-06 23:46:51 -07:00
|
|
|
ecore_evas_fullscreen_set(win->ee, fullscreen);
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2009-07-06 23:46:51 -07:00
|
|
|
_elm_win_xwin_update(win);
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2009-07-06 23:46:51 -07:00
|
|
|
break;
|
2009-03-14 11:03:19 -07:00
|
|
|
}
|
2009-03-12 22:50:38 -07:00
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Get the fullscreen state of a window.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @return If true, the window is fullscreen
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2009-10-12 02:09:55 -07:00
|
|
|
EAPI Eina_Bool
|
2010-03-23 20:06:00 -07:00
|
|
|
elm_win_fullscreen_get(const Evas_Object *obj)
|
2009-10-12 02:09:55 -07:00
|
|
|
{
|
|
|
|
Elm_Win *win;
|
2010-03-08 23:30:48 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
|
2009-10-12 02:09:55 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return EINA_FALSE;
|
|
|
|
switch (_elm_config->engine)
|
|
|
|
{
|
|
|
|
case ELM_SOFTWARE_16_WINCE:
|
|
|
|
case ELM_SOFTWARE_FB:
|
|
|
|
// these engines... can ONLY be fullscreen
|
|
|
|
return EINA_TRUE;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return ecore_evas_fullscreen_get(win->ee);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Set the maximized state of a window.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @param maximized If true, the window is maximized
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2009-03-12 22:50:38 -07:00
|
|
|
EAPI void
|
2009-06-17 08:35:19 -07:00
|
|
|
elm_win_maximized_set(Evas_Object *obj, Eina_Bool maximized)
|
2009-03-12 22:50:38 -07:00
|
|
|
{
|
2009-08-09 15:23:46 -07:00
|
|
|
Elm_Win *win;
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-08-09 15:23:46 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
2009-03-12 22:50:38 -07:00
|
|
|
if (!win) return;
|
|
|
|
ecore_evas_maximized_set(win->ee, maximized);
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2009-03-12 22:50:38 -07:00
|
|
|
_elm_win_xwin_update(win);
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2009-03-12 22:50:38 -07:00
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Get the maximized state of a window.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @return If true, the window is maximized
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2009-10-12 02:09:55 -07:00
|
|
|
EAPI Eina_Bool
|
2010-03-23 20:06:00 -07:00
|
|
|
elm_win_maximized_get(const Evas_Object *obj)
|
2009-10-12 02:09:55 -07:00
|
|
|
{
|
|
|
|
Elm_Win *win;
|
2010-03-08 23:30:48 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
|
2009-10-12 02:09:55 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return EINA_FALSE;
|
|
|
|
return ecore_evas_maximized_get(win->ee);
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Set the iconified state of a window.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @param iconified If true, the window is iconified
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2009-03-12 22:50:38 -07:00
|
|
|
EAPI void
|
2009-06-17 08:35:19 -07:00
|
|
|
elm_win_iconified_set(Evas_Object *obj, Eina_Bool iconified)
|
2009-03-12 22:50:38 -07:00
|
|
|
{
|
2009-08-09 15:23:46 -07:00
|
|
|
Elm_Win *win;
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-08-09 15:23:46 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
2009-03-12 22:50:38 -07:00
|
|
|
if (!win) return;
|
|
|
|
ecore_evas_iconified_set(win->ee, iconified);
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2009-03-12 22:50:38 -07:00
|
|
|
_elm_win_xwin_update(win);
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2009-03-12 22:50:38 -07:00
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Get the iconified state of a window.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @return If true, the window is iconified
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2009-10-12 02:09:55 -07:00
|
|
|
EAPI Eina_Bool
|
2010-03-23 20:06:00 -07:00
|
|
|
elm_win_iconified_get(const Evas_Object *obj)
|
2009-10-12 02:09:55 -07:00
|
|
|
{
|
|
|
|
Elm_Win *win;
|
2010-03-08 23:30:48 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
|
2009-10-12 02:09:55 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return EINA_FALSE;
|
|
|
|
return ecore_evas_iconified_get(win->ee);
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Set the layer of the window.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @param layer The layer of the window
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2009-03-12 22:50:38 -07:00
|
|
|
EAPI void
|
|
|
|
elm_win_layer_set(Evas_Object *obj, int layer)
|
|
|
|
{
|
2009-08-09 15:23:46 -07:00
|
|
|
Elm_Win *win;
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-08-09 15:23:46 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
2009-03-12 22:50:38 -07:00
|
|
|
if (!win) return;
|
2010-09-24 09:41:25 -07:00
|
|
|
ecore_evas_layer_set(win->ee, layer);
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2009-03-12 22:50:38 -07:00
|
|
|
_elm_win_xwin_update(win);
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2009-03-12 22:50:38 -07:00
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Get the layer of the window.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @return The layer of the window
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2009-10-12 02:09:55 -07:00
|
|
|
EAPI int
|
2010-03-23 20:06:00 -07:00
|
|
|
elm_win_layer_get(const Evas_Object *obj)
|
2009-10-12 02:09:55 -07:00
|
|
|
{
|
|
|
|
Elm_Win *win;
|
2010-03-08 23:30:48 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) -1;
|
2009-10-12 02:09:55 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return -1;
|
|
|
|
return ecore_evas_layer_get(win->ee);
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Set the rotation of the window.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @param rotation The rotation of the window, in degrees (0-360)
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2009-03-14 11:03:19 -07:00
|
|
|
EAPI void
|
|
|
|
elm_win_rotation_set(Evas_Object *obj, int rotation)
|
|
|
|
{
|
2009-08-09 15:23:46 -07:00
|
|
|
Elm_Win *win;
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-08-09 15:23:46 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
2009-03-14 11:03:19 -07:00
|
|
|
if (!win) return;
|
2009-05-06 05:41:23 -07:00
|
|
|
if (win->rot == rotation) return;
|
|
|
|
win->rot = rotation;
|
2009-03-14 11:03:19 -07:00
|
|
|
ecore_evas_rotation_set(win->ee, rotation);
|
2009-05-06 05:41:23 -07:00
|
|
|
evas_object_size_hint_min_set(obj, -1, -1);
|
|
|
|
evas_object_size_hint_max_set(obj, -1, -1);
|
|
|
|
_elm_win_eval_subobjs(obj);
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2009-03-14 11:03:19 -07:00
|
|
|
_elm_win_xwin_update(win);
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2009-03-14 11:03:19 -07:00
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Rotates the window and resizes it
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @param layer The rotation of the window in degrees (0-360)
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2010-02-10 06:38:08 -08:00
|
|
|
EAPI void
|
|
|
|
elm_win_rotation_with_resize_set(Evas_Object *obj, int rotation)
|
|
|
|
{
|
|
|
|
Elm_Win *win;
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2010-02-10 06:38:08 -08:00
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return;
|
|
|
|
if (win->rot == rotation) return;
|
|
|
|
win->rot = rotation;
|
|
|
|
ecore_evas_rotation_with_resize_set(win->ee, rotation);
|
|
|
|
evas_object_size_hint_min_set(obj, -1, -1);
|
|
|
|
evas_object_size_hint_max_set(obj, -1, -1);
|
|
|
|
_elm_win_eval_subobjs(obj);
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2010-02-10 06:38:08 -08:00
|
|
|
_elm_win_xwin_update(win);
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2010-02-10 06:38:08 -08:00
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Get the rotation of the window.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @return The rotation of the window in degrees (0-360)
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2009-10-12 02:09:55 -07:00
|
|
|
EAPI int
|
2010-03-23 20:06:00 -07:00
|
|
|
elm_win_rotation_get(const Evas_Object *obj)
|
2009-10-12 02:09:55 -07:00
|
|
|
{
|
|
|
|
Elm_Win *win;
|
2010-03-08 23:30:48 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) -1;
|
2009-10-12 02:09:55 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return -1;
|
|
|
|
return win->rot;
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Set the sticky state of the window.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @param sticky If true, the window's sticky state is enabled
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2009-04-03 14:52:01 -07:00
|
|
|
EAPI void
|
|
|
|
elm_win_sticky_set(Evas_Object *obj, Eina_Bool sticky)
|
|
|
|
{
|
2009-08-09 15:23:46 -07:00
|
|
|
Elm_Win *win;
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-08-09 15:23:46 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
2009-04-03 14:52:01 -07:00
|
|
|
if (!win) return;
|
|
|
|
ecore_evas_sticky_set(win->ee, sticky);
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2009-04-03 14:52:01 -07:00
|
|
|
_elm_win_xwin_update(win);
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2009-04-03 14:52:01 -07:00
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Get the sticky state of the window.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @return If true, the window's sticky state is enabled
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2009-10-12 02:09:55 -07:00
|
|
|
EAPI Eina_Bool
|
2010-03-23 20:06:00 -07:00
|
|
|
elm_win_sticky_get(const Evas_Object *obj)
|
2009-10-12 02:09:55 -07:00
|
|
|
{
|
|
|
|
Elm_Win *win;
|
2010-03-08 23:30:48 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
|
2009-10-12 02:09:55 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return EINA_FALSE;
|
|
|
|
return ecore_evas_sticky_get(win->ee);
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Sets the keyboard mode of the window.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @param mode The mode to set; one of:
|
|
|
|
* ELM_WIN_KEYBOARD_UNKNOWN
|
|
|
|
* ELM_WIN_KEYBOARD_OFF
|
|
|
|
* ELM_WIN_KEYBOARD_ON
|
|
|
|
* ELM_WIN_KEYBOARD_ALPHA
|
|
|
|
* ELM_WIN_KEYBOARD_NUMERIC
|
|
|
|
* ELM_WIN_KEYBOARD_PIN
|
|
|
|
* ELM_WIN_KEYBOARD_PHONE_NUMBER
|
|
|
|
* ELM_WIN_KEYBOARD_HEX
|
|
|
|
* ELM_WIN_KEYBOARD_TERMINAL
|
|
|
|
* ELM_WIN_KEYBOARD_PASSWORD
|
|
|
|
* ELM_WIN_KEYBOARD_IP
|
|
|
|
* ELM_WIN_KEYBOARD_HOST
|
|
|
|
* ELM_WIN_KEYBOARD_FILE
|
|
|
|
* ELM_WIN_KEYBOARD_URL
|
|
|
|
* ELM_WIN_KEYBOARD_KEYPAD
|
|
|
|
* ELM_WIN_KEYBOARD_J2ME
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2008-11-18 02:11:57 -08:00
|
|
|
EAPI void
|
|
|
|
elm_win_keyboard_mode_set(Evas_Object *obj, Elm_Win_Keyboard_Mode mode)
|
|
|
|
{
|
2009-08-09 15:23:46 -07:00
|
|
|
Elm_Win *win;
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-08-09 15:23:46 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
2008-11-18 02:11:57 -08:00
|
|
|
if (!win) return;
|
|
|
|
if (mode == win->kbdmode) return;
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2008-11-18 22:23:08 -08:00
|
|
|
_elm_win_xwindow_get(win);
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2008-11-18 02:11:57 -08:00
|
|
|
win->kbdmode = mode;
|
2009-07-06 23:46:51 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2008-11-18 02:11:57 -08:00
|
|
|
if (win->xwin)
|
|
|
|
ecore_x_e_virtual_keyboard_state_set
|
|
|
|
(win->xwin, (Ecore_X_Virtual_Keyboard_State)win->kbdmode);
|
2009-07-06 23:46:51 -07:00
|
|
|
#endif
|
2008-11-18 02:11:57 -08:00
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Sets whether the window is a keyboard.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @param is_keyboard If true, the window is a virtual keyboard
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2008-11-18 02:11:57 -08:00
|
|
|
EAPI void
|
2009-06-17 08:35:19 -07:00
|
|
|
elm_win_keyboard_win_set(Evas_Object *obj, Eina_Bool is_keyboard)
|
2008-11-18 02:11:57 -08:00
|
|
|
{
|
2009-08-09 15:23:46 -07:00
|
|
|
Elm_Win *win;
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-08-09 15:23:46 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
2008-11-18 02:11:57 -08:00
|
|
|
if (!win) return;
|
2009-07-06 23:46:51 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2010-04-12 01:27:10 -07:00
|
|
|
_elm_win_xwindow_get(win);
|
2008-11-18 02:11:57 -08:00
|
|
|
if (win->xwin)
|
2010-01-14 21:17:54 -08:00
|
|
|
ecore_x_e_virtual_keyboard_set(win->xwin, is_keyboard);
|
2009-07-06 23:46:51 -07:00
|
|
|
#endif
|
2008-11-18 02:11:57 -08:00
|
|
|
}
|
2008-11-18 22:23:08 -08:00
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Get the screen position of a window.
|
|
|
|
*
|
|
|
|
* @param obj The window object
|
|
|
|
* @param x The int to store the x coordinate to
|
|
|
|
* @param y The int to store the y coordinate to
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2009-12-01 03:03:14 -08:00
|
|
|
EAPI void
|
2010-03-23 20:06:00 -07:00
|
|
|
elm_win_screen_position_get(const Evas_Object *obj, int *x, int *y)
|
2009-12-01 03:03:14 -08:00
|
|
|
{
|
|
|
|
Elm_Win *win;
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-12-01 03:03:14 -08:00
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return;
|
|
|
|
if (x) *x = win->screen.x;
|
|
|
|
if (y) *y = win->screen.y;
|
|
|
|
}
|
|
|
|
|
2010-02-06 09:31:09 -08:00
|
|
|
/**
|
|
|
|
* Set if this window is an illume conformant window
|
2010-02-08 19:04:18 -08:00
|
|
|
*
|
2010-02-06 09:31:09 -08:00
|
|
|
* @param obj The window object
|
|
|
|
* @param conformant The conformant flag (1 = conformant, 0 = non-conformant)
|
2010-02-08 19:04:18 -08:00
|
|
|
*
|
2010-02-06 09:31:09 -08:00
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2010-02-08 19:04:18 -08:00
|
|
|
EAPI void
|
|
|
|
elm_win_conformant_set(Evas_Object *obj, Eina_Bool conformant)
|
2010-01-14 21:17:54 -08:00
|
|
|
{
|
|
|
|
Elm_Win *win;
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2010-01-14 21:17:54 -08:00
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return;
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2010-04-12 01:27:10 -07:00
|
|
|
_elm_win_xwindow_get(win);
|
2010-01-14 21:17:54 -08:00
|
|
|
if (win->xwin)
|
|
|
|
ecore_x_e_illume_conformant_set(win->xwin, conformant);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2010-02-06 09:31:09 -08:00
|
|
|
/**
|
|
|
|
* Get if this window is an illume conformant window
|
2010-02-08 19:04:18 -08:00
|
|
|
*
|
2010-02-06 09:31:09 -08:00
|
|
|
* @param obj The window object
|
|
|
|
* @return A boolean if this window is illume conformant or not
|
2010-02-08 19:04:18 -08:00
|
|
|
*
|
2010-02-06 09:31:09 -08:00
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2010-02-08 19:04:18 -08:00
|
|
|
EAPI Eina_Bool
|
2010-03-23 20:06:00 -07:00
|
|
|
elm_win_conformant_get(const Evas_Object *obj)
|
2010-01-14 21:17:54 -08:00
|
|
|
{
|
|
|
|
Elm_Win *win;
|
2010-03-08 23:30:48 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
|
2010-01-14 21:17:54 -08:00
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return EINA_FALSE;
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2010-04-12 01:27:10 -07:00
|
|
|
_elm_win_xwindow_get(win);
|
2010-01-14 21:17:54 -08:00
|
|
|
if (win->xwin)
|
|
|
|
return ecore_x_e_illume_conformant_get(win->xwin);
|
|
|
|
#endif
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2010-02-06 09:31:09 -08:00
|
|
|
/**
|
|
|
|
* Set a window to be an illume quickpanel window
|
2010-02-08 19:04:18 -08:00
|
|
|
*
|
2010-02-06 09:31:09 -08:00
|
|
|
* By default window objects are not quickpanel windows.
|
2010-02-08 19:04:18 -08:00
|
|
|
*
|
2010-02-06 09:31:09 -08:00
|
|
|
* @param obj The window object
|
|
|
|
* @param quickpanel The quickpanel flag (1 = quickpanel, 0 = normal window)
|
2010-02-08 19:04:18 -08:00
|
|
|
*
|
2010-02-06 09:31:09 -08:00
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2010-02-08 19:04:18 -08:00
|
|
|
EAPI void
|
|
|
|
elm_win_quickpanel_set(Evas_Object *obj, Eina_Bool quickpanel)
|
2010-01-24 02:12:57 -08:00
|
|
|
{
|
|
|
|
Elm_Win *win;
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2010-01-24 02:12:57 -08:00
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return;
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2010-04-12 01:27:10 -07:00
|
|
|
_elm_win_xwindow_get(win);
|
2010-02-08 19:04:18 -08:00
|
|
|
if (win->xwin)
|
2010-01-24 12:05:09 -08:00
|
|
|
{
|
|
|
|
ecore_x_e_illume_quickpanel_set(win->xwin, quickpanel);
|
2010-02-08 19:04:18 -08:00
|
|
|
if (quickpanel)
|
2010-01-24 12:05:09 -08:00
|
|
|
{
|
|
|
|
Ecore_X_Window_State states[2];
|
|
|
|
|
|
|
|
states[0] = ECORE_X_WINDOW_STATE_SKIP_TASKBAR;
|
|
|
|
states[1] = ECORE_X_WINDOW_STATE_SKIP_PAGER;
|
|
|
|
ecore_x_netwm_window_state_set(win->xwin, states, 2);
|
|
|
|
ecore_x_icccm_hints_set(win->xwin, 0, 0, 0, 0, 0, 0, 0);
|
|
|
|
}
|
|
|
|
}
|
2010-01-24 02:12:57 -08:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2010-02-06 09:31:09 -08:00
|
|
|
/**
|
|
|
|
* Get if this window is a quickpanel or not
|
2010-02-08 19:04:18 -08:00
|
|
|
*
|
2010-02-06 09:31:09 -08:00
|
|
|
* @param obj The window object
|
|
|
|
* @return A boolean if this window is a quickpanel or not
|
2010-02-08 19:04:18 -08:00
|
|
|
*
|
2010-02-06 09:31:09 -08:00
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2010-02-08 19:04:18 -08:00
|
|
|
EAPI Eina_Bool
|
2010-03-23 20:06:00 -07:00
|
|
|
elm_win_quickpanel_get(const Evas_Object *obj)
|
2010-01-24 02:12:57 -08:00
|
|
|
{
|
|
|
|
Elm_Win *win;
|
2010-03-08 23:30:48 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
|
2010-01-24 02:12:57 -08:00
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return EINA_FALSE;
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2010-04-12 01:27:10 -07:00
|
|
|
_elm_win_xwindow_get(win);
|
2010-01-24 02:12:57 -08:00
|
|
|
if (win->xwin)
|
|
|
|
return ecore_x_e_illume_quickpanel_get(win->xwin);
|
|
|
|
#endif
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2010-02-06 09:31:09 -08:00
|
|
|
/**
|
|
|
|
* Set the major priority of a quickpanel window
|
2010-02-08 19:04:18 -08:00
|
|
|
*
|
2010-02-06 09:31:09 -08:00
|
|
|
* @param obj The window object
|
|
|
|
* @param priority The major priority for this quickpanel
|
2010-02-08 19:04:18 -08:00
|
|
|
*
|
2010-02-06 09:31:09 -08:00
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2010-02-08 19:04:18 -08:00
|
|
|
EAPI void
|
|
|
|
elm_win_quickpanel_priority_major_set(Evas_Object *obj, int priority)
|
2010-01-24 02:21:54 -08:00
|
|
|
{
|
|
|
|
Elm_Win *win;
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2010-01-24 02:21:54 -08:00
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return;
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2010-04-12 01:27:10 -07:00
|
|
|
_elm_win_xwindow_get(win);
|
2010-01-24 02:21:54 -08:00
|
|
|
if (win->xwin)
|
|
|
|
ecore_x_e_illume_quickpanel_priority_major_set(win->xwin, priority);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2010-02-06 09:31:09 -08:00
|
|
|
/**
|
|
|
|
* Get the major priority of a quickpanel window
|
2010-02-08 19:04:18 -08:00
|
|
|
*
|
2010-02-06 09:31:09 -08:00
|
|
|
* @param obj The window object
|
|
|
|
* @return The major priority of this quickpanel
|
2010-02-08 19:04:18 -08:00
|
|
|
*
|
2010-02-06 09:31:09 -08:00
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2010-02-08 19:04:18 -08:00
|
|
|
EAPI int
|
2010-03-23 20:06:00 -07:00
|
|
|
elm_win_quickpanel_priority_major_get(const Evas_Object *obj)
|
2010-01-24 02:21:54 -08:00
|
|
|
{
|
|
|
|
Elm_Win *win;
|
2010-03-08 23:30:48 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) -1;
|
2010-01-24 02:21:54 -08:00
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return -1;
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2010-04-12 01:27:10 -07:00
|
|
|
_elm_win_xwindow_get(win);
|
2010-01-24 02:21:54 -08:00
|
|
|
if (win->xwin)
|
|
|
|
return ecore_x_e_illume_quickpanel_priority_major_get(win->xwin);
|
|
|
|
#endif
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2010-02-06 09:31:09 -08:00
|
|
|
/**
|
|
|
|
* Set the minor priority of a quickpanel window
|
2010-02-08 19:04:18 -08:00
|
|
|
*
|
2010-02-06 09:31:09 -08:00
|
|
|
* @param obj The window object
|
|
|
|
* @param priority The minor priority for this quickpanel
|
2010-02-08 19:04:18 -08:00
|
|
|
*
|
2010-02-06 09:31:09 -08:00
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2010-02-08 19:04:18 -08:00
|
|
|
EAPI void
|
|
|
|
elm_win_quickpanel_priority_minor_set(Evas_Object *obj, int priority)
|
2010-01-24 02:21:54 -08:00
|
|
|
{
|
|
|
|
Elm_Win *win;
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2010-01-24 02:21:54 -08:00
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return;
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2010-04-12 01:27:10 -07:00
|
|
|
_elm_win_xwindow_get(win);
|
2010-01-24 02:21:54 -08:00
|
|
|
if (win->xwin)
|
|
|
|
ecore_x_e_illume_quickpanel_priority_minor_set(win->xwin, priority);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2010-02-06 09:31:09 -08:00
|
|
|
/**
|
|
|
|
* Get the minor priority of a quickpanel window
|
2010-02-08 19:04:18 -08:00
|
|
|
*
|
2010-02-06 09:31:09 -08:00
|
|
|
* @param obj The window object
|
|
|
|
* @return The minor priority of this quickpanel
|
2010-02-08 19:04:18 -08:00
|
|
|
*
|
2010-02-06 09:31:09 -08:00
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2010-02-08 19:04:18 -08:00
|
|
|
EAPI int
|
2010-03-23 20:06:00 -07:00
|
|
|
elm_win_quickpanel_priority_minor_get(const Evas_Object *obj)
|
2010-01-24 02:21:54 -08:00
|
|
|
{
|
|
|
|
Elm_Win *win;
|
2010-03-08 23:30:48 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) -1;
|
2010-01-24 02:21:54 -08:00
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return -1;
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2010-04-12 01:27:10 -07:00
|
|
|
_elm_win_xwindow_get(win);
|
2010-01-24 02:21:54 -08:00
|
|
|
if (win->xwin)
|
|
|
|
return ecore_x_e_illume_quickpanel_priority_minor_get(win->xwin);
|
|
|
|
#endif
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2010-02-06 09:31:09 -08:00
|
|
|
/**
|
|
|
|
* Set which zone this quickpanel should appear in
|
2010-02-08 19:04:18 -08:00
|
|
|
*
|
2010-02-06 09:31:09 -08:00
|
|
|
* @param obj The window object
|
|
|
|
* @param zone The requested zone for this quickpanel
|
2010-02-08 19:04:18 -08:00
|
|
|
*
|
2010-02-06 09:31:09 -08:00
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2010-02-08 19:04:18 -08:00
|
|
|
EAPI void
|
|
|
|
elm_win_quickpanel_zone_set(Evas_Object *obj, int zone)
|
2010-01-24 12:05:09 -08:00
|
|
|
{
|
|
|
|
Elm_Win *win;
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2010-01-24 12:05:09 -08:00
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return;
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2010-04-12 01:27:10 -07:00
|
|
|
_elm_win_xwindow_get(win);
|
2010-02-08 19:04:18 -08:00
|
|
|
if (win->xwin)
|
2010-02-18 18:33:17 -08:00
|
|
|
ecore_x_e_illume_quickpanel_zone_set(win->xwin, zone);
|
2010-01-24 12:05:09 -08:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
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
|
|
|
/**
|
|
|
|
* Set the enabled status for the focus highlight in a window
|
|
|
|
*
|
|
|
|
* This function will enable or disable the focus highlight only for the
|
|
|
|
* given window, regardless of the global setting for it
|
|
|
|
*
|
|
|
|
* @param obj The window where to enable the highlight
|
|
|
|
* @param enabled The enabled value for the highlight
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
elm_win_focus_highlight_enabled_set(Evas_Object *obj, Eina_Bool enabled)
|
|
|
|
{
|
|
|
|
Elm_Win *win;
|
|
|
|
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
|
|
|
|
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
enabled = !!enabled;
|
|
|
|
if (win->focus_highlight.enabled == enabled)
|
|
|
|
return;
|
|
|
|
|
|
|
|
win->focus_highlight.enabled = enabled;
|
|
|
|
|
|
|
|
if (win->focus_highlight.enabled)
|
|
|
|
_elm_win_focus_highlight_init(win);
|
|
|
|
else
|
|
|
|
_elm_win_focus_highlight_shutdown(win);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the enabled value of the focus highlight for this window
|
|
|
|
*
|
|
|
|
* @param obj The window in which to check if the focus highlight is enabled
|
|
|
|
*
|
|
|
|
* @return EINA_TRUE if enabled, EINA_FALSE otherwise
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_win_focus_highlight_enabled_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Elm_Win *win;
|
|
|
|
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
|
|
|
|
|
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
return win->focus_highlight.enabled;
|
|
|
|
}
|
|
|
|
|
2010-10-04 10:34:35 -07:00
|
|
|
/**
|
|
|
|
* Set the style for the focus highlight on this window
|
|
|
|
*
|
|
|
|
* Sets the style to use for theming the highlight of focused objects on
|
|
|
|
* the given window. If @p style is NULL, the default will be used.
|
|
|
|
*
|
|
|
|
* @param obj The window where to set the style
|
|
|
|
* @param style The style to set
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
elm_win_focus_highlight_style_set(Evas_Object *obj, const char *style)
|
|
|
|
{
|
|
|
|
Elm_Win *win;
|
|
|
|
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
|
|
|
|
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
eina_stringshare_replace(&win->focus_highlight.style, style);
|
|
|
|
win->focus_highlight.changed_theme = EINA_TRUE;
|
|
|
|
_elm_win_focus_highlight_reconfigure_job_start(win);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the style set for the focus highlight object
|
|
|
|
*
|
|
|
|
* Gets the style set for this windows highilght object, or NULL if none
|
|
|
|
* is set.
|
|
|
|
*
|
|
|
|
* @param obj The window to retrieve the highlights style from
|
|
|
|
*
|
|
|
|
* @return The style set or NULL if none was. Default is used in that case.
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
|
|
|
EAPI const char *
|
|
|
|
elm_win_focus_highlight_style_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Elm_Win *win;
|
|
|
|
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
|
|
|
|
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
return win->focus_highlight.style;
|
|
|
|
}
|
|
|
|
|
2008-12-30 08:19:46 -08:00
|
|
|
typedef struct _Widget_Data Widget_Data;
|
|
|
|
|
|
|
|
struct _Widget_Data
|
|
|
|
{
|
|
|
|
Evas_Object *frm;
|
|
|
|
Evas_Object *content;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void _del_hook(Evas_Object *obj);
|
|
|
|
static void _theme_hook(Evas_Object *obj);
|
|
|
|
static void _sizing_eval(Evas_Object *obj);
|
|
|
|
static void _changed_size_hints(void *data, Evas *e, Evas_Object *obj, void *event_info);
|
|
|
|
static void _sub_del(void *data, Evas_Object *obj, void *event_info);
|
|
|
|
|
2010-03-08 23:30:48 -08:00
|
|
|
static const char *widtype2 = NULL;
|
|
|
|
|
2008-12-30 08:19:46 -08:00
|
|
|
static void
|
|
|
|
_del_hook(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2010-06-16 13:58:09 -07:00
|
|
|
if (!wd) return;
|
2008-12-30 08:19:46 -08:00
|
|
|
free(wd);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_theme_hook(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2010-05-11 18:03:46 -07:00
|
|
|
_elm_theme_object_set(obj, wd->frm, "win", "inwin", elm_widget_style_get(obj));
|
2008-12-30 08:19:46 -08:00
|
|
|
if (wd->content)
|
|
|
|
edje_object_part_swallow(wd->frm, "elm.swallow.content", wd->content);
|
|
|
|
_sizing_eval(obj);
|
|
|
|
}
|
|
|
|
|
2010-10-01 12:02:58 -07:00
|
|
|
static Eina_Bool
|
2010-10-06 13:24:19 -07:00
|
|
|
_elm_inwin_focus_next_hook(const Evas_Object *obj, Elm_Focus_Direction dir, Evas_Object **next)
|
2010-10-01 12:02:58 -07:00
|
|
|
{
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
Evas_Object *cur;
|
|
|
|
|
|
|
|
if ((!wd) || (!wd->content))
|
|
|
|
return EINA_FALSE;
|
|
|
|
|
|
|
|
cur = wd->content;
|
|
|
|
|
|
|
|
/* Try Focus cycle in subitem */
|
2010-10-06 13:24:13 -07:00
|
|
|
elm_widget_focus_next_get(cur, dir, next);
|
2010-10-06 13:24:09 -07:00
|
|
|
if (*next)
|
|
|
|
return EINA_TRUE;
|
|
|
|
return EINA_FALSE;
|
2010-10-01 12:02:58 -07:00
|
|
|
}
|
|
|
|
|
2008-12-30 08:19:46 -08:00
|
|
|
static void
|
|
|
|
_sizing_eval(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2009-11-14 17:51:39 -08:00
|
|
|
Evas_Coord minw = -1, minh = -1;
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2008-12-30 08:19:46 -08:00
|
|
|
evas_object_size_hint_min_get(wd->content, &minw, &minh);
|
|
|
|
edje_object_size_min_calc(wd->frm, &minw, &minh);
|
|
|
|
evas_object_size_hint_min_set(obj, minw, minh);
|
2009-11-14 17:51:39 -08:00
|
|
|
evas_object_size_hint_max_set(obj, -1, -1);
|
2008-12-30 08:19:46 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-03-09 09:51:30 -08:00
|
|
|
_changed_size_hints(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
|
2008-12-30 08:19:46 -08:00
|
|
|
{
|
|
|
|
_sizing_eval(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-03-09 09:51:30 -08:00
|
|
|
_sub_del(void *data __UNUSED__, Evas_Object *obj, void *event_info)
|
2008-12-30 08:19:46 -08:00
|
|
|
{
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
Evas_Object *sub = event_info;
|
|
|
|
if (sub == wd->content)
|
|
|
|
{
|
2009-10-22 15:10:23 -07:00
|
|
|
evas_object_event_callback_del_full
|
2009-11-14 17:51:39 -08:00
|
|
|
(sub, EVAS_CALLBACK_CHANGED_SIZE_HINTS, _changed_size_hints, obj);
|
2009-07-06 23:46:51 -07:00
|
|
|
wd->content = NULL;
|
|
|
|
_sizing_eval(obj);
|
2008-12-30 08:19:46 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* @defgroup Inwin Inwin
|
|
|
|
*
|
|
|
|
* An inwin is a window inside a window that is useful for a quick popup. It does not hover.
|
|
|
|
*/
|
2008-12-30 08:19:46 -08:00
|
|
|
EAPI Evas_Object *
|
|
|
|
elm_win_inwin_add(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Evas_Object *obj2;
|
|
|
|
Widget_Data *wd;
|
2009-11-14 17:51:39 -08:00
|
|
|
Elm_Win *win;
|
|
|
|
|
2010-03-08 23:30:48 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
2009-08-09 15:23:46 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
2008-12-30 08:19:46 -08:00
|
|
|
if (!win) return NULL;
|
|
|
|
wd = ELM_NEW(Widget_Data);
|
|
|
|
obj2 = elm_widget_add(win->evas);
|
2009-05-13 05:21:52 -07:00
|
|
|
elm_widget_type_set(obj2, "inwin");
|
2010-03-08 23:30:48 -08:00
|
|
|
ELM_SET_WIDTYPE(widtype2, "inwin");
|
2009-05-13 05:21:52 -07:00
|
|
|
elm_widget_sub_object_add(obj, obj2);
|
2009-11-14 17:51:39 -08:00
|
|
|
evas_object_size_hint_weight_set(obj2, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
|
|
|
|
evas_object_size_hint_align_set(obj2, EVAS_HINT_FILL, EVAS_HINT_FILL);
|
2008-12-30 08:19:46 -08:00
|
|
|
elm_win_resize_object_add(obj, obj2);
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2008-12-30 08:19:46 -08:00
|
|
|
elm_widget_data_set(obj2, wd);
|
|
|
|
elm_widget_del_hook_set(obj2, _del_hook);
|
|
|
|
elm_widget_theme_hook_set(obj2, _theme_hook);
|
2010-10-06 13:24:13 -07:00
|
|
|
elm_widget_focus_next_hook_set(obj2, _elm_inwin_focus_next_hook);
|
2010-09-29 05:22:30 -07:00
|
|
|
elm_widget_can_focus_set(obj2, EINA_FALSE);
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2008-12-30 08:19:46 -08:00
|
|
|
wd->frm = edje_object_add(win->evas);
|
2010-05-11 18:03:46 -07:00
|
|
|
_elm_theme_object_set(obj, wd->frm, "win", "inwin", "default");
|
2008-12-30 08:19:46 -08:00
|
|
|
elm_widget_resize_object_set(obj2, wd->frm);
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2008-12-30 08:19:46 -08:00
|
|
|
evas_object_smart_callback_add(obj2, "sub-object-del", _sub_del, obj2);
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2008-12-30 08:19:46 -08:00
|
|
|
_sizing_eval(obj2);
|
|
|
|
return obj2;
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Activates an inwin object
|
|
|
|
*
|
|
|
|
* @param obj The inwin to activate
|
|
|
|
*
|
|
|
|
* @ingroup Inwin
|
|
|
|
*/
|
2008-12-30 08:19:46 -08:00
|
|
|
EAPI void
|
|
|
|
elm_win_inwin_activate(Evas_Object *obj)
|
|
|
|
{
|
2010-03-08 23:30:48 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype2);
|
2008-12-30 08:19:46 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2010-03-08 23:30:48 -08:00
|
|
|
if (!wd) return;
|
2008-12-30 08:19:46 -08:00
|
|
|
evas_object_raise(obj);
|
|
|
|
evas_object_show(obj);
|
|
|
|
edje_object_signal_emit(wd->frm, "elm,action,show", "elm");
|
|
|
|
elm_widget_focused_object_clear(elm_widget_parent_get(obj));
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Set the content of an inwin object.
|
|
|
|
*
|
2010-06-16 13:58:09 -07:00
|
|
|
* Once the content object is set, a previously set one will be deleted.
|
|
|
|
* If you want to keep that old content object, use the
|
|
|
|
* elm_win_inwin_content_unset() function.
|
|
|
|
*
|
2010-04-12 01:12:02 -07:00
|
|
|
* @param obj The inwin object
|
|
|
|
* @param content The object to set as content
|
|
|
|
*
|
|
|
|
* @ingroup Inwin
|
|
|
|
*/
|
2008-12-30 08:19:46 -08:00
|
|
|
EAPI void
|
|
|
|
elm_win_inwin_content_set(Evas_Object *obj, Evas_Object *content)
|
|
|
|
{
|
2010-03-08 23:30:48 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype2);
|
2008-12-30 08:19:46 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2010-03-08 23:30:48 -08:00
|
|
|
if (!wd) return;
|
2010-06-16 13:58:09 -07:00
|
|
|
if (wd->content == content) return;
|
|
|
|
if (wd->content) evas_object_del(wd->content);
|
2008-12-30 08:19:46 -08:00
|
|
|
wd->content = content;
|
|
|
|
if (content)
|
|
|
|
{
|
2009-07-06 23:46:51 -07:00
|
|
|
elm_widget_sub_object_add(obj, content);
|
|
|
|
evas_object_event_callback_add(content, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
|
|
|
|
_changed_size_hints, obj);
|
2009-12-07 06:19:20 -08:00
|
|
|
edje_object_part_swallow(wd->frm, "elm.swallow.content", content);
|
2008-12-30 08:19:46 -08:00
|
|
|
}
|
2010-06-16 13:58:09 -07:00
|
|
|
_sizing_eval(obj);
|
|
|
|
}
|
|
|
|
|
2010-10-14 11:54:42 -07:00
|
|
|
/**
|
|
|
|
* Get the content of an inwin object.
|
|
|
|
*
|
|
|
|
* Return the content object which is set for this widget.
|
|
|
|
*
|
|
|
|
* @param obj The inwin object
|
|
|
|
* @return The content that is being used
|
|
|
|
*
|
|
|
|
* @ingroup Inwin
|
|
|
|
*/
|
|
|
|
EAPI Evas_Object *
|
|
|
|
elm_win_inwin_content_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype2) NULL;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return NULL;
|
|
|
|
return wd->content;
|
|
|
|
}
|
|
|
|
|
2010-06-16 13:58:09 -07:00
|
|
|
/**
|
|
|
|
* Unset the content of an inwin object.
|
|
|
|
*
|
|
|
|
* Unparent and return the content object which was set for this widget.
|
|
|
|
*
|
|
|
|
* @param obj The inwin object
|
|
|
|
* @return The content that was being used
|
|
|
|
*
|
|
|
|
* @ingroup Inwin
|
|
|
|
*/
|
|
|
|
EAPI Evas_Object *
|
|
|
|
elm_win_inwin_content_unset(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype2) NULL;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return NULL;
|
|
|
|
if (!wd->content) return NULL;
|
|
|
|
Evas_Object *content = wd->content;
|
|
|
|
elm_widget_sub_object_del(obj, wd->content);
|
|
|
|
edje_object_part_unswallow(wd->frm, wd->content);
|
|
|
|
wd->content = NULL;
|
|
|
|
return content;
|
2008-12-30 08:19:46 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* windowing spcific calls - shall we do this differently? */
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Get the Ecore_X_Window of an Evas_Object
|
|
|
|
*
|
|
|
|
* @param obj The object
|
|
|
|
*
|
|
|
|
* @return The Ecore_X_Window of @p obj
|
|
|
|
*
|
|
|
|
* @ingroup Win
|
|
|
|
*/
|
2008-11-18 22:23:08 -08:00
|
|
|
EAPI Ecore_X_Window
|
2009-02-25 07:54:26 -08:00
|
|
|
elm_win_xwindow_get(const Evas_Object *obj)
|
2008-11-18 22:23:08 -08:00
|
|
|
{
|
2009-08-09 15:23:46 -07:00
|
|
|
Ecore_X_Window xwin = 0;
|
|
|
|
Ecore_Evas *ee = NULL;
|
2010-03-08 23:30:48 -08:00
|
|
|
if (!obj) return 0;
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2009-08-09 15:23:46 -07:00
|
|
|
ee = ecore_evas_ecore_evas_get(evas_object_evas_get(obj));
|
|
|
|
if (ee) xwin = (Ecore_X_Window)ecore_evas_window_get(ee);
|
|
|
|
return xwin;
|
2010-04-12 01:27:10 -07:00
|
|
|
#else
|
|
|
|
return 0;
|
|
|
|
#endif
|
2008-11-18 22:23:08 -08:00
|
|
|
}
|