gtkcssnode.c 40.7 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
/* GTK - The GIMP Toolkit
 * Copyright (C) 2014 Benjamin Otte <otte@gnome.org>
 *
 * 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 "gtkcssnodeprivate.h"

22
#include "gtkcssanimatedstyleprivate.h"
23 24
#include "gtkcsssectionprivate.h"
#include "gtkcssstylepropertyprivate.h"
25 26
#include "gtkintl.h"
#include "gtkmarshalers.h"
27
#include "gtksettingsprivate.h"
Benjamin Otte's avatar
Benjamin Otte committed
28
#include "gtktypebuiltins.h"
29

Matthias Clasen's avatar
Matthias Clasen committed
30 31 32
/*
 * CSS nodes are the backbone of the GtkStyleContext implementation and
 * replace the role that GtkWidgetPath played in the past. A CSS node has
33 34 35
 * an element name and a state, and can have an id and style classes, which
 * is what is needed to determine the matching CSS selectors. CSS nodes have
 * a 'visible' property, which makes it possible to temporarily 'hide' them
Matthias Clasen's avatar
Matthias Clasen committed
36 37 38
 * from CSS matching - e.g. an invisible node will not affect :nth-child
 * matching and so forth.
 *
39 40 41 42 43 44 45
 * The API to manage states, names, ids and classes of CSS nodes is:
 * - gtk_css_node_get/set_state. States are represented as GtkStateFlags
 * - gtk_css_node_get/set_name. Names are represented as interned strings
 * - gtk_css_node_get/set_id. Ids are represented as interned strings
 * - gtk_css_node_add/remove/has_class and gtk_css_node_list_classes. Style
 *   classes are represented as quarks.
 *
Matthias Clasen's avatar
Matthias Clasen committed
46 47 48 49 50 51 52
 * CSS nodes are organized in a dom-like tree, and there is API to navigate
 * and manipulate this tree:
 * - gtk_css_node_set_parent
 * - gtk_css_node_insert_before/after
 * - gtk_css_node_get_parent
 * - gtk_css_node_get_first/last_child
 * - gtk_css_node_get_previous/next_sibling
53
 * Note that parents keep a reference on their children in this tree.
Matthias Clasen's avatar
Matthias Clasen committed
54 55
 *
 * Every widget has one or more CSS nodes - the first one gets created
56 57
 * automatically by GtkStyleContext. To set the name of the main node,
 * call gtk_widget_class_set_css_name() in class_init(). Widget implementations
Matthias Clasen's avatar
Matthias Clasen committed
58 59 60
 * can and should add subnodes as suitable.
 *
 * Best practice is:
61
 * - For permanent subnodes, create them in init(), and keep a pointer
Matthias Clasen's avatar
Matthias Clasen committed
62 63
 *   to the node (you don't have to keep a reference, cleanup will be
 *   automatic by means of the parent node getting cleaned up by the
64 65 66 67 68
 *   style context).
 * - For transient nodes, create/destroy them when the conditions that
 *   warrant their existence change.
 * - Keep the state of all your nodes up-to-date. This probably requires
 *   a ::state-flags-changed (and possibly ::direction-changed) handler,
69 70 71 72 73 74 75
 *   as well as code to update the state in other places. Note that GTK+
 *   does this automatically for the widget's main CSS node.
 * - The sibling ordering in the CSS node tree is supposed to correspond
 *   to the visible order of content: top-to-bottom and left-to-right.
 *   Reorder your nodes to maintain this correlation. In particular for
 *   horizontally layed out widgets, this will require listening to
 *   ::direction-changed.
76 77 78
 * - The draw function should just use gtk_style_context_save_to_node() to
 *   'switch' to the right node, not make any other changes to the style
 *   context.
Matthias Clasen's avatar
Matthias Clasen committed
79 80 81 82
 *
 * A noteworthy difference between gtk_style_context_save() and
 * gtk_style_context_save_to_node() is that the former inherits all the
 * style classes from the main CSS node, which often leads to unintended
83
 * inheritance.
Matthias Clasen's avatar
Matthias Clasen committed
84 85
 */

86 87
/* When these change we do a full restyling. Otherwise we try to figure out
 * if we need to change things. */
88
#define GTK_CSS_RADICAL_CHANGE (GTK_CSS_CHANGE_ID | GTK_CSS_CHANGE_NAME | GTK_CSS_CHANGE_CLASS | GTK_CSS_CHANGE_SOURCE | GTK_CSS_CHANGE_PARENT_STYLE)
89

90 91
G_DEFINE_TYPE (GtkCssNode, gtk_css_node, G_TYPE_OBJECT)

92 93 94
enum {
  NODE_ADDED,
  NODE_REMOVED,
95
  STYLE_CHANGED,
96 97 98
  LAST_SIGNAL
};

Benjamin Otte's avatar
Benjamin Otte committed
99 100 101 102
enum {
  PROP_0,
  PROP_CLASSES,
  PROP_ID,
103
  PROP_NAME,
Benjamin Otte's avatar
Benjamin Otte committed
104 105 106 107 108 109
  PROP_STATE,
  PROP_VISIBLE,
  PROP_WIDGET_TYPE,
  NUM_PROPERTIES
};

110 111 112 113 114
struct _GtkCssNodeStyleChange {
  GtkCssStyle *old_style;
  GtkCssStyle *new_style;
};

115
static guint cssnode_signals[LAST_SIGNAL] = { 0 };
Benjamin Otte's avatar
Benjamin Otte committed
116
static GParamSpec *cssnode_properties[NUM_PROPERTIES];
117

118 119 120 121 122 123
static GtkStyleProviderPrivate *
gtk_css_node_get_style_provider_or_null (GtkCssNode *cssnode)
{
  return GTK_CSS_NODE_GET_CLASS (cssnode)->get_style_provider (cssnode);
}

124
static void
125 126 127 128 129 130
gtk_css_node_set_invalid (GtkCssNode *node,
                          gboolean    invalid)
{
  if (node->invalid == invalid)
    return;

131 132
  node->invalid = invalid;

133
  if (node->visible)
134
    {
135 136 137 138 139
      if (node->parent)
        {
          if (invalid)
            gtk_css_node_set_invalid (node->parent, TRUE);
        }
140
      else
141 142 143 144 145 146
        {
          if (invalid)
            GTK_CSS_NODE_GET_CLASS (node)->queue_validate (node);
          else
            GTK_CSS_NODE_GET_CLASS (node)->dequeue_validate (node);
        }
147
    }
148 149
}

Benjamin Otte's avatar
Benjamin Otte committed
150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167
static void
gtk_css_node_get_property (GObject    *object,
                           guint       property_id,
                           GValue     *value,
                           GParamSpec *pspec)
{
  GtkCssNode *cssnode = GTK_CSS_NODE (object);

  switch (property_id)
    {
    case PROP_CLASSES:
      g_value_take_boxed (value, gtk_css_node_get_classes (cssnode));
      break;

    case PROP_ID:
      g_value_set_string (value, gtk_css_node_get_id (cssnode));
      break;

168 169 170 171
    case PROP_NAME:
      g_value_set_string (value, gtk_css_node_get_name (cssnode));
      break;

Benjamin Otte's avatar
Benjamin Otte committed
172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
    case PROP_STATE:
      g_value_set_flags (value, gtk_css_node_get_state (cssnode));
      break;

    case PROP_VISIBLE:
      g_value_set_boolean (value, gtk_css_node_get_visible (cssnode));
      break;

    case PROP_WIDGET_TYPE:
      g_value_set_gtype (value, gtk_css_node_get_widget_type (cssnode));
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
    }
}

static void
gtk_css_node_set_property (GObject      *object,
                           guint         property_id,
                           const GValue *value,
                           GParamSpec   *pspec)
{
  GtkCssNode *cssnode = GTK_CSS_NODE (object);

  switch (property_id)
    {
    case PROP_CLASSES:
      gtk_css_node_set_classes (cssnode, g_value_get_boxed (value));
      break;

    case PROP_ID:
      gtk_css_node_set_id (cssnode, g_value_get_string (value));
      break;

207 208 209 210
    case PROP_NAME:
      gtk_css_node_set_name (cssnode, g_value_get_string (value));
      break;

Benjamin Otte's avatar
Benjamin Otte committed
211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
    case PROP_STATE:
      gtk_css_node_set_state (cssnode, g_value_get_flags (value));
      break;

    case PROP_VISIBLE:
      gtk_css_node_set_visible (cssnode, g_value_get_boolean (value));
      break;

    case PROP_WIDGET_TYPE:
      gtk_css_node_set_widget_type (cssnode, g_value_get_gtype (value));
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
    }
}

228 229 230 231 232 233 234 235 236 237
static void
gtk_css_node_dispose (GObject *object)
{
  GtkCssNode *cssnode = GTK_CSS_NODE (object);

  while (cssnode->first_child)
    {
      gtk_css_node_set_parent (cssnode->first_child, NULL);
    }

238
  gtk_css_node_set_invalid (cssnode, FALSE);
239 240
  
  g_clear_pointer (&cssnode->cache, gtk_css_node_style_cache_unref);
241

242 243 244
  G_OBJECT_CLASS (gtk_css_node_parent_class)->dispose (object);
}

245 246
static void
gtk_css_node_finalize (GObject *object)
247
{
248
  GtkCssNode *cssnode = GTK_CSS_NODE (object);
249

250 251 252 253 254 255 256
  if (cssnode->style)
    g_object_unref (cssnode->style);
  gtk_css_node_declaration_unref (cssnode->decl);

  G_OBJECT_CLASS (gtk_css_node_parent_class)->finalize (object);
}

257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286
static gboolean
gtk_css_node_is_first_child (GtkCssNode *node)
{
  GtkCssNode *iter;

  for (iter = node->previous_sibling;
       iter != NULL;
       iter = iter->previous_sibling)
    {
      if (iter->visible)
        return FALSE;
    }
  return TRUE;
}

static gboolean
gtk_css_node_is_last_child (GtkCssNode *node)
{
  GtkCssNode *iter;

  for (iter = node->next_sibling;
       iter != NULL;
       iter = iter->next_sibling)
    {
      if (iter->visible)
        return FALSE;
    }
  return TRUE;
}

287 288 289
static gboolean
may_use_global_parent_cache (GtkCssNode *node)
{
290
  GtkStyleProviderPrivate *provider;
291 292 293 294 295 296
  GtkCssNode *parent;
  
  parent = gtk_css_node_get_parent (node);
  if (parent == NULL)
    return FALSE;

297 298
  provider = gtk_css_node_get_style_provider_or_null (node);
  if (provider != NULL && provider != gtk_css_node_get_style_provider (parent))
299 300 301 302 303 304 305 306 307
    return FALSE;

  return TRUE;
}

static GtkCssStyle *
lookup_in_global_parent_cache (GtkCssNode                  *node,
                               const GtkCssNodeDeclaration *decl)
{
308 309 310
  GtkCssNode *parent;

  parent = node->parent;
311 312 313 314 315

  if (parent == NULL ||
      !may_use_global_parent_cache (node))
    return NULL;

316
  if (parent->cache == NULL)
317 318
    return NULL;

319
  g_assert (node->cache == NULL);
320 321 322 323 324 325
  node->cache = gtk_css_node_style_cache_lookup (parent->cache,
                                                 (GtkCssNodeDeclaration *) decl,
                                                 gtk_css_node_is_first_child (node),
                                                 gtk_css_node_is_last_child (node));
  if (node->cache == NULL)
    return NULL;
326

327
  return gtk_css_node_style_cache_get_style (node->cache);
328 329
}

330 331 332 333 334
static void
store_in_global_parent_cache (GtkCssNode                  *node,
                              const GtkCssNodeDeclaration *decl,
                              GtkCssStyle                 *style)
{
335
  GtkCssNode *parent;
336 337 338

  g_assert (GTK_IS_CSS_STATIC_STYLE (style));

339 340
  parent = node->parent;

341 342 343 344
  if (parent == NULL ||
      !may_use_global_parent_cache (node))
    return;

345 346
  if (parent->cache == NULL)
    parent->cache = gtk_css_node_style_cache_new (parent->style);
347

348 349 350 351 352
  node->cache = gtk_css_node_style_cache_insert (parent->cache,
                                                 (GtkCssNodeDeclaration *) decl,
                                                 gtk_css_node_is_first_child (node),
                                                 gtk_css_node_is_last_child (node),
                                                 style);
353 354
}

355
static GtkCssStyle *
356 357 358 359 360 361 362 363 364 365
gtk_css_node_create_style (GtkCssNode *cssnode)
{
  const GtkCssNodeDeclaration *decl;
  GtkCssMatcher matcher;
  GtkCssStyle *parent;
  GtkCssStyle *style;

  decl = gtk_css_node_get_declaration (cssnode);
  parent = cssnode->parent ? cssnode->parent->style : NULL;

366
  style = lookup_in_global_parent_cache (cssnode, decl);
367 368 369
  if (style)
    return g_object_ref (style);

370
  if (gtk_css_node_init_matcher (cssnode, &matcher))
371 372 373 374 375 376 377 378
    style = gtk_css_static_style_new_compute (gtk_css_node_get_style_provider (cssnode),
                                              &matcher,
                                              parent);
  else
    style = gtk_css_static_style_new_compute (gtk_css_node_get_style_provider (cssnode),
                                              NULL,
                                              parent);

379
  store_in_global_parent_cache (cssnode, decl, style);
380 381 382 383

  return style;
}

384 385 386 387 388 389
static gboolean
should_create_transitions (GtkCssChange change)
{
  return (change & GTK_CSS_CHANGE_ANIMATIONS) == 0;
}

390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406
static gboolean
gtk_css_style_needs_recreation (GtkCssStyle  *style,
                                GtkCssChange  change)
{
  /* Try to avoid invalidating if we can */
  if (change & GTK_CSS_RADICAL_CHANGE)
    return TRUE;

  if (GTK_IS_CSS_ANIMATED_STYLE (style))
    style = GTK_CSS_ANIMATED_STYLE (style)->style;

  if (gtk_css_static_style_get_change (GTK_CSS_STATIC_STYLE (style)) & change)
    return TRUE;
  else
    return FALSE;
}

407 408
static GtkCssStyle *
gtk_css_node_real_update_style (GtkCssNode   *cssnode,
409
                                GtkCssChange  change,
410
                                gint64        timestamp,
411
                                GtkCssStyle  *style)
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
  GtkCssStyle *static_style, *new_static_style, *new_style;

  if (GTK_IS_CSS_ANIMATED_STYLE (style))
    {
      static_style = GTK_CSS_ANIMATED_STYLE (style)->style;
    }
  else
    {
      static_style = style;
    }

  if (gtk_css_style_needs_recreation (static_style, change))
    new_static_style = gtk_css_node_create_style (cssnode);
  else
    new_static_style = g_object_ref (static_style);

  if (new_static_style != static_style || (change & GTK_CSS_CHANGE_ANIMATIONS))
    {
      GtkCssNode *parent = gtk_css_node_get_parent (cssnode);
      new_style = gtk_css_animated_style_new (new_static_style,
                                              parent ? gtk_css_node_get_style (parent) : NULL,
                                              timestamp,
                                              gtk_css_node_get_style_provider (cssnode),
                                              should_create_transitions (change) ? style : NULL);
    }
438
  else if (static_style != style && (change & GTK_CSS_CHANGE_TIMESTAMP))
439 440 441 442 443 444 445 446 447 448
    {
      new_style = gtk_css_animated_style_new_advance (GTK_CSS_ANIMATED_STYLE (style),
                                                      static_style,
                                                      timestamp);
    }
  else
    {
      new_style = g_object_ref (style);
    }

449
  if (!gtk_css_style_is_static (new_style))
450 451 452
    gtk_css_node_set_invalid (cssnode, TRUE);

  g_object_unref (new_static_style);
453

454
  return new_style;
455 456
}

457
static void
458
gtk_css_node_real_invalidate (GtkCssNode *node)
459 460 461
{
}

462
static void
463
gtk_css_node_real_queue_validate (GtkCssNode *node)
464
{
465
}
466

467 468 469
static void
gtk_css_node_real_dequeue_validate (GtkCssNode *node)
{
470 471
}

472 473
static void
gtk_css_node_real_validate (GtkCssNode *node)
474 475 476
{
}

477 478
gboolean
gtk_css_node_real_init_matcher (GtkCssNode     *cssnode,
479
                                GtkCssMatcher  *matcher)
480
{
481
  _gtk_css_matcher_node_init (matcher, cssnode);
482 483 484 485

  return TRUE;
}

486 487 488 489 490 491 492 493 494 495 496 497
static GtkWidgetPath *
gtk_css_node_real_create_widget_path (GtkCssNode *cssnode)
{
  return gtk_widget_path_new ();
}

static const GtkWidgetPath *
gtk_css_node_real_get_widget_path (GtkCssNode *cssnode)
{
  return NULL;
}

498 499 500
static GtkStyleProviderPrivate *
gtk_css_node_real_get_style_provider (GtkCssNode *cssnode)
{
501
  return NULL;
502 503
}

504 505 506 507 508 509
static GdkFrameClock *
gtk_css_node_real_get_frame_clock (GtkCssNode *cssnode)
{
  return NULL;
}

510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
static void
gtk_css_node_real_node_removed (GtkCssNode *parent,
                                GtkCssNode *node,
                                GtkCssNode *previous)
{
  if (node->previous_sibling)
    node->previous_sibling->next_sibling = node->next_sibling;
  else
    node->parent->first_child = node->next_sibling;

  if (node->next_sibling)
    node->next_sibling->previous_sibling = node->previous_sibling;
  else
    node->parent->last_child = node->previous_sibling;

  node->previous_sibling = NULL;
  node->next_sibling = NULL;
  node->parent = NULL;
}

static void
gtk_css_node_real_node_added (GtkCssNode *parent,
                              GtkCssNode *node,
                              GtkCssNode *new_previous)
{
  if (new_previous)
    {
      node->previous_sibling = new_previous;
      node->next_sibling = new_previous->next_sibling;
      new_previous->next_sibling = node;
    }
  else
    {
      node->next_sibling = parent->first_child;
      parent->first_child = node;
    }

  if (node->next_sibling)
    node->next_sibling->previous_sibling = node;
  else
    parent->last_child = node;

  node->parent = parent;
}

555
static void
556 557
gtk_css_node_real_style_changed (GtkCssNode        *cssnode,
                                 GtkCssStyleChange *change)
558
{
559
  g_set_object (&cssnode->style, gtk_css_style_change_get_new_style (change));
560 561
}

562 563
static void
gtk_css_node_class_init (GtkCssNodeClass *klass)
564
{
565
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
566

Benjamin Otte's avatar
Benjamin Otte committed
567 568
  object_class->get_property = gtk_css_node_get_property;
  object_class->set_property = gtk_css_node_set_property;
569
  object_class->dispose = gtk_css_node_dispose;
570
  object_class->finalize = gtk_css_node_finalize;
571

572
  klass->update_style = gtk_css_node_real_update_style;
573
  klass->invalidate = gtk_css_node_real_invalidate;
574
  klass->validate = gtk_css_node_real_validate;
575 576
  klass->queue_validate = gtk_css_node_real_queue_validate;
  klass->dequeue_validate = gtk_css_node_real_dequeue_validate;
577
  klass->init_matcher = gtk_css_node_real_init_matcher;
578 579
  klass->create_widget_path = gtk_css_node_real_create_widget_path;
  klass->get_widget_path = gtk_css_node_real_get_widget_path;
580
  klass->get_style_provider = gtk_css_node_real_get_style_provider;
581
  klass->get_frame_clock = gtk_css_node_real_get_frame_clock;
582 583 584

  klass->node_added = gtk_css_node_real_node_added;
  klass->node_removed = gtk_css_node_real_node_removed;
585
  klass->style_changed = gtk_css_node_real_style_changed;
586 587 588 589 590 591 592 593 594 595

  cssnode_signals[NODE_ADDED] =
    g_signal_new (I_("node-added"),
		  G_TYPE_FROM_CLASS (object_class),
		  G_SIGNAL_RUN_LAST,
                  G_STRUCT_OFFSET (GtkCssNodeClass, node_added),
		  NULL, NULL,
		  _gtk_marshal_VOID__OBJECT_OBJECT,
		  G_TYPE_NONE, 2,
		  GTK_TYPE_CSS_NODE, GTK_TYPE_CSS_NODE);
596 597 598 599
  g_signal_set_va_marshaller (cssnode_signals[NODE_ADDED],
                              G_TYPE_FROM_CLASS (klass),
                              _gtk_marshal_VOID__OBJECT_OBJECTv);

600 601 602 603 604 605 606 607 608
  cssnode_signals[NODE_REMOVED] =
    g_signal_new (I_("node-removed"),
		  G_TYPE_FROM_CLASS (object_class),
		  G_SIGNAL_RUN_LAST,
                  G_STRUCT_OFFSET (GtkCssNodeClass, node_removed),
		  NULL, NULL,
		  _gtk_marshal_VOID__OBJECT_OBJECT,
		  G_TYPE_NONE, 2,
		  GTK_TYPE_CSS_NODE, GTK_TYPE_CSS_NODE);
609 610 611 612
  g_signal_set_va_marshaller (cssnode_signals[NODE_REMOVED],
                              G_TYPE_FROM_CLASS (klass),
                              _gtk_marshal_VOID__OBJECT_OBJECTv);

613 614 615 616 617 618
  cssnode_signals[STYLE_CHANGED] =
    g_signal_new (I_("style-changed"),
		  G_TYPE_FROM_CLASS (object_class),
		  G_SIGNAL_RUN_LAST,
                  G_STRUCT_OFFSET (GtkCssNodeClass, style_changed),
		  NULL, NULL,
619 620 621
		  _gtk_marshal_VOID__POINTER,
		  G_TYPE_NONE, 1,
		  G_TYPE_POINTER);
622 623 624
  g_signal_set_va_marshaller (cssnode_signals[STYLE_CHANGED],
                              G_TYPE_FROM_CLASS (klass),
                              _gtk_marshal_VOID__POINTERv);
Benjamin Otte's avatar
Benjamin Otte committed
625 626

  cssnode_properties[PROP_CLASSES] =
627
    g_param_spec_boxed ("classes", P_("Style Classes"), P_("List of classes"),
Benjamin Otte's avatar
Benjamin Otte committed
628 629 630 631
                         G_TYPE_STRV,
                         G_PARAM_READWRITE
                         | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
  cssnode_properties[PROP_ID] =
632
    g_param_spec_string ("id", P_("ID"), P_("Unique ID"),
Benjamin Otte's avatar
Benjamin Otte committed
633 634 635
                         NULL,
                         G_PARAM_READWRITE
                         | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
636
  cssnode_properties[PROP_NAME] =
637
    g_param_spec_string ("name", P_("Name"), "Name identifying the type of node",
638 639 640
                         NULL,
                         G_PARAM_READWRITE
                         | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
Benjamin Otte's avatar
Benjamin Otte committed
641
  cssnode_properties[PROP_STATE] =
642
    g_param_spec_flags ("state", P_("State"), P_("State flags"),
Benjamin Otte's avatar
Benjamin Otte committed
643 644 645 646 647
                        GTK_TYPE_STATE_FLAGS,
                        0,
                        G_PARAM_READWRITE
                        | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
  cssnode_properties[PROP_VISIBLE] =
648
    g_param_spec_boolean ("visible", P_("Visible"), P_("If other nodes can see this node"),
Benjamin Otte's avatar
Benjamin Otte committed
649 650 651 652
                          TRUE,
                          G_PARAM_READWRITE
                          | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
  cssnode_properties[PROP_WIDGET_TYPE] =
653
    g_param_spec_gtype ("widget-type", P_("Widget type"), P_("GType of the widget"),
Benjamin Otte's avatar
Benjamin Otte committed
654 655 656 657 658
                        G_TYPE_NONE,
                        G_PARAM_READWRITE
                        | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);

  g_object_class_install_properties (object_class, NUM_PROPERTIES, cssnode_properties);
659 660 661 662 663
}

static void
gtk_css_node_init (GtkCssNode *cssnode)
{
664
  cssnode->decl = gtk_css_node_declaration_new ();
665 666

  cssnode->style = g_object_ref (gtk_css_static_style_get_default ());
667 668

  cssnode->visible = TRUE;
669
}
670

671 672 673 674 675 676 677
/**
 * gtk_css_node_new:
 *
 * Creates a new CSS node.
 *
 * Returns: (transfer full): the new CSS node
 */
678 679 680 681 682 683
GtkCssNode *
gtk_css_node_new (void)
{
  return g_object_new (GTK_TYPE_CSS_NODE, NULL);
}

684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704
static GdkFrameClock *
gtk_css_node_get_frame_clock_or_null (GtkCssNode *cssnode)
{
  while (cssnode->parent)
    cssnode = cssnode->parent;

  return GTK_CSS_NODE_GET_CLASS (cssnode)->get_frame_clock (cssnode);
}

static gint64
gtk_css_node_get_timestamp (GtkCssNode *cssnode)
{
  GdkFrameClock *frameclock;

  frameclock = gtk_css_node_get_frame_clock_or_null (cssnode);
  if (frameclock == NULL)
    return 0;

  return gdk_frame_clock_get_frame_time (frameclock);
}

705 706 707 708 709 710 711 712 713 714 715 716 717 718
static void
gtk_css_node_parent_was_unset (GtkCssNode *node)
{
  if (node->invalid)
    GTK_CSS_NODE_GET_CLASS (node)->queue_validate (node);
}

static void
gtk_css_node_parent_will_be_set (GtkCssNode *node)
{
  if (node->invalid)
    GTK_CSS_NODE_GET_CLASS (node)->dequeue_validate (node);
}

719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734
static void
gtk_css_node_invalidate_style (GtkCssNode *cssnode)
{
  if (cssnode->style_is_invalid)
    return;

  cssnode->style_is_invalid = TRUE;
  gtk_css_node_set_invalid (cssnode, TRUE);
  
  if (cssnode->first_child)
    gtk_css_node_invalidate_style (cssnode->first_child);
  
  if (cssnode->next_sibling)
    gtk_css_node_invalidate_style (cssnode->next_sibling);
}

735 736
static void
gtk_css_node_reposition (GtkCssNode *node,
737
                         GtkCssNode *new_parent,
738 739
                         GtkCssNode *previous)
{
740
  GtkCssNode *old_parent;
741

742 743 744
  g_assert (! (new_parent == NULL && previous != NULL));

  old_parent = node->parent;
745 746
  /* Take a reference here so the whole function has a reference */
  g_object_ref (node);
747

748
  if (node->visible)
749
    {
750 751 752 753 754 755 756
      if (node->next_sibling)
        gtk_css_node_invalidate (node->next_sibling,
                                 GTK_CSS_CHANGE_ANY_SIBLING
                                 | GTK_CSS_CHANGE_NTH_CHILD
                                 | (node->previous_sibling ? 0 : GTK_CSS_CHANGE_FIRST_CHILD));
      else if (node->previous_sibling)
        gtk_css_node_invalidate (node->previous_sibling, GTK_CSS_CHANGE_LAST_CHILD);
757
    }
758

759 760 761
  if (old_parent != NULL)
    {
      g_signal_emit (old_parent, cssnode_signals[NODE_REMOVED], 0, node, node->previous_sibling);
762
      if (old_parent->first_child && node->visible)
763
        gtk_css_node_invalidate (old_parent->first_child, GTK_CSS_CHANGE_NTH_LAST_CHILD);
764
    }
765

766
  if (old_parent != new_parent)
767
    {
768
      if (old_parent == NULL)
769 770 771 772 773 774 775
        {
          gtk_css_node_parent_will_be_set (node);
        }
      else
        {
          g_object_unref (node);
        }
776

777 778 779
      if (gtk_css_node_get_style_provider_or_null (node) == NULL)
        gtk_css_node_invalidate_style_provider (node);
      gtk_css_node_invalidate (node, GTK_CSS_CHANGE_TIMESTAMP | GTK_CSS_CHANGE_ANIMATIONS);
780

781
      if (new_parent)
782
        {
783
          g_object_ref (node);
784

785
          if (node->pending_changes)
786
            new_parent->needs_propagation = TRUE;
787
          if (node->invalid && node->visible)
788
            gtk_css_node_set_invalid (new_parent, TRUE);
789 790 791 792
        }
      else
        {
          gtk_css_node_parent_was_unset (node);
793 794 795
        }
    }

796 797 798
  if (new_parent)
    {
      g_signal_emit (new_parent, cssnode_signals[NODE_ADDED], 0, node, previous);
799 800
      if (node->visible)
        gtk_css_node_invalidate (new_parent->first_child, GTK_CSS_CHANGE_NTH_LAST_CHILD);
801
    }
802

803
  if (node->visible)
804
    {
805 806 807 808 809 810 811 812 813 814 815
      if (node->next_sibling)
        {
          if (node->previous_sibling == NULL)
            gtk_css_node_invalidate (node->next_sibling, GTK_CSS_CHANGE_FIRST_CHILD);
          else
            gtk_css_node_invalidate_style (node->next_sibling);
        }
      else if (node->previous_sibling)
        {
          gtk_css_node_invalidate (node->previous_sibling, GTK_CSS_CHANGE_LAST_CHILD);
        }
816
    }
817
  else
818
    {
819 820
      if (node->next_sibling)
        gtk_css_node_invalidate_style (node->next_sibling);
821
    }
822

823 824 825 826 827
  gtk_css_node_invalidate (node, GTK_CSS_CHANGE_ANY_PARENT
                                 | GTK_CSS_CHANGE_ANY_SIBLING
                                 | GTK_CSS_CHANGE_NTH_CHILD
                                 | (node->previous_sibling ? 0 : GTK_CSS_CHANGE_FIRST_CHILD)
                                 | (node->next_sibling ? 0 : GTK_CSS_CHANGE_LAST_CHILD));
828

829 830 831 832 833 834 835 836 837 838 839
  g_object_unref (node);
}

void
gtk_css_node_set_parent (GtkCssNode *node,
                         GtkCssNode *parent)
{
  if (node->parent == parent)
    return;

  gtk_css_node_reposition (node, parent, parent ? parent->last_child : NULL);
840 841
}

842
/* If previous_sibling is NULL, insert at the beginning */
843
void
844 845 846
gtk_css_node_insert_after (GtkCssNode *parent,
                           GtkCssNode *cssnode,
                           GtkCssNode *previous_sibling)
847
{
848
  g_return_if_fail (previous_sibling == NULL || previous_sibling->parent == parent);
Matthias Clasen's avatar
Matthias Clasen committed
849
  g_return_if_fail (cssnode != previous_sibling);
850 851 852

  if (cssnode->previous_sibling == previous_sibling &&
      cssnode->parent == parent)
853 854 855
    return;

  gtk_css_node_reposition (cssnode,
856
                           parent,
857 858 859
                           previous_sibling);
}

860
/* If next_sibling is NULL, insert at the end */
861
void
862 863 864
gtk_css_node_insert_before (GtkCssNode *parent,
                            GtkCssNode *cssnode,
                            GtkCssNode *next_sibling)
865
{
866
  g_return_if_fail (next_sibling == NULL || next_sibling->parent == parent);
Matthias Clasen's avatar
Matthias Clasen committed
867
  g_return_if_fail (cssnode != next_sibling);
868 869 870

  if (cssnode->next_sibling == next_sibling && 
      cssnode->parent == parent)
871 872 873
    return;

  gtk_css_node_reposition (cssnode,
874 875
                           parent,
                           next_sibling ? next_sibling->previous_sibling : parent->last_child);
876 877
}

878 879 880 881 882 883 884 885 886 887 888 889 890 891 892
void
gtk_css_node_reverse_children (GtkCssNode *cssnode)
{
  GtkCssNode *end;

  end = cssnode->last_child;
  while (cssnode->first_child != end)
    {
      gtk_css_node_reposition (cssnode->first_child,
                               cssnode,
                               end);
    }

}

893 894 895 896 897 898
GtkCssNode *
gtk_css_node_get_parent (GtkCssNode *cssnode)
{
  return cssnode->parent;
}

899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922
GtkCssNode *
gtk_css_node_get_first_child (GtkCssNode *cssnode)
{
  return cssnode->first_child;
}

GtkCssNode *
gtk_css_node_get_last_child (GtkCssNode *cssnode)
{
  return cssnode->last_child;
}

GtkCssNode *
gtk_css_node_get_previous_sibling (GtkCssNode *cssnode)
{
  return cssnode->previous_sibling;
}

GtkCssNode *
gtk_css_node_get_next_sibling (GtkCssNode *cssnode)
{
  return cssnode->next_sibling;
}

923
static gboolean
924 925 926
gtk_css_node_set_style (GtkCssNode  *cssnode,
                        GtkCssStyle *style)
{
927
  GtkCssStyleChange change;
928
  gboolean style_changed;
929

930
  if (cssnode->style == style)
931
    return FALSE;
932

933 934
  gtk_css_style_change_init (&change, cssnode->style, style);

935 936
  style_changed = gtk_css_style_change_has_change (&change);
  if (style_changed)
937 938 939 940 941 942 943
    {
      g_signal_emit (cssnode, cssnode_signals[STYLE_CHANGED], 0, &change);
    }
  else if (cssnode->style != style &&
           (GTK_IS_CSS_ANIMATED_STYLE (cssnode->style) || GTK_IS_CSS_ANIMATED_STYLE (style)))
    {
      /* This is when animations are starting/stopping but they didn't change any CSS this frame */
944
      g_set_object (&cssnode->style, style);
945
    }
946 947 948

  gtk_css_style_change_finish (&change);

949
  return style_changed;
950 951
}

952
static void
953 954
gtk_css_node_propagate_pending_changes (GtkCssNode *cssnode,
                                        gboolean    style_changed)
955 956 957 958 959
{
  GtkCssChange change, child_change;
  GtkCssNode *child;

  change = _gtk_css_change_for_child (cssnode->pending_changes);
960 961
  if (style_changed)
    change |= GTK_CSS_CHANGE_PARENT_STYLE;
962

963
  if (!cssnode->needs_propagation && change == 0)
964 965
    return;

966 967 968 969 970 971 972 973 974
  for (child = gtk_css_node_get_first_child (cssnode);
       child;
       child = gtk_css_node_get_next_sibling (child))
    {
      child_change = child->pending_changes;
      gtk_css_node_invalidate (child, change);
      if (child->visible)
        change |= _gtk_css_change_for_sibling (child_change);
    }
975 976

  cssnode->needs_propagation = FALSE;
977 978
}

979 980 981
static gboolean
gtk_css_node_needs_new_style (GtkCssNode *cssnode)
{
982
  return cssnode->style_is_invalid || cssnode->needs_propagation;
983 984
}

985
static void
986 987
gtk_css_node_ensure_style (GtkCssNode *cssnode,
                           gint64      current_time)
988
{
989
  gboolean style_changed;
990

991
  if (!gtk_css_node_needs_new_style (cssnode))
992 993 994
    return;

  if (cssnode->parent)
995
    gtk_css_node_ensure_style (cssnode->parent, current_time);
996

997 998 999
  if (cssnode->style_is_invalid)
    {
      GtkCssStyle *new_style;
1000

1001 1002
      if (cssnode->previous_sibling)
        gtk_css_node_ensure_style (cssnode->previous_sibling, current_time);
1003

1004 1005
      g_clear_pointer (&cssnode->cache, gtk_css_node_style_cache_unref);

1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017
      new_style = GTK_CSS_NODE_GET_CLASS (cssnode)->update_style (cssnode,
                                                                  cssnode->pending_changes,
                                                                  current_time,
                                                                  cssnode->style);

      style_changed = gtk_css_node_set_style (cssnode, new_style);
      g_object_unref (new_style);
    }
  else
    {
      style_changed = FALSE;
    }
1018

1019 1020 1021
  gtk_css_node_propagate_pending_changes (cssnode, style_changed);

  cssnode->pending_changes = 0;
1022 1023 1024 1025 1026 1027
  cssnode->style_is_invalid = FALSE;
}

GtkCssStyle *
gtk_css_node_get_style (GtkCssNode *cssnode)
{
1028 1029 1030 1031 1032 1033
  if (gtk_css_node_needs_new_style (cssnode))
    {
      gint64 timestamp = gtk_css_node_get_timestamp (cssnode);

      gtk_css_node_ensure_style (cssnode, timestamp);
    }
1034

1035 1036 1037
  return cssnode->style;
}

1038 1039 1040 1041
void
gtk_css_node_set_visible (GtkCssNode *cssnode,
                          gboolean    visible)
{
1042 1043
  GtkCssNode *iter;

1044 1045 1046 1047
  if (cssnode->visible == visible)
    return;

  cssnode->visible = visible;
Benjamin Otte's avatar
Benjamin Otte committed
1048
  g_object_notify_by_pspec (G_OBJECT (cssnode), cssnode_properties[PROP_VISIBLE]);
1049

1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065
  if (cssnode->invalid)
    {
      if (cssnode->visible)
        {
          if (cssnode->parent)
            gtk_css_node_set_invalid (cssnode->parent, TRUE);
          else
            GTK_CSS_NODE_GET_CLASS (cssnode)->queue_validate (cssnode);
        }
      else
        {
          if (cssnode->parent == NULL)
            GTK_CSS_NODE_GET_CLASS (cssnode)->dequeue_validate (cssnode);
        }
    }

1066
  if (cssnode->next_sibling)
1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081
    {
      gtk_css_node_invalidate (cssnode->next_sibling, GTK_CSS_CHANGE_ANY_SIBLING | GTK_CSS_CHANGE_NTH_CHILD);
      if (gtk_css_node_is_first_child (cssnode))
        {
          for (iter = cssnode->next_sibling;
               iter != NULL;
               iter = iter->next_sibling)
            {
              gtk_css_node_invalidate (iter, GTK_CSS_CHANGE_FIRST_CHILD);
              if (iter->visible)
                break;
            }
        }
    }
               
1082
  if (cssnode->previous_sibling)
1083
    {
1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094
      if (gtk_css_node_is_last_child (cssnode))
        {
          for (iter = cssnode->previous_sibling;
               iter != NULL;
               iter = iter->previous_sibling)
            {
              gtk_css_node_invalidate (iter, GTK_CSS_CHANGE_LAST_CHILD);
              if (iter->visible)
                break;
            }
        }
1095 1096
      gtk_css_node_invalidate (cssnode->parent->first_child, GTK_CSS_CHANGE_NTH_LAST_CHILD);
    }
1097 1098 1099 1100 1101 1102 1103 1104
}

gboolean
gtk_css_node_get_visible (GtkCssNode *cssnode)
{
  return cssnode->visible;
}

1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121
void
gtk_css_node_set_name (GtkCssNode              *cssnode,
                       /*interned*/ const char *name)
{
  if (gtk_css_node_declaration_set_name (&cssnode->decl, name))
    {
      gtk_css_node_invalidate (cssnode, GTK_CSS_CHANGE_NAME);
      g_object_notify_by_pspec (G_OBJECT (cssnode), cssnode_properties[PROP_NAME]);
    }
}

/* interned */ const char *
gtk_css_node_get_name (GtkCssNode *cssnode)
{
  return gtk_css_node_declaration_get_name (cssnode->decl);
}

1122 1123 1124 1125
void
gtk_css_node_set_widget_type (GtkCssNode *cssnode,
                              GType       widget_type)
{
1126
  if (gtk_css_node_declaration_set_type (&cssnode->decl, widget_type))
Benjamin Otte's avatar
Benjamin Otte committed
1127 1128 1129 1130
    {
      gtk_css_node_invalidate (cssnode, GTK_CSS_CHANGE_NAME);
      g_object_notify_by_pspec (G_OBJECT (cssnode), cssnode_properties[PROP_WIDGET_TYPE]);
    }
1131 1132 1133 1134 1135 1136 1137 1138
}

GType
gtk_css_node_get_widget_type (GtkCssNode *cssnode)
{
  return gtk_css_node_declaration_get_type (cssnode->decl);
}

1139
void
1140 1141
gtk_css_node_set_id (GtkCssNode                *cssnode,
                     /* interned */ const char *id)
1142
{
1143
  if (gtk_css_node_declaration_set_id (&cssnode->decl, id))
Benjamin Otte's avatar
Benjamin Otte committed
1144 1145 1146 1147
    {
      gtk_css_node_invalidate (cssnode, GTK_CSS_CHANGE_ID);
      g_object_notify_by_pspec (G_OBJECT (cssnode), cssnode_properties[PROP_ID]);
    }
1148 1149
}

1150
/* interned */ const char *
1151 1152 1153 1154 1155
gtk_css_node_get_id (GtkCssNode *cssnode)
{
  return gtk_css_node_declaration_get_id (cssnode->decl);
}

1156
void
1157 1158 1159
gtk_css_node_set_state (GtkCssNode    *cssnode,
                        GtkStateFlags  state_flags)
{
1160
  if (gtk_css_node_declaration_set_state (&cssnode->decl, state_flags))
Benjamin Otte's avatar
Benjamin Otte committed
1161 1162 1163 1164
    {
      gtk_css_node_invalidate (cssnode, GTK_CSS_CHANGE_STATE);
      g_object_notify_by_pspec (G_OBJECT (cssnode), cssnode_properties[PROP_STATE]);
    }
1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185
}

GtkStateFlags
gtk_css_node_get_state (GtkCssNode *cssnode)
{
  return gtk_css_node_declaration_get_state (cssnode->decl);
}

void
gtk_css_node_set_junction_sides (GtkCssNode       *cssnode,
                                 GtkJunctionSides  junction_sides)
{
  gtk_css_node_declaration_set_junction_sides (&cssnode->decl, junction_sides);
}

GtkJunctionSides
gtk_css_node_get_junction_sides (GtkCssNode *cssnode)
{
  return gtk_css_node_declaration_get_junction_sides (cssnode->decl);
}

Benjamin Otte's avatar
Benjamin Otte committed
1186 1187 1188
static void
gtk_css_node_clear_classes (GtkCssNode *cssnode)
{
1189
  if (gtk_css_node_declaration_clear_classes (&cssnode->decl))
Benjamin Otte's avatar
Benjamin Otte committed
1190
    {
1191 1192
      gtk_css_node_invalidate (cssnode, GTK_CSS_CHANGE_CLASS);
      g_object_notify_by_pspec (G_OBJECT (cssnode), cssnode_properties[PROP_CLASSES]);
Benjamin Otte's avatar
Benjamin Otte committed
1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219
    }
}

void
gtk_css_node_set_classes (GtkCssNode  *cssnode,
                          const char **classes)
{
  guint i;

  g_object_freeze_notify (G_OBJECT (cssnode));

  gtk_css_node_clear_classes (cssnode);

  if (classes)
    {
      for (i = 0; classes[i] != NULL; i++)
        {
          gtk_css_node_add_class (cssnode, g_quark_from_string (classes[i]));
        }
    }

  g_object_thaw_notify (G_OBJECT (cssnode));
}

char **
gtk_css_node_get_classes (GtkCssNode *cssnode)
{
1220 1221 1222
  const GQuark *classes;
  char **result;
  guint n_classes, i, j;
Benjamin Otte's avatar
Benjamin Otte committed
1223

1224 1225 1226 1227
  classes = gtk_css_node_declaration_get_classes (cssnode->decl, &n_classes);
  result = g_new (char *, n_classes + 1);

  for (i = n_classes, j = 0; i-- > 0; ++j)
Benjamin Otte's avatar
Benjamin Otte committed
1228
    {
1229
      result[j] = g_strdup (g_quark_to_string (classes[i]));
Benjamin Otte's avatar
Benjamin Otte committed
1230 1231
    }

1232 1233
  result[n_classes] = NULL;
  return result;
Benjamin Otte's avatar
Benjamin Otte committed
1234 1235
}

1236
void
1237 1238 1239
gtk_css_node_add_class (GtkCssNode *cssnode,
                        GQuark      style_class)
{
1240
  if (gtk_css_node_declaration_add_class (&cssnode->decl, style_class))
Benjamin Otte's avatar
Benjamin Otte committed
1241 1242 1243 1244
    {
      gtk_css_node_invalidate (cssnode, GTK_CSS_CHANGE_CLASS);
      g_object_notify_by_pspec (G_OBJECT (cssnode), cssnode_properties[PROP_CLASSES]);
    }
1245 1246
}

1247
void
1248 1249 1250
gtk_css_node_remove_class (GtkCssNode *cssnode,
                           GQuark      style_class)
{
1251
  if (gtk_css_node_declaration_remove_class (&cssnode->decl, style_class))
Benjamin Otte's avatar
Benjamin Otte committed
1252 1253 1254 1255
    {
      gtk_css_node_invalidate (cssnode, GTK_CSS_CHANGE_CLASS);
      g_object_notify_by_pspec (G_OBJECT (cssnode), cssnode_properties[PROP_CLASSES]);
    }
1256 1257 1258 1259 1260 1261 1262 1263 1264
}

gboolean
gtk_css_node_has_class (GtkCssNode *cssnode,
                        GQuark      style_class)
{
  return gtk_css_node_declaration_has_class (cssnode->decl, style_class);
}

1265 1266 1267
const GQuark *
gtk_css_node_list_classes (GtkCssNode *cssnode,
                           guint      *n_classes)
1268
{
1269
  return gtk_css_node_declaration_get_classes (cssnode->decl, n_classes);
1270 1271
}

1272
void
1273 1274 1275 1276
gtk_css_node_add_region (GtkCssNode     *cssnode,
                         GQuark          region,
                         GtkRegionFlags  flags)
{
1277
  gtk_css_node_declaration_add_region (&cssnode->decl, region, flags);
1278 1279
}

1280
void
1281 1282 1283
gtk_css_node_remove_region (GtkCssNode *cssnode,
                            GQuark      region)
{
1284
  gtk_css_node_declaration_remove_region (&cssnode->decl, region);
1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307
}

gboolean
gtk_css_node_has_region (GtkCssNode     *cssnode,
                         GQuark          region,
                         GtkRegionFlags *out_flags)
{
  return gtk_css_node_declaration_has_region (cssnode->decl, region, out_flags);
}

GList *
gtk_css_node_list_regions (GtkCssNode *cssnode)
{
  return gtk_css_node_declaration_list_regions (cssnode->decl);
}


const GtkCssNodeDeclaration *
gtk_css_node_get_declaration (GtkCssNode *cssnode)
{
  return cssnode->decl;
}

1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323
void
gtk_css_node_invalidate_style_provider (GtkCssNode *cssnode)
{
  GtkCssNode *child;

  gtk_css_node_invalidate (cssnode, GTK_CSS_CHANGE_SOURCE);

  for (child = cssnode->first_child;
       child;
       child = child->next_sibling)
    {
      if (gtk_css_node_get_style_provider_or_null (child) == NULL)
        gtk_css_node_invalidate_style_provider (child);
    }
}

1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340
static void
gtk_css_node_invalidate_timestamp (GtkCssNode *cssnode)
{
  GtkCssNode *child;

  if (!cssnode->invalid)
    return;

  if (!gtk_css_style_is_static (cssnode->style))
    gtk_css_node_invalidate (cssnode, GTK_CSS_CHANGE_TIMESTAMP);

  for (child = cssnode->first_child; child; child = child->next_sibling)
    {
      gtk_css_node_invalidate_timestamp (child);
    }
}

1341 1342 1343 1344 1345 1346 1347 1348
void
gtk_css_node_invalidate_frame_clock (GtkCssNode *cssnode,
                                     gboolean    just_timestamp)
{
  /* frame clock is handled by the top level */
  if (cssnode->parent)
    return;

1349 1350 1351 1352
  gtk_css_node_invalidate_timestamp (cssnode);

  if (!just_timestamp)
    gtk_css_node_invalidate (cssnode, GTK_CSS_CHANGE_ANIMATIONS);
1353 1354
}

1355 1356 1357 1358
void
gtk_css_node_invalidate (GtkCssNode   *cssnode,
                         GtkCssChange  change)
{
1359 1360 1361 1362 1363 1364
  if (!cssnode->invalid)
    change &= ~GTK_CSS_CHANGE_TIMESTAMP;

  if (change == 0)
    return;

1365 1366
  cssnode->pending_changes |= change;

1367
  GTK_CSS_NODE_GET_CLASS (cssnode)->invalidate (cssnode);
1368

1369 1370
  if (cssnode->parent)
    cssnode->parent->needs_propagation = TRUE;
1371
  gtk_css_node_invalidate_style (cssnode);
1372 1373
}

1374
void
1375 1376
gtk_css_node_validate_internal (GtkCssNode *cssnode,
                                gint64      timestamp)
1377 1378 1379
{
  GtkCssNode *child;

1380
  if (!cssnode->invalid)
1381 1382
    return;

1383
  gtk_css_node_ensure_style (cssnode, timestamp);
1384

1385 1386
  /* need to set to FALSE then to TRUE here to make it chain up */
  gtk_css_node_set_invalid (cssnode, FALSE);
1387
  if (!gtk_css_style_is_static (cssnode->style))
1388
    gtk_css_node_set_invalid (cssnode, TRUE);
1389

1390
  GTK_CSS_NODE_GET_CLASS (cssnode)->validate (cssnode);
1391

1392 1393 1394 1395
  for (child = gtk_css_node_get_first_child (cssnode);
       child;
       child = gtk_css_node_get_next_sibling (child))
    {
1396
      if (child->visible)
1397
        gtk_css_node_validate_internal (child, timestamp);
1398 1399 1400
    }
}

1401 1402 1403 1404 1405 1406 1407 1408 1409 1410
void
gtk_css_node_validate (GtkCssNode *cssnode)
{
  gint64 timestamp;

  timestamp = gtk_css_node_get_timestamp (cssnode);

  gtk_css_node_validate_internal (cssnode, timestamp);
}

1411 1412
gboolean
gtk_css_node_init_matcher (GtkCssNode     *cssnode,
1413
                           GtkCssMatcher  *matcher)
1414
{
1415
  return GTK_CSS_NODE_GET_CLASS (cssnode)->init_matcher (cssnode, matcher);
1416 1417
}

1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429
GtkWidgetPath *
gtk_css_node_create_widget_path (GtkCssNode *cssnode)
{
  return GTK_CSS_NODE_GET_CLASS (cssnode)->create_widget_path (cssnode);
}

const GtkWidgetPath *
gtk_css_node_get_widget_path (GtkCssNode *cssnode)
{
  return GTK_CSS_NODE_GET_CLASS (cssnode)->get_widget_path (cssnode);
}

1430 1431 1432
GtkStyleProviderPrivate *
gtk_css_node_get_style_provider (GtkCssNode *cssnode)
{
1433
  GtkStyleProviderPrivate *result;
1434

1435 1436 1437 1438 1439 1440 1441 1442
  result = gtk_css_node_get_style_provider_or_null (cssnode);
  if (result)
    return result;

  if (cssnode->parent)
    return gtk_css_node_get_style_provider (cssnode->parent);

  return GTK_STYLE_PROVIDER_PRIVATE (_gtk_settings_get_style_cascade (gtk_settings_get_default (), 1));
1443
}
1444 1445 1446 1447 1448 1449 1450

void
gtk_css_node_print (GtkCssNode                *cssnode,
                    GtkStyleContextPrintFlags  flags,
                    GString                   *string,
                    guint                      indent)
{
1451
  gboolean need_newline = FALSE;
1452 1453

  g_string_append_printf (string, "%*s", indent, "");
1454 1455 1456 1457 1458 1459 1460 1461 1462

  if (!cssnode->visible)
    g_string_append_c (string, '[');

  gtk_css_node_declaration_print (cssnode->decl, string);

  if (!cssnode->visible)
    g_string_append_c (string, ']');

1463 1464
  g_string_append_c (string, '\n');

1465
  if (flags & GTK_STYLE_CONTEXT_PRINT_SHOW_STYLE)
1466
    need_newline = gtk_css_style_print (gtk_css_node_get_style (cssnode), string, indent + 2, TRUE);
1467 1468 1469

  if (flags & GTK_STYLE_CONTEXT_PRINT_RECURSE)
    {
1470 1471 1472 1473 1474
      GtkCssNode *node;

      if (need_newline && gtk_css_node_get_first_child (cssnode))
        g_string_append_c (string, '\n');

1475 1476 1477 1478
      for (node = gtk_css_node_get_first_child (cssnode); node; node = gtk_css_node_get_next_sibling (node))
        gtk_css_node_print (node, flags, string, indent + 2);
    }
}