2013-04-25 22:13:00 -07:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include "elementary_config.h"
|
|
|
|
#endif
|
|
|
|
|
2014-10-17 08:56:11 -07:00
|
|
|
#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
|
|
|
|
#define ELM_INTERFACE_ATSPI_WIDGET_ACTION_PROTECTED
|
2015-01-12 02:13:34 -08:00
|
|
|
#define ELM_WIN_PROTECTED
|
2014-10-17 08:56:11 -07:00
|
|
|
|
2012-01-12 01:10:27 -08:00
|
|
|
#include <Elementary.h>
|
2012-08-06 05:05:53 -07:00
|
|
|
#include <Elementary_Cursor.h>
|
2013-04-25 22:13:00 -07:00
|
|
|
|
2008-09-29 23:58:56 -07:00
|
|
|
#include "elm_priv.h"
|
2013-01-17 14:11:27 -08:00
|
|
|
#include "elm_widget_menu.h"
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2014-06-03 03:35:28 -07:00
|
|
|
#define MY_CLASS ELM_WIN_CLASS
|
2012-11-25 22:32:53 -08:00
|
|
|
|
2013-11-07 03:44:22 -08:00
|
|
|
#define MY_CLASS_NAME "Elm_Win"
|
|
|
|
#define MY_CLASS_NAME_LEGACY "elm_win"
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2012-07-18 21:35:50 -07:00
|
|
|
static const Elm_Win_Trap *trap = NULL;
|
|
|
|
|
|
|
|
#define TRAP(sd, name, ...) \
|
|
|
|
do \
|
|
|
|
{ \
|
2015-01-09 21:33:55 -08:00
|
|
|
if (sd->type != ELM_WIN_FAKE) \
|
|
|
|
if ((!trap) || (!trap->name) || \
|
|
|
|
((trap->name) && \
|
|
|
|
(trap->name(sd->trap_data, sd->obj, ## __VA_ARGS__)))) \
|
|
|
|
ecore_evas_##name(sd->ee, ##__VA_ARGS__); \
|
2012-07-18 21:35:50 -07:00
|
|
|
} \
|
|
|
|
while (0)
|
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
#define ELM_WIN_DATA_GET(o, sd) \
|
2014-03-27 06:15:52 -07:00
|
|
|
Elm_Win_Data * sd = eo_data_scope_get(o, MY_CLASS)
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
#define ELM_WIN_DATA_GET_OR_RETURN(o, ptr) \
|
|
|
|
ELM_WIN_DATA_GET(o, ptr); \
|
|
|
|
if (!ptr) \
|
|
|
|
{ \
|
2013-12-25 20:03:55 -08:00
|
|
|
CRI("No widget data for object %p (%s)", \
|
2012-05-03 15:42:15 -07:00
|
|
|
o, evas_object_type_get(o)); \
|
|
|
|
return; \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define ELM_WIN_DATA_GET_OR_RETURN_VAL(o, ptr, val) \
|
|
|
|
ELM_WIN_DATA_GET(o, ptr); \
|
|
|
|
if (!ptr) \
|
|
|
|
{ \
|
2013-12-25 20:03:55 -08:00
|
|
|
CRI("No widget data for object %p (%s)", \
|
2012-05-03 15:42:15 -07:00
|
|
|
o, evas_object_type_get(o)); \
|
|
|
|
return val; \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define ELM_WIN_CHECK(obj) \
|
2012-11-25 22:32:53 -08:00
|
|
|
if (!obj || !eo_isa(obj, MY_CLASS)) \
|
2012-05-03 15:42:15 -07:00
|
|
|
return
|
|
|
|
|
2014-04-09 03:04:55 -07:00
|
|
|
#define DECREMENT_MODALITY() \
|
|
|
|
EINA_LIST_FOREACH(_elm_win_list, l, current) \
|
|
|
|
{ \
|
|
|
|
ELM_WIN_DATA_GET_OR_RETURN(current, cursd); \
|
|
|
|
if ((obj != current) && (cursd->modal_count > 0)) \
|
|
|
|
{ \
|
|
|
|
cursd->modal_count--; \
|
|
|
|
} \
|
|
|
|
if (cursd->modal_count == 0) \
|
|
|
|
{ \
|
2014-12-15 09:02:40 -08:00
|
|
|
edje_object_signal_emit(cursd->edje, \
|
2014-04-09 03:04:55 -07:00
|
|
|
"elm,action,hide_blocker", "elm"); \
|
2015-05-13 04:34:44 -07:00
|
|
|
eo_do(cursd->main_menu, eo_event_callback_call \
|
|
|
|
(ELM_MENU_EVENT_ELM_ACTION_UNBLOCK_MENU, NULL)); \
|
2014-04-09 03:04:55 -07:00
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define INCREMENT_MODALITY() \
|
|
|
|
EINA_LIST_FOREACH(_elm_win_list, l, current) \
|
|
|
|
{ \
|
|
|
|
ELM_WIN_DATA_GET_OR_RETURN(current, cursd); \
|
|
|
|
if (obj != current) \
|
|
|
|
{ \
|
|
|
|
cursd->modal_count++; \
|
|
|
|
} \
|
|
|
|
if (cursd->modal_count > 0) \
|
|
|
|
{ \
|
2014-12-15 09:02:40 -08:00
|
|
|
edje_object_signal_emit(cursd->edje, \
|
2014-04-09 03:04:55 -07:00
|
|
|
"elm,action,show_blocker", "elm"); \
|
2015-05-13 04:34:44 -07:00
|
|
|
eo_do(cursd->main_menu, eo_event_callback_call \
|
|
|
|
(ELM_WIN_EVENT_ELM_ACTION_BLOCK_MENU, NULL)); \
|
2014-04-09 03:04:55 -07:00
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
2015-06-16 21:54:42 -07:00
|
|
|
#define ENGINE_GET() (_elm_preferred_engine ? _elm_preferred_engine : _elm_config->engine)
|
2012-06-15 07:11:47 -07:00
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
typedef struct _Elm_Win_Data Elm_Win_Data;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
struct _Elm_Win_Data
|
2012-05-03 15:42:15 -07:00
|
|
|
{
|
2012-07-17 11:46:18 -07:00
|
|
|
Ecore_Evas *ee;
|
|
|
|
Evas *evas;
|
|
|
|
Evas_Object *parent; /* parent *window* object*/
|
|
|
|
Evas_Object *img_obj, *frame_obj;
|
2013-08-23 00:36:24 -07:00
|
|
|
Evas_Object *client_obj; /* rect representing the client */
|
2014-12-15 09:02:40 -08:00
|
|
|
Eo *edje; /**< edje object for a window layout */
|
2013-01-17 14:11:15 -08:00
|
|
|
Eo *box;
|
2012-11-25 22:32:53 -08:00
|
|
|
Evas_Object *obj; /* The object itself */
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2012-06-06 01:25:12 -07:00
|
|
|
struct
|
|
|
|
{
|
2012-07-17 11:46:18 -07:00
|
|
|
Ecore_X_Window xwin;
|
|
|
|
Ecore_Event_Handler *client_message_handler;
|
2012-11-19 08:51:44 -08:00
|
|
|
Ecore_Event_Handler *property_handler;
|
2012-06-06 01:25:12 -07:00
|
|
|
} x;
|
2010-09-24 09:41:25 -07:00
|
|
|
#endif
|
2012-06-06 06:55:15 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_WAYLAND
|
|
|
|
struct
|
|
|
|
{
|
2012-07-17 11:46:18 -07:00
|
|
|
Ecore_Wl_Window *win;
|
2015-07-20 14:35:00 -07:00
|
|
|
Eina_Bool opaque_dirty : 1;
|
2012-06-06 06:55:15 -07:00
|
|
|
} wl;
|
|
|
|
#endif
|
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
Ecore_Job *deferred_resize_job;
|
|
|
|
Ecore_Job *deferred_child_eval_job;
|
2009-11-14 17:51:39 -08:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
Elm_Win_Type type;
|
|
|
|
Elm_Win_Keyboard_Mode kbdmode;
|
|
|
|
Elm_Win_Indicator_Mode indmode;
|
2012-03-07 06:27:36 -08:00
|
|
|
Elm_Win_Indicator_Opacity_Mode ind_o_mode;
|
2012-03-28 02:02:22 -07:00
|
|
|
struct
|
2012-05-03 15:42:15 -07:00
|
|
|
{
|
|
|
|
const char *info;
|
|
|
|
Ecore_Timer *timer;
|
|
|
|
int repeat_count;
|
|
|
|
int shot_counter;
|
|
|
|
} shot;
|
|
|
|
int resize_location;
|
|
|
|
int *autodel_clear, rot;
|
2012-03-28 02:02:22 -07:00
|
|
|
struct
|
2012-05-03 15:42:15 -07:00
|
|
|
{
|
|
|
|
int x, y;
|
|
|
|
} screen;
|
2012-03-28 02:02:22 -07:00
|
|
|
struct
|
2012-05-03 15:42:15 -07:00
|
|
|
{
|
2015-04-29 01:30:18 -07:00
|
|
|
#if 0
|
2012-05-03 15:42:15 -07:00
|
|
|
Ecore_Evas *ee;
|
2015-04-29 01:30:18 -07:00
|
|
|
#endif
|
2012-05-03 15:42:15 -07:00
|
|
|
Evas *evas;
|
|
|
|
Evas_Object *obj, *hot_obj;
|
|
|
|
int hot_x, hot_y;
|
|
|
|
} pointer;
|
2012-03-28 02:02:22 -07:00
|
|
|
struct
|
2012-05-03 15:42:15 -07:00
|
|
|
{
|
2013-08-04 01:37:30 -07:00
|
|
|
Evas_Object *fobj; /* focus highlight edje object */
|
2010-10-04 05:48:15 -07:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
struct
|
|
|
|
{
|
|
|
|
Evas_Object *target;
|
|
|
|
Eina_Bool visible : 1;
|
2014-02-10 05:27:08 -08:00
|
|
|
Eina_Bool in_theme: 1; /**< focus highlight is handled by theme.
|
2014-02-04 16:57:34 -08:00
|
|
|
this is set true if edc data item "focus_highlight" is set to "on" during focus in callback. */
|
2012-05-03 15:42:15 -07:00
|
|
|
} 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
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
const char *style;
|
|
|
|
Ecore_Job *reconf_job;
|
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
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
Eina_Bool enabled : 1;
|
2013-08-04 01:09:44 -07:00
|
|
|
Eina_Bool theme_changed : 1; /* set true when the focus theme is changed */
|
2013-08-04 01:52:54 -07:00
|
|
|
Eina_Bool animate : 1; /* set true when the focus highlight animate is enabled */
|
2013-08-11 02:58:28 -07:00
|
|
|
Eina_Bool animate_supported : 1; /* set true when the focus highlight animate is supported by theme */
|
2012-05-03 15:42:15 -07:00
|
|
|
Eina_Bool geometry_changed : 1;
|
2015-03-04 00:47:54 -08:00
|
|
|
Eina_Bool auto_enabled : 1;
|
|
|
|
Eina_Bool auto_animate : 1;
|
2012-05-03 15:42:15 -07:00
|
|
|
} focus_highlight;
|
2012-02-28 03:20:35 -08:00
|
|
|
|
2012-02-29 04:06:12 -08:00
|
|
|
Evas_Object *icon;
|
2012-05-03 15:42:15 -07:00
|
|
|
const char *title;
|
|
|
|
const char *icon_name;
|
|
|
|
const char *role;
|
2015-04-17 15:10:11 -07:00
|
|
|
Eina_Stringshare *name;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2012-12-27 05:38:33 -08:00
|
|
|
Evas_Object *main_menu;
|
|
|
|
|
2012-12-04 22:50:27 -08:00
|
|
|
struct
|
|
|
|
{
|
|
|
|
const char *name;
|
|
|
|
const char **available_list;
|
|
|
|
unsigned int count;
|
|
|
|
} profile;
|
2014-02-10 05:09:45 -08:00
|
|
|
struct
|
|
|
|
{
|
|
|
|
int preferred_rot; /* indicates preferred rotation value, -1 means invalid. */
|
|
|
|
int *rots; /* indicates available rotations */
|
|
|
|
unsigned int count; /* number of elements in available rotations */
|
|
|
|
Eina_Bool wm_supported : 1; /* set true when the window manager support window rotation */
|
|
|
|
Eina_Bool use : 1; /* set ture when application use window manager rotation. */
|
|
|
|
} wm_rot;
|
2012-12-04 22:50:27 -08:00
|
|
|
|
2012-07-18 21:35:50 -07:00
|
|
|
void *trap_data;
|
|
|
|
|
2015-04-30 05:58:26 -07:00
|
|
|
struct
|
|
|
|
{
|
|
|
|
Ecore_Animator *obj;
|
|
|
|
unsigned short wants;
|
|
|
|
} animator;
|
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
double aspect;
|
2012-06-12 03:15:19 -07:00
|
|
|
int size_base_w, size_base_h;
|
|
|
|
int size_step_w, size_step_h;
|
2012-08-21 01:48:47 -07:00
|
|
|
int norender;
|
2014-04-09 03:04:55 -07:00
|
|
|
int modal_count;
|
2012-05-03 15:42:15 -07:00
|
|
|
Eina_Bool urgent : 1;
|
|
|
|
Eina_Bool modal : 1;
|
|
|
|
Eina_Bool demand_attention : 1;
|
|
|
|
Eina_Bool autodel : 1;
|
2015-07-01 07:40:57 -07:00
|
|
|
Eina_Bool autohide : 1;
|
2012-05-03 15:42:15 -07:00
|
|
|
Eina_Bool constrain : 1;
|
|
|
|
Eina_Bool resizing : 1;
|
|
|
|
Eina_Bool iconified : 1;
|
|
|
|
Eina_Bool withdrawn : 1;
|
|
|
|
Eina_Bool sticky : 1;
|
|
|
|
Eina_Bool fullscreen : 1;
|
|
|
|
Eina_Bool maximized : 1;
|
|
|
|
Eina_Bool skip_focus : 1;
|
2012-09-14 06:06:57 -07:00
|
|
|
Eina_Bool floating : 1;
|
2014-07-20 19:39:32 -07:00
|
|
|
Eina_Bool noblank : 1;
|
2014-12-15 09:09:16 -08:00
|
|
|
Eina_Bool theme_alpha : 1; /**< alpha value fetched by a theme. this has higher priority than application_alpha */
|
|
|
|
Eina_Bool application_alpha : 1; /**< alpha value set by an elm_win_alpha_set() api. this has lower priority than theme_alpha */
|
2008-09-29 23:58:56 -07:00
|
|
|
};
|
|
|
|
|
2011-04-21 17:42:32 -07:00
|
|
|
static const char SIG_DELETE_REQUEST[] = "delete,request";
|
elm: added more "focused" and "unfocused" documentations.
genlist, hover, index, list, map, photocam, progressbar, radio, scroller, slider, slideshow, spinner, toolbar, win.
2013-06-09 22:12:51 -07:00
|
|
|
static const char SIG_FOCUS_OUT[] = "focus,out"; // deprecated. use "focused" instead.
|
|
|
|
static const char SIG_FOCUS_IN[] = "focus,in"; // deprecated. use "unfocused" instead.
|
2011-04-21 17:42:32 -07:00
|
|
|
static const char SIG_MOVED[] = "moved";
|
2012-02-28 03:20:35 -08:00
|
|
|
static const char SIG_WITHDRAWN[] = "withdrawn";
|
|
|
|
static const char SIG_ICONIFIED[] = "iconified";
|
|
|
|
static const char SIG_NORMAL[] = "normal";
|
|
|
|
static const char SIG_STICK[] = "stick";
|
|
|
|
static const char SIG_UNSTICK[] = "unstick";
|
|
|
|
static const char SIG_FULLSCREEN[] = "fullscreen";
|
|
|
|
static const char SIG_UNFULLSCREEN[] = "unfullscreen";
|
|
|
|
static const char SIG_MAXIMIZED[] = "maximized";
|
|
|
|
static const char SIG_UNMAXIMIZED[] = "unmaximized";
|
2012-08-05 21:09:02 -07:00
|
|
|
static const char SIG_IOERR[] = "ioerr";
|
2012-09-02 23:55:07 -07:00
|
|
|
static const char SIG_INDICATOR_PROP_CHANGED[] = "indicator,prop,changed";
|
|
|
|
static const char SIG_ROTATION_CHANGED[] = "rotation,changed";
|
2012-12-04 22:50:27 -08:00
|
|
|
static const char SIG_PROFILE_CHANGED[] = "profile,changed";
|
2014-02-10 05:09:45 -08:00
|
|
|
static const char SIG_WM_ROTATION_CHANGED[] = "wm,rotation,changed";
|
2014-12-15 08:45:59 -08:00
|
|
|
static const char SIG_THEME_CHANGED[] = "theme,changed";
|
2011-04-21 17:42:32 -07:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
static const Evas_Smart_Cb_Description _smart_callbacks[] = {
|
2011-04-21 17:42:32 -07:00
|
|
|
{SIG_DELETE_REQUEST, ""},
|
|
|
|
{SIG_FOCUS_OUT, ""},
|
|
|
|
{SIG_FOCUS_IN, ""},
|
|
|
|
{SIG_MOVED, ""},
|
2012-02-28 03:20:35 -08:00
|
|
|
{SIG_WITHDRAWN, ""},
|
|
|
|
{SIG_ICONIFIED, ""},
|
|
|
|
{SIG_NORMAL, ""},
|
|
|
|
{SIG_STICK, ""},
|
|
|
|
{SIG_UNSTICK, ""},
|
|
|
|
{SIG_FULLSCREEN, ""},
|
|
|
|
{SIG_UNFULLSCREEN, ""},
|
|
|
|
{SIG_MAXIMIZED, ""},
|
|
|
|
{SIG_UNMAXIMIZED, ""},
|
2012-08-05 21:09:02 -07:00
|
|
|
{SIG_IOERR, ""},
|
2012-09-02 23:55:07 -07:00
|
|
|
{SIG_INDICATOR_PROP_CHANGED, ""},
|
|
|
|
{SIG_ROTATION_CHANGED, ""},
|
2012-12-04 22:50:27 -08:00
|
|
|
{SIG_PROFILE_CHANGED, ""},
|
2014-02-10 05:09:45 -08:00
|
|
|
{SIG_WM_ROTATION_CHANGED, ""},
|
2014-07-14 10:06:10 -07:00
|
|
|
{SIG_WIDGET_FOCUSED, ""}, /**< handled by elm_widget */
|
|
|
|
{SIG_WIDGET_UNFOCUSED, ""}, /**< handled by elm_widget */
|
2011-04-21 17:42:32 -07:00
|
|
|
{NULL, NULL}
|
|
|
|
};
|
|
|
|
|
2014-04-15 18:38:34 -07:00
|
|
|
static Eina_Bool _key_action_return(Evas_Object *obj, const char *params);
|
|
|
|
static Eina_Bool _key_action_move(Evas_Object *obj, const char *params);
|
|
|
|
|
|
|
|
static const Elm_Action key_actions[] = {
|
|
|
|
{"return", _key_action_return},
|
|
|
|
{"move", _key_action_move},
|
|
|
|
{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
|
|
|
|
2012-08-28 03:37:02 -07:00
|
|
|
static int _elm_win_count = 0;
|
|
|
|
|
|
|
|
static Eina_Bool _elm_win_auto_throttled = EINA_FALSE;
|
|
|
|
|
2015-05-27 20:27:59 -07:00
|
|
|
static Ecore_Timer *_elm_win_state_eval_timer = NULL;
|
2012-08-28 03:37:02 -07:00
|
|
|
|
2013-01-17 14:11:15 -08:00
|
|
|
static void
|
|
|
|
_elm_win_on_resize_obj_changed_size_hints(void *data,
|
|
|
|
Evas *e,
|
|
|
|
Evas_Object *obj,
|
|
|
|
void *event_info);
|
2014-02-17 23:15:55 -08:00
|
|
|
static void
|
|
|
|
_elm_win_img_callbacks_del(Evas_Object *obj, Evas_Object *imgobj);
|
2014-12-15 08:45:59 -08:00
|
|
|
static Eina_Bool _elm_win_theme_internal(Eo *obj, Elm_Win_Data *sd);
|
2014-02-17 23:15:55 -08:00
|
|
|
|
2014-02-10 05:09:45 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2014-03-27 06:15:52 -07:00
|
|
|
static void _elm_win_xwin_update(Elm_Win_Data *sd);
|
2014-02-10 05:09:45 -08:00
|
|
|
#endif
|
2013-01-17 14:11:15 -08:00
|
|
|
|
2013-03-20 01:37:40 -07:00
|
|
|
EAPI double _elm_startup_time = 0;
|
|
|
|
|
|
|
|
static void
|
2013-08-11 01:30:56 -07:00
|
|
|
_elm_win_first_frame_do(void *data, Evas *e EINA_UNUSED, void *event_info EINA_UNUSED)
|
2013-03-20 01:37:40 -07:00
|
|
|
{
|
2014-11-02 21:38:17 -08:00
|
|
|
double end = ecore_time_unix_get();
|
2013-08-11 01:30:56 -07:00
|
|
|
char *first = data;
|
2013-03-20 01:37:40 -07:00
|
|
|
|
|
|
|
switch (*first)
|
|
|
|
{
|
|
|
|
case 'A': abort();
|
|
|
|
case 'E':
|
|
|
|
case 'D': exit(-1);
|
2013-08-01 04:03:19 -07:00
|
|
|
case 'T': fprintf(stderr, "Startup time: '%f' - '%f' = '%f' sec\n", end, _elm_startup_time, end - _elm_startup_time);
|
2013-08-11 01:30:56 -07:00
|
|
|
break;
|
2013-03-20 01:37:40 -07:00
|
|
|
}
|
|
|
|
|
2013-08-11 01:30:56 -07:00
|
|
|
evas_event_callback_del_full(e, EVAS_CALLBACK_RENDER_POST, _elm_win_first_frame_do, data);
|
2013-03-20 01:37:40 -07:00
|
|
|
}
|
|
|
|
|
2014-07-20 19:39:32 -07:00
|
|
|
static void
|
|
|
|
_win_noblank_eval(void)
|
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
Evas_Object *obj;
|
|
|
|
int noblanks = 0;
|
2014-08-07 07:19:24 -07:00
|
|
|
Eina_Bool change = EINA_FALSE;
|
2014-07-20 19:39:32 -07:00
|
|
|
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
EINA_LIST_FOREACH(_elm_win_list, l, obj)
|
|
|
|
{
|
|
|
|
ELM_WIN_DATA_GET(obj, sd);
|
|
|
|
|
|
|
|
if (sd->x.xwin)
|
|
|
|
{
|
|
|
|
if ((sd->noblank) && (!sd->iconified) && (!sd->withdrawn) &&
|
|
|
|
evas_object_visible_get(obj))
|
2014-08-07 07:19:24 -07:00
|
|
|
noblanks++;
|
|
|
|
|
|
|
|
change = EINA_TRUE;
|
2014-07-20 19:39:32 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-24 10:50:39 -07:00
|
|
|
|
2014-08-07 07:19:24 -07:00
|
|
|
if (!change) return;
|
|
|
|
|
2015-02-05 03:44:49 -08:00
|
|
|
if (noblanks > 0) ecore_x_screensaver_suspend();
|
2014-08-10 15:59:45 -07:00
|
|
|
else ecore_x_screensaver_resume();
|
2014-07-20 19:39:32 -07:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ELEMENTARY_WAYLAND
|
|
|
|
// XXX: no wl implementation of this yet - maybe higher up at prop level
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2014-09-03 23:09:10 -07:00
|
|
|
static Elm_Process_State _elm_process_state = ELM_PROCESS_STATE_FOREGROUND;
|
|
|
|
|
|
|
|
EAPI Elm_Process_State
|
|
|
|
elm_process_state_get(void)
|
|
|
|
{
|
|
|
|
return _elm_process_state;
|
|
|
|
}
|
|
|
|
|
2014-12-10 21:43:53 -08:00
|
|
|
static void
|
|
|
|
_elm_win_apply_alpha(Eo *obj, Elm_Win_Data *sd)
|
|
|
|
{
|
|
|
|
Eina_Bool enabled;
|
|
|
|
|
|
|
|
enabled = sd->theme_alpha | sd->application_alpha;
|
|
|
|
if (sd->img_obj)
|
|
|
|
{
|
|
|
|
evas_object_image_alpha_set(sd->img_obj, enabled);
|
|
|
|
ecore_evas_alpha_set(sd->ee, enabled);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
if (sd->x.xwin)
|
|
|
|
{
|
|
|
|
if (enabled)
|
|
|
|
{
|
|
|
|
if (!ecore_x_screen_is_composited(0))
|
|
|
|
elm_win_shaped_set(obj, enabled);
|
|
|
|
else
|
|
|
|
TRAP(sd, alpha_set, enabled);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
TRAP(sd, alpha_set, enabled);
|
|
|
|
_elm_win_xwin_update(sd);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
TRAP(sd, alpha_set, enabled);
|
|
|
|
}
|
|
|
|
}
|
2014-09-03 23:09:10 -07:00
|
|
|
|
2015-05-27 20:27:59 -07:00
|
|
|
static Eina_Bool
|
2014-01-06 06:30:02 -08:00
|
|
|
_elm_win_state_eval(void *data EINA_UNUSED)
|
2012-08-28 03:37:02 -07:00
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
Evas_Object *obj;
|
2013-01-14 01:46:25 -08:00
|
|
|
int _elm_win_count_shown = 0;
|
|
|
|
int _elm_win_count_iconified = 0;
|
|
|
|
int _elm_win_count_withdrawn = 0;
|
2014-09-03 23:09:10 -07:00
|
|
|
Eina_Bool throttle = EINA_FALSE;
|
2012-10-10 17:35:00 -07:00
|
|
|
|
2015-05-27 20:27:59 -07:00
|
|
|
_elm_win_state_eval_timer = NULL;
|
2012-10-10 17:35:00 -07:00
|
|
|
|
2015-05-27 20:27:59 -07:00
|
|
|
EINA_LIST_FOREACH(_elm_win_list, l, obj)
|
2012-08-28 03:37:02 -07:00
|
|
|
{
|
2015-05-27 20:27:59 -07:00
|
|
|
if (_elm_config->auto_norender_withdrawn)
|
2012-08-28 03:37:02 -07:00
|
|
|
{
|
|
|
|
if ((elm_win_withdrawn_get(obj)) ||
|
2012-10-10 17:35:00 -07:00
|
|
|
((elm_win_iconified_get(obj) &&
|
2012-08-28 03:37:02 -07:00
|
|
|
(_elm_config->auto_norender_iconified_same_as_withdrawn))))
|
|
|
|
{
|
|
|
|
if (!evas_object_data_get(obj, "__win_auto_norender"))
|
|
|
|
{
|
|
|
|
Evas *evas = evas_object_evas_get(obj);
|
2012-10-10 17:35:00 -07:00
|
|
|
|
2012-08-28 03:37:02 -07:00
|
|
|
elm_win_norender_push(obj);
|
|
|
|
evas_object_data_set(obj, "__win_auto_norender", obj);
|
2012-10-10 17:35:00 -07:00
|
|
|
|
2012-08-28 03:37:02 -07:00
|
|
|
if (_elm_config->auto_flush_withdrawn)
|
|
|
|
{
|
|
|
|
edje_file_cache_flush();
|
|
|
|
edje_collection_cache_flush();
|
|
|
|
evas_image_cache_flush(evas);
|
|
|
|
evas_font_cache_flush(evas);
|
|
|
|
}
|
|
|
|
if (_elm_config->auto_dump_withdrawn)
|
|
|
|
{
|
|
|
|
evas_render_dump(evas);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (evas_object_data_get(obj, "__win_auto_norender"))
|
|
|
|
{
|
|
|
|
elm_win_norender_pop(obj);
|
|
|
|
evas_object_data_del(obj, "__win_auto_norender");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-05-27 20:27:59 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (evas_object_data_get(obj, "__win_auto_norender"))
|
|
|
|
{
|
|
|
|
elm_win_norender_pop(obj);
|
|
|
|
evas_object_data_del(obj, "__win_auto_norender");
|
|
|
|
}
|
|
|
|
}
|
2012-08-28 03:37:02 -07:00
|
|
|
}
|
2013-07-25 06:17:52 -07:00
|
|
|
if (((_elm_config->auto_throttle) &&
|
|
|
|
(elm_policy_get(ELM_POLICY_THROTTLE) != ELM_POLICY_THROTTLE_NEVER)) ||
|
|
|
|
(elm_policy_get(ELM_POLICY_THROTTLE) == ELM_POLICY_THROTTLE_HIDDEN_ALWAYS))
|
2014-09-03 23:09:10 -07:00
|
|
|
throttle = EINA_TRUE;
|
|
|
|
if (_elm_win_count == 0)
|
2012-08-28 03:37:02 -07:00
|
|
|
{
|
2014-09-03 23:09:10 -07:00
|
|
|
if (_elm_win_auto_throttled)
|
2012-08-28 03:37:02 -07:00
|
|
|
{
|
2014-09-03 23:09:10 -07:00
|
|
|
_elm_process_state = ELM_PROCESS_STATE_FOREGROUND;
|
|
|
|
ecore_event_add(ELM_EVENT_PROCESS_FOREGROUND, NULL, NULL, NULL);
|
|
|
|
if (throttle)
|
|
|
|
ecore_throttle_adjust(-_elm_config->auto_throttle_amount);
|
|
|
|
_elm_win_auto_throttled = EINA_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
EINA_LIST_FOREACH(_elm_win_list, l, obj)
|
|
|
|
{
|
|
|
|
if (elm_win_withdrawn_get(obj)) _elm_win_count_withdrawn++;
|
|
|
|
else if (elm_win_iconified_get(obj)) _elm_win_count_iconified++;
|
|
|
|
else if (evas_object_visible_get(obj)) _elm_win_count_shown++;
|
|
|
|
}
|
|
|
|
if (_elm_win_count_shown <= 0)
|
|
|
|
{
|
|
|
|
if (!_elm_win_auto_throttled)
|
2012-08-28 03:37:02 -07:00
|
|
|
{
|
2014-09-03 23:09:10 -07:00
|
|
|
_elm_process_state = ELM_PROCESS_STATE_BACKGROUND;
|
|
|
|
ecore_event_add(ELM_EVENT_PROCESS_BACKGROUND, NULL, NULL, NULL);
|
|
|
|
if (throttle)
|
|
|
|
ecore_throttle_adjust(_elm_config->auto_throttle_amount);
|
|
|
|
_elm_win_auto_throttled = EINA_TRUE;
|
2012-08-28 03:37:02 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-09-03 23:09:10 -07:00
|
|
|
if (_elm_win_auto_throttled)
|
2012-08-28 03:37:02 -07:00
|
|
|
{
|
2014-09-03 23:09:10 -07:00
|
|
|
_elm_process_state = ELM_PROCESS_STATE_FOREGROUND;
|
|
|
|
ecore_event_add(ELM_EVENT_PROCESS_FOREGROUND, NULL, NULL, NULL);
|
|
|
|
if (throttle)
|
|
|
|
ecore_throttle_adjust(-_elm_config->auto_throttle_amount);
|
|
|
|
_elm_win_auto_throttled = EINA_FALSE;
|
2012-08-28 03:37:02 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-07-20 19:39:32 -07:00
|
|
|
_win_noblank_eval();
|
2015-05-27 20:27:59 -07:00
|
|
|
return EINA_FALSE;
|
2012-08-28 03:37:02 -07:00
|
|
|
}
|
|
|
|
|
2015-07-01 07:40:57 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_elm_win_policy_quit_triggered(Eo* triggering_obj)
|
|
|
|
{
|
|
|
|
if ((!_elm_win_list) &&
|
|
|
|
(elm_policy_get(ELM_POLICY_QUIT) == ELM_POLICY_QUIT_LAST_WINDOW_CLOSED))
|
|
|
|
{
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (elm_policy_get(ELM_POLICY_QUIT) == ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN)
|
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
Evas_Object *win;
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(_elm_win_list, l, win)
|
|
|
|
if (win != triggering_obj && evas_object_visible_get(win) == EINA_TRUE)
|
|
|
|
{
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_win_flush_cache_and_exit(Eo *obj)
|
|
|
|
{
|
|
|
|
edje_file_cache_flush();
|
|
|
|
edje_collection_cache_flush();
|
|
|
|
evas_image_cache_flush(evas_object_evas_get(obj));
|
|
|
|
evas_font_cache_flush(evas_object_evas_get(obj));
|
|
|
|
elm_exit();
|
|
|
|
}
|
|
|
|
|
2012-08-28 03:37:02 -07:00
|
|
|
static void
|
|
|
|
_elm_win_state_eval_queue(void)
|
|
|
|
{
|
2015-05-27 20:27:59 -07:00
|
|
|
if (_elm_win_state_eval_timer) ecore_timer_del(_elm_win_state_eval_timer);
|
|
|
|
_elm_win_state_eval_timer = ecore_timer_add(0.5, _elm_win_state_eval, NULL);
|
2012-08-28 03:37:02 -07:00
|
|
|
}
|
|
|
|
|
2012-05-16 00:28:29 -07:00
|
|
|
// example shot spec (wait 0.1 sec then save as my-window.png):
|
2011-05-04 03:09:59 -07:00
|
|
|
// ELM_ENGINE="shot:delay=0.1:file=my-window.png"
|
|
|
|
|
|
|
|
static double
|
2014-03-27 06:15:52 -07:00
|
|
|
_shot_delay_get(Elm_Win_Data *sd)
|
2011-05-04 03:09:59 -07:00
|
|
|
{
|
|
|
|
char *p, *pd;
|
2012-05-03 15:42:15 -07:00
|
|
|
char *d = strdup(sd->shot.info);
|
2011-05-07 01:37:47 -07:00
|
|
|
|
2011-05-04 03:09:59 -07:00
|
|
|
if (!d) return 0.5;
|
2012-05-03 15:42:15 -07:00
|
|
|
for (p = (char *)sd->shot.info; *p; p++)
|
2011-05-04 03:09:59 -07:00
|
|
|
{
|
|
|
|
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;
|
2012-04-25 20:32:18 -07:00
|
|
|
v = _elm_atof(d);
|
2011-05-04 03:09:59 -07:00
|
|
|
free(d);
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free(d);
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2011-05-04 03:09:59 -07:00
|
|
|
return 0.5;
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
2014-03-27 06:15:52 -07:00
|
|
|
_shot_file_get(Elm_Win_Data *sd)
|
2011-05-04 03:09:59 -07:00
|
|
|
{
|
|
|
|
char *p;
|
2012-05-03 15:42:15 -07:00
|
|
|
char *tmp = strdup(sd->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
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
for (p = (char *)sd->shot.info; *p; p++)
|
2011-05-04 03:09:59 -07:00
|
|
|
{
|
|
|
|
if (!strncmp(p, "file=", 5))
|
|
|
|
{
|
|
|
|
strcpy(tmp, p + 5);
|
2012-05-03 15:42:15 -07:00
|
|
|
if (!sd->shot.repeat_count) return tmp;
|
2011-07-05 01:17:39 -07:00
|
|
|
else
|
|
|
|
{
|
2011-07-10 21:15:42 -07:00
|
|
|
char *dotptr = strrchr(tmp, '.');
|
2011-07-05 01:17:39 -07:00
|
|
|
if (dotptr)
|
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
size_t size = sizeof(char) * (strlen(tmp) + 16);
|
2012-01-02 21:30:13 -08:00
|
|
|
repname = malloc(size);
|
2011-07-05 01:17:39 -07:00
|
|
|
strncpy(repname, tmp, dotptr - tmp);
|
2012-05-03 15:42:15 -07:00
|
|
|
snprintf(repname + (dotptr - tmp), size -
|
|
|
|
(dotptr - tmp), "%03i",
|
|
|
|
sd->shot.shot_counter + 1);
|
2011-07-05 01:17:39 -07:00
|
|
|
strcat(repname, dotptr);
|
2011-10-16 23:53:10 -07:00
|
|
|
free(tmp);
|
2011-07-05 01:17:39 -07:00
|
|
|
return repname;
|
|
|
|
}
|
|
|
|
}
|
2011-05-04 03:09:59 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
free(tmp);
|
2012-05-03 15:42:15 -07:00
|
|
|
if (!sd->shot.repeat_count) return strdup("out.png");
|
2012-01-02 21:30:13 -08:00
|
|
|
|
|
|
|
repname = malloc(sizeof(char) * 24);
|
2012-05-03 15:42:15 -07:00
|
|
|
snprintf(repname, sizeof(char) * 24, "out%03i.png",
|
|
|
|
sd->shot.shot_counter + 1);
|
|
|
|
|
2012-01-02 21:30:13 -08:00
|
|
|
return repname;
|
2011-07-05 01:17:39 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2014-03-27 06:15:52 -07:00
|
|
|
_shot_repeat_count_get(Elm_Win_Data *sd)
|
2011-07-05 01:17:39 -07:00
|
|
|
{
|
|
|
|
char *p, *pd;
|
2012-05-03 15:42:15 -07:00
|
|
|
char *d = strdup(sd->shot.info);
|
2011-07-05 01:17:39 -07:00
|
|
|
|
|
|
|
if (!d) return 0;
|
2012-05-03 15:42:15 -07:00
|
|
|
for (p = (char *)sd->shot.info; *p; p++)
|
2011-07-05 01:17:39 -07:00
|
|
|
{
|
|
|
|
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);
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2011-07-05 01:17:39 -07:00
|
|
|
return 0;
|
2011-05-04 03:09:59 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
2014-03-27 06:15:52 -07:00
|
|
|
_shot_key_get(Elm_Win_Data *sd EINA_UNUSED)
|
2011-05-04 03:09:59 -07:00
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
2014-03-27 06:15:52 -07:00
|
|
|
_shot_flags_get(Elm_Win_Data *sd EINA_UNUSED)
|
2011-05-04 03:09:59 -07:00
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2014-03-27 06:15:52 -07:00
|
|
|
_shot_do(Elm_Win_Data *sd)
|
2011-05-04 03:09:59 -07:00
|
|
|
{
|
|
|
|
Ecore_Evas *ee;
|
|
|
|
Evas_Object *o;
|
|
|
|
unsigned int *pixels;
|
|
|
|
int w, h;
|
|
|
|
char *file, *key, *flags;
|
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
ecore_evas_manual_render(sd->ee);
|
|
|
|
pixels = (void *)ecore_evas_buffer_pixels_get(sd->ee);
|
2011-05-04 03:09:59 -07:00
|
|
|
if (!pixels) return;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
ecore_evas_geometry_get(sd->ee, NULL, NULL, &w, &h);
|
2011-05-04 03:09:59 -07:00
|
|
|
if ((w < 1) || (h < 1)) return;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
file = _shot_file_get(sd);
|
2011-05-04 03:09:59 -07:00
|
|
|
if (!file) return;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
key = _shot_key_get(sd);
|
|
|
|
flags = _shot_flags_get(sd);
|
2011-05-04 03:09:59 -07:00
|
|
|
ee = ecore_evas_buffer_new(1, 1);
|
|
|
|
o = evas_object_image_add(ecore_evas_get(ee));
|
2014-12-10 21:43:53 -08:00
|
|
|
evas_object_image_alpha_set(o,
|
|
|
|
sd->theme_alpha | sd->application_alpha);
|
2011-05-04 03:09:59 -07:00
|
|
|
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);
|
2014-01-21 18:08:47 -08:00
|
|
|
free(key);
|
|
|
|
free(flags);
|
2011-05-04 03:09:59 -07:00
|
|
|
ecore_evas_free(ee);
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->shot.repeat_count) sd->shot.shot_counter++;
|
2011-05-04 03:09:59 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_shot_delay(void *data)
|
|
|
|
{
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_WIN_DATA_GET(data, sd);
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
_shot_do(sd);
|
|
|
|
if (sd->shot.repeat_count)
|
2011-07-05 01:17:39 -07:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
int remainshot = (sd->shot.repeat_count - sd->shot.shot_counter);
|
2011-07-05 01:17:39 -07:00
|
|
|
if (remainshot > 0) return EINA_TRUE;
|
2011-07-05 09:59:23 -07:00
|
|
|
}
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->shot.timer = NULL;
|
2011-05-04 03:09:59 -07:00
|
|
|
elm_exit();
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2011-05-04 03:09:59 -07:00
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2011-07-05 01:17:39 -07:00
|
|
|
static void
|
2014-03-27 06:15:52 -07:00
|
|
|
_shot_init(Elm_Win_Data *sd)
|
2011-07-05 01:17:39 -07:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
if (!sd->shot.info) return;
|
|
|
|
|
|
|
|
sd->shot.repeat_count = _shot_repeat_count_get(sd);
|
|
|
|
sd->shot.shot_counter = 0;
|
2011-07-05 01:17:39 -07:00
|
|
|
}
|
|
|
|
|
2011-05-04 03:09:59 -07:00
|
|
|
static void
|
2014-03-27 06:15:52 -07:00
|
|
|
_shot_handle(Elm_Win_Data *sd)
|
2011-05-04 03:09:59 -07:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
if (!sd->shot.info) return;
|
|
|
|
|
2013-05-20 03:09:13 -07:00
|
|
|
if (!sd->shot.timer)
|
|
|
|
sd->shot.timer = ecore_timer_add(_shot_delay_get(sd), _shot_delay,
|
|
|
|
sd->obj);
|
2011-05-04 03:09:59 -07:00
|
|
|
}
|
|
|
|
|
2012-07-18 21:35:50 -07:00
|
|
|
/* elm-win specific associate, does the trap while ecore_evas_object_associate()
|
|
|
|
* does not.
|
|
|
|
*/
|
2014-03-27 06:15:52 -07:00
|
|
|
static Elm_Win_Data *
|
2012-07-18 21:35:50 -07:00
|
|
|
_elm_win_associate_get(const Ecore_Evas *ee)
|
|
|
|
{
|
2014-02-17 22:58:57 -08:00
|
|
|
Evas_Object *obj = ecore_evas_data_get(ee, "elm_win");
|
|
|
|
if (!obj) return NULL;
|
|
|
|
ELM_WIN_DATA_GET(obj, sd);
|
2013-04-24 04:41:37 -07:00
|
|
|
return sd;
|
2012-07-18 21:35:50 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Interceptors Callbacks */
|
|
|
|
static void
|
2014-01-06 06:30:02 -08:00
|
|
|
_elm_win_obj_intercept_raise(void *data, Evas_Object *obj EINA_UNUSED)
|
2012-07-18 21:35:50 -07:00
|
|
|
{
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_WIN_DATA_GET(data, sd);
|
2012-07-18 21:35:50 -07:00
|
|
|
TRAP(sd, raise);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2014-01-06 06:30:02 -08:00
|
|
|
_elm_win_obj_intercept_lower(void *data, Evas_Object *obj EINA_UNUSED)
|
2012-07-18 21:35:50 -07:00
|
|
|
{
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_WIN_DATA_GET(data, sd);
|
2012-07-18 21:35:50 -07:00
|
|
|
TRAP(sd, lower);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2014-01-06 06:30:02 -08:00
|
|
|
_elm_win_obj_intercept_stack_above(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, Evas_Object *above EINA_UNUSED)
|
2012-07-18 21:35:50 -07:00
|
|
|
{
|
|
|
|
INF("TODO: %s", __FUNCTION__);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2014-01-06 06:30:02 -08:00
|
|
|
_elm_win_obj_intercept_stack_below(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, Evas_Object *below EINA_UNUSED)
|
2012-07-18 21:35:50 -07:00
|
|
|
{
|
|
|
|
INF("TODO: %s", __FUNCTION__);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2014-01-06 06:30:02 -08:00
|
|
|
_elm_win_obj_intercept_layer_set(void *data, Evas_Object *obj EINA_UNUSED, int l)
|
2012-07-18 21:35:50 -07:00
|
|
|
{
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_WIN_DATA_GET(data, sd);
|
2012-07-18 21:35:50 -07:00
|
|
|
TRAP(sd, layer_set, l);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Event Callbacks */
|
|
|
|
|
|
|
|
static void
|
2014-01-06 06:30:02 -08:00
|
|
|
_elm_win_obj_callback_changed_size_hints(void *data, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
|
2012-07-18 21:35:50 -07:00
|
|
|
{
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_WIN_DATA_GET(data, sd);
|
2012-07-18 21:35:50 -07:00
|
|
|
Evas_Coord w, h;
|
|
|
|
|
|
|
|
evas_object_size_hint_min_get(obj, &w, &h);
|
|
|
|
TRAP(sd, size_min_set, w, h);
|
|
|
|
|
|
|
|
evas_object_size_hint_max_get(obj, &w, &h);
|
|
|
|
if (w < 1) w = -1;
|
|
|
|
if (h < 1) h = -1;
|
|
|
|
TRAP(sd, size_max_set, w, h);
|
|
|
|
}
|
|
|
|
/* end of elm-win specific associate */
|
|
|
|
|
2009-12-01 03:03:14 -08:00
|
|
|
static void
|
|
|
|
_elm_win_move(Ecore_Evas *ee)
|
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
Elm_Win_Data *sd = _elm_win_associate_get(ee);
|
2009-12-01 03:03:14 -08:00
|
|
|
int x, y;
|
2010-09-24 09:41:25 -07:00
|
|
|
|
2014-02-17 22:58:57 -08:00
|
|
|
if (!sd) return;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2009-12-01 03:03:14 -08:00
|
|
|
ecore_evas_geometry_get(ee, &x, &y, NULL, NULL);
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->screen.x = x;
|
|
|
|
sd->screen.y = y;
|
2015-05-13 04:34:44 -07:00
|
|
|
eo_do(sd->obj, eo_event_callback_call(ELM_WIN_EVENT_MOVED, NULL));
|
2014-03-26 01:08:24 -07:00
|
|
|
evas_nochange_push(evas_object_evas_get(sd->obj));
|
|
|
|
evas_object_move(sd->obj, x, y);
|
|
|
|
evas_nochange_pop(evas_object_evas_get(sd->obj));
|
2012-05-03 15:42:15 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_win_resize_job(void *data)
|
|
|
|
{
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_WIN_DATA_GET(data, sd);
|
2012-05-03 15:42:15 -07:00
|
|
|
int w, h;
|
|
|
|
|
|
|
|
sd->deferred_resize_job = NULL;
|
|
|
|
ecore_evas_request_geometry_get(sd->ee, NULL, NULL, &w, &h);
|
|
|
|
if (sd->constrain)
|
|
|
|
{
|
|
|
|
int sw, sh;
|
|
|
|
ecore_evas_screen_geometry_get(sd->ee, NULL, NULL, &sw, &sh);
|
|
|
|
w = MIN(w, sw);
|
|
|
|
h = MIN(h, sh);
|
|
|
|
}
|
2012-07-30 03:06:28 -07:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->frame_obj)
|
2013-03-25 10:50:12 -07:00
|
|
|
{
|
2013-04-29 07:25:02 -07:00
|
|
|
int fx, fy, fw, fh;
|
2013-03-25 10:50:12 -07:00
|
|
|
|
2013-04-29 07:25:02 -07:00
|
|
|
evas_output_framespace_get(sd->evas, &fx, &fy, &fw, &fh);
|
|
|
|
evas_object_move(sd->frame_obj, -fx, -fy);
|
2013-08-23 00:36:24 -07:00
|
|
|
evas_object_resize(sd->frame_obj, w + fw, h + fh);
|
2013-03-25 10:50:12 -07:00
|
|
|
}
|
2012-08-22 02:21:28 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
evas_object_resize(sd->obj, w, h);
|
2014-12-15 09:02:40 -08:00
|
|
|
evas_object_resize(sd->edje, w, h);
|
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
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
Elm_Win_Data *sd = _elm_win_associate_get(ee);
|
2014-02-17 22:58:57 -08:00
|
|
|
if (!sd) return;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_job_del(sd->deferred_resize_job);
|
2013-04-24 04:41:37 -07:00
|
|
|
sd->deferred_resize_job = ecore_job_add(_elm_win_resize_job, sd->obj);
|
2008-09-29 23:58:56 -07:00
|
|
|
}
|
|
|
|
|
2012-03-28 02:02:22 -07:00
|
|
|
static void
|
2012-01-08 03:23:59 -08:00
|
|
|
_elm_win_mouse_in(Ecore_Evas *ee)
|
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
Elm_Win_Data *sd = _elm_win_associate_get(ee);
|
2014-02-17 22:58:57 -08:00
|
|
|
if (!sd) return;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
if (sd->resizing) sd->resizing = EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2014-03-27 06:15:52 -07:00
|
|
|
_elm_win_focus_highlight_reconfigure_job_stop(Elm_Win_Data *sd)
|
2012-05-03 15:42:15 -07:00
|
|
|
{
|
2013-05-29 05:11:46 -07:00
|
|
|
ELM_SAFE_FREE(sd->focus_highlight.reconf_job, ecore_job_del);
|
2012-05-03 15:42:15 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2014-03-27 06:15:52 -07:00
|
|
|
_elm_win_focus_highlight_visible_set(Elm_Win_Data *sd,
|
2012-05-03 15:42:15 -07:00
|
|
|
Eina_Bool visible)
|
|
|
|
{
|
2013-08-04 01:38:02 -07:00
|
|
|
Evas_Object *fobj = sd->focus_highlight.fobj;
|
|
|
|
if (!fobj) return;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
if (visible)
|
|
|
|
{
|
2013-08-04 01:38:02 -07:00
|
|
|
evas_object_show(fobj);
|
|
|
|
edje_object_signal_emit(fobj, "elm,action,focus,show", "elm");
|
2012-05-03 15:42:15 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-08-04 01:38:02 -07:00
|
|
|
edje_object_signal_emit(fobj, "elm,action,focus,hide", "elm");
|
2012-05-03 15:42:15 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2014-03-27 06:15:52 -07:00
|
|
|
_elm_win_focus_highlight_anim_setup(Elm_Win_Data *sd,
|
2012-05-03 15:42:15 -07:00
|
|
|
Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Evas_Coord tx, ty, tw, th;
|
2014-03-19 22:14:20 -07:00
|
|
|
Evas_Coord px, py, pw, ph;
|
2012-05-03 15:42:15 -07:00
|
|
|
Edje_Message_Int_Set *m;
|
|
|
|
Evas_Object *target = sd->focus_highlight.cur.target;
|
|
|
|
|
2014-03-19 22:14:20 -07:00
|
|
|
evas_object_geometry_get(obj, &px, &py, &pw, &ph);
|
2014-05-06 22:13:19 -07:00
|
|
|
elm_widget_focus_highlight_geometry_get(target, &tx, &ty, &tw, &th);
|
2013-03-04 03:16:35 -08:00
|
|
|
evas_object_move(obj, tx, ty);
|
2012-05-03 15:42:15 -07:00
|
|
|
evas_object_resize(obj, tw, th);
|
2014-03-08 10:39:23 -08:00
|
|
|
|
2014-04-03 03:10:53 -07:00
|
|
|
if ((px == tx) && (py == ty) && (pw == tw) && (ph == th)) return;
|
|
|
|
|
2014-03-08 10:39:23 -08:00
|
|
|
if (!_elm_config->focus_highlight_clip_disable)
|
|
|
|
evas_object_clip_unset(obj);
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
m = alloca(sizeof(*m) + (sizeof(int) * 8));
|
|
|
|
m->count = 8;
|
2013-03-04 03:16:35 -08:00
|
|
|
m->val[0] = px - tx;
|
|
|
|
m->val[1] = py - ty;
|
2012-05-03 15:42:15 -07:00
|
|
|
m->val[2] = pw;
|
|
|
|
m->val[3] = ph;
|
2013-03-04 03:16:35 -08:00
|
|
|
m->val[4] = 0;
|
|
|
|
m->val[5] = 0;
|
2012-05-03 15:42:15 -07:00
|
|
|
m->val[6] = tw;
|
|
|
|
m->val[7] = th;
|
|
|
|
edje_object_message_send(obj, EDJE_MESSAGE_INT_SET, 1, m);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2014-03-27 06:15:52 -07:00
|
|
|
_elm_win_focus_highlight_simple_setup(Elm_Win_Data *sd,
|
2012-05-03 15:42:15 -07:00
|
|
|
Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Evas_Object *clip, *target = sd->focus_highlight.cur.target;
|
|
|
|
Evas_Coord x, y, w, h;
|
|
|
|
|
2014-05-06 22:13:19 -07:00
|
|
|
elm_widget_focus_highlight_geometry_get(target, &x, &y, &w, &h);
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
evas_object_move(obj, x, y);
|
|
|
|
evas_object_resize(obj, w, h);
|
2014-03-08 10:39:23 -08:00
|
|
|
|
|
|
|
if (!_elm_config->focus_highlight_clip_disable)
|
|
|
|
{
|
|
|
|
clip = evas_object_clip_get(target);
|
|
|
|
if (clip) evas_object_clip_set(obj, clip);
|
|
|
|
}
|
2014-03-27 22:17:02 -07:00
|
|
|
|
|
|
|
edje_object_signal_emit(obj, "elm,state,anim,stop", "elm");
|
2012-05-03 15:42:15 -07:00
|
|
|
}
|
|
|
|
|
2014-05-22 19:07:59 -07:00
|
|
|
static void
|
|
|
|
_elm_win_focus_prev_target_del(void *data,
|
|
|
|
Evas *e EINA_UNUSED,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
void *event_info EINA_UNUSED)
|
|
|
|
{
|
|
|
|
ELM_WIN_DATA_GET(data, sd);
|
|
|
|
sd->focus_highlight.prev.target = NULL;
|
|
|
|
}
|
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
static void
|
2014-03-06 10:32:01 -08:00
|
|
|
_elm_win_focus_highlight_reconfigure_job(void *data)
|
2012-05-03 15:42:15 -07:00
|
|
|
{
|
2014-03-06 10:32:01 -08:00
|
|
|
ELM_WIN_DATA_GET(data, sd);
|
2012-05-03 15:42:15 -07:00
|
|
|
Evas_Object *target = sd->focus_highlight.cur.target;
|
|
|
|
Evas_Object *previous = sd->focus_highlight.prev.target;
|
2013-08-04 01:37:30 -07:00
|
|
|
Evas_Object *fobj = sd->focus_highlight.fobj;
|
2012-05-03 15:42:15 -07:00
|
|
|
Eina_Bool visible_changed;
|
|
|
|
Eina_Bool common_visible;
|
|
|
|
const char *sig = NULL;
|
2014-02-05 02:17:41 -08:00
|
|
|
const char *focus_style_target = NULL;
|
|
|
|
const char *focus_style_previous = NULL;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
_elm_win_focus_highlight_reconfigure_job_stop(sd);
|
|
|
|
|
|
|
|
visible_changed = (sd->focus_highlight.cur.visible !=
|
|
|
|
sd->focus_highlight.prev.visible);
|
|
|
|
|
|
|
|
if ((target == previous) && (!visible_changed) &&
|
2013-03-18 02:44:19 -07:00
|
|
|
(!sd->focus_highlight.geometry_changed) &&
|
2013-08-04 01:09:44 -07:00
|
|
|
(!sd->focus_highlight.theme_changed))
|
2012-05-03 15:42:15 -07:00
|
|
|
return;
|
|
|
|
|
2015-04-05 18:54:15 -07:00
|
|
|
if (previous)
|
2014-05-22 19:07:59 -07:00
|
|
|
{
|
|
|
|
evas_object_event_callback_del_full
|
|
|
|
(previous, EVAS_CALLBACK_DEL, _elm_win_focus_prev_target_del, data);
|
2015-04-05 18:54:15 -07:00
|
|
|
if (sd->focus_highlight.prev.in_theme)
|
|
|
|
elm_widget_signal_emit
|
|
|
|
(previous, "elm,action,focus_highlight,hide", "elm");
|
2014-05-22 19:07:59 -07:00
|
|
|
}
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
if (!target)
|
|
|
|
common_visible = EINA_FALSE;
|
2014-02-04 16:57:34 -08:00
|
|
|
else if (sd->focus_highlight.cur.in_theme)
|
2012-05-03 15:42:15 -07:00
|
|
|
{
|
|
|
|
common_visible = EINA_FALSE;
|
|
|
|
if (sd->focus_highlight.cur.visible)
|
|
|
|
sig = "elm,action,focus_highlight,show";
|
|
|
|
else
|
|
|
|
sig = "elm,action,focus_highlight,hide";
|
|
|
|
}
|
|
|
|
else
|
|
|
|
common_visible = sd->focus_highlight.cur.visible;
|
|
|
|
|
|
|
|
if (sig)
|
|
|
|
elm_widget_signal_emit(target, sig, "elm");
|
|
|
|
|
2014-02-04 16:57:34 -08:00
|
|
|
if ((!target) || (!common_visible) || (sd->focus_highlight.cur.in_theme))
|
2012-05-03 15:42:15 -07:00
|
|
|
goto the_end;
|
|
|
|
|
2014-02-05 07:16:59 -08:00
|
|
|
if (previous)
|
|
|
|
focus_style_previous = elm_widget_focus_highlight_style_get(previous);
|
2014-02-05 02:17:41 -08:00
|
|
|
focus_style_target = elm_widget_focus_highlight_style_get(target);
|
|
|
|
|
|
|
|
if (sd->focus_highlight.theme_changed ||
|
|
|
|
(focus_style_target != focus_style_previous))
|
2012-05-03 15:42:15 -07:00
|
|
|
{
|
|
|
|
const char *str;
|
2014-02-05 02:17:41 -08:00
|
|
|
|
|
|
|
if (focus_style_target)
|
|
|
|
str = focus_style_target;
|
|
|
|
else if (sd->focus_highlight.style)
|
2012-05-03 15:42:15 -07:00
|
|
|
str = sd->focus_highlight.style;
|
|
|
|
else
|
|
|
|
str = "default";
|
2014-02-05 02:17:41 -08:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
elm_widget_theme_object_set
|
2013-08-04 01:37:30 -07:00
|
|
|
(sd->obj, fobj, "focus_highlight", "top", str);
|
2013-08-04 01:09:44 -07:00
|
|
|
sd->focus_highlight.theme_changed = EINA_FALSE;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2015-03-04 00:47:54 -08:00
|
|
|
if ((sd->focus_highlight.animate) || (sd->focus_highlight.auto_animate))
|
2012-05-03 15:42:15 -07:00
|
|
|
{
|
2013-08-04 01:37:30 -07:00
|
|
|
str = edje_object_data_get(sd->focus_highlight.fobj, "animate");
|
2013-08-11 02:58:28 -07:00
|
|
|
sd->focus_highlight.animate_supported = ((str) && (!strcmp(str, "on")));
|
2012-05-03 15:42:15 -07:00
|
|
|
}
|
2013-08-15 06:42:59 -07:00
|
|
|
else
|
|
|
|
sd->focus_highlight.animate_supported = EINA_FALSE;
|
2012-05-03 15:42:15 -07:00
|
|
|
}
|
|
|
|
|
2013-08-11 02:58:28 -07:00
|
|
|
if ((sd->focus_highlight.animate_supported) && (previous) &&
|
2014-02-04 16:57:34 -08:00
|
|
|
(!sd->focus_highlight.prev.in_theme))
|
2013-08-04 01:37:30 -07:00
|
|
|
_elm_win_focus_highlight_anim_setup(sd, fobj);
|
2012-05-03 15:42:15 -07:00
|
|
|
else
|
2013-08-04 01:37:30 -07:00
|
|
|
_elm_win_focus_highlight_simple_setup(sd, fobj);
|
|
|
|
evas_object_raise(fobj);
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
the_end:
|
2014-01-22 21:12:46 -08:00
|
|
|
_elm_win_focus_highlight_visible_set(sd, common_visible);
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->focus_highlight.geometry_changed = EINA_FALSE;
|
|
|
|
sd->focus_highlight.prev = sd->focus_highlight.cur;
|
2014-05-22 19:07:59 -07:00
|
|
|
evas_object_event_callback_add
|
|
|
|
(sd->focus_highlight.prev.target,
|
|
|
|
EVAS_CALLBACK_DEL, _elm_win_focus_prev_target_del, data);
|
2012-05-03 15:42:15 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2014-03-27 06:15:52 -07:00
|
|
|
_elm_win_focus_highlight_reconfigure_job_start(Elm_Win_Data *sd)
|
2012-05-03 15:42:15 -07:00
|
|
|
{
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_job_del(sd->focus_highlight.reconf_job);
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
sd->focus_highlight.reconf_job = ecore_job_add(
|
2013-04-24 04:41:37 -07:00
|
|
|
_elm_win_focus_highlight_reconfigure_job, sd->obj);
|
2012-01-08 03:23:59 -08:00
|
|
|
}
|
|
|
|
|
2009-04-04 09:58:28 -07:00
|
|
|
static void
|
|
|
|
_elm_win_focus_in(Ecore_Evas *ee)
|
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
Elm_Win_Data *sd = _elm_win_associate_get(ee);
|
2012-07-18 21:35:50 -07:00
|
|
|
Evas_Object *obj;
|
2013-03-07 23:23:34 -08:00
|
|
|
unsigned int order = 0;
|
2010-09-24 09:41:25 -07:00
|
|
|
|
2014-04-09 03:04:55 -07:00
|
|
|
if ((!sd) || (sd->modal_count)) return;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
obj = sd->obj;
|
2012-10-10 17:35:00 -07:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_widget_top_win_focused_set(obj, EINA_TRUE);
|
2015-01-11 12:18:02 -08:00
|
|
|
if (sd->type != ELM_WIN_FAKE)
|
2011-09-06 18:41:19 -07:00
|
|
|
{
|
2015-01-11 12:18:02 -08:00
|
|
|
if (!elm_widget_focus_order_get(obj)
|
|
|
|
|| (obj == elm_widget_newest_focus_order_get(obj, &order, EINA_TRUE)))
|
|
|
|
{
|
|
|
|
elm_widget_focus_steal(obj);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
elm_widget_focus_restore(obj);
|
2011-09-06 18:41:19 -07:00
|
|
|
}
|
2015-07-06 04:38:34 -07:00
|
|
|
// FIXME: the event is deprecated but still in use.
|
|
|
|
// Has to be removed in EFL2.0
|
|
|
|
evas_object_smart_callback_call(obj, SIG_FOCUS_IN, NULL);
|
2015-07-05 23:21:40 -07:00
|
|
|
eo_do(obj, eo_event_callback_call(ELM_WIDGET_EVENT_FOCUSED, NULL));
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->focus_highlight.cur.visible = EINA_TRUE;
|
|
|
|
_elm_win_focus_highlight_reconfigure_job_start(sd);
|
|
|
|
if (sd->frame_obj)
|
2011-04-14 03:48:43 -07:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
edje_object_signal_emit(sd->frame_obj, "elm,action,focus", "elm");
|
2011-04-14 03:48:43 -07:00
|
|
|
}
|
2012-08-22 02:21:28 -07:00
|
|
|
|
2015-04-29 06:08:57 -07:00
|
|
|
if (_elm_config->atspi_mode)
|
2015-05-13 06:37:47 -07:00
|
|
|
{
|
|
|
|
eo_do(obj, eo_event_callback_call(ELM_INTERFACE_ATSPI_WINDOW_EVENT_WINDOW_ACTIVATED, NULL));
|
|
|
|
elm_interface_atspi_accessible_state_changed_signal_emit(obj, ELM_ATSPI_STATE_ACTIVE, EINA_TRUE);
|
|
|
|
}
|
2015-04-29 06:08:57 -07:00
|
|
|
|
2012-08-22 02:21:28 -07:00
|
|
|
/* do nothing */
|
|
|
|
/* else if (sd->img_obj) */
|
|
|
|
/* { */
|
|
|
|
/* } */
|
2009-04-04 09:58:28 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_win_focus_out(Ecore_Evas *ee)
|
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
Elm_Win_Data *sd = _elm_win_associate_get(ee);
|
2012-07-18 21:35:50 -07:00
|
|
|
Evas_Object *obj;
|
2010-09-24 09:41:25 -07:00
|
|
|
|
2014-02-17 22:58:57 -08:00
|
|
|
if (!sd) return;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
obj = sd->obj;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
elm_object_focus_set(obj, EINA_FALSE);
|
|
|
|
_elm_widget_top_win_focused_set(obj, EINA_FALSE);
|
2015-07-06 04:38:34 -07:00
|
|
|
// FIXME: the event is deprecated but still in use.
|
|
|
|
// Has to be removed in EFL2.0
|
|
|
|
evas_object_smart_callback_call(obj, SIG_FOCUS_OUT, NULL);
|
2015-07-05 23:21:40 -07:00
|
|
|
eo_do(obj, eo_event_callback_call(ELM_WIDGET_EVENT_UNFOCUSED, NULL));
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->focus_highlight.cur.visible = EINA_FALSE;
|
|
|
|
_elm_win_focus_highlight_reconfigure_job_start(sd);
|
|
|
|
if (sd->frame_obj)
|
2011-04-14 03:48:43 -07:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
edje_object_signal_emit(sd->frame_obj, "elm,action,unfocus", "elm");
|
2011-04-14 03:48:43 -07:00
|
|
|
}
|
2012-08-22 02:21:28 -07:00
|
|
|
|
2013-03-06 23:59:51 -08:00
|
|
|
/* access */
|
2013-10-31 07:01:56 -07:00
|
|
|
_elm_access_object_highlight_disable(evas_object_evas_get(obj));
|
2013-03-06 23:59:51 -08:00
|
|
|
|
2015-04-29 06:08:57 -07:00
|
|
|
if (_elm_config->atspi_mode)
|
2015-05-13 06:37:47 -07:00
|
|
|
{
|
|
|
|
eo_do(obj, eo_event_callback_call(ELM_INTERFACE_ATSPI_WINDOW_EVENT_WINDOW_DEACTIVATED, NULL));
|
|
|
|
elm_interface_atspi_accessible_state_changed_signal_emit(obj, ELM_ATSPI_STATE_ACTIVE, EINA_FALSE);
|
|
|
|
}
|
2015-04-29 06:08:57 -07:00
|
|
|
|
2012-08-22 02:21:28 -07:00
|
|
|
/* do nothing */
|
|
|
|
/* if (sd->img_obj) */
|
|
|
|
/* { */
|
|
|
|
/* } */
|
2009-04-04 09:58:28 -07:00
|
|
|
}
|
|
|
|
|
2012-12-04 22:50:27 -08:00
|
|
|
static void
|
2014-03-27 06:15:52 -07:00
|
|
|
_elm_win_available_profiles_del(Elm_Win_Data *sd)
|
2012-12-04 22:50:27 -08:00
|
|
|
{
|
|
|
|
if (!sd->profile.available_list) return;
|
|
|
|
|
|
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < sd->profile.count; i++)
|
2013-05-29 05:11:46 -07:00
|
|
|
ELM_SAFE_FREE(sd->profile.available_list[i], eina_stringshare_del);
|
2012-12-04 22:50:27 -08:00
|
|
|
sd->profile.count = 0;
|
2013-05-29 05:11:46 -07:00
|
|
|
ELM_SAFE_FREE(sd->profile.available_list, free);
|
2012-12-04 22:50:27 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2014-03-27 06:15:52 -07:00
|
|
|
_elm_win_profile_del(Elm_Win_Data *sd)
|
2012-12-04 22:50:27 -08:00
|
|
|
{
|
2013-05-29 05:11:46 -07:00
|
|
|
ELM_SAFE_FREE(sd->profile.name, eina_stringshare_del);
|
2012-12-04 22:50:27 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
2014-03-27 06:15:52 -07:00
|
|
|
_internal_elm_win_profile_set(Elm_Win_Data *sd, const char *profile)
|
2012-12-04 22:50:27 -08:00
|
|
|
{
|
|
|
|
Eina_Bool changed = EINA_FALSE;
|
|
|
|
if (profile)
|
|
|
|
{
|
|
|
|
if (sd->profile.name)
|
|
|
|
{
|
|
|
|
if (strcmp(sd->profile.name, profile) != 0)
|
|
|
|
{
|
|
|
|
eina_stringshare_replace(&(sd->profile.name), profile);
|
|
|
|
changed = EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
sd->profile.name = eina_stringshare_add(profile);
|
|
|
|
changed = EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
_elm_win_profile_del(sd);
|
|
|
|
|
|
|
|
return changed;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2014-03-27 06:15:52 -07:00
|
|
|
_elm_win_profile_update(Elm_Win_Data *sd)
|
2012-12-04 22:50:27 -08:00
|
|
|
{
|
2015-05-27 22:58:47 -07:00
|
|
|
if (getenv("ELM_PROFILE")) return;
|
|
|
|
|
2012-12-04 22:50:27 -08:00
|
|
|
if (sd->profile.available_list)
|
|
|
|
{
|
|
|
|
Eina_Bool found = EINA_FALSE;
|
|
|
|
if (sd->profile.name)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < sd->profile.count; i++)
|
|
|
|
{
|
|
|
|
if (!strcmp(sd->profile.name,
|
|
|
|
sd->profile.available_list[i]))
|
|
|
|
{
|
|
|
|
found = EINA_TRUE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If current profile is not present in an available profiles,
|
|
|
|
* change current profile to the 1st element of an array.
|
|
|
|
*/
|
|
|
|
if (!found)
|
2014-03-27 06:15:52 -07:00
|
|
|
_internal_elm_win_profile_set(sd, sd->profile.available_list[0]);
|
2012-12-04 22:50:27 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
_elm_config_profile_set(sd->profile.name);
|
|
|
|
|
|
|
|
/* update sub ee */
|
|
|
|
Ecore_Evas *ee2;
|
|
|
|
Eina_List *sub, *l = NULL;
|
|
|
|
|
|
|
|
sub = ecore_evas_sub_ecore_evas_list_get(sd->ee);
|
|
|
|
EINA_LIST_FOREACH(sub, l, ee2)
|
|
|
|
ecore_evas_window_profile_set(ee2, sd->profile.name);
|
|
|
|
|
2015-05-13 04:34:44 -07:00
|
|
|
eo_do(sd->obj, eo_event_callback_call(ELM_WIN_EVENT_PROFILE_CHANGED, NULL));
|
2012-12-04 22:50:27 -08:00
|
|
|
}
|
|
|
|
|
2015-07-20 14:35:00 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_WAYLAND
|
2015-03-03 11:59:03 -08:00
|
|
|
static void
|
2015-07-20 14:35:00 -07:00
|
|
|
_elm_win_opaque_update(Elm_Win_Data *sd)
|
2015-03-03 11:59:03 -08:00
|
|
|
{
|
|
|
|
int ox, oy, ow, oh;
|
2015-03-04 12:20:54 -08:00
|
|
|
|
|
|
|
if (sd->fullscreen)
|
|
|
|
{
|
|
|
|
ecore_evas_geometry_get(sd->ee, NULL, NULL, &ow, &oh);
|
|
|
|
ecore_wl_window_opaque_region_set(sd->wl.win, 0, 0, ow, oh);
|
2015-07-30 12:32:37 -07:00
|
|
|
ecore_wl_window_update_location(sd->wl.win, 0, 0);
|
2015-03-04 12:20:54 -08:00
|
|
|
return;
|
|
|
|
}
|
2015-07-16 10:10:13 -07:00
|
|
|
|
2015-07-20 14:35:00 -07:00
|
|
|
edje_object_part_geometry_get(sd->frame_obj, "elm.spacer.opaque",
|
|
|
|
&ox, &oy, &ow, &oh);
|
2015-07-28 12:39:46 -07:00
|
|
|
ecore_wl_window_opaque_region_set(sd->wl.win, ox, oy, ow, oh);
|
2015-07-30 12:32:37 -07:00
|
|
|
ecore_wl_window_update_location(sd->wl.win, ox, oy);
|
2015-07-20 14:35:00 -07:00
|
|
|
}
|
|
|
|
#endif
|
2015-03-03 11:59:03 -08:00
|
|
|
|
2015-07-20 14:35:00 -07:00
|
|
|
static void
|
|
|
|
_elm_win_frame_obj_update(Elm_Win_Data *sd)
|
|
|
|
{
|
|
|
|
int fx, fy, fw, fh;
|
|
|
|
int ox, oy, ow, oh;
|
2015-03-03 11:59:03 -08:00
|
|
|
|
|
|
|
#ifdef HAVE_ELEMENTARY_WAYLAND
|
2015-07-20 14:35:00 -07:00
|
|
|
sd->wl.opaque_dirty = 1;
|
2015-03-03 11:59:03 -08:00
|
|
|
#endif
|
2015-07-20 14:35:00 -07:00
|
|
|
if (sd->fullscreen)
|
|
|
|
{
|
|
|
|
evas_output_framespace_set(sd->evas, 0, 0, 0, 0);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
evas_object_geometry_get(sd->frame_obj, &fx, &fy, &fw, &fh);
|
|
|
|
evas_object_geometry_get(sd->client_obj, &ox, &oy, &ow, &oh);
|
|
|
|
|
|
|
|
evas_output_framespace_set(sd->evas, (ox - fx), (oy - fy), (fw - ow), (fh - oh));
|
2015-03-03 11:59:03 -08:00
|
|
|
}
|
|
|
|
|
2012-03-28 02:02:22 -07:00
|
|
|
static void
|
2012-02-28 03:20:35 -08:00
|
|
|
_elm_win_state_change(Ecore_Evas *ee)
|
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
Elm_Win_Data *sd = _elm_win_associate_get(ee);
|
2012-02-28 03:20:35 -08:00
|
|
|
Evas_Object *obj;
|
|
|
|
Eina_Bool ch_withdrawn = EINA_FALSE;
|
|
|
|
Eina_Bool ch_sticky = EINA_FALSE;
|
|
|
|
Eina_Bool ch_iconified = EINA_FALSE;
|
|
|
|
Eina_Bool ch_fullscreen = EINA_FALSE;
|
|
|
|
Eina_Bool ch_maximized = EINA_FALSE;
|
2012-12-04 22:50:27 -08:00
|
|
|
Eina_Bool ch_profile = EINA_FALSE;
|
2014-02-10 05:09:45 -08:00
|
|
|
Eina_Bool ch_wm_rotation = EINA_FALSE;
|
2012-12-04 22:50:27 -08:00
|
|
|
const char *profile;
|
2012-02-28 03:20:35 -08:00
|
|
|
|
2014-02-17 22:58:57 -08:00
|
|
|
if (!sd) return;
|
2012-03-28 02:02:22 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
obj = sd->obj;
|
2012-02-28 03:20:35 -08:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->withdrawn != ecore_evas_withdrawn_get(sd->ee))
|
2012-02-28 03:20:35 -08:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->withdrawn = ecore_evas_withdrawn_get(sd->ee);
|
2012-02-28 03:20:35 -08:00
|
|
|
ch_withdrawn = EINA_TRUE;
|
|
|
|
}
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->sticky != ecore_evas_sticky_get(sd->ee))
|
2012-02-28 03:20:35 -08:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->sticky = ecore_evas_sticky_get(sd->ee);
|
2012-02-28 03:20:35 -08:00
|
|
|
ch_sticky = EINA_TRUE;
|
|
|
|
}
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->iconified != ecore_evas_iconified_get(sd->ee))
|
2012-02-28 03:20:35 -08:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->iconified = ecore_evas_iconified_get(sd->ee);
|
2012-02-28 03:20:35 -08:00
|
|
|
ch_iconified = EINA_TRUE;
|
|
|
|
}
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->fullscreen != ecore_evas_fullscreen_get(sd->ee))
|
2012-02-28 03:20:35 -08:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->fullscreen = ecore_evas_fullscreen_get(sd->ee);
|
2012-02-28 03:20:35 -08:00
|
|
|
ch_fullscreen = EINA_TRUE;
|
|
|
|
}
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->maximized != ecore_evas_maximized_get(sd->ee))
|
2012-02-28 03:20:35 -08:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->maximized = ecore_evas_maximized_get(sd->ee);
|
2012-02-28 03:20:35 -08:00
|
|
|
ch_maximized = EINA_TRUE;
|
|
|
|
}
|
2012-08-28 03:37:02 -07:00
|
|
|
|
2015-02-05 22:06:49 -08:00
|
|
|
if (ecore_evas_window_profile_supported_get(sd->ee))
|
|
|
|
{
|
|
|
|
profile = ecore_evas_window_profile_get(sd->ee);
|
|
|
|
ch_profile = _internal_elm_win_profile_set(sd, profile);
|
|
|
|
}
|
2012-12-04 22:50:27 -08:00
|
|
|
|
2014-02-10 05:09:45 -08:00
|
|
|
if (sd->wm_rot.use)
|
|
|
|
{
|
|
|
|
if (sd->rot != ecore_evas_rotation_get(sd->ee))
|
|
|
|
{
|
|
|
|
sd->rot = ecore_evas_rotation_get(sd->ee);
|
|
|
|
ch_wm_rotation = EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-28 03:37:02 -07:00
|
|
|
_elm_win_state_eval_queue();
|
2012-10-10 17:35:00 -07:00
|
|
|
|
2012-02-28 03:20:35 -08:00
|
|
|
if ((ch_withdrawn) || (ch_iconified))
|
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->withdrawn)
|
2015-05-13 04:34:44 -07:00
|
|
|
eo_do(obj, eo_event_callback_call(ELM_WIN_EVENT_WITHDRAWN, NULL));
|
2012-05-03 15:42:15 -07:00
|
|
|
else if (sd->iconified)
|
2015-04-29 06:08:57 -07:00
|
|
|
{
|
2015-05-13 04:34:44 -07:00
|
|
|
eo_do(obj, eo_event_callback_call(ELM_WIN_EVENT_ICONIFIED, NULL));
|
2015-04-29 06:08:57 -07:00
|
|
|
if (_elm_config->atspi_mode)
|
2015-05-13 04:34:44 -07:00
|
|
|
eo_do(obj, eo_event_callback_call
|
|
|
|
(ELM_INTERFACE_ATSPI_WINDOW_EVENT_WINDOW_MINIMIZED, NULL));
|
2015-04-29 06:08:57 -07:00
|
|
|
}
|
2012-02-28 03:20:35 -08:00
|
|
|
else
|
2015-04-29 06:08:57 -07:00
|
|
|
{
|
2015-05-13 04:34:44 -07:00
|
|
|
eo_do(obj, eo_event_callback_call(ELM_WIN_EVENT_NORMAL, NULL));
|
2015-04-29 06:08:57 -07:00
|
|
|
if (_elm_config->atspi_mode)
|
2015-05-13 04:34:44 -07:00
|
|
|
eo_do(obj, eo_event_callback_call
|
|
|
|
(ELM_INTERFACE_ATSPI_WINDOW_EVENT_WINDOW_RESTORED, NULL));
|
2015-04-29 06:08:57 -07:00
|
|
|
}
|
2012-02-28 03:20:35 -08:00
|
|
|
}
|
|
|
|
if (ch_sticky)
|
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->sticky)
|
2015-05-13 04:34:44 -07:00
|
|
|
eo_do(obj, eo_event_callback_call(ELM_WIN_EVENT_STICK, NULL));
|
2012-02-28 03:20:35 -08:00
|
|
|
else
|
2015-05-13 04:34:44 -07:00
|
|
|
eo_do(obj, eo_event_callback_call(ELM_WIN_EVENT_UNSTICK, NULL));
|
2012-02-28 03:20:35 -08:00
|
|
|
}
|
|
|
|
if (ch_fullscreen)
|
|
|
|
{
|
2015-03-04 12:20:54 -08:00
|
|
|
_elm_win_frame_obj_update(sd);
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->fullscreen)
|
2015-03-03 11:59:33 -08:00
|
|
|
{
|
|
|
|
int w, h;
|
|
|
|
|
2015-05-13 04:34:44 -07:00
|
|
|
eo_do(obj, eo_event_callback_call
|
|
|
|
(ELM_WIN_EVENT_FULLSCREEN, NULL));
|
2015-03-03 11:59:33 -08:00
|
|
|
if (sd->frame_obj)
|
|
|
|
evas_object_hide(sd->frame_obj);
|
|
|
|
ecore_evas_geometry_get(sd->ee, NULL, NULL, &w, &h);
|
|
|
|
ecore_evas_resize(sd->ee, w, h);
|
|
|
|
}
|
2012-02-28 03:20:35 -08:00
|
|
|
else
|
2015-03-03 11:59:33 -08:00
|
|
|
{
|
2015-05-13 04:34:44 -07:00
|
|
|
eo_do(obj, eo_event_callback_call
|
|
|
|
(ELM_WIN_EVENT_UNFULLSCREEN, NULL));
|
2015-03-03 11:59:33 -08:00
|
|
|
if (sd->frame_obj)
|
2015-03-04 12:20:54 -08:00
|
|
|
evas_object_show(sd->frame_obj);
|
2015-03-03 11:59:33 -08:00
|
|
|
}
|
2012-02-28 03:20:35 -08:00
|
|
|
}
|
|
|
|
if (ch_maximized)
|
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->maximized)
|
2015-04-29 06:08:57 -07:00
|
|
|
{
|
2015-05-13 04:34:44 -07:00
|
|
|
eo_do(obj, eo_event_callback_call(ELM_WIN_EVENT_MAXIMIZED, NULL));
|
2015-04-29 06:08:57 -07:00
|
|
|
if (_elm_config->atspi_mode)
|
2015-05-13 04:34:44 -07:00
|
|
|
eo_do(obj, eo_event_callback_call
|
|
|
|
(ELM_INTERFACE_ATSPI_WINDOW_EVENT_WINDOW_MAXIMIZED, NULL));
|
2015-04-29 06:08:57 -07:00
|
|
|
}
|
2012-02-28 03:20:35 -08:00
|
|
|
else
|
2015-04-29 06:08:57 -07:00
|
|
|
{
|
2015-05-13 04:34:44 -07:00
|
|
|
eo_do(obj, eo_event_callback_call(ELM_WIN_EVENT_UNMAXIMIZED, NULL));
|
2015-04-29 06:08:57 -07:00
|
|
|
if (_elm_config->atspi_mode)
|
2015-05-13 04:34:44 -07:00
|
|
|
eo_do(obj, eo_event_callback_call
|
|
|
|
(ELM_INTERFACE_ATSPI_WINDOW_EVENT_WINDOW_RESTORED, NULL));
|
2015-04-29 06:08:57 -07:00
|
|
|
}
|
2012-02-28 03:20:35 -08:00
|
|
|
}
|
2012-12-04 22:50:27 -08:00
|
|
|
if (ch_profile)
|
|
|
|
{
|
|
|
|
_elm_win_profile_update(sd);
|
|
|
|
}
|
2014-02-10 05:09:45 -08:00
|
|
|
if (ch_wm_rotation)
|
|
|
|
{
|
|
|
|
evas_object_size_hint_min_set(obj, -1, -1);
|
|
|
|
evas_object_size_hint_max_set(obj, -1, -1);
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
_elm_win_xwin_update(sd);
|
|
|
|
#endif
|
|
|
|
elm_widget_orientation_set(obj, sd->rot);
|
2015-05-13 04:34:44 -07:00
|
|
|
eo_do(obj, eo_event_callback_call
|
|
|
|
(ELM_WIN_EVENT_ROTATION_CHANGED, NULL));
|
|
|
|
eo_do(obj, eo_event_callback_call
|
|
|
|
(ELM_WIN_EVENT_WM_ROTATION_CHANGED, NULL));
|
2014-02-10 05:09:45 -08:00
|
|
|
}
|
2012-02-28 03:20:35 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_elm_widget_focus_next_manager_is(Eo *obj EINA_UNUSED, Elm_Win_Data *_pd EINA_UNUSED)
|
2010-09-24 07:47:59 -07:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return EINA_TRUE;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_elm_widget_focus_next(Eo *obj, Elm_Win_Data *_pd EINA_UNUSED, Elm_Focus_Direction dir, Evas_Object **next)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd, EINA_FALSE);
|
2012-05-02 18:19:05 -07:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
const Eina_List *items;
|
|
|
|
void *(*list_data_get)(const Eina_List *list);
|
2010-09-24 07:47:59 -07:00
|
|
|
|
|
|
|
/* Focus chain */
|
2012-11-25 22:32:53 -08: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)))
|
2012-05-03 15:42:15 -07:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
items = wd->subobjs;
|
2012-05-03 15:42:15 -07:00
|
|
|
if (!items)
|
2014-03-27 06:15:52 -07:00
|
|
|
return EINA_FALSE;
|
2012-05-03 15:42:15 -07:00
|
|
|
}
|
2010-10-21 11:58:43 -07:00
|
|
|
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
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
if (*next) return EINA_TRUE;
|
2010-10-21 11:58:43 -07:00
|
|
|
}
|
|
|
|
*next = (Evas_Object *)obj;
|
2014-03-27 06:15:52 -07:00
|
|
|
return EINA_FALSE;
|
2010-09-24 07:47:59 -07:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_elm_widget_focus_direction_manager_is(Eo *obj EINA_UNUSED, Elm_Win_Data *_pd EINA_UNUSED)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return EINA_TRUE;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_elm_widget_focus_direction(Eo *obj, Elm_Win_Data *_pd EINA_UNUSED, const Evas_Object *base, double degree, Evas_Object **direction, double *weight)
|
|
|
|
{
|
2012-05-02 20:02:54 -07:00
|
|
|
const Eina_List *items;
|
2012-05-03 15:42:15 -07:00
|
|
|
void *(*list_data_get)(const Eina_List *list);
|
2012-05-02 20:02:54 -07:00
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd, EINA_FALSE);
|
2012-05-02 20:02:54 -07:00
|
|
|
|
|
|
|
/* Focus chain */
|
2012-11-25 22:32:53 -08:00
|
|
|
if (wd->subobjs)
|
2012-05-02 20:02:54 -07:00
|
|
|
{
|
|
|
|
if (!(items = elm_widget_focus_custom_chain_get(obj)))
|
2012-11-25 22:32:53 -08:00
|
|
|
items = wd->subobjs;
|
2012-05-02 20:02:54 -07:00
|
|
|
|
|
|
|
list_data_get = eina_list_data_get;
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
return elm_widget_focus_list_direction_get
|
2012-05-03 15:42:15 -07:00
|
|
|
(obj, base, items, list_data_get, degree, direction, weight);
|
2012-05-02 20:02:54 -07:00
|
|
|
}
|
2014-03-27 06:15:52 -07:00
|
|
|
|
|
|
|
return EINA_FALSE;
|
2012-05-02 20:02:54 -07:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_elm_widget_on_focus(Eo *obj, Elm_Win_Data *sd)
|
2010-10-21 11:58:43 -07:00
|
|
|
{
|
2013-06-06 09:13:37 -07:00
|
|
|
Eina_Bool int_ret = EINA_FALSE;
|
2014-04-03 09:23:03 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, int_ret = elm_obj_widget_on_focus());
|
2014-03-27 06:15:52 -07:00
|
|
|
if (!int_ret) return EINA_TRUE;
|
2011-04-20 07:16:51 -07:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->img_obj)
|
|
|
|
evas_object_focus_set(sd->img_obj, elm_widget_focus_get(obj));
|
2010-10-21 11:58:43 -07:00
|
|
|
else
|
2012-05-03 15:42:15 -07:00
|
|
|
evas_object_focus_set(obj, elm_widget_focus_get(obj));
|
2014-03-27 06:15:52 -07:00
|
|
|
|
|
|
|
return EINA_TRUE;
|
2010-10-21 11:58:43 -07:00
|
|
|
}
|
|
|
|
|
2014-04-15 18:38:34 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_key_action_return(Evas_Object *obj EINA_UNUSED, const char *params EINA_UNUSED)
|
|
|
|
{
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_key_action_move(Evas_Object *obj, const char *params)
|
|
|
|
{
|
|
|
|
const char *dir = params;
|
2015-03-04 00:47:54 -08:00
|
|
|
Evas_Object *top;
|
2014-04-15 18:38:34 -07:00
|
|
|
|
2015-03-04 00:47:54 -08:00
|
|
|
top = elm_widget_top_get(obj);
|
|
|
|
if (top && eo_isa(top, ELM_WIN_CLASS)) _elm_win_focus_auto_show(top);
|
2014-04-15 18:38:34 -07:00
|
|
|
if (!strcmp(dir, "previous"))
|
|
|
|
elm_widget_focus_cycle(obj, ELM_FOCUS_PREVIOUS);
|
|
|
|
else if (!strcmp(dir, "next"))
|
|
|
|
elm_widget_focus_cycle(obj, ELM_FOCUS_NEXT);
|
|
|
|
else if (!strcmp(dir, "left"))
|
|
|
|
elm_widget_focus_cycle(obj, ELM_FOCUS_LEFT);
|
|
|
|
else if (!strcmp(dir, "right"))
|
|
|
|
elm_widget_focus_cycle(obj, ELM_FOCUS_RIGHT);
|
|
|
|
else if (!strcmp(dir, "up"))
|
|
|
|
elm_widget_focus_cycle(obj, ELM_FOCUS_UP);
|
|
|
|
else if (!strcmp(dir, "down"))
|
|
|
|
elm_widget_focus_cycle(obj, ELM_FOCUS_DOWN);
|
|
|
|
else return EINA_FALSE;
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_elm_widget_event(Eo *obj, Elm_Win_Data *_pd EINA_UNUSED, Evas_Object *src, Evas_Callback_Type type, void *event_info)
|
2010-09-24 07:47:59 -07:00
|
|
|
{
|
2013-10-28 07:06:14 -07:00
|
|
|
(void) src;
|
2014-03-27 06:15:52 -07:00
|
|
|
Evas_Event_Key_Down *ev = event_info;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
if (elm_widget_disabled_get(obj)) return EINA_FALSE;
|
|
|
|
if (type != EVAS_CALLBACK_KEY_DOWN) return EINA_FALSE;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2014-04-15 18:38:34 -07:00
|
|
|
if (!_elm_config_key_binding_call(obj, ev, key_actions))
|
|
|
|
return EINA_FALSE;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
|
2014-03-27 06:15:52 -07:00
|
|
|
return EINA_TRUE;
|
2010-09-24 07:47:59 -07:00
|
|
|
}
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
2014-06-03 03:35:28 -07:00
|
|
|
_elm_win_evas_object_smart_show(Eo *obj, Elm_Win_Data *sd)
|
2010-10-21 11:58:43 -07:00
|
|
|
{
|
2014-04-09 03:04:55 -07:00
|
|
|
if (sd->modal_count) return;
|
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *current;
|
|
|
|
|
2012-08-28 03:37:02 -07:00
|
|
|
if (!evas_object_visible_get(obj))
|
2013-01-14 01:46:25 -08:00
|
|
|
_elm_win_state_eval_queue();
|
2013-03-18 09:07:38 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, evas_obj_smart_show());
|
2011-05-07 01:37:47 -07:00
|
|
|
|
2014-04-09 03:04:55 -07:00
|
|
|
if ((sd->modal) && (!evas_object_visible_get(obj)))
|
|
|
|
{
|
|
|
|
INCREMENT_MODALITY()
|
|
|
|
}
|
|
|
|
|
2012-07-18 21:35:50 -07:00
|
|
|
TRAP(sd, show);
|
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->shot.info) _shot_handle(sd);
|
2010-10-21 11:58:43 -07:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
2014-06-03 03:35:28 -07:00
|
|
|
_elm_win_evas_object_smart_hide(Eo *obj, Elm_Win_Data *sd)
|
2011-04-14 03:48:43 -07:00
|
|
|
{
|
2014-04-09 03:04:55 -07:00
|
|
|
if (sd->modal_count) return;
|
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *current;
|
|
|
|
|
2012-08-28 03:37:02 -07:00
|
|
|
if (evas_object_visible_get(obj))
|
2013-01-14 01:46:25 -08:00
|
|
|
_elm_win_state_eval_queue();
|
2013-03-18 09:07:38 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, evas_obj_smart_hide());
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2014-04-09 03:04:55 -07:00
|
|
|
if ((sd->modal) && (evas_object_visible_get(obj)))
|
|
|
|
{
|
|
|
|
DECREMENT_MODALITY()
|
|
|
|
}
|
|
|
|
|
2012-07-18 21:35:50 -07:00
|
|
|
TRAP(sd, hide);
|
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->frame_obj)
|
2011-04-14 03:48:43 -07:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
evas_object_hide(sd->frame_obj);
|
2011-04-14 03:48:43 -07:00
|
|
|
}
|
2012-08-22 02:21:28 -07:00
|
|
|
if (sd->img_obj)
|
2011-04-14 03:48:43 -07:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
evas_object_hide(sd->img_obj);
|
2011-04-14 03:48:43 -07:00
|
|
|
}
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->pointer.obj)
|
2012-02-10 00:37:16 -08:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
evas_object_hide(sd->pointer.obj);
|
2015-04-29 01:30:18 -07:00
|
|
|
#if 0
|
2012-05-03 15:42:15 -07:00
|
|
|
ecore_evas_hide(sd->pointer.ee);
|
2015-04-29 01:30:18 -07:00
|
|
|
#endif
|
2012-02-10 00:37:16 -08:00
|
|
|
}
|
2015-04-29 06:08:57 -07:00
|
|
|
if (_elm_config->atspi_mode)
|
|
|
|
eo_do(obj, eo_event_callback_call(ELM_INTERFACE_ATSPI_WINDOW_EVENT_WINDOW_DESTROYED, NULL));
|
2015-07-01 07:40:57 -07:00
|
|
|
|
|
|
|
if (_elm_win_policy_quit_triggered(obj))
|
|
|
|
_elm_win_flush_cache_and_exit(obj);
|
2011-04-14 03:48:43 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_on_parent_del(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas *e EINA_UNUSED,
|
2012-05-03 15:42:15 -07:00
|
|
|
Evas_Object *obj,
|
2014-01-06 06:30:02 -08:00
|
|
|
void *event_info EINA_UNUSED)
|
2012-05-02 18:19:05 -07:00
|
|
|
{
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_WIN_DATA_GET(data, sd);
|
2012-05-02 18:19:05 -07:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
if (obj == sd->parent) sd->parent = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_win_focus_target_move(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas *e EINA_UNUSED,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
void *event_info EINA_UNUSED)
|
2012-05-03 15:42:15 -07:00
|
|
|
{
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_WIN_DATA_GET(data, sd);
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
sd->focus_highlight.geometry_changed = EINA_TRUE;
|
|
|
|
_elm_win_focus_highlight_reconfigure_job_start(sd);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_win_focus_target_resize(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas *e EINA_UNUSED,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
void *event_info EINA_UNUSED)
|
2012-05-03 15:42:15 -07:00
|
|
|
{
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_WIN_DATA_GET(data, sd);
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
sd->focus_highlight.geometry_changed = EINA_TRUE;
|
|
|
|
_elm_win_focus_highlight_reconfigure_job_start(sd);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_win_focus_target_del(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas *e EINA_UNUSED,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
void *event_info EINA_UNUSED)
|
2012-05-03 15:42:15 -07:00
|
|
|
{
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_WIN_DATA_GET(data, sd);
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
sd->focus_highlight.cur.target = NULL;
|
|
|
|
|
|
|
|
_elm_win_focus_highlight_reconfigure_job_start(sd);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Evas_Object *
|
|
|
|
_elm_win_focus_target_get(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Evas_Object *o = obj;
|
|
|
|
|
|
|
|
do
|
2012-05-02 18:19:05 -07:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
if (elm_widget_is(o))
|
2012-05-02 18:19:05 -07:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
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
|
2014-03-27 06:15:52 -07:00
|
|
|
_elm_win_focus_target_callbacks_add(Elm_Win_Data *sd)
|
2012-05-03 15:42:15 -07:00
|
|
|
{
|
|
|
|
Evas_Object *obj = sd->focus_highlight.cur.target;
|
2012-12-07 23:00:55 -08:00
|
|
|
if (!obj) return;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
evas_object_event_callback_add
|
2013-04-24 04:41:37 -07:00
|
|
|
(obj, EVAS_CALLBACK_MOVE, _elm_win_focus_target_move, sd->obj);
|
2012-05-03 15:42:15 -07:00
|
|
|
evas_object_event_callback_add
|
2013-04-24 04:41:37 -07:00
|
|
|
(obj, EVAS_CALLBACK_RESIZE, _elm_win_focus_target_resize, sd->obj);
|
2012-05-03 15:42:15 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2014-03-27 06:15:52 -07:00
|
|
|
_elm_win_focus_target_callbacks_del(Elm_Win_Data *sd)
|
2012-05-03 15:42:15 -07:00
|
|
|
{
|
|
|
|
Evas_Object *obj = sd->focus_highlight.cur.target;
|
|
|
|
|
|
|
|
evas_object_event_callback_del_full
|
2013-04-24 04:41:37 -07:00
|
|
|
(obj, EVAS_CALLBACK_MOVE, _elm_win_focus_target_move, sd->obj);
|
2012-05-03 15:42:15 -07:00
|
|
|
evas_object_event_callback_del_full
|
2013-04-24 04:41:37 -07:00
|
|
|
(obj, EVAS_CALLBACK_RESIZE, _elm_win_focus_target_resize, sd->obj);
|
2012-05-03 15:42:15 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_win_object_focus_in(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas *e EINA_UNUSED,
|
2012-05-03 15:42:15 -07:00
|
|
|
void *event_info)
|
|
|
|
{
|
|
|
|
Evas_Object *obj = event_info, *target;
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_WIN_DATA_GET(data, sd);
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
if (sd->focus_highlight.cur.target == obj)
|
|
|
|
return;
|
|
|
|
|
|
|
|
target = _elm_win_focus_target_get(obj);
|
|
|
|
sd->focus_highlight.cur.target = target;
|
2014-01-15 09:33:46 -08:00
|
|
|
if (target && elm_widget_highlight_in_theme_get(target))
|
2014-02-04 16:57:34 -08:00
|
|
|
sd->focus_highlight.cur.in_theme = EINA_TRUE;
|
2012-05-03 15:42:15 -07:00
|
|
|
else
|
|
|
|
_elm_win_focus_target_callbacks_add(sd);
|
|
|
|
|
2015-08-04 22:46:01 -07:00
|
|
|
evas_object_event_callback_add
|
|
|
|
(target, EVAS_CALLBACK_DEL, _elm_win_focus_target_del, sd->obj);
|
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_focus_highlight_reconfigure_job_start(sd);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_win_object_focus_out(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas *e EINA_UNUSED,
|
|
|
|
void *event_info EINA_UNUSED)
|
2012-05-03 15:42:15 -07:00
|
|
|
{
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_WIN_DATA_GET(data, sd);
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
if (!sd->focus_highlight.cur.target)
|
|
|
|
return;
|
|
|
|
|
2014-02-04 16:57:34 -08:00
|
|
|
if (!sd->focus_highlight.cur.in_theme)
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_focus_target_callbacks_del(sd);
|
|
|
|
|
2015-08-04 22:46:01 -07:00
|
|
|
evas_object_event_callback_del_full
|
|
|
|
(sd->focus_highlight.cur.target,
|
|
|
|
EVAS_CALLBACK_DEL, _elm_win_focus_target_del, sd->obj);
|
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->focus_highlight.cur.target = NULL;
|
2014-02-04 16:57:34 -08:00
|
|
|
sd->focus_highlight.cur.in_theme = EINA_FALSE;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
_elm_win_focus_highlight_reconfigure_job_start(sd);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2014-03-27 06:15:52 -07:00
|
|
|
_elm_win_focus_highlight_shutdown(Elm_Win_Data *sd)
|
2012-05-03 15:42:15 -07:00
|
|
|
{
|
|
|
|
_elm_win_focus_highlight_reconfigure_job_stop(sd);
|
|
|
|
if (sd->focus_highlight.cur.target)
|
|
|
|
{
|
2013-07-12 20:37:03 -07:00
|
|
|
elm_widget_signal_emit(sd->focus_highlight.cur.target,
|
|
|
|
"elm,action,focus_highlight,hide", "elm");
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_focus_target_callbacks_del(sd);
|
2015-08-04 22:46:01 -07:00
|
|
|
evas_object_event_callback_del_full
|
|
|
|
(sd->focus_highlight.cur.target,
|
|
|
|
EVAS_CALLBACK_DEL, _elm_win_focus_target_del, sd->obj);
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->focus_highlight.cur.target = NULL;
|
|
|
|
}
|
2013-08-04 01:37:30 -07:00
|
|
|
ELM_SAFE_FREE(sd->focus_highlight.fobj, evas_object_del);
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
evas_event_callback_del_full
|
|
|
|
(sd->evas, EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_IN,
|
2013-04-24 04:41:37 -07:00
|
|
|
_elm_win_object_focus_in, sd->obj);
|
2012-05-03 15:42:15 -07:00
|
|
|
evas_event_callback_del_full
|
|
|
|
(sd->evas, EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_OUT,
|
2013-04-24 04:41:37 -07:00
|
|
|
_elm_win_object_focus_out, sd->obj);
|
2012-05-03 15:42:15 -07:00
|
|
|
}
|
|
|
|
|
2014-02-17 23:15:55 -08:00
|
|
|
static void
|
|
|
|
_win_img_hide(void *data,
|
|
|
|
Evas *e EINA_UNUSED,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
void *event_info EINA_UNUSED)
|
|
|
|
{
|
|
|
|
elm_widget_focus_hide_handle(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_win_img_mouse_up(void *data,
|
|
|
|
Evas *e EINA_UNUSED,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
void *event_info)
|
|
|
|
{
|
|
|
|
Evas_Event_Mouse_Up *ev = event_info;
|
|
|
|
if (!(ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD))
|
|
|
|
elm_widget_focus_mouse_up_handle(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_win_img_focus_in(void *data,
|
|
|
|
Evas *e EINA_UNUSED,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
void *event_info EINA_UNUSED)
|
|
|
|
{
|
|
|
|
elm_widget_focus_steal(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_win_img_focus_out(void *data,
|
|
|
|
Evas *e EINA_UNUSED,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
void *event_info EINA_UNUSED)
|
|
|
|
{
|
|
|
|
elm_widget_focused_object_clear(data);
|
|
|
|
}
|
|
|
|
|
2012-07-23 01:23:01 -07:00
|
|
|
static void
|
|
|
|
_elm_win_on_img_obj_del(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas *e EINA_UNUSED,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
void *event_info EINA_UNUSED)
|
2012-07-23 01:23:01 -07:00
|
|
|
{
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_WIN_DATA_GET(data, sd);
|
2014-02-17 23:15:55 -08:00
|
|
|
_elm_win_img_callbacks_del(sd->obj, sd->img_obj);
|
2012-07-23 01:23:01 -07:00
|
|
|
sd->img_obj = NULL;
|
|
|
|
}
|
|
|
|
|
2014-02-17 23:15:55 -08:00
|
|
|
static void
|
|
|
|
_elm_win_img_callbacks_del(Evas_Object *obj, Evas_Object *imgobj)
|
|
|
|
{
|
|
|
|
evas_object_event_callback_del_full
|
|
|
|
(imgobj, EVAS_CALLBACK_DEL, _elm_win_on_img_obj_del, obj);
|
|
|
|
evas_object_event_callback_del_full
|
|
|
|
(imgobj, EVAS_CALLBACK_HIDE, _win_img_hide, obj);
|
|
|
|
evas_object_event_callback_del_full
|
|
|
|
(imgobj, EVAS_CALLBACK_MOUSE_UP, _win_img_mouse_up, obj);
|
|
|
|
evas_object_event_callback_del_full
|
|
|
|
(imgobj, EVAS_CALLBACK_FOCUS_IN, _win_img_focus_in, obj);
|
|
|
|
evas_object_event_callback_del_full
|
|
|
|
(imgobj, EVAS_CALLBACK_FOCUS_OUT, _win_img_focus_out, obj);
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
2014-06-03 03:35:28 -07:00
|
|
|
_elm_win_evas_object_smart_del(Eo *obj, Elm_Win_Data *sd)
|
2012-05-03 15:42:15 -07:00
|
|
|
{
|
2014-04-09 03:04:55 -07:00
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *current;
|
|
|
|
|
|
|
|
if ((sd->modal) && (evas_object_visible_get(obj)))
|
|
|
|
{
|
|
|
|
DECREMENT_MODALITY()
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((sd->modal) && (sd->modal_count > 0))
|
|
|
|
ERR("Deleted modal win was blocked by another modal win which was created after creation of that win.");
|
|
|
|
|
2014-12-15 09:02:40 -08:00
|
|
|
evas_object_event_callback_del_full(sd->edje,
|
2013-01-18 07:56:25 -08:00
|
|
|
EVAS_CALLBACK_CHANGED_SIZE_HINTS,
|
|
|
|
_elm_win_on_resize_obj_changed_size_hints,
|
|
|
|
obj);
|
2013-01-17 14:11:15 -08:00
|
|
|
evas_object_del(sd->box);
|
2014-12-15 09:02:40 -08:00
|
|
|
evas_object_del(sd->edje);
|
2013-01-17 14:11:15 -08:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
/* NB: child deletion handled by parent's smart del */
|
|
|
|
|
2015-06-16 14:00:44 -07:00
|
|
|
if ((sd->type != ELM_WIN_FAKE) && (trap) && (trap->del))
|
2012-07-18 21:35:50 -07:00
|
|
|
trap->del(sd->trap_data, obj);
|
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->parent)
|
|
|
|
{
|
|
|
|
evas_object_event_callback_del_full
|
2013-04-24 04:41:37 -07:00
|
|
|
(sd->parent, EVAS_CALLBACK_DEL, _elm_win_on_parent_del, obj);
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->parent = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sd->autodel_clear) *(sd->autodel_clear) = -1;
|
|
|
|
|
|
|
|
_elm_win_list = eina_list_remove(_elm_win_list, obj);
|
2012-08-28 03:37:02 -07:00
|
|
|
_elm_win_count--;
|
|
|
|
_elm_win_state_eval_queue();
|
2012-10-10 17:35:00 -07:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->ee)
|
|
|
|
{
|
|
|
|
ecore_evas_callback_delete_request_set(sd->ee, NULL);
|
|
|
|
ecore_evas_callback_resize_set(sd->ee, NULL);
|
|
|
|
}
|
2013-05-22 23:54:49 -07:00
|
|
|
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_job_del(sd->deferred_resize_job);
|
|
|
|
ecore_job_del(sd->deferred_child_eval_job);
|
|
|
|
eina_stringshare_del(sd->shot.info);
|
|
|
|
ecore_timer_del(sd->shot.timer);
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2012-05-02 18:19:05 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_event_handler_del(sd->x.client_message_handler);
|
|
|
|
ecore_event_handler_del(sd->x.property_handler);
|
2012-05-02 18:19:05 -07:00
|
|
|
#endif
|
2008-10-06 18:23:49 -07:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->img_obj)
|
2012-05-02 18:19:05 -07:00
|
|
|
{
|
2014-02-17 23:15:55 -08:00
|
|
|
_elm_win_img_callbacks_del(obj, sd->img_obj);
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->img_obj = NULL;
|
2012-05-02 18:19:05 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-06-16 14:01:02 -07:00
|
|
|
if (sd->ee && (sd->type != ELM_WIN_FAKE))
|
2012-05-02 18:19:05 -07:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
ecore_job_add(_deferred_ecore_evas_free, sd->ee);
|
2012-05-02 18:19:05 -07:00
|
|
|
_elm_win_deferred_free++;
|
|
|
|
}
|
|
|
|
}
|
2011-03-09 22:35:33 -08:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_focus_highlight_shutdown(sd);
|
|
|
|
eina_stringshare_del(sd->focus_highlight.style);
|
2012-05-02 18:19:05 -07:00
|
|
|
|
2014-01-21 17:12:44 -08:00
|
|
|
eina_stringshare_del(sd->title);
|
|
|
|
eina_stringshare_del(sd->icon_name);
|
|
|
|
eina_stringshare_del(sd->role);
|
2015-04-17 15:10:11 -07:00
|
|
|
eina_stringshare_del(sd->name);
|
2014-01-21 17:12:44 -08:00
|
|
|
evas_object_del(sd->icon);
|
2014-01-21 17:38:55 -08:00
|
|
|
evas_object_del(sd->main_menu);
|
2012-12-27 05:38:33 -08:00
|
|
|
|
2012-12-04 22:50:27 -08:00
|
|
|
_elm_win_profile_del(sd);
|
|
|
|
_elm_win_available_profiles_del(sd);
|
|
|
|
|
2012-07-19 21:20:06 -07:00
|
|
|
/* Don't let callback in the air that point to sd */
|
|
|
|
ecore_evas_callback_delete_request_set(sd->ee, NULL);
|
|
|
|
ecore_evas_callback_resize_set(sd->ee, NULL);
|
|
|
|
ecore_evas_callback_mouse_in_set(sd->ee, NULL);
|
|
|
|
ecore_evas_callback_focus_in_set(sd->ee, NULL);
|
|
|
|
ecore_evas_callback_focus_out_set(sd->ee, NULL);
|
|
|
|
ecore_evas_callback_move_set(sd->ee, NULL);
|
|
|
|
ecore_evas_callback_state_change_set(sd->ee, NULL);
|
|
|
|
|
2013-03-18 09:07:38 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, evas_obj_smart_del());
|
2012-05-02 18:19:05 -07:00
|
|
|
|
2015-07-01 07:40:57 -07:00
|
|
|
if (_elm_win_policy_quit_triggered(obj))
|
2012-05-02 18:19:05 -07:00
|
|
|
{
|
2015-07-01 07:40:57 -07:00
|
|
|
_elm_win_flush_cache_and_exit(obj);
|
2012-05-02 18:19:05 -07:00
|
|
|
}
|
2015-06-29 07:30:34 -07:00
|
|
|
|
|
|
|
if (_elm_config->atspi_mode)
|
|
|
|
eo_do(obj, eo_event_callback_call(ELM_INTERFACE_ATSPI_WINDOW_EVENT_WINDOW_DESTROYED, NULL));
|
2012-05-02 09:58:56 -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
|
|
|
|
2011-04-14 03:48:43 -07:00
|
|
|
static void
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_obj_intercept_show(void *data,
|
|
|
|
Evas_Object *obj)
|
2011-04-14 03:48:43 -07:00
|
|
|
{
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_WIN_DATA_GET(data, sd);
|
2012-05-03 15:42:15 -07:00
|
|
|
|
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));
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->frame_obj)
|
2011-04-14 03:48:43 -07:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
evas_object_show(sd->frame_obj);
|
2011-04-14 03:48:43 -07:00
|
|
|
}
|
2012-08-22 02:21:28 -07:00
|
|
|
if (sd->img_obj)
|
2011-04-14 03:48:43 -07:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
evas_object_show(sd->img_obj);
|
2011-04-14 03:48:43 -07:00
|
|
|
}
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->pointer.obj)
|
2012-02-10 00:37:16 -08:00
|
|
|
{
|
2015-04-29 01:30:18 -07:00
|
|
|
#if 0
|
2012-05-03 15:42:15 -07:00
|
|
|
ecore_evas_show(sd->pointer.ee);
|
2015-04-29 01:30:18 -07:00
|
|
|
#endif
|
2012-05-03 15:42:15 -07:00
|
|
|
evas_object_show(sd->pointer.obj);
|
2012-02-10 00:37:16 -08:00
|
|
|
}
|
2012-01-02 17:45:22 -08:00
|
|
|
evas_object_show(obj);
|
2014-12-07 16:36:19 -08:00
|
|
|
#ifdef ELEMENTARY_X
|
|
|
|
if (sd->type == ELM_WIN_TOOLTIP)
|
|
|
|
ecore_x_window_shape_input_rectangle_set(sd->x.xwin, 0, 0, 0, 0);
|
|
|
|
#endif
|
2009-10-07 22:26:58 -07:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
2014-06-03 03:35:28 -07:00
|
|
|
_elm_win_evas_object_smart_move(Eo *obj, Elm_Win_Data *sd, Evas_Coord x, Evas_Coord y)
|
2011-03-23 06:29:26 -07:00
|
|
|
{
|
2012-07-18 21:35:50 -07:00
|
|
|
if (sd->img_obj)
|
|
|
|
{
|
|
|
|
if ((x != sd->screen.x) || (y != sd->screen.y))
|
|
|
|
{
|
|
|
|
sd->screen.x = x;
|
|
|
|
sd->screen.y = y;
|
2015-05-13 04:34:44 -07:00
|
|
|
eo_do(obj, eo_event_callback_call(ELM_WIN_EVENT_MOVED, NULL));
|
2012-07-18 21:35:50 -07:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
TRAP(sd, move, x, y);
|
|
|
|
if (!ecore_evas_override_get(sd->ee)) return;
|
|
|
|
}
|
|
|
|
|
2013-03-18 09:07:38 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, evas_obj_smart_move(x, y));
|
2012-05-02 18:19:05 -07:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
if (ecore_evas_override_get(sd->ee))
|
|
|
|
{
|
|
|
|
sd->screen.x = x;
|
|
|
|
sd->screen.y = y;
|
2015-05-13 04:34:44 -07:00
|
|
|
eo_do(obj, eo_event_callback_call(ELM_WIN_EVENT_MOVED, NULL));
|
2011-03-23 06:29:26 -07:00
|
|
|
}
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->frame_obj)
|
2011-04-14 03:48:43 -07:00
|
|
|
{
|
2015-01-08 02:46:52 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_WAYLAND
|
|
|
|
ecore_wl_window_update_location(sd->wl.win, x, y);
|
|
|
|
#endif
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->screen.x = x;
|
|
|
|
sd->screen.y = y;
|
2011-04-14 03:48:43 -07:00
|
|
|
}
|
2012-08-22 02:21:28 -07:00
|
|
|
if (sd->img_obj)
|
2011-04-14 03:48:43 -07:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->screen.x = x;
|
|
|
|
sd->screen.y = y;
|
2011-04-14 03:48:43 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
2014-06-03 03:35:28 -07:00
|
|
|
_elm_win_evas_object_smart_resize(Eo *obj, Elm_Win_Data *sd, Evas_Coord w, Evas_Coord h)
|
2011-04-14 03:48:43 -07:00
|
|
|
{
|
2013-03-18 09:07:38 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, evas_obj_smart_resize(w, h));
|
2012-05-02 18:19:05 -07:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->img_obj)
|
|
|
|
{
|
|
|
|
if (sd->constrain)
|
2011-12-03 14:51:12 -08:00
|
|
|
{
|
|
|
|
int sw, sh;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
ecore_evas_screen_geometry_get(sd->ee, NULL, NULL, &sw, &sh);
|
2011-12-03 14:51:12 -08:00
|
|
|
w = MIN(w, sw);
|
|
|
|
h = MIN(h, sh);
|
|
|
|
}
|
2011-12-04 14:02:02 -08:00
|
|
|
if (w < 1) w = 1;
|
|
|
|
if (h < 1) h = 1;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
evas_object_image_size_set(sd->img_obj, w, h);
|
2011-04-14 03:48:43 -07:00
|
|
|
}
|
2012-07-18 21:35:50 -07:00
|
|
|
|
2012-07-30 03:06:28 -07:00
|
|
|
TRAP(sd, resize, 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)
|
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
Elm_Win_Data *sd = _elm_win_associate_get(ee);
|
2012-07-18 21:35:50 -07:00
|
|
|
Evas_Object *obj;
|
2008-09-29 23:58:56 -07:00
|
|
|
|
2014-02-17 22:58:57 -08:00
|
|
|
if (!sd) return;
|
2012-07-18 21:35:50 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
obj = sd->obj;
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
int autodel = sd->autodel;
|
|
|
|
sd->autodel_clear = &autodel;
|
|
|
|
evas_object_ref(obj);
|
2015-05-13 04:34:44 -07:00
|
|
|
eo_do(obj, eo_event_callback_call(ELM_WIN_EVENT_DELETE_REQUEST, NULL));
|
2015-07-01 07:40:57 -07:00
|
|
|
if (sd->autohide)
|
|
|
|
evas_object_hide(obj);
|
2012-05-03 15:42:15 -07:00
|
|
|
// FIXME: if above callback deletes - then the below will be invalid
|
2015-04-29 06:08:57 -07:00
|
|
|
if (_elm_config->atspi_mode)
|
|
|
|
eo_do(obj, eo_event_callback_call(ELM_INTERFACE_ATSPI_WINDOW_EVENT_WINDOW_DESTROYED, NULL));
|
2012-05-03 15:42:15 -07:00
|
|
|
if (autodel) evas_object_del(obj);
|
|
|
|
else sd->autodel_clear = NULL;
|
|
|
|
evas_object_unref(obj);
|
2008-09-29 23:58:56 -07:00
|
|
|
}
|
|
|
|
|
2012-07-11 04:53:29 -07:00
|
|
|
Ecore_X_Window
|
2012-05-28 05:28:46 -07:00
|
|
|
_elm_ee_xwin_get(const Ecore_Evas *ee)
|
2008-09-29 23:58:56 -07:00
|
|
|
{
|
2012-05-29 21:57:31 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2014-01-07 16:05:08 -08:00
|
|
|
const char *engine_name;
|
2012-05-28 05:28:46 -07:00
|
|
|
if (!ee) return 0;
|
2014-01-07 16:05:08 -08:00
|
|
|
|
|
|
|
engine_name = ecore_evas_engine_name_get(ee);
|
|
|
|
if (EINA_UNLIKELY(!engine_name)) return 0;
|
|
|
|
|
|
|
|
if (!strcmp(engine_name, ELM_SOFTWARE_X11))
|
2010-11-01 14:10:07 -07:00
|
|
|
{
|
2014-01-07 16:05:08 -08:00
|
|
|
return ecore_evas_software_x11_window_get(ee);
|
2010-11-01 14:10:07 -07:00
|
|
|
}
|
2014-01-07 16:05:08 -08:00
|
|
|
else if (!strcmp(engine_name, ELM_OPENGL_X11))
|
2010-11-01 14:10:07 -07:00
|
|
|
{
|
2014-01-07 16:05:08 -08:00
|
|
|
return ecore_evas_gl_x11_window_get(ee);
|
2010-11-01 14:10:07 -07:00
|
|
|
}
|
2014-03-08 06:54:34 -08:00
|
|
|
#else
|
|
|
|
(void)ee;
|
2012-05-28 05:28:46 -07:00
|
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
static void
|
2014-03-27 06:15:52 -07:00
|
|
|
_internal_elm_win_xwindow_get(Elm_Win_Data *sd)
|
2012-05-28 05:28:46 -07:00
|
|
|
{
|
2012-06-06 01:25:12 -07:00
|
|
|
sd->x.xwin = _elm_ee_xwin_get(sd->ee);
|
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
|
|
|
|
2013-11-15 02:14:08 -08:00
|
|
|
Ecore_Wl_Window *
|
|
|
|
_elm_ee_wlwin_get(const Ecore_Evas *ee)
|
|
|
|
{
|
|
|
|
#ifdef HAVE_ELEMENTARY_WAYLAND
|
2014-01-07 16:05:08 -08:00
|
|
|
const char *engine_name;
|
2013-11-15 02:14:08 -08:00
|
|
|
|
|
|
|
if (!ee) return NULL;
|
2014-01-07 16:05:08 -08:00
|
|
|
|
|
|
|
engine_name = ecore_evas_engine_name_get(ee);
|
|
|
|
if (EINA_UNLIKELY(!engine_name)) return NULL;
|
|
|
|
|
|
|
|
if ((!strcmp(engine_name, ELM_WAYLAND_SHM)) ||
|
|
|
|
(!strcmp(engine_name, ELM_WAYLAND_EGL)))
|
2013-11-15 02:14:08 -08:00
|
|
|
{
|
2014-01-07 16:05:08 -08:00
|
|
|
return ecore_evas_wayland_window_get(ee);
|
2013-11-15 02:14:08 -08:00
|
|
|
}
|
2013-11-15 04:52:19 -08:00
|
|
|
#else
|
|
|
|
(void)ee;
|
2013-11-15 02:14:08 -08:00
|
|
|
#endif
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef HAVE_ELEMENTARY_WAYLAND
|
|
|
|
static void
|
2014-03-27 06:15:52 -07:00
|
|
|
_elm_win_wlwindow_get(Elm_Win_Data *sd)
|
2013-11-15 02:14:08 -08:00
|
|
|
{
|
|
|
|
sd->wl.win = _elm_ee_wlwin_get(sd->ee);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2008-11-18 22:23:08 -08:00
|
|
|
static void
|
2014-03-27 06:15:52 -07:00
|
|
|
_elm_win_xwin_update(Elm_Win_Data *sd)
|
2008-11-18 22:23:08 -08:00
|
|
|
{
|
2012-02-29 04:06:12 -08:00
|
|
|
const char *s;
|
2012-03-28 02:02:22 -07:00
|
|
|
|
2015-01-09 21:33:55 -08:00
|
|
|
if (sd->type == ELM_WIN_FAKE) return;
|
2014-03-27 06:15:52 -07:00
|
|
|
_internal_elm_win_xwindow_get(sd);
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->parent)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
ELM_WIN_DATA_GET(sd->parent, sdp);
|
|
|
|
if (sdp)
|
2011-04-01 04:20:18 -07:00
|
|
|
{
|
2012-06-06 01:25:12 -07:00
|
|
|
if (sd->x.xwin)
|
|
|
|
ecore_x_icccm_transient_for_set(sd->x.xwin, sdp->x.xwin);
|
2011-04-01 04:20:18 -07:00
|
|
|
}
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
2009-04-14 19:08:07 -07:00
|
|
|
|
2012-06-06 01:25:12 -07:00
|
|
|
if (!sd->x.xwin) return; /* nothing more to do */
|
2009-04-14 19:08:07 -07:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
s = sd->title;
|
2012-02-29 04:06:12 -08:00
|
|
|
if (!s) s = _elm_appname;
|
|
|
|
if (!s) s = "";
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->icon_name) s = sd->icon_name;
|
2012-06-06 01:25:12 -07:00
|
|
|
ecore_x_icccm_icon_name_set(sd->x.xwin, s);
|
|
|
|
ecore_x_netwm_icon_name_set(sd->x.xwin, s);
|
2012-02-29 04:06:12 -08:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
s = sd->role;
|
2012-06-06 01:25:12 -07:00
|
|
|
if (s) ecore_x_icccm_window_role_set(sd->x.xwin, s);
|
2012-03-28 02:02:22 -07:00
|
|
|
|
2012-02-29 04:06:12 -08:00
|
|
|
// set window icon
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->icon)
|
2012-02-29 04:06:12 -08:00
|
|
|
{
|
|
|
|
void *data;
|
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
data = evas_object_image_data_get(sd->icon, EINA_FALSE);
|
2012-02-29 04:06:12 -08:00
|
|
|
if (data)
|
|
|
|
{
|
|
|
|
Ecore_X_Icon ic;
|
|
|
|
int w = 0, h = 0, stride, x, y;
|
|
|
|
unsigned char *p;
|
|
|
|
unsigned int *p2;
|
2012-03-28 02:02:22 -07:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
evas_object_image_size_get(sd->icon, &w, &h);
|
|
|
|
stride = evas_object_image_stride_get(sd->icon);
|
2012-03-28 02:02:22 -07:00
|
|
|
if ((w > 0) && (h > 0) &&
|
2012-02-29 04:06:12 -08:00
|
|
|
(stride >= (int)(w * sizeof(unsigned int))))
|
|
|
|
{
|
|
|
|
ic.width = w;
|
|
|
|
ic.height = h;
|
|
|
|
ic.data = malloc(w * h * sizeof(unsigned int));
|
2012-03-28 02:02:22 -07:00
|
|
|
|
2012-02-29 04:06:12 -08:00
|
|
|
if (ic.data)
|
|
|
|
{
|
|
|
|
p = (unsigned char *)data;
|
|
|
|
p2 = (unsigned int *)ic.data;
|
|
|
|
for (y = 0; y < h; y++)
|
|
|
|
{
|
|
|
|
for (x = 0; x < w; x++)
|
|
|
|
{
|
|
|
|
*p2 = *((unsigned int *)p);
|
|
|
|
p += sizeof(unsigned int);
|
|
|
|
p2++;
|
|
|
|
}
|
2012-03-28 02:02:22 -07:00
|
|
|
p += (stride - (w * sizeof(unsigned int)));
|
2012-02-29 04:06:12 -08:00
|
|
|
}
|
2012-06-06 01:25:12 -07:00
|
|
|
ecore_x_netwm_icons_set(sd->x.xwin, &ic, 1);
|
2012-02-29 04:06:12 -08:00
|
|
|
free(ic.data);
|
|
|
|
}
|
|
|
|
}
|
2012-05-03 15:42:15 -07:00
|
|
|
evas_object_image_data_set(sd->icon, data);
|
2012-02-29 04:06:12 -08:00
|
|
|
}
|
|
|
|
}
|
2012-03-28 02:02:22 -07:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
switch (sd->type)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
2009-04-14 19:08:07 -07:00
|
|
|
case ELM_WIN_BASIC:
|
2012-06-06 01:25:12 -07:00
|
|
|
ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_NORMAL);
|
2012-05-03 15:42:15 -07:00
|
|
|
break;
|
|
|
|
|
2009-04-14 19:08:07 -07:00
|
|
|
case ELM_WIN_DIALOG_BASIC:
|
2012-06-06 01:25:12 -07:00
|
|
|
ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_DIALOG);
|
2012-05-03 15:42:15 -07:00
|
|
|
break;
|
|
|
|
|
2009-04-14 19:08:07 -07:00
|
|
|
case ELM_WIN_DESKTOP:
|
2012-06-06 01:25:12 -07:00
|
|
|
ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_DESKTOP);
|
2012-05-03 15:42:15 -07:00
|
|
|
break;
|
|
|
|
|
2009-04-14 19:08:07 -07:00
|
|
|
case ELM_WIN_DOCK:
|
2012-06-06 01:25:12 -07:00
|
|
|
ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_DOCK);
|
2012-05-03 15:42:15 -07:00
|
|
|
break;
|
|
|
|
|
2009-04-14 19:08:07 -07:00
|
|
|
case ELM_WIN_TOOLBAR:
|
2012-06-06 01:25:12 -07:00
|
|
|
ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_TOOLBAR);
|
2012-05-03 15:42:15 -07:00
|
|
|
break;
|
|
|
|
|
2009-04-14 19:08:07 -07:00
|
|
|
case ELM_WIN_MENU:
|
2012-06-06 01:25:12 -07:00
|
|
|
ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_MENU);
|
2012-05-03 15:42:15 -07:00
|
|
|
break;
|
|
|
|
|
2009-04-14 19:08:07 -07:00
|
|
|
case ELM_WIN_UTILITY:
|
2012-06-06 01:25:12 -07:00
|
|
|
ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_UTILITY);
|
2012-05-03 15:42:15 -07:00
|
|
|
break;
|
|
|
|
|
2009-04-14 19:08:07 -07:00
|
|
|
case ELM_WIN_SPLASH:
|
2012-06-06 01:25:12 -07:00
|
|
|
ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_SPLASH);
|
2012-05-03 15:42:15 -07:00
|
|
|
break;
|
|
|
|
|
2011-03-22 08:46:52 -07:00
|
|
|
case ELM_WIN_DROPDOWN_MENU:
|
2012-05-03 15:42:15 -07:00
|
|
|
ecore_x_netwm_window_type_set
|
2012-06-06 01:25:12 -07:00
|
|
|
(sd->x.xwin, ECORE_X_WINDOW_TYPE_DROPDOWN_MENU);
|
2012-05-03 15:42:15 -07:00
|
|
|
break;
|
|
|
|
|
2011-03-22 08:46:52 -07:00
|
|
|
case ELM_WIN_POPUP_MENU:
|
2012-05-03 15:42:15 -07:00
|
|
|
ecore_x_netwm_window_type_set
|
2012-06-06 01:25:12 -07:00
|
|
|
(sd->x.xwin, ECORE_X_WINDOW_TYPE_POPUP_MENU);
|
2012-05-03 15:42:15 -07:00
|
|
|
break;
|
|
|
|
|
2011-03-22 08:46:52 -07:00
|
|
|
case ELM_WIN_TOOLTIP:
|
2012-06-06 01:25:12 -07:00
|
|
|
ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_TOOLTIP);
|
2014-12-07 16:36:19 -08:00
|
|
|
ecore_x_window_shape_input_rectangle_set(sd->x.xwin, 0, 0, 0, 0);
|
2012-05-03 15:42:15 -07:00
|
|
|
break;
|
|
|
|
|
2011-03-22 08:46:52 -07:00
|
|
|
case ELM_WIN_NOTIFICATION:
|
2012-05-03 15:42:15 -07:00
|
|
|
ecore_x_netwm_window_type_set
|
2012-06-06 01:25:12 -07:00
|
|
|
(sd->x.xwin, ECORE_X_WINDOW_TYPE_NOTIFICATION);
|
2012-05-03 15:42:15 -07:00
|
|
|
break;
|
|
|
|
|
2011-03-22 08:46:52 -07:00
|
|
|
case ELM_WIN_COMBO:
|
2012-06-06 01:25:12 -07:00
|
|
|
ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_COMBO);
|
2012-05-03 15:42:15 -07:00
|
|
|
break;
|
|
|
|
|
2011-03-22 08:46:52 -07:00
|
|
|
case ELM_WIN_DND:
|
2012-06-06 01:25:12 -07:00
|
|
|
ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_DND);
|
2012-05-03 15:42:15 -07:00
|
|
|
break;
|
|
|
|
|
2009-04-14 19:08:07 -07:00
|
|
|
default:
|
2012-05-03 15:42:15 -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
|
2012-06-06 01:25:12 -07:00
|
|
|
(sd->x.xwin, (Ecore_X_Virtual_Keyboard_State)sd->kbdmode);
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->indmode == ELM_WIN_INDICATOR_SHOW)
|
2012-02-24 21:14:19 -08:00
|
|
|
ecore_x_e_illume_indicator_state_set
|
2012-06-06 01:25:12 -07:00
|
|
|
(sd->x.xwin, ECORE_X_ILLUME_INDICATOR_STATE_ON);
|
2012-05-03 15:42:15 -07:00
|
|
|
else if (sd->indmode == ELM_WIN_INDICATOR_HIDE)
|
2012-02-24 21:14:19 -08:00
|
|
|
ecore_x_e_illume_indicator_state_set
|
2012-06-06 01:25:12 -07:00
|
|
|
(sd->x.xwin, ECORE_X_ILLUME_INDICATOR_STATE_OFF);
|
2008-09-29 23:58:56 -07:00
|
|
|
}
|
2012-07-17 11:46:18 -07:00
|
|
|
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2008-09-29 23:58:56 -07:00
|
|
|
|
2013-07-02 21:19:56 -07:00
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Resize the window according to window layout's min and weight.
|
|
|
|
* If the window layout's weight is 0.0, the window max is limited to layout's
|
|
|
|
* min size.
|
|
|
|
*
|
|
|
|
* This is called when the window layout's weight hint is changed or when the
|
|
|
|
* window is rotated.
|
|
|
|
*
|
|
|
|
* @param obj window object
|
|
|
|
*/
|
2008-10-06 18:23:49 -07:00
|
|
|
static void
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_resize_objects_eval(Evas_Object *obj)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
ELM_WIN_DATA_GET(obj, sd);
|
2013-01-17 14:11:21 -08:00
|
|
|
Evas_Coord w, h, minw, minh, maxw, maxh;
|
2008-10-06 18:23:49 -07:00
|
|
|
double wx, wy;
|
|
|
|
|
2014-12-15 09:02:40 -08:00
|
|
|
evas_object_size_hint_min_get(sd->edje, &minw, &minh);
|
2013-01-17 14:11:21 -08:00
|
|
|
if (minw < 1) minw = 1;
|
|
|
|
if (minh < 1) minh = 1;
|
2011-04-01 04:20:18 -07:00
|
|
|
|
2014-12-15 09:02:40 -08:00
|
|
|
evas_object_size_hint_weight_get(sd->edje, &wx, &wy);
|
2013-01-17 14:11:21 -08:00
|
|
|
if (!wx) maxw = minw;
|
2008-10-06 18:23:49 -07:00
|
|
|
else maxw = 32767;
|
2013-01-17 14:11:21 -08:00
|
|
|
if (!wy) maxh = minh;
|
2008-10-06 18:23:49 -07:00
|
|
|
else maxh = 32767;
|
2013-01-17 14:11:21 -08:00
|
|
|
|
2008-10-06 18:23:49 -07:00
|
|
|
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;
|
2013-01-17 14:11:21 -08:00
|
|
|
if (w > maxw) w = maxw;
|
|
|
|
if (h > maxh) h = maxh;
|
2013-01-11 08:43:14 -08:00
|
|
|
evas_object_resize(obj, w, h);
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_on_resize_obj_changed_size_hints(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas *e EINA_UNUSED,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
void *event_info EINA_UNUSED)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_resize_objects_eval(data);
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
_elm_win_shutdown(void)
|
|
|
|
{
|
2014-09-26 02:09:15 -07:00
|
|
|
while (_elm_win_list)
|
|
|
|
{
|
|
|
|
Eina_List *itr = _elm_win_list;
|
|
|
|
evas_object_del(itr->data);
|
|
|
|
if (_elm_win_list == itr)
|
|
|
|
{
|
|
|
|
_elm_win_list = eina_list_remove_list(_elm_win_list, _elm_win_list);
|
|
|
|
}
|
|
|
|
}
|
2015-05-27 20:27:59 -07:00
|
|
|
ELM_SAFE_FREE(_elm_win_state_eval_timer, ecore_timer_del);
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
2008-11-14 22:09:04 -08:00
|
|
|
void
|
2012-05-03 15:42:15 -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)
|
|
|
|
{
|
2012-08-05 21:09:02 -07:00
|
|
|
EINA_LIST_FOREACH(_elm_win_list, l, obj)
|
2010-11-05 01:37:31 -07:00
|
|
|
elm_widget_theme(obj);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2012-08-05 21:09:02 -07:00
|
|
|
EINA_LIST_FOREACH(_elm_win_list, l, obj)
|
2010-11-05 01:37:31 -07:00
|
|
|
elm_widget_theme_specific(obj, th, EINA_FALSE);
|
|
|
|
}
|
2008-11-14 22:09:04 -08:00
|
|
|
}
|
|
|
|
|
2012-08-18 06:52:03 -07:00
|
|
|
void
|
|
|
|
_elm_win_access(Eina_Bool is_access)
|
|
|
|
{
|
2013-04-10 01:28:08 -07:00
|
|
|
Evas *evas;
|
2012-08-18 06:52:03 -07:00
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *obj;
|
2013-08-05 22:00:50 -07:00
|
|
|
Evas_Object *fobj;
|
2012-08-18 06:52:03 -07:00
|
|
|
|
2012-08-28 03:37:02 -07:00
|
|
|
EINA_LIST_FOREACH(_elm_win_list, l, obj)
|
2013-04-10 01:28:08 -07:00
|
|
|
{
|
|
|
|
elm_widget_access(obj, is_access);
|
2013-08-05 22:00:50 -07:00
|
|
|
|
|
|
|
/* floating orphan object. if there are A, B, C objects and user does
|
|
|
|
as below, then there would be floating orphan objects.
|
|
|
|
|
|
|
|
1. elm_object_content_set(layout, A);
|
|
|
|
2. elm_object_content_set(layout, B);
|
|
|
|
3. elm_object_content_set(layout, C);
|
|
|
|
|
|
|
|
now, the object A and B are floating orphan objects */
|
|
|
|
|
|
|
|
fobj = obj;
|
|
|
|
for (;;)
|
|
|
|
{
|
|
|
|
fobj = evas_object_below_get(fobj);
|
|
|
|
if (!fobj) break;
|
|
|
|
|
|
|
|
if (elm_widget_is(fobj) && !elm_widget_parent_get(fobj))
|
|
|
|
{
|
|
|
|
elm_widget_access(fobj, is_access);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-10 01:28:08 -07:00
|
|
|
if (!is_access)
|
|
|
|
{
|
|
|
|
evas = evas_object_evas_get(obj);
|
2013-10-31 07:01:56 -07:00
|
|
|
if (evas) _elm_access_object_highlight_disable(evas);
|
2013-04-10 01:28:08 -07:00
|
|
|
}
|
|
|
|
}
|
2012-08-18 06:52:03 -07:00
|
|
|
}
|
|
|
|
|
2011-10-19 07:17:14 -07:00
|
|
|
void
|
|
|
|
_elm_win_translate(void)
|
|
|
|
{
|
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *obj;
|
|
|
|
|
2012-08-05 21:09:02 -07:00
|
|
|
EINA_LIST_FOREACH(_elm_win_list, l, obj)
|
2012-05-03 15:42:15 -07:00
|
|
|
elm_widget_translate(obj);
|
2011-10-19 07:17:14 -07:00
|
|
|
}
|
|
|
|
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2010-06-25 02:58:14 -07:00
|
|
|
static Eina_Bool
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_client_message(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
int type EINA_UNUSED,
|
2012-05-03 15:42:15 -07:00
|
|
|
void *event)
|
2010-04-12 01:27:10 -07:00
|
|
|
{
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_WIN_DATA_GET(data, sd);
|
2010-04-12 01:27:10 -07:00
|
|
|
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)
|
|
|
|
{
|
2012-06-06 01:25:12 -07:00
|
|
|
if ((unsigned int)e->data.l[0] == sd->x.xwin)
|
2010-04-12 01:27:10 -07:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
Evas *evas = evas_object_evas_get(sd->obj);
|
2010-04-21 00:46:03 -07:00
|
|
|
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)
|
|
|
|
{
|
2012-06-06 01:25:12 -07:00
|
|
|
if ((unsigned int)e->data.l[0] == sd->x.xwin)
|
2010-04-12 01:27:10 -07:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
Evas *evas = evas_object_evas_get(sd->obj);
|
2010-04-21 00:46:03 -07:00
|
|
|
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
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-05-22 05:13:49 -07:00
|
|
|
else if (e->message_type == ECORE_X_ATOM_E_ILLUME_ACCESS_CONTROL)
|
|
|
|
{
|
2012-06-06 01:25:12 -07:00
|
|
|
if ((unsigned int)e->data.l[0] == sd->x.xwin)
|
2012-05-22 05:13:49 -07:00
|
|
|
{
|
|
|
|
if ((unsigned int)e->data.l[1] ==
|
|
|
|
ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_NEXT)
|
|
|
|
{
|
|
|
|
// XXX: call right access func
|
|
|
|
}
|
|
|
|
else if ((unsigned int)e->data.l[1] ==
|
|
|
|
ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_PREV)
|
|
|
|
{
|
|
|
|
// XXX: call right access func
|
|
|
|
}
|
2012-07-17 11:46:18 -07:00
|
|
|
else if ((unsigned int)e->data.l[1] ==
|
2012-05-22 05:13:49 -07:00
|
|
|
ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_ACTIVATE)
|
|
|
|
{
|
2012-09-16 20:01:46 -07:00
|
|
|
_elm_access_highlight_object_activate
|
2012-11-25 22:32:53 -08:00
|
|
|
(sd->obj, ELM_ACTIVATE_DEFAULT);
|
2012-05-22 05:13:49 -07:00
|
|
|
}
|
|
|
|
else if ((unsigned int)e->data.l[1] ==
|
|
|
|
ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_READ)
|
|
|
|
{
|
2012-11-30 03:50:52 -08:00
|
|
|
/* there would be better way to read highlight object */
|
2013-01-17 03:32:14 -08:00
|
|
|
Evas *evas;
|
|
|
|
evas = evas_object_evas_get(sd->obj);
|
|
|
|
if (!evas) return ECORE_CALLBACK_PASS_ON;
|
|
|
|
|
|
|
|
_elm_access_mouse_event_enabled_set(EINA_TRUE);
|
|
|
|
|
|
|
|
evas_event_feed_mouse_in(evas, 0, NULL);
|
|
|
|
evas_event_feed_mouse_move
|
|
|
|
(evas, e->data.l[2], e->data.l[3], 0, NULL);
|
|
|
|
|
|
|
|
_elm_access_mouse_event_enabled_set(EINA_FALSE);
|
2012-05-22 05:13:49 -07:00
|
|
|
}
|
2012-07-17 11:46:18 -07:00
|
|
|
else if ((unsigned int)e->data.l[1] ==
|
2012-05-22 05:13:49 -07:00
|
|
|
ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_READ_NEXT)
|
|
|
|
{
|
2012-11-30 03:50:52 -08:00
|
|
|
_elm_access_highlight_cycle(sd->obj, ELM_FOCUS_NEXT);
|
2012-05-22 05:13:49 -07:00
|
|
|
}
|
2012-07-17 11:46:18 -07:00
|
|
|
else if ((unsigned int)e->data.l[1] ==
|
2012-05-22 05:13:49 -07:00
|
|
|
ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_READ_PREV)
|
|
|
|
{
|
2012-11-30 03:50:52 -08:00
|
|
|
_elm_access_highlight_cycle(sd->obj, ELM_FOCUS_PREVIOUS);
|
2012-05-22 05:13:49 -07:00
|
|
|
}
|
2012-09-03 02:43:35 -07:00
|
|
|
else if ((unsigned int)e->data.l[1] ==
|
|
|
|
ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_UP)
|
|
|
|
{
|
2012-09-16 20:01:46 -07:00
|
|
|
_elm_access_highlight_object_activate
|
2012-11-25 22:32:53 -08:00
|
|
|
(sd->obj, ELM_ACTIVATE_UP);
|
2012-09-03 02:43:35 -07:00
|
|
|
}
|
|
|
|
else if ((unsigned int)e->data.l[1] ==
|
|
|
|
ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_DOWN)
|
|
|
|
{
|
2012-09-16 20:01:46 -07:00
|
|
|
_elm_access_highlight_object_activate
|
2012-11-25 22:32:53 -08:00
|
|
|
(sd->obj, ELM_ACTIVATE_DOWN);
|
2012-09-03 02:43:35 -07:00
|
|
|
}
|
2012-05-22 05:13:49 -07:00
|
|
|
}
|
|
|
|
}
|
2010-06-25 02:58:14 -07:00
|
|
|
return ECORE_CALLBACK_PASS_ON;
|
2010-04-12 01:27:10 -07:00
|
|
|
}
|
2012-05-02 18:19:05 -07:00
|
|
|
|
2012-11-19 08:51:44 -08:00
|
|
|
static Eina_Bool
|
|
|
|
_elm_win_property_change(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
int type EINA_UNUSED,
|
2012-11-19 08:51:44 -08:00
|
|
|
void *event)
|
|
|
|
{
|
2013-05-03 03:23:53 -07:00
|
|
|
ELM_WIN_DATA_GET(data, sd);
|
2012-11-19 08:51:44 -08:00
|
|
|
Ecore_X_Event_Window_Property *e = event;
|
|
|
|
|
|
|
|
if (e->atom == ECORE_X_ATOM_E_ILLUME_INDICATOR_STATE)
|
|
|
|
{
|
|
|
|
if (e->win == sd->x.xwin)
|
|
|
|
{
|
2013-06-26 09:54:26 -07:00
|
|
|
sd->indmode = (Elm_Win_Indicator_Mode)ecore_x_e_illume_indicator_state_get(e->win);
|
2015-05-13 04:34:44 -07:00
|
|
|
eo_do(sd->obj, eo_event_callback_call
|
|
|
|
(ELM_WIN_EVENT_INDICATOR_PROP_CHANGED, NULL));
|
2012-11-19 08:51:44 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return ECORE_CALLBACK_PASS_ON;
|
|
|
|
}
|
2012-05-03 15:42:15 -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
|
2014-01-06 06:30:02 -08:00
|
|
|
_elm_win_focus_highlight_hide(void *data EINA_UNUSED,
|
2012-05-03 15:42:15 -07:00
|
|
|
Evas_Object *obj,
|
2014-01-06 06:30:02 -08:00
|
|
|
const char *emission EINA_UNUSED,
|
|
|
|
const char *source EINA_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
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
evas_object_hide(obj);
|
2012-05-02 18:19:05 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_focus_highlight_anim_end(void *data,
|
|
|
|
Evas_Object *obj,
|
2014-01-06 06:30:02 -08:00
|
|
|
const char *emission EINA_UNUSED,
|
|
|
|
const char *source EINA_UNUSED)
|
2012-05-02 18:19:05 -07:00
|
|
|
{
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_WIN_DATA_GET(data, sd);
|
2012-05-02 18:19:05 -07:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_focus_highlight_simple_setup(sd, obj);
|
2012-05-02 18:19:05 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2014-03-27 06:15:52 -07:00
|
|
|
_elm_win_focus_highlight_init(Elm_Win_Data *sd)
|
2012-05-02 18:19:05 -07:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
evas_event_callback_add(sd->evas, EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_IN,
|
2013-04-24 04:41:37 -07:00
|
|
|
_elm_win_object_focus_in, sd->obj);
|
2012-05-03 15:42:15 -07:00
|
|
|
evas_event_callback_add(sd->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
|
|
|
EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_OUT,
|
2013-04-24 04:41:37 -07:00
|
|
|
_elm_win_object_focus_out, sd->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
|
|
|
|
2014-07-03 19:16:59 -07:00
|
|
|
sd->focus_highlight.cur.target = _elm_win_focus_target_get(evas_focus_get(sd->evas));
|
|
|
|
if (sd->focus_highlight.cur.target)
|
|
|
|
{
|
|
|
|
if (elm_widget_highlight_in_theme_get(sd->focus_highlight.cur.target))
|
|
|
|
sd->focus_highlight.cur.in_theme = EINA_TRUE;
|
|
|
|
else
|
|
|
|
_elm_win_focus_target_callbacks_add(sd);
|
2015-08-04 22:46:01 -07:00
|
|
|
|
|
|
|
evas_object_event_callback_add
|
|
|
|
(sd->focus_highlight.cur.target,
|
|
|
|
EVAS_CALLBACK_DEL, _elm_win_focus_target_del, sd->obj);
|
2014-07-03 19:16:59 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
sd->focus_highlight.prev.target = NULL;
|
2013-08-15 06:42:09 -07:00
|
|
|
sd->focus_highlight.fobj = edje_object_add(sd->evas);
|
2013-08-04 01:09:44 -07:00
|
|
|
sd->focus_highlight.theme_changed = EINA_TRUE;
|
2013-08-04 01:37:30 -07:00
|
|
|
|
|
|
|
edje_object_signal_callback_add(sd->focus_highlight.fobj,
|
2013-10-05 05:35:27 -07:00
|
|
|
"elm,action,focus,hide,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
|
|
|
_elm_win_focus_highlight_hide, NULL);
|
2013-08-04 01:37:30 -07:00
|
|
|
edje_object_signal_callback_add(sd->focus_highlight.fobj,
|
2013-10-05 05:35:27 -07:00
|
|
|
"elm,action,focus,anim,end", "*",
|
2013-04-24 04:41:37 -07:00
|
|
|
_elm_win_focus_highlight_anim_end, sd->obj);
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_focus_highlight_reconfigure_job_start(sd);
|
2012-05-02 18:19:05 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_frame_cb_move_start(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
const char *sig EINA_UNUSED,
|
2013-08-28 06:24:49 -07:00
|
|
|
const char *source)
|
2012-05-02 18:19:05 -07:00
|
|
|
{
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_WIN_DATA_GET(data, sd);
|
2012-05-02 18:19:05 -07:00
|
|
|
|
2013-04-24 04:41:37 -07:00
|
|
|
if (!sd) return;
|
2013-08-28 06:24:49 -07:00
|
|
|
|
|
|
|
#ifdef HAVE_ELEMENTARY_WAYLAND
|
|
|
|
if (!strcmp(source, "elm"))
|
|
|
|
ecore_wl_window_cursor_from_name_set(sd->wl.win, ELM_CURSOR_HAND1);
|
|
|
|
else
|
|
|
|
ecore_wl_window_cursor_default_restore(sd->wl.win);
|
|
|
|
#else
|
|
|
|
(void)source;
|
|
|
|
#endif
|
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
/* NB: Wayland handles moving surfaces by itself so we cannot
|
|
|
|
* specify a specific x/y we want. Instead, we will pass in the
|
|
|
|
* existing x/y values so they can be recorded as 'previous'
|
|
|
|
* position. The new position will get updated automatically when
|
|
|
|
* the move is finished */
|
2012-05-02 18:19:05 -07:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
ecore_evas_wayland_move(sd->ee, sd->screen.x, sd->screen.y);
|
2012-05-02 18:19:05 -07:00
|
|
|
}
|
|
|
|
|
2013-08-28 06:24:49 -07:00
|
|
|
static void
|
|
|
|
_elm_win_frame_cb_move_stop(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
const char *sig EINA_UNUSED,
|
|
|
|
const char *source EINA_UNUSED)
|
2013-08-28 06:24:49 -07:00
|
|
|
{
|
|
|
|
ELM_WIN_DATA_GET(data, sd);
|
|
|
|
|
|
|
|
if (!sd) return;
|
|
|
|
|
|
|
|
#ifdef HAVE_ELEMENTARY_WAYLAND
|
|
|
|
ecore_wl_window_cursor_default_restore(sd->wl.win);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2013-04-24 16:22:22 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_WAYLAND
|
|
|
|
struct _resize_info
|
|
|
|
{
|
|
|
|
const char *name;
|
|
|
|
int location;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct _resize_info _border_side[4] =
|
|
|
|
{
|
|
|
|
{ ELM_CURSOR_TOP_SIDE, 1 },
|
|
|
|
{ ELM_CURSOR_LEFT_SIDE, 4 },
|
|
|
|
{ ELM_CURSOR_BOTTOM_SIDE, 2 },
|
|
|
|
{ ELM_CURSOR_RIGHT_SIDE, 8 },
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct _resize_info _border_corner[4] =
|
|
|
|
{
|
|
|
|
{ ELM_CURSOR_TOP_LEFT_CORNER, 5 },
|
|
|
|
{ ELM_CURSOR_BOTTOM_LEFT_CORNER, 6 },
|
|
|
|
{ ELM_CURSOR_BOTTOM_RIGHT_CORNER, 10 },
|
|
|
|
{ ELM_CURSOR_TOP_RIGHT_CORNER, 9 },
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
2013-10-29 03:42:41 -07:00
|
|
|
static void
|
|
|
|
_elm_win_frame_obj_move(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas *e EINA_UNUSED,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
void *event_info EINA_UNUSED)
|
2013-10-29 03:42:41 -07:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
Elm_Win_Data *sd;
|
2013-10-29 03:42:41 -07:00
|
|
|
|
|
|
|
if (!(sd = data)) return;
|
|
|
|
if (!sd->client_obj) return;
|
|
|
|
|
|
|
|
_elm_win_frame_obj_update(sd);
|
|
|
|
}
|
|
|
|
|
2013-08-23 00:36:24 -07:00
|
|
|
static void
|
|
|
|
_elm_win_frame_obj_resize(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas *e EINA_UNUSED,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
void *event_info EINA_UNUSED)
|
2013-08-23 00:36:24 -07:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
Elm_Win_Data *sd;
|
2013-08-23 00:36:24 -07:00
|
|
|
|
|
|
|
if (!(sd = data)) return;
|
|
|
|
if (!sd->client_obj) return;
|
|
|
|
|
2013-10-29 03:42:41 -07:00
|
|
|
_elm_win_frame_obj_update(sd);
|
2013-08-23 00:36:24 -07:00
|
|
|
}
|
|
|
|
|
2012-08-06 05:05:53 -07:00
|
|
|
static void
|
|
|
|
_elm_win_frame_cb_resize_show(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
const char *sig EINA_UNUSED,
|
2012-08-06 05:05:53 -07:00
|
|
|
const char *source)
|
|
|
|
{
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_WIN_DATA_GET(data, sd);
|
2012-08-06 05:05:53 -07:00
|
|
|
|
2013-04-24 04:41:37 -07:00
|
|
|
if (!sd) return;
|
2012-08-06 05:05:53 -07:00
|
|
|
if (sd->resizing) return;
|
|
|
|
|
|
|
|
#ifdef HAVE_ELEMENTARY_WAYLAND
|
2013-04-24 16:22:22 -07:00
|
|
|
int i;
|
|
|
|
i = sd->rot / 90;
|
2012-08-06 05:05:53 -07:00
|
|
|
if (!strcmp(source, "elm.event.resize.t"))
|
2013-04-24 16:22:22 -07:00
|
|
|
ecore_wl_window_cursor_from_name_set(sd->wl.win,
|
|
|
|
_border_side[(0 + i) % 4].name);
|
2012-08-06 05:05:53 -07:00
|
|
|
else if (!strcmp(source, "elm.event.resize.b"))
|
2013-04-24 16:22:22 -07:00
|
|
|
ecore_wl_window_cursor_from_name_set(sd->wl.win,
|
|
|
|
_border_side[(2 + i) % 4].name);
|
2012-08-06 05:05:53 -07:00
|
|
|
else if (!strcmp(source, "elm.event.resize.l"))
|
2013-04-24 16:22:22 -07:00
|
|
|
ecore_wl_window_cursor_from_name_set(sd->wl.win,
|
|
|
|
_border_side[(1 + i) % 4].name);
|
2012-08-06 05:05:53 -07:00
|
|
|
else if (!strcmp(source, "elm.event.resize.r"))
|
2013-04-24 16:22:22 -07:00
|
|
|
ecore_wl_window_cursor_from_name_set(sd->wl.win,
|
|
|
|
_border_side[(3 + i) % 4].name);
|
2012-08-06 05:05:53 -07:00
|
|
|
else if (!strcmp(source, "elm.event.resize.tl"))
|
2012-10-10 17:35:00 -07:00
|
|
|
ecore_wl_window_cursor_from_name_set(sd->wl.win,
|
2013-04-24 16:22:22 -07:00
|
|
|
_border_corner[(0 + i) % 4].name);
|
2012-08-06 05:05:53 -07:00
|
|
|
else if (!strcmp(source, "elm.event.resize.tr"))
|
2012-10-10 17:35:00 -07:00
|
|
|
ecore_wl_window_cursor_from_name_set(sd->wl.win,
|
2013-04-24 16:22:22 -07:00
|
|
|
_border_corner[(3 + i) % 4].name);
|
2012-08-06 05:05:53 -07:00
|
|
|
else if (!strcmp(source, "elm.event.resize.bl"))
|
2012-10-10 17:35:00 -07:00
|
|
|
ecore_wl_window_cursor_from_name_set(sd->wl.win,
|
2013-04-24 16:22:22 -07:00
|
|
|
_border_corner[(1 + i) % 4].name);
|
2012-08-06 05:05:53 -07:00
|
|
|
else if (!strcmp(source, "elm.event.resize.br"))
|
2012-10-10 17:35:00 -07:00
|
|
|
ecore_wl_window_cursor_from_name_set(sd->wl.win,
|
2013-04-24 16:22:22 -07:00
|
|
|
_border_corner[(2 + i) % 4].name);
|
2012-08-06 05:05:53 -07:00
|
|
|
else
|
|
|
|
ecore_wl_window_cursor_default_restore(sd->wl.win);
|
2012-08-08 01:10:22 -07:00
|
|
|
#else
|
|
|
|
(void)source;
|
2012-08-06 05:05:53 -07:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2012-08-16 02:40:02 -07:00
|
|
|
static void
|
|
|
|
_elm_win_frame_cb_resize_hide(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
const char *sig EINA_UNUSED,
|
|
|
|
const char *source EINA_UNUSED)
|
2012-08-16 02:40:02 -07:00
|
|
|
{
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_WIN_DATA_GET(data, sd);
|
2012-08-16 02:40:02 -07:00
|
|
|
|
2013-04-24 04:41:37 -07:00
|
|
|
if (!sd) return;
|
2012-08-16 02:40:02 -07:00
|
|
|
if (sd->resizing) return;
|
|
|
|
|
|
|
|
#ifdef HAVE_ELEMENTARY_WAYLAND
|
|
|
|
ecore_wl_window_cursor_default_restore(sd->wl.win);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2012-05-02 18:19:05 -07:00
|
|
|
static void
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_frame_cb_resize_start(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
const char *sig EINA_UNUSED,
|
2012-05-03 15:42:15 -07:00
|
|
|
const char *source)
|
2012-05-02 18:19:05 -07:00
|
|
|
{
|
2013-04-24 16:22:22 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_WAYLAND
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_WIN_DATA_GET(data, sd);
|
2013-04-24 16:22:22 -07:00
|
|
|
int i;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2013-04-24 04:41:37 -07:00
|
|
|
if (!sd) return;
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->resizing) return;
|
2012-05-02 18:19:05 -07:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->resizing = EINA_TRUE;
|
2013-04-24 16:22:22 -07:00
|
|
|
i = sd->rot / 90;
|
2012-01-08 03:23:59 -08:00
|
|
|
if (!strcmp(source, "elm.event.resize.t"))
|
2013-04-24 16:22:22 -07:00
|
|
|
sd->resize_location = _border_side[(0 + i) % 4].location;
|
2012-01-08 03:23:59 -08:00
|
|
|
else if (!strcmp(source, "elm.event.resize.b"))
|
2013-04-24 16:22:22 -07:00
|
|
|
sd->resize_location = _border_side[(2 + i) % 4].location;
|
2012-01-08 03:23:59 -08:00
|
|
|
else if (!strcmp(source, "elm.event.resize.l"))
|
2013-04-24 16:22:22 -07:00
|
|
|
sd->resize_location = _border_side[(1 + i) % 4].location;
|
2012-01-08 03:23:59 -08:00
|
|
|
else if (!strcmp(source, "elm.event.resize.r"))
|
2013-04-24 16:22:22 -07:00
|
|
|
sd->resize_location = _border_side[(3 + i) % 4].location;
|
2012-01-08 03:23:59 -08:00
|
|
|
else if (!strcmp(source, "elm.event.resize.tl"))
|
2013-04-24 16:22:22 -07:00
|
|
|
sd->resize_location = _border_corner[(0 + i) % 4].location;
|
2012-01-08 03:23:59 -08:00
|
|
|
else if (!strcmp(source, "elm.event.resize.tr"))
|
2013-04-24 16:22:22 -07:00
|
|
|
sd->resize_location = _border_corner[(3 + i) % 4].location;
|
2012-01-08 03:23:59 -08:00
|
|
|
else if (!strcmp(source, "elm.event.resize.bl"))
|
2013-04-24 16:22:22 -07:00
|
|
|
sd->resize_location = _border_corner[(1 + i) % 4].location;
|
2012-01-08 03:23:59 -08:00
|
|
|
else if (!strcmp(source, "elm.event.resize.br"))
|
2013-04-24 16:22:22 -07:00
|
|
|
sd->resize_location = _border_corner[(2 + i) % 4].location;
|
2012-01-08 03:23:59 -08:00
|
|
|
else
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->resize_location = 0;
|
2012-01-08 03:23:59 -08:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->resize_location > 0)
|
|
|
|
ecore_evas_wayland_resize(sd->ee, sd->resize_location);
|
2013-05-01 06:51:25 -07:00
|
|
|
#else
|
|
|
|
(void)data;
|
|
|
|
(void)source;
|
2013-04-24 16:22:22 -07:00
|
|
|
#endif
|
2012-01-04 01:30:05 -08:00
|
|
|
}
|
|
|
|
|
2012-03-28 02:02:22 -07:00
|
|
|
static void
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_frame_cb_minimize(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
const char *sig EINA_UNUSED,
|
|
|
|
const char *source EINA_UNUSED)
|
2012-01-04 01:30:05 -08:00
|
|
|
{
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_WIN_DATA_GET(data, sd);
|
2012-01-04 01:30:05 -08:00
|
|
|
|
2013-04-24 04:41:37 -07:00
|
|
|
if (!sd) return;
|
2013-01-10 03:53:39 -08:00
|
|
|
// sd->iconified = EINA_TRUE;
|
2012-07-18 21:35:50 -07:00
|
|
|
TRAP(sd, iconified_set, EINA_TRUE);
|
2012-01-03 12:41:49 -08:00
|
|
|
}
|
|
|
|
|
2013-10-29 03:39:40 -07:00
|
|
|
static void
|
2014-03-27 06:15:52 -07:00
|
|
|
_elm_win_frame_maximized_state_update(Elm_Win_Data *sd, Eina_Bool maximized)
|
2013-10-29 03:39:40 -07:00
|
|
|
{
|
|
|
|
const char *emission;
|
|
|
|
|
|
|
|
if (maximized)
|
|
|
|
emission = "elm,state,maximized";
|
|
|
|
else
|
|
|
|
emission = "elm,state,unmaximized";
|
|
|
|
|
|
|
|
edje_object_signal_emit(sd->frame_obj, emission, "elm");
|
|
|
|
edje_object_message_signal_process(sd->frame_obj);
|
|
|
|
evas_object_smart_calculate(sd->frame_obj);
|
|
|
|
|
|
|
|
_elm_win_frame_obj_update(sd);
|
|
|
|
}
|
|
|
|
|
2012-03-28 02:02:22 -07:00
|
|
|
static void
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_frame_cb_maximize(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
const char *sig EINA_UNUSED,
|
|
|
|
const char *source EINA_UNUSED)
|
2012-01-03 12:41:49 -08:00
|
|
|
{
|
2013-10-29 03:39:40 -07:00
|
|
|
Eina_Bool value;
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_WIN_DATA_GET(data, sd);
|
2012-01-04 01:30:05 -08:00
|
|
|
|
2013-04-24 04:41:37 -07:00
|
|
|
if (!sd) return;
|
2013-10-29 03:39:40 -07:00
|
|
|
if (sd->maximized) value = EINA_FALSE;
|
|
|
|
else value = EINA_TRUE;
|
|
|
|
|
|
|
|
_elm_win_frame_maximized_state_update(sd, value);
|
|
|
|
|
|
|
|
TRAP(sd, maximized_set, value);
|
2012-01-04 01:30:05 -08:00
|
|
|
}
|
|
|
|
|
2012-03-28 02:02:22 -07:00
|
|
|
static void
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_frame_cb_close(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
const char *sig EINA_UNUSED,
|
|
|
|
const char *source EINA_UNUSED)
|
2012-01-04 01:30:05 -08:00
|
|
|
{
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_WIN_DATA_GET(data, sd);
|
2012-08-06 07:34:25 -07:00
|
|
|
Evas_Object *win;
|
|
|
|
|
|
|
|
/* FIXME: After the current freeze, this should be handled differently.
|
2012-10-10 17:35:00 -07:00
|
|
|
*
|
|
|
|
* Ideally, we would want to mimic the X11 backend and use something
|
|
|
|
* like ECORE_WL_EVENT_WINDOW_DELETE and handle the delete_request
|
|
|
|
* inside of ecore_evas. That would be the 'proper' way, but since we are
|
|
|
|
* in a freeze right now, I cannot add a new event value, or a new
|
2012-08-06 07:34:25 -07:00
|
|
|
* event structure to ecore_wayland.
|
2012-10-10 17:35:00 -07:00
|
|
|
*
|
|
|
|
* So yes, this is a temporary 'stop-gap' solution which will be fixed
|
|
|
|
* when the freeze is over, but it does fix a trac bug for now, and in a
|
2012-08-06 07:34:25 -07:00
|
|
|
* way which does not break API or the freeze. - dh
|
|
|
|
*/
|
2012-01-04 01:30:05 -08:00
|
|
|
|
2013-04-24 04:41:37 -07:00
|
|
|
if (!sd) return;
|
2012-08-06 07:34:25 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
win = sd->obj;
|
2012-08-06 07:34:25 -07:00
|
|
|
|
|
|
|
int autodel = sd->autodel;
|
|
|
|
sd->autodel_clear = &autodel;
|
|
|
|
evas_object_ref(win);
|
2015-05-13 04:34:44 -07:00
|
|
|
eo_do(win, eo_event_callback_call(ELM_WIN_EVENT_DELETE_REQUEST, NULL));
|
2015-07-01 07:40:57 -07:00
|
|
|
if (sd->autohide)
|
|
|
|
evas_object_hide(win);
|
2012-08-06 07:34:25 -07:00
|
|
|
// FIXME: if above callback deletes - then the below will be invalid
|
|
|
|
if (autodel) evas_object_del(win);
|
|
|
|
else sd->autodel_clear = NULL;
|
|
|
|
evas_object_unref(win);
|
2012-01-04 01:30:05 -08:00
|
|
|
}
|
|
|
|
|
2015-07-20 14:35:00 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_WAYLAND
|
|
|
|
static void
|
|
|
|
_elm_win_frame_pre_render(void *data, Evas *e EINA_UNUSED, void *ev EINA_UNUSED)
|
|
|
|
{
|
|
|
|
Elm_Win_Data *sd = data;
|
|
|
|
|
|
|
|
if (sd->wl.opaque_dirty)
|
|
|
|
_elm_win_opaque_update(sd);
|
|
|
|
sd->wl.opaque_dirty = 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2012-03-28 02:02:22 -07:00
|
|
|
static void
|
2014-03-27 06:15:52 -07:00
|
|
|
_elm_win_frame_add(Elm_Win_Data *sd,
|
2012-05-03 15:42:15 -07:00
|
|
|
const char *style)
|
2012-02-10 00:37:16 -08:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
Evas_Object *obj = sd->obj;
|
2013-08-23 00:36:24 -07:00
|
|
|
int w, h, mw, mh;
|
2012-11-20 20:21:24 -08:00
|
|
|
short layer;
|
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->frame_obj = edje_object_add(sd->evas);
|
2012-11-20 20:21:24 -08:00
|
|
|
layer = evas_object_layer_get(obj);
|
|
|
|
evas_object_layer_set(sd->frame_obj, layer + 1);
|
2013-05-21 12:32:48 -07:00
|
|
|
if (!elm_widget_theme_object_set
|
|
|
|
(sd->obj, sd->frame_obj, "border", "base", style))
|
|
|
|
{
|
2014-01-21 17:38:55 -08:00
|
|
|
ELM_SAFE_FREE(sd->frame_obj, evas_object_del);
|
2013-05-21 12:32:48 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-08-23 00:36:24 -07:00
|
|
|
sd->client_obj = evas_object_rectangle_add(sd->evas);
|
|
|
|
evas_object_color_set(sd->client_obj, 0, 0, 0, 0);
|
|
|
|
/* NB: Tried pass_events here, but that fails to send events */
|
|
|
|
evas_object_repeat_events_set(sd->client_obj, EINA_TRUE);
|
2013-09-30 03:21:31 -07:00
|
|
|
edje_object_part_swallow(sd->frame_obj, "elm.swallow.client",
|
2013-08-23 00:36:24 -07:00
|
|
|
sd->client_obj);
|
|
|
|
|
2013-09-11 05:41:05 -07:00
|
|
|
evas_object_is_frame_object_set(sd->frame_obj, EINA_TRUE);
|
|
|
|
|
2015-06-25 10:33:57 -07:00
|
|
|
if (!sd->icon)
|
|
|
|
{
|
|
|
|
Efreet_Desktop *d;
|
|
|
|
|
|
|
|
sd->icon = elm_icon_add(sd->obj);
|
|
|
|
|
|
|
|
d = efreet_util_desktop_exec_find(_elm_appname);
|
|
|
|
if (d)
|
|
|
|
{
|
|
|
|
elm_icon_standard_set(sd->icon, d->icon);
|
|
|
|
efreet_desktop_free(d);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
edje_object_part_swallow(sd->frame_obj, "elm.swallow.icon",
|
|
|
|
sd->icon);
|
|
|
|
|
2013-08-23 00:36:24 -07:00
|
|
|
evas_object_event_callback_add
|
|
|
|
(sd->frame_obj, EVAS_CALLBACK_MOVE, _elm_win_frame_obj_move, sd);
|
|
|
|
evas_object_event_callback_add
|
|
|
|
(sd->frame_obj, EVAS_CALLBACK_RESIZE, _elm_win_frame_obj_resize, sd);
|
2015-07-20 14:35:00 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_WAYLAND
|
|
|
|
evas_event_callback_add(sd->evas, EVAS_CALLBACK_RENDER_PRE, _elm_win_frame_pre_render, sd);
|
|
|
|
#endif
|
2012-05-15 07:48:30 -07:00
|
|
|
|
2013-09-30 03:21:31 -07:00
|
|
|
/* NB: Do NOT remove these calls !! Needed to calculate proper
|
2013-08-23 00:36:24 -07:00
|
|
|
* framespace on inital show of the window */
|
|
|
|
edje_object_size_min_calc(sd->frame_obj, &mw, &mh);
|
2012-05-03 15:42:15 -07:00
|
|
|
evas_object_move(sd->frame_obj, 0, 0);
|
2013-08-23 00:36:24 -07:00
|
|
|
evas_object_resize(sd->frame_obj, mw, mh);
|
|
|
|
evas_object_smart_calculate(sd->frame_obj);
|
2012-05-02 18:19:05 -07:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
edje_object_signal_callback_add
|
|
|
|
(sd->frame_obj, "elm,action,move,start", "elm",
|
2013-04-24 04:41:37 -07:00
|
|
|
_elm_win_frame_cb_move_start, obj);
|
2013-08-28 06:24:49 -07:00
|
|
|
edje_object_signal_callback_add
|
|
|
|
(sd->frame_obj, "elm,action,move,stop", "elm",
|
|
|
|
_elm_win_frame_cb_move_stop, obj);
|
2012-08-06 05:05:53 -07:00
|
|
|
edje_object_signal_callback_add
|
|
|
|
(sd->frame_obj, "elm,action,resize,show", "*",
|
2013-04-24 04:41:37 -07:00
|
|
|
_elm_win_frame_cb_resize_show, obj);
|
2012-08-16 02:40:02 -07:00
|
|
|
edje_object_signal_callback_add
|
|
|
|
(sd->frame_obj, "elm,action,resize,hide", "*",
|
2013-04-24 04:41:37 -07:00
|
|
|
_elm_win_frame_cb_resize_hide, obj);
|
2012-05-03 15:42:15 -07:00
|
|
|
edje_object_signal_callback_add
|
|
|
|
(sd->frame_obj, "elm,action,resize,start", "*",
|
2013-04-24 04:41:37 -07:00
|
|
|
_elm_win_frame_cb_resize_start, obj);
|
2012-05-03 15:42:15 -07:00
|
|
|
edje_object_signal_callback_add
|
|
|
|
(sd->frame_obj, "elm,action,minimize", "elm",
|
2013-04-24 04:41:37 -07:00
|
|
|
_elm_win_frame_cb_minimize, obj);
|
2012-05-03 15:42:15 -07:00
|
|
|
edje_object_signal_callback_add
|
|
|
|
(sd->frame_obj, "elm,action,maximize", "elm",
|
2013-04-24 04:41:37 -07:00
|
|
|
_elm_win_frame_cb_maximize, obj);
|
2012-05-03 15:42:15 -07:00
|
|
|
edje_object_signal_callback_add
|
2013-04-24 04:41:37 -07:00
|
|
|
(sd->frame_obj, "elm,action,close", "elm", _elm_win_frame_cb_close, obj);
|
2012-08-15 03:57:31 -07:00
|
|
|
|
|
|
|
if (sd->title)
|
|
|
|
{
|
|
|
|
edje_object_part_text_escaped_set
|
|
|
|
(sd->frame_obj, "elm.text.title", sd->title);
|
|
|
|
}
|
2013-05-06 16:08:58 -07:00
|
|
|
|
|
|
|
ecore_evas_geometry_get(sd->ee, NULL, NULL, &w, &h);
|
|
|
|
ecore_evas_resize(sd->ee, w, h);
|
2012-08-15 03:57:31 -07:00
|
|
|
}
|
|
|
|
|
2012-10-10 17:35:00 -07:00
|
|
|
static void
|
2014-03-27 06:15:52 -07:00
|
|
|
_elm_win_frame_del(Elm_Win_Data *sd)
|
2012-08-15 03:57:31 -07:00
|
|
|
{
|
2013-05-06 16:08:58 -07:00
|
|
|
int w, h;
|
2013-08-23 00:36:24 -07:00
|
|
|
|
2014-01-21 17:38:55 -08:00
|
|
|
ELM_SAFE_FREE(sd->client_obj, evas_object_del);
|
2013-08-23 00:36:24 -07:00
|
|
|
|
2012-08-15 03:57:31 -07:00
|
|
|
if (sd->frame_obj)
|
|
|
|
{
|
2013-08-23 00:36:24 -07:00
|
|
|
evas_object_event_callback_del_full
|
|
|
|
(sd->frame_obj, EVAS_CALLBACK_MOVE, _elm_win_frame_obj_move, sd);
|
|
|
|
evas_object_event_callback_del_full
|
|
|
|
(sd->frame_obj, EVAS_CALLBACK_RESIZE, _elm_win_frame_obj_resize, sd);
|
2015-07-20 14:35:00 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_WAYLAND
|
|
|
|
evas_event_callback_del_full(sd->evas, EVAS_CALLBACK_RENDER_PRE, _elm_win_frame_pre_render, sd);
|
|
|
|
#endif
|
2013-08-23 00:36:24 -07:00
|
|
|
|
2012-08-15 03:57:31 -07:00
|
|
|
edje_object_signal_callback_del
|
|
|
|
(sd->frame_obj, "elm,action,move,start", "elm",
|
|
|
|
_elm_win_frame_cb_move_start);
|
2013-08-28 06:24:49 -07:00
|
|
|
edje_object_signal_callback_del
|
|
|
|
(sd->frame_obj, "elm,action,move,stop", "elm",
|
|
|
|
_elm_win_frame_cb_move_stop);
|
2012-08-15 03:57:31 -07:00
|
|
|
edje_object_signal_callback_del
|
|
|
|
(sd->frame_obj, "elm,action,resize,show", "*",
|
|
|
|
_elm_win_frame_cb_resize_show);
|
2012-08-16 02:40:02 -07:00
|
|
|
edje_object_signal_callback_del
|
|
|
|
(sd->frame_obj, "elm,action,resize,hide", "*",
|
|
|
|
_elm_win_frame_cb_resize_hide);
|
2012-08-15 03:57:31 -07:00
|
|
|
edje_object_signal_callback_del
|
|
|
|
(sd->frame_obj, "elm,action,resize,start", "*",
|
|
|
|
_elm_win_frame_cb_resize_start);
|
|
|
|
edje_object_signal_callback_del
|
|
|
|
(sd->frame_obj, "elm,action,minimize", "elm",
|
|
|
|
_elm_win_frame_cb_minimize);
|
|
|
|
edje_object_signal_callback_del
|
|
|
|
(sd->frame_obj, "elm,action,maximize", "elm",
|
|
|
|
_elm_win_frame_cb_maximize);
|
|
|
|
edje_object_signal_callback_del
|
2012-10-10 17:35:00 -07:00
|
|
|
(sd->frame_obj, "elm,action,close", "elm",
|
2012-08-15 03:57:31 -07:00
|
|
|
_elm_win_frame_cb_close);
|
|
|
|
|
2014-01-21 17:38:55 -08:00
|
|
|
ELM_SAFE_FREE(sd->frame_obj, evas_object_del);
|
2012-08-15 03:57:31 -07:00
|
|
|
}
|
2013-05-06 16:08:58 -07:00
|
|
|
|
|
|
|
evas_output_framespace_set(sd->evas, 0, 0, 0, 0);
|
|
|
|
ecore_evas_geometry_get(sd->ee, NULL, NULL, &w, &h);
|
|
|
|
ecore_evas_resize(sd->ee, w, h);
|
2012-02-10 00:37:16 -08:00
|
|
|
}
|
|
|
|
|
2010-10-20 05:38:30 -07:00
|
|
|
#ifdef ELM_DEBUG
|
|
|
|
static void
|
2014-01-06 06:30:02 -08:00
|
|
|
_debug_key_down(void *data EINA_UNUSED,
|
|
|
|
Evas *e EINA_UNUSED,
|
2012-05-03 15:42:15 -07:00
|
|
|
Evas_Object *obj,
|
|
|
|
void *event_info)
|
2010-10-20 05:38:30 -07:00
|
|
|
{
|
|
|
|
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
|
|
|
|
2013-07-30 23:14:09 -07:00
|
|
|
if ((strcmp(ev->key, "F12")) ||
|
2010-10-20 05:38:30 -07:00
|
|
|
(!evas_key_modifier_is_set(ev->modifiers, "Control")))
|
|
|
|
return;
|
|
|
|
|
2013-06-06 21:46:47 -07:00
|
|
|
INF("Tree graph generated.");
|
2010-10-20 05:38:30 -07:00
|
|
|
elm_object_tree_dot_dump(obj, "./dump.dot");
|
|
|
|
}
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2010-10-20 05:38:30 -07:00
|
|
|
#endif
|
|
|
|
|
2011-12-04 20:26:32 -08:00
|
|
|
static void
|
2014-03-27 06:15:52 -07:00
|
|
|
_win_inlined_image_set(Elm_Win_Data *sd)
|
2011-12-04 20:26:32 -08:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
evas_object_image_alpha_set(sd->img_obj, EINA_FALSE);
|
|
|
|
evas_object_image_filled_set(sd->img_obj, EINA_TRUE);
|
2012-05-02 09:58:56 -07:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
evas_object_event_callback_add
|
2013-04-24 04:41:37 -07:00
|
|
|
(sd->img_obj, EVAS_CALLBACK_DEL, _elm_win_on_img_obj_del, sd->obj);
|
2012-05-03 15:42:15 -07:00
|
|
|
evas_object_event_callback_add
|
2013-04-24 04:41:37 -07:00
|
|
|
(sd->img_obj, EVAS_CALLBACK_HIDE, _win_img_hide, sd->obj);
|
2012-05-03 15:42:15 -07:00
|
|
|
evas_object_event_callback_add
|
2013-04-24 04:41:37 -07:00
|
|
|
(sd->img_obj, EVAS_CALLBACK_MOUSE_UP, _win_img_mouse_up, sd->obj);
|
2012-05-03 15:42:15 -07:00
|
|
|
evas_object_event_callback_add
|
2013-04-24 04:41:37 -07:00
|
|
|
(sd->img_obj, EVAS_CALLBACK_FOCUS_IN, _win_img_focus_in, sd->obj);
|
2012-05-03 15:42:15 -07:00
|
|
|
evas_object_event_callback_add
|
2013-04-24 04:41:37 -07:00
|
|
|
(sd->img_obj, EVAS_CALLBACK_FOCUS_OUT, _win_img_focus_out, sd->obj);
|
2011-12-04 20:26:32 -08:00
|
|
|
}
|
|
|
|
|
2012-02-29 04:06:12 -08:00
|
|
|
static void
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_on_icon_del(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas *e EINA_UNUSED,
|
2012-05-03 15:42:15 -07:00
|
|
|
Evas_Object *obj,
|
2014-01-06 06:30:02 -08:00
|
|
|
void *event_info EINA_UNUSED)
|
2012-02-29 04:06:12 -08:00
|
|
|
{
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_WIN_DATA_GET(data, sd);
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
if (sd->icon == obj) sd->icon = NULL;
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
2014-06-03 03:35:28 -07:00
|
|
|
_elm_win_evas_object_smart_add(Eo *obj, Elm_Win_Data *_pd EINA_UNUSED)
|
2012-05-03 15:42:15 -07:00
|
|
|
{
|
2013-03-18 09:07:38 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, evas_obj_smart_add());
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
elm_widget_can_focus_set(obj, EINA_TRUE);
|
|
|
|
|
|
|
|
elm_widget_highlight_ignore_set(obj, EINA_TRUE);
|
2012-05-02 09:58:56 -07:00
|
|
|
}
|
|
|
|
|
2012-08-05 21:09:02 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
static void
|
2014-01-06 06:30:02 -08:00
|
|
|
_elm_x_io_err(void *data EINA_UNUSED)
|
2012-08-05 21:09:02 -07:00
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
Evas_Object *obj;
|
2012-08-06 03:30:55 -07:00
|
|
|
|
2012-08-05 21:09:02 -07:00
|
|
|
EINA_LIST_FOREACH(_elm_win_list, l, obj)
|
2015-05-13 04:34:44 -07:00
|
|
|
eo_do(obj, eo_event_callback_call(ELM_WIN_EVENT_IOERR, NULL));
|
2012-08-05 21:09:02 -07:00
|
|
|
elm_exit();
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-10-06 18:23:49 -07:00
|
|
|
EAPI Evas_Object *
|
2012-05-03 15:42:15 -07:00
|
|
|
elm_win_add(Evas_Object *parent,
|
|
|
|
const char *name,
|
|
|
|
Elm_Win_Type type)
|
2008-09-29 23:58:56 -07:00
|
|
|
{
|
2015-04-17 15:10:11 -07:00
|
|
|
Evas_Object *obj = eo_add(MY_CLASS, parent,
|
|
|
|
elm_obj_win_name_set(name),
|
|
|
|
elm_obj_win_type_set(type));
|
2012-11-25 22:32:53 -08:00
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
2015-01-09 21:33:55 -08:00
|
|
|
EAPI Evas_Object *
|
2015-01-12 02:13:00 -08:00
|
|
|
elm_win_fake_add(Ecore_Evas *ee)
|
2015-01-09 21:33:55 -08:00
|
|
|
{
|
2015-01-12 02:13:34 -08:00
|
|
|
return eo_add(MY_CLASS, NULL,
|
|
|
|
elm_obj_win_fake_canvas_set(ee),
|
2015-04-17 15:10:11 -07:00
|
|
|
elm_obj_win_name_set(NULL),
|
|
|
|
elm_obj_win_type_set(ELM_WIN_FAKE));
|
2015-01-09 21:33:55 -08:00
|
|
|
}
|
|
|
|
|
2013-01-10 03:53:39 -08:00
|
|
|
static void
|
2014-01-06 06:30:02 -08:00
|
|
|
_elm_win_cb_hide(void *data EINA_UNUSED,
|
|
|
|
Evas *e EINA_UNUSED,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
void *event_info EINA_UNUSED)
|
2013-01-10 03:53:39 -08:00
|
|
|
{
|
|
|
|
_elm_win_state_eval_queue();
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2014-01-06 06:30:02 -08:00
|
|
|
_elm_win_cb_show(void *data EINA_UNUSED,
|
|
|
|
Evas *e EINA_UNUSED,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
void *event_info EINA_UNUSED)
|
2013-01-10 03:53:39 -08:00
|
|
|
{
|
|
|
|
_elm_win_state_eval_queue();
|
|
|
|
}
|
|
|
|
|
2013-07-02 21:19:56 -07:00
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Recalculate the size of window considering its resize objects' weight and
|
|
|
|
* min size. If any of its resize objects' weight equals to 0.0, window
|
|
|
|
* layout's weight will be set to 0.0.
|
|
|
|
*
|
|
|
|
* @param o box object
|
|
|
|
* @param p box's private data
|
|
|
|
* @param data window object
|
|
|
|
*/
|
2013-01-17 14:11:15 -08:00
|
|
|
static void
|
|
|
|
_window_layout_stack(Evas_Object *o, Evas_Object_Box_Data *p, void *data)
|
|
|
|
{
|
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *child;
|
|
|
|
Evas_Object_Box_Option *opt;
|
|
|
|
Evas_Coord x, y, w, h;
|
|
|
|
double wx, wy;
|
|
|
|
Evas_Coord minw = -1, minh = -1;
|
|
|
|
double weight_x = EVAS_HINT_EXPAND;
|
|
|
|
double weight_y = EVAS_HINT_EXPAND;
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(p->children, l, opt)
|
|
|
|
{
|
|
|
|
child = opt->obj;
|
|
|
|
evas_object_size_hint_weight_get(child, &wx, &wy);
|
|
|
|
if (wx == 0.0) weight_x = 0;
|
|
|
|
if (wy == 0.0) weight_y = 0;
|
|
|
|
|
|
|
|
evas_object_size_hint_min_get(child, &w, &h);
|
|
|
|
if (w > minw) minw = w;
|
|
|
|
if (h > minh) minh = h;
|
|
|
|
}
|
|
|
|
|
|
|
|
evas_object_size_hint_min_set(o, minw, minh);
|
|
|
|
evas_object_geometry_get(o, &x, &y, &w, &h);
|
|
|
|
if (w < minw) w = minw;
|
|
|
|
if (h < minh) h = minh;
|
|
|
|
evas_object_resize(o, w, h);
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(p->children, l, opt)
|
|
|
|
{
|
|
|
|
child = opt->obj;
|
|
|
|
evas_object_move(child, x, y);
|
|
|
|
evas_object_resize(child, w, h);
|
|
|
|
}
|
|
|
|
|
|
|
|
ELM_WIN_DATA_GET(data, sd);
|
2014-12-15 09:02:40 -08:00
|
|
|
evas_object_size_hint_weight_set(sd->edje, weight_x, weight_y);
|
|
|
|
evas_object_smart_changed(sd->edje);
|
2013-01-17 14:11:15 -08:00
|
|
|
}
|
|
|
|
|
2014-03-28 00:28:31 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_accel_is_gl(void)
|
|
|
|
{
|
2014-09-24 08:32:24 -07:00
|
|
|
const char *env = NULL;
|
|
|
|
const char *str = NULL;
|
|
|
|
|
|
|
|
if (_elm_config->accel) str = _elm_config->accel;
|
|
|
|
if (_elm_accel_preference) str = _elm_accel_preference;
|
|
|
|
if ((_elm_config->accel_override) && (_elm_config->accel))
|
|
|
|
str = _elm_config->accel;
|
|
|
|
env = getenv("ELM_ACCEL");
|
|
|
|
if (env) str = env;
|
2014-04-15 02:41:39 -07:00
|
|
|
if ((str) &&
|
|
|
|
((!strcasecmp(str, "gl")) ||
|
|
|
|
(!strcasecmp(str, "opengl")) ||
|
|
|
|
(!strcasecmp(str, "3d")) ||
|
|
|
|
(!strcasecmp(str, "hw")) ||
|
|
|
|
(!strcasecmp(str, "accel")) ||
|
|
|
|
(!strcasecmp(str, "hardware"))
|
2014-03-28 00:28:31 -07:00
|
|
|
))
|
|
|
|
return EINA_TRUE;
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2015-04-30 05:58:26 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_animator_tick_cb(void *_obj)
|
|
|
|
{
|
|
|
|
Elm_Win *obj = _obj;
|
|
|
|
eo_do(obj, eo_event_callback_call(ELM_WIN_EVENT_ANIMATOR_TICK, NULL));
|
|
|
|
|
|
|
|
return ECORE_CALLBACK_RENEW;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_cb_added(void *_data,
|
|
|
|
Eo *obj,
|
|
|
|
const Eo_Event_Description *desc EINA_UNUSED,
|
|
|
|
void *event_info)
|
|
|
|
{
|
|
|
|
const Eo_Callback_Array_Item *event = event_info;
|
|
|
|
Elm_Win_Data *data = _data;
|
|
|
|
|
|
|
|
if (event->desc == ELM_WIN_EVENT_ANIMATOR_TICK)
|
|
|
|
{
|
|
|
|
data->animator.wants++;
|
|
|
|
if (data->animator.wants == 1)
|
|
|
|
{
|
|
|
|
data->animator.obj = eo_add(ECORE_ANIMATOR_CLASS, obj,
|
|
|
|
ecore_animator_constructor(_animator_tick_cb, obj));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return EO_CALLBACK_CONTINUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_cb_deled(void *_data,
|
|
|
|
Eo *obj EINA_UNUSED,
|
|
|
|
const Eo_Event_Description *desc EINA_UNUSED,
|
|
|
|
void *event_info)
|
|
|
|
{
|
|
|
|
const Eo_Callback_Array_Item *event = event_info;
|
|
|
|
Elm_Win_Data *data = _data;
|
|
|
|
|
|
|
|
if (event->desc == ELM_WIN_EVENT_ANIMATOR_TICK)
|
|
|
|
{
|
|
|
|
data->animator.wants--;
|
|
|
|
if (data->animator.wants == 0)
|
|
|
|
{
|
|
|
|
eo_del(data->animator.obj);
|
|
|
|
data->animator.obj = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return EO_CALLBACK_CONTINUE;
|
|
|
|
}
|
|
|
|
|
2015-05-20 08:31:04 -07:00
|
|
|
static Eo *
|
2015-04-17 15:10:11 -07:00
|
|
|
_elm_win_finalize_internal(Eo *obj, Elm_Win_Data *sd, const char *name, Elm_Win_Type type)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
|
|
|
sd->obj = obj; // in ctor
|
|
|
|
|
2014-04-03 09:23:03 -07:00
|
|
|
Evas_Object *parent = NULL;
|
2012-05-03 15:42:15 -07:00
|
|
|
Evas *e;
|
2009-02-25 11:50:45 -08:00
|
|
|
const Eina_List *l;
|
2014-03-08 07:49:33 -08:00
|
|
|
const char *fontpath, *engine = NULL, *enginelist[32], *disp;
|
2014-08-26 04:11:02 -07:00
|
|
|
int i, p = 0;
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
Elm_Win_Data tmp_sd;
|
2010-11-01 14:10:07 -07:00
|
|
|
|
2014-04-03 09:23:03 -07:00
|
|
|
eo_do(obj, parent = eo_parent_get());
|
2013-09-24 21:33:39 -07:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
/* just to store some data while trying out to create a canvas */
|
2014-03-27 06:15:52 -07:00
|
|
|
memset(&tmp_sd, 0, sizeof(Elm_Win_Data));
|
2011-04-14 03:48:43 -07:00
|
|
|
|
|
|
|
switch (type)
|
2008-09-29 23:58:56 -07:00
|
|
|
{
|
2015-01-09 21:33:55 -08:00
|
|
|
case ELM_WIN_FAKE:
|
2015-01-12 02:13:34 -08:00
|
|
|
tmp_sd.ee = sd->ee;
|
2015-01-09 21:33:55 -08:00
|
|
|
break;
|
2011-04-14 03:48:43 -07:00
|
|
|
case ELM_WIN_INLINED_IMAGE:
|
2011-07-23 10:27:39 -07:00
|
|
|
if (!parent) break;
|
2013-11-15 00:47:54 -08:00
|
|
|
{
|
|
|
|
e = evas_object_evas_get(parent);
|
|
|
|
Ecore_Evas *ee;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2013-11-15 00:47:54 -08:00
|
|
|
if (!e) break;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2013-11-15 00:47:54 -08:00
|
|
|
ee = ecore_evas_ecore_evas_get(e);
|
|
|
|
if (!ee) break;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2013-11-15 00:47:54 -08:00
|
|
|
tmp_sd.img_obj = ecore_evas_object_image_new(ee);
|
|
|
|
if (!tmp_sd.img_obj) break;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2013-11-15 00:47:54 -08:00
|
|
|
tmp_sd.ee = ecore_evas_object_ecore_evas_get(tmp_sd.img_obj);
|
|
|
|
if (!tmp_sd.ee)
|
|
|
|
{
|
2014-01-21 17:38:55 -08:00
|
|
|
ELM_SAFE_FREE(tmp_sd.img_obj, evas_object_del);
|
2013-11-15 00:47:54 -08:00
|
|
|
}
|
|
|
|
}
|
2011-04-14 03:48:43 -07:00
|
|
|
break;
|
2012-01-16 09:18:20 -08:00
|
|
|
|
|
|
|
case ELM_WIN_SOCKET_IMAGE:
|
2012-05-03 15:42:15 -07:00
|
|
|
tmp_sd.ee = ecore_evas_extn_socket_new(1, 1);
|
2012-01-16 09:18:20 -08:00
|
|
|
break;
|
|
|
|
|
2011-04-14 03:48:43 -07:00
|
|
|
default:
|
2014-03-08 07:49:33 -08:00
|
|
|
disp = getenv("ELM_DISPLAY");
|
2014-08-26 04:11:02 -07:00
|
|
|
if ((disp) && (!strcmp(disp, "ews")))
|
|
|
|
{
|
|
|
|
enginelist[p++] = ELM_EWS;
|
|
|
|
}
|
|
|
|
else if ((disp) && (!strcmp(disp, "buffer")))
|
|
|
|
{
|
|
|
|
enginelist[p++] = ELM_BUFFER;
|
|
|
|
}
|
|
|
|
else if ((disp) && (!strcmp(disp, "shot")))
|
|
|
|
{
|
|
|
|
enginelist[p++] = ENGINE_GET();
|
|
|
|
}
|
|
|
|
// welcome to ifdef hell! :)
|
|
|
|
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
else if ((disp) && (!strcmp(disp, "x11")))
|
2011-04-14 03:48:43 -07:00
|
|
|
{
|
2014-03-28 00:28:31 -07:00
|
|
|
if (_accel_is_gl())
|
2014-03-08 08:22:33 -08:00
|
|
|
{
|
2014-08-26 04:11:02 -07:00
|
|
|
enginelist[p++] = ELM_OPENGL_X11;
|
|
|
|
enginelist[p++] = ELM_SOFTWARE_X11;
|
2014-03-08 08:22:33 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-08-26 04:11:02 -07:00
|
|
|
enginelist[p++] = ELM_SOFTWARE_X11;
|
|
|
|
enginelist[p++] = ELM_OPENGL_X11;
|
2014-03-08 08:22:33 -08:00
|
|
|
}
|
2011-04-14 03:48:43 -07:00
|
|
|
}
|
2014-08-26 04:11:02 -07:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef HAVE_ELEMENTARY_WAYLAND
|
2014-03-08 07:49:33 -08:00
|
|
|
else if ((disp) && (!strcmp(disp, "wl")))
|
2011-04-14 03:48:43 -07:00
|
|
|
{
|
2014-03-28 00:28:31 -07:00
|
|
|
if (_accel_is_gl())
|
2014-03-08 08:22:33 -08:00
|
|
|
{
|
2014-08-26 04:11:02 -07:00
|
|
|
enginelist[p++] = ELM_WAYLAND_EGL;
|
|
|
|
enginelist[p++] = ELM_WAYLAND_SHM;
|
2014-03-08 08:22:33 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-08-26 04:11:02 -07:00
|
|
|
enginelist[p++] = ELM_WAYLAND_SHM;
|
|
|
|
enginelist[p++] = ELM_WAYLAND_EGL;
|
2014-03-08 08:22:33 -08:00
|
|
|
}
|
2011-04-14 03:48:43 -07:00
|
|
|
}
|
2014-08-26 04:11:02 -07:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef HAVE_ELEMENTARY_WIN32
|
2014-03-08 07:49:33 -08:00
|
|
|
else if ((disp) && (!strcmp(disp, "win")))
|
2011-04-14 03:48:43 -07:00
|
|
|
{
|
2014-08-26 04:11:02 -07:00
|
|
|
enginelist[p++] = ELM_SOFTWARE_WIN32;
|
|
|
|
enginelist[p++] = ELM_SOFTWARE_DDRAW;
|
2011-04-14 03:48:43 -07:00
|
|
|
}
|
2014-08-26 04:11:02 -07:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef HAVE_ELEMENTARY_SDL
|
2014-03-08 07:49:33 -08:00
|
|
|
else if ((disp) && (!strcmp(disp, "sdl")))
|
2011-04-14 03:48:43 -07:00
|
|
|
{
|
2014-03-28 00:28:31 -07:00
|
|
|
if (_accel_is_gl())
|
2014-03-08 08:22:33 -08:00
|
|
|
{
|
2014-08-26 04:11:02 -07:00
|
|
|
enginelist[p++] = ELM_OPENGL_SDL;
|
|
|
|
enginelist[p++] = ELM_SOFTWARE_SDL;
|
2014-03-08 08:22:33 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-08-26 04:11:02 -07:00
|
|
|
enginelist[p++] = ELM_SOFTWARE_SDL;
|
|
|
|
enginelist[p++] = ELM_OPENGL_SDL;
|
2014-03-08 08:22:33 -08:00
|
|
|
}
|
2011-04-14 03:48:43 -07:00
|
|
|
}
|
2014-08-26 04:11:02 -07:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef HAVE_ELEMENTARY_COCOA
|
2014-03-08 07:49:33 -08:00
|
|
|
else if ((disp) && (!strcmp(disp, "mac")))
|
2011-11-05 10:50:09 -07:00
|
|
|
{
|
2014-08-26 04:11:02 -07:00
|
|
|
enginelist[p++] = ELM_OPENGL_COCOA;
|
2011-04-14 03:48:43 -07:00
|
|
|
}
|
2014-08-26 04:11:02 -07:00
|
|
|
#endif
|
|
|
|
|
2015-08-03 05:39:54 -07:00
|
|
|
#if defined(HAVE_ELEMENTARY_DRM) || defined(HAVE_ELEMENTARY_FB)
|
2014-03-08 07:49:33 -08:00
|
|
|
else if ((disp) && (!strcmp(disp, "fb")))
|
2011-04-14 03:48:43 -07:00
|
|
|
{
|
2014-08-26 04:11:02 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_DRM
|
|
|
|
enginelist[p++] = ELM_DRM;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ELEMENTARY_FB
|
|
|
|
enginelist[p++] = ELM_SOFTWARE_FB;
|
|
|
|
#endif
|
2011-11-02 12:26:29 -07:00
|
|
|
}
|
2014-08-26 04:11:02 -07:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef HAVE_ELEMENTARY_PSL1GHT
|
2014-03-08 07:49:33 -08:00
|
|
|
else if ((disp) && (!strcmp(disp, "ps3")))
|
2011-07-25 05:02:52 -07:00
|
|
|
{
|
2014-08-26 04:11:02 -07:00
|
|
|
enginelist[p++] = ELM_SOFTWARE_PSL1GHT;
|
2011-10-05 15:18:22 -07:00
|
|
|
}
|
2014-08-26 04:11:02 -07:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2015-02-10 02:48:21 -08:00
|
|
|
else if (!_elm_preferred_engine &&
|
2014-12-12 04:56:26 -08:00
|
|
|
getenv("DISPLAY") && !getenv("ELM_ENGINE"))
|
2014-08-05 08:04:11 -07:00
|
|
|
{
|
|
|
|
if (_accel_is_gl())
|
|
|
|
{
|
2014-08-26 04:11:02 -07:00
|
|
|
enginelist[p++] = ELM_OPENGL_X11;
|
|
|
|
enginelist[p++] = ELM_SOFTWARE_X11;
|
2014-08-05 08:04:11 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-08-26 04:11:02 -07:00
|
|
|
enginelist[p++] = ELM_SOFTWARE_X11;
|
|
|
|
enginelist[p++] = ELM_OPENGL_X11;
|
2014-08-05 08:04:11 -07:00
|
|
|
}
|
|
|
|
}
|
2014-08-26 04:11:02 -07:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ELEMENTARY_WAYLAND
|
2015-02-10 02:48:21 -08:00
|
|
|
else if (!_elm_preferred_engine &&
|
2014-12-12 04:56:26 -08:00
|
|
|
getenv("WAYLAND_DISPLAY") && !getenv("ELM_ENGINE"))
|
2014-08-05 08:04:11 -07:00
|
|
|
{
|
|
|
|
if (_accel_is_gl())
|
|
|
|
{
|
2014-08-26 04:11:02 -07:00
|
|
|
enginelist[p++] = ELM_WAYLAND_EGL;
|
|
|
|
enginelist[p++] = ELM_WAYLAND_SHM;
|
2014-08-05 08:04:11 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-08-26 04:11:02 -07:00
|
|
|
enginelist[p++] = ELM_WAYLAND_SHM;
|
|
|
|
enginelist[p++] = ELM_WAYLAND_EGL;
|
2014-08-05 08:04:11 -07:00
|
|
|
}
|
|
|
|
}
|
2014-08-26 04:11:02 -07:00
|
|
|
#endif
|
2014-03-08 07:49:33 -08:00
|
|
|
else
|
2012-01-12 01:10:27 -08:00
|
|
|
{
|
2014-03-28 00:28:31 -07:00
|
|
|
if (_accel_is_gl())
|
2014-03-08 08:22:33 -08:00
|
|
|
{
|
2015-02-10 02:48:21 -08:00
|
|
|
// add all engines with selected engine first - if any
|
|
|
|
enginelist[p++] = ENGINE_GET();
|
2014-08-26 04:11:02 -07:00
|
|
|
|
|
|
|
// add all engines with gl/accelerated ones first - only engines compiled
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
enginelist[p++] = ELM_OPENGL_X11;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ELEMENTARY_WAYLAND
|
|
|
|
enginelist[p++] = ELM_WAYLAND_EGL;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ELEMENTARY_DRM
|
|
|
|
enginelist[p++] = ELM_DRM;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ELEMENTARY_FB
|
|
|
|
enginelist[p++] = ELM_SOFTWARE_FB;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ELEMENTARY_COCOA
|
|
|
|
enginelist[p++] = ELM_OPENGL_COCOA;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ELEMENTARY_SDL
|
|
|
|
enginelist[p++] = ELM_OPENGL_SDL;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
enginelist[p++] = ELM_SOFTWARE_X11;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ELEMENTARY_WAYLAND
|
|
|
|
enginelist[p++] = ELM_WAYLAND_SHM;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ELEMENTARY_WIN32
|
|
|
|
enginelist[p++] = ELM_SOFTWARE_WIN32;
|
|
|
|
enginelist[p++] = ELM_SOFTWARE_DDRAW;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ELEMENTARY_SDL
|
|
|
|
enginelist[p++] = ELM_SOFTWARE_SDL;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ELEMENTARY_PSL1GHT
|
|
|
|
enginelist[p++] = ELM_SOFTWARE_PSL1GHT;
|
|
|
|
#endif
|
2014-03-08 08:22:33 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-08-26 04:11:02 -07:00
|
|
|
// add all engines with selected engine first - if any
|
|
|
|
enginelist[p++] = ENGINE_GET();
|
|
|
|
|
|
|
|
// add all engines with gl/accelerated ones first - only engines compiled
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
enginelist[p++] = ELM_SOFTWARE_X11;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ELEMENTARY_WAYLAND
|
|
|
|
enginelist[p++] = ELM_WAYLAND_SHM;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ELEMENTARY_DRM
|
|
|
|
enginelist[p++] = ELM_DRM;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ELEMENTARY_FB
|
|
|
|
enginelist[p++] = ELM_SOFTWARE_FB;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ELEMENTARY_COCOA
|
|
|
|
enginelist[p++] = ELM_OPENGL_COCOA;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ELEMENTARY_WIN32
|
|
|
|
enginelist[p++] = ELM_SOFTWARE_WIN32;
|
|
|
|
enginelist[p++] = ELM_SOFTWARE_DDRAW;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ELEMENTARY_SDL
|
|
|
|
enginelist[p++] = ELM_SOFTWARE_SDL;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
enginelist[p++] = ELM_OPENGL_X11;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ELEMENTARY_WAYLAND
|
|
|
|
enginelist[p++] = ELM_WAYLAND_EGL;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ELEMENTARY_DRM
|
|
|
|
enginelist[p++] = ELM_DRM;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ELEMENTARY_SDL
|
|
|
|
enginelist[p++] = ELM_OPENGL_SDL;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ELEMENTARY_PSL1GHT
|
|
|
|
enginelist[p++] = ELM_SOFTWARE_PSL1GHT;
|
|
|
|
#endif
|
2014-03-08 08:22:33 -08:00
|
|
|
}
|
2012-05-02 18:19:05 -07:00
|
|
|
}
|
2014-08-26 04:11:02 -07:00
|
|
|
enginelist[p++] = NULL;
|
2014-03-08 07:49:33 -08:00
|
|
|
for (i = 0; i < 30; i++)
|
2012-05-02 18:19:05 -07:00
|
|
|
{
|
2014-03-08 07:49:33 -08:00
|
|
|
if ((i > 0) && (!enginelist[i])) break;
|
|
|
|
if (!strcmp(enginelist[i], ELM_SOFTWARE_X11))
|
|
|
|
tmp_sd.ee = ecore_evas_software_x11_new(NULL, 0, 0, 0, 1, 1);
|
|
|
|
else if (!strcmp(enginelist[i], ELM_OPENGL_X11))
|
|
|
|
{
|
2015-03-15 22:14:12 -07:00
|
|
|
int opt[20], opt_i = 0;
|
2014-03-08 07:49:33 -08:00
|
|
|
|
|
|
|
if (_elm_config->vsync)
|
|
|
|
{
|
|
|
|
opt[opt_i++] = ECORE_EVAS_GL_X11_OPT_VSYNC;
|
|
|
|
opt[opt_i++] = 1;
|
|
|
|
}
|
2015-03-15 22:14:12 -07:00
|
|
|
if (_elm_config->gl_depth)
|
|
|
|
{
|
|
|
|
opt[opt_i++] = ECORE_EVAS_GL_X11_OPT_GL_DEPTH;
|
|
|
|
opt[opt_i++] = _elm_config->gl_depth;
|
|
|
|
}
|
|
|
|
if (_elm_config->gl_stencil)
|
|
|
|
{
|
|
|
|
opt[opt_i++] = ECORE_EVAS_GL_X11_OPT_GL_STENCIL;
|
|
|
|
opt[opt_i++] = _elm_config->gl_stencil;
|
|
|
|
}
|
|
|
|
if (_elm_config->gl_msaa)
|
|
|
|
{
|
|
|
|
opt[opt_i++] = ECORE_EVAS_GL_X11_OPT_GL_MSAA;
|
|
|
|
opt[opt_i++] = _elm_config->gl_msaa;
|
|
|
|
}
|
|
|
|
opt[opt_i] = 0;
|
2014-03-08 07:49:33 -08:00
|
|
|
if (opt_i > 0)
|
|
|
|
tmp_sd.ee = ecore_evas_gl_x11_options_new(NULL, 0, 0, 0, 1, 1, opt);
|
|
|
|
else
|
|
|
|
tmp_sd.ee = ecore_evas_gl_x11_new(NULL, 0, 0, 0, 1, 1);
|
|
|
|
}
|
|
|
|
else if (!strcmp(enginelist[i], ELM_WAYLAND_SHM))
|
|
|
|
tmp_sd.ee = ecore_evas_wayland_shm_new(NULL, 0, 0, 0, 1, 1, 0);
|
|
|
|
else if (!strcmp(enginelist[i], ELM_WAYLAND_EGL))
|
|
|
|
tmp_sd.ee = ecore_evas_wayland_egl_new(NULL, 0, 0, 0, 1, 1, 0);
|
|
|
|
else if (!strcmp(enginelist[i], ELM_SOFTWARE_WIN32))
|
|
|
|
tmp_sd.ee = ecore_evas_software_gdi_new(NULL, 0, 0, 1, 1);
|
2014-08-26 04:11:02 -07:00
|
|
|
else if (!strcmp(enginelist[i], ELM_SOFTWARE_DDRAW))
|
|
|
|
tmp_sd.ee = ecore_evas_software_ddraw_new(NULL, 0, 0, 1, 1);
|
2014-03-08 07:49:33 -08:00
|
|
|
else if (!strcmp(enginelist[i], ELM_SOFTWARE_SDL))
|
|
|
|
tmp_sd.ee = ecore_evas_sdl_new(NULL, 0, 0, 0, 0, 0, 1);
|
|
|
|
else if (!strcmp(enginelist[i], ELM_OPENGL_SDL))
|
|
|
|
tmp_sd.ee = ecore_evas_gl_sdl_new(NULL, 1, 1, 0, 0);
|
|
|
|
else if (!strcmp(enginelist[i], ELM_OPENGL_COCOA))
|
|
|
|
tmp_sd.ee = ecore_evas_cocoa_new(NULL, 1, 1, 0, 0);
|
|
|
|
else if (!strcmp(enginelist[i], ELM_EWS))
|
|
|
|
tmp_sd.ee = ecore_evas_ews_new(0, 0, 1, 1);
|
|
|
|
else if (!strcmp(enginelist[i], ELM_SOFTWARE_FB))
|
|
|
|
tmp_sd.ee = ecore_evas_fb_new(NULL, 0, 1, 1);
|
|
|
|
else if (!strcmp(enginelist[i], ELM_BUFFER))
|
|
|
|
tmp_sd.ee = ecore_evas_buffer_new(1, 1);
|
|
|
|
else if (!strcmp(enginelist[i], ELM_SOFTWARE_PSL1GHT))
|
|
|
|
tmp_sd.ee = ecore_evas_psl1ght_new(NULL, 1, 1);
|
2014-03-28 03:42:27 -07:00
|
|
|
else if (!strcmp(enginelist[i], ELM_DRM))
|
|
|
|
tmp_sd.ee = ecore_evas_drm_new(NULL, 0, 0, 0, 1, 1);
|
2014-03-08 07:49:33 -08:00
|
|
|
else if (!strncmp(enginelist[i], "shot:", 5))
|
|
|
|
{
|
|
|
|
tmp_sd.ee = ecore_evas_buffer_new(1, 1);
|
|
|
|
ecore_evas_manual_render_set(tmp_sd.ee, EINA_TRUE);
|
|
|
|
tmp_sd.shot.info = eina_stringshare_add(ENGINE_GET() + 5);
|
|
|
|
}
|
|
|
|
engine = enginelist[i];
|
|
|
|
if (tmp_sd.ee) break;
|
2012-05-02 18:19:05 -07:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2012-05-02 09:58:56 -07:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
if (!tmp_sd.ee)
|
|
|
|
{
|
|
|
|
ERR("Cannot create window.");
|
2015-05-20 08:31:04 -07:00
|
|
|
return NULL;
|
2012-05-03 15:42:15 -07:00
|
|
|
}
|
2012-07-17 11:46:18 -07:00
|
|
|
|
2013-09-24 21:33:39 -07:00
|
|
|
eo_do(obj, eo_parent_set(ecore_evas_get(tmp_sd.ee)));
|
2014-09-25 09:39:32 -07:00
|
|
|
|
|
|
|
/* XXX: This hack is needed because we parent ourselves to an inside object.
|
|
|
|
* That should be fixed, and then this can be fixed.
|
|
|
|
* Only needed if there wasn't a parent, because if there was, we are just
|
|
|
|
* replacing it. */
|
|
|
|
if (!parent)
|
|
|
|
{
|
|
|
|
eo_unref(obj);
|
|
|
|
}
|
|
|
|
|
2013-03-18 09:07:38 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, eo_constructor());
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_do(obj,
|
2013-11-07 03:44:22 -08:00
|
|
|
evas_obj_type_set(MY_CLASS_NAME_LEGACY),
|
2014-04-03 09:23:03 -07:00
|
|
|
evas_obj_smart_callbacks_descriptions_set(_smart_callbacks));
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2013-03-20 01:37:40 -07:00
|
|
|
if (getenv("ELM_FIRST_FRAME"))
|
|
|
|
evas_event_callback_add(ecore_evas_get(tmp_sd.ee), EVAS_CALLBACK_RENDER_POST,
|
2013-10-13 22:40:35 -07:00
|
|
|
_elm_win_first_frame_do, getenv("ELM_FIRST_FRAME"));
|
2013-03-20 01:37:40 -07:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
/* copying possibly altered fields back */
|
|
|
|
#define SD_CPY(_field) \
|
|
|
|
do \
|
|
|
|
{ \
|
|
|
|
sd->_field = tmp_sd._field; \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
SD_CPY(ee);
|
|
|
|
SD_CPY(img_obj);
|
|
|
|
SD_CPY(shot.info);
|
|
|
|
#undef SD_CPY
|
|
|
|
|
2015-01-09 21:33:55 -08:00
|
|
|
if ((type != ELM_WIN_FAKE) && (trap) && (trap->add))
|
2012-07-18 21:35:50 -07:00
|
|
|
sd->trap_data = trap->add(obj);
|
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
/* complementary actions, which depend on final smart data
|
|
|
|
* pointer */
|
|
|
|
if (type == ELM_WIN_INLINED_IMAGE)
|
|
|
|
_win_inlined_image_set(sd);
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2014-03-09 05:17:28 -07:00
|
|
|
else if ((engine) &&
|
|
|
|
((!strcmp(engine, ELM_SOFTWARE_X11)) ||
|
|
|
|
(!strcmp(engine, ELM_OPENGL_X11))))
|
2012-11-19 08:51:44 -08:00
|
|
|
{
|
|
|
|
sd->x.client_message_handler = ecore_event_handler_add
|
2013-04-24 04:41:37 -07:00
|
|
|
(ECORE_X_EVENT_CLIENT_MESSAGE, _elm_win_client_message, obj);
|
2012-11-19 08:51:44 -08:00
|
|
|
sd->x.property_handler = ecore_event_handler_add
|
2013-04-24 04:41:37 -07:00
|
|
|
(ECORE_X_EVENT_WINDOW_PROPERTY, _elm_win_property_change, obj);
|
2012-11-19 08:51:44 -08:00
|
|
|
}
|
2012-05-03 15:42:15 -07:00
|
|
|
#endif
|
2014-03-09 05:17:28 -07:00
|
|
|
else if ((engine) && (!strncmp(engine, "shot:", 5)))
|
2012-05-03 15:42:15 -07:00
|
|
|
_shot_init(sd);
|
|
|
|
|
|
|
|
sd->kbdmode = ELM_WIN_KEYBOARD_UNKNOWN;
|
|
|
|
sd->indmode = ELM_WIN_INDICATOR_UNKNOWN;
|
|
|
|
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2014-03-27 06:15:52 -07:00
|
|
|
_internal_elm_win_xwindow_get(sd);
|
2012-08-05 21:09:02 -07:00
|
|
|
if (sd->x.xwin)
|
|
|
|
{
|
|
|
|
ecore_x_io_error_handler_set(_elm_x_io_err, NULL);
|
|
|
|
}
|
2010-09-24 09:41:25 -07:00
|
|
|
#endif
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2012-06-06 06:55:15 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_WAYLAND
|
2014-08-10 15:59:45 -07:00
|
|
|
_elm_win_wlwindow_get(sd);
|
2012-06-06 06:55:15 -07:00
|
|
|
#endif
|
|
|
|
|
2012-11-30 03:00:01 -08:00
|
|
|
if ((_elm_config->bgpixmap)
|
2012-11-30 02:26:18 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2012-11-30 03:00:01 -08:00
|
|
|
&&
|
2012-11-30 02:26:18 -08:00
|
|
|
(((sd->x.xwin) && (!ecore_x_screen_is_composited(0))) ||
|
|
|
|
(!sd->x.xwin)))
|
2012-11-30 03:00:01 -08:00
|
|
|
#else
|
2014-03-28 03:42:27 -07:00
|
|
|
)
|
2012-11-30 03:00:01 -08:00
|
|
|
#endif
|
2012-07-18 21:35:50 -07:00
|
|
|
TRAP(sd, avoid_damage_set, 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
|
2012-07-18 21:35:50 -07:00
|
|
|
// TRAP(sd, avoid_damage_set, ECORE_EVAS_AVOID_DAMAGE_BUILT_IN);
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
sd->type = type;
|
|
|
|
sd->parent = parent;
|
2014-04-09 03:04:55 -07:00
|
|
|
sd->modal_count = 0;
|
2015-05-19 05:32:10 -07:00
|
|
|
sd->withdrawn = ecore_evas_withdrawn_get(sd->ee);
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
if (sd->parent)
|
|
|
|
evas_object_event_callback_add
|
2013-04-24 04:41:37 -07:00
|
|
|
(sd->parent, EVAS_CALLBACK_DEL, _elm_win_on_parent_del, obj);
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
sd->evas = ecore_evas_get(sd->ee);
|
|
|
|
|
|
|
|
evas_object_color_set(obj, 0, 0, 0, 0);
|
|
|
|
evas_object_move(obj, 0, 0);
|
|
|
|
evas_object_resize(obj, 1, 1);
|
|
|
|
evas_object_layer_set(obj, 50);
|
|
|
|
evas_object_pass_events_set(obj, EINA_TRUE);
|
|
|
|
|
2011-08-02 03:34:30 -07:00
|
|
|
if (type == ELM_WIN_INLINED_IMAGE)
|
2012-05-03 15:42:15 -07:00
|
|
|
elm_widget_parent2_set(obj, parent);
|
|
|
|
|
2012-07-18 21:35:50 -07:00
|
|
|
/* use own version of ecore_evas_object_associate() that does TRAP() */
|
2013-04-24 04:41:37 -07:00
|
|
|
ecore_evas_data_set(sd->ee, "elm_win", obj);
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2015-01-09 21:33:55 -08:00
|
|
|
if (type != ELM_WIN_FAKE)
|
|
|
|
{
|
|
|
|
evas_object_event_callback_add(obj, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
|
|
|
|
_elm_win_obj_callback_changed_size_hints, obj);
|
|
|
|
evas_object_intercept_raise_callback_add
|
|
|
|
(obj, _elm_win_obj_intercept_raise, obj);
|
|
|
|
evas_object_intercept_lower_callback_add
|
|
|
|
(obj, _elm_win_obj_intercept_lower, obj);
|
|
|
|
evas_object_intercept_stack_above_callback_add
|
|
|
|
(obj, _elm_win_obj_intercept_stack_above, obj);
|
|
|
|
evas_object_intercept_stack_below_callback_add
|
|
|
|
(obj, _elm_win_obj_intercept_stack_below, obj);
|
|
|
|
evas_object_intercept_layer_set_callback_add
|
|
|
|
(obj, _elm_win_obj_intercept_layer_set, obj);
|
|
|
|
evas_object_intercept_show_callback_add
|
|
|
|
(obj, _elm_win_obj_intercept_show, obj);
|
|
|
|
}
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2012-07-18 21:35:50 -07:00
|
|
|
TRAP(sd, name_class_set, name, _elm_appname);
|
2015-04-17 15:10:11 -07:00
|
|
|
TRAP(sd, title_set, sd->title);
|
2012-05-03 15:42:15 -07:00
|
|
|
ecore_evas_callback_delete_request_set(sd->ee, _elm_win_delete_request);
|
|
|
|
ecore_evas_callback_state_change_set(sd->ee, _elm_win_state_change);
|
2015-01-09 22:36:27 -08:00
|
|
|
ecore_evas_callback_focus_in_set(sd->ee, _elm_win_focus_in);
|
|
|
|
ecore_evas_callback_focus_out_set(sd->ee, _elm_win_focus_out);
|
2015-01-09 21:33:55 -08:00
|
|
|
if (type != ELM_WIN_FAKE)
|
|
|
|
{
|
|
|
|
ecore_evas_callback_resize_set(sd->ee, _elm_win_resize);
|
|
|
|
ecore_evas_callback_mouse_in_set(sd->ee, _elm_win_mouse_in);
|
|
|
|
ecore_evas_callback_move_set(sd->ee, _elm_win_move);
|
|
|
|
}
|
2013-04-24 04:41:37 -07:00
|
|
|
evas_object_event_callback_add(obj, EVAS_CALLBACK_HIDE, _elm_win_cb_hide, NULL);
|
|
|
|
evas_object_event_callback_add(obj, EVAS_CALLBACK_SHOW, _elm_win_cb_show, NULL);
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
evas_image_cache_set(sd->evas, (_elm_config->image_cache * 1024));
|
|
|
|
evas_font_cache_set(sd->evas, (_elm_config->font_cache * 1024));
|
|
|
|
|
2012-08-05 21:09:02 -07:00
|
|
|
EINA_LIST_FOREACH(_elm_config->font_dirs, l, fontpath)
|
2012-05-03 15:42:15 -07:00
|
|
|
evas_font_path_append(sd->evas, fontpath);
|
|
|
|
|
2010-10-22 14:41:27 -07:00
|
|
|
if (!_elm_config->font_hinting)
|
2012-05-03 15:42:15 -07:00
|
|
|
evas_font_hinting_set(sd->evas, EVAS_FONT_HINTING_NONE);
|
2009-02-03 02:27:52 -08:00
|
|
|
else if (_elm_config->font_hinting == 1)
|
2012-05-03 15:42:15 -07:00
|
|
|
evas_font_hinting_set(sd->evas, EVAS_FONT_HINTING_AUTO);
|
2009-02-03 02:27:52 -08:00
|
|
|
else if (_elm_config->font_hinting == 2)
|
2012-05-03 15:42:15 -07:00
|
|
|
evas_font_hinting_set(sd->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
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_xwin_update(sd);
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2010-09-24 09:41:25 -07:00
|
|
|
|
2015-01-09 21:33:55 -08:00
|
|
|
/* do not append to list; all windows render as black rects */
|
2015-05-20 08:31:04 -07:00
|
|
|
if (type == ELM_WIN_FAKE) return obj;
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_list = eina_list_append(_elm_win_list, obj);
|
2012-08-28 03:37:02 -07:00
|
|
|
_elm_win_count++;
|
2012-10-10 17:35:00 -07:00
|
|
|
|
2015-08-03 05:39:54 -07:00
|
|
|
if ((engine) && ((!strcmp(engine, ELM_SOFTWARE_FB)) || (!strcmp(engine, ELM_DRM))))
|
2008-12-09 22:33:24 -08:00
|
|
|
{
|
2012-07-18 21:35:50 -07:00
|
|
|
TRAP(sd, fullscreen_set, 1);
|
2008-12-09 22:33:24 -08:00
|
|
|
}
|
2012-10-15 13:51:23 -07:00
|
|
|
else if ((type != ELM_WIN_INLINED_IMAGE) &&
|
2014-03-09 05:17:28 -07:00
|
|
|
((engine) &&
|
|
|
|
((!strcmp(engine, ELM_WAYLAND_SHM) ||
|
|
|
|
(!strcmp(engine, ELM_WAYLAND_EGL))))))
|
2012-05-15 07:48:30 -07:00
|
|
|
_elm_win_frame_add(sd, "default");
|
|
|
|
|
2010-10-04 09:55:32 -07:00
|
|
|
if (_elm_config->focus_highlight_enable)
|
2012-05-03 15:42:15 -07:00
|
|
|
elm_win_focus_highlight_enabled_set(obj, EINA_TRUE);
|
2013-08-11 02:58:28 -07:00
|
|
|
if (_elm_config->focus_highlight_animate)
|
|
|
|
elm_win_focus_highlight_animate_set(obj, EINA_TRUE);
|
2010-10-04 09:55:32 -07:00
|
|
|
|
2010-10-20 05:38:30 -07:00
|
|
|
#ifdef ELM_DEBUG
|
2012-05-03 15:42:15 -07:00
|
|
|
Evas_Modifier_Mask mask = evas_key_modifier_mask_get(sd->evas, "Control");
|
|
|
|
evas_object_event_callback_add
|
2013-04-24 04:41:37 -07:00
|
|
|
(obj, EVAS_CALLBACK_KEY_DOWN, _debug_key_down, NULL);
|
2011-04-14 04:43:43 -07:00
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
if (evas_object_key_grab(obj, "F12", mask, 0, EINA_TRUE))
|
|
|
|
INF("Ctrl+F12 key combination exclusive for dot tree generation\n");
|
|
|
|
else
|
|
|
|
ERR("failed to grab F12 key to elm widgets (dot) tree generation");
|
2010-10-20 05:38:30 -07:00
|
|
|
#endif
|
2011-04-21 17:42:32 -07:00
|
|
|
|
2012-07-05 02:23:38 -07:00
|
|
|
if ((_elm_config->softcursor_mode == ELM_SOFTCURSOR_MODE_ON) ||
|
|
|
|
((_elm_config->softcursor_mode == ELM_SOFTCURSOR_MODE_AUTO) &&
|
2014-03-28 03:42:27 -07:00
|
|
|
((engine) &&
|
2015-08-03 05:39:54 -07:00
|
|
|
((!strcmp(engine, ELM_SOFTWARE_FB)) || (!strcmp(engine, ELM_DRM))))))
|
2012-07-05 02:23:38 -07:00
|
|
|
{
|
|
|
|
Evas_Object *o;
|
|
|
|
Evas_Coord mw = 1, mh = 1, hx = 0, hy = 0;
|
2012-07-17 11:46:18 -07:00
|
|
|
|
2012-07-05 02:23:38 -07:00
|
|
|
sd->pointer.obj = o = edje_object_add(ecore_evas_get(tmp_sd.ee));
|
2013-02-25 20:26:22 -08:00
|
|
|
_elm_theme_object_set(obj, o, "pointer", "base", "default");
|
2012-07-05 02:23:38 -07:00
|
|
|
edje_object_size_min_calc(o, &mw, &mh);
|
|
|
|
evas_object_resize(o, mw, mh);
|
|
|
|
edje_object_part_geometry_get(o, "elm.swallow.hotspot",
|
|
|
|
&hx, &hy, NULL, NULL);
|
|
|
|
sd->pointer.hot_x = hx;
|
|
|
|
sd->pointer.hot_y = hy;
|
|
|
|
evas_object_show(o);
|
|
|
|
ecore_evas_object_cursor_set(tmp_sd.ee, o, EVAS_LAYER_MAX, hx, hy);
|
|
|
|
}
|
|
|
|
else if (_elm_config->softcursor_mode == ELM_SOFTCURSOR_MODE_OFF)
|
|
|
|
{
|
|
|
|
// do nothing
|
|
|
|
}
|
2013-01-17 14:11:15 -08:00
|
|
|
|
2014-02-10 05:09:45 -08:00
|
|
|
sd->wm_rot.wm_supported = ecore_evas_wm_rotation_supported_get(sd->ee);
|
|
|
|
sd->wm_rot.preferred_rot = -1; // it means that elm_win doesn't use preferred rotation.
|
|
|
|
|
2014-12-15 09:02:40 -08:00
|
|
|
sd->edje = edje_object_add(sd->evas);
|
2014-12-15 08:45:59 -08:00
|
|
|
_elm_win_theme_internal(obj, sd);
|
|
|
|
|
2013-01-17 14:11:15 -08:00
|
|
|
sd->box = evas_object_box_add(sd->evas);
|
|
|
|
evas_object_box_layout_set(sd->box, _window_layout_stack, obj, NULL);
|
2014-12-15 09:02:40 -08:00
|
|
|
edje_object_part_swallow(sd->edje, "elm.swallow.contents", sd->box);
|
|
|
|
evas_object_move(sd->edje, 0, 0);
|
|
|
|
evas_object_resize(sd->edje, 1, 1);
|
|
|
|
edje_object_update_hints_set(sd->edje, EINA_TRUE);
|
|
|
|
evas_object_event_callback_add(sd->edje, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
|
2013-01-17 14:11:15 -08:00
|
|
|
_elm_win_on_resize_obj_changed_size_hints, obj);
|
2014-04-20 20:46:11 -07:00
|
|
|
|
2014-07-21 09:37:41 -07:00
|
|
|
eo_do(obj, elm_interface_atspi_accessible_role_set(ELM_ATSPI_ROLE_WINDOW));
|
2014-04-20 22:58:18 -07:00
|
|
|
if (_elm_config->atspi_mode == ELM_ATSPI_MODE_ON)
|
2015-07-02 04:53:43 -07:00
|
|
|
eo_do(obj, eo_event_callback_call(ELM_INTERFACE_ATSPI_WINDOW_EVENT_WINDOW_CREATED, NULL));
|
2014-04-20 20:46:11 -07:00
|
|
|
|
2014-12-15 09:02:40 -08:00
|
|
|
evas_object_show(sd->edje);
|
2015-04-30 05:58:26 -07:00
|
|
|
|
|
|
|
eo_do(obj, eo_event_callback_add(EO_EV_CALLBACK_ADD, _cb_added, sd),
|
|
|
|
eo_event_callback_add(EO_EV_CALLBACK_DEL, _cb_deled, sd));
|
2015-05-20 08:31:04 -07:00
|
|
|
|
|
|
|
return obj;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
2012-07-05 02:23:38 -07:00
|
|
|
|
2015-04-17 15:10:11 -07:00
|
|
|
EOLIAN static Eo *
|
|
|
|
_elm_win_eo_base_finalize(Eo *obj, Elm_Win_Data *_pd)
|
|
|
|
{
|
2015-05-20 08:31:04 -07:00
|
|
|
obj = _elm_win_finalize_internal(obj, _pd, _pd->name, _pd->type);
|
|
|
|
if (obj)
|
|
|
|
{
|
|
|
|
eo_do_super(obj, MY_CLASS, obj = eo_finalize());
|
|
|
|
}
|
2015-04-17 15:10:11 -07:00
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
2015-05-19 05:34:07 -07:00
|
|
|
EOLIAN static Eo *
|
|
|
|
_elm_win_eo_base_constructor(Eo *obj, Elm_Win_Data *_pd EINA_UNUSED)
|
|
|
|
{
|
|
|
|
/* Do nothing. */
|
|
|
|
/* XXX: We are calling the constructor chain from the finalizer. It's
|
|
|
|
* really bad and hacky. Needs fixing. */
|
|
|
|
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
2015-01-12 02:13:34 -08:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_fake_canvas_set(Eo *obj EINA_UNUSED, Elm_Win_Data *pd, Ecore_Evas *oee)
|
|
|
|
{
|
|
|
|
pd->ee = oee;
|
|
|
|
}
|
|
|
|
|
2015-04-17 15:10:11 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_type_set(Eo *obj, Elm_Win_Data *sd, Elm_Win_Type type)
|
|
|
|
{
|
|
|
|
Eina_Bool finalized;
|
|
|
|
if (eo_do_ret(obj, finalized, eo_finalized_get()))
|
|
|
|
{
|
|
|
|
ERR("This function is only allowed during construction.");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
sd->type = type;
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Elm_Win_Type
|
|
|
|
_elm_win_type_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2014-03-21 23:17:00 -07:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return sd->type;
|
2014-03-21 23:17:00 -07:00
|
|
|
}
|
|
|
|
|
2015-04-17 15:10:11 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_name_set(Eo *obj, Elm_Win_Data *sd, const char *name)
|
|
|
|
{
|
|
|
|
Eina_Bool finalized;
|
|
|
|
if (eo_do_ret(obj, finalized, eo_finalized_get()))
|
|
|
|
{
|
|
|
|
ERR("This function is only allowed during construction.");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
sd->name = eina_stringshare_add(name);
|
|
|
|
}
|
|
|
|
|
2014-07-20 19:39:32 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_noblank_set(Eo *obj EINA_UNUSED, Elm_Win_Data *pd, Eina_Bool noblank)
|
|
|
|
{
|
|
|
|
noblank = !!noblank;
|
|
|
|
if (pd->noblank == noblank) return;
|
|
|
|
pd->noblank = noblank;
|
|
|
|
_win_noblank_eval();
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_noblank_get(Eo *obj EINA_UNUSED, Elm_Win_Data *pd)
|
|
|
|
{
|
|
|
|
return pd->noblank;
|
|
|
|
}
|
|
|
|
|
2014-09-23 14:38:22 -07:00
|
|
|
EOLIAN static void *
|
|
|
|
_elm_win_trap_data_get(Eo *obj EINA_UNUSED, Elm_Win_Data *pd)
|
|
|
|
{
|
|
|
|
return pd->trap_data;
|
|
|
|
}
|
|
|
|
|
2014-07-20 19:39:32 -07:00
|
|
|
|
2011-10-25 01:45:56 -07:00
|
|
|
EAPI Evas_Object *
|
2015-01-03 05:13:35 -08:00
|
|
|
elm_win_util_standard_add(const char *name, const char *title)
|
2011-10-25 01:45:56 -07:00
|
|
|
{
|
|
|
|
Evas_Object *win, *bg;
|
2011-11-30 09:44:00 -08:00
|
|
|
|
2011-10-25 01:45:56 -07:00
|
|
|
win = elm_win_add(NULL, name, ELM_WIN_BASIC);
|
2011-10-25 05:30:10 -07:00
|
|
|
if (!win) return NULL;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2011-10-25 01:45:56 -07:00
|
|
|
elm_win_title_set(win, title);
|
|
|
|
bg = elm_bg_add(win);
|
|
|
|
if (!bg)
|
|
|
|
{
|
|
|
|
evas_object_del(win);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
|
|
|
|
elm_win_resize_object_add(win, bg);
|
|
|
|
evas_object_show(bg);
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2011-10-25 01:45:56 -07:00
|
|
|
return win;
|
|
|
|
}
|
|
|
|
|
2015-01-03 05:13:35 -08:00
|
|
|
EAPI Evas_Object *
|
|
|
|
elm_win_util_dialog_add(Evas_Object *parent, const char *name, const char *title)
|
|
|
|
{
|
|
|
|
Evas_Object *win, *bg;
|
|
|
|
|
|
|
|
win = elm_win_add(parent, name, ELM_WIN_DIALOG_BASIC);
|
|
|
|
if (!win) return NULL;
|
|
|
|
|
|
|
|
elm_win_title_set(win, title);
|
|
|
|
bg = elm_bg_add(win);
|
|
|
|
if (!bg)
|
|
|
|
{
|
|
|
|
evas_object_del(win);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
|
|
|
|
elm_win_resize_object_add(win, bg);
|
|
|
|
evas_object_show(bg);
|
|
|
|
|
|
|
|
return win;
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_resize_object_add(Eo *obj, Elm_Win_Data *sd, Evas_Object *subobj)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2013-04-02 19:28:53 -07:00
|
|
|
elm_widget_sub_object_add(obj, subobj);
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2013-01-17 14:11:21 -08:00
|
|
|
if (!evas_object_box_append(sd->box, subobj))
|
|
|
|
ERR("could not append %p to box", subobj);
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_resize_object_del(Eo *obj, Elm_Win_Data *sd, Evas_Object *subobj)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
|
|
|
if (!elm_widget_sub_object_del(obj, subobj))
|
2012-05-03 15:42:15 -07:00
|
|
|
ERR("could not remove sub object %p from %p", subobj, obj);
|
|
|
|
|
2013-01-17 14:11:21 -08:00
|
|
|
evas_object_box_remove(sd->box, subobj);
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_title_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, const char *title)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
if (!title) return;
|
|
|
|
eina_stringshare_replace(&(sd->title), title);
|
2015-04-17 15:10:11 -07:00
|
|
|
if (sd->ee)
|
|
|
|
TRAP(sd, title_set, sd->title);
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->frame_obj)
|
|
|
|
edje_object_part_text_escaped_set
|
|
|
|
(sd->frame_obj, "elm.text.title", sd->title);
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static const char*
|
|
|
|
_elm_win_title_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2012-02-29 04:06:12 -08:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return sd->title;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_icon_name_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, const char *icon_name)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
if (!icon_name) return;
|
|
|
|
eina_stringshare_replace(&(sd->icon_name), icon_name);
|
2012-02-29 04:06:12 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_xwin_update(sd);
|
2012-02-29 04:06:12 -08:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static const char*
|
|
|
|
_elm_win_icon_name_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2012-02-29 04:06:12 -08:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return sd->icon_name;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_role_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, const char *role)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
if (!role) return;
|
|
|
|
eina_stringshare_replace(&(sd->role), role);
|
2012-02-29 04:06:12 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_xwin_update(sd);
|
2012-02-29 04:06:12 -08:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static const char*
|
|
|
|
_elm_win_role_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2012-05-03 15:42:15 -07:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return sd->role;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_icon_object_set(Eo *obj, Elm_Win_Data *sd, Evas_Object *icon)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->icon)
|
|
|
|
evas_object_event_callback_del_full
|
2013-04-24 04:41:37 -07:00
|
|
|
(sd->icon, EVAS_CALLBACK_DEL, _elm_win_on_icon_del, obj);
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->icon = icon;
|
|
|
|
if (sd->icon)
|
|
|
|
evas_object_event_callback_add
|
2013-04-24 04:41:37 -07:00
|
|
|
(sd->icon, EVAS_CALLBACK_DEL, _elm_win_on_icon_del, obj);
|
2012-02-29 04:06:12 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_xwin_update(sd);
|
2012-02-29 04:06:12 -08:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static const Evas_Object*
|
|
|
|
_elm_win_icon_object_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return sd->icon;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_autodel_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, Eina_Bool autodel)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->autodel = autodel;
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_autodel_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return sd->autodel;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2015-07-01 07:40:57 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_autohide_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, Eina_Bool autohide)
|
|
|
|
{
|
|
|
|
sd->autohide = autohide;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_autohide_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
|
|
|
{
|
|
|
|
return sd->autohide;
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_activate(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-07-18 21:35:50 -07:00
|
|
|
TRAP(sd, activate);
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_lower(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-07-18 21:35:50 -07:00
|
|
|
TRAP(sd, lower);
|
2009-04-03 14:52:01 -07:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_raise(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-07-18 21:35:50 -07:00
|
|
|
TRAP(sd, raise);
|
2009-04-03 14:52:01 -07:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_center(Eo *obj, Elm_Win_Data *sd, Eina_Bool h, Eina_Bool v)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2011-12-03 14:51:12 -08:00
|
|
|
int win_w, win_h, screen_w, screen_h, nx, ny;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2015-02-05 18:32:55 -08:00
|
|
|
if ((trap) && (trap->center) && (!trap->center(sd->trap_data, obj, h, v)))
|
2012-07-18 21:35:50 -07:00
|
|
|
return;
|
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
ecore_evas_screen_geometry_get(sd->ee, NULL, NULL, &screen_w, &screen_h);
|
2011-12-04 12:44:41 -08:00
|
|
|
if ((!screen_w) || (!screen_h)) return;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2015-01-22 19:35:28 -08:00
|
|
|
evas_object_geometry_get(obj, &nx, &ny, &win_w, &win_h);
|
2011-12-04 12:44:41 -08:00
|
|
|
if ((!win_w) || (!win_h)) return;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2011-12-03 14:51:12 -08:00
|
|
|
if (h) nx = win_w >= screen_w ? 0 : (screen_w / 2) - (win_w / 2);
|
|
|
|
if (v) ny = win_h >= screen_h ? 0 : (screen_h / 2) - (win_h / 2);
|
2015-01-22 19:35:28 -08:00
|
|
|
if (nx < sd->screen.x) nx = sd->screen.x;
|
|
|
|
if (ny < sd->screen.y) ny = sd->screen.y;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2011-12-03 14:51:12 -08:00
|
|
|
evas_object_move(obj, nx, ny);
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_borderless_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, Eina_Bool borderless)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2014-01-07 16:05:08 -08:00
|
|
|
const char *engine_name = ecore_evas_engine_name_get(sd->ee);
|
2014-08-10 15:59:45 -07:00
|
|
|
Eina_Bool need_frame = engine_name &&
|
|
|
|
((!strcmp(engine_name, ELM_WAYLAND_SHM)) ||
|
|
|
|
(!strcmp(engine_name, ELM_WAYLAND_EGL)));
|
2014-01-07 16:05:08 -08:00
|
|
|
|
2014-06-10 12:28:20 -07:00
|
|
|
if (need_frame)
|
|
|
|
need_frame = !sd->fullscreen;
|
|
|
|
|
2013-05-06 16:08:58 -07:00
|
|
|
if (borderless)
|
|
|
|
{
|
2014-01-07 16:05:08 -08:00
|
|
|
if (need_frame)
|
2013-05-06 16:08:58 -07:00
|
|
|
_elm_win_frame_del(sd);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-01-07 16:05:08 -08:00
|
|
|
if (need_frame)
|
2013-05-06 16:08:58 -07:00
|
|
|
_elm_win_frame_add(sd, "default");
|
|
|
|
|
2013-05-21 12:32:48 -07:00
|
|
|
if (sd->frame_obj)
|
|
|
|
evas_object_show(sd->frame_obj);
|
2013-05-06 16:08:58 -07:00
|
|
|
}
|
|
|
|
|
2012-07-18 21:35:50 -07:00
|
|
|
TRAP(sd, borderless_set, borderless);
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_xwin_update(sd);
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_borderless_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return ecore_evas_borderless_get(sd->ee);
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_shaped_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, Eina_Bool shaped)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-07-18 21:35:50 -07:00
|
|
|
TRAP(sd, shaped_set, shaped);
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_xwin_update(sd);
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_shaped_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return ecore_evas_shaped_get(sd->ee);
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_alpha_set(Eo *obj, Elm_Win_Data *sd, Eina_Bool enabled)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2014-12-10 21:43:53 -08:00
|
|
|
sd->application_alpha = enabled;
|
|
|
|
_elm_win_apply_alpha(obj, sd);
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_alpha_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-05-15 07:48:30 -07:00
|
|
|
if (sd->img_obj)
|
2011-10-14 00:30:52 -07:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return evas_object_image_alpha_get(sd->img_obj);
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return ecore_evas_alpha_get(sd->ee);
|
2011-10-14 00:30:52 -07:00
|
|
|
}
|
2009-10-12 02:09:55 -07:00
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
return EINA_FALSE;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_override_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, Eina_Bool override)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-07-18 21:35:50 -07:00
|
|
|
TRAP(sd, override_set, override);
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_xwin_update(sd);
|
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
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_override_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2009-03-12 22:50:38 -07:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return ecore_evas_override_get(sd->ee);
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_fullscreen_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, Eina_Bool fullscreen)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2014-08-10 15:59:45 -07:00
|
|
|
const char *engine_name = ecore_evas_engine_name_get(sd->ee);
|
2012-05-03 15:42:15 -07:00
|
|
|
// YYY: handle if sd->img_obj
|
2014-08-10 15:59:45 -07:00
|
|
|
if (engine_name &&
|
|
|
|
((!strcmp(engine_name, ELM_SOFTWARE_FB)) ||
|
2015-08-03 05:39:54 -07:00
|
|
|
(!strcmp(engine_name, ELM_DRM))))
|
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
|
|
|
}
|
2015-03-18 07:53:56 -07:00
|
|
|
else if (sd->type == ELM_WIN_FAKE)
|
|
|
|
sd->fullscreen = !!fullscreen;
|
2010-11-01 14:10:07 -07:00
|
|
|
else
|
|
|
|
{
|
2013-01-10 03:53:39 -08:00
|
|
|
// sd->fullscreen = fullscreen;
|
2014-08-10 15:59:45 -07:00
|
|
|
Eina_Bool need_frame = engine_name &&
|
|
|
|
((!strcmp(engine_name, ELM_WAYLAND_SHM)) ||
|
|
|
|
(!strcmp(engine_name, ELM_WAYLAND_EGL)));
|
2014-01-07 16:05:08 -08:00
|
|
|
|
2014-06-10 12:28:20 -07:00
|
|
|
if (need_frame)
|
|
|
|
need_frame = !ecore_evas_borderless_get(sd->ee);
|
|
|
|
|
2013-05-08 14:45:02 -07:00
|
|
|
TRAP(sd, fullscreen_set, fullscreen);
|
|
|
|
|
2012-08-15 03:57:31 -07:00
|
|
|
if (fullscreen)
|
|
|
|
{
|
2014-01-07 16:05:08 -08:00
|
|
|
if (need_frame)
|
2012-08-15 03:57:31 -07:00
|
|
|
_elm_win_frame_del(sd);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-01-07 16:05:08 -08:00
|
|
|
if (need_frame)
|
2012-08-15 03:57:31 -07:00
|
|
|
_elm_win_frame_add(sd, "default");
|
|
|
|
|
2013-05-21 12:32:48 -07:00
|
|
|
if (sd->frame_obj)
|
|
|
|
evas_object_show(sd->frame_obj);
|
2012-08-15 03:57:31 -07:00
|
|
|
}
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_xwin_update(sd);
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2009-03-14 11:03:19 -07:00
|
|
|
}
|
2009-03-12 22:50:38 -07:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_fullscreen_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2014-08-10 15:59:45 -07:00
|
|
|
const char *engine_name = ecore_evas_engine_name_get(sd->ee);
|
2014-01-07 16:05:08 -08:00
|
|
|
|
|
|
|
if (engine_name &&
|
|
|
|
((!strcmp(engine_name, ELM_SOFTWARE_FB)) ||
|
2015-08-03 05:39:54 -07:00
|
|
|
(!strcmp(engine_name, ELM_DRM))))
|
2009-10-12 02:09:55 -07:00
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
// these engines... can ONLY be fullscreen
|
2014-03-27 06:15:52 -07:00
|
|
|
return EINA_TRUE;
|
2010-11-01 14:10:07 -07:00
|
|
|
}
|
2015-03-18 07:51:29 -07:00
|
|
|
return sd->fullscreen;
|
2012-12-27 05:38:33 -08:00
|
|
|
}
|
|
|
|
|
2013-01-17 14:11:33 -08:00
|
|
|
static void
|
2013-01-30 19:30:53 -08:00
|
|
|
_dbus_menu_set(Eina_Bool dbus_connect, void *data)
|
2013-01-17 14:11:33 -08:00
|
|
|
{
|
2013-01-22 10:51:16 -08:00
|
|
|
ELM_WIN_DATA_GET_OR_RETURN(data, sd);
|
2013-01-17 14:11:33 -08:00
|
|
|
|
2013-01-30 19:30:53 -08:00
|
|
|
if (dbus_connect)
|
2013-01-17 14:11:33 -08:00
|
|
|
{
|
2013-01-22 10:51:16 -08:00
|
|
|
DBG("Setting menu to D-Bus");
|
2014-12-15 09:02:40 -08:00
|
|
|
edje_object_part_unswallow(sd->edje, sd->main_menu);
|
|
|
|
edje_object_signal_emit(sd->edje, "elm,action,hide_menu", "elm");
|
2013-01-22 10:51:16 -08:00
|
|
|
_elm_menu_menu_bar_hide(sd->main_menu);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
DBG("Setting menu to local mode");
|
2014-12-15 09:02:40 -08:00
|
|
|
edje_object_part_swallow(sd->edje, "elm.swallow.menu", sd->main_menu);
|
|
|
|
edje_object_signal_emit(sd->edje, "elm,action,show_menu", "elm");
|
2013-01-22 10:51:16 -08:00
|
|
|
evas_object_show(sd->main_menu);
|
2013-01-17 14:11:33 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Evas_Object *
|
|
|
|
_elm_win_main_menu_get(Eo *obj, Elm_Win_Data *sd)
|
2012-12-27 05:38:33 -08:00
|
|
|
{
|
2013-01-17 14:11:33 -08:00
|
|
|
Eina_Bool use_dbus = EINA_FALSE;
|
2012-12-27 05:38:33 -08:00
|
|
|
|
|
|
|
if (sd->main_menu) goto end;
|
|
|
|
|
|
|
|
sd->main_menu = elm_menu_add(obj);
|
2013-01-22 10:51:16 -08:00
|
|
|
_elm_menu_menu_bar_set(sd->main_menu, EINA_TRUE);
|
2012-12-27 05:38:33 -08:00
|
|
|
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2013-01-22 10:51:24 -08:00
|
|
|
if (!_elm_config->disable_external_menu && sd->x.xwin) use_dbus = EINA_TRUE;
|
2012-12-27 05:38:33 -08:00
|
|
|
#endif
|
2013-01-17 14:11:33 -08:00
|
|
|
|
2013-05-13 04:18:24 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2013-01-22 10:51:16 -08:00
|
|
|
if (use_dbus && _elm_dbus_menu_register(sd->main_menu))
|
2012-12-27 05:38:33 -08:00
|
|
|
{
|
2013-01-17 14:11:33 -08:00
|
|
|
_elm_dbus_menu_app_menu_register(sd->x.xwin, sd->main_menu,
|
2013-01-22 10:51:16 -08:00
|
|
|
_dbus_menu_set, obj);
|
2012-12-27 05:38:33 -08:00
|
|
|
}
|
2013-01-17 14:11:33 -08:00
|
|
|
else
|
2013-05-13 04:18:24 -07:00
|
|
|
#endif
|
2013-01-22 10:51:16 -08:00
|
|
|
_dbus_menu_set(EINA_FALSE, obj);
|
2013-01-17 14:11:33 -08:00
|
|
|
|
2012-12-27 05:38:33 -08:00
|
|
|
end:
|
2014-03-27 06:15:52 -07:00
|
|
|
return sd->main_menu;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_maximized_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, Eina_Bool maximized)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2013-10-29 03:39:40 -07:00
|
|
|
_elm_win_frame_maximized_state_update(sd, maximized);
|
2012-05-03 15:42:15 -07:00
|
|
|
// YYY: handle if sd->img_obj
|
2012-07-18 21:35:50 -07:00
|
|
|
TRAP(sd, maximized_set, maximized);
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_xwin_update(sd);
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2009-03-12 22:50:38 -07:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_maximized_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2009-10-12 02:09:55 -07:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return sd->maximized;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_iconified_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, Eina_Bool iconified)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
// sd->iconified = iconified;
|
|
|
|
TRAP(sd, iconified_set, iconified);
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
_elm_win_xwin_update(sd);
|
|
|
|
#endif
|
2009-10-12 02:09:55 -07:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_iconified_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2012-05-03 15:42:15 -07:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return sd->iconified;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_withdrawn_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, Eina_Bool withdrawn)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
// sd->withdrawn = withdrawn;
|
|
|
|
TRAP(sd, withdrawn_set, withdrawn);
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_xwin_update(sd);
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2009-03-12 22:50:38 -07:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_withdrawn_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2009-10-12 02:09:55 -07:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return sd->withdrawn;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_available_profiles_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, const char **profiles, unsigned int count)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-12-04 22:50:27 -08:00
|
|
|
Eina_Bool found = EINA_FALSE;
|
|
|
|
|
|
|
|
_elm_win_available_profiles_del(sd);
|
|
|
|
if ((profiles) && (count >= 1))
|
|
|
|
{
|
|
|
|
sd->profile.available_list = calloc(count, sizeof(char *));
|
|
|
|
if (sd->profile.available_list)
|
|
|
|
{
|
|
|
|
if (!sd->profile.name) found = EINA_TRUE;
|
|
|
|
|
|
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < count; i++)
|
|
|
|
{
|
|
|
|
sd->profile.available_list[i] = eina_stringshare_add(profiles[i]);
|
|
|
|
|
|
|
|
/* check to see if a given array has a current profile of elm_win */
|
|
|
|
if ((sd->profile.name) &&
|
|
|
|
(!strcmp(sd->profile.name, profiles[i])))
|
|
|
|
{
|
|
|
|
found = EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
sd->profile.count = count;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ecore_evas_window_profile_supported_get(sd->ee))
|
|
|
|
{
|
|
|
|
ecore_evas_window_available_profiles_set(sd->ee,
|
|
|
|
sd->profile.available_list,
|
|
|
|
sd->profile.count);
|
|
|
|
|
|
|
|
/* current profile of elm_win is wrong, change profile */
|
|
|
|
if ((sd->profile.available_list) && (!found))
|
|
|
|
{
|
|
|
|
eina_stringshare_replace(&(sd->profile.name),
|
|
|
|
sd->profile.available_list[0]);
|
|
|
|
ecore_evas_window_profile_set(sd->ee, sd->profile.name);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (sd->profile.available_list)
|
|
|
|
_elm_win_profile_update(sd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_available_profiles_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, char ***profiles, unsigned int *count)
|
2012-12-04 22:50:27 -08:00
|
|
|
{
|
|
|
|
if (ecore_evas_window_profile_supported_get(sd->ee))
|
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return ecore_evas_window_available_profiles_get(sd->ee,
|
2012-12-04 22:50:27 -08:00
|
|
|
profiles,
|
|
|
|
count);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (profiles) *profiles = (char **)sd->profile.available_list;
|
|
|
|
if (count) *count = sd->profile.count;
|
2014-03-27 06:15:52 -07:00
|
|
|
return EINA_TRUE;
|
2012-12-04 22:50:27 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_profile_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, const char *profile)
|
2012-12-04 22:50:27 -08:00
|
|
|
{
|
|
|
|
/* check to see if a given profile is present in an available profiles */
|
|
|
|
if ((profile) && (sd->profile.available_list))
|
|
|
|
{
|
|
|
|
Eina_Bool found = EINA_FALSE;
|
|
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < sd->profile.count; i++)
|
|
|
|
{
|
|
|
|
if (!strcmp(profile,
|
|
|
|
sd->profile.available_list[i]))
|
|
|
|
{
|
|
|
|
found = EINA_TRUE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!found) return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ecore_evas_window_profile_supported_get(sd->ee))
|
|
|
|
{
|
|
|
|
if (!profile) _elm_win_profile_del(sd);
|
|
|
|
ecore_evas_window_profile_set(sd->ee, profile);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
if (_internal_elm_win_profile_set(sd, profile))
|
2012-12-04 22:50:27 -08:00
|
|
|
_elm_win_profile_update(sd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static const char*
|
|
|
|
_elm_win_profile_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2012-05-03 15:42:15 -07:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return sd->profile.name;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_urgent_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, Eina_Bool urgent)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2015-07-05 20:28:02 -07:00
|
|
|
if (sd->urgent == urgent)
|
|
|
|
return;
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->urgent = urgent;
|
2012-07-18 21:35:50 -07:00
|
|
|
TRAP(sd, urgent_set, urgent);
|
2012-02-28 03:20:35 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_xwin_update(sd);
|
2012-02-28 03:20:35 -08:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_urgent_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2012-05-03 15:42:15 -07:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return sd->urgent;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_demand_attention_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, Eina_Bool demand_attention)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->demand_attention = demand_attention;
|
2012-07-18 21:35:50 -07:00
|
|
|
TRAP(sd, demand_attention_set, demand_attention);
|
2012-02-28 03:20:35 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_xwin_update(sd);
|
2012-02-28 03:20:35 -08:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_demand_attention_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2012-05-03 15:42:15 -07:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return sd->demand_attention;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
2014-04-09 03:04:55 -07:00
|
|
|
_elm_win_modal_set(Eo *obj, Elm_Win_Data *sd, Eina_Bool modal)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2014-04-09 03:04:55 -07:00
|
|
|
if (sd->modal_count) return;
|
|
|
|
|
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *current;
|
|
|
|
|
|
|
|
if ((modal) && (!sd->modal) && (evas_object_visible_get(obj)))
|
|
|
|
{
|
|
|
|
INCREMENT_MODALITY()
|
|
|
|
}
|
|
|
|
else if ((!modal) && (sd->modal) && (evas_object_visible_get(obj)))
|
|
|
|
{
|
|
|
|
DECREMENT_MODALITY()
|
|
|
|
}
|
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->modal = modal;
|
2012-07-18 21:35:50 -07:00
|
|
|
TRAP(sd, modal_set, modal);
|
2012-02-28 03:20:35 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_xwin_update(sd);
|
2012-02-28 03:20:35 -08:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_modal_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2012-05-03 15:42:15 -07:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return sd->modal;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_aspect_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, double aspect)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->aspect = aspect;
|
2012-07-18 21:35:50 -07:00
|
|
|
TRAP(sd, aspect_set, aspect);
|
2012-02-28 03:20:35 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_xwin_update(sd);
|
2012-02-28 03:20:35 -08:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static double
|
|
|
|
_elm_win_aspect_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2012-06-12 03:15:19 -07:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return sd->aspect;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_size_base_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, int w, int h)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-06-12 03:15:19 -07:00
|
|
|
sd->size_base_w = w;
|
|
|
|
sd->size_base_h = h;
|
2012-07-18 21:35:50 -07:00
|
|
|
TRAP(sd, size_base_set, w, h);
|
2012-06-12 03:15:19 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
_elm_win_xwin_update(sd);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_size_base_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, int *w, int *h)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-06-12 03:15:19 -07:00
|
|
|
if (w) *w = sd->size_base_w;
|
2014-10-13 09:07:36 -07:00
|
|
|
if (h) *h = sd->size_base_h;
|
2012-06-12 03:15:19 -07:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_size_step_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, int w, int h)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-06-12 03:15:19 -07:00
|
|
|
sd->size_step_w = w;
|
|
|
|
sd->size_step_h = h;
|
2012-07-18 21:35:50 -07:00
|
|
|
TRAP(sd, size_step_set, w, h);
|
2012-06-12 03:15:19 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
_elm_win_xwin_update(sd);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_size_step_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, int *w, int *h)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-06-12 03:15:19 -07:00
|
|
|
if (w) *w = sd->size_step_w;
|
2014-10-13 09:07:36 -07:00
|
|
|
if (h) *h = sd->size_step_h;
|
2012-06-12 03:15:19 -07:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_layer_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, int layer)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-07-18 21:35:50 -07:00
|
|
|
TRAP(sd, layer_set, layer);
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_xwin_update(sd);
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2009-03-12 22:50:38 -07:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static int
|
|
|
|
_elm_win_layer_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return ecore_evas_layer_get(sd->ee);
|
2009-10-12 02:09:55 -07:00
|
|
|
}
|
|
|
|
|
2012-08-21 01:48:47 -07:00
|
|
|
EAPI void
|
|
|
|
elm_win_norender_push(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_WIN_CHECK(obj);
|
|
|
|
ELM_WIN_DATA_GET_OR_RETURN(obj, sd);
|
2012-10-10 17:35:00 -07:00
|
|
|
|
2012-08-21 01:48:47 -07:00
|
|
|
sd->norender++;
|
|
|
|
if (sd->norender == 1) ecore_evas_manual_render_set(sd->ee, EINA_TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_win_norender_pop(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_WIN_CHECK(obj);
|
|
|
|
ELM_WIN_DATA_GET_OR_RETURN(obj, sd);
|
|
|
|
|
|
|
|
if (sd->norender <= 0) return;
|
|
|
|
sd->norender--;
|
|
|
|
if (sd->norender == 0) ecore_evas_manual_render_set(sd->ee, EINA_FALSE);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI int
|
2015-06-08 10:44:29 -07:00
|
|
|
elm_win_norender_get(const Evas_Object *obj)
|
2012-08-21 01:48:47 -07:00
|
|
|
{
|
|
|
|
ELM_WIN_CHECK(obj) - 1;
|
|
|
|
ELM_WIN_DATA_GET_OR_RETURN_VAL(obj, sd, -1);
|
|
|
|
return sd->norender;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_win_render(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_WIN_CHECK(obj);
|
|
|
|
ELM_WIN_DATA_GET_OR_RETURN(obj, sd);
|
|
|
|
ecore_evas_manual_render(sd->ee);
|
|
|
|
}
|
|
|
|
|
2012-11-21 03:48:02 -08:00
|
|
|
static int
|
|
|
|
_win_rotation_degree_check(int rotation)
|
|
|
|
{
|
2012-11-21 03:42:52 -08:00
|
|
|
if ((rotation > 360) || (rotation < 0))
|
|
|
|
{
|
2012-11-21 04:50:17 -08:00
|
|
|
WRN("Rotation degree should be 0 ~ 360 (passed degree: %d)", rotation);
|
|
|
|
rotation %= 360;
|
2012-11-21 03:42:52 -08:00
|
|
|
if (rotation < 0) rotation += 360;
|
|
|
|
}
|
2012-11-21 03:48:02 -08:00
|
|
|
return rotation;
|
|
|
|
}
|
|
|
|
|
2013-12-27 06:14:27 -08:00
|
|
|
/*
|
|
|
|
* This API resizes the internal window(ex: X window) and evas_output.
|
|
|
|
* But this does not resize the elm window object and its contents.
|
|
|
|
*/
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
2014-03-27 06:15:52 -07:00
|
|
|
_win_rotate(Evas_Object *obj, Elm_Win_Data *sd, int rotation, Eina_Bool resize)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-11-21 03:48:02 -08:00
|
|
|
rotation = _win_rotation_degree_check(rotation);
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->rot == rotation) return;
|
|
|
|
sd->rot = rotation;
|
2013-02-13 03:47:51 -08:00
|
|
|
if (resize) TRAP(sd, rotation_with_resize_set, rotation);
|
|
|
|
else TRAP(sd, rotation_set, 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);
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_resize_objects_eval(obj);
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_xwin_update(sd);
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2013-11-26 08:56:14 -08:00
|
|
|
_elm_win_frame_obj_update(sd);
|
2013-02-13 21:38:26 -08:00
|
|
|
elm_widget_orientation_set(obj, rotation);
|
2015-05-13 04:34:44 -07:00
|
|
|
eo_do(obj, eo_event_callback_call
|
|
|
|
(ELM_WIN_EVENT_ROTATION_CHANGED, NULL));
|
2009-03-14 11:03:19 -07:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_rotation_set(Eo *obj, Elm_Win_Data *sd, int rotation)
|
2013-02-13 03:47:51 -08:00
|
|
|
{
|
|
|
|
_win_rotate(obj, sd, rotation, EINA_FALSE);
|
|
|
|
}
|
|
|
|
|
2013-12-27 06:14:27 -08:00
|
|
|
/*
|
|
|
|
* This API does not resize the internal window (ex: X window).
|
|
|
|
* But this resizes evas_output, elm window, and its contents.
|
|
|
|
*/
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_rotation_with_resize_set(Eo *obj, Elm_Win_Data *sd, int rotation)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2013-02-13 03:47:51 -08:00
|
|
|
_win_rotate(obj, sd, rotation, EINA_TRUE);
|
2010-02-10 06:38:08 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static int
|
|
|
|
_elm_win_rotation_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2014-02-10 05:09:45 -08:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return sd->rot;
|
2014-02-10 05:09:45 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_wm_rotation_supported_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2014-02-10 05:09:45 -08:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return sd->wm_rot.wm_supported;
|
2014-02-10 05:09:45 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* This will unset a preferred rotation, if given preferred rotation is '-1'.
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
elm_win_wm_rotation_preferred_rotation_set(const Evas_Object *obj,
|
|
|
|
int rotation)
|
|
|
|
{
|
|
|
|
ELM_WIN_CHECK(obj);
|
|
|
|
eo_do((Eo *) obj, elm_obj_win_wm_preferred_rotation_set(rotation));
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_wm_preferred_rotation_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, int rotation)
|
2014-02-10 05:09:45 -08:00
|
|
|
{
|
|
|
|
int rot;
|
|
|
|
|
|
|
|
if (!sd->wm_rot.use)
|
|
|
|
sd->wm_rot.use = EINA_TRUE;
|
|
|
|
|
|
|
|
// '-1' means that elm_win doesn't use preferred rotation.
|
|
|
|
if (rotation == -1)
|
|
|
|
rot = -1;
|
|
|
|
else
|
|
|
|
rot = _win_rotation_degree_check(rotation);
|
|
|
|
|
|
|
|
if (sd->wm_rot.preferred_rot == rot) return;
|
|
|
|
sd->wm_rot.preferred_rot = rot;
|
|
|
|
|
|
|
|
ecore_evas_wm_rotation_preferred_rotation_set(sd->ee, rot);
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static int
|
|
|
|
_elm_win_wm_preferred_rotation_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2014-02-10 05:09:45 -08:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return sd->wm_rot.preferred_rot;
|
2014-02-10 05:09:45 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_wm_available_rotations_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, const int *rotations, unsigned int count)
|
2014-02-10 05:09:45 -08:00
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
if (!sd->wm_rot.use)
|
|
|
|
sd->wm_rot.use = EINA_TRUE;
|
|
|
|
|
|
|
|
ELM_SAFE_FREE(sd->wm_rot.rots, free);
|
|
|
|
sd->wm_rot.count = 0;
|
|
|
|
|
|
|
|
if (count > 0)
|
|
|
|
{
|
|
|
|
sd->wm_rot.rots = calloc(count, sizeof(int));
|
|
|
|
if (!sd->wm_rot.rots) return;
|
|
|
|
for (i = 0; i < count; i++)
|
|
|
|
{
|
|
|
|
r = _win_rotation_degree_check(rotations[i]);
|
|
|
|
sd->wm_rot.rots[i] = r;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
sd->wm_rot.count = count;
|
|
|
|
|
|
|
|
ecore_evas_wm_rotation_available_rotations_set(sd->ee,
|
|
|
|
sd->wm_rot.rots,
|
|
|
|
sd->wm_rot.count);
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_wm_available_rotations_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, int **rotations, unsigned int *count)
|
2014-02-10 05:09:45 -08:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
if (!sd->wm_rot.use) return EINA_FALSE;
|
2014-02-10 05:09:45 -08:00
|
|
|
|
|
|
|
if (sd->wm_rot.count > 0)
|
|
|
|
{
|
|
|
|
if (rotations)
|
|
|
|
{
|
|
|
|
*rotations = calloc(sd->wm_rot.count, sizeof(int));
|
|
|
|
if (*rotations)
|
|
|
|
{
|
|
|
|
memcpy(*rotations,
|
|
|
|
sd->wm_rot.rots,
|
|
|
|
sizeof(int) * sd->wm_rot.count);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (count) *count = sd->wm_rot.count;
|
2014-03-27 06:15:52 -07:00
|
|
|
return EINA_TRUE;
|
2014-02-10 05:09:45 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_wm_manual_rotation_done_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, Eina_Bool set)
|
2014-02-10 05:09:45 -08:00
|
|
|
{
|
|
|
|
if (!sd->wm_rot.use) return;
|
|
|
|
ecore_evas_wm_rotation_manual_rotation_done_set(sd->ee, set);
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_wm_manual_rotation_done_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2014-02-10 05:09:45 -08:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
if (!sd->wm_rot.use) return EINA_FALSE;
|
|
|
|
return ecore_evas_wm_rotation_manual_rotation_done_get(sd->ee);
|
2014-02-10 05:09:45 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
2014-10-09 04:27:59 -07:00
|
|
|
_elm_win_wm_manual_rotation_done_manual(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2014-02-10 05:09:45 -08:00
|
|
|
{
|
|
|
|
if (!sd->wm_rot.use) return;
|
|
|
|
ecore_evas_wm_rotation_manual_rotation_done(sd->ee);
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_sticky_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, Eina_Bool sticky)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2013-01-10 03:53:39 -08:00
|
|
|
// sd->sticky = sticky;
|
2012-07-18 21:35:50 -07:00
|
|
|
TRAP(sd, sticky_set, sticky);
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_xwin_update(sd);
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2009-04-03 14:52:01 -07:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_sticky_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2008-11-18 02:11:57 -08:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return sd->sticky;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_keyboard_mode_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, Elm_Win_Keyboard_Mode mode)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
if (mode == sd->kbdmode) return;
|
2010-04-12 01:27:10 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2014-03-27 06:15:52 -07:00
|
|
|
_internal_elm_win_xwindow_get(sd);
|
2010-04-12 01:27:10 -07:00
|
|
|
#endif
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->kbdmode = mode;
|
2009-07-06 23:46:51 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2012-06-06 01:25:12 -07:00
|
|
|
if (sd->x.xwin)
|
2008-11-18 02:11:57 -08:00
|
|
|
ecore_x_e_virtual_keyboard_state_set
|
2012-06-06 01:25:12 -07:00
|
|
|
(sd->x.xwin, (Ecore_X_Virtual_Keyboard_State)sd->kbdmode);
|
2009-07-06 23:46:51 -07:00
|
|
|
#endif
|
2008-11-18 02:11:57 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Elm_Win_Keyboard_Mode
|
|
|
|
_elm_win_keyboard_mode_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2008-11-18 02:11:57 -08:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return sd->kbdmode;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_keyboard_win_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, Eina_Bool is_keyboard)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2009-07-06 23:46:51 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2014-03-27 06:15:52 -07:00
|
|
|
_internal_elm_win_xwindow_get(sd);
|
2012-06-06 01:25:12 -07:00
|
|
|
if (sd->x.xwin)
|
|
|
|
ecore_x_e_virtual_keyboard_set(sd->x.xwin, is_keyboard);
|
2011-11-20 06:00:41 -08:00
|
|
|
#else
|
2012-05-03 15:42:15 -07:00
|
|
|
(void)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
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_keyboard_win_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2010-10-27 07:38:37 -07:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
_internal_elm_win_xwindow_get(sd);
|
|
|
|
if (sd->x.xwin) return ecore_x_e_virtual_keyboard_get(sd->x.xwin);
|
|
|
|
#endif
|
|
|
|
return EINA_FALSE;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_indicator_mode_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, Elm_Win_Indicator_Mode mode)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
if (mode == sd->indmode) return;
|
2012-02-24 21:14:19 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2014-03-27 06:15:52 -07:00
|
|
|
_internal_elm_win_xwindow_get(sd);
|
2012-02-24 21:14:19 -08:00
|
|
|
#endif
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->indmode = mode;
|
2012-02-24 21:14:19 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2012-06-06 01:25:12 -07:00
|
|
|
if (sd->x.xwin)
|
2012-02-24 21:14:19 -08:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->indmode == ELM_WIN_INDICATOR_SHOW)
|
2012-02-24 21:14:19 -08:00
|
|
|
ecore_x_e_illume_indicator_state_set
|
2012-06-06 01:25:12 -07:00
|
|
|
(sd->x.xwin, ECORE_X_ILLUME_INDICATOR_STATE_ON);
|
2012-05-03 15:42:15 -07:00
|
|
|
else if (sd->indmode == ELM_WIN_INDICATOR_HIDE)
|
2012-02-24 21:14:19 -08:00
|
|
|
ecore_x_e_illume_indicator_state_set
|
2012-06-06 01:25:12 -07:00
|
|
|
(sd->x.xwin, ECORE_X_ILLUME_INDICATOR_STATE_OFF);
|
2012-02-24 21:14:19 -08:00
|
|
|
}
|
|
|
|
#endif
|
2015-05-13 04:34:44 -07:00
|
|
|
eo_do(obj, eo_event_callback_call
|
|
|
|
(ELM_WIN_EVENT_INDICATOR_PROP_CHANGED, NULL));
|
2012-02-24 21:14:19 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Elm_Win_Indicator_Mode
|
|
|
|
_elm_win_indicator_mode_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2012-02-24 21:14:19 -08:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return sd->indmode;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_indicator_opacity_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, Elm_Win_Indicator_Opacity_Mode mode)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
if (mode == sd->ind_o_mode) return;
|
|
|
|
sd->ind_o_mode = mode;
|
2012-03-07 06:27:36 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2014-03-27 06:15:52 -07:00
|
|
|
_internal_elm_win_xwindow_get(sd);
|
2012-06-06 01:25:12 -07:00
|
|
|
if (sd->x.xwin)
|
2012-03-07 06:27:36 -08:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->ind_o_mode == ELM_WIN_INDICATOR_OPAQUE)
|
2012-03-07 06:27:36 -08:00
|
|
|
ecore_x_e_illume_indicator_opacity_set
|
2012-06-06 01:25:12 -07:00
|
|
|
(sd->x.xwin, ECORE_X_ILLUME_INDICATOR_OPAQUE);
|
2012-05-03 15:42:15 -07:00
|
|
|
else if (sd->ind_o_mode == ELM_WIN_INDICATOR_TRANSLUCENT)
|
2012-03-07 06:27:36 -08:00
|
|
|
ecore_x_e_illume_indicator_opacity_set
|
2012-06-06 01:25:12 -07:00
|
|
|
(sd->x.xwin, ECORE_X_ILLUME_INDICATOR_TRANSLUCENT);
|
2012-05-03 15:42:15 -07:00
|
|
|
else if (sd->ind_o_mode == ELM_WIN_INDICATOR_TRANSPARENT)
|
2012-03-07 06:27:36 -08:00
|
|
|
ecore_x_e_illume_indicator_opacity_set
|
2012-06-06 01:25:12 -07:00
|
|
|
(sd->x.xwin, ECORE_X_ILLUME_INDICATOR_TRANSPARENT);
|
2012-03-07 06:27:36 -08:00
|
|
|
}
|
|
|
|
#endif
|
2015-05-13 04:34:44 -07:00
|
|
|
eo_do(obj, eo_event_callback_call
|
|
|
|
(ELM_WIN_EVENT_INDICATOR_PROP_CHANGED, NULL));
|
2012-03-07 06:27:36 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Elm_Win_Indicator_Opacity_Mode
|
|
|
|
_elm_win_indicator_opacity_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2009-12-01 03:03:14 -08:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return sd->ind_o_mode;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_screen_position_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, int *x, int *y)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
if (x) *x = sd->screen.x;
|
|
|
|
if (y) *y = sd->screen.y;
|
2009-12-01 03:03:14 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_focus_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2011-12-03 14:51:12 -08:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return ecore_evas_focus_get(sd->ee);
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_screen_constrain_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, Eina_Bool constrain)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->constrain = !!constrain;
|
2011-12-03 14:51:12 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_screen_constrain_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2011-12-03 14:51:12 -08:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return sd->constrain;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_screen_size_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, int *x, int *y, int *w, int *h)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
ecore_evas_screen_geometry_get(sd->ee, x, y, w, h);
|
2011-11-21 11:51:24 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_screen_dpi_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, int *xdpi, int *ydpi)
|
2012-07-05 05:59:06 -07:00
|
|
|
{
|
|
|
|
ecore_evas_screen_dpi_get(sd->ee, xdpi, ydpi);
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_conformant_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, Eina_Bool conformant)
|
2010-01-14 21:17:54 -08:00
|
|
|
{
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2014-03-27 06:15:52 -07:00
|
|
|
_internal_elm_win_xwindow_get(sd);
|
2012-06-06 01:25:12 -07:00
|
|
|
if (sd->x.xwin)
|
|
|
|
ecore_x_e_illume_conformant_set(sd->x.xwin, conformant);
|
2011-11-20 06:00:41 -08:00
|
|
|
#else
|
2012-05-03 15:42:15 -07:00
|
|
|
(void)conformant;
|
2010-01-14 21:17:54 -08:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_conformant_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2010-01-14 21:17:54 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2014-03-27 06:15:52 -07:00
|
|
|
_internal_elm_win_xwindow_get(sd);
|
2012-06-06 01:25:12 -07:00
|
|
|
if (sd->x.xwin)
|
2014-03-27 06:15:52 -07:00
|
|
|
return ecore_x_e_illume_conformant_get(sd->x.xwin);
|
2010-01-14 21:17:54 -08:00
|
|
|
#endif
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
return EINA_FALSE;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_quickpanel_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, Eina_Bool quickpanel)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2010-01-24 02:12:57 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2014-03-27 06:15:52 -07:00
|
|
|
_internal_elm_win_xwindow_get(sd);
|
2012-06-06 01:25:12 -07:00
|
|
|
if (sd->x.xwin)
|
2010-01-24 12:05:09 -08:00
|
|
|
{
|
2012-06-06 01:25:12 -07:00
|
|
|
ecore_x_e_illume_quickpanel_set(sd->x.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;
|
2012-06-06 01:25:12 -07:00
|
|
|
ecore_x_netwm_window_state_set(sd->x.xwin, states, 2);
|
|
|
|
ecore_x_icccm_hints_set(sd->x.xwin, 0, 0, 0, 0, 0, 0, 0);
|
2010-01-24 12:05:09 -08:00
|
|
|
}
|
|
|
|
}
|
2011-11-20 06:00:41 -08:00
|
|
|
#else
|
2012-05-03 15:42:15 -07:00
|
|
|
(void)quickpanel;
|
2010-01-24 02:12:57 -08:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_quickpanel_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2010-01-24 02:12:57 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2014-03-27 06:15:52 -07:00
|
|
|
_internal_elm_win_xwindow_get(sd);
|
2012-06-06 01:25:12 -07:00
|
|
|
if (sd->x.xwin)
|
2014-03-27 06:15:52 -07:00
|
|
|
return ecore_x_e_illume_quickpanel_get(sd->x.xwin);
|
2010-01-24 02:12:57 -08:00
|
|
|
#endif
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
return EINA_FALSE;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_quickpanel_priority_major_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, int priority)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2010-01-24 02:21:54 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2014-03-27 06:15:52 -07:00
|
|
|
_internal_elm_win_xwindow_get(sd);
|
2012-06-06 01:25:12 -07:00
|
|
|
if (sd->x.xwin)
|
|
|
|
ecore_x_e_illume_quickpanel_priority_major_set(sd->x.xwin, priority);
|
2011-11-20 06:00:41 -08:00
|
|
|
#else
|
2012-05-03 15:42:15 -07:00
|
|
|
(void)priority;
|
2010-01-24 02:21:54 -08:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static int
|
|
|
|
_elm_win_quickpanel_priority_major_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2010-01-24 02:21:54 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2014-03-27 06:15:52 -07:00
|
|
|
_internal_elm_win_xwindow_get(sd);
|
2012-06-06 01:25:12 -07:00
|
|
|
if (sd->x.xwin)
|
2014-03-27 06:15:52 -07:00
|
|
|
return ecore_x_e_illume_quickpanel_priority_major_get(sd->x.xwin);
|
2010-01-24 02:21:54 -08:00
|
|
|
#endif
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
return -1;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_quickpanel_priority_minor_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, int priority)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2010-01-24 02:21:54 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2014-03-27 06:15:52 -07:00
|
|
|
_internal_elm_win_xwindow_get(sd);
|
2012-06-06 01:25:12 -07:00
|
|
|
if (sd->x.xwin)
|
|
|
|
ecore_x_e_illume_quickpanel_priority_minor_set(sd->x.xwin, priority);
|
2011-11-20 06:00:41 -08:00
|
|
|
#else
|
2012-05-03 15:42:15 -07:00
|
|
|
(void)priority;
|
2010-01-24 02:21:54 -08:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static int
|
|
|
|
_elm_win_quickpanel_priority_minor_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2010-01-24 02:21:54 -08:00
|
|
|
{
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2014-03-27 06:15:52 -07:00
|
|
|
_internal_elm_win_xwindow_get(sd);
|
2012-06-06 01:25:12 -07:00
|
|
|
if (sd->x.xwin)
|
2014-03-27 06:15:52 -07:00
|
|
|
return ecore_x_e_illume_quickpanel_priority_minor_get(sd->x.xwin);
|
2010-01-24 02:21:54 -08:00
|
|
|
#endif
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
return -1;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_quickpanel_zone_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, int zone)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2010-01-24 12:05:09 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2014-03-27 06:15:52 -07:00
|
|
|
_internal_elm_win_xwindow_get(sd);
|
2012-06-06 01:25:12 -07:00
|
|
|
if (sd->x.xwin)
|
|
|
|
ecore_x_e_illume_quickpanel_zone_set(sd->x.xwin, zone);
|
2011-11-20 06:00:41 -08:00
|
|
|
#else
|
2012-05-03 15:42:15 -07:00
|
|
|
(void)zone;
|
2010-01-24 12:05:09 -08:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static int
|
|
|
|
_elm_win_quickpanel_zone_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2010-10-27 07:38:37 -07:00
|
|
|
{
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2014-03-27 06:15:52 -07:00
|
|
|
_internal_elm_win_xwindow_get(sd);
|
2012-06-06 01:25:12 -07:00
|
|
|
if (sd->x.xwin)
|
2014-03-27 06:15:52 -07:00
|
|
|
return ecore_x_e_illume_quickpanel_zone_get(sd->x.xwin);
|
2010-10-27 07:38:37 -07:00
|
|
|
#endif
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
return 0;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_prop_focus_skip_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, Eina_Bool skip)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->skip_focus = skip;
|
2012-07-18 21:35:50 -07:00
|
|
|
TRAP(sd, focus_skip_set, skip);
|
2011-02-17 02:56:32 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_illume_command_send(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, Elm_Illume_Command command, void *params)
|
2011-02-17 02:56:32 -08:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
(void) params;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2011-02-17 02:56:32 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2014-03-27 06:15:52 -07:00
|
|
|
_internal_elm_win_xwindow_get(sd);
|
2012-06-06 01:25:12 -07:00
|
|
|
if (sd->x.xwin)
|
2011-02-17 02:56:32 -08:00
|
|
|
{
|
|
|
|
switch (command)
|
|
|
|
{
|
|
|
|
case ELM_ILLUME_COMMAND_FOCUS_BACK:
|
2012-06-06 01:25:12 -07:00
|
|
|
ecore_x_e_illume_focus_back_send(sd->x.xwin);
|
2012-05-03 15:42:15 -07:00
|
|
|
break;
|
|
|
|
|
2011-02-17 02:56:32 -08:00
|
|
|
case ELM_ILLUME_COMMAND_FOCUS_FORWARD:
|
2012-06-06 01:25:12 -07:00
|
|
|
ecore_x_e_illume_focus_forward_send(sd->x.xwin);
|
2012-05-03 15:42:15 -07:00
|
|
|
break;
|
|
|
|
|
2011-02-17 02:56:32 -08:00
|
|
|
case ELM_ILLUME_COMMAND_FOCUS_HOME:
|
2012-06-06 01:25:12 -07:00
|
|
|
ecore_x_e_illume_focus_home_send(sd->x.xwin);
|
2012-05-03 15:42:15 -07:00
|
|
|
break;
|
|
|
|
|
2011-02-17 02:56:32 -08:00
|
|
|
case ELM_ILLUME_COMMAND_CLOSE:
|
2012-06-06 01:25:12 -07:00
|
|
|
ecore_x_e_illume_close_send(sd->x.xwin);
|
2012-05-03 15:42:15 -07:00
|
|
|
break;
|
|
|
|
|
2011-02-17 02:56:32 -08:00
|
|
|
default:
|
2012-05-03 15:42:15 -07:00
|
|
|
break;
|
2011-02-17 02:56:32 -08:00
|
|
|
}
|
|
|
|
}
|
2011-11-20 06:00:41 -08:00
|
|
|
#else
|
2012-05-03 15:42:15 -07:00
|
|
|
(void)command;
|
2011-02-17 02:56:32 -08:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2015-05-13 04:57:36 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_keygrab_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, const char *key, Evas_Modifier_Mask modifiers EINA_UNUSED, Evas_Modifier_Mask not_modifiers EINA_UNUSED, int priority EINA_UNUSED, Elm_Win_Keygrab_Mode grab_mode)
|
|
|
|
{
|
|
|
|
Eina_Bool ret = EINA_FALSE;
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
_internal_elm_win_xwindow_get(sd);
|
|
|
|
if (sd->x.xwin)
|
|
|
|
{
|
2015-06-11 19:16:25 -07:00
|
|
|
Ecore_X_Win_Keygrab_Mode x_grab_mode;
|
|
|
|
switch (grab_mode)
|
|
|
|
{
|
|
|
|
case ELM_WIN_KEYGRAB_SHARED:
|
|
|
|
x_grab_mode = ECORE_X_WIN_KEYGRAB_SHARED;
|
|
|
|
break;
|
|
|
|
case ELM_WIN_KEYGRAB_TOPMOST:
|
|
|
|
x_grab_mode = ECORE_X_WIN_KEYGRAB_TOPMOST;
|
|
|
|
break;
|
|
|
|
case ELM_WIN_KEYGRAB_EXCLUSIVE:
|
|
|
|
x_grab_mode = ECORE_X_WIN_KEYGRAB_EXCLUSIVE;
|
|
|
|
break;
|
|
|
|
case ELM_WIN_KEYGRAB_OVERRIDE_EXCLUSIVE:
|
|
|
|
x_grab_mode = ECORE_X_WIN_KEYGRAB_OVERRIDE_EXCLUSIVE;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
ret = ecore_x_window_keygrab_set(sd->x.xwin, key, 0, 0, 0, x_grab_mode);
|
2015-05-13 04:57:36 -07:00
|
|
|
}
|
|
|
|
#endif
|
2015-06-11 19:16:25 -07:00
|
|
|
return ret;
|
2015-05-13 04:57:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_keygrab_unset(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, const char *key, Evas_Modifier_Mask modifiers EINA_UNUSED, Evas_Modifier_Mask not_modifiers EINA_UNUSED)
|
|
|
|
{
|
|
|
|
Eina_Bool ret = EINA_FALSE;
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
_internal_elm_win_xwindow_get(sd);
|
|
|
|
if (sd->x.xwin)
|
|
|
|
ret = ecore_x_window_keygrab_unset(sd->x.xwin, key, 0, 0);
|
|
|
|
#endif
|
2015-06-11 19:16:25 -07:00
|
|
|
return ret;
|
2015-05-13 04:57:36 -07:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Evas_Object*
|
|
|
|
_elm_win_inlined_image_object_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
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
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return sd->img_obj;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_focus_highlight_enabled_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, Eina_Bool enabled)
|
2012-11-25 22:32:53 -08: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
|
|
|
enabled = !!enabled;
|
2012-05-03 15:42:15 -07:00
|
|
|
if (sd->focus_highlight.enabled == enabled)
|
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;
|
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
sd->focus_highlight.enabled = enabled;
|
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
|
|
|
|
2015-03-04 00:47:54 -08:00
|
|
|
if ((sd->focus_highlight.enabled) || (sd->focus_highlight.auto_enabled))
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_focus_highlight_init(sd);
|
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
|
|
|
else
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_focus_highlight_shutdown(sd);
|
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
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_focus_highlight_enabled_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
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
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return sd->focus_highlight.enabled;
|
2012-11-25 22:32:53 -08: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
|
|
|
|
2014-12-15 08:45:59 -08:00
|
|
|
static Eina_Bool
|
|
|
|
_elm_win_theme_internal(Eo *obj, Elm_Win_Data *sd)
|
|
|
|
{
|
|
|
|
Eina_Bool ret = EINA_FALSE;
|
2014-12-15 08:57:24 -08:00
|
|
|
const char *s;
|
2014-12-15 08:45:59 -08:00
|
|
|
|
2014-12-15 09:02:40 -08:00
|
|
|
if (!_elm_theme_object_set(obj, sd->edje, "win", "base",
|
2014-12-15 08:45:59 -08:00
|
|
|
elm_widget_style_get(obj)))
|
|
|
|
return EINA_FALSE;
|
|
|
|
|
2014-12-15 09:02:40 -08:00
|
|
|
edje_object_mirrored_set(sd->edje, elm_widget_mirrored_get(obj));
|
|
|
|
edje_object_scale_set(sd->edje,
|
2014-12-15 08:45:59 -08:00
|
|
|
elm_widget_scale_get(obj) * elm_config_scale_get());
|
|
|
|
|
2015-05-13 04:34:44 -07:00
|
|
|
eo_do(obj, eo_event_callback_call(ELM_WIN_EVENT_THEME_CHANGED, NULL));
|
2014-12-15 08:45:59 -08:00
|
|
|
eo_do(obj, ret = elm_obj_widget_disable());
|
|
|
|
|
2014-12-15 08:57:24 -08:00
|
|
|
if (!sd->theme_alpha && !sd->application_alpha)
|
|
|
|
{
|
2014-12-15 09:02:40 -08:00
|
|
|
s = edje_object_data_get(sd->edje, "alpha");
|
2014-12-15 08:57:24 -08:00
|
|
|
if (s)
|
|
|
|
{
|
|
|
|
if (!strcmp(s, "1") ||
|
|
|
|
!strcmp(s, "true"))
|
|
|
|
{
|
|
|
|
sd->application_alpha = 1;
|
|
|
|
_elm_win_apply_alpha(obj, sd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-12-15 08:45:59 -08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_elm_widget_theme_apply(Eo *obj, Elm_Win_Data *sd)
|
2013-10-03 07:57:08 -07:00
|
|
|
{
|
2013-10-11 05:52:15 -07:00
|
|
|
Eina_Bool int_ret = EINA_FALSE;
|
2014-04-03 09:23:03 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, int_ret = elm_obj_widget_theme_apply());
|
2014-12-15 07:40:39 -08:00
|
|
|
if (!int_ret) return EINA_FALSE;
|
2013-10-11 05:52:15 -07:00
|
|
|
|
2013-10-03 07:57:08 -07:00
|
|
|
sd->focus_highlight.theme_changed = EINA_TRUE;
|
2014-12-15 08:45:59 -08:00
|
|
|
if (!_elm_win_theme_internal(obj, sd))
|
|
|
|
return EINA_FALSE;
|
2013-10-03 07:57:08 -07:00
|
|
|
_elm_win_focus_highlight_reconfigure_job_start(sd);
|
2013-10-11 05:52:15 -07:00
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
return EINA_TRUE;
|
2013-10-03 07:57:08 -07:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_focus_highlight_style_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, const char *style)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-05-03 15:42:15 -07:00
|
|
|
eina_stringshare_replace(&sd->focus_highlight.style, style);
|
2013-08-04 01:09:44 -07:00
|
|
|
sd->focus_highlight.theme_changed = EINA_TRUE;
|
2012-05-03 15:42:15 -07:00
|
|
|
_elm_win_focus_highlight_reconfigure_job_start(sd);
|
2010-10-04 10:34:35 -07:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static const char*
|
|
|
|
_elm_win_focus_highlight_style_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2010-10-04 10:34:35 -07:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return sd->focus_highlight.style;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
2012-05-03 15:42:15 -07:00
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_focus_highlight_animate_set(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, Eina_Bool animate)
|
2013-08-11 02:58:28 -07:00
|
|
|
{
|
|
|
|
animate = !!animate;
|
|
|
|
if (sd->focus_highlight.animate == animate)
|
|
|
|
return;
|
|
|
|
|
|
|
|
sd->focus_highlight.animate = animate;
|
2013-08-15 06:42:59 -07:00
|
|
|
sd->focus_highlight.theme_changed = EINA_TRUE;
|
|
|
|
_elm_win_focus_highlight_reconfigure_job_start(sd);
|
2013-08-11 02:58:28 -07:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_focus_highlight_animate_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2013-08-11 02:58:28 -07:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
return sd->focus_highlight.animate;
|
2013-08-11 02:58:28 -07:00
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_win_socket_listen(Eo *obj EINA_UNUSED, Elm_Win_Data *sd, const char *svcname, int svcnum, Eina_Bool svcsys)
|
2013-08-11 02:58:28 -07:00
|
|
|
{
|
2014-03-27 06:15:52 -07:00
|
|
|
if (!sd->ee) return EINA_FALSE;
|
2012-05-03 15:42:15 -07:00
|
|
|
|
|
|
|
if (!ecore_evas_extn_socket_listen(sd->ee, svcname, svcnum, svcsys))
|
2014-03-27 06:15:52 -07:00
|
|
|
return EINA_FALSE;
|
2010-10-04 10:34:35 -07:00
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
return EINA_TRUE;
|
2010-10-04 10:34:35 -07:00
|
|
|
}
|
|
|
|
|
2012-05-03 15:42:15 -07:00
|
|
|
/* windowing specific calls - shall we do this differently? */
|
2012-05-02 09:58:56 -07:00
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Ecore_X_Window
|
|
|
|
_elm_win_xwindow_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2012-05-03 15:42:15 -07:00
|
|
|
{
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2014-03-27 06:15:52 -07:00
|
|
|
if (sd->x.xwin) return sd->x.xwin;
|
|
|
|
if (sd->parent) return elm_win_xwindow_get(sd->parent);
|
2012-05-03 15:42:15 -07:00
|
|
|
#endif
|
2014-03-27 06:15:52 -07:00
|
|
|
return 0;
|
2012-05-02 18:19:05 -07:00
|
|
|
}
|
2012-06-06 06:55:15 -07:00
|
|
|
|
|
|
|
EAPI Ecore_Wl_Window *
|
|
|
|
elm_win_wl_window_get(const Evas_Object *obj)
|
|
|
|
{
|
2014-08-10 15:59:45 -07:00
|
|
|
ELM_WIN_CHECK(obj) NULL;
|
|
|
|
ELM_WIN_DATA_GET_OR_RETURN_VAL(obj, sd, NULL);
|
|
|
|
const char *engine_name = ecore_evas_engine_name_get(sd->ee);
|
2012-06-06 06:55:15 -07:00
|
|
|
|
2014-08-10 15:59:45 -07:00
|
|
|
if (!(engine_name &&
|
|
|
|
((!strcmp(engine_name, ELM_WAYLAND_SHM)) ||
|
|
|
|
(!strcmp(engine_name, ELM_WAYLAND_EGL)))))
|
2012-12-19 06:41:45 -08:00
|
|
|
return NULL;
|
|
|
|
|
2013-11-07 03:44:22 -08:00
|
|
|
if (!evas_object_smart_type_check_ptr(obj, MY_CLASS_NAME_LEGACY))
|
2012-06-06 06:55:15 -07:00
|
|
|
{
|
|
|
|
Ecore_Evas *ee = ecore_evas_ecore_evas_get(evas_object_evas_get(obj));
|
2013-11-15 02:14:08 -08:00
|
|
|
return _elm_ee_wlwin_get(ee);
|
2012-06-06 06:55:15 -07:00
|
|
|
}
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
Ecore_Wl_Window *ret = NULL;
|
2014-04-03 09:23:03 -07:00
|
|
|
eo_do((Eo *) obj, ret = elm_obj_win_wl_window_get());
|
2012-11-25 22:32:53 -08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Ecore_Wl_Window*
|
|
|
|
_elm_win_wl_window_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-12-06 01:49:43 -08:00
|
|
|
#if HAVE_ELEMENTARY_WAYLAND
|
2014-03-27 06:15:52 -07:00
|
|
|
if (sd->wl.win) return sd->wl.win;
|
|
|
|
if (sd->parent) return elm_win_wl_window_get(sd->parent);
|
2013-11-15 04:52:19 -08:00
|
|
|
#else
|
2014-03-27 06:15:52 -07:00
|
|
|
(void)sd;
|
2012-12-06 01:38:25 -08:00
|
|
|
#endif
|
2014-03-27 06:15:52 -07:00
|
|
|
return NULL;
|
2012-06-06 06:55:15 -07:00
|
|
|
}
|
2012-07-18 21:35:50 -07:00
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_win_trap_set(const Elm_Win_Trap *t)
|
|
|
|
{
|
|
|
|
DBG("old %p, new %p", trap, t);
|
|
|
|
|
|
|
|
if ((t) && (t->version != ELM_WIN_TRAP_VERSION))
|
|
|
|
{
|
2013-12-25 20:03:55 -08:00
|
|
|
CRI("trying to set a trap version %lu while %lu was expected!",
|
2012-07-18 21:35:50 -07:00
|
|
|
t->version, ELM_WIN_TRAP_VERSION);
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
trap = t;
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
2012-09-14 06:06:57 -07:00
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_win_floating_mode_set(Evas_Object *obj, Eina_Bool floating)
|
|
|
|
{
|
|
|
|
ELM_WIN_CHECK(obj);
|
|
|
|
ELM_WIN_DATA_GET_OR_RETURN(obj, sd);
|
|
|
|
|
2013-12-25 21:23:29 -08:00
|
|
|
floating = !!floating;
|
2012-09-14 06:06:57 -07:00
|
|
|
if (floating == sd->floating) return;
|
|
|
|
sd->floating = floating;
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2014-03-27 06:15:52 -07:00
|
|
|
_internal_elm_win_xwindow_get(sd);
|
2012-09-14 06:06:57 -07:00
|
|
|
if (sd->x.xwin)
|
|
|
|
{
|
|
|
|
if (sd->floating)
|
|
|
|
ecore_x_e_illume_window_state_set
|
|
|
|
(sd->x.xwin, ECORE_X_ILLUME_WINDOW_STATE_FLOATING);
|
|
|
|
else
|
|
|
|
ecore_x_e_illume_window_state_set
|
|
|
|
(sd->x.xwin, ECORE_X_ILLUME_WINDOW_STATE_NORMAL);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_win_floating_mode_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_WIN_CHECK(obj) EINA_FALSE;
|
|
|
|
ELM_WIN_DATA_GET_OR_RETURN_VAL(obj, sd, EINA_FALSE);
|
|
|
|
|
|
|
|
return sd->floating;
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static Ecore_Window
|
|
|
|
_elm_win_window_id_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd)
|
2013-09-04 01:19:30 -07:00
|
|
|
{
|
2014-08-10 15:59:45 -07:00
|
|
|
const char *engine_name = ecore_evas_engine_name_get(sd->ee);
|
|
|
|
|
|
|
|
if ((engine_name &&
|
|
|
|
((!strcmp(engine_name, ELM_WAYLAND_SHM)) ||
|
|
|
|
(!strcmp(engine_name, ELM_WAYLAND_EGL)))))
|
2013-09-04 01:19:30 -07:00
|
|
|
{
|
|
|
|
#if HAVE_ELEMENTARY_WAYLAND
|
2015-04-16 08:49:41 -07:00
|
|
|
if (sd->wl.win) return (Ecore_Window)ecore_wl_window_surface_id_get(sd->wl.win);
|
2013-09-04 01:19:30 -07:00
|
|
|
if (sd->parent)
|
|
|
|
{
|
|
|
|
Ecore_Wl_Window *parent;
|
|
|
|
|
|
|
|
parent = elm_win_wl_window_get(sd->parent);
|
2015-04-16 08:49:41 -07:00
|
|
|
if (parent) return (Ecore_Window)ecore_wl_window_surface_id_get(parent);
|
2014-03-27 06:15:52 -07:00
|
|
|
return 0;
|
2013-09-04 01:19:30 -07:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
2014-08-10 15:59:45 -07:00
|
|
|
else if ((engine_name &&
|
|
|
|
((!strcmp(engine_name, ELM_SOFTWARE_X11)) ||
|
|
|
|
(!strcmp(engine_name, ELM_OPENGL_X11)))))
|
2013-09-04 01:19:30 -07:00
|
|
|
{
|
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2014-03-27 06:15:52 -07:00
|
|
|
_internal_elm_win_xwindow_get(sd);
|
|
|
|
if (sd->x.xwin) return (Ecore_Window)sd->x.xwin;
|
|
|
|
if (sd->parent) return (Ecore_Window)elm_win_xwindow_get(sd->parent);
|
2013-09-04 01:19:30 -07:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
return 0;
|
2013-09-04 01:19:30 -07:00
|
|
|
}
|
|
|
|
|
2014-05-11 09:04:25 -07:00
|
|
|
void
|
|
|
|
_elm_win_focus_highlight_in_theme_update(Evas_Object *obj, Eina_Bool in_theme)
|
|
|
|
{
|
|
|
|
ELM_WIN_DATA_GET(obj, sd);
|
|
|
|
sd->focus_highlight.cur.in_theme = !!in_theme;
|
|
|
|
}
|
|
|
|
|
2014-02-18 06:40:48 -08:00
|
|
|
void
|
|
|
|
_elm_win_focus_highlight_start(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_WIN_DATA_GET(obj, sd);
|
|
|
|
|
|
|
|
if (!elm_win_focus_highlight_enabled_get(obj)) return;
|
|
|
|
sd->focus_highlight.cur.visible = EINA_TRUE;
|
|
|
|
sd->focus_highlight.geometry_changed = EINA_TRUE;
|
2014-03-07 03:34:37 -08:00
|
|
|
_elm_win_focus_highlight_reconfigure_job(obj);
|
2014-02-18 06:40:48 -08:00
|
|
|
}
|
|
|
|
|
2015-03-04 00:47:54 -08:00
|
|
|
void
|
|
|
|
_elm_win_focus_auto_show(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_WIN_DATA_GET(obj, sd);
|
|
|
|
Eina_Bool pfocus = (sd->focus_highlight.enabled) || (sd->focus_highlight.auto_enabled);
|
|
|
|
sd->focus_highlight.auto_enabled = _elm_config->win_auto_focus_enable;
|
|
|
|
sd->focus_highlight.auto_animate = _elm_config->win_auto_focus_animate;
|
|
|
|
if (pfocus != ((sd->focus_highlight.enabled) || (sd->focus_highlight.auto_enabled)))
|
|
|
|
{
|
|
|
|
if ((sd->focus_highlight.enabled) || (sd->focus_highlight.auto_enabled))
|
|
|
|
_elm_win_focus_highlight_init(sd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
_elm_win_focus_auto_hide(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_WIN_DATA_GET(obj, sd);
|
|
|
|
Eina_Bool pfocus = (sd->focus_highlight.enabled) || (sd->focus_highlight.auto_enabled);
|
|
|
|
sd->focus_highlight.auto_enabled = EINA_FALSE;
|
|
|
|
sd->focus_highlight.auto_animate = EINA_FALSE;
|
|
|
|
if (pfocus != ((sd->focus_highlight.enabled) || (sd->focus_highlight.auto_enabled)))
|
|
|
|
{
|
|
|
|
if (!((sd->focus_highlight.enabled) || (sd->focus_highlight.auto_enabled)))
|
|
|
|
_elm_win_focus_highlight_shutdown(sd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-09-30 03:21:31 -07:00
|
|
|
EAPI Ecore_Window
|
2013-09-04 01:19:30 -07:00
|
|
|
elm_win_window_id_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
if (!obj) return 0;
|
|
|
|
|
2013-11-07 03:44:22 -08:00
|
|
|
if (!evas_object_smart_type_check_ptr(obj, MY_CLASS_NAME_LEGACY))
|
2013-09-04 01:19:30 -07:00
|
|
|
{
|
|
|
|
Ecore_Evas *ee = ecore_evas_ecore_evas_get(evas_object_evas_get(obj));
|
|
|
|
return ecore_evas_window_get(ee);
|
|
|
|
}
|
|
|
|
|
|
|
|
ELM_WIN_CHECK(obj) 0;
|
|
|
|
Ecore_Window ret = 0;
|
2014-04-03 09:23:03 -07:00
|
|
|
eo_do((Eo *) obj, ret = elm_obj_win_window_id_get());
|
2013-09-04 01:19:30 -07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-06-29 07:30:34 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_on_atspi_bus_connected(void *data EINA_UNUSED, Eo *obj EINA_UNUSED, const Eo_Event_Description *desc EINA_UNUSED, void *event_info EINA_UNUSED)
|
|
|
|
{
|
|
|
|
Evas_Object *win;
|
|
|
|
Eina_List *l;
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(_elm_win_list, l, win)
|
|
|
|
{
|
|
|
|
/**
|
|
|
|
* Reemit accessibility events when AT-SPI2 connection is begin
|
|
|
|
* established. This assures that Assistive Technology clients will
|
|
|
|
* recieve all org.a11y.window events and could keep track of active
|
|
|
|
* windows whithin system.
|
|
|
|
*/
|
|
|
|
eo_do(win, eo_event_callback_call(ELM_INTERFACE_ATSPI_WINDOW_EVENT_WINDOW_CREATED, NULL));
|
|
|
|
if (elm_win_focus_get(win))
|
|
|
|
eo_do(win, eo_event_callback_call(ELM_INTERFACE_ATSPI_WINDOW_EVENT_WINDOW_ACTIVATED, NULL));
|
|
|
|
else
|
|
|
|
eo_do(win, eo_event_callback_call(ELM_INTERFACE_ATSPI_WINDOW_EVENT_WINDOW_DEACTIVATED, NULL));
|
|
|
|
}
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_win_class_constructor(Eo_Class *klass)
|
|
|
|
{
|
2013-11-07 03:44:22 -08:00
|
|
|
evas_smart_legacy_type_register(MY_CLASS_NAME_LEGACY, klass);
|
2015-06-29 07:30:34 -07:00
|
|
|
|
|
|
|
if (_elm_config->atspi_mode)
|
|
|
|
{
|
|
|
|
Eo *bridge = _elm_atspi_bridge_get();
|
|
|
|
if (bridge)
|
|
|
|
eo_do(bridge, eo_event_callback_add(ELM_ATSPI_BRIDGE_EVENT_CONNECTED, _on_atspi_bus_connected, NULL));
|
|
|
|
}
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-04-20 20:46:11 -07:00
|
|
|
EOLIAN static Eo*
|
|
|
|
_elm_win_elm_interface_atspi_accessible_parent_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd EINA_UNUSED)
|
|
|
|
{
|
|
|
|
// attach all kinds of windows directly to ATSPI application root object
|
2015-06-08 06:40:28 -07:00
|
|
|
Eo *bridge = _elm_atspi_bridge_get();
|
|
|
|
return elm_atspi_bridge_root_get(bridge);
|
2014-04-20 20:46:11 -07:00
|
|
|
}
|
|
|
|
|
2014-07-25 01:33:19 -07:00
|
|
|
EOLIAN static const Elm_Atspi_Action*
|
|
|
|
_elm_win_elm_interface_atspi_widget_action_elm_actions_get(Eo *obj EINA_UNUSED, Elm_Win_Data *sd EINA_UNUSED)
|
|
|
|
{
|
|
|
|
static Elm_Atspi_Action atspi_actions[] = {
|
|
|
|
{ "move,previous", "move", "previous", _key_action_move},
|
|
|
|
{ "move,next", "move", "next", _key_action_move},
|
|
|
|
{ "move,left", "move", "left", _key_action_move},
|
|
|
|
{ "move,right", "move", "right", _key_action_move},
|
|
|
|
{ "move,up", "move", "up", _key_action_move},
|
|
|
|
{ "move,down", "move", "down", _key_action_move},
|
|
|
|
{ NULL, NULL, NULL, NULL }
|
|
|
|
};
|
|
|
|
return &atspi_actions[0];
|
|
|
|
}
|
|
|
|
|
2015-05-13 06:37:47 -07:00
|
|
|
EOLIAN static Elm_Atspi_State_Set
|
|
|
|
_elm_win_elm_interface_atspi_accessible_state_set_get(Eo *obj, Elm_Win_Data *sd EINA_UNUSED)
|
|
|
|
{
|
|
|
|
Elm_Atspi_State_Set ret;
|
|
|
|
eo_do_super(obj, MY_CLASS, ret = elm_interface_atspi_accessible_state_set_get());
|
|
|
|
|
|
|
|
if (elm_win_focus_get(obj))
|
|
|
|
STATE_TYPE_SET(ret, ELM_ATSPI_STATE_ACTIVE);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-07-02 04:53:02 -07:00
|
|
|
EOLIAN static char*
|
|
|
|
_elm_win_elm_interface_atspi_accessible_name_get(Eo *obj, Elm_Win_Data *sd EINA_UNUSED)
|
|
|
|
{
|
|
|
|
const char *ret = elm_win_title_get(obj);
|
|
|
|
return ret ? strdup(ret) : strdup("");
|
|
|
|
}
|
|
|
|
|
2014-03-27 06:15:52 -07:00
|
|
|
#include "elm_win.eo.c"
|