kimcinoo
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
efl/src/modules/ecore_evas/engines/x/ecore_evas_x.c

5046 lines
162 KiB
C
Raw Normal View History

ecore: fix header inclusion. SVN revision: 66039
2011-12-08 08:19:44 -08:00
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
Ecore: fix warnings SVN revision: 65976
2011-12-06 14:33:01 -08:00
#include <stdlib.h>
remove a bit the mess n ecore. It's just the first patch... * add vim header * include config.h when necessary * fix the order of some include * move the standard header in ecore_private.h to the source files I have recompiled all the efl and e17, and e17 seems to work fine with these changes. If you encounter problems with that commit, let me know. SVN revision: 38864
2009-01-31 10:33:39 -08:00
#include <string.h>
ecore: fix header inclusion. SVN revision: 66039
2011-12-08 08:19:44 -08:00
#include <Eina.h>
#include <Ecore.h>
ecore_evas: re-order inclusion of header to fix compilation on Windows. It is a very tricky things to get header order right on windows. Having that order only in .c files simplify the work a lot. So let's try to do it with Ecore_Evas after it rewrite and split into modules.
2013-03-11 13:11:44 -07:00
#include "ecore_private.h"
#include <Ecore_Input.h>
#include <Ecore_Input_Evas.h>
ecore: fix header inclusion. SVN revision: 66039
2011-12-08 08:19:44 -08:00
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
#include <Ecore_X.h>
#include <Ecore_X_Atoms.h>
#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
# include <Evas_Engine_Software_X11.h>
#endif
#ifdef BUILD_ECORE_EVAS_OPENGL_X11
# include <Evas_Engine_GL_X11.h>
#endif
ecore_evas: re-order inclusion of header to fix compilation on Windows. It is a very tricky things to get header order right on windows. Having that order only in .c files simplify the work a lot. So let's try to do it with Ecore_Evas after it rewrite and split into modules.
2013-03-11 13:11:44 -07:00
#include <Ecore_Evas.h>
#include "ecore_evas_private.h"
#include "ecore_evas_x11.h"
ecore_evas_x: add some debug to help find out e_border problems. EDBG macro is at level 5 to avoid messing existing debugs, use it like: export EINA_LOG_LEVELS=ecore_evas:5 SVN revision: 82656
2013-01-11 10:45:10 -08:00
#define EDBG(...) \
EINA_LOG(_ecore_evas_log_dom, EINA_LOG_LEVEL_DBG + 1, __VA_ARGS__);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
static int _ecore_evas_init_count = 0;
more work on the sync stuff... looking good now. SVN revision: 45772
2010-02-01 06:13:48 -08:00
static Ecore_Event_Handler *ecore_evas_event_handlers[13];
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
set client leader by default - support setting it explicitly from code too. fix default win props too. SVN revision: 52974
2010-10-01 18:56:23 -07:00
static int leader_ref = 0;
static Ecore_X_Window leader_win = 0;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
static const char *interface_x11_name = "x11";
static const int interface_x11_version = 1;
static const char *interface_software_x11_name = "software_x11";
static const int interface_software_x11_version = 1;
Fix unused var warning.
2014-05-30 05:34:13 -07:00
#ifdef BUILD_ECORE_EVAS_OPENGL_X11
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
static const char *interface_gl_x11_name = "gl_x11";
Fix unused var warning.
2014-05-30 05:34:13 -07:00
#endif
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
static const int interface_gl_x11_version = 1;
typedef struct _Ecore_Evas_Engine_Data_X11 Ecore_Evas_Engine_Data_X11;
struct _Ecore_Evas_Engine_Data_X11 {
Ecore_X_Window win_root;
Eina_List *win_extra;
Ecore_X_Pixmap pmap;
Ecore_X_Pixmap mask;
Ecore_X_GC gc;
Ecore_X_XRegion *damages;
ecore-evas - handle mouse out then in due to click-to-focus passive grabs
2013-10-18 03:23:38 -07:00
Ecore_Timer *outdelay;
Ecore_X_Event_Mouse_Out out_ev;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_X_Sync_Counter sync_counter;
Ecore_X_Window leader;
Ecore_X_Sync_Counter netwm_sync_counter;
int netwm_sync_val_hi;
unsigned int netwm_sync_val_lo;
int sync_val; // bigger! this will screw up at 2 billion fram~
int screen_num;
int px, py, pw, ph;
unsigned char direct_resize : 1;
unsigned char using_bg_pixmap : 1;
unsigned char managed : 1;
unsigned char sync_began : 1;
unsigned char sync_cancel : 1;
unsigned char netwm_sync_set : 1;
unsigned char configure_coming : 1;
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;
} state;
struct {
unsigned char available : 1; // need to setup available profiles in a w
unsigned char change : 1; // need to send change event to the WM
unsigned char done : 1; // need to send change done event to the WM
} profile;
ecore_evas: added window manager rotation to manage the rotation of windows by the WM. Summary: The window manager rotation allows the WM to controls the rotation of application windows. It is designed to support synchronized rotation for the multiple application windows at same time. Reviewers: raster, seoz, cedric, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D529
2014-02-08 16:46:51 -08:00
struct {
unsigned char supported: 1;
unsigned char prepare : 1;
unsigned char request : 1;
unsigned char done : 1;
unsigned char configure_coming : 1;
Ecore_Job *manual_mode_job;
} wm_rot;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_X_Window win_shaped_input;
ecore - clean up code. fix indentation and use Eina_Bool instead of char.
2014-01-11 01:19:43 -08:00
struct
Add code for ecore_evas_<engine>_pixmap_new/get functions. - Add "pixmap" structure to engine_data. - Free the front and back pixmaps when the ecore_evas gets freed. - On resize, drop the backing pixmap if size is different. - Before we render, check pixmap size vs EE size and create new backing pixmap if needed. - After we have rendered into the backing pixmap, flip it to the front so that any calls to "pixmap_get" will return the proper one. - Add pixmap_new_internal code (the actual guts for all this) NB: These can be used to create an internally double-buffered ecore_evas that renders to a pixmap (not a window). Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-05 02:38:43 -07:00
{
unsigned int front, back; // front and back pixmaps (double-buffer)
Evas_Coord w, h; // store pixmap size (saves X roundtrips)
int depth; // store depth to save us from fetching engine info pre_render
Add visual and colormap to pixmap structure Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-11 02:22:17 -07:00
void *visual; // store visual used to create pixmap
unsigned long colormap; // store colormap used to create pixmap
Add code for ecore_evas_<engine>_pixmap_new/get functions. - Add "pixmap" structure to engine_data. - Free the front and back pixmaps when the ecore_evas gets freed. - On resize, drop the backing pixmap if size is different. - Before we render, check pixmap size vs EE size and create new backing pixmap if needed. - After we have rendered into the backing pixmap, flip it to the front so that any calls to "pixmap_get" will return the proper one. - Add pixmap_new_internal code (the actual guts for all this) NB: These can be used to create an internally double-buffered ecore_evas that renders to a pixmap (not a window). Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-05 02:38:43 -07:00
} pixmap;
ecore-evas-x no longer uses X windows after receiving a destroy event
2013-07-24 05:58:57 -07:00
Eina_Bool destroyed : 1; // X window has been deleted and cannot be used
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
};
static Ecore_Evas_Interface_X11 * _ecore_evas_x_interface_x11_new(void);
#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
static Ecore_Evas_Interface_Software_X11 *_ecore_evas_x_interface_software_x11_new(void);
#endif
#ifdef BUILD_ECORE_EVAS_OPENGL_X11
static Ecore_Evas_Interface_Gl_X11 *_ecore_evas_x_interface_gl_x11_new(void);
#endif
ecore_evas: added window manager rotation to manage the rotation of windows by the WM. Summary: The window manager rotation allows the WM to controls the rotation of application windows. It is designed to support synchronized rotation for the multiple application windows at same time. Reviewers: raster, seoz, cedric, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D529
2014-02-08 16:46:51 -08:00
static void _ecore_evas_x_rotation_set(Ecore_Evas *ee, int rotation, int resize);
static Eina_Bool _ecore_evas_x_wm_rot_manual_rotation_done_timeout(void *data);
static void _ecore_evas_x_wm_rot_manual_rotation_done_timeout_update(Ecore_Evas *ee);
ecore_evas: Added support for window auxiliary hint Summary: The window auxiliary hint is the value which is used to decide which actions should be made available to the user by the WM. If you want to set specific hint to your window, then you should check whether it exists in the supported auxiliary hints that are registered in the root window by the window manager. Once you've added an auxiliary hint, you can get a new ID which is used to change value and delete hint. The window manager sends the response message to the application on receiving auxiliary hint change event. A list of auxiliary hint within the Ecore_Evas has this format: ID:HINT:VALUE,ID:HINT:VALUE,... Reviewers: raster, cedric, seoz, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D543
2014-02-27 14:20:01 -08:00
static void _ecore_evas_x_aux_hints_set(Ecore_Evas *ee, const char *hints);
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
static void _resize_shape_do(Ecore_Evas *);
static void _shaped_do(Ecore_Evas *, int);
static void _alpha_do(Ecore_Evas *, int);
static void _transparent_do(Ecore_Evas *, int);
static void _avoid_damage_do(Ecore_Evas *, int);
static void _rotation_do(Ecore_Evas *, int, int);
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
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 */,
ecore - clean up code. fix indentation and use Eina_Bool instead of char.
2014-01-11 01:19:43 -08:00
ee->prop.iconified ? ECORE_X_WINDOW_STATE_HINT_ICONIC :
ee->prop.withdrawn ? ECORE_X_WINDOW_STATE_HINT_WITHDRAWN :
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
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 */);
}
set client leader by default - support setting it explicitly from code too. fix default win props too. SVN revision: 52974
2010-10-01 18:56:23 -07:00
static void
_ecore_evas_x_group_leader_set(Ecore_Evas *ee)
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
set client leader by default - support setting it explicitly from code too. fix default win props too. SVN revision: 52974
2010-10-01 18:56:23 -07:00
leader_ref++;
if (leader_ref == 1)
{
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
char *id = NULL;
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
leader_win =
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ecore_x_window_override_new(edata->win_root, 1234, 5678, 1, 2);
set client leader by default - support setting it explicitly from code too. fix default win props too. SVN revision: 52974
2010-10-01 18:56:23 -07:00
ecore_x_window_defaults_set(leader_win);
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
if ((id = getenv("DESKTOP_STARTUP_ID")))
ecore_x_netwm_startup_id_set(leader_win,id);
set client leader by default - support setting it explicitly from code too. fix default win props too. SVN revision: 52974
2010-10-01 18:56:23 -07:00
ecore_x_icccm_client_leader_set(leader_win, leader_win);
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->leader = leader_win;
set client leader by default - support setting it explicitly from code too. fix default win props too. SVN revision: 52974
2010-10-01 18:56:23 -07:00
ecore_x_icccm_client_leader_set(ee->prop.window, leader_win);
}
static void
_ecore_evas_x_group_leader_unset(Ecore_Evas *ee)
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
ecore-evas-x no longer uses X windows after receiving a destroy event
2013-07-24 05:58:57 -07:00
if (!edata->destroyed)
ecore_x_window_prop_property_del(ee->prop.window,
ECORE_X_ATOM_WM_CLIENT_LEADER);
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (edata->leader == leader_win)
set client leader by default - support setting it explicitly from code too. fix default win props too. SVN revision: 52974
2010-10-01 18:56:23 -07:00
{
leader_ref--;
if (leader_ref <= 0)
{
ecore_x_window_free(leader_win);
leader_win = 0;
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->leader = 0;
set client leader by default - support setting it explicitly from code too. fix default win props too. SVN revision: 52974
2010-10-01 18:56:23 -07:00
}
}
static void
_ecore_evas_x_group_leader_update(Ecore_Evas *ee)
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
if (edata->leader)
ecore_x_icccm_client_leader_set(ee->prop.window, edata->leader);
set client leader by default - support setting it explicitly from code too. fix default win props too. SVN revision: 52974
2010-10-01 18:56:23 -07:00
}
say we do pings - and respond within the event handler. SVN revision: 45699
2010-01-29 02:28:54 -08:00
static void
_ecore_evas_x_protocols_set(Ecore_Evas *ee)
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
Ecore_Evas: We don't need to allocate 10 items for this array if we are only going to use (at most) 3. SVN revision: 65194
2011-11-14 10:48:19 -08:00
Ecore_X_Atom protos[3];
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
unsigned int num = 0, tmp = 0;
Ecore: Removed trailing whitespaces. SVN revision: 58753
2011-04-20 07:15:33 -07:00
say we do pings - and respond within the event handler. SVN revision: 45699
2010-01-29 02:28:54 -08:00
if (ee->func.fn_delete_request)
Ecore_Evas: We don't need to allocate 10 items for this array if we are only going to use (at most) 3. SVN revision: 65194
2011-11-14 10:48:19 -08:00
protos[num++] = ECORE_X_ATOM_WM_DELETE_WINDOW;
aaaah. i smell another broken wm out there that only handles wm_delete as the first wm_protocols property. BAD WM! (its not e17 - thats for sure) SVN revision: 45827
2010-02-02 19:20:22 -08:00
protos[num++] = ECORE_X_ATOM_NET_WM_PING;
ecore-evas: feature++ : support netm sync protocol for clients SVN revision: 58198
2011-03-30 03:10:04 -07:00
protos[num++] = ECORE_X_ATOM_NET_WM_SYNC_REQUEST;
typo fix! SVN revision: 45702
2010-01-29 03:06:32 -08:00
ecore_x_icccm_protocol_atoms_set(ee->prop.window, protos, num);
Ecore: Removed trailing whitespaces. SVN revision: 58753
2011-04-20 07:15:33 -07:00
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (!edata->netwm_sync_counter)
edata->netwm_sync_counter = ecore_x_sync_counter_new(0);
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
tmp = edata->netwm_sync_counter;
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
ecore_x_window_prop_card32_set(ee->prop.window,
ECORE_X_ATOM_NET_WM_SYNC_REQUEST_COUNTER,
&tmp, 1);
Ecore_x: Add manual render code before deiconify
2013-03-06 23:33:59 -08:00
// set property on window to say "I talk the deiconify approve protcol"
tmp = 1;
ecore_x_window_prop_card32_set(ee->prop.window,
ECORE_X_ATOM_E_DEICONIFY_APPROVE,
&tmp, 1);
say we do pings - and respond within the event handler. SVN revision: 45699
2010-01-29 02:28:54 -08:00
}
add some sync stuff.. wil be used soon SVN revision: 45733
2010-01-30 02:42:22 -08:00
static void
_ecore_evas_x_sync_set(Ecore_Evas *ee)
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
Ecore_X_Sync_Counter sync_counter = edata->sync_counter;
Ecore_Evas Merge Tizen changes to upstream EFL. SVN revision: 73206
2012-07-03 00:44:17 -07:00
delay comp setup until show. (and unset on hide) SVN revision: 53256
2010-10-10 23:28:01 -07:00
if (((ee->should_be_visible) || (ee->visible)) &&
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
((ecore_x_e_comp_sync_supported_get(edata->win_root)) &&
delay comp setup until show. (and unset on hide) SVN revision: 53256
2010-10-10 23:28:01 -07:00
(!ee->no_comp_sync) && (_ecore_evas_app_comp_sync)))
more work on the sync stuff... looking good now. SVN revision: 45772
2010-02-01 06:13:48 -08:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (!edata->sync_counter)
edata->sync_counter = ecore_x_sync_counter_new(0);
more work on the sync stuff... looking good now. SVN revision: 45772
2010-02-01 06:13:48 -08:00
}
else
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (edata->sync_counter)
Ecore_Evas Merge Tizen changes to upstream EFL. SVN revision: 73206
2012-07-03 00:44:17 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ecore_x_sync_counter_free(edata->sync_counter);
edata->sync_val = 0;
Ecore_Evas Merge Tizen changes to upstream EFL. SVN revision: 73206
2012-07-03 00:44:17 -07:00
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->sync_counter = 0;
more work on the sync stuff... looking good now. SVN revision: 45772
2010-02-01 06:13:48 -08:00
}
ecore-evas-x no longer uses X windows after receiving a destroy event
2013-07-24 05:58:57 -07:00
if ((!edata->destroyed) && (sync_counter != edata->sync_counter))
ecore_x_e_comp_sync_counter_set(ee->prop.window, edata->sync_counter);
add some sync stuff.. wil be used soon SVN revision: 45733
2010-01-30 02:42:22 -08:00
}
static void
_ecore_evas_x_sync_clear(Ecore_Evas *ee)
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
if (!edata->sync_counter) return;
ecore_x_sync_counter_free(edata->sync_counter);
edata->sync_val = 0;
edata->sync_counter = 0;
add some sync stuff.. wil be used soon SVN revision: 45733
2010-01-30 02:42:22 -08:00
}
ecore_evas: added window manager rotation to manage the rotation of windows by the WM. Summary: The window manager rotation allows the WM to controls the rotation of application windows. It is designed to support synchronized rotation for the multiple application windows at same time. Reviewers: raster, seoz, cedric, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D529
2014-02-08 16:46:51 -08:00
static void
_ecore_evas_x_wm_rotation_protocol_set(Ecore_Evas *ee)
{
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
if (ecore_x_e_window_rotation_supported_get(edata->win_root))
ee->prop.wm_rot.supported = 1;
else
ee->prop.wm_rot.supported = 0;
}
From: Gwanglim Lee <gl77.lee@samsung.com> Subject: Re: Re: Re: [E-devel] [RFC] Virtual desktop window profile I've attached 4th patch. May the 4th be with you. ecore patch has been merged with efl and all files are based on r80123. Thanks & Regards, Gwanglim ------- Original Message ------- Sender : Daniel Juyung Seo<seojuyung2@gmail.com> Date : 2012-12-04 01:55 (GMT+09:00) Title : Re: Re: [E-devel] [RFC] Virtual desktop window profile It looks ok to me. Sorry but can you re-generate the patch according to the recent ecore merge to efl single tree? Daniel Juyung Seo (SeoZ) On Thu, Nov 29, 2012 at 12:29 AM, Gwanglim Lee <gl77.lee@samsung.com> wrote: Dear Raster and Daniel Juyung Seo, I've attached 3rd patches and test_config according to your reviews. These are based on r79782. [elementary & ecore] 1. "profile,set" -> "profile,changed" - done 2. spaces after EINA_LIST_FOREACH - done 3. variable type - keep 4. author - done 5. removing deprecated marking in patch - done 6. add elm_win_available_profiles_get to test_config for the debugging purpose - done 7. check whether a given profile is present in an available profiles. otherwise window profile will be one of the item in available profiles. - newly added thing to the elm_win 8. merge with EO - done. :( Any comments would be appreciated. SVN revision: 80214
2012-12-04 22:48:46 -08:00
static void
_ecore_evas_x_window_profile_protocol_set(Ecore_Evas *ee)
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
From: Gwanglim Lee <gl77.lee@samsung.com> Subject: Re: Re: Re: [E-devel] [RFC] Virtual desktop window profile I've attached 4th patch. May the 4th be with you. ecore patch has been merged with efl and all files are based on r80123. Thanks & Regards, Gwanglim ------- Original Message ------- Sender : Daniel Juyung Seo<seojuyung2@gmail.com> Date : 2012-12-04 01:55 (GMT+09:00) Title : Re: Re: [E-devel] [RFC] Virtual desktop window profile It looks ok to me. Sorry but can you re-generate the patch according to the recent ecore merge to efl single tree? Daniel Juyung Seo (SeoZ) On Thu, Nov 29, 2012 at 12:29 AM, Gwanglim Lee <gl77.lee@samsung.com> wrote: Dear Raster and Daniel Juyung Seo, I've attached 3rd patches and test_config according to your reviews. These are based on r79782. [elementary & ecore] 1. "profile,set" -> "profile,changed" - done 2. spaces after EINA_LIST_FOREACH - done 3. variable type - keep 4. author - done 5. removing deprecated marking in patch - done 6. add elm_win_available_profiles_get to test_config for the debugging purpose - done 7. check whether a given profile is present in an available profiles. otherwise window profile will be one of the item in available profiles. - newly added thing to the elm_win 8. merge with EO - done. :( Any comments would be appreciated. SVN revision: 80214
2012-12-04 22:48:46 -08:00
/* check and set profile protocol hint */
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (ecore_x_e_window_profile_supported_get(edata->win_root))
From: Gwanglim Lee <gl77.lee@samsung.com> Subject: Re: Re: Re: [E-devel] [RFC] Virtual desktop window profile I've attached 4th patch. May the 4th be with you. ecore patch has been merged with efl and all files are based on r80123. Thanks & Regards, Gwanglim ------- Original Message ------- Sender : Daniel Juyung Seo<seojuyung2@gmail.com> Date : 2012-12-04 01:55 (GMT+09:00) Title : Re: Re: [E-devel] [RFC] Virtual desktop window profile It looks ok to me. Sorry but can you re-generate the patch according to the recent ecore merge to efl single tree? Daniel Juyung Seo (SeoZ) On Thu, Nov 29, 2012 at 12:29 AM, Gwanglim Lee <gl77.lee@samsung.com> wrote: Dear Raster and Daniel Juyung Seo, I've attached 3rd patches and test_config according to your reviews. These are based on r79782. [elementary & ecore] 1. "profile,set" -> "profile,changed" - done 2. spaces after EINA_LIST_FOREACH - done 3. variable type - keep 4. author - done 5. removing deprecated marking in patch - done 6. add elm_win_available_profiles_get to test_config for the debugging purpose - done 7. check whether a given profile is present in an available profiles. otherwise window profile will be one of the item in available profiles. - newly added thing to the elm_win 8. merge with EO - done. :( Any comments would be appreciated. SVN revision: 80214
2012-12-04 22:48:46 -08:00
{
unsigned int v = 1;
ecore_x_window_prop_card32_set
(ee->prop.window,
ECORE_X_ATOM_E_WINDOW_PROFILE_SUPPORTED,
&v, 1);
ee->profile_supported = 1;
}
else
ee->profile_supported = 0;
}
static void
_ecore_evas_x_window_profile_set(Ecore_Evas *ee)
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
From: Gwanglim Lee <gl77.lee@samsung.com> Subject: Re: Re: Re: [E-devel] [RFC] Virtual desktop window profile I've attached 4th patch. May the 4th be with you. ecore patch has been merged with efl and all files are based on r80123. Thanks & Regards, Gwanglim ------- Original Message ------- Sender : Daniel Juyung Seo<seojuyung2@gmail.com> Date : 2012-12-04 01:55 (GMT+09:00) Title : Re: Re: [E-devel] [RFC] Virtual desktop window profile It looks ok to me. Sorry but can you re-generate the patch according to the recent ecore merge to efl single tree? Daniel Juyung Seo (SeoZ) On Thu, Nov 29, 2012 at 12:29 AM, Gwanglim Lee <gl77.lee@samsung.com> wrote: Dear Raster and Daniel Juyung Seo, I've attached 3rd patches and test_config according to your reviews. These are based on r79782. [elementary & ecore] 1. "profile,set" -> "profile,changed" - done 2. spaces after EINA_LIST_FOREACH - done 3. variable type - keep 4. author - done 5. removing deprecated marking in patch - done 6. add elm_win_available_profiles_get to test_config for the debugging purpose - done 7. check whether a given profile is present in an available profiles. otherwise window profile will be one of the item in available profiles. - newly added thing to the elm_win 8. merge with EO - done. :( Any comments would be appreciated. SVN revision: 80214
2012-12-04 22:48:46 -08:00
if (((ee->should_be_visible) || (ee->visible)) &&
(ee->profile_supported))
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (edata->profile.available)
From: Gwanglim Lee <gl77.lee@samsung.com> Subject: Re: Re: Re: [E-devel] [RFC] Virtual desktop window profile I've attached 4th patch. May the 4th be with you. ecore patch has been merged with efl and all files are based on r80123. Thanks & Regards, Gwanglim ------- Original Message ------- Sender : Daniel Juyung Seo<seojuyung2@gmail.com> Date : 2012-12-04 01:55 (GMT+09:00) Title : Re: Re: [E-devel] [RFC] Virtual desktop window profile It looks ok to me. Sorry but can you re-generate the patch according to the recent ecore merge to efl single tree? Daniel Juyung Seo (SeoZ) On Thu, Nov 29, 2012 at 12:29 AM, Gwanglim Lee <gl77.lee@samsung.com> wrote: Dear Raster and Daniel Juyung Seo, I've attached 3rd patches and test_config according to your reviews. These are based on r79782. [elementary & ecore] 1. "profile,set" -> "profile,changed" - done 2. spaces after EINA_LIST_FOREACH - done 3. variable type - keep 4. author - done 5. removing deprecated marking in patch - done 6. add elm_win_available_profiles_get to test_config for the debugging purpose - done 7. check whether a given profile is present in an available profiles. otherwise window profile will be one of the item in available profiles. - newly added thing to the elm_win 8. merge with EO - done. :( Any comments would be appreciated. SVN revision: 80214
2012-12-04 22:48:46 -08:00
{
ecore_x_e_window_available_profiles_set
(ee->prop.window,
(const char **)ee->prop.profile.available_list,
(const int)ee->prop.profile.count);
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->profile.available = 0;
From: Gwanglim Lee <gl77.lee@samsung.com> Subject: Re: Re: Re: [E-devel] [RFC] Virtual desktop window profile I've attached 4th patch. May the 4th be with you. ecore patch has been merged with efl and all files are based on r80123. Thanks & Regards, Gwanglim ------- Original Message ------- Sender : Daniel Juyung Seo<seojuyung2@gmail.com> Date : 2012-12-04 01:55 (GMT+09:00) Title : Re: Re: [E-devel] [RFC] Virtual desktop window profile It looks ok to me. Sorry but can you re-generate the patch according to the recent ecore merge to efl single tree? Daniel Juyung Seo (SeoZ) On Thu, Nov 29, 2012 at 12:29 AM, Gwanglim Lee <gl77.lee@samsung.com> wrote: Dear Raster and Daniel Juyung Seo, I've attached 3rd patches and test_config according to your reviews. These are based on r79782. [elementary & ecore] 1. "profile,set" -> "profile,changed" - done 2. spaces after EINA_LIST_FOREACH - done 3. variable type - keep 4. author - done 5. removing deprecated marking in patch - done 6. add elm_win_available_profiles_get to test_config for the debugging purpose - done 7. check whether a given profile is present in an available profiles. otherwise window profile will be one of the item in available profiles. - newly added thing to the elm_win 8. merge with EO - done. :( Any comments would be appreciated. SVN revision: 80214
2012-12-04 22:48:46 -08:00
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (edata->profile.change)
From: Gwanglim Lee <gl77.lee@samsung.com> Subject: Re: Re: Re: [E-devel] [RFC] Virtual desktop window profile I've attached 4th patch. May the 4th be with you. ecore patch has been merged with efl and all files are based on r80123. Thanks & Regards, Gwanglim ------- Original Message ------- Sender : Daniel Juyung Seo<seojuyung2@gmail.com> Date : 2012-12-04 01:55 (GMT+09:00) Title : Re: Re: [E-devel] [RFC] Virtual desktop window profile It looks ok to me. Sorry but can you re-generate the patch according to the recent ecore merge to efl single tree? Daniel Juyung Seo (SeoZ) On Thu, Nov 29, 2012 at 12:29 AM, Gwanglim Lee <gl77.lee@samsung.com> wrote: Dear Raster and Daniel Juyung Seo, I've attached 3rd patches and test_config according to your reviews. These are based on r79782. [elementary & ecore] 1. "profile,set" -> "profile,changed" - done 2. spaces after EINA_LIST_FOREACH - done 3. variable type - keep 4. author - done 5. removing deprecated marking in patch - done 6. add elm_win_available_profiles_get to test_config for the debugging purpose - done 7. check whether a given profile is present in an available profiles. otherwise window profile will be one of the item in available profiles. - newly added thing to the elm_win 8. merge with EO - done. :( Any comments would be appreciated. SVN revision: 80214
2012-12-04 22:48:46 -08:00
{
if (ee->prop.profile.name)
{
/* We need to keep the profile as an x property to let the WM.
* Then the WM reads it when creating the border window.
*/
Ecore_X_Atom a = ecore_x_atom_get(ee->prop.profile.name);
ecore_x_window_prop_atom_set
(ee->prop.window,
ECORE_X_ATOM_E_WINDOW_PROFILE_CHANGE,
&a, 1);
ecore_x_e_window_profile_change_send
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
(edata->win_root,
From: Gwanglim Lee <gl77.lee@samsung.com> Subject: Re: Re: Re: [E-devel] [RFC] Virtual desktop window profile I've attached 4th patch. May the 4th be with you. ecore patch has been merged with efl and all files are based on r80123. Thanks & Regards, Gwanglim ------- Original Message ------- Sender : Daniel Juyung Seo<seojuyung2@gmail.com> Date : 2012-12-04 01:55 (GMT+09:00) Title : Re: Re: [E-devel] [RFC] Virtual desktop window profile It looks ok to me. Sorry but can you re-generate the patch according to the recent ecore merge to efl single tree? Daniel Juyung Seo (SeoZ) On Thu, Nov 29, 2012 at 12:29 AM, Gwanglim Lee <gl77.lee@samsung.com> wrote: Dear Raster and Daniel Juyung Seo, I've attached 3rd patches and test_config according to your reviews. These are based on r79782. [elementary & ecore] 1. "profile,set" -> "profile,changed" - done 2. spaces after EINA_LIST_FOREACH - done 3. variable type - keep 4. author - done 5. removing deprecated marking in patch - done 6. add elm_win_available_profiles_get to test_config for the debugging purpose - done 7. check whether a given profile is present in an available profiles. otherwise window profile will be one of the item in available profiles. - newly added thing to the elm_win 8. merge with EO - done. :( Any comments would be appreciated. SVN revision: 80214
2012-12-04 22:48:46 -08:00
ee->prop.window,
ee->prop.profile.name);
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->profile.change = 0;
From: Gwanglim Lee <gl77.lee@samsung.com> Subject: Re: Re: Re: [E-devel] [RFC] Virtual desktop window profile I've attached 4th patch. May the 4th be with you. ecore patch has been merged with efl and all files are based on r80123. Thanks & Regards, Gwanglim ------- Original Message ------- Sender : Daniel Juyung Seo<seojuyung2@gmail.com> Date : 2012-12-04 01:55 (GMT+09:00) Title : Re: Re: [E-devel] [RFC] Virtual desktop window profile It looks ok to me. Sorry but can you re-generate the patch according to the recent ecore merge to efl single tree? Daniel Juyung Seo (SeoZ) On Thu, Nov 29, 2012 at 12:29 AM, Gwanglim Lee <gl77.lee@samsung.com> wrote: Dear Raster and Daniel Juyung Seo, I've attached 3rd patches and test_config according to your reviews. These are based on r79782. [elementary & ecore] 1. "profile,set" -> "profile,changed" - done 2. spaces after EINA_LIST_FOREACH - done 3. variable type - keep 4. author - done 5. removing deprecated marking in patch - done 6. add elm_win_available_profiles_get to test_config for the debugging purpose - done 7. check whether a given profile is present in an available profiles. otherwise window profile will be one of the item in available profiles. - newly added thing to the elm_win 8. merge with EO - done. :( Any comments would be appreciated. SVN revision: 80214
2012-12-04 22:48:46 -08:00
}
}
}
ecore_evas: added window manager rotation to manage the rotation of windows by the WM. Summary: The window manager rotation allows the WM to controls the rotation of application windows. It is designed to support synchronized rotation for the multiple application windows at same time. Reviewers: raster, seoz, cedric, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D529
2014-02-08 16:46:51 -08:00
static void
_ecore_evas_x_wm_rot_manual_rotation_done_job(void *data)
{
Ecore_Evas *ee = (Ecore_Evas *)data;
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
edata->wm_rot.manual_mode_job = NULL;
ee->prop.wm_rot.manual_mode.wait_for_done = EINA_FALSE;
ecore_x_e_window_rotation_change_done_send
(edata->win_root, ee->prop.window, ee->rotation, ee->w, ee->h);
edata->wm_rot.done = 0;
}
ecore_evas: Added support for window auxiliary hint Summary: The window auxiliary hint is the value which is used to decide which actions should be made available to the user by the WM. If you want to set specific hint to your window, then you should check whether it exists in the supported auxiliary hints that are registered in the root window by the window manager. Once you've added an auxiliary hint, you can get a new ID which is used to change value and delete hint. The window manager sends the response message to the application on receiving auxiliary hint change event. A list of auxiliary hint within the Ecore_Evas has this format: ID:HINT:VALUE,ID:HINT:VALUE,... Reviewers: raster, cedric, seoz, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D543
2014-02-27 14:20:01 -08:00
static void
_ecore_evas_x_aux_hints_supprted_update(Ecore_Evas *ee)
{
Ecore_X_Window root = ecore_x_window_root_first_get();
unsigned char *data = NULL;
unsigned int num = 0, i = 0;
int res = 0, n = 0;
char **str;
const char *hint;
EINA_LIST_FREE(ee->prop.aux_hint.supported_list, hint)
{
eina_stringshare_del(hint);
}
res = ecore_x_window_prop_property_get
(root, ECORE_X_ATOM_E_WINDOW_AUX_HINT_SUPPORTED_LIST,
ECORE_X_ATOM_STRING, 0, &data, &n);
ecore-evas-x: Fix formatting Signed-off-by: Chris Michael <cp.michael@samsung.com>
2014-03-05 06:31:22 -08:00
if ((res == 8) && (n > 0))
ecore_evas: Added support for window auxiliary hint Summary: The window auxiliary hint is the value which is used to decide which actions should be made available to the user by the WM. If you want to set specific hint to your window, then you should check whether it exists in the supported auxiliary hints that are registered in the root window by the window manager. Once you've added an auxiliary hint, you can get a new ID which is used to change value and delete hint. The window manager sends the response message to the application on receiving auxiliary hint change event. A list of auxiliary hint within the Ecore_Evas has this format: ID:HINT:VALUE,ID:HINT:VALUE,... Reviewers: raster, cedric, seoz, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D543
2014-02-27 14:20:01 -08:00
{
str = eina_str_split_full((char *)data, ",", -1, &num);
for (i = 0; i < num; i++)
{
hint = eina_stringshare_add(str[i]);
ecore-evas-x: Fix formatting Signed-off-by: Chris Michael <cp.michael@samsung.com>
2014-03-05 06:31:22 -08:00
ee->prop.aux_hint.supported_list =
eina_list_append(ee->prop.aux_hint.supported_list, hint);
ecore_evas: Added support for window auxiliary hint Summary: The window auxiliary hint is the value which is used to decide which actions should be made available to the user by the WM. If you want to set specific hint to your window, then you should check whether it exists in the supported auxiliary hints that are registered in the root window by the window manager. Once you've added an auxiliary hint, you can get a new ID which is used to change value and delete hint. The window manager sends the response message to the application on receiving auxiliary hint change event. A list of auxiliary hint within the Ecore_Evas has this format: ID:HINT:VALUE,ID:HINT:VALUE,... Reviewers: raster, cedric, seoz, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D543
2014-02-27 14:20:01 -08:00
}
fix coverity leak detection in ecore_evas_x hints... this fixes CID 1188012
2014-08-13 00:15:42 -07:00
if (str)
ecore_evas: Added support for window auxiliary hint Summary: The window auxiliary hint is the value which is used to decide which actions should be made available to the user by the WM. If you want to set specific hint to your window, then you should check whether it exists in the supported auxiliary hints that are registered in the root window by the window manager. Once you've added an auxiliary hint, you can get a new ID which is used to change value and delete hint. The window manager sends the response message to the application on receiving auxiliary hint change event. A list of auxiliary hint within the Ecore_Evas has this format: ID:HINT:VALUE,ID:HINT:VALUE,... Reviewers: raster, cedric, seoz, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D543
2014-02-27 14:20:01 -08:00
{
free(str[0]);
free(str);
}
}
free(data);
}
static void
_ecore_evas_x_aux_hints_update(Ecore_Evas *ee)
{
Eina_Strbuf *buf = _ecore_evas_aux_hints_string_get(ee);
if (buf)
{
_ecore_evas_x_aux_hints_set(ee, eina_strbuf_string_get(buf));
eina_strbuf_free(buf);
}
}
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
# ifdef BUILD_ECORE_EVAS_OPENGL_X11
evilness... but it works. SVN revision: 21091
2006-03-08 00:02:55 -08:00
static Ecore_X_Window
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
_ecore_evas_x_gl_window_new(Ecore_Evas *ee, Ecore_X_Window parent, int x, int y, int w, int h, Eina_Bool override, int argb, const int *opt)
evilness... but it works. SVN revision: 21091
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
evilness... but it works. SVN revision: 21091
2006-03-08 00:02:55 -08:00
einfo = (Evas_Engine_Info_GL_X11 *)evas_engine_info_get(ee->evas);
if (einfo)
{
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
int screen;
evilness... but it works. SVN revision: 21091
2006-03-08 00:02:55 -08:00
change gl engine api a little - fixed in ecore-evas and expedite. expose indirect option in ecore-evas with a new opt param for gl engines - will add more opts over time. SVN revision: 46177
2010-02-14 21:05:05 -08:00
if (opt)
{
int op;
Ecore: Removed trailing whitespaces. SVN revision: 58753
2011-04-20 07:15:33 -07:00
change gl engine api a little - fixed in ecore-evas and expedite. expose indirect option in ecore-evas with a new opt param for gl engines - will add more opts over time. SVN revision: 46177
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];
}
and we were missing vsync set support in ecore-evas, but had indirect support. fix. SVN revision: 55755
2010-12-26 02:17:31 -08:00
else if (opt[op] == ECORE_EVAS_GL_X11_OPT_VSYNC)
{
op++;
einfo->vsync = opt[op];
}
support new swap mode field. SVN revision: 77129
2012-09-26 23:57:16 -07:00
#ifdef EVAS_ENGINE_GL_X11_SWAP_MODE_EXISTS
actualyl do option this way. SVN revision: 77130
2012-09-27 00:00:28 -07:00
else if (opt[op] == ECORE_EVAS_GL_X11_OPT_SWAP_MODE)
support new swap mode field. SVN revision: 77129
2012-09-26 23:57:16 -07:00
{
op++;
if ((evas_version->major >= 1) &&
(evas_version->minor >= 7) &&
oops use micro not minor SVN revision: 77131
2012-09-27 00:13:15 -07:00
(evas_version->micro >= 99))
actualyl do option this way. SVN revision: 77130
2012-09-27 00:00:28 -07:00
einfo->swap_mode = opt[op];
support new swap mode field. SVN revision: 77129
2012-09-26 23:57:16 -07:00
}
ecore - clean up code. fix indentation and use Eina_Bool instead of char.
2014-01-11 01:19:43 -08:00
#endif
change gl engine api a little - fixed in ecore-evas and expedite. expose indirect option in ecore-evas with a new opt param for gl engines - will add more opts over time. SVN revision: 46177
2010-02-14 21:05:05 -08:00
}
}
Ecore: Removed trailing whitespaces. SVN revision: 58753
2011-04-20 07:15:33 -07:00
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
/* FIXME: this is inefficient as its 1 or more round trips */
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
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)
tab------------ SVN revision: 52896
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)
{
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
Ecore_X_Window root;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
root = ecore_x_window_root_get(parent);
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
for (i = 0; i < num; i++)
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
if (root == roots[i])
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
screen = i;
break;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
}
}
free(roots);
}
}
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
einfo->info.display = ecore_x_display_get();
einfo->info.screen = screen;
Ecore: Removed trailing whitespaces. SVN revision: 58753
2011-04-20 07:15:33 -07:00
allow alpha ee windows. SVN revision: 46678
2010-02-28 20:44:36 -08:00
einfo->info.destination_alpha = argb;
Ecore: Removed trailing whitespaces. SVN revision: 58753
2011-04-20 07:15:33 -07:00
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
einfo->info.visual = einfo->func.best_visual_get(einfo);
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
einfo->info.colormap = einfo->func.best_colormap_get(einfo);
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
einfo->info.depth = einfo->func.best_depth_get(einfo);
be more robust when gtl creation fails - return a null ee. SVN revision: 46178
2010-02-14 21:26:42 -08:00
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
if ((!einfo->info.visual) ||
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
(!einfo->info.colormap) || (!einfo->info.depth))
be more robust when gtl creation fails - return a null ee. SVN revision: 46178
2010-02-14 21:26:42 -08:00
{
handle info_set failures. SVN revision: 48957
2010-05-17 20:50:17 -07:00
WRN("OpenGL X11 init engine '%s' failed - no visual, colormap or depth.", ee->driver);
check returned value of evas_engine_info_set() SVN revision: 52360
2010-09-16 23:14:08 -07:00
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
{
check the returned value of evas_engine_info_set() SVN revision: 52894
2010-09-29 09:45:49 -07:00
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
check returned value of evas_engine_info_set() SVN revision: 52360
2010-09-16 23:14:08 -07:00
return 0;
}
be more robust when gtl creation fails - return a null ee. SVN revision: 46178
2010-02-14 21:26:42 -08:00
}
evas gl rgba visual/rendering fix try ... again so this is a re-try at the evas gl destination alpha fix. this is what cedric tried, but done RIGHT. it required adding an ecore_x call to create a window with correct visual/colormap. it requires doing visuals totally correctly all the way from ecore_evas to the evas gl_x11 core. nvidia drivers are very picky about visuals. i also had to vid the egl/gles code too to do the same thing. nvidia gles/egl drivers are also picky, mesa is not. this all requires a lot of code changes. it's far from trivial this isn't backported for a few reasons: 1. verify this fix doesn't break for anyone. i tested: nvidia glx + egl/gles intel glx + egl/gles radeon glx it needs wider testing. nouveau, fglrx for starters and maybe some other gles/egl drivers. 2. have some review time 3. time to settle before blasting to stable branches @fix
2014-10-25 04:04:52 -07:00
win = ecore_x_window_full_new(parent, x, y, w, h,
einfo->info.visual,
einfo->info.colormap,
einfo->info.depth,
override);
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
ecore_x_window_pixel_gravity_set(win, ECORE_X_GRAVITY_FORGET);
ecore-evas - enable attempting to turn on dri2 vsync this enables the x11 dri2 vsync enabling code for x11 ecore-evas
2014-07-24 22:45:50 -07:00
ecore_x_vsync_animator_tick_source_set(win);
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
/* 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); */
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
einfo->info.drawable = win;
check the returned value of evas_engine_info_set() SVN revision: 52894
2010-09-29 09:45:49 -07:00
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
handle info_set failures. SVN revision: 48957
2010-05-17 20:50:17 -07:00
{
ecore_evas: No error if window creation fails It is common that some types of ee's will fail as the underlying system does not support it, just warn.
2013-11-21 01:45:27 -08:00
WRN("evas_engine_info_set() for engine '%s' failed.", ee->driver);
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
ecore_x_window_free(win);
handle info_set failures. SVN revision: 48957
2010-05-17 20:50:17 -07:00
return 0;
}
Fix warning/potential trouble. SVN revision: 24543
2006-08-10 19:26:16 -07:00
}
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
else
win = 0;
evilness... but it works. SVN revision: 21091
2006-03-08 00:02:55 -08:00
return win;
}
#endif
ECORE_EVAS_FPS_DEBUG now printfs useful data. SVN revision: 39273
2009-02-27 23:54:47 -08:00
static int
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
_render_updates_process(Ecore_Evas *ee, Eina_List *updates)
if an ecore evas is shaped and avoid damage - render it just before a show :) SVN revision: 15651
2005-07-06 20:31:34 -07:00
{
ECORE_EVAS_FPS_DEBUG now printfs useful data. SVN revision: 39273
2009-02-27 23:54:47 -08:00
int rend = 0;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
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
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
if (ee->prop.avoid_damage)
if an ecore evas is shaped and avoid damage - render it just before a show :) SVN revision: 15651
2005-07-06 20:31:34 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (edata->using_bg_pixmap)
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
if (updates)
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
Ecore_Evas: Rework ecore_evas_x_render function so it does not allocate memory for list variables & rectangles unless we need to (ie: If there are no evas_render_updates to do, then there is no need to allocate extra list variables & rectangles). SVN revision: 63528
2011-09-21 19:39:23 -07:00
Eina_List *l = NULL;
Eina_Rectangle *r;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
EINA_LIST_FOREACH(updates, l, r)
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
ecore_x_window_area_clear(ee->prop.window,
Ecore_Evas: Rework ecore_evas_x_render function so it does not allocate memory for list variables & rectangles unless we need to (ie: If there are no evas_render_updates to do, then there is no need to allocate extra list variables & rectangles). SVN revision: 63528
2011-09-21 19:39:23 -07:00
r->x, r->y, r->w, r->h);
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
if (ee->shaped)
big patch from Samsung SAIT (Advanced research group) for async multi-frame rendering. to turn on: 1. configure with --enable-async-render 2. export EVAS_RENDER_MODE=non-blocking presto. necessitates some api swizzling (thus the expedite. ecore etc. changes) the kind of results you get on a desktop: http://www.rasterman.com/files/evas-async-vs-none.html SVN revision: 49087
2010-05-21 00:10:45 -07:00
{
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
ecore_x_window_shape_mask_set(ee->prop.window,
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->mask);
big patch from Samsung SAIT (Advanced research group) for async multi-frame rendering. to turn on: 1. configure with --enable-async-render 2. export EVAS_RENDER_MODE=non-blocking presto. necessitates some api swizzling (thus the expedite. ecore etc. changes) the kind of results you get on a desktop: http://www.rasterman.com/files/evas-async-vs-none.html SVN revision: 49087
2010-05-21 00:10:45 -07:00
}
Ecore_Evas: Rework ecore_evas_x_render function so it does not allocate memory for list variables & rectangles unless we need to (ie: If there are no evas_render_updates to do, then there is no need to allocate extra list variables & rectangles). SVN revision: 63528
2011-09-21 19:39:23 -07:00
if (ee->alpha)
big patch from Samsung SAIT (Advanced research group) for async multi-frame rendering. to turn on: 1. configure with --enable-async-render 2. export EVAS_RENDER_MODE=non-blocking presto. necessitates some api swizzling (thus the expedite. ecore etc. changes) the kind of results you get on a desktop: http://www.rasterman.com/files/evas-async-vs-none.html SVN revision: 49087
2010-05-21 00:10:45 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
// ecore_x_window_shape_input_mask_set(ee->prop.window, edata->mask);
big patch from Samsung SAIT (Advanced research group) for async multi-frame rendering. to turn on: 1. configure with --enable-async-render 2. export EVAS_RENDER_MODE=non-blocking presto. necessitates some api swizzling (thus the expedite. ecore etc. changes) the kind of results you get on a desktop: http://www.rasterman.com/files/evas-async-vs-none.html SVN revision: 49087
2010-05-21 00:10:45 -07:00
}
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
_ecore_evas_idle_timeout_update(ee);
ECORE_EVAS_FPS_DEBUG now printfs useful data. SVN revision: 39273
2009-02-27 23:54:47 -08:00
rend = 1;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
}
}
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
else
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
if (updates)
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
Ecore_Evas: Rework ecore_evas_x_render function so it does not allocate memory for list variables & rectangles unless we need to (ie: If there are no evas_render_updates to do, then there is no need to allocate extra list variables & rectangles). SVN revision: 63528
2011-09-21 19:39:23 -07:00
Eina_List *l = NULL;
Eina_Rectangle *r;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
Ecore_Evas: Rework ecore_evas_x_render function so it does not allocate memory for list variables & rectangles unless we need to (ie: If there are no evas_render_updates to do, then there is no need to allocate extra list variables & rectangles). SVN revision: 63528
2011-09-21 19:39:23 -07:00
EINA_LIST_FOREACH(updates, l, r)
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
Ecore_Evas: Rework ecore_evas_x_render function so it does not allocate memory for list variables & rectangles unless we need to (ie: If there are no evas_render_updates to do, then there is no need to allocate extra list variables & rectangles). SVN revision: 63528
2011-09-21 19:39:23 -07:00
Ecore_X_Rectangle rect;
Ecore_X_XRegion *tmpr;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (!edata->damages)
edata->damages = ecore_x_xregion_new();
Ecore_Evas: Rework ecore_evas_x_render function so it does not allocate memory for list variables & rectangles unless we need to (ie: If there are no evas_render_updates to do, then there is no need to allocate extra list variables & rectangles). SVN revision: 63528
2011-09-21 19:39:23 -07:00
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;
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ecore_x_xregion_union_rect(tmpr, edata->damages,
Ecore_Evas: Rework ecore_evas_x_render function so it does not allocate memory for list variables & rectangles unless we need to (ie: If there are no evas_render_updates to do, then there is no need to allocate extra list variables & rectangles). SVN revision: 63528
2011-09-21 19:39:23 -07:00
&rect);
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ecore_x_xregion_free(edata->damages);
edata->damages = tmpr;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (edata->damages)
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
Ecore_Evas: Rework ecore_evas_x_render function so it does not allocate memory for list variables & rectangles unless we need to (ie: If there are no evas_render_updates to do, then there is no need to allocate extra list variables & rectangles). SVN revision: 63528
2011-09-21 19:39:23 -07:00
if (ee->shaped)
only need to avoid exposures when we're shaped SVN revision: 75071
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 */
simplify unsetting/setting damage flag in ecore evas rendering to avoid altering previously set event mask flags SVN revision: 75072
2012-08-10 01:45:28 -07:00
ecore_x_event_mask_unset(ee->prop.window, ECORE_X_EVENT_MASK_WINDOW_DAMAGE);
only need to avoid exposures when we're shaped SVN revision: 75071
2012-08-10 01:41:10 -07:00
ecore_x_window_shape_mask_set(ee->prop.window,
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->mask);
only need to avoid exposures when we're shaped SVN revision: 75071
2012-08-10 01:41:10 -07:00
/* and re-enable them again */
simplify unsetting/setting damage flag in ecore evas rendering to avoid altering previously set event mask flags SVN revision: 75072
2012-08-10 01:45:28 -07:00
ecore_x_event_mask_set(ee->prop.window, ECORE_X_EVENT_MASK_WINDOW_DAMAGE);
only need to avoid exposures when we're shaped SVN revision: 75071
2012-08-10 01:41:10 -07:00
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ecore_x_xregion_set(edata->damages, edata->gc);
ecore_x_pixmap_paste(edata->pmap, ee->prop.window,
edata->gc, 0, 0, ee->w, ee->h,
Ecore_Evas: Rework ecore_evas_x_render function so it does not allocate memory for list variables & rectangles unless we need to (ie: If there are no evas_render_updates to do, then there is no need to allocate extra list variables & rectangles). SVN revision: 63528
2011-09-21 19:39:23 -07:00
0, 0);
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ecore_x_xregion_free(edata->damages);
edata->damages = NULL;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
}
_ecore_evas_idle_timeout_update(ee);
ECORE_EVAS_FPS_DEBUG now printfs useful data. SVN revision: 39273
2009-02-27 23:54:47 -08:00
rend = 1;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
}
}
if an ecore evas is shaped and avoid damage - render it just before a show :) SVN revision: 15651
2005-07-06 20:31:34 -07:00
}
whitespaces-- SVN revision: 63531
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)))
if an ecore evas is shaped and avoid damage - render it just before a show :) SVN revision: 15651
2005-07-06 20:31:34 -07:00
{
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
if (updates)
Reorganize code a little here to remove duplication. No function changes (and no issues found when tested). SVN revision: 46184
2010-02-14 23:23:58 -08:00
{
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
if (ee->shaped)
big patch from Samsung SAIT (Advanced research group) for async multi-frame rendering. to turn on: 1. configure with --enable-async-render 2. export EVAS_RENDER_MODE=non-blocking presto. necessitates some api swizzling (thus the expedite. ecore etc. changes) the kind of results you get on a desktop: http://www.rasterman.com/files/evas-async-vs-none.html SVN revision: 49087
2010-05-21 00:10:45 -07:00
{
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
ecore_x_window_shape_mask_set(ee->prop.window,
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->mask);
big patch from Samsung SAIT (Advanced research group) for async multi-frame rendering. to turn on: 1. configure with --enable-async-render 2. export EVAS_RENDER_MODE=non-blocking presto. necessitates some api swizzling (thus the expedite. ecore etc. changes) the kind of results you get on a desktop: http://www.rasterman.com/files/evas-async-vs-none.html SVN revision: 49087
2010-05-21 00:10:45 -07:00
}
if (ee->alpha)
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
// ecore_x_window_shape_input_mask_set(ee->prop.window, edata->mask);
big patch from Samsung SAIT (Advanced research group) for async multi-frame rendering. to turn on: 1. configure with --enable-async-render 2. export EVAS_RENDER_MODE=non-blocking presto. necessitates some api swizzling (thus the expedite. ecore etc. changes) the kind of results you get on a desktop: http://www.rasterman.com/files/evas-async-vs-none.html SVN revision: 49087
2010-05-21 00:10:45 -07:00
}
Reorganize code a little here to remove duplication. No function changes (and no issues found when tested). SVN revision: 46184
2010-02-14 23:23:58 -08:00
_ecore_evas_idle_timeout_update(ee);
rend = 1;
}
if an ecore evas is shaped and avoid damage - render it just before a show :) SVN revision: 15651
2005-07-06 20:31:34 -07:00
}
1. make curl interactivity MUCH better. 2. make ecore_evas use the norender call to delete objects aggressively for hiddent canvases. SVN revision: 28015
2007-01-16 02:17:46 -08:00
else
evas_norender(ee->evas);
ecore: fix leak of evas_render_update list. SVN revision: 75807
2012-08-28 22:18:27 -07:00
if an ecore evas is shaped and avoid damage - render it just before a show :) SVN revision: 15651
2005-07-06 20:31:34 -07:00
if (ee->func.fn_post_render) ee->func.fn_post_render(ee);
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
Ecore: Removed trailing whitespaces. SVN revision: 58753
2011-04-20 07:15:33 -07:00
/*
more work on the sync stuff... looking good now. SVN revision: 45772
2010-02-01 06:13:48 -08:00
if (rend)
{
static int frames = 0;
static double t0 = 0.0;
double t, td;
Ecore: Removed trailing whitespaces. SVN revision: 58753
2011-04-20 07:15:33 -07:00
more work on the sync stuff... looking good now. SVN revision: 45772
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;
}
}
*/
ECORE_EVAS_FPS_DEBUG now printfs useful data. SVN revision: 39273
2009-02-27 23:54:47 -08:00
return rend;
if an ecore evas is shaped and avoid damage - render it just before a show :) SVN revision: 15651
2005-07-06 20:31:34 -07:00
}
fix shaped ecore_evas handling to be more efficient on resize and if we combine it with obscures - those obscured areas at least start as empty :) SVN revision: 14580
2005-05-03 10:35:50 -07:00
static void
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
_ecore_evas_x_render_updates(void *data, Evas *e EINA_UNUSED, void *event_info)
{
evas: no need for a callback per async call. Let's not multiply our callback infrastructure without any serious need. We already have to many of them.
2013-03-25 19:48:23 -07:00
Evas_Event_Render_Post *ev = event_info;
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
Ecore_Evas *ee = data;
evas: no need for a callback per async call. Let's not multiply our callback infrastructure without any serious need. We already have to many of them.
2013-03-25 19:48:23 -07:00
efl: formatting
2013-06-20 04:28:18 -07:00
if (!ev) return;
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
ecore_evas_x: add some debug to help find out e_border problems. EDBG macro is at level 5 to avoid messing existing debugs, use it like: export EINA_LOG_LEVELS=ecore_evas:5 SVN revision: 82656
2013-01-11 10:45:10 -08:00
EDBG("ee=%p finished asynchronous render.", ee);
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
ee->in_async_render = EINA_FALSE;
evas: no need for a callback per async call. Let's not multiply our callback infrastructure without any serious need. We already have to many of them.
2013-03-25 19:48:23 -07:00
_render_updates_process(ee, ev->updated_area);
ecore_evas_x: add some debug to help find out e_border problems. EDBG macro is at level 5 to avoid messing existing debugs, use it like: export EINA_LOG_LEVELS=ecore_evas:5 SVN revision: 82656
2013-01-11 10:45:10 -08:00
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
if (ee->delayed.resize_shape)
{
_resize_shape_do(ee);
ee->delayed.resize_shape = EINA_FALSE;
}
if (ee->delayed.shaped_changed)
{
_shaped_do(ee, ee->delayed.shaped);
ee->delayed.shaped_changed = EINA_FALSE;
}
if (ee->delayed.alpha_changed)
{
_alpha_do(ee, ee->delayed.alpha);
ee->delayed.alpha_changed = EINA_FALSE;
}
if (ee->delayed.transparent_changed)
{
_transparent_do(ee, ee->delayed.transparent);
ee->delayed.transparent_changed = EINA_FALSE;
}
if (ee->delayed.avoid_damage != ee->prop.avoid_damage)
_avoid_damage_do(ee, ee->delayed.avoid_damage);
if (ee->delayed.rotation_changed)
{
_rotation_do(ee, ee->delayed.rotation, ee->delayed.rotation_resize);
ee->delayed.rotation_changed = EINA_FALSE;
}
}
static int
_ecore_evas_x_render(Ecore_Evas *ee)
fix shaped ecore_evas handling to be more efficient on resize and if we combine it with obscures - those obscured areas at least start as empty :) SVN revision: 14580
2005-05-03 10:35:50 -07:00
{
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
int rend = 0;
Eina_List *ll;
Ecore_Evas *ee2;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
if ((!ee->no_comp_sync) && (_ecore_evas_app_comp_sync) &&
(edata->sync_counter) && (!edata->sync_began) &&
(!edata->sync_cancel))
return 0;
ecore_evas_x: add some debug to help find out e_border problems. EDBG macro is at level 5 to avoid messing existing debugs, use it like: export EINA_LOG_LEVELS=ecore_evas:5 SVN revision: 82656
2013-01-11 10:45:10 -08:00
if (ee->in_async_render)
{
EDBG("ee=%p is rendering asynchronously, skip.", ee);
return 0;
}
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
EINA_LIST_FOREACH(ee->sub_ecore_evas, ll, 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
{
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
if (ee2->func.fn_pre_render) ee2->func.fn_pre_render(ee2);
if (ee2->engine.func->fn_render)
rend |= ee2->engine.func->fn_render(ee2);
if (ee2->func.fn_post_render) ee2->func.fn_post_render(ee2);
}
if (ee->func.fn_pre_render) ee->func.fn_pre_render(ee);
ecore_evas_x: add some debug to help find out e_border problems. EDBG macro is at level 5 to avoid messing existing debugs, use it like: export EINA_LOG_LEVELS=ecore_evas:5 SVN revision: 82656
2013-01-11 10:45:10 -08:00
if (!ee->can_async_render)
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
{
ecore_evas_x: add some debug to help find out e_border problems. EDBG macro is at level 5 to avoid messing existing debugs, use it like: export EINA_LOG_LEVELS=ecore_evas:5 SVN revision: 82656
2013-01-11 10:45:10 -08:00
Eina_List *updates = evas_render_updates(ee->evas);
rend = _render_updates_process(ee, updates);
evas: no need for a callback per async call. Let's not multiply our callback infrastructure without any serious need. We already have to many of them.
2013-03-25 19:48:23 -07:00
evas_render_updates_free(updates);
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
}
evas: no need for a callback per async call. Let's not multiply our callback infrastructure without any serious need. We already have to many of them.
2013-03-25 19:48:23 -07:00
else if (evas_render_async(ee->evas))
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
{
ecore_evas_x: add some debug to help find out e_border problems. EDBG macro is at level 5 to avoid messing existing debugs, use it like: export EINA_LOG_LEVELS=ecore_evas:5 SVN revision: 82656
2013-01-11 10:45:10 -08:00
EDBG("ee=%p started asynchronous render.", ee);
ee->in_async_render = EINA_TRUE;
rend = 1;
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
}
ecore_evas: Ecore_Evas_X - make sure that ecore evas post render is always called. This fix a case where when doing asynchronous rendering and no update was done, the post render evas event would never be triggered and so no call to ecore evas post render callback were made. Now the async X backend follow all other backend behavior. @fix
2014-08-21 03:31:07 -07:00
else if (ee->func.fn_post_render) ee->func.fn_post_render(ee);
ecore_evas_x: add some debug to help find out e_border problems. EDBG macro is at level 5 to avoid messing existing debugs, use it like: export EINA_LOG_LEVELS=ecore_evas:5 SVN revision: 82656
2013-01-11 10:45:10 -08:00
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
return rend;
}
static void
_resize_shape_do(Ecore_Evas *ee)
{
rename 'x11' to 'xlib' for software x11 based engines when it makes sense SVN revision: 41330
2009-07-14 14:18:27 -07:00
#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
Evas_Engine_Info_Software_X11 *einfo;
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
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: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
einfo = (Evas_Engine_Info_Software_X11 *)evas_engine_info_get(ee->evas);
if (einfo)
{
unsigned int foreground;
Ecore_X_GC gc;
if (edata->mask) ecore_x_pixmap_free(edata->mask);
edata->mask = ecore_x_pixmap_new(ee->prop.window, ee->w, ee->h, 1);
foreground = 0;
gc = ecore_x_gc_new(edata->mask,
ECORE_X_GC_VALUE_MASK_FOREGROUND,
&foreground);
ecore_x_drawable_rectangle_fill(edata->mask, gc,
0, 0, ee->w, ee->h);
ecore_x_gc_free(gc);
einfo->info.mask = edata->mask;
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
}
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
}
rename 'x11' to 'xlib' for software x11 based engines when it makes sense SVN revision: 41330
2009-07-14 14:18:27 -07:00
#endif /* BUILD_ECORE_EVAS_SOFTWARE_X11 */
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
}
static void
_ecore_evas_x_resize_shape(Ecore_Evas *ee)
{
if (!strcmp(ee->driver, "software_x11"))
{
if (ee->in_async_render)
{
ee->delayed.resize_shape = EINA_TRUE;
return;
}
_resize_shape_do(ee);
evilness... but it works. SVN revision: 21091
2006-03-08 00:02:55 -08:00
}
fix shaped ecore_evas handling to be more efficient on resize and if we combine it with obscures - those obscured areas at least start as empty :) SVN revision: 14580
2005-05-03 10:35:50 -07:00
}
- if something other than ecore_evas changes some of the states of the x_window, we need to listen to the changes and update our local flags (like sticky for example). If we dont, things like ecore_evas_sticky_get will always return an outdated sticky property. I have implemented it for the sticky bit for now, but this needs to be done for all the others as well. - question: do we want to implement ecore_evas_callback_sticky_set or something similar that will tell the programmer when the sticky bit has changed? I think it would be a good idea to do it here as opposed to doing it inside Etk for example. SVN revision: 24223
2006-07-26 19:42:41 -07:00
/* TODO: we need to make this work for all the states, not just sticky */
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
static Eina_Bool
Ecore: __UNUSED__ --> EINA_UNUSED SVN revision: 79649
2012-11-25 01:55:32 -08:00
_ecore_evas_x_event_property_change(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
- if something other than ecore_evas changes some of the states of the x_window, we need to listen to the changes and update our local flags (like sticky for example). If we dont, things like ecore_evas_sticky_get will always return an outdated sticky property. I have implemented it for the sticky bit for now, but this needs to be done for all the others as well. - question: do we want to implement ecore_evas_callback_sticky_set or something similar that will tell the programmer when the sticky bit has changed? I think it would be a good idea to do it here as opposed to doing it inside Etk for example. SVN revision: 24223
2006-07-26 19:42:41 -07:00
{
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;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
int state_change = 0;
- if something other than ecore_evas changes some of the states of the x_window, we need to listen to the changes and update our local flags (like sticky for example). If we dont, things like ecore_evas_sticky_get will always return an outdated sticky property. I have implemented it for the sticky bit for now, but this needs to be done for all the others as well. - question: do we want to implement ecore_evas_callback_sticky_set or something similar that will tell the programmer when the sticky bit has changed? I think it would be a good idea to do it here as opposed to doing it inside Etk for example. SVN revision: 24223
2006-07-26 19:42:41 -07:00
e = event;
* Ecore_Input: Make it generic. SVN revision: 39577
2009-03-19 06:06:16 -07:00
ee = ecore_event_window_match(e->win);
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
if ((!ee) || (ee->ignore_events)) return ECORE_CALLBACK_PASS_ON; /* pass on event */
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata = ee->engine.data;
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
- if something other than ecore_evas changes some of the states of the x_window, we need to listen to the changes and update our local flags (like sticky for example). If we dont, things like ecore_evas_sticky_get will always return an outdated sticky property. I have implemented it for the sticky bit for now, but this needs to be done for all the others as well. - question: do we want to implement ecore_evas_callback_sticky_set or something similar that will tell the programmer when the sticky bit has changed? I think it would be a good idea to do it here as opposed to doing it inside Etk for example. SVN revision: 24223
2006-07-26 19:42:41 -07:00
if (e->atom == ECORE_X_ATOM_NET_WM_STATE)
{
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
unsigned int i, num;
Ecore_X_Window_State *state;
and now actually test and make sure things work. SVN revision: 68500
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;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
prev.x.modal = edata->state.modal;
prev.x.sticky = edata->state.sticky;
prev.x.maximized_v = edata->state.maximized_v;
prev.x.maximized_h = edata->state.maximized_h;
prev.x.shaded = edata->state.shaded;
prev.x.skip_taskbar = edata->state.skip_taskbar;
prev.x.skip_pager = edata->state.skip_pager;
prev.x.fullscreen = edata->state.fullscreen;
prev.x.above = edata->state.above;
prev.x.below = edata->state.below;
and now actually test and make sure things work. SVN revision: 68500
2012-02-28 02:46:38 -08:00
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;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->state.modal = 0;
edata->state.sticky = 0;
edata->state.maximized_v = 0;
edata->state.maximized_h = 0;
edata->state.shaded = 0;
edata->state.skip_taskbar = 0;
edata->state.skip_pager = 0;
edata->state.fullscreen = 0;
edata->state.above = 0;
edata->state.below = 0;
and now actually test and make sure things work. SVN revision: 68500
2012-02-28 02:46:38 -08:00
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
ee->prop.modal = EINA_FALSE;
ee->prop.maximized = EINA_FALSE;
ee->prop.sticky = EINA_FALSE;
ee->prop.fullscreen = EINA_FALSE;
ecore-evas - fix focus skip flag to be one way this fixes focus skip being set if someone else sets skip pager/taskbar. it's a one-way prop. if focus skip is set THEN skip pager/taskbar is set. not the other way.
2014-11-23 05:01:34 -08:00
// ee->prop.focus_skip = EINA_FALSE;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
tab------------ SVN revision: 52896
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:
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->state.modal = 1;
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
ee->prop.modal = EINA_TRUE;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
break;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
case ECORE_X_WINDOW_STATE_STICKY:
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
ee->prop.sticky = EINA_TRUE;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->state.sticky = 1;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
break;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
case ECORE_X_WINDOW_STATE_MAXIMIZED_VERT:
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->state.maximized_v = 1;
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
ee->prop.maximized = EINA_TRUE;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
break;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
case ECORE_X_WINDOW_STATE_MAXIMIZED_HORZ:
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->state.maximized_h = 1;
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
ee->prop.maximized = EINA_TRUE;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
break;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
case ECORE_X_WINDOW_STATE_SHADED:
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->state.shaded = 1;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
break;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
case ECORE_X_WINDOW_STATE_SKIP_TASKBAR:
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->state.skip_taskbar = 1;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
break;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
case ECORE_X_WINDOW_STATE_SKIP_PAGER:
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->state.skip_pager = 1;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
break;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
case ECORE_X_WINDOW_STATE_FULLSCREEN:
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
ee->prop.fullscreen = 1;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->state.fullscreen = 1;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
break;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
case ECORE_X_WINDOW_STATE_ABOVE:
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->state.above = 1;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
break;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
case ECORE_X_WINDOW_STATE_BELOW:
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->state.below = 1;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
break;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
default:
break;
}
}
free(state);
}
and now actually test and make sure things work. SVN revision: 68500
2012-02-28 02:46:38 -08:00
if (
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
// (prev.x.modal != edata->state.modal) ||
(prev.x.sticky != edata->state.sticky) ||
(prev.x.maximized_v != edata->state.maximized_v) ||
(prev.x.maximized_h != edata->state.maximized_h) ||
// (prev.x.shaded != edata->state.shaded) ||
ecore-evas - fix focus skip flag to be one way this fixes focus skip being set if someone else sets skip pager/taskbar. it's a one-way prop. if focus skip is set THEN skip pager/taskbar is set. not the other way.
2014-11-23 05:01:34 -08:00
(prev.x.skip_taskbar != edata->state.skip_taskbar) ||
(prev.x.skip_pager != edata->state.skip_pager) ||
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
(prev.x.fullscreen != edata->state.fullscreen) ||
// (prev.x.above != edata->state.above) ||
// (prev.x.below != edata->state.below) ||
and now actually test and make sure things work. SVN revision: 68500
2012-02-28 02:46:38 -08:00
// (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;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
}
else if (e->atom == ECORE_X_ATOM_WM_STATE)
{
Ecore_X_Window_State_Hint state;
elm win throttle/norender auto... eocre-evas got a few things wrong. no - not planning a backport of this at this stage. small thing. maybe backport (and chlog/news) if this doesnt cause any new issues? SVN revision: 82549
2013-01-10 03:23:10 -08:00
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
// handle WM_STATE changes
state = ecore_x_icccm_state_get(e->win);
switch (state)
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
case ECORE_X_WINDOW_STATE_HINT_WITHDRAWN:
and now actually test and make sure things work. SVN revision: 68500
2012-02-28 02:46:38 -08:00
if ((!ee->prop.withdrawn) || (ee->prop.iconified))
{
state_change = 1;
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
ee->prop.withdrawn = EINA_TRUE;
ecore - clean up code. fix indentation and use Eina_Bool instead of char.
2014-01-11 01:19:43 -08:00
ee->prop.iconified = EINA_FALSE;
and now actually test and make sure things work. SVN revision: 68500
2012-02-28 02:46:38 -08:00
}
break;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
case ECORE_X_WINDOW_STATE_HINT_ICONIC:
and now actually test and make sure things work. SVN revision: 68500
2012-02-28 02:46:38 -08:00
if ((!ee->prop.iconified) || (ee->prop.withdrawn))
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
{
state_change = 1;
ecore - clean up code. fix indentation and use Eina_Bool instead of char.
2014-01-11 01:19:43 -08:00
ee->prop.iconified = EINA_TRUE;
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
ee->prop.withdrawn = EINA_FALSE;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
}
break;
case ECORE_X_WINDOW_STATE_HINT_NORMAL:
and now actually test and make sure things work. SVN revision: 68500
2012-02-28 02:46:38 -08:00
if ((ee->prop.iconified) || (ee->prop.withdrawn))
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
{
state_change = 1;
ecore - clean up code. fix indentation and use Eina_Bool instead of char.
2014-01-11 01:19:43 -08:00
ee->prop.iconified = EINA_FALSE;
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
ee->prop.withdrawn = EINA_FALSE;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
}
break;
default:
break;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
}
- more work on window state changes. - add ecore_evas_callback_[un]sticky_set SVN revision: 24240
2006-07-27 09:14:33 -07:00
}
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
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
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
return ECORE_CALLBACK_PASS_ON;
- if something other than ecore_evas changes some of the states of the x_window, we need to listen to the changes and update our local flags (like sticky for example). If we dont, things like ecore_evas_sticky_get will always return an outdated sticky property. I have implemented it for the sticky bit for now, but this needs to be done for all the others as well. - question: do we want to implement ecore_evas_callback_sticky_set or something similar that will tell the programmer when the sticky bit has changed? I think it would be a good idea to do it here as opposed to doing it inside Etk for example. SVN revision: 24223
2006-07-26 19:42:41 -07:00
}
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
static Eina_Bool
Ecore: __UNUSED__ --> EINA_UNUSED SVN revision: 79649
2012-11-25 01:55:32 -08:00
_ecore_evas_x_event_visibility_change(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
trying to optimise expose draws - i think i fixed a double-draw bug. SVN revision: 31831
2007-09-27 08:31:00 -07:00
{
Ecore_Evas *ee;
Ecore_X_Event_Window_Visibility_Change *e;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata;
trying to optimise expose draws - i think i fixed a double-draw bug. SVN revision: 31831
2007-09-27 08:31:00 -07:00
e = event;
* Ecore_Input: Make it generic. SVN revision: 39577
2009-03-19 06:06:16 -07:00
ee = ecore_event_window_match(e->win);
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata = ee->engine.data;
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
trying to optimise expose draws - i think i fixed a double-draw bug. SVN revision: 31831
2007-09-27 08:31:00 -07:00
// printf("VIS CHANGE OBSCURED: %p %i\n", ee, e->fully_obscured);
1. ecore-evas doesnt disable draws to fully obscured windows if compositoir is there 2. static atom for compositor check 3. stop filterng out mouse moves for better scroll momentum checks SVN revision: 42182
2009-09-02 05:48:56 -07:00
if (e->fully_obscured)
{
/* FIXME: round trip */
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (!ecore_x_screen_is_composited(edata->screen_num))
1. ecore-evas doesnt disable draws to fully obscured windows if compositoir is there 2. static atom for compositor check 3. stop filterng out mouse moves for better scroll momentum checks SVN revision: 42182
2009-09-02 05:48:56 -07:00
ee->draw_ok = 0;
}
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
else
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
ee->draw_ok = 1;
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
return ECORE_CALLBACK_PASS_ON;
trying to optimise expose draws - i think i fixed a double-draw bug. SVN revision: 31831
2007-09-27 08:31:00 -07:00
}
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
static Eina_Bool
Ecore: __UNUSED__ --> EINA_UNUSED SVN revision: 79649
2012-11-25 01:55:32 -08:00
_ecore_evas_x_event_client_message(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
more work on the sync stuff... looking good now. SVN revision: 45772
2010-02-01 06:13:48 -08:00
{
Ecore_Evas *ee;
Ecore_X_Event_Client_Message *e;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata;
more work on the sync stuff... looking good now. SVN revision: 45772
2010-02-01 06:13:48 -08:00
e = event;
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
if (e->format != 32) return ECORE_CALLBACK_PASS_ON;
more work on the sync stuff... looking good now. SVN revision: 45772
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]);
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
ecore - clean up code. fix indentation and use Eina_Bool instead of char.
2014-01-11 01:19:43 -08:00
edata = ee->engine.data;
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
if (e->data.l[0] != (long)ee->prop.window)
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
return ECORE_CALLBACK_PASS_ON;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (!edata->sync_began)
fix sync issue in 1 special event re-order case. booo! SVN revision: 51609
2010-08-24 02:26:34 -07:00
{
// qeue a damage + draw. work around an event re-ordering thing.
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
fix sync issue in 1 special event re-order case. booo! SVN revision: 51609
2010-08-24 02:26:34 -07:00
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->sync_began = 1;
edata->sync_cancel = 0;
more work on the sync stuff... looking good now. SVN revision: 45772
2010-02-01 06:13:48 -08:00
}
else if (e->message_type == ECORE_X_ATOM_E_COMP_SYNC_END)
{
ee = ecore_event_window_match(e->data.l[0]);
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
ecore - clean up code. fix indentation and use Eina_Bool instead of char.
2014-01-11 01:19:43 -08:00
edata = ee->engine.data;
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
if (e->data.l[0] != (long)ee->prop.window)
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
return ECORE_CALLBACK_PASS_ON;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->sync_began = 0;
edata->sync_cancel = 0;
more work on the sync stuff... looking good now. SVN revision: 45772
2010-02-01 06:13:48 -08:00
}
else if (e->message_type == ECORE_X_ATOM_E_COMP_SYNC_CANCEL)
{
ee = ecore_event_window_match(e->data.l[0]);
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
ecore - clean up code. fix indentation and use Eina_Bool instead of char.
2014-01-11 01:19:43 -08:00
edata = ee->engine.data;
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
if (e->data.l[0] != (long)ee->prop.window)
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
return ECORE_CALLBACK_PASS_ON;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->sync_began = 0;
edata->sync_cancel = 1;
more work on the sync stuff... looking good now. SVN revision: 45772
2010-02-01 06:13:48 -08:00
}
ecore-evas: feature++ : support netm sync protocol for clients SVN revision: 58198
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 */
ecore - clean up code. fix indentation and use Eina_Bool instead of char.
2014-01-11 01:19:43 -08:00
edata = ee->engine.data;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->netwm_sync_val_lo = (unsigned int)e->data.l[2];
edata->netwm_sync_val_hi = (int)e->data.l[3];
edata->netwm_sync_set = 1;
ecore-evas: feature++ : support netm sync protocol for clients SVN revision: 58198
2011-03-30 03:10:04 -07:00
}
some clang warning cleanups i forgot to commit SVN revision: 83024
2013-01-20 16:22:35 -08:00
else if (e->message_type == ECORE_X_ATOM_E_WINDOW_PROFILE_CHANGE_REQUEST)
From: Gwanglim Lee <gl77.lee@samsung.com> Subject: Re: Re: Re: [E-devel] [RFC] Virtual desktop window profile I've attached 4th patch. May the 4th be with you. ecore patch has been merged with efl and all files are based on r80123. Thanks & Regards, Gwanglim ------- Original Message ------- Sender : Daniel Juyung Seo<seojuyung2@gmail.com> Date : 2012-12-04 01:55 (GMT+09:00) Title : Re: Re: [E-devel] [RFC] Virtual desktop window profile It looks ok to me. Sorry but can you re-generate the patch according to the recent ecore merge to efl single tree? Daniel Juyung Seo (SeoZ) On Thu, Nov 29, 2012 at 12:29 AM, Gwanglim Lee <gl77.lee@samsung.com> wrote: Dear Raster and Daniel Juyung Seo, I've attached 3rd patches and test_config according to your reviews. These are based on r79782. [elementary & ecore] 1. "profile,set" -> "profile,changed" - done 2. spaces after EINA_LIST_FOREACH - done 3. variable type - keep 4. author - done 5. removing deprecated marking in patch - done 6. add elm_win_available_profiles_get to test_config for the debugging purpose - done 7. check whether a given profile is present in an available profiles. otherwise window profile will be one of the item in available profiles. - newly added thing to the elm_win 8. merge with EO - done. :( Any comments would be appreciated. SVN revision: 80214
2012-12-04 22:48:46 -08:00
{
ee = ecore_event_window_match(e->win);
if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
ecore - clean up code. fix indentation and use Eina_Bool instead of char.
2014-01-11 01:19:43 -08:00
edata = ee->engine.data;
From: Gwanglim Lee <gl77.lee@samsung.com> Subject: Re: Re: Re: [E-devel] [RFC] Virtual desktop window profile I've attached 4th patch. May the 4th be with you. ecore patch has been merged with efl and all files are based on r80123. Thanks & Regards, Gwanglim ------- Original Message ------- Sender : Daniel Juyung Seo<seojuyung2@gmail.com> Date : 2012-12-04 01:55 (GMT+09:00) Title : Re: Re: [E-devel] [RFC] Virtual desktop window profile It looks ok to me. Sorry but can you re-generate the patch according to the recent ecore merge to efl single tree? Daniel Juyung Seo (SeoZ) On Thu, Nov 29, 2012 at 12:29 AM, Gwanglim Lee <gl77.lee@samsung.com> wrote: Dear Raster and Daniel Juyung Seo, I've attached 3rd patches and test_config according to your reviews. These are based on r79782. [elementary & ecore] 1. "profile,set" -> "profile,changed" - done 2. spaces after EINA_LIST_FOREACH - done 3. variable type - keep 4. author - done 5. removing deprecated marking in patch - done 6. add elm_win_available_profiles_get to test_config for the debugging purpose - done 7. check whether a given profile is present in an available profiles. otherwise window profile will be one of the item in available profiles. - newly added thing to the elm_win 8. merge with EO - done. :( Any comments would be appreciated. SVN revision: 80214
2012-12-04 22:48:46 -08:00
if (ee->profile_supported)
{
char *p = ecore_x_atom_name_get(e->data.l[1]);
if (p)
{
_ecore_evas_window_profile_free(ee);
ee->prop.profile.name = (char *)eina_stringshare_add(p);
/* window profiles of each sub_ecore_evas will be changed
* in fn_state_change callback.
*/
if (ee->func.fn_state_change)
ee->func.fn_state_change(ee);
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->profile.done = 1;
From: Gwanglim Lee <gl77.lee@samsung.com> Subject: Re: Re: Re: [E-devel] [RFC] Virtual desktop window profile I've attached 4th patch. May the 4th be with you. ecore patch has been merged with efl and all files are based on r80123. Thanks & Regards, Gwanglim ------- Original Message ------- Sender : Daniel Juyung Seo<seojuyung2@gmail.com> Date : 2012-12-04 01:55 (GMT+09:00) Title : Re: Re: [E-devel] [RFC] Virtual desktop window profile It looks ok to me. Sorry but can you re-generate the patch according to the recent ecore merge to efl single tree? Daniel Juyung Seo (SeoZ) On Thu, Nov 29, 2012 at 12:29 AM, Gwanglim Lee <gl77.lee@samsung.com> wrote: Dear Raster and Daniel Juyung Seo, I've attached 3rd patches and test_config according to your reviews. These are based on r79782. [elementary & ecore] 1. "profile,set" -> "profile,changed" - done 2. spaces after EINA_LIST_FOREACH - done 3. variable type - keep 4. author - done 5. removing deprecated marking in patch - done 6. add elm_win_available_profiles_get to test_config for the debugging purpose - done 7. check whether a given profile is present in an available profiles. otherwise window profile will be one of the item in available profiles. - newly added thing to the elm_win 8. merge with EO - done. :( Any comments would be appreciated. SVN revision: 80214
2012-12-04 22:48:46 -08:00
free(p);
}
}
}
Add infrastructure to handle message between ecore and parent ecore in Ecore_Evas I add new example related with this. (ecore_evas_extn_socket & plug example) ecore extn use this infrasturcture, server app and client app can communicate each other later, this can be used to contorl access message SVN revision: 83942
2013-02-15 01:32:40 -08:00
else if (e->message_type == ECORE_X_ATOM_E_ILLUME_ACCESS_CONTROL)
ecore - clean up code. fix indentation and use Eina_Bool instead of char.
2014-01-11 01:19:43 -08:00
{
///TODO after access structure determined
// if (ee->func.fn_msg_handle)
// ee->func.fn_msg_handle(ee, msg_domain, msg_id, data, size);
Ecore_x: Add manual render code before deiconify
2013-03-06 23:33:59 -08:00
}
else if (e->message_type == ECORE_X_ATOM_E_DEICONIFY_APPROVE)
{
ee = ecore_event_window_match(e->win);
if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
ecore_x: fix bug not check data value when get deiconify message
2013-03-11 19:53:21 -07:00
if (e->data.l[1] != 0) //wm sends request message using value 0
return ECORE_CALLBACK_PASS_ON;
Ecore_x: Add manual render code before deiconify
2013-03-06 23:33:59 -08:00
if (ecore_evas_manual_render_get(ee))
ecore_evas_manual_render(ee);
ecore_x: fix bug not check data value when get deiconify message
2013-03-11 19:53:21 -07:00
//client sends reply message using value 1
Ecore_x: Add manual render code before deiconify
2013-03-06 23:33:59 -08:00
ecore_x_client_message32_send(e->win, ECORE_X_ATOM_E_DEICONIFY_APPROVE,
ECORE_X_EVENT_MASK_WINDOW_CONFIGURE,
e->win, 1,
0, 0, 0);
ecore - clean up code. fix indentation and use Eina_Bool instead of char.
2014-01-11 01:19:43 -08:00
}
ecore_evas: added window manager rotation to manage the rotation of windows by the WM. Summary: The window manager rotation allows the WM to controls the rotation of application windows. It is designed to support synchronized rotation for the multiple application windows at same time. Reviewers: raster, seoz, cedric, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D529
2014-02-08 16:46:51 -08:00
else if (e->message_type == ECORE_X_ATOM_E_WINDOW_ROTATION_CHANGE_PREPARE)
{
ee = ecore_event_window_match(e->data.l[0]);
if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
edata = ee->engine.data;
if (e->data.l[0] != (long)ee->prop.window)
return ECORE_CALLBACK_PASS_ON;
if (ee->prop.wm_rot.supported)
{
if (ee->prop.wm_rot.app_set)
{
ee->prop.wm_rot.angle = (int)e->data.l[1];
ee->prop.wm_rot.win_resize = (int)e->data.l[2];
ee->prop.wm_rot.w = (int)e->data.l[3];
ee->prop.wm_rot.h = (int)e->data.l[4];
if (ee->prop.wm_rot.win_resize)
edata->wm_rot.configure_coming = 1;
edata->wm_rot.prepare = 1;
edata->wm_rot.request = 0;
edata->wm_rot.done = 0;
}
}
}
else if (e->message_type == ECORE_X_ATOM_E_WINDOW_ROTATION_CHANGE_REQUEST)
{
ee = ecore_event_window_match(e->data.l[0]);
if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
edata = ee->engine.data;
if (e->data.l[0] != (long)ee->prop.window)
return ECORE_CALLBACK_PASS_ON;
if (ee->prop.wm_rot.supported)
{
if (ee->prop.wm_rot.app_set)
{
edata->wm_rot.prepare = 0;
edata->wm_rot.request = 1;
edata->wm_rot.done = 0;
if (ee->prop.wm_rot.win_resize)
{
if ((ee->w == ee->prop.wm_rot.w) &&
(ee->h == ee->prop.wm_rot.h))
{
edata->wm_rot.configure_coming = 0;
}
}
if (!edata->wm_rot.configure_coming)
{
if (ee->prop.wm_rot.manual_mode.set)
{
ee->prop.wm_rot.manual_mode.wait_for_done = EINA_TRUE;
_ecore_evas_x_wm_rot_manual_rotation_done_timeout_update(ee);
}
_ecore_evas_x_rotation_set(ee, ee->prop.wm_rot.angle, 1);
}
}
}
}
ecore_evas: Added support for window auxiliary hint Summary: The window auxiliary hint is the value which is used to decide which actions should be made available to the user by the WM. If you want to set specific hint to your window, then you should check whether it exists in the supported auxiliary hints that are registered in the root window by the window manager. Once you've added an auxiliary hint, you can get a new ID which is used to change value and delete hint. The window manager sends the response message to the application on receiving auxiliary hint change event. A list of auxiliary hint within the Ecore_Evas has this format: ID:HINT:VALUE,ID:HINT:VALUE,... Reviewers: raster, cedric, seoz, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D543
2014-02-27 14:20:01 -08:00
else if (e->message_type == ECORE_X_ATOM_E_WINDOW_AUX_HINT_ALLOWED)
{
ee = ecore_event_window_match(e->win);
if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
int id = e->data.l[1]; /* id of aux hint */
Eina_List *l;
Ecore_Evas_Aux_Hint *aux;
EINA_LIST_FOREACH(ee->prop.aux_hint.hints, l, aux)
{
if (id == aux->id)
{
aux->allowed = 1;
if (!aux->notified)
{
if (ee->func.fn_state_change) ee->func.fn_state_change(ee);
aux->notified = 1;
}
break;
}
}
}
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
return ECORE_CALLBACK_PASS_ON;
more work on the sync stuff... looking good now. SVN revision: 45772
2010-02-01 06:13:48 -08:00
}
ecore-evas - handle mouse out then in due to click-to-focus passive grabs
2013-10-18 03:23:38 -07:00
static Eina_Bool
_fake_out(void *data)
{
Ecore_Evas *ee = data;
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
Ecore_X_Event_Mouse_Out *e = &(edata->out_ev);
whitespace-- Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-10-31 02:38:34 -07:00
ecore-evas - handle mouse out then in due to click-to-focus passive grabs
2013-10-18 03:23:38 -07:00
edata->outdelay = NULL;
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;
return EINA_FALSE;
}
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
static Eina_Bool
Ecore: __UNUSED__ --> EINA_UNUSED SVN revision: 79649
2012-11-25 01:55:32 -08:00
_ecore_evas_x_event_mouse_in(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
Ecore_Evas *ee;
Ecore_X_Event_Mouse_In *e;
ecore-evas - handle mouse out then in due to click-to-focus passive grabs
2013-10-18 03:23:38 -07:00
Ecore_Evas_Engine_Data_X11 *edata;
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
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
e = event;
Revert the changes on ecore_x, seems not needed and break composite SVN revision: 53617
2010-10-19 06:56:17 -07:00
ee = ecore_event_window_match(e->win);
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
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;
ecore-evas - handle mouse out then in due to click-to-focus passive grabs
2013-10-18 03:23:38 -07:00
edata = ee->engine.data;
/*
{
time_t t;
char *ct;
const char *modes[] = {
"MODE_NORMAL",
"MODE_WHILE_GRABBED",
"MODE_GRAB",
"MODE_UNGRAB"
};
const char *details[] = {
"DETAIL_ANCESTOR",
"DETAIL_VIRTUAL",
"DETAIL_INFERIOR",
"DETAIL_NON_LINEAR",
"DETAIL_NON_LINEAR_VIRTUAL",
"DETAIL_POINTER",
"DETAIL_POINTER_ROOT",
"DETAIL_DETAIL_NONE"
};
t = time(NULL);
ct = ctime(&t);
ct[strlen(ct) - 1] = 0;
printf("@@ ->IN 0x%x 0x%x %s md=%s dt=%s\n",
e->win, e->event_win,
ct,
modes[e->mode],
details[e->detail]);
}
*/
Fix common misspellings Following misspellings were fixed: alledgedly->allegedly cant->can't carefull->careful consistant->consistent currenly->currently dependancy->dependency descripters->descriptors doesnt->doesn't dosen't->doesn't existant->existent exmaple->example inbetween->between independant->independent isnt->isn't mroe->more neccessary->necessary occured->occurred occurence->occurrence parrallel->parallel particualr->particular preceeding->preceding recieved->received recieves->receives seperate->separate substraction->subtraction succesfully->successfully successfull->successful sucess->success supress->suppress usefull->useful witht->with SVN revision: 51986
2010-09-08 04:23:42 -07:00
// disable. causes more problems than it fixes
Let me introduce you to Ecore_Input. The idea is to share as much as possible event between all ecore graphic engine to ease porting of application and reduce the amount of specific code per engine. This patch does just that. All your application should continu to work has previously, if it's not the case please report any new behaviour regarding mouse and keyboard. SVN revision: 39505
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;
ecore-evas - handle mouse out then in due to click-to-focus passive grabs
2013-10-18 03:23:38 -07:00
// handle click to focus passive buton grab side-effects
if ((e->mode == ECORE_X_EVENT_MODE_UNGRAB) &&
(e->detail == ECORE_X_EVENT_DETAIL_ANCESTOR) &&
(edata->outdelay))
{
ecore_timer_del(edata->outdelay);
edata->outdelay = NULL;
return 0;
}
if (edata->outdelay)
{
ecore_timer_del(edata->outdelay);
edata->outdelay = NULL;
_fake_out(ee);
}
Let me introduce you to Ecore_Input. The idea is to share as much as possible event between all ecore graphic engine to ease porting of application and reduce the amount of specific code per engine. This patch does just that. All your application should continu to work has previously, if it's not the case please report any new behaviour regarding mouse and keyboard. SVN revision: 39505
2009-03-16 09:24:43 -07:00
/* if (e->mode != ECORE_X_EVENT_MODE_NORMAL) return 0; */
fix mouse down grab coutns if window minimized or hidden (especially the second). SVN revision: 66568
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;
}
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
return ECORE_CALLBACK_PASS_ON;
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
static Eina_Bool
Ecore: __UNUSED__ --> EINA_UNUSED SVN revision: 79649
2012-11-25 01:55:32 -08:00
_ecore_evas_x_event_mouse_out(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
Ecore_Evas *ee;
Ecore_X_Event_Mouse_Out *e;
ecore-evas - handle mouse out then in due to click-to-focus passive grabs
2013-10-18 03:23:38 -07:00
Ecore_Evas_Engine_Data_X11 *edata;
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
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
e = event;
Revert the changes on ecore_x, seems not needed and break composite SVN revision: 53617
2010-10-19 06:56:17 -07:00
ee = ecore_event_window_match(e->win);
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
if ((!ee) || (ee->ignore_events)) return ECORE_CALLBACK_PASS_ON;
Let me introduce you to Ecore_Input. The idea is to share as much as possible event between all ecore graphic engine to ease porting of application and reduce the amount of specific code per engine. This patch does just that. All your application should continu to work has previously, if it's not the case please report any new behaviour regarding mouse and keyboard. SVN revision: 39505
2009-03-16 09:24:43 -07:00
/* pass on event */
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
ecore-evas - handle mouse out then in due to click-to-focus passive grabs
2013-10-18 03:23:38 -07:00
edata = ee->engine.data;
/*
{
time_t t;
char *ct;
const char *modes[] = {
"MODE_NORMAL",
"MODE_WHILE_GRABBED",
"MODE_GRAB",
"MODE_UNGRAB"
};
const char *details[] = {
"DETAIL_ANCESTOR",
"DETAIL_VIRTUAL",
"DETAIL_INFERIOR",
"DETAIL_NON_LINEAR",
"DETAIL_NON_LINEAR_VIRTUAL",
"DETAIL_POINTER",
"DETAIL_POINTER_ROOT",
"DETAIL_DETAIL_NONE"
};
t = time(NULL);
ct = ctime(&t);
ct[strlen(ct) - 1] = 0;
printf("@@ ->OUT 0x%x 0x%x %s md=%s dt=%s\n",
e->win, e->event_win,
ct,
modes[e->mode],
details[e->detail]);
}
*/
Let me introduce you to Ecore_Input. The idea is to share as much as possible event between all ecore graphic engine to ease porting of application and reduce the amount of specific code per engine. This patch does just that. All your application should continu to work has previously, if it's not the case please report any new behaviour regarding mouse and keyboard. SVN revision: 39505
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;
ecore-evas - handle mouse out then in due to click-to-focus passive grabs
2013-10-18 03:23:38 -07:00
// click to focus mouse out+in work-around
if ((e->mode == ECORE_X_EVENT_MODE_GRAB) &&
(e->detail == ECORE_X_EVENT_DETAIL_ANCESTOR))
{
// defer out handling in case its a "fake" out thanks to click
// to focus (which gets us another out soon after
if (edata->outdelay) ecore_timer_del(edata->outdelay);
edata->out_ev = *e;
edata->outdelay = ecore_timer_add(0.05, _fake_out, ee);
return 0;
}
if (edata->outdelay)
{
ecore_timer_del(edata->outdelay);
edata->outdelay = NULL;
}
// if (e->mode != ECORE_X_EVENT_MODE_NORMAL) return 0;
and fix my "mouse grab+hide_mouse out" fix to not break e17 dnd :) SVN revision: 66582
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));
fix mouse down grab coutns if window minimized or hidden (especially the second). SVN revision: 66568
2011-12-27 04:02:18 -08:00
if (ee->in)
{
and fix my "mouse grab+hide_mouse out" fix to not break e17 dnd :) SVN revision: 66582
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))))
fix mouse down grab coutns if window minimized or hidden (especially the second). SVN revision: 66568
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;
}
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
return ECORE_CALLBACK_PASS_ON;
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
static Eina_Bool
Ecore: __UNUSED__ --> EINA_UNUSED SVN revision: 79649
2012-11-25 01:55:32 -08:00
_ecore_evas_x_event_window_focus_in(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
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
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
e = event;
* Ecore_Input: Make it generic. SVN revision: 39577
2009-03-19 06:06:16 -07:00
ee = ecore_event_window_match(e->win);
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
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;
this is dicsomfitors focus problem. commit and lets see if peolpe suffer. SVN revision: 69039
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;
ecore - clean up code. fix indentation and use Eina_Bool instead of char.
2014-01-11 01:19:43 -08:00
ee->prop.focused = EINA_TRUE;
more work on the sync stuff... looking good now. SVN revision: 45772
2010-02-01 06:13:48 -08:00
evas_focus_in(ee->evas);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
if (ee->func.fn_focus_in) ee->func.fn_focus_in(ee);
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
return ECORE_CALLBACK_PASS_ON;
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
static Eina_Bool
Ecore: __UNUSED__ --> EINA_UNUSED SVN revision: 79649
2012-11-25 01:55:32 -08:00
_ecore_evas_x_event_window_focus_out(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
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
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
e = event;
* Ecore_Input: Make it generic. SVN revision: 39577
2009-03-19 06:06:16 -07:00
ee = ecore_event_window_match(e->win);
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
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;
this is dicsomfitors focus problem. commit and lets see if peolpe suffer. SVN revision: 69039
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;
more work on the sync stuff... looking good now. SVN revision: 45772
2010-02-01 06:13:48 -08:00
// if (ee->prop.fullscreen)
// ecore_x_window_focus(ee->prop.window);
evas_focus_out(ee->evas);
ecore - clean up code. fix indentation and use Eina_Bool instead of char.
2014-01-11 01:19:43 -08:00
ee->prop.focused = EINA_FALSE;
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
if (ee->func.fn_focus_out) ee->func.fn_focus_out(ee);
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
return ECORE_CALLBACK_PASS_ON;
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
static Eina_Bool
Ecore: __UNUSED__ --> EINA_UNUSED SVN revision: 79649
2012-11-25 01:55:32 -08:00
_ecore_evas_x_event_window_damage(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
Ecore_Evas *ee;
Ecore_X_Event_Window_Damage *e;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata;
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
e = event;
* Ecore_Input: Make it generic. SVN revision: 39577
2009-03-19 06:06:16 -07:00
ee = ecore_event_window_match(e->win);
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata = ee->engine.data;
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (edata->using_bg_pixmap) return ECORE_CALLBACK_PASS_ON;
trying to optimise expose draws - i think i fixed a double-draw bug. SVN revision: 31831
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);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
if (ee->prop.avoid_damage)
{
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
Ecore_X_Rectangle rect;
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
Ecore_X_XRegion *tmpr;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (!edata->damages)
edata->damages = ecore_x_xregion_new();
tab------------ SVN revision: 52896
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_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ecore_x_xregion_union_rect(tmpr, edata->damages, &rect);
ecore_x_xregion_free(edata->damages);
edata->damages = tmpr;
noooo. fixie fixie. SVN revision: 29503
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
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
Ecore_X_Rectangle rect;
Ecore_X_XRegion *tmpr;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (!edata->damages) edata->damages = ecore_x_xregion_new();
tab------------ SVN revision: 52896
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_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ecore_x_xregion_union_rect(tmpr, edata->damages, &rect);
ecore_x_xregion_free(edata->damages);
edata->damages = tmpr;
noooo. fixie fixie. SVN revision: 29503
2007-04-13 21:20:23 -07:00
*/
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
else
{
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
if (ee->rotation == 0)
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
evas_damage_rectangle_add(ee->evas, e->x, e->y, e->w, e->h);
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
else if (ee->rotation == 90)
evas_damage_rectangle_add(ee->evas,
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
ee->h - e->y - e->h, e->x, e->h, e->w);
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
else if (ee->rotation == 180)
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
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);
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
else if (ee->rotation == 270)
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
evas_damage_rectangle_add(ee->evas, e->y, ee->w - e->x - e->w,
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
e->h, e->w);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
return ECORE_CALLBACK_PASS_ON;
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
static Eina_Bool
Ecore: __UNUSED__ --> EINA_UNUSED SVN revision: 79649
2012-11-25 01:55:32 -08:00
_ecore_evas_x_event_window_destroy(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
Ecore_Evas *ee;
Ecore_X_Event_Window_Destroy *e;
ecore-evas-x no longer uses X windows after receiving a destroy event
2013-07-24 05:58:57 -07:00
Ecore_Evas_Engine_Data_X11 *edata;
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
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
e = event;
Revert the changes on ecore_x, seems not needed and break composite SVN revision: 53617
2010-10-19 06:56:17 -07:00
ee = ecore_event_window_match(e->win);
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
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;
ecore-evas-x no longer uses X windows after receiving a destroy event
2013-07-24 05:58:57 -07:00
edata = ee->engine.data;
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
if (ee->func.fn_destroy) ee->func.fn_destroy(ee);
ecore-evas-x no longer uses X windows after receiving a destroy event
2013-07-24 05:58:57 -07:00
edata->destroyed = 1;
more work on the sync stuff... looking good now. SVN revision: 45772
2010-02-01 06:13:48 -08:00
_ecore_evas_x_sync_clear(ee);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
ecore_evas_free(ee);
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
return ECORE_CALLBACK_PASS_ON;
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
static Eina_Bool
Ecore: __UNUSED__ --> EINA_UNUSED SVN revision: 79649
2012-11-25 01:55:32 -08:00
_ecore_evas_x_event_window_configure(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
Ecore_Evas *ee;
Ecore_X_Event_Window_Configure *e;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata;
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
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
e = event;
Revert the changes on ecore_x, seems not needed and break composite SVN revision: 53617
2010-10-19 06:56:17 -07:00
ee = ecore_event_window_match(e->win);
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata = ee->engine.data;
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (edata->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
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->configure_coming = 0;
evilness... but it works. SVN revision: 21091
2006-03-08 00:02:55 -08:00
if ((e->from_wm) || (ee->prop.override))
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
tab------------ SVN revision: 52896
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;
hmm fix resize before change alpha... SVN revision: 46579
2010-02-27 06:40:10 -08:00
ee->req.x = ee->x;
ee->req.y = ee->y;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
if (ee->func.fn_move) ee->func.fn_move(ee);
}
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
ecore-evas - x11 - call resize callback if wm denies resize request in SOME cases a wm may deny a resize request entirely and keep the window size the same. it does so with a configurenotify of the SAME size as before. problem is we never passed this onto the app with a resize callback of the original size before request to the new size. this does that now. cherry-pick me!
2013-12-29 20:39:18 -08:00
if ((ee->w != e->w) || (ee->h != e->h) ||
(ee->req.w != e->w) || (ee->req.h != e->h))
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
ee->w = e->w;
ee->h = e->h;
hmm fix resize before change alpha... SVN revision: 46579
2010-02-27 06:40:10 -08:00
ee->req.w = ee->w;
ee->req.h = ee->h;
ecore_evas - applied macro to check rotation state. also, let the potrait compare on the higher priority. if you can suggest better macro name, then please modify it.
2014-01-18 05:26:10 -08:00
if (ECORE_EVAS_PORTRAIT(ee))
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
ecore_evas - applied macro to check rotation state. also, let the potrait compare on the higher priority. if you can suggest better macro name, then please modify it.
2014-01-18 05:26:10 -08:00
evas_output_size_set(ee->evas, ee->w, ee->h);
evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
}
else
{
ecore_evas - applied macro to check rotation state. also, let the potrait compare on the higher priority. if you can suggest better macro name, then please modify it.
2014-01-18 05:26:10 -08:00
evas_output_size_set(ee->evas, ee->h, ee->w);
evas_output_viewport_set(ee->evas, 0, 0, ee->h, ee->w);
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
}
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);
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
if ((ee->expecting_resize.w > 0) && (ee->expecting_resize.h > 0))
tab------------ SVN revision: 52896
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);
ecore_evas: added window manager rotation to manage the rotation of windows by the WM. Summary: The window manager rotation allows the WM to controls the rotation of application windows. It is designed to support synchronized rotation for the multiple application windows at same time. Reviewers: raster, seoz, cedric, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D529
2014-02-08 16:46:51 -08:00
if (ee->prop.wm_rot.supported)
{
if (edata->wm_rot.prepare)
{
if ((ee->prop.wm_rot.w == e->w) &&
(ee->prop.wm_rot.h == e->h))
{
edata->wm_rot.configure_coming = 0;
}
}
else if (edata->wm_rot.request)
{
if ((edata->wm_rot.configure_coming) &&
(ee->prop.wm_rot.w == e->w) &&
(ee->prop.wm_rot.h == e->h))
{
edata->wm_rot.configure_coming = 0;
if (ee->prop.wm_rot.manual_mode.set)
{
ee->prop.wm_rot.manual_mode.wait_for_done = EINA_TRUE;
_ecore_evas_x_wm_rot_manual_rotation_done_timeout_update(ee);
}
_ecore_evas_x_rotation_set(ee,
ee->prop.wm_rot.angle,
EINA_TRUE);
}
}
}
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
return ECORE_CALLBACK_PASS_ON;
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
static Eina_Bool
Ecore: __UNUSED__ --> EINA_UNUSED SVN revision: 79649
2012-11-25 01:55:32 -08:00
_ecore_evas_x_event_window_delete_request(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
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
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
e = event;
* Ecore_Input: Make it generic. SVN revision: 39577
2009-03-19 06:06:16 -07:00
ee = ecore_event_window_match(e->win);
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
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;
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
if (ee->func.fn_delete_request) ee->func.fn_delete_request(ee);
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
return ECORE_CALLBACK_PASS_ON;
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
static Eina_Bool
Ecore: __UNUSED__ --> EINA_UNUSED SVN revision: 79649
2012-11-25 01:55:32 -08:00
_ecore_evas_x_event_window_show(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
Ecore_Evas *ee;
Ecore_X_Event_Window_Show *e;
work around a gl driver bug export ECORE_EVAS_GL_FIRST_MAP_BUG=1 if you end up with blank empty windows when using evas gl engine in them SVN revision: 50981
2010-08-10 22:12:22 -07:00
static int first_map_bug = -1;
Ecore: Removed trailing whitespaces. SVN revision: 58753
2011-04-20 07:15:33 -07:00
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
e = event;
Revert the changes on ecore_x, seems not needed and break composite SVN revision: 53617
2010-10-19 06:56:17 -07:00
ee = ecore_event_window_match(e->win);
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
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;
ecore_evas_x: Fixed formatting and added an empty line for a better readability.
2014-01-08 02:51:42 -08:00
Ecore_Evas Merge Tizen changes to upstream EFL. SVN revision: 73206
2012-07-03 00:44:17 -07:00
if (ee->gl_sync_draw_done < 0)
{
ecore_evas_x: Fix gl_sync_draw_done initialize routine to handle exceptional case. As ECORE_EVAS_GL_SYNC_DRAW_DONE is an environment variable, that could have unexpected value like 2 or 3. So set gl_sync_draw_done to 1 only when the env variable is 1.
2014-01-12 00:01:02 -08:00
char *sync = getenv("ECORE_EVAS_GL_SYNC_DRAW_DONE");
if (sync && (atoi(sync) == 1))
ee->gl_sync_draw_done = 1;
Ecore_Evas Merge Tizen changes to upstream EFL. SVN revision: 73206
2012-07-03 00:44:17 -07:00
else
ecore_evas_x: Fixed formatting and added an empty line for a better readability.
2014-01-08 02:51:42 -08:00
ee->gl_sync_draw_done = 0;
Ecore_Evas Merge Tizen changes to upstream EFL. SVN revision: 73206
2012-07-03 00:44:17 -07:00
}
ecore_evas_x: Fixed formatting and added an empty line for a better readability.
2014-01-08 02:51:42 -08:00
work around a gl driver bug export ECORE_EVAS_GL_FIRST_MAP_BUG=1 if you end up with blank empty windows when using evas gl engine in them SVN revision: 50981
2010-08-10 22:12:22 -07:00
if (first_map_bug < 0)
{
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
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);
work around a gl driver bug export ECORE_EVAS_GL_FIRST_MAP_BUG=1 if you end up with blank empty windows when using evas gl engine in them SVN revision: 50981
2010-08-10 22:12:22 -07:00
else
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
first_map_bug = 0;
work around a gl driver bug export ECORE_EVAS_GL_FIRST_MAP_BUG=1 if you end up with blank empty windows when using evas gl engine in them SVN revision: 50981
2010-08-10 22:12:22 -07:00
}
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
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);
ecore_evas - ecore_evas's should start withdrawn then normal on show this fixes initial state of an ee where you couldn't detect when the window had been accepted by the wm (goes to normal state from withdrawn). @fix
2014-10-29 03:33:16 -07:00
if (ee->prop.override)
{
ee->prop.withdrawn = EINA_FALSE;
if (ee->func.fn_state_change) ee->func.fn_state_change(ee);
}
Fix bug ecore-evas for fb, buffer, sdl back-ends to ensure mouse is in on init (as events wont always give this) and focus is set on show if appropriate if no focus in/out events come from the back-end later Fix setting override state to only hide if it should be visible at that point in x back end support SVN revision: 65508
2011-11-21 21:51:06 -08:00
if (ee->visible) return ECORE_CALLBACK_PASS_ON;
// if (ee->visible) return ECORE_CALLBACK_DONE;
trying to optimise expose draws - i think i fixed a double-draw bug. SVN revision: 31831
2007-09-27 08:31:00 -07:00
// printf("SHOW EVENT %p\n", ee);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
ee->visible = 1;
if (ee->func.fn_show) ee->func.fn_show(ee);
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
return ECORE_CALLBACK_PASS_ON;
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
static Eina_Bool
Ecore: __UNUSED__ --> EINA_UNUSED SVN revision: 79649
2012-11-25 01:55:32 -08:00
_ecore_evas_x_event_window_hide(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
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
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
e = event;
Revert the changes on ecore_x, seems not needed and break composite SVN revision: 53617
2010-10-19 06:56:17 -07:00
ee = ecore_event_window_match(e->win);
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
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;
fix mouse down grab coutns if window minimized or hidden (especially the second). SVN revision: 66568
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;
}
ecore_evas - ecore_evas's should start withdrawn then normal on show this fixes initial state of an ee where you couldn't detect when the window had been accepted by the wm (goes to normal state from withdrawn). @fix
2014-10-29 03:33:16 -07:00
if (ee->prop.override)
{
ee->prop.withdrawn = EINA_TRUE;
if (ee->func.fn_state_change) ee->func.fn_state_change(ee);
}
Fix bug ecore-evas for fb, buffer, sdl back-ends to ensure mouse is in on init (as events wont always give this) and focus is set on show if appropriate if no focus in/out events come from the back-end later Fix setting override state to only hide if it should be visible at that point in x back end support SVN revision: 65508
2011-11-21 21:51:06 -08:00
if (!ee->visible) return ECORE_CALLBACK_PASS_ON;
// if (!ee->visible) return ECORE_CALLBACK_DONE;
ok fixed visibility event. now it works as planned. SVN revision: 31832
2007-09-27 08:43:08 -07:00
// printf("HIDE EVENT %p\n", ee);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
ee->visible = 0;
if (ee->func.fn_hide) ee->func.fn_hide(ee);
* ecore: Ecore callback really should return Eina_Bool. SVN revision: 49829
2010-06-24 09:15:56 -07:00
return ECORE_CALLBACK_PASS_ON;
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
Make ecore evas use netwm and icccm, not window_prop. Window_prop is gone, but maybe resurrect some parts of it as a wrapper around icccm/netwm as convencience functions? SVN revision: 15227
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 */
Make ecore evas use netwm and icccm, not window_prop. Window_prop is gone, but maybe resurrect some parts of it as a wrapper around icccm/netwm as convencience functions? SVN revision: 15227
2005-06-09 21:18:24 -07:00
static void
change of internal names for parralel implementation of ecore_xcb SVN revision: 15248
2005-06-10 23:05:51 -07:00
_ecore_evas_x_size_pos_hints_update(Ecore_Evas *ee)
Make ecore evas use netwm and icccm, not window_prop. Window_prop is gone, but maybe resurrect some parts of it as a wrapper around icccm/netwm as convencience functions? SVN revision: 15227
2005-06-09 21:18:24 -07:00
{
Let me introduce you to Ecore_Input. The idea is to share as much as possible event between all ecore graphic engine to ease porting of application and reduce the amount of specific code per engine. This patch does just that. All your application should continu to work has previously, if it's not the case please report any new behaviour regarding mouse and keyboard. SVN revision: 39505
2009-03-16 09:24:43 -07:00
ecore_x_icccm_size_pos_hints_set(ee->prop.window,
tab------------ SVN revision: 52896
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 */,
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
ee->prop.aspect /* min_aspect */,
ee->prop.aspect /* max_aspect */);
Make ecore evas use netwm and icccm, not window_prop. Window_prop is gone, but maybe resurrect some parts of it as a wrapper around icccm/netwm as convencience functions? SVN revision: 15227
2005-06-09 21:18:24 -07:00
}
/* FIXME, should be in idler */
static void
change of internal names for parralel implementation of ecore_xcb SVN revision: 15248
2005-06-10 23:05:51 -07:00
_ecore_evas_x_state_update(Ecore_Evas *ee)
Make ecore evas use netwm and icccm, not window_prop. Window_prop is gone, but maybe resurrect some parts of it as a wrapper around icccm/netwm as convencience functions? SVN revision: 15227
2005-06-09 21:18:24 -07:00
{
Ecore_X_Window_State state[10];
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
int num = 0;
Make ecore evas use netwm and icccm, not window_prop. Window_prop is gone, but maybe resurrect some parts of it as a wrapper around icccm/netwm as convencience functions? SVN revision: 15227
2005-06-09 21:18:24 -07:00
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
if (ee->prop.modal)
Make ecore evas use netwm and icccm, not window_prop. Window_prop is gone, but maybe resurrect some parts of it as a wrapper around icccm/netwm as convencience functions? SVN revision: 15227
2005-06-09 21:18:24 -07:00
state[num++] = ECORE_X_WINDOW_STATE_MODAL;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
if (ee->prop.sticky)
Make ecore evas use netwm and icccm, not window_prop. Window_prop is gone, but maybe resurrect some parts of it as a wrapper around icccm/netwm as convencience functions? SVN revision: 15227
2005-06-09 21:18:24 -07:00
state[num++] = ECORE_X_WINDOW_STATE_STICKY;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
if (ee->prop.maximized)
Make ecore evas use netwm and icccm, not window_prop. Window_prop is gone, but maybe resurrect some parts of it as a wrapper around icccm/netwm as convencience functions? SVN revision: 15227
2005-06-09 21:18:24 -07:00
state[num++] = ECORE_X_WINDOW_STATE_MAXIMIZED_VERT;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
if (ee->prop.maximized)
Make ecore evas use netwm and icccm, not window_prop. Window_prop is gone, but maybe resurrect some parts of it as a wrapper around icccm/netwm as convencience functions? SVN revision: 15227
2005-06-09 21:18:24 -07:00
state[num++] = ECORE_X_WINDOW_STATE_MAXIMIZED_HORZ;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
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)
Make ecore evas use netwm and icccm, not window_prop. Window_prop is gone, but maybe resurrect some parts of it as a wrapper around icccm/netwm as convencience functions? SVN revision: 15227
2005-06-09 21:18:24 -07:00
state[num++] = ECORE_X_WINDOW_STATE_SKIP_TASKBAR;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
if (ee->prop.focus_skip)
Make ecore evas use netwm and icccm, not window_prop. Window_prop is gone, but maybe resurrect some parts of it as a wrapper around icccm/netwm as convencience functions? SVN revision: 15227
2005-06-09 21:18:24 -07:00
state[num++] = ECORE_X_WINDOW_STATE_SKIP_PAGER;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
// if (bd->client.netwm.state.hidden)
// state[num++] = ECORE_X_WINDOW_STATE_HIDDEN;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (edata->state.fullscreen)
Let the WM decide how fullscreening is done. SVN revision: 24582
2006-08-12 03:16:53 -07:00
state[num++] = ECORE_X_WINDOW_STATE_FULLSCREEN;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (edata->state.above)
Make ecore evas use netwm and icccm, not window_prop. Window_prop is gone, but maybe resurrect some parts of it as a wrapper around icccm/netwm as convencience functions? SVN revision: 15227
2005-06-09 21:18:24 -07:00
state[num++] = ECORE_X_WINDOW_STATE_ABOVE;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (edata->state.below)
Make ecore evas use netwm and icccm, not window_prop. Window_prop is gone, but maybe resurrect some parts of it as a wrapper around icccm/netwm as convencience functions? SVN revision: 15227
2005-06-09 21:18:24 -07:00
state[num++] = ECORE_X_WINDOW_STATE_BELOW;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
if (ee->prop.demand_attention)
state[num++] = ECORE_X_WINDOW_STATE_DEMANDS_ATTENTION;
Make ecore evas use netwm and icccm, not window_prop. Window_prop is gone, but maybe resurrect some parts of it as a wrapper around icccm/netwm as convencience functions? SVN revision: 15227
2005-06-09 21:18:24 -07:00
Let me introduce you to Ecore_Input. The idea is to share as much as possible event between all ecore graphic engine to ease porting of application and reduce the amount of specific code per engine. This patch does just that. All your application should continu to work has previously, if it's not the case please report any new behaviour regarding mouse and keyboard. SVN revision: 39505
2009-03-16 09:24:43 -07:00
ecore_x_netwm_window_state_set(ee->prop.window, state, num);
Make ecore evas use netwm and icccm, not window_prop. Window_prop is gone, but maybe resurrect some parts of it as a wrapper around icccm/netwm as convencience functions? SVN revision: 15227
2005-06-09 21:18:24 -07:00
}
* Difference between user wanting a module, and the possibility of building a module. * Only do tests related to a module, if the module is to be built * use AC_PATH_GENERIC * Formatting * Remove som weird AC_SUBST, why were they there? SVN revision: 16543
2005-09-05 01:40:50 -07:00
static void
change of internal names for parralel implementation of ecore_xcb SVN revision: 15248
2005-06-10 23:05:51 -07:00
_ecore_evas_x_layer_update(Ecore_Evas *ee)
Make ecore evas use netwm and icccm, not window_prop. Window_prop is gone, but maybe resurrect some parts of it as a wrapper around icccm/netwm as convencience functions? SVN revision: 15227
2005-06-09 21:18:24 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
Make ecore evas use netwm and icccm, not window_prop. Window_prop is gone, but maybe resurrect some parts of it as a wrapper around icccm/netwm as convencience functions? SVN revision: 15227
2005-06-09 21:18:24 -07:00
if (ee->should_be_visible)
{
tab------------ SVN revision: 52896
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)
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (edata->state.above)
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->state.above = 0;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
ecore_x_netwm_state_request_send(ee->prop.window,
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->win_root,
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
ECORE_X_WINDOW_STATE_ABOVE, -1, 0);
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (!edata->state.below)
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->state.below = 1;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
ecore_x_netwm_state_request_send(ee->prop.window,
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->win_root,
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
ECORE_X_WINDOW_STATE_BELOW, -1, 1);
}
}
else if (ee->prop.layer > 5)
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (edata->state.below)
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->state.below = 0;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
ecore_x_netwm_state_request_send(ee->prop.window,
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->win_root,
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
ECORE_X_WINDOW_STATE_BELOW, -1, 0);
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (!edata->state.above)
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->state.above = 1;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
ecore_x_netwm_state_request_send(ee->prop.window,
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->win_root,
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
ECORE_X_WINDOW_STATE_ABOVE, -1, 1);
}
}
else
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (edata->state.below)
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->state.below = 0;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
ecore_x_netwm_state_request_send(ee->prop.window,
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->win_root,
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
ECORE_X_WINDOW_STATE_BELOW, -1, 0);
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (edata->state.above)
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->state.above = 0;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
ecore_x_netwm_state_request_send(ee->prop.window,
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->win_root,
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
ECORE_X_WINDOW_STATE_ABOVE, -1, 0);
}
}
Make ecore evas use netwm and icccm, not window_prop. Window_prop is gone, but maybe resurrect some parts of it as a wrapper around icccm/netwm as convencience functions? SVN revision: 15227
2005-06-09 21:18:24 -07:00
}
else
{
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
/* Just set the state */
if (ee->prop.layer < 3)
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if ((edata->state.above) || (!edata->state.below))
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->state.above = 0;
edata->state.below = 1;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
_ecore_evas_x_state_update(ee);
}
}
else if (ee->prop.layer > 5)
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if ((!edata->state.above) || (edata->state.below))
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->state.above = 1;
edata->state.below = 0;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
_ecore_evas_x_state_update(ee);
}
}
else
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if ((edata->state.above) || (edata->state.below))
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->state.above = 0;
edata->state.below = 0;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
_ecore_evas_x_state_update(ee);
}
}
Make ecore evas use netwm and icccm, not window_prop. Window_prop is gone, but maybe resurrect some parts of it as a wrapper around icccm/netwm as convencience functions? SVN revision: 15227
2005-06-09 21:18:24 -07:00
}
/* FIXME: Set gnome layer */
}
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
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;
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
ecore_evas_event_handlers[0] =
ecore_event_handler_add(ECORE_X_EVENT_MOUSE_IN,
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
_ecore_evas_x_event_mouse_in, NULL);
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
ecore_evas_event_handlers[1] =
ecore_event_handler_add(ECORE_X_EVENT_MOUSE_OUT,
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
_ecore_evas_x_event_mouse_out, NULL);
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
ecore_evas_event_handlers[2] =
ecore_event_handler_add(ECORE_X_EVENT_WINDOW_FOCUS_IN,
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
_ecore_evas_x_event_window_focus_in, NULL);
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
ecore_evas_event_handlers[3] =
ecore_event_handler_add(ECORE_X_EVENT_WINDOW_FOCUS_OUT,
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
_ecore_evas_x_event_window_focus_out, NULL);
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
ecore_evas_event_handlers[4] =
ecore_event_handler_add(ECORE_X_EVENT_WINDOW_DAMAGE,
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
_ecore_evas_x_event_window_damage, NULL);
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
ecore_evas_event_handlers[5] =
ecore_event_handler_add(ECORE_X_EVENT_WINDOW_DESTROY,
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
_ecore_evas_x_event_window_destroy, NULL);
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
ecore_evas_event_handlers[6] =
ecore_event_handler_add(ECORE_X_EVENT_WINDOW_CONFIGURE,
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
_ecore_evas_x_event_window_configure, NULL);
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
ecore_evas_event_handlers[7] =
ecore_event_handler_add(ECORE_X_EVENT_WINDOW_DELETE_REQUEST,
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
_ecore_evas_x_event_window_delete_request, NULL);
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
ecore_evas_event_handlers[8] =
ecore_event_handler_add(ECORE_X_EVENT_WINDOW_SHOW,
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
_ecore_evas_x_event_window_show, NULL);
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
ecore_evas_event_handlers[9] =
ecore_event_handler_add(ECORE_X_EVENT_WINDOW_HIDE,
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
_ecore_evas_x_event_window_hide, NULL);
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
ecore_evas_event_handlers[10] =
ecore_event_handler_add(ECORE_X_EVENT_WINDOW_PROPERTY,
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
_ecore_evas_x_event_property_change, NULL);
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
ecore_evas_event_handlers[11] =
ecore_event_handler_add(ECORE_X_EVENT_WINDOW_VISIBILITY_CHANGE,
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
_ecore_evas_x_event_visibility_change, NULL);
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
ecore_evas_event_handlers[12] =
ecore_event_handler_add(ECORE_X_EVENT_CLIENT_MESSAGE,
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
_ecore_evas_x_event_client_message, NULL);
* Ecore_Input: Make it generic. SVN revision: 39577
2009-03-19 06:06:16 -07:00
ecore_event_evas_init();
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
return _ecore_evas_init_count;
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
int
_ecore_evas_x_shutdown(void)
{
_ecore_evas_init_count--;
if (_ecore_evas_init_count == 0)
{
unsigned int i;
for (i = 0; i < sizeof(ecore_evas_event_handlers) / sizeof(Ecore_Event_Handler*); i++)
{
if (ecore_evas_event_handlers[i])
ecore_event_handler_del(ecore_evas_event_handlers[i]);
}
ecore_event_evas_shutdown();
}
if (_ecore_evas_init_count < 0) _ecore_evas_init_count = 0;
return _ecore_evas_init_count;
}
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
static void
_ecore_evas_x_free(Ecore_Evas *ee)
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
Add code for ecore_evas_<engine>_pixmap_new/get functions. - Add "pixmap" structure to engine_data. - Free the front and back pixmaps when the ecore_evas gets freed. - On resize, drop the backing pixmap if size is different. - Before we render, check pixmap size vs EE size and create new backing pixmap if needed. - After we have rendered into the backing pixmap, flip it to the front so that any calls to "pixmap_get" will return the proper one. - Add pixmap_new_internal code (the actual guts for all this) NB: These can be used to create an internally double-buffered ecore_evas that renders to a pixmap (not a window). Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-05 02:38:43 -07:00
if (edata->pixmap.back)
ecore_x_pixmap_free(edata->pixmap.back);
if (edata->pixmap.front)
ecore_x_pixmap_free(edata->pixmap.front);
ecore_evas: added window manager rotation to manage the rotation of windows by the WM. Summary: The window manager rotation allows the WM to controls the rotation of application windows. It is designed to support synchronized rotation for the multiple application windows at same time. Reviewers: raster, seoz, cedric, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D529
2014-02-08 16:46:51 -08:00
if (edata->wm_rot.manual_mode_job)
{
ecore_job_del(edata->wm_rot.manual_mode_job);
edata->wm_rot.manual_mode_job = NULL;
}
Add code for ecore_evas_<engine>_pixmap_new/get functions. - Add "pixmap" structure to engine_data. - Free the front and back pixmaps when the ecore_evas gets freed. - On resize, drop the backing pixmap if size is different. - Before we render, check pixmap size vs EE size and create new backing pixmap if needed. - After we have rendered into the backing pixmap, flip it to the front so that any calls to "pixmap_get" will return the proper one. - Add pixmap_new_internal code (the actual guts for all this) NB: These can be used to create an internally double-buffered ecore_evas that renders to a pixmap (not a window). Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-05 02:38:43 -07:00
set client leader by default - support setting it explicitly from code too. fix default win props too. SVN revision: 52974
2010-10-01 18:56:23 -07:00
_ecore_evas_x_group_leader_unset(ee);
ecore-evas-x no longer tries making x calls on deleted windows when trying to free its sync counter
2013-08-01 04:17:58 -07:00
if (edata->sync_counter)
ecore_x_sync_counter_free(edata->sync_counter);
ecore_evas_x: Free XCounter values leak. Summary: Whenever creating a window via elm_win_add(), save netwm_sync_counter values to edata->netwm_sync_counter by ecore_x_sync_counter_new(). However, never free the values when a window has been destroyed. So this patch is for free the values in _ecore_evas_x_free(). @fix Reviewers: cedric, raster, Hermet, devilhorns Reviewed By: devilhorns Subscribers: cedric, seoz Differential Revision: https://phab.enlightenment.org/D1855
2015-01-08 05:35:49 -08:00
if (edata->netwm_sync_counter)
ecore_x_sync_counter_free(edata->netwm_sync_counter);
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (edata->win_shaped_input)
ecore_x_window_free(edata->win_shaped_input);
ecore-evas-x no longer uses X windows after receiving a destroy event
2013-07-24 05:58:57 -07:00
ecore_event_window_unregister(ee->prop.window);
if (ee->prop.window && (!edata->destroyed)) ecore_x_window_free(ee->prop.window);
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (edata->pmap) ecore_x_pixmap_free(edata->pmap);
if (edata->mask) ecore_x_pixmap_free(edata->mask);
if (edata->gc) ecore_x_gc_free(edata->gc);
if (edata->damages) ecore_x_xregion_free(edata->damages);
edata->pmap = 0;
edata->mask = 0;
edata->gc = 0;
edata->damages = NULL;
while (edata->win_extra)
just DONT ask! DONT! x. focvus. client, self, not getting key events... fuck! workarounds. SVN revision: 16904
2005-09-24 02:00:23 -07:00
{
tab------------ SVN revision: 52896
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
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
winp = edata->win_extra->data;
edata->win_extra =
eina_list_remove_list(edata->win_extra, edata->win_extra);
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
ecore_event_window_unregister(*winp);
free(winp);
just DONT ask! DONT! x. focvus. client, self, not getting key events... fuck! workarounds. SVN revision: 16904
2005-09-24 02:00:23 -07:00
}
ecore-evas - handle mouse out then in due to click-to-focus passive grabs
2013-10-18 03:23:38 -07:00
if (edata->outdelay)
{
ecore_timer_del(edata->outdelay);
edata->outdelay = NULL;
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
free(edata);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
_ecore_evas_x_shutdown();
ecore_x_shutdown();
}
static void
From: Jérémy Zurcher <jeremy@asynk.ch> Subject: [E-devel] ecore_evas typedef patch src/lib the attached patch adds typedef void (*Ecore_Evas_Event_Cb) (Ecore_Evas *ee); in Ecore_Evas.h and ecore_evas_private.h Ecore_Evas_Event_Cb is then used within : ecore_evas.c ecore_evas_psl1ght.c ecore_evas_win32.c ecore_evas_wince.c ecore_evas_x.c SVN revision: 68140
2012-02-19 20:38:54 -08:00
_ecore_evas_x_callback_delete_request_set(Ecore_Evas *ee, Ecore_Evas_Event_Cb func)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
ee->func.fn_delete_request = func;
say we do pings - and respond within the event handler. SVN revision: 45699
2010-01-29 02:28:54 -08:00
_ecore_evas_x_protocols_set(ee);
add some sync stuff.. wil be used soon SVN revision: 45733
2010-01-30 02:42:22 -08:00
_ecore_evas_x_sync_set(ee);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
static void
change of internal names for parralel implementation of ecore_xcb SVN revision: 15248
2005-06-10 23:05:51 -07:00
_ecore_evas_x_move(Ecore_Evas *ee, int x, int y)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
hmm fix resize before change alpha... SVN revision: 46579
2010-02-27 06:40:10 -08:00
ee->req.x = x;
ee->req.y = y;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (edata->direct_resize)
If the ecore_evas is hidden, we need to request pos for a move to be effective. SVN revision: 15300
2005-06-13 04:57:14 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (!edata->managed)
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
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 */
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
ee->prop.request_pos = EINA_TRUE;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
_ecore_evas_x_size_pos_hints_update(ee);
}
if (ee->func.fn_move) ee->func.fn_move(ee);
}
}
If the ecore_evas is hidden, we need to request pos for a move to be effective. SVN revision: 15300
2005-06-13 04:57:14 -07:00
}
allow managed co-ords to be set directly - for internal wm use :) SVN revision: 18242
2005-11-03 03:32:59 -08:00
else
{
thanks to jiyoun's work in finding why this happens - here's actually a simpler fix. :) SVN revision: 64405
2011-10-25 22:29:38 -07:00
if (((ee->x != x) || (ee->y != y)) ||
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
(edata->configure_coming))
Ecore_Evas: No need to call ecore_x_window_move/resize is the canvas is already at the required size or position. SVN revision: 63522
2011-09-21 13:55:12 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->configure_coming = 1;
if (!edata->managed)
Ecore_Evas: No need to call ecore_x_window_move/resize is the canvas is already at the required size or position. SVN revision: 63522
2011-09-21 13:55:12 -07:00
{
ee->x = x;
ee->y = y;
}
ecore_x_window_move(ee->prop.window, x, y);
}
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
if (!ee->should_be_visible)
{
/* We need to request pos */
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
ee->prop.request_pos = EINA_TRUE;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
_ecore_evas_x_size_pos_hints_update(ee);
}
allow managed co-ords to be set directly - for internal wm use :) SVN revision: 18242
2005-11-03 03:32:59 -08:00
}
}
static void
_ecore_evas_x_managed_move(Ecore_Evas *ee, int x, int y)
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
hmm fix resize before change alpha... SVN revision: 46579
2010-02-27 06:40:10 -08:00
ee->req.x = x;
ee->req.y = y;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (edata->direct_resize)
if direct resize is set - call callbacks... directly :) SVN revision: 18239
2005-11-02 22:16:40 -08:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->managed = 1;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
if ((x != ee->x) || (y != ee->y))
{
ee->x = x;
ee->y = y;
if (ee->func.fn_move) ee->func.fn_move(ee);
}
if direct resize is set - call callbacks... directly :) SVN revision: 18239
2005-11-02 22:16:40 -08:00
}
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
static void
change of internal names for parralel implementation of ecore_xcb SVN revision: 15248
2005-06-10 23:05:51 -07:00
_ecore_evas_x_resize(Ecore_Evas *ee, int w, int h)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
hmm fix resize before change alpha... SVN revision: 46579
2010-02-27 06:40:10 -08:00
ee->req.w = w;
ee->req.h = h;
Add code for ecore_evas_<engine>_pixmap_new/get functions. - Add "pixmap" structure to engine_data. - Free the front and back pixmaps when the ecore_evas gets freed. - On resize, drop the backing pixmap if size is different. - Before we render, check pixmap size vs EE size and create new backing pixmap if needed. - After we have rendered into the backing pixmap, flip it to the front so that any calls to "pixmap_get" will return the proper one. - Add pixmap_new_internal code (the actual guts for all this) NB: These can be used to create an internally double-buffered ecore_evas that renders to a pixmap (not a window). Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-05 02:38:43 -07:00
/* check for valid property window
*
* NB: If we do not have one, check for valid pixmap rendering */
if (!ee->prop.window)
{
/* the ecore_evas was resized. we need to free the back pixmap */
if ((edata->pixmap.w != w) || (edata->pixmap.h != h))
{
/* free the backing pixmap */
if (edata->pixmap.back)
ecore_x_pixmap_free(edata->pixmap.back);
}
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (edata->direct_resize)
extra ecore_x and ecore_evas features for e17.. :) SVN revision: 12241
2004-11-23 07:17:56 -08:00
{
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
if ((ee->w != w) || (ee->h != h))
{
ee->w = w;
ee->h = h;
Add code for ecore_evas_<engine>_pixmap_new/get functions. - Add "pixmap" structure to engine_data. - Free the front and back pixmaps when the ecore_evas gets freed. - On resize, drop the backing pixmap if size is different. - Before we render, check pixmap size vs EE size and create new backing pixmap if needed. - After we have rendered into the backing pixmap, flip it to the front so that any calls to "pixmap_get" will return the proper one. - Add pixmap_new_internal code (the actual guts for all this) NB: These can be used to create an internally double-buffered ecore_evas that renders to a pixmap (not a window). Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-05 02:38:43 -07:00
if (ee->prop.window) ecore_x_window_resize(ee->prop.window, w, h);
ecore_evas - applied macro to check rotation state. also, let the potrait compare on the higher priority. if you can suggest better macro name, then please modify it.
2014-01-18 05:26:10 -08:00
if (ECORE_EVAS_PORTRAIT(ee))
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
ecore_evas - applied macro to check rotation state. also, let the potrait compare on the higher priority. if you can suggest better macro name, then please modify it.
2014-01-18 05:26:10 -08:00
evas_output_size_set(ee->evas, ee->w, ee->h);
evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
}
else
{
ecore_evas - applied macro to check rotation state. also, let the potrait compare on the higher priority. if you can suggest better macro name, then please modify it.
2014-01-18 05:26:10 -08:00
evas_output_size_set(ee->evas, ee->h, ee->w);
evas_output_viewport_set(ee->evas, 0, 0, ee->h, ee->w);
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
}
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);
}
extra ecore_x and ecore_evas features for e17.. :) SVN revision: 12241
2004-11-23 07:17:56 -08:00
}
thanks to jiyoun's work in finding why this happens - here's actually a simpler fix. :) SVN revision: 64405
2011-10-25 22:29:38 -07:00
else if (((ee->w != w) || (ee->h != h)) ||
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
(edata->configure_coming))
thanks to jiyoun's work in finding why this happens - here's actually a simpler fix. :) SVN revision: 64405
2011-10-25 22:29:38 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->configure_coming = 1;
Add code for ecore_evas_<engine>_pixmap_new/get functions. - Add "pixmap" structure to engine_data. - Free the front and back pixmaps when the ecore_evas gets freed. - On resize, drop the backing pixmap if size is different. - Before we render, check pixmap size vs EE size and create new backing pixmap if needed. - After we have rendered into the backing pixmap, flip it to the front so that any calls to "pixmap_get" will return the proper one. - Add pixmap_new_internal code (the actual guts for all this) NB: These can be used to create an internally double-buffered ecore_evas that renders to a pixmap (not a window). Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-05 02:38:43 -07:00
if (ee->prop.window) ecore_x_window_resize(ee->prop.window, w, h);
thanks to jiyoun's work in finding why this happens - here's actually a simpler fix. :) SVN revision: 64405
2011-10-25 22:29:38 -07:00
}
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
static void
change of internal names for parralel implementation of ecore_xcb SVN revision: 15248
2005-06-10 23:05:51 -07:00
_ecore_evas_x_move_resize(Ecore_Evas *ee, int x, int y, int w, int h)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
hmm fix resize before change alpha... SVN revision: 46579
2010-02-27 06:40:10 -08:00
ee->req.x = x;
ee->req.y = y;
ee->req.w = w;
ee->req.h = h;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (edata->direct_resize)
extra ecore_x and ecore_evas features for e17.. :) SVN revision: 12241
2004-11-23 07:17:56 -08:00
{
tab------------ SVN revision: 52896
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;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (!edata->managed)
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
if ((x != ee->x) || (y != ee->y)) change_pos = 1;
}
ecore_x_window_move_resize(ee->prop.window, x, y, w, h);
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (!edata->managed)
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
ee->x = x;
ee->y = y;
}
ee->w = w;
ee->h = h;
ecore_evas - applied macro to check rotation state. also, let the potrait compare on the higher priority. if you can suggest better macro name, then please modify it.
2014-01-18 05:26:10 -08:00
if (ECORE_EVAS_PORTRAIT(ee))
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
ecore_evas - applied macro to check rotation state. also, let the potrait compare on the higher priority. if you can suggest better macro name, then please modify it.
2014-01-18 05:26:10 -08:00
evas_output_size_set(ee->evas, ee->w, ee->h);
evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
}
else
{
ecore_evas - applied macro to check rotation state. also, let the potrait compare on the higher priority. if you can suggest better macro name, then please modify it.
2014-01-18 05:26:10 -08:00
evas_output_size_set(ee->evas, ee->h, ee->w);
evas_output_viewport_set(ee->evas, 0, 0, ee->h, ee->w);
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
}
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);
}
}
extra ecore_x and ecore_evas features for e17.. :) SVN revision: 12241
2004-11-23 07:17:56 -08:00
}
thanks to jiyoun's work in finding why this happens - here's actually a simpler fix. :) SVN revision: 64405
2011-10-25 22:29:38 -07:00
else if (((ee->w != w) || (ee->h != h) || (ee->x != x) || (ee->y != y)) ||
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
(edata->configure_coming))
update x, y if not managed (override) SVN revision: 24078
2006-07-20 10:12:30 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->configure_coming = 1;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
ecore_x_window_move_resize(ee->prop.window, x, y, w, h);
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (!edata->managed)
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
ee->x = x;
ee->y = y;
}
update x, y if not managed (override) SVN revision: 24078
2006-07-20 10:12:30 -07:00
}
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
static void
From: 이상진 <lsj119@samsung.com> Patch for rotate with resize (fixed formatting a bit) SVN revision: 46046
2010-02-10 06:35:07 -08:00
_ecore_evas_x_rotation_set_internal(Ecore_Evas *ee, int rotation, int resize,
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
Evas_Engine_Info *einfo)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
int rot_dif;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
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
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
rot_dif = ee->rotation - rotation;
if (rot_dif < 0) rot_dif = -rot_dif;
Software 16 X11 now does rotation. SVN revision: 31215
2007-08-07 12:09:53 -07:00
if (rot_dif != 180)
{
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
int minw, minh, maxw, maxh, basew, baseh, stepw, steph;
Software 16 X11 now does rotation. SVN revision: 31215
2007-08-07 12:09:53 -07:00
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
if (!evas_engine_info_set(ee->evas, einfo))
handle info_set failures. SVN revision: 48957
2010-05-17 20:50:17 -07:00
{
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
}
From: 이상진 <lsj119@samsung.com> Patch for rotate with resize (fixed formatting a bit) SVN revision: 46046
2010-02-10 06:35:07 -08:00
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
if (!resize)
From: 이상진 <lsj119@samsung.com> Patch for rotate with resize (fixed formatting a bit) SVN revision: 46046
2010-02-10 06:35:07 -08:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->configure_coming = 1;
From: 이상진 <lsj119@samsung.com> Patch for rotate with resize (fixed formatting a bit) SVN revision: 46046
2010-02-10 06:35:07 -08:00
if (!ee->prop.fullscreen)
{
hmm fix resize before change alpha... SVN revision: 46579
2010-02-27 06:40:10 -08:00
ecore_x_window_resize(ee->prop.window, ee->req.h, ee->req.w);
From: 이상진 <lsj119@samsung.com> Patch for rotate with resize (fixed formatting a bit) SVN revision: 46046
2010-02-10 06:35:07 -08:00
ee->expecting_resize.w = ee->h;
ee->expecting_resize.h = ee->w;
fix rotation issue with ecore-evas SVN revision: 76596
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);
From: 이상진 <lsj119@samsung.com> Patch for rotate with resize (fixed formatting a bit) SVN revision: 46046
2010-02-10 06:35:07 -08:00
}
else
{
int w, h;
Ecore: Removed trailing whitespaces. SVN revision: 58753
2011-04-20 07:15:33 -07:00
From: 이상진 <lsj119@samsung.com> Patch for rotate with resize (fixed formatting a bit) SVN revision: 46046
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);
ecore_evas: Ecore_Evas_X - Fix broken rendering during rotation with resize Summary: When ee is trying to do rotation, ee should check whether given rotation value is portrait or not. Then it sets output size of evas canvas according to rotation value. But, ECORE_EVAS_PORTRAIT macro used in ee x engine only checks ee's rotation value, even if ee's rotation value is not updated yet. Thus we should change the logic to compare with given rotation value, not ee's rotation, before setting output size of evas. This fixes T1371 problem. @fix Test Plan: 1. run elementary_test -to "window states" 2. check resize 3. rotation 0 ~ 270 Reviewers: jpeg, raster, cedric, zmike, devilhorns, Hermet Reviewed By: Hermet Subscribers: cedric Maniphest Tasks: T1371 Differential Revision: https://phab.enlightenment.org/D1351
2014-08-27 03:35:27 -07:00
if (PORTRAIT_CHECK(rotation))
From: 이상진 <lsj119@samsung.com> Patch for rotate with resize (fixed formatting a bit) SVN revision: 46046
2010-02-10 06:35:07 -08:00
{
hmm fix resize before change alpha... SVN revision: 46579
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);
From: 이상진 <lsj119@samsung.com> Patch for rotate with resize (fixed formatting a bit) SVN revision: 46046
2010-02-10 06:35:07 -08:00
}
else
{
hmm fix resize before change alpha... SVN revision: 46579
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);
From: 이상진 <lsj119@samsung.com> Patch for rotate with resize (fixed formatting a bit) SVN revision: 46046
2010-02-10 06:35:07 -08:00
}
if (ee->func.fn_resize) ee->func.fn_resize(ee);
}
ecore_evas: Ecore_Evas_X - Fix broken rendering during rotation with resize Summary: When ee is trying to do rotation, ee should check whether given rotation value is portrait or not. Then it sets output size of evas canvas according to rotation value. But, ECORE_EVAS_PORTRAIT macro used in ee x engine only checks ee's rotation value, even if ee's rotation value is not updated yet. Thus we should change the logic to compare with given rotation value, not ee's rotation, before setting output size of evas. This fixes T1371 problem. @fix Test Plan: 1. run elementary_test -to "window states" 2. check resize 3. rotation 0 ~ 270 Reviewers: jpeg, raster, cedric, zmike, devilhorns, Hermet Reviewed By: Hermet Subscribers: cedric Maniphest Tasks: T1371 Differential Revision: https://phab.enlightenment.org/D1351
2014-08-27 03:35:27 -07:00
if (PORTRAIT_CHECK(rotation))
hmm fix resize before change alpha... SVN revision: 46579
2010-02-27 06:40:10 -08:00
evas_damage_rectangle_add(ee->evas, 0, 0, ee->req.w, ee->req.h);
ecore_evas - applied macro to check rotation state. also, let the potrait compare on the higher priority. if you can suggest better macro name, then please modify it.
2014-01-18 05:26:10 -08:00
else
evas_damage_rectangle_add(ee->evas, 0, 0, ee->req.h, ee->req.w);
From: 이상진 <lsj119@samsung.com> Patch for rotate with resize (fixed formatting a bit) SVN revision: 46046
2010-02-10 06:35:07 -08:00
}
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
else
From: 이상진 <lsj119@samsung.com> Patch for rotate with resize (fixed formatting a bit) SVN revision: 46046
2010-02-10 06:35:07 -08:00
{
Ecore_Evas: When doing rotation_set_internal, no need to fetch the ecore_x_window_size here as the returned values are not used anyway, so avoid the extra function call. SVN revision: 63523
2011-09-21 14:01:15 -07:00
/* int w, h; */
Ecore: Removed trailing whitespaces. SVN revision: 58753
2011-04-20 07:15:33 -07:00
Ecore_Evas: When doing rotation_set_internal, no need to fetch the ecore_x_window_size here as the returned values are not used anyway, so avoid the extra function call. SVN revision: 63523
2011-09-21 14:01:15 -07:00
/* ecore_x_window_size_get(ee->prop.window, &w, &h); */
ecore_evas: Ecore_Evas_X - Fix broken rendering during rotation with resize Summary: When ee is trying to do rotation, ee should check whether given rotation value is portrait or not. Then it sets output size of evas canvas according to rotation value. But, ECORE_EVAS_PORTRAIT macro used in ee x engine only checks ee's rotation value, even if ee's rotation value is not updated yet. Thus we should change the logic to compare with given rotation value, not ee's rotation, before setting output size of evas. This fixes T1371 problem. @fix Test Plan: 1. run elementary_test -to "window states" 2. check resize 3. rotation 0 ~ 270 Reviewers: jpeg, raster, cedric, zmike, devilhorns, Hermet Reviewed By: Hermet Subscribers: cedric Maniphest Tasks: T1371 Differential Revision: https://phab.enlightenment.org/D1351
2014-08-27 03:35:27 -07:00
if (PORTRAIT_CHECK(rotation))
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
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);
ecore_evas: Ecore_Evas_X - Fix broken rendering during rotation with resize Summary: When ee is trying to do rotation, ee should check whether given rotation value is portrait or not. Then it sets output size of evas canvas according to rotation value. But, ECORE_EVAS_PORTRAIT macro used in ee x engine only checks ee's rotation value, even if ee's rotation value is not updated yet. Thus we should change the logic to compare with given rotation value, not ee's rotation, before setting output size of evas. This fixes T1371 problem. @fix Test Plan: 1. run elementary_test -to "window states" 2. check resize 3. rotation 0 ~ 270 Reviewers: jpeg, raster, cedric, zmike, devilhorns, Hermet Reviewed By: Hermet Subscribers: cedric Maniphest Tasks: T1371 Differential Revision: https://phab.enlightenment.org/D1351
2014-08-27 03:35:27 -07:00
if (PORTRAIT_CHECK(rotation))
hmm fix resize before change alpha... SVN revision: 46579
2010-02-27 06:40:10 -08:00
evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
ecore_evas - applied macro to check rotation state. also, let the potrait compare on the higher priority. if you can suggest better macro name, then please modify it.
2014-01-18 05:26:10 -08:00
else
evas_damage_rectangle_add(ee->evas, 0, 0, ee->h, ee->w);
From: 이상진 <lsj119@samsung.com> Patch for rotate with resize (fixed formatting a bit) SVN revision: 46046
2010-02-10 06:35:07 -08:00
}
tab------------ SVN revision: 52896
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());
Software 16 X11 now does rotation. SVN revision: 31215
2007-08-07 12:09:53 -07:00
}
else
{
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
if (!evas_engine_info_set(ee->evas, einfo))
handle info_set failures. SVN revision: 48957
2010-05-17 20:50:17 -07:00
{
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
}
tab------------ SVN revision: 52896
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);
Ecore: Removed trailing whitespaces. SVN revision: 58753
2011-04-20 07:15:33 -07:00
ecore_evas - applied macro to check rotation state. also, let the potrait compare on the higher priority. if you can suggest better macro name, then please modify it.
2014-01-18 05:26:10 -08:00
if (ECORE_EVAS_PORTRAIT(ee))
hmm fix resize before change alpha... SVN revision: 46579
2010-02-27 06:40:10 -08:00
evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
ecore_evas - applied macro to check rotation state. also, let the potrait compare on the higher priority. if you can suggest better macro name, then please modify it.
2014-01-18 05:26:10 -08:00
else
evas_damage_rectangle_add(ee->evas, 0, 0, ee->h, ee->w);
Software 16 X11 now does rotation. SVN revision: 31215
2007-08-07 12:09:53 -07:00
}
}
ecore_evas: added window manager rotation to manage the rotation of windows by the WM. Summary: The window manager rotation allows the WM to controls the rotation of application windows. It is designed to support synchronized rotation for the multiple application windows at same time. Reviewers: raster, seoz, cedric, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D529
2014-02-08 16:46:51 -08:00
static Eina_Bool
_ecore_evas_x_wm_rotation_check(Ecore_Evas *ee)
Ecore_Evas Merge Tizen changes to upstream EFL. SVN revision: 73206
2012-07-03 00:44:17 -07:00
{
ecore_evas: added window manager rotation to manage the rotation of windows by the WM. Summary: The window manager rotation allows the WM to controls the rotation of application windows. It is designed to support synchronized rotation for the multiple application windows at same time. Reviewers: raster, seoz, cedric, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D529
2014-02-08 16:46:51 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
if (ee->prop.wm_rot.supported)
{
if (ee->prop.wm_rot.app_set)
{
if (edata->wm_rot.request)
{
if (ee->prop.wm_rot.win_resize)
{
if (!((ee->w == ee->prop.wm_rot.w) &&
(ee->h == ee->prop.wm_rot.h)))
{
return EINA_FALSE;
}
else
edata->wm_rot.configure_coming = 0;
}
}
}
}
return EINA_TRUE;
Ecore_Evas Merge Tizen changes to upstream EFL. SVN revision: 73206
2012-07-03 00:44:17 -07:00
}
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
static void
_rotation_do(Ecore_Evas *ee, int rotation, int resize)
{
#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
ecore_evas: added window manager rotation to manage the rotation of windows by the WM. Summary: The window manager rotation allows the WM to controls the rotation of application windows. It is designed to support synchronized rotation for the multiple application windows at same time. Reviewers: raster, seoz, cedric, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D529
2014-02-08 16:46:51 -08:00
if (ee->prop.wm_rot.supported)
{
if (!_ecore_evas_x_wm_rotation_check(ee)) return;
if (!resize) resize = 1;
}
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
Evas_Engine_Info_Software_X11 *einfo;
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
einfo = (Evas_Engine_Info_Software_X11 *)evas_engine_info_get(ee->evas);
if (!einfo) return;
einfo->info.rotation = rotation;
_ecore_evas_x_rotation_set_internal(ee, rotation, resize,
(Evas_Engine_Info *)einfo);
ecore_evas: added window manager rotation to manage the rotation of windows by the WM. Summary: The window manager rotation allows the WM to controls the rotation of application windows. It is designed to support synchronized rotation for the multiple application windows at same time. Reviewers: raster, seoz, cedric, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D529
2014-02-08 16:46:51 -08:00
if (ee->prop.wm_rot.supported)
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
{
ecore_evas: added window manager rotation to manage the rotation of windows by the WM. Summary: The window manager rotation allows the WM to controls the rotation of application windows. It is designed to support synchronized rotation for the multiple application windows at same time. Reviewers: raster, seoz, cedric, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D529
2014-02-08 16:46:51 -08:00
if (ee->prop.wm_rot.app_set)
{
if (edata->wm_rot.request)
{
if (ee->func.fn_state_change) ee->func.fn_state_change(ee);
edata->wm_rot.request = 0;
edata->wm_rot.done = 1;
}
}
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
}
ecore_evas: added window manager rotation to manage the rotation of windows by the WM. Summary: The window manager rotation allows the WM to controls the rotation of application windows. It is designed to support synchronized rotation for the multiple application windows at same time. Reviewers: raster, seoz, cedric, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D529
2014-02-08 16:46:51 -08:00
int angles[2] = { rotation, rotation };
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
ecore_x_window_prop_property_set(ee->prop.window,
ECORE_X_ATOM_E_ILLUME_ROTATE_WINDOW_ANGLE,
ecore_evas: added window manager rotation to manage the rotation of windows by the WM. Summary: The window manager rotation allows the WM to controls the rotation of application windows. It is designed to support synchronized rotation for the multiple application windows at same time. Reviewers: raster, seoz, cedric, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D529
2014-02-08 16:46:51 -08:00
ECORE_X_ATOM_CARDINAL, 32, &angles, 2);
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
#endif /* BUILD_ECORE_EVAS_SOFTWARE_X11 */
}
Software 16 X11 now does rotation. SVN revision: 31215
2007-08-07 12:09:53 -07:00
static void
From: 이상진 <lsj119@samsung.com> Patch for rotate with resize (fixed formatting a bit) SVN revision: 46046
2010-02-10 06:35:07 -08:00
_ecore_evas_x_rotation_set(Ecore_Evas *ee, int rotation, int resize)
Software 16 X11 now does rotation. SVN revision: 31215
2007-08-07 12:09:53 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
ecore_evas: added window manager rotation to manage the rotation of windows by the WM. Summary: The window manager rotation allows the WM to controls the rotation of application windows. It is designed to support synchronized rotation for the multiple application windows at same time. Reviewers: raster, seoz, cedric, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D529
2014-02-08 16:46:51 -08:00
if (ee->rotation == rotation)
{
if (ee->prop.wm_rot.supported)
{
if (edata->wm_rot.request)
{
if (ee->prop.wm_rot.manual_mode.set)
{
ee->prop.wm_rot.manual_mode.wait_for_done = EINA_FALSE;
if (ee->prop.wm_rot.manual_mode.timer)
ecore_timer_del(ee->prop.wm_rot.manual_mode.timer);
ee->prop.wm_rot.manual_mode.timer = NULL;
}
/* send rotation done message to wm, even if window is already rotated.
* that's why wm must be wait for comming rotation done message
* after sending rotation request.
*/
ecore_x_e_window_rotation_change_done_send
(edata->win_root, ee->prop.window, ee->rotation, ee->w, ee->h);
edata->wm_rot.request = 0;
}
}
return;
}
Ecore_Evas Merge Tizen changes to upstream EFL. SVN revision: 73206
2012-07-03 00:44:17 -07:00
ecore_evas: added window manager rotation to manage the rotation of windows by the WM. Summary: The window manager rotation allows the WM to controls the rotation of application windows. It is designed to support synchronized rotation for the multiple application windows at same time. Reviewers: raster, seoz, cedric, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D529
2014-02-08 16:46:51 -08:00
if (ee->prop.wm_rot.supported)
{
if (!_ecore_evas_x_wm_rotation_check(ee)) return;
if (!resize) resize = 1;
}
add patrch for rotation atoms also fix previous indicator patch to have atoms set up right. SVN revision: 68960
2012-03-07 06:34:24 -08:00
support new gl enigne rotate ability from ecore-evas SVN revision: 48705
2010-05-08 22:15:55 -07:00
if (!strcmp(ee->driver, "opengl_x11"))
{
try right #ifdef SVN revision: 48707
2010-05-08 22:51:10 -07:00
#ifdef BUILD_ECORE_EVAS_OPENGL_X11
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
Evas_Engine_Info_GL_X11 *einfo;
support new gl enigne rotate ability from ecore-evas SVN revision: 48705
2010-05-08 22:15:55 -07:00
tab------------ SVN revision: 52896
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;
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
_ecore_evas_x_rotation_set_internal(ee, rotation, resize,
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
(Evas_Engine_Info *)einfo);
ecore_evas: added window manager rotation to manage the rotation of windows by the WM. Summary: The window manager rotation allows the WM to controls the rotation of application windows. It is designed to support synchronized rotation for the multiple application windows at same time. Reviewers: raster, seoz, cedric, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D529
2014-02-08 16:46:51 -08:00
if (ee->prop.wm_rot.supported)
{
if (ee->prop.wm_rot.app_set)
{
if (edata->wm_rot.request)
{
if (ee->func.fn_state_change) ee->func.fn_state_change(ee);
edata->wm_rot.request = 0;
edata->wm_rot.done = 1;
}
}
}
int angles[2] = { rotation, rotation };
add patrch for rotation atoms also fix previous indicator patch to have atoms set up right. SVN revision: 68960
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);
* fix comment * do consistent test (though it is useless) SVN revision: 48708
2010-05-08 23:03:46 -07:00
#endif /* BUILD_ECORE_EVAS_OPENGL_X11 */
support new gl enigne rotate ability from ecore-evas SVN revision: 48705
2010-05-08 22:15:55 -07:00
}
* fix comment * do consistent test (though it is useless) SVN revision: 48708
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
{
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
if (ee->in_async_render)
{
ee->delayed.rotation = rotation;
ee->delayed.rotation_resize = resize;
ee->delayed.rotation_changed = EINA_TRUE;
return;
}
_rotation_do(ee, rotation, resize);
return;
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
}
static void
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
_shaped_do(Ecore_Evas *ee, int shaped)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
Evas_Engine_Info_Software_X11 *einfo;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
some clang warning cleanups i forgot to commit SVN revision: 83024
2013-01-20 16:22:35 -08:00
if (ee->shaped == shaped) return;
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
einfo = (Evas_Engine_Info_Software_X11 *)evas_engine_info_get(ee->evas);
ee->shaped = shaped;
if (einfo)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
if (ee->shaped)
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
unsigned int foreground;
Ecore_X_GC gc;
if (!edata->mask)
edata->mask = ecore_x_pixmap_new(ee->prop.window, ee->w, ee->h, 1);
foreground = 0;
gc = ecore_x_gc_new(edata->mask,
ECORE_X_GC_VALUE_MASK_FOREGROUND,
&foreground);
ecore_x_drawable_rectangle_fill(edata->mask, gc,
0, 0, ee->w, ee->h);
ecore_x_gc_free(gc);
einfo->info.mask = edata->mask;
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
}
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08: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 (edata->mask) ecore_x_pixmap_free(edata->mask);
edata->mask = 0;
einfo->info.mask = 0;
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
}
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
ecore_x_window_shape_mask_set(ee->prop.window, 0);
ecore_x_window_shape_input_mask_set(ee->prop.window, 0);
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
}
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
}
rename 'x11' to 'xlib' for software x11 based engines when it makes sense SVN revision: 41330
2009-07-14 14:18:27 -07:00
#endif /* BUILD_ECORE_EVAS_SOFTWARE_X11 */
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
}
static void
_ecore_evas_x_shaped_set(Ecore_Evas *ee, int shaped)
{
if (!strcmp(ee->driver, "opengl_x11")) return;
if (!strcmp(ee->driver, "software_x11"))
{
if (ee->in_async_render)
{
ee->delayed.shaped = shaped;
ee->delayed.shaped_changed = EINA_TRUE;
return;
}
_shaped_do(ee, shaped);
properly support shaped windows with xrender engine... :) SVN revision: 17125
2005-10-02 23:45:45 -07:00
}
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
evilness... but it works. SVN revision: 21091
2006-03-08 00:02:55 -08:00
static void
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
_alpha_do(Ecore_Evas *ee, int alpha)
evilness... but it works. SVN revision: 21091
2006-03-08 00:02:55 -08:00
{
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
char *id = NULL;
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
Ecore_X_Window_Attributes att;
Evas_Engine_Info_Software_X11 *einfo;
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
refactored _alpha_set a bit SVN revision: 29967
2007-05-12 07:13:19 -07:00
some clang warning cleanups i forgot to commit SVN revision: 83024
2013-01-20 16:22:35 -08:00
if (ee->alpha == alpha) return;
refactored _alpha_set a bit SVN revision: 29967
2007-05-12 07:13:19 -07:00
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
einfo = (Evas_Engine_Info_Software_X11 *)evas_engine_info_get(ee->evas);
if (!einfo) return;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
if (!ecore_x_composite_query()) return;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
ee->shaped = 0;
ee->alpha = alpha;
* Ecore_x: fix alpha set function not clear sync counter
2013-03-22 02:49:46 -07:00
_ecore_evas_x_sync_clear(ee);
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
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(edata->win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
else
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
ee->prop.window = ecore_x_window_argb_new(edata->win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
// if (!edata->mask)
// edata->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(edata->win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
else
ee->prop.window = ecore_x_window_new(edata->win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
if (edata->mask) ecore_x_pixmap_free(edata->mask);
edata->mask = 0;
ecore_x_window_shape_input_mask_set(ee->prop.window, 0);
ecore-evas - enable attempting to turn on dri2 vsync this enables the x11 dri2 vsync enabling code for x11 ecore-evas
2014-07-24 22:45:50 -07:00
ecore_x_vsync_animator_tick_source_set(ee->prop.window);
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
}
einfo->info.destination_alpha = alpha;
ecore_x_window_attributes_get(ee->prop.window, &att);
einfo->info.visual = att.visual;
einfo->info.colormap = att.colormap;
einfo->info.depth = att.depth;
// if (edata->mask) ecore_x_pixmap_free(edata->mask);
// edata->mask = 0;
einfo->info.mask = edata->mask;
einfo->info.drawable = ee->prop.window;
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
{
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
}
evas_damage_rectangle_add(ee->evas, 0, 0, ee->req.w, ee->req.h);
ecore_x_window_shape_mask_set(ee->prop.window, 0);
Expose device (e.g. pen) axis information to applications Summary: This patch set adds the necessary code to expose device axis state to applications. This was primarily written with graphics tablets in mind, which -- in addition to acting like a mouse -- also provide information about pen pressure, tilt, etc. Other devices could potentially benefit from this API as well: touchscreens, joysticks, knob controllers, "spaceballs", etc. Whenever an update to the device state is recieved, an "Axis update" event is synthesized. This event contains the updated information, typically scaled and normalized to a particular logical range (e.g. zero to one for pressure, -pi to pi radians for angles, etc.). Information about the tool which generated the event is also stored so that applications can disambiguate events from multiple devices (or in the case of multitouch screens, individual fingers). This API is only wired up for use with X11 at the moment. Support for other backends (e.g. Wayland) should be easy to add for those familiar them. **Note**: The following is a list of changes from the "v2" patches originally sent to the mailinglist //Define and implement new Ecore_Event_Axis_Update events// * Harcode axis labels instead of including xserver-properties.h * Use C89-style comments * Use doxygen comments * Update comment text to note axes with unbounded/undefined ranges/units * Create "Ecore_Axis" and "Ecore_Axis_Label" typedefs * Reference typedef'd instead of raw types * Adjust how we count through valuators to support tilt/az * Add support for tilt and azimuth * Tweak memory management in case number of valuators differ * Expand TWIST axis normalization to declared range * Only normalize TWIST axis if resolution == 1 (wacom bug) * Cache label atoms on first use to minimize round-trips //Implement EVAS_CALLBACK_AXIS_UPDATE event and friends// * Update to doxygen comments * Update comment text to note axes with unbounded/undefined ranges/units * Typedef 'Evas_Axis_Label', 'Evas_Axis' * Move typedef for 'Evas_Event_Axis_Update' * Reference typedef'd instead of raw types //Wire the Ecore and Evas implementations of axis update events together// * Expose ecore_event_evas_axis_update in Ecore_Input_Evas.h * Move ecore_event_evas_axis_update to more logical position //DEBUG: Add axis update logging to evas-multi-touch.c// * Removed from patch set //Make evas-multi-touch demo use new axis functionality// * Have pressure adjust rectangle brightness instead of size * Use more available axis data when rendering rectangle (azimuth, tilt, twist) Test Plan: The evas-multi-touch demo was updated to support axis update events. A graphics tablet was then used to verify that the pressure, azimuth, tilt, and twist data was coming through correctly. Reviewers: cedric, raster Subscribers: cedric Differential Revision: https://phab.enlightenment.org/D1514 Conflicts: src/lib/ecore_input/Ecore_Input.h Carsten Haitzler - ** fixed forward enum typedefs (make things unhappy) ** fixed conflict above ** fixed wrong param type for _evas_canvas_event_feed_axis_update() ** fixed @sinces to be 1.13 ** fixed formatting/indeting ** fixed order of operation reliance in if's with ()'s to be clear ** fixed functions to be static that should have been
2014-11-24 19:07:50 -08:00
ecore_x_input_select(ee->prop.window);
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -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);
if (ee->prop.borderless)
ecore_x_mwm_borderless_set(ee->prop.window, ee->prop.borderless);
ecore/ecore_x - show the window if the window should be visible. when the window alpha mode is changed, the x window is re-created. but if the window is going on the show state(not visible yet but waiting for visible from xserver) this window never be visible. so here it make the window visible also if the window is going on the visible state.
2013-12-17 03:37:17 -08:00
if (ee->visible || ee->should_be_visible)
ecore_x_window_show(ee->prop.window);
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
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);
}
if (ee->prop.name)
ecore_x_icccm_name_class_set(ee->prop.window,
ee->prop.name, ee->prop.clas);
_ecore_evas_x_hints_update(ee);
_ecore_evas_x_group_leader_update(ee);
ecore_x_window_defaults_set(ee->prop.window);
_ecore_evas_x_protocols_set(ee);
_ecore_evas_x_window_profile_protocol_set(ee);
ecore_evas: added window manager rotation to manage the rotation of windows by the WM. Summary: The window manager rotation allows the WM to controls the rotation of application windows. It is designed to support synchronized rotation for the multiple application windows at same time. Reviewers: raster, seoz, cedric, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D529
2014-02-08 16:46:51 -08:00
_ecore_evas_x_wm_rotation_protocol_set(ee);
ecore_evas: Added support for window auxiliary hint Summary: The window auxiliary hint is the value which is used to decide which actions should be made available to the user by the WM. If you want to set specific hint to your window, then you should check whether it exists in the supported auxiliary hints that are registered in the root window by the window manager. Once you've added an auxiliary hint, you can get a new ID which is used to change value and delete hint. The window manager sends the response message to the application on receiving auxiliary hint change event. A list of auxiliary hint within the Ecore_Evas has this format: ID:HINT:VALUE,ID:HINT:VALUE,... Reviewers: raster, cedric, seoz, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D543
2014-02-27 14:20:01 -08:00
_ecore_evas_x_aux_hints_supprted_update(ee);
_ecore_evas_x_aux_hints_update(ee);
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
_ecore_evas_x_sync_set(ee);
_ecore_evas_x_size_pos_hints_update(ee);
#endif /* BUILD_ECORE_EVAS_SOFTWARE_X11 */
if ((id = getenv("DESKTOP_STARTUP_ID")))
{
ecore_x_netwm_startup_id_set(ee->prop.window, 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=");
}
}
refactored _alpha_set a bit SVN revision: 29967
2007-05-12 07:13:19 -07:00
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
/* FIXME, round trip */
static void
_ecore_evas_x_alpha_set(Ecore_Evas *ee, int alpha)
{
char *id = NULL;
refactored _alpha_set a bit SVN revision: 29967
2007-05-12 07:13:19 -07:00
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
if (!strcmp(ee->driver, "software_x11"))
{
if (ee->in_async_render)
allow alpha ee windows. SVN revision: 46678
2010-02-28 20:44:36 -08:00
{
async render -> alpha set. if not visible dont WAIT. do it now.
2013-10-16 08:00:05 -07:00
if (ee->visible)
{
ee->delayed.alpha = alpha;
ee->delayed.alpha_changed = EINA_TRUE;
return;
}
cosmetic/logic move evas_sync call into same if block when applying alpha settings that might be deferred
2013-10-16 09:57:07 -07:00
evas_sync(ee->evas);
allow alpha ee windows. SVN revision: 46678
2010-02-28 20:44:36 -08:00
}
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
_alpha_do(ee, alpha);
allow alpha ee windows. SVN revision: 46678
2010-02-28 20:44:36 -08:00
}
else if (!strcmp(ee->driver, "opengl_x11"))
{
#ifdef BUILD_ECORE_EVAS_OPENGL_X11
Fix unused var warning
2014-05-30 05:26:55 -07:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
Fix unused var warning.
2014-05-30 05:24:42 -07:00
Ecore_X_Window_Attributes att;
some clang warning cleanups i forgot to commit SVN revision: 83024
2013-01-20 16:22:35 -08:00
if (ee->alpha == alpha) return;
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
Evas_Engine_Info_GL_X11 *einfo;
ecore_evas_x: Call _ecore_evas_x_sync_clear() after _ecore_evas_x_gl_window_new() to ensure eglDestroySurface is called before XDestroyWindow call. In case of gl engine, eglDestroySurface should be called before XDestroyWindow. Special thanks to Changwoo Kim <ce2010.kim@samsung.com> for the idea.
2014-01-12 00:22:40 -08:00
Ecore_Window prev_win;
allow alpha ee windows. SVN revision: 46678
2010-02-28 20:44:36 -08:00
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
einfo = (Evas_Engine_Info_GL_X11 *)evas_engine_info_get(ee->evas);
if (!einfo) return;
allow alpha ee windows. SVN revision: 46678
2010-02-28 20:44:36 -08:00
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
if (!ecore_x_composite_query()) return;
allow alpha ee windows. SVN revision: 46678
2010-02-28 20:44:36 -08:00
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
ee->shaped = 0;
ee->alpha = alpha;
* Ecore_x: fix alpha set function not clear sync counter
2013-03-22 02:49:46 -07:00
_ecore_evas_x_sync_clear(ee);
ecore_evas_x: Call _ecore_evas_x_sync_clear() after _ecore_evas_x_gl_window_new() to ensure eglDestroySurface is called before XDestroyWindow call. In case of gl engine, eglDestroySurface should be called before XDestroyWindow. Special thanks to Changwoo Kim <ce2010.kim@samsung.com> for the idea.
2014-01-12 00:22:40 -08:00
prev_win = ee->prop.window;
set win to 0 - in case SVN revision: 46684
2010-03-01 04:01:57 -08:00
ee->prop.window = 0;
Ecore: Removed trailing whitespaces. SVN revision: 58753
2011-04-20 07:15:33 -07:00
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
einfo->info.destination_alpha = alpha;
Ecore: Removed trailing whitespaces. SVN revision: 58753
2011-04-20 07:15:33 -07:00
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (edata->win_root != 0)
allow alpha ee windows. SVN revision: 46678
2010-02-28 20:44:36 -08:00
{
/* FIXME: round trip in ecore_x_window_argb_get */
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (ecore_x_window_argb_get(edata->win_root))
allow alpha ee windows. SVN revision: 46678
2010-02-28 20:44:36 -08:00
{
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
ee->prop.window =
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
_ecore_evas_x_gl_window_new(ee, edata->win_root,
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
ee->req.x, ee->req.y,
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
ee->req.w, ee->req.h,
ee->prop.override, 1, NULL);
}
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
else
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
{
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
ee->prop.window =
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
_ecore_evas_x_gl_window_new(ee, edata->win_root,
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
ee->req.x, ee->req.y,
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
ee->req.w, ee->req.h,
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
ee->prop.override, ee->alpha,
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
NULL);
allow alpha ee windows. SVN revision: 46678
2010-02-28 20:44:36 -08:00
}
}
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
else
handle info_set failures. SVN revision: 48957
2010-05-17 20:50:17 -07:00
{
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
ee->prop.window =
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
_ecore_evas_x_gl_window_new(ee, edata->win_root,
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
ee->req.x, ee->req.y,
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
ee->req.w, ee->req.h,
ee->prop.override, ee->alpha, NULL);
handle info_set failures. SVN revision: 48957
2010-05-17 20:50:17 -07:00
}
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
ecore_evas_x: Call _ecore_evas_x_sync_clear() after _ecore_evas_x_gl_window_new() to ensure eglDestroySurface is called before XDestroyWindow call. In case of gl engine, eglDestroySurface should be called before XDestroyWindow. Special thanks to Changwoo Kim <ce2010.kim@samsung.com> for the idea.
2014-01-12 00:22:40 -08:00
ecore_x_window_free(prev_win);
ecore_event_window_unregister(prev_win);
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
if (!ee->prop.window) return;
Ecore: Removed trailing whitespaces. SVN revision: 58753
2011-04-20 07:15:33 -07:00
/*
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
if (ee->alpha)
{
if (ee->prop.override)
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ee->prop.window = ecore_x_window_override_argb_new(edata->win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
else
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ee->prop.window = ecore_x_window_argb_new(edata->win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
if (!edata->mask)
edata->mask = ecore_x_pixmap_new(ee->prop.window, ee->req.w, ee->req.h, 1);
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
}
else
{
if (ee->prop.override)
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ee->prop.window = ecore_x_window_override_new(edata->win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
else
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ee->prop.window = ecore_x_window_new(edata->win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
if (edata->mask) ecore_x_pixmap_free(edata->mask);
edata->mask = 0;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
ecore_x_window_shape_input_mask_set(ee->prop.window, 0);
}
allow alpha ee windows. SVN revision: 46678
2010-02-28 20:44:36 -08:00
*/
Ecore_Evas: Use ecore_x function(s) for getting window attributes. Some fixes for OpenGL wrt xcb (minor stuffs). NB: We already use ecore_x for some things in here, so let's keep duplicated code down to a minimum and resuse what we already have ;) SVN revision: 61676
2011-07-25 02:29:09 -07:00
ecore_x_window_attributes_get(ee->prop.window, &att);
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
einfo->info.visual = att.visual;
einfo->info.colormap = att.colormap;
einfo->info.depth = att.depth;
allow alpha ee windows. SVN revision: 46678
2010-02-28 20:44:36 -08:00
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
// if (edata->mask) ecore_x_pixmap_free(edata->mask);
// edata->mask = 0;
// einfo->info.mask = edata->mask;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
einfo->info.drawable = ee->prop.window;
handle info_set failures. SVN revision: 48957
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);
}
tab------------ SVN revision: 52896
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);
Expose device (e.g. pen) axis information to applications Summary: This patch set adds the necessary code to expose device axis state to applications. This was primarily written with graphics tablets in mind, which -- in addition to acting like a mouse -- also provide information about pen pressure, tilt, etc. Other devices could potentially benefit from this API as well: touchscreens, joysticks, knob controllers, "spaceballs", etc. Whenever an update to the device state is recieved, an "Axis update" event is synthesized. This event contains the updated information, typically scaled and normalized to a particular logical range (e.g. zero to one for pressure, -pi to pi radians for angles, etc.). Information about the tool which generated the event is also stored so that applications can disambiguate events from multiple devices (or in the case of multitouch screens, individual fingers). This API is only wired up for use with X11 at the moment. Support for other backends (e.g. Wayland) should be easy to add for those familiar them. **Note**: The following is a list of changes from the "v2" patches originally sent to the mailinglist //Define and implement new Ecore_Event_Axis_Update events// * Harcode axis labels instead of including xserver-properties.h * Use C89-style comments * Use doxygen comments * Update comment text to note axes with unbounded/undefined ranges/units * Create "Ecore_Axis" and "Ecore_Axis_Label" typedefs * Reference typedef'd instead of raw types * Adjust how we count through valuators to support tilt/az * Add support for tilt and azimuth * Tweak memory management in case number of valuators differ * Expand TWIST axis normalization to declared range * Only normalize TWIST axis if resolution == 1 (wacom bug) * Cache label atoms on first use to minimize round-trips //Implement EVAS_CALLBACK_AXIS_UPDATE event and friends// * Update to doxygen comments * Update comment text to note axes with unbounded/undefined ranges/units * Typedef 'Evas_Axis_Label', 'Evas_Axis' * Move typedef for 'Evas_Event_Axis_Update' * Reference typedef'd instead of raw types //Wire the Ecore and Evas implementations of axis update events together// * Expose ecore_event_evas_axis_update in Ecore_Input_Evas.h * Move ecore_event_evas_axis_update to more logical position //DEBUG: Add axis update logging to evas-multi-touch.c// * Removed from patch set //Make evas-multi-touch demo use new axis functionality// * Have pressure adjust rectangle brightness instead of size * Use more available axis data when rendering rectangle (azimuth, tilt, twist) Test Plan: The evas-multi-touch demo was updated to support axis update events. A graphics tablet was then used to verify that the pressure, azimuth, tilt, and twist data was coming through correctly. Reviewers: cedric, raster Subscribers: cedric Differential Revision: https://phab.enlightenment.org/D1514 Conflicts: src/lib/ecore_input/Ecore_Input.h Carsten Haitzler - ** fixed forward enum typedefs (make things unhappy) ** fixed conflict above ** fixed wrong param type for _evas_canvas_event_feed_axis_update() ** fixed @sinces to be 1.13 ** fixed formatting/indeting ** fixed order of operation reliance in if's with ()'s to be clear ** fixed functions to be static that should have been
2014-11-24 19:07:50 -08:00
ecore_x_input_select(ee->prop.window);
and break api in ecore_input_evas - not used anyway except within ecore. the api didn't allow for rotation of multitouch input. need to fix. done. SVN revision: 55367
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);
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
if (ee->prop.borderless)
ecore_x_mwm_borderless_set(ee->prop.window, ee->prop.borderless);
ecore/ecore_x - show the window if the window should be visible. when the window alpha mode is changed, the x window is re-created. but if the window is going on the show state(not visible yet but waiting for visible from xserver) this window never be visible. so here it make the window visible also if the window is going on the visible state.
2013-12-17 03:37:17 -08:00
if (ee->visible || ee->should_be_visible)
ecore_x_window_show(ee->prop.window);
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
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);
}
fix ecore-evas name/class set on ecore-evas's when alpha is enabled SVN revision: 72279
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);
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
_ecore_evas_x_hints_update(ee);
set client leader by default - support setting it explicitly from code too. fix default win props too. SVN revision: 52974
2010-10-01 18:56:23 -07:00
_ecore_evas_x_group_leader_update(ee);
ecore_x_window_defaults_set(ee->prop.window);
allow alpha ee windows. SVN revision: 46678
2010-02-28 20:44:36 -08:00
_ecore_evas_x_protocols_set(ee);
From: Gwanglim Lee <gl77.lee@samsung.com> Subject: Re: Re: Re: [E-devel] [RFC] Virtual desktop window profile I've attached 4th patch. May the 4th be with you. ecore patch has been merged with efl and all files are based on r80123. Thanks & Regards, Gwanglim ------- Original Message ------- Sender : Daniel Juyung Seo<seojuyung2@gmail.com> Date : 2012-12-04 01:55 (GMT+09:00) Title : Re: Re: [E-devel] [RFC] Virtual desktop window profile It looks ok to me. Sorry but can you re-generate the patch according to the recent ecore merge to efl single tree? Daniel Juyung Seo (SeoZ) On Thu, Nov 29, 2012 at 12:29 AM, Gwanglim Lee <gl77.lee@samsung.com> wrote: Dear Raster and Daniel Juyung Seo, I've attached 3rd patches and test_config according to your reviews. These are based on r79782. [elementary & ecore] 1. "profile,set" -> "profile,changed" - done 2. spaces after EINA_LIST_FOREACH - done 3. variable type - keep 4. author - done 5. removing deprecated marking in patch - done 6. add elm_win_available_profiles_get to test_config for the debugging purpose - done 7. check whether a given profile is present in an available profiles. otherwise window profile will be one of the item in available profiles. - newly added thing to the elm_win 8. merge with EO - done. :( Any comments would be appreciated. SVN revision: 80214
2012-12-04 22:48:46 -08:00
_ecore_evas_x_window_profile_protocol_set(ee);
ecore_evas: added window manager rotation to manage the rotation of windows by the WM. Summary: The window manager rotation allows the WM to controls the rotation of application windows. It is designed to support synchronized rotation for the multiple application windows at same time. Reviewers: raster, seoz, cedric, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D529
2014-02-08 16:46:51 -08:00
_ecore_evas_x_wm_rotation_protocol_set(ee);
ecore_evas: Added support for window auxiliary hint Summary: The window auxiliary hint is the value which is used to decide which actions should be made available to the user by the WM. If you want to set specific hint to your window, then you should check whether it exists in the supported auxiliary hints that are registered in the root window by the window manager. Once you've added an auxiliary hint, you can get a new ID which is used to change value and delete hint. The window manager sends the response message to the application on receiving auxiliary hint change event. A list of auxiliary hint within the Ecore_Evas has this format: ID:HINT:VALUE,ID:HINT:VALUE,... Reviewers: raster, cedric, seoz, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D543
2014-02-27 14:20:01 -08:00
_ecore_evas_x_aux_hints_supprted_update(ee);
_ecore_evas_x_aux_hints_update(ee);
allow alpha ee windows. SVN revision: 46678
2010-02-28 20:44:36 -08:00
_ecore_evas_x_sync_set(ee);
fix alpha change losing some properties SVN revision: 72258
2012-06-16 19:37:18 -07:00
_ecore_evas_x_size_pos_hints_update(ee);
allow alpha ee windows. SVN revision: 46678
2010-02-28 20:44:36 -08:00
#endif /* BUILD_ECORE_EVAS_OPENGL_X11 */
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
if ((id = getenv("DESKTOP_STARTUP_ID")))
allow alpha ee windows. SVN revision: 46678
2010-02-28 20:44:36 -08:00
{
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
ecore_x_netwm_startup_id_set(ee->prop.window, id);
allow alpha ee windows. SVN revision: 46678
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 */
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
// putenv((char*)"DESKTOP_STARTUP_ID=");
allow alpha ee windows. SVN revision: 46678
2010-02-28 20:44:36 -08:00
}
support argb targets for ecore_evas sw_x11 SVN revision: 21120
2006-03-08 19:51:43 -08:00
}
evilness... but it works. SVN revision: 21091
2006-03-08 00:02:55 -08:00
}
From: 이상진 <lsj119@samsung.com> I am attaching another patches for transparent window. 1. Use RGB Visual. 2. Set destination_alpha in ecore_evas for alpha composite in evas. 3. add Function - Ecore_Evas_Engine_Func->fn_transparent_set - ecore_evas_transparent_set , ecore_evas_transparent_get - elm_win_transparent_set, elm_win_transparent_get SVN revision: 46106
2010-02-11 21:31:26 -08:00
static void
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
_transparent_do(Ecore_Evas *ee, int transparent)
From: 이상진 <lsj119@samsung.com> I am attaching another patches for transparent window. 1. Use RGB Visual. 2. Set destination_alpha in ecore_evas for alpha composite in evas. 3. add Function - Ecore_Evas_Engine_Func->fn_transparent_set - ecore_evas_transparent_set , ecore_evas_transparent_get - elm_win_transparent_set, elm_win_transparent_get SVN revision: 46106
2010-02-11 21:31:26 -08:00
{
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
some clang warning cleanups i forgot to commit SVN revision: 83024
2013-01-20 16:22:35 -08:00
if (ee->transparent == transparent) return;
From: 이상진 <lsj119@samsung.com> I am attaching another patches for transparent window. 1. Use RGB Visual. 2. Set destination_alpha in ecore_evas for alpha composite in evas. 3. add Function - Ecore_Evas_Engine_Func->fn_transparent_set - ecore_evas_transparent_set , ecore_evas_transparent_get - elm_win_transparent_set, elm_win_transparent_get SVN revision: 46106
2010-02-11 21:31:26 -08:00
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
Evas_Engine_Info_Software_X11 *einfo;
From: 이상진 <lsj119@samsung.com> I am attaching another patches for transparent window. 1. Use RGB Visual. 2. Set destination_alpha in ecore_evas for alpha composite in evas. 3. add Function - Ecore_Evas_Engine_Func->fn_transparent_set - ecore_evas_transparent_set , ecore_evas_transparent_get - elm_win_transparent_set, elm_win_transparent_get SVN revision: 46106
2010-02-11 21:31:26 -08:00
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
einfo = (Evas_Engine_Info_Software_X11 *)evas_engine_info_get(ee->evas);
if (!einfo) return;
From: 이상진 <lsj119@samsung.com> I am attaching another patches for transparent window. 1. Use RGB Visual. 2. Set destination_alpha in ecore_evas for alpha composite in evas. 3. add Function - Ecore_Evas_Engine_Func->fn_transparent_set - ecore_evas_transparent_set , ecore_evas_transparent_get - elm_win_transparent_set, elm_win_transparent_get SVN revision: 46106
2010-02-11 21:31:26 -08:00
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
ee->transparent = transparent;
einfo->info.destination_alpha = transparent;
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
{
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
}
evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
#endif
}
static void
_ecore_evas_x_transparent_set(Ecore_Evas *ee, int transparent)
{
if (!strcmp(ee->driver, "software_x11"))
{
if (ee->in_async_render)
handle info_set failures. SVN revision: 48957
2010-05-17 20:50:17 -07:00
{
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
ee->delayed.transparent = transparent;
ee->delayed.transparent_changed = EINA_TRUE;
return;
handle info_set failures. SVN revision: 48957
2010-05-17 20:50:17 -07:00
}
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
_transparent_do(ee, transparent);
From: 이상진 <lsj119@samsung.com> I am attaching another patches for transparent window. 1. Use RGB Visual. 2. Set destination_alpha in ecore_evas for alpha composite in evas. 3. add Function - Ecore_Evas_Engine_Func->fn_transparent_set - ecore_evas_transparent_set , ecore_evas_transparent_get - elm_win_transparent_set, elm_win_transparent_get SVN revision: 46106
2010-02-11 21:31:26 -08:00
}
}
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
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 - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
_ecore_evas_x_urgent_set(Ecore_Evas *ee, Eina_Bool on)
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
{
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
if (ee->prop.urgent == on) return;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
ee->prop.urgent = on;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
_ecore_evas_x_hints_update(ee);
}
static void
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
_ecore_evas_x_modal_set(Ecore_Evas *ee, Eina_Bool on)
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
if (ee->prop.modal == on) return;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
ee->prop.modal = on;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
if (ee->should_be_visible)
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ecore_x_netwm_state_request_send(ee->prop.window, edata->win_root,
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
ECORE_X_WINDOW_STATE_MODAL, -1, on);
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
else
_ecore_evas_x_state_update(ee);
}
static void
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
_ecore_evas_x_demand_attention_set(Ecore_Evas *ee, Eina_Bool on)
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
if (ee->prop.demand_attention == on) return;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
ee->prop.demand_attention = on;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
if (ee->should_be_visible)
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ecore_x_netwm_state_request_send(ee->prop.window, edata->win_root,
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
ECORE_X_WINDOW_STATE_DEMANDS_ATTENTION,
-1, on);
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
else
_ecore_evas_x_state_update(ee);
}
static void
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
_ecore_evas_x_focus_skip_set(Ecore_Evas *ee, Eina_Bool on)
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
if (ee->prop.focus_skip == on) return;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
ee->prop.focus_skip = on;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
if (ee->should_be_visible)
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ecore_x_netwm_state_request_send(ee->prop.window, edata->win_root,
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
ECORE_X_WINDOW_STATE_SKIP_TASKBAR, -1,
on);
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ecore_x_netwm_state_request_send(ee->prop.window, edata->win_root,
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
ECORE_X_WINDOW_STATE_SKIP_PAGER, -1,
on);
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
}
else
_ecore_evas_x_state_update(ee);
_ecore_evas_x_hints_update(ee);
}
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
static void
change of internal names for parralel implementation of ecore_xcb SVN revision: 15248
2005-06-10 23:05:51 -07:00
_ecore_evas_x_show(Ecore_Evas *ee)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
if an ecore evas is shaped and avoid damage - render it just before a show :) SVN revision: 15651
2005-07-06 20:31:34 -07:00
ee->should_be_visible = 1;
actually - if avoid damage is set render anyway :) SVN revision: 15653
2005-07-06 20:37:57 -07:00
if (ee->prop.avoid_damage)
if an ecore evas is shaped and avoid damage - render it just before a show :) SVN revision: 15651
2005-07-06 20:31:34 -07:00
_ecore_evas_x_render(ee);
delay comp setup until show. (and unset on hide) SVN revision: 53256
2010-10-10 23:28:01 -07:00
_ecore_evas_x_sync_set(ee);
From: Gwanglim Lee <gl77.lee@samsung.com> Subject: Re: Re: Re: [E-devel] [RFC] Virtual desktop window profile I've attached 4th patch. May the 4th be with you. ecore patch has been merged with efl and all files are based on r80123. Thanks & Regards, Gwanglim ------- Original Message ------- Sender : Daniel Juyung Seo<seojuyung2@gmail.com> Date : 2012-12-04 01:55 (GMT+09:00) Title : Re: Re: [E-devel] [RFC] Virtual desktop window profile It looks ok to me. Sorry but can you re-generate the patch according to the recent ecore merge to efl single tree? Daniel Juyung Seo (SeoZ) On Thu, Nov 29, 2012 at 12:29 AM, Gwanglim Lee <gl77.lee@samsung.com> wrote: Dear Raster and Daniel Juyung Seo, I've attached 3rd patches and test_config according to your reviews. These are based on r79782. [elementary & ecore] 1. "profile,set" -> "profile,changed" - done 2. spaces after EINA_LIST_FOREACH - done 3. variable type - keep 4. author - done 5. removing deprecated marking in patch - done 6. add elm_win_available_profiles_get to test_config for the debugging purpose - done 7. check whether a given profile is present in an available profiles. otherwise window profile will be one of the item in available profiles. - newly added thing to the elm_win 8. merge with EO - done. :( Any comments would be appreciated. SVN revision: 80214
2012-12-04 22:48:46 -08:00
_ecore_evas_x_window_profile_set(ee);
Let me introduce you to Ecore_Input. The idea is to share as much as possible event between all ecore graphic engine to ease porting of application and reduce the amount of specific code per engine. This patch does just that. All your application should continu to work has previously, if it's not the case please report any new behaviour regarding mouse and keyboard. SVN revision: 39505
2009-03-16 09:24:43 -07:00
ecore_x_window_show(ee->prop.window);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
if (ee->prop.fullscreen)
Let me introduce you to Ecore_Input. The idea is to share as much as possible event between all ecore graphic engine to ease porting of application and reduce the amount of specific code per engine. This patch does just that. All your application should continu to work has previously, if it's not the case please report any new behaviour regarding mouse and keyboard. SVN revision: 39505
2009-03-16 09:24:43 -07:00
ecore_x_window_focus(ee->prop.window);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
static void
change of internal names for parralel implementation of ecore_xcb SVN revision: 15248
2005-06-10 23:05:51 -07:00
_ecore_evas_x_hide(Ecore_Evas *ee)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
Let me introduce you to Ecore_Input. The idea is to share as much as possible event between all ecore graphic engine to ease porting of application and reduce the amount of specific code per engine. This patch does just that. All your application should continu to work has previously, if it's not the case please report any new behaviour regarding mouse and keyboard. SVN revision: 39505
2009-03-16 09:24:43 -07:00
ecore_x_window_hide(ee->prop.window);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
ee->should_be_visible = 0;
delay comp setup until show. (and unset on hide) SVN revision: 53256
2010-10-10 23:28:01 -07:00
_ecore_evas_x_sync_set(ee);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
static void
change of internal names for parralel implementation of ecore_xcb SVN revision: 15248
2005-06-10 23:05:51 -07:00
_ecore_evas_x_raise(Ecore_Evas *ee)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
ecore_x_window_raise(ee->prop.window);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
static void
change of internal names for parralel implementation of ecore_xcb SVN revision: 15248
2005-06-10 23:05:51 -07:00
_ecore_evas_x_lower(Ecore_Evas *ee)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
ecore_x_window_lower(ee->prop.window);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
ecore_evas activate call.. uses netwm one... eek. need to add xcb. SVN revision: 34949
2008-06-30 01:39:36 -07:00
static void
_ecore_evas_x_activate(Ecore_Evas *ee)
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
elm win throttle/norender auto... eocre-evas got a few things wrong. no - not planning a backport of this at this stage. small thing. maybe backport (and chlog/news) if this doesnt cause any new issues? SVN revision: 82549
2013-01-10 03:23:10 -08:00
ecore_evas_show(ee);
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ecore_x_netwm_client_active_request(edata->win_root,
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
ee->prop.window, 2, 0);
ecore_evas activate call.. uses netwm one... eek. need to add xcb. SVN revision: 34949
2008-06-30 01:39:36 -07:00
}
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
static void
change of internal names for parralel implementation of ecore_xcb SVN revision: 15248
2005-06-10 23:05:51 -07:00
_ecore_evas_x_title_set(Ecore_Evas *ee, const char *t)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
if (ee->prop.title) free(ee->prop.title);
ee->prop.title = NULL;
ecore_evas: Fix potential NULL dereference. We don't want to execute any of the function below if t is NULL. Its not only about strdup but alsa ecore_x_netwm_name_set which might dereference it. CID 1039400
2013-08-07 07:38:35 -07:00
if (!t) return;
ee->prop.title = strdup(t);
Let me introduce you to Ecore_Input. The idea is to share as much as possible event between all ecore graphic engine to ease porting of application and reduce the amount of specific code per engine. This patch does just that. All your application should continu to work has previously, if it's not the case please report any new behaviour regarding mouse and keyboard. SVN revision: 39505
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);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
static void
change of internal names for parralel implementation of ecore_xcb SVN revision: 15248
2005-06-10 23:05:51 -07:00
_ecore_evas_x_name_class_set(Ecore_Evas *ee, const char *n, const char *c)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
ecore-evas-x should check itself before it wrecks itself when re-setting the same name/class
2015-01-14 22:30:27 -08:00
if (!eina_streq(n, ee->prop.name))
{
free(ee->prop.name);
ee->prop.name = NULL;
if (n) ee->prop.name = strdup(n);
}
if (!eina_streq(c, ee->prop.clas))
{
free(ee->prop.clas);
ee->prop.clas = NULL;
if (c) ee->prop.clas = strdup(c);
}
Let me introduce you to Ecore_Input. The idea is to share as much as possible event between all ecore graphic engine to ease porting of application and reduce the amount of specific code per engine. This patch does just that. All your application should continu to work has previously, if it's not the case please report any new behaviour regarding mouse and keyboard. SVN revision: 39505
2009-03-16 09:24:43 -07:00
ecore_x_icccm_name_class_set(ee->prop.window, ee->prop.name, ee->prop.clas);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
static void
change of internal names for parralel implementation of ecore_xcb SVN revision: 15248
2005-06-10 23:05:51 -07:00
_ecore_evas_x_size_min_set(Ecore_Evas *ee, int w, int h)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
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;
change of internal names for parralel implementation of ecore_xcb SVN revision: 15248
2005-06-10 23:05:51 -07:00
_ecore_evas_x_size_pos_hints_update(ee);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
static void
change of internal names for parralel implementation of ecore_xcb SVN revision: 15248
2005-06-10 23:05:51 -07:00
_ecore_evas_x_size_max_set(Ecore_Evas *ee, int w, int h)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
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;
change of internal names for parralel implementation of ecore_xcb SVN revision: 15248
2005-06-10 23:05:51 -07:00
_ecore_evas_x_size_pos_hints_update(ee);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
static void
change of internal names for parralel implementation of ecore_xcb SVN revision: 15248
2005-06-10 23:05:51 -07:00
_ecore_evas_x_size_base_set(Ecore_Evas *ee, int w, int h)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
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;
change of internal names for parralel implementation of ecore_xcb SVN revision: 15248
2005-06-10 23:05:51 -07:00
_ecore_evas_x_size_pos_hints_update(ee);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
static void
change of internal names for parralel implementation of ecore_xcb SVN revision: 15248
2005-06-10 23:05:51 -07:00
_ecore_evas_x_size_step_set(Ecore_Evas *ee, int w, int h)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
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;
change of internal names for parralel implementation of ecore_xcb SVN revision: 15248
2005-06-10 23:05:51 -07:00
_ecore_evas_x_size_pos_hints_update(ee);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
* ecore/src/lib/ecore_evas/ecore_evas_quartz.c, * ecore/src/lib/ecore_evas/ecore_evas_fb.c, * ecore/src/lib/ecore_evas/ecore_evas_x.c, * ecore/src/lib/ecore_evas/ecore_evas_directfb.c, * ecore/src/lib/ecore_evas/ecore_evas_sdl.c: Prevent use of deleted object. SVN revision: 38949
2009-02-05 02:45:52 -08:00
static void
Ecore: __UNUSED__ --> EINA_UNUSED SVN revision: 79649
2012-11-25 01:55:32 -08:00
_ecore_evas_object_cursor_del(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
* ecore/src/lib/ecore_evas/ecore_evas_quartz.c, * ecore/src/lib/ecore_evas/ecore_evas_fb.c, * ecore/src/lib/ecore_evas/ecore_evas_x.c, * ecore/src/lib/ecore_evas/ecore_evas_directfb.c, * ecore/src/lib/ecore_evas/ecore_evas_sdl.c: Prevent use of deleted object. SVN revision: 38949
2009-02-05 02:45:52 -08:00
{
Ecore_Evas *ee;
ee = data;
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
if (ee) ee->prop.cursor.object = NULL;
* ecore/src/lib/ecore_evas/ecore_evas_quartz.c, * ecore/src/lib/ecore_evas/ecore_evas_fb.c, * ecore/src/lib/ecore_evas/ecore_evas_x.c, * ecore/src/lib/ecore_evas/ecore_evas_directfb.c, * ecore/src/lib/ecore_evas/ecore_evas_sdl.c: Prevent use of deleted object. SVN revision: 38949
2009-02-05 02:45:52 -08:00
}
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
static void
Change Ecore_Evas to work with Evas_Object as cursor. WARNING: this breaks the API, if you rely on ecore_evas_cursor_get(), you need to get the "Evas_Object *" instead of the filename. Now the code is smaller and we can handle any object, including Edje. Patch by Cedric BAIL. SVN revision: 31818
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)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
ecore_evas: avoid using non initialized value for cursor position in X backend. CID 1195445.
2014-04-17 12:16:12 -07:00
int x = 0, y = 0;
ecore-evas - fix object cursor to not delete the same cursor when set this fixes a misbehavior with ecore evas object cursors when you set one, the old one is deleted, but if the old is the same, the new one you set gets deleted, rather than just updated. @fix
2014-04-02 04:29:03 -07:00
Evas_Object *old;
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/x: Fixed that cursor object was not disappear When moved mouse among two objects having cursor set, EVAS_CALLBACK_MOUSE_OUT and EVAS_CALLBACK_MOUSE_IN are fired. I observed that evas_object_del in callback of EVAS_CALLBACK_MOUSE_OUT calls EVAS_CALLBACK_MOUSE_IN so that newly added cursor object was detached.
2013-05-20 17:38:19 -07:00
old = ee->prop.cursor.object;
Convert (hopefully) all comparisons to NULL Apply badzero.cocci, badnull.coci and badnull2.cocci This should convert all cases where there's a comparison to NULL to simpler forms. This patch applies the following transformations: code before patch ||code after patch =============================================================== return a == NULL; return !a; return a != NULL; return !!a; func(a == NULL); func(!a); func(a != NULL); func(!!a); b = a == NULL; b = !a; b = a != NULL; b = !!a; b = a == NULL ? c : d; b = !a ? c : d; b = a != NULL ? c : d; b = a ? c : d; other cases: a == NULL !a a != NULL a SVN revision: 51487
2010-08-21 06:52:25 -07:00
if (!obj)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
tab------------ SVN revision: 52896
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);
ecore_evas/x: Fixed that cursor object was not disappear When moved mouse among two objects having cursor set, EVAS_CALLBACK_MOUSE_OUT and EVAS_CALLBACK_MOUSE_IN are fired. I observed that evas_object_del in callback of EVAS_CALLBACK_MOUSE_OUT calls EVAS_CALLBACK_MOUSE_IN so that newly added cursor object was detached.
2013-05-20 17:38:19 -07:00
goto end;
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
Change Ecore_Evas to work with Evas_Object as cursor. WARNING: this breaks the API, if you rely on ecore_evas_cursor_get(), you need to get the "Evas_Object *" instead of the filename. Now the code is smaller and we can handle any object, including Edje. Patch by Cedric BAIL. SVN revision: 31818
2007-09-26 07:40:02 -07:00
ee->prop.cursor.object = obj;
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
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;
Change Ecore_Evas to work with Evas_Object as cursor. WARNING: this breaks the API, if you rely on ecore_evas_cursor_get(), you need to get the "Evas_Object *" instead of the filename. Now the code is smaller and we can handle any object, including Edje. Patch by Cedric BAIL. SVN revision: 31818
2007-09-26 07:40:02 -07:00
ecore-evas: Fix cursor position getting reset to 0,0 when using ecore_evas_cursor_object_set NB: Previously, if we mad calls to ecore_evas_cursor_object_set to update the mouse cursor hotspot, the mouse cursor would be repositioned at 0,0 on the canvas due to x & y being set to 0,0. We fix that here by fetching the current mouse position Regardless if we are changing the object or not (ie: perhaps we are just updating the hotspot and not the object) @fix Signed-off-by: Chris Michael <cp.michael@samsung.com>
2014-06-25 10:11:16 -07:00
evas_pointer_output_xy_get(ee->evas, &x, &y);
ecore-evas - fix object cursor to not delete the same cursor when set this fixes a misbehavior with ecore evas object cursors when you set one, the old one is deleted, but if the old is the same, the new one you set gets deleted, rather than just updated. @fix
2014-04-02 04:29:03 -07:00
if (obj != old)
{
ecore_x_window_cursor_show(ee->prop.window, 0);
evas_object_layer_set(ee->prop.cursor.object, ee->prop.cursor.layer);
evas_object_pass_events_set(ee->prop.cursor.object, 1);
if (evas_pointer_inside_get(ee->evas))
evas_object_show(ee->prop.cursor.object);
evas_object_event_callback_add(obj, EVAS_CALLBACK_DEL,
_ecore_evas_object_cursor_del, ee);
}
ecore-evas: Fix formatting and remove whitespace Signed-off-by: Chris Michael <cp.michael@samsung.com>
2014-06-25 10:20:13 -07:00
evas_object_move(ee->prop.cursor.object, x - ee->prop.cursor.hot.x,
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
y - ee->prop.cursor.hot.y);
ecore_evas/x: Fixed that cursor object was not disappear When moved mouse among two objects having cursor set, EVAS_CALLBACK_MOUSE_OUT and EVAS_CALLBACK_MOUSE_IN are fired. I observed that evas_object_del in callback of EVAS_CALLBACK_MOUSE_OUT calls EVAS_CALLBACK_MOUSE_IN so that newly added cursor object was detached.
2013-05-20 17:38:19 -07:00
end:
ecore-evas - fix object cursor to not delete the same cursor when set this fixes a misbehavior with ecore evas object cursors when you set one, the old one is deleted, but if the old is the same, the new one you set gets deleted, rather than just updated. @fix
2014-04-02 04:29:03 -07:00
if ((old) && (obj != old))
{
evas_object_event_callback_del_full
(old, EVAS_CALLBACK_DEL, _ecore_evas_object_cursor_del, ee);
evas_object_del(old);
}
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
Make ecore evas use netwm and icccm, not window_prop. Window_prop is gone, but maybe resurrect some parts of it as a wrapper around icccm/netwm as convencience functions? SVN revision: 15227
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)
*/
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
static void
change of internal names for parralel implementation of ecore_xcb SVN revision: 15248
2005-06-10 23:05:51 -07:00
_ecore_evas_x_layer_set(Ecore_Evas *ee, int layer)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
if (ee->prop.layer == layer) return;
Make ecore evas use netwm and icccm, not window_prop. Window_prop is gone, but maybe resurrect some parts of it as a wrapper around icccm/netwm as convencience functions? SVN revision: 15227
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;
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
ee->prop.layer = layer;
change of internal names for parralel implementation of ecore_xcb SVN revision: 15248
2005-06-10 23:05:51 -07:00
_ecore_evas_x_layer_update(ee);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
static void
ecore - clean up code. fix indentation and use Eina_Bool instead of char.
2014-01-11 01:19:43 -08:00
_ecore_evas_x_focus_set(Ecore_Evas *ee, Eina_Bool on EINA_UNUSED)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
Let me introduce you to Ecore_Input. The idea is to share as much as possible event between all ecore graphic engine to ease porting of application and reduce the amount of specific code per engine. This patch does just that. All your application should continu to work has previously, if it's not the case please report any new behaviour regarding mouse and keyboard. SVN revision: 39505
2009-03-16 09:24:43 -07:00
ecore_x_window_focus(ee->prop.window);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
hook in ecore_evas_iconified_set into the x11 engine, use code in ecore_x to do it SVN revision: 9689
2004-04-11 10:37:39 -07:00
static void
ecore - clean up code. fix indentation and use Eina_Bool instead of char.
2014-01-11 01:19:43 -08:00
_ecore_evas_x_iconified_set(Ecore_Evas *ee, Eina_Bool on)
hook in ecore_evas_iconified_set into the x11 engine, use code in ecore_x to do it SVN revision: 9689
2004-04-11 10:37:39 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
if (ee->prop.iconified == on) return;
ecore_evas_x: Fixed strange condition. Summary: To satisfy this condition, ee->visible will be EINA_FALSE. But when iconify is requested, ee->visible is usually EINA_TRUE. @fix Reviewers: raster, Hermet, seoz Reviewed By: seoz Subscribers: cedric Differential Revision: https://phab.enlightenment.org/D1710
2014-11-28 08:10:39 -08:00
if (((ee->should_be_visible) && (!ee->visible)) || (ee->visible))
follow on from last week - ee state not quite being handled right in x11 when being iconified. missed commenting it out. fix and handle initial state too. SVN revision: 82747
2013-01-14 01:45:05 -08:00
ee->prop.iconified = on;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
_ecore_evas_x_hints_update(ee);
Make ecore evas use netwm and icccm, not window_prop. Window_prop is gone, but maybe resurrect some parts of it as a wrapper around icccm/netwm as convencience functions? SVN revision: 15227
2005-06-09 21:18:24 -07:00
if (on)
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ecore_x_icccm_iconic_request_send(ee->prop.window, edata->win_root);
Make ecore evas use netwm and icccm, not window_prop. Window_prop is gone, but maybe resurrect some parts of it as a wrapper around icccm/netwm as convencience functions? SVN revision: 15227
2005-06-09 21:18:24 -07:00
else
Revert "ecore_evas: window does not go back to normal state if you set iconified to EINA_FALSE." This reverts commit 9bfb730ff57da3d8789f80256abedcbc19e98bfe. wrong! on deiconify this will now FORCE a ACTIVATE request to the wm (which asks the wm to focus the window/hilight it and make it active. might switch desktops or whatever). this is wrong. de-icoifying a windows does NOT mean ALSO activating it!. the log message also doesnt say what "go back to normal state"... means.... do they expect/INSIST windows MUSt be focused after de-iconification? that's wrong as it's a window management FOCUS policy, not something to do in the lib.
2013-10-14 18:45:37 -07:00
ecore_evas_show(ee);
hook in ecore_evas_iconified_set into the x11 engine, use code in ecore_x to do it SVN revision: 9689
2004-04-11 10:37:39 -07:00
}
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
static void
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
_ecore_evas_x_borderless_set(Ecore_Evas *ee, Eina_Bool on)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
if (ee->prop.borderless == on) return;
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
ee->prop.borderless = on;
Let me introduce you to Ecore_Input. The idea is to share as much as possible event between all ecore graphic engine to ease porting of application and reduce the amount of specific code per engine. This patch does just that. All your application should continu to work has previously, if it's not the case please report any new behaviour regarding mouse and keyboard. SVN revision: 39505
2009-03-16 09:24:43 -07:00
ecore_x_mwm_borderless_set(ee->prop.window, ee->prop.borderless);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
Make ecore evas use netwm and icccm, not window_prop. Window_prop is gone, but maybe resurrect some parts of it as a wrapper around icccm/netwm as convencience functions? SVN revision: 15227
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! */
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
static void
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
_ecore_evas_x_withdrawn_set(Ecore_Evas *ee, Eina_Bool on)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
if (ee->prop.withdrawn == on) return;
// ee->prop.withdrawn = on;
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
_ecore_evas_x_hints_update(ee);
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
if (on)
elm win throttle/norender auto... eocre-evas got a few things wrong. no - not planning a backport of this at this stage. small thing. maybe backport (and chlog/news) if this doesnt cause any new issues? SVN revision: 82549
2013-01-10 03:23:10 -08:00
ecore_evas_hide(ee);
else
ecore_evas_show(ee);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
till's stick patch SVN revision: 7901
2003-11-15 18:29:10 -08:00
static void
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
_ecore_evas_x_sticky_set(Ecore_Evas *ee, Eina_Bool on)
till's stick patch SVN revision: 7901
2003-11-15 18:29:10 -08:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
if (ee->prop.sticky == on) return;
till's stick patch SVN revision: 7901
2003-11-15 18:29:10 -08:00
initialize to 0, set prop.sticky properly SVN revision: 24296
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.
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
* ee->prop.sticky = 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
*/
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
// edata->state.sticky = on;
Make ecore evas use netwm and icccm, not window_prop. Window_prop is gone, but maybe resurrect some parts of it as a wrapper around icccm/netwm as convencience functions? SVN revision: 15227
2005-06-09 21:18:24 -07:00
if (ee->should_be_visible)
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ecore_x_netwm_state_request_send(ee->prop.window, edata->win_root,
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
ECORE_X_WINDOW_STATE_STICKY, -1, on);
Make ecore evas use netwm and icccm, not window_prop. Window_prop is gone, but maybe resurrect some parts of it as a wrapper around icccm/netwm as convencience functions? SVN revision: 15227
2005-06-09 21:18:24 -07:00
else
change of internal names for parralel implementation of ecore_xcb SVN revision: 15248
2005-06-10 23:05:51 -07:00
_ecore_evas_x_state_update(ee);
till's stick patch SVN revision: 7901
2003-11-15 18:29:10 -08:00
}
ignore events. Should we add extra windows to the ignore list (ecore_x_window_ignore_set)? SVN revision: 17317
2005-10-08 05:41:59 -07:00
static void
_ecore_evas_x_ignore_events_set(Ecore_Evas *ee, int ignore)
{
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
if (ee->ignore_events == ignore) return;
ignore events. Should we add extra windows to the ignore list (ecore_x_window_ignore_set)? SVN revision: 17317
2005-10-08 05:41:59 -07:00
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
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);
ignore events. Should we add extra windows to the ignore list (ecore_x_window_ignore_set)? SVN revision: 17317
2005-10-08 05:41:59 -07:00
}
support argb targets for ecore_evas sw_x11 SVN revision: 21120
2006-03-08 19:51:43 -08:00
/*
evilness... but it works. SVN revision: 21091
2006-03-08 00:02:55 -08:00
static void
_ecore_evas_x_reinit_win(Ecore_Evas *ee)
{
if (!strcmp(ee->driver, "software_x11"))
{
ECORE_X doesn't have anything to do with ecore_evas_x. TODO: Split the idea of ECORE_EVAS_X11 and the basic software engine. SVN revision: 32403
2007-11-05 23:21:08 -08:00
#ifdef BUILD_ECORE_EVAS_X11
tab------------ SVN revision: 52896
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;
ecore_evas: let's be consistent and always report an error.
2014-09-30 09:19:15 -07:00
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
{
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
}
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -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
#endif
evilness... but it works. SVN revision: 21091
2006-03-08 00:02:55 -08:00
}
Export driver as engine_name. Also make sure it matches the names used by engines_get(). SVN revision: 37314
2008-10-29 12:31:05 -07:00
else if (!strcmp(ee->driver, "opengl_x11"))
evilness... but it works. SVN revision: 21091
2006-03-08 00:02:55 -08:00
{
Big change in configure.in, ecore_x and ecore_evas. Everything compile nicely after a make maintainer-clean, with xlib or xcb. e17 also has no problem. Please report any problem. Thanks * put xlib and xcb specific code in their own directories inside ecore_x * fix xcb logic check in autotools and ecore_evas * update configure.in for detection of ecore_evas with xlib and xcb support, update ecore_evas accordingly. Note that e17 needs a little fix after that, it will come in a few minutes SVN revision: 35188
2008-07-23 03:00:01 -07:00
#ifdef BUILD_ECORE_EVAS_OPENGL_X11
tab------------ SVN revision: 52896
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;
ecore_evas: let's be consistent and always report an error.
2014-09-30 09:19:15 -07:00
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
{
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
}
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -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
#endif
evilness... but it works. SVN revision: 21091
2006-03-08 00:02:55 -08:00
}
}
support argb targets for ecore_evas sw_x11 SVN revision: 21120
2006-03-08 19:51:43 -08:00
*/
evilness... but it works. SVN revision: 21091
2006-03-08 00:02:55 -08:00
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
static void
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
_ecore_evas_x_override_set(Ecore_Evas *ee, Eina_Bool on)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
if (ee->prop.override == on) return;
Fix bug ecore-evas for fb, buffer, sdl back-ends to ensure mouse is in on init (as events wont always give this) and focus is set on show if appropriate if no focus in/out events come from the back-end later Fix setting override state to only hide if it should be visible at that point in x back end support SVN revision: 65508
2011-11-21 21:51:06 -08:00
if (ee->should_be_visible) ecore_x_window_hide(ee->prop.window);
Let me introduce you to Ecore_Input. The idea is to share as much as possible event between all ecore graphic engine to ease porting of application and reduce the amount of specific code per engine. This patch does just that. All your application should continu to work has previously, if it's not the case please report any new behaviour regarding mouse and keyboard. SVN revision: 39505
2009-03-16 09:24:43 -07:00
ecore_x_window_override_set(ee->prop.window, on);
Fix bug ecore-evas for fb, buffer, sdl back-ends to ensure mouse is in on init (as events wont always give this) and focus is set on show if appropriate if no focus in/out events come from the back-end later Fix setting override state to only hide if it should be visible at that point in x back end support SVN revision: 65508
2011-11-21 21:51:06 -08:00
if (ee->should_be_visible) ecore_x_window_show(ee->prop.window);
Let me introduce you to Ecore_Input. The idea is to share as much as possible event between all ecore graphic engine to ease porting of application and reduce the amount of specific code per engine. This patch does just that. All your application should continu to work has previously, if it's not the case please report any new behaviour regarding mouse and keyboard. SVN revision: 39505
2009-03-16 09:24:43 -07:00
if (ee->prop.focused) ecore_x_window_focus(ee->prop.window);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
ee->prop.override = on;
}
fix ecore-evas to not ignore maximized requests in x11. SVN revision: 74883
2012-08-05 02:00:08 -07:00
static void
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
_ecore_evas_x_maximized_set(Ecore_Evas *ee, Eina_Bool on)
fix ecore-evas to not ignore maximized requests in x11. SVN revision: 74883
2012-08-05 02:00:08 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
fix ecore-evas to not ignore maximized requests in x11. SVN revision: 74883
2012-08-05 02:00:08 -07:00
if (ee->prop.maximized == on) return;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->state.maximized_h = 1;
edata->state.maximized_v = 1;
oh and also fix up properties to not update until event comes back from x telling us they did. :) SVN revision: 82558
2013-01-10 03:53:07 -08:00
// ee->prop.maximized = on;
fix ecore-evas to not ignore maximized requests in x11. SVN revision: 74883
2012-08-05 02:00:08 -07:00
if (ee->should_be_visible)
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ecore_x_netwm_state_request_send(ee->prop.window, edata->win_root,
fix ecore-evas to not ignore maximized requests in x11. SVN revision: 74883
2012-08-05 02:00:08 -07:00
ECORE_X_WINDOW_STATE_MAXIMIZED_VERT, -1, on);
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ecore_x_netwm_state_request_send(ee->prop.window, edata->win_root,
fix ecore-evas to not ignore maximized requests in x11. SVN revision: 74883
2012-08-05 02:00:08 -07:00
ECORE_X_WINDOW_STATE_MAXIMIZED_HORZ, -1, on);
}
else
_ecore_evas_x_state_update(ee);
}
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
static void
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
_ecore_evas_x_fullscreen_set(Ecore_Evas *ee, Eina_Bool on)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
if (ee->prop.fullscreen == on) return;
Let the WM decide how fullscreening is done. SVN revision: 24582
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 */
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->state.fullscreen = on;
evilness... but it works. SVN revision: 21091
2006-03-08 00:02:55 -08:00
if (ee->should_be_visible)
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ecore_x_netwm_state_request_send(ee->prop.window, edata->win_root,
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
ECORE_X_WINDOW_STATE_FULLSCREEN, -1, on);
till's stick patch SVN revision: 7901
2003-11-15 18:29:10 -08:00
else
Let the WM decide how fullscreening is done. SVN revision: 24582
2006-08-12 03:16:53 -07:00
_ecore_evas_x_state_update(ee);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
From: Gwanglim Lee <gl77.lee@samsung.com> Subject: Re: Re: Re: [E-devel] [RFC] Virtual desktop window profile I've attached 4th patch. May the 4th be with you. ecore patch has been merged with efl and all files are based on r80123. Thanks & Regards, Gwanglim ------- Original Message ------- Sender : Daniel Juyung Seo<seojuyung2@gmail.com> Date : 2012-12-04 01:55 (GMT+09:00) Title : Re: Re: [E-devel] [RFC] Virtual desktop window profile It looks ok to me. Sorry but can you re-generate the patch according to the recent ecore merge to efl single tree? Daniel Juyung Seo (SeoZ) On Thu, Nov 29, 2012 at 12:29 AM, Gwanglim Lee <gl77.lee@samsung.com> wrote: Dear Raster and Daniel Juyung Seo, I've attached 3rd patches and test_config according to your reviews. These are based on r79782. [elementary & ecore] 1. "profile,set" -> "profile,changed" - done 2. spaces after EINA_LIST_FOREACH - done 3. variable type - keep 4. author - done 5. removing deprecated marking in patch - done 6. add elm_win_available_profiles_get to test_config for the debugging purpose - done 7. check whether a given profile is present in an available profiles. otherwise window profile will be one of the item in available profiles. - newly added thing to the elm_win 8. merge with EO - done. :( Any comments would be appreciated. SVN revision: 80214
2012-12-04 22:48:46 -08:00
static void
_ecore_evas_x_profile_set(Ecore_Evas *ee, const char *profile)
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
From: Gwanglim Lee <gl77.lee@samsung.com> Subject: Re: Re: Re: [E-devel] [RFC] Virtual desktop window profile I've attached 4th patch. May the 4th be with you. ecore patch has been merged with efl and all files are based on r80123. Thanks & Regards, Gwanglim ------- Original Message ------- Sender : Daniel Juyung Seo<seojuyung2@gmail.com> Date : 2012-12-04 01:55 (GMT+09:00) Title : Re: Re: [E-devel] [RFC] Virtual desktop window profile It looks ok to me. Sorry but can you re-generate the patch according to the recent ecore merge to efl single tree? Daniel Juyung Seo (SeoZ) On Thu, Nov 29, 2012 at 12:29 AM, Gwanglim Lee <gl77.lee@samsung.com> wrote: Dear Raster and Daniel Juyung Seo, I've attached 3rd patches and test_config according to your reviews. These are based on r79782. [elementary & ecore] 1. "profile,set" -> "profile,changed" - done 2. spaces after EINA_LIST_FOREACH - done 3. variable type - keep 4. author - done 5. removing deprecated marking in patch - done 6. add elm_win_available_profiles_get to test_config for the debugging purpose - done 7. check whether a given profile is present in an available profiles. otherwise window profile will be one of the item in available profiles. - newly added thing to the elm_win 8. merge with EO - done. :( Any comments would be appreciated. SVN revision: 80214
2012-12-04 22:48:46 -08:00
_ecore_evas_window_profile_free(ee);
ee->prop.profile.name = NULL;
if (profile)
ee->prop.profile.name = (char *)eina_stringshare_add(profile);
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->profile.change = 1;
From: Gwanglim Lee <gl77.lee@samsung.com> Subject: Re: Re: Re: [E-devel] [RFC] Virtual desktop window profile I've attached 4th patch. May the 4th be with you. ecore patch has been merged with efl and all files are based on r80123. Thanks & Regards, Gwanglim ------- Original Message ------- Sender : Daniel Juyung Seo<seojuyung2@gmail.com> Date : 2012-12-04 01:55 (GMT+09:00) Title : Re: Re: [E-devel] [RFC] Virtual desktop window profile It looks ok to me. Sorry but can you re-generate the patch according to the recent ecore merge to efl single tree? Daniel Juyung Seo (SeoZ) On Thu, Nov 29, 2012 at 12:29 AM, Gwanglim Lee <gl77.lee@samsung.com> wrote: Dear Raster and Daniel Juyung Seo, I've attached 3rd patches and test_config according to your reviews. These are based on r79782. [elementary & ecore] 1. "profile,set" -> "profile,changed" - done 2. spaces after EINA_LIST_FOREACH - done 3. variable type - keep 4. author - done 5. removing deprecated marking in patch - done 6. add elm_win_available_profiles_get to test_config for the debugging purpose - done 7. check whether a given profile is present in an available profiles. otherwise window profile will be one of the item in available profiles. - newly added thing to the elm_win 8. merge with EO - done. :( Any comments would be appreciated. SVN revision: 80214
2012-12-04 22:48:46 -08:00
_ecore_evas_x_window_profile_set(ee);
}
Ecore_Evas Merge Tizen changes to upstream EFL. SVN revision: 73206
2012-07-03 00:44:17 -07:00
static void
_ecore_evas_x_profiles_set(Ecore_Evas *ee, const char **plist, int n)
{
From: Gwanglim Lee <gl77.lee@samsung.com> Subject: Re: Re: Re: [E-devel] [RFC] Virtual desktop window profile I've attached 4th patch. May the 4th be with you. ecore patch has been merged with efl and all files are based on r80123. Thanks & Regards, Gwanglim ------- Original Message ------- Sender : Daniel Juyung Seo<seojuyung2@gmail.com> Date : 2012-12-04 01:55 (GMT+09:00) Title : Re: Re: [E-devel] [RFC] Virtual desktop window profile It looks ok to me. Sorry but can you re-generate the patch according to the recent ecore merge to efl single tree? Daniel Juyung Seo (SeoZ) On Thu, Nov 29, 2012 at 12:29 AM, Gwanglim Lee <gl77.lee@samsung.com> wrote: Dear Raster and Daniel Juyung Seo, I've attached 3rd patches and test_config according to your reviews. These are based on r79782. [elementary & ecore] 1. "profile,set" -> "profile,changed" - done 2. spaces after EINA_LIST_FOREACH - done 3. variable type - keep 4. author - done 5. removing deprecated marking in patch - done 6. add elm_win_available_profiles_get to test_config for the debugging purpose - done 7. check whether a given profile is present in an available profiles. otherwise window profile will be one of the item in available profiles. - newly added thing to the elm_win 8. merge with EO - done. :( Any comments would be appreciated. SVN revision: 80214
2012-12-04 22:48:46 -08:00
int i;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
From: Gwanglim Lee <gl77.lee@samsung.com> Subject: Re: Re: Re: [E-devel] [RFC] Virtual desktop window profile I've attached 4th patch. May the 4th be with you. ecore patch has been merged with efl and all files are based on r80123. Thanks & Regards, Gwanglim ------- Original Message ------- Sender : Daniel Juyung Seo<seojuyung2@gmail.com> Date : 2012-12-04 01:55 (GMT+09:00) Title : Re: Re: [E-devel] [RFC] Virtual desktop window profile It looks ok to me. Sorry but can you re-generate the patch according to the recent ecore merge to efl single tree? Daniel Juyung Seo (SeoZ) On Thu, Nov 29, 2012 at 12:29 AM, Gwanglim Lee <gl77.lee@samsung.com> wrote: Dear Raster and Daniel Juyung Seo, I've attached 3rd patches and test_config according to your reviews. These are based on r79782. [elementary & ecore] 1. "profile,set" -> "profile,changed" - done 2. spaces after EINA_LIST_FOREACH - done 3. variable type - keep 4. author - done 5. removing deprecated marking in patch - done 6. add elm_win_available_profiles_get to test_config for the debugging purpose - done 7. check whether a given profile is present in an available profiles. otherwise window profile will be one of the item in available profiles. - newly added thing to the elm_win 8. merge with EO - done. :( Any comments would be appreciated. SVN revision: 80214
2012-12-04 22:48:46 -08:00
_ecore_evas_window_available_profiles_free(ee);
ee->prop.profile.available_list = NULL;
if ((plist) && (n >= 1))
{
ee->prop.profile.available_list = calloc(n, sizeof(char *));
if (ee->prop.profile.available_list)
{
for (i = 0; i < n; i++)
ee->prop.profile.available_list[i] = (char *)eina_stringshare_add(plist[i]);
ee->prop.profile.count = n;
}
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->profile.available = 1;
From: Gwanglim Lee <gl77.lee@samsung.com> Subject: Re: Re: Re: [E-devel] [RFC] Virtual desktop window profile I've attached 4th patch. May the 4th be with you. ecore patch has been merged with efl and all files are based on r80123. Thanks & Regards, Gwanglim ------- Original Message ------- Sender : Daniel Juyung Seo<seojuyung2@gmail.com> Date : 2012-12-04 01:55 (GMT+09:00) Title : Re: Re: [E-devel] [RFC] Virtual desktop window profile It looks ok to me. Sorry but can you re-generate the patch according to the recent ecore merge to efl single tree? Daniel Juyung Seo (SeoZ) On Thu, Nov 29, 2012 at 12:29 AM, Gwanglim Lee <gl77.lee@samsung.com> wrote: Dear Raster and Daniel Juyung Seo, I've attached 3rd patches and test_config according to your reviews. These are based on r79782. [elementary & ecore] 1. "profile,set" -> "profile,changed" - done 2. spaces after EINA_LIST_FOREACH - done 3. variable type - keep 4. author - done 5. removing deprecated marking in patch - done 6. add elm_win_available_profiles_get to test_config for the debugging purpose - done 7. check whether a given profile is present in an available profiles. otherwise window profile will be one of the item in available profiles. - newly added thing to the elm_win 8. merge with EO - done. :( Any comments would be appreciated. SVN revision: 80214
2012-12-04 22:48:46 -08:00
_ecore_evas_x_window_profile_set(ee);
Ecore_Evas Merge Tizen changes to upstream EFL. SVN revision: 73206
2012-07-03 00:44:17 -07:00
}
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
static void
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
_avoid_damage_do(Ecore_Evas *ee, int on)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
Evas_Engine_Info_Software_X11 *einfo;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
ee->prop.avoid_damage = on;
einfo = (Evas_Engine_Info_Software_X11 *)evas_engine_info_get(ee->evas);
if (einfo)
Ecore_Evas now supports software_16_x11 engine. SVN revision: 30424
2007-06-21 15:49:36 -07:00
{
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
if (ee->prop.avoid_damage)
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
edata->pmap = ecore_x_pixmap_new(ee->prop.window, ee->w, ee->h, einfo->info.depth);
edata->gc = ecore_x_gc_new(edata->pmap, 0, NULL);
einfo->info.drawable = edata->pmap;
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
}
ecore_evas - applied macro to check rotation state. also, let the potrait compare on the higher priority. if you can suggest better macro name, then please modify it.
2014-01-18 05:26:10 -08:00
if (ECORE_EVAS_PORTRAIT(ee))
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
ecore_evas - applied macro to check rotation state. also, let the potrait compare on the higher priority. if you can suggest better macro name, then please modify it.
2014-01-18 05:26:10 -08:00
else
evas_damage_rectangle_add(ee->evas, 0, 0, ee->h, ee->w);
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
if (ee->prop.avoid_damage == ECORE_EVAS_AVOID_DAMAGE_BUILT_IN)
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
edata->using_bg_pixmap = 1;
ecore_x_window_pixmap_set(ee->prop.window, edata->pmap);
ecore_x_window_area_expose(ee->prop.window, 0, 0, ee->w, ee->h);
}
if (edata->direct_resize)
{
/* Turn this off for now
edata->using_bg_pixmap = 1;
ecore_x_window_pixmap_set(ee->prop.window, edata->pmap);
*/
}
}
else
{
if (edata->pmap) ecore_x_pixmap_free(edata->pmap);
if (edata->gc) ecore_x_gc_free(edata->gc);
if (edata->using_bg_pixmap)
{
ecore_x_window_pixmap_set(ee->prop.window, 0);
edata->using_bg_pixmap = 0;
ecore_x_window_area_expose(ee->prop.window, 0, 0, ee->w, ee->h);
}
edata->pmap = 0;
edata->gc = 0;
einfo->info.drawable = ee->prop.window;
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
{
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
}
}
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
}
rename 'x11' to 'xlib' for software x11 based engines when it makes sense SVN revision: 41330
2009-07-14 14:18:27 -07:00
#endif /* BUILD_ECORE_EVAS_SOFTWARE_X11 */
ecore-evas: Async render SVN revision: 81283
2012-12-18 08:27:26 -08:00
}
static void
_ecore_evas_x_avoid_damage_set(Ecore_Evas *ee, int on)
{
if (ee->prop.avoid_damage == on) return;
if (!strcmp(ee->driver, "opengl_x11")) return;
if (!strcmp(ee->driver, "software_x11"))
{
if (ee->in_async_render)
{
ee->delayed.avoid_damage = on;
return;
}
_avoid_damage_do(ee, on);
Ecore_Evas now supports software_16_x11 engine. SVN revision: 30424
2007-06-21 15:49:36 -07:00
}
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
Ecore_Evas: introduce ecore_evas_screen_geometry_get() This common interface allows engines to provide whole screen information to users. Right now just X is implemented and it queries the size of the default screen. I hope this is fine. SVN revision: 59761
2011-05-27 12:31:11 -07:00
static void
Ecore: __UNUSED__ --> EINA_UNUSED SVN revision: 79649
2012-11-25 01:55:32 -08:00
_ecore_evas_x_screen_geometry_get(const Ecore_Evas *ee EINA_UNUSED, int *x, int *y, int *w, int *h)
Ecore_Evas: introduce ecore_evas_screen_geometry_get() This common interface allows engines to provide whole screen information to users. Right now just X is implemented and it queries the size of the default screen. I hope this is fine. SVN revision: 59761
2011-05-27 12:31:11 -07:00
{
ecore evas gets func to get dpi and frix x screen size get. SVN revision: 73341
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;
use e17 zone property first before using randr to find screen - more correct. SVN revision: 75491
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)
{
fix crashing in ecore_evas when x/y/w/h is not passed to screen_geometry_get SVN revision: 75522
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];
use e17 zone property first before using randr to find screen - more correct. SVN revision: 75491
2012-08-21 01:06:53 -07:00
return;
}
ecore evas gets func to get dpi and frix x screen size get. SVN revision: 73341
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);
Ecore_Evas: introduce ecore_evas_screen_geometry_get() This common interface allows engines to provide whole screen information to users. Right now just X is implemented and it queries the size of the default screen. I hope this is fine. SVN revision: 59761
2011-05-27 12:31:11 -07:00
}
Add functions to X engine for ecore_evas_pointer_xy_get and ecore_evas_pointer_warp Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-08 02:57:00 -07:00
static void
_ecore_evas_x_pointer_xy_get(const Ecore_Evas *ee, Evas_Coord *x, Evas_Coord *y)
{
if (ee->prop.window)
ecore_x_pointer_xy_get(ee->prop.window, x, y);
}
static Eina_Bool
_ecore_evas_x_pointer_warp(const Ecore_Evas *ee, Evas_Coord x, Evas_Coord y)
{
return ecore_x_pointer_warp(ee->prop.window, x, y);
}
ecore_evas: added window manager rotation to manage the rotation of windows by the WM. Summary: The window manager rotation allows the WM to controls the rotation of application windows. It is designed to support synchronized rotation for the multiple application windows at same time. Reviewers: raster, seoz, cedric, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D529
2014-02-08 16:46:51 -08:00
static void
_ecore_evas_x_wm_rot_preferred_rotation_set(Ecore_Evas *ee, int rot)
{
if (ee->prop.wm_rot.supported)
{
if (!ee->prop.wm_rot.app_set)
{
ecore_x_e_window_rotation_app_set(ee->prop.window, EINA_TRUE);
ee->prop.wm_rot.app_set = EINA_TRUE;
}
ecore_x_e_window_rotation_preferred_rotation_set(ee->prop.window, rot);
ee->prop.wm_rot.preferred_rot = rot;
}
}
static void
_ecore_evas_x_wm_rot_available_rotations_set(Ecore_Evas *ee, const int *rots, unsigned int count)
{
if (ee->prop.wm_rot.supported)
{
if (!ee->prop.wm_rot.app_set)
{
ecore_x_e_window_rotation_app_set(ee->prop.window, EINA_TRUE);
ee->prop.wm_rot.app_set = EINA_TRUE;
}
if (ee->prop.wm_rot.available_rots)
{
free(ee->prop.wm_rot.available_rots);
ee->prop.wm_rot.available_rots = NULL;
}
ee->prop.wm_rot.count = 0;
if (count > 0)
{
ee->prop.wm_rot.available_rots = calloc(count, sizeof(int));
if (!ee->prop.wm_rot.available_rots) return;
memcpy(ee->prop.wm_rot.available_rots, rots, sizeof(int) * count);
}
ee->prop.wm_rot.count = count;
ecore_x_e_window_rotation_available_rotations_set(ee->prop.window, rots, count);
}
}
static void
_ecore_evas_x_wm_rot_manual_rotation_done_set(Ecore_Evas *ee, Eina_Bool set)
{
ee->prop.wm_rot.manual_mode.set = set;
}
static void
_ecore_evas_x_wm_rot_manual_rotation_done(Ecore_Evas *ee)
{
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
if ((ee->prop.wm_rot.supported) &&
(ee->prop.wm_rot.app_set) &&
(ee->prop.wm_rot.manual_mode.set))
{
if (ee->prop.wm_rot.manual_mode.wait_for_done)
{
if (ee->prop.wm_rot.manual_mode.timer)
ecore_timer_del(ee->prop.wm_rot.manual_mode.timer);
ee->prop.wm_rot.manual_mode.timer = NULL;
if (edata->wm_rot.manual_mode_job)
ecore_job_del(edata->wm_rot.manual_mode_job);
edata->wm_rot.manual_mode_job = ecore_job_add
(_ecore_evas_x_wm_rot_manual_rotation_done_job, ee);
}
}
}
static Eina_Bool
_ecore_evas_x_wm_rot_manual_rotation_done_timeout(void *data)
{
Ecore_Evas *ee = data;
ee->prop.wm_rot.manual_mode.timer = NULL;
_ecore_evas_x_wm_rot_manual_rotation_done(ee);
return ECORE_CALLBACK_CANCEL;
}
static void
_ecore_evas_x_wm_rot_manual_rotation_done_timeout_update(Ecore_Evas *ee)
{
if (ee->prop.wm_rot.manual_mode.timer)
ecore_timer_del(ee->prop.wm_rot.manual_mode.timer);
ee->prop.wm_rot.manual_mode.timer = ecore_timer_add
(4.0f, _ecore_evas_x_wm_rot_manual_rotation_done_timeout, ee);
}
ecore_evas: Added support for window auxiliary hint Summary: The window auxiliary hint is the value which is used to decide which actions should be made available to the user by the WM. If you want to set specific hint to your window, then you should check whether it exists in the supported auxiliary hints that are registered in the root window by the window manager. Once you've added an auxiliary hint, you can get a new ID which is used to change value and delete hint. The window manager sends the response message to the application on receiving auxiliary hint change event. A list of auxiliary hint within the Ecore_Evas has this format: ID:HINT:VALUE,ID:HINT:VALUE,... Reviewers: raster, cedric, seoz, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D543
2014-02-27 14:20:01 -08:00
static void
_ecore_evas_x_aux_hints_set(Ecore_Evas *ee, const char *hints)
{
if (hints)
ecore_x_window_prop_property_set
(ee->prop.window, ECORE_X_ATOM_E_WINDOW_AUX_HINT,
ECORE_X_ATOM_STRING, 8, (void *)hints, strlen(hints) + 1);
else
ecore_x_window_prop_property_del
(ee->prop.window, ECORE_X_ATOM_E_WINDOW_AUX_HINT);
}
clean up engines - put idle entere handlign in core. same with lists. quyartz looks broken to me. sdl looks like it could be much more complete - like multiple sdl windows/instances. anyway - allow rendering to be manual. SVN revision: 44938
2010-01-06 21:29:06 -08:00
static Ecore_Evas_Engine_Func _ecore_x_engine_func =
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
_ecore_evas_x_free,
Fix formating ... Wow, how did this get sooo screwed ? :( Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-08 02:16:09 -07:00
NULL,
NULL,
NULL,
NULL,
_ecore_evas_x_callback_delete_request_set,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
_ecore_evas_x_move,
_ecore_evas_x_managed_move,
_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,
_ecore_evas_x_activate,
_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,
_ecore_evas_x_object_cursor_set,
_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,
_ecore_evas_x_maximized_set,
_ecore_evas_x_fullscreen_set,
_ecore_evas_x_avoid_damage_set,
_ecore_evas_x_withdrawn_set,
_ecore_evas_x_sticky_set,
_ecore_evas_x_ignore_events_set,
_ecore_evas_x_alpha_set,
_ecore_evas_x_transparent_set,
_ecore_evas_x_profiles_set,
_ecore_evas_x_profile_set,
_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,
NULL, // render
_ecore_evas_x_screen_geometry_get,
_ecore_evas_x_screen_dpi_get,
NULL,
Add functions to X engine for ecore_evas_pointer_xy_get and ecore_evas_pointer_warp Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-08 02:57:00 -07:00
NULL, //fn_msg_send
_ecore_evas_x_pointer_xy_get,
ecore_evas: added window manager rotation to manage the rotation of windows by the WM. Summary: The window manager rotation allows the WM to controls the rotation of application windows. It is designed to support synchronized rotation for the multiple application windows at same time. Reviewers: raster, seoz, cedric, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D529
2014-02-08 16:46:51 -08:00
_ecore_evas_x_pointer_warp,
_ecore_evas_x_wm_rot_preferred_rotation_set,
_ecore_evas_x_wm_rot_available_rotations_set,
_ecore_evas_x_wm_rot_manual_rotation_done_set,
ecore_evas: Added support for window auxiliary hint Summary: The window auxiliary hint is the value which is used to decide which actions should be made available to the user by the WM. If you want to set specific hint to your window, then you should check whether it exists in the supported auxiliary hints that are registered in the root window by the window manager. Once you've added an auxiliary hint, you can get a new ID which is used to change value and delete hint. The window manager sends the response message to the application on receiving auxiliary hint change event. A list of auxiliary hint within the Ecore_Evas has this format: ID:HINT:VALUE,ID:HINT:VALUE,... Reviewers: raster, cedric, seoz, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D543
2014-02-27 14:20:01 -08:00
_ecore_evas_x_wm_rot_manual_rotation_done,
_ecore_evas_x_aux_hints_set
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
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
Fix common misspellings Following misspellings were fixed: alledgedly->allegedly cant->can't carefull->careful consistant->consistent currenly->currently dependancy->dependency descripters->descriptors doesnt->doesn't dosen't->doesn't existant->existent exmaple->example inbetween->between independant->independent isnt->isn't mroe->more neccessary->necessary occured->occurred occurence->occurrence parrallel->parallel particualr->particular preceeding->preceding recieved->received recieves->receives seperate->separate substraction->subtraction succesfully->successfully successfull->successful sucess->success supress->suppress usefull->useful witht->with SVN revision: 51986
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
*/
remove 8bpp evas engine support from e3core-evas as its now gone from evas. SVN revision: 78027
2012-10-15 19:54:05 -07:00
#if defined (BUILD_ECORE_EVAS_SOFTWARE_X11) || defined (BUILD_ECORE_EVAS_OPENGL_X11)
Add code for ecore_evas_<engine>_pixmap_new/get functions. - Add "pixmap" structure to engine_data. - Free the front and back pixmaps when the ecore_evas gets freed. - On resize, drop the backing pixmap if size is different. - Before we render, check pixmap size vs EE size and create new backing pixmap if needed. - After we have rendered into the backing pixmap, flip it to the front so that any calls to "pixmap_get" will return the proper one. - Add pixmap_new_internal code (the actual guts for all this) NB: These can be used to create an internally double-buffered ecore_evas that renders to a pixmap (not a window). Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-05 02:38:43 -07:00
static void
_ecore_evas_x_render_pre(void *data, Evas *e EINA_UNUSED, void *event_info EINA_UNUSED)
{
Ecore_Evas *ee = data;
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
/* printf("Ecore_Evas Render Pre\n"); */
/* printf("\tPixman Size: %d %d\n", edata->pixmap.w, edata->pixmap.h); */
/* printf("\tEE Size: %d %d\n", ee->w, ee->h); */
/* before rendering to the back buffer pixmap, we should check the
* size. If the back buffer is not the proper size, destroy it and
* create a new one at the proper size */
if ((edata->pixmap.w != ee->w) || (edata->pixmap.h != ee->h))
{
/* free the backing pixmap */
if (edata->pixmap.back)
ecore_x_pixmap_free(edata->pixmap.back);
edata->pixmap.back =
ecore_x_pixmap_new(edata->win_root, ee->w, ee->h,
edata->pixmap.depth);
edata->pixmap.w = ee->w;
edata->pixmap.h = ee->h;
if (!strcmp(ee->driver, "software_x11"))
{
# ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
Evas_Engine_Info_Software_X11 *einfo;
einfo = (Evas_Engine_Info_Software_X11 *)evas_engine_info_get(ee->evas);
if (einfo)
{
einfo->info.drawable = edata->pixmap.back;
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
{
ERR("evas_engine_info_set() init engine '%s' failed.",
ee->driver);
}
}
# endif
}
else if (!strcmp(ee->driver, "opengl_x11"))
{
# ifdef BUILD_ECORE_EVAS_OPENGL_X11
Evas_Engine_Info_GL_X11 *einfo;
einfo = (Evas_Engine_Info_GL_X11 *)evas_engine_info_get(ee->evas);
if (einfo)
{
einfo->info.drawable = edata->pixmap.back;
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
{
ERR("evas_engine_info_set() init engine '%s' failed.",
ee->driver);
}
}
# endif
}
}
}
more work on the sync stuff... looking good now. SVN revision: 45772
2010-02-01 06:13:48 -08:00
static void
Ecore: __UNUSED__ --> EINA_UNUSED SVN revision: 79649
2012-11-25 01:55:32 -08:00
_ecore_evas_x_flush_pre(void *data, Evas *e EINA_UNUSED, void *event_info EINA_UNUSED)
more work on the sync stuff... looking good now. SVN revision: 45772
2010-02-01 06:13:48 -08:00
{
Ecore_Evas *ee = data;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
more work on the sync stuff... looking good now. SVN revision: 45772
2010-02-01 06:13:48 -08:00
if (ee->no_comp_sync) return;
if (!_ecore_evas_app_comp_sync) return;
ecore_evas_x: Refactored by reducing cascaded if statements. Just return the function. Do not create unnecessary cascaded if statements it makes indentation depth deeper.
2014-01-08 06:29:40 -08:00
if (!edata->sync_counter) return;
if (!edata->sync_began) return;
edata->sync_val++;
if (!edata->sync_cancel)
more work on the sync stuff... looking good now. SVN revision: 45772
2010-02-01 06:13:48 -08:00
{
ecore_evas_x: Refactored by reducing cascaded if statements. Just return the function. Do not create unnecessary cascaded if statements it makes indentation depth deeper.
2014-01-08 06:29:40 -08:00
if (!ee->semi_sync)
ecore_x_sync_counter_val_wait(edata->sync_counter,
edata->sync_val);
more work on the sync stuff... looking good now. SVN revision: 45772
2010-02-01 06:13:48 -08:00
}
}
static void
Ecore: __UNUSED__ --> EINA_UNUSED SVN revision: 79649
2012-11-25 01:55:32 -08:00
_ecore_evas_x_flush_post(void *data, Evas *e EINA_UNUSED, void *event_info EINA_UNUSED)
more work on the sync stuff... looking good now. SVN revision: 45772
2010-02-01 06:13:48 -08:00
{
Ecore_Evas *ee = data;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
fix sync issue in 1 special event re-order case. booo! SVN revision: 51609
2010-08-24 02:26:34 -07:00
Add code for ecore_evas_<engine>_pixmap_new/get functions. - Add "pixmap" structure to engine_data. - Free the front and back pixmaps when the ecore_evas gets freed. - On resize, drop the backing pixmap if size is different. - Before we render, check pixmap size vs EE size and create new backing pixmap if needed. - After we have rendered into the backing pixmap, flip it to the front so that any calls to "pixmap_get" will return the proper one. - Add pixmap_new_internal code (the actual guts for all this) NB: These can be used to create an internally double-buffered ecore_evas that renders to a pixmap (not a window). Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-05 02:38:43 -07:00
if ((!ee->prop.window) && (edata->pixmap.back))
{
Remove prev_front pixmap from structure Use a local variable to hold previous front pixmap while swapping Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-11 00:50:25 -07:00
Ecore_X_Pixmap prev;
Add code for ecore_evas_<engine>_pixmap_new/get functions. - Add "pixmap" structure to engine_data. - Free the front and back pixmaps when the ecore_evas gets freed. - On resize, drop the backing pixmap if size is different. - Before we render, check pixmap size vs EE size and create new backing pixmap if needed. - After we have rendered into the backing pixmap, flip it to the front so that any calls to "pixmap_get" will return the proper one. - Add pixmap_new_internal code (the actual guts for all this) NB: These can be used to create an internally double-buffered ecore_evas that renders to a pixmap (not a window). Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-05 02:38:43 -07:00
/* printf("Ecore_Evas Flush Post\n"); */
/* printf("\tBack Pixmap: %d\n", edata->pixmap.back); */
/* printf("\tFront Pixmap: %d\n", edata->pixmap.front); */
/* done drawing to the back buffer. flip it to the front so that
* any calls to "fetch pixmap" will return the front buffer already
* pre-rendered */
/* record the current front buffer */
Remove prev_front pixmap from structure Use a local variable to hold previous front pixmap while swapping Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-11 00:50:25 -07:00
prev = edata->pixmap.front;
Add code for ecore_evas_<engine>_pixmap_new/get functions. - Add "pixmap" structure to engine_data. - Free the front and back pixmaps when the ecore_evas gets freed. - On resize, drop the backing pixmap if size is different. - Before we render, check pixmap size vs EE size and create new backing pixmap if needed. - After we have rendered into the backing pixmap, flip it to the front so that any calls to "pixmap_get" will return the proper one. - Add pixmap_new_internal code (the actual guts for all this) NB: These can be used to create an internally double-buffered ecore_evas that renders to a pixmap (not a window). Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-05 02:38:43 -07:00
/* flip them */
edata->pixmap.front = edata->pixmap.back;
/* reassign back buffer to be the old front one */
Remove prev_front pixmap from structure Use a local variable to hold previous front pixmap while swapping Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-11 00:50:25 -07:00
edata->pixmap.back = prev;
Add code for ecore_evas_<engine>_pixmap_new/get functions. - Add "pixmap" structure to engine_data. - Free the front and back pixmaps when the ecore_evas gets freed. - On resize, drop the backing pixmap if size is different. - Before we render, check pixmap size vs EE size and create new backing pixmap if needed. - After we have rendered into the backing pixmap, flip it to the front so that any calls to "pixmap_get" will return the proper one. - Add pixmap_new_internal code (the actual guts for all this) NB: These can be used to create an internally double-buffered ecore_evas that renders to a pixmap (not a window). Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-05 02:38:43 -07:00
/* update evas drawable */
if (!strcmp(ee->driver, "software_x11"))
{
# ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
Evas_Engine_Info_Software_X11 *einfo;
einfo = (Evas_Engine_Info_Software_X11 *)evas_engine_info_get(ee->evas);
if (einfo)
{
einfo->info.drawable = edata->pixmap.back;
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
{
ERR("evas_engine_info_set() init engine '%s' failed.",
ee->driver);
}
}
# endif
}
else if (!strcmp(ee->driver, "opengl_x11"))
{
# ifdef BUILD_ECORE_EVAS_OPENGL_X11
Evas_Engine_Info_GL_X11 *einfo;
einfo = (Evas_Engine_Info_GL_X11 *)evas_engine_info_get(ee->evas);
if (einfo)
{
einfo->info.drawable = edata->pixmap.back;
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
{
ERR("evas_engine_info_set() init engine '%s' failed.",
ee->driver);
}
}
# endif
}
}
Ecore_Evas Merge Tizen changes to upstream EFL. SVN revision: 73206
2012-07-03 00:44:17 -07:00
if ((!ee->no_comp_sync) && (_ecore_evas_app_comp_sync) &&
ecore_evas_x: Check 1 for gl_sync_draw_done instead of 0 before sending comp_sync_draw_size_done. There was a corner case which gl_sync_draw_done is set to -1. So send comp_sync_draw_size_done when the gl_sync_draw_done is not 1. It can be -1 or 0. This is a manual cherry-pick from tizen.org. Thanks to original author Jiyoun Park. commit 4be6c821df4ccd418dbe44f7e6fecbcd7dd66d74 Author: Jiyoun Park <jy0703.park@samsung.com> Date: Thu Jul 4 18:04:11 2013 +0900 fix lockup issue (N_SE-44214) because this sync draw done cannot be send Change-Id: Id05978e925d5b44d6ca9af0a1684bbb255b9ec5b
2014-01-08 06:24:50 -08:00
(ee->gl_sync_draw_done != 1))
add new version of efl sync proto between comp and client. SVN revision: 58220
2011-03-31 01:13:14 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (edata->sync_counter)
add new version of efl sync proto between comp and client. SVN revision: 58220
2011-03-31 01:13:14 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (edata->sync_began)
add new version of efl sync proto between comp and client. SVN revision: 58220
2011-03-31 01:13:14 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (!edata->sync_cancel)
add new version of efl sync proto between comp and client. SVN revision: 58220
2011-03-31 01:13:14 -07:00
{
Add code for ecore_evas_<engine>_pixmap_new/get functions. - Add "pixmap" structure to engine_data. - Free the front and back pixmaps when the ecore_evas gets freed. - On resize, drop the backing pixmap if size is different. - Before we render, check pixmap size vs EE size and create new backing pixmap if needed. - After we have rendered into the backing pixmap, flip it to the front so that any calls to "pixmap_get" will return the proper one. - Add pixmap_new_internal code (the actual guts for all this) NB: These can be used to create an internally double-buffered ecore_evas that renders to a pixmap (not a window). Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-05 02:38:43 -07:00
if (ee->prop.window)
{
ecore_x_e_comp_sync_draw_size_done_send
(edata->win_root, ee->prop.window, ee->w, ee->h);
}
add new version of efl sync proto between comp and client. SVN revision: 58220
2011-03-31 01:13:14 -07:00
}
}
}
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (edata->netwm_sync_set)
ecore-evas: feature++ : support netm sync protocol for clients SVN revision: 58198
2011-03-30 03:10:04 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ecore_x_sync_counter_2_set(edata->netwm_sync_counter,
edata->netwm_sync_val_hi,
edata->netwm_sync_val_lo);
edata->netwm_sync_set = 0;
ecore-evas: feature++ : support netm sync protocol for clients SVN revision: 58198
2011-03-30 03:10:04 -07:00
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (edata->profile.done)
From: Gwanglim Lee <gl77.lee@samsung.com> Subject: Re: Re: Re: [E-devel] [RFC] Virtual desktop window profile I've attached 4th patch. May the 4th be with you. ecore patch has been merged with efl and all files are based on r80123. Thanks & Regards, Gwanglim ------- Original Message ------- Sender : Daniel Juyung Seo<seojuyung2@gmail.com> Date : 2012-12-04 01:55 (GMT+09:00) Title : Re: Re: [E-devel] [RFC] Virtual desktop window profile It looks ok to me. Sorry but can you re-generate the patch according to the recent ecore merge to efl single tree? Daniel Juyung Seo (SeoZ) On Thu, Nov 29, 2012 at 12:29 AM, Gwanglim Lee <gl77.lee@samsung.com> wrote: Dear Raster and Daniel Juyung Seo, I've attached 3rd patches and test_config according to your reviews. These are based on r79782. [elementary & ecore] 1. "profile,set" -> "profile,changed" - done 2. spaces after EINA_LIST_FOREACH - done 3. variable type - keep 4. author - done 5. removing deprecated marking in patch - done 6. add elm_win_available_profiles_get to test_config for the debugging purpose - done 7. check whether a given profile is present in an available profiles. otherwise window profile will be one of the item in available profiles. - newly added thing to the elm_win 8. merge with EO - done. :( Any comments would be appreciated. SVN revision: 80214
2012-12-04 22:48:46 -08:00
{
Add code for ecore_evas_<engine>_pixmap_new/get functions. - Add "pixmap" structure to engine_data. - Free the front and back pixmaps when the ecore_evas gets freed. - On resize, drop the backing pixmap if size is different. - Before we render, check pixmap size vs EE size and create new backing pixmap if needed. - After we have rendered into the backing pixmap, flip it to the front so that any calls to "pixmap_get" will return the proper one. - Add pixmap_new_internal code (the actual guts for all this) NB: These can be used to create an internally double-buffered ecore_evas that renders to a pixmap (not a window). Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-05 02:38:43 -07:00
if (ee->prop.window)
{
ecore_x_e_window_profile_change_done_send
(edata->win_root, ee->prop.window, ee->prop.profile.name);
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->profile.done = 0;
From: Gwanglim Lee <gl77.lee@samsung.com> Subject: Re: Re: Re: [E-devel] [RFC] Virtual desktop window profile I've attached 4th patch. May the 4th be with you. ecore patch has been merged with efl and all files are based on r80123. Thanks & Regards, Gwanglim ------- Original Message ------- Sender : Daniel Juyung Seo<seojuyung2@gmail.com> Date : 2012-12-04 01:55 (GMT+09:00) Title : Re: Re: [E-devel] [RFC] Virtual desktop window profile It looks ok to me. Sorry but can you re-generate the patch according to the recent ecore merge to efl single tree? Daniel Juyung Seo (SeoZ) On Thu, Nov 29, 2012 at 12:29 AM, Gwanglim Lee <gl77.lee@samsung.com> wrote: Dear Raster and Daniel Juyung Seo, I've attached 3rd patches and test_config according to your reviews. These are based on r79782. [elementary & ecore] 1. "profile,set" -> "profile,changed" - done 2. spaces after EINA_LIST_FOREACH - done 3. variable type - keep 4. author - done 5. removing deprecated marking in patch - done 6. add elm_win_available_profiles_get to test_config for the debugging purpose - done 7. check whether a given profile is present in an available profiles. otherwise window profile will be one of the item in available profiles. - newly added thing to the elm_win 8. merge with EO - done. :( Any comments would be appreciated. SVN revision: 80214
2012-12-04 22:48:46 -08:00
}
ecore_evas: added window manager rotation to manage the rotation of windows by the WM. Summary: The window manager rotation allows the WM to controls the rotation of application windows. It is designed to support synchronized rotation for the multiple application windows at same time. Reviewers: raster, seoz, cedric, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D529
2014-02-08 16:46:51 -08:00
if ((ee->prop.wm_rot.supported) &&
(edata->wm_rot.done))
{
if (!ee->prop.wm_rot.manual_mode.set)
{
ecore_x_e_window_rotation_change_done_send
(edata->win_root, ee->prop.window, ee->rotation, ee->w, ee->h);
edata->wm_rot.done = 0;
}
}
more work on the sync stuff... looking good now. SVN revision: 45772
2010-02-01 06:13:48 -08:00
}
* ecore_evas_x: Fix build without X. SVN revision: 45838
2010-02-03 08:05:25 -08:00
#endif
more work on the sync stuff... looking good now. SVN revision: 45772
2010-02-01 06:13:48 -08:00
rename 'x11' to 'xlib' for software x11 based engines when it makes sense SVN revision: 41330
2009-07-14 14:18:27 -07:00
#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
and yet more warning removal SVN revision: 19568
2006-01-06 10:46:30 -08:00
EAPI Ecore_Evas *
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ecore_evas_software_x11_new_internal(const char *disp_name, Ecore_X_Window parent,
int x, int y, int w, int h)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
Evas_Engine_Info_Software_X11 *einfo;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Interface_X11 *iface;
Ecore_Evas_Interface_Software_X11 *siface;
Ecore_Evas_Engine_Data_X11 *edata;
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
Ecore_Evas *ee;
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
int argb = 0, rmethod;
support REDRAW_DEBUg env var SVN revision: 18188
2005-11-01 01:49:12 -08:00
static int redraw_debug = -1;
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
char *id = NULL;
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
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;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata = calloc(1, sizeof(Ecore_Evas_Engine_Data_X11));
if (!edata)
{
free(ee);
return NULL;
}
ee->engine.data = edata;
iface = _ecore_evas_x_interface_x11_new();
siface = _ecore_evas_x_interface_software_x11_new();
ee->engine.ifaces = eina_list_append(ee->engine.ifaces, iface);
ee->engine.ifaces = eina_list_append(ee->engine.ifaces, siface);
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
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
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
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
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
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
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
evilness... but it works. SVN revision: 21091
2006-03-08 00:02:55 -08:00
ee->driver = "software_x11";
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
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;
hmm fix resize before change alpha... SVN revision: 46579
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
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
ee->prop.max.w = 32767;
ee->prop.max.h = 32767;
ee->prop.layer = 4;
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
ee->prop.request_pos = EINA_FALSE;
initialize to 0, set prop.sticky properly SVN revision: 24296
2006-07-29 07:50:18 -07:00
ee->prop.sticky = 0;
ecore_evas - ecore_evas's should start withdrawn then normal on show this fixes initial state of an ee where you couldn't detect when the window had been accepted by the wm (goes to normal state from withdrawn). @fix
2014-10-29 03:33:16 -07:00
ee->prop.withdrawn = EINA_TRUE;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->state.sticky = 0;
evas_render: Measure time spent while rendering in sync and async modes SVN revision: 82936
2013-01-17 06:31:34 -08:00
if (getenv("ECORE_EVAS_FORCE_SYNC_RENDER"))
ee->can_async_render = 0;
else
ee->can_async_render = 1;
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
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
/* init evas here */
ee->evas = evas_new();
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
evas_event_callback_add(ee->evas, EVAS_CALLBACK_RENDER_FLUSH_PRE,
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
_ecore_evas_x_flush_pre, ee);
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
evas_event_callback_add(ee->evas, EVAS_CALLBACK_RENDER_FLUSH_POST,
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
_ecore_evas_x_flush_post, ee);
evas: no need for a callback per async call. Let's not multiply our callback infrastructure without any serious need. We already have to many of them.
2013-03-25 19:48:23 -07:00
if (ee->can_async_render)
evas_event_callback_add(ee->evas, EVAS_CALLBACK_RENDER_POST,
_ecore_evas_x_render_updates, ee);
add a call SVN revision: 18336
2005-11-06 01:47:28 -08:00
evas_data_attach_set(ee->evas, ee);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
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);
oh silly! this woudl fuck up on multihead... FIXED! SVN revision: 14341
2005-04-25 01:28:27 -07:00
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->win_root = parent;
edata->screen_num = 0;
Ecore: Removed trailing whitespaces. SVN revision: 58753
2011-04-20 07:15:33 -07:00
handle dst alpha better SVN revision: 21103
2006-03-08 07:35:01 -08:00
if (parent != 0)
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->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 */
tab------------ SVN revision: 52896
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);
handle dst alpha better SVN revision: 21103
2006-03-08 07:35:01 -08:00
}
else
Let me introduce you to Ecore_Input. The idea is to share as much as possible event between all ecore graphic engine to ease porting of application and reduce the amount of specific code per engine. This patch does just that. All your application should continu to work has previously, if it's not the case please report any new behaviour regarding mouse and keyboard. SVN revision: 39505
2009-03-16 09:24:43 -07:00
ee->prop.window = ecore_x_window_new(parent, x, y, w, h);
ecore-evas - enable attempting to turn on dri2 vsync this enables the x11 dri2 vsync enabling code for x11 ecore-evas
2014-07-24 22:45:50 -07:00
ecore_x_vsync_animator_tick_source_set(ee->prop.window);
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
if ((id = getenv("DESKTOP_STARTUP_ID")))
some support for launch id in netwm. SVN revision: 16706
2005-09-13 20:26:23 -07:00
{
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
ecore_x_netwm_startup_id_set(ee->prop.window, id);
tab------------ SVN revision: 52896
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=");
some support for launch id in netwm. SVN revision: 16706
2005-09-13 20:26:23 -07:00
}
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
einfo = (Evas_Engine_Info_Software_X11 *)evas_engine_info_get(ee->evas);
if (einfo)
{
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
Ecore_X_Screen *screen;
fix ecore_x and ecore-evas to work in multihead at all... :) SVN revision: 12224
2004-11-19 00:16:49 -08:00
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
/* FIXME: this is inefficient as its 1 or more round trips */
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
screen = ecore_x_default_screen_get();
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
if (ecore_x_screen_count_get() > 1)
tab------------ SVN revision: 52896
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)
{
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
Ecore_X_Window root;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
root = ecore_x_window_root_get(parent);
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
for (i = 0; i < num; i++)
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
if (root == roots[i])
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
screen = ecore_x_screen_get(i);
break;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
}
}
free(roots);
}
}
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
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
tab------------ SVN revision: 52896
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;
}
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
Big change in configure.in, ecore_x and ecore_evas. Everything compile nicely after a make maintainer-clean, with xlib or xcb. e17 also has no problem. Please report any problem. Thanks * put xlib and xcb specific code in their own directories inside ecore_x * fix xcb logic check in autotools and ecore_evas * update configure.in for detection of ecore_evas with xlib and xcb support, update ecore_evas accordingly. Note that e17 needs a little fix after that, it will come in a few minutes SVN revision: 35188
2008-07-23 03:00:01 -07:00
# ifdef BUILD_ECORE_EVAS_SOFTWARE_XCB
rename 'x11' to 'xlib' for software x11 based engines when it makes sense SVN revision: 41330
2009-07-14 14:18:27 -07:00
einfo->info.backend = EVAS_ENGINE_INFO_SOFTWARE_X11_BACKEND_XCB;
tab------------ SVN revision: 52896
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
rename 'x11' to 'xlib' for software x11 based engines when it makes sense SVN revision: 41330
2009-07-14 14:18:27 -07:00
einfo->info.backend = EVAS_ENGINE_INFO_SOFTWARE_X11_BACKEND_XLIB;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
einfo->info.connection = ecore_x_display_get();
einfo->info.screen = NULL;
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
# endif
tab------------ SVN revision: 52896
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
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
if (argb)
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
{
Ecore_Evas: Don't need the WindowAttributes variable unless we are an argb window. (Sorry vtorri). SVN revision: 63534
2011-09-22 02:26:02 -07:00
Ecore_X_Window_Attributes at;
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
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;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
}
else
{
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
einfo->info.visual =
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
ecore_x_default_visual_get(einfo->info.connection, screen);
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
einfo->info.colormap =
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
ecore_x_default_colormap_get(einfo->info.connection, screen);
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
einfo->info.depth =
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
ecore_x_default_depth_get(einfo->info.connection, screen);
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
einfo->info.destination_alpha = 0;
}
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
einfo->info.rotation = 0;
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
einfo->info.debug = redraw_debug;
handle info_set failures. SVN revision: 48957
2010-05-17 20:50:17 -07:00
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
{
ecore_evas: let's be consistent and always report an error.
2014-09-30 09:19:15 -07:00
ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
handle info_set failures. SVN revision: 48957
2010-05-17 20:50:17 -07:00
ecore_evas_free(ee);
return NULL;
}
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
}
Ecore: Removed trailing whitespaces. SVN revision: 58753
2011-04-20 07:15:33 -07:00
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
_ecore_evas_x_hints_update(ee);
set client leader by default - support setting it explicitly from code too. fix default win props too. SVN revision: 52974
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);
From: Gwanglim Lee <gl77.lee@samsung.com> Subject: Re: Re: Re: [E-devel] [RFC] Virtual desktop window profile I've attached 4th patch. May the 4th be with you. ecore patch has been merged with efl and all files are based on r80123. Thanks & Regards, Gwanglim ------- Original Message ------- Sender : Daniel Juyung Seo<seojuyung2@gmail.com> Date : 2012-12-04 01:55 (GMT+09:00) Title : Re: Re: [E-devel] [RFC] Virtual desktop window profile It looks ok to me. Sorry but can you re-generate the patch according to the recent ecore merge to efl single tree? Daniel Juyung Seo (SeoZ) On Thu, Nov 29, 2012 at 12:29 AM, Gwanglim Lee <gl77.lee@samsung.com> wrote: Dear Raster and Daniel Juyung Seo, I've attached 3rd patches and test_config according to your reviews. These are based on r79782. [elementary & ecore] 1. "profile,set" -> "profile,changed" - done 2. spaces after EINA_LIST_FOREACH - done 3. variable type - keep 4. author - done 5. removing deprecated marking in patch - done 6. add elm_win_available_profiles_get to test_config for the debugging purpose - done 7. check whether a given profile is present in an available profiles. otherwise window profile will be one of the item in available profiles. - newly added thing to the elm_win 8. merge with EO - done. :( Any comments would be appreciated. SVN revision: 80214
2012-12-04 22:48:46 -08:00
_ecore_evas_x_window_profile_protocol_set(ee);
ecore_evas: added window manager rotation to manage the rotation of windows by the WM. Summary: The window manager rotation allows the WM to controls the rotation of application windows. It is designed to support synchronized rotation for the multiple application windows at same time. Reviewers: raster, seoz, cedric, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D529
2014-02-08 16:46:51 -08:00
_ecore_evas_x_wm_rotation_protocol_set(ee);
ecore_evas: Added support for window auxiliary hint Summary: The window auxiliary hint is the value which is used to decide which actions should be made available to the user by the WM. If you want to set specific hint to your window, then you should check whether it exists in the supported auxiliary hints that are registered in the root window by the window manager. Once you've added an auxiliary hint, you can get a new ID which is used to change value and delete hint. The window manager sends the response message to the application on receiving auxiliary hint change event. A list of auxiliary hint within the Ecore_Evas has this format: ID:HINT:VALUE,ID:HINT:VALUE,... Reviewers: raster, cedric, seoz, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D543
2014-02-27 14:20:01 -08:00
_ecore_evas_x_aux_hints_supprted_update(ee);
_ecore_evas_x_aux_hints_update(ee);
set client leader by default - support setting it explicitly from code too. fix default win props too. SVN revision: 52974
2010-10-01 18:56:23 -07:00
_ecore_evas_x_sync_set(ee);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
clean up engines - put idle entere handlign in core. same with lists. quyartz looks broken to me. sdl looks like it could be much more complete - like multiple sdl windows/instances. anyway - allow rendering to be manual. SVN revision: 44938
2010-01-06 21:29:06 -08:00
ee->engine.func->fn_render = _ecore_evas_x_render;
_ecore_evas_register(ee);
Expose device (e.g. pen) axis information to applications Summary: This patch set adds the necessary code to expose device axis state to applications. This was primarily written with graphics tablets in mind, which -- in addition to acting like a mouse -- also provide information about pen pressure, tilt, etc. Other devices could potentially benefit from this API as well: touchscreens, joysticks, knob controllers, "spaceballs", etc. Whenever an update to the device state is recieved, an "Axis update" event is synthesized. This event contains the updated information, typically scaled and normalized to a particular logical range (e.g. zero to one for pressure, -pi to pi radians for angles, etc.). Information about the tool which generated the event is also stored so that applications can disambiguate events from multiple devices (or in the case of multitouch screens, individual fingers). This API is only wired up for use with X11 at the moment. Support for other backends (e.g. Wayland) should be easy to add for those familiar them. **Note**: The following is a list of changes from the "v2" patches originally sent to the mailinglist //Define and implement new Ecore_Event_Axis_Update events// * Harcode axis labels instead of including xserver-properties.h * Use C89-style comments * Use doxygen comments * Update comment text to note axes with unbounded/undefined ranges/units * Create "Ecore_Axis" and "Ecore_Axis_Label" typedefs * Reference typedef'd instead of raw types * Adjust how we count through valuators to support tilt/az * Add support for tilt and azimuth * Tweak memory management in case number of valuators differ * Expand TWIST axis normalization to declared range * Only normalize TWIST axis if resolution == 1 (wacom bug) * Cache label atoms on first use to minimize round-trips //Implement EVAS_CALLBACK_AXIS_UPDATE event and friends// * Update to doxygen comments * Update comment text to note axes with unbounded/undefined ranges/units * Typedef 'Evas_Axis_Label', 'Evas_Axis' * Move typedef for 'Evas_Event_Axis_Update' * Reference typedef'd instead of raw types //Wire the Ecore and Evas implementations of axis update events together// * Expose ecore_event_evas_axis_update in Ecore_Input_Evas.h * Move ecore_event_evas_axis_update to more logical position //DEBUG: Add axis update logging to evas-multi-touch.c// * Removed from patch set //Make evas-multi-touch demo use new axis functionality// * Have pressure adjust rectangle brightness instead of size * Use more available axis data when rendering rectangle (azimuth, tilt, twist) Test Plan: The evas-multi-touch demo was updated to support axis update events. A graphics tablet was then used to verify that the pressure, azimuth, tilt, and twist data was coming through correctly. Reviewers: cedric, raster Subscribers: cedric Differential Revision: https://phab.enlightenment.org/D1514 Conflicts: src/lib/ecore_input/Ecore_Input.h Carsten Haitzler - ** fixed forward enum typedefs (make things unhappy) ** fixed conflict above ** fixed wrong param type for _evas_canvas_event_feed_axis_update() ** fixed @sinces to be 1.13 ** fixed formatting/indeting ** fixed order of operation reliance in if's with ()'s to be clear ** fixed functions to be static that should have been
2014-11-24 19:07:50 -08:00
ecore_x_input_select(ee->prop.window);
and break api in ecore_input_evas - not used anyway except within ecore. the api didn't allow for rotation of multitouch input. need to fix. done. SVN revision: 55367
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);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
return ee;
* unused parameters -- * llvm report -- SVN revision: 39977
2009-04-11 03:31:42 -07:00
}
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
Add code for ecore_evas_<engine>_pixmap_new/get functions. - Add "pixmap" structure to engine_data. - Free the front and back pixmaps when the ecore_evas gets freed. - On resize, drop the backing pixmap if size is different. - Before we render, check pixmap size vs EE size and create new backing pixmap if needed. - After we have rendered into the backing pixmap, flip it to the front so that any calls to "pixmap_get" will return the proper one. - Add pixmap_new_internal code (the actual guts for all this) NB: These can be used to create an internally double-buffered ecore_evas that renders to a pixmap (not a window). Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-05 02:38:43 -07:00
EAPI Ecore_Evas *
ecore_evas_software_x11_pixmap_new_internal(const char *disp_name, Ecore_X_Window parent,
int x, int y, int w, int h)
{
Evas_Engine_Info_Software_X11 *einfo;
Ecore_Evas_Interface_X11 *iface;
Ecore_Evas_Interface_Software_X11 *siface;
Ecore_Evas_Engine_Data_X11 *edata;
Ecore_Evas *ee;
int argb = 0, rmethod;
static int redraw_debug = -1;
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;
edata = calloc(1, sizeof(Ecore_Evas_Engine_Data_X11));
if (!edata)
{
free(ee);
return NULL;
}
ee->engine.data = edata;
iface = _ecore_evas_x_interface_x11_new();
siface = _ecore_evas_x_interface_software_x11_new();
ee->engine.ifaces = eina_list_append(ee->engine.ifaces, iface);
ee->engine.ifaces = eina_list_append(ee->engine.ifaces, siface);
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_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;
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
ee->prop.request_pos = EINA_FALSE;
Add code for ecore_evas_<engine>_pixmap_new/get functions. - Add "pixmap" structure to engine_data. - Free the front and back pixmaps when the ecore_evas gets freed. - On resize, drop the backing pixmap if size is different. - Before we render, check pixmap size vs EE size and create new backing pixmap if needed. - After we have rendered into the backing pixmap, flip it to the front so that any calls to "pixmap_get" will return the proper one. - Add pixmap_new_internal code (the actual guts for all this) NB: These can be used to create an internally double-buffered ecore_evas that renders to a pixmap (not a window). Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-05 02:38:43 -07:00
ee->prop.sticky = 0;
edata->state.sticky = 0;
if (getenv("ECORE_EVAS_FORCE_SYNC_RENDER"))
ee->can_async_render = 0;
else
ee->can_async_render = 1;
/* 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_event_callback_add(ee->evas, EVAS_CALLBACK_RENDER_PRE,
_ecore_evas_x_render_pre, ee);
if (ee->can_async_render)
evas_event_callback_add(ee->evas, EVAS_CALLBACK_RENDER_POST,
_ecore_evas_x_render_updates, 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);
edata->win_root = parent;
edata->screen_num = 0;
edata->direct_resize = 1;
if (parent != 0)
{
edata->screen_num = 1; /* FIXME: get real scren # */
/* FIXME: round trip in ecore_x_window_argb_get */
if (ecore_x_window_argb_get(parent))
argb = 1;
}
/* if ((id = getenv("DESKTOP_STARTUP_ID"))) */
/* { */
/* ecore_x_netwm_startup_id_set(ee->prop.window, 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=");
/* } */
einfo = (Evas_Engine_Info_Software_X11 *)evas_engine_info_get(ee->evas);
if (einfo)
{
Ecore_X_Screen *screen;
/* FIXME: this is inefficient as its 1 or more round trips */
screen = ecore_x_default_screen_get();
if (ecore_x_screen_count_get() > 1)
{
Ecore_X_Window *roots;
int num, i;
num = 0;
roots = ecore_x_window_root_list(&num);
if (roots)
{
Ecore_X_Window root;
root = ecore_x_window_root_get(parent);
for (i = 0; i < num; i++)
{
if (root == roots[i])
{
screen = ecore_x_screen_get(i);
break;
}
}
free(roots);
}
}
einfo->info.destination_alpha = argb;
if (redraw_debug < 0)
{
if (getenv("REDRAW_DEBUG"))
redraw_debug = atoi(getenv("REDRAW_DEBUG"));
else
redraw_debug = 0;
}
# ifdef BUILD_ECORE_EVAS_SOFTWARE_XCB
einfo->info.backend = EVAS_ENGINE_INFO_SOFTWARE_X11_BACKEND_XCB;
einfo->info.connection = ecore_x_connection_get();
einfo->info.screen = screen;
# else
einfo->info.backend = EVAS_ENGINE_INFO_SOFTWARE_X11_BACKEND_XLIB;
einfo->info.connection = ecore_x_display_get();
einfo->info.screen = NULL;
# endif
Check for valid ee->prop.window before trying to fetch window attributes from it. Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-05 03:09:25 -07:00
if ((argb) && (ee->prop.window))
Add code for ecore_evas_<engine>_pixmap_new/get functions. - Add "pixmap" structure to engine_data. - Free the front and back pixmaps when the ecore_evas gets freed. - On resize, drop the backing pixmap if size is different. - Before we render, check pixmap size vs EE size and create new backing pixmap if needed. - After we have rendered into the backing pixmap, flip it to the front so that any calls to "pixmap_get" will return the proper one. - Add pixmap_new_internal code (the actual guts for all this) NB: These can be used to create an internally double-buffered ecore_evas that renders to a pixmap (not a window). Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-05 02:38:43 -07:00
{
Ecore_X_Window_Attributes at;
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;
}
else
{
einfo->info.visual =
ecore_x_default_visual_get(einfo->info.connection, screen);
einfo->info.colormap =
ecore_x_default_colormap_get(einfo->info.connection, screen);
einfo->info.depth =
ecore_x_default_depth_get(einfo->info.connection, screen);
einfo->info.destination_alpha = 0;
}
einfo->info.rotation = 0;
einfo->info.debug = redraw_debug;
/* record pixmap size to save X roundtrips */
edata->pixmap.w = w;
edata->pixmap.h = h;
edata->pixmap.depth = einfo->info.depth;
Add engine interface code for: - ecore_evas_pixmap_visual_get - ecore_evas_pixmap_colormap_get - ecore_evas_pixmap_depth_get Assign interface functions for above when creating the new interface. When creating the pixmap, store the visual and colormap for later retrieval. Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-11 02:47:08 -07:00
edata->pixmap.visual = einfo->info.visual;
edata->pixmap.colormap = einfo->info.colormap;
Add code for ecore_evas_<engine>_pixmap_new/get functions. - Add "pixmap" structure to engine_data. - Free the front and back pixmaps when the ecore_evas gets freed. - On resize, drop the backing pixmap if size is different. - Before we render, check pixmap size vs EE size and create new backing pixmap if needed. - After we have rendered into the backing pixmap, flip it to the front so that any calls to "pixmap_get" will return the proper one. - Add pixmap_new_internal code (the actual guts for all this) NB: These can be used to create an internally double-buffered ecore_evas that renders to a pixmap (not a window). Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-05 02:38:43 -07:00
/* create front and back pixmaps for double-buffer rendering */
edata->pixmap.front =
ecore_x_pixmap_new(parent, w, h, edata->pixmap.depth);
edata->pixmap.back =
ecore_x_pixmap_new(parent, w, h, edata->pixmap.depth);
einfo->info.drawable = edata->pixmap.back;
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
{
ecore_evas: let's be consistent and always report an error.
2014-09-30 09:19:15 -07:00
ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
Add code for ecore_evas_<engine>_pixmap_new/get functions. - Add "pixmap" structure to engine_data. - Free the front and back pixmaps when the ecore_evas gets freed. - On resize, drop the backing pixmap if size is different. - Before we render, check pixmap size vs EE size and create new backing pixmap if needed. - After we have rendered into the backing pixmap, flip it to the front so that any calls to "pixmap_get" will return the proper one. - Add pixmap_new_internal code (the actual guts for all this) NB: These can be used to create an internally double-buffered ecore_evas that renders to a pixmap (not a window). Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-05 02:38:43 -07:00
ecore_evas_free(ee);
return NULL;
}
}
/* FIXME: Allow of these set properties or do something with the
* ee->prop.window (x window), which we do not have in pixmap case */
/* _ecore_evas_x_hints_update(ee); */
/* _ecore_evas_x_group_leader_set(ee); */
/* ecore_x_window_defaults_set(ee->prop.window); */
/* _ecore_evas_x_protocols_set(ee); */
/* _ecore_evas_x_window_profile_protocol_set(ee); */
/* _ecore_evas_x_sync_set(ee); */
ee->engine.func->fn_render = _ecore_evas_x_render;
_ecore_evas_register(ee);
ee->draw_ok = 1;
Expose device (e.g. pen) axis information to applications Summary: This patch set adds the necessary code to expose device axis state to applications. This was primarily written with graphics tablets in mind, which -- in addition to acting like a mouse -- also provide information about pen pressure, tilt, etc. Other devices could potentially benefit from this API as well: touchscreens, joysticks, knob controllers, "spaceballs", etc. Whenever an update to the device state is recieved, an "Axis update" event is synthesized. This event contains the updated information, typically scaled and normalized to a particular logical range (e.g. zero to one for pressure, -pi to pi radians for angles, etc.). Information about the tool which generated the event is also stored so that applications can disambiguate events from multiple devices (or in the case of multitouch screens, individual fingers). This API is only wired up for use with X11 at the moment. Support for other backends (e.g. Wayland) should be easy to add for those familiar them. **Note**: The following is a list of changes from the "v2" patches originally sent to the mailinglist //Define and implement new Ecore_Event_Axis_Update events// * Harcode axis labels instead of including xserver-properties.h * Use C89-style comments * Use doxygen comments * Update comment text to note axes with unbounded/undefined ranges/units * Create "Ecore_Axis" and "Ecore_Axis_Label" typedefs * Reference typedef'd instead of raw types * Adjust how we count through valuators to support tilt/az * Add support for tilt and azimuth * Tweak memory management in case number of valuators differ * Expand TWIST axis normalization to declared range * Only normalize TWIST axis if resolution == 1 (wacom bug) * Cache label atoms on first use to minimize round-trips //Implement EVAS_CALLBACK_AXIS_UPDATE event and friends// * Update to doxygen comments * Update comment text to note axes with unbounded/undefined ranges/units * Typedef 'Evas_Axis_Label', 'Evas_Axis' * Move typedef for 'Evas_Event_Axis_Update' * Reference typedef'd instead of raw types //Wire the Ecore and Evas implementations of axis update events together// * Expose ecore_event_evas_axis_update in Ecore_Input_Evas.h * Move ecore_event_evas_axis_update to more logical position //DEBUG: Add axis update logging to evas-multi-touch.c// * Removed from patch set //Make evas-multi-touch demo use new axis functionality// * Have pressure adjust rectangle brightness instead of size * Use more available axis data when rendering rectangle (azimuth, tilt, twist) Test Plan: The evas-multi-touch demo was updated to support axis update events. A graphics tablet was then used to verify that the pressure, azimuth, tilt, and twist data was coming through correctly. Reviewers: cedric, raster Subscribers: cedric Differential Revision: https://phab.enlightenment.org/D1514 Conflicts: src/lib/ecore_input/Ecore_Input.h Carsten Haitzler - ** fixed forward enum typedefs (make things unhappy) ** fixed conflict above ** fixed wrong param type for _evas_canvas_event_feed_axis_update() ** fixed @sinces to be 1.13 ** fixed formatting/indeting ** fixed order of operation reliance in if's with ()'s to be clear ** fixed functions to be static that should have been
2014-11-24 19:07:50 -08:00
/* ecore_x_input_select(ee->prop.window); */
Add code for ecore_evas_<engine>_pixmap_new/get functions. - Add "pixmap" structure to engine_data. - Free the front and back pixmaps when the ecore_evas gets freed. - On resize, drop the backing pixmap if size is different. - Before we render, check pixmap size vs EE size and create new backing pixmap if needed. - After we have rendered into the backing pixmap, flip it to the front so that any calls to "pixmap_get" will return the proper one. - Add pixmap_new_internal code (the actual guts for all this) NB: These can be used to create an internally double-buffered ecore_evas that renders to a pixmap (not a window). Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-05 02:38:43 -07: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); */
return ee;
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
static Ecore_X_Window
_ecore_evas_software_x11_window_get(const Ecore_Evas *ee)
don't build the ecore_x dependant parts if we didn't built ecore_x at all SVN revision: 11401
2004-08-27 03:02:45 -07:00
{
Ecore_Evas: Patch from Robert Bradford <robert.bradford@intel.com>: The challenge here is that the native window representation is stored in Ecore_Evas's prop.window. But currently there is no checking of what driver the Ecore_Evas is for when calls are made to e.g. ecore_evas_software_x11_window_get. The attached change to Ecore makes the appropriate functions return 0 or NULL if the driver for the Ecore doesn't match as expected. This can then be used to identify if an Ecore_Evas is e.g. from X11 or from Wayland. SVN revision: 71453
2012-05-28 05:24:30 -07:00
if (!(!strcmp(ee->driver, "software_x11"))) return 0;
Let me introduce you to Ecore_Input. The idea is to share as much as possible event between all ecore graphic engine to ease porting of application and reduce the amount of specific code per engine. This patch does just that. All your application should continu to work has previously, if it's not the case please report any new behaviour regarding mouse and keyboard. SVN revision: 39505
2009-03-16 09:24:43 -07:00
return (Ecore_X_Window) ecore_evas_window_get(ee);
* unused parameters -- * llvm report -- SVN revision: 39977
2009-04-11 03:31:42 -07:00
}
don't build the ecore_x dependant parts if we didn't built ecore_x at all SVN revision: 11401
2004-08-27 03:02:45 -07:00
Add code for ecore_evas_<engine>_pixmap_new/get functions. - Add "pixmap" structure to engine_data. - Free the front and back pixmaps when the ecore_evas gets freed. - On resize, drop the backing pixmap if size is different. - Before we render, check pixmap size vs EE size and create new backing pixmap if needed. - After we have rendered into the backing pixmap, flip it to the front so that any calls to "pixmap_get" will return the proper one. - Add pixmap_new_internal code (the actual guts for all this) NB: These can be used to create an internally double-buffered ecore_evas that renders to a pixmap (not a window). Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-05 02:38:43 -07:00
static Ecore_X_Pixmap
_ecore_evas_software_x11_pixmap_get(const Ecore_Evas *ee)
{
if (!(!strcmp(ee->driver, "software_x11"))) return 0;
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
return (Ecore_X_Pixmap) edata->pixmap.front;
}
Add engine interface code for: - ecore_evas_pixmap_visual_get - ecore_evas_pixmap_colormap_get - ecore_evas_pixmap_depth_get Assign interface functions for above when creating the new interface. When creating the pixmap, store the visual and colormap for later retrieval. Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-11 02:47:08 -07:00
static void *
_ecore_evas_software_x11_pixmap_visual_get(const Ecore_Evas *ee)
{
if (!(!strcmp(ee->driver, "software_x11"))) return 0;
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
return edata->pixmap.visual;
}
static unsigned long
_ecore_evas_software_x11_pixmap_colormap_get(const Ecore_Evas *ee)
{
if (!(!strcmp(ee->driver, "software_x11"))) return 0;
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
return edata->pixmap.colormap;
}
static int
_ecore_evas_software_x11_pixmap_depth_get(const Ecore_Evas *ee)
{
if (!(!strcmp(ee->driver, "software_x11"))) return 0;
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
return edata->pixmap.depth;
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
static void
_ecore_evas_software_x11_direct_resize_set(Ecore_Evas *ee, Eina_Bool on)
extra ecore_x and ecore_evas features for e17.. :) SVN revision: 12241
2004-11-23 07:17:56 -08:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
edata->direct_resize = on;
special case - if direct resize on AND avoid damage... THEN use window bg pixmap. :) SVN revision: 15531
2005-06-25 00:23:38 -07:00
if (ee->prop.avoid_damage)
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (edata->direct_resize)
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -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
/* turn this off for now
tab------------ SVN revision: 52896
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);
the bg pixmap was a nice experiemnt - but not working as nicely as i hoped SVN revision: 15574
2005-06-29 23:32:30 -07:00
*/
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
}
else
{
put guards around config.h, remove trailing spaces SVN revision: 35104
2008-07-14 03:06:34 -07:00
/* turn this off too- bg pixmap is controlled by avoid damage directly
tab------------ SVN revision: 52896
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);
avoid damage now has an enum (compatible with the old way at ABI though), so you can either handle it via exposes, or native system methods (bg pixmaps) SVN revision: 31944
2007-10-02 23:31:05 -07:00
*/
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
}
special case - if direct resize on AND avoid damage... THEN use window bg pixmap. :) SVN revision: 15531
2005-06-25 00:23:38 -07:00
}
* unused parameters -- * llvm report -- SVN revision: 39977
2009-04-11 03:31:42 -07:00
}
extra ecore_x and ecore_evas features for e17.. :) SVN revision: 12241
2004-11-23 07:17:56 -08:00
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
static Eina_Bool
_ecore_evas_software_x11_direct_resize_get(const Ecore_Evas *ee)
* unused parameters -- * llvm report -- SVN revision: 39977
2009-04-11 03:31:42 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
return edata->direct_resize;
extra ecore_x and ecore_evas features for e17.. :) SVN revision: 12241
2004-11-23 07:17:56 -08:00
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
static void
_ecore_evas_software_x11_extra_event_window_add(Ecore_Evas *ee, Ecore_X_Window win)
just DONT ask! DONT! x. focvus. client, self, not getting key events... fuck! workarounds. SVN revision: 16904
2005-09-24 02:00:23 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
just DONT ask! DONT! x. focvus. client, self, not getting key events... fuck! workarounds. SVN revision: 16904
2005-09-24 02:00:23 -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
just DONT ask! DONT! x. focvus. client, self, not getting key events... fuck! workarounds. SVN revision: 16904
2005-09-24 02:00:23 -07:00
winp = malloc(sizeof(Ecore_X_Window));
if (winp)
{
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
*winp = win;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->win_extra = eina_list_append(edata->win_extra, winp);
Expose device (e.g. pen) axis information to applications Summary: This patch set adds the necessary code to expose device axis state to applications. This was primarily written with graphics tablets in mind, which -- in addition to acting like a mouse -- also provide information about pen pressure, tilt, etc. Other devices could potentially benefit from this API as well: touchscreens, joysticks, knob controllers, "spaceballs", etc. Whenever an update to the device state is recieved, an "Axis update" event is synthesized. This event contains the updated information, typically scaled and normalized to a particular logical range (e.g. zero to one for pressure, -pi to pi radians for angles, etc.). Information about the tool which generated the event is also stored so that applications can disambiguate events from multiple devices (or in the case of multitouch screens, individual fingers). This API is only wired up for use with X11 at the moment. Support for other backends (e.g. Wayland) should be easy to add for those familiar them. **Note**: The following is a list of changes from the "v2" patches originally sent to the mailinglist //Define and implement new Ecore_Event_Axis_Update events// * Harcode axis labels instead of including xserver-properties.h * Use C89-style comments * Use doxygen comments * Update comment text to note axes with unbounded/undefined ranges/units * Create "Ecore_Axis" and "Ecore_Axis_Label" typedefs * Reference typedef'd instead of raw types * Adjust how we count through valuators to support tilt/az * Add support for tilt and azimuth * Tweak memory management in case number of valuators differ * Expand TWIST axis normalization to declared range * Only normalize TWIST axis if resolution == 1 (wacom bug) * Cache label atoms on first use to minimize round-trips //Implement EVAS_CALLBACK_AXIS_UPDATE event and friends// * Update to doxygen comments * Update comment text to note axes with unbounded/undefined ranges/units * Typedef 'Evas_Axis_Label', 'Evas_Axis' * Move typedef for 'Evas_Event_Axis_Update' * Reference typedef'd instead of raw types //Wire the Ecore and Evas implementations of axis update events together// * Expose ecore_event_evas_axis_update in Ecore_Input_Evas.h * Move ecore_event_evas_axis_update to more logical position //DEBUG: Add axis update logging to evas-multi-touch.c// * Removed from patch set //Make evas-multi-touch demo use new axis functionality// * Have pressure adjust rectangle brightness instead of size * Use more available axis data when rendering rectangle (azimuth, tilt, twist) Test Plan: The evas-multi-touch demo was updated to support axis update events. A graphics tablet was then used to verify that the pressure, azimuth, tilt, and twist data was coming through correctly. Reviewers: cedric, raster Subscribers: cedric Differential Revision: https://phab.enlightenment.org/D1514 Conflicts: src/lib/ecore_input/Ecore_Input.h Carsten Haitzler - ** fixed forward enum typedefs (make things unhappy) ** fixed conflict above ** fixed wrong param type for _evas_canvas_event_feed_axis_update() ** fixed @sinces to be 1.13 ** fixed formatting/indeting ** fixed order of operation reliance in if's with ()'s to be clear ** fixed functions to be static that should have been
2014-11-24 19:07:50 -08:00
ecore_x_input_select(win);
and break api in ecore_input_evas - not used anyway except within ecore. the api didn't allow for rotation of multitouch input. need to fix. done. SVN revision: 55367
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);
just DONT ask! DONT! x. focvus. client, self, not getting key events... fuck! workarounds. SVN revision: 16904
2005-09-24 02:00:23 -07:00
}
* unused parameters -- * llvm report -- SVN revision: 39977
2009-04-11 03:31:42 -07:00
}
#endif
just DONT ask! DONT! x. focvus. client, self, not getting key events... fuck! workarounds. SVN revision: 16904
2005-09-24 02:00:23 -07:00
* unused parameters -- * llvm report -- SVN revision: 39977
2009-04-11 03:31:42 -07:00
#ifdef BUILD_ECORE_EVAS_OPENGL_X11
and yet more warning removal SVN revision: 19568
2006-01-06 10:46:30 -08:00
EAPI Ecore_Evas *
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ecore_evas_gl_x11_options_new_internal(const char *disp_name, Ecore_X_Window parent,
int x, int y, int w, int h, const int *opt)
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
{
Ecore_Evas *ee;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata;
Ecore_Evas_Interface_X11 *iface;
Ecore_Evas_Interface_Gl_X11 *giface;
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
int rmethod;
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
char *id = NULL;
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
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;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata = calloc(1, sizeof(Ecore_Evas_Engine_Data_X11));
if (!edata)
{
free(ee);
return NULL;
}
iface = _ecore_evas_x_interface_x11_new();
giface = _ecore_evas_x_interface_gl_x11_new();
ee->engine.ifaces = eina_list_append(ee->engine.ifaces, iface);
ee->engine.ifaces = eina_list_append(ee->engine.ifaces, giface);
ee->engine.data = edata;
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
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
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
ecore_evas: removed author's name from source code as the author requested it. Git log should be enough for the credit :) This code was merged into efl upstream by devilhorn's aggressive synchronization between efl upstream and tizen. But that commit didn't have the author's credit. However We will never forget the contribution of Gwanglim Lee <gl77.lee@samsung.com>.
2013-12-18 06:47:29 -08:00
ee->gl_sync_draw_done = -1;
Ecore_Evas Merge Tizen changes to upstream EFL. SVN revision: 73206
2012-07-03 00:44:17 -07:00
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
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
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
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
Export driver as engine_name. Also make sure it matches the names used by engines_get(). SVN revision: 37314
2008-10-29 12:31:05 -07:00
ee->driver = "opengl_x11";
Ecore_Evas Merge Tizen changes to upstream EFL. SVN revision: 73206
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
lets have envrionment var control over semisync in ecore-evas SVN revision: 64191
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
ecore: fix misspellings Misspellings found by codespell SVN revision: 59821
2011-05-30 09:17:07 -07:00
// ee->no_comp_sync = 1; // gl engine doesn't need to sync - its whole swaps
Ecore_Evas Merge Tizen changes to upstream EFL. SVN revision: 73206
2012-07-03 00:44:17 -07:00
#endif
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
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;
hmm fix resize before change alpha... SVN revision: 46579
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
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
ee->prop.max.w = 32767;
ee->prop.max.h = 32767;
ee->prop.layer = 4;
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
ee->prop.request_pos = EINA_FALSE;
initialize to 0, set prop.sticky properly SVN revision: 24296
2006-07-29 07:50:18 -07:00
ee->prop.sticky = 0;
ecore_evas - ecore_evas's should start withdrawn then normal on show this fixes initial state of an ee where you couldn't detect when the window had been accepted by the wm (goes to normal state from withdrawn). @fix
2014-10-29 03:33:16 -07:00
ee->prop.withdrawn = EINA_TRUE;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->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
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
/* init evas here */
ee->evas = evas_new();
more work on the sync stuff... looking good now. SVN revision: 45772
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);
add a call SVN revision: 18336
2005-11-06 01:47:28 -08:00
evas_data_attach_set(ee->evas, ee);
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
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);
evilness... but it works. SVN revision: 21091
2006-03-08 00:02:55 -08:00
small change - not worth chglogging... make evas gl x11 header not need xlib.h anymore... :) SVN revision: 82378
2013-01-07 19:49:49 -08:00
if (parent == 0) parent = ecore_x_window_root_first_get();
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->win_root = parent;
* ecore_evas: Fix ecore_evas_gl_x11_new usage. SVN revision: 41167
2009-06-23 02:55:47 -07:00
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (edata->win_root != 0)
allow alpha ee windows. SVN revision: 46678
2010-02-28 20:44:36 -08:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->screen_num = 1; /* FIXME: get real scren # */
allow alpha ee windows. SVN revision: 46678
2010-02-28 20:44:36 -08:00
/* FIXME: round trip in ecore_x_window_argb_get */
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (ecore_x_window_argb_get(edata->win_root))
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
{
allow alpha ee windows. SVN revision: 46678
2010-02-28 20:44:36 -08:00
ee->prop.window = _ecore_evas_x_gl_window_new
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
(ee, edata->win_root, x, y, w, h, 0, 1, opt);
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
}
else
allow alpha ee windows. SVN revision: 46678
2010-02-28 20:44:36 -08:00
ee->prop.window = _ecore_evas_x_gl_window_new
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
(ee, edata->win_root, x, y, w, h, 0, 0, opt);
allow alpha ee windows. SVN revision: 46678
2010-02-28 20:44:36 -08:00
}
else
ee->prop.window = _ecore_evas_x_gl_window_new
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
(ee, edata->win_root, x, y, w, h, 0, 0, opt);
be more robust when gtl creation fails - return a null ee. SVN revision: 46178
2010-02-14 21:26:42 -08:00
if (!ee->prop.window)
{
ecore_evas: let's be consistent and always report an error.
2014-09-30 09:19:15 -07:00
ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
be more robust when gtl creation fails - return a null ee. SVN revision: 46178
2010-02-14 21:26:42 -08:00
ecore_evas_free(ee);
return NULL;
}
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
if ((id = getenv("DESKTOP_STARTUP_ID")))
some support for launch id in netwm. SVN revision: 16706
2005-09-13 20:26:23 -07:00
{
Ecore_Evas: Remove xlib (and xcb) specific calls for the software_x11 and opengl_x11 engines and replace with ecore_x calls. NB: I did not touch software_16 or software_8 so we cannot yet remove the XLib linking wrt ecore_evas. I leave that exercise to 'the old man' as per our convo this morning...but this does put us one step closer ;) SVN revision: 61743
2011-07-26 04:24:10 -07:00
ecore_x_netwm_startup_id_set(ee->prop.window, id);
tab------------ SVN revision: 52896
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=");
some support for launch id in netwm. SVN revision: 16706
2005-09-13 20:26:23 -07:00
}
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
booyah. added lots of ecore_evas state stuff and ability to track state changes too made by a wm - eg getting iconified. SVN revision: 68493
2012-02-27 22:43:59 -08:00
_ecore_evas_x_hints_update(ee);
set client leader by default - support setting it explicitly from code too. fix default win props too. SVN revision: 52974
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);
From: Gwanglim Lee <gl77.lee@samsung.com> Subject: Re: Re: Re: [E-devel] [RFC] Virtual desktop window profile I've attached 4th patch. May the 4th be with you. ecore patch has been merged with efl and all files are based on r80123. Thanks & Regards, Gwanglim ------- Original Message ------- Sender : Daniel Juyung Seo<seojuyung2@gmail.com> Date : 2012-12-04 01:55 (GMT+09:00) Title : Re: Re: [E-devel] [RFC] Virtual desktop window profile It looks ok to me. Sorry but can you re-generate the patch according to the recent ecore merge to efl single tree? Daniel Juyung Seo (SeoZ) On Thu, Nov 29, 2012 at 12:29 AM, Gwanglim Lee <gl77.lee@samsung.com> wrote: Dear Raster and Daniel Juyung Seo, I've attached 3rd patches and test_config according to your reviews. These are based on r79782. [elementary & ecore] 1. "profile,set" -> "profile,changed" - done 2. spaces after EINA_LIST_FOREACH - done 3. variable type - keep 4. author - done 5. removing deprecated marking in patch - done 6. add elm_win_available_profiles_get to test_config for the debugging purpose - done 7. check whether a given profile is present in an available profiles. otherwise window profile will be one of the item in available profiles. - newly added thing to the elm_win 8. merge with EO - done. :( Any comments would be appreciated. SVN revision: 80214
2012-12-04 22:48:46 -08:00
_ecore_evas_x_window_profile_protocol_set(ee);
ecore_evas: added window manager rotation to manage the rotation of windows by the WM. Summary: The window manager rotation allows the WM to controls the rotation of application windows. It is designed to support synchronized rotation for the multiple application windows at same time. Reviewers: raster, seoz, cedric, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D529
2014-02-08 16:46:51 -08:00
_ecore_evas_x_wm_rotation_protocol_set(ee);
ecore_evas: Added support for window auxiliary hint Summary: The window auxiliary hint is the value which is used to decide which actions should be made available to the user by the WM. If you want to set specific hint to your window, then you should check whether it exists in the supported auxiliary hints that are registered in the root window by the window manager. Once you've added an auxiliary hint, you can get a new ID which is used to change value and delete hint. The window manager sends the response message to the application on receiving auxiliary hint change event. A list of auxiliary hint within the Ecore_Evas has this format: ID:HINT:VALUE,ID:HINT:VALUE,... Reviewers: raster, cedric, seoz, Hermet Reviewed By: raster CC: cedric Differential Revision: https://phab.enlightenment.org/D543
2014-02-27 14:20:01 -08:00
_ecore_evas_x_aux_hints_supprted_update(ee);
_ecore_evas_x_aux_hints_update(ee);
set client leader by default - support setting it explicitly from code too. fix default win props too. SVN revision: 52974
2010-10-01 18:56:23 -07:00
_ecore_evas_x_sync_set(ee);
clean up engines - put idle entere handlign in core. same with lists. quyartz looks broken to me. sdl looks like it could be much more complete - like multiple sdl windows/instances. anyway - allow rendering to be manual. SVN revision: 44938
2010-01-06 21:29:06 -08:00
ee->engine.func->fn_render = _ecore_evas_x_render;
_ecore_evas_register(ee);
Expose device (e.g. pen) axis information to applications Summary: This patch set adds the necessary code to expose device axis state to applications. This was primarily written with graphics tablets in mind, which -- in addition to acting like a mouse -- also provide information about pen pressure, tilt, etc. Other devices could potentially benefit from this API as well: touchscreens, joysticks, knob controllers, "spaceballs", etc. Whenever an update to the device state is recieved, an "Axis update" event is synthesized. This event contains the updated information, typically scaled and normalized to a particular logical range (e.g. zero to one for pressure, -pi to pi radians for angles, etc.). Information about the tool which generated the event is also stored so that applications can disambiguate events from multiple devices (or in the case of multitouch screens, individual fingers). This API is only wired up for use with X11 at the moment. Support for other backends (e.g. Wayland) should be easy to add for those familiar them. **Note**: The following is a list of changes from the "v2" patches originally sent to the mailinglist //Define and implement new Ecore_Event_Axis_Update events// * Harcode axis labels instead of including xserver-properties.h * Use C89-style comments * Use doxygen comments * Update comment text to note axes with unbounded/undefined ranges/units * Create "Ecore_Axis" and "Ecore_Axis_Label" typedefs * Reference typedef'd instead of raw types * Adjust how we count through valuators to support tilt/az * Add support for tilt and azimuth * Tweak memory management in case number of valuators differ * Expand TWIST axis normalization to declared range * Only normalize TWIST axis if resolution == 1 (wacom bug) * Cache label atoms on first use to minimize round-trips //Implement EVAS_CALLBACK_AXIS_UPDATE event and friends// * Update to doxygen comments * Update comment text to note axes with unbounded/undefined ranges/units * Typedef 'Evas_Axis_Label', 'Evas_Axis' * Move typedef for 'Evas_Event_Axis_Update' * Reference typedef'd instead of raw types //Wire the Ecore and Evas implementations of axis update events together// * Expose ecore_event_evas_axis_update in Ecore_Input_Evas.h * Move ecore_event_evas_axis_update to more logical position //DEBUG: Add axis update logging to evas-multi-touch.c// * Removed from patch set //Make evas-multi-touch demo use new axis functionality// * Have pressure adjust rectangle brightness instead of size * Use more available axis data when rendering rectangle (azimuth, tilt, twist) Test Plan: The evas-multi-touch demo was updated to support axis update events. A graphics tablet was then used to verify that the pressure, azimuth, tilt, and twist data was coming through correctly. Reviewers: cedric, raster Subscribers: cedric Differential Revision: https://phab.enlightenment.org/D1514 Conflicts: src/lib/ecore_input/Ecore_Input.h Carsten Haitzler - ** fixed forward enum typedefs (make things unhappy) ** fixed conflict above ** fixed wrong param type for _evas_canvas_event_feed_axis_update() ** fixed @sinces to be 1.13 ** fixed formatting/indeting ** fixed order of operation reliance in if's with ()'s to be clear ** fixed functions to be static that should have been
2014-11-24 19:07:50 -08:00
ecore_x_input_select(ee->prop.window);
and break api in ecore_input_evas - not used anyway except within ecore. the api didn't allow for rotation of multitouch input. need to fix. done. SVN revision: 55367
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
damn you salizar! damn you! errr. i mean. ecore moves to HEAD! SVN revision: 7475
2003-09-23 01:09:32 -07:00
return ee;
* unused parameters -- * llvm report -- SVN revision: 39977
2009-04-11 03:31:42 -07:00
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
missing call if gl enigne not built. SVN revision: 46763
2010-03-01 17:43:45 -08:00
EAPI Ecore_Evas *
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ecore_evas_gl_x11_new_internal(const char *disp_name, Ecore_X_Window parent,
int x, int y, int w, int h)
missing call if gl enigne not built. SVN revision: 46763
2010-03-01 17:43:45 -08:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
return ecore_evas_gl_x11_options_new_internal(disp_name, parent, x, y, w, h, NULL);
missing call if gl enigne not built. SVN revision: 46763
2010-03-01 17:43:45 -08:00
}
added ecore_evas_gl_x11_window_get() SVN revision: 11400
2004-08-27 02:37:14 -07:00
Add code for gl_pixmap_new and pixmap_get functions Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-07 23:21:14 -07:00
EAPI Ecore_Evas *
ecore_evas_gl_x11_pixmap_new_internal(const char *disp_name, Ecore_X_Window parent,
int x, int y, int w, int h)
{
Ecore_Evas *ee;
Ecore_Evas_Engine_Data_X11 *edata;
Ecore_Evas_Interface_X11 *iface;
Ecore_Evas_Interface_Gl_X11 *giface;
Evas_Engine_Info_GL_X11 *einfo;
int rmethod, argb = 0;
static int redraw_debug = -1;
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;
edata = calloc(1, sizeof(Ecore_Evas_Engine_Data_X11));
if (!edata)
{
free(ee);
return NULL;
}
iface = _ecore_evas_x_interface_x11_new();
giface = _ecore_evas_x_interface_gl_x11_new();
ee->engine.ifaces = eina_list_append(ee->engine.ifaces, iface);
ee->engine.ifaces = eina_list_append(ee->engine.ifaces, giface);
ee->engine.data = edata;
ECORE_MAGIC_SET(ee, ECORE_MAGIC_EVAS);
ecore_evas: removed author's name from source code as the author requested it. Git log should be enough for the credit :) This code was merged into efl upstream by devilhorn's aggressive synchronization between efl upstream and tizen. But that commit didn't have the author's credit. However We will never forget the contribution of Gwanglim Lee <gl77.lee@samsung.com>.
2013-12-18 06:47:29 -08:00
ee->gl_sync_draw_done = -1;
Add code for gl_pixmap_new and pixmap_get functions Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-07 23:21:14 -07:00
_ecore_evas_x_init();
ee->engine.func = (Ecore_Evas_Engine_Func *)&_ecore_x_engine_func;
ee->driver = "opengl_x11";
#if 1
ee->semi_sync = 0; // gl engine doesn't need to sync - its whole swaps
#else
if (!getenv("ECORE_EVAS_COMP_NOSEMISYNC"))
ee->semi_sync = 1; // gl engine doesn't need to sync - its whole swaps
// ee->no_comp_sync = 1; // gl engine doesn't need to sync - its whole swaps
#endif
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;
ecore_evas - use eina_bool instead of the char for interal data.
2014-01-12 21:26:36 -08:00
ee->prop.request_pos = EINA_FALSE;
Add code for gl_pixmap_new and pixmap_get functions Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-07 23:21:14 -07:00
ee->prop.sticky = 0;
edata->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_event_callback_add(ee->evas, EVAS_CALLBACK_RENDER_PRE,
_ecore_evas_x_render_pre, 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);
if (ee->can_async_render)
evas_event_callback_add(ee->evas, EVAS_CALLBACK_RENDER_POST,
_ecore_evas_x_render_updates, ee);
if (parent == 0) parent = ecore_x_window_root_first_get();
edata->win_root = parent;
if (parent != 0)
{
edata->screen_num = 1; /* FIXME: get real scren # */
/* FIXME: round trip in ecore_x_window_argb_get */
if (ecore_x_window_argb_get(parent))
argb = 1;
}
edata->direct_resize = 1;
einfo = (Evas_Engine_Info_GL_X11 *)evas_engine_info_get(ee->evas);
if (einfo)
{
int screen = 0;
/* FIXME: this is inefficient as its 1 or more round trips */
screen = ecore_x_screen_index_get(ecore_x_default_screen_get());
if (ecore_x_screen_count_get() > 1)
{
Ecore_X_Window *roots;
int num, i;
num = 0;
roots = ecore_x_window_root_list(&num);
if (roots)
{
Ecore_X_Window root;
root = ecore_x_window_root_get(parent);
for (i = 0; i < num; i++)
{
if (root == roots[i])
{
screen = i;
break;
}
}
free(roots);
}
}
einfo->info.display = ecore_x_display_get();
einfo->info.screen = screen;
einfo->info.destination_alpha = argb;
einfo->info.visual = einfo->func.best_visual_get(einfo);
einfo->info.colormap = einfo->func.best_colormap_get(einfo);
einfo->info.depth = einfo->func.best_depth_get(einfo);
if (redraw_debug < 0)
{
if (getenv("REDRAW_DEBUG"))
redraw_debug = atoi(getenv("REDRAW_DEBUG"));
else
redraw_debug = 0;
}
einfo->info.rotation = 0;
/* record pixmap size to save X roundtrips */
edata->pixmap.w = w;
edata->pixmap.h = h;
edata->pixmap.depth = einfo->info.depth;
Add engine interface code for: - ecore_evas_pixmap_visual_get - ecore_evas_pixmap_colormap_get - ecore_evas_pixmap_depth_get Assign interface functions for above when creating the new interface. When creating the pixmap, store the visual and colormap for later retrieval. Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-11 02:47:08 -07:00
edata->pixmap.visual = einfo->info.visual;
edata->pixmap.colormap = einfo->info.colormap;
Add code for gl_pixmap_new and pixmap_get functions Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-07 23:21:14 -07:00
/* create front and back pixmaps for double-buffer rendering */
edata->pixmap.front =
ecore_x_pixmap_new(parent, w, h, edata->pixmap.depth);
edata->pixmap.back =
ecore_x_pixmap_new(parent, w, h, edata->pixmap.depth);
einfo->info.drawable = edata->pixmap.back;
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
{
ecore_evas: let's be consistent and always report an error.
2014-09-30 09:19:15 -07:00
ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
Add code for gl_pixmap_new and pixmap_get functions Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-07 23:21:14 -07:00
ecore_evas_free(ee);
return NULL;
}
}
/* _ecore_evas_x_hints_update(ee); */
/* _ecore_evas_x_group_leader_set(ee); */
/* ecore_x_window_defaults_set(ee->prop.window); */
/* _ecore_evas_x_protocols_set(ee); */
/* _ecore_evas_x_window_profile_protocol_set(ee); */
/* _ecore_evas_x_sync_set(ee); */
ee->engine.func->fn_render = _ecore_evas_x_render;
_ecore_evas_register(ee);
Expose device (e.g. pen) axis information to applications Summary: This patch set adds the necessary code to expose device axis state to applications. This was primarily written with graphics tablets in mind, which -- in addition to acting like a mouse -- also provide information about pen pressure, tilt, etc. Other devices could potentially benefit from this API as well: touchscreens, joysticks, knob controllers, "spaceballs", etc. Whenever an update to the device state is recieved, an "Axis update" event is synthesized. This event contains the updated information, typically scaled and normalized to a particular logical range (e.g. zero to one for pressure, -pi to pi radians for angles, etc.). Information about the tool which generated the event is also stored so that applications can disambiguate events from multiple devices (or in the case of multitouch screens, individual fingers). This API is only wired up for use with X11 at the moment. Support for other backends (e.g. Wayland) should be easy to add for those familiar them. **Note**: The following is a list of changes from the "v2" patches originally sent to the mailinglist //Define and implement new Ecore_Event_Axis_Update events// * Harcode axis labels instead of including xserver-properties.h * Use C89-style comments * Use doxygen comments * Update comment text to note axes with unbounded/undefined ranges/units * Create "Ecore_Axis" and "Ecore_Axis_Label" typedefs * Reference typedef'd instead of raw types * Adjust how we count through valuators to support tilt/az * Add support for tilt and azimuth * Tweak memory management in case number of valuators differ * Expand TWIST axis normalization to declared range * Only normalize TWIST axis if resolution == 1 (wacom bug) * Cache label atoms on first use to minimize round-trips //Implement EVAS_CALLBACK_AXIS_UPDATE event and friends// * Update to doxygen comments * Update comment text to note axes with unbounded/undefined ranges/units * Typedef 'Evas_Axis_Label', 'Evas_Axis' * Move typedef for 'Evas_Event_Axis_Update' * Reference typedef'd instead of raw types //Wire the Ecore and Evas implementations of axis update events together// * Expose ecore_event_evas_axis_update in Ecore_Input_Evas.h * Move ecore_event_evas_axis_update to more logical position //DEBUG: Add axis update logging to evas-multi-touch.c// * Removed from patch set //Make evas-multi-touch demo use new axis functionality// * Have pressure adjust rectangle brightness instead of size * Use more available axis data when rendering rectangle (azimuth, tilt, twist) Test Plan: The evas-multi-touch demo was updated to support axis update events. A graphics tablet was then used to verify that the pressure, azimuth, tilt, and twist data was coming through correctly. Reviewers: cedric, raster Subscribers: cedric Differential Revision: https://phab.enlightenment.org/D1514 Conflicts: src/lib/ecore_input/Ecore_Input.h Carsten Haitzler - ** fixed forward enum typedefs (make things unhappy) ** fixed conflict above ** fixed wrong param type for _evas_canvas_event_feed_axis_update() ** fixed @sinces to be 1.13 ** fixed formatting/indeting ** fixed order of operation reliance in if's with ()'s to be clear ** fixed functions to be static that should have been
2014-11-24 19:07:50 -08:00
/* ecore_x_input_select(ee->prop.window); */
Add code for gl_pixmap_new and pixmap_get functions Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-07 23:21:14 -07: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); */
return ee;
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
static Ecore_X_Window
_ecore_evas_gl_x11_window_get(const Ecore_Evas *ee)
added ecore_evas_gl_x11_window_get() SVN revision: 11400
2004-08-27 02:37:14 -07:00
{
Ecore_Evas: Patch from Robert Bradford <robert.bradford@intel.com>: The challenge here is that the native window representation is stored in Ecore_Evas's prop.window. But currently there is no checking of what driver the Ecore_Evas is for when calls are made to e.g. ecore_evas_software_x11_window_get. The attached change to Ecore makes the appropriate functions return 0 or NULL if the driver for the Ecore doesn't match as expected. This can then be used to identify if an Ecore_Evas is e.g. from X11 or from Wayland. SVN revision: 71453
2012-05-28 05:24:30 -07:00
if (!(!strcmp(ee->driver, "opengl_x11"))) return 0;
Let me introduce you to Ecore_Input. The idea is to share as much as possible event between all ecore graphic engine to ease porting of application and reduce the amount of specific code per engine. This patch does just that. All your application should continu to work has previously, if it's not the case please report any new behaviour regarding mouse and keyboard. SVN revision: 39505
2009-03-16 09:24:43 -07:00
return (Ecore_X_Window) ecore_evas_window_get(ee);
* unused parameters -- * llvm report -- SVN revision: 39977
2009-04-11 03:31:42 -07:00
}
extra ecore_x and ecore_evas features for e17.. :) SVN revision: 12241
2004-11-23 07:17:56 -08:00
Add code for gl_pixmap_new and pixmap_get functions Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-07 23:21:14 -07:00
static Ecore_X_Pixmap
_ecore_evas_gl_x11_pixmap_get(const Ecore_Evas *ee)
{
if (!(!strcmp(ee->driver, "opengl_x11"))) return 0;
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
return (Ecore_X_Pixmap) edata->pixmap.front;
}
Add engine interface code for: - ecore_evas_pixmap_visual_get - ecore_evas_pixmap_colormap_get - ecore_evas_pixmap_depth_get Assign interface functions for above when creating the new interface. When creating the pixmap, store the visual and colormap for later retrieval. Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-11 02:47:08 -07:00
static void *
_ecore_evas_gl_x11_pixmap_visual_get(const Ecore_Evas *ee)
{
if (!(!strcmp(ee->driver, "opengl_x11"))) return 0;
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
return edata->pixmap.visual;
}
static unsigned long
_ecore_evas_gl_x11_pixmap_colormap_get(const Ecore_Evas *ee)
{
if (!(!strcmp(ee->driver, "opengl_x11"))) return 0;
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
return edata->pixmap.colormap;
}
static int
_ecore_evas_gl_x11_pixmap_depth_get(const Ecore_Evas *ee)
{
if (!(!strcmp(ee->driver, "opengl_x11"))) return 0;
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
return edata->pixmap.depth;
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
static void
_ecore_evas_gl_x11_direct_resize_set(Ecore_Evas *ee, Eina_Bool on)
* unused parameters -- * llvm report -- SVN revision: 39977
2009-04-11 03:31:42 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
edata->direct_resize = on;
extra ecore_x and ecore_evas features for e17.. :) SVN revision: 12241
2004-11-23 07:17:56 -08:00
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
static Eina_Bool
_ecore_evas_gl_x11_direct_resize_get(const Ecore_Evas *ee)
* unused parameters -- * llvm report -- SVN revision: 39977
2009-04-11 03:31:42 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
return edata->direct_resize;
extra ecore_x and ecore_evas features for e17.. :) SVN revision: 12241
2004-11-23 07:17:56 -08:00
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
static void
_ecore_evas_gl_x11_extra_event_window_add(Ecore_Evas *ee, Ecore_X_Window win)
just DONT ask! DONT! x. focvus. client, self, not getting key events... fuck! workarounds. SVN revision: 16904
2005-09-24 02:00:23 -07:00
{
ecore_evas_software_x11_extra_event_window_add(ee, win);
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
static 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))
use pre-post swap callbacks and expose for gl SVN revision: 45515
2010-01-24 03:01:39 -08:00
{
Evas_Engine_Info_GL_X11 *einfo;
Ecore: Removed trailing whitespaces. SVN revision: 58753
2011-04-20 07:15:33 -07:00
use pre-post swap callbacks and expose for gl SVN revision: 45515
2010-01-24 03:01:39 -08:00
if (!(!strcmp(ee->driver, "opengl_x11"))) return;
Ecore: Removed trailing whitespaces. SVN revision: 58753
2011-04-20 07:15:33 -07:00
use pre-post swap callbacks and expose for gl SVN revision: 45515
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;
ecore_evas - patched by Gwanglim Lee <gl77.lee@samsung.com> Hi all, I've fixed a minor bug in the ecore_evas_gl_x11_pre_post_swap_callback_set API. It wasn't setting a post_swap callback properly. Please review it. BR, SVN revision: 62785
2011-08-25 01:14:21 -07:00
einfo->callback.post_swap = post_cb;
use pre-post swap callbacks and expose for gl SVN revision: 45515
2010-01-24 03:01:39 -08:00
einfo->callback.data = data;
tab------------ SVN revision: 52896
2010-09-29 10:03:38 -07:00
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
handle info_set failures. SVN revision: 48957
2010-05-17 20:50:17 -07:00
{
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
}
use pre-post swap callbacks and expose for gl SVN revision: 45515
2010-01-24 03:01:39 -08:00
}
}
#endif /* ! BUILD_ECORE_EVAS_OPENGL_X11 */
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
static void
_ecore_evas_x11_leader_set(Ecore_Evas *ee, Ecore_X_Window win)
set client leader by default - support setting it explicitly from code too. fix default win props too. SVN revision: 52974
2010-10-01 18:56:23 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
set client leader by default - support setting it explicitly from code too. fix default win props too. SVN revision: 52974
2010-10-01 18:56:23 -07:00
_ecore_evas_x_group_leader_unset(ee);
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata->leader = win;
set client leader by default - support setting it explicitly from code too. fix default win props too. SVN revision: 52974
2010-10-01 18:56:23 -07:00
_ecore_evas_x_group_leader_update(ee);
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
static Ecore_X_Window
_ecore_evas_x11_leader_get(Ecore_Evas *ee)
set client leader by default - support setting it explicitly from code too. fix default win props too. SVN revision: 52974
2010-10-01 18:56:23 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata = ee->engine.data;
return edata->leader;
set client leader by default - support setting it explicitly from code too. fix default win props too. SVN revision: 52974
2010-10-01 18:56:23 -07:00
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
static void
_ecore_evas_x11_leader_default_set(Ecore_Evas *ee)
set client leader by default - support setting it explicitly from code too. fix default win props too. SVN revision: 52974
2010-10-01 18:56:23 -07:00
{
_ecore_evas_x_group_leader_unset(ee);
_ecore_evas_x_group_leader_set(ee);
}
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
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)
{
Ecore_Evas: Fixes for working with the xcb engine. Fix some formatting. Fix dst_rect being uninitialized. Remove 'prefetch & fetch' calls as they are not used in the new xcb stuffs. SVN revision: 61379
2011-07-14 08:40:53 -07:00
if ((!src_rect) || (!dst_rect)) return 0;
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
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;
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
static void
_ecore_evas_x11_shape_input_rectangle_set(Ecore_Evas *ee, int x, int y, int w, int h)
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
{
Eina_Bool ret;
Ecore_X_Rectangle src_rect;
Ecore_X_Rectangle dst_rect;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata;
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
{
ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
"ecore_evas_x11_shape_input_rectangle_set");
return;
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata = ee->engine.data;
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
src_rect.x = x;
src_rect.y = y;
src_rect.width = w;
src_rect.height = h;
Ecore_Evas: Fixes for working with the xcb engine. Fix some formatting. Fix dst_rect being uninitialized. Remove 'prefetch & fetch' calls as they are not used in the new xcb stuffs. SVN revision: 61379
2011-07-14 08:40:53 -07:00
dst_rect.x = 0;
dst_rect.y = 0;
dst_rect.width = 0;
dst_rect.height = 0;
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
ret = _ecore_evas_x11_convert_rectangle_with_angle(ee, &dst_rect, &src_rect);
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (!edata->win_shaped_input)
edata->win_shaped_input = ecore_x_window_override_new(edata->win_root,
Ecore_Evas: Fixes for working with the xcb engine. Fix some formatting. Fix dst_rect being uninitialized. Remove 'prefetch & fetch' calls as they are not used in the new xcb stuffs. SVN revision: 61379
2011-07-14 08:40:53 -07:00
0, 0, 1, 1);
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
if (ret)
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ecore_x_window_shape_input_rectangle_set(edata->win_shaped_input,
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
dst_rect.x, dst_rect.y,
Ecore_Evas: Fixes for working with the xcb engine. Fix some formatting. Fix dst_rect being uninitialized. Remove 'prefetch & fetch' calls as they are not used in the new xcb stuffs. SVN revision: 61379
2011-07-14 08:40:53 -07:00
dst_rect.width, dst_rect.height);
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
static void
_ecore_evas_x11_shape_input_rectangle_add(Ecore_Evas *ee, int x, int y, int w, int h)
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
{
Eina_Bool ret;
Ecore_X_Rectangle src_rect;
Ecore_X_Rectangle dst_rect;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata;
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
{
ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
"ecore_evas_x11_shape_input_rectangle_add");
return;
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata = ee->engine.data;
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
src_rect.x = x;
src_rect.y = y;
src_rect.width = w;
src_rect.height = h;
Ecore_Evas: Fixes for working with the xcb engine. Fix some formatting. Fix dst_rect being uninitialized. Remove 'prefetch & fetch' calls as they are not used in the new xcb stuffs. SVN revision: 61379
2011-07-14 08:40:53 -07:00
dst_rect.x = 0;
dst_rect.y = 0;
dst_rect.width = 0;
dst_rect.height = 0;
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
ret = _ecore_evas_x11_convert_rectangle_with_angle(ee, &dst_rect, &src_rect);
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (!edata->win_shaped_input)
edata->win_shaped_input = ecore_x_window_override_new(edata->win_root,
Ecore_Evas: Fixes for working with the xcb engine. Fix some formatting. Fix dst_rect being uninitialized. Remove 'prefetch & fetch' calls as they are not used in the new xcb stuffs. SVN revision: 61379
2011-07-14 08:40:53 -07:00
0, 0, 1, 1);
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
if (ret)
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ecore_x_window_shape_input_rectangle_add(edata->win_shaped_input,
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
dst_rect.x, dst_rect.y,
Ecore_Evas: Fixes for working with the xcb engine. Fix some formatting. Fix dst_rect being uninitialized. Remove 'prefetch & fetch' calls as they are not used in the new xcb stuffs. SVN revision: 61379
2011-07-14 08:40:53 -07:00
dst_rect.width, dst_rect.height);
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
static void
_ecore_evas_x11_shape_input_rectangle_subtract(Ecore_Evas *ee, int x, int y, int w, int h)
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
{
Eina_Bool ret;
Ecore_X_Rectangle src_rect;
Ecore_X_Rectangle dst_rect;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata;
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
{
ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
"ecore_evas_x11_shape_input_rectangle_subtract");
return;
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata = ee->engine.data;
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
src_rect.x = x;
src_rect.y = y;
src_rect.width = w;
src_rect.height = h;
Ecore_Evas: Fixes for working with the xcb engine. Fix some formatting. Fix dst_rect being uninitialized. Remove 'prefetch & fetch' calls as they are not used in the new xcb stuffs. SVN revision: 61379
2011-07-14 08:40:53 -07:00
dst_rect.x = 0;
dst_rect.y = 0;
dst_rect.width = 0;
dst_rect.height = 0;
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
ret = _ecore_evas_x11_convert_rectangle_with_angle(ee, &dst_rect, &src_rect);
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
if (!edata->win_shaped_input)
edata->win_shaped_input = ecore_x_window_override_new(edata->win_root,
Ecore_Evas: Fixes for working with the xcb engine. Fix some formatting. Fix dst_rect being uninitialized. Remove 'prefetch & fetch' calls as they are not used in the new xcb stuffs. SVN revision: 61379
2011-07-14 08:40:53 -07:00
0, 0, 1, 1);
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
if (ret)
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ecore_x_window_shape_input_rectangle_subtract(edata->win_shaped_input,
whitespaces-- SVN revision: 63531
2011-09-21 23:02:26 -07:00
dst_rect.x, dst_rect.y,
Ecore_Evas: Fixes for working with the xcb engine. Fix some formatting. Fix dst_rect being uninitialized. Remove 'prefetch & fetch' calls as they are not used in the new xcb stuffs. SVN revision: 61379
2011-07-14 08:40:53 -07:00
dst_rect.width, dst_rect.height);
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
static void
_ecore_evas_x11_shape_input_empty(Ecore_Evas *ee)
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata;
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
{
ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
"ecore_evas_x11_shape_input_empty");
return;
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata = ee->engine.data;
if (!edata->win_shaped_input)
edata->win_shaped_input = ecore_x_window_override_new(edata->win_root, 0, 0, 1, 1);
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ecore_x_window_shape_input_rectangle_set(edata->win_shaped_input, 0, 0, 0, 0);
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
static void
_ecore_evas_x11_shape_input_reset(Ecore_Evas *ee)
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata;
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
{
ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
"ecore_evas_x11_shape_input_reset");
return;
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata = ee->engine.data;
if (!edata->win_shaped_input)
edata->win_shaped_input = ecore_x_window_override_new(edata->win_root, 0, 0, 1, 1);
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ecore_x_window_shape_input_rectangle_set(edata->win_shaped_input, 0, 0, 65535, 65535);
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
static void
_ecore_evas_x11_shape_input_apply(Ecore_Evas *ee)
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
{
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
Ecore_Evas_Engine_Data_X11 *edata;
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
{
ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
"ecore_evas_x11_shape_input_apply");
return;
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
edata = ee->engine.data;
if (!edata->win_shaped_input) return;
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
ecore_x_window_shape_input_window_set(ee->prop.window, edata->win_shaped_input);
}
static Ecore_Evas_Interface_X11 *
_ecore_evas_x_interface_x11_new(void)
{
Ecore_Evas_Interface_X11 *iface;
iface = calloc(1, sizeof(Ecore_Evas_Interface_X11));
if (!iface) return NULL;
iface->base.name = interface_x11_name;
iface->base.version = interface_x11_version;
iface->leader_set = _ecore_evas_x11_leader_set;
iface->leader_get = _ecore_evas_x11_leader_get;
iface->leader_default_set = _ecore_evas_x11_leader_default_set;
iface->shape_input_rectangle_set = _ecore_evas_x11_shape_input_rectangle_set;
iface->shape_input_rectangle_add = _ecore_evas_x11_shape_input_rectangle_add;
iface->shape_input_rectangle_subtract = _ecore_evas_x11_shape_input_rectangle_subtract;
iface->shape_input_empty = _ecore_evas_x11_shape_input_empty;
iface->shape_input_reset = _ecore_evas_x11_shape_input_reset;
iface->shape_input_reset = _ecore_evas_x11_shape_input_apply;
return iface;
}
#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
static Ecore_Evas_Interface_Software_X11 *
_ecore_evas_x_interface_software_x11_new(void)
{
Ecore_Evas_Interface_Software_X11 *iface;
iface = calloc(1, sizeof(Ecore_Evas_Interface_Software_X11));
if (!iface) return NULL;
iface->base.name = interface_software_x11_name;
iface->base.version = interface_software_x11_version;
iface->window_get = _ecore_evas_software_x11_window_get;
Add code for ecore_evas_<engine>_pixmap_new/get functions. - Add "pixmap" structure to engine_data. - Free the front and back pixmaps when the ecore_evas gets freed. - On resize, drop the backing pixmap if size is different. - Before we render, check pixmap size vs EE size and create new backing pixmap if needed. - After we have rendered into the backing pixmap, flip it to the front so that any calls to "pixmap_get" will return the proper one. - Add pixmap_new_internal code (the actual guts for all this) NB: These can be used to create an internally double-buffered ecore_evas that renders to a pixmap (not a window). Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-05 02:38:43 -07:00
iface->pixmap_get = _ecore_evas_software_x11_pixmap_get;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
iface->resize_set = _ecore_evas_software_x11_direct_resize_set;
iface->resize_get = _ecore_evas_software_x11_direct_resize_get;
iface->extra_event_window_add = _ecore_evas_software_x11_extra_event_window_add;
Add engine interface code for: - ecore_evas_pixmap_visual_get - ecore_evas_pixmap_colormap_get - ecore_evas_pixmap_depth_get Assign interface functions for above when creating the new interface. When creating the pixmap, store the visual and colormap for later retrieval. Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-11 02:47:08 -07:00
iface->pixmap_visual_get = _ecore_evas_software_x11_pixmap_visual_get;
iface->pixmap_colormap_get = _ecore_evas_software_x11_pixmap_colormap_get;
iface->pixmap_depth_get = _ecore_evas_software_x11_pixmap_depth_get;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
return iface;
}
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
#endif
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
#ifdef BUILD_ECORE_EVAS_OPENGL_X11
static Ecore_Evas_Interface_Gl_X11 *
_ecore_evas_x_interface_gl_x11_new(void)
{
Ecore_Evas_Interface_Gl_X11 *iface;
iface = calloc(1, sizeof(Ecore_Evas_Interface_Gl_X11));
if (!iface) return NULL;
iface->base.name = interface_gl_x11_name;
iface->base.version = interface_gl_x11_version;
iface->window_get = _ecore_evas_gl_x11_window_get;
Add code for gl_pixmap_new and pixmap_get functions Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-07 23:21:14 -07:00
iface->pixmap_get = _ecore_evas_gl_x11_pixmap_get;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
iface->resize_set = _ecore_evas_gl_x11_direct_resize_set;
iface->resize_get = _ecore_evas_gl_x11_direct_resize_get;
efl: warnings-- SVN revision: 82273
2013-01-05 06:04:22 -08:00
iface->extra_event_window_add = _ecore_evas_gl_x11_extra_event_window_add;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
iface->pre_post_swap_callback_set = _ecore_evas_gl_x11_pre_post_swap_callback_set;
Add engine interface code for: - ecore_evas_pixmap_visual_get - ecore_evas_pixmap_colormap_get - ecore_evas_pixmap_depth_get Assign interface functions for above when creating the new interface. When creating the pixmap, store the visual and colormap for later retrieval. Signed-off-by: Chris Michael <cp.michael@samsung.com>
2013-07-11 02:47:08 -07:00
iface->pixmap_visual_get = _ecore_evas_gl_x11_pixmap_visual_get;
iface->pixmap_colormap_get = _ecore_evas_gl_x11_pixmap_colormap_get;
iface->pixmap_depth_get = _ecore_evas_gl_x11_pixmap_depth_get;
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
return iface;
From: Doyun Kang <doyoun.kang@samsung.com> Add support for shape input setting and modification (with fixes/modifications and extensions added tomake it more complete). SVN revision: 58621
2011-04-13 02:06:05 -07:00
}
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
#endif