2011-12-08 08:19:44 -08:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include <config.h>
|
|
|
|
#endif
|
|
|
|
|
2011-12-06 14:33:01 -08:00
|
|
|
#include <stdlib.h>
|
2009-01-31 10:33:39 -08:00
|
|
|
#include <string.h>
|
2011-12-08 08:19:44 -08:00
|
|
|
|
|
|
|
#include <Eina.h>
|
|
|
|
#include <Ecore.h>
|
|
|
|
|
2008-07-14 03:06:34 -07:00
|
|
|
#include "ecore_evas_private.h"
|
2009-04-14 13:04:16 -07:00
|
|
|
#include "Ecore_Evas.h"
|
2008-07-14 03:06:34 -07:00
|
|
|
|
2007-11-05 23:21:08 -08:00
|
|
|
#ifdef BUILD_ECORE_EVAS_X11
|
2003-09-23 01:09:32 -07:00
|
|
|
static int _ecore_evas_init_count = 0;
|
|
|
|
|
2010-02-01 06:13:48 -08:00
|
|
|
static Ecore_Event_Handler *ecore_evas_event_handlers[13];
|
2003-09-23 01:09:32 -07:00
|
|
|
|
2010-10-01 18:56:23 -07:00
|
|
|
static int leader_ref = 0;
|
|
|
|
static Ecore_X_Window leader_win = 0;
|
|
|
|
|
2012-02-27 22:43:59 -08:00
|
|
|
static void
|
|
|
|
_ecore_evas_x_hints_update(Ecore_Evas *ee)
|
|
|
|
{
|
|
|
|
ecore_x_icccm_hints_set
|
|
|
|
(ee->prop.window,
|
|
|
|
!ee->prop.focus_skip /* accepts_focus */,
|
|
|
|
ee->prop.iconified ? ECORE_X_WINDOW_STATE_HINT_ICONIC :
|
|
|
|
ee->prop.withdrawn ? ECORE_X_WINDOW_STATE_HINT_WITHDRAWN :
|
|
|
|
ECORE_X_WINDOW_STATE_HINT_NORMAL /* initial_state */,
|
|
|
|
0 /* icon_pixmap */,
|
|
|
|
0 /* icon_mask */,
|
|
|
|
0 /* icon_window */,
|
|
|
|
ee->prop.group_ee_win /* window_group */,
|
|
|
|
ee->prop.urgent /* is_urgent */);
|
|
|
|
}
|
|
|
|
|
2010-10-01 18:56:23 -07:00
|
|
|
static void
|
|
|
|
_ecore_evas_x_group_leader_set(Ecore_Evas *ee)
|
|
|
|
{
|
|
|
|
leader_ref++;
|
|
|
|
if (leader_ref == 1)
|
|
|
|
{
|
2011-07-26 04:24:10 -07:00
|
|
|
char *id = NULL;
|
|
|
|
|
2011-09-21 23:02:26 -07:00
|
|
|
leader_win =
|
2011-07-26 04:24:10 -07:00
|
|
|
ecore_x_window_override_new(ee->engine.x.win_root, 1234, 5678, 1, 2);
|
2010-10-01 18:56:23 -07:00
|
|
|
ecore_x_window_defaults_set(leader_win);
|
2011-07-26 04:24:10 -07:00
|
|
|
if ((id = getenv("DESKTOP_STARTUP_ID")))
|
|
|
|
ecore_x_netwm_startup_id_set(leader_win,id);
|
2010-10-01 18:56:23 -07:00
|
|
|
ecore_x_icccm_client_leader_set(leader_win, leader_win);
|
|
|
|
}
|
|
|
|
ee->engine.x.leader = leader_win;
|
|
|
|
ecore_x_icccm_client_leader_set(ee->prop.window, leader_win);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_ecore_evas_x_group_leader_unset(Ecore_Evas *ee)
|
|
|
|
{
|
2011-09-21 23:02:26 -07:00
|
|
|
ecore_x_window_prop_property_del(ee->prop.window,
|
2011-07-26 04:24:10 -07:00
|
|
|
ECORE_X_ATOM_WM_CLIENT_LEADER);
|
2010-10-01 18:56:23 -07:00
|
|
|
if (ee->engine.x.leader == leader_win)
|
|
|
|
{
|
|
|
|
leader_ref--;
|
|
|
|
if (leader_ref <= 0)
|
|
|
|
{
|
|
|
|
ecore_x_window_free(leader_win);
|
|
|
|
leader_win = 0;
|
|
|
|
}
|
|
|
|
ee->engine.x.leader = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_ecore_evas_x_group_leader_update(Ecore_Evas *ee)
|
|
|
|
{
|
|
|
|
if (ee->engine.x.leader)
|
|
|
|
ecore_x_icccm_client_leader_set(ee->prop.window, ee->engine.x.leader);
|
|
|
|
}
|
|
|
|
|
2010-01-29 02:28:54 -08:00
|
|
|
static void
|
|
|
|
_ecore_evas_x_protocols_set(Ecore_Evas *ee)
|
|
|
|
{
|
2011-11-14 10:48:19 -08:00
|
|
|
Ecore_X_Atom protos[3];
|
2011-07-26 04:24:10 -07:00
|
|
|
unsigned int num = 0, tmp = 0;
|
2011-04-20 07:15:33 -07:00
|
|
|
|
2010-01-29 02:28:54 -08:00
|
|
|
if (ee->func.fn_delete_request)
|
2011-11-14 10:48:19 -08:00
|
|
|
protos[num++] = ECORE_X_ATOM_WM_DELETE_WINDOW;
|
2010-02-02 19:20:22 -08:00
|
|
|
protos[num++] = ECORE_X_ATOM_NET_WM_PING;
|
2011-03-30 03:10:04 -07:00
|
|
|
protos[num++] = ECORE_X_ATOM_NET_WM_SYNC_REQUEST;
|
2010-01-29 03:06:32 -08:00
|
|
|
ecore_x_icccm_protocol_atoms_set(ee->prop.window, protos, num);
|
2011-04-20 07:15:33 -07:00
|
|
|
|
2011-03-30 03:10:04 -07:00
|
|
|
if (!ee->engine.x.netwm_sync_counter)
|
2011-11-14 10:48:19 -08:00
|
|
|
ee->engine.x.netwm_sync_counter = ecore_x_sync_counter_new(0);
|
2011-07-26 04:24:10 -07:00
|
|
|
|
|
|
|
tmp = ee->engine.x.netwm_sync_counter;
|
|
|
|
ecore_x_window_prop_card32_set(ee->prop.window,
|
|
|
|
ECORE_X_ATOM_NET_WM_SYNC_REQUEST_COUNTER,
|
|
|
|
&tmp, 1);
|
2010-01-29 02:28:54 -08:00
|
|
|
}
|
|
|
|
|
2010-01-30 02:42:22 -08:00
|
|
|
static void
|
|
|
|
_ecore_evas_x_sync_set(Ecore_Evas *ee)
|
|
|
|
{
|
2012-07-03 00:44:17 -07:00
|
|
|
Ecore_X_Sync_Counter sync_counter = ee->engine.x.sync_counter;
|
|
|
|
|
2010-10-10 23:28:01 -07:00
|
|
|
if (((ee->should_be_visible) || (ee->visible)) &&
|
|
|
|
((ecore_x_e_comp_sync_supported_get(ee->engine.x.win_root)) &&
|
|
|
|
(!ee->no_comp_sync) && (_ecore_evas_app_comp_sync)))
|
2010-02-01 06:13:48 -08:00
|
|
|
{
|
|
|
|
if (!ee->engine.x.sync_counter)
|
2010-10-01 18:56:23 -07:00
|
|
|
ee->engine.x.sync_counter = ecore_x_sync_counter_new(0);
|
2010-02-01 06:13:48 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (ee->engine.x.sync_counter)
|
2012-07-03 00:44:17 -07:00
|
|
|
{
|
2010-10-01 18:56:23 -07:00
|
|
|
ecore_x_sync_counter_free(ee->engine.x.sync_counter);
|
2012-07-03 00:44:17 -07:00
|
|
|
ee->engine.x.sync_val = 0;
|
|
|
|
}
|
2010-02-01 06:13:48 -08:00
|
|
|
ee->engine.x.sync_counter = 0;
|
|
|
|
}
|
2012-07-03 00:44:17 -07:00
|
|
|
if (sync_counter != ee->engine.x.sync_counter)
|
2010-01-30 02:42:22 -08:00
|
|
|
ecore_x_e_comp_sync_counter_set(ee->prop.window, ee->engine.x.sync_counter);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_ecore_evas_x_sync_clear(Ecore_Evas *ee)
|
|
|
|
{
|
|
|
|
if (!ee->engine.x.sync_counter) return;
|
|
|
|
ecore_x_sync_counter_free(ee->engine.x.sync_counter);
|
2012-07-03 00:44:17 -07:00
|
|
|
ee->engine.x.sync_val = 0;
|
2010-01-30 02:42:22 -08:00
|
|
|
ee->engine.x.sync_counter = 0;
|
|
|
|
}
|
|
|
|
|
2011-07-26 04:24:10 -07:00
|
|
|
# ifdef BUILD_ECORE_EVAS_OPENGL_X11
|
2006-03-08 00:02:55 -08:00
|
|
|
static Ecore_X_Window
|
2010-02-28 20:44:36 -08:00
|
|
|
_ecore_evas_x_gl_window_new(Ecore_Evas *ee, Ecore_X_Window parent, int x, int y, int w, int h, int override, int argb, const int *opt)
|
2006-03-08 00:02:55 -08:00
|
|
|
{
|
|
|
|
Evas_Engine_Info_GL_X11 *einfo;
|
|
|
|
Ecore_X_Window win;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2006-03-08 00:02:55 -08:00
|
|
|
einfo = (Evas_Engine_Info_GL_X11 *)evas_engine_info_get(ee->evas);
|
|
|
|
if (einfo)
|
|
|
|
{
|
2010-09-29 10:03:38 -07:00
|
|
|
int screen;
|
2006-03-08 00:02:55 -08:00
|
|
|
|
2010-02-14 21:05:05 -08:00
|
|
|
if (opt)
|
|
|
|
{
|
|
|
|
int op;
|
2011-04-20 07:15:33 -07:00
|
|
|
|
2010-02-14 21:05:05 -08:00
|
|
|
for (op = 0; opt[op]; op++)
|
|
|
|
{
|
|
|
|
if (opt[op] == ECORE_EVAS_GL_X11_OPT_INDIRECT)
|
|
|
|
{
|
|
|
|
op++;
|
|
|
|
einfo->indirect = opt[op];
|
|
|
|
}
|
2010-12-26 02:17:31 -08:00
|
|
|
else if (opt[op] == ECORE_EVAS_GL_X11_OPT_VSYNC)
|
|
|
|
{
|
|
|
|
op++;
|
|
|
|
einfo->vsync = opt[op];
|
|
|
|
}
|
2012-09-26 23:57:16 -07:00
|
|
|
#ifdef EVAS_ENGINE_GL_X11_SWAP_MODE_EXISTS
|
2012-09-27 00:00:28 -07:00
|
|
|
else if (opt[op] == ECORE_EVAS_GL_X11_OPT_SWAP_MODE)
|
2012-09-26 23:57:16 -07:00
|
|
|
{
|
|
|
|
op++;
|
|
|
|
if ((evas_version->major >= 1) &&
|
|
|
|
(evas_version->minor >= 7) &&
|
2012-09-27 00:13:15 -07:00
|
|
|
(evas_version->micro >= 99))
|
2012-09-27 00:00:28 -07:00
|
|
|
einfo->swap_mode = opt[op];
|
2012-09-26 23:57:16 -07:00
|
|
|
}
|
|
|
|
#endif
|
2010-02-14 21:05:05 -08:00
|
|
|
}
|
|
|
|
}
|
2011-04-20 07:15:33 -07:00
|
|
|
|
2010-09-29 10:03:38 -07:00
|
|
|
/* FIXME: this is inefficient as its 1 or more round trips */
|
2011-07-26 04:24:10 -07:00
|
|
|
screen = ecore_x_screen_index_get(ecore_x_default_screen_get());
|
|
|
|
if (ecore_x_screen_count_get() > 1)
|
2010-09-29 10:03:38 -07:00
|
|
|
{
|
|
|
|
Ecore_X_Window *roots;
|
|
|
|
int num, i;
|
|
|
|
|
|
|
|
num = 0;
|
|
|
|
roots = ecore_x_window_root_list(&num);
|
|
|
|
if (roots)
|
|
|
|
{
|
2011-07-26 04:24:10 -07:00
|
|
|
Ecore_X_Window root;
|
2010-09-29 10:03:38 -07:00
|
|
|
|
2011-07-26 04:24:10 -07:00
|
|
|
root = ecore_x_window_root_get(parent);
|
2011-09-21 23:02:26 -07:00
|
|
|
for (i = 0; i < num; i++)
|
2010-09-29 10:03:38 -07:00
|
|
|
{
|
2011-09-21 23:02:26 -07:00
|
|
|
if (root == roots[i])
|
2010-09-29 10:03:38 -07:00
|
|
|
{
|
2011-07-26 04:24:10 -07:00
|
|
|
screen = i;
|
|
|
|
break;
|
2010-09-29 10:03:38 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
free(roots);
|
|
|
|
}
|
|
|
|
}
|
2011-07-26 04:24:10 -07:00
|
|
|
|
|
|
|
einfo->info.display = ecore_x_display_get();
|
|
|
|
einfo->info.screen = screen;
|
2011-04-20 07:15:33 -07:00
|
|
|
|
2010-02-28 20:44:36 -08:00
|
|
|
einfo->info.destination_alpha = argb;
|
2011-04-20 07:15:33 -07:00
|
|
|
|
2011-07-26 04:24:10 -07:00
|
|
|
einfo->info.visual = einfo->func.best_visual_get(einfo);
|
2010-09-29 10:03:38 -07:00
|
|
|
einfo->info.colormap = einfo->func.best_colormap_get(einfo);
|
2011-07-26 04:24:10 -07:00
|
|
|
einfo->info.depth = einfo->func.best_depth_get(einfo);
|
2010-02-14 21:26:42 -08:00
|
|
|
|
2011-09-21 23:02:26 -07:00
|
|
|
if ((!einfo->info.visual) ||
|
2011-07-26 04:24:10 -07:00
|
|
|
(!einfo->info.colormap) || (!einfo->info.depth))
|
2010-02-14 21:26:42 -08:00
|
|
|
{
|
2010-05-17 20:50:17 -07:00
|
|
|
WRN("OpenGL X11 init engine '%s' failed - no visual, colormap or depth.", ee->driver);
|
2010-09-16 23:14:08 -07:00
|
|
|
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
|
|
|
|
{
|
2010-09-29 09:45:49 -07:00
|
|
|
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
|
2010-09-16 23:14:08 -07:00
|
|
|
return 0;
|
|
|
|
}
|
2010-02-14 21:26:42 -08:00
|
|
|
}
|
2011-04-20 07:15:33 -07:00
|
|
|
|
2011-09-21 23:02:26 -07:00
|
|
|
if (argb)
|
2011-07-26 04:24:10 -07:00
|
|
|
{
|
|
|
|
if (override)
|
|
|
|
win = ecore_x_window_override_argb_new(parent, x, y, w, h);
|
|
|
|
else
|
|
|
|
win = ecore_x_window_argb_new(parent, x, y, w, h);
|
|
|
|
}
|
2011-09-21 23:02:26 -07:00
|
|
|
else
|
2011-07-26 04:24:10 -07:00
|
|
|
{
|
|
|
|
if (override)
|
|
|
|
win = ecore_x_window_override_new(parent, x, y, w, h);
|
|
|
|
else
|
|
|
|
win = ecore_x_window_new(parent, x, y, w, h);
|
|
|
|
}
|
|
|
|
|
|
|
|
ecore_x_window_pixel_gravity_set(win, ECORE_X_GRAVITY_FORGET);
|
|
|
|
|
|
|
|
/* attr.backing_store = NotUseful; */
|
|
|
|
/* attr.override_redirect = override; */
|
|
|
|
/* attr.colormap = einfo->info.colormap; */
|
|
|
|
/* attr.border_pixel = 0; */
|
|
|
|
/* attr.background_pixmap = None; */
|
|
|
|
/* attr.event_mask = */
|
|
|
|
/* KeyPressMask | KeyReleaseMask | */
|
|
|
|
/* ExposureMask | ButtonPressMask | ButtonReleaseMask | */
|
|
|
|
/* EnterWindowMask | LeaveWindowMask | */
|
|
|
|
/* PointerMotionMask | StructureNotifyMask | VisibilityChangeMask | */
|
|
|
|
/* FocusChangeMask | PropertyChangeMask | ColormapChangeMask; */
|
|
|
|
/* attr.bit_gravity = ForgetGravity; */
|
|
|
|
|
|
|
|
/* win = */
|
|
|
|
/* XCreateWindow(einfo->info.display, parent, x, y, w, h, 0, */
|
|
|
|
/* einfo->info.depth, InputOutput, einfo->info.visual, */
|
|
|
|
/* CWBackingStore | CWColormap | CWBackPixmap | */
|
|
|
|
/* CWBorderPixel | CWBitGravity | CWEventMask | */
|
|
|
|
/* CWOverrideRedirect, &attr); */
|
|
|
|
|
2010-09-29 10:03:38 -07:00
|
|
|
einfo->info.drawable = win;
|
2010-09-29 09:45:49 -07:00
|
|
|
|
|
|
|
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
|
2010-05-17 20:50:17 -07:00
|
|
|
{
|
2010-09-29 09:45:49 -07:00
|
|
|
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
|
2011-07-26 04:24:10 -07:00
|
|
|
ecore_x_window_free(win);
|
2010-05-17 20:50:17 -07:00
|
|
|
return 0;
|
|
|
|
}
|
2006-08-10 19:26:16 -07:00
|
|
|
}
|
2011-07-26 04:24:10 -07:00
|
|
|
else
|
|
|
|
win = 0;
|
|
|
|
|
2006-03-08 00:02:55 -08:00
|
|
|
return win;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2009-02-27 23:54:47 -08:00
|
|
|
static int
|
2005-07-06 20:31:34 -07:00
|
|
|
_ecore_evas_x_render(Ecore_Evas *ee)
|
|
|
|
{
|
2009-02-27 23:54:47 -08:00
|
|
|
int rend = 0;
|
2011-09-21 19:39:23 -07:00
|
|
|
Eina_List *updates = NULL;
|
2008-10-21 08:54:55 -07:00
|
|
|
Eina_List *ll;
|
|
|
|
Ecore_Evas *ee2;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2010-02-01 06:13:48 -08:00
|
|
|
if ((!ee->no_comp_sync) && (_ecore_evas_app_comp_sync) &&
|
|
|
|
(ee->engine.x.sync_counter) && (!ee->engine.x.sync_began) &&
|
|
|
|
(!ee->engine.x.sync_cancel))
|
|
|
|
return 0;
|
2011-04-20 07:15:33 -07:00
|
|
|
|
2008-10-21 08:54:55 -07:00
|
|
|
EINA_LIST_FOREACH(ee->sub_ecore_evas, ll, ee2)
|
2005-07-06 20:31:34 -07:00
|
|
|
{
|
2010-09-29 10:03:38 -07:00
|
|
|
if (ee2->func.fn_pre_render) ee2->func.fn_pre_render(ee2);
|
2011-10-05 15:52:41 -07:00
|
|
|
if (ee2->engine.func->fn_render)
|
|
|
|
rend |= ee2->engine.func->fn_render(ee2);
|
2010-09-29 10:03:38 -07:00
|
|
|
if (ee2->func.fn_post_render) ee2->func.fn_post_render(ee2);
|
2005-07-06 20:31:34 -07:00
|
|
|
}
|
2011-09-21 19:39:23 -07:00
|
|
|
|
2005-07-11 20:31:21 -07:00
|
|
|
if (ee->func.fn_pre_render) ee->func.fn_pre_render(ee);
|
2011-09-21 19:39:23 -07:00
|
|
|
updates = evas_render_updates(ee->evas);
|
2011-09-21 23:02:26 -07:00
|
|
|
if (ee->prop.avoid_damage)
|
2005-07-06 20:31:34 -07:00
|
|
|
{
|
2011-09-21 23:02:26 -07:00
|
|
|
if (ee->engine.x.using_bg_pixmap)
|
2010-09-29 10:03:38 -07:00
|
|
|
{
|
2011-09-21 23:02:26 -07:00
|
|
|
if (updates)
|
2010-09-29 10:03:38 -07:00
|
|
|
{
|
2011-09-21 19:39:23 -07:00
|
|
|
Eina_List *l = NULL;
|
|
|
|
Eina_Rectangle *r;
|
|
|
|
|
2010-09-29 10:03:38 -07:00
|
|
|
EINA_LIST_FOREACH(updates, l, r)
|
2011-09-21 23:02:26 -07:00
|
|
|
ecore_x_window_area_clear(ee->prop.window,
|
2011-09-21 19:39:23 -07:00
|
|
|
r->x, r->y, r->w, r->h);
|
2011-09-21 23:02:26 -07:00
|
|
|
if (ee->shaped)
|
2010-05-21 00:10:45 -07:00
|
|
|
{
|
2011-09-21 23:02:26 -07:00
|
|
|
ecore_x_window_shape_mask_set(ee->prop.window,
|
2011-09-21 19:39:23 -07:00
|
|
|
ee->engine.x.mask);
|
2010-05-21 00:10:45 -07:00
|
|
|
}
|
2011-09-21 19:39:23 -07:00
|
|
|
if (ee->alpha)
|
2010-05-21 00:10:45 -07:00
|
|
|
{
|
|
|
|
// ecore_x_window_shape_input_mask_set(ee->prop.window, ee->engine.x.mask);
|
|
|
|
}
|
2010-09-29 10:03:38 -07:00
|
|
|
_ecore_evas_idle_timeout_update(ee);
|
2009-02-27 23:54:47 -08:00
|
|
|
rend = 1;
|
2010-09-29 10:03:38 -07:00
|
|
|
}
|
|
|
|
}
|
2011-09-21 23:02:26 -07:00
|
|
|
else
|
2010-09-29 10:03:38 -07:00
|
|
|
{
|
2011-09-21 23:02:26 -07:00
|
|
|
if (updates)
|
2010-09-29 10:03:38 -07:00
|
|
|
{
|
2011-09-21 19:39:23 -07:00
|
|
|
Eina_List *l = NULL;
|
|
|
|
Eina_Rectangle *r;
|
2010-09-29 10:03:38 -07:00
|
|
|
|
2011-09-21 19:39:23 -07:00
|
|
|
EINA_LIST_FOREACH(updates, l, r)
|
2010-09-29 10:03:38 -07:00
|
|
|
{
|
2011-09-21 19:39:23 -07:00
|
|
|
Ecore_X_Rectangle rect;
|
|
|
|
Ecore_X_XRegion *tmpr;
|
|
|
|
|
|
|
|
if (!ee->engine.x.damages)
|
|
|
|
ee->engine.x.damages = ecore_x_xregion_new();
|
|
|
|
tmpr = ecore_x_xregion_new();
|
|
|
|
if (ee->rotation == 0)
|
|
|
|
{
|
|
|
|
rect.x = r->x;
|
|
|
|
rect.y = r->y;
|
|
|
|
rect.width = r->w;
|
|
|
|
rect.height = r->h;
|
|
|
|
}
|
|
|
|
else if (ee->rotation == 90)
|
|
|
|
{
|
|
|
|
rect.x = r->y;
|
|
|
|
rect.y = ee->h - r->x - r->w;
|
|
|
|
rect.width = r->h;
|
|
|
|
rect.height = r->w;
|
|
|
|
}
|
|
|
|
else if (ee->rotation == 180)
|
|
|
|
{
|
|
|
|
rect.x = ee->w - r->x - r->w;
|
|
|
|
rect.y = ee->h - r->y - r->h;
|
|
|
|
rect.width = r->w;
|
|
|
|
rect.height = r->h;
|
|
|
|
}
|
|
|
|
else if (ee->rotation == 270)
|
|
|
|
{
|
|
|
|
rect.x = ee->w - r->y - r->h;
|
|
|
|
rect.y = r->x;
|
|
|
|
rect.width = r->h;
|
|
|
|
rect.height = r->w;
|
|
|
|
}
|
2011-09-21 23:02:26 -07:00
|
|
|
ecore_x_xregion_union_rect(tmpr, ee->engine.x.damages,
|
2011-09-21 19:39:23 -07:00
|
|
|
&rect);
|
|
|
|
ecore_x_xregion_free(ee->engine.x.damages);
|
|
|
|
ee->engine.x.damages = tmpr;
|
2010-09-29 10:03:38 -07:00
|
|
|
}
|
2011-09-21 23:02:26 -07:00
|
|
|
if (ee->engine.x.damages)
|
2010-09-29 10:03:38 -07:00
|
|
|
{
|
2011-09-21 19:39:23 -07:00
|
|
|
if (ee->shaped)
|
2012-08-10 01:41:10 -07:00
|
|
|
{
|
2012-08-10 01:45:28 -07:00
|
|
|
|
2012-08-10 01:41:10 -07:00
|
|
|
/* if we have a damage pixmap - we can avoid exposures by
|
|
|
|
* disabling them just for setting the mask */
|
2012-08-10 01:45:28 -07:00
|
|
|
ecore_x_event_mask_unset(ee->prop.window, ECORE_X_EVENT_MASK_WINDOW_DAMAGE);
|
2012-08-10 01:41:10 -07:00
|
|
|
ecore_x_window_shape_mask_set(ee->prop.window,
|
|
|
|
ee->engine.x.mask);
|
|
|
|
/* and re-enable them again */
|
2012-08-10 01:45:28 -07:00
|
|
|
ecore_x_event_mask_set(ee->prop.window, ECORE_X_EVENT_MASK_WINDOW_DAMAGE);
|
2012-08-10 01:41:10 -07:00
|
|
|
}
|
2011-09-21 19:39:23 -07:00
|
|
|
ecore_x_xregion_set(ee->engine.x.damages, ee->engine.x.gc);
|
2011-09-21 23:02:26 -07:00
|
|
|
ecore_x_pixmap_paste(ee->engine.x.pmap, ee->prop.window,
|
|
|
|
ee->engine.x.gc, 0, 0, ee->w, ee->h,
|
2011-09-21 19:39:23 -07:00
|
|
|
0, 0);
|
|
|
|
ecore_x_xregion_free(ee->engine.x.damages);
|
|
|
|
ee->engine.x.damages = NULL;
|
2010-09-29 10:03:38 -07:00
|
|
|
}
|
|
|
|
_ecore_evas_idle_timeout_update(ee);
|
2009-02-27 23:54:47 -08:00
|
|
|
rend = 1;
|
2010-09-29 10:03:38 -07:00
|
|
|
}
|
|
|
|
}
|
2005-07-06 20:31:34 -07:00
|
|
|
}
|
2011-09-21 23:02:26 -07:00
|
|
|
else if (((ee->visible) && (ee->draw_ok)) ||
|
|
|
|
((ee->should_be_visible) && (ee->prop.fullscreen)) ||
|
|
|
|
((ee->should_be_visible) && (ee->prop.override)))
|
2005-07-06 20:31:34 -07:00
|
|
|
{
|
2011-09-21 23:02:26 -07:00
|
|
|
if (updates)
|
2010-02-14 23:23:58 -08:00
|
|
|
{
|
2011-09-21 23:02:26 -07:00
|
|
|
if (ee->shaped)
|
2010-05-21 00:10:45 -07:00
|
|
|
{
|
2011-09-21 23:02:26 -07:00
|
|
|
ecore_x_window_shape_mask_set(ee->prop.window,
|
2011-09-21 19:39:23 -07:00
|
|
|
ee->engine.x.mask);
|
2010-05-21 00:10:45 -07:00
|
|
|
}
|
|
|
|
if (ee->alpha)
|
|
|
|
{
|
|
|
|
// ecore_x_window_shape_input_mask_set(ee->prop.window, ee->engine.x.mask);
|
|
|
|
}
|
2010-02-14 23:23:58 -08:00
|
|
|
_ecore_evas_idle_timeout_update(ee);
|
|
|
|
rend = 1;
|
|
|
|
}
|
2005-07-06 20:31:34 -07:00
|
|
|
}
|
2007-01-16 02:17:46 -08:00
|
|
|
else
|
|
|
|
evas_norender(ee->evas);
|
2012-08-28 22:18:27 -07:00
|
|
|
evas_render_updates_free(updates);
|
|
|
|
|
2005-07-06 20:31:34 -07:00
|
|
|
if (ee->func.fn_post_render) ee->func.fn_post_render(ee);
|
2011-04-20 07:15:33 -07:00
|
|
|
/*
|
2010-02-01 06:13:48 -08:00
|
|
|
if (rend)
|
|
|
|
{
|
|
|
|
static int frames = 0;
|
|
|
|
static double t0 = 0.0;
|
|
|
|
double t, td;
|
2011-04-20 07:15:33 -07:00
|
|
|
|
2010-02-01 06:13:48 -08:00
|
|
|
t = ecore_time_get();
|
|
|
|
frames++;
|
|
|
|
if ((t - t0) > 1.0)
|
|
|
|
{
|
|
|
|
td = t - t0;
|
|
|
|
printf("FPS: %3.3f\n", (double)frames / td);
|
|
|
|
frames = 0;
|
|
|
|
t0 = t;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
*/
|
2011-09-21 19:39:23 -07:00
|
|
|
|
2009-02-27 23:54:47 -08:00
|
|
|
return rend;
|
2005-07-06 20:31:34 -07:00
|
|
|
}
|
|
|
|
|
2005-05-03 10:35:50 -07:00
|
|
|
static void
|
|
|
|
_ecore_evas_x_resize_shape(Ecore_Evas *ee)
|
|
|
|
{
|
2009-03-21 13:32:02 -07:00
|
|
|
if (!strcmp(ee->driver, "software_x11"))
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
{
|
2009-07-14 14:18:27 -07:00
|
|
|
#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
|
2010-09-29 10:03:38 -07:00
|
|
|
Evas_Engine_Info_Software_X11 *einfo;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2010-09-29 10:03:38 -07:00
|
|
|
einfo = (Evas_Engine_Info_Software_X11 *)evas_engine_info_get(ee->evas);
|
|
|
|
if (einfo)
|
|
|
|
{
|
2011-07-25 02:29:09 -07:00
|
|
|
unsigned int foreground;
|
|
|
|
Ecore_X_GC gc;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2010-09-29 10:03:38 -07:00
|
|
|
if (ee->engine.x.mask) ecore_x_pixmap_free(ee->engine.x.mask);
|
|
|
|
ee->engine.x.mask = ecore_x_pixmap_new(ee->prop.window, ee->w, ee->h, 1);
|
2009-03-23 06:28:59 -07:00
|
|
|
foreground = 0;
|
|
|
|
gc = ecore_x_gc_new(ee->engine.x.mask,
|
|
|
|
ECORE_X_GC_VALUE_MASK_FOREGROUND,
|
|
|
|
&foreground);
|
2009-04-25 00:16:59 -07:00
|
|
|
ecore_x_drawable_rectangle_fill(ee->engine.x.mask, gc,
|
|
|
|
0, 0, ee->w, ee->h);
|
2009-05-07 01:35:00 -07:00
|
|
|
ecore_x_gc_free(gc);
|
2010-09-29 10:03:38 -07:00
|
|
|
einfo->info.mask = ee->engine.x.mask;
|
2010-05-17 20:50:17 -07:00
|
|
|
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
|
|
|
|
{
|
|
|
|
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
|
|
|
|
}
|
2010-09-29 10:03:38 -07:00
|
|
|
evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
|
|
|
|
}
|
2009-07-14 14:18:27 -07:00
|
|
|
#endif /* BUILD_ECORE_EVAS_SOFTWARE_X11 */
|
2006-03-08 00:02:55 -08:00
|
|
|
}
|
2010-07-27 17:17:40 -07:00
|
|
|
if (!strcmp(ee->driver, "software_8_x11"))
|
|
|
|
{
|
|
|
|
#if defined (BUILD_ECORE_EVAS_SOFTWARE_8_X11)
|
2010-09-29 10:03:38 -07:00
|
|
|
Evas_Engine_Info_Software_8_X11 *einfo;
|
2010-07-27 17:17:40 -07:00
|
|
|
|
2010-09-29 10:03:38 -07:00
|
|
|
einfo = (Evas_Engine_Info_Software_8_X11 *)evas_engine_info_get(ee->evas);
|
|
|
|
if (einfo)
|
|
|
|
{
|
2011-07-25 02:29:09 -07:00
|
|
|
unsigned int foreground;
|
|
|
|
Ecore_X_GC gc;
|
2010-07-27 17:17:40 -07:00
|
|
|
|
2010-09-29 10:03:38 -07:00
|
|
|
if (ee->engine.x.mask) ecore_x_pixmap_free(ee->engine.x.mask);
|
|
|
|
ee->engine.x.mask = ecore_x_pixmap_new(ee->prop.window, ee->w, ee->h, 1);
|
2010-07-27 17:17:40 -07:00
|
|
|
foreground = 0;
|
|
|
|
gc = ecore_x_gc_new(ee->engine.x.mask,
|
|
|
|
ECORE_X_GC_VALUE_MASK_FOREGROUND,
|
|
|
|
&foreground);
|
|
|
|
ecore_x_drawable_rectangle_fill(ee->engine.x.mask, gc,
|
|
|
|
0, 0, ee->w, ee->h);
|
|
|
|
ecore_x_gc_free(gc);
|
2010-09-29 10:03:38 -07:00
|
|
|
einfo->info.mask = ee->engine.x.mask;
|
2010-07-27 17:17:40 -07:00
|
|
|
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
|
|
|
|
{
|
|
|
|
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
|
|
|
|
}
|
2010-09-29 10:03:38 -07:00
|
|
|
evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
|
|
|
|
}
|
2010-07-27 17:17:40 -07:00
|
|
|
#endif /* BUILD_ECORE_EVAS_SOFTWARE_8_X11 */
|
|
|
|
}
|
2005-05-03 10:35:50 -07:00
|
|
|
}
|
|
|
|
|
2006-07-26 19:42:41 -07:00
|
|
|
/* TODO: we need to make this work for all the states, not just sticky */
|
2010-06-24 09:15:56 -07:00
|
|
|
static Eina_Bool
|
2006-07-26 19:42:41 -07:00
|
|
|
_ecore_evas_x_event_property_change(void *data __UNUSED__, int type __UNUSED__, void *event)
|
|
|
|
{
|
|
|
|
Ecore_Evas *ee;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
Ecore_X_Event_Window_Property *e;
|
2012-02-27 22:43:59 -08:00
|
|
|
int state_change = 0;
|
2006-07-26 19:42:41 -07:00
|
|
|
|
|
|
|
e = event;
|
2009-03-19 06:06:16 -07:00
|
|
|
ee = ecore_event_window_match(e->win);
|
2010-06-24 09:15:56 -07:00
|
|
|
if ((!ee) || (ee->ignore_events)) return ECORE_CALLBACK_PASS_ON; /* pass on event */
|
|
|
|
if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
|
2006-07-26 19:42:41 -07:00
|
|
|
if (e->atom == ECORE_X_ATOM_NET_WM_STATE)
|
|
|
|
{
|
2010-09-29 10:03:38 -07:00
|
|
|
unsigned int i, num;
|
|
|
|
Ecore_X_Window_State *state;
|
2012-02-28 02:46:38 -08:00
|
|
|
struct {
|
|
|
|
struct {
|
|
|
|
unsigned char modal : 1;
|
|
|
|
unsigned char sticky : 1;
|
|
|
|
unsigned char maximized_v : 1;
|
|
|
|
unsigned char maximized_h : 1;
|
|
|
|
unsigned char shaded : 1;
|
|
|
|
unsigned char skip_taskbar : 1;
|
|
|
|
unsigned char skip_pager : 1;
|
|
|
|
unsigned char fullscreen : 1;
|
|
|
|
unsigned char above : 1;
|
|
|
|
unsigned char below : 1;
|
|
|
|
} x;
|
|
|
|
struct {
|
|
|
|
char modal : 1;
|
|
|
|
char maximized : 1;
|
|
|
|
char sticky : 1;
|
|
|
|
char fullscreen : 1;
|
|
|
|
char focus_skip : 1;
|
|
|
|
} prop;
|
|
|
|
} prev;
|
|
|
|
|
|
|
|
prev.x.modal = ee->engine.x.state.modal;
|
|
|
|
prev.x.sticky = ee->engine.x.state.sticky;
|
|
|
|
prev.x.maximized_v = ee->engine.x.state.maximized_v;
|
|
|
|
prev.x.maximized_h = ee->engine.x.state.maximized_h;
|
|
|
|
prev.x.shaded = ee->engine.x.state.shaded;
|
|
|
|
prev.x.skip_taskbar = ee->engine.x.state.skip_taskbar;
|
|
|
|
prev.x.skip_pager = ee->engine.x.state.skip_pager;
|
|
|
|
prev.x.fullscreen = ee->engine.x.state.fullscreen;
|
|
|
|
prev.x.above = ee->engine.x.state.above;
|
|
|
|
prev.x.below = ee->engine.x.state.below;
|
|
|
|
|
|
|
|
prev.prop.modal = ee->prop.modal;
|
|
|
|
prev.prop.maximized = ee->prop.maximized;
|
|
|
|
prev.prop.sticky = ee->prop.sticky;
|
|
|
|
prev.prop.fullscreen = ee->prop.fullscreen;
|
|
|
|
prev.prop.focus_skip = ee->prop.focus_skip;
|
|
|
|
|
|
|
|
ee->engine.x.state.modal = 0;
|
|
|
|
ee->engine.x.state.sticky = 0;
|
|
|
|
ee->engine.x.state.maximized_v = 0;
|
|
|
|
ee->engine.x.state.maximized_h = 0;
|
|
|
|
ee->engine.x.state.shaded = 0;
|
2010-09-29 10:03:38 -07:00
|
|
|
ee->engine.x.state.skip_taskbar = 0;
|
2012-02-28 02:46:38 -08:00
|
|
|
ee->engine.x.state.skip_pager = 0;
|
|
|
|
ee->engine.x.state.fullscreen = 0;
|
|
|
|
ee->engine.x.state.above = 0;
|
|
|
|
ee->engine.x.state.below = 0;
|
|
|
|
|
|
|
|
ee->prop.modal = 0;
|
|
|
|
ee->prop.maximized = 0;
|
|
|
|
ee->prop.sticky = 0;
|
2010-09-29 10:03:38 -07:00
|
|
|
ee->prop.fullscreen = 0;
|
2012-02-28 02:46:38 -08:00
|
|
|
ee->prop.focus_skip = 0;
|
2012-02-27 22:43:59 -08:00
|
|
|
|
2010-09-29 10:03:38 -07:00
|
|
|
ecore_x_netwm_window_state_get(e->win, &state, &num);
|
|
|
|
if (state)
|
|
|
|
{
|
|
|
|
for (i = 0; i < num; i++)
|
|
|
|
{
|
|
|
|
switch (state[i])
|
|
|
|
{
|
|
|
|
case ECORE_X_WINDOW_STATE_MODAL:
|
2012-02-27 22:43:59 -08:00
|
|
|
ee->engine.x.state.modal = 1;
|
2012-02-28 02:46:38 -08:00
|
|
|
ee->prop.modal = 1;
|
2012-02-27 22:43:59 -08:00
|
|
|
break;
|
2010-09-29 10:03:38 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_STICKY:
|
2012-02-27 22:43:59 -08:00
|
|
|
ee->prop.sticky = 1;
|
|
|
|
ee->engine.x.state.sticky = 1;
|
|
|
|
break;
|
2010-09-29 10:03:38 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_MAXIMIZED_VERT:
|
2012-02-27 22:43:59 -08:00
|
|
|
ee->engine.x.state.maximized_v = 1;
|
2012-02-28 02:46:38 -08:00
|
|
|
ee->prop.maximized = 1;
|
2012-02-27 22:43:59 -08:00
|
|
|
break;
|
2010-09-29 10:03:38 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_MAXIMIZED_HORZ:
|
2012-02-27 22:43:59 -08:00
|
|
|
ee->engine.x.state.maximized_h = 1;
|
2012-02-28 02:46:38 -08:00
|
|
|
ee->prop.maximized = 1;
|
2012-02-27 22:43:59 -08:00
|
|
|
break;
|
2010-09-29 10:03:38 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_SHADED:
|
2012-02-27 22:43:59 -08:00
|
|
|
ee->engine.x.state.shaded = 1;
|
|
|
|
break;
|
2010-09-29 10:03:38 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_SKIP_TASKBAR:
|
2012-02-27 22:43:59 -08:00
|
|
|
ee->engine.x.state.skip_taskbar = 1;
|
2012-02-28 02:46:38 -08:00
|
|
|
ee->prop.focus_skip = 1;
|
2012-02-27 22:43:59 -08:00
|
|
|
break;
|
2010-09-29 10:03:38 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_SKIP_PAGER:
|
2012-02-27 22:43:59 -08:00
|
|
|
ee->engine.x.state.skip_pager = 1;
|
2012-02-28 02:46:38 -08:00
|
|
|
ee->prop.focus_skip = 1;
|
2012-02-27 22:43:59 -08:00
|
|
|
break;
|
2010-09-29 10:03:38 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_FULLSCREEN:
|
2012-02-27 22:43:59 -08:00
|
|
|
ee->prop.fullscreen = 1;
|
|
|
|
ee->engine.x.state.fullscreen = 1;
|
|
|
|
break;
|
2010-09-29 10:03:38 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_ABOVE:
|
2012-02-27 22:43:59 -08:00
|
|
|
ee->engine.x.state.above = 1;
|
|
|
|
break;
|
2010-09-29 10:03:38 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_BELOW:
|
2012-02-27 22:43:59 -08:00
|
|
|
ee->engine.x.state.below = 1;
|
|
|
|
break;
|
2010-09-29 10:03:38 -07:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free(state);
|
|
|
|
}
|
2012-02-28 02:46:38 -08:00
|
|
|
if (
|
|
|
|
// (prev.x.modal != ee->engine.x.state.modal) ||
|
|
|
|
(prev.x.sticky != ee->engine.x.state.sticky) ||
|
|
|
|
(prev.x.maximized_v != ee->engine.x.state.maximized_v) ||
|
|
|
|
(prev.x.maximized_h != ee->engine.x.state.maximized_h) ||
|
|
|
|
// (prev.x.shaded != ee->engine.x.state.shaded) ||
|
|
|
|
// (prev.x.skip_taskbar != ee->engine.x.state.skip_taskbar) ||
|
|
|
|
// (prev.x.skip_pager != ee->engine.x.state.skip_pager) ||
|
|
|
|
(prev.x.fullscreen != ee->engine.x.state.fullscreen) ||
|
|
|
|
// (prev.x.above != ee->engine.x.state.above) ||
|
|
|
|
// (prev.x.below != ee->engine.x.state.below) ||
|
|
|
|
// (prev.prop.modal != ee->prop.modal) ||
|
|
|
|
(prev.prop.maximized != ee->prop.maximized) ||
|
|
|
|
(prev.prop.sticky != ee->prop.sticky) ||
|
|
|
|
(prev.prop.fullscreen != ee->prop.fullscreen) ||
|
|
|
|
(prev.prop.focus_skip != ee->prop.focus_skip))
|
|
|
|
state_change = 1;
|
2012-02-27 22:43:59 -08:00
|
|
|
}
|
|
|
|
else if (e->atom == ECORE_X_ATOM_WM_STATE)
|
|
|
|
{
|
|
|
|
Ecore_X_Window_State_Hint state;
|
|
|
|
|
|
|
|
// handle WM_STATE changes
|
|
|
|
state = ecore_x_icccm_state_get(e->win);
|
|
|
|
switch (state)
|
2010-09-29 10:03:38 -07:00
|
|
|
{
|
2012-02-27 22:43:59 -08:00
|
|
|
case ECORE_X_WINDOW_STATE_HINT_WITHDRAWN:
|
2012-02-28 02:46:38 -08:00
|
|
|
if ((!ee->prop.withdrawn) || (ee->prop.iconified))
|
|
|
|
{
|
|
|
|
state_change = 1;
|
|
|
|
ee->prop.withdrawn = 1;
|
|
|
|
ee->prop.iconified = 0;
|
|
|
|
}
|
|
|
|
break;
|
2012-02-27 22:43:59 -08:00
|
|
|
case ECORE_X_WINDOW_STATE_HINT_ICONIC:
|
2012-02-28 02:46:38 -08:00
|
|
|
if ((!ee->prop.iconified) || (ee->prop.withdrawn))
|
2012-02-27 22:43:59 -08:00
|
|
|
{
|
|
|
|
state_change = 1;
|
|
|
|
ee->prop.iconified = 1;
|
2012-02-28 02:46:38 -08:00
|
|
|
ee->prop.withdrawn = 0;
|
2012-02-27 22:43:59 -08:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ECORE_X_WINDOW_STATE_HINT_NORMAL:
|
2012-02-28 02:46:38 -08:00
|
|
|
if ((ee->prop.iconified) || (ee->prop.withdrawn))
|
2012-02-27 22:43:59 -08:00
|
|
|
{
|
|
|
|
state_change = 1;
|
|
|
|
ee->prop.iconified = 0;
|
2012-02-28 02:46:38 -08:00
|
|
|
ee->prop.withdrawn = 0;
|
2012-02-27 22:43:59 -08:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2010-09-29 10:03:38 -07:00
|
|
|
}
|
2006-07-27 09:14:33 -07:00
|
|
|
}
|
2012-07-03 00:44:17 -07:00
|
|
|
else if (e->atom == ECORE_X_ATOM_E_PROFILE)
|
|
|
|
{
|
|
|
|
char *p = ecore_x_e_window_profile_get(e->win);
|
|
|
|
if ((p) && (ee->prop.profile))
|
|
|
|
{
|
|
|
|
if (strcmp(p, ee->prop.profile) != 0)
|
|
|
|
{
|
|
|
|
free(ee->prop.profile);
|
|
|
|
ee->prop.profile = strdup(p);
|
|
|
|
state_change = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if ((!p) && (ee->prop.profile))
|
|
|
|
{
|
|
|
|
free(ee->prop.profile);
|
|
|
|
ee->prop.profile = NULL;
|
|
|
|
state_change = 1;
|
|
|
|
}
|
|
|
|
else if ((p) && (!ee->prop.profile))
|
|
|
|
{
|
|
|
|
ee->prop.profile = strdup(p);
|
|
|
|
state_change = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (p)
|
|
|
|
free(p);
|
|
|
|
}
|
|
|
|
|
2012-02-27 22:43:59 -08:00
|
|
|
if (state_change)
|
|
|
|
{
|
|
|
|
if (ee->func.fn_state_change) ee->func.fn_state_change(ee);
|
|
|
|
}
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2010-06-24 09:15:56 -07:00
|
|
|
return ECORE_CALLBACK_PASS_ON;
|
2006-07-26 19:42:41 -07:00
|
|
|
}
|
|
|
|
|
2010-06-24 09:15:56 -07:00
|
|
|
static Eina_Bool
|
2007-09-27 08:31:00 -07:00
|
|
|
_ecore_evas_x_event_visibility_change(void *data __UNUSED__, int type __UNUSED__, void *event)
|
|
|
|
{
|
|
|
|
Ecore_Evas *ee;
|
|
|
|
Ecore_X_Event_Window_Visibility_Change *e;
|
|
|
|
|
|
|
|
e = event;
|
2009-03-19 06:06:16 -07:00
|
|
|
ee = ecore_event_window_match(e->win);
|
2010-06-24 09:15:56 -07:00
|
|
|
if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
|
|
|
|
if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
|
2007-09-27 08:31:00 -07:00
|
|
|
// printf("VIS CHANGE OBSCURED: %p %i\n", ee, e->fully_obscured);
|
2009-09-02 05:48:56 -07:00
|
|
|
if (e->fully_obscured)
|
|
|
|
{
|
|
|
|
/* FIXME: round trip */
|
|
|
|
if (!ecore_x_screen_is_composited(ee->engine.x.screen_num))
|
|
|
|
ee->draw_ok = 0;
|
|
|
|
}
|
2011-09-21 23:02:26 -07:00
|
|
|
else
|
2011-07-26 04:24:10 -07:00
|
|
|
ee->draw_ok = 1;
|
2010-06-24 09:15:56 -07:00
|
|
|
return ECORE_CALLBACK_PASS_ON;
|
2007-09-27 08:31:00 -07:00
|
|
|
}
|
|
|
|
|
2010-06-24 09:15:56 -07:00
|
|
|
static Eina_Bool
|
2010-02-01 06:13:48 -08:00
|
|
|
_ecore_evas_x_event_client_message(void *data __UNUSED__, int type __UNUSED__, void *event)
|
|
|
|
{
|
|
|
|
Ecore_Evas *ee;
|
|
|
|
Ecore_X_Event_Client_Message *e;
|
|
|
|
|
|
|
|
e = event;
|
2010-06-24 09:15:56 -07:00
|
|
|
if (e->format != 32) return ECORE_CALLBACK_PASS_ON;
|
2010-02-01 06:13:48 -08:00
|
|
|
if (e->message_type == ECORE_X_ATOM_E_COMP_SYNC_BEGIN)
|
|
|
|
{
|
|
|
|
ee = ecore_event_window_match(e->data.l[0]);
|
2010-06-24 09:15:56 -07:00
|
|
|
if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
|
2011-09-21 23:02:26 -07:00
|
|
|
if (e->data.l[0] != (long)ee->prop.window)
|
2011-07-26 04:24:10 -07:00
|
|
|
return ECORE_CALLBACK_PASS_ON;
|
2010-08-24 02:26:34 -07:00
|
|
|
if (!ee->engine.x.sync_began)
|
|
|
|
{
|
|
|
|
// qeue a damage + draw. work around an event re-ordering thing.
|
2010-09-29 10:03:38 -07:00
|
|
|
evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
|
2010-08-24 02:26:34 -07:00
|
|
|
}
|
2010-02-01 06:13:48 -08:00
|
|
|
ee->engine.x.sync_began = 1;
|
|
|
|
ee->engine.x.sync_cancel = 0;
|
|
|
|
}
|
|
|
|
else if (e->message_type == ECORE_X_ATOM_E_COMP_SYNC_END)
|
|
|
|
{
|
|
|
|
ee = ecore_event_window_match(e->data.l[0]);
|
2010-06-24 09:15:56 -07:00
|
|
|
if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
|
2011-09-21 23:02:26 -07:00
|
|
|
if (e->data.l[0] != (long)ee->prop.window)
|
2011-07-26 04:24:10 -07:00
|
|
|
return ECORE_CALLBACK_PASS_ON;
|
2010-02-01 06:13:48 -08:00
|
|
|
ee->engine.x.sync_began = 0;
|
|
|
|
ee->engine.x.sync_cancel = 0;
|
|
|
|
}
|
|
|
|
else if (e->message_type == ECORE_X_ATOM_E_COMP_SYNC_CANCEL)
|
|
|
|
{
|
|
|
|
ee = ecore_event_window_match(e->data.l[0]);
|
2010-06-24 09:15:56 -07:00
|
|
|
if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
|
2011-09-21 23:02:26 -07:00
|
|
|
if (e->data.l[0] != (long)ee->prop.window)
|
2011-07-26 04:24:10 -07:00
|
|
|
return ECORE_CALLBACK_PASS_ON;
|
2010-02-01 06:13:48 -08:00
|
|
|
ee->engine.x.sync_began = 0;
|
|
|
|
ee->engine.x.sync_cancel = 1;
|
|
|
|
}
|
2011-03-30 03:10:04 -07:00
|
|
|
else if ((e->message_type == ECORE_X_ATOM_WM_PROTOCOLS) &&
|
|
|
|
(e->data.l[0] == (int)ECORE_X_ATOM_NET_WM_SYNC_REQUEST))
|
|
|
|
{
|
|
|
|
ee = ecore_event_window_match(e->win);
|
|
|
|
if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
|
|
|
|
ee->engine.x.netwm_sync_val_lo = (unsigned int)e->data.l[2];
|
|
|
|
ee->engine.x.netwm_sync_val_hi = (int)e->data.l[3];
|
|
|
|
ee->engine.x.netwm_sync_set = 1;
|
|
|
|
}
|
2010-06-24 09:15:56 -07:00
|
|
|
return ECORE_CALLBACK_PASS_ON;
|
2010-02-01 06:13:48 -08:00
|
|
|
}
|
|
|
|
|
2010-06-24 09:15:56 -07:00
|
|
|
static Eina_Bool
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_event_mouse_in(void *data __UNUSED__, int type __UNUSED__, void *event)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
Ecore_Evas *ee;
|
|
|
|
Ecore_X_Event_Mouse_In *e;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
e = event;
|
2010-10-19 06:56:17 -07:00
|
|
|
ee = ecore_event_window_match(e->win);
|
2010-06-24 09:15:56 -07:00
|
|
|
if ((!ee) || (ee->ignore_events)) return ECORE_CALLBACK_PASS_ON; /* pass on event */
|
|
|
|
if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
|
2009-03-16 09:24:43 -07:00
|
|
|
/* { */
|
|
|
|
/* time_t t; */
|
|
|
|
/* char *ct; */
|
|
|
|
|
|
|
|
/* const char *modes[] = { */
|
2010-09-29 10:03:38 -07:00
|
|
|
/* "MODE_NORMAL", */
|
|
|
|
/* "MODE_WHILE_GRABBED", */
|
|
|
|
/* "MODE_GRAB", */
|
|
|
|
/* "MODE_UNGRAB" */
|
2009-03-16 09:24:43 -07:00
|
|
|
/* }; */
|
|
|
|
/* const char *details[] = { */
|
2010-09-29 10:03:38 -07:00
|
|
|
/* "DETAIL_ANCESTOR", */
|
|
|
|
/* "DETAIL_VIRTUAL", */
|
|
|
|
/* "DETAIL_INFERIOR", */
|
|
|
|
/* "DETAIL_NON_LINEAR", */
|
|
|
|
/* "DETAIL_NON_LINEAR_VIRTUAL", */
|
|
|
|
/* "DETAIL_POINTER", */
|
|
|
|
/* "DETAIL_POINTER_ROOT", */
|
|
|
|
/* "DETAIL_DETAIL_NONE" */
|
2009-03-16 09:24:43 -07:00
|
|
|
/* }; */
|
|
|
|
/* t = time(NULL); */
|
|
|
|
/* ct = ctime(&t); */
|
|
|
|
/* ct[strlen(ct) - 1] = 0; */
|
|
|
|
/* printf("@@ ->IN 0x%x 0x%x %s md=%s dt=%s\n", */
|
2010-09-29 10:03:38 -07:00
|
|
|
/* e->win, e->event_win, */
|
|
|
|
/* ct, */
|
|
|
|
/* modes[e->mode], */
|
|
|
|
/* details[e->detail]); */
|
2009-03-16 09:24:43 -07:00
|
|
|
/* } */
|
2010-09-08 04:23:42 -07:00
|
|
|
// disable. causes more problems than it fixes
|
2009-03-16 09:24:43 -07:00
|
|
|
// if ((e->mode == ECORE_X_EVENT_MODE_GRAB) ||
|
|
|
|
// (e->mode == ECORE_X_EVENT_MODE_UNGRAB))
|
|
|
|
// return 0;
|
|
|
|
/* if (e->mode != ECORE_X_EVENT_MODE_NORMAL) return 0; */
|
2011-12-27 04:02:18 -08:00
|
|
|
if (!ee->in)
|
|
|
|
{
|
|
|
|
if (ee->func.fn_mouse_in) ee->func.fn_mouse_in(ee);
|
|
|
|
ecore_event_evas_modifier_lock_update(ee->evas, e->modifiers);
|
|
|
|
evas_event_feed_mouse_in(ee->evas, e->time, NULL);
|
|
|
|
_ecore_evas_mouse_move_process(ee, e->x, e->y, e->time);
|
|
|
|
ee->in = EINA_TRUE;
|
|
|
|
}
|
2010-06-24 09:15:56 -07:00
|
|
|
return ECORE_CALLBACK_PASS_ON;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
2010-06-24 09:15:56 -07:00
|
|
|
static Eina_Bool
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_event_mouse_out(void *data __UNUSED__, int type __UNUSED__, void *event)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
Ecore_Evas *ee;
|
|
|
|
Ecore_X_Event_Mouse_Out *e;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
e = event;
|
2010-10-19 06:56:17 -07:00
|
|
|
ee = ecore_event_window_match(e->win);
|
2010-06-24 09:15:56 -07:00
|
|
|
if ((!ee) || (ee->ignore_events)) return ECORE_CALLBACK_PASS_ON;
|
2009-03-16 09:24:43 -07:00
|
|
|
/* pass on event */
|
2010-06-24 09:15:56 -07:00
|
|
|
if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
|
2009-03-16 09:24:43 -07:00
|
|
|
/* { */
|
|
|
|
/* time_t t; */
|
|
|
|
/* char *ct; */
|
|
|
|
|
|
|
|
/* const char *modes[] = { */
|
2010-09-29 10:03:38 -07:00
|
|
|
/* "MODE_NORMAL", */
|
|
|
|
/* "MODE_WHILE_GRABBED", */
|
|
|
|
/* "MODE_GRAB", */
|
|
|
|
/* "MODE_UNGRAB" */
|
2009-03-16 09:24:43 -07:00
|
|
|
/* }; */
|
|
|
|
/* const char *details[] = { */
|
2010-09-29 10:03:38 -07:00
|
|
|
/* "DETAIL_ANCESTOR", */
|
|
|
|
/* "DETAIL_VIRTUAL", */
|
|
|
|
/* "DETAIL_INFERIOR", */
|
|
|
|
/* "DETAIL_NON_LINEAR", */
|
|
|
|
/* "DETAIL_NON_LINEAR_VIRTUAL", */
|
|
|
|
/* "DETAIL_POINTER", */
|
|
|
|
/* "DETAIL_POINTER_ROOT", */
|
|
|
|
/* "DETAIL_DETAIL_NONE" */
|
2009-03-16 09:24:43 -07:00
|
|
|
/* }; */
|
|
|
|
/* t = time(NULL); */
|
|
|
|
/* ct = ctime(&t); */
|
|
|
|
/* ct[strlen(ct) - 1] = 0; */
|
|
|
|
/* printf("@@ ->OUT 0x%x 0x%x %s md=%s dt=%s\n", */
|
2010-09-29 10:03:38 -07:00
|
|
|
/* e->win, e->event_win, */
|
|
|
|
/* ct, */
|
|
|
|
/* modes[e->mode], */
|
|
|
|
/* details[e->detail]); */
|
2009-03-16 09:24:43 -07:00
|
|
|
/* } */
|
|
|
|
// disable. causes more problems than it fixes
|
|
|
|
// if ((e->mode == ECORE_X_EVENT_MODE_GRAB) ||
|
|
|
|
// (e->mode == ECORE_X_EVENT_MODE_UNGRAB))
|
|
|
|
// return 0;
|
|
|
|
/* if (e->mode != ECORE_X_EVENT_MODE_NORMAL) return 0; */
|
2011-12-27 19:07:39 -08:00
|
|
|
// printf("OUT: ee->in=%i, e->mode=%i, e->detail=%i, dount_count=%i\n",
|
|
|
|
// ee->in, e->mode, e->detail, evas_event_down_count_get(ee->evas));
|
2011-12-27 04:02:18 -08:00
|
|
|
if (ee->in)
|
|
|
|
{
|
2011-12-27 19:07:39 -08:00
|
|
|
if ((evas_event_down_count_get(ee->evas) > 0) &&
|
|
|
|
(!((e->mode == ECORE_X_EVENT_MODE_GRAB) &&
|
|
|
|
(e->detail == ECORE_X_EVENT_DETAIL_NON_LINEAR))))
|
2011-12-27 04:02:18 -08:00
|
|
|
return ECORE_CALLBACK_PASS_ON;
|
|
|
|
ecore_event_evas_modifier_lock_update(ee->evas, e->modifiers);
|
|
|
|
_ecore_evas_mouse_move_process(ee, e->x, e->y, e->time);
|
|
|
|
if (e->mode == ECORE_X_EVENT_MODE_GRAB)
|
|
|
|
evas_event_feed_mouse_cancel(ee->evas, e->time, NULL);
|
|
|
|
evas_event_feed_mouse_out(ee->evas, e->time, NULL);
|
|
|
|
if (ee->func.fn_mouse_out) ee->func.fn_mouse_out(ee);
|
|
|
|
if (ee->prop.cursor.object) evas_object_hide(ee->prop.cursor.object);
|
|
|
|
ee->in = EINA_FALSE;
|
|
|
|
}
|
2010-06-24 09:15:56 -07:00
|
|
|
return ECORE_CALLBACK_PASS_ON;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
2010-06-24 09:15:56 -07:00
|
|
|
static Eina_Bool
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_event_window_focus_in(void *data __UNUSED__, int type __UNUSED__, void *event)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
Ecore_Evas *ee;
|
|
|
|
Ecore_X_Event_Window_Focus_In *e;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
e = event;
|
2009-03-19 06:06:16 -07:00
|
|
|
ee = ecore_event_window_match(e->win);
|
2010-06-24 09:15:56 -07:00
|
|
|
if ((!ee) || (ee->ignore_events)) return ECORE_CALLBACK_PASS_ON; /* pass on event */
|
|
|
|
if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
|
2012-03-07 23:51:39 -08:00
|
|
|
//xx// filtering with these doesnt help
|
|
|
|
//xx// if (e->mode == ECORE_X_EVENT_MODE_UNGRAB) return ECORE_CALLBACK_PASS_ON;
|
2003-09-23 01:09:32 -07:00
|
|
|
ee->prop.focused = 1;
|
2010-02-01 06:13:48 -08:00
|
|
|
evas_focus_in(ee->evas);
|
2003-09-23 01:09:32 -07:00
|
|
|
if (ee->func.fn_focus_in) ee->func.fn_focus_in(ee);
|
2010-06-24 09:15:56 -07:00
|
|
|
return ECORE_CALLBACK_PASS_ON;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
2010-06-24 09:15:56 -07:00
|
|
|
static Eina_Bool
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_event_window_focus_out(void *data __UNUSED__, int type __UNUSED__, void *event)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
Ecore_Evas *ee;
|
|
|
|
Ecore_X_Event_Window_Focus_Out *e;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
e = event;
|
2009-03-19 06:06:16 -07:00
|
|
|
ee = ecore_event_window_match(e->win);
|
2010-06-24 09:15:56 -07:00
|
|
|
if ((!ee) || (ee->ignore_events)) return ECORE_CALLBACK_PASS_ON; /* pass on event */
|
|
|
|
if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
|
2012-03-07 23:51:39 -08:00
|
|
|
//xx// filtering with these doesnt help
|
|
|
|
//xx// if (e->mode == ECORE_X_EVENT_MODE_GRAB) return ECORE_CALLBACK_PASS_ON;
|
|
|
|
|
2010-02-01 06:13:48 -08:00
|
|
|
// if (ee->prop.fullscreen)
|
|
|
|
// ecore_x_window_focus(ee->prop.window);
|
|
|
|
evas_focus_out(ee->evas);
|
2003-09-23 01:09:32 -07:00
|
|
|
ee->prop.focused = 0;
|
|
|
|
if (ee->func.fn_focus_out) ee->func.fn_focus_out(ee);
|
2010-06-24 09:15:56 -07:00
|
|
|
return ECORE_CALLBACK_PASS_ON;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
2010-06-24 09:15:56 -07:00
|
|
|
static Eina_Bool
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_event_window_damage(void *data __UNUSED__, int type __UNUSED__, void *event)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
Ecore_Evas *ee;
|
|
|
|
Ecore_X_Event_Window_Damage *e;
|
|
|
|
|
|
|
|
e = event;
|
2009-03-19 06:06:16 -07:00
|
|
|
ee = ecore_event_window_match(e->win);
|
2010-06-24 09:15:56 -07:00
|
|
|
if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
|
|
|
|
if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
|
|
|
|
if (ee->engine.x.using_bg_pixmap) return ECORE_CALLBACK_PASS_ON;
|
2007-09-27 08:31:00 -07:00
|
|
|
// printf("EXPOSE %p [%i] %i %i %ix%i\n", ee, ee->prop.avoid_damage, e->x, e->y, e->w, e->h);
|
2003-09-23 01:09:32 -07:00
|
|
|
if (ee->prop.avoid_damage)
|
|
|
|
{
|
2010-09-29 10:03:38 -07:00
|
|
|
Ecore_X_Rectangle rect;
|
2011-07-26 04:24:10 -07:00
|
|
|
Ecore_X_XRegion *tmpr;
|
2010-09-29 10:03:38 -07:00
|
|
|
|
2011-09-21 23:02:26 -07:00
|
|
|
if (!ee->engine.x.damages)
|
2011-07-26 04:24:10 -07:00
|
|
|
ee->engine.x.damages = ecore_x_xregion_new();
|
2010-09-29 10:03:38 -07:00
|
|
|
tmpr = ecore_x_xregion_new();
|
|
|
|
rect.x = e->x;
|
|
|
|
rect.y = e->y;
|
|
|
|
rect.width = e->w;
|
|
|
|
rect.height = e->h;
|
|
|
|
ecore_x_xregion_union_rect(tmpr, ee->engine.x.damages, &rect);
|
|
|
|
ecore_x_xregion_free(ee->engine.x.damages);
|
|
|
|
ee->engine.x.damages = tmpr;
|
2007-04-13 21:20:23 -07:00
|
|
|
/* no - this breaks things badly. disable. Ecore_X_Rectangle != XRectangle - see
|
|
|
|
* the typedefs in x's headers and ecore_x's. also same with Region - it's a pointer in x - not an X ID
|
2010-09-29 10:03:38 -07:00
|
|
|
Ecore_X_Rectangle rect;
|
|
|
|
Ecore_X_XRegion *tmpr;
|
|
|
|
|
|
|
|
if (!ee->engine.x.damages) ee->engine.x.damages = ecore_x_xregion_new();
|
|
|
|
tmpr = ecore_x_xregion_new();
|
|
|
|
rect.x = e->x;
|
|
|
|
rect.y = e->y;
|
|
|
|
rect.width = e->w;
|
|
|
|
rect.height = e->h;
|
|
|
|
ecore_x_xregion_union_rect(tmpr, ee->engine.x.damages, &rect);
|
|
|
|
ecore_x_xregion_free(ee->engine.x.damages);
|
|
|
|
ee->engine.x.damages = tmpr;
|
2007-04-13 21:20:23 -07:00
|
|
|
*/
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2010-09-29 10:03:38 -07:00
|
|
|
if (ee->rotation == 0)
|
2011-07-26 04:24:10 -07:00
|
|
|
evas_damage_rectangle_add(ee->evas, e->x, e->y, e->w, e->h);
|
2010-09-29 10:03:38 -07:00
|
|
|
else if (ee->rotation == 90)
|
|
|
|
evas_damage_rectangle_add(ee->evas,
|
2011-07-26 04:24:10 -07:00
|
|
|
ee->h - e->y - e->h, e->x, e->h, e->w);
|
2010-09-29 10:03:38 -07:00
|
|
|
else if (ee->rotation == 180)
|
2011-07-26 04:24:10 -07:00
|
|
|
evas_damage_rectangle_add(ee->evas, ee->w - e->x - e->w,
|
|
|
|
ee->h - e->y - e->h, e->w, e->h);
|
2010-09-29 10:03:38 -07:00
|
|
|
else if (ee->rotation == 270)
|
2011-07-26 04:24:10 -07:00
|
|
|
evas_damage_rectangle_add(ee->evas, e->y, ee->w - e->x - e->w,
|
2010-09-29 10:03:38 -07:00
|
|
|
e->h, e->w);
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
2010-06-24 09:15:56 -07:00
|
|
|
return ECORE_CALLBACK_PASS_ON;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
2010-06-24 09:15:56 -07:00
|
|
|
static Eina_Bool
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_event_window_destroy(void *data __UNUSED__, int type __UNUSED__, void *event)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
Ecore_Evas *ee;
|
|
|
|
Ecore_X_Event_Window_Destroy *e;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
e = event;
|
2010-10-19 06:56:17 -07:00
|
|
|
ee = ecore_event_window_match(e->win);
|
2010-06-24 09:15:56 -07:00
|
|
|
if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
|
|
|
|
if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
|
2003-09-23 01:09:32 -07:00
|
|
|
if (ee->func.fn_destroy) ee->func.fn_destroy(ee);
|
2010-02-01 06:13:48 -08:00
|
|
|
_ecore_evas_x_sync_clear(ee);
|
2003-09-23 01:09:32 -07:00
|
|
|
ecore_evas_free(ee);
|
2010-06-24 09:15:56 -07:00
|
|
|
return ECORE_CALLBACK_PASS_ON;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
2010-06-24 09:15:56 -07:00
|
|
|
static Eina_Bool
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_event_window_configure(void *data __UNUSED__, int type __UNUSED__, void *event)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
Ecore_Evas *ee;
|
|
|
|
Ecore_X_Event_Window_Configure *e;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
e = event;
|
2010-10-19 06:56:17 -07:00
|
|
|
ee = ecore_event_window_match(e->win);
|
2010-06-24 09:15:56 -07:00
|
|
|
if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
|
|
|
|
if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
|
|
|
|
if (ee->engine.x.direct_resize) return ECORE_CALLBACK_PASS_ON;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2011-10-25 22:29:38 -07:00
|
|
|
ee->engine.x.configure_coming = 0;
|
2006-03-08 00:02:55 -08:00
|
|
|
if ((e->from_wm) || (ee->prop.override))
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2010-09-29 10:03:38 -07:00
|
|
|
if ((ee->x != e->x) || (ee->y != e->y))
|
|
|
|
{
|
|
|
|
ee->x = e->x;
|
|
|
|
ee->y = e->y;
|
2010-02-27 06:40:10 -08:00
|
|
|
ee->req.x = ee->x;
|
|
|
|
ee->req.y = ee->y;
|
2010-09-29 10:03:38 -07:00
|
|
|
if (ee->func.fn_move) ee->func.fn_move(ee);
|
|
|
|
}
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
if ((ee->w != e->w) || (ee->h != e->h))
|
|
|
|
{
|
2010-09-29 10:03:38 -07:00
|
|
|
ee->w = e->w;
|
|
|
|
ee->h = e->h;
|
2010-02-27 06:40:10 -08:00
|
|
|
ee->req.w = ee->w;
|
|
|
|
ee->req.h = ee->h;
|
2010-09-29 10:03:38 -07:00
|
|
|
if ((ee->rotation == 90) || (ee->rotation == 270))
|
|
|
|
{
|
|
|
|
evas_output_size_set(ee->evas, ee->h, ee->w);
|
|
|
|
evas_output_viewport_set(ee->evas, 0, 0, ee->h, ee->w);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
evas_output_size_set(ee->evas, ee->w, ee->h);
|
|
|
|
evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
|
|
|
|
}
|
|
|
|
if (ee->prop.avoid_damage)
|
|
|
|
{
|
|
|
|
int pdam;
|
|
|
|
|
|
|
|
pdam = ecore_evas_avoid_damage_get(ee);
|
|
|
|
ecore_evas_avoid_damage_set(ee, 0);
|
|
|
|
ecore_evas_avoid_damage_set(ee, pdam);
|
|
|
|
}
|
|
|
|
if ((ee->shaped) || (ee->alpha))
|
|
|
|
_ecore_evas_x_resize_shape(ee);
|
2011-07-26 04:24:10 -07:00
|
|
|
if ((ee->expecting_resize.w > 0) && (ee->expecting_resize.h > 0))
|
2010-09-29 10:03:38 -07:00
|
|
|
{
|
|
|
|
if ((ee->expecting_resize.w == ee->w) &&
|
|
|
|
(ee->expecting_resize.h == ee->h))
|
|
|
|
_ecore_evas_mouse_move_process(ee, ee->mouse.x, ee->mouse.y,
|
|
|
|
ecore_x_current_time_get());
|
|
|
|
ee->expecting_resize.w = 0;
|
|
|
|
ee->expecting_resize.h = 0;
|
|
|
|
}
|
|
|
|
if (ee->func.fn_resize) ee->func.fn_resize(ee);
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
2010-06-24 09:15:56 -07:00
|
|
|
return ECORE_CALLBACK_PASS_ON;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
2010-06-24 09:15:56 -07:00
|
|
|
static Eina_Bool
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_event_window_delete_request(void *data __UNUSED__, int type __UNUSED__, void *event)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
Ecore_Evas *ee;
|
|
|
|
Ecore_X_Event_Window_Delete_Request *e;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
e = event;
|
2009-03-19 06:06:16 -07:00
|
|
|
ee = ecore_event_window_match(e->win);
|
2010-06-24 09:15:56 -07:00
|
|
|
if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
|
|
|
|
if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
|
2003-09-23 01:09:32 -07:00
|
|
|
if (ee->func.fn_delete_request) ee->func.fn_delete_request(ee);
|
2010-06-24 09:15:56 -07:00
|
|
|
return ECORE_CALLBACK_PASS_ON;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
2010-06-24 09:15:56 -07:00
|
|
|
static Eina_Bool
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_event_window_show(void *data __UNUSED__, int type __UNUSED__, void *event)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
Ecore_Evas *ee;
|
|
|
|
Ecore_X_Event_Window_Show *e;
|
2010-08-10 22:12:22 -07:00
|
|
|
static int first_map_bug = -1;
|
2011-04-20 07:15:33 -07:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
e = event;
|
2010-10-19 06:56:17 -07:00
|
|
|
ee = ecore_event_window_match(e->win);
|
2010-06-24 09:15:56 -07:00
|
|
|
if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
|
|
|
|
if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
|
2012-07-03 00:44:17 -07:00
|
|
|
/* some GL drivers are doing buffer copy in a separate thread.
|
|
|
|
* we need to check whether GL driver sends SYNC_DRAW_DONE msg afger copying
|
|
|
|
* that are required in order to exactly render. - added by gl77.lee
|
|
|
|
*/
|
|
|
|
if (ee->gl_sync_draw_done < 0)
|
|
|
|
{
|
|
|
|
if (getenv("ECORE_EVAS_GL_SYNC_DRAW_DONE"))
|
|
|
|
ee->gl_sync_draw_done = atoi(getenv("ECORE_EVAS_GL_SYNC_DRAW_DONE"));
|
|
|
|
else
|
|
|
|
ee->gl_sync_draw_done = 0;
|
|
|
|
}
|
2010-08-10 22:12:22 -07:00
|
|
|
if (first_map_bug < 0)
|
|
|
|
{
|
2011-07-26 04:24:10 -07:00
|
|
|
char *bug = NULL;
|
|
|
|
|
|
|
|
if ((bug = getenv("ECORE_EVAS_GL_FIRST_MAP_BUG")))
|
|
|
|
first_map_bug = atoi(bug);
|
2010-08-10 22:12:22 -07:00
|
|
|
else
|
2011-07-26 04:24:10 -07:00
|
|
|
first_map_bug = 0;
|
2010-08-10 22:12:22 -07:00
|
|
|
}
|
2011-07-26 04:24:10 -07:00
|
|
|
if ((first_map_bug) && (!strcmp(ee->driver, "opengl_x11")))
|
|
|
|
evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
|
2011-11-21 21:51:06 -08:00
|
|
|
if (ee->visible) return ECORE_CALLBACK_PASS_ON;
|
|
|
|
// if (ee->visible) return ECORE_CALLBACK_DONE;
|
2007-09-27 08:31:00 -07:00
|
|
|
// printf("SHOW EVENT %p\n", ee);
|
2003-09-23 01:09:32 -07:00
|
|
|
ee->visible = 1;
|
|
|
|
if (ee->func.fn_show) ee->func.fn_show(ee);
|
2010-06-24 09:15:56 -07:00
|
|
|
return ECORE_CALLBACK_PASS_ON;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
2010-06-24 09:15:56 -07:00
|
|
|
static Eina_Bool
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_event_window_hide(void *data __UNUSED__, int type __UNUSED__, void *event)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
Ecore_Evas *ee;
|
|
|
|
Ecore_X_Event_Window_Hide *e;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
e = event;
|
2010-10-19 06:56:17 -07:00
|
|
|
ee = ecore_event_window_match(e->win);
|
2010-06-24 09:15:56 -07:00
|
|
|
if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
|
|
|
|
if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
|
2011-12-27 04:02:18 -08:00
|
|
|
if (ee->in)
|
|
|
|
{
|
|
|
|
evas_event_feed_mouse_cancel(ee->evas, e->time, NULL);
|
|
|
|
evas_event_feed_mouse_out(ee->evas, e->time, NULL);
|
|
|
|
if (ee->func.fn_mouse_out) ee->func.fn_mouse_out(ee);
|
|
|
|
if (ee->prop.cursor.object) evas_object_hide(ee->prop.cursor.object);
|
|
|
|
ee->in = EINA_FALSE;
|
|
|
|
}
|
2011-11-21 21:51:06 -08:00
|
|
|
if (!ee->visible) return ECORE_CALLBACK_PASS_ON;
|
|
|
|
// if (!ee->visible) return ECORE_CALLBACK_DONE;
|
2007-09-27 08:43:08 -07:00
|
|
|
// printf("HIDE EVENT %p\n", ee);
|
2003-09-23 01:09:32 -07:00
|
|
|
ee->visible = 0;
|
|
|
|
if (ee->func.fn_hide) ee->func.fn_hide(ee);
|
2010-06-24 09:15:56 -07:00
|
|
|
return ECORE_CALLBACK_PASS_ON;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
2005-06-09 21:18:24 -07:00
|
|
|
/* FIXME, should be in idler */
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
/* FIXME, round trip */
|
2005-06-09 21:18:24 -07:00
|
|
|
static void
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_size_pos_hints_update(Ecore_Evas *ee)
|
2005-06-09 21:18:24 -07:00
|
|
|
{
|
2009-03-16 09:24:43 -07:00
|
|
|
ecore_x_icccm_size_pos_hints_set(ee->prop.window,
|
2010-09-29 10:03:38 -07:00
|
|
|
ee->prop.request_pos /*request_pos */,
|
|
|
|
ECORE_X_GRAVITY_NW /* gravity */,
|
|
|
|
ee->prop.min.w /* min_w */,
|
|
|
|
ee->prop.min.h /* min_h */,
|
|
|
|
ee->prop.max.w /* max_w */,
|
|
|
|
ee->prop.max.h /* max_h */,
|
|
|
|
ee->prop.base.w /* base_w */,
|
|
|
|
ee->prop.base.h /* base_h */,
|
|
|
|
ee->prop.step.w /* step_x */,
|
|
|
|
ee->prop.step.h /* step_y */,
|
2012-02-27 22:43:59 -08:00
|
|
|
ee->prop.aspect /* min_aspect */,
|
|
|
|
ee->prop.aspect /* max_aspect */);
|
2005-06-09 21:18:24 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* FIXME, should be in idler */
|
|
|
|
static void
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_state_update(Ecore_Evas *ee)
|
2005-06-09 21:18:24 -07:00
|
|
|
{
|
|
|
|
Ecore_X_Window_State state[10];
|
2011-07-26 04:24:10 -07:00
|
|
|
int num = 0;
|
2005-06-09 21:18:24 -07:00
|
|
|
|
2012-02-27 22:43:59 -08:00
|
|
|
if (ee->prop.modal)
|
2005-06-09 21:18:24 -07:00
|
|
|
state[num++] = ECORE_X_WINDOW_STATE_MODAL;
|
2012-02-27 22:43:59 -08:00
|
|
|
if (ee->prop.sticky)
|
2005-06-09 21:18:24 -07:00
|
|
|
state[num++] = ECORE_X_WINDOW_STATE_STICKY;
|
2012-02-27 22:43:59 -08:00
|
|
|
if (ee->prop.maximized)
|
2005-06-09 21:18:24 -07:00
|
|
|
state[num++] = ECORE_X_WINDOW_STATE_MAXIMIZED_VERT;
|
2012-02-27 22:43:59 -08:00
|
|
|
if (ee->prop.maximized)
|
2005-06-09 21:18:24 -07:00
|
|
|
state[num++] = ECORE_X_WINDOW_STATE_MAXIMIZED_HORZ;
|
2012-02-27 22:43:59 -08:00
|
|
|
// if (bd->client.netwm.state.shaded)
|
|
|
|
// state[num++] = ECORE_X_WINDOW_STATE_SHADED;
|
|
|
|
if (ee->prop.focus_skip)
|
2005-06-09 21:18:24 -07:00
|
|
|
state[num++] = ECORE_X_WINDOW_STATE_SKIP_TASKBAR;
|
2012-02-27 22:43:59 -08:00
|
|
|
if (ee->prop.focus_skip)
|
2005-06-09 21:18:24 -07:00
|
|
|
state[num++] = ECORE_X_WINDOW_STATE_SKIP_PAGER;
|
2012-02-27 22:43:59 -08:00
|
|
|
// if (bd->client.netwm.state.hidden)
|
|
|
|
// state[num++] = ECORE_X_WINDOW_STATE_HIDDEN;
|
2006-08-12 03:16:53 -07:00
|
|
|
if (ee->engine.x.state.fullscreen)
|
|
|
|
state[num++] = ECORE_X_WINDOW_STATE_FULLSCREEN;
|
2005-06-09 21:18:24 -07:00
|
|
|
if (ee->engine.x.state.above)
|
|
|
|
state[num++] = ECORE_X_WINDOW_STATE_ABOVE;
|
|
|
|
if (ee->engine.x.state.below)
|
|
|
|
state[num++] = ECORE_X_WINDOW_STATE_BELOW;
|
2012-02-27 22:43:59 -08:00
|
|
|
if (ee->prop.demand_attention)
|
|
|
|
state[num++] = ECORE_X_WINDOW_STATE_DEMANDS_ATTENTION;
|
2005-06-09 21:18:24 -07:00
|
|
|
|
2009-03-16 09:24:43 -07:00
|
|
|
ecore_x_netwm_window_state_set(ee->prop.window, state, num);
|
2005-06-09 21:18:24 -07:00
|
|
|
}
|
|
|
|
|
2005-09-05 01:40:50 -07:00
|
|
|
static void
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_layer_update(Ecore_Evas *ee)
|
2005-06-09 21:18:24 -07:00
|
|
|
{
|
|
|
|
if (ee->should_be_visible)
|
|
|
|
{
|
2010-09-29 10:03:38 -07:00
|
|
|
/* We need to send a netwm request to the wm */
|
|
|
|
/* FIXME: Do we have to remove old state before adding new? */
|
|
|
|
if (ee->prop.layer < 3)
|
|
|
|
{
|
|
|
|
if (ee->engine.x.state.above)
|
|
|
|
{
|
|
|
|
ee->engine.x.state.above = 0;
|
|
|
|
ecore_x_netwm_state_request_send(ee->prop.window,
|
|
|
|
ee->engine.x.win_root,
|
|
|
|
ECORE_X_WINDOW_STATE_ABOVE, -1, 0);
|
|
|
|
}
|
|
|
|
if (!ee->engine.x.state.below)
|
|
|
|
{
|
|
|
|
ee->engine.x.state.below = 1;
|
|
|
|
ecore_x_netwm_state_request_send(ee->prop.window,
|
|
|
|
ee->engine.x.win_root,
|
|
|
|
ECORE_X_WINDOW_STATE_BELOW, -1, 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (ee->prop.layer > 5)
|
|
|
|
{
|
|
|
|
if (ee->engine.x.state.below)
|
|
|
|
{
|
|
|
|
ee->engine.x.state.below = 0;
|
|
|
|
ecore_x_netwm_state_request_send(ee->prop.window,
|
|
|
|
ee->engine.x.win_root,
|
|
|
|
ECORE_X_WINDOW_STATE_BELOW, -1, 0);
|
|
|
|
}
|
|
|
|
if (!ee->engine.x.state.above)
|
|
|
|
{
|
|
|
|
ee->engine.x.state.above = 1;
|
|
|
|
ecore_x_netwm_state_request_send(ee->prop.window,
|
|
|
|
ee->engine.x.win_root,
|
|
|
|
ECORE_X_WINDOW_STATE_ABOVE, -1, 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (ee->engine.x.state.below)
|
|
|
|
{
|
|
|
|
ee->engine.x.state.below = 0;
|
|
|
|
ecore_x_netwm_state_request_send(ee->prop.window,
|
|
|
|
ee->engine.x.win_root,
|
|
|
|
ECORE_X_WINDOW_STATE_BELOW, -1, 0);
|
|
|
|
}
|
|
|
|
if (ee->engine.x.state.above)
|
|
|
|
{
|
|
|
|
ee->engine.x.state.above = 0;
|
|
|
|
ecore_x_netwm_state_request_send(ee->prop.window,
|
|
|
|
ee->engine.x.win_root,
|
|
|
|
ECORE_X_WINDOW_STATE_ABOVE, -1, 0);
|
|
|
|
}
|
|
|
|
}
|
2005-06-09 21:18:24 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2010-09-29 10:03:38 -07:00
|
|
|
/* Just set the state */
|
|
|
|
if (ee->prop.layer < 3)
|
|
|
|
{
|
|
|
|
if ((ee->engine.x.state.above) || (!ee->engine.x.state.below))
|
|
|
|
{
|
|
|
|
ee->engine.x.state.above = 0;
|
|
|
|
ee->engine.x.state.below = 1;
|
|
|
|
_ecore_evas_x_state_update(ee);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (ee->prop.layer > 5)
|
|
|
|
{
|
|
|
|
if ((!ee->engine.x.state.above) || (ee->engine.x.state.below))
|
|
|
|
{
|
|
|
|
ee->engine.x.state.above = 1;
|
|
|
|
ee->engine.x.state.below = 0;
|
|
|
|
_ecore_evas_x_state_update(ee);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if ((ee->engine.x.state.above) || (ee->engine.x.state.below))
|
|
|
|
{
|
|
|
|
ee->engine.x.state.above = 0;
|
|
|
|
ee->engine.x.state.below = 0;
|
|
|
|
_ecore_evas_x_state_update(ee);
|
|
|
|
}
|
|
|
|
}
|
2005-06-09 21:18:24 -07:00
|
|
|
}
|
|
|
|
/* FIXME: Set gnome layer */
|
|
|
|
}
|
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
static int
|
|
|
|
_ecore_evas_x_init(void)
|
|
|
|
{
|
|
|
|
_ecore_evas_init_count++;
|
|
|
|
if (_ecore_evas_init_count > 1) return _ecore_evas_init_count;
|
2011-09-21 23:02:26 -07:00
|
|
|
ecore_evas_event_handlers[0] =
|
|
|
|
ecore_event_handler_add(ECORE_X_EVENT_MOUSE_IN,
|
2011-07-26 04:24:10 -07:00
|
|
|
_ecore_evas_x_event_mouse_in, NULL);
|
2011-09-21 23:02:26 -07:00
|
|
|
ecore_evas_event_handlers[1] =
|
|
|
|
ecore_event_handler_add(ECORE_X_EVENT_MOUSE_OUT,
|
2011-07-26 04:24:10 -07:00
|
|
|
_ecore_evas_x_event_mouse_out, NULL);
|
2011-09-21 23:02:26 -07:00
|
|
|
ecore_evas_event_handlers[2] =
|
|
|
|
ecore_event_handler_add(ECORE_X_EVENT_WINDOW_FOCUS_IN,
|
2011-07-26 04:24:10 -07:00
|
|
|
_ecore_evas_x_event_window_focus_in, NULL);
|
2011-09-21 23:02:26 -07:00
|
|
|
ecore_evas_event_handlers[3] =
|
|
|
|
ecore_event_handler_add(ECORE_X_EVENT_WINDOW_FOCUS_OUT,
|
2011-07-26 04:24:10 -07:00
|
|
|
_ecore_evas_x_event_window_focus_out, NULL);
|
2011-09-21 23:02:26 -07:00
|
|
|
ecore_evas_event_handlers[4] =
|
|
|
|
ecore_event_handler_add(ECORE_X_EVENT_WINDOW_DAMAGE,
|
2011-07-26 04:24:10 -07:00
|
|
|
_ecore_evas_x_event_window_damage, NULL);
|
2011-09-21 23:02:26 -07:00
|
|
|
ecore_evas_event_handlers[5] =
|
|
|
|
ecore_event_handler_add(ECORE_X_EVENT_WINDOW_DESTROY,
|
2011-07-26 04:24:10 -07:00
|
|
|
_ecore_evas_x_event_window_destroy, NULL);
|
2011-09-21 23:02:26 -07:00
|
|
|
ecore_evas_event_handlers[6] =
|
|
|
|
ecore_event_handler_add(ECORE_X_EVENT_WINDOW_CONFIGURE,
|
2011-07-26 04:24:10 -07:00
|
|
|
_ecore_evas_x_event_window_configure, NULL);
|
2011-09-21 23:02:26 -07:00
|
|
|
ecore_evas_event_handlers[7] =
|
|
|
|
ecore_event_handler_add(ECORE_X_EVENT_WINDOW_DELETE_REQUEST,
|
2011-07-26 04:24:10 -07:00
|
|
|
_ecore_evas_x_event_window_delete_request, NULL);
|
2011-09-21 23:02:26 -07:00
|
|
|
ecore_evas_event_handlers[8] =
|
|
|
|
ecore_event_handler_add(ECORE_X_EVENT_WINDOW_SHOW,
|
2011-07-26 04:24:10 -07:00
|
|
|
_ecore_evas_x_event_window_show, NULL);
|
2011-09-21 23:02:26 -07:00
|
|
|
ecore_evas_event_handlers[9] =
|
|
|
|
ecore_event_handler_add(ECORE_X_EVENT_WINDOW_HIDE,
|
2011-07-26 04:24:10 -07:00
|
|
|
_ecore_evas_x_event_window_hide, NULL);
|
2011-09-21 23:02:26 -07:00
|
|
|
ecore_evas_event_handlers[10] =
|
|
|
|
ecore_event_handler_add(ECORE_X_EVENT_WINDOW_PROPERTY,
|
2011-07-26 04:24:10 -07:00
|
|
|
_ecore_evas_x_event_property_change, NULL);
|
2011-09-21 23:02:26 -07:00
|
|
|
ecore_evas_event_handlers[11] =
|
|
|
|
ecore_event_handler_add(ECORE_X_EVENT_WINDOW_VISIBILITY_CHANGE,
|
2011-07-26 04:24:10 -07:00
|
|
|
_ecore_evas_x_event_visibility_change, NULL);
|
2011-09-21 23:02:26 -07:00
|
|
|
ecore_evas_event_handlers[12] =
|
|
|
|
ecore_event_handler_add(ECORE_X_EVENT_CLIENT_MESSAGE,
|
2011-07-26 04:24:10 -07:00
|
|
|
_ecore_evas_x_event_client_message, NULL);
|
2009-03-19 06:06:16 -07:00
|
|
|
ecore_event_evas_init();
|
2003-09-23 01:09:32 -07:00
|
|
|
return _ecore_evas_init_count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_ecore_evas_x_free(Ecore_Evas *ee)
|
|
|
|
{
|
2010-10-01 18:56:23 -07:00
|
|
|
_ecore_evas_x_group_leader_unset(ee);
|
2010-01-30 02:42:22 -08:00
|
|
|
_ecore_evas_x_sync_set(ee);
|
2011-09-21 23:02:26 -07:00
|
|
|
if (ee->engine.x.win_shaped_input)
|
2011-07-26 04:24:10 -07:00
|
|
|
ecore_x_window_free(ee->engine.x.win_shaped_input);
|
2009-04-10 01:46:41 -07:00
|
|
|
ecore_x_window_free(ee->prop.window);
|
2009-05-07 01:35:00 -07:00
|
|
|
if (ee->engine.x.pmap) ecore_x_pixmap_free(ee->engine.x.pmap);
|
|
|
|
if (ee->engine.x.mask) ecore_x_pixmap_free(ee->engine.x.mask);
|
|
|
|
if (ee->engine.x.gc) ecore_x_gc_free(ee->engine.x.gc);
|
2009-06-07 23:34:20 -07:00
|
|
|
if (ee->engine.x.damages) ecore_x_xregion_free(ee->engine.x.damages);
|
2003-09-23 01:09:32 -07:00
|
|
|
ee->engine.x.pmap = 0;
|
|
|
|
ee->engine.x.mask = 0;
|
|
|
|
ee->engine.x.gc = 0;
|
2009-06-07 23:34:20 -07:00
|
|
|
ee->engine.x.damages = NULL;
|
2010-01-06 21:29:06 -08:00
|
|
|
ecore_event_window_unregister(ee->prop.window);
|
2005-09-24 02:00:23 -07:00
|
|
|
while (ee->engine.x.win_extra)
|
|
|
|
{
|
2010-09-29 10:03:38 -07:00
|
|
|
Ecore_X_Window *winp;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2010-09-29 10:03:38 -07:00
|
|
|
winp = ee->engine.x.win_extra->data;
|
2011-09-21 23:02:26 -07:00
|
|
|
ee->engine.x.win_extra =
|
2011-07-26 04:24:10 -07:00
|
|
|
eina_list_remove_list(ee->engine.x.win_extra, ee->engine.x.win_extra);
|
2010-09-29 10:03:38 -07:00
|
|
|
ecore_event_window_unregister(*winp);
|
|
|
|
free(winp);
|
2005-09-24 02:00:23 -07:00
|
|
|
}
|
2003-09-23 01:09:32 -07:00
|
|
|
_ecore_evas_x_shutdown();
|
|
|
|
ecore_x_shutdown();
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-02-19 20:38:54 -08:00
|
|
|
_ecore_evas_x_callback_delete_request_set(Ecore_Evas *ee, Ecore_Evas_Event_Cb func)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
ee->func.fn_delete_request = func;
|
2010-01-29 02:28:54 -08:00
|
|
|
_ecore_evas_x_protocols_set(ee);
|
2010-01-30 02:42:22 -08:00
|
|
|
_ecore_evas_x_sync_set(ee);
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_move(Ecore_Evas *ee, int x, int y)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2010-02-27 06:40:10 -08:00
|
|
|
ee->req.x = x;
|
|
|
|
ee->req.y = y;
|
2005-11-03 03:32:59 -08:00
|
|
|
if (ee->engine.x.direct_resize)
|
2005-06-13 04:57:14 -07:00
|
|
|
{
|
2010-09-29 10:03:38 -07:00
|
|
|
if (!ee->engine.x.managed)
|
|
|
|
{
|
|
|
|
if ((x != ee->x) || (y != ee->y))
|
|
|
|
{
|
|
|
|
ee->x = x;
|
|
|
|
ee->y = y;
|
|
|
|
ecore_x_window_move(ee->prop.window, x, y);
|
|
|
|
if (!ee->should_be_visible)
|
|
|
|
{
|
|
|
|
/* We need to request pos */
|
|
|
|
ee->prop.request_pos = 1;
|
|
|
|
_ecore_evas_x_size_pos_hints_update(ee);
|
|
|
|
}
|
|
|
|
if (ee->func.fn_move) ee->func.fn_move(ee);
|
|
|
|
}
|
|
|
|
}
|
2005-06-13 04:57:14 -07:00
|
|
|
}
|
2005-11-03 03:32:59 -08:00
|
|
|
else
|
|
|
|
{
|
2011-10-25 22:29:38 -07:00
|
|
|
if (((ee->x != x) || (ee->y != y)) ||
|
|
|
|
(ee->engine.x.configure_coming))
|
2011-09-21 13:55:12 -07:00
|
|
|
{
|
2011-10-25 22:29:38 -07:00
|
|
|
ee->engine.x.configure_coming = 1;
|
2011-09-21 13:55:12 -07:00
|
|
|
if (!ee->engine.x.managed)
|
|
|
|
{
|
|
|
|
ee->x = x;
|
|
|
|
ee->y = y;
|
|
|
|
}
|
|
|
|
ecore_x_window_move(ee->prop.window, x, y);
|
|
|
|
}
|
2010-09-29 10:03:38 -07:00
|
|
|
if (!ee->should_be_visible)
|
|
|
|
{
|
|
|
|
/* We need to request pos */
|
|
|
|
ee->prop.request_pos = 1;
|
|
|
|
_ecore_evas_x_size_pos_hints_update(ee);
|
|
|
|
}
|
2005-11-03 03:32:59 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_ecore_evas_x_managed_move(Ecore_Evas *ee, int x, int y)
|
|
|
|
{
|
2010-02-27 06:40:10 -08:00
|
|
|
ee->req.x = x;
|
|
|
|
ee->req.y = y;
|
2005-11-02 22:16:40 -08:00
|
|
|
if (ee->engine.x.direct_resize)
|
|
|
|
{
|
2010-09-29 10:03:38 -07:00
|
|
|
ee->engine.x.managed = 1;
|
|
|
|
if ((x != ee->x) || (y != ee->y))
|
|
|
|
{
|
|
|
|
ee->x = x;
|
|
|
|
ee->y = y;
|
|
|
|
if (ee->func.fn_move) ee->func.fn_move(ee);
|
|
|
|
}
|
2005-11-02 22:16:40 -08:00
|
|
|
}
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_resize(Ecore_Evas *ee, int w, int h)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2010-02-27 06:40:10 -08:00
|
|
|
ee->req.w = w;
|
|
|
|
ee->req.h = h;
|
2004-11-23 07:17:56 -08:00
|
|
|
if (ee->engine.x.direct_resize)
|
|
|
|
{
|
2010-09-29 10:03:38 -07:00
|
|
|
if ((ee->w != w) || (ee->h != h))
|
|
|
|
{
|
|
|
|
ee->w = w;
|
|
|
|
ee->h = h;
|
2011-09-21 14:01:15 -07:00
|
|
|
ecore_x_window_resize(ee->prop.window, w, h);
|
2010-09-29 10:03:38 -07:00
|
|
|
if ((ee->rotation == 90) || (ee->rotation == 270))
|
|
|
|
{
|
|
|
|
evas_output_size_set(ee->evas, ee->h, ee->w);
|
|
|
|
evas_output_viewport_set(ee->evas, 0, 0, ee->h, ee->w);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
evas_output_size_set(ee->evas, ee->w, ee->h);
|
|
|
|
evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
|
|
|
|
}
|
|
|
|
if (ee->prop.avoid_damage)
|
|
|
|
{
|
|
|
|
int pdam;
|
|
|
|
|
|
|
|
pdam = ecore_evas_avoid_damage_get(ee);
|
|
|
|
ecore_evas_avoid_damage_set(ee, 0);
|
|
|
|
ecore_evas_avoid_damage_set(ee, pdam);
|
|
|
|
}
|
|
|
|
if ((ee->shaped) || (ee->alpha))
|
|
|
|
_ecore_evas_x_resize_shape(ee);
|
|
|
|
if (ee->func.fn_resize) ee->func.fn_resize(ee);
|
|
|
|
}
|
2004-11-23 07:17:56 -08:00
|
|
|
}
|
2011-10-25 22:29:38 -07:00
|
|
|
else if (((ee->w != w) || (ee->h != h)) ||
|
|
|
|
(ee->engine.x.configure_coming))
|
|
|
|
{
|
|
|
|
ee->engine.x.configure_coming = 1;
|
|
|
|
ecore_x_window_resize(ee->prop.window, w, h);
|
|
|
|
}
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_move_resize(Ecore_Evas *ee, int x, int y, int w, int h)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2010-02-27 06:40:10 -08:00
|
|
|
ee->req.x = x;
|
|
|
|
ee->req.y = y;
|
|
|
|
ee->req.w = w;
|
|
|
|
ee->req.h = h;
|
2004-11-23 07:17:56 -08:00
|
|
|
if (ee->engine.x.direct_resize)
|
|
|
|
{
|
2010-09-29 10:03:38 -07:00
|
|
|
if ((ee->w != w) || (ee->h != h) || (x != ee->x) || (y != ee->y))
|
|
|
|
{
|
|
|
|
int change_size = 0, change_pos = 0;
|
|
|
|
|
|
|
|
if ((ee->w != w) || (ee->h != h)) change_size = 1;
|
|
|
|
if (!ee->engine.x.managed)
|
|
|
|
{
|
|
|
|
if ((x != ee->x) || (y != ee->y)) change_pos = 1;
|
|
|
|
}
|
|
|
|
ecore_x_window_move_resize(ee->prop.window, x, y, w, h);
|
|
|
|
if (!ee->engine.x.managed)
|
|
|
|
{
|
|
|
|
ee->x = x;
|
|
|
|
ee->y = y;
|
|
|
|
}
|
|
|
|
ee->w = w;
|
|
|
|
ee->h = h;
|
|
|
|
if ((ee->rotation == 90) || (ee->rotation == 270))
|
|
|
|
{
|
|
|
|
evas_output_size_set(ee->evas, ee->h, ee->w);
|
|
|
|
evas_output_viewport_set(ee->evas, 0, 0, ee->h, ee->w);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
evas_output_size_set(ee->evas, ee->w, ee->h);
|
|
|
|
evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
|
|
|
|
}
|
|
|
|
if (ee->prop.avoid_damage)
|
|
|
|
{
|
|
|
|
int pdam;
|
|
|
|
|
|
|
|
pdam = ecore_evas_avoid_damage_get(ee);
|
|
|
|
ecore_evas_avoid_damage_set(ee, 0);
|
|
|
|
ecore_evas_avoid_damage_set(ee, pdam);
|
|
|
|
}
|
|
|
|
if ((ee->shaped) || (ee->alpha))
|
|
|
|
_ecore_evas_x_resize_shape(ee);
|
|
|
|
if (change_pos)
|
|
|
|
{
|
|
|
|
if (ee->func.fn_move) ee->func.fn_move(ee);
|
|
|
|
}
|
|
|
|
if (change_size)
|
|
|
|
{
|
|
|
|
if (ee->func.fn_resize) ee->func.fn_resize(ee);
|
|
|
|
}
|
|
|
|
}
|
2004-11-23 07:17:56 -08:00
|
|
|
}
|
2011-10-25 22:29:38 -07:00
|
|
|
else if (((ee->w != w) || (ee->h != h) || (ee->x != x) || (ee->y != y)) ||
|
|
|
|
(ee->engine.x.configure_coming))
|
2006-07-20 10:12:30 -07:00
|
|
|
{
|
2011-10-25 22:29:38 -07:00
|
|
|
ee->engine.x.configure_coming = 1;
|
2010-09-29 10:03:38 -07:00
|
|
|
ecore_x_window_move_resize(ee->prop.window, x, y, w, h);
|
|
|
|
if (!ee->engine.x.managed)
|
|
|
|
{
|
|
|
|
ee->x = x;
|
|
|
|
ee->y = y;
|
|
|
|
}
|
2006-07-20 10:12:30 -07:00
|
|
|
}
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-02-10 06:35:07 -08:00
|
|
|
_ecore_evas_x_rotation_set_internal(Ecore_Evas *ee, int rotation, int resize,
|
2010-09-29 10:03:38 -07:00
|
|
|
Evas_Engine_Info *einfo)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
int rot_dif;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
rot_dif = ee->rotation - rotation;
|
|
|
|
if (rot_dif < 0) rot_dif = -rot_dif;
|
2007-08-07 12:09:53 -07:00
|
|
|
|
|
|
|
if (rot_dif != 180)
|
|
|
|
{
|
2010-09-29 10:03:38 -07:00
|
|
|
int minw, minh, maxw, maxh, basew, baseh, stepw, steph;
|
2007-08-07 12:09:53 -07:00
|
|
|
|
2010-09-29 10:03:38 -07:00
|
|
|
if (!evas_engine_info_set(ee->evas, einfo))
|
2010-05-17 20:50:17 -07:00
|
|
|
{
|
|
|
|
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
|
|
|
|
}
|
2010-02-10 06:35:07 -08:00
|
|
|
|
2010-09-29 10:03:38 -07:00
|
|
|
if (!resize)
|
2010-02-10 06:35:07 -08:00
|
|
|
{
|
2011-10-25 22:29:38 -07:00
|
|
|
ee->engine.x.configure_coming = 1;
|
2010-02-10 06:35:07 -08:00
|
|
|
if (!ee->prop.fullscreen)
|
|
|
|
{
|
2010-02-27 06:40:10 -08:00
|
|
|
ecore_x_window_resize(ee->prop.window, ee->req.h, ee->req.w);
|
2010-02-10 06:35:07 -08:00
|
|
|
ee->expecting_resize.w = ee->h;
|
|
|
|
ee->expecting_resize.h = ee->w;
|
2012-09-13 03:20:17 -07:00
|
|
|
evas_output_size_set(ee->evas, ee->req.h, ee->req.w);
|
|
|
|
evas_output_viewport_set(ee->evas, 0, 0, ee->req.h, ee->req.w);
|
2010-02-10 06:35:07 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
int w, h;
|
2011-04-20 07:15:33 -07:00
|
|
|
|
2010-02-10 06:35:07 -08:00
|
|
|
ecore_x_window_size_get(ee->prop.window, &w, &h);
|
|
|
|
ecore_x_window_resize(ee->prop.window, h, w);
|
|
|
|
if ((rotation == 0) || (rotation == 180))
|
|
|
|
{
|
2010-02-27 06:40:10 -08:00
|
|
|
evas_output_size_set(ee->evas, ee->req.w, ee->req.h);
|
|
|
|
evas_output_viewport_set(ee->evas, 0, 0, ee->req.w, ee->req.h);
|
2010-02-10 06:35:07 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2010-02-27 06:40:10 -08:00
|
|
|
evas_output_size_set(ee->evas, ee->req.h, ee->req.w);
|
|
|
|
evas_output_viewport_set(ee->evas, 0, 0, ee->req.h, ee->req.w);
|
2010-02-10 06:35:07 -08:00
|
|
|
}
|
|
|
|
if (ee->func.fn_resize) ee->func.fn_resize(ee);
|
|
|
|
}
|
2010-02-27 06:40:10 -08:00
|
|
|
if ((ee->rotation == 90) || (ee->rotation == 270))
|
|
|
|
evas_damage_rectangle_add(ee->evas, 0, 0, ee->req.h, ee->req.w);
|
|
|
|
else
|
|
|
|
evas_damage_rectangle_add(ee->evas, 0, 0, ee->req.w, ee->req.h);
|
2010-02-10 06:35:07 -08:00
|
|
|
}
|
2010-09-29 10:03:38 -07:00
|
|
|
else
|
2010-02-10 06:35:07 -08:00
|
|
|
{
|
2011-09-21 14:01:15 -07:00
|
|
|
/* int w, h; */
|
2011-04-20 07:15:33 -07:00
|
|
|
|
2011-09-21 14:01:15 -07:00
|
|
|
/* ecore_x_window_size_get(ee->prop.window, &w, &h); */
|
2010-09-29 10:03:38 -07:00
|
|
|
if ((rotation == 0) || (rotation == 180))
|
|
|
|
{
|
|
|
|
evas_output_size_set(ee->evas, ee->w, ee->h);
|
|
|
|
evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
evas_output_size_set(ee->evas, ee->h, ee->w);
|
|
|
|
evas_output_viewport_set(ee->evas, 0, 0, ee->h, ee->w);
|
|
|
|
}
|
|
|
|
if (ee->func.fn_resize) ee->func.fn_resize(ee);
|
2010-02-27 06:40:10 -08:00
|
|
|
if ((ee->rotation == 90) || (ee->rotation == 270))
|
|
|
|
evas_damage_rectangle_add(ee->evas, 0, 0, ee->h, ee->w);
|
|
|
|
else
|
|
|
|
evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
|
2010-02-10 06:35:07 -08:00
|
|
|
}
|
2010-09-29 10:03:38 -07:00
|
|
|
ecore_evas_size_min_get(ee, &minw, &minh);
|
|
|
|
ecore_evas_size_max_get(ee, &maxw, &maxh);
|
|
|
|
ecore_evas_size_base_get(ee, &basew, &baseh);
|
|
|
|
ecore_evas_size_step_get(ee, &stepw, &steph);
|
|
|
|
ee->rotation = rotation;
|
|
|
|
ecore_evas_size_min_set(ee, minh, minw);
|
|
|
|
ecore_evas_size_max_set(ee, maxh, maxw);
|
|
|
|
ecore_evas_size_base_set(ee, baseh, basew);
|
|
|
|
ecore_evas_size_step_set(ee, steph, stepw);
|
|
|
|
_ecore_evas_mouse_move_process(ee, ee->mouse.x, ee->mouse.y,
|
|
|
|
ecore_x_current_time_get());
|
2007-08-07 12:09:53 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2010-09-29 10:03:38 -07:00
|
|
|
if (!evas_engine_info_set(ee->evas, einfo))
|
2010-05-17 20:50:17 -07:00
|
|
|
{
|
|
|
|
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
|
|
|
|
}
|
2010-09-29 10:03:38 -07:00
|
|
|
ee->rotation = rotation;
|
|
|
|
_ecore_evas_mouse_move_process(ee, ee->mouse.x, ee->mouse.y,
|
|
|
|
ecore_x_current_time_get());
|
|
|
|
if (ee->func.fn_resize) ee->func.fn_resize(ee);
|
2011-04-20 07:15:33 -07:00
|
|
|
|
2010-02-27 06:40:10 -08:00
|
|
|
if ((ee->rotation == 90) || (ee->rotation == 270))
|
|
|
|
evas_damage_rectangle_add(ee->evas, 0, 0, ee->h, ee->w);
|
|
|
|
else
|
|
|
|
evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
|
2007-08-07 12:09:53 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-03 00:44:17 -07:00
|
|
|
#define _USE_WIN_ROT_EFFECT 1
|
|
|
|
|
|
|
|
#if _USE_WIN_ROT_EFFECT
|
|
|
|
static void _ecore_evas_x_flush_pre(void *data, Evas *e __UNUSED__, void *event_info __UNUSED__);
|
|
|
|
|
|
|
|
typedef struct _Ecore_Evas_X_Rotation_Effect Ecore_Evas_X_Rotation_Effect;
|
|
|
|
struct _Ecore_Evas_X_Rotation_Effect
|
|
|
|
{
|
|
|
|
Eina_Bool wait_for_comp_reply;
|
|
|
|
};
|
|
|
|
|
|
|
|
static Ecore_Evas_X_Rotation_Effect _rot_effect =
|
|
|
|
{
|
|
|
|
EINA_FALSE
|
|
|
|
};
|
|
|
|
|
|
|
|
static void
|
|
|
|
_ecore_evas_x_rotation_effect_setup(void)
|
|
|
|
{
|
|
|
|
_rot_effect.wait_for_comp_reply = EINA_TRUE;
|
|
|
|
}
|
|
|
|
#endif /* end of _USE_WIN_ROT_EFFECT */
|
|
|
|
|
2007-08-07 12:09:53 -07:00
|
|
|
static void
|
2010-02-10 06:35:07 -08:00
|
|
|
_ecore_evas_x_rotation_set(Ecore_Evas *ee, int rotation, int resize)
|
2007-08-07 12:09:53 -07:00
|
|
|
{
|
2012-07-03 00:44:17 -07:00
|
|
|
if (ee->rotation == rotation) return;
|
|
|
|
if (!strcmp(ee->driver, "xrender_x11")) return;
|
|
|
|
|
|
|
|
#if _USE_WIN_ROT_EFFECT
|
2012-03-07 06:34:24 -08:00
|
|
|
int angles[2];
|
|
|
|
angles[0] = rotation;
|
|
|
|
angles[1] = ee->rotation;
|
2012-07-03 00:44:17 -07:00
|
|
|
#endif /* end of _USE_WIN_ROT_EFFECT */
|
2012-03-07 06:34:24 -08:00
|
|
|
|
2010-05-08 22:15:55 -07:00
|
|
|
if (!strcmp(ee->driver, "opengl_x11"))
|
|
|
|
{
|
2010-05-08 22:51:10 -07:00
|
|
|
#ifdef BUILD_ECORE_EVAS_OPENGL_X11
|
2010-09-29 10:03:38 -07:00
|
|
|
Evas_Engine_Info_GL_X11 *einfo;
|
2010-05-08 22:15:55 -07:00
|
|
|
|
2010-09-29 10:03:38 -07:00
|
|
|
einfo = (Evas_Engine_Info_GL_X11 *)evas_engine_info_get(ee->evas);
|
|
|
|
if (!einfo) return;
|
|
|
|
einfo->info.rotation = rotation;
|
2011-09-21 23:02:26 -07:00
|
|
|
_ecore_evas_x_rotation_set_internal(ee, rotation, resize,
|
2011-07-26 04:24:10 -07:00
|
|
|
(Evas_Engine_Info *)einfo);
|
2012-07-03 00:44:17 -07:00
|
|
|
# if _USE_WIN_ROT_EFFECT
|
2012-03-07 06:34:24 -08:00
|
|
|
ecore_x_window_prop_property_set(ee->prop.window,
|
|
|
|
ECORE_X_ATOM_E_ILLUME_ROTATE_WINDOW_ANGLE,
|
|
|
|
ECORE_X_ATOM_CARDINAL, 32, &angles, 2);
|
2012-07-03 00:44:17 -07:00
|
|
|
# else
|
|
|
|
ecore_x_window_prop_property_set(ee->prop.window,
|
|
|
|
ECORE_X_ATOM_E_ILLUME_ROTATE_WINDOW_ANGLE,
|
|
|
|
ECORE_X_ATOM_CARDINAL, 32, &rotation, 1);
|
|
|
|
# endif
|
2010-05-08 23:03:46 -07:00
|
|
|
#endif /* BUILD_ECORE_EVAS_OPENGL_X11 */
|
2010-05-08 22:15:55 -07:00
|
|
|
}
|
2010-05-08 23:03:46 -07:00
|
|
|
else if (!strcmp(ee->driver, "software_x11"))
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
{
|
2009-07-14 14:18:27 -07:00
|
|
|
#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
|
2010-09-29 10:03:38 -07:00
|
|
|
Evas_Engine_Info_Software_X11 *einfo;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2010-09-29 10:03:38 -07:00
|
|
|
einfo = (Evas_Engine_Info_Software_X11 *)evas_engine_info_get(ee->evas);
|
|
|
|
if (!einfo) return;
|
|
|
|
einfo->info.rotation = rotation;
|
2011-09-21 23:02:26 -07:00
|
|
|
_ecore_evas_x_rotation_set_internal(ee, rotation, resize,
|
2011-07-26 04:24:10 -07:00
|
|
|
(Evas_Engine_Info *)einfo);
|
2012-07-03 00:44:17 -07:00
|
|
|
# if _USE_WIN_ROT_EFFECT
|
2012-03-07 06:34:24 -08:00
|
|
|
ecore_x_window_prop_property_set(ee->prop.window,
|
|
|
|
ECORE_X_ATOM_E_ILLUME_ROTATE_WINDOW_ANGLE,
|
|
|
|
ECORE_X_ATOM_CARDINAL, 32, &angles, 2);
|
2012-07-03 00:44:17 -07:00
|
|
|
# else
|
|
|
|
ecore_x_window_prop_property_set(ee->prop.window,
|
|
|
|
ECORE_X_ATOM_E_ILLUME_ROTATE_WINDOW_ANGLE,
|
|
|
|
ECORE_X_ATOM_CARDINAL, 32, &rotation, 1);
|
|
|
|
# endif
|
2009-07-14 14:18:27 -07:00
|
|
|
#endif /* BUILD_ECORE_EVAS_SOFTWARE_X11 */
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
2010-07-27 17:17:40 -07:00
|
|
|
else if (!strcmp(ee->driver, "software_8_x11"))
|
|
|
|
{
|
|
|
|
#if BUILD_ECORE_EVAS_SOFTWARE_8_X11
|
2010-09-29 10:03:38 -07:00
|
|
|
Evas_Engine_Info_Software_8_X11 *einfo;
|
2010-07-27 17:17:40 -07:00
|
|
|
|
2010-09-29 10:03:38 -07:00
|
|
|
einfo = (Evas_Engine_Info_Software_8_X11 *)evas_engine_info_get(ee->evas);
|
|
|
|
if (!einfo) return;
|
|
|
|
einfo->info.rotation = rotation;
|
2011-09-21 23:02:26 -07:00
|
|
|
_ecore_evas_x_rotation_set_internal(ee, rotation, resize,
|
2011-07-26 04:24:10 -07:00
|
|
|
(Evas_Engine_Info *)einfo);
|
2012-07-03 00:44:17 -07:00
|
|
|
# if _USE_WIN_ROT_EFFECT
|
2012-03-07 06:34:24 -08:00
|
|
|
ecore_x_window_prop_property_set(ee->prop.window,
|
|
|
|
ECORE_X_ATOM_E_ILLUME_ROTATE_WINDOW_ANGLE,
|
|
|
|
ECORE_X_ATOM_CARDINAL, 32, &angles, 2);
|
2012-07-03 00:44:17 -07:00
|
|
|
# else
|
|
|
|
ecore_x_window_prop_property_set(ee->prop.window,
|
|
|
|
ECORE_X_ATOM_E_ILLUME_ROTATE_WINDOW_ANGLE,
|
|
|
|
ECORE_X_ATOM_CARDINAL, 32, &rotation, 1);
|
|
|
|
# endif
|
2010-07-27 17:17:40 -07:00
|
|
|
#endif /* BUILD_ECORE_EVAS_SOFTWARE_8_X11 */
|
|
|
|
}
|
2012-07-03 00:44:17 -07:00
|
|
|
|
|
|
|
#if _USE_WIN_ROT_EFFECT
|
|
|
|
if ((ee->visible) &&
|
|
|
|
((ecore_x_e_comp_sync_supported_get(ee->engine.x.win_root)) &&
|
|
|
|
(!ee->no_comp_sync) && (_ecore_evas_app_comp_sync)) &&
|
|
|
|
(ee->engine.x.sync_counter) &&
|
|
|
|
(ee->engine.x.sync_val > 0))
|
|
|
|
{
|
|
|
|
_ecore_evas_x_rotation_effect_setup();
|
|
|
|
_ecore_evas_x_flush_pre(ee, NULL, NULL);
|
|
|
|
}
|
|
|
|
#endif /* end of _USE_WIN_ROT_EFFECT */
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_shaped_set(Ecore_Evas *ee, int shaped)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2011-07-25 02:29:09 -07:00
|
|
|
if ((ee->shaped == shaped)) return;
|
2008-10-29 12:31:05 -07:00
|
|
|
if (!strcmp(ee->driver, "opengl_x11")) return;
|
2009-03-21 13:32:02 -07:00
|
|
|
if (!strcmp(ee->driver, "software_x11"))
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2009-07-14 14:18:27 -07:00
|
|
|
#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
|
2010-09-29 10:03:38 -07:00
|
|
|
Evas_Engine_Info_Software_X11 *einfo;
|
|
|
|
|
|
|
|
einfo = (Evas_Engine_Info_Software_X11 *)evas_engine_info_get(ee->evas);
|
|
|
|
ee->shaped = shaped;
|
|
|
|
if (einfo)
|
|
|
|
{
|
|
|
|
if (ee->shaped)
|
|
|
|
{
|
2011-07-25 02:29:09 -07:00
|
|
|
unsigned int foreground;
|
|
|
|
Ecore_X_GC gc;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2010-09-29 10:03:38 -07:00
|
|
|
if (!ee->engine.x.mask)
|
|
|
|
ee->engine.x.mask = ecore_x_pixmap_new(ee->prop.window, ee->w, ee->h, 1);
|
2009-03-23 06:28:59 -07:00
|
|
|
foreground = 0;
|
|
|
|
gc = ecore_x_gc_new(ee->engine.x.mask,
|
|
|
|
ECORE_X_GC_VALUE_MASK_FOREGROUND,
|
|
|
|
&foreground);
|
2009-04-25 00:53:28 -07:00
|
|
|
ecore_x_drawable_rectangle_fill(ee->engine.x.mask, gc,
|
|
|
|
0, 0, ee->w, ee->h);
|
2009-05-07 01:35:00 -07:00
|
|
|
ecore_x_gc_free(gc);
|
2010-09-29 10:03:38 -07:00
|
|
|
einfo->info.mask = ee->engine.x.mask;
|
|
|
|
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
|
2010-05-17 20:50:17 -07:00
|
|
|
{
|
|
|
|
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
|
|
|
|
}
|
2010-09-29 10:03:38 -07:00
|
|
|
evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
|
|
|
|
ecore_x_window_shape_input_mask_set(ee->prop.window, 0);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (ee->engine.x.mask) ecore_x_pixmap_free(ee->engine.x.mask);
|
|
|
|
ee->engine.x.mask = 0;
|
|
|
|
einfo->info.mask = 0;
|
|
|
|
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
|
2010-09-16 23:14:08 -07:00
|
|
|
{
|
|
|
|
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
|
|
|
|
}
|
2010-09-29 10:03:38 -07:00
|
|
|
ecore_x_window_shape_mask_set(ee->prop.window, 0);
|
|
|
|
ecore_x_window_shape_input_mask_set(ee->prop.window, 0);
|
|
|
|
}
|
|
|
|
}
|
2009-07-14 14:18:27 -07:00
|
|
|
#endif /* BUILD_ECORE_EVAS_SOFTWARE_X11 */
|
2005-10-02 23:45:45 -07:00
|
|
|
}
|
2010-07-27 17:17:40 -07:00
|
|
|
if (!strcmp(ee->driver, "software_8_x11"))
|
|
|
|
{
|
|
|
|
#if defined (BUILD_ECORE_EVAS_SOFTWARE_8_X11)
|
2010-09-29 10:03:38 -07:00
|
|
|
Evas_Engine_Info_Software_8_X11 *einfo;
|
|
|
|
|
|
|
|
einfo = (Evas_Engine_Info_Software_8_X11 *)evas_engine_info_get(ee->evas);
|
|
|
|
ee->shaped = shaped;
|
|
|
|
if (einfo)
|
|
|
|
{
|
|
|
|
if (ee->shaped)
|
|
|
|
{
|
2011-07-25 02:29:09 -07:00
|
|
|
unsigned int foreground;
|
|
|
|
Ecore_X_GC gc;
|
2007-06-21 15:49:36 -07:00
|
|
|
|
2010-09-29 10:03:38 -07:00
|
|
|
if (!ee->engine.x.mask)
|
|
|
|
ee->engine.x.mask = ecore_x_pixmap_new(ee->prop.window, ee->w, ee->h, 1);
|
2010-07-27 17:17:40 -07:00
|
|
|
foreground = 0;
|
|
|
|
gc = ecore_x_gc_new(ee->engine.x.mask,
|
|
|
|
ECORE_X_GC_VALUE_MASK_FOREGROUND,
|
|
|
|
&foreground);
|
|
|
|
ecore_x_drawable_rectangle_fill(ee->engine.x.mask, gc,
|
|
|
|
0, 0, ee->w, ee->h);
|
|
|
|
ecore_x_gc_free(gc);
|
2010-09-29 10:03:38 -07:00
|
|
|
einfo->info.mask = ee->engine.x.mask;
|
|
|
|
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
|
2010-07-27 17:17:40 -07:00
|
|
|
{
|
|
|
|
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
|
|
|
|
}
|
2010-09-29 10:03:38 -07:00
|
|
|
evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
|
|
|
|
ecore_x_window_shape_input_mask_set(ee->prop.window, 0);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (ee->engine.x.mask) ecore_x_pixmap_free(ee->engine.x.mask);
|
|
|
|
ee->engine.x.mask = 0;
|
|
|
|
einfo->info.mask = 0;
|
|
|
|
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
|
2010-09-16 23:14:08 -07:00
|
|
|
{
|
|
|
|
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
|
|
|
|
}
|
2010-09-29 10:03:38 -07:00
|
|
|
ecore_x_window_shape_mask_set(ee->prop.window, 0);
|
|
|
|
ecore_x_window_shape_input_mask_set(ee->prop.window, 0);
|
|
|
|
}
|
|
|
|
}
|
2010-07-27 17:17:40 -07:00
|
|
|
#endif /* BUILD_ECORE_EVAS_SOFTWARE_8_X11 */
|
|
|
|
}
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
/* FIXME, round trip */
|
2006-03-08 00:02:55 -08:00
|
|
|
static void
|
|
|
|
_ecore_evas_x_alpha_set(Ecore_Evas *ee, int alpha)
|
|
|
|
{
|
2011-07-25 02:29:09 -07:00
|
|
|
Ecore_X_Window_Attributes att;
|
2011-07-26 04:24:10 -07:00
|
|
|
char *id = NULL;
|
2007-05-12 07:13:19 -07:00
|
|
|
|
2011-07-23 10:37:04 -07:00
|
|
|
if ((ee->alpha == alpha)) return;
|
2007-05-12 07:13:19 -07:00
|
|
|
|
2009-03-21 13:32:02 -07:00
|
|
|
if (!strcmp(ee->driver, "software_x11"))
|
2006-03-08 19:51:43 -08:00
|
|
|
{
|
2009-07-14 14:18:27 -07:00
|
|
|
#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
|
2010-09-29 10:03:38 -07:00
|
|
|
Evas_Engine_Info_Software_X11 *einfo;
|
|
|
|
|
|
|
|
einfo = (Evas_Engine_Info_Software_X11 *)evas_engine_info_get(ee->evas);
|
|
|
|
if (!einfo) return;
|
|
|
|
|
|
|
|
if (!ecore_x_composite_query()) return;
|
|
|
|
|
|
|
|
ee->shaped = 0;
|
|
|
|
ee->alpha = alpha;
|
|
|
|
ecore_x_window_free(ee->prop.window);
|
|
|
|
ecore_event_window_unregister(ee->prop.window);
|
|
|
|
if (ee->alpha)
|
|
|
|
{
|
|
|
|
if (ee->prop.override)
|
|
|
|
ee->prop.window = ecore_x_window_override_argb_new(ee->engine.x.win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
|
|
|
|
else
|
|
|
|
ee->prop.window = ecore_x_window_argb_new(ee->engine.x.win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
|
2012-10-15 06:04:47 -07:00
|
|
|
// if (!ee->engine.x.mask)
|
|
|
|
// ee->engine.x.mask = ecore_x_pixmap_new(ee->prop.window, ee->req.w, ee->req.h, 1);
|
2010-09-29 10:03:38 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (ee->prop.override)
|
|
|
|
ee->prop.window = ecore_x_window_override_new(ee->engine.x.win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
|
|
|
|
else
|
|
|
|
ee->prop.window = ecore_x_window_new(ee->engine.x.win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
|
|
|
|
if (ee->engine.x.mask) ecore_x_pixmap_free(ee->engine.x.mask);
|
|
|
|
ee->engine.x.mask = 0;
|
|
|
|
ecore_x_window_shape_input_mask_set(ee->prop.window, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
einfo->info.destination_alpha = alpha;
|
2007-05-12 07:13:19 -07:00
|
|
|
|
2011-07-25 02:29:09 -07:00
|
|
|
ecore_x_window_attributes_get(ee->prop.window, &att);
|
2010-09-29 10:03:38 -07:00
|
|
|
einfo->info.visual = att.visual;
|
|
|
|
einfo->info.colormap = att.colormap;
|
|
|
|
einfo->info.depth = att.depth;
|
2007-05-12 07:13:19 -07:00
|
|
|
|
2010-09-29 10:03:38 -07:00
|
|
|
// if (ee->engine.x.mask) ecore_x_pixmap_free(ee->engine.x.mask);
|
|
|
|
// ee->engine.x.mask = 0;
|
|
|
|
einfo->info.mask = ee->engine.x.mask;
|
|
|
|
einfo->info.drawable = ee->prop.window;
|
2010-05-17 20:50:17 -07:00
|
|
|
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
|
|
|
|
{
|
|
|
|
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
|
|
|
|
}
|
2010-09-29 10:03:38 -07:00
|
|
|
evas_damage_rectangle_add(ee->evas, 0, 0, ee->req.w, ee->req.h);
|
|
|
|
ecore_x_window_shape_mask_set(ee->prop.window, 0);
|
2010-01-16 04:20:56 -08:00
|
|
|
ecore_x_input_multi_select(ee->prop.window);
|
2010-12-07 19:25:23 -08:00
|
|
|
ecore_event_window_register(ee->prop.window, ee, ee->evas,
|
|
|
|
(Ecore_Event_Mouse_Move_Cb)_ecore_evas_mouse_move_process,
|
|
|
|
(Ecore_Event_Multi_Move_Cb)_ecore_evas_mouse_multi_move_process,
|
|
|
|
(Ecore_Event_Multi_Down_Cb)_ecore_evas_mouse_multi_down_process,
|
|
|
|
(Ecore_Event_Multi_Up_Cb)_ecore_evas_mouse_multi_up_process);
|
2010-09-29 10:03:38 -07:00
|
|
|
if (ee->prop.borderless)
|
|
|
|
ecore_x_mwm_borderless_set(ee->prop.window, ee->prop.borderless);
|
|
|
|
if (ee->visible) ecore_x_window_show(ee->prop.window);
|
|
|
|
if (ee->prop.focused) ecore_x_window_focus(ee->prop.window);
|
|
|
|
if (ee->prop.title)
|
|
|
|
{
|
|
|
|
ecore_x_icccm_title_set(ee->prop.window, ee->prop.title);
|
|
|
|
ecore_x_netwm_name_set(ee->prop.window, ee->prop.title);
|
|
|
|
}
|
2012-06-17 00:24:11 -07:00
|
|
|
if (ee->prop.name)
|
|
|
|
ecore_x_icccm_name_class_set(ee->prop.window,
|
|
|
|
ee->prop.name, ee->prop.clas);
|
2012-02-27 22:43:59 -08:00
|
|
|
_ecore_evas_x_hints_update(ee);
|
2010-10-01 18:56:23 -07:00
|
|
|
_ecore_evas_x_group_leader_update(ee);
|
|
|
|
ecore_x_window_defaults_set(ee->prop.window);
|
2010-01-29 02:28:54 -08:00
|
|
|
_ecore_evas_x_protocols_set(ee);
|
2010-01-30 02:42:22 -08:00
|
|
|
_ecore_evas_x_sync_set(ee);
|
2012-06-16 19:37:18 -07:00
|
|
|
_ecore_evas_x_size_pos_hints_update(ee);
|
2009-07-14 14:18:27 -07:00
|
|
|
#endif /* BUILD_ECORE_EVAS_SOFTWARE_X11 */
|
2011-07-26 04:24:10 -07:00
|
|
|
if ((id = getenv("DESKTOP_STARTUP_ID")))
|
2010-02-28 20:44:36 -08:00
|
|
|
{
|
2011-07-26 04:24:10 -07:00
|
|
|
ecore_x_netwm_startup_id_set(ee->prop.window, id);
|
2010-02-28 20:44:36 -08:00
|
|
|
/* NB: on linux this may simply empty the env as opposed to completely
|
|
|
|
* unset it to being empty - unsure as solartis libc crashes looking
|
|
|
|
* for the '=' char */
|
2010-09-29 10:03:38 -07:00
|
|
|
// putenv((char*)"DESKTOP_STARTUP_ID=");
|
2010-02-28 20:44:36 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (!strcmp(ee->driver, "opengl_x11"))
|
|
|
|
{
|
|
|
|
#ifdef BUILD_ECORE_EVAS_OPENGL_X11
|
2010-09-29 10:03:38 -07:00
|
|
|
Evas_Engine_Info_GL_X11 *einfo;
|
2010-02-28 20:44:36 -08:00
|
|
|
|
2010-09-29 10:03:38 -07:00
|
|
|
einfo = (Evas_Engine_Info_GL_X11 *)evas_engine_info_get(ee->evas);
|
|
|
|
if (!einfo) return;
|
2010-02-28 20:44:36 -08:00
|
|
|
|
2010-09-29 10:03:38 -07:00
|
|
|
if (!ecore_x_composite_query()) return;
|
2010-02-28 20:44:36 -08:00
|
|
|
|
2010-09-29 10:03:38 -07:00
|
|
|
ee->shaped = 0;
|
|
|
|
ee->alpha = alpha;
|
|
|
|
ecore_x_window_free(ee->prop.window);
|
|
|
|
ecore_event_window_unregister(ee->prop.window);
|
2010-03-01 04:01:57 -08:00
|
|
|
ee->prop.window = 0;
|
2011-04-20 07:15:33 -07:00
|
|
|
|
2010-09-29 10:03:38 -07:00
|
|
|
einfo->info.destination_alpha = alpha;
|
2011-04-20 07:15:33 -07:00
|
|
|
|
2010-02-28 20:44:36 -08:00
|
|
|
if (ee->engine.x.win_root != 0)
|
|
|
|
{
|
|
|
|
/* FIXME: round trip in ecore_x_window_argb_get */
|
|
|
|
if (ecore_x_window_argb_get(ee->engine.x.win_root))
|
|
|
|
{
|
2011-09-21 23:02:26 -07:00
|
|
|
ee->prop.window =
|
2011-07-26 04:24:10 -07:00
|
|
|
_ecore_evas_x_gl_window_new(ee, ee->engine.x.win_root,
|
2011-09-21 23:02:26 -07:00
|
|
|
ee->req.x, ee->req.y,
|
2011-07-26 04:24:10 -07:00
|
|
|
ee->req.w, ee->req.h,
|
|
|
|
ee->prop.override, 1, NULL);
|
|
|
|
}
|
2011-09-21 23:02:26 -07:00
|
|
|
else
|
2011-07-26 04:24:10 -07:00
|
|
|
{
|
2011-09-21 23:02:26 -07:00
|
|
|
ee->prop.window =
|
2011-07-26 04:24:10 -07:00
|
|
|
_ecore_evas_x_gl_window_new(ee, ee->engine.x.win_root,
|
2011-09-21 23:02:26 -07:00
|
|
|
ee->req.x, ee->req.y,
|
2011-07-26 04:24:10 -07:00
|
|
|
ee->req.w, ee->req.h,
|
2011-09-21 23:02:26 -07:00
|
|
|
ee->prop.override, ee->alpha,
|
2011-07-26 04:24:10 -07:00
|
|
|
NULL);
|
2010-02-28 20:44:36 -08:00
|
|
|
}
|
|
|
|
}
|
2011-09-21 23:02:26 -07:00
|
|
|
else
|
2010-05-17 20:50:17 -07:00
|
|
|
{
|
2011-09-21 23:02:26 -07:00
|
|
|
ee->prop.window =
|
2011-07-26 04:24:10 -07:00
|
|
|
_ecore_evas_x_gl_window_new(ee, ee->engine.x.win_root,
|
2011-09-21 23:02:26 -07:00
|
|
|
ee->req.x, ee->req.y,
|
2011-07-26 04:24:10 -07:00
|
|
|
ee->req.w, ee->req.h,
|
|
|
|
ee->prop.override, ee->alpha, NULL);
|
2010-05-17 20:50:17 -07:00
|
|
|
}
|
2011-07-26 04:24:10 -07:00
|
|
|
|
|
|
|
if (!ee->prop.window) return;
|
2011-04-20 07:15:33 -07:00
|
|
|
/*
|
2010-09-29 10:03:38 -07:00
|
|
|
if (ee->alpha)
|
|
|
|
{
|
|
|
|
if (ee->prop.override)
|
|
|
|
ee->prop.window = ecore_x_window_override_argb_new(ee->engine.x.win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
|
|
|
|
else
|
|
|
|
ee->prop.window = ecore_x_window_argb_new(ee->engine.x.win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
|
|
|
|
if (!ee->engine.x.mask)
|
|
|
|
ee->engine.x.mask = ecore_x_pixmap_new(ee->prop.window, ee->req.w, ee->req.h, 1);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (ee->prop.override)
|
|
|
|
ee->prop.window = ecore_x_window_override_new(ee->engine.x.win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
|
|
|
|
else
|
|
|
|
ee->prop.window = ecore_x_window_new(ee->engine.x.win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
|
|
|
|
if (ee->engine.x.mask) ecore_x_pixmap_free(ee->engine.x.mask);
|
|
|
|
ee->engine.x.mask = 0;
|
|
|
|
ecore_x_window_shape_input_mask_set(ee->prop.window, 0);
|
|
|
|
}
|
2010-02-28 20:44:36 -08:00
|
|
|
*/
|
|
|
|
|
2011-07-25 02:29:09 -07:00
|
|
|
ecore_x_window_attributes_get(ee->prop.window, &att);
|
2010-09-29 10:03:38 -07:00
|
|
|
einfo->info.visual = att.visual;
|
|
|
|
einfo->info.colormap = att.colormap;
|
|
|
|
einfo->info.depth = att.depth;
|
2010-02-28 20:44:36 -08:00
|
|
|
|
2010-09-29 10:03:38 -07:00
|
|
|
// if (ee->engine.x.mask) ecore_x_pixmap_free(ee->engine.x.mask);
|
|
|
|
// ee->engine.x.mask = 0;
|
|
|
|
// einfo->info.mask = ee->engine.x.mask;
|
|
|
|
einfo->info.drawable = ee->prop.window;
|
2010-05-17 20:50:17 -07:00
|
|
|
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
|
|
|
|
{
|
|
|
|
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
|
|
|
|
}
|
2010-09-29 10:03:38 -07:00
|
|
|
evas_damage_rectangle_add(ee->evas, 0, 0, ee->req.w, ee->req.h);
|
|
|
|
// ecore_x_window_shape_mask_set(ee->prop.window, 0);
|
2010-02-28 20:44:36 -08:00
|
|
|
ecore_x_input_multi_select(ee->prop.window);
|
2010-12-07 19:25:23 -08:00
|
|
|
ecore_event_window_register(ee->prop.window, ee, ee->evas,
|
|
|
|
(Ecore_Event_Mouse_Move_Cb)_ecore_evas_mouse_move_process,
|
|
|
|
(Ecore_Event_Multi_Move_Cb)_ecore_evas_mouse_multi_move_process,
|
|
|
|
(Ecore_Event_Multi_Down_Cb)_ecore_evas_mouse_multi_down_process,
|
|
|
|
(Ecore_Event_Multi_Up_Cb)_ecore_evas_mouse_multi_up_process);
|
2010-09-29 10:03:38 -07:00
|
|
|
if (ee->prop.borderless)
|
|
|
|
ecore_x_mwm_borderless_set(ee->prop.window, ee->prop.borderless);
|
|
|
|
if (ee->visible) ecore_x_window_show(ee->prop.window);
|
|
|
|
if (ee->prop.focused) ecore_x_window_focus(ee->prop.window);
|
|
|
|
if (ee->prop.title)
|
|
|
|
{
|
|
|
|
ecore_x_icccm_title_set(ee->prop.window, ee->prop.title);
|
|
|
|
ecore_x_netwm_name_set(ee->prop.window, ee->prop.title);
|
|
|
|
}
|
2012-06-17 00:24:11 -07:00
|
|
|
if (ee->prop.name)
|
|
|
|
ecore_x_icccm_name_class_set(ee->prop.window,
|
|
|
|
ee->prop.name, ee->prop.clas);
|
2012-02-27 22:43:59 -08:00
|
|
|
_ecore_evas_x_hints_update(ee);
|
2010-10-01 18:56:23 -07:00
|
|
|
_ecore_evas_x_group_leader_update(ee);
|
|
|
|
ecore_x_window_defaults_set(ee->prop.window);
|
2010-02-28 20:44:36 -08:00
|
|
|
_ecore_evas_x_protocols_set(ee);
|
|
|
|
_ecore_evas_x_sync_set(ee);
|
2012-06-16 19:37:18 -07:00
|
|
|
_ecore_evas_x_size_pos_hints_update(ee);
|
2010-02-28 20:44:36 -08:00
|
|
|
#endif /* BUILD_ECORE_EVAS_OPENGL_X11 */
|
2011-07-26 04:24:10 -07:00
|
|
|
if ((id = getenv("DESKTOP_STARTUP_ID")))
|
2010-02-28 20:44:36 -08:00
|
|
|
{
|
2011-07-26 04:24:10 -07:00
|
|
|
ecore_x_netwm_startup_id_set(ee->prop.window, id);
|
2010-02-28 20:44:36 -08:00
|
|
|
/* NB: on linux this may simply empty the env as opposed to completely
|
|
|
|
* unset it to being empty - unsure as solartis libc crashes looking
|
|
|
|
* for the '=' char */
|
2010-09-29 10:03:38 -07:00
|
|
|
// putenv((char*)"DESKTOP_STARTUP_ID=");
|
2010-02-28 20:44:36 -08:00
|
|
|
}
|
2006-03-08 19:51:43 -08:00
|
|
|
}
|
2010-07-27 17:17:40 -07:00
|
|
|
else if (!strcmp(ee->driver, "software_8_x11"))
|
|
|
|
{
|
|
|
|
#if defined (BUILD_ECORE_EVAS_SOFTWARE_8_X11)
|
2010-09-29 10:03:38 -07:00
|
|
|
Evas_Engine_Info_Software_8_X11 *einfo;
|
|
|
|
|
|
|
|
einfo = (Evas_Engine_Info_Software_8_X11 *)evas_engine_info_get(ee->evas);
|
|
|
|
if (!einfo) return;
|
|
|
|
|
|
|
|
ee->shaped = 0;
|
|
|
|
ee->alpha = alpha;
|
|
|
|
ecore_x_window_free(ee->prop.window);
|
|
|
|
ecore_event_window_unregister(ee->prop.window);
|
|
|
|
if (ee->alpha)
|
|
|
|
{
|
|
|
|
if (ee->prop.override)
|
|
|
|
ee->prop.window = ecore_x_window_override_argb_new(ee->engine.x.win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
|
|
|
|
else
|
|
|
|
ee->prop.window = ecore_x_window_argb_new(ee->engine.x.win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
|
2012-10-15 06:04:47 -07:00
|
|
|
// if (!ee->engine.x.mask)
|
|
|
|
// ee->engine.x.mask = ecore_x_pixmap_new(ee->prop.window, ee->req.w, ee->req.h, 1);
|
2010-09-29 10:03:38 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (ee->prop.override)
|
|
|
|
ee->prop.window = ecore_x_window_override_new(ee->engine.x.win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
|
|
|
|
else
|
|
|
|
ee->prop.window = ecore_x_window_new(ee->engine.x.win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
|
|
|
|
if (ee->engine.x.mask) ecore_x_pixmap_free(ee->engine.x.mask);
|
|
|
|
ee->engine.x.mask = 0;
|
|
|
|
ecore_x_window_shape_input_mask_set(ee->prop.window, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
einfo->info.destination_alpha = alpha;
|
|
|
|
|
2011-07-26 04:24:10 -07:00
|
|
|
ecore_x_window_attributes_get(ee->prop.window, &att);
|
|
|
|
einfo->info.visual = att.visual;
|
|
|
|
einfo->info.colormap = att.colormap;
|
|
|
|
einfo->info.depth = att.depth;
|
2010-09-29 10:03:38 -07:00
|
|
|
|
|
|
|
// if (ee->engine.x.mask) ecore_x_pixmap_free(ee->engine.x.mask);
|
|
|
|
// ee->engine.x.mask = 0;
|
|
|
|
einfo->info.mask = ee->engine.x.mask;
|
|
|
|
einfo->info.drawable = ee->prop.window;
|
2010-07-27 17:17:40 -07:00
|
|
|
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
|
|
|
|
{
|
|
|
|
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
|
|
|
|
}
|
2010-09-29 10:03:38 -07:00
|
|
|
evas_damage_rectangle_add(ee->evas, 0, 0, ee->req.w, ee->req.h);
|
|
|
|
ecore_x_window_shape_mask_set(ee->prop.window, 0);
|
2010-07-27 17:17:40 -07:00
|
|
|
ecore_x_input_multi_select(ee->prop.window);
|
2010-12-07 19:25:23 -08:00
|
|
|
ecore_event_window_register(ee->prop.window, ee, ee->evas,
|
|
|
|
(Ecore_Event_Mouse_Move_Cb)_ecore_evas_mouse_move_process,
|
|
|
|
(Ecore_Event_Multi_Move_Cb)_ecore_evas_mouse_multi_move_process,
|
|
|
|
(Ecore_Event_Multi_Down_Cb)_ecore_evas_mouse_multi_down_process,
|
|
|
|
(Ecore_Event_Multi_Up_Cb)_ecore_evas_mouse_multi_up_process);
|
2010-09-29 10:03:38 -07:00
|
|
|
if (ee->prop.borderless)
|
|
|
|
ecore_x_mwm_borderless_set(ee->prop.window, ee->prop.borderless);
|
|
|
|
if (ee->visible) ecore_x_window_show(ee->prop.window);
|
|
|
|
if (ee->prop.focused) ecore_x_window_focus(ee->prop.window);
|
|
|
|
if (ee->prop.title)
|
|
|
|
{
|
|
|
|
ecore_x_icccm_title_set(ee->prop.window, ee->prop.title);
|
|
|
|
ecore_x_netwm_name_set(ee->prop.window, ee->prop.title);
|
|
|
|
}
|
2012-06-17 00:24:11 -07:00
|
|
|
if (ee->prop.name)
|
|
|
|
ecore_x_icccm_name_class_set(ee->prop.window,
|
|
|
|
ee->prop.name, ee->prop.clas);
|
2012-02-27 22:43:59 -08:00
|
|
|
_ecore_evas_x_hints_update(ee);
|
2010-10-01 18:56:23 -07:00
|
|
|
_ecore_evas_x_group_leader_update(ee);
|
|
|
|
ecore_x_window_defaults_set(ee->prop.window);
|
2010-07-27 17:17:40 -07:00
|
|
|
_ecore_evas_x_protocols_set(ee);
|
|
|
|
_ecore_evas_x_sync_set(ee);
|
2012-06-16 19:37:18 -07:00
|
|
|
_ecore_evas_x_size_pos_hints_update(ee);
|
2010-07-27 17:17:40 -07:00
|
|
|
|
2011-07-26 04:24:10 -07:00
|
|
|
if ((id = getenv("DESKTOP_STARTUP_ID")))
|
2010-07-27 17:17:40 -07:00
|
|
|
{
|
2011-07-26 04:24:10 -07:00
|
|
|
ecore_x_netwm_startup_id_set(ee->prop.window, id);
|
2010-07-27 17:17:40 -07:00
|
|
|
/* NB: on linux this may simply empty the env as opposed to completely
|
|
|
|
* unset it to being empty - unsure as solartis libc crashes looking
|
|
|
|
* for the '=' char */
|
2010-09-29 10:03:38 -07:00
|
|
|
// putenv((char*)"DESKTOP_STARTUP_ID=");
|
2010-07-27 17:17:40 -07:00
|
|
|
}
|
|
|
|
#endif /* BUILD_ECORE_EVAS_SOFTWARE_8_X11 */
|
|
|
|
}
|
2006-03-08 00:02:55 -08:00
|
|
|
}
|
2010-02-11 21:31:26 -08:00
|
|
|
|
|
|
|
static void
|
|
|
|
_ecore_evas_x_transparent_set(Ecore_Evas *ee, int transparent)
|
|
|
|
{
|
2011-07-26 04:24:10 -07:00
|
|
|
if ((ee->transparent == transparent)) return;
|
2010-02-11 21:31:26 -08:00
|
|
|
|
|
|
|
if (!strcmp(ee->driver, "software_x11"))
|
|
|
|
{
|
2010-02-15 17:27:25 -08:00
|
|
|
#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
|
2010-09-29 10:03:38 -07:00
|
|
|
Evas_Engine_Info_Software_X11 *einfo;
|
2010-02-11 21:31:26 -08:00
|
|
|
|
2010-09-29 10:03:38 -07:00
|
|
|
einfo = (Evas_Engine_Info_Software_X11 *)evas_engine_info_get(ee->evas);
|
|
|
|
if (!einfo) return;
|
2010-02-11 21:31:26 -08:00
|
|
|
|
2010-09-29 10:03:38 -07:00
|
|
|
ee->transparent = transparent;
|
|
|
|
einfo->info.destination_alpha = transparent;
|
2010-05-17 20:50:17 -07:00
|
|
|
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
|
|
|
|
{
|
|
|
|
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
|
|
|
|
}
|
2010-09-29 10:03:38 -07:00
|
|
|
evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
|
2011-04-20 07:15:33 -07:00
|
|
|
#endif
|
2010-02-11 21:31:26 -08:00
|
|
|
}
|
|
|
|
}
|
2012-02-27 22:43:59 -08:00
|
|
|
|
|
|
|
static void
|
|
|
|
_ecore_evas_x_window_group_set(Ecore_Evas *ee, const Ecore_Evas *group_ee)
|
|
|
|
{
|
|
|
|
if (ee->prop.group_ee == group_ee) return;
|
|
|
|
|
|
|
|
ee->prop.group_ee = (Ecore_Evas *)group_ee;
|
|
|
|
if (ee->prop.group_ee)
|
|
|
|
ee->prop.group_ee_win = group_ee->prop.window;
|
|
|
|
else
|
|
|
|
ee->prop.group_ee_win = 0;
|
|
|
|
_ecore_evas_x_hints_update(ee);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_ecore_evas_x_aspect_set(Ecore_Evas *ee, double aspect)
|
|
|
|
{
|
|
|
|
if (ee->prop.aspect == aspect) return;
|
|
|
|
|
|
|
|
ee->prop.aspect = aspect;
|
|
|
|
_ecore_evas_x_size_pos_hints_update(ee);
|
|
|
|
// netwm state
|
|
|
|
// if (ee->should_be_visible)
|
|
|
|
// ecore_x_netwm_state_request_send(ee->prop.window, ee->engine.x.win_root,
|
|
|
|
// ECORE_X_WINDOW_STATE_STICKY, -1, sticky);
|
|
|
|
// else
|
|
|
|
// _ecore_evas_x_state_update(ee);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_ecore_evas_x_urgent_set(Ecore_Evas *ee, int urgent)
|
|
|
|
{
|
|
|
|
if (ee->prop.urgent == urgent) return;
|
|
|
|
|
|
|
|
ee->prop.urgent = urgent;
|
|
|
|
_ecore_evas_x_hints_update(ee);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_ecore_evas_x_modal_set(Ecore_Evas *ee, int modal)
|
|
|
|
{
|
|
|
|
if (ee->prop.modal == modal) return;
|
|
|
|
|
|
|
|
ee->prop.modal = modal;
|
|
|
|
if (ee->should_be_visible)
|
|
|
|
ecore_x_netwm_state_request_send(ee->prop.window, ee->engine.x.win_root,
|
|
|
|
ECORE_X_WINDOW_STATE_MODAL, -1, modal);
|
|
|
|
else
|
|
|
|
_ecore_evas_x_state_update(ee);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_ecore_evas_x_demand_attention_set(Ecore_Evas *ee, int demand)
|
|
|
|
{
|
|
|
|
if (ee->prop.demand_attention == demand) return;
|
|
|
|
|
|
|
|
ee->prop.demand_attention = demand;
|
|
|
|
if (ee->should_be_visible)
|
|
|
|
ecore_x_netwm_state_request_send(ee->prop.window, ee->engine.x.win_root,
|
|
|
|
ECORE_X_WINDOW_STATE_DEMANDS_ATTENTION, -1, demand);
|
|
|
|
else
|
|
|
|
_ecore_evas_x_state_update(ee);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_ecore_evas_x_focus_skip_set(Ecore_Evas *ee, int skip)
|
|
|
|
{
|
|
|
|
if (ee->prop.focus_skip == skip) return;
|
|
|
|
|
|
|
|
ee->prop.focus_skip = skip;
|
|
|
|
if (ee->should_be_visible)
|
|
|
|
{
|
|
|
|
ecore_x_netwm_state_request_send(ee->prop.window, ee->engine.x.win_root,
|
2012-02-28 02:46:38 -08:00
|
|
|
ECORE_X_WINDOW_STATE_SKIP_TASKBAR, -1, skip);
|
2012-02-27 22:43:59 -08:00
|
|
|
ecore_x_netwm_state_request_send(ee->prop.window, ee->engine.x.win_root,
|
2012-02-28 02:46:38 -08:00
|
|
|
ECORE_X_WINDOW_STATE_SKIP_PAGER, -1, skip);
|
2012-02-27 22:43:59 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
_ecore_evas_x_state_update(ee);
|
|
|
|
_ecore_evas_x_hints_update(ee);
|
|
|
|
}
|
|
|
|
|
2008-07-23 03:00:01 -07:00
|
|
|
#endif /* BUILD_ECORE_EVAS_X11 */
|
2006-03-08 00:02:55 -08:00
|
|
|
|
2007-11-30 09:12:27 -08:00
|
|
|
#ifdef BUILD_ECORE_EVAS_X11
|
2003-09-23 01:09:32 -07:00
|
|
|
static void
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_show(Ecore_Evas *ee)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2005-07-06 20:31:34 -07:00
|
|
|
ee->should_be_visible = 1;
|
2005-07-06 20:37:57 -07:00
|
|
|
if (ee->prop.avoid_damage)
|
2005-07-06 20:31:34 -07:00
|
|
|
_ecore_evas_x_render(ee);
|
2010-10-10 23:28:01 -07:00
|
|
|
_ecore_evas_x_sync_set(ee);
|
2009-03-16 09:24:43 -07:00
|
|
|
ecore_x_window_show(ee->prop.window);
|
2003-09-23 01:09:32 -07:00
|
|
|
if (ee->prop.fullscreen)
|
2009-03-16 09:24:43 -07:00
|
|
|
ecore_x_window_focus(ee->prop.window);
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_hide(Ecore_Evas *ee)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2009-03-16 09:24:43 -07:00
|
|
|
ecore_x_window_hide(ee->prop.window);
|
2003-09-23 01:09:32 -07:00
|
|
|
ee->should_be_visible = 0;
|
2010-10-10 23:28:01 -07:00
|
|
|
_ecore_evas_x_sync_set(ee);
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_raise(Ecore_Evas *ee)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2011-07-26 04:24:10 -07:00
|
|
|
ecore_x_window_raise(ee->prop.window);
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_lower(Ecore_Evas *ee)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2011-07-26 04:24:10 -07:00
|
|
|
ecore_x_window_lower(ee->prop.window);
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
2008-06-30 01:39:36 -07:00
|
|
|
static void
|
|
|
|
_ecore_evas_x_activate(Ecore_Evas *ee)
|
|
|
|
{
|
2008-07-14 03:06:34 -07:00
|
|
|
ecore_x_netwm_client_active_request(ee->engine.x.win_root,
|
2010-09-29 10:03:38 -07:00
|
|
|
ee->prop.window, 2, 0);
|
2008-06-30 01:39:36 -07:00
|
|
|
}
|
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
static void
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_title_set(Ecore_Evas *ee, const char *t)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
if (ee->prop.title) free(ee->prop.title);
|
|
|
|
ee->prop.title = NULL;
|
|
|
|
if (t) ee->prop.title = strdup(t);
|
2009-03-16 09:24:43 -07:00
|
|
|
ecore_x_icccm_title_set(ee->prop.window, ee->prop.title);
|
|
|
|
ecore_x_netwm_name_set(ee->prop.window, ee->prop.title);
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_name_class_set(Ecore_Evas *ee, const char *n, const char *c)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
if (ee->prop.name) free(ee->prop.name);
|
|
|
|
if (ee->prop.clas) free(ee->prop.clas);
|
|
|
|
ee->prop.name = NULL;
|
|
|
|
ee->prop.clas = NULL;
|
2009-10-23 23:59:30 -07:00
|
|
|
if (n) ee->prop.name = strdup(n);
|
|
|
|
if (c) ee->prop.clas = strdup(c);
|
2009-03-16 09:24:43 -07:00
|
|
|
ecore_x_icccm_name_class_set(ee->prop.window, ee->prop.name, ee->prop.clas);
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_size_min_set(Ecore_Evas *ee, int w, int h)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
if (w < 0) w = 0;
|
|
|
|
if (h < 0) h = 0;
|
|
|
|
if ((ee->prop.min.w == w) && (ee->prop.min.h == h)) return;
|
|
|
|
ee->prop.min.w = w;
|
|
|
|
ee->prop.min.h = h;
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_size_pos_hints_update(ee);
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_size_max_set(Ecore_Evas *ee, int w, int h)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
if (w < 0) w = 0;
|
|
|
|
if (h < 0) h = 0;
|
|
|
|
if ((ee->prop.max.w == w) && (ee->prop.max.h == h)) return;
|
|
|
|
ee->prop.max.w = w;
|
|
|
|
ee->prop.max.h = h;
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_size_pos_hints_update(ee);
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_size_base_set(Ecore_Evas *ee, int w, int h)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
if (w < 0) w = 0;
|
|
|
|
if (h < 0) h = 0;
|
|
|
|
if ((ee->prop.base.w == w) && (ee->prop.base.h == h)) return;
|
|
|
|
ee->prop.base.w = w;
|
|
|
|
ee->prop.base.h = h;
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_size_pos_hints_update(ee);
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_size_step_set(Ecore_Evas *ee, int w, int h)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
if (w < 1) w = 1;
|
|
|
|
if (h < 1) h = 1;
|
|
|
|
if ((ee->prop.step.w == w) && (ee->prop.step.h == h)) return;
|
|
|
|
ee->prop.step.w = w;
|
|
|
|
ee->prop.step.h = h;
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_size_pos_hints_update(ee);
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
2009-02-05 02:45:52 -08:00
|
|
|
static void
|
2009-04-11 03:31:42 -07:00
|
|
|
_ecore_evas_object_cursor_del(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
|
2009-02-05 02:45:52 -08:00
|
|
|
{
|
|
|
|
Ecore_Evas *ee;
|
|
|
|
|
|
|
|
ee = data;
|
2011-07-26 04:24:10 -07:00
|
|
|
if (ee) ee->prop.cursor.object = NULL;
|
2009-02-05 02:45:52 -08:00
|
|
|
}
|
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
static void
|
2007-09-26 07:40:02 -07:00
|
|
|
_ecore_evas_x_object_cursor_set(Ecore_Evas *ee, Evas_Object *obj, int layer, int hot_x, int hot_y)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
int x, y;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2007-09-26 07:40:02 -07:00
|
|
|
if (ee->prop.cursor.object) evas_object_del(ee->prop.cursor.object);
|
|
|
|
|
2010-08-21 06:52:25 -07:00
|
|
|
if (!obj)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2010-09-29 10:03:38 -07:00
|
|
|
ee->prop.cursor.object = NULL;
|
|
|
|
ee->prop.cursor.layer = 0;
|
|
|
|
ee->prop.cursor.hot.x = 0;
|
|
|
|
ee->prop.cursor.hot.y = 0;
|
|
|
|
ecore_x_window_cursor_show(ee->prop.window, 1);
|
|
|
|
return;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
2007-09-26 07:40:02 -07:00
|
|
|
|
|
|
|
ee->prop.cursor.object = obj;
|
2003-09-23 01:09:32 -07:00
|
|
|
ee->prop.cursor.layer = layer;
|
|
|
|
ee->prop.cursor.hot.x = hot_x;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
ee->prop.cursor.hot.y = hot_y;
|
2007-09-26 07:40:02 -07:00
|
|
|
|
2009-03-16 09:24:43 -07:00
|
|
|
ecore_x_window_cursor_show(ee->prop.window, 0);
|
2007-09-26 07:40:02 -07:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
evas_pointer_output_xy_get(ee->evas, &x, &y);
|
|
|
|
evas_object_layer_set(ee->prop.cursor.object, ee->prop.cursor.layer);
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
evas_object_move(ee->prop.cursor.object,
|
2010-09-29 10:03:38 -07:00
|
|
|
x - ee->prop.cursor.hot.x,
|
|
|
|
y - ee->prop.cursor.hot.y);
|
2003-09-23 01:09:32 -07:00
|
|
|
evas_object_pass_events_set(ee->prop.cursor.object, 1);
|
|
|
|
if (evas_pointer_inside_get(ee->evas))
|
|
|
|
evas_object_show(ee->prop.cursor.object);
|
2009-02-05 02:45:52 -08:00
|
|
|
|
|
|
|
evas_object_event_callback_add(obj, EVAS_CALLBACK_DEL, _ecore_evas_object_cursor_del, ee);
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
2005-06-09 21:18:24 -07:00
|
|
|
/*
|
|
|
|
* @param ee
|
|
|
|
* @param layer If < 3, @a ee will be put below all other windows.
|
|
|
|
* If > 5, @a ee will be "always-on-top"
|
|
|
|
* If = 4, @a ee will be put in the default layer.
|
|
|
|
* Acceptable values range from 1 to 255 (0 reserved for
|
|
|
|
* desktop windows)
|
|
|
|
*/
|
2003-09-23 01:09:32 -07:00
|
|
|
static void
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_layer_set(Ecore_Evas *ee, int layer)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
if (ee->prop.layer == layer) return;
|
2005-06-09 21:18:24 -07:00
|
|
|
|
|
|
|
/* FIXME: Should this logic be here? */
|
|
|
|
if (layer < 1)
|
|
|
|
layer = 1;
|
|
|
|
else if (layer > 255)
|
|
|
|
layer = 255;
|
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
ee->prop.layer = layer;
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_layer_update(ee);
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_focus_set(Ecore_Evas *ee, int on __UNUSED__)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2009-03-16 09:24:43 -07:00
|
|
|
ecore_x_window_focus(ee->prop.window);
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
2004-04-11 10:37:39 -07:00
|
|
|
static void
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_iconified_set(Ecore_Evas *ee, int on)
|
2004-04-11 10:37:39 -07:00
|
|
|
{
|
2011-07-26 04:24:10 -07:00
|
|
|
if (ee->prop.iconified == on) return;
|
2004-04-11 10:37:39 -07:00
|
|
|
ee->prop.iconified = on;
|
2012-02-27 22:43:59 -08:00
|
|
|
_ecore_evas_x_hints_update(ee);
|
2005-06-09 21:18:24 -07:00
|
|
|
if (on)
|
2012-02-27 22:43:59 -08:00
|
|
|
ecore_x_icccm_iconic_request_send(ee->prop.window, ee->engine.x.win_root);
|
2005-06-09 21:18:24 -07:00
|
|
|
else
|
2012-02-27 22:43:59 -08:00
|
|
|
ecore_evas_show(ee);
|
2004-04-11 10:37:39 -07:00
|
|
|
}
|
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
static void
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_borderless_set(Ecore_Evas *ee, int on)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2011-07-26 04:24:10 -07:00
|
|
|
if (ee->prop.borderless == on) return;
|
2003-09-23 01:09:32 -07:00
|
|
|
ee->prop.borderless = on;
|
2009-03-16 09:24:43 -07:00
|
|
|
ecore_x_mwm_borderless_set(ee->prop.window, ee->prop.borderless);
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
2005-06-09 21:18:24 -07:00
|
|
|
/* FIXME: This function changes the initial state of the ee
|
|
|
|
* whilest the iconic function changes the current state! */
|
2003-09-23 01:09:32 -07:00
|
|
|
static void
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_withdrawn_set(Ecore_Evas *ee, int withdrawn)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2011-07-26 04:24:10 -07:00
|
|
|
if (ee->prop.withdrawn == withdrawn) return;
|
2003-09-23 01:09:32 -07:00
|
|
|
ee->prop.withdrawn = withdrawn;
|
2012-02-27 22:43:59 -08:00
|
|
|
_ecore_evas_x_hints_update(ee);
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
2003-11-15 18:29:10 -08:00
|
|
|
static void
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_sticky_set(Ecore_Evas *ee, int sticky)
|
2003-11-15 18:29:10 -08:00
|
|
|
{
|
2011-07-26 04:24:10 -07:00
|
|
|
if (ee->prop.sticky == sticky) return;
|
2003-11-15 18:29:10 -08:00
|
|
|
|
2006-07-29 07:50:18 -07:00
|
|
|
/* We dont want to set prop.sticky here as it will cause
|
|
|
|
* the sticky callback not to get called. Its set on the
|
|
|
|
* property change event.
|
|
|
|
* ee->prop.sticky = sticky;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
*/
|
2005-06-09 21:18:24 -07:00
|
|
|
ee->engine.x.state.sticky = sticky;
|
|
|
|
if (ee->should_be_visible)
|
2009-03-16 09:24:43 -07:00
|
|
|
ecore_x_netwm_state_request_send(ee->prop.window, ee->engine.x.win_root,
|
2010-09-29 10:03:38 -07:00
|
|
|
ECORE_X_WINDOW_STATE_STICKY, -1, sticky);
|
2005-06-09 21:18:24 -07:00
|
|
|
else
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_state_update(ee);
|
2003-11-15 18:29:10 -08:00
|
|
|
}
|
|
|
|
|
2005-10-08 05:41:59 -07:00
|
|
|
static void
|
|
|
|
_ecore_evas_x_ignore_events_set(Ecore_Evas *ee, int ignore)
|
|
|
|
{
|
2011-07-26 04:24:10 -07:00
|
|
|
if (ee->ignore_events == ignore) return;
|
2005-10-08 05:41:59 -07:00
|
|
|
|
2011-07-26 04:24:10 -07:00
|
|
|
ee->ignore_events = ignore;
|
|
|
|
if (ee->prop.window)
|
|
|
|
ecore_x_window_ignore_set(ee->prop.window, ignore);
|
2005-10-08 05:41:59 -07:00
|
|
|
}
|
|
|
|
|
2006-03-08 19:51:43 -08:00
|
|
|
/*
|
2006-03-08 00:02:55 -08:00
|
|
|
static void
|
|
|
|
_ecore_evas_x_reinit_win(Ecore_Evas *ee)
|
|
|
|
{
|
|
|
|
if (!strcmp(ee->driver, "software_x11"))
|
|
|
|
{
|
2007-11-05 23:21:08 -08:00
|
|
|
#ifdef BUILD_ECORE_EVAS_X11
|
2010-09-29 10:03:38 -07:00
|
|
|
Evas_Engine_Info_Software_X11 *einfo;
|
|
|
|
|
|
|
|
einfo = (Evas_Engine_Info_Software_X11 *)evas_engine_info_get(ee->evas);
|
|
|
|
if (einfo)
|
|
|
|
{
|
|
|
|
einfo->info.drawable = ee->prop.window;
|
|
|
|
evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo);
|
|
|
|
}
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
#endif
|
2006-03-08 00:02:55 -08:00
|
|
|
}
|
2008-10-29 12:31:05 -07:00
|
|
|
else if (!strcmp(ee->driver, "opengl_x11"))
|
2006-03-08 00:02:55 -08:00
|
|
|
{
|
2008-07-23 03:00:01 -07:00
|
|
|
#ifdef BUILD_ECORE_EVAS_OPENGL_X11
|
2010-09-29 10:03:38 -07:00
|
|
|
Evas_Engine_Info_GL_X11 *einfo;
|
|
|
|
|
|
|
|
einfo = (Evas_Engine_Info_GL_X11 *)evas_engine_info_get(ee->evas);
|
|
|
|
if (einfo)
|
|
|
|
{
|
|
|
|
einfo->info.drawable = ee->prop.window;
|
|
|
|
evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo);
|
|
|
|
}
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
#endif
|
2006-03-08 00:02:55 -08:00
|
|
|
}
|
|
|
|
}
|
2006-03-08 19:51:43 -08:00
|
|
|
*/
|
2006-03-08 00:02:55 -08:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
static void
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_override_set(Ecore_Evas *ee, int on)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2011-07-26 04:24:10 -07:00
|
|
|
if (ee->prop.override == on) return;
|
2011-11-21 21:51:06 -08:00
|
|
|
if (ee->should_be_visible) ecore_x_window_hide(ee->prop.window);
|
2009-03-16 09:24:43 -07:00
|
|
|
ecore_x_window_override_set(ee->prop.window, on);
|
2011-11-21 21:51:06 -08:00
|
|
|
if (ee->should_be_visible) ecore_x_window_show(ee->prop.window);
|
2009-03-16 09:24:43 -07:00
|
|
|
if (ee->prop.focused) ecore_x_window_focus(ee->prop.window);
|
2003-09-23 01:09:32 -07:00
|
|
|
ee->prop.override = on;
|
|
|
|
}
|
|
|
|
|
2012-08-05 02:00:08 -07:00
|
|
|
static void
|
|
|
|
_ecore_evas_x_maximized_set(Ecore_Evas *ee, int on)
|
|
|
|
{
|
|
|
|
if (ee->prop.maximized == on) return;
|
|
|
|
ee->engine.x.state.maximized_h = 1;
|
|
|
|
ee->engine.x.state.maximized_v = 1;
|
|
|
|
ee->prop.maximized = on;
|
|
|
|
if (ee->should_be_visible)
|
|
|
|
{
|
|
|
|
ecore_x_netwm_state_request_send(ee->prop.window, ee->engine.x.win_root,
|
|
|
|
ECORE_X_WINDOW_STATE_MAXIMIZED_VERT, -1, on);
|
|
|
|
ecore_x_netwm_state_request_send(ee->prop.window, ee->engine.x.win_root,
|
|
|
|
ECORE_X_WINDOW_STATE_MAXIMIZED_HORZ, -1, on);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
_ecore_evas_x_state_update(ee);
|
|
|
|
}
|
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
static void
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_fullscreen_set(Ecore_Evas *ee, int on)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2011-07-26 04:24:10 -07:00
|
|
|
if (ee->prop.fullscreen == on) return;
|
2006-08-12 03:16:53 -07:00
|
|
|
|
|
|
|
/* FIXME: Detect if WM is EWMH compliant and handle properly if not,
|
|
|
|
* i.e. reposition, resize, and change borderless hint */
|
|
|
|
ee->engine.x.state.fullscreen = on;
|
2006-03-08 00:02:55 -08:00
|
|
|
if (ee->should_be_visible)
|
2009-03-16 09:24:43 -07:00
|
|
|
ecore_x_netwm_state_request_send(ee->prop.window, ee->engine.x.win_root,
|
2010-09-29 10:03:38 -07:00
|
|
|
ECORE_X_WINDOW_STATE_FULLSCREEN, -1, on);
|
2003-11-15 18:29:10 -08:00
|
|
|
else
|
2006-08-12 03:16:53 -07:00
|
|
|
_ecore_evas_x_state_update(ee);
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
2012-07-03 00:44:17 -07:00
|
|
|
static void
|
|
|
|
_ecore_evas_x_profiles_set(Ecore_Evas *ee, const char **plist, int n)
|
|
|
|
{
|
|
|
|
/* Ecore_Evas's profile will be updated when WM sets the E_PROFILE. */
|
|
|
|
ecore_x_e_window_profile_list_set(ee->prop.window, plist, n);
|
|
|
|
}
|
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
static void
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_avoid_damage_set(Ecore_Evas *ee, int on)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2007-10-02 23:31:05 -07:00
|
|
|
if (ee->prop.avoid_damage == on) return;
|
2008-10-29 12:31:05 -07:00
|
|
|
if (!strcmp(ee->driver, "opengl_x11")) return;
|
2007-06-21 15:49:36 -07:00
|
|
|
|
2009-03-21 13:32:02 -07:00
|
|
|
if (!strcmp(ee->driver, "software_x11"))
|
2007-06-21 15:49:36 -07:00
|
|
|
{
|
2009-07-14 14:18:27 -07:00
|
|
|
#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
|
2010-09-29 10:03:38 -07:00
|
|
|
Evas_Engine_Info_Software_X11 *einfo;
|
|
|
|
|
|
|
|
ee->prop.avoid_damage = on;
|
|
|
|
einfo = (Evas_Engine_Info_Software_X11 *)evas_engine_info_get(ee->evas);
|
|
|
|
if (einfo)
|
|
|
|
{
|
|
|
|
if (ee->prop.avoid_damage)
|
|
|
|
{
|
|
|
|
ee->engine.x.pmap = ecore_x_pixmap_new(ee->prop.window, ee->w, ee->h, einfo->info.depth);
|
|
|
|
ee->engine.x.gc = ecore_x_gc_new(ee->engine.x.pmap, 0, NULL);
|
|
|
|
einfo->info.drawable = ee->engine.x.pmap;
|
2010-05-17 20:50:17 -07:00
|
|
|
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
|
|
|
|
{
|
|
|
|
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
|
|
|
|
}
|
2010-09-29 10:03:38 -07:00
|
|
|
if ((ee->rotation == 90) || (ee->rotation == 270))
|
|
|
|
evas_damage_rectangle_add(ee->evas, 0, 0, ee->h, ee->w);
|
|
|
|
else
|
|
|
|
evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
|
|
|
|
if (ee->prop.avoid_damage == ECORE_EVAS_AVOID_DAMAGE_BUILT_IN)
|
|
|
|
{
|
|
|
|
ee->engine.x.using_bg_pixmap = 1;
|
|
|
|
ecore_x_window_pixmap_set(ee->prop.window, ee->engine.x.pmap);
|
|
|
|
ecore_x_window_area_expose(ee->prop.window, 0, 0, ee->w, ee->h);
|
|
|
|
}
|
|
|
|
if (ee->engine.x.direct_resize)
|
|
|
|
{
|
|
|
|
/* Turn this off for now
|
|
|
|
ee->engine.x.using_bg_pixmap = 1;
|
|
|
|
ecore_x_window_pixmap_set(ee->prop.window, ee->engine.x.pmap);
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (ee->engine.x.pmap) ecore_x_pixmap_free(ee->engine.x.pmap);
|
|
|
|
if (ee->engine.x.gc) ecore_x_gc_free(ee->engine.x.gc);
|
|
|
|
if (ee->engine.x.using_bg_pixmap)
|
|
|
|
{
|
|
|
|
ecore_x_window_pixmap_set(ee->prop.window, 0);
|
|
|
|
ee->engine.x.using_bg_pixmap = 0;
|
|
|
|
ecore_x_window_area_expose(ee->prop.window, 0, 0, ee->w, ee->h);
|
|
|
|
}
|
|
|
|
ee->engine.x.pmap = 0;
|
|
|
|
ee->engine.x.gc = 0;
|
|
|
|
einfo->info.drawable = ee->prop.window;
|
2010-05-17 20:50:17 -07:00
|
|
|
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
|
|
|
|
{
|
|
|
|
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
|
|
|
|
}
|
2010-09-29 10:03:38 -07:00
|
|
|
}
|
|
|
|
}
|
2009-07-14 14:18:27 -07:00
|
|
|
#endif /* BUILD_ECORE_EVAS_SOFTWARE_X11 */
|
2007-06-21 15:49:36 -07:00
|
|
|
}
|
2010-07-27 17:17:40 -07:00
|
|
|
else if (!strcmp(ee->driver, "software_8_x11"))
|
|
|
|
{
|
|
|
|
#if BUILD_ECORE_EVAS_SOFTWARE_8_X11
|
2010-09-29 10:03:38 -07:00
|
|
|
Evas_Engine_Info_Software_8_X11 *einfo;
|
|
|
|
|
|
|
|
ee->prop.avoid_damage = on;
|
|
|
|
einfo = (Evas_Engine_Info_Software_8_X11 *)evas_engine_info_get(ee->evas);
|
|
|
|
if (einfo)
|
|
|
|
{
|
|
|
|
if (ee->prop.avoid_damage)
|
|
|
|
{
|
|
|
|
ee->engine.x.pmap = ecore_x_pixmap_new(ee->prop.window, ee->w, ee->h, einfo->info.depth);
|
|
|
|
ee->engine.x.gc = ecore_x_gc_new(ee->engine.x.pmap, 0, NULL);
|
|
|
|
einfo->info.drawable = ee->engine.x.pmap;
|
2010-07-27 17:17:40 -07:00
|
|
|
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
|
|
|
|
{
|
|
|
|
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
|
|
|
|
}
|
2010-09-29 10:03:38 -07:00
|
|
|
if ((ee->rotation == 90) || (ee->rotation == 270))
|
|
|
|
evas_damage_rectangle_add(ee->evas, 0, 0, ee->h, ee->w);
|
|
|
|
else
|
|
|
|
evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
|
|
|
|
if (ee->prop.avoid_damage == ECORE_EVAS_AVOID_DAMAGE_BUILT_IN)
|
|
|
|
{
|
|
|
|
ee->engine.x.using_bg_pixmap = 1;
|
|
|
|
ecore_x_window_pixmap_set(ee->prop.window, ee->engine.x.pmap);
|
|
|
|
ecore_x_window_area_expose(ee->prop.window, 0, 0, ee->w, ee->h);
|
|
|
|
}
|
|
|
|
if (ee->engine.x.direct_resize)
|
|
|
|
{
|
|
|
|
/* Turn this off for now
|
|
|
|
ee->engine.x.using_bg_pixmap = 1;
|
|
|
|
ecore_x_window_pixmap_set(ee->prop.window, ee->engine.x.pmap);
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (ee->engine.x.pmap) ecore_x_pixmap_free(ee->engine.x.pmap);
|
|
|
|
if (ee->engine.x.gc) ecore_x_gc_free(ee->engine.x.gc);
|
|
|
|
if (ee->engine.x.using_bg_pixmap)
|
|
|
|
{
|
|
|
|
ecore_x_window_pixmap_set(ee->prop.window, 0);
|
|
|
|
ee->engine.x.using_bg_pixmap = 0;
|
|
|
|
ecore_x_window_area_expose(ee->prop.window, 0, 0, ee->w, ee->h);
|
|
|
|
}
|
|
|
|
ee->engine.x.pmap = 0;
|
|
|
|
ee->engine.x.gc = 0;
|
|
|
|
einfo->info.drawable = ee->prop.window;
|
2010-07-27 17:17:40 -07:00
|
|
|
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
|
|
|
|
{
|
|
|
|
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
|
|
|
|
}
|
2010-09-29 10:03:38 -07:00
|
|
|
}
|
|
|
|
}
|
2010-07-27 17:17:40 -07:00
|
|
|
#endif /* BUILD_ECORE_EVAS_SOFTWARE_8_X11 */
|
|
|
|
}
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
2011-05-27 12:31:11 -07:00
|
|
|
static void
|
|
|
|
_ecore_evas_x_screen_geometry_get(const Ecore_Evas *ee __UNUSED__, int *x, int *y, int *w, int *h)
|
|
|
|
{
|
2012-07-05 05:51:05 -07:00
|
|
|
int outnum = 0;
|
|
|
|
int px = 0, py = 0, pw = 0, ph = 0;
|
|
|
|
Ecore_X_Window root;
|
|
|
|
Ecore_X_Randr_Output *out = NULL;
|
|
|
|
Ecore_X_Randr_Crtc crtc;
|
2012-08-21 01:06:53 -07:00
|
|
|
unsigned int val[4] = { 0 };
|
|
|
|
|
|
|
|
if (ecore_x_window_prop_card32_get
|
|
|
|
(ee->prop.window, ecore_x_atom_get("E_ZONE_GEOMETRY"), val, 4) == 4)
|
|
|
|
{
|
2012-08-22 01:27:06 -07:00
|
|
|
if (x) *x = (int)val[0];
|
|
|
|
if (y) *y = (int)val[1];
|
|
|
|
if (w) *w = (int)val[2];
|
|
|
|
if (h) *h = (int)val[3];
|
2012-08-21 01:06:53 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-07-05 05:51:05 -07:00
|
|
|
root = ecore_x_window_root_get(ee->prop.window);
|
|
|
|
out = ecore_x_randr_window_outputs_get(ee->prop.window, &outnum);
|
|
|
|
if (!out)
|
|
|
|
{
|
|
|
|
norandr:
|
|
|
|
if (out) free(out);
|
|
|
|
if (x) *x = 0;
|
|
|
|
if (y) *y = 0;
|
|
|
|
ecore_x_window_size_get(root, w, h);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
crtc = ecore_x_randr_output_crtc_get(root, out[0]);
|
|
|
|
if (!crtc) goto norandr;
|
|
|
|
ecore_x_randr_crtc_geometry_get(root, crtc, &px, &py, &pw, &ph);
|
|
|
|
if ((pw == 0) || (ph == 0)) goto norandr;
|
|
|
|
if (x) *x = px;
|
|
|
|
if (y) *y = py;
|
|
|
|
if (w) *w = pw;
|
|
|
|
if (h) *h = ph;
|
|
|
|
free(out);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_ecore_evas_x_screen_dpi_get(const Ecore_Evas *ee, int *xdpi, int *ydpi)
|
|
|
|
{
|
|
|
|
int scdpi, xmm = 0, ymm = 0, outnum = 0, w = 0, h = 0;
|
|
|
|
int px = 0, py = 0;
|
|
|
|
Ecore_X_Window root;
|
|
|
|
Ecore_X_Randr_Output *out = NULL;
|
|
|
|
Ecore_X_Randr_Crtc crtc;
|
|
|
|
|
|
|
|
root = ecore_x_window_root_get(ee->prop.window);
|
|
|
|
out = ecore_x_randr_window_outputs_get(ee->prop.window, &outnum);
|
|
|
|
if (!out)
|
|
|
|
{
|
|
|
|
norandr:
|
|
|
|
if (out) free(out);
|
|
|
|
scdpi = ecore_x_dpi_get();
|
|
|
|
if (xdpi) *xdpi = scdpi;
|
|
|
|
if (ydpi) *ydpi = scdpi;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
crtc = ecore_x_randr_output_crtc_get(root, out[0]);
|
|
|
|
if (!crtc) goto norandr;
|
|
|
|
ecore_x_randr_crtc_geometry_get(root, crtc, &px, &py, &w, &h);
|
|
|
|
if ((w == 0) || (h == 0)) goto norandr;
|
|
|
|
ecore_x_randr_output_size_mm_get(root, out[0], &xmm, &ymm);
|
|
|
|
if ((xmm == 0) || (ymm == 0)) goto norandr;
|
|
|
|
if (xdpi) *xdpi = (w * 254) / (xmm * 10); // 25.4mm / inch
|
|
|
|
if (ydpi) *ydpi = (h * 254) / (ymm * 10); // 25.4mm / inch
|
|
|
|
free(out);
|
2011-05-27 12:31:11 -07:00
|
|
|
}
|
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
int
|
|
|
|
_ecore_evas_x_shutdown(void)
|
|
|
|
{
|
|
|
|
_ecore_evas_init_count--;
|
|
|
|
if (_ecore_evas_init_count == 0)
|
|
|
|
{
|
2010-09-29 10:03:38 -07:00
|
|
|
unsigned int i;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2010-09-29 10:03:38 -07:00
|
|
|
for (i = 0; i < sizeof(ecore_evas_event_handlers) / sizeof(Ecore_Event_Handler*); i++)
|
2010-02-01 06:13:48 -08:00
|
|
|
{
|
|
|
|
if (ecore_evas_event_handlers[i])
|
|
|
|
ecore_event_handler_del(ecore_evas_event_handlers[i]);
|
|
|
|
}
|
2010-09-29 10:03:38 -07:00
|
|
|
ecore_event_evas_shutdown();
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
if (_ecore_evas_init_count < 0) _ecore_evas_init_count = 0;
|
|
|
|
return _ecore_evas_init_count;
|
|
|
|
}
|
|
|
|
|
2010-01-06 21:29:06 -08:00
|
|
|
static Ecore_Evas_Engine_Func _ecore_x_engine_func =
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
_ecore_evas_x_free,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_callback_delete_request_set,
|
2003-09-23 01:09:32 -07:00
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
2006-07-27 09:14:33 -07:00
|
|
|
NULL,
|
|
|
|
NULL,
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_move,
|
2005-11-03 03:32:59 -08:00
|
|
|
_ecore_evas_x_managed_move,
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_resize,
|
|
|
|
_ecore_evas_x_move_resize,
|
|
|
|
_ecore_evas_x_rotation_set,
|
|
|
|
_ecore_evas_x_shaped_set,
|
|
|
|
_ecore_evas_x_show,
|
|
|
|
_ecore_evas_x_hide,
|
|
|
|
_ecore_evas_x_raise,
|
|
|
|
_ecore_evas_x_lower,
|
2008-06-30 01:39:36 -07:00
|
|
|
_ecore_evas_x_activate,
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_title_set,
|
|
|
|
_ecore_evas_x_name_class_set,
|
|
|
|
_ecore_evas_x_size_min_set,
|
|
|
|
_ecore_evas_x_size_max_set,
|
|
|
|
_ecore_evas_x_size_base_set,
|
|
|
|
_ecore_evas_x_size_step_set,
|
2007-09-26 07:40:02 -07:00
|
|
|
_ecore_evas_x_object_cursor_set,
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_layer_set,
|
|
|
|
_ecore_evas_x_focus_set,
|
|
|
|
_ecore_evas_x_iconified_set,
|
|
|
|
_ecore_evas_x_borderless_set,
|
|
|
|
_ecore_evas_x_override_set,
|
2012-08-05 02:00:08 -07:00
|
|
|
_ecore_evas_x_maximized_set,
|
2005-06-10 23:05:51 -07:00
|
|
|
_ecore_evas_x_fullscreen_set,
|
|
|
|
_ecore_evas_x_avoid_damage_set,
|
|
|
|
_ecore_evas_x_withdrawn_set,
|
2005-10-08 05:41:59 -07:00
|
|
|
_ecore_evas_x_sticky_set,
|
2006-03-08 00:02:55 -08:00
|
|
|
_ecore_evas_x_ignore_events_set,
|
2010-01-06 21:29:06 -08:00
|
|
|
_ecore_evas_x_alpha_set,
|
2010-02-11 21:31:26 -08:00
|
|
|
_ecore_evas_x_transparent_set,
|
2012-07-03 00:44:17 -07:00
|
|
|
_ecore_evas_x_profiles_set,
|
2012-02-27 22:43:59 -08:00
|
|
|
|
|
|
|
_ecore_evas_x_window_group_set,
|
|
|
|
_ecore_evas_x_aspect_set,
|
|
|
|
_ecore_evas_x_urgent_set,
|
|
|
|
_ecore_evas_x_modal_set,
|
|
|
|
_ecore_evas_x_demand_attention_set,
|
|
|
|
_ecore_evas_x_focus_skip_set,
|
2011-04-20 07:15:33 -07:00
|
|
|
|
2011-05-27 12:31:11 -07:00
|
|
|
NULL, // render
|
2012-07-05 05:51:05 -07:00
|
|
|
_ecore_evas_x_screen_geometry_get,
|
|
|
|
_ecore_evas_x_screen_dpi_get
|
2003-09-23 01:09:32 -07:00
|
|
|
};
|
2008-07-23 03:00:01 -07:00
|
|
|
#endif /* BUILD_ECORE_EVAS_X11 */
|
2003-09-23 01:09:32 -07:00
|
|
|
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
/*
|
|
|
|
* FIXME: there are some round trips. Especially, we can split
|
2010-09-08 04:23:42 -07:00
|
|
|
* ecore_x_init in 2 functions and suppress some round trips.
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
*/
|
|
|
|
|
2012-10-15 06:02:39 -07:00
|
|
|
#if defined (BUILD_ECORE_EVAS_SOFTWARE_X11) || defined (BUILD_ECORE_EVAS_OPENGL_X11) || defined (BUILD_ECORE_EVAS_SOFTWARE_8_X11)
|
2010-02-01 06:13:48 -08:00
|
|
|
static void
|
2010-02-28 15:27:47 -08:00
|
|
|
_ecore_evas_x_flush_pre(void *data, Evas *e __UNUSED__, void *event_info __UNUSED__)
|
2010-02-01 06:13:48 -08:00
|
|
|
{
|
|
|
|
Ecore_Evas *ee = data;
|
|
|
|
|
|
|
|
if (ee->no_comp_sync) return;
|
|
|
|
if (!_ecore_evas_app_comp_sync) return;
|
|
|
|
if (ee->engine.x.sync_counter)
|
|
|
|
{
|
|
|
|
if (ee->engine.x.sync_began)
|
|
|
|
{
|
|
|
|
ee->engine.x.sync_val++;
|
|
|
|
if (!ee->engine.x.sync_cancel)
|
2010-03-16 05:31:09 -07:00
|
|
|
{
|
2011-01-30 22:21:57 -08:00
|
|
|
if (!ee->semi_sync)
|
|
|
|
ecore_x_sync_counter_val_wait(ee->engine.x.sync_counter,
|
|
|
|
ee->engine.x.sync_val);
|
2010-03-16 05:31:09 -07:00
|
|
|
}
|
2010-02-01 06:13:48 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-02-28 15:27:47 -08:00
|
|
|
_ecore_evas_x_flush_post(void *data, Evas *e __UNUSED__, void *event_info __UNUSED__)
|
2010-02-01 06:13:48 -08:00
|
|
|
{
|
|
|
|
Ecore_Evas *ee = data;
|
2010-08-24 02:26:34 -07:00
|
|
|
|
2012-07-03 00:44:17 -07:00
|
|
|
if ((!ee->no_comp_sync) && (_ecore_evas_app_comp_sync) &&
|
|
|
|
(!ee->gl_sync_draw_done)) // added by gl77.lee
|
2011-03-31 01:13:14 -07:00
|
|
|
{
|
|
|
|
if (ee->engine.x.sync_counter)
|
|
|
|
{
|
|
|
|
if (ee->engine.x.sync_began)
|
|
|
|
{
|
|
|
|
if (!ee->engine.x.sync_cancel)
|
|
|
|
{
|
|
|
|
ecore_x_e_comp_sync_draw_size_done_send
|
|
|
|
(ee->engine.x.win_root, ee->prop.window, ee->w, ee->h);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-03-30 03:10:04 -07:00
|
|
|
if (ee->engine.x.netwm_sync_set)
|
|
|
|
{
|
2011-04-20 07:15:33 -07:00
|
|
|
ecore_x_sync_counter_2_set(ee->engine.x.netwm_sync_counter,
|
|
|
|
ee->engine.x.netwm_sync_val_hi,
|
2011-03-30 03:10:04 -07:00
|
|
|
ee->engine.x.netwm_sync_val_lo);
|
|
|
|
ee->engine.x.netwm_sync_set = 0;
|
|
|
|
}
|
2010-02-01 06:13:48 -08:00
|
|
|
}
|
2010-02-03 08:05:25 -08:00
|
|
|
#endif
|
2010-02-01 06:13:48 -08:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
/**
|
2012-04-23 13:09:48 -07:00
|
|
|
* @brief Create Ecore_Evas using software x11.
|
|
|
|
* @note If ecore is not compiled with support to x11 then nothing is done and NULL is returned.
|
|
|
|
* @param disp_name The name of the Ecore_Evas to be created.
|
|
|
|
* @param parent The parent of the Ecore_Evas to be created.
|
|
|
|
* @param x The X coordinate to be used.
|
|
|
|
* @param y The Y coordinate to be used.
|
|
|
|
* @param w The width of the Ecore_Evas to be created.
|
|
|
|
* @param h The height of the Ecore_Evas to be created.
|
|
|
|
* @return A handle to the created Ecore_Evas.
|
2003-09-23 01:09:32 -07:00
|
|
|
*/
|
2009-07-14 14:18:27 -07:00
|
|
|
#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
|
2006-01-06 10:46:30 -08:00
|
|
|
EAPI Ecore_Evas *
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
ecore_evas_software_x11_new(const char *disp_name, Ecore_X_Window parent,
|
2010-09-29 10:03:38 -07:00
|
|
|
int x, int y, int w, int h)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
Evas_Engine_Info_Software_X11 *einfo;
|
|
|
|
Ecore_Evas *ee;
|
2011-07-26 04:24:10 -07:00
|
|
|
int argb = 0, rmethod;
|
2005-11-01 01:49:12 -08:00
|
|
|
static int redraw_debug = -1;
|
2011-07-26 04:24:10 -07:00
|
|
|
char *id = NULL;
|
2003-09-23 01:09:32 -07:00
|
|
|
|
|
|
|
rmethod = evas_render_method_lookup("software_x11");
|
|
|
|
if (!rmethod) return NULL;
|
|
|
|
if (!ecore_x_init(disp_name)) return NULL;
|
|
|
|
ee = calloc(1, sizeof(Ecore_Evas));
|
|
|
|
if (!ee) return NULL;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
ECORE_MAGIC_SET(ee, ECORE_MAGIC_EVAS);
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
_ecore_evas_x_init();
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
ee->engine.func = (Ecore_Evas_Engine_Func *)&_ecore_x_engine_func;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2006-03-08 00:02:55 -08:00
|
|
|
ee->driver = "software_x11";
|
2003-09-23 01:09:32 -07:00
|
|
|
if (disp_name) ee->name = strdup(disp_name);
|
|
|
|
|
|
|
|
if (w < 1) w = 1;
|
|
|
|
if (h < 1) h = 1;
|
|
|
|
ee->x = x;
|
|
|
|
ee->y = y;
|
|
|
|
ee->w = w;
|
|
|
|
ee->h = h;
|
2010-02-27 06:40:10 -08:00
|
|
|
ee->req.x = ee->x;
|
|
|
|
ee->req.y = ee->y;
|
|
|
|
ee->req.w = ee->w;
|
|
|
|
ee->req.h = ee->h;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
ee->prop.max.w = 32767;
|
|
|
|
ee->prop.max.h = 32767;
|
|
|
|
ee->prop.layer = 4;
|
2005-08-04 01:51:31 -07:00
|
|
|
ee->prop.request_pos = 0;
|
2006-07-29 07:50:18 -07:00
|
|
|
ee->prop.sticky = 0;
|
|
|
|
ee->engine.x.state.sticky = 0;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
/* init evas here */
|
|
|
|
ee->evas = evas_new();
|
2011-09-21 23:02:26 -07:00
|
|
|
evas_event_callback_add(ee->evas, EVAS_CALLBACK_RENDER_FLUSH_PRE,
|
2011-07-26 04:24:10 -07:00
|
|
|
_ecore_evas_x_flush_pre, ee);
|
2011-09-21 23:02:26 -07:00
|
|
|
evas_event_callback_add(ee->evas, EVAS_CALLBACK_RENDER_FLUSH_POST,
|
2011-07-26 04:24:10 -07:00
|
|
|
_ecore_evas_x_flush_post, ee);
|
2005-11-06 01:47:28 -08:00
|
|
|
evas_data_attach_set(ee->evas, ee);
|
2003-09-23 01:09:32 -07:00
|
|
|
evas_output_method_set(ee->evas, rmethod);
|
|
|
|
evas_output_size_set(ee->evas, w, h);
|
|
|
|
evas_output_viewport_set(ee->evas, 0, 0, w, h);
|
2005-04-25 01:28:27 -07:00
|
|
|
|
|
|
|
ee->engine.x.win_root = parent;
|
2009-09-02 05:48:56 -07:00
|
|
|
ee->engine.x.screen_num = 0;
|
2011-04-20 07:15:33 -07:00
|
|
|
|
2006-03-08 07:35:01 -08:00
|
|
|
if (parent != 0)
|
|
|
|
{
|
2009-09-02 05:48:56 -07:00
|
|
|
ee->engine.x.screen_num = 1; /* FIXME: get real scren # */
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
/* FIXME: round trip in ecore_x_window_argb_get */
|
2010-09-29 10:03:38 -07:00
|
|
|
if (ecore_x_window_argb_get(parent))
|
|
|
|
{
|
|
|
|
ee->prop.window = ecore_x_window_argb_new(parent, x, y, w, h);
|
|
|
|
argb = 1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
ee->prop.window = ecore_x_window_new(parent, x, y, w, h);
|
2006-03-08 07:35:01 -08:00
|
|
|
}
|
|
|
|
else
|
2009-03-16 09:24:43 -07:00
|
|
|
ee->prop.window = ecore_x_window_new(parent, x, y, w, h);
|
2011-07-26 04:24:10 -07:00
|
|
|
if ((id = getenv("DESKTOP_STARTUP_ID")))
|
2005-09-13 20:26:23 -07:00
|
|
|
{
|
2011-07-26 04:24:10 -07:00
|
|
|
ecore_x_netwm_startup_id_set(ee->prop.window, id);
|
2010-09-29 10:03:38 -07:00
|
|
|
/* NB: on linux this may simply empty the env as opposed to completely
|
|
|
|
* unset it to being empty - unsure as solartis libc crashes looking
|
|
|
|
* for the '=' char */
|
|
|
|
// putenv((char*)"DESKTOP_STARTUP_ID=");
|
2005-09-13 20:26:23 -07:00
|
|
|
}
|
2003-09-23 01:09:32 -07:00
|
|
|
einfo = (Evas_Engine_Info_Software_X11 *)evas_engine_info_get(ee->evas);
|
|
|
|
if (einfo)
|
|
|
|
{
|
2011-07-26 04:24:10 -07:00
|
|
|
Ecore_X_Screen *screen;
|
2004-11-19 00:16:49 -08:00
|
|
|
|
2011-07-26 04:24:10 -07:00
|
|
|
/* FIXME: this is inefficient as its 1 or more round trips */
|
2010-09-29 10:03:38 -07:00
|
|
|
screen = ecore_x_default_screen_get();
|
2011-07-26 04:24:10 -07:00
|
|
|
if (ecore_x_screen_count_get() > 1)
|
2010-09-29 10:03:38 -07:00
|
|
|
{
|
|
|
|
Ecore_X_Window *roots;
|
|
|
|
int num, i;
|
|
|
|
|
|
|
|
num = 0;
|
|
|
|
roots = ecore_x_window_root_list(&num);
|
|
|
|
if (roots)
|
|
|
|
{
|
2011-07-26 04:24:10 -07:00
|
|
|
Ecore_X_Window root;
|
2010-09-29 10:03:38 -07:00
|
|
|
|
2011-07-26 04:24:10 -07:00
|
|
|
root = ecore_x_window_root_get(parent);
|
2011-09-21 23:02:26 -07:00
|
|
|
for (i = 0; i < num; i++)
|
2010-09-29 10:03:38 -07:00
|
|
|
{
|
2011-09-21 23:02:26 -07:00
|
|
|
if (root == roots[i])
|
2010-09-29 10:03:38 -07:00
|
|
|
{
|
2011-07-26 04:24:10 -07:00
|
|
|
screen = ecore_x_screen_get(i);
|
|
|
|
break;
|
2010-09-29 10:03:38 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
free(roots);
|
|
|
|
}
|
|
|
|
}
|
2011-07-26 04:24:10 -07:00
|
|
|
|
|
|
|
einfo->info.destination_alpha = argb;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2010-09-29 10:03:38 -07:00
|
|
|
if (redraw_debug < 0)
|
|
|
|
{
|
|
|
|
if (getenv("REDRAW_DEBUG"))
|
|
|
|
redraw_debug = atoi(getenv("REDRAW_DEBUG"));
|
|
|
|
else
|
|
|
|
redraw_debug = 0;
|
|
|
|
}
|
2011-07-26 04:24:10 -07:00
|
|
|
|
2008-07-23 03:00:01 -07:00
|
|
|
# ifdef BUILD_ECORE_EVAS_SOFTWARE_XCB
|
2009-07-14 14:18:27 -07:00
|
|
|
einfo->info.backend = EVAS_ENGINE_INFO_SOFTWARE_X11_BACKEND_XCB;
|
2010-09-29 10:03:38 -07:00
|
|
|
einfo->info.connection = ecore_x_connection_get();
|
|
|
|
einfo->info.screen = screen;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
# else
|
2009-07-14 14:18:27 -07:00
|
|
|
einfo->info.backend = EVAS_ENGINE_INFO_SOFTWARE_X11_BACKEND_XLIB;
|
2010-09-29 10:03:38 -07:00
|
|
|
einfo->info.connection = ecore_x_display_get();
|
|
|
|
einfo->info.screen = NULL;
|
2011-07-26 04:24:10 -07:00
|
|
|
# endif
|
2010-09-29 10:03:38 -07:00
|
|
|
einfo->info.drawable = ee->prop.window;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2011-09-21 23:02:26 -07:00
|
|
|
if (argb)
|
2011-07-26 04:24:10 -07:00
|
|
|
{
|
2011-09-22 02:26:02 -07:00
|
|
|
Ecore_X_Window_Attributes at;
|
|
|
|
|
2011-07-26 04:24:10 -07:00
|
|
|
ecore_x_window_attributes_get(ee->prop.window, &at);
|
|
|
|
einfo->info.visual = at.visual;
|
|
|
|
einfo->info.colormap = at.colormap;
|
|
|
|
einfo->info.depth = at.depth;
|
|
|
|
einfo->info.destination_alpha = 1;
|
2010-09-29 10:03:38 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-09-21 23:02:26 -07:00
|
|
|
einfo->info.visual =
|
2011-07-26 04:24:10 -07:00
|
|
|
ecore_x_default_visual_get(einfo->info.connection, screen);
|
2011-09-21 23:02:26 -07:00
|
|
|
einfo->info.colormap =
|
2011-07-26 04:24:10 -07:00
|
|
|
ecore_x_default_colormap_get(einfo->info.connection, screen);
|
2011-09-21 23:02:26 -07:00
|
|
|
einfo->info.depth =
|
2011-07-26 04:24:10 -07:00
|
|
|
ecore_x_default_depth_get(einfo->info.connection, screen);
|
2010-09-29 10:03:38 -07:00
|
|
|
einfo->info.destination_alpha = 0;
|
|
|
|
}
|
2011-07-26 04:24:10 -07:00
|
|
|
|
2010-09-29 10:03:38 -07:00
|
|
|
einfo->info.rotation = 0;
|
2011-07-26 04:24:10 -07:00
|
|
|
einfo->info.debug = redraw_debug;
|
2010-05-17 20:50:17 -07:00
|
|
|
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
|
|
|
|
{
|
2010-09-29 09:45:49 -07:00
|
|
|
ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
|
2010-05-17 20:50:17 -07:00
|
|
|
ecore_evas_free(ee);
|
|
|
|
return NULL;
|
|
|
|
}
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
2011-04-20 07:15:33 -07:00
|
|
|
|
2012-02-27 22:43:59 -08:00
|
|
|
_ecore_evas_x_hints_update(ee);
|
2010-10-01 18:56:23 -07:00
|
|
|
_ecore_evas_x_group_leader_set(ee);
|
|
|
|
ecore_x_window_defaults_set(ee->prop.window);
|
|
|
|
_ecore_evas_x_protocols_set(ee);
|
|
|
|
_ecore_evas_x_sync_set(ee);
|
2003-09-23 01:09:32 -07:00
|
|
|
|
2010-01-06 21:29:06 -08:00
|
|
|
ee->engine.func->fn_render = _ecore_evas_x_render;
|
|
|
|
_ecore_evas_register(ee);
|
2010-01-16 04:20:56 -08:00
|
|
|
ecore_x_input_multi_select(ee->prop.window);
|
2010-12-07 19:25:23 -08:00
|
|
|
ecore_event_window_register(ee->prop.window, ee, ee->evas,
|
|
|
|
(Ecore_Event_Mouse_Move_Cb)_ecore_evas_mouse_move_process,
|
|
|
|
(Ecore_Event_Multi_Move_Cb)_ecore_evas_mouse_multi_move_process,
|
|
|
|
(Ecore_Event_Multi_Down_Cb)_ecore_evas_mouse_multi_down_process,
|
|
|
|
(Ecore_Event_Multi_Up_Cb)_ecore_evas_mouse_multi_up_process);
|
2003-09-23 01:09:32 -07:00
|
|
|
return ee;
|
2009-04-11 03:31:42 -07:00
|
|
|
}
|
2004-10-21 20:41:49 -07:00
|
|
|
#else
|
2009-04-11 03:31:42 -07:00
|
|
|
EAPI Ecore_Evas *
|
|
|
|
ecore_evas_software_x11_new(const char *disp_name __UNUSED__, Ecore_X_Window parent __UNUSED__,
|
2010-09-29 10:03:38 -07:00
|
|
|
int x __UNUSED__, int y __UNUSED__, int w __UNUSED__, int h __UNUSED__)
|
2009-04-11 03:31:42 -07:00
|
|
|
{
|
2004-10-21 20:41:49 -07:00
|
|
|
return NULL;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
2009-04-11 03:31:42 -07:00
|
|
|
#endif
|
2003-09-23 01:09:32 -07:00
|
|
|
|
2004-08-27 03:02:45 -07:00
|
|
|
/**
|
2012-04-23 13:09:48 -07:00
|
|
|
* @brief Get the window from Ecore_Evas using software x11.
|
2012-05-30 17:18:38 -07:00
|
|
|
* @note If ecore is not compiled with support for x11 or if @p ee was not
|
2012-05-28 05:24:30 -07:00
|
|
|
* created with ecore_evas_software_x11_new() then nothing is done and
|
|
|
|
* 0 is returned.
|
2012-04-23 13:09:48 -07:00
|
|
|
* @param ee The Ecore_Evas from which to get the window.
|
|
|
|
* @return The window of type Ecore_X_Window.
|
2004-08-27 03:02:45 -07:00
|
|
|
*/
|
2009-07-14 14:18:27 -07:00
|
|
|
#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
|
2006-01-06 10:46:30 -08:00
|
|
|
EAPI Ecore_X_Window
|
2008-10-29 13:12:45 -07:00
|
|
|
ecore_evas_software_x11_window_get(const Ecore_Evas *ee)
|
2004-08-27 03:02:45 -07:00
|
|
|
{
|
2012-05-28 05:24:30 -07:00
|
|
|
if (!(!strcmp(ee->driver, "software_x11"))) return 0;
|
2009-03-16 09:24:43 -07:00
|
|
|
return (Ecore_X_Window) ecore_evas_window_get(ee);
|
2009-04-11 03:31:42 -07:00
|
|
|
}
|
2008-07-23 03:00:01 -07:00
|
|
|
#else
|
2009-04-11 03:31:42 -07:00
|
|
|
EAPI Ecore_X_Window
|
|
|
|
ecore_evas_software_x11_window_get(const Ecore_Evas *ee __UNUSED__)
|
|
|
|
{
|
2008-07-23 03:00:01 -07:00
|
|
|
return 0;
|
2004-08-27 03:02:45 -07:00
|
|
|
}
|
2009-04-11 03:31:42 -07:00
|
|
|
#endif
|
2004-08-27 03:02:45 -07:00
|
|
|
|
2004-11-23 07:17:56 -08:00
|
|
|
/**
|
2012-04-23 13:09:48 -07:00
|
|
|
* @brief Set the direct_resize of Ecore_Evas using software x11.
|
|
|
|
* @note If ecore is not compiled with support to x11 then nothing is done.
|
|
|
|
* @param ee The Ecore_Evas in which to set direct resize.
|
|
|
|
* @param on Enables the resize of Ecore_Evas if equals EINA_TRUE, disables if equals EINA_FALSE.
|
2004-11-23 07:17:56 -08:00
|
|
|
*/
|
2009-07-14 14:18:27 -07:00
|
|
|
#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
|
2006-01-06 10:46:30 -08:00
|
|
|
EAPI void
|
2010-09-25 00:03:02 -07:00
|
|
|
ecore_evas_software_x11_direct_resize_set(Ecore_Evas *ee, Eina_Bool on)
|
2004-11-23 07:17:56 -08:00
|
|
|
{
|
|
|
|
ee->engine.x.direct_resize = on;
|
2005-06-25 00:23:38 -07:00
|
|
|
if (ee->prop.avoid_damage)
|
|
|
|
{
|
2010-09-29 10:03:38 -07:00
|
|
|
if (ee->engine.x.direct_resize)
|
|
|
|
{
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
/* turn this off for now
|
2010-09-29 10:03:38 -07:00
|
|
|
ee->engine.x.using_bg_pixmap = 1;
|
|
|
|
ecore_x_window_pixmap_set(ee->prop.window, ee->engine.x.pmap);
|
2005-06-29 23:32:30 -07:00
|
|
|
*/
|
2010-09-29 10:03:38 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2008-07-14 03:06:34 -07:00
|
|
|
/* turn this off too- bg pixmap is controlled by avoid damage directly
|
2010-09-29 10:03:38 -07:00
|
|
|
ee->engine.x.using_bg_pixmap = 0;
|
|
|
|
ecore_x_window_pixmap_set(ee->prop.window, 0);
|
|
|
|
ecore_x_window_area_expose(ee->prop.window, 0, 0, ee->w, ee->h);
|
2007-10-02 23:31:05 -07:00
|
|
|
*/
|
2010-09-29 10:03:38 -07:00
|
|
|
}
|
2005-06-25 00:23:38 -07:00
|
|
|
}
|
2009-04-11 03:31:42 -07:00
|
|
|
}
|
2004-11-23 07:17:56 -08:00
|
|
|
#else
|
2009-04-11 03:31:42 -07:00
|
|
|
EAPI void
|
2010-09-25 00:03:02 -07:00
|
|
|
ecore_evas_software_x11_direct_resize_set(Ecore_Evas *ee __UNUSED__, Eina_Bool on __UNUSED__)
|
2009-04-11 03:31:42 -07:00
|
|
|
{
|
2004-11-23 07:17:56 -08:00
|
|
|
}
|
2009-04-11 03:31:42 -07:00
|
|
|
#endif
|
2004-11-23 07:17:56 -08:00
|
|
|
|
|
|
|
/**
|
2012-04-23 13:09:48 -07:00
|
|
|
* @brief Gets if the Ecore_Evas is being directly resized using software x11.
|
|
|
|
* @note If ecore is not compiled with support to x11 then nothing is done and EINA_FALSE is returned.
|
|
|
|
* @param ee The Ecore_Evas from which to get direct resize.
|
|
|
|
* @return EINA_TRUE if the resize was managed directly, otherwise return EINA_FALSE.
|
2004-11-23 07:17:56 -08:00
|
|
|
*/
|
2009-07-14 14:18:27 -07:00
|
|
|
#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
|
2010-09-25 00:03:02 -07:00
|
|
|
EAPI Eina_Bool
|
2008-10-29 13:12:45 -07:00
|
|
|
ecore_evas_software_x11_direct_resize_get(const Ecore_Evas *ee)
|
2004-11-23 07:17:56 -08:00
|
|
|
{
|
|
|
|
return ee->engine.x.direct_resize;
|
2009-04-11 03:31:42 -07:00
|
|
|
}
|
2004-11-23 07:17:56 -08:00
|
|
|
#else
|
2010-09-25 00:03:02 -07:00
|
|
|
EAPI Eina_Bool
|
2009-04-11 03:31:42 -07:00
|
|
|
ecore_evas_software_x11_direct_resize_get(const Ecore_Evas *ee __UNUSED__)
|
|
|
|
{
|
2004-11-23 07:17:56 -08:00
|
|
|
return 0;
|
|
|
|
}
|
2009-04-11 03:31:42 -07:00
|
|
|
#endif
|
2004-11-23 07:17:56 -08:00
|
|
|
|
2005-09-24 02:00:23 -07:00
|
|
|
/**
|
2012-04-23 13:09:48 -07:00
|
|
|
* @brief Add extra window on Ecore_Evas using software x11.
|
|
|
|
* @note If ecore is not compiled with support to x11 then nothing is done.
|
|
|
|
* @param ee The Ecore_Evas on which to add the window.
|
|
|
|
* @param win The window to be added at the Ecore_Evas.
|
2005-09-24 02:00:23 -07:00
|
|
|
*/
|
2009-07-14 14:18:27 -07:00
|
|
|
#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
|
2006-01-06 10:46:30 -08:00
|
|
|
EAPI void
|
2005-09-24 02:00:23 -07:00
|
|
|
ecore_evas_software_x11_extra_event_window_add(Ecore_Evas *ee, Ecore_X_Window win)
|
|
|
|
{
|
|
|
|
Ecore_X_Window *winp;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2005-09-24 02:00:23 -07:00
|
|
|
winp = malloc(sizeof(Ecore_X_Window));
|
|
|
|
if (winp)
|
|
|
|
{
|
2010-09-29 10:03:38 -07:00
|
|
|
*winp = win;
|
|
|
|
ee->engine.x.win_extra = eina_list_append(ee->engine.x.win_extra, winp);
|
2010-01-16 04:20:56 -08:00
|
|
|
ecore_x_input_multi_select(win);
|
2010-12-07 19:25:23 -08:00
|
|
|
ecore_event_window_register(win, ee, ee->evas,
|
|
|
|
(Ecore_Event_Mouse_Move_Cb)_ecore_evas_mouse_move_process,
|
|
|
|
(Ecore_Event_Multi_Move_Cb)_ecore_evas_mouse_multi_move_process,
|
|
|
|
(Ecore_Event_Multi_Down_Cb)_ecore_evas_mouse_multi_down_process,
|
|
|
|
(Ecore_Event_Multi_Up_Cb)_ecore_evas_mouse_multi_up_process);
|
2005-09-24 02:00:23 -07:00
|
|
|
}
|
2009-04-11 03:31:42 -07:00
|
|
|
}
|
2005-09-24 02:00:23 -07:00
|
|
|
#else
|
2009-04-11 03:31:42 -07:00
|
|
|
EAPI void
|
|
|
|
ecore_evas_software_x11_extra_event_window_add(Ecore_Evas *ee __UNUSED__, Ecore_X_Window win __UNUSED__)
|
|
|
|
{
|
2005-09-24 02:00:23 -07:00
|
|
|
}
|
2009-04-11 03:31:42 -07:00
|
|
|
#endif
|
2005-09-24 02:00:23 -07:00
|
|
|
|
2004-11-23 07:17:56 -08:00
|
|
|
/**
|
2012-04-23 13:09:48 -07:00
|
|
|
* @brief Create Ecore_Evas using opengl x11.
|
|
|
|
* @note If ecore is not compiled with support to x11 then nothing is done and NULL is returned.
|
|
|
|
* @param disp_name The name of the display of the Ecore_Evas to be created.
|
|
|
|
* @param parent The parent of the Ecore_Evas to be created.
|
|
|
|
* @param x The X coordinate to be used.
|
|
|
|
* @param y The Y coordinate to be used.
|
|
|
|
* @param w The width of the Ecore_Evas to be created.
|
|
|
|
* @param h The height of the Ecore_Evas to be created.
|
|
|
|
* @return The new Ecore_Evas.
|
2004-11-23 07:17:56 -08:00
|
|
|
*/
|
2009-04-11 03:31:42 -07:00
|
|
|
#ifdef BUILD_ECORE_EVAS_OPENGL_X11
|
2006-01-06 10:46:30 -08:00
|
|
|
EAPI Ecore_Evas *
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
ecore_evas_gl_x11_new(const char *disp_name, Ecore_X_Window parent,
|
2010-09-29 10:03:38 -07:00
|
|
|
int x, int y, int w, int h)
|
2010-02-14 21:05:05 -08:00
|
|
|
{
|
|
|
|
return ecore_evas_gl_x11_options_new(disp_name, parent, x, y, w, h, NULL);
|
|
|
|
}
|
2011-07-25 02:29:09 -07:00
|
|
|
|
2010-02-14 21:05:05 -08:00
|
|
|
EAPI Ecore_Evas *
|
|
|
|
ecore_evas_gl_x11_options_new(const char *disp_name, Ecore_X_Window parent,
|
2010-02-14 21:26:42 -08:00
|
|
|
int x, int y, int w, int h, const int *opt)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
Ecore_Evas *ee;
|
|
|
|
int rmethod;
|
2011-07-26 04:24:10 -07:00
|
|
|
char *id = NULL;
|
2003-09-23 01:09:32 -07:00
|
|
|
|
|
|
|
rmethod = evas_render_method_lookup("gl_x11");
|
|
|
|
if (!rmethod) return NULL;
|
|
|
|
if (!ecore_x_init(disp_name)) return NULL;
|
|
|
|
ee = calloc(1, sizeof(Ecore_Evas));
|
|
|
|
if (!ee) return NULL;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
ECORE_MAGIC_SET(ee, ECORE_MAGIC_EVAS);
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2012-07-03 00:44:17 -07:00
|
|
|
ee->gl_sync_draw_done = -1; // added by gl77.lee
|
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
_ecore_evas_x_init();
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
ee->engine.func = (Ecore_Evas_Engine_Func *)&_ecore_x_engine_func;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2008-10-29 12:31:05 -07:00
|
|
|
ee->driver = "opengl_x11";
|
2012-07-03 00:44:17 -07:00
|
|
|
#if 1
|
|
|
|
ee->semi_sync = 0; // gl engine doesn't need to sync - its whole swaps
|
|
|
|
#else
|
2011-10-19 23:39:03 -07:00
|
|
|
if (!getenv("ECORE_EVAS_COMP_NOSEMISYNC"))
|
|
|
|
ee->semi_sync = 1; // gl engine doesn't need to sync - its whole swaps
|
2011-05-30 09:17:07 -07:00
|
|
|
// ee->no_comp_sync = 1; // gl engine doesn't need to sync - its whole swaps
|
2012-07-03 00:44:17 -07:00
|
|
|
#endif
|
2003-09-23 01:09:32 -07:00
|
|
|
if (disp_name) ee->name = strdup(disp_name);
|
|
|
|
|
|
|
|
if (w < 1) w = 1;
|
|
|
|
if (h < 1) h = 1;
|
|
|
|
ee->x = x;
|
|
|
|
ee->y = y;
|
|
|
|
ee->w = w;
|
|
|
|
ee->h = h;
|
2010-02-27 06:40:10 -08:00
|
|
|
ee->req.x = ee->x;
|
|
|
|
ee->req.y = ee->y;
|
|
|
|
ee->req.w = ee->w;
|
|
|
|
ee->req.h = ee->h;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
ee->prop.max.w = 32767;
|
|
|
|
ee->prop.max.h = 32767;
|
|
|
|
ee->prop.layer = 4;
|
2005-08-04 01:51:31 -07:00
|
|
|
ee->prop.request_pos = 0;
|
2006-07-29 07:50:18 -07:00
|
|
|
ee->prop.sticky = 0;
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
ee->engine.x.state.sticky = 0;
|
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
/* init evas here */
|
|
|
|
ee->evas = evas_new();
|
2010-02-01 06:13:48 -08:00
|
|
|
evas_event_callback_add(ee->evas, EVAS_CALLBACK_RENDER_FLUSH_PRE, _ecore_evas_x_flush_pre, ee);
|
|
|
|
evas_event_callback_add(ee->evas, EVAS_CALLBACK_RENDER_FLUSH_POST, _ecore_evas_x_flush_post, ee);
|
2005-11-06 01:47:28 -08:00
|
|
|
evas_data_attach_set(ee->evas, ee);
|
2003-09-23 01:09:32 -07:00
|
|
|
evas_output_method_set(ee->evas, rmethod);
|
|
|
|
evas_output_size_set(ee->evas, w, h);
|
|
|
|
evas_output_viewport_set(ee->evas, 0, 0, w, h);
|
2006-03-08 00:02:55 -08:00
|
|
|
|
|
|
|
if (parent == 0) parent = DefaultRootWindow(ecore_x_display_get());
|
2005-04-25 01:28:27 -07:00
|
|
|
ee->engine.x.win_root = parent;
|
2009-06-23 02:55:47 -07:00
|
|
|
|
2010-02-28 20:44:36 -08:00
|
|
|
if (ee->engine.x.win_root != 0)
|
|
|
|
{
|
|
|
|
ee->engine.x.screen_num = 1; /* FIXME: get real scren # */
|
|
|
|
/* FIXME: round trip in ecore_x_window_argb_get */
|
2010-09-29 10:03:38 -07:00
|
|
|
if (ecore_x_window_argb_get(ee->engine.x.win_root))
|
|
|
|
{
|
2010-02-28 20:44:36 -08:00
|
|
|
ee->prop.window = _ecore_evas_x_gl_window_new
|
|
|
|
(ee, ee->engine.x.win_root, x, y, w, h, 0, 1, opt);
|
2010-09-29 10:03:38 -07:00
|
|
|
}
|
|
|
|
else
|
2010-02-28 20:44:36 -08:00
|
|
|
ee->prop.window = _ecore_evas_x_gl_window_new
|
|
|
|
(ee, ee->engine.x.win_root, x, y, w, h, 0, 0, opt);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
ee->prop.window = _ecore_evas_x_gl_window_new
|
|
|
|
(ee, ee->engine.x.win_root, x, y, w, h, 0, 0, opt);
|
2010-02-14 21:26:42 -08:00
|
|
|
if (!ee->prop.window)
|
|
|
|
{
|
2011-07-28 23:20:55 -07:00
|
|
|
ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
|
2010-02-14 21:26:42 -08:00
|
|
|
ecore_evas_free(ee);
|
|
|
|
return NULL;
|
|
|
|
}
|
2011-07-26 04:24:10 -07:00
|
|
|
if ((id = getenv("DESKTOP_STARTUP_ID")))
|
2005-09-13 20:26:23 -07:00
|
|
|
{
|
2011-07-26 04:24:10 -07:00
|
|
|
ecore_x_netwm_startup_id_set(ee->prop.window, id);
|
2010-09-29 10:03:38 -07:00
|
|
|
/* NB: on linux this may simply empty the env as opposed to completely
|
|
|
|
* unset it to being empty - unsure as solartis libc crashes looking
|
|
|
|
* for the '=' char */
|
|
|
|
// putenv((char*)"DESKTOP_STARTUP_ID=");
|
2005-09-13 20:26:23 -07:00
|
|
|
}
|
2003-09-23 01:09:32 -07:00
|
|
|
|
2012-02-27 22:43:59 -08:00
|
|
|
_ecore_evas_x_hints_update(ee);
|
2010-10-01 18:56:23 -07:00
|
|
|
_ecore_evas_x_group_leader_set(ee);
|
|
|
|
ecore_x_window_defaults_set(ee->prop.window);
|
|
|
|
_ecore_evas_x_protocols_set(ee);
|
|
|
|
_ecore_evas_x_sync_set(ee);
|
|
|
|
|
2010-01-06 21:29:06 -08:00
|
|
|
ee->engine.func->fn_render = _ecore_evas_x_render;
|
|
|
|
_ecore_evas_register(ee);
|
2010-01-16 04:20:56 -08:00
|
|
|
ecore_x_input_multi_select(ee->prop.window);
|
2010-12-07 19:25:23 -08:00
|
|
|
ecore_event_window_register(ee->prop.window, ee, ee->evas,
|
|
|
|
(Ecore_Event_Mouse_Move_Cb)_ecore_evas_mouse_move_process,
|
|
|
|
(Ecore_Event_Multi_Move_Cb)_ecore_evas_mouse_multi_move_process,
|
|
|
|
(Ecore_Event_Multi_Down_Cb)_ecore_evas_mouse_multi_down_process,
|
|
|
|
(Ecore_Event_Multi_Up_Cb)_ecore_evas_mouse_multi_up_process);
|
Here is ecore_x with XCB backend.
* The XCB backend is disabled by default during the
configuration. To enable it, add --enable-ecore-x-xcb. See the
messages that configure displays when it finishes.
* The way XCB is detected, and used in src/lib/ecore_x/Makefile.am
should be improved
* Any program that uses ecore_evas does not need to be modified.
Any program that uses ecore_x may need some changes. That is,
adding some functions (_prefetch and _fetch ones). No other
change is needed. See the documention of any _get functions, as
these are the ones that need those functions.
* There are some missing parts, especially everything that involves
the keyboard, as porting Xlib functions related to strings (utf8
stuff, XKeysymToString, etc...) is an horror. So keyboard events
are not working yet.
* I tried to write as much documentation as I could. But there is
certainly some missing doc here and there.
there are certainly other things that I have forgotten.
Improvements of that backend:
* the creation of an ecore_evas is faster. Especially when done over
an ssh connection (on my computer, 7-10s with Xlib, 1.5s with XCB,
over an ssh)
* A Window Manager should be more responsive. But it's not tomorrow
that e17 will use it :)
Have fun !
SVN revision: 29500
2007-04-13 10:15:19 -07:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
return ee;
|
2009-04-11 03:31:42 -07:00
|
|
|
}
|
2004-10-21 20:41:49 -07:00
|
|
|
#else
|
2009-04-11 03:31:42 -07:00
|
|
|
EAPI Ecore_Evas *
|
|
|
|
ecore_evas_gl_x11_new(const char *disp_name __UNUSED__, Ecore_X_Window parent __UNUSED__,
|
2010-09-29 10:03:38 -07:00
|
|
|
int x __UNUSED__, int y __UNUSED__, int w __UNUSED__, int h __UNUSED__)
|
2009-04-11 03:31:42 -07:00
|
|
|
{
|
2004-10-21 20:41:49 -07:00
|
|
|
return NULL;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
2010-03-01 17:43:45 -08:00
|
|
|
EAPI Ecore_Evas *
|
2011-02-20 08:39:43 -08:00
|
|
|
ecore_evas_gl_x11_options_new(const char *disp_name __UNUSED__, Ecore_X_Window parent __UNUSED__,
|
|
|
|
int x __UNUSED__, int y __UNUSED__, int w __UNUSED__, int h __UNUSED__, const int *opt __UNUSED__)
|
2010-03-01 17:43:45 -08:00
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
2009-04-11 03:31:42 -07:00
|
|
|
#endif /* ! BUILD_ECORE_EVAS_OPENGL_X11 */
|
2004-08-27 02:37:14 -07:00
|
|
|
|
|
|
|
/**
|
2012-04-23 13:09:48 -07:00
|
|
|
* @brief Get the window from Ecore_Evas using opengl x11.
|
2012-05-30 17:18:38 -07:00
|
|
|
* @note If ecore is not compiled with support for x11 or if @p ee was not
|
2012-05-28 05:24:30 -07:00
|
|
|
* created with ecore_evas_gl_x11_new() then nothing is done and
|
|
|
|
* 0 is returned.
|
2012-04-23 13:09:48 -07:00
|
|
|
* @param ee The Ecore_Evas from which to get the window.
|
|
|
|
* @return The window of type Ecore_X_Window of Ecore_Evas.
|
2004-08-27 02:37:14 -07:00
|
|
|
*/
|
2009-04-11 03:31:42 -07:00
|
|
|
#ifdef BUILD_ECORE_EVAS_OPENGL_X11
|
2006-01-06 10:46:30 -08:00
|
|
|
EAPI Ecore_X_Window
|
2008-10-29 13:12:45 -07:00
|
|
|
ecore_evas_gl_x11_window_get(const Ecore_Evas *ee)
|
2004-08-27 02:37:14 -07:00
|
|
|
{
|
2012-05-28 05:24:30 -07:00
|
|
|
if (!(!strcmp(ee->driver, "opengl_x11"))) return 0;
|
2009-03-16 09:24:43 -07:00
|
|
|
return (Ecore_X_Window) ecore_evas_window_get(ee);
|
2009-04-11 03:31:42 -07:00
|
|
|
}
|
2008-07-23 03:00:01 -07:00
|
|
|
#else
|
2009-04-11 03:31:42 -07:00
|
|
|
EAPI Ecore_X_Window
|
|
|
|
ecore_evas_gl_x11_window_get(const Ecore_Evas *ee __UNUSED__)
|
|
|
|
{
|
2008-07-23 03:00:01 -07:00
|
|
|
return 0;
|
2004-10-21 20:41:49 -07:00
|
|
|
}
|
2009-04-11 03:31:42 -07:00
|
|
|
#endif /* ! BUILD_ECORE_EVAS_OPENGL_X11 */
|
2004-11-23 07:17:56 -08:00
|
|
|
|
|
|
|
/**
|
2012-04-23 13:09:48 -07:00
|
|
|
* @brief Set direct_resize for Ecore_Evas using opengl x11.
|
|
|
|
* @note If ecore is not compiled with support to x11 then nothing is done.
|
|
|
|
* @param ee The Ecore_Evas in which to set direct resize.
|
|
|
|
* @param on Enables the resize of Ecore_Evas if equals EINA_TRUE, disables if equals EINA_FALSE.
|
2004-11-23 07:17:56 -08:00
|
|
|
*/
|
2009-04-11 03:31:42 -07:00
|
|
|
#ifdef BUILD_ECORE_EVAS_OPENGL_X11
|
2006-01-06 10:46:30 -08:00
|
|
|
EAPI void
|
2010-09-25 00:03:02 -07:00
|
|
|
ecore_evas_gl_x11_direct_resize_set(Ecore_Evas *ee, Eina_Bool on)
|
2004-11-23 07:17:56 -08:00
|
|
|
{
|
|
|
|
ee->engine.x.direct_resize = on;
|
2009-04-11 03:31:42 -07:00
|
|
|
}
|
2004-11-23 07:17:56 -08:00
|
|
|
#else
|
2009-04-11 03:31:42 -07:00
|
|
|
EAPI void
|
2010-09-25 00:03:02 -07:00
|
|
|
ecore_evas_gl_x11_direct_resize_set(Ecore_Evas *ee __UNUSED__, Eina_Bool on __UNUSED__)
|
2009-04-11 03:31:42 -07:00
|
|
|
{
|
2004-11-23 07:17:56 -08:00
|
|
|
}
|
2009-04-11 03:31:42 -07:00
|
|
|
#endif /* ! BUILD_ECORE_EVAS_OPENGL_X11 */
|
2004-11-23 07:17:56 -08:00
|
|
|
|
|
|
|
/**
|
2012-04-23 13:09:48 -07:00
|
|
|
* @brief Gets if the Ecore_Evas is being directly resized using opengl x11.
|
|
|
|
* @note If ecore is not compiled with support to x11 then nothing is done and EINA_FALSE is returned.
|
|
|
|
* @param ee The Ecore_Evas from which to get direct resize.
|
|
|
|
* @return EINA_TRUE if the resize was managed directly, otherwise return EINA_FALSE.
|
2004-11-23 07:17:56 -08:00
|
|
|
*/
|
2009-04-11 03:31:42 -07:00
|
|
|
#ifdef BUILD_ECORE_EVAS_OPENGL_X11
|
2010-09-25 00:03:02 -07:00
|
|
|
EAPI Eina_Bool
|
2008-10-29 13:12:45 -07:00
|
|
|
ecore_evas_gl_x11_direct_resize_get(const Ecore_Evas *ee)
|
2004-11-23 07:17:56 -08:00
|
|
|
{
|
|
|
|
return ee->engine.x.direct_resize;
|
2009-04-11 03:31:42 -07:00
|
|
|
}
|
2004-11-23 07:17:56 -08:00
|
|
|
#else
|
2010-09-25 00:03:02 -07:00
|
|
|
EAPI Eina_Bool
|
2009-04-11 03:31:42 -07:00
|
|
|
ecore_evas_gl_x11_direct_resize_get(const Ecore_Evas *ee __UNUSED__)
|
|
|
|
{
|
2004-11-23 07:17:56 -08:00
|
|
|
return 0;
|
|
|
|
}
|
2009-04-11 03:31:42 -07:00
|
|
|
#endif /* ! BUILD_ECORE_EVAS_OPENGL_X11 */
|
2004-11-23 07:17:56 -08:00
|
|
|
|
2005-09-24 02:00:23 -07:00
|
|
|
/**
|
2012-04-23 13:09:48 -07:00
|
|
|
* @brief Add extra window on Ecore_Evas using opengl x11.
|
|
|
|
* @note If ecore is not compiled with support to x11 then nothing is done.
|
|
|
|
* @param ee The Ecore_Evas for which to add the window.
|
|
|
|
* @param win The window to be added at the Ecore_Evas.
|
2005-09-24 02:00:23 -07:00
|
|
|
*/
|
2009-04-11 03:31:42 -07:00
|
|
|
#ifdef BUILD_ECORE_EVAS_OPENGL_X11
|
2006-01-06 10:46:30 -08:00
|
|
|
EAPI void
|
2005-09-24 02:00:23 -07:00
|
|
|
ecore_evas_gl_x11_extra_event_window_add(Ecore_Evas *ee, Ecore_X_Window win)
|
|
|
|
{
|
|
|
|
ecore_evas_software_x11_extra_event_window_add(ee, win);
|
|
|
|
}
|
2009-04-11 03:31:42 -07:00
|
|
|
#else
|
|
|
|
EAPI void
|
|
|
|
ecore_evas_gl_x11_extra_event_window_add(Ecore_Evas *ee __UNUSED__, Ecore_X_Window win __UNUSED__)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif /* ! BUILD_ECORE_EVAS_OPENGL_X11 */
|
2005-09-24 02:00:23 -07:00
|
|
|
|
2010-01-24 03:01:39 -08:00
|
|
|
/**
|
2012-04-23 13:09:48 -07:00
|
|
|
* @brief Set the functions to be used before and after the swap callback.
|
|
|
|
* @note If ecore is not compiled with support to x11 then nothing is done and the function is returned.
|
|
|
|
* @param ee The Ecore_Evas for which to set the swap callback.
|
|
|
|
* @param data The data for which to set the swap callback.
|
|
|
|
* @param pre_cb The function to be called before the callback.
|
|
|
|
* @param post_cb The function to be called after the callback.
|
2010-01-24 03:01:39 -08:00
|
|
|
*/
|
|
|
|
#ifdef BUILD_ECORE_EVAS_OPENGL_X11
|
|
|
|
EAPI void
|
|
|
|
ecore_evas_gl_x11_pre_post_swap_callback_set(const Ecore_Evas *ee, void *data, void (*pre_cb) (void *data, Evas *e), void (*post_cb) (void *data, Evas *e))
|
|
|
|
{
|
|
|
|
Evas_Engine_Info_GL_X11 *einfo;
|
2011-04-20 07:15:33 -07:00
|
|
|
|
2010-01-24 03:01:39 -08:00
|
|
|
if (!(!strcmp(ee->driver, "opengl_x11"))) return;
|
2011-04-20 07:15:33 -07:00
|
|
|
|
2010-01-24 03:01:39 -08:00
|
|
|
einfo = (Evas_Engine_Info_GL_X11 *)evas_engine_info_get(ee->evas);
|
|
|
|
if (einfo)
|
|
|
|
{
|
|
|
|
einfo->callback.pre_swap = pre_cb;
|
2011-08-25 01:14:21 -07:00
|
|
|
einfo->callback.post_swap = post_cb;
|
2010-01-24 03:01:39 -08:00
|
|
|
einfo->callback.data = data;
|
2010-09-29 10:03:38 -07:00
|
|
|
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
|
2010-05-17 20:50:17 -07:00
|
|
|
{
|
|
|
|
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
|
|
|
|
}
|
2010-01-24 03:01:39 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
EAPI void
|
2011-02-20 08:39:43 -08:00
|
|
|
ecore_evas_gl_x11_pre_post_swap_callback_set(const Ecore_Evas *ee __UNUSED__, void *data __UNUSED__, void (*pre_cb) (void *data, Evas *e) __UNUSED__, void (*post_cb) (void *data, Evas *e) __UNUSED__)
|
2010-01-24 03:01:39 -08:00
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif /* ! BUILD_ECORE_EVAS_OPENGL_X11 */
|
|
|
|
|
2009-04-11 03:31:42 -07:00
|
|
|
EAPI Ecore_Evas *
|
|
|
|
ecore_evas_xrender_x11_new(const char *disp_name __UNUSED__, Ecore_X_Window parent __UNUSED__,
|
|
|
|
int x __UNUSED__, int y __UNUSED__, int w __UNUSED__, int h __UNUSED__)
|
|
|
|
{
|
2005-10-02 23:45:45 -07:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-04-11 03:31:42 -07:00
|
|
|
EAPI Ecore_X_Window
|
|
|
|
ecore_evas_xrender_x11_window_get(const Ecore_Evas *ee __UNUSED__)
|
|
|
|
{
|
2008-07-23 03:00:01 -07:00
|
|
|
return 0;
|
2005-10-02 23:45:45 -07:00
|
|
|
}
|
|
|
|
|
2009-04-11 03:31:42 -07:00
|
|
|
EAPI void
|
2010-09-25 00:03:02 -07:00
|
|
|
ecore_evas_xrender_x11_direct_resize_set(Ecore_Evas *ee __UNUSED__, Eina_Bool on __UNUSED__)
|
2009-04-11 03:31:42 -07:00
|
|
|
{
|
2005-10-02 23:45:45 -07:00
|
|
|
}
|
|
|
|
|
2010-09-25 00:03:02 -07:00
|
|
|
EAPI Eina_Bool
|
2009-04-11 03:31:42 -07:00
|
|
|
ecore_evas_xrender_x11_direct_resize_get(const Ecore_Evas *ee __UNUSED__)
|
|
|
|
{
|
2005-10-02 23:45:45 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-04-11 03:31:42 -07:00
|
|
|
EAPI void
|
|
|
|
ecore_evas_xrender_x11_extra_event_window_add(Ecore_Evas *ee __UNUSED__, Ecore_X_Window win __UNUSED__)
|
|
|
|
{
|
2005-10-02 23:45:45 -07:00
|
|
|
}
|
2007-06-21 15:49:36 -07:00
|
|
|
|
2009-04-11 03:31:42 -07:00
|
|
|
EAPI Ecore_Evas *
|
|
|
|
ecore_evas_software_x11_16_new(const char *disp_name __UNUSED__, Ecore_X_Window parent __UNUSED__,
|
|
|
|
int x __UNUSED__, int y __UNUSED__, int w __UNUSED__, int h __UNUSED__)
|
|
|
|
{
|
2007-06-21 15:49:36 -07:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-04-11 03:31:42 -07:00
|
|
|
EAPI Ecore_X_Window
|
|
|
|
ecore_evas_software_x11_16_window_get(const Ecore_Evas *ee __UNUSED__)
|
|
|
|
{
|
2008-07-23 03:00:01 -07:00
|
|
|
return 0;
|
2007-06-21 15:49:36 -07:00
|
|
|
}
|
|
|
|
|
2009-04-11 03:31:42 -07:00
|
|
|
EAPI void
|
2010-09-25 00:03:02 -07:00
|
|
|
ecore_evas_software_x11_16_direct_resize_set(Ecore_Evas *ee __UNUSED__, Eina_Bool on __UNUSED__)
|
2009-04-11 03:31:42 -07:00
|
|
|
{
|
2007-06-21 15:49:36 -07:00
|
|
|
}
|
|
|
|
|
2010-09-25 00:03:02 -07:00
|
|
|
EAPI Eina_Bool
|
2009-04-11 03:31:42 -07:00
|
|
|
ecore_evas_software_x11_16_direct_resize_get(const Ecore_Evas *ee __UNUSED__)
|
|
|
|
{
|
2007-06-21 15:49:36 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-04-11 03:31:42 -07:00
|
|
|
EAPI void
|
|
|
|
ecore_evas_software_x11_16_extra_event_window_add(Ecore_Evas *ee __UNUSED__, Ecore_X_Window win __UNUSED__)
|
|
|
|
{
|
2007-06-21 15:49:36 -07:00
|
|
|
}
|
2010-07-27 17:17:40 -07:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
2012-04-23 13:09:48 -07:00
|
|
|
* @brief Create Ecore_Evas using software 8 x11.
|
|
|
|
* @note If ecore is not compiled with support to x11 then nothing is done and NULL is returned.
|
|
|
|
* @param disp_name The name of the display of the Ecore_Evas to be created.
|
|
|
|
* @param parent The parent of the Ecore_Evas to be created.
|
|
|
|
* @param x The X coordinate to be used.
|
|
|
|
* @param y The Y coordinate to be used.
|
|
|
|
* @param w The width of the Ecore_Evas to be created.
|
|
|
|
* @param h The height of the Ecore_Evas to be created.
|
|
|
|
* @return The new Ecore_Evas.
|
2010-07-27 17:17:40 -07:00
|
|
|
*/
|
|
|
|
EAPI Ecore_Evas *
|
|
|
|
ecore_evas_software_x11_8_new(const char *disp_name, Ecore_X_Window parent,
|
2010-08-19 07:41:24 -07:00
|
|
|
int x, int y, int w, int h)
|
2010-07-27 17:17:40 -07:00
|
|
|
{
|
|
|
|
#if defined (BUILD_ECORE_EVAS_SOFTWARE_8_X11)
|
|
|
|
Evas_Engine_Info_Software_8_X11 *einfo;
|
|
|
|
Ecore_Evas *ee;
|
|
|
|
int argb = 0;
|
|
|
|
int rmethod;
|
|
|
|
static int redraw_debug = -1;
|
|
|
|
|
|
|
|
rmethod = evas_render_method_lookup("software_8_x11");
|
|
|
|
if (!rmethod) return NULL;
|
|
|
|
if (!ecore_x_init(disp_name)) return NULL;
|
|
|
|
ee = calloc(1, sizeof(Ecore_Evas));
|
|
|
|
if (!ee) return NULL;
|
|
|
|
|
|
|
|
ECORE_MAGIC_SET(ee, ECORE_MAGIC_EVAS);
|
|
|
|
|
|
|
|
_ecore_evas_x_init();
|
|
|
|
|
|
|
|
ee->engine.func = (Ecore_Evas_Engine_Func *)&_ecore_x_engine_func;
|
|
|
|
|
|
|
|
ee->driver = "software_8_x11";
|
|
|
|
if (disp_name) ee->name = strdup(disp_name);
|
|
|
|
|
|
|
|
if (w < 1) w = 1;
|
|
|
|
if (h < 1) h = 1;
|
|
|
|
ee->x = x;
|
|
|
|
ee->y = y;
|
|
|
|
ee->w = w;
|
|
|
|
ee->h = h;
|
|
|
|
ee->req.x = ee->x;
|
|
|
|
ee->req.y = ee->y;
|
|
|
|
ee->req.w = ee->w;
|
|
|
|
ee->req.h = ee->h;
|
|
|
|
|
|
|
|
ee->prop.max.w = 32767;
|
|
|
|
ee->prop.max.h = 32767;
|
|
|
|
ee->prop.layer = 4;
|
|
|
|
ee->prop.request_pos = 0;
|
|
|
|
ee->prop.sticky = 0;
|
|
|
|
ee->engine.x.state.sticky = 0;
|
|
|
|
|
|
|
|
/* init evas here */
|
|
|
|
ee->evas = evas_new();
|
|
|
|
evas_event_callback_add(ee->evas, EVAS_CALLBACK_RENDER_FLUSH_PRE, _ecore_evas_x_flush_pre, ee);
|
|
|
|
evas_event_callback_add(ee->evas, EVAS_CALLBACK_RENDER_FLUSH_POST, _ecore_evas_x_flush_post, ee);
|
|
|
|
evas_data_attach_set(ee->evas, ee);
|
|
|
|
evas_output_method_set(ee->evas, rmethod);
|
|
|
|
evas_output_size_set(ee->evas, w, h);
|
|
|
|
evas_output_viewport_set(ee->evas, 0, 0, w, h);
|
|
|
|
|
|
|
|
ee->engine.x.win_root = parent;
|
|
|
|
// if (parent != 0)
|
|
|
|
// {
|
|
|
|
// /* FIXME: round trip in ecore_x_window_argb_get */
|
2010-09-29 10:03:38 -07:00
|
|
|
// if (ecore_x_window_argb_get(parent))
|
|
|
|
// {
|
|
|
|
// ee->engine.x.win = ecore_x_window_argb_new(parent, x, y, w, h);
|
|
|
|
// argb = 1;
|
|
|
|
// }
|
|
|
|
// else
|
|
|
|
// ee->engine.x.win = ecore_x_window_new(parent, x, y, w, h);
|
2010-07-27 17:17:40 -07:00
|
|
|
// }
|
|
|
|
// else
|
|
|
|
ee->prop.window = ecore_x_window_new(parent, x, y, w, h);
|
|
|
|
if (getenv("DESKTOP_STARTUP_ID"))
|
|
|
|
{
|
2010-09-29 10:03:38 -07:00
|
|
|
ecore_x_netwm_startup_id_set(ee->prop.window,
|
|
|
|
getenv("DESKTOP_STARTUP_ID"));
|
|
|
|
/* NB: on linux this may simply empty the env as opposed to completely
|
|
|
|
* unset it to being empty - unsure as solartis libc crashes looking
|
|
|
|
* for the '=' char */
|
|
|
|
// putenv((char*)"DESKTOP_STARTUP_ID=");
|
2010-07-27 17:17:40 -07:00
|
|
|
}
|
|
|
|
einfo = (Evas_Engine_Info_Software_8_X11 *)evas_engine_info_get(ee->evas);
|
|
|
|
if (einfo)
|
|
|
|
{
|
2010-09-29 10:03:38 -07:00
|
|
|
xcb_screen_iterator_t iter;
|
|
|
|
xcb_screen_t *screen;
|
|
|
|
|
|
|
|
/* FIXME: this is inefficient as its a round trip */
|
|
|
|
//einfo->info.backend = 1;
|
|
|
|
screen = ecore_x_default_screen_get();
|
|
|
|
iter = xcb_setup_roots_iterator (xcb_get_setup (ecore_x_connection_get()));
|
|
|
|
if (iter.rem > 1)
|
|
|
|
{
|
|
|
|
xcb_get_geometry_cookie_t cookie;
|
|
|
|
xcb_get_geometry_reply_t *reply;
|
|
|
|
Ecore_X_Window *roots;
|
|
|
|
int num;
|
|
|
|
uint8_t i;
|
|
|
|
|
|
|
|
num = 0;
|
|
|
|
cookie = xcb_get_geometry_unchecked(ecore_x_connection_get(), parent);
|
|
|
|
roots = ecore_x_window_root_list(&num);
|
|
|
|
if (roots)
|
|
|
|
{
|
|
|
|
reply = xcb_get_geometry_reply(ecore_x_connection_get(), cookie, NULL);
|
|
|
|
|
|
|
|
if (reply)
|
|
|
|
{
|
|
|
|
for (i = 0; i < num; xcb_screen_next (&iter), i++)
|
|
|
|
{
|
|
|
|
if (reply->root == roots[i])
|
|
|
|
{
|
|
|
|
screen = iter.data;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free(reply);
|
|
|
|
}
|
|
|
|
free(roots);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
reply = xcb_get_geometry_reply(ecore_x_connection_get(), cookie, NULL);
|
|
|
|
if (reply) free(reply);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (redraw_debug < 0)
|
|
|
|
{
|
|
|
|
if (getenv("REDRAW_DEBUG"))
|
|
|
|
redraw_debug = atoi(getenv("REDRAW_DEBUG"));
|
|
|
|
else
|
|
|
|
redraw_debug = 0;
|
|
|
|
}
|
|
|
|
einfo->info.connection = ecore_x_connection_get();
|
|
|
|
einfo->info.screen = screen;
|
|
|
|
einfo->info.drawable = ee->prop.window;
|
|
|
|
if (argb)
|
|
|
|
{
|
|
|
|
/* FIXME: round trip */
|
|
|
|
xcb_get_geometry_cookie_t cookie_geom;
|
|
|
|
xcb_get_window_attributes_cookie_t cookie_attr;
|
|
|
|
xcb_get_geometry_reply_t *reply_geom;
|
|
|
|
xcb_get_window_attributes_reply_t *reply_attr;
|
|
|
|
|
|
|
|
cookie_geom = xcb_get_geometry_unchecked(ecore_x_connection_get(), ee->prop.window);
|
|
|
|
cookie_attr = xcb_get_window_attributes_unchecked(ecore_x_connection_get(), ee->prop.window);
|
|
|
|
|
|
|
|
reply_geom = xcb_get_geometry_reply(ecore_x_connection_get(), cookie_geom, NULL);
|
|
|
|
reply_attr = xcb_get_window_attributes_reply(ecore_x_connection_get(), cookie_attr, NULL);
|
|
|
|
if (reply_attr && reply_geom)
|
|
|
|
{
|
|
|
|
einfo->info.visual = xcb_visualtype_get(ecore_x_default_screen_get(), reply_attr->visual);
|
|
|
|
einfo->info.colormap = reply_attr->colormap;
|
|
|
|
einfo->info.depth = reply_geom->depth;
|
|
|
|
einfo->info.destination_alpha = 1;
|
|
|
|
free(reply_geom);
|
|
|
|
free(reply_attr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
xcb_screen_t *screen;
|
|
|
|
|
|
|
|
screen = ecore_x_default_screen_get();
|
|
|
|
einfo->info.visual = xcb_visualtype_get(screen, screen->root_visual);
|
|
|
|
einfo->info.colormap = screen->default_colormap;
|
|
|
|
einfo->info.depth = screen->root_depth;
|
|
|
|
einfo->info.destination_alpha = 0;
|
|
|
|
}
|
|
|
|
einfo->info.rotation = 0;
|
|
|
|
einfo->info.debug = redraw_debug;
|
2010-09-29 09:45:49 -07:00
|
|
|
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
|
|
|
|
{
|
|
|
|
ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
|
|
|
|
ecore_evas_free(ee);
|
|
|
|
return NULL;
|
|
|
|
}
|
2010-07-27 17:17:40 -07:00
|
|
|
}
|
2011-07-28 23:20:55 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
|
|
|
|
ecore_evas_free(ee);
|
|
|
|
return NULL;
|
|
|
|
}
|
2010-07-27 17:17:40 -07:00
|
|
|
|
2012-02-27 22:43:59 -08:00
|
|
|
_ecore_evas_x_hints_update(ee);
|
2010-10-01 18:56:23 -07:00
|
|
|
_ecore_evas_x_group_leader_set(ee);
|
|
|
|
ecore_x_window_defaults_set(ee->prop.window);
|
|
|
|
_ecore_evas_x_protocols_set(ee);
|
|
|
|
_ecore_evas_x_sync_set(ee);
|
2010-07-27 17:17:40 -07:00
|
|
|
|
|
|
|
ee->engine.func->fn_render = _ecore_evas_x_render;
|
|
|
|
_ecore_evas_register(ee);
|
|
|
|
ecore_x_input_multi_select(ee->prop.window);
|
2010-12-07 19:25:23 -08:00
|
|
|
ecore_event_window_register(ee->prop.window, ee, ee->evas,
|
|
|
|
(Ecore_Event_Mouse_Move_Cb)_ecore_evas_mouse_move_process,
|
|
|
|
(Ecore_Event_Multi_Move_Cb)_ecore_evas_mouse_multi_move_process,
|
|
|
|
(Ecore_Event_Multi_Down_Cb)_ecore_evas_mouse_multi_down_process,
|
|
|
|
(Ecore_Event_Multi_Up_Cb)_ecore_evas_mouse_multi_up_process);
|
2010-07-27 17:17:40 -07:00
|
|
|
|
|
|
|
return ee;
|
|
|
|
#else
|
|
|
|
return NULL;
|
2011-08-23 05:04:52 -07:00
|
|
|
(void)(disp_name);
|
|
|
|
(void)(parent);
|
|
|
|
(void)(x);
|
|
|
|
(void)(y);
|
|
|
|
(void)(w);
|
|
|
|
(void)(h);
|
2010-07-27 17:17:40 -07:00
|
|
|
#endif /* ! BUILD_ECORE_EVAS_SOFTWARE_8_X11 */
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2012-04-23 13:09:48 -07:00
|
|
|
* @brief Get window from Ecore_Evas using software 8 x11.
|
2012-05-30 17:18:38 -07:00
|
|
|
* @note If ecore is not compiled with support for x11 or if @p ee was not
|
2012-05-28 05:24:30 -07:00
|
|
|
* created with ecore_evas_software_x11_8_new() then nothing is done and
|
|
|
|
* 0 is returned.
|
2012-04-23 13:09:48 -07:00
|
|
|
* @param ee The Ecore_Evas from which to get the window.
|
|
|
|
* @return The window of type Ecore_X_Window of Ecore_Evas.
|
2010-07-27 17:17:40 -07:00
|
|
|
*/
|
|
|
|
EAPI Ecore_X_Window
|
|
|
|
ecore_evas_software_x11_8_window_get(const Ecore_Evas *ee)
|
|
|
|
{
|
|
|
|
#if defined (BUILD_ECORE_EVAS_SOFTWARE_8_X11)
|
2012-05-28 05:24:30 -07:00
|
|
|
if (!(!strcmp(ee->driver, "software_8_x11"))) return 0;
|
2010-07-27 17:17:40 -07:00
|
|
|
return (Ecore_X_Window) ecore_evas_window_get(ee);
|
|
|
|
#else
|
|
|
|
return 0;
|
2011-08-23 05:04:52 -07:00
|
|
|
(void)(ee);
|
2010-07-27 17:17:40 -07:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2012-04-23 13:09:48 -07:00
|
|
|
* @brief Get subwindow from Ecore_Evas using software 8 x11.
|
2012-05-30 17:18:38 -07:00
|
|
|
* @note If ecore is not compiled with support for x11 or if @p ee was not
|
2012-05-28 05:24:30 -07:00
|
|
|
* created with ecore_evas_software_x11_8_new() then nothing is done and
|
|
|
|
* 0 is returned.
|
2012-04-23 13:09:48 -07:00
|
|
|
* @param ee The Ecore_Evas from which to get the subwindow.
|
|
|
|
* @return The window of type Ecore_X_Window of Ecore_Evas.
|
2010-07-27 17:17:40 -07:00
|
|
|
*/
|
|
|
|
EAPI Ecore_X_Window
|
|
|
|
ecore_evas_software_x11_8_subwindow_get(const Ecore_Evas *ee)
|
|
|
|
{
|
|
|
|
#if defined (BUILD_ECORE_EVAS_SOFTWARE_8_X11)
|
2012-05-28 05:24:30 -07:00
|
|
|
if (!(!strcmp(ee->driver, "software_8_x11"))) return 0;
|
2010-07-27 17:17:40 -07:00
|
|
|
return (Ecore_X_Window) ecore_evas_window_get(ee);
|
|
|
|
#else
|
|
|
|
return 0;
|
2011-08-23 05:04:52 -07:00
|
|
|
(void)(ee);
|
2010-07-27 17:17:40 -07:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2012-04-23 13:09:48 -07:00
|
|
|
* @brief Set direct_size for Ecore_Evas using software 8 x11.
|
|
|
|
* @note If ecore is not compiled with support to x11 then nothing is done and the function is returned.
|
|
|
|
* @param ee The Ecore_Evas in which to set direct resize.
|
|
|
|
* @param on Enables the resize of Ecore_Evas if equals EINA_TRUE, disables if equals EINA_FALSE.
|
2010-07-27 17:17:40 -07:00
|
|
|
*/
|
|
|
|
EAPI void
|
2010-09-25 00:03:02 -07:00
|
|
|
ecore_evas_software_x11_8_direct_resize_set(Ecore_Evas *ee, Eina_Bool on)
|
2010-07-27 17:17:40 -07:00
|
|
|
{
|
|
|
|
#if defined (BUILD_ECORE_EVAS_SOFTWARE_8_X11)
|
|
|
|
ee->engine.x.direct_resize = on;
|
|
|
|
if (ee->prop.avoid_damage)
|
|
|
|
{
|
2010-09-29 10:03:38 -07:00
|
|
|
if (ee->engine.x.direct_resize)
|
|
|
|
{
|
|
|
|
/* turn this off for now
|
|
|
|
ee->engine.x.using_bg_pixmap = 1;
|
|
|
|
ecore_x_window_pixmap_set(ee->engine.x.win, ee->engine.x.pmap);
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* turn this off too- bg pixmap is controlled by avoid damage directly
|
|
|
|
ee->engine.x.using_bg_pixmap = 0;
|
|
|
|
ecore_x_window_pixmap_set(ee->engine.x.win, 0);
|
|
|
|
ecore_x_window_area_expose(ee->engine.x.win, 0, 0, ee->w, ee->h);
|
|
|
|
*/
|
|
|
|
}
|
2010-07-27 17:17:40 -07:00
|
|
|
}
|
|
|
|
#else
|
|
|
|
return;
|
2011-08-23 05:04:52 -07:00
|
|
|
(void)(ee);
|
|
|
|
(void)(on);
|
2010-07-27 17:17:40 -07:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2012-04-23 13:09:48 -07:00
|
|
|
* @brief Gets if the Ecore_Evas is being directly resized using software 8 x11.
|
|
|
|
* @note If ecore is not compiled with support to x11 then nothing is done and 0 is returned.
|
|
|
|
* @param ee The Ecore_Evas from which to get direct resize.
|
|
|
|
* @return EINA_TRUE if the resize was managed directly, otherwise return EINA_FALSE.
|
2010-07-27 17:17:40 -07:00
|
|
|
*/
|
2010-09-25 00:03:02 -07:00
|
|
|
EAPI Eina_Bool
|
2010-07-27 17:17:40 -07:00
|
|
|
ecore_evas_software_x11_8_direct_resize_get(const Ecore_Evas *ee)
|
|
|
|
{
|
|
|
|
#if defined (BUILD_ECORE_EVAS_SOFTWARE_8_X11)
|
|
|
|
return ee->engine.x.direct_resize;
|
|
|
|
#else
|
|
|
|
return 0;
|
2011-08-23 05:04:52 -07:00
|
|
|
(void)(ee);
|
2010-07-27 17:17:40 -07:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2012-04-23 13:09:48 -07:00
|
|
|
* @brief Add extra window on Ecore_Evas using software 8 x11.
|
|
|
|
* @note If ecore is not compiled with support to x11 then nothing is done and the function is returned.
|
|
|
|
* @param ee The Ecore_Evas on which to add the window.
|
|
|
|
* @param win The window to be added at Ecore_Evas.
|
2010-07-27 17:17:40 -07:00
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_evas_software_x11_8_extra_event_window_add(Ecore_Evas *ee, Ecore_X_Window win)
|
|
|
|
{
|
|
|
|
#if defined (BUILD_ECORE_EVAS_SOFTWARE_8_X11)
|
|
|
|
Ecore_X_Window *winp;
|
|
|
|
|
|
|
|
winp = malloc(sizeof(Ecore_X_Window));
|
|
|
|
if (winp)
|
|
|
|
{
|
2010-09-29 10:03:38 -07:00
|
|
|
*winp = win;
|
|
|
|
ee->engine.x.win_extra = eina_list_append(ee->engine.x.win_extra, winp);
|
2010-07-27 17:17:40 -07:00
|
|
|
ecore_x_input_multi_select(win);
|
2010-12-07 19:25:23 -08:00
|
|
|
ecore_event_window_register(win, ee, ee->evas,
|
|
|
|
(Ecore_Event_Mouse_Move_Cb)_ecore_evas_mouse_move_process,
|
|
|
|
(Ecore_Event_Multi_Move_Cb)_ecore_evas_mouse_multi_move_process,
|
|
|
|
(Ecore_Event_Multi_Down_Cb)_ecore_evas_mouse_multi_down_process,
|
|
|
|
(Ecore_Event_Multi_Up_Cb)_ecore_evas_mouse_multi_up_process);
|
2010-07-27 17:17:40 -07:00
|
|
|
}
|
|
|
|
#else
|
2010-09-18 20:51:56 -07:00
|
|
|
return;
|
2011-08-23 05:04:52 -07:00
|
|
|
(void)(ee);
|
|
|
|
(void)(win);
|
2010-07-27 17:17:40 -07:00
|
|
|
#endif
|
|
|
|
}
|
2010-10-01 18:56:23 -07:00
|
|
|
|
|
|
|
EAPI void
|
|
|
|
ecore_evas_x11_leader_set(Ecore_Evas *ee, Ecore_X_Window win)
|
|
|
|
{
|
|
|
|
#ifdef BUILD_ECORE_EVAS_X11
|
|
|
|
_ecore_evas_x_group_leader_unset(ee);
|
|
|
|
ee->engine.x.leader = win;
|
|
|
|
_ecore_evas_x_group_leader_update(ee);
|
|
|
|
#else
|
|
|
|
return;
|
|
|
|
ee = NULL;
|
|
|
|
win = 0;
|
2011-04-20 07:15:33 -07:00
|
|
|
#endif
|
2010-10-01 18:56:23 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Ecore_X_Window
|
|
|
|
ecore_evas_x11_leader_get(Ecore_Evas *ee)
|
|
|
|
{
|
|
|
|
#ifdef BUILD_ECORE_EVAS_X11
|
|
|
|
return ee->engine.x.leader;
|
|
|
|
#else
|
|
|
|
return 0;
|
|
|
|
ee = NULL;
|
2011-04-20 07:15:33 -07:00
|
|
|
#endif
|
2010-10-01 18:56:23 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
ecore_evas_x11_leader_default_set(Ecore_Evas *ee)
|
|
|
|
{
|
|
|
|
#ifdef BUILD_ECORE_EVAS_X11
|
|
|
|
_ecore_evas_x_group_leader_unset(ee);
|
|
|
|
_ecore_evas_x_group_leader_set(ee);
|
|
|
|
#else
|
|
|
|
return;
|
|
|
|
ee = NULL;
|
2010-10-04 02:35:06 -07:00
|
|
|
#endif
|
2010-10-01 18:56:23 -07:00
|
|
|
}
|
|
|
|
|
2011-04-15 06:33:44 -07:00
|
|
|
#ifdef BUILD_ECORE_EVAS_X11
|
2011-04-13 02:06:05 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_ecore_evas_x11_convert_rectangle_with_angle(Ecore_Evas *ee, Ecore_X_Rectangle *dst_rect, Ecore_X_Rectangle *src_rect)
|
|
|
|
{
|
2011-07-14 08:40:53 -07:00
|
|
|
if ((!src_rect) || (!dst_rect)) return 0;
|
2011-04-13 02:06:05 -07:00
|
|
|
|
|
|
|
if (ee->rotation == 0)
|
|
|
|
{
|
|
|
|
dst_rect->x = src_rect->x;
|
|
|
|
dst_rect->y = src_rect->y;
|
|
|
|
dst_rect->width = src_rect->width;
|
|
|
|
dst_rect->height = src_rect->height;
|
|
|
|
}
|
|
|
|
else if (ee->rotation == 90)
|
|
|
|
{
|
|
|
|
dst_rect->x = src_rect->y;
|
|
|
|
dst_rect->y = ee->req.h - src_rect->x - src_rect->width;
|
|
|
|
dst_rect->width = src_rect->height;
|
|
|
|
dst_rect->height = src_rect->width;
|
|
|
|
}
|
|
|
|
else if (ee->rotation == 180)
|
|
|
|
{
|
|
|
|
dst_rect->x = ee->req.w - src_rect->x - src_rect->width;
|
|
|
|
dst_rect->y = ee->req.h - src_rect->y - src_rect->height;
|
|
|
|
dst_rect->width = src_rect->width;
|
|
|
|
dst_rect->height = src_rect->height;
|
|
|
|
}
|
|
|
|
else if (ee->rotation == 270)
|
|
|
|
{
|
|
|
|
dst_rect->x = ee->req.w - src_rect->y - src_rect->height;
|
|
|
|
dst_rect->y = src_rect->x;
|
|
|
|
dst_rect->width = src_rect->height;
|
|
|
|
dst_rect->height = src_rect->width;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
2011-04-15 06:33:44 -07:00
|
|
|
#endif
|
2011-04-13 02:06:05 -07:00
|
|
|
|
|
|
|
EAPI void
|
|
|
|
ecore_evas_x11_shape_input_rectangle_set(Ecore_Evas *ee, int x, int y, int w, int h)
|
|
|
|
{
|
|
|
|
#ifdef BUILD_ECORE_EVAS_X11
|
|
|
|
Eina_Bool ret;
|
|
|
|
Ecore_X_Rectangle src_rect;
|
|
|
|
Ecore_X_Rectangle dst_rect;
|
|
|
|
|
|
|
|
if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
|
|
|
|
{
|
|
|
|
ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
|
|
|
|
"ecore_evas_x11_shape_input_rectangle_set");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
src_rect.x = x;
|
|
|
|
src_rect.y = y;
|
|
|
|
src_rect.width = w;
|
|
|
|
src_rect.height = h;
|
|
|
|
|
2011-07-14 08:40:53 -07:00
|
|
|
dst_rect.x = 0;
|
|
|
|
dst_rect.y = 0;
|
|
|
|
dst_rect.width = 0;
|
|
|
|
dst_rect.height = 0;
|
|
|
|
|
2011-04-13 02:06:05 -07:00
|
|
|
ret = _ecore_evas_x11_convert_rectangle_with_angle(ee, &dst_rect, &src_rect);
|
|
|
|
|
|
|
|
if (!ee->engine.x.win_shaped_input)
|
2011-09-21 23:02:26 -07:00
|
|
|
ee->engine.x.win_shaped_input = ecore_x_window_override_new(ee->engine.x.win_root,
|
2011-07-14 08:40:53 -07:00
|
|
|
0, 0, 1, 1);
|
2011-04-13 02:06:05 -07:00
|
|
|
|
|
|
|
if (ret)
|
2011-09-21 23:02:26 -07:00
|
|
|
ecore_x_window_shape_input_rectangle_set(ee->engine.x.win_shaped_input,
|
|
|
|
dst_rect.x, dst_rect.y,
|
2011-07-14 08:40:53 -07:00
|
|
|
dst_rect.width, dst_rect.height);
|
2011-04-13 02:06:05 -07:00
|
|
|
#else
|
|
|
|
return;
|
|
|
|
ee = NULL;
|
|
|
|
x = 0;
|
|
|
|
y = 0;
|
|
|
|
w = 0;
|
|
|
|
h = 0;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
ecore_evas_x11_shape_input_rectangle_add(Ecore_Evas *ee, int x, int y, int w, int h)
|
|
|
|
{
|
|
|
|
#ifdef BUILD_ECORE_EVAS_X11
|
|
|
|
Eina_Bool ret;
|
|
|
|
Ecore_X_Rectangle src_rect;
|
|
|
|
Ecore_X_Rectangle dst_rect;
|
|
|
|
|
|
|
|
if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
|
|
|
|
{
|
|
|
|
ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
|
|
|
|
"ecore_evas_x11_shape_input_rectangle_add");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
src_rect.x = x;
|
|
|
|
src_rect.y = y;
|
|
|
|
src_rect.width = w;
|
|
|
|
src_rect.height = h;
|
|
|
|
|
2011-07-14 08:40:53 -07:00
|
|
|
dst_rect.x = 0;
|
|
|
|
dst_rect.y = 0;
|
|
|
|
dst_rect.width = 0;
|
|
|
|
dst_rect.height = 0;
|
|
|
|
|
2011-04-13 02:06:05 -07:00
|
|
|
ret = _ecore_evas_x11_convert_rectangle_with_angle(ee, &dst_rect, &src_rect);
|
|
|
|
|
|
|
|
if (!ee->engine.x.win_shaped_input)
|
2011-09-21 23:02:26 -07:00
|
|
|
ee->engine.x.win_shaped_input = ecore_x_window_override_new(ee->engine.x.win_root,
|
2011-07-14 08:40:53 -07:00
|
|
|
0, 0, 1, 1);
|
2011-04-13 02:06:05 -07:00
|
|
|
|
|
|
|
if (ret)
|
2011-09-21 23:02:26 -07:00
|
|
|
ecore_x_window_shape_input_rectangle_add(ee->engine.x.win_shaped_input,
|
|
|
|
dst_rect.x, dst_rect.y,
|
2011-07-14 08:40:53 -07:00
|
|
|
dst_rect.width, dst_rect.height);
|
2011-04-13 02:06:05 -07:00
|
|
|
#else
|
|
|
|
return;
|
|
|
|
ee = NULL;
|
|
|
|
x = 0;
|
|
|
|
y = 0;
|
|
|
|
w = 0;
|
|
|
|
h = 0;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
ecore_evas_x11_shape_input_rectangle_subtract(Ecore_Evas *ee, int x, int y, int w, int h)
|
|
|
|
{
|
|
|
|
#ifdef BUILD_ECORE_EVAS_X11
|
|
|
|
Eina_Bool ret;
|
|
|
|
Ecore_X_Rectangle src_rect;
|
|
|
|
Ecore_X_Rectangle dst_rect;
|
|
|
|
|
|
|
|
if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
|
|
|
|
{
|
|
|
|
ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
|
|
|
|
"ecore_evas_x11_shape_input_rectangle_subtract");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
src_rect.x = x;
|
|
|
|
src_rect.y = y;
|
|
|
|
src_rect.width = w;
|
|
|
|
src_rect.height = h;
|
|
|
|
|
2011-07-14 08:40:53 -07:00
|
|
|
dst_rect.x = 0;
|
|
|
|
dst_rect.y = 0;
|
|
|
|
dst_rect.width = 0;
|
|
|
|
dst_rect.height = 0;
|
|
|
|
|
2011-04-13 02:06:05 -07:00
|
|
|
ret = _ecore_evas_x11_convert_rectangle_with_angle(ee, &dst_rect, &src_rect);
|
|
|
|
|
|
|
|
if (!ee->engine.x.win_shaped_input)
|
2011-09-21 23:02:26 -07:00
|
|
|
ee->engine.x.win_shaped_input = ecore_x_window_override_new(ee->engine.x.win_root,
|
2011-07-14 08:40:53 -07:00
|
|
|
0, 0, 1, 1);
|
2011-04-13 02:06:05 -07:00
|
|
|
|
|
|
|
if (ret)
|
2011-09-21 23:02:26 -07:00
|
|
|
ecore_x_window_shape_input_rectangle_subtract(ee->engine.x.win_shaped_input,
|
|
|
|
dst_rect.x, dst_rect.y,
|
2011-07-14 08:40:53 -07:00
|
|
|
dst_rect.width, dst_rect.height);
|
2011-04-13 02:06:05 -07:00
|
|
|
#else
|
|
|
|
return;
|
|
|
|
ee = NULL;
|
|
|
|
x = 0;
|
|
|
|
y = 0;
|
|
|
|
w = 0;
|
|
|
|
h = 0;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
ecore_evas_x11_shape_input_empty(Ecore_Evas *ee)
|
|
|
|
{
|
|
|
|
#ifdef BUILD_ECORE_EVAS_X11
|
|
|
|
if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
|
|
|
|
{
|
|
|
|
ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
|
|
|
|
"ecore_evas_x11_shape_input_empty");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ee->engine.x.win_shaped_input)
|
|
|
|
ee->engine.x.win_shaped_input = ecore_x_window_override_new(ee->engine.x.win_root, 0, 0, 1, 1);
|
|
|
|
|
|
|
|
ecore_x_window_shape_input_rectangle_set(ee->engine.x.win_shaped_input, 0, 0, 0, 0);
|
|
|
|
#else
|
|
|
|
return;
|
|
|
|
ee = NULL;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
ecore_evas_x11_shape_input_reset(Ecore_Evas *ee)
|
|
|
|
{
|
|
|
|
#ifdef BUILD_ECORE_EVAS_X11
|
|
|
|
if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
|
|
|
|
{
|
|
|
|
ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
|
|
|
|
"ecore_evas_x11_shape_input_reset");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ee->engine.x.win_shaped_input)
|
|
|
|
ee->engine.x.win_shaped_input = ecore_x_window_override_new(ee->engine.x.win_root, 0, 0, 1, 1);
|
|
|
|
|
|
|
|
ecore_x_window_shape_input_rectangle_set(ee->engine.x.win_shaped_input, 0, 0, 65535, 65535);
|
|
|
|
#else
|
|
|
|
return;
|
|
|
|
ee = NULL;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
ecore_evas_x11_shape_input_apply(Ecore_Evas *ee)
|
|
|
|
{
|
|
|
|
#ifdef BUILD_ECORE_EVAS_X11
|
|
|
|
if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
|
|
|
|
{
|
|
|
|
ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
|
|
|
|
"ecore_evas_x11_shape_input_apply");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ee->engine.x.win_shaped_input) return;
|
|
|
|
|
|
|
|
ecore_x_window_shape_input_window_set(ee->prop.window, ee->engine.x.win_shaped_input);
|
|
|
|
#else
|
|
|
|
return;
|
|
|
|
ee = NULL;
|
|
|
|
#endif
|
|
|
|
}
|