kimcinoo
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
efl/src/modules/ecore_evas/engines/wayland/ecore_evas_wayland_private.h

58 lines
1.4 KiB
C
Raw Normal View History

ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
#ifndef _ECORE_EVAS_WAYLAND_PRIVATE_H_
ecore-evas-wayland: Minor formatting fix NB: No functional changes, just formatting Signed-off-by: Chris Michael <cp.michael@samsung.com>
2016-12-02 11:00:04 -08:00
# define _ECORE_EVAS_WAYLAND_PRIVATE_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-evas-wayland: Minor formatting fix NB: No functional changes, just formatting Signed-off-by: Chris Michael <cp.michael@samsung.com>
2016-12-02 11:00:04 -08:00
# ifdef HAVE_CONFIG_H
# include "config.h"
# 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
ecore-evas-wayland: Minor formatting fix NB: No functional changes, just formatting Signed-off-by: Chris Michael <cp.michael@samsung.com>
2016-12-02 11:00:04 -08:00
# define ECORE_EVAS_INTERNAL
ecore_evas: Register direct input cb from modules If the ecore_evas modules were using ecore_event_window_register() then they can also redirect everything though the direct callback instead.
2016-05-10 21:29:23 -07:00
ecore-evas-wayland: Minor formatting fix NB: No functional changes, just formatting Signed-off-by: Chris Michael <cp.michael@samsung.com>
2016-12-02 11:00:04 -08:00
# ifndef ELEMENTARY_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
//#define LOGFNS 1
ecore-evas-wayland: Minor formatting fix NB: No functional changes, just formatting Signed-off-by: Chris Michael <cp.michael@samsung.com>
2016-12-02 11:00:04 -08:00
# ifdef LOGFNS
# include <stdio.h>
# define LOGFN(fl, ln, fn) \
ecore_evas: Make the engines loadable modules Implementing support for loadables modules. It makes the engines been loaded when they are needed. It not breakes the api, so each engine still has its own api. The implementation basically is: * Functions that creates Ecore_Evas, for example ecore_evas_software_x11_new, request to load its module and then get the module's function to create the Ecore_Evas. * The other functions such as \(.*\)_window_get from the Ecore_Evas its interface and then call the appropriate method. * As there is no unified interface to communicate with the engines (not break api problem), all interfaces were declared in ecore_evas_private.h * Now the data necessary for each module is not declared in the Ecore_Evas_Engine structure, instead of this, the struct has a void pointer that is used by the modules. * In this first moment engines as software_x11 and gl_x11 were put together in the same module, but obviously exporting all the things necessary. SVN revision: 80280
2012-12-05 13:15:42 -08:00
printf("-ECORE_EVAS-WL: %25s: %5i - %s\n", fl, ln, fn);
ecore-evas-wayland: Minor formatting fix NB: No functional changes, just formatting Signed-off-by: Chris Michael <cp.michael@samsung.com>
2016-12-02 11:00:04 -08:00
# else
# define LOGFN(fl, ln, fn)
# endif
# include <Eina.h>
# include <Ecore.h>
# include <Ecore_Input.h>
# include <Ecore_Input_Evas.h>
# include <Ecore_Wl2.h>
# include <Ecore_Evas.h>
# endif
# include "ecore_wl2_private.h"
# include "ecore_private.h"
# include "ecore_evas_private.h"
# include "ecore_evas_wayland.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
typedef struct _Ecore_Evas_Engine_Wl_Data Ecore_Evas_Engine_Wl_Data;
Fix formatting. Signed-off-by: Christopher Michael <cp.michael@samsung.com>
2013-02-05 04:48:25 -08:00
struct _Ecore_Evas_Engine_Wl_Data
{
ecore-wl2: Port Ecore_Evas engines to use Ecore_Wl2 code Signed-off-by: Chris Michael <cp.michael@samsung.com>
2015-09-28 10:42:38 -07:00
Ecore_Wl2_Display *display;
wayland: implement session recovery add support for reconnecting wayland applications if the compositor dies disconnect -> destroy gl ctx + image textures -> block rendering -> reconnect -> create gl ctx -> create image textures -> unblock rendering -> sprinkle special seasoning on top -> just like ma used to make #SamsungFeatures @feature
2016-05-05 07:45:59 -07:00
Eina_List *regen_objs;
ecore-wl2: Port Ecore_Evas engines to use Ecore_Wl2 code Signed-off-by: Chris Michael <cp.michael@samsung.com>
2015-09-28 10:42:38 -07:00
Ecore_Wl2_Window *parent, *win;
wayland: implement session recovery add support for reconnecting wayland applications if the compositor dies disconnect -> destroy gl ctx + image textures -> block rendering -> reconnect -> create gl ctx -> create image textures -> unblock rendering -> sprinkle special seasoning on top -> just like ma used to make #SamsungFeatures @feature
2016-05-05 07:45:59 -07:00
Ecore_Event_Handler *sync_handler;
ecore_evas/wayland: Implement borderless_set engine method. It is needed to set the engine internal borderless property. Also update the border (frame) object, showing/hiding it as needed, and updating the framespace size when the frame object is handled by the engine.
2013-05-08 15:18:55 -07:00
int fx, fy, fw, fh;
wayland: hook engine data from elm_win and update rect with evas size the only way to accurately calculate the "evas" size in the engine from window geometry is to have the size of the frame available to subtract from window geometry window geometry is NOT framespace--framespace is the entire csd region, possibly containing a shadow, and window geometry is explicitly the region occupied by the window, ie. not the shadowed part. not my ideal solution to the synchronization issue here, but I guess this is a benefit of the unified tree fix T3396
2016-04-07 11:14:14 -07:00
Eina_Rectangle content;
ecore-evas-wayland: add frame callback listener during render when a render occurs, frame callbacks must be managed in order to ensure successful rendering for future frames. the best place to do this is in the engine here, since this is the lowest-level place which has access to both the wl_surface as well as the evas rendering state ref T2784
2015-10-16 12:51:06 -07:00
struct wl_callback *anim_callback;
ecore-evas wayland: use www protocol when available handle www protocol events and store the provided data into engine data Signed-off-by: Derek Foreman <derekf@osg.samsung.com>
2016-03-24 10:44:21 -07:00
int x_rel;
int y_rel;
uint32_t timestamp;
ecore_evas/wayland: handle added / removed seats Create or delete evas_devices with class EVAS_DEVICE_CLASS_SEAT for seats on each ecore_evas created so far. Initially it's named considering its Wayland id.
2016-10-03 08:34:10 -07:00
Eina_List *devices_list;
ecore-evas wayland: use www protocol when available handle www protocol events and store the provided data into engine data Signed-off-by: Derek Foreman <derekf@osg.samsung.com>
2016-03-24 10:44:21 -07:00
Eina_Bool dragging : 1;
ecore-evas-wl: Defer creating surfaces for wayland canvas This code adds support for deferring of surface creation and showing inside Ecore_Evas Wayland. This is needed for Enlightenment so that it does not try to create or show surfaces until the compositor has had a chance to sync globals. This fixes an issue where early surface creation would cause a crash in the compositor due to globals not being syncd. @fix Signed-off-by: Chris Michael <cp.michael@samsung.com>
2015-12-11 08:26:24 -08:00
Eina_Bool sync_done : 1;
Eina_Bool defer_show : 1;
wayland: implement session recovery add support for reconnecting wayland applications if the compositor dies disconnect -> destroy gl ctx + image textures -> block rendering -> reconnect -> create gl ctx -> create image textures -> unblock rendering -> sprinkle special seasoning on top -> just like ma used to make #SamsungFeatures @feature
2016-05-05 07:45:59 -07:00
Eina_Bool reset_pending : 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
};
ecore_evas_wayland: Minimize differences between shm and egl Finally bring these together as much as possible to avoid future diversions when bugs are only fixed in one or the other. There are functional changes - state tracking for client side effects is now added to the shm engine, some bug fixes for the egl engine have been brought to the shm engine.
2016-11-02 11:13:07 -07:00
Ecore_Evas *_ecore_evas_wl_common_new_internal(const char *disp_name, unsigned int parent, int x, int y, int w, int h, Eina_Bool frame, const char *engine_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
#endif /* _ECORE_EVAS_WAYLAND_PRIVATE_H_ */