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
This fixes Phab #T611. Previously, windows which were opaque would
become transparent after being hidden and then shown. We fix that by a
call to ecore_wl_window_alpha_set when the window gets shown. This
patch also brings the wayland_egl hide code more inline with the shm
hide code by testing if the surface does not match the existing one.
Signed-off-by: Chris Michael <cp.michael@samsung.com>
Ecore_wl_window_resize essentially tells the shell to start the resize
process. We should have the evas engine info's resize_edge updated
Before we start that process so that Evas knows where the resize is
occuring from
Signed-off-by: Chris Michael <cp.michael@samsung.com>
This callback must be manually destroyed and removed on
ecore_evas_hide(), because it won't be delivered anymore after the
surface is destroyed. If the callback still exists, the engine will find
it and avoid doing a new redraw until it is finally called.
Maybe the correct thing to do is to keep this callback in the
Ecore_Wl_Window struct, and have some functions to set/unset it, so it
gets destroyed when the window is hidden. Or when the surface is
destroyed.
This reduces code duplication for ecore_evas resize routines inside
wayland engines by using a common _ecore_evas_wl_common_resize
function as the resize code for both engines was the same anyway.
Signed-off-by: Chris Michael <cp.michael@samsung.com>
These two APIs will save the title and class_name inside
Ecore_Wl_Window, so if they are called before the shell surface is
created, the stored names will be used later when the window is finally
shown (shell surface is created).
This way we are also hiding the shell surface from ecore_evas modules.
This is a configure event info, so put it in the right place. Some
places adding edges info were also removed, which means that they were
redundant.
Tested with <Meta> + middle click resize, and with window border resize,
on all the edges. Apparently, nothing breaks.
At the end of the ecore_wl_init() function, send a sync request to the
server, and add a callback listener to the "done" event. When this event
is received, we are sure that all the registry bind requests done so
far were processed already, and that the registry and globals are
available and can be used.
Now, on the functions that request interfaces or registry, we call
_ecore_wl_init_wait(), which will check if the callback was received
already (that means that all requests inside the init were processed).
If it was not yet, then we wait until receiving that callback, before
returning the requested data.
NB: We will still create all new canvases as alpha by setting it in evas,
however this allows the 'state' of ecore_evas_alpha_set/get to retain
it's original functionality and thus accurately report what a client
application May have set alpha value too.
NB: Fixes Phab Ticket T350
Signed-off-by: Chris Michael <cp.michael@samsung.com>
Remove calls to ecore_wl_window_update_size inside the alpha &
transparent_do functions (this call not needed here anymore).
NB: This is needed due to recent frame "fixes". Basically, even tho we
set the opaque region correctly on a surface now, if the canvas itself
is not alpha, then we will end up with a black "spacer" around the
window.
NNB: Tested Both engines with terminology (both translucent and not) and also the window state test in elementary.
Signed-off-by: Chris Michael <cp.michael@samsung.com>
erroneous calls to engine_setup code if we check surface validity.
NB: Short Version: Don't reassign surface if we don't need to.
NB: Prior to this, during a call to ecore_evas_show we would always
Reset the evas engine data (which was basically triggering code to
tear down and reconstruct all the engine internals including the
buffers and the swapper). By checking surface validity first, we can
potentially avoid all that teardown and reconstruction Thus resulting
in faster "show" speed.
Signed-off-by: Chris Michael <cp.michael@samsung.com>
AND get the surface for it...so that we can pass the surface directly
to the evas engine.
NB: Works. nothing broken.
Signed-off-by: Chris Michael <cp.michael@samsung.com>
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.
If Ecore_Evas is requested to draw its own frame, then set the
framespace too. Otherwise, keep it at 0,0 + 0x0, which means not
framespace offset at all (and the window will have exactly the
requested size).
This reverts commit 809144780e.
Conflicts:
src/modules/ecore_evas/engines/wayland/ecore_evas_wayland_shm.c
Signed-off-by: Chris Michael <cp.michael@samsung.com>
Since we don't have a changed state callback on Wayland, just call the
changed_state callback of Ecore_Evas from the configure callback.
There's no need to add the Ecore_Job that will send the event later.
This makes the code cleaner, simpler, and will call the callback when
the configure event is received, which is a good place to check for the
changes.
Reduce duplicated code in ecore_evas_wl_resize and just call the
_common_resize function
Fix segfault on elm app closing
Signed-off-by: Chris Michael <cp.michael@samsung.com>
Instead of moving the objects by adding the framespace offset to them,
use this offset when rendering them. This way there's no change in the
object's geometry/position, it works correctly with map, and will be
automatically updated in case that the framespace values change (for
instance if one sets a window to borderless).
There are 2 main places where changes were needed:
- output redraws, when they come from an object being changed, must be
add the framespace offset to their damaged area;
- checks to see if the object is inside a given rendering area, must
also add this offset, since the object is actually being rendered on
a different position;
Add 4 rectangles to be used as border of the window, instead of a single
rectangle under the framespace. This allows to move the frame object to
the top layer, instead of staying on the lowest layer. With the frame
over the other objects, there's no need of framespace clipper object,
which causes several bugs.
The frame should not stay in the same layer as the other objects. If the
application wants to allow it to be on top of the content, then it must
provide a custom frame object and set it to that layer.
NOTE: Should we make Elementary's be on a lower layer too?
This will update the edges info inside the Evas_Engine_Info, and make it
correctly resize to the top/left if needed.
Also call ecore_wl_window_buffer_attach() on the egl engine, since it's
needed after the ecore_wl_window_update_size().
Using the server_allocation/allocation to determine the resize offset
was not completely precise, and causing the window to not always resize
correctly.
Additionally, calling evas_engine_info_set() on every resize step caused
the window content to blink and resize very slow, because the swap
buffer, swapper, and everything were being destroyed and recreated. Now
only the swapbuf_reconfigure is being called during the resize, which is
way faster.
This will allow it to report to Ecore_Evas that the window has changed
its state. Elementary uses this to update its maximized/fullscreen/other
window states internal information.
The code that uses this callback is also added to Ecore_Evas.
SVN revision: 83625
Before this commit, when using any of the wayland backends, if the user
requested an ecore_evas window of width x height, the reported size of
the window would include the frames width and height.
Now the requested size is stored on the ecore_evas and reported when
ecore_evas_geometry_get() is used, although the ecore_evas is still
created with additional space for the frame area.
This is one of the reasons causing bug #1673.
SVN revision: 83042
Implementing support for loadables modules. It makes the engines been
loaded when they are needed. It not breakes the api, so each engine
still has its own api.
The implementation basically is:
* Functions that creates Ecore_Evas, for example
ecore_evas_software_x11_new, request to load its module and then get
the module's function to create the Ecore_Evas.
* The other functions such as \(.*\)_window_get from the Ecore_Evas
its interface and then call the appropriate method.
* As there is no unified interface to communicate with the engines
(not break api problem), all interfaces were declared in
ecore_evas_private.h
* Now the data necessary for each module is not declared in the
Ecore_Evas_Engine structure, instead of this, the struct has a void
pointer that is used by the modules.
* In this first moment engines as software_x11 and gl_x11 were put
together in the same module, but obviously exporting all the things
necessary.
SVN revision: 80280