2008-09-29 23:58:56 -07:00
|
|
|
#include <Elementary.h>
|
|
|
|
#include "elm_priv.h"
|
|
|
|
|
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;
|
2011-04-14 03:48:43 -07:00
|
|
|
Evas_Object *parent, *win_obj, *img_obj, *frame_obj;
|
2009-11-14 17:51:39 -08:00
|
|
|
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;
|
2011-05-04 03:09:59 -07:00
|
|
|
struct {
|
|
|
|
const char *info;
|
|
|
|
Ecore_Timer *timer;
|
2011-07-05 01:17:39 -07:00
|
|
|
int repeat_count;
|
|
|
|
int shot_counter;
|
2011-05-04 03:09:59 -07:00
|
|
|
} shot;
|
2009-11-14 17:51:39 -08:00
|
|
|
Eina_Bool autodel : 1;
|
|
|
|
int *autodel_clear, rot;
|
2011-09-06 18:41:19 -07:00
|
|
|
int show_count;
|
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);
|
2011-04-14 03:48:43 -07:00
|
|
|
static void _elm_win_obj_callback_img_obj_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);
|
2011-04-14 03:48:43 -07:00
|
|
|
static void _elm_win_obj_intercept_move(void *data, Evas_Object *obj, Evas_Coord x, Evas_Coord y);
|
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
|
|
|
|
2011-04-21 17:42:32 -07:00
|
|
|
static const char SIG_DELETE_REQUEST[] = "delete,request";
|
2011-08-01 12:41:56 -07:00
|
|
|
static const char SIG_FOCUS_OUT[] = "focus,out";
|
|
|
|
static const char SIG_FOCUS_IN[] = "focus,in";
|
2011-04-21 17:42:32 -07:00
|
|
|
static const char SIG_MOVED[] = "moved";
|
2011-09-13 19:09:05 -07:00
|
|
|
static const char SIG_THEME_CHANGED[] = "theme,changed";
|
2011-04-21 17:42:32 -07:00
|
|
|
|
|
|
|
static const Evas_Smart_Cb_Description _signals[] = {
|
|
|
|
{SIG_DELETE_REQUEST, ""},
|
|
|
|
{SIG_FOCUS_OUT, ""},
|
|
|
|
{SIG_FOCUS_IN, ""},
|
|
|
|
{SIG_MOVED, ""},
|
|
|
|
{NULL, NULL}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
2010-04-12 01:27:10 -07:00
|
|
|
Eina_List *_elm_win_list = NULL;
|
2011-03-09 22:35:33 -08:00
|
|
|
int _elm_win_deferred_free = 0;
|
2008-10-06 18:23:49 -07:00
|
|
|
|
2011-05-04 03:09:59 -07:00
|
|
|
// exmaple shot spec (wait 0.1 sec then save as my-window.png):
|
|
|
|
// ELM_ENGINE="shot:delay=0.1:file=my-window.png"
|
|
|
|
|
|
|
|
static double
|
|
|
|
_shot_delay_get(Elm_Win *win)
|
|
|
|
{
|
|
|
|
char *p, *pd;
|
|
|
|
char *d = strdup(win->shot.info);
|
2011-05-07 01:37:47 -07:00
|
|
|
|
2011-05-04 03:09:59 -07:00
|
|
|
if (!d) return 0.5;
|
|
|
|
for (p = (char *)win->shot.info; *p; p++)
|
|
|
|
{
|
|
|
|
if (!strncmp(p, "delay=", 6))
|
|
|
|
{
|
|
|
|
double v;
|
2011-05-07 01:37:47 -07:00
|
|
|
|
2011-05-04 03:09:59 -07:00
|
|
|
for (pd = d, p += 6; (*p) && (*p != ':'); p++, pd++)
|
|
|
|
{
|
|
|
|
*pd = *p;
|
|
|
|
}
|
|
|
|
*pd = 0;
|
|
|
|
v = atof(d);
|
|
|
|
free(d);
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free(d);
|
|
|
|
return 0.5;
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
|
|
|
_shot_file_get(Elm_Win *win)
|
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
char *tmp = strdup(win->shot.info);
|
2011-07-05 01:17:39 -07:00
|
|
|
char *repname = NULL;
|
2011-05-07 01:37:47 -07:00
|
|
|
|
2011-05-04 03:09:59 -07:00
|
|
|
if (!tmp) return NULL;
|
2011-07-05 01:17:39 -07:00
|
|
|
|
2011-05-04 03:09:59 -07:00
|
|
|
for (p = (char *)win->shot.info; *p; p++)
|
|
|
|
{
|
|
|
|
if (!strncmp(p, "file=", 5))
|
|
|
|
{
|
|
|
|
strcpy(tmp, p + 5);
|
2011-07-05 01:17:39 -07:00
|
|
|
if (!win->shot.repeat_count) return tmp;
|
|
|
|
else
|
|
|
|
{
|
2011-07-10 21:15:42 -07:00
|
|
|
char *dotptr = strrchr(tmp, '.');
|
2011-07-05 01:17:39 -07:00
|
|
|
if (dotptr)
|
|
|
|
{
|
|
|
|
repname = malloc(sizeof(char)*(strlen(tmp) + 16));
|
|
|
|
strncpy(repname, tmp, dotptr - tmp);
|
2011-07-05 09:59:23 -07:00
|
|
|
sprintf(repname + (dotptr - tmp), "%03i",
|
2011-07-05 01:17:39 -07:00
|
|
|
win->shot.shot_counter + 1);
|
|
|
|
strcat(repname, dotptr);
|
|
|
|
return repname;
|
|
|
|
}
|
|
|
|
}
|
2011-05-04 03:09:59 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
free(tmp);
|
2011-07-05 01:17:39 -07:00
|
|
|
if (!win->shot.repeat_count) return strdup("out.png");
|
2011-07-05 09:59:23 -07:00
|
|
|
else
|
2011-07-05 01:17:39 -07:00
|
|
|
{
|
|
|
|
repname = malloc(sizeof(char) * 24);
|
|
|
|
sprintf(repname, "out%03i.png", win->shot.shot_counter + 1);
|
|
|
|
return repname;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
_shot_repeat_count_get(Elm_Win *win)
|
|
|
|
{
|
|
|
|
|
|
|
|
char *p, *pd;
|
|
|
|
char *d = strdup(win->shot.info);
|
|
|
|
|
|
|
|
if (!d) return 0;
|
|
|
|
for (p = (char *)win->shot.info; *p; p++)
|
|
|
|
{
|
|
|
|
if (!strncmp(p, "repeat=", 7))
|
|
|
|
{
|
|
|
|
int v;
|
|
|
|
|
|
|
|
for (pd = d, p += 7; (*p) && (*p != ':'); p++, pd++)
|
|
|
|
{
|
|
|
|
*pd = *p;
|
|
|
|
}
|
|
|
|
*pd = 0;
|
|
|
|
v = atoi(d);
|
|
|
|
if (v < 0) v = 0;
|
|
|
|
if (v > 1000) v = 999;
|
|
|
|
free(d);
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free(d);
|
|
|
|
return 0;
|
2011-05-04 03:09:59 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
|
|
|
_shot_key_get(Elm_Win *win __UNUSED__)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
|
|
|
_shot_flags_get(Elm_Win *win __UNUSED__)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_shot_do(Elm_Win *win)
|
|
|
|
{
|
|
|
|
Ecore_Evas *ee;
|
|
|
|
Evas_Object *o;
|
|
|
|
unsigned int *pixels;
|
|
|
|
int w, h;
|
|
|
|
char *file, *key, *flags;
|
|
|
|
|
|
|
|
ecore_evas_manual_render(win->ee);
|
|
|
|
pixels = (void *)ecore_evas_buffer_pixels_get(win->ee);
|
|
|
|
if (!pixels) return;
|
|
|
|
ecore_evas_geometry_get(win->ee, NULL, NULL, &w, &h);
|
|
|
|
if ((w < 1) || (h < 1)) return;
|
|
|
|
file = _shot_file_get(win);
|
|
|
|
if (!file) return;
|
|
|
|
key = _shot_key_get(win);
|
|
|
|
flags = _shot_flags_get(win);
|
|
|
|
ee = ecore_evas_buffer_new(1, 1);
|
|
|
|
o = evas_object_image_add(ecore_evas_get(ee));
|
|
|
|
evas_object_image_alpha_set(o, ecore_evas_alpha_get(win->ee));
|
|
|
|
evas_object_image_size_set(o, w, h);
|
|
|
|
evas_object_image_data_set(o, pixels);
|
|
|
|
if (!evas_object_image_save(o, file, key, flags))
|
|
|
|
{
|
|
|
|
ERR("Cannot save window to '%s' (key '%s', flags '%s')",
|
|
|
|
file, key, flags);
|
|
|
|
}
|
|
|
|
free(file);
|
|
|
|
if (key) free(key);
|
|
|
|
if (flags) free(flags);
|
|
|
|
ecore_evas_free(ee);
|
2011-07-05 01:17:39 -07:00
|
|
|
if (win->shot.repeat_count) win->shot.shot_counter++;
|
2011-05-04 03:09:59 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_shot_delay(void *data)
|
|
|
|
{
|
|
|
|
Elm_Win *win = data;
|
|
|
|
_shot_do(win);
|
2011-07-05 01:17:39 -07:00
|
|
|
if (win->shot.repeat_count)
|
|
|
|
{
|
|
|
|
int remainshot = (win->shot.repeat_count - win->shot.shot_counter);
|
|
|
|
if (remainshot > 0) return EINA_TRUE;
|
2011-07-05 09:59:23 -07:00
|
|
|
}
|
2011-05-04 03:09:59 -07:00
|
|
|
win->shot.timer = NULL;
|
|
|
|
elm_exit();
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2011-07-05 01:17:39 -07:00
|
|
|
static void
|
|
|
|
_shot_init(Elm_Win *win)
|
|
|
|
{
|
|
|
|
if (!win->shot.info) return;
|
|
|
|
win->shot.repeat_count = _shot_repeat_count_get(win);
|
|
|
|
win->shot.shot_counter = 0;
|
|
|
|
}
|
|
|
|
|
2011-05-04 03:09:59 -07:00
|
|
|
static void
|
|
|
|
_shot_handle(Elm_Win *win)
|
|
|
|
{
|
|
|
|
if (!win->shot.info) return;
|
|
|
|
win->shot.timer = ecore_timer_add(_shot_delay_get(win), _shot_delay, win);
|
|
|
|
}
|
|
|
|
|
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;
|
2011-04-21 17:42:32 -07:00
|
|
|
evas_object_smart_callback_call(win->win_obj, SIG_MOVED, NULL);
|
2009-12-01 03:03:14 -08:00
|
|
|
}
|
|
|
|
|
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;
|
2011-09-06 23:15:55 -07:00
|
|
|
_elm_widget_top_win_focused_set(win->win_obj, EINA_TRUE);
|
2011-09-06 18:41:19 -07:00
|
|
|
if (win->show_count == 1)
|
|
|
|
{
|
|
|
|
elm_object_focus_set(win->win_obj, EINA_TRUE);
|
|
|
|
win->show_count++;
|
|
|
|
}
|
|
|
|
else
|
2011-08-09 02:29:22 -07:00
|
|
|
elm_widget_focus_restore(win->win_obj);
|
2011-04-21 17:42:32 -07:00
|
|
|
evas_object_smart_callback_call(win->win_obj, SIG_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);
|
2011-04-14 03:48:43 -07:00
|
|
|
if (win->frame_obj)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
else if (win->img_obj)
|
|
|
|
{
|
|
|
|
/* do nothing */
|
|
|
|
}
|
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;
|
2011-08-09 01:36:02 -07:00
|
|
|
elm_object_focus_set(win->win_obj, EINA_FALSE);
|
2011-09-06 23:15:55 -07:00
|
|
|
_elm_widget_top_win_focused_set(win->win_obj, EINA_FALSE);
|
2011-04-21 17:42:32 -07:00
|
|
|
evas_object_smart_callback_call(win->win_obj, SIG_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);
|
2011-04-14 03:48:43 -07:00
|
|
|
if (win->frame_obj)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
else if (win->img_obj)
|
|
|
|
{
|
|
|
|
/* do nothing */
|
|
|
|
}
|
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)
|
|
|
|
{
|
2011-04-14 05:47:16 -07:00
|
|
|
Elm_Win *win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return;
|
2011-04-20 07:16:51 -07:00
|
|
|
|
2011-04-14 05:47:16 -07:00
|
|
|
if (win->img_obj)
|
|
|
|
evas_object_focus_set(win->img_obj, elm_widget_focus_get(obj));
|
2010-10-21 11:58:43 -07:00
|
|
|
else
|
2011-04-14 05:47:16 -07:00
|
|
|
evas_object_focus_set(obj, elm_widget_focus_get(obj));
|
2010-10-21 11:58:43 -07:00
|
|
|
}
|
|
|
|
|
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"))
|
|
|
|
{
|
2011-04-14 05:47:16 -07:00
|
|
|
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;
|
|
|
|
}
|
2011-08-05 01:25:07 -07:00
|
|
|
else if ((!strcmp(ev->keyname, "Left")) ||
|
|
|
|
(!strcmp(ev->keyname, "KP_Left")))
|
|
|
|
{
|
2011-08-06 00:39:31 -07:00
|
|
|
//TODO : woohyun jung
|
2011-08-05 01:25:07 -07:00
|
|
|
}
|
|
|
|
else if ((!strcmp(ev->keyname, "Right")) ||
|
|
|
|
(!strcmp(ev->keyname, "KP_Right")))
|
|
|
|
{
|
2011-08-06 00:39:31 -07:00
|
|
|
//TODO : woohyun jung
|
2011-08-05 01:25:07 -07:00
|
|
|
}
|
|
|
|
else if ((!strcmp(ev->keyname, "Up")) ||
|
|
|
|
(!strcmp(ev->keyname, "KP_Up")))
|
|
|
|
{
|
2011-08-06 00:39:31 -07:00
|
|
|
//TODO : woohyun jung
|
2011-08-05 01:25:07 -07:00
|
|
|
}
|
|
|
|
else if ((!strcmp(ev->keyname, "Down")) ||
|
|
|
|
(!strcmp(ev->keyname, "KP_Down")))
|
|
|
|
{
|
2011-08-06 00:39:31 -07:00
|
|
|
//TODO : woohyun jung
|
2011-08-05 01:25:07 -07:00
|
|
|
}
|
2010-09-24 07:47:59 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2008-10-24 19:11:06 -07:00
|
|
|
static void
|
|
|
|
_deferred_ecore_evas_free(void *data)
|
|
|
|
{
|
|
|
|
ecore_evas_free(data);
|
2011-03-09 22:35:33 -08:00
|
|
|
_elm_win_deferred_free--;
|
2008-10-24 19:11:06 -07:00
|
|
|
}
|
|
|
|
|
2010-10-21 11:58:43 -07:00
|
|
|
static void
|
2011-09-06 18:41:19 -07:00
|
|
|
_elm_win_obj_callback_show(void *data __UNUSED__, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
|
2010-10-21 11:58:43 -07:00
|
|
|
{
|
2011-05-04 03:09:59 -07:00
|
|
|
Elm_Win *win = data;
|
2011-05-07 01:37:47 -07:00
|
|
|
|
2011-09-06 18:41:19 -07:00
|
|
|
if (!win->show_count) win->show_count++;
|
2011-05-04 03:09:59 -07:00
|
|
|
if (win->shot.info) _shot_handle(win);
|
2010-10-21 11:58:43 -07:00
|
|
|
}
|
|
|
|
|
2008-09-29 23:58:56 -07:00
|
|
|
static void
|
2011-04-14 03:48:43 -07:00
|
|
|
_elm_win_obj_callback_hide(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
|
|
|
|
{
|
|
|
|
Elm_Win *win = data;
|
2011-04-14 04:43:43 -07:00
|
|
|
|
2011-04-14 03:48:43 -07:00
|
|
|
if (win->frame_obj)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
else if (win->img_obj)
|
|
|
|
{
|
|
|
|
evas_object_hide(win->img_obj);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_win_obj_callback_del(void *data, Evas *e, 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);
|
2011-04-14 03:48:43 -07:00
|
|
|
if (win->ee)
|
|
|
|
{
|
|
|
|
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);
|
2011-05-04 03:09:59 -07:00
|
|
|
if (win->shot.info) eina_stringshare_del(win->shot.info);
|
|
|
|
if (win->shot.timer) ecore_timer_del(win->shot.timer);
|
2011-10-02 21:12:40 -07:00
|
|
|
evas_object_event_callback_del_full(win->win_obj, EVAS_CALLBACK_DEL,
|
|
|
|
_elm_win_obj_callback_del, win);
|
2010-08-21 06:52:25 -07:00
|
|
|
while (((child = evas_object_bottom_get(win->evas))) &&
|
2011-04-01 04:20:18 -07:00
|
|
|
(child != obj))
|
2009-02-14 18:53:56 -08:00
|
|
|
{
|
2011-04-01 04:20:18 -07: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))) &&
|
2011-04-01 04:20:18 -07:00
|
|
|
(child != obj))
|
2009-02-14 18:53:56 -08:00
|
|
|
{
|
2011-04-01 04:20:18 -07: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
|
2011-04-01 04:20:18 -07:00
|
|
|
// FIXME: Why are we flushing edje on every window destroy ??
|
|
|
|
// edje_file_cache_flush();
|
|
|
|
// edje_collection_cache_flush();
|
|
|
|
// evas_image_cache_flush(win->evas);
|
|
|
|
// evas_font_cache_flush(win->evas);
|
|
|
|
// FIXME: we are in the del handler for the object and delete the canvas
|
|
|
|
// that lives under it from the handler... nasty. deferring doesn't help either
|
2011-03-09 22:35:33 -08:00
|
|
|
|
2011-04-14 03:48:43 -07:00
|
|
|
if (win->img_obj)
|
|
|
|
{
|
|
|
|
win->img_obj = NULL;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (win->ee)
|
|
|
|
{
|
|
|
|
ecore_job_add(_deferred_ecore_evas_free, win->ee);
|
|
|
|
_elm_win_deferred_free++;
|
|
|
|
}
|
|
|
|
}
|
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
|
|
|
edje_file_cache_flush();
|
|
|
|
edje_collection_cache_flush();
|
2010-10-22 18:00:46 -07:00
|
|
|
evas_image_cache_flush(e);
|
|
|
|
evas_font_cache_flush(e);
|
2011-04-01 04:20:18 -07:00
|
|
|
elm_exit();
|
2009-12-01 05:32:48 -08:00
|
|
|
}
|
2008-09-29 23:58:56 -07:00
|
|
|
}
|
2008-10-06 18:23:49 -07:00
|
|
|
|
2011-04-14 03:48:43 -07:00
|
|
|
static void
|
|
|
|
_elm_win_obj_callback_img_obj_del(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
|
|
|
|
{
|
|
|
|
Elm_Win *win = data;
|
|
|
|
if (!win->img_obj) return;
|
|
|
|
evas_object_event_callback_del_full
|
|
|
|
(win->img_obj, EVAS_CALLBACK_DEL, _elm_win_obj_callback_img_obj_del, win);
|
|
|
|
evas_object_del(win->img_obj);
|
|
|
|
}
|
|
|
|
|
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
|
2011-04-14 03:48:43 -07:00
|
|
|
_elm_win_obj_intercept_move(void *data, Evas_Object *obj, Evas_Coord x, Evas_Coord y)
|
2009-10-07 22:26:58 -07:00
|
|
|
{
|
2011-04-14 03:48:43 -07:00
|
|
|
Elm_Win *win = data;
|
2011-04-14 04:43:43 -07:00
|
|
|
|
2011-04-14 03:48:43 -07:00
|
|
|
if (win->img_obj)
|
|
|
|
{
|
2011-04-18 18:53:19 -07:00
|
|
|
if ((x != win->screen.x) || (y != win->screen.y))
|
|
|
|
{
|
|
|
|
win->screen.x = x;
|
|
|
|
win->screen.y = y;
|
2011-04-21 17:42:32 -07:00
|
|
|
evas_object_smart_callback_call(win->win_obj, SIG_MOVED, NULL);
|
2011-04-18 18:53:19 -07:00
|
|
|
}
|
2011-04-14 03:48:43 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
evas_object_move(obj, x, y);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_win_obj_intercept_show(void *data, Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Elm_Win *win = data;
|
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);
|
2011-04-14 03:48:43 -07:00
|
|
|
if (win->frame_obj)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
else if (win->img_obj)
|
|
|
|
{
|
|
|
|
evas_object_show(win->img_obj);
|
|
|
|
}
|
2009-10-07 22:26:58 -07:00
|
|
|
}
|
|
|
|
|
2011-03-23 06:29:26 -07:00
|
|
|
static void
|
|
|
|
_elm_win_obj_callback_move(void *data, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
|
|
|
|
{
|
|
|
|
Elm_Win *win = data;
|
2011-04-01 04:20:18 -07:00
|
|
|
|
2011-03-23 06:29:26 -07:00
|
|
|
if (ecore_evas_override_get(win->ee))
|
|
|
|
{
|
|
|
|
Evas_Coord x, y;
|
2011-04-01 04:20:18 -07:00
|
|
|
|
2011-03-23 06:29:26 -07:00
|
|
|
evas_object_geometry_get(obj, &x, &y, NULL, NULL);
|
|
|
|
win->screen.x = x;
|
|
|
|
win->screen.y = y;
|
2011-04-21 17:42:32 -07:00
|
|
|
evas_object_smart_callback_call(win->win_obj, SIG_MOVED, NULL);
|
2011-03-23 06:29:26 -07:00
|
|
|
}
|
2011-04-14 03:48:43 -07:00
|
|
|
if (win->frame_obj)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
else if (win->img_obj)
|
|
|
|
{
|
|
|
|
Evas_Coord x, y;
|
2011-04-14 04:43:43 -07:00
|
|
|
|
2011-04-14 03:48:43 -07:00
|
|
|
evas_object_geometry_get(obj, &x, &y, NULL, NULL);
|
|
|
|
win->screen.x = x;
|
|
|
|
win->screen.y = y;
|
|
|
|
// evas_object_move(win->img_obj, x, y);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_win_obj_callback_resize(void *data, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
|
|
|
|
{
|
|
|
|
Elm_Win *win = data;
|
|
|
|
|
|
|
|
if (win->frame_obj)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
else if (win->img_obj)
|
|
|
|
{
|
|
|
|
Evas_Coord w = 1, h = 1;
|
|
|
|
|
|
|
|
evas_object_geometry_get(obj, NULL, NULL, &w, &h);
|
|
|
|
if (w < 1) w = 1;
|
|
|
|
if (h < 1) h = 1;
|
|
|
|
evas_object_image_size_set(win->img_obj, w, h);
|
|
|
|
}
|
2011-03-23 06:29:26 -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;
|
2011-06-10 00:08:34 -07:00
|
|
|
evas_object_ref(win->win_obj);
|
2011-04-21 17:42:32 -07:00
|
|
|
evas_object_smart_callback_call(win->win_obj, SIG_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;
|
2011-06-10 00:08:34 -07:00
|
|
|
evas_object_unref(win->win_obj);
|
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);
|
2011-04-14 03:48:43 -07:00
|
|
|
if (win->frame_obj)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
else if (win->img_obj)
|
|
|
|
{
|
|
|
|
}
|
2009-02-25 11:50:45 -08:00
|
|
|
EINA_LIST_FOREACH(win->subobjs, l, obj)
|
2008-09-29 23:58:56 -07:00
|
|
|
{
|
2011-04-01 04:20:18 -07: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;
|
2010-11-01 14:10:07 -07:00
|
|
|
|
|
|
|
#define ENGINE_COMPARE(name) (!strcmp(_elm_config->engine, name))
|
|
|
|
if (ENGINE_COMPARE(ELM_SOFTWARE_X11))
|
|
|
|
{
|
|
|
|
if (win->ee) win->xwin = ecore_evas_software_x11_window_get(win->ee);
|
|
|
|
}
|
|
|
|
else if (ENGINE_COMPARE(ELM_SOFTWARE_X11) ||
|
|
|
|
ENGINE_COMPARE(ELM_SOFTWARE_FB) ||
|
|
|
|
ENGINE_COMPARE(ELM_SOFTWARE_16_WINCE) ||
|
|
|
|
ENGINE_COMPARE(ELM_SOFTWARE_SDL) ||
|
|
|
|
ENGINE_COMPARE(ELM_SOFTWARE_16_SDL) ||
|
|
|
|
ENGINE_COMPARE(ELM_OPENGL_SDL))
|
|
|
|
{
|
|
|
|
}
|
|
|
|
else if (ENGINE_COMPARE(ELM_SOFTWARE_16_X11))
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
if (win->ee) win->xwin = ecore_evas_software_x11_16_window_get(win->ee);
|
2010-11-01 14:10:07 -07:00
|
|
|
}
|
|
|
|
else if (ENGINE_COMPARE(ELM_SOFTWARE_8_X11))
|
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
if (win->ee) win->xwin = ecore_evas_software_x11_8_window_get(win->ee);
|
2010-11-01 14:10:07 -07:00
|
|
|
}
|
2011-05-07 01:37:47 -07:00
|
|
|
/* killed
|
2010-11-01 14:10:07 -07:00
|
|
|
else if (ENGINE_COMPARE(ELM_XRENDER_X11))
|
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
if (win->ee) win->xwin = ecore_evas_xrender_x11_window_get(win->ee);
|
2010-11-01 14:10:07 -07:00
|
|
|
}
|
2011-05-04 03:09:59 -07:00
|
|
|
*/
|
2010-11-01 14:10:07 -07:00
|
|
|
else if (ENGINE_COMPARE(ELM_OPENGL_X11))
|
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
if (win->ee) win->xwin = ecore_evas_gl_x11_window_get(win->ee);
|
2010-11-01 14:10:07 -07:00
|
|
|
}
|
|
|
|
else if (ENGINE_COMPARE(ELM_SOFTWARE_WIN32))
|
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
if (win->ee) win->xwin = (long)ecore_evas_win32_window_get(win->ee);
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
2010-11-01 14:10:07 -07:00
|
|
|
#undef ENGINE_COMPARE
|
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)
|
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
Elm_Win *win2;
|
|
|
|
|
|
|
|
win2 = elm_widget_data_get(win->parent);
|
|
|
|
if (win2)
|
|
|
|
{
|
|
|
|
if (win->xwin)
|
|
|
|
ecore_x_icccm_transient_for_set(win->xwin, win2->xwin);
|
|
|
|
}
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
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:
|
2011-04-01 04:20:18 -07:00
|
|
|
ecore_x_netwm_window_type_set(win->xwin, ECORE_X_WINDOW_TYPE_NORMAL);
|
|
|
|
break;
|
2009-04-14 19:08:07 -07:00
|
|
|
case ELM_WIN_DIALOG_BASIC:
|
2011-04-01 04:20:18 -07:00
|
|
|
ecore_x_netwm_window_type_set(win->xwin, ECORE_X_WINDOW_TYPE_DIALOG);
|
|
|
|
break;
|
2009-04-14 19:08:07 -07:00
|
|
|
case ELM_WIN_DESKTOP:
|
2011-04-01 04:20:18 -07:00
|
|
|
ecore_x_netwm_window_type_set(win->xwin, ECORE_X_WINDOW_TYPE_DESKTOP);
|
|
|
|
break;
|
2009-04-14 19:08:07 -07:00
|
|
|
case ELM_WIN_DOCK:
|
2011-04-01 04:20:18 -07:00
|
|
|
ecore_x_netwm_window_type_set(win->xwin, ECORE_X_WINDOW_TYPE_DOCK);
|
|
|
|
break;
|
2009-04-14 19:08:07 -07:00
|
|
|
case ELM_WIN_TOOLBAR:
|
2011-04-01 04:20:18 -07:00
|
|
|
ecore_x_netwm_window_type_set(win->xwin, ECORE_X_WINDOW_TYPE_TOOLBAR);
|
|
|
|
break;
|
2009-04-14 19:08:07 -07:00
|
|
|
case ELM_WIN_MENU:
|
2011-04-01 04:20:18 -07:00
|
|
|
ecore_x_netwm_window_type_set(win->xwin, ECORE_X_WINDOW_TYPE_MENU);
|
|
|
|
break;
|
2009-04-14 19:08:07 -07:00
|
|
|
case ELM_WIN_UTILITY:
|
2011-04-01 04:20:18 -07:00
|
|
|
ecore_x_netwm_window_type_set(win->xwin, ECORE_X_WINDOW_TYPE_UTILITY);
|
|
|
|
break;
|
2009-04-14 19:08:07 -07:00
|
|
|
case ELM_WIN_SPLASH:
|
2011-04-01 04:20:18 -07:00
|
|
|
ecore_x_netwm_window_type_set(win->xwin, ECORE_X_WINDOW_TYPE_SPLASH);
|
|
|
|
break;
|
2011-03-22 08:46:52 -07:00
|
|
|
case ELM_WIN_DROPDOWN_MENU:
|
2011-04-01 04:20:18 -07:00
|
|
|
ecore_x_netwm_window_type_set(win->xwin, ECORE_X_WINDOW_TYPE_DROPDOWN_MENU);
|
|
|
|
break;
|
2011-03-22 08:46:52 -07:00
|
|
|
case ELM_WIN_POPUP_MENU:
|
2011-04-01 04:20:18 -07:00
|
|
|
ecore_x_netwm_window_type_set(win->xwin, ECORE_X_WINDOW_TYPE_POPUP_MENU);
|
|
|
|
break;
|
2011-03-22 08:46:52 -07:00
|
|
|
case ELM_WIN_TOOLTIP:
|
2011-04-01 04:20:18 -07:00
|
|
|
ecore_x_netwm_window_type_set(win->xwin, ECORE_X_WINDOW_TYPE_TOOLTIP);
|
|
|
|
break;
|
2011-03-22 08:46:52 -07:00
|
|
|
case ELM_WIN_NOTIFICATION:
|
2011-04-01 04:20:18 -07:00
|
|
|
ecore_x_netwm_window_type_set(win->xwin, ECORE_X_WINDOW_TYPE_NOTIFICATION);
|
|
|
|
break;
|
2011-03-22 08:46:52 -07:00
|
|
|
case ELM_WIN_COMBO:
|
2011-04-01 04:20:18 -07:00
|
|
|
ecore_x_netwm_window_type_set(win->xwin, ECORE_X_WINDOW_TYPE_COMBO);
|
|
|
|
break;
|
2011-03-22 08:46:52 -07:00
|
|
|
case ELM_WIN_DND:
|
2011-04-01 04:20:18 -07:00
|
|
|
ecore_x_netwm_window_type_set(win->xwin, ECORE_X_WINDOW_TYPE_DND);
|
|
|
|
break;
|
2009-04-14 19:08:07 -07:00
|
|
|
default:
|
2011-04-01 04:20:18 -07:00
|
|
|
break;
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
2009-04-14 19:08:07 -07:00
|
|
|
ecore_x_e_virtual_keyboard_state_set
|
2011-04-01 04:20:18 -07: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
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
evas_object_size_hint_weight_get(child, &wx, &wy);
|
|
|
|
if (wx == 0.0) xx = 0;
|
|
|
|
if (wy == 0.0) xy = 0;
|
|
|
|
|
|
|
|
evas_object_size_hint_min_get(child, &w, &h);
|
2011-08-01 05:19:36 -07:00
|
|
|
if (w < 1) w = 1;
|
|
|
|
if (h < 1) h = 1;
|
2011-04-01 04:20:18 -07:00
|
|
|
if (w > minw) minw = w;
|
|
|
|
if (h > minh) minh = h;
|
|
|
|
|
|
|
|
evas_object_size_hint_max_get(child, &w, &h);
|
|
|
|
if (w < 1) w = -1;
|
|
|
|
if (h < 1) h = -1;
|
|
|
|
if (maxw == -1) maxw = w;
|
|
|
|
else if ((w > 0) && (w < maxw)) maxw = w;
|
|
|
|
if (maxh == -1) maxh = h;
|
|
|
|
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
|
2010-11-05 01:37:31 -07:00
|
|
|
_elm_win_rescale(Elm_Theme *th, Eina_Bool use_theme)
|
2008-11-14 22:09:04 -08:00
|
|
|
{
|
2009-02-25 11:50:45 -08:00
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *obj;
|
2009-11-14 17:51:39 -08:00
|
|
|
|
2010-11-05 01:37:31 -07:00
|
|
|
if (!use_theme)
|
|
|
|
{
|
|
|
|
EINA_LIST_FOREACH(_elm_win_list, l, obj)
|
|
|
|
elm_widget_theme(obj);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
EINA_LIST_FOREACH(_elm_win_list, l, obj)
|
|
|
|
elm_widget_theme_specific(obj, th, EINA_FALSE);
|
|
|
|
}
|
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,
|
2011-04-01 04:20:18 -07:00
|
|
|
_elm_win_focus_target_move, 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
|
|
|
evas_object_event_callback_add(obj, EVAS_CALLBACK_RESIZE,
|
2011-04-01 04:20:18 -07:00
|
|
|
_elm_win_focus_target_resize, 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
|
|
|
evas_object_event_callback_add(obj, EVAS_CALLBACK_DEL,
|
2011-04-01 04:20:18 -07:00
|
|
|
_elm_win_focus_target_del, 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
|
|
|
}
|
|
|
|
|
|
|
|
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,
|
2011-04-01 04:20:18 -07:00
|
|
|
_elm_win_focus_target_move, 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
|
|
|
evas_object_event_callback_del_full(obj, EVAS_CALLBACK_RESIZE,
|
2011-04-01 04:20:18 -07:00
|
|
|
_elm_win_focus_target_resize, 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
|
|
|
evas_object_event_callback_del_full(obj, EVAS_CALLBACK_DEL,
|
2011-04-01 04:20:18 -07:00
|
|
|
_elm_win_focus_target_del, 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
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2011-04-01 04:20:18 -07:00
|
|
|
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);
|
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_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)
|
2011-04-01 04:20:18 -07:00
|
|
|
return;
|
2010-10-20 05:38:30 -07:00
|
|
|
|
|
|
|
|
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
|
|
|
|
|
2011-04-14 05:47:16 -07:00
|
|
|
static void
|
|
|
|
_win_img_hide(void *data,
|
|
|
|
Evas *e __UNUSED__,
|
|
|
|
Evas_Object *obj __UNUSED__,
|
|
|
|
void *event_info __UNUSED__)
|
|
|
|
{
|
|
|
|
Elm_Win *win = data;
|
2011-04-20 07:16:51 -07:00
|
|
|
|
2011-04-14 05:47:16 -07:00
|
|
|
elm_widget_focus_hide_handle(win->win_obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-08-08 03:32:32 -07:00
|
|
|
_win_img_mouse_up(void *data,
|
|
|
|
Evas *e __UNUSED__,
|
|
|
|
Evas_Object *obj __UNUSED__,
|
|
|
|
void *event_info)
|
2011-04-14 05:47:16 -07:00
|
|
|
{
|
|
|
|
Elm_Win *win = data;
|
2011-08-08 03:32:32 -07:00
|
|
|
Evas_Event_Mouse_Up *ev = event_info;
|
|
|
|
if (!(ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD))
|
|
|
|
elm_widget_focus_mouse_up_handle(win->win_obj);
|
2011-04-14 05:47:16 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_win_img_focus_in(void *data,
|
|
|
|
Evas *e __UNUSED__,
|
|
|
|
Evas_Object *obj __UNUSED__,
|
|
|
|
void *event_info __UNUSED__)
|
|
|
|
{
|
|
|
|
Elm_Win *win = data;
|
|
|
|
elm_widget_focus_steal(win->win_obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_win_img_focus_out(void *data,
|
|
|
|
Evas *e __UNUSED__,
|
|
|
|
Evas_Object *obj __UNUSED__,
|
|
|
|
void *event_info __UNUSED__)
|
|
|
|
{
|
|
|
|
Elm_Win *win = data;
|
|
|
|
elm_widget_focused_object_clear(win->win_obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_win_inlined_image_set(Elm_Win *win)
|
|
|
|
{
|
|
|
|
evas_object_image_alpha_set(win->img_obj, EINA_FALSE);
|
|
|
|
evas_object_image_filled_set(win->img_obj, EINA_TRUE);
|
|
|
|
evas_object_event_callback_add(win->img_obj, EVAS_CALLBACK_DEL,
|
|
|
|
_elm_win_obj_callback_img_obj_del, win);
|
2011-04-20 07:16:51 -07:00
|
|
|
|
2011-04-14 05:47:16 -07:00
|
|
|
evas_object_event_callback_add(win->img_obj, EVAS_CALLBACK_HIDE,
|
|
|
|
_win_img_hide, win);
|
2011-08-08 03:32:32 -07:00
|
|
|
evas_object_event_callback_add(win->img_obj, EVAS_CALLBACK_MOUSE_UP,
|
|
|
|
_win_img_mouse_up, win);
|
2011-04-14 05:47:16 -07:00
|
|
|
evas_object_event_callback_add(win->img_obj, EVAS_CALLBACK_FOCUS_IN,
|
|
|
|
_win_img_focus_in, win);
|
|
|
|
evas_object_event_callback_add(win->img_obj, EVAS_CALLBACK_FOCUS_OUT,
|
|
|
|
_win_img_focus_out, 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);
|
2010-11-01 14:10:07 -07:00
|
|
|
|
2011-10-15 02:48:34 -07:00
|
|
|
#define FALLBACK_TRY(engine) \
|
|
|
|
if (!win->ee) \
|
|
|
|
do { \
|
|
|
|
CRITICAL(engine " engine creation failed. Trying default."); \
|
|
|
|
win->ee = ecore_evas_new(NULL, 0, 0, 1, 1, NULL); \
|
|
|
|
if (win->ee) \
|
|
|
|
elm_engine_set(ecore_evas_engine_name_get(win->ee)); \
|
2011-04-01 04:20:18 -07:00
|
|
|
} while (0)
|
2010-11-01 14:10:07 -07:00
|
|
|
#define ENGINE_COMPARE(name) (!strcmp(_elm_config->engine, name))
|
2011-04-14 03:48:43 -07:00
|
|
|
|
|
|
|
switch (type)
|
2008-09-29 23:58:56 -07:00
|
|
|
{
|
2011-04-14 03:48:43 -07:00
|
|
|
case ELM_WIN_INLINED_IMAGE:
|
2011-07-23 10:27:39 -07:00
|
|
|
if (!parent) break;
|
|
|
|
{
|
|
|
|
Evas *e = evas_object_evas_get(parent);
|
|
|
|
Ecore_Evas *ee;
|
|
|
|
if (!e) break;
|
|
|
|
ee = ecore_evas_ecore_evas_get(e);
|
|
|
|
if (!ee) break;
|
|
|
|
win->img_obj = ecore_evas_object_image_new(ee);
|
|
|
|
if (!win->img_obj) break;
|
|
|
|
win->ee = ecore_evas_object_ecore_evas_get(win->img_obj);
|
|
|
|
if (win->ee)
|
|
|
|
{
|
|
|
|
_win_inlined_image_set(win);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
evas_object_del(win->img_obj);
|
|
|
|
win->img_obj = NULL;
|
|
|
|
}
|
2011-04-14 03:48:43 -07:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (ENGINE_COMPARE(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
|
2011-04-14 03:48:43 -07:00
|
|
|
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
|
2011-10-15 02:48:34 -07:00
|
|
|
FALLBACK_TRY("Sofware X11");
|
2011-04-14 03:48:43 -07:00
|
|
|
}
|
|
|
|
else if (ENGINE_COMPARE(ELM_SOFTWARE_FB))
|
|
|
|
{
|
|
|
|
win->ee = ecore_evas_fb_new(NULL, 0, 1, 1);
|
|
|
|
FALLBACK_TRY("Sofware FB");
|
|
|
|
}
|
|
|
|
else if (ENGINE_COMPARE(ELM_SOFTWARE_DIRECTFB))
|
|
|
|
{
|
|
|
|
win->ee = ecore_evas_directfb_new(NULL, 1, 0, 0, 1, 1);
|
|
|
|
FALLBACK_TRY("Sofware DirectFB");
|
|
|
|
}
|
|
|
|
else if (ENGINE_COMPARE(ELM_SOFTWARE_16_X11))
|
|
|
|
{
|
|
|
|
win->ee = ecore_evas_software_x11_16_new(NULL, 0, 0, 0, 1, 1);
|
|
|
|
FALLBACK_TRY("Sofware-16");
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2011-04-14 03:48:43 -07:00
|
|
|
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
|
2010-11-01 14:10:07 -07:00
|
|
|
}
|
2011-04-14 03:48:43 -07:00
|
|
|
else if (ENGINE_COMPARE(ELM_SOFTWARE_8_X11))
|
|
|
|
{
|
|
|
|
win->ee = ecore_evas_software_x11_8_new(NULL, 0, 0, 0, 1, 1);
|
|
|
|
FALLBACK_TRY("Sofware-8");
|
2010-09-28 15:43:48 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2011-04-14 03:48:43 -07:00
|
|
|
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
|
2011-04-14 03:48:43 -07:00
|
|
|
}
|
2011-05-07 01:37:47 -07:00
|
|
|
/* killed
|
2011-04-14 03:48:43 -07:00
|
|
|
else if (ENGINE_COMPARE(ELM_XRENDER_X11))
|
|
|
|
{
|
|
|
|
win->ee = ecore_evas_xrender_x11_new(NULL, 0, 0, 0, 1, 1);
|
|
|
|
FALLBACK_TRY("XRender");
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2011-04-14 03:48:43 -07:00
|
|
|
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
|
2011-04-14 03:48:43 -07:00
|
|
|
}
|
2011-05-04 03:09:59 -07:00
|
|
|
*/
|
2011-04-14 03:48:43 -07:00
|
|
|
else if (ENGINE_COMPARE(ELM_OPENGL_X11))
|
|
|
|
{
|
2011-05-11 02:06:59 -07:00
|
|
|
int opt[10];
|
|
|
|
int opt_i = 0;
|
2011-05-12 19:50:00 -07:00
|
|
|
|
2011-05-11 02:06:59 -07:00
|
|
|
if (_elm_config->vsync)
|
|
|
|
{
|
|
|
|
opt[opt_i] = ECORE_EVAS_GL_X11_OPT_VSYNC;
|
|
|
|
opt_i++;
|
|
|
|
opt[opt_i] = 1;
|
|
|
|
opt_i++;
|
|
|
|
}
|
|
|
|
if (opt_i > 0)
|
|
|
|
win->ee = ecore_evas_gl_x11_options_new(NULL, 0, 0, 0, 1, 1, opt);
|
|
|
|
else
|
|
|
|
win->ee = ecore_evas_gl_x11_new(NULL, 0, 0, 0, 1, 1);
|
2011-04-14 03:48:43 -07:00
|
|
|
FALLBACK_TRY("OpenGL");
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2011-04-14 03:48:43 -07:00
|
|
|
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
|
2011-04-14 03:48:43 -07:00
|
|
|
}
|
|
|
|
else if (ENGINE_COMPARE(ELM_SOFTWARE_WIN32))
|
|
|
|
{
|
|
|
|
win->ee = ecore_evas_software_gdi_new(NULL, 0, 0, 1, 1);
|
|
|
|
FALLBACK_TRY("Sofware Win32");
|
|
|
|
}
|
|
|
|
else if (ENGINE_COMPARE(ELM_SOFTWARE_16_WINCE))
|
|
|
|
{
|
|
|
|
win->ee = ecore_evas_software_wince_gdi_new(NULL, 0, 0, 1, 1);
|
|
|
|
FALLBACK_TRY("Sofware-16-WinCE");
|
|
|
|
}
|
|
|
|
else if (ENGINE_COMPARE(ELM_SOFTWARE_SDL))
|
|
|
|
{
|
|
|
|
win->ee = ecore_evas_sdl_new(NULL, 0, 0, 0, 0, 0, 1);
|
|
|
|
FALLBACK_TRY("Sofware SDL");
|
|
|
|
}
|
|
|
|
else if (ENGINE_COMPARE(ELM_SOFTWARE_16_SDL))
|
|
|
|
{
|
|
|
|
win->ee = ecore_evas_sdl16_new(NULL, 0, 0, 0, 0, 0, 1);
|
|
|
|
FALLBACK_TRY("Sofware-16-SDL");
|
|
|
|
}
|
|
|
|
else if (ENGINE_COMPARE(ELM_OPENGL_SDL))
|
|
|
|
{
|
|
|
|
win->ee = ecore_evas_gl_sdl_new(NULL, 1, 1, 0, 0);
|
|
|
|
FALLBACK_TRY("OpenGL SDL");
|
|
|
|
}
|
2011-07-25 05:02:52 -07:00
|
|
|
else if (ENGINE_COMPARE(ELM_BUFFER))
|
|
|
|
{
|
|
|
|
win->ee = ecore_evas_buffer_new(1, 1);
|
|
|
|
}
|
2011-10-05 15:18:22 -07:00
|
|
|
else if (ENGINE_COMPARE(ELM_EWS))
|
|
|
|
{
|
|
|
|
win->ee = ecore_evas_ews_new(0, 0, 1, 1);
|
|
|
|
}
|
2011-05-04 03:09:59 -07:00
|
|
|
else if (!strncmp(_elm_config->engine, "shot:", 5))
|
|
|
|
{
|
|
|
|
win->ee = ecore_evas_buffer_new(1, 1);
|
|
|
|
ecore_evas_manual_render_set(win->ee, EINA_TRUE);
|
|
|
|
win->shot.info = eina_stringshare_add(_elm_config->engine + 5);
|
2011-07-05 01:17:39 -07:00
|
|
|
_shot_init(win);
|
2011-05-04 03:09:59 -07:00
|
|
|
}
|
2010-11-01 14:10:21 -07:00
|
|
|
#undef FALLBACK_TRY
|
2011-04-14 03:48:43 -07:00
|
|
|
break;
|
|
|
|
}
|
2011-04-14 04:43:43 -07:00
|
|
|
|
2008-09-29 23:58:56 -07:00
|
|
|
if (!win->ee)
|
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
ERR("Cannot create window.");
|
|
|
|
free(win);
|
|
|
|
return NULL;
|
2008-09-29 23:58:56 -07:00
|
|
|
}
|
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);
|
2011-04-01 04:20:18 -07:00
|
|
|
// bg pixmap done by x - has other issues like can be redrawn by x before it
|
|
|
|
// is filled/ready by app
|
|
|
|
// 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
|
|
|
|
2011-08-02 03:34:30 -07:00
|
|
|
if (type == ELM_WIN_INLINED_IMAGE)
|
2011-08-13 09:36:44 -07:00
|
|
|
elm_widget_parent2_set(win->win_obj, parent);
|
2008-12-19 06:32:59 -08:00
|
|
|
ecore_evas_object_associate(win->ee, win->win_obj,
|
2011-04-01 04:20:18 -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,
|
2011-04-01 04:20:18 -07:00
|
|
|
_elm_win_obj_callback_show, win);
|
2011-04-14 03:48:43 -07:00
|
|
|
evas_object_event_callback_add(win->win_obj, EVAS_CALLBACK_HIDE,
|
|
|
|
_elm_win_obj_callback_hide, win);
|
2008-12-19 06:32:59 -08:00
|
|
|
evas_object_event_callback_add(win->win_obj, EVAS_CALLBACK_DEL,
|
2011-04-01 04:20:18 -07:00
|
|
|
_elm_win_obj_callback_del, win);
|
2011-03-23 06:29:26 -07:00
|
|
|
evas_object_event_callback_add(win->win_obj, EVAS_CALLBACK_MOVE,
|
2011-04-01 04:20:18 -07:00
|
|
|
_elm_win_obj_callback_move, win);
|
2011-04-14 03:48:43 -07:00
|
|
|
evas_object_event_callback_add(win->win_obj, EVAS_CALLBACK_RESIZE,
|
|
|
|
_elm_win_obj_callback_resize, win);
|
2011-04-18 18:53:19 -07:00
|
|
|
if (win->img_obj)
|
2011-08-13 09:36:44 -07:00
|
|
|
evas_object_intercept_move_callback_add(win->win_obj,
|
|
|
|
_elm_win_obj_intercept_move, win);
|
2011-04-18 18:53:19 -07:00
|
|
|
evas_object_intercept_show_callback_add(win->win_obj,
|
|
|
|
_elm_win_obj_intercept_show, win);
|
2009-07-06 23:46:51 -07:00
|
|
|
|
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)
|
2011-08-13 09:36:44 -07:00
|
|
|
evas_font_path_append(win->evas, fontpath);
|
2010-10-22 14:41:27 -07:00
|
|
|
if (!_elm_config->font_hinting)
|
2009-02-03 02:27:52 -08:00
|
|
|
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
|
|
|
|
2010-11-01 14:10:07 -07:00
|
|
|
if (ENGINE_COMPARE(ELM_SOFTWARE_FB))
|
2008-12-09 22:33:24 -08:00
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
ecore_evas_fullscreen_set(win->ee, 1);
|
2008-12-09 22:33:24 -08:00
|
|
|
}
|
2010-11-01 14:10:07 -07:00
|
|
|
#undef ENGINE_COMPARE
|
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);
|
2011-04-14 04:43:43 -07:00
|
|
|
|
2011-04-14 03:48:43 -07:00
|
|
|
Eina_Bool ret = evas_object_key_grab(win->win_obj, "F12", mask, 0,
|
|
|
|
EINA_TRUE);
|
2011-08-23 15:44:57 -07:00
|
|
|
printf("Ctrl+F12 key combination exclusive for dot tree generation\n");
|
2010-10-20 05:38:30 -07:00
|
|
|
#endif
|
2011-04-21 17:42:32 -07:00
|
|
|
|
|
|
|
evas_object_smart_callbacks_descriptions_set(win->win_obj, _signals);
|
|
|
|
|
2008-10-06 18:23:49 -07:00
|
|
|
return win->win_obj;
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
2011-05-22 18:24:43 -07:00
|
|
|
if (eina_list_data_find(win->subobjs, subobj)) 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);
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
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-10-27 07:38:37 -07:00
|
|
|
EAPI const char *
|
|
|
|
elm_win_title_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Elm_Win *win;
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return NULL;
|
|
|
|
return ecore_evas_title_get(win->ee);
|
|
|
|
}
|
|
|
|
|
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-10-27 07:38:37 -07:00
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_win_autodel_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Elm_Win *win;
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
|
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return EINA_FALSE;
|
|
|
|
return win->autodel;
|
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
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;
|
2011-04-14 03:48:43 -07:00
|
|
|
if (win->frame_obj)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
else if (win->img_obj)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
2011-04-14 03:48:43 -07:00
|
|
|
evas_object_image_alpha_set(win->img_obj, alpha);
|
2011-10-14 00:30:52 -07:00
|
|
|
ecore_evas_alpha_set(win->ee, alpha);
|
2011-04-14 03:48:43 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
if (win->xwin)
|
2011-04-01 04:20:18 -07:00
|
|
|
{
|
2011-04-14 03:48:43 -07:00
|
|
|
if (alpha)
|
|
|
|
{
|
|
|
|
if (!_elm_config->compositing)
|
|
|
|
elm_win_shaped_set(obj, alpha);
|
|
|
|
else
|
|
|
|
ecore_evas_alpha_set(win->ee, alpha);
|
|
|
|
}
|
2011-04-01 04:20:18 -07:00
|
|
|
else
|
2011-04-14 03:48:43 -07:00
|
|
|
ecore_evas_alpha_set(win->ee, alpha);
|
|
|
|
_elm_win_xwin_update(win);
|
2011-04-01 04:20:18 -07:00
|
|
|
}
|
|
|
|
else
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2011-04-14 03:48:43 -07:00
|
|
|
ecore_evas_alpha_set(win->ee, alpha);
|
|
|
|
}
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
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;
|
2011-10-14 00:30:52 -07:00
|
|
|
if (win->frame_obj)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
else if (win->img_obj)
|
|
|
|
{
|
|
|
|
return evas_object_image_alpha_get(win->img_obj);
|
|
|
|
}
|
2009-10-12 02:09:55 -07:00
|
|
|
return ecore_evas_alpha_get(win->ee);
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
2011-04-14 03:48:43 -07:00
|
|
|
if (win->frame_obj)
|
2010-02-11 21:31:26 -08:00
|
|
|
{
|
2011-04-14 03:48:43 -07:00
|
|
|
}
|
|
|
|
else if (win->img_obj)
|
|
|
|
{
|
|
|
|
evas_object_image_alpha_set(win->img_obj, transparent);
|
2010-02-11 21:31:26 -08:00
|
|
|
}
|
|
|
|
else
|
2011-04-14 03:48:43 -07:00
|
|
|
{
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
if (win->xwin)
|
|
|
|
{
|
|
|
|
ecore_evas_transparent_set(win->ee, transparent);
|
|
|
|
_elm_win_xwin_update(win);
|
|
|
|
}
|
|
|
|
else
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2011-04-14 03:48:43 -07:00
|
|
|
ecore_evas_transparent_set(win->ee, transparent);
|
|
|
|
}
|
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);
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
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;
|
2010-11-01 14:10:07 -07:00
|
|
|
|
2011-04-14 03:48:43 -07:00
|
|
|
// YYY: handle if win->img_obj
|
2010-11-01 14:10:07 -07:00
|
|
|
#define ENGINE_COMPARE(name) (!strcmp(_elm_config->engine, name))
|
|
|
|
if (ENGINE_COMPARE(ELM_SOFTWARE_FB) ||
|
|
|
|
ENGINE_COMPARE(ELM_SOFTWARE_16_WINCE))
|
2009-03-14 11:03:19 -07:00
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
// these engines... can ONLY be fullscreen
|
|
|
|
return;
|
2010-11-01 14:10:07 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
ecore_evas_fullscreen_set(win->ee, fullscreen);
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2011-04-01 04:20:18 -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-11-01 14:10:07 -07:00
|
|
|
#undef ENGINE_COMPARE
|
2009-03-12 22:50:38 -07:00
|
|
|
}
|
|
|
|
|
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;
|
2010-11-01 14:10:07 -07:00
|
|
|
|
|
|
|
#define ENGINE_COMPARE(name) (!strcmp(_elm_config->engine, name))
|
|
|
|
if (ENGINE_COMPARE(ELM_SOFTWARE_FB) ||
|
|
|
|
ENGINE_COMPARE(ELM_SOFTWARE_16_WINCE))
|
2009-10-12 02:09:55 -07:00
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
// these engines... can ONLY be fullscreen
|
|
|
|
return EINA_TRUE;
|
2010-11-01 14:10:07 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
return ecore_evas_fullscreen_get(win->ee);
|
2009-10-12 02:09:55 -07:00
|
|
|
}
|
2010-11-01 14:10:07 -07:00
|
|
|
#undef ENGINE_COMPARE
|
2009-10-12 02:09:55 -07:00
|
|
|
}
|
|
|
|
|
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;
|
2011-04-14 03:48:43 -07:00
|
|
|
// YYY: handle if win->img_obj
|
2009-03-12 22:50:38 -07:00
|
|
|
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
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
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-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
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
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
|
2011-04-01 04:20:18 -07:00
|
|
|
(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-10-27 07:38:37 -07:00
|
|
|
EAPI Elm_Win_Keyboard_Mode
|
|
|
|
elm_win_keyboard_mode_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Elm_Win *win;
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) ELM_WIN_KEYBOARD_UNKNOWN;
|
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return ELM_WIN_KEYBOARD_UNKNOWN;
|
|
|
|
return win->kbdmode;
|
|
|
|
}
|
|
|
|
|
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-10-27 07:38:37 -07:00
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_win_keyboard_win_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Elm_Win *win;
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
|
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return EINA_FALSE;
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
_elm_win_xwindow_get(win);
|
|
|
|
if (win->xwin)
|
|
|
|
return ecore_x_e_virtual_keyboard_get(win->xwin);
|
|
|
|
#endif
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
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-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-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-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-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-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-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-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-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-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
|
|
|
|
}
|
|
|
|
|
2010-10-27 07:38:37 -07:00
|
|
|
EAPI int
|
|
|
|
elm_win_quickpanel_zone_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Elm_Win *win;
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) 0;
|
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return 0;
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
_elm_win_xwindow_get(win);
|
|
|
|
if (win->xwin)
|
|
|
|
return ecore_x_e_illume_quickpanel_zone_get(win->xwin);
|
|
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-02-17 02:56:32 -08:00
|
|
|
EAPI void
|
|
|
|
elm_win_prop_focus_skip_set(Evas_Object *obj, Eina_Bool skip)
|
|
|
|
{
|
|
|
|
Elm_Win *win;
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return;
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
_elm_win_xwindow_get(win);
|
|
|
|
if (skip)
|
|
|
|
{
|
|
|
|
if (win->xwin)
|
|
|
|
{
|
|
|
|
Ecore_X_Window_State states[2];
|
2011-04-01 04:20:18 -07:00
|
|
|
|
2011-02-17 02:56:32 -08:00
|
|
|
ecore_x_icccm_hints_set(win->xwin, 0, 0, 0, 0, 0, 0, 0);
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_win_illume_command_send(Evas_Object *obj, Elm_Illume_Command command, void *params __UNUSED__)
|
|
|
|
{
|
|
|
|
Elm_Win *win;
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return;
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
_elm_win_xwindow_get(win);
|
|
|
|
if (win->xwin)
|
|
|
|
{
|
|
|
|
switch (command)
|
|
|
|
{
|
|
|
|
case ELM_ILLUME_COMMAND_FOCUS_BACK:
|
2011-04-01 04:20:18 -07:00
|
|
|
ecore_x_e_illume_focus_back_send(win->xwin);
|
|
|
|
break;
|
2011-02-17 02:56:32 -08:00
|
|
|
case ELM_ILLUME_COMMAND_FOCUS_FORWARD:
|
2011-04-01 04:20:18 -07:00
|
|
|
ecore_x_e_illume_focus_forward_send(win->xwin);
|
|
|
|
break;
|
2011-02-17 02:56:32 -08:00
|
|
|
case ELM_ILLUME_COMMAND_FOCUS_HOME:
|
2011-04-01 04:20:18 -07:00
|
|
|
ecore_x_e_illume_focus_home_send(win->xwin);
|
|
|
|
break;
|
2011-02-17 02:56:32 -08:00
|
|
|
case ELM_ILLUME_COMMAND_CLOSE:
|
2011-04-01 04:20:18 -07:00
|
|
|
ecore_x_e_illume_close_send(win->xwin);
|
|
|
|
break;
|
2011-02-17 02:56:32 -08:00
|
|
|
default:
|
2011-04-01 04:20:18 -07:00
|
|
|
break;
|
2011-02-17 02:56:32 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2011-04-14 03:48:43 -07:00
|
|
|
EAPI Evas_Object *
|
|
|
|
elm_win_inlined_image_object_get(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Elm_Win *win;
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
|
|
|
win = elm_widget_data_get(obj);
|
|
|
|
if (!win) return NULL;
|
|
|
|
return win->img_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
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
2011-09-13 19:09:05 -07:00
|
|
|
|
|
|
|
evas_object_smart_callback_call(obj, SIG_THEME_CHANGED, NULL);
|
2008-12-30 08:19:46 -08:00
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
|
2010-12-09 05:07:43 -08:00
|
|
|
if (!wd)
|
2010-10-01 12:02:58 -07:00
|
|
|
return EINA_FALSE;
|
|
|
|
|
|
|
|
/* Try Focus cycle in subitem */
|
2010-12-09 05:07:43 -08:00
|
|
|
if (wd->content)
|
|
|
|
{
|
|
|
|
elm_widget_focus_next_get(wd->content, dir, next);
|
|
|
|
if (*next)
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
*next = (Evas_Object *)obj;
|
2010-10-06 13:24:09 -07:00
|
|
|
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)
|
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
evas_object_event_callback_del_full
|
|
|
|
(sub, EVAS_CALLBACK_CHANGED_SIZE_HINTS, _changed_size_hints, obj);
|
|
|
|
wd->content = NULL;
|
|
|
|
_sizing_eval(obj);
|
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-12-09 05:07:43 -08:00
|
|
|
elm_widget_can_focus_set(obj2, EINA_TRUE);
|
|
|
|
elm_widget_highlight_ignore_set(obj2, EINA_TRUE);
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
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");
|
2011-08-03 04:46:23 -07:00
|
|
|
elm_object_focus_set(obj, EINA_TRUE);
|
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)
|
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
elm_widget_sub_object_add(obj, content);
|
|
|
|
evas_object_event_callback_add(content, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
|
|
|
|
_changed_size_hints, obj);
|
|
|
|
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
|
|
|
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
|
|
|
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? */
|
2011-04-14 03:48:43 -07:00
|
|
|
|
|
|
|
static Ecore_X_Window
|
|
|
|
_elm_ee_win_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
if (!obj) return 0;
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
Ecore_Evas *ee = ecore_evas_ecore_evas_get(evas_object_evas_get(obj));
|
|
|
|
if (ee) return (Ecore_X_Window)ecore_evas_window_get(ee);
|
|
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
{
|
2011-04-14 03:48:43 -07:00
|
|
|
Elm_Win *win;
|
|
|
|
const char *type;
|
2011-04-14 04:43:43 -07:00
|
|
|
|
2010-03-08 23:30:48 -08:00
|
|
|
if (!obj) return 0;
|
2011-04-14 06:51:12 -07:00
|
|
|
type = elm_widget_type_get(obj);
|
2011-04-14 03:48:43 -07:00
|
|
|
if (!type) return 0;
|
|
|
|
if (type != widtype) return _elm_ee_win_get(obj);
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2011-04-14 03:48:43 -07:00
|
|
|
win = elm_widget_data_get(obj);
|
2011-07-31 23:49:58 -07:00
|
|
|
if (!win) return 0;
|
2011-04-14 06:51:12 -07:00
|
|
|
if (win->xwin) return win->xwin;
|
2011-04-14 03:48:43 -07:00
|
|
|
if (win->parent) return elm_win_xwindow_get(win->parent);
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2011-07-31 23:49:58 -07:00
|
|
|
return 0;
|
2011-04-14 03:48:43 -07:00
|
|
|
win = NULL;
|
2008-11-18 22:23:08 -08:00
|
|
|
}
|