mirror of
https://gitlab.gnome.org/GNOME/gtk.git
synced 2024-12-26 13:41:07 +00:00
0c67b367ac
Do the backend call before changing the stacking order in the frontend. This is necessary so the backend can look at the current stacking order to determine if it will change.
373 lines
12 KiB
C
373 lines
12 KiB
C
/* GDK - The GIMP Drawing Kit
|
|
* Copyright (C) 2023 Red Hat, Inc.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include "gdksubsurfaceprivate.h"
|
|
#include "gdksurfaceprivate.h"
|
|
#include "gdktexture.h"
|
|
#include "gsk/gskrectprivate.h"
|
|
|
|
G_DEFINE_TYPE (GdkSubsurface, gdk_subsurface, G_TYPE_OBJECT)
|
|
|
|
static void
|
|
gdk_subsurface_init (GdkSubsurface *self)
|
|
{
|
|
}
|
|
|
|
static void
|
|
gdk_subsurface_finalize (GObject *object)
|
|
{
|
|
GdkSubsurface *subsurface = GDK_SUBSURFACE (object);
|
|
|
|
g_ptr_array_remove (subsurface->parent->subsurfaces, subsurface);
|
|
g_clear_object (&subsurface->parent);
|
|
|
|
G_OBJECT_CLASS (gdk_subsurface_parent_class)->finalize (object);
|
|
}
|
|
|
|
static void
|
|
gdk_subsurface_class_init (GdkSubsurfaceClass *class)
|
|
{
|
|
GObjectClass *object_class = G_OBJECT_CLASS (class);
|
|
|
|
object_class->finalize = gdk_subsurface_finalize;
|
|
}
|
|
|
|
/*< private >
|
|
* gdk_subsurface_get_parent:
|
|
* @subsurface: a `GdkSubsurface`
|
|
*
|
|
* Returns the parent surface of @subsurface.
|
|
*
|
|
* Returns: the parent surface
|
|
*/
|
|
GdkSurface *
|
|
gdk_subsurface_get_parent (GdkSubsurface *subsurface)
|
|
{
|
|
g_return_val_if_fail (GDK_IS_SUBSURFACE (subsurface), NULL);
|
|
|
|
return subsurface->parent;
|
|
}
|
|
|
|
static void
|
|
remove_subsurface (GdkSubsurface *subsurface)
|
|
{
|
|
GdkSurface *parent = subsurface->parent;
|
|
|
|
if (parent->subsurfaces_above == subsurface)
|
|
parent->subsurfaces_above = subsurface->sibling_above;
|
|
if (parent->subsurfaces_below == subsurface)
|
|
parent->subsurfaces_below = subsurface->sibling_below;
|
|
|
|
if (subsurface->sibling_above)
|
|
subsurface->sibling_above->sibling_below = subsurface->sibling_below;
|
|
if (subsurface->sibling_below)
|
|
subsurface->sibling_below->sibling_above = subsurface->sibling_above;
|
|
|
|
subsurface->sibling_above = NULL;
|
|
subsurface->sibling_below = NULL;
|
|
}
|
|
|
|
static void
|
|
insert_subsurface (GdkSubsurface *subsurface,
|
|
gboolean above,
|
|
GdkSubsurface *sibling)
|
|
{
|
|
GdkSurface *parent = subsurface->parent;
|
|
|
|
subsurface->above_parent = sibling->above_parent;
|
|
|
|
if (above)
|
|
{
|
|
subsurface->sibling_above = sibling->sibling_above;
|
|
sibling->sibling_above = subsurface;
|
|
subsurface->sibling_below = sibling;
|
|
if (subsurface->sibling_above)
|
|
subsurface->sibling_above->sibling_below = subsurface;
|
|
|
|
if (parent->subsurfaces_below == sibling)
|
|
parent->subsurfaces_below = subsurface;
|
|
}
|
|
else
|
|
{
|
|
subsurface->sibling_below = sibling->sibling_below;
|
|
sibling->sibling_below = subsurface;
|
|
subsurface->sibling_above = sibling;
|
|
if (subsurface->sibling_below)
|
|
subsurface->sibling_below->sibling_above = subsurface;
|
|
|
|
if (parent->subsurfaces_above == sibling)
|
|
parent->subsurfaces_above = subsurface;
|
|
}
|
|
}
|
|
|
|
/*< private >
|
|
* gdk_subsurface_attach:
|
|
* @subsurface: the `GdkSubsurface`
|
|
* @texture: the texture to attach. This typically has to be a `GdkDmabufTexture`
|
|
* @source: the source rectangle (i.e. the subset of the texture) to display
|
|
* @dest: the dest rectangle, in application pixels, relative to the parent surface.
|
|
* It must be integral in application and device pixels, or attaching will fail
|
|
* @transform: the transform to apply to the texture contents before displaying
|
|
* @background: (nullable): the background rectangle, in application pixels relative
|
|
* to the parent surface. This tells GDK to put a black background of this
|
|
* size below the subsurface. It must be integral in application and device pixels,
|
|
* or attaching will fail
|
|
* @above: whether the subsurface should be above its sibling
|
|
* @sibling: (nullable): the sibling subsurface to stack relative to, or `NULL` to
|
|
* stack relative to the parent surface
|
|
*
|
|
* Attaches content to a subsurface.
|
|
*
|
|
* This function takes all the necessary arguments to determine the subsurface
|
|
* configuration, including its position, size, content, background and stacking.
|
|
*
|
|
* Returns: `TRUE` if the attaching succeeded
|
|
*/
|
|
gboolean
|
|
gdk_subsurface_attach (GdkSubsurface *subsurface,
|
|
GdkTexture *texture,
|
|
const graphene_rect_t *source,
|
|
const graphene_rect_t *dest,
|
|
GdkTextureTransform transform,
|
|
const graphene_rect_t *background,
|
|
gboolean above,
|
|
GdkSubsurface *sibling)
|
|
{
|
|
GdkSurface *parent = subsurface->parent;
|
|
gboolean result;
|
|
|
|
g_return_val_if_fail (GDK_IS_SUBSURFACE (subsurface), FALSE);
|
|
g_return_val_if_fail (GDK_IS_TEXTURE (texture), FALSE);
|
|
g_return_val_if_fail (source != NULL &&
|
|
gsk_rect_contains_rect (&GRAPHENE_RECT_INIT (0, 0,
|
|
gdk_texture_get_width (texture),
|
|
gdk_texture_get_height (texture)),
|
|
source), FALSE);
|
|
g_return_val_if_fail (dest != NULL, FALSE);
|
|
g_return_val_if_fail (sibling != subsurface, FALSE);
|
|
g_return_val_if_fail (sibling == NULL || GDK_IS_SUBSURFACE (sibling), FALSE);
|
|
g_return_val_if_fail (sibling == NULL || sibling->parent == subsurface->parent, FALSE);
|
|
|
|
result = GDK_SUBSURFACE_GET_CLASS (subsurface)->attach (subsurface,
|
|
texture,
|
|
source,
|
|
dest,
|
|
transform,
|
|
background,
|
|
above,
|
|
sibling);
|
|
|
|
remove_subsurface (subsurface);
|
|
|
|
if (sibling)
|
|
{
|
|
insert_subsurface (subsurface, above, sibling);
|
|
}
|
|
else
|
|
{
|
|
sibling = above ? parent->subsurfaces_above : parent->subsurfaces_below;
|
|
|
|
if (sibling)
|
|
{
|
|
insert_subsurface (subsurface, !above, sibling);
|
|
}
|
|
else
|
|
{
|
|
subsurface->above_parent = above;
|
|
|
|
if (above)
|
|
parent->subsurfaces_above = subsurface;
|
|
else
|
|
parent->subsurfaces_below = subsurface;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/*< private >
|
|
* gdk_subsurface_detach:
|
|
* @subsurface: a `GdkSubsurface`
|
|
*
|
|
* Hides the subsurface.
|
|
*
|
|
* To show it again, you need to call gdk_subsurface_attach().
|
|
*/
|
|
void
|
|
gdk_subsurface_detach (GdkSubsurface *subsurface)
|
|
{
|
|
g_return_if_fail (GDK_IS_SUBSURFACE (subsurface));
|
|
|
|
remove_subsurface (subsurface);
|
|
|
|
GDK_SUBSURFACE_GET_CLASS (subsurface)->detach (subsurface);
|
|
}
|
|
|
|
/*< private >
|
|
* gdk_subsurface_get_texture:
|
|
* @subsurface: a `GdkSubsurface`
|
|
*
|
|
* Gets the texture that is currently displayed by the subsurface.
|
|
*
|
|
* Returns: (nullable): the texture that is displayed
|
|
*/
|
|
GdkTexture *
|
|
gdk_subsurface_get_texture (GdkSubsurface *subsurface)
|
|
{
|
|
g_return_val_if_fail (GDK_IS_SUBSURFACE (subsurface), NULL);
|
|
|
|
return GDK_SUBSURFACE_GET_CLASS (subsurface)->get_texture (subsurface);
|
|
}
|
|
|
|
/*< private >
|
|
* gdk_subsurface_get_source_rect:
|
|
* @subsurface: a `GdkSubsurface`
|
|
* @rect: (out caller-allocates): return location for the rectangle
|
|
*
|
|
* Returns the source rect that was specified in the most recent
|
|
* gdk_subsurface_attach() call for @subsurface.
|
|
*/
|
|
void
|
|
gdk_subsurface_get_source_rect (GdkSubsurface *subsurface,
|
|
graphene_rect_t *rect)
|
|
{
|
|
g_return_if_fail (GDK_IS_SUBSURFACE (subsurface));
|
|
g_return_if_fail (rect != NULL);
|
|
|
|
GDK_SUBSURFACE_GET_CLASS (subsurface)->get_source_rect (subsurface, rect);
|
|
}
|
|
|
|
/*< private >
|
|
* gdk_subsurface_get_texture_rect:
|
|
* @subsurface: a `GdkSubsurface`
|
|
* @rect: (out caller-allocates): return location for the rectangle
|
|
*
|
|
* Returns the texture rect that was specified in the most recent
|
|
* gdk_subsurface_attach() call for @subsurface.
|
|
*/
|
|
void
|
|
gdk_subsurface_get_texture_rect (GdkSubsurface *subsurface,
|
|
graphene_rect_t *rect)
|
|
{
|
|
g_return_if_fail (GDK_IS_SUBSURFACE (subsurface));
|
|
g_return_if_fail (rect != NULL);
|
|
|
|
GDK_SUBSURFACE_GET_CLASS (subsurface)->get_texture_rect (subsurface, rect);
|
|
}
|
|
|
|
/*< private >
|
|
* gdk_subsurface_is_above_parent:
|
|
* @subsurface: a `GdkSubsurface`
|
|
*
|
|
* Returns whether the subsurface is above the parent surface
|
|
* or below. Note that a subsurface can be above its parent
|
|
* surface, and still be covered by sibling subsurfaces.
|
|
*
|
|
* Returns: `TRUE` if @subsurface is above its parent
|
|
*/
|
|
gboolean
|
|
gdk_subsurface_is_above_parent (GdkSubsurface *subsurface)
|
|
{
|
|
g_return_val_if_fail (GDK_IS_SUBSURFACE (subsurface), FALSE);
|
|
|
|
return subsurface->above_parent;
|
|
}
|
|
|
|
/*< private>
|
|
* gdk_subsurface_get_sibling:
|
|
* @subsurface: the `GdkSubsurface`
|
|
* @above: whether to get the subsurface above
|
|
*
|
|
* Returns the subsurface above (or below) @subsurface in
|
|
* the stacking order.
|
|
*
|
|
* Returns: the sibling, or `NULL` if there is none.
|
|
*/
|
|
GdkSubsurface *
|
|
gdk_subsurface_get_sibling (GdkSubsurface *subsurface,
|
|
gboolean above)
|
|
{
|
|
g_return_val_if_fail (GDK_IS_SUBSURFACE (subsurface), NULL);
|
|
|
|
if (above)
|
|
return subsurface->sibling_above;
|
|
else
|
|
return subsurface->sibling_below;
|
|
}
|
|
|
|
/*< private >
|
|
* gdk_subsurface_get_transform:
|
|
* @subsurface: a `GdkSubsurface`
|
|
*
|
|
* Returns the transform that was specified in the most recent call to
|
|
* gdk_subsurface_attach() call for @subsurface.
|
|
*
|
|
* Returns: the transform
|
|
*/
|
|
GdkTextureTransform
|
|
gdk_subsurface_get_transform (GdkSubsurface *subsurface)
|
|
{
|
|
g_return_val_if_fail (GDK_IS_SUBSURFACE (subsurface), GDK_TEXTURE_TRANSFORM_NORMAL);
|
|
|
|
return GDK_SUBSURFACE_GET_CLASS (subsurface)->get_transform (subsurface);
|
|
}
|
|
|
|
/*< private >
|
|
* gdk_subsurface_get_background_rect:
|
|
* @subsurface: a `GdkSubsurface`
|
|
* @rect: (out caller-allocates): return location for the rectangle
|
|
*
|
|
* Obtains the background rect that was specified in the most recent
|
|
* gdk_subsurface_attach() call for @subsurface.
|
|
*
|
|
* Returns: `TRUE` if @subsurface has a background
|
|
*/
|
|
gboolean
|
|
gdk_subsurface_get_background_rect (GdkSubsurface *subsurface,
|
|
graphene_rect_t *rect)
|
|
{
|
|
g_return_val_if_fail (GDK_IS_SUBSURFACE (subsurface), FALSE);
|
|
g_return_val_if_fail (rect != NULL, FALSE);
|
|
|
|
return GDK_SUBSURFACE_GET_CLASS (subsurface)->get_background_rect (subsurface, rect);
|
|
}
|
|
|
|
/*< private >
|
|
* gdk_subsurface_get_bounds:
|
|
* @subsurface: a `GdkSubsurface`
|
|
* @bounds: (out caller-allocates): return location for the bounds
|
|
*
|
|
* Returns the bounds of the subsurface.
|
|
*
|
|
* The bounds are the union of the texture and background rects.
|
|
*/
|
|
void
|
|
gdk_subsurface_get_bounds (GdkSubsurface *subsurface,
|
|
graphene_rect_t *bounds)
|
|
{
|
|
graphene_rect_t background;
|
|
|
|
g_return_if_fail (GDK_IS_SUBSURFACE (subsurface));
|
|
g_return_if_fail (bounds != NULL);
|
|
|
|
gdk_subsurface_get_texture_rect (subsurface, bounds);
|
|
if (gdk_subsurface_get_background_rect (subsurface, &background))
|
|
graphene_rect_union (bounds, &background, bounds);
|
|
}
|