gtknative.c 14.1 KB
Newer Older
Matthias Clasen's avatar
Matthias Clasen committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/*
 * Copyright © 2019 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.1 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/>.
 *
 * Authors: Matthias Clasen <mclasen@redhat.com>
 */

#include "config.h"

22
23
#include <math.h>

Matthias Clasen's avatar
Matthias Clasen committed
24
#include "gtkintl.h"
25
26
27
28

#include "gtkcssboxesimplprivate.h"
#include "gtkcsscolorvalueprivate.h"
#include "gtkcsscornervalueprivate.h"
29
#include "gtkcssnodeprivate.h"
30
31
32
#include "gtkcssshadowvalueprivate.h"
#include "gtknativeprivate.h"
#include "gtkwidgetprivate.h"
33

Benjamin Otte's avatar
Benjamin Otte committed
34
35
#include "gdk/gdksurfaceprivate.h"

36
37
38
39
typedef struct _GtkNativePrivate
{
  gulong update_handler_id;
  gulong layout_handler_id;
40
  gulong scale_changed_handler_id;
41
42
43
} GtkNativePrivate;

static GQuark quark_gtk_native_private;
Matthias Clasen's avatar
Matthias Clasen committed
44
45

/**
Matthias Clasen's avatar
Matthias Clasen committed
46
 * GtkNative:
Matthias Clasen's avatar
Matthias Clasen committed
47
 *
Matthias Clasen's avatar
Matthias Clasen committed
48
49
 * `GtkNative` is the interface implemented by all widgets that have
 * their own `GdkSurface`.
Matthias Clasen's avatar
Matthias Clasen committed
50
 *
Matthias Clasen's avatar
Matthias Clasen committed
51
52
53
54
55
56
57
58
59
60
61
62
 * The obvious example of a `GtkNative` is `GtkWindow`.
 *
 * Every widget that is not itself a `GtkNative` is contained in one,
 * and you can get it with [method@Gtk.Widget.get_native].
 *
 * To get the surface of a `GtkNative`, use [method@Gtk.Native.get_surface].
 * It is also possible to find the `GtkNative` to which a surface
 * belongs, with [func@Gtk.Native.get_for_surface].
 *
 * In addition to a [class@Gdk.Surface], a `GtkNative` also provides
 * a [class@Gsk.Renderer] for rendering on that surface. To get the
 * renderer, use [method@Gtk.Native.get_renderer].
Matthias Clasen's avatar
Matthias Clasen committed
63
64
65
66
67
68
69
70
71
72
73
74
 */

G_DEFINE_INTERFACE (GtkNative, gtk_native, GTK_TYPE_WIDGET)

static GskRenderer *
gtk_native_default_get_renderer (GtkNative *self)
{
  return NULL;
}

static void
gtk_native_default_get_surface_transform (GtkNative *self,
75
76
                                          double    *x,
                                          double    *y)
Matthias Clasen's avatar
Matthias Clasen committed
77
78
79
80
81
{
  *x = 0;
  *y = 0;
}

82
83
84
85
86
87
88
static void
gtk_native_default_layout (GtkNative *self,
                           int        width,
                           int        height)
{
}

Matthias Clasen's avatar
Matthias Clasen committed
89
90
91
92
93
static void
gtk_native_default_init (GtkNativeInterface *iface)
{
  iface->get_renderer = gtk_native_default_get_renderer;
  iface->get_surface_transform = gtk_native_default_get_surface_transform;
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
  iface->layout = gtk_native_default_layout;

  quark_gtk_native_private = g_quark_from_static_string ("gtk-native-private");
}

static void
frame_clock_update_cb (GdkFrameClock *clock,
                       GtkNative     *native)
{
  if (GTK_IS_ROOT (native))
    gtk_css_node_validate (gtk_widget_get_css_node (GTK_WIDGET (native)));
}

static void
gtk_native_layout (GtkNative *self,
                   int        width,
                   int        height)
{
112
  GTK_NATIVE_GET_IFACE (self)->layout (self, width, height);
113
114
115
116
117
118
119
120
121
122
123
124
125
126
}

static void
surface_layout_cb (GdkSurface *surface,
                   int         width,
                   int         height,
                   GtkNative  *native)
{
  gtk_native_layout (native, width, height);

  if (gtk_widget_needs_allocate (GTK_WIDGET (native)))
    gtk_native_queue_relayout (native);
}

127
128
129
130
131
132
133
134
static void
scale_changed_cb (GdkSurface *surface,
                  GParamSpec *pspec,
                  GtkNative  *native)
{
  _gtk_widget_scale_changed (GTK_WIDGET (native));
}

135
136
137
138
139
140
141
static void
verify_priv_unrealized (gpointer user_data)
{
  GtkNativePrivate *priv = user_data;

  g_warn_if_fail (priv->update_handler_id == 0);
  g_warn_if_fail (priv->layout_handler_id == 0);
142
  g_warn_if_fail (priv->scale_changed_handler_id == 0);
143
144
145
146

  g_free (priv);
}

147
148
/**
 * gtk_native_realize:
Matthias Clasen's avatar
Matthias Clasen committed
149
 * @self: a `GtkNative`
150
 *
Matthias Clasen's avatar
Matthias Clasen committed
151
152
153
 * Realizes a `GtkNative`.
 *
 * This should only be used by subclasses.
154
 */
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
void
gtk_native_realize (GtkNative *self)
{
  GdkSurface *surface;
  GdkFrameClock *clock;
  GtkNativePrivate *priv;

  g_return_if_fail (g_object_get_qdata (G_OBJECT (self),
                                        quark_gtk_native_private) == NULL);

  surface = gtk_native_get_surface (self);
  clock = gdk_surface_get_frame_clock (surface);
  g_return_if_fail (clock != NULL);

  priv = g_new0 (GtkNativePrivate, 1);
  priv->update_handler_id = g_signal_connect_after (clock, "update",
                                              G_CALLBACK (frame_clock_update_cb),
                                              self);
  priv->layout_handler_id = g_signal_connect (surface, "layout",
                                              G_CALLBACK (surface_layout_cb),
                                              self);
176
177
178
179
180

  priv->scale_changed_handler_id = g_signal_connect (surface, "notify::scale-factor",
                                                     G_CALLBACK (scale_changed_cb),
                                                     self);

181
182
183
184
185
186
  g_object_set_qdata_full (G_OBJECT (self),
                           quark_gtk_native_private,
                           priv,
                           verify_priv_unrealized);
}

187
188
/**
 * gtk_native_unrealize:
Matthias Clasen's avatar
Matthias Clasen committed
189
190
191
 * @self: a `GtkNative`
 *
 * Unrealizes a `GtkNative`.
192
 *
Matthias Clasen's avatar
Matthias Clasen committed
193
 * This should only be used by subclasses.
194
 */
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
void
gtk_native_unrealize (GtkNative *self)
{
  GtkNativePrivate *priv;
  GdkSurface *surface;
  GdkFrameClock *clock;

  priv = g_object_get_qdata (G_OBJECT (self), quark_gtk_native_private);
  g_return_if_fail (priv != NULL);

  surface = gtk_native_get_surface (self);
  clock = gdk_surface_get_frame_clock (surface);
  g_return_if_fail (clock != NULL);

  g_clear_signal_handler (&priv->update_handler_id, clock);
  g_clear_signal_handler (&priv->layout_handler_id, surface);
211
  g_clear_signal_handler (&priv->scale_changed_handler_id, surface);
212
213

  g_object_set_qdata (G_OBJECT (self), quark_gtk_native_private, NULL);
Matthias Clasen's avatar
Matthias Clasen committed
214
215
216
217
}

/**
 * gtk_native_get_surface:
Matthias Clasen's avatar
Matthias Clasen committed
218
 * @self: a `GtkNative`
Matthias Clasen's avatar
Matthias Clasen committed
219
 *
Matthias Clasen's avatar
Matthias Clasen committed
220
 * Returns the surface of this `GtkNative`.
Matthias Clasen's avatar
Matthias Clasen committed
221
 *
222
 * Returns: (transfer none): the surface of @self
Matthias Clasen's avatar
Matthias Clasen committed
223
224
225
226
227
228
229
230
231
232
233
 */
GdkSurface *
gtk_native_get_surface (GtkNative *self)
{
  g_return_val_if_fail (GTK_IS_NATIVE (self), NULL);

  return GTK_NATIVE_GET_IFACE (self)->get_surface (self);
}

/**
 * gtk_native_get_renderer:
Matthias Clasen's avatar
Matthias Clasen committed
234
 * @self: a `GtkNative`
Matthias Clasen's avatar
Matthias Clasen committed
235
 *
Matthias Clasen's avatar
Matthias Clasen committed
236
 * Returns the renderer that is used for this `GtkNative`.
Matthias Clasen's avatar
Matthias Clasen committed
237
 *
238
 * Returns: (transfer none): the renderer for @self
Matthias Clasen's avatar
Matthias Clasen committed
239
240
241
242
243
244
245
246
247
 */
GskRenderer *
gtk_native_get_renderer (GtkNative *self)
{
  g_return_val_if_fail (GTK_IS_NATIVE (self), NULL);

  return GTK_NATIVE_GET_IFACE (self)->get_renderer (self);
}

248
249
/**
 * gtk_native_get_surface_transform:
Matthias Clasen's avatar
Matthias Clasen committed
250
 * @self: a `GtkNative`
251
252
253
 * @x: (out): return location for the x coordinate
 * @y: (out): return location for the y coordinate
 *
Matthias Clasen's avatar
Matthias Clasen committed
254
255
256
257
 * Retrieves the surface transform of @self.
 *
 * This is the translation from @self's surface coordinates into
 * @self's widget coordinates.
258
 */
Matthias Clasen's avatar
Matthias Clasen committed
259
260
void
gtk_native_get_surface_transform (GtkNative *self,
261
262
                                  double    *x,
                                  double    *y)
Matthias Clasen's avatar
Matthias Clasen committed
263
264
{
  g_return_if_fail (GTK_IS_NATIVE (self));
265
266
  g_return_if_fail (x != NULL);
  g_return_if_fail (y != NULL);
Matthias Clasen's avatar
Matthias Clasen committed
267

268
  GTK_NATIVE_GET_IFACE (self)->get_surface_transform (self, x, y);
Matthias Clasen's avatar
Matthias Clasen committed
269
270
271
272
}

/**
 * gtk_native_get_for_surface:
Matthias Clasen's avatar
Matthias Clasen committed
273
 * @surface: a `GdkSurface`
Matthias Clasen's avatar
Matthias Clasen committed
274
 *
Matthias Clasen's avatar
Matthias Clasen committed
275
 * Finds the `GtkNative` associated with the surface.
Matthias Clasen's avatar
Matthias Clasen committed
276
 *
277
 * Returns: (transfer none) (nullable): the `GtkNative` that is associated with @surface
Matthias Clasen's avatar
Matthias Clasen committed
278
 */
279
GtkNative *
Matthias Clasen's avatar
Matthias Clasen committed
280
281
282
283
284
285
286
gtk_native_get_for_surface (GdkSurface *surface)
{
  GtkWidget *widget;

  widget = (GtkWidget *)gdk_surface_get_widget (surface);

  if (widget && GTK_IS_NATIVE (widget))
287
    return GTK_NATIVE (widget);
Matthias Clasen's avatar
Matthias Clasen committed
288
289
290

  return NULL;
}
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306

void
gtk_native_queue_relayout (GtkNative *self)
{
  GtkWidget *widget = GTK_WIDGET (self);
  GdkSurface *surface;
  GdkFrameClock *clock;

  surface = gtk_widget_get_surface (widget);
  clock = gtk_widget_get_frame_clock (widget);
  if (clock == NULL)
    return;

  gdk_frame_clock_request_phase (clock, GDK_FRAME_CLOCK_PHASE_UPDATE);
  gdk_surface_request_layout (surface);
}
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484

static void
corner_rect (const GtkCssValue     *value,
             cairo_rectangle_int_t *rect)
{
  rect->width = _gtk_css_corner_value_get_x (value, 100);
  rect->height = _gtk_css_corner_value_get_y (value, 100);
}

static void
subtract_decoration_corners_from_region (cairo_region_t        *region,
                                         cairo_rectangle_int_t *extents,
                                         const GtkCssStyle     *style)
{
  cairo_rectangle_int_t rect;

  corner_rect (style->border->border_top_left_radius, &rect);
  rect.x = extents->x;
  rect.y = extents->y;
  cairo_region_subtract_rectangle (region, &rect);

  corner_rect (style->border->border_top_right_radius, &rect);
  rect.x = extents->x + extents->width - rect.width;
  rect.y = extents->y;
  cairo_region_subtract_rectangle (region, &rect);

  corner_rect (style->border->border_bottom_left_radius, &rect);
  rect.x = extents->x;
  rect.y = extents->y + extents->height - rect.height;
  cairo_region_subtract_rectangle (region, &rect);

  corner_rect (style->border->border_bottom_right_radius, &rect);
  rect.x = extents->x + extents->width - rect.width;
  rect.y = extents->y + extents->height - rect.height;
  cairo_region_subtract_rectangle (region, &rect);
}

static int
get_translucent_border_edge (const GtkCssValue *color,
                             const GtkCssValue *border_color,
                             const GtkCssValue *border_width)
{
  if (border_color == NULL)
    border_color = color;

  if (!gdk_rgba_is_opaque (gtk_css_color_value_get_rgba (border_color)))
    return round (_gtk_css_number_value_get (border_width, 100));

  return 0;
}

static void
get_translucent_border_width (GtkWidget *widget,
                              GtkBorder *border)
{
  GtkCssNode *css_node = gtk_widget_get_css_node (widget);
  GtkCssStyle *style = gtk_css_node_get_style (css_node);

  border->top = get_translucent_border_edge (style->core->color,
                                             style->border->border_top_color,
                                             style->border->border_top_width);
  border->bottom = get_translucent_border_edge (style->core->color,
                                                style->border->border_bottom_color,
                                                style->border->border_bottom_width);
  border->left = get_translucent_border_edge (style->core->color,
                                              style->border->border_left_color,
                                              style->border->border_left_width);
  border->right = get_translucent_border_edge (style->core->color,
                                               style->border->border_right_color,
                                               style->border->border_right_width);
}

static gboolean
get_opaque_rect (GtkWidget             *widget,
                 const GtkCssStyle     *style,
                 cairo_rectangle_int_t *rect)
{
  gboolean is_opaque = gdk_rgba_is_opaque (gtk_css_color_value_get_rgba (style->background->background_color));

  if (is_opaque && gtk_widget_get_opacity (widget) < 1.0)
    is_opaque = FALSE;

  if (is_opaque)
    {
      const graphene_rect_t *border_rect;
      GtkCssBoxes css_boxes;
      GtkBorder border;

      gtk_css_boxes_init (&css_boxes, widget);
      border_rect = gtk_css_boxes_get_border_rect (&css_boxes);
      get_translucent_border_width (widget, &border);

      rect->x = border_rect->origin.x + border.left;
      rect->y = border_rect->origin.y + border.top;
      rect->width = border_rect->size.width - border.left - border.right;
      rect->height = border_rect->size.height - border.top - border.bottom;
    }

  return is_opaque;
}

static void
get_shadow_width (GtkWidget *widget,
                  GtkBorder *shadow_width,
                  int        resize_handle_size)
{
  GtkCssNode *css_node = gtk_widget_get_css_node (widget);
  const GtkCssStyle *style = gtk_css_node_get_style (css_node);

  gtk_css_shadow_value_get_extents (style->background->box_shadow, shadow_width);

  shadow_width->left = MAX (shadow_width->left, resize_handle_size);
  shadow_width->top = MAX (shadow_width->top, resize_handle_size);
  shadow_width->bottom = MAX (shadow_width->bottom, resize_handle_size);
  shadow_width->right = MAX (shadow_width->right, resize_handle_size);
}

void
gtk_native_update_opaque_region (GtkNative  *native,
                                 GtkWidget  *contents,
                                 gboolean    subtract_decoration_corners,
                                 gboolean    subtract_shadow,
                                 int         resize_handle_size)
{
  cairo_rectangle_int_t rect;
  cairo_region_t *opaque_region = NULL;
  const GtkCssStyle *style;
  GtkCssNode *css_node;
  GdkSurface *surface;
  GtkBorder shadow;

  g_return_if_fail (GTK_IS_NATIVE (native));
  g_return_if_fail (!contents || GTK_IS_WIDGET (contents));

  if (contents == NULL)
    contents = GTK_WIDGET (native);

  if (!_gtk_widget_get_realized (GTK_WIDGET (native)) ||
      !_gtk_widget_get_realized (contents))
    return;

  css_node = gtk_widget_get_css_node (contents);

  if (subtract_shadow)
    get_shadow_width (contents, &shadow, resize_handle_size);
  else
    shadow = (GtkBorder) {0, 0, 0, 0};

  surface = gtk_native_get_surface (native);
  style = gtk_css_node_get_style (css_node);

  if (get_opaque_rect (contents, style, &rect))
    {
      double native_x, native_y;

      gtk_native_get_surface_transform (native, &native_x, &native_y);
      rect.x += native_x;
      rect.y += native_y;

      if (contents != GTK_WIDGET (native))
        {
          double contents_x, contents_y;

          gtk_widget_translate_coordinates (contents, GTK_WIDGET (native), 0, 0, &contents_x, &contents_y);
          rect.x += contents_x;
          rect.y += contents_y;
        }

      opaque_region = cairo_region_create_rectangle (&rect);

      if (subtract_decoration_corners)
        subtract_decoration_corners_from_region (opaque_region, &rect, style);
    }

  gdk_surface_set_opaque_region (surface, opaque_region);

  cairo_region_destroy (opaque_region);
}