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>
In the window_configure callback, reduce duplicated/not needed code.
Account for rotation when getting new size during common_rotation_set.
Reduce duplicated code in ecore_evas_wl_resize function and just call
the _common_resize function (as that already has most of this code).
Fix issue of Segfault on elm app closing:
- During hide we need to call evas_sync to make sure the async
render has flushed out everything that is pending.
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?
The real canvas size contains enough space for rendering the frame, but
ecore_evas_geometry_get() should be consistent accross all the engines
and report only the client area.
Maybe we should switch to use -Wno-unused-parameter in our default cflags?
I mean unused parameters are really common and I do not see their harm.
Using -Wno-unused-parameter would let us remove all the cluttered EINA_UNUSED
and __UNUSED__ and also be safe when a paramter gets is use later as the
compiler could optimize it out when tagged with unused. Still we would avoid
the warnings to find the important ones.
Jenkins as well as klocwork complained here as data is already used for
the parameter of the function and we shadow it here locally. Does not look
like it would really harm us here but better avoid it.
When creating windows directly with Ecore_Evas, instead of using
Elementary, a default smart object is provided for the frame (client
side window decorations).
Now this smart object inherits from the clipped smart object, which
means that all its member objects will be clipped to its main clipper,
being skipped when the framespace clipper checks for objects without a
clipper.
Fix a ticket, which I don't remember the number because trac doesn't
work.
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.
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().
This will force the window to correctly update its size when the event
is received by the compositor, rather than just after an
ecore_evas_resize().
It fixes the window resizing of non-elementary applications, since
the elementary window already deals with such resize by calling
ecore_evas_resize.
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.
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
Again they are already used but nobody did bother to declare or define them.
I have choosen the name with what came into my head first and version seem
to be 1 in other engines, too. Evas engine gods please review.
SVN revision: 83826
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
It's needed to set the edge where the middle click is being done in
order to allow Evas know which direction the resize should take.
SVN revision: 83610