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 /**
 359  * gtk_theming_engine_get_property:
 360  * @engine: a #GtkThemingEngine
 361  * @property: the property name
 362  * @state: state to retrieve the value for
 363  * @value: (out) (transfer full): return location for the property value,
 364  *         you must free this memory using g_value_unset() once you are
 365  *         done with it.
 366  *
 367  * Gets a property value as retrieved from the style settings that apply
 368  * to the currently rendered element.
 369  *
 370  * Since: 3.0
 371  **/
 372 void
 373 gtk_theming_engine_get_property (GtkThemingEngine *engine,
 374                                  const gchar      *property,
 375                                  GtkStateFlags     state,
 376                                  GValue           *value)
 377 {
 378   GtkThemingEnginePrivate *priv;
 379
 380   g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
 381   g_return_if_fail (property != NULL);
 382   g_return_if_fail (value != NULL);
 383
 384   priv = engine->priv;
 385   gtk_style_context_get_property (priv->context, property, state, value);
 386 }
 387
 388 /**
 389  * gtk_theming_engine_get_valist:
 390  * @engine: a #GtkThemingEngine
 391  * @state: state to retrieve values for
 392  * @args: va_list of property name/return location pairs, followed by %NULL
 393  *
 394  * Retrieves several style property values that apply to the currently
 395  * rendered element.
 396  *
 397  * Since: 3.0
 398  **/
 399 void
 400 gtk_theming_engine_get_valist (GtkThemingEngine *engine,
 401                                GtkStateFlags     state,
 402                                va_list           args)
 403 {
 404   GtkThemingEnginePrivate *priv;
 405
 406   g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
 407
 408   priv = engine->priv;
 409   gtk_style_context_get_valist (priv->context, state, args);
 410 }
 411
 412 /**
 413  * gtk_theming_engine_get:
 414  * @engine: a #GtkThemingEngine
 415  * @state: state to retrieve values for
 416  * @...: property name /return value pairs, followed by %NULL
 417  *
 418  * Retrieves several style property values that apply to the currently
 419  * rendered element.
 420  *
 421  * Since: 3.0
 422  **/
 423 void
 424 gtk_theming_engine_get (GtkThemingEngine *engine,
 425                         GtkStateFlags     state,
 426                         ...)
 427 {
 428   GtkThemingEnginePrivate *priv;
 429   va_list args;
 430
 431   g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
 432
 433   priv = engine->priv;
 434
 435   va_start (args, state);
 436   gtk_style_context_get_valist (priv->context, state, args);
 437   va_end (args);
 438 }
 439
 440 /**
 441  * gtk_theming_engine_get_style_property:
 442  * @engine: a #GtkThemingEngine
 443  * @property_name: the name of the widget style property
 444  * @value: Return location for the property value, free with
 445  *         g_value_unset() after use.
 446  *
 447  * Gets the value for a widget style property.
 448  *
 449  * Since: 3.0
 450  **/
 451 void
 452 gtk_theming_engine_get_style_property (GtkThemingEngine *engine,
 453                                        const gchar      *property_name,
 454                                        GValue           *value)
 455 {
 456   GtkThemingEnginePrivate *priv;
 457
 458   g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
 459   g_return_if_fail (property_name != NULL);
 460
 461   priv = engine->priv;
 462   gtk_style_context_get_style_property (priv->context, property_name, value);
 463 }
 464
 465 /**
 466  * gtk_theming_engine_get_style_valist:
 467  * @engine: a #GtkThemingEngine
 468  * @args: va_list of property name/return location pairs, followed by %NULL
 469  *
 470  * Retrieves several widget style properties from @engine according to the
 471  * currently rendered content's style.
 472  *
 473  * Since: 3.0
 474  **/
 475 void
 476 gtk_theming_engine_get_style_valist (GtkThemingEngine *engine,
 477                                      va_list           args)
 478 {
 479   GtkThemingEnginePrivate *priv;
 480
 481   g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
 482
 483   priv = engine->priv;
 484   gtk_style_context_get_style_valist (priv->context, args);
 485 }
 486
 487 /**
 488  * gtk_theming_engine_get_style:
 489  * @engine: a #GtkThemingEngine
 490  * @...: property name /return value pairs, followed by %NULL
 491  *
 492  * Retrieves several widget style properties from @engine according
 493  * to the currently rendered content's style.
 494  *
 495  * Since: 3.0
 496  **/
 497 void
 498 gtk_theming_engine_get_style (GtkThemingEngine *engine,
 499                               ...)
 500 {
 501   GtkThemingEnginePrivate *priv;
 502   va_list args;
 503
 504   g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
 505
 506   priv = engine->priv;
 507
 508   va_start (args, engine);
 509   gtk_style_context_get_style_valist (priv->context, args);
 510   va_end (args);
 511 }
 512
 513 /**
 514  * gtk_theming_engine_lookup_color:
 515  * @engine: a #GtkThemingEngine
 516  * @color_name: color name to lookup
 517  * @color: (out): Return location for the looked up color
 518  *
 519  * Looks up and resolves a color name in the current style's color map.
 520  *
 521  * Returns: %TRUE if @color_name was found and resolved, %FALSE otherwise
 522  **/
 523 gboolean
 524 gtk_theming_engine_lookup_color (GtkThemingEngine *engine,
 525                                  const gchar      *color_name,
 526                                  GdkRGBA          *color)
 527 {
 528   GtkThemingEnginePrivate *priv;
 529
 530   g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), FALSE);
 531   g_return_val_if_fail (color_name != NULL, FALSE);
 532
 533   priv = engine->priv;
 534   return gtk_style_context_lookup_color (priv->context, color_name, color);
 535 }
 536
 537 /**
 538  * gtk_theming_engine_get_state:
 539  * @engine: a #GtkThemingEngine
 540  *
 541  * returns the state used when rendering.
 542  *
 543  * Returns: the state flags
 544  *
 545  * Since: 3.0
 546  **/
 547 GtkStateFlags
 548 gtk_theming_engine_get_state (GtkThemingEngine *engine)
 549 {
 550   GtkThemingEnginePrivate *priv;
 551
 552   g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), 0);
 553
 554   priv = engine->priv;
 555   return gtk_style_context_get_state (priv->context);
 556 }
 557
 558 /**
 559  * gtk_theming_engine_state_is_running:
 560  * @engine: a #GtkThemingEngine
 561  * @state: a widget state
 562  * @progress: (out): return location for the transition progress
 563  *
 564  * Returns %TRUE if there is a transition animation running for the
 565  * current region (see gtk_style_context_push_animatable_region()).
 566  *
 567  * If @progress is not %NULL, the animation progress will be returned
 568  * there, 0.0 means the state is closest to being %FALSE, while 1.0 means
 569  * it's closest to being %TRUE. This means transition animations will
 570  * run from 0 to 1 when @state is being set to %TRUE and from 1 to 0 when
 571  * it's being set to %FALSE.
 572  *
 573  * Returns: %TRUE if there is a running transition animation for @state.
 574  *
 575  * Since: 3.0
 576  *
 577  * Deprecated: 3.6: Always returns %FALSE
 578  **/
 579 gboolean
 580 gtk_theming_engine_state_is_running (GtkThemingEngine *engine,
 581                                      GtkStateType      state,
 582                                      gdouble          *progress)
 583 {
 584   g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), FALSE);
 585
 586   return FALSE;
 587 }
 588
 589 /**
 590  * gtk_theming_engine_get_path:
 591  * @engine: a #GtkThemingEngine
 592  *
 593  * Returns the widget path used for style matching.
 594  *
 595  * Returns: (transfer none): A #GtkWidgetPath
 596  *
 597  * Since: 3.0
 598  **/
 599 const GtkWidgetPath *
 600 gtk_theming_engine_get_path (GtkThemingEngine *engine)
 601 {
 602   GtkThemingEnginePrivate *priv;
 603
 604   g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), NULL);
 605
 606   priv = engine->priv;
 607   return gtk_style_context_get_path (priv->context);
 608 }
 609
 610 /**
 611  * gtk_theming_engine_has_class:
 612  * @engine: a #GtkThemingEngine
 613  * @style_class: class name to look up
 614  *
 615  * Returns %TRUE if the currently rendered contents have
 616  * defined the given class name.
 617  *
 618  * Returns: %TRUE if @engine has @class_name defined
 619  *
 620  * Since: 3.0
 621  **/
 622 gboolean
 623 gtk_theming_engine_has_class (GtkThemingEngine *engine,
 624                               const gchar      *style_class)
 625 {
 626   GtkThemingEnginePrivate *priv;
 627
 628   g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), FALSE);
 629
 630   priv = engine->priv;
 631   return gtk_style_context_has_class (priv->context, style_class);
 632 }
 633
 634 /**
 635  * gtk_theming_engine_has_region:
 636  * @engine: a #GtkThemingEngine
 637  * @style_region: a region name
 638  * @flags: (out) (allow-none): return location for region flags
 639  *
 640  * Returns %TRUE if the currently rendered contents have the
 641  * region defined. If @flags_return is not %NULL, it is set
 642  * to the flags affecting the region.
 643  *
 644  * Returns: %TRUE if region is defined
 645  *
 646  * Since: 3.0
 647  **/
 648 gboolean
 649 gtk_theming_engine_has_region (GtkThemingEngine *engine,
 650                                const gchar      *style_region,
 651                                GtkRegionFlags   *flags)
 652 {
 653   GtkThemingEnginePrivate *priv;
 654
 655   if (flags)
 656     *flags = 0;
 657
 658   g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), FALSE);
 659
 660   priv = engine->priv;
 661   return gtk_style_context_has_region (priv->context, style_region, flags);
 662 }
 663
 664 /**
 665  * gtk_theming_engine_get_direction:
 666  * @engine: a #GtkThemingEngine
 667  *
 668  * Returns the widget direction used for rendering.
 669  *
 670  * Returns: the widget direction
 671  *
 672  * Since: 3.0
 673  *
 674  * Deprecated: 3.8: Use gtk_theming_engine_get_state() and
 675  *   check for #GTK_STATE_FLAG_DIR_LTR and
 676  *   #GTK_STATE_FLAG_DIR_RTL instead.
 677  **/
 678 GtkTextDirection
 679 gtk_theming_engine_get_direction (GtkThemingEngine *engine)
 680 {
 681   GtkThemingEnginePrivate *priv;
 682
 683   g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), GTK_TEXT_DIR_LTR);
 684
 685   priv = engine->priv;
 686   G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
 687   return gtk_style_context_get_direction (priv->context);
 688   G_GNUC_END_IGNORE_DEPRECATIONS;
 689 }
 690
 691 /**
 692  * gtk_theming_engine_get_junction_sides:
 693  * @engine: a #GtkThemingEngine
 694  *
 695  * Returns the widget direction used for rendering.
 696  *
 697  * Returns: the widget direction
 698  *
 699  * Since: 3.0
 700  **/
 701 GtkJunctionSides
 702 gtk_theming_engine_get_junction_sides (GtkThemingEngine *engine)
 703 {
 704   GtkThemingEnginePrivate *priv;
 705
 706   g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), 0);
 707
 708   priv = engine->priv;
 709   return gtk_style_context_get_junction_sides (priv->context);
 710 }
 711
 712 /**
 713  * gtk_theming_engine_get_color:
 714  * @engine: a #GtkThemingEngine
 715  * @state: state to retrieve the color for
 716  * @color: (out): return value for the foreground color
 717  *
 718  * Gets the foreground color for a given state.
 719  *
 720  * Since: 3.0
 721  **/
 722 void
 723 gtk_theming_engine_get_color (GtkThemingEngine *engine,
 724                               GtkStateFlags     state,
 725                               GdkRGBA          *color)
 726 {
 727   GtkThemingEnginePrivate *priv;
 728
 729   g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
 730
 731   priv = engine->priv;
 732   gtk_style_context_get_color (priv->context, state, color);
 733 }
 734
 735 /**
 736  * gtk_theming_engine_get_background_color:
 737  * @engine: a #GtkThemingEngine
 738  * @state: state to retrieve the color for
 739  * @color: (out): return value for the background color
 740  *
 741  * Gets the background color for a given state.
 742  *
 743  * Since: 3.0
 744  **/
 745 void
 746 gtk_theming_engine_get_background_color (GtkThemingEngine *engine,
 747                                          GtkStateFlags     state,
 748                                          GdkRGBA          *color)
 749 {
 750   GtkThemingEnginePrivate *priv;
 751
 752   g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
 753
 754   priv = engine->priv;
 755   gtk_style_context_get_background_color (priv->context, state, color);
 756 }
 757
 758 /**
 759  * gtk_theming_engine_get_border_color:
 760  * @engine: a #GtkThemingEngine
 761  * @state: state to retrieve the color for
 762  * @color: (out): return value for the border color
 763  *
 764  * Gets the border color for a given state.
 765  *
 766  * Since: 3.0
 767  **/
 768 void
 769 gtk_theming_engine_get_border_color (GtkThemingEngine *engine,
 770                                      GtkStateFlags     state,
 771                                      GdkRGBA          *color)
 772 {
 773   GtkThemingEnginePrivate *priv;
 774
 775   g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
 776
 777   priv = engine->priv;
 778   gtk_style_context_get_border_color (priv->context, state, color);
 779 }
 780
 781 /**
 782  * gtk_theming_engine_get_border:
 783  * @engine: a #GtkThemingEngine
 784  * @state: state to retrieve the border for
 785  * @border: (out): return value for the border settings
 786  *
 787  * Gets the border for a given state as a #GtkBorder.
 788  *
 789  * Since: 3.0
 790  **/
 791 void
 792 gtk_theming_engine_get_border (GtkThemingEngine *engine,
 793                                GtkStateFlags     state,
 794                                GtkBorder        *border)
 795 {
 796   GtkThemingEnginePrivate *priv;
 797
 798   g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
 799
 800   priv = engine->priv;
 801   gtk_style_context_get_border (priv->context, state, border);
 802 }
 803
 804 /**
 805  * gtk_theming_engine_get_padding:
 806  * @engine: a #GtkThemingEngine
 807  * @state: state to retrieve the padding for
 808  * @padding: (out): return value for the padding settings
 809  *
 810  * Gets the padding for a given state as a #GtkBorder.
 811  *
 812  * Since: 3.0
 813  **/
 814 void
 815 gtk_theming_engine_get_padding (GtkThemingEngine *engine,
 816                                 GtkStateFlags     state,
 817                                 GtkBorder        *padding)
 818 {
 819   GtkThemingEnginePrivate *priv;
 820
 821   g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
 822
 823   priv = engine->priv;
 824   gtk_style_context_get_padding (priv->context, state, padding);
 825 }
 826
 827 /**
 828  * gtk_theming_engine_get_margin:
 829  * @engine: a #GtkThemingEngine
 830  * @state: state to retrieve the border for
 831  * @margin: (out): return value for the margin settings
 832  *
 833  * Gets the margin for a given state as a #GtkBorder.
 834  *
 835  * Since: 3.0
 836  **/
 837 void
 838 gtk_theming_engine_get_margin (GtkThemingEngine *engine,
 839                                GtkStateFlags     state,
 840                                GtkBorder        *margin)
 841 {
 842   GtkThemingEnginePrivate *priv;
 843
 844   g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
 845
 846   priv = engine->priv;
 847   gtk_style_context_get_margin (priv->context, state, margin);
 848 }
 849
 850 /**
 851  * gtk_theming_engine_get_font:
 852  * @engine: a #GtkThemingEngine
 853  * @state: state to retrieve the font for
 854  *
 855  * Returns the font description for a given state.
 856  *
 857  * Returns: (transfer none): the #PangoFontDescription for the given
 858  *          state. This object is owned by GTK+ and should not be
 859  *          freed.
 860  *
 861  * Since: 3.0
 862  *
 863  * Deprecated: 3.8: Use gtk_theming_engine_get()
 864  **/
 865 const PangoFontDescription *
 866 gtk_theming_engine_get_font (GtkThemingEngine *engine,
 867                              GtkStateFlags     state)
 868 {
 869   GtkThemingEnginePrivate *priv;
 870
 871   g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), NULL);
 872
 873   G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
 874   priv = engine->priv;
 875   return gtk_style_context_get_font (priv->context, state);
 876   G_GNUC_END_IGNORE_DEPRECATIONS;
 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           break;
1660         case GTK_BORDER_STYLE_GROOVE:
1661         case GTK_BORDER_STYLE_RIDGE:
1662           {
1663             GtkRoundedBox other_box;
1664             GdkRGBA other_colors[4];
1665             guint dont_draw = hidden_side;
1666             double other_border[4];
1667
1668             for (j = 0; j < 4; j++)
1669               {
1670                 other_colors[j] = colors[j];
1671                 if ((j == 0 || j == 3) ^ (border_style[j] == GTK_BORDER_STYLE_RIDGE))
1672                   color_shade (&other_colors[j], 1.8, &other_colors[j]);
1673                 else
1674                   color_shade (&colors[j], 1.8, &colors[j]);
1675                 if (border_style[j] == GTK_BORDER_STYLE_GROOVE ||
1676                     border_style[j] == GTK_BORDER_STYLE_RIDGE)
1677                   hidden_side |= (1 << j);
1678                 else
1679                   dont_draw |= (1 << j);
1680                 other_border[i] = border_width[i] / 2;
1681               }
1682
1683             render_frame_fill (cr, border_box, other_border, colors, dont_draw);
1684
1685             other_box = *border_box;
1686             _gtk_rounded_box_shrink (&other_box,
1687                                      other_border[GTK_CSS_TOP],
1688                                      other_border[GTK_CSS_RIGHT],
1689                                      other_border[GTK_CSS_BOTTOM],
1690                                      other_border[GTK_CSS_LEFT]);
1691             render_frame_fill (cr, &other_box, other_border, other_colors, dont_draw);
1692           }
1693           break;
1694         default:
1695           g_assert_not_reached ();
1696           break;
1697         }
1698     }
1699
1700   render_frame_fill (cr, border_box, border_width, colors, hidden_side);
1701
1702   cairo_restore (cr);
1703 }
1704
1705 static void
1706 render_frame_internal (GtkThemingEngine *engine,
1707                        cairo_t          *cr,
1708                        gdouble           x,
1709                        gdouble           y,
1710                        gdouble           width,
1711                        gdouble           height,
1712                        guint             hidden_side,
1713                        GtkJunctionSides  junction)
1714 {
1715   GtkBorderImage border_image;
1716   GtkBorderStyle border_style[4];
1717   GtkRoundedBox border_box;
1718   double border_width[4];
1719   GdkRGBA colors[4];
1720
1721   border_width[0] = _gtk_css_number_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_TOP_WIDTH), 100);
1722   border_width[1] = _gtk_css_number_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_RIGHT_WIDTH), 100);
1723   border_width[2] = _gtk_css_number_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_BOTTOM_WIDTH), 100);
1724   border_width[3] = _gtk_css_number_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_LEFT_WIDTH), 100);
1725
1726   border_style[0] = _gtk_css_border_style_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_TOP_STYLE));
1727   border_style[1] = _gtk_css_border_style_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_RIGHT_STYLE));
1728   border_style[2] = _gtk_css_border_style_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_BOTTOM_STYLE));
1729   border_style[3] = _gtk_css_border_style_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_LEFT_STYLE));
1730
1731   gtk_theming_engine_hide_border_sides (border_width, border_style, hidden_side);
1732
1733   if (_gtk_border_image_init (&border_image, engine))
1734     _gtk_border_image_render (&border_image, border_width, cr, x, y, width, height);
1735   else
1736     {
1737       colors[0] = *_gtk_css_rgba_value_get_rgba (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_TOP_COLOR));
1738       colors[1] = *_gtk_css_rgba_value_get_rgba (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_RIGHT_COLOR));
1739       colors[2] = *_gtk_css_rgba_value_get_rgba (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_BOTTOM_COLOR));
1740       colors[3] = *_gtk_css_rgba_value_get_rgba (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_LEFT_COLOR));
1741
1742       _gtk_rounded_box_init_rect (&border_box, x, y, width, height);
1743       _gtk_rounded_box_apply_border_radius_for_engine (&border_box, engine, junction);
1744
1745       render_border (cr, &border_box, border_width, hidden_side, colors, border_style);
1746     }
1747
1748   border_style[0] = _gtk_css_border_style_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_OUTLINE_STYLE));
1749   if (border_style[0] != GTK_BORDER_STYLE_NONE)
1750     {
1751       int offset;
1752
1753       border_style[1] = border_style[2] = border_style[3] = border_style[0];
1754       border_width[0] = _gtk_css_number_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_OUTLINE_WIDTH), 100);
1755       border_width[3] = border_width[2] = border_width[1] = border_width[0];
1756       colors[0] = *_gtk_css_rgba_value_get_rgba (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_OUTLINE_COLOR));
1757       colors[3] = colors[2] = colors[1] = colors[0];
1758       offset = _gtk_css_number_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_OUTLINE_OFFSET), 100);
1759
1760       /* reinit box here - outlines don't have a border radius */
1761       _gtk_rounded_box_init_rect (&border_box, x, y, width, height);
1762       _gtk_rounded_box_shrink (&border_box,
1763                                - border_width[GTK_CSS_TOP] - offset,
1764                                - border_width[GTK_CSS_RIGHT] - offset,
1765                                - border_width[GTK_CSS_LEFT] - offset,
1766                                - border_width[GTK_CSS_BOTTOM] - offset);
1767
1768       render_border (cr, &border_box, border_width, hidden_side, colors, border_style);
1769     }
1770 }
1771
1772 static void
1773 gtk_theming_engine_render_frame (GtkThemingEngine *engine,
1774                                  cairo_t          *cr,
1775                                  gdouble           x,
1776                                  gdouble           y,
1777                                  gdouble           width,
1778                                  gdouble           height)
1779 {
1780   GtkJunctionSides junction;
1781
1782   junction = gtk_theming_engine_get_junction_sides (engine);
1783
1784   render_frame_internal (engine, cr,
1785                          x, y, width, height,
1786                          0, junction);
1787 }
1788
1789 static void
1790 gtk_theming_engine_render_expander (GtkThemingEngine *engine,
1791                                     cairo_t          *cr,
1792                                     gdouble           x,
1793                                     gdouble           y,
1794                                     gdouble           width,
1795                                     gdouble           height)
1796 {
1797   GtkStateFlags flags;
1798   GdkRGBA outline_color, fg_color;
1799   double vertical_overshoot;
1800   int diameter;
1801   double radius;
1802   double interp;                /* interpolation factor for center position */
1803   double x_double_horz, y_double_horz;
1804   double x_double_vert, y_double_vert;
1805   double x_double, y_double;
1806   gdouble angle;
1807   gint line_width;
1808   gboolean is_rtl;
1809   gdouble progress;
1810
1811   cairo_save (cr);
1812   flags = gtk_theming_engine_get_state (engine);
1813
1814   gtk_theming_engine_get_color (engine, flags, &fg_color);
1815   gtk_theming_engine_get_border_color (engine, flags, &outline_color);
1816
1817   is_rtl = (gtk_theming_engine_get_state (engine) & GTK_STATE_FLAG_DIR_RTL);
1818   line_width = 1;
1819   progress = (flags & GTK_STATE_FLAG_ACTIVE) ? 1 : 0;
1820
1821   if (!gtk_theming_engine_has_class (engine, GTK_STYLE_CLASS_HORIZONTAL))
1822     {
1823       if (is_rtl)
1824         angle = (G_PI) - ((G_PI / 2) * progress);
1825       else
1826         angle = (G_PI / 2) * progress;
1827     }
1828   else
1829     {
1830       if (is_rtl)
1831         angle = (G_PI / 2) + ((G_PI / 2) * progress);
1832       else
1833         angle = (G_PI / 2) - ((G_PI / 2) * progress);
1834     }
1835
1836   interp = progress;
1837
1838   /* Compute distance that the stroke extends beyonds the end
1839    * of the triangle we draw.
1840    */
1841   vertical_overshoot = line_width / 2.0 * (1. / tan (G_PI / 8));
1842
1843   /* For odd line widths, we end the vertical line of the triangle
1844    * at a half pixel, so we round differently.
1845    */
1846   if (line_width % 2 == 1)
1847     vertical_overshoot = ceil (0.5 + vertical_overshoot) - 0.5;
1848   else
1849     vertical_overshoot = ceil (vertical_overshoot);
1850
1851   /* Adjust the size of the triangle we draw so that the entire stroke fits
1852    */
1853   diameter = (gint) MAX (3, width - 2 * vertical_overshoot);
1854
1855   /* If the line width is odd, we want the diameter to be even,
1856    * and vice versa, so force the sum to be odd. This relationship
1857    * makes the point of the triangle look right.
1858    */
1859   diameter -= (1 - (diameter + line_width) % 2);
1860
1861   radius = diameter / 2.;
1862
1863   /* Adjust the center so that the stroke is properly aligned with
1864    * the pixel grid. The center adjustment is different for the
1865    * horizontal and vertical orientations. For intermediate positions
1866    * we interpolate between the two.
1867    */
1868   x_double_vert = floor ((x + width / 2) - (radius + line_width) / 2.) + (radius + line_width) / 2.;
1869   y_double_vert = (y + height / 2) - 0.5;
1870
1871   x_double_horz = (x + width / 2) - 0.5;
1872   y_double_horz = floor ((y + height / 2) - (radius + line_width) / 2.) + (radius + line_width) / 2.;
1873
1874   x_double = x_double_vert * (1 - interp) + x_double_horz * interp;
1875   y_double = y_double_vert * (1 - interp) + y_double_horz * interp;
1876
1877   cairo_translate (cr, x_double, y_double);
1878   cairo_rotate (cr, angle);
1879
1880   cairo_move_to (cr, - radius / 2., - radius);
1881   cairo_line_to (cr,   radius / 2.,   0);
1882   cairo_line_to (cr, - radius / 2.,   radius);
1883   cairo_close_path (cr);
1884
1885   cairo_set_line_width (cr, line_width);
1886
1887   gdk_cairo_set_source_rgba (cr, &fg_color);
1888
1889   cairo_fill_preserve (cr);
1890
1891   gdk_cairo_set_source_rgba (cr, &outline_color);
1892   cairo_stroke (cr);
1893
1894   cairo_restore (cr);
1895 }
1896
1897 static void
1898 gtk_theming_engine_render_focus (GtkThemingEngine *engine,
1899                                  cairo_t          *cr,
1900                                  gdouble           x,
1901                                  gdouble           y,
1902                                  gdouble           width,
1903                                  gdouble           height)
1904 {
1905   GtkStateFlags flags;
1906   GdkRGBA color;
1907   gint line_width;
1908   gint8 *dash_list;
1909
1910   cairo_save (cr);
1911   flags = gtk_theming_engine_get_state (engine);
1912
1913   gtk_theming_engine_get_color (engine, flags, &color);
1914
1915   gtk_theming_engine_get_style (engine,
1916                                 "focus-line-width", &line_width,
1917                                 "focus-line-pattern", (gchar *) &dash_list,
1918                                 NULL);
1919
1920   cairo_set_line_width (cr, (gdouble) line_width);
1921
1922   if (dash_list[0])
1923     {
1924       gint n_dashes = strlen ((const gchar *) dash_list);
1925       gdouble *dashes = g_new (gdouble, n_dashes);
1926       gdouble total_length = 0;
1927       gdouble dash_offset;
1928       gint i;
1929
1930       for (i = 0; i < n_dashes; i++)
1931         {
1932           dashes[i] = dash_list[i];
1933           total_length += dash_list[i];
1934         }
1935
1936       /* The dash offset here aligns the pattern to integer pixels
1937        * by starting the dash at the right side of the left border
1938        * Negative dash offsets in cairo don't work
1939        * (https://bugs.freedesktop.org/show_bug.cgi?id=2729)
1940        */
1941       dash_offset = - line_width / 2.;
1942
1943       while (dash_offset < 0)
1944         dash_offset += total_length;
1945
1946       cairo_set_dash (cr, dashes, n_dashes, dash_offset);
1947       g_free (dashes);
1948     }
1949
1950   cairo_rectangle (cr,
1951                    x + line_width / 2.,
1952                    y + line_width / 2.,
1953                    width - line_width,
1954                    height - line_width);
1955
1956   gdk_cairo_set_source_rgba (cr, &color);
1957   cairo_stroke (cr);
1958
1959   cairo_restore (cr);
1960
1961   g_free (dash_list);
1962 }
1963
1964 static void
1965 gtk_theming_engine_render_line (GtkThemingEngine *engine,
1966                                 cairo_t          *cr,
1967                                 gdouble           x0,
1968                                 gdouble           y0,
1969                                 gdouble           x1,
1970                                 gdouble           y1)
1971 {
1972   GdkRGBA color;
1973   GtkStateFlags flags;
1974
1975   flags = gtk_theming_engine_get_state (engine);
1976   cairo_save (cr);
1977
1978   gtk_theming_engine_get_color (engine, flags, &color);
1979
1980   cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
1981   cairo_set_line_width (cr, 1);
1982
1983   cairo_move_to (cr, x0 + 0.5, y0 + 0.5);
1984   cairo_line_to (cr, x1 + 0.5, y1 + 0.5);
1985
1986   gdk_cairo_set_source_rgba (cr, &color);
1987   cairo_stroke (cr);
1988
1989   cairo_restore (cr);
1990 }
1991
1992 static void
1993 prepare_context_for_layout (cairo_t *cr,
1994                             gdouble x,
1995                             gdouble y,
1996                             PangoLayout *layout)
1997 {
1998   const PangoMatrix *matrix;
1999
2000   matrix = pango_context_get_matrix (pango_layout_get_context (layout));
2001
2002   cairo_move_to (cr, x, y);
2003
2004   if (matrix)
2005     {
2006       cairo_matrix_t cairo_matrix;
2007
2008       cairo_matrix_init (&cairo_matrix,
2009                          matrix->xx, matrix->yx,
2010                          matrix->xy, matrix->yy,
2011                          matrix->x0, matrix->y0);
2012
2013       cairo_transform (cr, &cairo_matrix);
2014     }
2015 }
2016
2017 static void
2018 gtk_theming_engine_render_layout (GtkThemingEngine *engine,
2019                                   cairo_t          *cr,
2020                                   gdouble           x,
2021                                   gdouble           y,
2022                                   PangoLayout      *layout)
2023 {
2024   GdkRGBA fg_color;
2025   GtkStateFlags flags;
2026
2027   cairo_save (cr);
2028   flags = gtk_theming_engine_get_state (engine);
2029   gtk_theming_engine_get_color (engine, flags, &fg_color);
2030
2031   prepare_context_for_layout (cr, x, y, layout);
2032
2033   _gtk_css_shadows_value_paint_layout (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_TEXT_SHADOW),
2034                                        cr, layout);
2035
2036   gdk_cairo_set_source_rgba (cr, &fg_color);
2037   pango_cairo_show_layout (cr, layout);
2038
2039   cairo_restore (cr);
2040 }
2041
2042 static void
2043 gtk_theming_engine_render_slider (GtkThemingEngine *engine,
2044                                   cairo_t          *cr,
2045                                   gdouble           x,
2046                                   gdouble           y,
2047                                   gdouble           width,
2048                                   gdouble           height,
2049                                   GtkOrientation    orientation)
2050 {
2051   gtk_theming_engine_render_background (engine, cr, x, y, width, height);
2052   gtk_theming_engine_render_frame (engine, cr, x, y, width, height);
2053 }
2054
2055 static void
2056 gtk_theming_engine_render_frame_gap (GtkThemingEngine *engine,
2057                                      cairo_t          *cr,
2058                                      gdouble           x,
2059                                      gdouble           y,
2060                                      gdouble           width,
2061                                      gdouble           height,
2062                                      GtkPositionType   gap_side,
2063                                      gdouble           xy0_gap,
2064                                      gdouble           xy1_gap)
2065 {
2066   GtkJunctionSides junction;
2067   GtkStateFlags state;
2068   gint border_width;
2069   GtkCssValue *corner[4];
2070   gdouble x0, y0, x1, y1, xc, yc, wc, hc;
2071   GtkBorder border;
2072
2073   xc = yc = wc = hc = 0;
2074   state = gtk_theming_engine_get_state (engine);
2075   junction = gtk_theming_engine_get_junction_sides (engine);
2076
2077   gtk_theming_engine_get_border (engine, state, &border);
2078   corner[GTK_CSS_TOP_LEFT] = _gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_TOP_LEFT_RADIUS);
2079   corner[GTK_CSS_TOP_RIGHT] = _gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_TOP_RIGHT_RADIUS);
2080   corner[GTK_CSS_BOTTOM_LEFT] = _gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_BOTTOM_LEFT_RADIUS);
2081   corner[GTK_CSS_BOTTOM_RIGHT] = _gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_BOTTOM_RIGHT_RADIUS);
2082
2083   border_width = MIN (MIN (border.top, border.bottom),
2084                       MIN (border.left, border.right));
2085
2086   cairo_save (cr);
2087
2088   switch (gap_side)
2089     {
2090     case GTK_POS_TOP:
2091       xc = x + xy0_gap + border_width;
2092       yc = y;
2093       wc = MAX (xy1_gap - xy0_gap - 2 * border_width, 0);
2094       hc = border_width;
2095
2096       if (xy0_gap < _gtk_css_corner_value_get_x (corner[GTK_CSS_TOP_LEFT], width))
2097         junction |= GTK_JUNCTION_CORNER_TOPLEFT;
2098
2099       if (xy1_gap > width - _gtk_css_corner_value_get_x (corner[GTK_CSS_TOP_RIGHT], width))
2100         junction |= GTK_JUNCTION_CORNER_TOPRIGHT;
2101       break;
2102     case GTK_POS_BOTTOM:
2103       xc = x + xy0_gap + border_width;
2104       yc = y + height - border_width;
2105       wc = MAX (xy1_gap - xy0_gap - 2 * border_width, 0);
2106       hc = border_width;
2107
2108       if (xy0_gap < _gtk_css_corner_value_get_x (corner[GTK_CSS_BOTTOM_LEFT], width))
2109         junction |= GTK_JUNCTION_CORNER_BOTTOMLEFT;
2110
2111       if (xy1_gap > width - _gtk_css_corner_value_get_x (corner[GTK_CSS_BOTTOM_RIGHT], width))
2112         junction |= GTK_JUNCTION_CORNER_BOTTOMRIGHT;
2113
2114       break;
2115     case GTK_POS_LEFT:
2116       xc = x;
2117       yc = y + xy0_gap + border_width;
2118       wc = border_width;
2119       hc = MAX (xy1_gap - xy0_gap - 2 * border_width, 0);
2120
2121       if (xy0_gap < _gtk_css_corner_value_get_y (corner[GTK_CSS_TOP_LEFT], height))
2122         junction |= GTK_JUNCTION_CORNER_TOPLEFT;
2123
2124       if (xy1_gap > height - _gtk_css_corner_value_get_y (corner[GTK_CSS_BOTTOM_LEFT], height))
2125         junction |= GTK_JUNCTION_CORNER_BOTTOMLEFT;
2126
2127       break;
2128     case GTK_POS_RIGHT:
2129       xc = x + width - border_width;
2130       yc = y + xy0_gap + border_width;
2131       wc = border_width;
2132       hc = MAX (xy1_gap - xy0_gap - 2 * border_width, 0);
2133
2134       if (xy0_gap < _gtk_css_corner_value_get_y (corner[GTK_CSS_TOP_RIGHT], height))
2135         junction |= GTK_JUNCTION_CORNER_TOPRIGHT;
2136
2137       if (xy1_gap > height - _gtk_css_corner_value_get_y (corner[GTK_CSS_BOTTOM_RIGHT], height))
2138         junction |= GTK_JUNCTION_CORNER_BOTTOMRIGHT;
2139
2140       break;
2141     }
2142
2143   cairo_clip_extents (cr, &x0, &y0, &x1, &y1);
2144   cairo_rectangle (cr, x0, y0, x1 - x0, yc - y0);
2145   cairo_rectangle (cr, x0, yc, xc - x0, hc);
2146   cairo_rectangle (cr, xc + wc, yc, x1 - (xc + wc), hc);
2147   cairo_rectangle (cr, x0, yc + hc, x1 - x0, y1 - (yc + hc));
2148   cairo_clip (cr);
2149
2150   render_frame_internal (engine, cr,
2151                          x, y, width, height,
2152                          0, junction);
2153
2154   cairo_restore (cr);
2155 }
2156
2157 static void
2158 gtk_theming_engine_render_extension (GtkThemingEngine *engine,
2159                                      cairo_t          *cr,
2160                                      gdouble           x,
2161                                      gdouble           y,
2162                                      gdouble           width,
2163                                      gdouble           height,
2164                                      GtkPositionType   gap_side)
2165 {
2166   GtkThemingBackground bg;
2167   GtkJunctionSides junction = 0;
2168   guint hidden_side = 0;
2169
2170   switch (gap_side)
2171     {
2172     case GTK_POS_LEFT:
2173       junction = GTK_JUNCTION_LEFT;
2174       hidden_side = (1 << GTK_CSS_LEFT);
2175       break;
2176     case GTK_POS_RIGHT:
2177       junction = GTK_JUNCTION_RIGHT;
2178       hidden_side = (1 << GTK_CSS_RIGHT);
2179       break;
2180     case GTK_POS_TOP:
2181       junction = GTK_JUNCTION_TOP;
2182       hidden_side = (1 << GTK_CSS_TOP);
2183       break;
2184     case GTK_POS_BOTTOM:
2185       junction = GTK_JUNCTION_BOTTOM;
2186       hidden_side = (1 << GTK_CSS_BOTTOM);
2187       break;
2188     }
2189
2190   _gtk_theming_background_init (&bg, engine,
2191                                 x, y,
2192                                 width, height,
2193                                 junction);
2194   _gtk_theming_background_render (&bg, cr);
2195
2196   render_frame_internal (engine, cr,
2197                          x, y, width, height,
2198                          hidden_side, junction);
2199 }
2200
2201 static void
2202 render_dot (cairo_t       *cr,
2203             const GdkRGBA *lighter,
2204             const GdkRGBA *darker,
2205             gdouble        x,
2206             gdouble        y,
2207             gdouble        size)
2208 {
2209   size = CLAMP ((gint) size, 2, 3);
2210
2211   if (size == 2)
2212     {
2213       gdk_cairo_set_source_rgba (cr, lighter);
2214       cairo_rectangle (cr, x, y, 1, 1);
2215       cairo_rectangle (cr, x + 1, y + 1, 1, 1);
2216       cairo_fill (cr);
2217     }
2218   else if (size == 3)
2219     {
2220       gdk_cairo_set_source_rgba (cr, lighter);
2221       cairo_rectangle (cr, x, y, 2, 1);
2222       cairo_rectangle (cr, x, y, 1, 2);
2223       cairo_fill (cr);
2224
2225       gdk_cairo_set_source_rgba (cr, darker);
2226       cairo_rectangle (cr, x + 1, y + 1, 2, 1);
2227       cairo_rectangle (cr, x + 2, y, 1, 2);
2228       cairo_fill (cr);
2229     }
2230 }
2231
2232 static void
2233 gtk_theming_engine_render_handle (GtkThemingEngine *engine,
2234                                   cairo_t          *cr,
2235                                   gdouble           x,
2236                                   gdouble           y,
2237                                   gdouble           width,
2238                                   gdouble           height)
2239 {
2240   GtkStateFlags flags;
2241   GdkRGBA bg_color, lighter, darker;
2242   GtkJunctionSides sides;
2243   GtkThemingBackground bg;
2244   gint xx, yy;
2245   gboolean has_image;
2246
2247   cairo_save (cr);
2248   flags = gtk_theming_engine_get_state (engine);
2249
2250   cairo_set_line_width (cr, 1.0);
2251   sides = gtk_theming_engine_get_junction_sides (engine);
2252   gtk_theming_engine_get_background_color (engine, flags, &bg_color);
2253
2254   color_shade (&bg_color, 0.7, &darker);
2255   color_shade (&bg_color, 1.3, &lighter);
2256
2257   _gtk_theming_background_init (&bg, engine, x, y, width, height, sides);
2258   has_image = _gtk_theming_background_has_background_image (&bg);
2259   _gtk_theming_background_render (&bg, cr);
2260
2261   gtk_theming_engine_render_frame (engine, cr, x, y, width, height);
2262
2263   if (gtk_theming_engine_has_class (engine, GTK_STYLE_CLASS_GRIP))
2264     {
2265       /* reduce confusing values to a meaningful state */
2266       if ((sides & (GTK_JUNCTION_CORNER_TOPLEFT | GTK_JUNCTION_CORNER_BOTTOMRIGHT)) == (GTK_JUNCTION_CORNER_TOPLEFT | GTK_JUNCTION_CORNER_BOTTOMRIGHT))
2267         sides &= ~GTK_JUNCTION_CORNER_TOPLEFT;
2268
2269       if ((sides & (GTK_JUNCTION_CORNER_TOPRIGHT | GTK_JUNCTION_CORNER_BOTTOMLEFT)) == (GTK_JUNCTION_CORNER_TOPRIGHT | GTK_JUNCTION_CORNER_BOTTOMLEFT))
2270         sides &= ~GTK_JUNCTION_CORNER_TOPRIGHT;
2271
2272       if (sides == 0)
2273         sides = GTK_JUNCTION_CORNER_BOTTOMRIGHT;
2274
2275       /* align drawing area to the connected side */
2276       if (sides == GTK_JUNCTION_LEFT)
2277         {
2278           if (height < width)
2279             width = height;
2280         }
2281       else if (sides == GTK_JUNCTION_CORNER_TOPLEFT)
2282         {
2283           if (width < height)
2284             height = width;
2285           else if (height < width)
2286             width = height;
2287         }
2288       else if (sides == GTK_JUNCTION_CORNER_BOTTOMLEFT)
2289         {
2290           /* make it square, aligning to bottom left */
2291           if (width < height)
2292             {
2293               y += (height - width);
2294               height = width;
2295             }
2296           else if (height < width)
2297             width = height;
2298         }
2299       else if (sides == GTK_JUNCTION_RIGHT)
2300         {
2301           /* aligning to right */
2302           if (height < width)
2303             {
2304               x += (width - height);
2305               width = height;
2306             }
2307         }
2308       else if (sides == GTK_JUNCTION_CORNER_TOPRIGHT)
2309         {
2310           if (width < height)
2311             height = width;
2312           else if (height < width)
2313             {
2314               x += (width - height);
2315               width = height;
2316             }
2317         }
2318       else if (sides == GTK_JUNCTION_CORNER_BOTTOMRIGHT)
2319         {
2320           /* make it square, aligning to bottom right */
2321           if (width < height)
2322             {
2323               y += (height - width);
2324               height = width;
2325             }
2326           else if (height < width)
2327             {
2328               x += (width - height);
2329               width = height;
2330             }
2331         }
2332       else if (sides == GTK_JUNCTION_TOP)
2333         {
2334           if (width < height)
2335             height = width;
2336         }
2337       else if (sides == GTK_JUNCTION_BOTTOM)
2338         {
2339           /* align to bottom */
2340           if (width < height)
2341             {
2342               y += (height - width);
2343               height = width;
2344             }
2345         }
2346       else
2347         g_assert_not_reached ();
2348
2349       if (sides == GTK_JUNCTION_LEFT ||
2350           sides == GTK_JUNCTION_RIGHT)
2351         {
2352           gint xi;
2353
2354           xi = x;
2355
2356           while (xi < x + width)
2357             {
2358               gdk_cairo_set_source_rgba (cr, &lighter);
2359               add_path_line (cr, x, y, x, y + height);
2360               cairo_stroke (cr);
2361               xi++;
2362
2363               gdk_cairo_set_source_rgba (cr, &darker);
2364               add_path_line (cr, xi, y, xi, y + height);
2365               cairo_stroke (cr);
2366               xi += 2;
2367             }
2368         }
2369       else if (sides == GTK_JUNCTION_TOP ||
2370                sides == GTK_JUNCTION_BOTTOM)
2371         {
2372           gint yi;
2373
2374           yi = y;
2375
2376           while (yi < y + height)
2377             {
2378               gdk_cairo_set_source_rgba (cr, &lighter);
2379               add_path_line (cr, x, yi, x + width, yi);
2380               cairo_stroke (cr);
2381               yi++;
2382
2383               gdk_cairo_set_source_rgba (cr, &darker);
2384               add_path_line (cr, x, yi, x + width, yi);
2385               cairo_stroke (cr);
2386               yi += 2;
2387             }
2388         }
2389       else if (sides == GTK_JUNCTION_CORNER_TOPLEFT)
2390         {
2391           gint xi, yi;
2392
2393           xi = x + width;
2394           yi = y + height;
2395
2396           while (xi > x + 3)
2397             {
2398               gdk_cairo_set_source_rgba (cr, &darker);
2399               add_path_line (cr, xi, y, x, yi);
2400               cairo_stroke (cr);
2401
2402               --xi;
2403               --yi;
2404
2405               add_path_line (cr, xi, y, x, yi);
2406               cairo_stroke (cr);
2407
2408               --xi;
2409               --yi;
2410
2411               gdk_cairo_set_source_rgba (cr, &lighter);
2412               add_path_line (cr, xi, y, x, yi);
2413               cairo_stroke (cr);
2414
2415               xi -= 3;
2416               yi -= 3;
2417             }
2418         }
2419       else if (sides == GTK_JUNCTION_CORNER_TOPRIGHT)
2420         {
2421           gint xi, yi;
2422
2423           xi = x;
2424           yi = y + height;
2425
2426           while (xi < (x + width - 3))
2427             {
2428               gdk_cairo_set_source_rgba (cr, &lighter);
2429               add_path_line (cr, xi, y, x + width, yi);
2430               cairo_stroke (cr);
2431
2432               ++xi;
2433               --yi;
2434
2435               gdk_cairo_set_source_rgba (cr, &darker);
2436               add_path_line (cr, xi, y, x + width, yi);
2437               cairo_stroke (cr);
2438
2439               ++xi;
2440               --yi;
2441
2442               add_path_line (cr, xi, y, x + width, yi);
2443               cairo_stroke (cr);
2444
2445               xi += 3;
2446               yi -= 3;
2447             }
2448         }
2449       else if (sides == GTK_JUNCTION_CORNER_BOTTOMLEFT)
2450         {
2451           gint xi, yi;
2452
2453           xi = x + width;
2454           yi = y;
2455
2456           while (xi > x + 3)
2457             {
2458               gdk_cairo_set_source_rgba (cr, &darker);
2459               add_path_line (cr, x, yi, xi, y + height);
2460               cairo_stroke (cr);
2461
2462               --xi;
2463               ++yi;
2464
2465               add_path_line (cr, x, yi, xi, y + height);
2466               cairo_stroke (cr);
2467
2468               --xi;
2469               ++yi;
2470
2471               gdk_cairo_set_source_rgba (cr, &lighter);
2472               add_path_line (cr, x, yi, xi, y + height);
2473               cairo_stroke (cr);
2474
2475               xi -= 3;
2476               yi += 3;
2477             }
2478         }
2479       else if (sides == GTK_JUNCTION_CORNER_BOTTOMRIGHT)
2480         {
2481           gint xi, yi;
2482
2483           xi = x;
2484           yi = y;
2485
2486           while (xi < (x + width - 3))
2487             {
2488               gdk_cairo_set_source_rgba (cr, &lighter);
2489               add_path_line (cr, xi, y + height, x + width, yi);
2490               cairo_stroke (cr);
2491
2492               ++xi;
2493               ++yi;
2494
2495               gdk_cairo_set_source_rgba (cr, &darker);
2496               add_path_line (cr, xi, y + height, x + width, yi);
2497               cairo_stroke (cr);
2498
2499               ++xi;
2500               ++yi;
2501
2502               add_path_line (cr, xi, y + height, x + width, yi);
2503               cairo_stroke (cr);
2504
2505               xi += 3;
2506               yi += 3;
2507             }
2508         }
2509     }
2510   else if (gtk_theming_engine_has_class (engine, GTK_STYLE_CLASS_PANE_SEPARATOR))
2511     {
2512       if (!has_image)
2513         {
2514           if (width > height)
2515             for (xx = x + width / 2 - 15; xx <= x + width / 2 + 15; xx += 5)
2516               render_dot (cr, &lighter, &darker, xx, y + height / 2 - 1, 3);
2517           else
2518             for (yy = y + height / 2 - 15; yy <= y + height / 2 + 15; yy += 5)
2519               render_dot (cr, &lighter, &darker, x + width / 2 - 1, yy, 3);
2520         }
2521     }
2522   else
2523     {
2524       for (yy = y; yy < y + height; yy += 3)
2525         for (xx = x; xx < x + width; xx += 6)
2526           {
2527             render_dot (cr, &lighter, &darker, xx, yy, 2);
2528             render_dot (cr, &lighter, &darker, xx + 3, yy + 1, 2);
2529           }
2530     }
2531
2532   cairo_restore (cr);
2533 }
2534
2535 void
2536 _gtk_theming_engine_paint_spinner (cairo_t       *cr,
2537                                    gdouble        radius,
2538                                    gdouble        progress,
2539                                    const GdkRGBA *color)
2540 {
2541   guint num_steps, step;
2542   gdouble half;
2543   gint i;
2544
2545   num_steps = 12;
2546
2547   if (progress >= 0)
2548     step = (guint) (progress * num_steps);
2549   else
2550     step = 0;
2551
2552   cairo_save (cr);
2553
2554   cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
2555   cairo_set_line_width (cr, 2.0);
2556
2557   half = num_steps / 2;
2558
2559   for (i = 0; i < num_steps; i++)
2560     {
2561       gint inset = 0.7 * radius;
2562
2563       /* transparency is a function of time and intial value */
2564       gdouble t = 1.0 - (gdouble) ((i + step) % num_steps) / num_steps;
2565       gdouble xscale = - sin (i * G_PI / half);
2566       gdouble yscale = - cos (i * G_PI / half);
2567
2568       cairo_set_source_rgba (cr,
2569                              color->red,
2570                              color->green,
2571                              color->blue,
2572                              color->alpha * t);
2573
2574       cairo_move_to (cr,
2575                      (radius - inset) * xscale,
2576                      (radius - inset) * yscale);
2577       cairo_line_to (cr,
2578                      radius * xscale,
2579                      radius * yscale);
2580
2581       cairo_stroke (cr);
2582     }
2583
2584   cairo_restore (cr);
2585 }
2586
2587 static void
2588 render_spinner (GtkThemingEngine *engine,
2589                 cairo_t          *cr,
2590                 gdouble           x,
2591                 gdouble           y,
2592                 gdouble           width,
2593                 gdouble           height)
2594 {
2595   GtkStateFlags state;
2596   GdkRGBA color;
2597   gdouble radius;
2598
2599   state = gtk_theming_engine_get_state (engine);
2600   radius = MIN (width / 2, height / 2);
2601
2602   gtk_theming_engine_get_color (engine, state, &color);
2603
2604   cairo_save (cr);
2605   cairo_translate (cr, x + width / 2, y + height / 2);
2606
2607   _gtk_css_shadows_value_paint_spinner (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_ICON_SHADOW),
2608                                         cr,
2609                                         radius,
2610                                         -1);
2611
2612   _gtk_theming_engine_paint_spinner (cr,
2613                                      radius,
2614                                      -1,
2615                                      &color);
2616
2617   cairo_restore (cr);
2618 }
2619
2620 static void
2621 gtk_theming_engine_render_activity (GtkThemingEngine *engine,
2622                                     cairo_t          *cr,
2623                                     gdouble           x,
2624                                     gdouble           y,
2625                                     gdouble           width,
2626                                     gdouble           height)
2627 {
2628   GtkThemingBackground bg;
2629
2630   _gtk_theming_background_init (&bg, engine, x, y, width, height, 0);
2631
2632   if (gtk_theming_engine_has_class (engine, GTK_STYLE_CLASS_SPINNER) &&
2633       !_gtk_theming_background_has_background_image (&bg))
2634     {
2635       render_spinner (engine, cr, x, y, width, height);
2636     }
2637   else
2638     {
2639       _gtk_theming_background_render (&bg, cr);
2640       gtk_theming_engine_render_frame (engine, cr, x, y, width, height);
2641     }
2642 }
2643
2644 static GdkPixbuf *
2645 scale_or_ref (GdkPixbuf *src,
2646               gint       width,
2647               gint       height)
2648 {
2649   if (width == gdk_pixbuf_get_width (src) &&
2650       height == gdk_pixbuf_get_height (src))
2651     return g_object_ref (src);
2652   else
2653     return gdk_pixbuf_scale_simple (src,
2654                                     width, height,
2655                                     GDK_INTERP_BILINEAR);
2656 }
2657
2658 static gboolean
2659 lookup_icon_size (GtkThemingEngine *engine,
2660                   GtkIconSize       size,
2661                   gint             *width,
2662                   gint             *height)
2663 {
2664   GdkScreen *screen;
2665   GtkSettings *settings;
2666
2667   screen = gtk_theming_engine_get_screen (engine);
2668   settings = gtk_settings_get_for_screen (screen);
2669
2670   return gtk_icon_size_lookup_for_settings (settings, size, width, height);
2671 }
2672
2673 static void
2674 colorshift_source (cairo_t *cr,
2675                    gdouble shift)
2676 {
2677   cairo_pattern_t *source;
2678
2679   cairo_save (cr);
2680   cairo_paint (cr);
2681
2682   source = cairo_pattern_reference (cairo_get_source (cr));
2683
2684   cairo_set_source_rgb (cr, shift, shift, shift);
2685   cairo_set_operator (cr, CAIRO_OPERATOR_COLOR_DODGE);
2686
2687   cairo_mask (cr, source);
2688
2689   cairo_pattern_destroy (source);
2690   cairo_restore (cr);
2691 }
2692
2693 static GdkPixbuf *
2694 gtk_theming_engine_render_icon_pixbuf (GtkThemingEngine    *engine,
2695                                        const GtkIconSource *source,
2696                                        GtkIconSize          size)
2697 {
2698   GdkPixbuf *scaled;
2699   GdkPixbuf *stated;
2700   GdkPixbuf *base_pixbuf;
2701   GtkStateFlags state;
2702   gint width = 1;
2703   gint height = 1;
2704   cairo_t *cr;
2705   cairo_surface_t *surface;
2706
2707   base_pixbuf = gtk_icon_source_get_pixbuf (source);
2708   state = gtk_theming_engine_get_state (engine);
2709
2710   g_return_val_if_fail (base_pixbuf != NULL, NULL);
2711
2712   if (size != (GtkIconSize) -1 &&
2713       !lookup_icon_size (engine, size, &width, &height))
2714     {
2715       g_warning (G_STRLOC ": invalid icon size '%d'", size);
2716       return NULL;
2717     }
2718
2719   /* If the size was wildcarded, and we're allowed to scale, then scale; otherwise,
2720    * leave it alone.
2721    */
2722   if (size != (GtkIconSize) -1 &&
2723       gtk_icon_source_get_size_wildcarded (source))
2724     scaled = scale_or_ref (base_pixbuf, width, height);
2725   else
2726     scaled = g_object_ref (base_pixbuf);
2727
2728   /* If the state was wildcarded, then generate a state. */
2729   if (gtk_icon_source_get_state_wildcarded (source))
2730     {
2731       if (state & GTK_STATE_FLAG_INSENSITIVE)
2732         {
2733           surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
2734                                                 gdk_pixbuf_get_width (scaled),
2735                                                 gdk_pixbuf_get_height (scaled));
2736           cr = cairo_create (surface);
2737           gdk_cairo_set_source_pixbuf (cr, scaled, 0, 0);
2738           cairo_paint_with_alpha (cr, 0.5);
2739
2740           cairo_destroy (cr);
2741
2742           g_object_unref (scaled);
2743           stated = gdk_pixbuf_get_from_surface (surface, 0, 0,
2744                                                 cairo_image_surface_get_width (surface),
2745                                                 cairo_image_surface_get_height (surface));
2746           cairo_surface_destroy (surface);
2747         }
2748       else if (state & GTK_STATE_FLAG_PRELIGHT)
2749         {
2750           surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
2751                                                 gdk_pixbuf_get_width (scaled),
2752                                                 gdk_pixbuf_get_height (scaled));
2753
2754           cr = cairo_create (surface);
2755           gdk_cairo_set_source_pixbuf (cr, scaled, 0, 0);
2756           colorshift_source (cr, 0.10);
2757
2758           cairo_destroy (cr);
2759
2760           g_object_unref (scaled);
2761           stated = gdk_pixbuf_get_from_surface (surface, 0, 0,
2762                                                 cairo_image_surface_get_width (surface),
2763                                                 cairo_image_surface_get_height (surface));
2764           cairo_surface_destroy (surface);
2765         }
2766       else
2767         stated = scaled;
2768     }
2769   else
2770     stated = scaled;
2771
2772   return stated;
2773 }
2774
2775 static void
2776 gtk_theming_engine_render_icon (GtkThemingEngine *engine,
2777                                 cairo_t *cr,
2778                                 GdkPixbuf *pixbuf,
2779                                 gdouble x,
2780                                 gdouble y)
2781 {
2782   cairo_save (cr);
2783
2784   gdk_cairo_set_source_pixbuf (cr, pixbuf, x, y);
2785
2786   _gtk_css_shadows_value_paint_icon (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_ICON_SHADOW), cr);
2787
2788   cairo_paint (cr);
2789
2790   cairo_restore (cr);
2791 }
2792