Pileus Git - ~andy/gtk/blob - gtk/gtkthemingengine.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 2010 Carlos Garnacho <carlosg@gnome.org>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library. If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include "config.h"
  19
  20 #include <math.h>
  21 #include <gtk/gtk.h>
  22
  23 #include <gtk/gtkthemingengine.h>
  24 #include <gtk/gtkstylecontext.h>
  25 #include <gtk/gtkintl.h>
  26
  27 #include "gtkprivate.h"
  28 #include "gtkmodulesprivate.h"
  29 #include "gtkborderimageprivate.h"
  30 #include "gtkpango.h"
  31 #include "gtkcssarrayvalueprivate.h"
  32 #include "gtkcsscornervalueprivate.h"
  33 #include "gtkcssenumvalueprivate.h"
  34 #include "gtkcssnumbervalueprivate.h"
  35 #include "gtkcssrgbavalueprivate.h"
  36 #include "gtkcssshadowsvalueprivate.h"
  37 #include "gtkcsstypesprivate.h"
  38 #include "gtkhslaprivate.h"
  39 #include "gtkthemingengineprivate.h"
  40 #include "gtkroundedboxprivate.h"
  41 #include "gtkthemingbackgroundprivate.h"
  42
  43 #include "fallback-c89.c"
  44
  45 /**
  46  * SECTION:gtkthemingengine
  47  * @Short_description: Theming renderers
  48  * @Title: GtkThemingEngine
  49  * @See_also: #GtkStyleContext
  50  *
  51  * #GtkThemingEngine is the object used for rendering themed content
  52  * in GTK+ widgets. Even though GTK+ has a default implementation,
  53  * it can be overridden in CSS files by enforcing a #GtkThemingEngine
  54  * object to be loaded as a module.
  55  *
  56  * In order to implement a theming engine, a #GtkThemingEngine subclass
  57  * must be created, alongside the CSS file that will reference it, the
  58  * theming engine would be created as an .so library, and installed in
  59  * $(gtk-modules-dir)/theming-engines/.
  60  *
  61  * #GtkThemingEngine<!-- -->s have limited access to the object they are
  62  * rendering, the #GtkThemingEngine API has read-only accessors to the
  63  * style information contained in the rendered object's #GtkStyleContext.
  64  */
  65
  66 enum {
  67   PROP_0,
  68   PROP_NAME
  69 };
  70
  71 struct GtkThemingEnginePrivate
  72 {
  73   GtkStyleContext *context;
  74   gchar *name;
  75 };
  76
  77 #define GTK_THEMING_ENGINE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GTK_TYPE_THEMING_ENGINE, GtkThemingEnginePrivate))
  78
  79 static void gtk_theming_engine_finalize          (GObject      *object);
  80 static void gtk_theming_engine_impl_set_property (GObject      *object,
  81                                                   guint         prop_id,
  82                                                   const GValue *value,
  83                                                   GParamSpec   *pspec);
  84 static void gtk_theming_engine_impl_get_property (GObject      *object,
  85                                                   guint         prop_id,
  86                                                   GValue       *value,
  87                                                   GParamSpec   *pspec);
  88
  89 static void gtk_theming_engine_render_check (GtkThemingEngine *engine,
  90                                              cairo_t          *cr,
  91                                              gdouble           x,
  92                                              gdouble           y,
  93                                              gdouble           width,
  94                                              gdouble           height);
  95 static void gtk_theming_engine_render_option (GtkThemingEngine *engine,
  96                                               cairo_t          *cr,
  97                                               gdouble           x,
  98                                               gdouble           y,
  99                                               gdouble           width,
 100                                               gdouble           height);
 101 static void gtk_theming_engine_render_arrow  (GtkThemingEngine *engine,
 102                                               cairo_t          *cr,
 103                                               gdouble           angle,
 104                                               gdouble           x,
 105                                               gdouble           y,
 106                                               gdouble           size);
 107 static void gtk_theming_engine_render_background (GtkThemingEngine *engine,
 108                                                   cairo_t          *cr,
 109                                                   gdouble           x,
 110                                                   gdouble           y,
 111                                                   gdouble           width,
 112                                                   gdouble           height);
 113 static void gtk_theming_engine_render_frame  (GtkThemingEngine *engine,
 114                                               cairo_t          *cr,
 115                                               gdouble           x,
 116                                               gdouble           y,
 117                                               gdouble           width,
 118                                               gdouble           height);
 119 static void gtk_theming_engine_render_expander (GtkThemingEngine *engine,
 120                                                 cairo_t          *cr,
 121                                                 gdouble           x,
 122                                                 gdouble           y,
 123                                                 gdouble           width,
 124                                                 gdouble           height);
 125 static void gtk_theming_engine_render_focus    (GtkThemingEngine *engine,
 126                                                 cairo_t          *cr,
 127                                                 gdouble           x,
 128                                                 gdouble           y,
 129                                                 gdouble           width,
 130                                                 gdouble           height);
 131 static void gtk_theming_engine_render_layout   (GtkThemingEngine *engine,
 132                                                 cairo_t          *cr,
 133                                                 gdouble           x,
 134                                                 gdouble           y,
 135                                                 PangoLayout      *layout);
 136 static void gtk_theming_engine_render_line     (GtkThemingEngine *engine,
 137                                                 cairo_t          *cr,
 138                                                 gdouble           x0,
 139                                                 gdouble           y0,
 140                                                 gdouble           x1,
 141                                                 gdouble           y1);
 142 static void gtk_theming_engine_render_slider   (GtkThemingEngine *engine,
 143                                                 cairo_t          *cr,
 144                                                 gdouble           x,
 145                                                 gdouble           y,
 146                                                 gdouble           width,
 147                                                 gdouble           height,
 148                                                 GtkOrientation    orientation);
 149 static void gtk_theming_engine_render_frame_gap (GtkThemingEngine *engine,
 150                                                  cairo_t          *cr,
 151                                                  gdouble           x,
 152                                                  gdouble           y,
 153                                                  gdouble           width,
 154                                                  gdouble           height,
 155                                                  GtkPositionType   gap_side,
 156                                                  gdouble           xy0_gap,
 157                                                  gdouble           xy1_gap);
 158 static void gtk_theming_engine_render_extension (GtkThemingEngine *engine,
 159                                                  cairo_t          *cr,
 160                                                  gdouble           x,
 161                                                  gdouble           y,
 162                                                  gdouble           width,
 163                                                  gdouble           height,
 164                                                  GtkPositionType   gap_side);
 165 static void gtk_theming_engine_render_handle    (GtkThemingEngine *engine,
 166                                                  cairo_t          *cr,
 167                                                  gdouble           x,
 168                                                  gdouble           y,
 169                                                  gdouble           width,
 170                                                  gdouble           height);
 171 static void gtk_theming_engine_render_activity  (GtkThemingEngine *engine,
 172                                                  cairo_t          *cr,
 173                                                  gdouble           x,
 174                                                  gdouble           y,
 175                                                  gdouble           width,
 176                                                  gdouble           height);
 177 static GdkPixbuf * gtk_theming_engine_render_icon_pixbuf (GtkThemingEngine    *engine,
 178                                                           const GtkIconSource *source,
 179                                                           GtkIconSize          size);
 180 static void gtk_theming_engine_render_icon (GtkThemingEngine *engine,
 181                                             cairo_t *cr,
 182                                             GdkPixbuf *pixbuf,
 183                                             gdouble x,
 184                                             gdouble y);
 185
 186 G_DEFINE_TYPE (GtkThemingEngine, gtk_theming_engine, G_TYPE_OBJECT)
 187
 188
 189 typedef struct GtkThemingModule GtkThemingModule;
 190 typedef struct GtkThemingModuleClass GtkThemingModuleClass;
 191
 192 struct GtkThemingModule
 193 {
 194   GTypeModule parent_instance;
 195   GModule *module;
 196   gchar *name;
 197
 198   void (*init) (GTypeModule *module);
 199   void (*exit) (void);
 200   GtkThemingEngine * (*create_engine) (void);
 201 };
 202
 203 struct GtkThemingModuleClass
 204 {
 205   GTypeModuleClass parent_class;
 206 };
 207
 208 #define GTK_TYPE_THEMING_MODULE  (gtk_theming_module_get_type ())
 209 #define GTK_THEMING_MODULE(o)    (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_THEMING_MODULE, GtkThemingModule))
 210 #define GTK_IS_THEMING_MODULE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_THEMING_MODULE))
 211
 212 GType gtk_theming_module_get_type (void);
 213
 214 G_DEFINE_TYPE (GtkThemingModule, gtk_theming_module, G_TYPE_TYPE_MODULE);
 215
 216 static void
 217 gtk_theming_engine_class_init (GtkThemingEngineClass *klass)
 218 {
 219   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 220
 221   object_class->finalize = gtk_theming_engine_finalize;
 222   object_class->set_property = gtk_theming_engine_impl_set_property;
 223   object_class->get_property = gtk_theming_engine_impl_get_property;
 224
 225   klass->render_icon = gtk_theming_engine_render_icon;
 226   klass->render_check = gtk_theming_engine_render_check;
 227   klass->render_option = gtk_theming_engine_render_option;
 228   klass->render_arrow = gtk_theming_engine_render_arrow;
 229   klass->render_background = gtk_theming_engine_render_background;
 230   klass->render_frame = gtk_theming_engine_render_frame;
 231   klass->render_expander = gtk_theming_engine_render_expander;
 232   klass->render_focus = gtk_theming_engine_render_focus;
 233   klass->render_layout = gtk_theming_engine_render_layout;
 234   klass->render_line = gtk_theming_engine_render_line;
 235   klass->render_slider = gtk_theming_engine_render_slider;
 236   klass->render_frame_gap = gtk_theming_engine_render_frame_gap;
 237   klass->render_extension = gtk_theming_engine_render_extension;
 238   klass->render_handle = gtk_theming_engine_render_handle;
 239   klass->render_activity = gtk_theming_engine_render_activity;
 240   klass->render_icon_pixbuf = gtk_theming_engine_render_icon_pixbuf;
 241
 242   /**
 243    * GtkThemingEngine:name:
 244    *
 245    * The theming engine name, this name will be used when registering
 246    * custom properties, for a theming engine named "Clearlooks" registering
 247    * a "glossy" custom property, it could be referenced in the CSS file as
 248    *
 249    * <programlisting>
 250    * -Clearlooks-glossy: true;
 251    * </programlisting>
 252    *
 253    * Since: 3.0
 254    */
 255   g_object_class_install_property (object_class,
 256                                    PROP_NAME,
 257                                    g_param_spec_string ("name",
 258                                                         P_("Name"),
 259                                                         P_("Theming engine name"),
 260                                                         NULL,
 261                                                         G_PARAM_CONSTRUCT_ONLY | GTK_PARAM_READWRITE));
 262
 263   g_type_class_add_private (object_class, sizeof (GtkThemingEnginePrivate));
 264 }
 265
 266 static void
 267 gtk_theming_engine_init (GtkThemingEngine *engine)
 268 {
 269   engine->priv = GTK_THEMING_ENGINE_GET_PRIVATE (engine);
 270 }
 271
 272 static void
 273 gtk_theming_engine_finalize (GObject *object)
 274 {
 275   GtkThemingEnginePrivate *priv;
 276
 277   priv = GTK_THEMING_ENGINE (object)->priv;
 278   g_free (priv->name);
 279
 280   G_OBJECT_GET_CLASS (gtk_theming_engine_parent_class)->finalize (object);
 281 }
 282
 283 static void
 284 gtk_theming_engine_impl_set_property (GObject      *object,
 285                                       guint         prop_id,
 286                                       const GValue *value,
 287                                       GParamSpec   *pspec)
 288 {
 289   GtkThemingEnginePrivate *priv;
 290
 291   priv = GTK_THEMING_ENGINE (object)->priv;
 292
 293   switch (prop_id)
 294     {
 295     case PROP_NAME:
 296       if (priv->name)
 297         g_free (priv->name);
 298
 299       priv->name = g_value_dup_string (value);
 300       break;
 301     default:
 302       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 303       break;
 304     }
 305 }
 306
 307 static void
 308 gtk_theming_engine_impl_get_property (GObject    *object,
 309                                       guint       prop_id,
 310                                       GValue     *value,
 311                                       GParamSpec *pspec)
 312 {
 313   GtkThemingEnginePrivate *priv;
 314
 315   priv = GTK_THEMING_ENGINE (object)->priv;
 316
 317   switch (prop_id)
 318     {
 319     case PROP_NAME:
 320       g_value_set_string (value, priv->name);
 321       break;
 322     default:
 323       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 324       break;
 325     }
 326 }
 327
 328 void
 329 _gtk_theming_engine_set_context (GtkThemingEngine *engine,
 330                                  GtkStyleContext  *context)
 331 {
 332   GtkThemingEnginePrivate *priv;
 333
 334   g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
 335   g_return_if_fail (GTK_IS_STYLE_CONTEXT (context));
 336
 337   priv = engine->priv;
 338   priv->context = context;
 339 }
 340
 341 GtkStyleContext *
 342 _gtk_theming_engine_get_context (GtkThemingEngine *engine)
 343 {
 344   g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), NULL);
 345
 346   return engine->priv->context;
 347 }
 348
 349 GtkCssValue *
 350 _gtk_theming_engine_peek_property (GtkThemingEngine *engine,
 351                                    guint             property_id)
 352 {
 353   g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), NULL);
 354
 355   return _gtk_style_context_peek_property (engine->priv->context, property_id);
 356 }
 357
 358 double
 359 _gtk_theming_engine_get_number (GtkThemingEngine *engine,
 360                                 guint             property_id,
 361                                 double            one_hundred_percent)
 362 {
 363   g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), 0.0);
 364
 365   return _gtk_style_context_get_number (engine->priv->context, property_id, one_hundred_percent);
 366 }
 367
 368 /**
 369  * gtk_theming_engine_get_property:
 370  * @engine: a #GtkThemingEngine
 371  * @property: the property name
 372  * @state: state to retrieve the value for
 373  * @value: (out) (transfer full): return location for the property value,
 374  *         you must free this memory using g_value_unset() once you are
 375  *         done with it.
 376  *
 377  * Gets a property value as retrieved from the style settings that apply
 378  * to the currently rendered element.
 379  *
 380  * Since: 3.0
 381  **/
 382 void
 383 gtk_theming_engine_get_property (GtkThemingEngine *engine,
 384                                  const gchar      *property,
 385                                  GtkStateFlags     state,
 386                                  GValue           *value)
 387 {
 388   GtkThemingEnginePrivate *priv;
 389
 390   g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
 391   g_return_if_fail (property != NULL);
 392   g_return_if_fail (value != NULL);
 393
 394   priv = engine->priv;
 395   gtk_style_context_get_property (priv->context, property, state, value);
 396 }
 397
 398 /**
 399  * gtk_theming_engine_get_valist:
 400  * @engine: a #GtkThemingEngine
 401  * @state: state to retrieve values for
 402  * @args: va_list of property name/return location pairs, followed by %NULL
 403  *
 404  * Retrieves several style property values that apply to the currently
 405  * rendered element.
 406  *
 407  * Since: 3.0
 408  **/
 409 void
 410 gtk_theming_engine_get_valist (GtkThemingEngine *engine,
 411                                GtkStateFlags     state,
 412                                va_list           args)
 413 {
 414   GtkThemingEnginePrivate *priv;
 415
 416   g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
 417
 418   priv = engine->priv;
 419   gtk_style_context_get_valist (priv->context, state, args);
 420 }
 421
 422 /**
 423  * gtk_theming_engine_get:
 424  * @engine: a #GtkThemingEngine
 425  * @state: state to retrieve values for
 426  * @...: property name /return value pairs, followed by %NULL
 427  *
 428  * Retrieves several style property values that apply to the currently
 429  * rendered element.
 430  *
 431  * Since: 3.0
 432  **/
 433 void
 434 gtk_theming_engine_get (GtkThemingEngine *engine,
 435                         GtkStateFlags     state,
 436                         ...)
 437 {
 438   GtkThemingEnginePrivate *priv;
 439   va_list args;
 440
 441   g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
 442
 443   priv = engine->priv;
 444
 445   va_start (args, state);
 446   gtk_style_context_get_valist (priv->context, state, args);
 447   va_end (args);
 448 }
 449
 450 /**
 451  * gtk_theming_engine_get_style_property:
 452  * @engine: a #GtkThemingEngine
 453  * @property_name: the name of the widget style property
 454  * @value: Return location for the property value, free with
 455  *         g_value_unset() after use.
 456  *
 457  * Gets the value for a widget style property.
 458  *
 459  * Since: 3.0
 460  **/
 461 void
 462 gtk_theming_engine_get_style_property (GtkThemingEngine *engine,
 463                                        const gchar      *property_name,
 464                                        GValue           *value)
 465 {
 466   GtkThemingEnginePrivate *priv;
 467
 468   g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
 469   g_return_if_fail (property_name != NULL);
 470
 471   priv = engine->priv;
 472   gtk_style_context_get_style_property (priv->context, property_name, value);
 473 }
 474
 475 /**
 476  * gtk_theming_engine_get_style_valist:
 477  * @engine: a #GtkThemingEngine
 478  * @args: va_list of property name/return location pairs, followed by %NULL
 479  *
 480  * Retrieves several widget style properties from @engine according to the
 481  * currently rendered content's style.
 482  *
 483  * Since: 3.0
 484  **/
 485 void
 486 gtk_theming_engine_get_style_valist (GtkThemingEngine *engine,
 487                                      va_list           args)
 488 {
 489   GtkThemingEnginePrivate *priv;
 490
 491   g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
 492
 493   priv = engine->priv;
 494   gtk_style_context_get_style_valist (priv->context, args);
 495 }
 496
 497 /**
 498  * gtk_theming_engine_get_style:
 499  * @engine: a #GtkThemingEngine
 500  * @...: property name /return value pairs, followed by %NULL
 501  *
 502  * Retrieves several widget style properties from @engine according
 503  * to the currently rendered content's style.
 504  *
 505  * Since: 3.0
 506  **/
 507 void
 508 gtk_theming_engine_get_style (GtkThemingEngine *engine,
 509                               ...)
 510 {
 511   GtkThemingEnginePrivate *priv;
 512   va_list args;
 513
 514   g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
 515
 516   priv = engine->priv;
 517
 518   va_start (args, engine);
 519   gtk_style_context_get_style_valist (priv->context, args);
 520   va_end (args);
 521 }
 522
 523 /**
 524  * gtk_theming_engine_lookup_color:
 525  * @engine: a #GtkThemingEngine
 526  * @color_name: color name to lookup
 527  * @color: (out): Return location for the looked up color
 528  *
 529  * Looks up and resolves a color name in the current style's color map.
 530  *
 531  * Returns: %TRUE if @color_name was found and resolved, %FALSE otherwise
 532  **/
 533 gboolean
 534 gtk_theming_engine_lookup_color (GtkThemingEngine *engine,
 535                                  const gchar      *color_name,
 536                                  GdkRGBA          *color)
 537 {
 538   GtkThemingEnginePrivate *priv;
 539
 540   g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), FALSE);
 541   g_return_val_if_fail (color_name != NULL, FALSE);
 542
 543   priv = engine->priv;
 544   return gtk_style_context_lookup_color (priv->context, color_name, color);
 545 }
 546
 547 /**
 548  * gtk_theming_engine_get_state:
 549  * @engine: a #GtkThemingEngine
 550  *
 551  * returns the state used when rendering.
 552  *
 553  * Returns: the state flags
 554  *
 555  * Since: 3.0
 556  **/
 557 GtkStateFlags
 558 gtk_theming_engine_get_state (GtkThemingEngine *engine)
 559 {
 560   GtkThemingEnginePrivate *priv;
 561
 562   g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), 0);
 563
 564   priv = engine->priv;
 565   return gtk_style_context_get_state (priv->context);
 566 }
 567
 568 /**
 569  * gtk_theming_engine_state_is_running:
 570  * @engine: a #GtkThemingEngine
 571  * @state: a widget state
 572  * @progress: (out): return location for the transition progress
 573  *
 574  * Returns %TRUE if there is a transition animation running for the
 575  * current region (see gtk_style_context_push_animatable_region()).
 576  *
 577  * If @progress is not %NULL, the animation progress will be returned
 578  * there, 0.0 means the state is closest to being %FALSE, while 1.0 means
 579  * it's closest to being %TRUE. This means transition animations will
 580  * run from 0 to 1 when @state is being set to %TRUE and from 1 to 0 when
 581  * it's being set to %FALSE.
 582  *
 583  * Returns: %TRUE if there is a running transition animation for @state.
 584  *
 585  * Since: 3.0
 586  *
 587  * Deprecated: 3.6: Always returns %FALSE
 588  **/
 589 gboolean
 590 gtk_theming_engine_state_is_running (GtkThemingEngine *engine,
 591                                      GtkStateType      state,
 592                                      gdouble          *progress)
 593 {
 594   g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), FALSE);
 595
 596   return FALSE;
 597 }
 598
 599 /**
 600  * gtk_theming_engine_get_path:
 601  * @engine: a #GtkThemingEngine
 602  *
 603  * Returns the widget path used for style matching.
 604  *
 605  * Returns: (transfer none): A #GtkWidgetPath
 606  *
 607  * Since: 3.0
 608  **/
 609 const GtkWidgetPath *
 610 gtk_theming_engine_get_path (GtkThemingEngine *engine)
 611 {
 612   GtkThemingEnginePrivate *priv;
 613
 614   g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), NULL);
 615
 616   priv = engine->priv;
 617   return gtk_style_context_get_path (priv->context);
 618 }
 619
 620 /**
 621  * gtk_theming_engine_has_class:
 622  * @engine: a #GtkThemingEngine
 623  * @style_class: class name to look up
 624  *
 625  * Returns %TRUE if the currently rendered contents have
 626  * defined the given class name.
 627  *
 628  * Returns: %TRUE if @engine has @class_name defined
 629  *
 630  * Since: 3.0
 631  **/
 632 gboolean
 633 gtk_theming_engine_has_class (GtkThemingEngine *engine,
 634                               const gchar      *style_class)
 635 {
 636   GtkThemingEnginePrivate *priv;
 637
 638   g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), FALSE);
 639
 640   priv = engine->priv;
 641   return gtk_style_context_has_class (priv->context, style_class);
 642 }
 643
 644 /**
 645  * gtk_theming_engine_has_region:
 646  * @engine: a #GtkThemingEngine
 647  * @style_region: a region name
 648  * @flags: (out) (allow-none): return location for region flags
 649  *
 650  * Returns %TRUE if the currently rendered contents have the
 651  * region defined. If @flags_return is not %NULL, it is set
 652  * to the flags affecting the region.
 653  *
 654  * Returns: %TRUE if region is defined
 655  *
 656  * Since: 3.0
 657  **/
 658 gboolean
 659 gtk_theming_engine_has_region (GtkThemingEngine *engine,
 660                                const gchar      *style_region,
 661                                GtkRegionFlags   *flags)
 662 {
 663   GtkThemingEnginePrivate *priv;
 664
 665   if (flags)
 666     *flags = 0;
 667
 668   g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), FALSE);
 669
 670   priv = engine->priv;
 671   return gtk_style_context_has_region (priv->context, style_region, flags);
 672 }
 673
 674 /**
 675  * gtk_theming_engine_get_direction:
 676  * @engine: a #GtkThemingEngine
 677  *
 678  * Returns the widget direction used for rendering.
 679  *
 680  * Returns: the widget direction
 681  *
 682  * Since: 3.0
 683  **/
 684 GtkTextDirection
 685 gtk_theming_engine_get_direction (GtkThemingEngine *engine)
 686 {
 687   GtkThemingEnginePrivate *priv;
 688
 689   g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), GTK_TEXT_DIR_LTR);
 690
 691   priv = engine->priv;
 692   return gtk_style_context_get_direction (priv->context);
 693 }
 694
 695 /**
 696  * gtk_theming_engine_get_junction_sides:
 697  * @engine: a #GtkThemingEngine
 698  *
 699  * Returns the widget direction used for rendering.
 700  *
 701  * Returns: the widget direction
 702  *
 703  * Since: 3.0
 704  **/
 705 GtkJunctionSides
 706 gtk_theming_engine_get_junction_sides (GtkThemingEngine *engine)
 707 {
 708   GtkThemingEnginePrivate *priv;
 709
 710   g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), 0);
 711
 712   priv = engine->priv;
 713   return gtk_style_context_get_junction_sides (priv->context);
 714 }
 715
 716 /**
 717  * gtk_theming_engine_get_color:
 718  * @engine: a #GtkThemingEngine
 719  * @state: state to retrieve the color for
 720  * @color: (out): return value for the foreground color
 721  *
 722  * Gets the foreground color for a given state.
 723  *
 724  * Since: 3.0
 725  **/
 726 void
 727 gtk_theming_engine_get_color (GtkThemingEngine *engine,
 728                               GtkStateFlags     state,
 729                               GdkRGBA          *color)
 730 {
 731   GtkThemingEnginePrivate *priv;
 732
 733   g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
 734
 735   priv = engine->priv;
 736   gtk_style_context_get_color (priv->context, state, color);
 737 }
 738
 739 /**
 740  * gtk_theming_engine_get_background_color:
 741  * @engine: a #GtkThemingEngine
 742  * @state: state to retrieve the color for
 743  * @color: (out): return value for the background color
 744  *
 745  * Gets the background color for a given state.
 746  *
 747  * Since: 3.0
 748  **/
 749 void
 750 gtk_theming_engine_get_background_color (GtkThemingEngine *engine,
 751                                          GtkStateFlags     state,
 752                                          GdkRGBA          *color)
 753 {
 754   GtkThemingEnginePrivate *priv;
 755
 756   g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
 757
 758   priv = engine->priv;
 759   gtk_style_context_get_background_color (priv->context, state, color);
 760 }
 761
 762 /**
 763  * gtk_theming_engine_get_border_color:
 764  * @engine: a #GtkThemingEngine
 765  * @state: state to retrieve the color for
 766  * @color: (out): return value for the border color
 767  *
 768  * Gets the border color for a given state.
 769  *
 770  * Since: 3.0
 771  **/
 772 void
 773 gtk_theming_engine_get_border_color (GtkThemingEngine *engine,
 774                                      GtkStateFlags     state,
 775                                      GdkRGBA          *color)
 776 {
 777   GtkThemingEnginePrivate *priv;
 778
 779   g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
 780
 781   priv = engine->priv;
 782   gtk_style_context_get_border_color (priv->context, state, color);
 783 }
 784
 785 /**
 786  * gtk_theming_engine_get_border:
 787  * @engine: a #GtkThemingEngine
 788  * @state: state to retrieve the border for
 789  * @border: (out): return value for the border settings
 790  *
 791  * Gets the border for a given state as a #GtkBorder.
 792  *
 793  * Since: 3.0
 794  **/
 795 void
 796 gtk_theming_engine_get_border (GtkThemingEngine *engine,
 797                                GtkStateFlags     state,
 798                                GtkBorder        *border)
 799 {
 800   GtkThemingEnginePrivate *priv;
 801
 802   g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
 803
 804   priv = engine->priv;
 805   gtk_style_context_get_border (priv->context, state, border);
 806 }
 807
 808 /**
 809  * gtk_theming_engine_get_padding:
 810  * @engine: a #GtkThemingEngine
 811  * @state: state to retrieve the padding for
 812  * @padding: (out): return value for the padding settings
 813  *
 814  * Gets the padding for a given state as a #GtkBorder.
 815  *
 816  * Since: 3.0
 817  **/
 818 void
 819 gtk_theming_engine_get_padding (GtkThemingEngine *engine,
 820                                 GtkStateFlags     state,
 821                                 GtkBorder        *padding)
 822 {
 823   GtkThemingEnginePrivate *priv;
 824
 825   g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
 826
 827   priv = engine->priv;
 828   gtk_style_context_get_padding (priv->context, state, padding);
 829 }
 830
 831 /**
 832  * gtk_theming_engine_get_margin:
 833  * @engine: a #GtkThemingEngine
 834  * @state: state to retrieve the border for
 835  * @margin: (out): return value for the margin settings
 836  *
 837  * Gets the margin for a given state as a #GtkBorder.
 838  *
 839  * Since: 3.0
 840  **/
 841 void
 842 gtk_theming_engine_get_margin (GtkThemingEngine *engine,
 843                                GtkStateFlags     state,
 844                                GtkBorder        *margin)
 845 {
 846   GtkThemingEnginePrivate *priv;
 847
 848   g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
 849
 850   priv = engine->priv;
 851   gtk_style_context_get_margin (priv->context, state, margin);
 852 }
 853
 854 /**
 855  * gtk_theming_engine_get_font:
 856  * @engine: a #GtkThemingEngine
 857  * @state: state to retrieve the font for
 858  *
 859  * Returns the font description for a given state.
 860  *
 861  * Returns: (transfer none): the #PangoFontDescription for the given
 862  *          state. This object is owned by GTK+ and should not be
 863  *          freed.
 864  *
 865  * Since: 3.0
 866  **/
 867 const PangoFontDescription *
 868 gtk_theming_engine_get_font (GtkThemingEngine *engine,
 869                              GtkStateFlags     state)
 870 {
 871   GtkThemingEnginePrivate *priv;
 872
 873   g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), NULL);
 874
 875   priv = engine->priv;
 876   return gtk_style_context_get_font (priv->context, state);
 877 }
 878
 879 /* GtkThemingModule */
 880
 881 static gboolean
 882 gtk_theming_module_load (GTypeModule *type_module)
 883 {
 884   GtkThemingModule *theming_module;
 885   GModule *module;
 886   gchar *name, *module_path;
 887
 888   theming_module = GTK_THEMING_MODULE (type_module);
 889   name = theming_module->name;
 890   module_path = _gtk_find_module (name, "theming-engines");
 891
 892   if (!module_path)
 893     return FALSE;
 894
 895   module = g_module_open (module_path, G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL);
 896   g_free (module_path);
 897
 898   if (!module)
 899     return FALSE;
 900
 901   if (!g_module_symbol (module, "theme_init",
 902                         (gpointer *) &theming_module->init) ||
 903       !g_module_symbol (module, "theme_exit",
 904                         (gpointer *) &theming_module->exit) ||
 905       !g_module_symbol (module, "create_engine",
 906                         (gpointer *) &theming_module->create_engine))
 907     {
 908       g_module_close (module);
 909
 910       return FALSE;
 911     }
 912
 913   theming_module->module = module;
 914
 915   theming_module->init (G_TYPE_MODULE (theming_module));
 916
 917   return TRUE;
 918 }
 919
 920 static void
 921 gtk_theming_module_unload (GTypeModule *type_module)
 922 {
 923   GtkThemingModule *theming_module;
 924
 925   theming_module = GTK_THEMING_MODULE (type_module);
 926
 927   theming_module->exit ();
 928
 929   g_module_close (theming_module->module);
 930
 931   theming_module->module = NULL;
 932   theming_module->init = NULL;
 933   theming_module->exit = NULL;
 934   theming_module->create_engine = NULL;
 935 }
 936
 937 static void
 938 gtk_theming_module_class_init (GtkThemingModuleClass *klass)
 939 {
 940   GTypeModuleClass *module_class = G_TYPE_MODULE_CLASS (klass);
 941
 942   module_class->load = gtk_theming_module_load;
 943   module_class->unload = gtk_theming_module_unload;
 944 }
 945
 946 static void
 947 gtk_theming_module_init (GtkThemingModule *module)
 948 {
 949 }
 950
 951 /**
 952  * gtk_theming_engine_load:
 953  * @name: Theme engine name to load
 954  *
 955  * Loads and initializes a theming engine module from the
 956  * standard directories.
 957  *
 958  * Returns: (transfer none): A theming engine, or %NULL if
 959  * the engine @name doesn't exist.
 960  **/
 961 GtkThemingEngine *
 962 gtk_theming_engine_load (const gchar *name)
 963 {
 964   static GHashTable *engines = NULL;
 965   static GtkThemingEngine *default_engine;
 966   GtkThemingEngine *engine = NULL;
 967
 968   if (name)
 969     {
 970       if (!engines)
 971         engines = g_hash_table_new (g_str_hash, g_str_equal);
 972
 973       engine = g_hash_table_lookup (engines, name);
 974
 975       if (!engine)
 976         {
 977           GtkThemingModule *module;
 978
 979           module = g_object_new (GTK_TYPE_THEMING_MODULE, NULL);
 980           g_type_module_set_name (G_TYPE_MODULE (module), name);
 981           module->name = g_strdup (name);
 982
 983           if (module && g_type_module_use (G_TYPE_MODULE (module)))
 984             {
 985               engine = (module->create_engine) ();
 986
 987               if (engine)
 988                 g_hash_table_insert (engines, module->name, engine);
 989             }
 990         }
 991     }
 992   else
 993     {
 994       if (G_UNLIKELY (!default_engine))
 995         default_engine = g_object_new (GTK_TYPE_THEMING_ENGINE, NULL);
 996
 997       engine = default_engine;
 998     }
 999
1000   return engine;
1001 }
1002
1003 /**
1004  * gtk_theming_engine_get_screen:
1005  * @engine: a #GtkThemingEngine
1006  *
1007  * Returns the #GdkScreen to which @engine currently rendering to.
1008  *
1009  * Returns: (transfer none): a #GdkScreen, or %NULL.
1010  **/
1011 GdkScreen *
1012 gtk_theming_engine_get_screen (GtkThemingEngine *engine)
1013 {
1014   GtkThemingEnginePrivate *priv;
1015
1016   g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), NULL);
1017
1018   priv = engine->priv;
1019   return gtk_style_context_get_screen (priv->context);
1020 }
1021
1022 /* Paint method implementations */
1023 static void
1024 gtk_theming_engine_render_check (GtkThemingEngine *engine,
1025                                  cairo_t          *cr,
1026                                  gdouble           x,
1027                                  gdouble           y,
1028                                  gdouble           width,
1029                                  gdouble           height)
1030 {
1031   GdkRGBA fg_color, bg_color;
1032   GtkStateFlags flags;
1033   gint exterior_size, interior_size, thickness, pad;
1034   GtkBorderStyle border_style;
1035   GtkBorder border;
1036   gint border_width;
1037   GtkThemingBackground bg;
1038
1039   _gtk_theming_background_init (&bg, engine,
1040                                 x, y,
1041                                 width, height,
1042                                 gtk_theming_engine_get_junction_sides (engine));
1043
1044   if (_gtk_theming_background_has_background_image (&bg))
1045     {
1046       _gtk_theming_background_render (&bg, cr);
1047       return;
1048     }
1049
1050   flags = gtk_theming_engine_get_state (engine);
1051   cairo_save (cr);
1052
1053   gtk_theming_engine_get_color (engine, flags, &fg_color);
1054   gtk_theming_engine_get_background_color (engine, flags, &bg_color);
1055   gtk_theming_engine_get_border (engine, flags, &border);
1056   border_style = _gtk_css_border_style_value_get
1057     (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_TOP_STYLE));
1058
1059   border_width = MIN (MIN (border.top, border.bottom),
1060                       MIN (border.left, border.right));
1061   exterior_size = MIN (width, height);
1062
1063   if (exterior_size % 2 == 0) /* Ensure odd */
1064     exterior_size -= 1;
1065
1066   /* FIXME: thickness */
1067   thickness = 1;
1068   pad = thickness + MAX (1, (exterior_size - 2 * thickness) / 9);
1069   interior_size = MAX (1, exterior_size - 2 * pad);
1070
1071   if (interior_size < 7)
1072     {
1073       interior_size = 7;
1074       pad = MAX (0, (exterior_size - interior_size) / 2);
1075     }
1076
1077   x -= (1 + exterior_size - (gint) width) / 2;
1078   y -= (1 + exterior_size - (gint) height) / 2;
1079
1080   if (border_style == GTK_BORDER_STYLE_SOLID)
1081     {
1082       GdkRGBA border_color;
1083
1084       cairo_set_line_width (cr, border_width);
1085       gtk_theming_engine_get_border_color (engine, flags, &border_color);
1086
1087       cairo_rectangle (cr, x + 0.5, y + 0.5, exterior_size - 1, exterior_size - 1);
1088       gdk_cairo_set_source_rgba (cr, &bg_color);
1089       cairo_fill_preserve (cr);
1090
1091       gdk_cairo_set_source_rgba (cr, &border_color);
1092       cairo_stroke (cr);
1093     }
1094
1095   gdk_cairo_set_source_rgba (cr, &fg_color);
1096
1097   if (flags & GTK_STATE_FLAG_INCONSISTENT)
1098     {
1099       int line_thickness = MAX (1, (3 + interior_size * 2) / 7);
1100
1101       cairo_rectangle (cr,
1102                        x + pad,
1103                        y + pad + (1 + interior_size - line_thickness) / 2,
1104                        interior_size,
1105                        line_thickness);
1106       cairo_fill (cr);
1107     }
1108   else
1109     {
1110       if (flags & GTK_STATE_FLAG_ACTIVE)
1111         {
1112           cairo_translate (cr,
1113                            x + pad, y + pad);
1114
1115           cairo_scale (cr, interior_size / 7., interior_size / 7.);
1116
1117           cairo_rectangle (cr, 0, 0, 7, 7);
1118           cairo_clip (cr);
1119
1120           cairo_move_to  (cr, 7.0, 0.0);
1121           cairo_line_to  (cr, 7.5, 1.0);
1122           cairo_curve_to (cr, 5.3, 2.0,
1123                           4.3, 4.0,
1124                           3.5, 7.0);
1125           cairo_curve_to (cr, 3.0, 5.7,
1126                           1.3, 4.7,
1127                           0.0, 4.7);
1128           cairo_line_to  (cr, 0.2, 3.5);
1129           cairo_curve_to (cr, 1.1, 3.5,
1130                           2.3, 4.3,
1131                           3.0, 5.0);
1132           cairo_curve_to (cr, 1.0, 3.9,
1133                           2.4, 4.1,
1134                           3.2, 4.9);
1135           cairo_curve_to (cr, 3.5, 3.1,
1136                           5.2, 2.0,
1137                           7.0, 0.0);
1138
1139           cairo_fill (cr);
1140         }
1141     }
1142
1143   cairo_restore (cr);
1144 }
1145
1146 static void
1147 gtk_theming_engine_render_option (GtkThemingEngine *engine,
1148                                   cairo_t          *cr,
1149                                   gdouble           x,
1150                                   gdouble           y,
1151                                   gdouble           width,
1152                                   gdouble           height)
1153 {
1154   GtkStateFlags flags;
1155   GdkRGBA fg_color, bg_color;
1156   gint exterior_size, interior_size, pad, thickness, border_width;
1157   GtkBorderStyle border_style;
1158   GtkBorder border;
1159   GtkThemingBackground bg;
1160
1161   _gtk_theming_background_init (&bg, engine,
1162                                 x, y,
1163                                 width, height,
1164                                 gtk_theming_engine_get_junction_sides (engine));
1165
1166   if (_gtk_theming_background_has_background_image (&bg))
1167     {
1168       _gtk_theming_background_render (&bg, cr);
1169       return;
1170     }
1171
1172   flags = gtk_theming_engine_get_state (engine);
1173
1174   cairo_save (cr);
1175
1176   gtk_theming_engine_get_color (engine, flags, &fg_color);
1177   gtk_theming_engine_get_background_color (engine, flags, &bg_color);
1178   gtk_theming_engine_get_border (engine, flags, &border);
1179   border_style = _gtk_css_border_style_value_get
1180     (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_TOP_STYLE));
1181
1182   exterior_size = MIN (width, height);
1183   border_width = MIN (MIN (border.top, border.bottom),
1184                       MIN (border.left, border.right));
1185
1186   if (exterior_size % 2 == 0) /* Ensure odd */
1187     exterior_size -= 1;
1188
1189   x -= (1 + exterior_size - width) / 2;
1190   y -= (1 + exterior_size - height) / 2;
1191
1192   if (border_style == GTK_BORDER_STYLE_SOLID)
1193     {
1194       GdkRGBA border_color;
1195
1196       cairo_set_line_width (cr, border_width);
1197       gtk_theming_engine_get_border_color (engine, flags, &border_color);
1198
1199       cairo_new_sub_path (cr);
1200       cairo_arc (cr,
1201                  x + exterior_size / 2.,
1202                  y + exterior_size / 2.,
1203                  (exterior_size - 1) / 2.,
1204                  0, 2 * G_PI);
1205
1206       gdk_cairo_set_source_rgba (cr, &bg_color);
1207       cairo_fill_preserve (cr);
1208
1209       gdk_cairo_set_source_rgba (cr, &border_color);
1210       cairo_stroke (cr);
1211     }
1212
1213   gdk_cairo_set_source_rgba (cr, &fg_color);
1214
1215   /* FIXME: thickness */
1216   thickness = 1;
1217
1218   if (flags & GTK_STATE_FLAG_INCONSISTENT)
1219     {
1220       gint line_thickness;
1221
1222       pad = thickness + MAX (1, (exterior_size - 2 * thickness) / 9);
1223       interior_size = MAX (1, exterior_size - 2 * pad);
1224
1225       if (interior_size < 7)
1226         {
1227           interior_size = 7;
1228           pad = MAX (0, (exterior_size - interior_size) / 2);
1229         }
1230
1231       line_thickness = MAX (1, (3 + interior_size * 2) / 7);
1232
1233       cairo_rectangle (cr,
1234                        x + pad,
1235                        y + pad + (interior_size - line_thickness) / 2.,
1236                        interior_size,
1237                        line_thickness);
1238       cairo_fill (cr);
1239     }
1240   if (flags & GTK_STATE_FLAG_ACTIVE)
1241     {
1242       pad = thickness + MAX (1, 2 * (exterior_size - 2 * thickness) / 9);
1243       interior_size = MAX (1, exterior_size - 2 * pad);
1244
1245       if (interior_size < 5)
1246         {
1247           interior_size = 7;
1248           pad = MAX (0, (exterior_size - interior_size) / 2);
1249         }
1250
1251       cairo_new_sub_path (cr);
1252       cairo_arc (cr,
1253                  x + pad + interior_size / 2.,
1254                  y + pad + interior_size / 2.,
1255                  interior_size / 2.,
1256                  0, 2 * G_PI);
1257       cairo_fill (cr);
1258     }
1259
1260   cairo_restore (cr);
1261 }
1262
1263 static void
1264 add_path_arrow (cairo_t *cr,
1265                 gdouble  angle,
1266                 gdouble  x,
1267                 gdouble  y,
1268                 gdouble  size)
1269 {
1270   cairo_save (cr);
1271
1272   cairo_translate (cr, x + (size / 2), y + (size / 2));
1273   cairo_rotate (cr, angle);
1274
1275   cairo_move_to (cr, 0, - (size / 4));
1276   cairo_line_to (cr, - (size / 2), (size / 4));
1277   cairo_line_to (cr, (size / 2), (size / 4));
1278   cairo_close_path (cr);
1279
1280   cairo_restore (cr);
1281 }
1282
1283 static void
1284 gtk_theming_engine_render_arrow (GtkThemingEngine *engine,
1285                                  cairo_t          *cr,
1286                                  gdouble           angle,
1287                                  gdouble           x,
1288                                  gdouble           y,
1289                                  gdouble           size)
1290 {
1291   GtkStateFlags flags;
1292   GdkRGBA fg_color;
1293
1294   cairo_save (cr);
1295
1296   flags = gtk_theming_engine_get_state (engine);
1297   gtk_theming_engine_get_color (engine, flags, &fg_color);
1298
1299   if (flags & GTK_STATE_FLAG_INSENSITIVE)
1300     {
1301       add_path_arrow (cr, angle, x + 1, y + 1, size);
1302       cairo_set_source_rgb (cr, 1, 1, 1);
1303       cairo_fill (cr);
1304     }
1305
1306   add_path_arrow (cr, angle, x, y, size);
1307   gdk_cairo_set_source_rgba (cr, &fg_color);
1308   cairo_fill (cr);
1309
1310   cairo_restore (cr);
1311 }
1312
1313 static void
1314 add_path_line (cairo_t        *cr,
1315                gdouble         x1,
1316                gdouble         y1,
1317                gdouble         x2,
1318                gdouble         y2)
1319 {
1320   /* Adjust endpoints */
1321   if (y1 == y2)
1322     {
1323       y1 += 0.5;
1324       y2 += 0.5;
1325       x2 += 1;
1326     }
1327   else if (x1 == x2)
1328     {
1329       x1 += 0.5;
1330       x2 += 0.5;
1331       y2 += 1;
1332     }
1333
1334   cairo_move_to (cr, x1, y1);
1335   cairo_line_to (cr, x2, y2);
1336 }
1337
1338 static void
1339 color_shade (const GdkRGBA *color,
1340              gdouble        factor,
1341              GdkRGBA       *color_return)
1342 {
1343   GtkHSLA hsla;
1344
1345   _gtk_hsla_init_from_rgba (&hsla, color);
1346   _gtk_hsla_shade (&hsla, &hsla, factor);
1347   _gdk_rgba_init_from_hsla (color_return, &hsla);
1348 }
1349
1350 static void
1351 gtk_theming_engine_render_background (GtkThemingEngine *engine,
1352                                       cairo_t          *cr,
1353                                       gdouble           x,
1354                                       gdouble           y,
1355                                       gdouble           width,
1356                                       gdouble           height)
1357 {
1358   GtkThemingBackground bg;
1359
1360   _gtk_theming_background_init (&bg, engine,
1361                                 x, y,
1362                                 width, height,
1363                                 gtk_theming_engine_get_junction_sides (engine));
1364
1365   _gtk_theming_background_render (&bg, cr);
1366 }
1367
1368 static void
1369 gtk_theming_engine_hide_border_sides (double         border[4],
1370                                       GtkBorderStyle border_style[4],
1371                                       guint          hidden_side)
1372 {
1373   guint i;
1374
1375   for (i = 0; i < 4; i++)
1376     {
1377       if (hidden_side & (1 << i) ||
1378           border_style[i] == GTK_BORDER_STYLE_NONE ||
1379           border_style[i] == GTK_BORDER_STYLE_HIDDEN)
1380         border[i] = 0;
1381     }
1382 }
1383
1384 static void
1385 render_frame_fill (cairo_t       *cr,
1386                    GtkRoundedBox *border_box,
1387                    const double   border_width[4],
1388                    GdkRGBA        colors[4],
1389                    guint          hidden_side)
1390 {
1391   GtkRoundedBox padding_box;
1392   guint i, j;
1393
1394   padding_box = *border_box;
1395   _gtk_rounded_box_shrink (&padding_box,
1396                            border_width[GTK_CSS_TOP],
1397                            border_width[GTK_CSS_RIGHT],
1398                            border_width[GTK_CSS_BOTTOM],
1399                            border_width[GTK_CSS_LEFT]);
1400
1401   if (hidden_side == 0 &&
1402       gdk_rgba_equal (&colors[0], &colors[1]) &&
1403       gdk_rgba_equal (&colors[0], &colors[2]) &&
1404       gdk_rgba_equal (&colors[0], &colors[3]))
1405     {
1406       gdk_cairo_set_source_rgba (cr, &colors[0]);
1407
1408       _gtk_rounded_box_path (border_box, cr);
1409       _gtk_rounded_box_path (&padding_box, cr);
1410       cairo_fill (cr);
1411     }
1412   else
1413     {
1414       for (i = 0; i < 4; i++)
1415         {
1416           if (hidden_side & (1 << i))
1417             continue;
1418
1419           for (j = 0; j < 4; j++)
1420             {
1421               if (hidden_side & (1 << j))
1422                 continue;
1423
1424               if (i == j ||
1425                   (gdk_rgba_equal (&colors[i], &colors[j])))
1426                 {
1427                   /* We were already painted when i == j */
1428                   if (i > j)
1429                     break;
1430
1431                   if (j == 0)
1432                     _gtk_rounded_box_path_top (border_box, &padding_box, cr);
1433                   else if (j == 1)
1434                     _gtk_rounded_box_path_right (border_box, &padding_box, cr);
1435                   else if (j == 2)
1436                     _gtk_rounded_box_path_bottom (border_box, &padding_box, cr);
1437                   else if (j == 3)
1438                     _gtk_rounded_box_path_left (border_box, &padding_box, cr);
1439                 }
1440             }
1441           /* We were already painted when i == j */
1442           if (i > j)
1443             continue;
1444
1445           gdk_cairo_set_source_rgba (cr, &colors[i]);
1446
1447           cairo_fill (cr);
1448         }
1449     }
1450 }
1451
1452 static void
1453 set_stroke_style (cairo_t        *cr,
1454                   double          line_width,
1455                   GtkBorderStyle  style,
1456                   double          length)
1457 {
1458   double segments[2];
1459   double n;
1460
1461   cairo_set_line_width (cr, line_width);
1462
1463   if (style == GTK_BORDER_STYLE_DOTTED)
1464     {
1465       n = round (0.5 * length / line_width);
1466
1467       segments[0] = 0;
1468       segments[1] = n ? length / n : 2;
1469       cairo_set_dash (cr, segments, G_N_ELEMENTS (segments), 0);
1470
1471       cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
1472       cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);
1473     }
1474   else
1475     {
1476       n = length / line_width;
1477       /* Optimize the common case of an integer-sized rectangle
1478        * Again, we care about focus rectangles.
1479        */
1480       if (n == nearbyint (n))
1481         {
1482           segments[0] = 1;
1483           segments[1] = 2;
1484         }
1485       else
1486         {
1487           n = round ((1. / 3) * n);
1488
1489           segments[0] = n ? (1. / 3) * length / n : 1;
1490           segments[1] = 2 * segments[1];
1491         }
1492       cairo_set_dash (cr, segments, G_N_ELEMENTS (segments), 0);
1493
1494       cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
1495       cairo_set_line_join (cr, CAIRO_LINE_JOIN_MITER);
1496     }
1497 }
1498
1499 static void
1500 render_frame_stroke (cairo_t       *cr,
1501                      GtkRoundedBox *border_box,
1502                      const double   border_width[4],
1503                      GdkRGBA        colors[4],
1504                      guint          hidden_side,
1505                      GtkBorderStyle stroke_style)
1506 {
1507   gboolean different_colors, different_borders;
1508   GtkRoundedBox stroke_box;
1509   guint i;
1510
1511   different_colors = !gdk_rgba_equal (&colors[0], &colors[1]) ||
1512                      !gdk_rgba_equal (&colors[0], &colors[2]) ||
1513                      !gdk_rgba_equal (&colors[0], &colors[3]);
1514   different_borders = border_width[0] != border_width[1] ||
1515                       border_width[0] != border_width[2] ||
1516                       border_width[0] != border_width[3] ;
1517
1518   stroke_box = *border_box;
1519   _gtk_rounded_box_shrink (&stroke_box,
1520                            border_width[GTK_CSS_TOP] / 2.0,
1521                            border_width[GTK_CSS_RIGHT] / 2.0,
1522                            border_width[GTK_CSS_BOTTOM] / 2.0,
1523                            border_width[GTK_CSS_LEFT] / 2.0);
1524
1525   if (!different_colors && !different_borders && hidden_side == 0)
1526     {
1527       double length = 0;
1528
1529       /* FAST PATH:
1530        * Mostly expected to trigger for focus rectangles */
1531       for (i = 0; i < 4; i++)
1532         {
1533           length += _gtk_rounded_box_guess_length (&stroke_box, i);
1534           _gtk_rounded_box_path_side (&stroke_box, cr, i);
1535         }
1536
1537       gdk_cairo_set_source_rgba (cr, &colors[0]);
1538       set_stroke_style (cr, border_width[0], stroke_style, length);
1539       cairo_stroke (cr);
1540     }
1541   else
1542     {
1543       GtkRoundedBox padding_box;
1544
1545       padding_box = *border_box;
1546       _gtk_rounded_box_path (&padding_box, cr);
1547       _gtk_rounded_box_shrink (&padding_box,
1548                                border_width[GTK_CSS_TOP],
1549                                border_width[GTK_CSS_RIGHT],
1550                                border_width[GTK_CSS_BOTTOM],
1551                                border_width[GTK_CSS_LEFT]);
1552
1553       for (i = 0; i < 4; i++)
1554         {
1555           if (hidden_side & (1 << i))
1556             continue;
1557
1558           cairo_save (cr);
1559
1560           if (i == 0)
1561             _gtk_rounded_box_path_top (border_box, &padding_box, cr);
1562           else if (i == 1)
1563             _gtk_rounded_box_path_right (border_box, &padding_box, cr);
1564           else if (i == 2)
1565             _gtk_rounded_box_path_bottom (border_box, &padding_box, cr);
1566           else if (i == 3)
1567             _gtk_rounded_box_path_left (border_box, &padding_box, cr);
1568           cairo_clip (cr);
1569
1570           _gtk_rounded_box_path_side (&stroke_box, cr, i);
1571
1572           gdk_cairo_set_source_rgba (cr, &colors[i]);
1573           set_stroke_style (cr,
1574                             border_width[i],
1575                             stroke_style,
1576                             _gtk_rounded_box_guess_length (&stroke_box, i));
1577           cairo_stroke (cr);
1578
1579           cairo_restore (cr);
1580         }
1581     }
1582 }
1583
1584 static void
1585 render_border (cairo_t       *cr,
1586                GtkRoundedBox *border_box,
1587                const double   border_width[4],
1588                guint          hidden_side,
1589                GdkRGBA        colors[4],
1590                GtkBorderStyle border_style[4])
1591 {
1592   guint i, j;
1593
1594   cairo_save (cr);
1595
1596   cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
1597
1598   for (i = 0; i < 4; i++)
1599     {
1600       if (hidden_side & (1 << i))
1601         continue;
1602
1603       switch (border_style[i])
1604         {
1605         case GTK_BORDER_STYLE_NONE:
1606         case GTK_BORDER_STYLE_HIDDEN:
1607         case GTK_BORDER_STYLE_SOLID:
1608           break;
1609         case GTK_BORDER_STYLE_INSET:
1610           if (i == 1 || i == 2)
1611             color_shade (&colors[i], 1.8, &colors[i]);
1612           break;
1613         case GTK_BORDER_STYLE_OUTSET:
1614           if (i == 0 || i == 3)
1615             color_shade (&colors[i], 1.8, &colors[i]);
1616           break;
1617         case GTK_BORDER_STYLE_DOTTED:
1618         case GTK_BORDER_STYLE_DASHED:
1619           {
1620             guint dont_draw = hidden_side;
1621
1622             for (j = 0; j < 4; j++)
1623               {
1624                 if (border_style[j] == border_style[i])
1625                   hidden_side |= (1 << j);
1626                 else
1627                   dont_draw |= (1 << j);
1628               }
1629
1630             render_frame_stroke (cr, border_box, border_width, colors, dont_draw, border_style[i]);
1631           }
1632           break;
1633         case GTK_BORDER_STYLE_DOUBLE:
1634           {
1635             GtkRoundedBox other_box;
1636             double other_border[4];
1637             guint dont_draw = hidden_side;
1638
1639             for (j = 0; j < 4; j++)
1640               {
1641                 if (border_style[j] == GTK_BORDER_STYLE_DOUBLE)
1642                   hidden_side |= (1 << j);
1643                 else
1644                   dont_draw |= (1 << j);
1645
1646                 other_border[i] = border_width[i] / 3;
1647               }
1648
1649             render_frame_fill (cr, border_box, other_border, colors, dont_draw);
1650
1651             other_box = *border_box;
1652             _gtk_rounded_box_shrink (&other_box,
1653                                      2 * other_border[GTK_CSS_TOP],
1654                                      2 * other_border[GTK_CSS_RIGHT],
1655                                      2 * other_border[GTK_CSS_BOTTOM],
1656                                      2 * other_border[GTK_CSS_LEFT]);
1657             render_frame_fill (cr, &other_box, other_border, colors, dont_draw);
1658           }
1659         case GTK_BORDER_STYLE_GROOVE:
1660         case GTK_BORDER_STYLE_RIDGE:
1661           {
1662             GtkRoundedBox other_box;
1663             GdkRGBA other_colors[4];
1664             guint dont_draw = hidden_side;
1665             double other_border[4];
1666
1667             for (j = 0; j < 4; j++)
1668               {
1669                 other_colors[j] = colors[j];
1670                 if ((j == 0 || j == 3) ^ (border_style[j] == GTK_BORDER_STYLE_RIDGE))
1671                   color_shade (&other_colors[j], 1.8, &other_colors[j]);
1672                 else
1673                   color_shade (&colors[j], 1.8, &colors[j]);
1674                 if (border_style[j] == GTK_BORDER_STYLE_GROOVE ||
1675                     border_style[j] == GTK_BORDER_STYLE_RIDGE)
1676                   hidden_side |= (1 << j);
1677                 else
1678                   dont_draw |= (1 << j);
1679                 other_border[i] = border_width[i] / 2;
1680               }
1681
1682             render_frame_fill (cr, border_box, other_border, colors, dont_draw);
1683
1684             other_box = *border_box;
1685             _gtk_rounded_box_shrink (&other_box,
1686                                      other_border[GTK_CSS_TOP],
1687                                      other_border[GTK_CSS_RIGHT],
1688                                      other_border[GTK_CSS_BOTTOM],
1689                                      other_border[GTK_CSS_LEFT]);
1690             render_frame_fill (cr, &other_box, other_border, other_colors, dont_draw);
1691           }
1692           break;
1693         default:
1694           g_assert_not_reached ();
1695           break;
1696         }
1697     }
1698
1699   render_frame_fill (cr, border_box, border_width, colors, hidden_side);
1700
1701   cairo_restore (cr);
1702 }
1703
1704 static void
1705 render_frame_internal (GtkThemingEngine *engine,
1706                        cairo_t          *cr,
1707                        gdouble           x,
1708                        gdouble           y,
1709                        gdouble           width,
1710                        gdouble           height,
1711                        guint             hidden_side,
1712                        GtkJunctionSides  junction)
1713 {
1714   GtkBorderImage border_image;
1715   GtkBorderStyle border_style[4];
1716   GtkRoundedBox border_box;
1717   double border_width[4];
1718   GdkRGBA colors[4];
1719
1720   border_width[0] = _gtk_css_number_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_TOP_WIDTH), 100);
1721   border_width[1] = _gtk_css_number_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_RIGHT_WIDTH), 100);
1722   border_width[2] = _gtk_css_number_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_BOTTOM_WIDTH), 100);
1723   border_width[3] = _gtk_css_number_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_LEFT_WIDTH), 100);
1724
1725   border_style[0] = _gtk_css_border_style_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_TOP_STYLE));
1726   border_style[1] = _gtk_css_border_style_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_RIGHT_STYLE));
1727   border_style[2] = _gtk_css_border_style_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_BOTTOM_STYLE));
1728   border_style[3] = _gtk_css_border_style_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_LEFT_STYLE));
1729
1730   gtk_theming_engine_hide_border_sides (border_width, border_style, hidden_side);
1731
1732   if (_gtk_border_image_init (&border_image, engine))
1733     _gtk_border_image_render (&border_image, border_width, cr, x, y, width, height);
1734   else
1735     {
1736       colors[0] = *_gtk_css_rgba_value_get_rgba (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_TOP_COLOR));
1737       colors[1] = *_gtk_css_rgba_value_get_rgba (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_RIGHT_COLOR));
1738       colors[2] = *_gtk_css_rgba_value_get_rgba (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_BOTTOM_COLOR));
1739       colors[3] = *_gtk_css_rgba_value_get_rgba (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_LEFT_COLOR));
1740
1741       _gtk_rounded_box_init_rect (&border_box, x, y, width, height);
1742       _gtk_rounded_box_apply_border_radius_for_engine (&border_box, engine, junction);
1743
1744       render_border (cr, &border_box, border_width, hidden_side, colors, border_style);
1745     }
1746
1747   border_style[0] = _gtk_css_border_style_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_OUTLINE_STYLE));
1748   if (border_style[0] != GTK_BORDER_STYLE_NONE)
1749     {
1750       int offset;
1751
1752       border_style[1] = border_style[2] = border_style[3] = border_style[0];
1753       border_width[0] = _gtk_css_number_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_OUTLINE_WIDTH), 100);
1754       border_width[3] = border_width[2] = border_width[1] = border_width[0];
1755       colors[0] = *_gtk_css_rgba_value_get_rgba (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_OUTLINE_COLOR));
1756       colors[3] = colors[2] = colors[1] = colors[0];
1757       offset = _gtk_css_number_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_OUTLINE_OFFSET), 100);
1758
1759       /* reinit box here - outlines don't have a border radius */
1760       _gtk_rounded_box_init_rect (&border_box, x, y, width, height);
1761       _gtk_rounded_box_shrink (&border_box,
1762                                - border_width[GTK_CSS_TOP] - offset,
1763                                - border_width[GTK_CSS_RIGHT] - offset,
1764                                - border_width[GTK_CSS_LEFT] - offset,
1765                                - border_width[GTK_CSS_BOTTOM] - offset);
1766
1767       render_border (cr, &border_box, border_width, hidden_side, colors, border_style);
1768     }
1769 }
1770
1771 static void
1772 gtk_theming_engine_render_frame (GtkThemingEngine *engine,
1773                                  cairo_t          *cr,
1774                                  gdouble           x,
1775                                  gdouble           y,
1776                                  gdouble           width,
1777                                  gdouble           height)
1778 {
1779   GtkJunctionSides junction;
1780
1781   junction = gtk_theming_engine_get_junction_sides (engine);
1782
1783   render_frame_internal (engine, cr,
1784                          x, y, width, height,
1785                          0, junction);
1786 }
1787
1788 static void
1789 gtk_theming_engine_render_expander (GtkThemingEngine *engine,
1790                                     cairo_t          *cr,
1791                                     gdouble           x,
1792                                     gdouble           y,
1793                                     gdouble           width,
1794                                     gdouble           height)
1795 {
1796   GtkStateFlags flags;
1797   GdkRGBA outline_color, fg_color;
1798   double vertical_overshoot;
1799   int diameter;
1800   double radius;
1801   double interp;                /* interpolation factor for center position */
1802   double x_double_horz, y_double_horz;
1803   double x_double_vert, y_double_vert;
1804   double x_double, y_double;
1805   gdouble angle;
1806   gint line_width;
1807   gboolean is_rtl;
1808   gdouble progress;
1809
1810   cairo_save (cr);
1811   flags = gtk_theming_engine_get_state (engine);
1812
1813   gtk_theming_engine_get_color (engine, flags, &fg_color);
1814   gtk_theming_engine_get_border_color (engine, flags, &outline_color);
1815
1816   is_rtl = (gtk_theming_engine_get_direction (engine) == GTK_TEXT_DIR_RTL);
1817   line_width = 1;
1818   progress = (flags & GTK_STATE_FLAG_ACTIVE) ? 1 : 0;
1819
1820   if (!gtk_theming_engine_has_class (engine, GTK_STYLE_CLASS_HORIZONTAL))
1821     {
1822       if (is_rtl)
1823         angle = (G_PI) - ((G_PI / 2) * progress);
1824       else
1825         angle = (G_PI / 2) * progress;
1826     }
1827   else
1828     {
1829       if (is_rtl)
1830         angle = (G_PI / 2) + ((G_PI / 2) * progress);
1831       else
1832         angle = (G_PI / 2) - ((G_PI / 2) * progress);
1833     }
1834
1835   interp = progress;
1836
1837   /* Compute distance that the stroke extends beyonds the end
1838    * of the triangle we draw.
1839    */
1840   vertical_overshoot = line_width / 2.0 * (1. / tan (G_PI / 8));
1841
1842   /* For odd line widths, we end the vertical line of the triangle
1843    * at a half pixel, so we round differently.
1844    */
1845   if (line_width % 2 == 1)
1846     vertical_overshoot = ceil (0.5 + vertical_overshoot) - 0.5;
1847   else
1848     vertical_overshoot = ceil (vertical_overshoot);
1849
1850   /* Adjust the size of the triangle we draw so that the entire stroke fits
1851    */
1852   diameter = (gint) MAX (3, width - 2 * vertical_overshoot);
1853
1854   /* If the line width is odd, we want the diameter to be even,
1855    * and vice versa, so force the sum to be odd. This relationship
1856    * makes the point of the triangle look right.
1857    */
1858   diameter -= (1 - (diameter + line_width) % 2);
1859
1860   radius = diameter / 2.;
1861
1862   /* Adjust the center so that the stroke is properly aligned with
1863    * the pixel grid. The center adjustment is different for the
1864    * horizontal and vertical orientations. For intermediate positions
1865    * we interpolate between the two.
1866    */
1867   x_double_vert = floor ((x + width / 2) - (radius + line_width) / 2.) + (radius + line_width) / 2.;
1868   y_double_vert = (y + height / 2) - 0.5;
1869
1870   x_double_horz = (x + width / 2) - 0.5;
1871   y_double_horz = floor ((y + height / 2) - (radius + line_width) / 2.) + (radius + line_width) / 2.;
1872
1873   x_double = x_double_vert * (1 - interp) + x_double_horz * interp;
1874   y_double = y_double_vert * (1 - interp) + y_double_horz * interp;
1875
1876   cairo_translate (cr, x_double, y_double);
1877   cairo_rotate (cr, angle);
1878
1879   cairo_move_to (cr, - radius / 2., - radius);
1880   cairo_line_to (cr,   radius / 2.,   0);
1881   cairo_line_to (cr, - radius / 2.,   radius);
1882   cairo_close_path (cr);
1883
1884   cairo_set_line_width (cr, line_width);
1885
1886   gdk_cairo_set_source_rgba (cr, &fg_color);
1887
1888   cairo_fill_preserve (cr);
1889
1890   gdk_cairo_set_source_rgba (cr, &outline_color);
1891   cairo_stroke (cr);
1892
1893   cairo_restore (cr);
1894 }
1895
1896 static void
1897 gtk_theming_engine_render_focus (GtkThemingEngine *engine,
1898                                  cairo_t          *cr,
1899                                  gdouble           x,
1900                                  gdouble           y,
1901                                  gdouble           width,
1902                                  gdouble           height)
1903 {
1904   GtkStateFlags flags;
1905   GdkRGBA color;
1906   gint line_width;
1907   gint8 *dash_list;
1908
1909   cairo_save (cr);
1910   flags = gtk_theming_engine_get_state (engine);
1911
1912   gtk_theming_engine_get_color (engine, flags, &color);
1913
1914   gtk_theming_engine_get_style (engine,
1915                                 "focus-line-width", &line_width,
1916                                 "focus-line-pattern", (gchar *) &dash_list,
1917                                 NULL);
1918
1919   cairo_set_line_width (cr, (gdouble) line_width);
1920
1921   if (dash_list[0])
1922     {
1923       gint n_dashes = strlen ((const gchar *) dash_list);
1924       gdouble *dashes = g_new (gdouble, n_dashes);
1925       gdouble total_length = 0;
1926       gdouble dash_offset;
1927       gint i;
1928
1929       for (i = 0; i < n_dashes; i++)
1930         {
1931           dashes[i] = dash_list[i];
1932           total_length += dash_list[i];
1933         }
1934
1935       /* The dash offset here aligns the pattern to integer pixels
1936        * by starting the dash at the right side of the left border
1937        * Negative dash offsets in cairo don't work
1938        * (https://bugs.freedesktop.org/show_bug.cgi?id=2729)
1939        */
1940       dash_offset = - line_width / 2.;
1941
1942       while (dash_offset < 0)
1943         dash_offset += total_length;
1944
1945       cairo_set_dash (cr, dashes, n_dashes, dash_offset);
1946       g_free (dashes);
1947     }
1948
1949   cairo_rectangle (cr,
1950                    x + line_width / 2.,
1951                    y + line_width / 2.,
1952                    width - line_width,
1953                    height - line_width);
1954
1955   gdk_cairo_set_source_rgba (cr, &color);
1956   cairo_stroke (cr);
1957
1958   cairo_restore (cr);
1959
1960   g_free (dash_list);
1961 }
1962
1963 static void
1964 gtk_theming_engine_render_line (GtkThemingEngine *engine,
1965                                 cairo_t          *cr,
1966                                 gdouble           x0,
1967                                 gdouble           y0,
1968                                 gdouble           x1,
1969                                 gdouble           y1)
1970 {
1971   GdkRGBA color;
1972   GtkStateFlags flags;
1973
1974   flags = gtk_theming_engine_get_state (engine);
1975   cairo_save (cr);
1976
1977   gtk_theming_engine_get_color (engine, flags, &color);
1978
1979   cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
1980   cairo_set_line_width (cr, 1);
1981
1982   cairo_move_to (cr, x0 + 0.5, y0 + 0.5);
1983   cairo_line_to (cr, x1 + 0.5, y1 + 0.5);
1984
1985   gdk_cairo_set_source_rgba (cr, &color);
1986   cairo_stroke (cr);
1987
1988   cairo_restore (cr);
1989 }
1990
1991 static void
1992 prepare_context_for_layout (cairo_t *cr,
1993                             gdouble x,
1994                             gdouble y,
1995                             PangoLayout *layout)
1996 {
1997   const PangoMatrix *matrix;
1998
1999   matrix = pango_context_get_matrix (pango_layout_get_context (layout));
2000
2001   cairo_move_to (cr, x, y);
2002
2003   if (matrix)
2004     {
2005       cairo_matrix_t cairo_matrix;
2006
2007       cairo_matrix_init (&cairo_matrix,
2008                          matrix->xx, matrix->yx,
2009                          matrix->xy, matrix->yy,
2010                          matrix->x0, matrix->y0);
2011
2012       cairo_transform (cr, &cairo_matrix);
2013     }
2014 }
2015
2016 static void
2017 gtk_theming_engine_render_layout (GtkThemingEngine *engine,
2018                                   cairo_t          *cr,
2019                                   gdouble           x,
2020                                   gdouble           y,
2021                                   PangoLayout      *layout)
2022 {
2023   GdkRGBA fg_color;
2024   GtkStateFlags flags;
2025
2026   cairo_save (cr);
2027   flags = gtk_theming_engine_get_state (engine);
2028   gtk_theming_engine_get_color (engine, flags, &fg_color);
2029
2030   prepare_context_for_layout (cr, x, y, layout);
2031
2032   _gtk_css_shadows_value_paint_layout (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_TEXT_SHADOW),
2033                                        cr, layout);
2034
2035   gdk_cairo_set_source_rgba (cr, &fg_color);
2036   pango_cairo_show_layout (cr, layout);
2037
2038   cairo_restore (cr);
2039 }
2040
2041 static void
2042 gtk_theming_engine_render_slider (GtkThemingEngine *engine,
2043                                   cairo_t          *cr,
2044                                   gdouble           x,
2045                                   gdouble           y,
2046                                   gdouble           width,
2047                                   gdouble           height,
2048                                   GtkOrientation    orientation)
2049 {
2050   gtk_theming_engine_render_background (engine, cr, x, y, width, height);
2051   gtk_theming_engine_render_frame (engine, cr, x, y, width, height);
2052 }
2053
2054 static void
2055 gtk_theming_engine_render_frame_gap (GtkThemingEngine *engine,
2056                                      cairo_t          *cr,
2057                                      gdouble           x,
2058                                      gdouble           y,
2059                                      gdouble           width,
2060                                      gdouble           height,
2061                                      GtkPositionType   gap_side,
2062                                      gdouble           xy0_gap,
2063                                      gdouble           xy1_gap)
2064 {
2065   GtkJunctionSides junction;
2066   GtkStateFlags state;
2067   gint border_width;
2068   GtkCssValue *corner[4];
2069   gdouble x0, y0, x1, y1, xc, yc, wc, hc;
2070   GtkBorder border;
2071
2072   xc = yc = wc = hc = 0;
2073   state = gtk_theming_engine_get_state (engine);
2074   junction = gtk_theming_engine_get_junction_sides (engine);
2075
2076   gtk_theming_engine_get_border (engine, state, &border);
2077   corner[GTK_CSS_TOP_LEFT] = _gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_TOP_LEFT_RADIUS);
2078   corner[GTK_CSS_TOP_RIGHT] = _gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_TOP_RIGHT_RADIUS);
2079   corner[GTK_CSS_BOTTOM_LEFT] = _gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_BOTTOM_LEFT_RADIUS);
2080   corner[GTK_CSS_BOTTOM_RIGHT] = _gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_BOTTOM_RIGHT_RADIUS);
2081
2082   border_width = MIN (MIN (border.top, border.bottom),
2083                       MIN (border.left, border.right));
2084
2085   cairo_save (cr);
2086
2087   switch (gap_side)
2088     {
2089     case GTK_POS_TOP:
2090       xc = x + xy0_gap + border_width;
2091       yc = y;
2092       wc = MAX (xy1_gap - xy0_gap - 2 * border_width, 0);
2093       hc = border_width;
2094
2095       if (xy0_gap < _gtk_css_corner_value_get_x (corner[GTK_CSS_TOP_LEFT], width))
2096         junction |= GTK_JUNCTION_CORNER_TOPLEFT;
2097
2098       if (xy1_gap > width - _gtk_css_corner_value_get_x (corner[GTK_CSS_TOP_RIGHT], width))
2099         junction |= GTK_JUNCTION_CORNER_TOPRIGHT;
2100       break;
2101     case GTK_POS_BOTTOM:
2102       xc = x + xy0_gap + border_width;
2103       yc = y + height - border_width;
2104       wc = MAX (xy1_gap - xy0_gap - 2 * border_width, 0);
2105       hc = border_width;
2106
2107       if (xy0_gap < _gtk_css_corner_value_get_x (corner[GTK_CSS_BOTTOM_LEFT], width))
2108         junction |= GTK_JUNCTION_CORNER_BOTTOMLEFT;
2109
2110       if (xy1_gap > width - _gtk_css_corner_value_get_x (corner[GTK_CSS_BOTTOM_RIGHT], width))
2111         junction |= GTK_JUNCTION_CORNER_BOTTOMRIGHT;
2112
2113       break;
2114     case GTK_POS_LEFT:
2115       xc = x;
2116       yc = y + xy0_gap + border_width;
2117       wc = border_width;
2118       hc = MAX (xy1_gap - xy0_gap - 2 * border_width, 0);
2119
2120       if (xy0_gap < _gtk_css_corner_value_get_y (corner[GTK_CSS_TOP_LEFT], height))
2121         junction |= GTK_JUNCTION_CORNER_TOPLEFT;
2122
2123       if (xy1_gap > height - _gtk_css_corner_value_get_y (corner[GTK_CSS_BOTTOM_LEFT], height))
2124         junction |= GTK_JUNCTION_CORNER_BOTTOMLEFT;
2125
2126       break;
2127     case GTK_POS_RIGHT:
2128       xc = x + width - border_width;
2129       yc = y + xy0_gap + border_width;
2130       wc = border_width;
2131       hc = MAX (xy1_gap - xy0_gap - 2 * border_width, 0);
2132
2133       if (xy0_gap < _gtk_css_corner_value_get_y (corner[GTK_CSS_TOP_RIGHT], height))
2134         junction |= GTK_JUNCTION_CORNER_TOPRIGHT;
2135
2136       if (xy1_gap > height - _gtk_css_corner_value_get_y (corner[GTK_CSS_BOTTOM_RIGHT], height))
2137         junction |= GTK_JUNCTION_CORNER_BOTTOMRIGHT;
2138
2139       break;
2140     }
2141
2142   cairo_clip_extents (cr, &x0, &y0, &x1, &y1);
2143   cairo_rectangle (cr, x0, y0, x1 - x0, yc - y0);
2144   cairo_rectangle (cr, x0, yc, xc - x0, hc);
2145   cairo_rectangle (cr, xc + wc, yc, x1 - (xc + wc), hc);
2146   cairo_rectangle (cr, x0, yc + hc, x1 - x0, y1 - (yc + hc));
2147   cairo_clip (cr);
2148
2149   render_frame_internal (engine, cr,
2150                          x, y, width, height,
2151                          0, junction);
2152
2153   cairo_restore (cr);
2154 }
2155
2156 static void
2157 gtk_theming_engine_render_extension (GtkThemingEngine *engine,
2158                                      cairo_t          *cr,
2159                                      gdouble           x,
2160                                      gdouble           y,
2161                                      gdouble           width,
2162                                      gdouble           height,
2163                                      GtkPositionType   gap_side)
2164 {
2165   GtkThemingBackground bg;
2166   GtkJunctionSides junction = 0;
2167   guint hidden_side = 0;
2168
2169   switch (gap_side)
2170     {
2171     case GTK_POS_LEFT:
2172       junction = GTK_JUNCTION_LEFT;
2173       hidden_side = (1 << GTK_CSS_LEFT);
2174       break;
2175     case GTK_POS_RIGHT:
2176       junction = GTK_JUNCTION_RIGHT;
2177       hidden_side = (1 << GTK_CSS_RIGHT);
2178       break;
2179     case GTK_POS_TOP:
2180       junction = GTK_JUNCTION_TOP;
2181       hidden_side = (1 << GTK_CSS_TOP);
2182       break;
2183     case GTK_POS_BOTTOM:
2184       junction = GTK_JUNCTION_BOTTOM;
2185       hidden_side = (1 << GTK_CSS_BOTTOM);
2186       break;
2187     }
2188
2189   _gtk_theming_background_init (&bg, engine,
2190                                 x, y,
2191                                 width, height,
2192                                 junction);
2193   _gtk_theming_background_render (&bg, cr);
2194
2195   render_frame_internal (engine, cr,
2196                          x, y, width, height,
2197                          hidden_side, junction);
2198 }
2199
2200 static void
2201 render_dot (cairo_t       *cr,
2202             const GdkRGBA *lighter,
2203             const GdkRGBA *darker,
2204             gdouble        x,
2205             gdouble        y,
2206             gdouble        size)
2207 {
2208   size = CLAMP ((gint) size, 2, 3);
2209
2210   if (size == 2)
2211     {
2212       gdk_cairo_set_source_rgba (cr, lighter);
2213       cairo_rectangle (cr, x, y, 1, 1);
2214       cairo_rectangle (cr, x + 1, y + 1, 1, 1);
2215       cairo_fill (cr);
2216     }
2217   else if (size == 3)
2218     {
2219       gdk_cairo_set_source_rgba (cr, lighter);
2220       cairo_rectangle (cr, x, y, 2, 1);
2221       cairo_rectangle (cr, x, y, 1, 2);
2222       cairo_fill (cr);
2223
2224       gdk_cairo_set_source_rgba (cr, darker);
2225       cairo_rectangle (cr, x + 1, y + 1, 2, 1);
2226       cairo_rectangle (cr, x + 2, y, 1, 2);
2227       cairo_fill (cr);
2228     }
2229 }
2230
2231 static void
2232 gtk_theming_engine_render_handle (GtkThemingEngine *engine,
2233                                   cairo_t          *cr,
2234                                   gdouble           x,
2235                                   gdouble           y,
2236                                   gdouble           width,
2237                                   gdouble           height)
2238 {
2239   GtkStateFlags flags;
2240   GdkRGBA bg_color, lighter, darker;
2241   GtkJunctionSides sides;
2242   GtkThemingBackground bg;
2243   gint xx, yy;
2244   gboolean has_image;
2245
2246   cairo_save (cr);
2247   flags = gtk_theming_engine_get_state (engine);
2248
2249   cairo_set_line_width (cr, 1.0);
2250   sides = gtk_theming_engine_get_junction_sides (engine);
2251   gtk_theming_engine_get_background_color (engine, flags, &bg_color);
2252
2253   color_shade (&bg_color, 0.7, &darker);
2254   color_shade (&bg_color, 1.3, &lighter);
2255
2256   _gtk_theming_background_init (&bg, engine, x, y, width, height, sides);
2257   has_image = _gtk_theming_background_has_background_image (&bg);
2258   _gtk_theming_background_render (&bg, cr);
2259
2260   gtk_theming_engine_render_frame (engine, cr, x, y, width, height);
2261
2262   if (gtk_theming_engine_has_class (engine, GTK_STYLE_CLASS_GRIP))
2263     {
2264       /* reduce confusing values to a meaningful state */
2265       if ((sides & (GTK_JUNCTION_CORNER_TOPLEFT | GTK_JUNCTION_CORNER_BOTTOMRIGHT)) == (GTK_JUNCTION_CORNER_TOPLEFT | GTK_JUNCTION_CORNER_BOTTOMRIGHT))
2266         sides &= ~GTK_JUNCTION_CORNER_TOPLEFT;
2267
2268       if ((sides & (GTK_JUNCTION_CORNER_TOPRIGHT | GTK_JUNCTION_CORNER_BOTTOMLEFT)) == (GTK_JUNCTION_CORNER_TOPRIGHT | GTK_JUNCTION_CORNER_BOTTOMLEFT))
2269         sides &= ~GTK_JUNCTION_CORNER_TOPRIGHT;
2270
2271       if (sides == 0)
2272         sides = GTK_JUNCTION_CORNER_BOTTOMRIGHT;
2273
2274       /* align drawing area to the connected side */
2275       if (sides == GTK_JUNCTION_LEFT)
2276         {
2277           if (height < width)
2278             width = height;
2279         }
2280       else if (sides == GTK_JUNCTION_CORNER_TOPLEFT)
2281         {
2282           if (width < height)
2283             height = width;
2284           else if (height < width)
2285             width = height;
2286         }
2287       else if (sides == GTK_JUNCTION_CORNER_BOTTOMLEFT)
2288         {
2289           /* make it square, aligning to bottom left */
2290           if (width < height)
2291             {
2292               y += (height - width);
2293               height = width;
2294             }
2295           else if (height < width)
2296             width = height;
2297         }
2298       else if (sides == GTK_JUNCTION_RIGHT)
2299         {
2300           /* aligning to right */
2301           if (height < width)
2302             {
2303               x += (width - height);
2304               width = height;
2305             }
2306         }
2307       else if (sides == GTK_JUNCTION_CORNER_TOPRIGHT)
2308         {
2309           if (width < height)
2310             height = width;
2311           else if (height < width)
2312             {
2313               x += (width - height);
2314               width = height;
2315             }
2316         }
2317       else if (sides == GTK_JUNCTION_CORNER_BOTTOMRIGHT)
2318         {
2319           /* make it square, aligning to bottom right */
2320           if (width < height)
2321             {
2322               y += (height - width);
2323               height = width;
2324             }
2325           else if (height < width)
2326             {
2327               x += (width - height);
2328               width = height;
2329             }
2330         }
2331       else if (sides == GTK_JUNCTION_TOP)
2332         {
2333           if (width < height)
2334             height = width;
2335         }
2336       else if (sides == GTK_JUNCTION_BOTTOM)
2337         {
2338           /* align to bottom */
2339           if (width < height)
2340             {
2341               y += (height - width);
2342               height = width;
2343             }
2344         }
2345       else
2346         g_assert_not_reached ();
2347
2348       if (sides == GTK_JUNCTION_LEFT ||
2349           sides == GTK_JUNCTION_RIGHT)
2350         {
2351           gint xi;
2352
2353           xi = x;
2354
2355           while (xi < x + width)
2356             {
2357               gdk_cairo_set_source_rgba (cr, &lighter);
2358               add_path_line (cr, x, y, x, y + height);
2359               cairo_stroke (cr);
2360               xi++;
2361
2362               gdk_cairo_set_source_rgba (cr, &darker);
2363               add_path_line (cr, xi, y, xi, y + height);
2364               cairo_stroke (cr);
2365               xi += 2;
2366             }
2367         }
2368       else if (sides == GTK_JUNCTION_TOP ||
2369                sides == GTK_JUNCTION_BOTTOM)
2370         {
2371           gint yi;
2372
2373           yi = y;
2374
2375           while (yi < y + height)
2376             {
2377               gdk_cairo_set_source_rgba (cr, &lighter);
2378               add_path_line (cr, x, yi, x + width, yi);
2379               cairo_stroke (cr);
2380               yi++;
2381
2382               gdk_cairo_set_source_rgba (cr, &darker);
2383               add_path_line (cr, x, yi, x + width, yi);
2384               cairo_stroke (cr);
2385               yi += 2;
2386             }
2387         }
2388       else if (sides == GTK_JUNCTION_CORNER_TOPLEFT)
2389         {
2390           gint xi, yi;
2391
2392           xi = x + width;
2393           yi = y + height;
2394
2395           while (xi > x + 3)
2396             {
2397               gdk_cairo_set_source_rgba (cr, &darker);
2398               add_path_line (cr, xi, y, x, yi);
2399               cairo_stroke (cr);
2400
2401               --xi;
2402               --yi;
2403
2404               add_path_line (cr, xi, y, x, yi);
2405               cairo_stroke (cr);
2406
2407               --xi;
2408               --yi;
2409
2410               gdk_cairo_set_source_rgba (cr, &lighter);
2411               add_path_line (cr, xi, y, x, yi);
2412               cairo_stroke (cr);
2413
2414               xi -= 3;
2415               yi -= 3;
2416             }
2417         }
2418       else if (sides == GTK_JUNCTION_CORNER_TOPRIGHT)
2419         {
2420           gint xi, yi;
2421
2422           xi = x;
2423           yi = y + height;
2424
2425           while (xi < (x + width - 3))
2426             {
2427               gdk_cairo_set_source_rgba (cr, &lighter);
2428               add_path_line (cr, xi, y, x + width, yi);
2429               cairo_stroke (cr);
2430
2431               ++xi;
2432               --yi;
2433
2434               gdk_cairo_set_source_rgba (cr, &darker);
2435               add_path_line (cr, xi, y, x + width, yi);
2436               cairo_stroke (cr);
2437
2438               ++xi;
2439               --yi;
2440
2441               add_path_line (cr, xi, y, x + width, yi);
2442               cairo_stroke (cr);
2443
2444               xi += 3;
2445               yi -= 3;
2446             }
2447         }
2448       else if (sides == GTK_JUNCTION_CORNER_BOTTOMLEFT)
2449         {
2450           gint xi, yi;
2451
2452           xi = x + width;
2453           yi = y;
2454
2455           while (xi > x + 3)
2456             {
2457               gdk_cairo_set_source_rgba (cr, &darker);
2458               add_path_line (cr, x, yi, xi, y + height);
2459               cairo_stroke (cr);
2460
2461               --xi;
2462               ++yi;
2463
2464               add_path_line (cr, x, yi, xi, y + height);
2465               cairo_stroke (cr);
2466
2467               --xi;
2468               ++yi;
2469
2470               gdk_cairo_set_source_rgba (cr, &lighter);
2471               add_path_line (cr, x, yi, xi, y + height);
2472               cairo_stroke (cr);
2473
2474               xi -= 3;
2475               yi += 3;
2476             }
2477         }
2478       else if (sides == GTK_JUNCTION_CORNER_BOTTOMRIGHT)
2479         {
2480           gint xi, yi;
2481
2482           xi = x;
2483           yi = y;
2484
2485           while (xi < (x + width - 3))
2486             {
2487               gdk_cairo_set_source_rgba (cr, &lighter);
2488               add_path_line (cr, xi, y + height, x + width, yi);
2489               cairo_stroke (cr);
2490
2491               ++xi;
2492               ++yi;
2493
2494               gdk_cairo_set_source_rgba (cr, &darker);
2495               add_path_line (cr, xi, y + height, x + width, yi);
2496               cairo_stroke (cr);
2497
2498               ++xi;
2499               ++yi;
2500
2501               add_path_line (cr, xi, y + height, x + width, yi);
2502               cairo_stroke (cr);
2503
2504               xi += 3;
2505               yi += 3;
2506             }
2507         }
2508     }
2509   else if (gtk_theming_engine_has_class (engine, GTK_STYLE_CLASS_PANE_SEPARATOR))
2510     {
2511       if (!has_image)
2512         {
2513           if (width > height)
2514             for (xx = x + width / 2 - 15; xx <= x + width / 2 + 15; xx += 5)
2515               render_dot (cr, &lighter, &darker, xx, y + height / 2 - 1, 3);
2516           else
2517             for (yy = y + height / 2 - 15; yy <= y + height / 2 + 15; yy += 5)
2518               render_dot (cr, &lighter, &darker, x + width / 2 - 1, yy, 3);
2519         }
2520     }
2521   else
2522     {
2523       for (yy = y; yy < y + height; yy += 3)
2524         for (xx = x; xx < x + width; xx += 6)
2525           {
2526             render_dot (cr, &lighter, &darker, xx, yy, 2);
2527             render_dot (cr, &lighter, &darker, xx + 3, yy + 1, 2);
2528           }
2529     }
2530
2531   cairo_restore (cr);
2532 }
2533
2534 void
2535 _gtk_theming_engine_paint_spinner (cairo_t       *cr,
2536                                    gdouble        radius,
2537                                    gdouble        progress,
2538                                    const GdkRGBA *color)
2539 {
2540   guint num_steps, step;
2541   gdouble half;
2542   gint i;
2543
2544   num_steps = 12;
2545
2546   if (progress >= 0)
2547     step = (guint) (progress * num_steps);
2548   else
2549     step = 0;
2550
2551   cairo_save (cr);
2552
2553   cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
2554   cairo_set_line_width (cr, 2.0);
2555
2556   half = num_steps / 2;
2557
2558   for (i = 0; i < num_steps; i++)
2559     {
2560       gint inset = 0.7 * radius;
2561
2562       /* transparency is a function of time and intial value */
2563       gdouble t = 1.0 - (gdouble) ((i + step) % num_steps) / num_steps;
2564       gdouble xscale = - sin (i * G_PI / half);
2565       gdouble yscale = - cos (i * G_PI / half);
2566
2567       cairo_set_source_rgba (cr,
2568                              color->red,
2569                              color->green,
2570                              color->blue,
2571                              color->alpha * t);
2572
2573       cairo_move_to (cr,
2574                      (radius - inset) * xscale,
2575                      (radius - inset) * yscale);
2576       cairo_line_to (cr,
2577                      radius * xscale,
2578                      radius * yscale);
2579
2580       cairo_stroke (cr);
2581     }
2582
2583   cairo_restore (cr);
2584 }
2585
2586 static void
2587 render_spinner (GtkThemingEngine *engine,
2588                 cairo_t          *cr,
2589                 gdouble           x,
2590                 gdouble           y,
2591                 gdouble           width,
2592                 gdouble           height)
2593 {
2594   GtkStateFlags state;
2595   GdkRGBA color;
2596   gdouble radius;
2597
2598   state = gtk_theming_engine_get_state (engine);
2599   radius = MIN (width / 2, height / 2);
2600
2601   gtk_theming_engine_get_color (engine, state, &color);
2602
2603   cairo_save (cr);
2604   cairo_translate (cr, x + width / 2, y + height / 2);
2605
2606   _gtk_css_shadows_value_paint_spinner (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_ICON_SHADOW),
2607                                         cr,
2608                                         radius,
2609                                         -1);
2610
2611   _gtk_theming_engine_paint_spinner (cr,
2612                                      radius,
2613                                      -1,
2614                                      &color);
2615
2616   cairo_restore (cr);
2617 }
2618
2619 static void
2620 gtk_theming_engine_render_activity (GtkThemingEngine *engine,
2621                                     cairo_t          *cr,
2622                                     gdouble           x,
2623                                     gdouble           y,
2624                                     gdouble           width,
2625                                     gdouble           height)
2626 {
2627   GtkThemingBackground bg;
2628
2629   _gtk_theming_background_init (&bg, engine, x, y, width, height, 0);
2630
2631   if (gtk_theming_engine_has_class (engine, GTK_STYLE_CLASS_SPINNER) &&
2632       !_gtk_theming_background_has_background_image (&bg))
2633     {
2634       render_spinner (engine, cr, x, y, width, height);
2635     }
2636   else
2637     {
2638       _gtk_theming_background_render (&bg, cr);
2639       gtk_theming_engine_render_frame (engine, cr, x, y, width, height);
2640     }
2641 }
2642
2643 static GdkPixbuf *
2644 scale_or_ref (GdkPixbuf *src,
2645               gint       width,
2646               gint       height)
2647 {
2648   if (width == gdk_pixbuf_get_width (src) &&
2649       height == gdk_pixbuf_get_height (src))
2650     return g_object_ref (src);
2651   else
2652     return gdk_pixbuf_scale_simple (src,
2653                                     width, height,
2654                                     GDK_INTERP_BILINEAR);
2655 }
2656
2657 static gboolean
2658 lookup_icon_size (GtkThemingEngine *engine,
2659                   GtkIconSize       size,
2660                   gint             *width,
2661                   gint             *height)
2662 {
2663   GdkScreen *screen;
2664   GtkSettings *settings;
2665
2666   screen = gtk_theming_engine_get_screen (engine);
2667   settings = gtk_settings_get_for_screen (screen);
2668
2669   return gtk_icon_size_lookup_for_settings (settings, size, width, height);
2670 }
2671
2672 static void
2673 colorshift_source (cairo_t *cr,
2674                    gdouble shift)
2675 {
2676   cairo_pattern_t *source;
2677
2678   cairo_save (cr);
2679   cairo_paint (cr);
2680
2681   source = cairo_pattern_reference (cairo_get_source (cr));
2682
2683   cairo_set_source_rgb (cr, shift, shift, shift);
2684   cairo_set_operator (cr, CAIRO_OPERATOR_COLOR_DODGE);
2685
2686   cairo_mask (cr, source);
2687
2688   cairo_pattern_destroy (source);
2689   cairo_restore (cr);
2690 }
2691
2692 static GdkPixbuf *
2693 gtk_theming_engine_render_icon_pixbuf (GtkThemingEngine    *engine,
2694                                        const GtkIconSource *source,
2695                                        GtkIconSize          size)
2696 {
2697   GdkPixbuf *scaled;
2698   GdkPixbuf *stated;
2699   GdkPixbuf *base_pixbuf;
2700   GtkStateFlags state;
2701   gint width = 1;
2702   gint height = 1;
2703   cairo_t *cr;
2704   cairo_surface_t *surface;
2705
2706   base_pixbuf = gtk_icon_source_get_pixbuf (source);
2707   state = gtk_theming_engine_get_state (engine);
2708
2709   g_return_val_if_fail (base_pixbuf != NULL, NULL);
2710
2711   if (size != (GtkIconSize) -1 &&
2712       !lookup_icon_size (engine, size, &width, &height))
2713     {
2714       g_warning (G_STRLOC ": invalid icon size '%d'", size);
2715       return NULL;
2716     }
2717
2718   /* If the size was wildcarded, and we're allowed to scale, then scale; otherwise,
2719    * leave it alone.
2720    */
2721   if (size != (GtkIconSize) -1 &&
2722       gtk_icon_source_get_size_wildcarded (source))
2723     scaled = scale_or_ref (base_pixbuf, width, height);
2724   else
2725     scaled = g_object_ref (base_pixbuf);
2726
2727   /* If the state was wildcarded, then generate a state. */
2728   if (gtk_icon_source_get_state_wildcarded (source))
2729     {
2730       if (state & GTK_STATE_FLAG_INSENSITIVE)
2731         {
2732           surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
2733                                                 gdk_pixbuf_get_width (scaled),
2734                                                 gdk_pixbuf_get_height (scaled));
2735           cr = cairo_create (surface);
2736           gdk_cairo_set_source_pixbuf (cr, scaled, 0, 0);
2737           cairo_paint_with_alpha (cr, 0.5);
2738
2739           cairo_destroy (cr);
2740
2741           g_object_unref (scaled);
2742           stated = gdk_pixbuf_get_from_surface (surface, 0, 0,
2743                                                 cairo_image_surface_get_width (surface),
2744                                                 cairo_image_surface_get_height (surface));
2745           cairo_surface_destroy (surface);
2746         }
2747       else if (state & GTK_STATE_FLAG_PRELIGHT)
2748         {
2749           surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
2750                                                 gdk_pixbuf_get_width (scaled),
2751                                                 gdk_pixbuf_get_height (scaled));
2752
2753           cr = cairo_create (surface);
2754           gdk_cairo_set_source_pixbuf (cr, scaled, 0, 0);
2755           colorshift_source (cr, 0.10);
2756
2757           cairo_destroy (cr);
2758
2759           g_object_unref (scaled);
2760           stated = gdk_pixbuf_get_from_surface (surface, 0, 0,
2761                                                 cairo_image_surface_get_width (surface),
2762                                                 cairo_image_surface_get_height (surface));
2763           cairo_surface_destroy (surface);
2764         }
2765       else
2766         stated = scaled;
2767     }
2768   else
2769     stated = scaled;
2770
2771   return stated;
2772 }
2773
2774 static void
2775 gtk_theming_engine_render_icon (GtkThemingEngine *engine,
2776                                 cairo_t *cr,
2777                                 GdkPixbuf *pixbuf,
2778                                 gdouble x,
2779                                 gdouble y)
2780 {
2781   cairo_save (cr);
2782
2783   gdk_cairo_set_source_pixbuf (cr, pixbuf, x, y);
2784
2785   _gtk_css_shadows_value_paint_icon (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_ICON_SHADOW), cr);
2786
2787   cairo_paint (cr);
2788
2789   cairo_restore (cr);
2790 }
2791