mirror of
https://gitlab.gnome.org/GNOME/gtk.git
synced 2024-12-26 13:41:07 +00:00
dc6e831524
The term "hdr" is so overloaded, we shouldn't use them anywhere, except from maybe describing all of this work in blog posts and other marketing materials. So do renames: * hdr => high_depth * request_hdr => prefers_high_depth This more accurately describes what is going on.
465 lines
15 KiB
C
465 lines
15 KiB
C
/* GDK - The GIMP Drawing Kit
|
|
*
|
|
* gdkdrawcontext.c: base class for rendering system support
|
|
*
|
|
* Copyright © 2016 Benjamin Otte
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library 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
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include "gdkdrawcontextprivate.h"
|
|
|
|
#include "gdkdebug.h"
|
|
#include "gdkintl.h"
|
|
#include "gdkprofilerprivate.h"
|
|
#include "gdksurfaceprivate.h"
|
|
|
|
/**
|
|
* GdkDrawContext:
|
|
*
|
|
* Base class for objects implementing different rendering methods.
|
|
*
|
|
* `GdkDrawContext` is the base object used by contexts implementing different
|
|
* rendering methods, such as [class@Gdk.CairoContext] or [class@Gdk.GLContext].
|
|
* It provides shared functionality between those contexts.
|
|
*
|
|
* You will always interact with one of those subclasses.
|
|
*
|
|
* A `GdkDrawContext` is always associated with a single toplevel surface.
|
|
*/
|
|
|
|
typedef struct _GdkDrawContextPrivate GdkDrawContextPrivate;
|
|
|
|
struct _GdkDrawContextPrivate {
|
|
GdkDisplay *display;
|
|
GdkSurface *surface;
|
|
|
|
cairo_region_t *frame_region;
|
|
};
|
|
|
|
enum {
|
|
PROP_0,
|
|
|
|
PROP_DISPLAY,
|
|
PROP_SURFACE,
|
|
|
|
LAST_PROP
|
|
};
|
|
|
|
static GParamSpec *pspecs[LAST_PROP] = { NULL, };
|
|
|
|
G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GdkDrawContext, gdk_draw_context, G_TYPE_OBJECT)
|
|
|
|
static void
|
|
gdk_draw_context_default_surface_resized (GdkDrawContext *context)
|
|
{
|
|
}
|
|
|
|
static void
|
|
gdk_draw_context_dispose (GObject *gobject)
|
|
{
|
|
GdkDrawContext *context = GDK_DRAW_CONTEXT (gobject);
|
|
GdkDrawContextPrivate *priv = gdk_draw_context_get_instance_private (context);
|
|
|
|
if (priv->surface)
|
|
{
|
|
priv->surface->draw_contexts = g_slist_remove (priv->surface->draw_contexts, context);
|
|
g_clear_object (&priv->surface);
|
|
}
|
|
g_clear_object (&priv->display);
|
|
|
|
G_OBJECT_CLASS (gdk_draw_context_parent_class)->dispose (gobject);
|
|
}
|
|
|
|
static void
|
|
gdk_draw_context_set_property (GObject *gobject,
|
|
guint prop_id,
|
|
const GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
GdkDrawContext *context = GDK_DRAW_CONTEXT (gobject);
|
|
GdkDrawContextPrivate *priv = gdk_draw_context_get_instance_private (context);
|
|
|
|
switch (prop_id)
|
|
{
|
|
case PROP_DISPLAY:
|
|
if (priv->display != NULL)
|
|
{
|
|
g_assert (g_value_get_object (value) == NULL);
|
|
}
|
|
else
|
|
{
|
|
priv->display = g_value_dup_object (value);
|
|
}
|
|
break;
|
|
|
|
case PROP_SURFACE:
|
|
priv->surface = g_value_dup_object (value);
|
|
if (priv->surface)
|
|
{
|
|
priv->surface->draw_contexts = g_slist_prepend (priv->surface->draw_contexts, context);
|
|
if (priv->display)
|
|
{
|
|
g_assert (priv->display == gdk_surface_get_display (priv->surface));
|
|
}
|
|
else
|
|
{
|
|
priv->display = g_object_ref (gdk_surface_get_display (priv->surface));
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gdk_draw_context_get_property (GObject *gobject,
|
|
guint prop_id,
|
|
GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
GdkDrawContext *context = GDK_DRAW_CONTEXT (gobject);
|
|
GdkDrawContextPrivate *priv = gdk_draw_context_get_instance_private (context);
|
|
|
|
switch (prop_id)
|
|
{
|
|
case PROP_DISPLAY:
|
|
g_value_set_object (value, gdk_draw_context_get_display (context));
|
|
break;
|
|
|
|
case PROP_SURFACE:
|
|
g_value_set_object (value, priv->surface);
|
|
break;
|
|
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gdk_draw_context_class_init (GdkDrawContextClass *klass)
|
|
{
|
|
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
|
|
|
|
gobject_class->set_property = gdk_draw_context_set_property;
|
|
gobject_class->get_property = gdk_draw_context_get_property;
|
|
gobject_class->dispose = gdk_draw_context_dispose;
|
|
|
|
klass->surface_resized = gdk_draw_context_default_surface_resized;
|
|
|
|
/**
|
|
* GdkDrawContext:display: (attributes org.gtk.Property.get=gdk_draw_context_get_display)
|
|
*
|
|
* The `GdkDisplay` used to create the `GdkDrawContext`.
|
|
*/
|
|
pspecs[PROP_DISPLAY] =
|
|
g_param_spec_object ("display",
|
|
P_("Display"),
|
|
P_("The GDK display used to create the context"),
|
|
GDK_TYPE_DISPLAY,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_CONSTRUCT_ONLY |
|
|
G_PARAM_STATIC_STRINGS);
|
|
|
|
/**
|
|
* GdkDrawContext:surface: (attributes org.gtk.Property.get=gdk_draw_context_get_surface)
|
|
*
|
|
* The `GdkSurface` the context is bound to.
|
|
*/
|
|
pspecs[PROP_SURFACE] =
|
|
g_param_spec_object ("surface",
|
|
P_("Surface"),
|
|
P_("The GDK surface bound to the context"),
|
|
GDK_TYPE_SURFACE,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_CONSTRUCT_ONLY |
|
|
G_PARAM_STATIC_STRINGS);
|
|
|
|
g_object_class_install_properties (gobject_class, LAST_PROP, pspecs);
|
|
}
|
|
|
|
static guint pixels_counter;
|
|
|
|
static void
|
|
gdk_draw_context_init (GdkDrawContext *self)
|
|
{
|
|
if (pixels_counter == 0)
|
|
pixels_counter = gdk_profiler_define_int_counter ("frame pixels", "Pixels drawn per frame");
|
|
}
|
|
|
|
/**
|
|
* gdk_draw_context_is_in_frame:
|
|
* @context: a `GdkDrawContext`
|
|
*
|
|
* Returns %TRUE if @context is in the process of drawing to its surface.
|
|
*
|
|
* This is the case between calls to [method@Gdk.DrawContext.begin_frame]
|
|
* and [method@Gdk.DrawContext.end_frame]. In this situation, drawing commands
|
|
* may be effecting the contents of the @context's surface.
|
|
*
|
|
* Returns: %TRUE if the context is between [method@Gdk.DrawContext.begin_frame]
|
|
* and [method@Gdk.DrawContext.end_frame] calls.
|
|
*/
|
|
gboolean
|
|
gdk_draw_context_is_in_frame (GdkDrawContext *context)
|
|
{
|
|
GdkDrawContextPrivate *priv = gdk_draw_context_get_instance_private (context);
|
|
|
|
g_return_val_if_fail (GDK_IS_DRAW_CONTEXT (context), FALSE);
|
|
|
|
return priv->frame_region != NULL;
|
|
}
|
|
|
|
/*< private >
|
|
* gdk_draw_context_surface_resized:
|
|
* @context: a `GdkDrawContext`
|
|
*
|
|
* Called by the surface the @context belongs to when the size of the surface
|
|
* changes.
|
|
*/
|
|
void
|
|
gdk_draw_context_surface_resized (GdkDrawContext *context)
|
|
{
|
|
GDK_DRAW_CONTEXT_GET_CLASS (context)->surface_resized (context);
|
|
}
|
|
|
|
/**
|
|
* gdk_draw_context_get_display: (attributes org.gtk.Method.get_property=display)
|
|
* @context: a `GdkDrawContext`
|
|
*
|
|
* Retrieves the `GdkDisplay` the @context is created for
|
|
*
|
|
* Returns: (nullable) (transfer none): the `GdkDisplay`
|
|
*/
|
|
GdkDisplay *
|
|
gdk_draw_context_get_display (GdkDrawContext *context)
|
|
{
|
|
GdkDrawContextPrivate *priv = gdk_draw_context_get_instance_private (context);
|
|
|
|
g_return_val_if_fail (GDK_IS_DRAW_CONTEXT (context), NULL);
|
|
|
|
return priv->display;
|
|
}
|
|
|
|
/**
|
|
* gdk_draw_context_get_surface: (attributes org.gtk.Method.get_property=surface)
|
|
* @context: a `GdkDrawContext`
|
|
*
|
|
* Retrieves the surface that @context is bound to.
|
|
*
|
|
* Returns: (nullable) (transfer none): a `GdkSurface`
|
|
*/
|
|
GdkSurface *
|
|
gdk_draw_context_get_surface (GdkDrawContext *context)
|
|
{
|
|
GdkDrawContextPrivate *priv = gdk_draw_context_get_instance_private (context);
|
|
|
|
g_return_val_if_fail (GDK_IS_DRAW_CONTEXT (context), NULL);
|
|
|
|
return priv->surface;
|
|
}
|
|
|
|
/**
|
|
* gdk_draw_context_begin_frame:
|
|
* @context: the `GdkDrawContext` used to draw the frame
|
|
* @region: minimum region that should be drawn
|
|
*
|
|
* Indicates that you are beginning the process of redrawing @region
|
|
* on the @context's surface.
|
|
*
|
|
* Calling this function begins a drawing operation using @context on the
|
|
* surface that @context was created from. The actual requirements and
|
|
* guarantees for the drawing operation vary for different implementations
|
|
* of drawing, so a [class@Gdk.CairoContext] and a [class@Gdk.GLContext]
|
|
* need to be treated differently.
|
|
*
|
|
* A call to this function is a requirement for drawing and must be
|
|
* followed by a call to [method@Gdk.DrawContext.end_frame], which will
|
|
* complete the drawing operation and ensure the contents become visible
|
|
* on screen.
|
|
*
|
|
* Note that the @region passed to this function is the minimum region that
|
|
* needs to be drawn and depending on implementation, windowing system and
|
|
* hardware in use, it might be necessary to draw a larger region. Drawing
|
|
* implementation must use [method@Gdk.DrawContext.get_frame_region] to
|
|
* query the region that must be drawn.
|
|
*
|
|
* When using GTK, the widget system automatically places calls to
|
|
* gdk_draw_context_begin_frame() and gdk_draw_context_end_frame() via the
|
|
* use of [class@Gsk.Renderer]s, so application code does not need to call
|
|
* these functions explicitly.
|
|
*/
|
|
void
|
|
gdk_draw_context_begin_frame (GdkDrawContext *context,
|
|
const cairo_region_t *region)
|
|
{
|
|
g_return_if_fail (GDK_IS_DRAW_CONTEXT (context));
|
|
g_return_if_fail (region != NULL);
|
|
|
|
gdk_draw_context_begin_frame_full (context, FALSE, region);
|
|
}
|
|
|
|
/*
|
|
* @prefers_high_depth: %TRUE to request a higher bit depth
|
|
*
|
|
* If high depth is preferred, GDK will see about providing a rendering target
|
|
* that supports higher bit depth than 8 bits per channel. Typically this means
|
|
* a target supporting 16bit floating point pixels, but that is not guaranteed.
|
|
*
|
|
* This is only a request and if the GDK backend does not support HDR rendering
|
|
* or does not consider it worthwhile, it may choose to not honor the request.
|
|
* It may also choose to provide high depth even if it was not requested.
|
|
* Typically the steps undertaken by a backend are:
|
|
* 1. Check if high depth is supported by this drawing backend.
|
|
* 2. Check if the compositor supports high depth.
|
|
* 3. Check if the compositor prefers regular bit depth. This is usually the case
|
|
* when the attached monitors do not support high depth content or when the
|
|
* system is resource constrained.
|
|
* In either of those cases, the context will usually choose to not honor the request.
|
|
*
|
|
* The rendering code must be able to deal with content in any bit depth, no matter
|
|
* the preference. The prefers_high_depth argument is only a hint and GDK is free
|
|
* to choose.
|
|
*/
|
|
void
|
|
gdk_draw_context_begin_frame_full (GdkDrawContext *context,
|
|
gboolean prefers_high_depth,
|
|
const cairo_region_t *region)
|
|
{
|
|
GdkDrawContextPrivate *priv = gdk_draw_context_get_instance_private (context);
|
|
|
|
if (GDK_SURFACE_DESTROYED (priv->surface))
|
|
return;
|
|
|
|
if (priv->surface->paint_context != NULL)
|
|
{
|
|
if (priv->surface->paint_context == context)
|
|
{
|
|
g_critical ("The surface %p is already drawing. You must finish the "
|
|
"previous drawing operation with gdk_draw_context_end_frame() first.",
|
|
priv->surface);
|
|
}
|
|
else
|
|
{
|
|
g_critical ("The surface %p is already being drawn by %s %p. "
|
|
"You cannot draw a surface with multiple contexts at the same time.",
|
|
priv->surface,
|
|
G_OBJECT_TYPE_NAME (priv->surface->paint_context), priv->surface->paint_context);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (GDK_DISPLAY_DEBUG_CHECK (priv->display, HIGH_DEPTH))
|
|
prefers_high_depth = TRUE;
|
|
|
|
priv->frame_region = cairo_region_copy (region);
|
|
priv->surface->paint_context = g_object_ref (context);
|
|
|
|
GDK_DRAW_CONTEXT_GET_CLASS (context)->begin_frame (context, prefers_high_depth, priv->frame_region);
|
|
}
|
|
|
|
#ifdef HAVE_SYSPROF
|
|
static gint64
|
|
region_get_pixels (cairo_region_t *region)
|
|
{
|
|
int i, n;
|
|
cairo_rectangle_int_t rect;
|
|
gint64 pixels = 0;
|
|
|
|
n = cairo_region_num_rectangles (region);
|
|
for (i = 0; i < n; i++)
|
|
{
|
|
cairo_region_get_rectangle (region, i, &rect);
|
|
pixels += rect.width * rect.height;
|
|
}
|
|
|
|
return pixels;
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* gdk_draw_context_end_frame:
|
|
* @context: a `GdkDrawContext`
|
|
*
|
|
* Ends a drawing operation started with gdk_draw_context_begin_frame().
|
|
*
|
|
* This makes the drawing available on screen.
|
|
* See [method@Gdk.DrawContext.begin_frame] for more details about drawing.
|
|
*
|
|
* When using a [class@Gdk.GLContext], this function may call `glFlush()`
|
|
* implicitly before returning; it is not recommended to call `glFlush()`
|
|
* explicitly before calling this function.
|
|
*/
|
|
void
|
|
gdk_draw_context_end_frame (GdkDrawContext *context)
|
|
{
|
|
GdkDrawContextPrivate *priv = gdk_draw_context_get_instance_private (context);
|
|
|
|
g_return_if_fail (GDK_IS_DRAW_CONTEXT (context));
|
|
|
|
if (GDK_SURFACE_DESTROYED (priv->surface))
|
|
return;
|
|
|
|
if (priv->surface->paint_context == NULL)
|
|
{
|
|
g_critical ("The surface %p has no drawing context. You must call "
|
|
"gdk_draw_context_begin_frame() before calling "
|
|
"gdk_draw_context_end_frame().", priv->surface);
|
|
return;
|
|
}
|
|
else if (priv->surface->paint_context != context)
|
|
{
|
|
g_critical ("The surface %p is not drawn by this context but by %s %p.",
|
|
priv->surface,
|
|
G_OBJECT_TYPE_NAME (priv->surface->paint_context), priv->surface->paint_context);
|
|
return;
|
|
}
|
|
|
|
GDK_DRAW_CONTEXT_GET_CLASS (context)->end_frame (context, priv->frame_region);
|
|
|
|
gdk_profiler_set_int_counter (pixels_counter, region_get_pixels (priv->frame_region));
|
|
|
|
g_clear_pointer (&priv->frame_region, cairo_region_destroy);
|
|
g_clear_object (&priv->surface->paint_context);
|
|
}
|
|
|
|
/**
|
|
* gdk_draw_context_get_frame_region:
|
|
* @context: a `GdkDrawContext`
|
|
*
|
|
* Retrieves the region that is currently being repainted.
|
|
*
|
|
* After a call to [method@Gdk.DrawContext.begin_frame] this function will
|
|
* return a union of the region passed to that function and the area of the
|
|
* surface that the @context determined needs to be repainted.
|
|
*
|
|
* If @context is not in between calls to [method@Gdk.DrawContext.begin_frame]
|
|
* and [method@Gdk.DrawContext.end_frame], %NULL will be returned.
|
|
*
|
|
* Returns: (transfer none) (nullable): a Cairo region
|
|
*/
|
|
const cairo_region_t *
|
|
gdk_draw_context_get_frame_region (GdkDrawContext *context)
|
|
{
|
|
GdkDrawContextPrivate *priv = gdk_draw_context_get_instance_private (context);
|
|
|
|
g_return_val_if_fail (GDK_IS_DRAW_CONTEXT (context), NULL);
|
|
|
|
return priv->frame_region;
|
|
}
|