AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
21761ce5fc
gtk2/gtk/gtkthemingengine.c

3179 lines
96 KiB
C
Raw Normal View History

Add GtkThemingEngine. GtkThemingEngine will be the theming engines base class, with default implementations for all paint functions, and readonly access to the related GtkStyleContext data.
2010-03-13 10:23:23 +00:00
/* GTK - The GIMP Toolkit
* Copyright (C) 2010 Carlos Garnacho <carlosg@gnome.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include "config.h"
GtkThemingEngine: Unify code to render lines.
2010-07-19 09:54:31 +00:00
#include <math.h>
Add GtkThemingEngine. GtkThemingEngine will be the theming engines base class, with default implementations for all paint functions, and readonly access to the related GtkStyleContext data.
2010-03-13 10:23:23 +00:00
#include <gtk/gtk.h>
#include <gtk/gtkthemingengine.h>
#include <gtk/gtkstylecontext.h>
#include <gtk/gtkintl.h>
GtkThemingEngine: Add ::name construct only property This property is to be set by theming engines, the name set will be favored over the object type name when registering custom properties, making possible something like: -Clearlooks-border: blah;
2010-10-25 22:43:20 +00:00
#include "gtkprivate.h"
GtkThemingEngine: Use border-image to render borders if an image is available.
2010-09-24 20:08:49 +00:00
#include "gtk9slice.h"
Get rid of GdkPangoRenderer code in GtkThemingEngine.
2010-08-20 12:58:54 +00:00
#include "gtkpango.h"
Add theming docs Both API and file format is documented, there's still missing a migration doc though.
2010-10-19 08:59:46 +00:00
/**
* SECTION:gtkthemingengine
* @Short_description: Theming renderers
* @Title: GtkThemingEngine
* @See_also: #GtkStyleContext
*
* #GtkThemingEngine is the object used for rendering themed content
* in GTK+ widgets. Even though GTK+ has a default implementation,
* it can be overridden in CSS files by enforcing a #GtkThemingEngine
* object to be loaded as a module.
*
* In order to implement a theming engine, a #GtkThemingEngine subclass
* must be created, alongside the CSS file that will reference it, the
* theming engine would be created as an .so library, and installed in
* $(gtk-modules-dir)/theming-engines/.
GtkThemingEngine: Documents that engines must only use this API. It was a bit unclear in the documentation, even if it was from the API POV.
2010-10-29 18:17:03 +00:00
*
* #GtkThemingEngine<!-- -->s have limited access to the object they are
* rendering, the #GtkThemingEngine API has read-only accessors to the
* style information contained in the rendered object's #GtkStyleContext.
Add theming docs Both API and file format is documented, there's still missing a migration doc though.
2010-10-19 08:59:46 +00:00
*/
Add GtkThemingEngine. GtkThemingEngine will be the theming engines base class, with default implementations for all paint functions, and readonly access to the related GtkStyleContext data.
2010-03-13 10:23:23 +00:00
typedef struct GtkThemingEnginePrivate GtkThemingEnginePrivate;
GtkThemingEngine: Add vmethod to render backgrounds.
2010-03-27 19:06:44 +00:00
enum {
SIDE_LEFT = 1,
SIDE_BOTTOM = 1 << 1,
SIDE_RIGHT = 1 << 2,
GtkStyleSet: Register the border-style and border-color properties This is also implemented in the theming engine, although the default CSS should be using it in order to theme buttons, troughs, sliders and such.
2010-10-22 08:38:21 +00:00
SIDE_TOP = 1 << 3,
SIDE_ALL = 0xF
GtkThemingEngine: Add vmethod to render backgrounds.
2010-03-27 19:06:44 +00:00
};
GtkThemingEngine: Add ::name construct only property This property is to be set by theming engines, the name set will be favored over the object type name when registering custom properties, making possible something like: -Clearlooks-border: blah;
2010-10-25 22:43:20 +00:00
enum {
PROP_0,
PROP_NAME
};
Add GtkThemingEngine. GtkThemingEngine will be the theming engines base class, with default implementations for all paint functions, and readonly access to the related GtkStyleContext data.
2010-03-13 10:23:23 +00:00
struct GtkThemingEnginePrivate
{
GtkStyleContext *context;
GtkThemingEngine: Add ::name construct only property This property is to be set by theming engines, the name set will be favored over the object type name when registering custom properties, making possible something like: -Clearlooks-border: blah;
2010-10-25 22:43:20 +00:00
gchar *name;
Add GtkThemingEngine. GtkThemingEngine will be the theming engines base class, with default implementations for all paint functions, and readonly access to the related GtkStyleContext data.
2010-03-13 10:23:23 +00:00
};
#define GTK_THEMING_ENGINE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GTK_TYPE_THEMING_ENGINE, GtkThemingEnginePrivate))
GtkThemingEngine: Add ::name construct only property This property is to be set by theming engines, the name set will be favored over the object type name when registering custom properties, making possible something like: -Clearlooks-border: blah;
2010-10-25 22:43:20 +00:00
static void gtk_theming_engine_finalize (GObject *object);
static void gtk_theming_engine_impl_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec);
static void gtk_theming_engine_impl_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec);
GtkThemingEngine: Add vmethod to render checkboxes.
2010-03-20 13:17:40 +00:00
static void gtk_theming_engine_render_check (GtkThemingEngine *engine,
cairo_t *cr,
gdouble x,
gdouble y,
gdouble width,
gdouble height);
GtkThemingEngine: Add vmethod to render radio buttons.
2010-03-20 16:37:34 +00:00
static void gtk_theming_engine_render_option (GtkThemingEngine *engine,
cairo_t *cr,
gdouble x,
gdouble y,
gdouble width,
gdouble height);
GtkThemingEngine: Add vmethod to render arrows.
2010-03-27 17:50:39 +00:00
static void gtk_theming_engine_render_arrow (GtkThemingEngine *engine,
cairo_t *cr,
gdouble angle,
gdouble x,
gdouble y,
gdouble size);
GtkThemingEngine: Add vmethod to render backgrounds.
2010-03-27 19:06:44 +00:00
static void gtk_theming_engine_render_background (GtkThemingEngine *engine,
cairo_t *cr,
gdouble x,
gdouble y,
gdouble width,
gdouble height);
GtkThemingEngine: Add vmethod to render frames.
2010-03-27 19:11:31 +00:00
static void gtk_theming_engine_render_frame (GtkThemingEngine *engine,
cairo_t *cr,
gdouble x,
gdouble y,
gdouble width,
gdouble height);
GtkThemingEngine: Add vmethod to render expanders.
2010-03-27 19:15:45 +00:00
static void gtk_theming_engine_render_expander (GtkThemingEngine *engine,
cairo_t *cr,
gdouble x,
gdouble y,
gdouble width,
gdouble height);
GtkThemingEngine: Add vmethod to render focus indicator.
2010-03-27 19:18:38 +00:00
static void gtk_theming_engine_render_focus (GtkThemingEngine *engine,
cairo_t *cr,
gdouble x,
gdouble y,
gdouble width,
gdouble height);
GtkThemingEngine: Add vmethod to render layouts.
2010-03-27 19:21:55 +00:00
static void gtk_theming_engine_render_layout (GtkThemingEngine *engine,
cairo_t *cr,
gdouble x,
gdouble y,
PangoLayout *layout);
GtkThemingEngine: Add vmethod to render lines.
2010-03-27 20:17:22 +00:00
static void gtk_theming_engine_render_line (GtkThemingEngine *engine,
cairo_t *cr,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1);
GtkThemingEngine: Add vmethod to render sliders.
2010-03-27 20:20:21 +00:00
static void gtk_theming_engine_render_slider (GtkThemingEngine *engine,
cairo_t *cr,
gdouble x,
gdouble y,
gdouble width,
gdouble height,
GtkOrientation orientation);
GtkThemingEngine: Add vmethod to render frames with a gap.
2010-03-27 20:23:13 +00:00
static void gtk_theming_engine_render_frame_gap (GtkThemingEngine *engine,
cairo_t *cr,
gdouble x,
gdouble y,
gdouble width,
gdouble height,
GtkPositionType gap_side,
gdouble xy0_gap,
gdouble xy1_gap);
GtkThemingEngine: Add vmethod to render an extension.
2010-03-27 20:25:33 +00:00
static void gtk_theming_engine_render_extension (GtkThemingEngine *engine,
cairo_t *cr,
gdouble x,
gdouble y,
gdouble width,
gdouble height,
GtkPositionType gap_side);
GtkThemingEngine: Add vmethod to render a handle area.
2010-03-27 20:27:52 +00:00
static void gtk_theming_engine_render_handle (GtkThemingEngine *engine,
cairo_t *cr,
gdouble x,
gdouble y,
gdouble width,
Remove GtkOrientation parameter from gtk_render_handle(). The case for paned can be guessed out from the height and width, for handlebox the orientation parameter doesn't make much sense, and this way it could also be used for resize grips.
2010-10-12 22:52:50 +00:00
gdouble height);
Add gtk_render_activity() This method will render progress bars and spinners, these should handle active and inconsistent states' animation progress in order to perform animations.
2010-11-01 01:46:35 +00:00
static void gtk_theming_engine_render_activity (GtkThemingEngine *engine,
cairo_t *cr,
gdouble x,
gdouble y,
gdouble width,
gdouble height);
GtkStyleContext: Add gtk_render_icon_pixbuf() This function is similar to gtk_style_render_icon(), which is now implemented on top of this one.
2010-11-03 20:14:08 +00:00
static GdkPixbuf * gtk_theming_engine_render_icon_pixbuf (GtkThemingEngine *engine,
const GtkIconSource *source,
GtkIconSize size);
GtkThemingEngine: Add vmethod to render checkboxes.
2010-03-20 13:17:40 +00:00
Add GtkThemingEngine. GtkThemingEngine will be the theming engines base class, with default implementations for all paint functions, and readonly access to the related GtkStyleContext data.
2010-03-13 10:23:23 +00:00
G_DEFINE_TYPE (GtkThemingEngine, gtk_theming_engine, G_TYPE_OBJECT)
GtkThemingEngine: Add module loading capabilities.
2010-03-13 17:35:35 +00:00
typedef struct GtkThemingModule GtkThemingModule;
typedef struct GtkThemingModuleClass GtkThemingModuleClass;
struct GtkThemingModule
{
GTypeModule parent_instance;
Make loading of theming engines from modules work
2010-10-20 11:26:27 +00:00
GModule *module;
GtkThemingEngine: Add module loading capabilities.
2010-03-13 17:35:35 +00:00
gchar *name;
Make loading of theming engines from modules work
2010-10-20 11:26:27 +00:00
void (*init) (GTypeModule *module);
void (*exit) (void);
GtkThemingEngine: Add module loading capabilities.
2010-03-13 17:35:35 +00:00
GtkThemingEngine * (*create_engine) (void);
};
struct GtkThemingModuleClass
{
GTypeModuleClass parent_class;
};
#define GTK_TYPE_THEMING_MODULE (gtk_theming_module_get_type ())
#define GTK_THEMING_MODULE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_THEMING_MODULE, GtkThemingModule))
#define GTK_IS_THEMING_MODULE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_THEMING_MODULE))
G_DEFINE_TYPE (GtkThemingModule, gtk_theming_module, G_TYPE_TYPE_MODULE);
Add GtkThemingEngine. GtkThemingEngine will be the theming engines base class, with default implementations for all paint functions, and readonly access to the related GtkStyleContext data.
2010-03-13 10:23:23 +00:00
static void
gtk_theming_engine_class_init (GtkThemingEngineClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GtkThemingEngine: Add ::name construct only property This property is to be set by theming engines, the name set will be favored over the object type name when registering custom properties, making possible something like: -Clearlooks-border: blah;
2010-10-25 22:43:20 +00:00
object_class->finalize = gtk_theming_engine_finalize;
object_class->set_property = gtk_theming_engine_impl_set_property;
object_class->get_property = gtk_theming_engine_impl_get_property;
GtkThemingEngine: Add vmethod to render checkboxes.
2010-03-20 13:17:40 +00:00
klass->render_check = gtk_theming_engine_render_check;
GtkThemingEngine: Add vmethod to render radio buttons.
2010-03-20 16:37:34 +00:00
klass->render_option = gtk_theming_engine_render_option;
GtkThemingEngine: Add vmethod to render arrows.
2010-03-27 17:50:39 +00:00
klass->render_arrow = gtk_theming_engine_render_arrow;
GtkThemingEngine: Add vmethod to render backgrounds.
2010-03-27 19:06:44 +00:00
klass->render_background = gtk_theming_engine_render_background;
GtkThemingEngine: Add vmethod to render frames.
2010-03-27 19:11:31 +00:00
klass->render_frame = gtk_theming_engine_render_frame;
GtkThemingEngine: Add vmethod to render expanders.
2010-03-27 19:15:45 +00:00
klass->render_expander = gtk_theming_engine_render_expander;
GtkThemingEngine: Add vmethod to render focus indicator.
2010-03-27 19:18:38 +00:00
klass->render_focus = gtk_theming_engine_render_focus;
GtkThemingEngine: Add vmethod to render layouts.
2010-03-27 19:21:55 +00:00
klass->render_layout = gtk_theming_engine_render_layout;
GtkThemingEngine: Add vmethod to render lines.
2010-03-27 20:17:22 +00:00
klass->render_line = gtk_theming_engine_render_line;
GtkThemingEngine: Add vmethod to render sliders.
2010-03-27 20:20:21 +00:00
klass->render_slider = gtk_theming_engine_render_slider;
GtkThemingEngine: Add vmethod to render frames with a gap.
2010-03-27 20:23:13 +00:00
klass->render_frame_gap = gtk_theming_engine_render_frame_gap;
GtkThemingEngine: Add vmethod to render an extension.
2010-03-27 20:25:33 +00:00
klass->render_extension = gtk_theming_engine_render_extension;
GtkThemingEngine: Add vmethod to render a handle area.
2010-03-27 20:27:52 +00:00
klass->render_handle = gtk_theming_engine_render_handle;
Add gtk_render_activity() This method will render progress bars and spinners, these should handle active and inconsistent states' animation progress in order to perform animations.
2010-11-01 01:46:35 +00:00
klass->render_activity = gtk_theming_engine_render_activity;
GtkStyleContext: Add gtk_render_icon_pixbuf() This function is similar to gtk_style_render_icon(), which is now implemented on top of this one.
2010-11-03 20:14:08 +00:00
klass->render_icon_pixbuf = gtk_theming_engine_render_icon_pixbuf;
GtkThemingEngine: Add vmethod to render checkboxes.
2010-03-20 13:17:40 +00:00
GtkThemingEngine: Add ::name construct only property This property is to be set by theming engines, the name set will be favored over the object type name when registering custom properties, making possible something like: -Clearlooks-border: blah;
2010-10-25 22:43:20 +00:00
/**
* GtkThemingEngine:name:
*
* The theming engine name, this name will be used when registering
* custom properties, for a theming engine named "Clearlooks" registering
* a "glossy" custom property, it could be referenced in the CSS file as
*
* <programlisting>
* -Clearlooks-glossy: true;
* </programlisting>
*
* Since: 3.0
*/
g_object_class_install_property (object_class,
PROP_NAME,
g_param_spec_string ("name",
P_("Name"),
P_("Theming engine name"),
NULL,
G_PARAM_CONSTRUCT_ONLY | GTK_PARAM_READWRITE));
Add GtkThemingEngine. GtkThemingEngine will be the theming engines base class, with default implementations for all paint functions, and readonly access to the related GtkStyleContext data.
2010-03-13 10:23:23 +00:00
g_type_class_add_private (object_class, sizeof (GtkThemingEnginePrivate));
}
static void
gtk_theming_engine_init (GtkThemingEngine *engine)
{
engine->priv = GTK_THEMING_ENGINE_GET_PRIVATE (engine);
}
GtkThemingEngine: Add ::name construct only property This property is to be set by theming engines, the name set will be favored over the object type name when registering custom properties, making possible something like: -Clearlooks-border: blah;
2010-10-25 22:43:20 +00:00
static void
gtk_theming_engine_finalize (GObject *object)
{
GtkThemingEnginePrivate *priv;
priv = GTK_THEMING_ENGINE (object)->priv;
g_free (priv->name);
G_OBJECT_GET_CLASS (gtk_theming_engine_parent_class)->finalize (object);
}
static void
gtk_theming_engine_impl_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkThemingEnginePrivate *priv;
priv = GTK_THEMING_ENGINE (object)->priv;
switch (prop_id)
{
case PROP_NAME:
if (priv->name)
g_free (priv->name);
priv->name = g_value_dup_string (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gtk_theming_engine_impl_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GtkThemingEnginePrivate *priv;
priv = GTK_THEMING_ENGINE (object)->priv;
switch (prop_id)
{
case PROP_NAME:
g_value_set_string (value, priv->name);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
Add GtkThemingEngine. GtkThemingEngine will be the theming engines base class, with default implementations for all paint functions, and readonly access to the related GtkStyleContext data.
2010-03-13 10:23:23 +00:00
void
_gtk_theming_engine_set_context (GtkThemingEngine *engine,
GtkStyleContext *context)
{
GtkThemingEnginePrivate *priv;
g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
g_return_if_fail (GTK_IS_STYLE_CONTEXT (context));
priv = engine->priv;
priv->context = context;
}
Add theming docs Both API and file format is documented, there's still missing a migration doc though.
2010-10-19 08:59:46 +00:00
/**
[GI] Mark unintrospectable constructs as (skip) Also adds 'Rename to:' annotation to some constructs replacing the skipped ones.
2011-01-18 05:37:11 +00:00
* gtk_theming_engine_register_property: (skip)
GtkThemingEngine: Do not use possible reserved word.
2010-11-14 18:47:09 +00:00
* @name_space: namespace for the property name
Add theming docs Both API and file format is documented, there's still missing a migration doc though.
2010-10-19 08:59:46 +00:00
* @parse_func: parsing function to use, or %NULL
GtkStyleProperties: Use GParamSpec for properties registration.
2010-11-13 18:53:36 +00:00
* @pspec: the #GParamSpec for the new property
Add theming docs Both API and file format is documented, there's still missing a migration doc though.
2010-10-19 08:59:46 +00:00
*
* Registers a property so it can be used in the CSS file format,
* on the CSS file the property will look like
GtkThemingEngine: Do not use possible reserved word.
2010-11-14 18:47:09 +00:00
* "-${@name_space}-${property_name}". being
* ${property_name} the given to @pspec. @name_space will usually
GtkStyleProperties: Use GParamSpec for properties registration.
2010-11-13 18:53:36 +00:00
* be the theme engine name.
Add theming docs Both API and file format is documented, there's still missing a migration doc though.
2010-10-19 08:59:46 +00:00
*
* For any type a @parse_func may be provided, being this function
* used for turning any property value (between ':' and ';') in
* CSS to the #GValue needed. For basic types there is already
* builtin parsing support, so %NULL may be provided for these
* cases.
*
* <note>
GtkStyleProperties: Use GParamSpec for properties registration.
2010-11-13 18:53:36 +00:00
* Engines must ensure property registration happens exactly once,
* usually GTK+ deals with theming engines as singletons, so this
* should be guaranteed to happen once, but bear this in mind
* when creating #GtkThemeEngine<!-- -->s yourself.
Add theming docs Both API and file format is documented, there's still missing a migration doc though.
2010-10-19 08:59:46 +00:00
* </note>
*
* <note>
* In order to make use of the custom registered properties in
GtkStyleProperties: Use GParamSpec for properties registration.
2010-11-13 18:53:36 +00:00
* the CSS file, make sure the engine is loaded first by specifying
* the engine property, either in a previous rule or within the same
* one.
Add theming docs Both API and file format is documented, there's still missing a migration doc though.
2010-10-19 08:59:46 +00:00
* <programlisting>
* &ast; {
* engine: someengine;
GtkStyleProperties: Use GParamSpec for properties registration.
2010-11-13 18:53:36 +00:00
* -SomeEngine-custom-property: 2;
Add theming docs Both API and file format is documented, there's still missing a migration doc though.
2010-10-19 08:59:46 +00:00
* }
* </programlisting>
* </note>
*
* Since: 3.0
**/
GtkThemingEngine: Add gtk_theming_engine_register_property(). This function may be used for custom property registration from theming engines. The property names will have the -${engine-type-name}-${prop-name} format, the parser has been modified to allow properties with '-' as the first char.
2010-08-04 15:51:19 +00:00
void
GtkThemingEngine: Do not use possible reserved word.
2010-11-14 18:47:09 +00:00
gtk_theming_engine_register_property (const gchar *name_space,
GtkStyleProperties: Use GParamSpec for properties registration.
2010-11-13 18:53:36 +00:00
GtkStylePropertyParser parse_func,
GParamSpec *pspec)
GtkThemingEngine: Add gtk_theming_engine_register_property(). This function may be used for custom property registration from theming engines. The property names will have the -${engine-type-name}-${prop-name} format, the parser has been modified to allow properties with '-' as the first char.
2010-08-04 15:51:19 +00:00
{
GtkThemingEngine: Use ::name when registering style props.
2010-10-27 21:23:14 +00:00
gchar *name;
GtkThemingEngine: Add gtk_theming_engine_register_property(). This function may be used for custom property registration from theming engines. The property names will have the -${engine-type-name}-${prop-name} format, the parser has been modified to allow properties with '-' as the first char.
2010-08-04 15:51:19 +00:00
GtkThemingEngine: Do not use possible reserved word.
2010-11-14 18:47:09 +00:00
g_return_if_fail (name_space != NULL);
g_return_if_fail (strchr (name_space, ' ') == NULL);
GtkStyleProperties: Use GParamSpec for properties registration.
2010-11-13 18:53:36 +00:00
g_return_if_fail (G_IS_PARAM_SPEC (pspec));
GtkThemingEngine: Add ::name construct only property This property is to be set by theming engines, the name set will be favored over the object type name when registering custom properties, making possible something like: -Clearlooks-border: blah;
2010-10-25 22:43:20 +00:00
GtkStyleProperties: Use GParamSpec for properties registration.
2010-11-13 18:53:36 +00:00
/* FIXME: hack hack hack, replacing pspec->name to include namespace */
GtkThemingEngine: Do not use possible reserved word.
2010-11-14 18:47:09 +00:00
name = g_strdup_printf ("-%s-%s", name_space, pspec->name);
GtkStyleProperties: Use GParamSpec for properties registration.
2010-11-13 18:53:36 +00:00
g_free (pspec->name);
pspec->name = name;
GtkThemingEngine: Add ::name construct only property This property is to be set by theming engines, the name set will be favored over the object type name when registering custom properties, making possible something like: -Clearlooks-border: blah;
2010-10-25 22:43:20 +00:00
GtkStyleProperties: Use GParamSpec for properties registration.
2010-11-13 18:53:36 +00:00
gtk_style_properties_register_property (parse_func, pspec);
GtkThemingEngine: Add gtk_theming_engine_register_property(). This function may be used for custom property registration from theming engines. The property names will have the -${engine-type-name}-${prop-name} format, the parser has been modified to allow properties with '-' as the first char.
2010-08-04 15:51:19 +00:00
}
Add theming docs Both API and file format is documented, there's still missing a migration doc though.
2010-10-19 08:59:46 +00:00
/**
* gtk_theming_engine_get_property:
* @engine: a #GtkThemingEngine
* @property: the property name
* @state: state to retrieve the value for
* @value: (out) (transfer full): return location for the property value,
* you must free this memory using g_value_unset() once you are
* done with it.
*
* Gets a property value as retrieved from the style settings that apply
* to the currently rendered element.
*
* Since: 3.0
**/
Add GtkThemingEngine. GtkThemingEngine will be the theming engines base class, with default implementations for all paint functions, and readonly access to the related GtkStyleContext data.
2010-03-13 10:23:23 +00:00
void
gtk_theming_engine_get_property (GtkThemingEngine *engine,
const gchar *property,
Move all theming stack to use GtkStateFlags. This support goes from the theming engines, which are able to retrieve style for different combined states to the CSS provider, where several state pseudo-classes may be specified, such as: GtkButton:active:prelight {}
2010-08-16 17:09:34 +00:00
GtkStateFlags state,
Add GtkThemingEngine. GtkThemingEngine will be the theming engines base class, with default implementations for all paint functions, and readonly access to the related GtkStyleContext data.
2010-03-13 10:23:23 +00:00
GValue *value)
{
GtkThemingEnginePrivate *priv;
g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
g_return_if_fail (property != NULL);
g_return_if_fail (value != NULL);
priv = engine->priv;
gtk_style_context_get_property (priv->context, property, state, value);
}
Add theming docs Both API and file format is documented, there's still missing a migration doc though.
2010-10-19 08:59:46 +00:00
/**
* gtk_theming_engine_get_valist:
* @engine: a #GtkThemingEngine
* @state: state to retrieve values for
* @args: va_list of property name/return location pairs, followed by %NULL
*
* Retrieves several style property values that apply to the currently
* rendered element.
*
* Since: 3.0
**/
Add GtkThemingEngine. GtkThemingEngine will be the theming engines base class, with default implementations for all paint functions, and readonly access to the related GtkStyleContext data.
2010-03-13 10:23:23 +00:00
void
gtk_theming_engine_get_valist (GtkThemingEngine *engine,
Move all theming stack to use GtkStateFlags. This support goes from the theming engines, which are able to retrieve style for different combined states to the CSS provider, where several state pseudo-classes may be specified, such as: GtkButton:active:prelight {}
2010-08-16 17:09:34 +00:00
GtkStateFlags state,
Add GtkThemingEngine. GtkThemingEngine will be the theming engines base class, with default implementations for all paint functions, and readonly access to the related GtkStyleContext data.
2010-03-13 10:23:23 +00:00
va_list args)
{
GtkThemingEnginePrivate *priv;
g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
priv = engine->priv;
gtk_style_context_get_valist (priv->context, state, args);
}
Add theming docs Both API and file format is documented, there's still missing a migration doc though.
2010-10-19 08:59:46 +00:00
/**
* gtk_theming_engine_get:
* @engine: a #GtkThemingEngine
* @state: state to retrieve values for
* @...: property name /return value pairs, followed by %NULL
*
* Retrieves several style property values that apply to the currently
* rendered element.
*
* Since: 3.0
**/
Add GtkThemingEngine. GtkThemingEngine will be the theming engines base class, with default implementations for all paint functions, and readonly access to the related GtkStyleContext data.
2010-03-13 10:23:23 +00:00
void
gtk_theming_engine_get (GtkThemingEngine *engine,
Move all theming stack to use GtkStateFlags. This support goes from the theming engines, which are able to retrieve style for different combined states to the CSS provider, where several state pseudo-classes may be specified, such as: GtkButton:active:prelight {}
2010-08-16 17:09:34 +00:00
GtkStateFlags state,
Add GtkThemingEngine. GtkThemingEngine will be the theming engines base class, with default implementations for all paint functions, and readonly access to the related GtkStyleContext data.
2010-03-13 10:23:23 +00:00
...)
{
GtkThemingEnginePrivate *priv;
va_list args;
g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
priv = engine->priv;
va_start (args, state);
gtk_style_context_get_valist (priv->context, state, args);
va_end (args);
}
Add theming docs Both API and file format is documented, there's still missing a migration doc though.
2010-10-19 08:59:46 +00:00
/**
* gtk_theming_engine_get_style_property:
* @engine: a #GtkThemingEngine
* @property_name: the name of the widget style property
[GI] Fixes of existing incorrect annotations
2011-01-18 09:14:33 +00:00
* @value: Return location for the property value, free with
Add theming docs Both API and file format is documented, there's still missing a migration doc though.
2010-10-19 08:59:46 +00:00
* g_value_unset() after use.
*
* Gets the value for a widget style property.
*
* Since: 3.0
**/
GtkThemingEngine: Add methods to retrieve widget style properties.
2010-08-02 13:33:20 +00:00
void
gtk_theming_engine_get_style_property (GtkThemingEngine *engine,
const gchar *property_name,
GValue *value)
{
GtkThemingEnginePrivate *priv;
g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
g_return_if_fail (property_name != NULL);
priv = engine->priv;
gtk_style_context_get_style_property (priv->context, property_name, value);
}
Add theming docs Both API and file format is documented, there's still missing a migration doc though.
2010-10-19 08:59:46 +00:00
/**
* gtk_theming_engine_get_style_valist:
* @engine: a #GtkThemingEngine
* @args: va_list of property name/return location pairs, followed by %NULL
*
* Retrieves several widget style properties from @engine according to the
* currently rendered content's style.
*
* Since: 3.0
**/
GtkThemingEngine: Add methods to retrieve widget style properties.
2010-08-02 13:33:20 +00:00
void
gtk_theming_engine_get_style_valist (GtkThemingEngine *engine,
va_list args)
{
GtkThemingEnginePrivate *priv;
g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
priv = engine->priv;
gtk_style_context_get_style_valist (priv->context, args);
}
Add theming docs Both API and file format is documented, there's still missing a migration doc though.
2010-10-19 08:59:46 +00:00
/**
* gtk_theming_engine_get_style:
* @engine: a #GtkThemingEngine
* @...: property name /return value pairs, followed by %NULL
*
* Retrieves several widget style properties from @engine according
* to the currently rendered content's style.
*
* Since: 3.0
**/
GtkThemingEngine: Add methods to retrieve widget style properties.
2010-08-02 13:33:20 +00:00
void
gtk_theming_engine_get_style (GtkThemingEngine *engine,
...)
{
GtkThemingEnginePrivate *priv;
va_list args;
g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
priv = engine->priv;
va_start (args, engine);
gtk_style_context_get_style_valist (priv->context, args);
va_end (args);
}
GtkThemingEngine: Add gtk_theming_engine_lookup_color() It could also be handy for theme engines...
2010-12-01 18:19:26 +00:00
/**
* gtk_theming_engine_lookup_color:
* @engine: a #GtkThemingEngine
* @color_name: color name to lookup
GtkThemingEngine: Fix parameters for gtk_theming_engine_lookup_color()
2010-12-04 14:08:35 +00:00
* @color: (out): Return location for the looked up color
GtkThemingEngine: Add gtk_theming_engine_lookup_color() It could also be handy for theme engines...
2010-12-01 18:19:26 +00:00
*
* Looks up and resolves a color name in the current style's color map.
Revert "docs: Reinstate pixbufs section in GDK docs" I committed my whole working tee instead of just one file. Ooops. This reverts commit ded14b256202d8792629b88874d934638762cee3.
2010-12-09 22:55:33 +00:00
*
* Returns: %TRUE if @color_name was found and resolved, %FALSE otherwise
GtkThemingEngine: Add gtk_theming_engine_lookup_color() It could also be handy for theme engines...
2010-12-01 18:19:26 +00:00
**/
Revert "docs: Reinstate pixbufs section in GDK docs" I committed my whole working tee instead of just one file. Ooops. This reverts commit ded14b256202d8792629b88874d934638762cee3.
2010-12-09 22:55:33 +00:00
gboolean
GtkThemingEngine: Fix parameters for gtk_theming_engine_lookup_color()
2010-12-04 14:08:35 +00:00
gtk_theming_engine_lookup_color (GtkThemingEngine *engine,
const gchar *color_name,
GdkRGBA *color)
GtkThemingEngine: Add gtk_theming_engine_lookup_color() It could also be handy for theme engines...
2010-12-01 18:19:26 +00:00
{
GtkThemingEnginePrivate *priv;
Revert "docs: Reinstate pixbufs section in GDK docs" I committed my whole working tee instead of just one file. Ooops. This reverts commit ded14b256202d8792629b88874d934638762cee3.
2010-12-09 22:55:33 +00:00
g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), FALSE);
g_return_val_if_fail (color_name != NULL, FALSE);
GtkThemingEngine: Add gtk_theming_engine_lookup_color() It could also be handy for theme engines...
2010-12-01 18:19:26 +00:00
priv = engine->priv;
Revert "docs: Reinstate pixbufs section in GDK docs" I committed my whole working tee instead of just one file. Ooops. This reverts commit ded14b256202d8792629b88874d934638762cee3.
2010-12-09 22:55:33 +00:00
return gtk_style_context_lookup_color (priv->context, color_name, color);
GtkThemingEngine: Add gtk_theming_engine_lookup_color() It could also be handy for theme engines...
2010-12-01 18:19:26 +00:00
}
Add theming docs Both API and file format is documented, there's still missing a migration doc though.
2010-10-19 08:59:46 +00:00
/**
* gtk_theming_engine_get_state:
* @engine: a #GtkThemingEngine
*
* returns the state used when rendering.
*
* Returns: the state flags
*
* Since: 3.0
**/
Add GtkThemingEngine. GtkThemingEngine will be the theming engines base class, with default implementations for all paint functions, and readonly access to the related GtkStyleContext data.
2010-03-13 10:23:23 +00:00
GtkStateFlags
gtk_theming_engine_get_state (GtkThemingEngine *engine)
{
GtkThemingEnginePrivate *priv;
g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), 0);
priv = engine->priv;
return gtk_style_context_get_state (priv->context);
}
Change semantics of the methods to check whether an animation is running. It actually messed up with the state being actually set, and having a transition animation running for it. Now this dichotomy is removed, and gtk_style_context_state_is_running() only checks whether an animation is running, leaving state checking to flags & GTK_STATE_FLAG_*.
2010-10-19 10:09:23 +00:00
/**
* gtk_theming_engine_state_is_running:
* @engine: a #GtkThemingEngine
* @state: a widget state
* @progress: (out): return location for the transition progress
*
* Returns %TRUE if there is a transition animation running for the
* current region (see gtk_style_context_push_animatable_region()).
*
* If @progress is not %NULL, the animation progress will be returned
* there, 0.0 means the state is closest to being %FALSE, while 1.0 means
* it's closest to being %TRUE. This means transition animations will
* run from 0 to 1 when @state is being set to %TRUE and from 1 to 0 when
* it's being set to %FALSE.
*
* Returns: %TRUE if there is a running transition animation for @state.
*
* Since: 3.0
**/
Add GtkThemingEngine. GtkThemingEngine will be the theming engines base class, with default implementations for all paint functions, and readonly access to the related GtkStyleContext data.
2010-03-13 10:23:23 +00:00
gboolean
Change semantics of the methods to check whether an animation is running. It actually messed up with the state being actually set, and having a transition animation running for it. Now this dichotomy is removed, and gtk_style_context_state_is_running() only checks whether an animation is running, leaving state checking to flags & GTK_STATE_FLAG_*.
2010-10-19 10:09:23 +00:00
gtk_theming_engine_state_is_running (GtkThemingEngine *engine,
GtkStateType state,
gdouble *progress)
Add GtkThemingEngine. GtkThemingEngine will be the theming engines base class, with default implementations for all paint functions, and readonly access to the related GtkStyleContext data.
2010-03-13 10:23:23 +00:00
{
GtkThemingEnginePrivate *priv;
Change semantics of the methods to check whether an animation is running. It actually messed up with the state being actually set, and having a transition animation running for it. Now this dichotomy is removed, and gtk_style_context_state_is_running() only checks whether an animation is running, leaving state checking to flags & GTK_STATE_FLAG_*.
2010-10-19 10:09:23 +00:00
g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), FALSE);
Add GtkThemingEngine. GtkThemingEngine will be the theming engines base class, with default implementations for all paint functions, and readonly access to the related GtkStyleContext data.
2010-03-13 10:23:23 +00:00
priv = engine->priv;
Change semantics of the methods to check whether an animation is running. It actually messed up with the state being actually set, and having a transition animation running for it. Now this dichotomy is removed, and gtk_style_context_state_is_running() only checks whether an animation is running, leaving state checking to flags & GTK_STATE_FLAG_*.
2010-10-19 10:09:23 +00:00
return gtk_style_context_state_is_running (priv->context, state, progress);
Add GtkThemingEngine. GtkThemingEngine will be the theming engines base class, with default implementations for all paint functions, and readonly access to the related GtkStyleContext data.
2010-03-13 10:23:23 +00:00
}
Add theming docs Both API and file format is documented, there's still missing a migration doc though.
2010-10-19 08:59:46 +00:00
/**
* gtk_theming_engine_get_path:
* @engine: a #GtkThemingEngine
*
* Returns the widget path used for style matching.
*
* Returns: (transfer none): A #GtkWidgetPath
*
* Since: 3.0
**/
Add GtkThemingEngine. GtkThemingEngine will be the theming engines base class, with default implementations for all paint functions, and readonly access to the related GtkStyleContext data.
2010-03-13 10:23:23 +00:00
G_CONST_RETURN GtkWidgetPath *
gtk_theming_engine_get_path (GtkThemingEngine *engine)
{
GtkThemingEnginePrivate *priv;
g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), NULL);
priv = engine->priv;
return gtk_style_context_get_path (priv->context);
}
Add theming docs Both API and file format is documented, there's still missing a migration doc though.
2010-10-19 08:59:46 +00:00
/**
* gtk_theming_engine_has_class:
* @engine: a #GtkThemingEngine
* @style_class: class name to look up
*
* Returns %TRUE if the currently rendered contents have
* defined the given class name.
*
* Returns: %TRUE if @engine has @class_name defined
*
* Since: 3.0
**/
GtkThemingEngine: Add accessors to style classes.
2010-03-20 13:13:50 +00:00
gboolean
gtk_theming_engine_has_class (GtkThemingEngine *engine,
const gchar *style_class)
{
GtkThemingEnginePrivate *priv;
g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), FALSE);
priv = engine->priv;
return gtk_style_context_has_class (priv->context, style_class);
}
Add theming docs Both API and file format is documented, there's still missing a migration doc though.
2010-10-19 08:59:46 +00:00
/**
* gtk_theming_engine_has_region:
* @engine: a #GtkThemingEngine
* @style_region: a region name
* @flags: (out) (allow-none): return location for region flags
*
* Returns %TRUE if the currently rendered contents have the
* region defined. If @flags_return is not %NULL, it is set
* to the flags affecting the region.
*
* Returns: %TRUE if region is defined
*
* Since: 3.0
**/
GtkThemingEngine: Add accessors to style classes.
2010-03-20 13:13:50 +00:00
gboolean
s/child class/region/ everywhere. "Child class" is an invented term anyway, and it conceptually defines identifiable regions in widgets.
2010-08-05 09:08:51 +00:00
gtk_theming_engine_has_region (GtkThemingEngine *engine,
Add theming docs Both API and file format is documented, there's still missing a migration doc though.
2010-10-19 08:59:46 +00:00
const gchar *style_region,
s/child class/region/ everywhere. "Child class" is an invented term anyway, and it conceptually defines identifiable regions in widgets.
2010-08-05 09:08:51 +00:00
GtkRegionFlags *flags)
GtkThemingEngine: Add accessors to style classes.
2010-03-20 13:13:50 +00:00
{
GtkThemingEnginePrivate *priv;
if (flags)
*flags = 0;
g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), FALSE);
priv = engine->priv;
Add theming docs Both API and file format is documented, there's still missing a migration doc though.
2010-10-19 08:59:46 +00:00
return gtk_style_context_has_region (priv->context, style_region, flags);
GtkThemingEngine: Add accessors to style classes.
2010-03-20 13:13:50 +00:00
}
Add theming docs Both API and file format is documented, there's still missing a migration doc though.
2010-10-19 08:59:46 +00:00
/**
* gtk_theming_engine_get_direction:
* @engine: a #GtkThemingEngine
*
* Returns the widget direction used for rendering.
*
* Returns: the widget direction
*
* Since: 3.0
**/
GtkThemingEngine: Add gtk_theming_engine_get_direction().
2010-08-03 18:26:53 +00:00
GtkTextDirection
gtk_theming_engine_get_direction (GtkThemingEngine *engine)
{
GtkThemingEnginePrivate *priv;
g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), GTK_TEXT_DIR_LTR);
priv = engine->priv;
return gtk_style_context_get_direction (priv->context);
}
Add theming docs Both API and file format is documented, there's still missing a migration doc though.
2010-10-19 08:59:46 +00:00
/**
* gtk_theming_engine_get_junction_sides:
* @engine: a #GtkThemingEngine
*
* Returns the widget direction used for rendering.
*
* Returns: the widget direction
*
* Since: 3.0
**/
GtkThemingEngine: Add gtk_theming_engine_get_junction_sides().
2010-08-03 18:36:09 +00:00
GtkJunctionSides
gtk_theming_engine_get_junction_sides (GtkThemingEngine *engine)
{
GtkThemingEnginePrivate *priv;
g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), 0);
priv = engine->priv;
return gtk_style_context_get_junction_sides (priv->context);
}
Add helper API for getting colors/borders in GtkStyleContext/GtkThemingEngine
2010-12-02 22:41:24 +00:00
/**
* gtk_theming_engine_get_color:
* @engine: a #GtkThemingEngine
* @state: state to retrieve the color for
* @color: (out): return value for the foreground color
*
* Gets the foreground color for a given state.
*
* Since: 3.0
**/
void
gtk_theming_engine_get_color (GtkThemingEngine *engine,
GtkStateFlags state,
GdkRGBA *color)
{
GtkThemingEnginePrivate *priv;
g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
priv = engine->priv;
gtk_style_context_get_color (priv->context, state, color);
}
/**
* gtk_theming_engine_get_background_color:
* @engine: a #GtkThemingEngine
* @state: state to retrieve the color for
* @color: (out): return value for the background color
*
* Gets the background color for a given state.
*
* Since: 3.0
**/
void
gtk_theming_engine_get_background_color (GtkThemingEngine *engine,
GtkStateFlags state,
GdkRGBA *color)
{
GtkThemingEnginePrivate *priv;
g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
priv = engine->priv;
gtk_style_context_get_background_color (priv->context, state, color);
}
/**
* gtk_theming_engine_get_border_color:
* @engine: a #GtkThemingEngine
* @state: state to retrieve the color for
* @color: (out): return value for the border color
*
* Gets the border color for a given state.
*
* Since: 3.0
**/
void
gtk_theming_engine_get_border_color (GtkThemingEngine *engine,
GtkStateFlags state,
GdkRGBA *color)
{
GtkThemingEnginePrivate *priv;
g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
priv = engine->priv;
gtk_style_context_get_border_color (priv->context, state, color);
}
/**
* gtk_theming_engine_get_border:
* @engine: a #GtkthemingEngine
* @state: state to retrieve the border for
Documentation fixes
2011-01-06 13:12:01 +00:00
* @border: (out): return value for the border settings
Add helper API for getting colors/borders in GtkStyleContext/GtkThemingEngine
2010-12-02 22:41:24 +00:00
*
* Gets the border for a given state as a #GtkBorder.
*
* Since: 3.0
**/
void
gtk_theming_engine_get_border (GtkThemingEngine *engine,
GtkStateFlags state,
GtkBorder *border)
{
GtkThemingEnginePrivate *priv;
g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
priv = engine->priv;
gtk_style_context_get_border (priv->context, state, border);
}
/**
* gtk_theming_engine_get_padding:
* @engine: a #GtkthemingEngine
* @state: state to retrieve the padding for
More parameter name mismatches
2010-12-17 19:47:56 +00:00
* @padding: (out): return value for the padding settings
Add helper API for getting colors/borders in GtkStyleContext/GtkThemingEngine
2010-12-02 22:41:24 +00:00
*
* Gets the padding for a given state as a #GtkBorder.
*
* Since: 3.0
**/
void
gtk_theming_engine_get_padding (GtkThemingEngine *engine,
GtkStateFlags state,
GtkBorder *padding)
{
GtkThemingEnginePrivate *priv;
g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
priv = engine->priv;
gtk_style_context_get_padding (priv->context, state, padding);
}
/**
* gtk_theming_engine_get_margin:
More parameter name mismatches
2010-12-17 19:47:56 +00:00
* @engine: a #GtkThemingEngine
Add helper API for getting colors/borders in GtkStyleContext/GtkThemingEngine
2010-12-02 22:41:24 +00:00
* @state: state to retrieve the border for
More parameter name mismatches
2010-12-17 19:47:56 +00:00
* @margin: (out): return value for the margin settings
Add helper API for getting colors/borders in GtkStyleContext/GtkThemingEngine
2010-12-02 22:41:24 +00:00
*
* Gets the margin for a given state as a #GtkBorder.
*
* Since: 3.0
**/
void
gtk_theming_engine_get_margin (GtkThemingEngine *engine,
GtkStateFlags state,
GtkBorder *margin)
{
GtkThemingEnginePrivate *priv;
g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
priv = engine->priv;
gtk_style_context_get_margin (priv->context, state, margin);
}
Add getter for font description in GtkThemingEngine This function is analogous to gtk_style_context_get_font().
2010-12-13 20:36:49 +00:00
/**
* gtk_theming_engine_get_font:
* @engine: a #GtkThemingEngine
* @state: state to retrieve the font for
*
* Returns the font description for a given state.
*
[GI] Add missing (transfer) annotations
2011-01-18 09:01:17 +00:00
* Returns: (transfer none): the #PangoFontDescription for the given
* state. This object is owned by GTK+ and should not be
* freed.
Add getter for font description in GtkThemingEngine This function is analogous to gtk_style_context_get_font().
2010-12-13 20:36:49 +00:00
*
* Since: 3.0
**/
const PangoFontDescription *
gtk_theming_engine_get_font (GtkThemingEngine *engine,
GtkStateFlags state)
{
GtkThemingEnginePrivate *priv;
g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), NULL);
priv = engine->priv;
return gtk_style_context_get_font (priv->context, state);
}
Add helper API for getting colors/borders in GtkStyleContext/GtkThemingEngine
2010-12-02 22:41:24 +00:00
GtkThemingEngine: Add module loading capabilities.
2010-03-13 17:35:35 +00:00
/* GtkThemingModule */
static gboolean
gtk_theming_module_load (GTypeModule *type_module)
{
GtkThemingModule *theming_module;
GModule *module;
gchar *name, *module_path;
theming_module = GTK_THEMING_MODULE (type_module);
name = theming_module->name;
module_path = _gtk_find_module (name, "theming-engines");
if (!module_path)
Don't use g_warning when loading an engine fails This causes the tests to abort if clearlooks can't be found.
2010-12-06 05:44:01 +00:00
return FALSE;
GtkThemingEngine: Add module loading capabilities.
2010-03-13 17:35:35 +00:00
module = g_module_open (module_path, G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL);
g_free (module_path);
if (!module)
Don't use g_warning when loading an engine fails This causes the tests to abort if clearlooks can't be found.
2010-12-06 05:44:01 +00:00
return FALSE;
GtkThemingEngine: Add module loading capabilities.
2010-03-13 17:35:35 +00:00
Make loading of theming engines from modules work
2010-10-20 11:26:27 +00:00
if (!g_module_symbol (module, "theme_init",
(gpointer *) &theming_module->init) ||
!g_module_symbol (module, "theme_exit",
(gpointer *) &theming_module->exit) ||
!g_module_symbol (module, "create_engine",
GtkThemingEngine: Add module loading capabilities.
2010-03-13 17:35:35 +00:00
(gpointer *) &theming_module->create_engine))
{
g_module_close (module);
return FALSE;
}
Make loading of theming engines from modules work
2010-10-20 11:26:27 +00:00
theming_module->module = module;
GtkThemingEngine: Fix compile warning.
2010-11-03 20:12:57 +00:00
theming_module->init (G_TYPE_MODULE (theming_module));
GtkThemingEngine: Add module loading capabilities.
2010-03-13 17:35:35 +00:00
return TRUE;
}
Make loading of theming engines from modules work
2010-10-20 11:26:27 +00:00
static void
gtk_theming_module_unload (GTypeModule *type_module)
{
GtkThemingModule *theming_module;
theming_module = GTK_THEMING_MODULE (type_module);
theming_module->exit ();
g_module_close (theming_module->module);
theming_module->module = NULL;
theming_module->init = NULL;
theming_module->exit = NULL;
theming_module->create_engine = NULL;
}
GtkThemingEngine: Add module loading capabilities.
2010-03-13 17:35:35 +00:00
static void
gtk_theming_module_class_init (GtkThemingModuleClass *klass)
{
GTypeModuleClass *module_class = G_TYPE_MODULE_CLASS (klass);
module_class->load = gtk_theming_module_load;
Make loading of theming engines from modules work
2010-10-20 11:26:27 +00:00
module_class->unload = gtk_theming_module_unload;
GtkThemingEngine: Add module loading capabilities.
2010-03-13 17:35:35 +00:00
}
static void
gtk_theming_module_init (GtkThemingModule *module)
{
}
Add theming docs Both API and file format is documented, there's still missing a migration doc though.
2010-10-19 08:59:46 +00:00
/**
* gtk_theming_engine_load:
* @name: Theme engine name to load
*
* Loads and initializes a theming engine module from the
* standard directories.
*
* Returns: (transfer none): A theming engine, or %NULL if
* the engine @name doesn't exist.
**/
GtkThemingEngine: Do not return a const GtkThemingEngine on load()
2010-10-08 16:13:14 +00:00
GtkThemingEngine *
GtkThemingEngine: Add module loading capabilities.
2010-03-13 17:35:35 +00:00
gtk_theming_engine_load (const gchar *name)
{
static GHashTable *engines = NULL;
static GtkThemingEngine *default_engine;
GtkThemingEngine *engine = NULL;
if (name)
{
if (!engines)
engines = g_hash_table_new (g_str_hash, g_str_equal);
engine = g_hash_table_lookup (engines, name);
if (!engine)
{
GtkThemingModule *module;
module = g_object_new (GTK_TYPE_THEMING_MODULE, NULL);
g_type_module_set_name (G_TYPE_MODULE (module), name);
module->name = g_strdup (name);
if (module && g_type_module_use (G_TYPE_MODULE (module)))
{
engine = (module->create_engine) ();
if (engine)
g_hash_table_insert (engines, module->name, engine);
}
}
}
if (!engine)
{
GtkStyleSet: Register GtkThemingEngine type. This has been also hooked up to the CSS provider, which parses the "engine" value to load the corresponding module.
2010-06-13 15:31:22 +00:00
if (G_UNLIKELY (!default_engine))
GtkThemingEngine: Add module loading capabilities.
2010-03-13 17:35:35 +00:00
default_engine = g_object_new (GTK_TYPE_THEMING_ENGINE, NULL);
engine = default_engine;
}
return engine;
}
Add theming docs Both API and file format is documented, there's still missing a migration doc though.
2010-10-19 08:59:46 +00:00
/**
* gtk_theming_engine_get_screen:
* @engine: a #GtkThemingEngine
*
* Returns the #GdkScreen to which @engine currently rendering to.
*
[GI] Add missing (transfer) annotations
2011-01-18 09:01:17 +00:00
* Returns: (transfer none): a #GdkScreen, or %NULL.
Add theming docs Both API and file format is documented, there's still missing a migration doc though.
2010-10-19 08:59:46 +00:00
**/
GtkThemingEngine: Add gtk_theming_engine_get_screen().
2010-07-03 11:21:56 +00:00
GdkScreen *
gtk_theming_engine_get_screen (GtkThemingEngine *engine)
{
GtkThemingEnginePrivate *priv;
g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), NULL);
priv = engine->priv;
return gtk_style_context_get_screen (priv->context);
}
GtkThemingEngine: Add vmethod to render checkboxes.
2010-03-20 13:17:40 +00:00
/* Paint method implementations */
static void
gtk_theming_engine_render_check (GtkThemingEngine *engine,
cairo_t *cr,
gdouble x,
gdouble y,
gdouble width,
gdouble height)
{
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
GdkRGBA fg_color, bg_color;
GtkThemingEngine: Add vmethod to render checkboxes.
2010-03-20 13:17:40 +00:00
GtkStateFlags flags;
GtkThemingEngine: Take checkbox rendering from GtkStyle.
2010-07-19 09:42:18 +00:00
gint exterior_size, interior_size, thickness, pad;
GtkThemingEngine: Make render_check() depend on border-style and border-color.
2010-11-19 18:18:20 +00:00
GtkBorderStyle border_style;
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
GtkBorder border;
GtkThemingEngine: Make render_check() depend on border-style and border-color.
2010-11-19 18:18:20 +00:00
gint border_width;
GtkThemingEngine: Add vmethod to render checkboxes.
2010-03-20 13:17:40 +00:00
flags = gtk_theming_engine_get_state (engine);
cairo_save (cr);
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gtk_theming_engine_get_color (engine, flags, &fg_color);
gtk_theming_engine_get_background_color (engine, flags, &bg_color);
gtk_theming_engine_get_border (engine, flags, &border);
Move all theming stack to use GtkStateFlags. This support goes from the theming engines, which are able to retrieve style for different combined states to the CSS provider, where several state pseudo-classes may be specified, such as: GtkButton:active:prelight {}
2010-08-16 17:09:34 +00:00
gtk_theming_engine_get (engine, flags,
GtkThemingEngine: Make render_check() depend on border-style and border-color.
2010-11-19 18:18:20 +00:00
"border-style", &border_style,
GtkThemingEngine: Add vmethod to render checkboxes.
2010-03-20 13:17:40 +00:00
NULL);
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
border_width = MIN (MIN (border.top, border.bottom),
MIN (border.left, border.right));
GtkThemingEngine: Take checkbox rendering from GtkStyle.
2010-07-19 09:42:18 +00:00
exterior_size = MIN (width, height);
if (exterior_size % 2 == 0) /* Ensure odd */
exterior_size -= 1;
/* FIXME: thickness */
thickness = 1;
pad = thickness + MAX (1, (exterior_size - 2 * thickness) / 9);
interior_size = MAX (1, exterior_size - 2 * pad);
if (interior_size < 7)
GtkThemingEngine: Add vmethod to render checkboxes.
2010-03-20 13:17:40 +00:00
{
GtkThemingEngine: Take checkbox rendering from GtkStyle.
2010-07-19 09:42:18 +00:00
interior_size = 7;
pad = MAX (0, (exterior_size - interior_size) / 2);
}
GtkThemingEngine: Add vmethod to render checkboxes.
2010-03-20 13:17:40 +00:00
GtkThemingEngine: Take checkbox rendering from GtkStyle.
2010-07-19 09:42:18 +00:00
x -= (1 + exterior_size - (gint) width) / 2;
y -= (1 + exterior_size - (gint) height) / 2;
GtkThemingEngine: Add vmethod to render checkboxes.
2010-03-20 13:17:40 +00:00
GtkThemingEngine: Make render_check() depend on border-style and border-color.
2010-11-19 18:18:20 +00:00
if (border_style == GTK_BORDER_STYLE_SOLID)
GtkThemingEngine: Take checkbox rendering from GtkStyle.
2010-07-19 09:42:18 +00:00
{
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
GdkRGBA border_color;
GtkThemingEngine: Make render_check() depend on border-style and border-color.
2010-11-19 18:18:20 +00:00
cairo_set_line_width (cr, border_width);
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gtk_theming_engine_get_border_color (engine, flags, &border_color);
GtkThemingEngine: Take checkbox rendering from GtkStyle.
2010-07-19 09:42:18 +00:00
cairo_rectangle (cr, x + 0.5, y + 0.5, exterior_size - 1, exterior_size - 1);
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gdk_cairo_set_source_rgba (cr, &bg_color);
GtkThemingEngine: Add vmethod to render checkboxes.
2010-03-20 13:17:40 +00:00
cairo_fill_preserve (cr);
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gdk_cairo_set_source_rgba (cr, &border_color);
GtkThemingEngine: Add vmethod to render checkboxes.
2010-03-20 13:17:40 +00:00
cairo_stroke (cr);
}
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gdk_cairo_set_source_rgba (cr, &fg_color);
GtkThemingEngine: Add vmethod to render checkboxes.
2010-03-20 13:17:40 +00:00
Change semantics of the methods to check whether an animation is running. It actually messed up with the state being actually set, and having a transition animation running for it. Now this dichotomy is removed, and gtk_style_context_state_is_running() only checks whether an animation is running, leaving state checking to flags & GTK_STATE_FLAG_*.
2010-10-19 10:09:23 +00:00
if (flags & GTK_STATE_FLAG_INCONSISTENT)
GtkThemingEngine: Add vmethod to render checkboxes.
2010-03-20 13:17:40 +00:00
{
GtkThemingEngine: Take checkbox rendering from GtkStyle.
2010-07-19 09:42:18 +00:00
int line_thickness = MAX (1, (3 + interior_size * 2) / 7);
cairo_rectangle (cr,
x + pad,
y + pad + (1 + interior_size - line_thickness) / 2,
interior_size,
line_thickness);
cairo_fill (cr);
GtkThemingEngine: Add vmethod to render checkboxes.
2010-03-20 13:17:40 +00:00
}
GtkThemingEngine: Animate checkboxes activation.
2010-08-19 20:47:02 +00:00
else
GtkThemingEngine: Add vmethod to render checkboxes.
2010-03-20 13:17:40 +00:00
{
GtkThemingEngine: Animate checkboxes activation.
2010-08-19 20:47:02 +00:00
gdouble progress;
Change semantics of the methods to check whether an animation is running. It actually messed up with the state being actually set, and having a transition animation running for it. Now this dichotomy is removed, and gtk_style_context_state_is_running() only checks whether an animation is running, leaving state checking to flags & GTK_STATE_FLAG_*.
2010-10-19 10:09:23 +00:00
gboolean running;
GtkThemingEngine: Take checkbox rendering from GtkStyle.
2010-07-19 09:42:18 +00:00
Change semantics of the methods to check whether an animation is running. It actually messed up with the state being actually set, and having a transition animation running for it. Now this dichotomy is removed, and gtk_style_context_state_is_running() only checks whether an animation is running, leaving state checking to flags & GTK_STATE_FLAG_*.
2010-10-19 10:09:23 +00:00
running = gtk_theming_engine_state_is_running (engine, GTK_STATE_ACTIVE, &progress);
GtkThemingEngine: Animate checkboxes activation.
2010-08-19 20:47:02 +00:00
Change semantics of the methods to check whether an animation is running. It actually messed up with the state being actually set, and having a transition animation running for it. Now this dichotomy is removed, and gtk_style_context_state_is_running() only checks whether an animation is running, leaving state checking to flags & GTK_STATE_FLAG_*.
2010-10-19 10:09:23 +00:00
if ((flags & GTK_STATE_FLAG_ACTIVE) || running)
GtkThemingEngine: Animate checkboxes activation.
2010-08-19 20:47:02 +00:00
{
Change semantics of the methods to check whether an animation is running. It actually messed up with the state being actually set, and having a transition animation running for it. Now this dichotomy is removed, and gtk_style_context_state_is_running() only checks whether an animation is running, leaving state checking to flags & GTK_STATE_FLAG_*.
2010-10-19 10:09:23 +00:00
if (!running)
progress = 1;
GtkThemingEngine: Animate checkboxes activation.
2010-08-19 20:47:02 +00:00
cairo_translate (cr,
x + pad, y + pad);
cairo_scale (cr, interior_size / 7., interior_size / 7.);
cairo_rectangle (cr, 0, 0, 7 * progress, 7);
cairo_clip (cr);
cairo_move_to (cr, 7.0, 0.0);
cairo_line_to (cr, 7.5, 1.0);
cairo_curve_to (cr, 5.3, 2.0,
4.3, 4.0,
3.5, 7.0);
cairo_curve_to (cr, 3.0, 5.7,
1.3, 4.7,
0.0, 4.7);
cairo_line_to (cr, 0.2, 3.5);
cairo_curve_to (cr, 1.1, 3.5,
2.3, 4.3,
3.0, 5.0);
cairo_curve_to (cr, 1.0, 3.9,
2.4, 4.1,
3.2, 4.9);
cairo_curve_to (cr, 3.5, 3.1,
5.2, 2.0,
7.0, 0.0);
cairo_fill (cr);
}
GtkThemingEngine: Add vmethod to render checkboxes.
2010-03-20 13:17:40 +00:00
}
cairo_restore (cr);
}
GtkThemingEngine: Add vmethod to render radio buttons.
2010-03-20 16:37:34 +00:00
static void
gtk_theming_engine_render_option (GtkThemingEngine *engine,
cairo_t *cr,
gdouble x,
gdouble y,
gdouble width,
gdouble height)
{
GtkStateFlags flags;
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
GdkRGBA fg_color, bg_color;
GtkThemingEngine: Make render_option() depend on border-style and border-color.
2010-11-19 19:17:18 +00:00
gint exterior_size, interior_size, pad, thickness, border_width;
GtkBorderStyle border_style;
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
GtkBorder border;
GtkThemingEngine: Add vmethod to render radio buttons.
2010-03-20 16:37:34 +00:00
flags = gtk_theming_engine_get_state (engine);
cairo_save (cr);
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gtk_theming_engine_get_color (engine, flags, &fg_color);
gtk_theming_engine_get_background_color (engine, flags, &bg_color);
gtk_theming_engine_get_border (engine, flags, &border);
Move all theming stack to use GtkStateFlags. This support goes from the theming engines, which are able to retrieve style for different combined states to the CSS provider, where several state pseudo-classes may be specified, such as: GtkButton:active:prelight {}
2010-08-16 17:09:34 +00:00
gtk_theming_engine_get (engine, flags,
GtkThemingEngine: Make render_option() depend on border-style and border-color.
2010-11-19 19:17:18 +00:00
"border-style", &border_style,
GtkThemingEngine: Add vmethod to render radio buttons.
2010-03-20 16:37:34 +00:00
NULL);
GtkThemingEngine: Take option rendering from GtkStyle.
2010-07-19 09:45:35 +00:00
exterior_size = MIN (width, height);
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
border_width = MIN (MIN (border.top, border.bottom),
MIN (border.left, border.right));
GtkThemingEngine: Take option rendering from GtkStyle.
2010-07-19 09:45:35 +00:00
if (exterior_size % 2 == 0) /* Ensure odd */
exterior_size -= 1;
x -= (1 + exterior_size - width) / 2;
y -= (1 + exterior_size - height) / 2;
GtkThemingEngine: Make render_option() depend on border-style and border-color.
2010-11-19 19:17:18 +00:00
if (border_style == GTK_BORDER_STYLE_SOLID)
GtkThemingEngine: Add vmethod to render radio buttons.
2010-03-20 16:37:34 +00:00
{
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
GdkRGBA border_color;
GtkThemingEngine: Make render_option() depend on border-style and border-color.
2010-11-19 19:17:18 +00:00
cairo_set_line_width (cr, border_width);
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gtk_theming_engine_get_border_color (engine, flags, &border_color);
Fix rendering glitch in menu radiobuttons The arcs needed a new subpath.
2011-01-12 19:29:08 +00:00
cairo_new_sub_path (cr);
GtkThemingEngine: Add vmethod to render radio buttons.
2010-03-20 16:37:34 +00:00
cairo_arc (cr,
Silence new gcc warnings gcc 4.6.0 has started to warn about set-but-unused variables. So don't do that, then.
2011-01-24 02:50:39 +00:00
x + exterior_size / 2.,
y + exterior_size / 2.,
(exterior_size - 1) / 2.,
0, 2 * G_PI);
GtkThemingEngine: Add vmethod to render radio buttons.
2010-03-20 16:37:34 +00:00
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gdk_cairo_set_source_rgba (cr, &bg_color);
GtkThemingEngine: Add vmethod to render radio buttons.
2010-03-20 16:37:34 +00:00
cairo_fill_preserve (cr);
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gdk_cairo_set_source_rgba (cr, &border_color);
GtkThemingEngine: Add vmethod to render radio buttons.
2010-03-20 16:37:34 +00:00
cairo_stroke (cr);
}
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gdk_cairo_set_source_rgba (cr, &fg_color);
GtkThemingEngine: Add vmethod to render radio buttons.
2010-03-20 16:37:34 +00:00
GtkThemingEngine: Take option rendering from GtkStyle.
2010-07-19 09:45:35 +00:00
/* FIXME: thickness */
thickness = 1;
Change semantics of the methods to check whether an animation is running. It actually messed up with the state being actually set, and having a transition animation running for it. Now this dichotomy is removed, and gtk_style_context_state_is_running() only checks whether an animation is running, leaving state checking to flags & GTK_STATE_FLAG_*.
2010-10-19 10:09:23 +00:00
if (flags & GTK_STATE_FLAG_INCONSISTENT)
GtkThemingEngine: Add vmethod to render radio buttons.
2010-03-20 16:37:34 +00:00
{
GtkThemingEngine: Take option rendering from GtkStyle.
2010-07-19 09:45:35 +00:00
gint line_thickness;
pad = thickness + MAX (1, (exterior_size - 2 * thickness) / 9);
interior_size = MAX (1, exterior_size - 2 * pad);
if (interior_size < 7)
{
interior_size = 7;
pad = MAX (0, (exterior_size - interior_size) / 2);
}
line_thickness = MAX (1, (3 + interior_size * 2) / 7);
cairo_rectangle (cr,
Silence new gcc warnings gcc 4.6.0 has started to warn about set-but-unused variables. So don't do that, then.
2011-01-24 02:50:39 +00:00
x + pad,
y + pad + (interior_size - line_thickness) / 2.,
interior_size,
line_thickness);
GtkThemingEngine: Take option rendering from GtkStyle.
2010-07-19 09:45:35 +00:00
cairo_fill (cr);
GtkThemingEngine: Add vmethod to render radio buttons.
2010-03-20 16:37:34 +00:00
}
Change semantics of the methods to check whether an animation is running. It actually messed up with the state being actually set, and having a transition animation running for it. Now this dichotomy is removed, and gtk_style_context_state_is_running() only checks whether an animation is running, leaving state checking to flags & GTK_STATE_FLAG_*.
2010-10-19 10:09:23 +00:00
if (flags & GTK_STATE_FLAG_ACTIVE)
GtkThemingEngine: Add vmethod to render radio buttons.
2010-03-20 16:37:34 +00:00
{
GtkThemingEngine: Take option rendering from GtkStyle.
2010-07-19 09:45:35 +00:00
pad = thickness + MAX (1, 2 * (exterior_size - 2 * thickness) / 9);
interior_size = MAX (1, exterior_size - 2 * pad);
GtkThemingEngine: Add vmethod to render radio buttons.
2010-03-20 16:37:34 +00:00
GtkThemingEngine: Take option rendering from GtkStyle.
2010-07-19 09:45:35 +00:00
if (interior_size < 5)
Silence new gcc warnings gcc 4.6.0 has started to warn about set-but-unused variables. So don't do that, then.
2011-01-24 02:50:39 +00:00
{
interior_size = 7;
pad = MAX (0, (exterior_size - interior_size) / 2);
}
GtkThemingEngine: Take option rendering from GtkStyle.
2010-07-19 09:45:35 +00:00
Fix rendering glitch in menu radiobuttons The arcs needed a new subpath.
2011-01-12 19:29:08 +00:00
cairo_new_sub_path (cr);
GtkThemingEngine: Take option rendering from GtkStyle.
2010-07-19 09:45:35 +00:00
cairo_arc (cr,
Silence new gcc warnings gcc 4.6.0 has started to warn about set-but-unused variables. So don't do that, then.
2011-01-24 02:50:39 +00:00
x + pad + interior_size / 2.,
y + pad + interior_size / 2.,
interior_size / 2.,
0, 2 * G_PI);
GtkThemingEngine: Add vmethod to render radio buttons.
2010-03-20 16:37:34 +00:00
cairo_fill (cr);
}
cairo_restore (cr);
}
GtkThemingEngine: Add vmethod to render arrows.
2010-03-27 17:50:39 +00:00
static void
add_path_arrow (cairo_t *cr,
gdouble angle,
gdouble x,
gdouble y,
gdouble size)
{
cairo_save (cr);
cairo_translate (cr, x + (size / 2), y + (size / 2));
cairo_rotate (cr, angle);
GtkThemingEngine: Improve pixel alignment in arrows.
2010-08-02 13:45:13 +00:00
cairo_move_to (cr, 0, - (size / 4));
cairo_line_to (cr, - (size / 2), (size / 4));
cairo_line_to (cr, (size / 2), (size / 4));
GtkThemingEngine: Add vmethod to render arrows.
2010-03-27 17:50:39 +00:00
cairo_close_path (cr);
cairo_restore (cr);
}
static void
gtk_theming_engine_render_arrow (GtkThemingEngine *engine,
cairo_t *cr,
gdouble angle,
gdouble x,
gdouble y,
gdouble size)
{
GtkStateFlags flags;
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
GdkRGBA fg_color;
GtkThemingEngine: Add vmethod to render arrows.
2010-03-27 17:50:39 +00:00
cairo_save (cr);
flags = gtk_theming_engine_get_state (engine);
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gtk_theming_engine_get_color (engine, flags, &fg_color);
GtkThemingEngine: Add vmethod to render arrows.
2010-03-27 17:50:39 +00:00
if (flags & GTK_STATE_FLAG_INSENSITIVE)
{
add_path_arrow (cr, angle, x + 1, y + 1, size);
cairo_set_source_rgb (cr, 1, 1, 1);
cairo_fill (cr);
}
add_path_arrow (cr, angle, x, y, size);
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gdk_cairo_set_source_rgba (cr, &fg_color);
GtkThemingEngine: Add vmethod to render arrows.
2010-03-27 17:50:39 +00:00
cairo_fill (cr);
cairo_restore (cr);
}
GtkThemingEngine: Add vmethod to render backgrounds.
2010-03-27 19:06:44 +00:00
static void
GtkThemingEngine: Add cairo-ified rendering primitives. Functions to add paths for lines, rectangle sides, and the gap side in notebooks have been added.
2010-07-19 09:51:17 +00:00
add_path_line (cairo_t *cr,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2)
GtkThemingEngine: Add vmethod to render backgrounds.
2010-03-27 19:06:44 +00:00
{
GtkThemingEngine: Add cairo-ified rendering primitives. Functions to add paths for lines, rectangle sides, and the gap side in notebooks have been added.
2010-07-19 09:51:17 +00:00
/* Adjust endpoints */
if (y1 == y2)
{
y1 += 0.5;
y2 += 0.5;
x2 += 1;
}
else if (x1 == x2)
{
x1 += 0.5;
x2 += 0.5;
y2 += 1;
}
GtkThemingEngine: Add vmethod to render backgrounds.
2010-03-27 19:06:44 +00:00
GtkThemingEngine: Add cairo-ified rendering primitives. Functions to add paths for lines, rectangle sides, and the gap side in notebooks have been added.
2010-07-19 09:51:17 +00:00
cairo_move_to (cr, x1, y1);
cairo_line_to (cr, x2, y2);
}
GtkThemingEngine: Add vmethod to render frames.
2010-03-27 19:11:31 +00:00
static void
Use GdkRGBA all around in GtkStyleContext.
2010-10-22 10:41:19 +00:00
color_shade (const GdkRGBA *color,
gdouble factor,
GdkRGBA *color_return)
GtkThemingEngine: Add vmethod to render frames.
2010-03-27 19:11:31 +00:00
{
GtkThemingEngine: Use GtkSymbolicColor for shades.
2010-11-06 11:38:52 +00:00
GtkSymbolicColor *literal, *shade;
literal = gtk_symbolic_color_new_literal (color);
shade = gtk_symbolic_color_new_shade (literal, factor);
gtk_symbolic_color_unref (literal);
gtk_symbolic_color_resolve (shade, NULL, color_return);
gtk_symbolic_color_unref (shade);
GtkThemingEngine: Add vmethod to render frames.
2010-03-27 19:11:31 +00:00
}
GtkThemingEngine: Honor border-radius in render_background().
2010-10-20 16:47:28 +00:00
static void
GtkStyleSet: Register the border-style and border-color properties This is also implemented in the theming engine, although the default CSS should be using it in order to theme buttons, troughs, sliders and such.
2010-10-22 08:38:21 +00:00
_cairo_round_rectangle_sides (cairo_t *cr,
gdouble radius,
gdouble x,
gdouble y,
gdouble width,
gdouble height,
guint sides,
GtkJunctionSides junction)
GtkThemingEngine: Honor border-radius in render_background().
2010-10-20 16:47:28 +00:00
{
radius = CLAMP (radius, 0, MIN (width / 2, height / 2));
GtkStyleSet: Register the border-style and border-color properties This is also implemented in the theming engine, although the default CSS should be using it in order to theme buttons, troughs, sliders and such.
2010-10-22 08:38:21 +00:00
if (sides & SIDE_RIGHT)
{
if (radius == 0 ||
Fix handling of junctions in frame drawing code
2010-11-23 21:13:15 +00:00
(junction & GTK_JUNCTION_CORNER_TOPRIGHT))
GtkStyleSet: Register the border-style and border-color properties This is also implemented in the theming engine, although the default CSS should be using it in order to theme buttons, troughs, sliders and such.
2010-10-22 08:38:21 +00:00
cairo_move_to (cr, x + width, y);
else
{
cairo_new_sub_path (cr);
cairo_arc (cr, x + width - radius, y + radius, radius, - G_PI / 4, 0);
}
if (radius == 0 ||
Fix handling of junctions in frame drawing code
2010-11-23 21:13:15 +00:00
(junction & GTK_JUNCTION_CORNER_BOTTOMRIGHT))
GtkStyleSet: Register the border-style and border-color properties This is also implemented in the theming engine, although the default CSS should be using it in order to theme buttons, troughs, sliders and such.
2010-10-22 08:38:21 +00:00
cairo_line_to (cr, x + width, y + height);
else
cairo_arc (cr, x + width - radius, y + height - radius, radius, 0, G_PI / 4);
}
if (sides & SIDE_BOTTOM)
{
if (radius != 0 &&
Fix handling of junctions in frame drawing code
2010-11-23 21:13:15 +00:00
! (junction & GTK_JUNCTION_CORNER_BOTTOMRIGHT))
GtkStyleSet: Register the border-style and border-color properties This is also implemented in the theming engine, although the default CSS should be using it in order to theme buttons, troughs, sliders and such.
2010-10-22 08:38:21 +00:00
{
if ((sides & SIDE_RIGHT) == 0)
cairo_new_sub_path (cr);
cairo_arc (cr, x + width - radius, y + height - radius, radius, G_PI / 4, G_PI / 2);
}
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
else if ((sides & SIDE_RIGHT) == 0)
cairo_move_to (cr, x + width, y + height);
GtkStyleSet: Register the border-style and border-color properties This is also implemented in the theming engine, although the default CSS should be using it in order to theme buttons, troughs, sliders and such.
2010-10-22 08:38:21 +00:00
if (radius == 0 ||
Fix handling of junctions in frame drawing code
2010-11-23 21:13:15 +00:00
(junction & GTK_JUNCTION_CORNER_BOTTOMLEFT))
GtkStyleSet: Register the border-style and border-color properties This is also implemented in the theming engine, although the default CSS should be using it in order to theme buttons, troughs, sliders and such.
2010-10-22 08:38:21 +00:00
cairo_line_to (cr, x, y + height);
else
cairo_arc (cr, x + radius, y + height - radius, radius, G_PI / 2, 3 * (G_PI / 4));
}
GtkThemingEngine: Honor border-radius in render_background().
2010-10-20 16:47:28 +00:00
else
GtkStyleSet: Register the border-style and border-color properties This is also implemented in the theming engine, although the default CSS should be using it in order to theme buttons, troughs, sliders and such.
2010-10-22 08:38:21 +00:00
cairo_move_to (cr, x, y + height);
if (sides & SIDE_LEFT)
{
if (radius != 0 &&
Fix handling of junctions in frame drawing code
2010-11-23 21:13:15 +00:00
! (junction & GTK_JUNCTION_CORNER_BOTTOMLEFT))
GtkStyleSet: Register the border-style and border-color properties This is also implemented in the theming engine, although the default CSS should be using it in order to theme buttons, troughs, sliders and such.
2010-10-22 08:38:21 +00:00
{
if ((sides & SIDE_BOTTOM) == 0)
cairo_new_sub_path (cr);
cairo_arc (cr, x + radius, y + height - radius, radius, 3 * (G_PI / 4), G_PI);
}
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
else if ((sides & SIDE_BOTTOM) == 0)
cairo_move_to (cr, x, y + height);
GtkStyleSet: Register the border-style and border-color properties This is also implemented in the theming engine, although the default CSS should be using it in order to theme buttons, troughs, sliders and such.
2010-10-22 08:38:21 +00:00
if (radius == 0 ||
Fix handling of junctions in frame drawing code
2010-11-23 21:13:15 +00:00
(junction & GTK_JUNCTION_CORNER_TOPLEFT))
GtkStyleSet: Register the border-style and border-color properties This is also implemented in the theming engine, although the default CSS should be using it in order to theme buttons, troughs, sliders and such.
2010-10-22 08:38:21 +00:00
cairo_line_to (cr, x, y);
else
cairo_arc (cr, x + radius, y + radius, radius, G_PI, G_PI + G_PI / 4);
}
if (sides & SIDE_TOP)
GtkThemingEngine: Honor border-radius in render_background().
2010-10-20 16:47:28 +00:00
{
GtkStyleSet: Register the border-style and border-color properties This is also implemented in the theming engine, although the default CSS should be using it in order to theme buttons, troughs, sliders and such.
2010-10-22 08:38:21 +00:00
if (radius != 0 &&
Fix handling of junctions in frame drawing code
2010-11-23 21:13:15 +00:00
! (junction & GTK_JUNCTION_CORNER_TOPLEFT))
GtkStyleSet: Register the border-style and border-color properties This is also implemented in the theming engine, although the default CSS should be using it in order to theme buttons, troughs, sliders and such.
2010-10-22 08:38:21 +00:00
{
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
if ((sides & SIDE_LEFT) == 0)
GtkStyleSet: Register the border-style and border-color properties This is also implemented in the theming engine, although the default CSS should be using it in order to theme buttons, troughs, sliders and such.
2010-10-22 08:38:21 +00:00
cairo_new_sub_path (cr);
cairo_arc (cr, x + radius, y + radius, radius, 5 * (G_PI / 4), 3 * (G_PI / 2));
}
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
else if ((sides & SIDE_LEFT) == 0)
cairo_move_to (cr, x, y);
GtkStyleSet: Register the border-style and border-color properties This is also implemented in the theming engine, although the default CSS should be using it in order to theme buttons, troughs, sliders and such.
2010-10-22 08:38:21 +00:00
if (radius == 0 ||
Fix handling of junctions in frame drawing code
2010-11-23 21:13:15 +00:00
(junction & GTK_JUNCTION_CORNER_TOPRIGHT))
GtkStyleSet: Register the border-style and border-color properties This is also implemented in the theming engine, although the default CSS should be using it in order to theme buttons, troughs, sliders and such.
2010-10-22 08:38:21 +00:00
cairo_line_to (cr, x + width, y);
else
cairo_arc (cr, x + width - radius, y + radius, radius, 3 * (G_PI / 2), - G_PI / 4);
GtkThemingEngine: Honor border-radius in render_background().
2010-10-20 16:47:28 +00:00
}
}
theming: Implement non-uniform border-width in the theming engine. The border-width CSS parameter takes up to 4 values, but it was being ignored by the theming engine until now.
2011-03-28 22:59:49 +00:00
static void
_cairo_uneven_frame (cairo_t *cr,
gdouble radius,
gdouble x,
gdouble y,
gdouble width,
gdouble height,
GtkBorder *border,
GtkJunctionSides junction)
{
cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
cairo_set_line_width (cr, 1);
_cairo_round_rectangle_sides (cr, (gdouble) radius,
x, y,
width, height,
SIDE_ALL, junction);
_cairo_round_rectangle_sides (cr, (gdouble) radius,
x + border->left,
y + border->top,
width - border->left - border->right,
height - border->top - border->bottom,
SIDE_ALL, junction);
}
Avoid the need for cairo_push_group() in gtk_render_background() This operation is potentially expensive, so the code has been refurbished so avoid the cases it was needed for. Antialiased cairo_clip() has been also reduced to transitions with surface patterns involved.
2011-02-09 16:00:49 +00:00
/* Set the appropriate matrix for
* patterns coming from the style context
*/
static void
style_pattern_set_matrix (cairo_pattern_t *pattern,
gdouble width,
gdouble height)
{
cairo_matrix_t matrix;
gint w, h;
if (cairo_pattern_get_type (pattern) == CAIRO_PATTERN_TYPE_SURFACE)
{
cairo_surface_t *surface;
cairo_pattern_get_surface (pattern, &surface);
w = cairo_image_surface_get_width (surface);
h = cairo_image_surface_get_height (surface);
}
else
w = h = 1;
cairo_matrix_init_scale (&matrix, (gdouble) w / width, (gdouble) h / height);
cairo_pattern_set_matrix (pattern, &matrix);
}
GtkThemingEngine: Add vmethod to render backgrounds.
2010-03-27 19:06:44 +00:00
static void
GtkThemingEngine: split background rendering to a private function.
2010-11-29 10:24:04 +00:00
render_background_internal (GtkThemingEngine *engine,
cairo_t *cr,
gdouble x,
gdouble y,
gdouble width,
gdouble height,
GtkJunctionSides junction)
GtkThemingEngine: Add vmethod to render backgrounds.
2010-03-27 19:06:44 +00:00
{
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
GdkRGBA bg_color;
GtkThemingEngine: use background-image in render_background()
2010-09-02 00:14:10 +00:00
cairo_pattern_t *pattern;
GtkThemingEngine: Add vmethod to render backgrounds.
2010-03-27 19:06:44 +00:00
GtkStateFlags flags;
Change semantics of the methods to check whether an animation is running. It actually messed up with the state being actually set, and having a transition animation running for it. Now this dichotomy is removed, and gtk_style_context_state_is_running() only checks whether an animation is running, leaving state checking to flags & GTK_STATE_FLAG_*.
2010-10-19 10:09:23 +00:00
gboolean running;
GtkGradient: Handle symbolic gradients. The css parser has been modified to parse correctly radial gradients: background-image: -gtk-gradient (radial, center center, 0, center center, 0.8, from (#000), to (#fff)); The theming engine has been modified to correctly animate these, as well as transitions between different pattern types.
2010-10-12 19:48:23 +00:00
gdouble progress, alpha = 1;
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
GtkBorder border;
Ensure gtk_render_background()/frame() yield the same shape On rounded boxes the background and the frame wouldn't fit in perfectly, leaving some visual noise in the corners. This is now gone.
2011-02-05 12:53:04 +00:00
gint radius, border_width;
GtkBorderStyle border_style;
Avoid the need for cairo_push_group() in gtk_render_background() This operation is potentially expensive, so the code has been refurbished so avoid the cases it was needed for. Antialiased cairo_clip() has been also reduced to transitions with surface patterns involved.
2011-02-09 16:00:49 +00:00
gdouble mat_w, mat_h;
cairo_matrix_t identity;
GtkThemingEngine: Add vmethod to render backgrounds.
2010-03-27 19:06:44 +00:00
Avoid the need for cairo_push_group() in gtk_render_background() This operation is potentially expensive, so the code has been refurbished so avoid the cases it was needed for. Antialiased cairo_clip() has been also reduced to transitions with surface patterns involved.
2011-02-09 16:00:49 +00:00
/* Use unmodified size for pattern scaling */
mat_w = width;
mat_h = height;
gtk: bail out in render_background_internal() if the extents are <= 0 otherwise we run into scaling the cairo_t into a borken state that's not fixable by cairo_restore().
2011-02-06 10:13:42 +00:00
GtkThemingEngine: Add vmethod to render backgrounds.
2010-03-27 19:06:44 +00:00
flags = gtk_theming_engine_get_state (engine);
Avoid the need for cairo_push_group() in gtk_render_background() This operation is potentially expensive, so the code has been refurbished so avoid the cases it was needed for. Antialiased cairo_clip() has been also reduced to transitions with surface patterns involved.
2011-02-09 16:00:49 +00:00
cairo_matrix_init_identity (&identity);
GtkThemingEngine: Improve background rendering. Now active and selected states are taken into account, and GtkSpinButton buttons are special cased.
2010-08-02 13:46:08 +00:00
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gtk_theming_engine_get_background_color (engine, flags, &bg_color);
gtk_theming_engine_get_border (engine, flags, &border);
GtkThemingEngine: use background-image in render_background()
2010-09-02 00:14:10 +00:00
gtk_theming_engine_get (engine, flags,
"background-image", &pattern,
GtkThemingEngine: Honor border-radius in render_background().
2010-10-20 16:47:28 +00:00
"border-radius", &radius,
Ensure gtk_render_background()/frame() yield the same shape On rounded boxes the background and the frame wouldn't fit in perfectly, leaving some visual noise in the corners. This is now gone.
2011-02-05 12:53:04 +00:00
"border-style", &border_style,
GtkThemingEngine: use background-image in render_background()
2010-09-02 00:14:10 +00:00
NULL);
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
border_width = MIN (MIN (border.top, border.bottom),
MIN (border.left, border.right));
Ensure gtk_render_background()/frame() yield the same shape On rounded boxes the background and the frame wouldn't fit in perfectly, leaving some visual noise in the corners. This is now gone.
2011-02-05 12:53:04 +00:00
Avoid the need for cairo_push_group() in gtk_render_background() This operation is potentially expensive, so the code has been refurbished so avoid the cases it was needed for. Antialiased cairo_clip() has been also reduced to transitions with surface patterns involved.
2011-02-09 16:00:49 +00:00
if (border_width > 1 &&
border_style == GTK_BORDER_STYLE_NONE)
{
x += (gdouble) border_width / 2;
y += (gdouble) border_width / 2;
width -= border_width;
height -= border_width;
}
else
{
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
x += border.left;
y += border.top;
width -= border.left + border.right;
height -= border.top + border.bottom;
Avoid the need for cairo_push_group() in gtk_render_background() This operation is potentially expensive, so the code has been refurbished so avoid the cases it was needed for. Antialiased cairo_clip() has been also reduced to transitions with surface patterns involved.
2011-02-09 16:00:49 +00:00
}
if (width <= 0 || height <= 0)
return;
cairo_save (cr);
themingengine: don't set a line width before saving the cairo context https://bugzilla.gnome.org/show_bug.cgi?id=647086
2011-04-07 19:22:18 +00:00
cairo_set_line_width (cr, border_width);
Avoid the need for cairo_push_group() in gtk_render_background() This operation is potentially expensive, so the code has been refurbished so avoid the cases it was needed for. Antialiased cairo_clip() has been also reduced to transitions with surface patterns involved.
2011-02-09 16:00:49 +00:00
cairo_translate (cr, x, y);
running = gtk_theming_engine_state_is_running (engine, GTK_STATE_PRELIGHT, &progress);
GtkThemingEngine: Honor border-radius in render_background().
2010-10-20 16:47:28 +00:00
GtkThemingEngine: Clear the background for .background class
2010-10-23 22:04:34 +00:00
if (gtk_theming_engine_has_class (engine, "background"))
{
cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, 0.0); /* transparent */
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
cairo_paint (cr);
}
Change semantics of the methods to check whether an animation is running. It actually messed up with the state being actually set, and having a transition animation running for it. Now this dichotomy is removed, and gtk_style_context_state_is_running() only checks whether an animation is running, leaving state checking to flags & GTK_STATE_FLAG_*.
2010-10-19 10:09:23 +00:00
if (running)
GtkThemingEngine: Implement animations between gradients/colors.
2010-10-05 08:55:40 +00:00
{
cairo_pattern_t *other_pattern;
GtkStateFlags other_flags;
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
GdkRGBA other_bg;
GtkThemingEngine: Implement animations between gradients/colors.
2010-10-05 08:55:40 +00:00
cairo_pattern_t *new_pattern = NULL;
Change semantics of the methods to check whether an animation is running. It actually messed up with the state being actually set, and having a transition animation running for it. Now this dichotomy is removed, and gtk_style_context_state_is_running() only checks whether an animation is running, leaving state checking to flags & GTK_STATE_FLAG_*.
2010-10-19 10:09:23 +00:00
if (flags & GTK_STATE_FLAG_PRELIGHT)
GtkThemingEngine: Implement animations between gradients/colors.
2010-10-05 08:55:40 +00:00
{
other_flags = flags & ~(GTK_STATE_FLAG_PRELIGHT);
progress = 1 - progress;
}
else
other_flags = flags | GTK_STATE_FLAG_PRELIGHT;
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gtk_theming_engine_get_background_color (engine, other_flags, &other_bg);
GtkThemingEngine: Implement animations between gradients/colors.
2010-10-05 08:55:40 +00:00
gtk_theming_engine_get (engine, other_flags,
"background-image", &other_pattern,
NULL);
if (pattern && other_pattern)
{
GtkGradient: Handle symbolic gradients. The css parser has been modified to parse correctly radial gradients: background-image: -gtk-gradient (radial, center center, 0, center center, 0.8, from (#000), to (#fff)); The theming engine has been modified to correctly animate these, as well as transitions between different pattern types.
2010-10-12 19:48:23 +00:00
cairo_pattern_type_t type, other_type;
GtkThemingEngine: Implement animations between gradients/colors.
2010-10-05 08:55:40 +00:00
gint n0, n1;
cairo_pattern_get_color_stop_count (pattern, &n0);
cairo_pattern_get_color_stop_count (other_pattern, &n1);
GtkGradient: Handle symbolic gradients. The css parser has been modified to parse correctly radial gradients: background-image: -gtk-gradient (radial, center center, 0, center center, 0.8, from (#000), to (#fff)); The theming engine has been modified to correctly animate these, as well as transitions between different pattern types.
2010-10-12 19:48:23 +00:00
type = cairo_pattern_get_type (pattern);
other_type = cairo_pattern_get_type (other_pattern);
GtkThemingEngine: Implement animations between gradients/colors.
2010-10-05 08:55:40 +00:00
GtkGradient: Handle symbolic gradients. The css parser has been modified to parse correctly radial gradients: background-image: -gtk-gradient (radial, center center, 0, center center, 0.8, from (#000), to (#fff)); The theming engine has been modified to correctly animate these, as well as transitions between different pattern types.
2010-10-12 19:48:23 +00:00
if (type == other_type && n0 == n1)
GtkThemingEngine: Implement animations between gradients/colors.
2010-10-05 08:55:40 +00:00
{
GtkGradient: Handle symbolic gradients. The css parser has been modified to parse correctly radial gradients: background-image: -gtk-gradient (radial, center center, 0, center center, 0.8, from (#000), to (#fff)); The theming engine has been modified to correctly animate these, as well as transitions between different pattern types.
2010-10-12 19:48:23 +00:00
gdouble offset0, red0, green0, blue0, alpha0;
gdouble offset1, red1, green1, blue1, alpha1;
gdouble x00, x01, y00, y01, x10, x11, y10, y11;
gdouble r00, r01, r10, r11;
guint i;
if (type == CAIRO_PATTERN_TYPE_LINEAR)
{
cairo_pattern_get_linear_points (pattern, &x00, &y00, &x01, &y01);
cairo_pattern_get_linear_points (other_pattern, &x10, &y10, &x11, &y11);
new_pattern = cairo_pattern_create_linear (x00 + (x10 - x00) * progress,
y00 + (y10 - y00) * progress,
x01 + (x11 - x01) * progress,
y01 + (y11 - y01) * progress);
}
else
{
cairo_pattern_get_radial_circles (pattern, &x00, &y00, &r00, &x01, &y01, &r01);
cairo_pattern_get_radial_circles (other_pattern, &x10, &y10, &r10, &x11, &y11, &r11);
new_pattern = cairo_pattern_create_radial (x00 + (x10 - x00) * progress,
y00 + (y10 - y00) * progress,
r00 + (r10 - r00) * progress,
x01 + (x11 - x01) * progress,
y01 + (y11 - y01) * progress,
r01 + (r11 - r01) * progress);
}
cairo_pattern_set_filter (new_pattern, CAIRO_FILTER_FAST);
i = 0;
/* Blend both gradients into one */
while (i < n0 && i < n1)
{
cairo_pattern_get_color_stop_rgba (pattern, i,
&offset0,
&red0, &green0, &blue0,
&alpha0);
cairo_pattern_get_color_stop_rgba (other_pattern, i,
&offset1,
&red1, &green1, &blue1,
&alpha1);
cairo_pattern_add_color_stop_rgba (new_pattern,
offset0 + ((offset1 - offset0) * progress),
red0 + ((red1 - red0) * progress),
green0 + ((green1 - green0) * progress),
blue0 + ((blue1 - blue0) * progress),
alpha0 + ((alpha1 - alpha0) * progress));
i++;
}
}
else
{
/* Different pattern types, or different color
* stop counts, alpha blend both patterns.
*/
Avoid the need for cairo_push_group() in gtk_render_background() This operation is potentially expensive, so the code has been refurbished so avoid the cases it was needed for. Antialiased cairo_clip() has been also reduced to transitions with surface patterns involved.
2011-02-09 16:00:49 +00:00
_cairo_round_rectangle_sides (cr, (gdouble) radius,
0, 0, width, height,
SIDE_ALL, junction);
style_pattern_set_matrix (other_pattern, mat_w, mat_h);
GtkGradient: Handle symbolic gradients. The css parser has been modified to parse correctly radial gradients: background-image: -gtk-gradient (radial, center center, 0, center center, 0.8, from (#000), to (#fff)); The theming engine has been modified to correctly animate these, as well as transitions between different pattern types.
2010-10-12 19:48:23 +00:00
cairo_set_source (cr, other_pattern);
GtkThemingEngine: Honor border-radius in render_background().
2010-10-20 16:47:28 +00:00
cairo_fill_preserve (cr);
GtkGradient: Handle symbolic gradients. The css parser has been modified to parse correctly radial gradients: background-image: -gtk-gradient (radial, center center, 0, center center, 0.8, from (#000), to (#fff)); The theming engine has been modified to correctly animate these, as well as transitions between different pattern types.
2010-10-12 19:48:23 +00:00
Avoid the need for cairo_push_group() in gtk_render_background() This operation is potentially expensive, so the code has been refurbished so avoid the cases it was needed for. Antialiased cairo_clip() has been also reduced to transitions with surface patterns involved.
2011-02-09 16:00:49 +00:00
cairo_pattern_set_matrix (other_pattern, &identity);
GtkGradient: Handle symbolic gradients. The css parser has been modified to parse correctly radial gradients: background-image: -gtk-gradient (radial, center center, 0, center center, 0.8, from (#000), to (#fff)); The theming engine has been modified to correctly animate these, as well as transitions between different pattern types.
2010-10-12 19:48:23 +00:00
/* Set alpha for posterior drawing
* of the target pattern
*/
alpha = 1 - progress;
GtkThemingEngine: Implement animations between gradients/colors.
2010-10-05 08:55:40 +00:00
}
}
else if (pattern || other_pattern)
{
cairo_pattern_t *p;
Rely only on fg/bg colors. "foreground-color" has been renamed to just "color" as in regular CSS, and the "text-color" and "base-color" properties have been removed. The default CSS has been changed to have widgets cope with this change.
2010-10-29 03:33:38 +00:00
const GdkRGBA *c;
GtkGradient: Handle symbolic gradients. The css parser has been modified to parse correctly radial gradients: background-image: -gtk-gradient (radial, center center, 0, center center, 0.8, from (#000), to (#fff)); The theming engine has been modified to correctly animate these, as well as transitions between different pattern types.
2010-10-12 19:48:23 +00:00
gdouble x0, y0, x1, y1, r0, r1;
GtkThemingEngine: Implement animations between gradients/colors.
2010-10-05 08:55:40 +00:00
gint n, i;
/* Blend a pattern with a color */
if (pattern)
{
p = pattern;
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
c = &other_bg;
GtkThemingEngine: Implement animations between gradients/colors.
2010-10-05 08:55:40 +00:00
progress = 1 - progress;
}
else
{
p = other_pattern;
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
c = &bg_color;
GtkThemingEngine: Implement animations between gradients/colors.
2010-10-05 08:55:40 +00:00
}
GtkGradient: Handle symbolic gradients. The css parser has been modified to parse correctly radial gradients: background-image: -gtk-gradient (radial, center center, 0, center center, 0.8, from (#000), to (#fff)); The theming engine has been modified to correctly animate these, as well as transitions between different pattern types.
2010-10-12 19:48:23 +00:00
if (cairo_pattern_get_type (p) == CAIRO_PATTERN_TYPE_LINEAR)
{
cairo_pattern_get_linear_points (p, &x0, &y0, &x1, &y1);
new_pattern = cairo_pattern_create_linear (x0, y0, x1, y1);
}
else
{
cairo_pattern_get_radial_circles (p, &x0, &y0, &r0, &x1, &y1, &r1);
new_pattern = cairo_pattern_create_radial (x0, y0, r0, x1, y1, r1);
}
GtkThemingEngine: Implement animations between gradients/colors.
2010-10-05 08:55:40 +00:00
cairo_pattern_get_color_stop_count (p, &n);
for (i = 0; i < n; i++)
{
Use GdkRGBA all around in GtkStyleContext.
2010-10-22 10:41:19 +00:00
gdouble red1, green1, blue1, alpha1;
gdouble offset;
GtkThemingEngine: Implement animations between gradients/colors.
2010-10-05 08:55:40 +00:00
cairo_pattern_get_color_stop_rgba (p, i,
&offset,
&red1, &green1, &blue1,
Use GdkRGBA all around in GtkStyleContext.
2010-10-22 10:41:19 +00:00
&alpha1);
GtkThemingEngine: Implement animations between gradients/colors.
2010-10-05 08:55:40 +00:00
cairo_pattern_add_color_stop_rgba (new_pattern, offset,
Use GdkRGBA all around in GtkStyleContext.
2010-10-22 10:41:19 +00:00
c->red + ((red1 - c->red) * progress),
c->green + ((green1 - c->green) * progress),
c->blue + ((blue1 - c->blue) * progress),
c->alpha + ((alpha1 - c->alpha) * progress));
GtkThemingEngine: Implement animations between gradients/colors.
2010-10-05 08:55:40 +00:00
}
}
else
{
/* Merge just colors */
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
new_pattern = cairo_pattern_create_rgba (CLAMP (bg_color.red + ((other_bg.red - bg_color.red) * progress), 0, 1),
CLAMP (bg_color.green + ((other_bg.green - bg_color.green) * progress), 0, 1),
CLAMP (bg_color.blue + ((other_bg.blue - bg_color.blue) * progress), 0, 1),
CLAMP (bg_color.alpha + ((other_bg.alpha - bg_color.alpha) * progress), 0, 1));
GtkThemingEngine: Implement animations between gradients/colors.
2010-10-05 08:55:40 +00:00
}
if (new_pattern)
{
/* Replace pattern to use */
cairo_pattern_destroy (pattern);
pattern = new_pattern;
}
if (other_pattern)
cairo_pattern_destroy (other_pattern);
}
Avoid the need for cairo_push_group() in gtk_render_background() This operation is potentially expensive, so the code has been refurbished so avoid the cases it was needed for. Antialiased cairo_clip() has been also reduced to transitions with surface patterns involved.
2011-02-09 16:00:49 +00:00
_cairo_round_rectangle_sides (cr, (gdouble) radius,
0, 0, width, height,
SIDE_ALL, junction);
GtkThemingEngine: use background-image in render_background()
2010-09-02 00:14:10 +00:00
if (pattern)
{
Avoid the need for cairo_push_group() in gtk_render_background() This operation is potentially expensive, so the code has been refurbished so avoid the cases it was needed for. Antialiased cairo_clip() has been also reduced to transitions with surface patterns involved.
2011-02-09 16:00:49 +00:00
style_pattern_set_matrix (pattern, mat_w, mat_h);
GtkThemingEngine: use background-image in render_background()
2010-09-02 00:14:10 +00:00
cairo_set_source (cr, pattern);
}
GtkThemingEngine: Improve background rendering. Now active and selected states are taken into account, and GtkSpinButton buttons are special cased.
2010-08-02 13:46:08 +00:00
else
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gdk_cairo_set_source_rgba (cr, &bg_color);
GtkThemingEngine: Add vmethod to render backgrounds.
2010-03-27 19:06:44 +00:00
GtkThemingEngine: Get rid of obsolete code for tooltips.
2010-11-08 11:48:29 +00:00
if (alpha == 1)
Ensure gtk_render_background()/frame() yield the same shape On rounded boxes the background and the frame wouldn't fit in perfectly, leaving some visual noise in the corners. This is now gone.
2011-02-05 12:53:04 +00:00
{
Avoid the need for cairo_push_group() in gtk_render_background() This operation is potentially expensive, so the code has been refurbished so avoid the cases it was needed for. Antialiased cairo_clip() has been also reduced to transitions with surface patterns involved.
2011-02-09 16:00:49 +00:00
if (border_width > 1 &&
border_style != GTK_BORDER_STYLE_NONE)
{
/* stroke with the same source, so the background
* has exactly the shape than the frame, this
* is important so gtk_render_background() and
* gtk_render_frame() fit perfectly with round
* borders.
*/
cairo_fill_preserve (cr);
cairo_stroke (cr);
}
else
cairo_fill (cr);
Ensure gtk_render_background()/frame() yield the same shape On rounded boxes the background and the frame wouldn't fit in perfectly, leaving some visual noise in the corners. This is now gone.
2011-02-05 12:53:04 +00:00
}
else
{
Avoid the need for cairo_push_group() in gtk_render_background() This operation is potentially expensive, so the code has been refurbished so avoid the cases it was needed for. Antialiased cairo_clip() has been also reduced to transitions with surface patterns involved.
2011-02-09 16:00:49 +00:00
cairo_save (cr);
_cairo_round_rectangle_sides (cr, (gdouble) radius,
0, 0, width, height,
SIDE_ALL, junction);
cairo_clip (cr);
Ensure gtk_render_background()/frame() yield the same shape On rounded boxes the background and the frame wouldn't fit in perfectly, leaving some visual noise in the corners. This is now gone.
2011-02-05 12:53:04 +00:00
Avoid the need for cairo_push_group() in gtk_render_background() This operation is potentially expensive, so the code has been refurbished so avoid the cases it was needed for. Antialiased cairo_clip() has been also reduced to transitions with surface patterns involved.
2011-02-09 16:00:49 +00:00
cairo_paint_with_alpha (cr, alpha);
Ensure gtk_render_background()/frame() yield the same shape On rounded boxes the background and the frame wouldn't fit in perfectly, leaving some visual noise in the corners. This is now gone.
2011-02-05 12:53:04 +00:00
Avoid the need for cairo_push_group() in gtk_render_background() This operation is potentially expensive, so the code has been refurbished so avoid the cases it was needed for. Antialiased cairo_clip() has been also reduced to transitions with surface patterns involved.
2011-02-09 16:00:49 +00:00
cairo_restore (cr);
}
if (pattern)
Ensure gtk_render_background()/frame() yield the same shape On rounded boxes the background and the frame wouldn't fit in perfectly, leaving some visual noise in the corners. This is now gone.
2011-02-05 12:53:04 +00:00
{
Avoid the need for cairo_push_group() in gtk_render_background() This operation is potentially expensive, so the code has been refurbished so avoid the cases it was needed for. Antialiased cairo_clip() has been also reduced to transitions with surface patterns involved.
2011-02-09 16:00:49 +00:00
cairo_pattern_set_matrix (pattern, &identity);
cairo_pattern_destroy (pattern);
Ensure gtk_render_background()/frame() yield the same shape On rounded boxes the background and the frame wouldn't fit in perfectly, leaving some visual noise in the corners. This is now gone.
2011-02-05 12:53:04 +00:00
}
Use cairo_push_group() to mix backgrounds during transitions It also helps remove the cairo_clip() call to achieve the rounded shape.
2011-02-05 12:44:30 +00:00
GtkThemingEngine: Add vmethod to render backgrounds.
2010-03-27 19:06:44 +00:00
cairo_restore (cr);
}
GtkThemingEngine: split background rendering to a private function.
2010-11-29 10:24:04 +00:00
static void
gtk_theming_engine_render_background (GtkThemingEngine *engine,
cairo_t *cr,
gdouble x,
gdouble y,
gdouble width,
gdouble height)
{
GtkJunctionSides junction;
junction = gtk_theming_engine_get_junction_sides (engine);
render_background_internal (engine, cr,
x, y, width, height,
junction);
}
GtkThemingEngine: Draw 3D-like effects on square frames with lines.
2010-11-24 00:19:06 +00:00
/* Renders the small triangle on corners so
* frames with 0 radius have a 3D-like effect
*/
static void
_cairo_corner_triangle (cairo_t *cr,
gdouble x,
gdouble y,
gint size)
{
gint i;
cairo_move_to (cr, x + 0.5, y + size - 0.5);
cairo_line_to (cr, x + size - 0.5, y + size - 0.5);
cairo_line_to (cr, x + size - 0.5, y + 0.5);
for (i = 1; i < size - 1; i++)
{
cairo_move_to (cr, x + size - 0.5, y + i + 0.5);
cairo_line_to (cr, x + (size - i) - 0.5, y + i + 0.5);
}
}
GtkThemingEngine: Add vmethod to render frames.
2010-03-27 19:11:31 +00:00
static void
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
render_frame_internal (GtkThemingEngine *engine,
cairo_t *cr,
gdouble x,
gdouble y,
gdouble width,
gdouble height,
guint hidden_side,
GtkJunctionSides junction)
GtkThemingEngine: Add vmethod to render frames.
2010-03-27 19:11:31 +00:00
{
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
GtkStateFlags state;
GtkThemingEngine: Improve rendering of inset/outset borders.
2010-10-23 16:33:07 +00:00
GdkRGBA lighter;
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
GdkRGBA border_color;
GtkStyleSet: Register the border-style and border-color properties This is also implemented in the theming engine, although the default CSS should be using it in order to theme buttons, troughs, sliders and such.
2010-10-22 08:38:21 +00:00
GtkBorderStyle border_style;
gint border_width, radius;
GtkStyleContext: handle prelight transitions
2010-11-24 22:21:28 +00:00
gdouble progress, d1, d2, m;
gboolean running;
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
GtkBorder border;
theming: Implement non-uniform border-width in the theming engine. The border-width CSS parameter takes up to 4 values, but it was being ignored by the theming engine until now.
2011-03-28 22:59:49 +00:00
gboolean uniform_border;
GtkThemingEngine: Add vmethod to render frames.
2010-03-27 19:11:31 +00:00
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
state = gtk_theming_engine_get_state (engine);
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gtk_theming_engine_get_border_color (engine, state, &border_color);
gtk_theming_engine_get_border (engine, state, &border);
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
gtk_theming_engine_get (engine, state,
GtkStyleSet: Register the border-style and border-color properties This is also implemented in the theming engine, although the default CSS should be using it in order to theme buttons, troughs, sliders and such.
2010-10-22 08:38:21 +00:00
"border-style", &border_style,
"border-radius", &radius,
GtkThemingEngine: Add vmethod to render frames.
2010-03-27 19:11:31 +00:00
NULL);
GtkThemingEngine: Use border-image to render borders if an image is available.
2010-09-24 20:08:49 +00:00
GtkStyleContext: handle prelight transitions
2010-11-24 22:21:28 +00:00
running = gtk_theming_engine_state_is_running (engine, GTK_STATE_PRELIGHT, &progress);
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
border_width = MIN (MIN (border.top, border.bottom),
MIN (border.left, border.right));
theming: Implement non-uniform border-width in the theming engine. The border-width CSS parameter takes up to 4 values, but it was being ignored by the theming engine until now.
2011-03-28 22:59:49 +00:00
uniform_border = (border.top == border.bottom &&
border.top == border.left &&
border.top == border.right);
GtkStyleContext: handle prelight transitions
2010-11-24 22:21:28 +00:00
if (running)
{
GtkStateFlags other_state;
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
GdkRGBA other_color;
GtkStyleContext: handle prelight transitions
2010-11-24 22:21:28 +00:00
if (state & GTK_STATE_FLAG_PRELIGHT)
{
other_state = state & ~(GTK_STATE_FLAG_PRELIGHT);
progress = 1 - progress;
}
else
other_state = state | GTK_STATE_FLAG_PRELIGHT;
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gtk_theming_engine_get_border_color (engine, other_state, &other_color);
GtkStyleContext: handle prelight transitions
2010-11-24 22:21:28 +00:00
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
border_color.red = CLAMP (border_color.red + ((other_color.red - border_color.red) * progress), 0, 1);
border_color.green = CLAMP (border_color.green + ((other_color.green - border_color.green) * progress), 0, 1);
border_color.blue = CLAMP (border_color.blue + ((other_color.blue - border_color.blue) * progress), 0, 1);
border_color.alpha = CLAMP (border_color.alpha + ((other_color.alpha - border_color.alpha) * progress), 0, 1);
GtkStyleContext: handle prelight transitions
2010-11-24 22:21:28 +00:00
}
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
cairo_save (cr);
GtkThemingEngine: Add vmethod to render frames.
2010-03-27 19:11:31 +00:00
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
color_shade (&border_color, 1.8, &lighter);
GtkThemingEngine: Cairo-ify frame rendering from GtkStyle.
2010-07-19 09:59:27 +00:00
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
switch (border_style)
{
case GTK_BORDER_STYLE_NONE:
break;
case GTK_BORDER_STYLE_SOLID:
cairo_set_line_width (cr, border_width);
cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
GtkThemingEngine: Render correctly spinbutton buttons.
2010-08-03 18:38:23 +00:00
theming: Implement non-uniform border-width in the theming engine. The border-width CSS parameter takes up to 4 values, but it was being ignored by the theming engine until now.
2011-03-28 22:59:49 +00:00
gdk_cairo_set_source_rgba (cr, &border_color);
if (uniform_border)
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
{
theming: Implement non-uniform border-width in the theming engine. The border-width CSS parameter takes up to 4 values, but it was being ignored by the theming engine until now.
2011-03-28 22:59:49 +00:00
if (border_width > 1)
{
x += (gdouble) border_width / 2;
y += (gdouble) border_width / 2;
width -= border_width;
height -= border_width;
}
else if (border_width == 1)
{
x += 0.5;
y += 0.5;
width -= 1;
height -= 1;
}
_cairo_round_rectangle_sides (cr, (gdouble) radius,
x, y, width, height,
SIDE_ALL & ~(hidden_side),
junction);
cairo_stroke (cr);
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
}
theming: Implement non-uniform border-width in the theming engine. The border-width CSS parameter takes up to 4 values, but it was being ignored by the theming engine until now.
2011-03-28 22:59:49 +00:00
else
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
{
theming: Implement non-uniform border-width in the theming engine. The border-width CSS parameter takes up to 4 values, but it was being ignored by the theming engine until now.
2011-03-28 22:59:49 +00:00
cairo_save (cr);
_cairo_uneven_frame (cr, (gdouble) radius,
x, y, width, height,
&border, junction);
cairo_fill (cr);
cairo_restore (cr);
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
}
GtkThemingEngine: Render correctly spinbutton buttons.
2010-08-03 18:38:23 +00:00
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
break;
case GTK_BORDER_STYLE_INSET:
case GTK_BORDER_STYLE_OUTSET:
cairo_set_line_width (cr, border_width);
GtkThemingEngine: Render rounded frames with light/shadow connections at 45°
2010-11-24 00:17:44 +00:00
if (radius == 0)
cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
else
cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT);
GtkThemingEngine: Add vmethod to render frames.
2010-03-27 19:11:31 +00:00
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
if (border_width > 1)
{
d1 = (gdouble) border_width / 2;
GtkThemingEngine: don't overshoot when rendering frames.
2010-11-24 00:16:15 +00:00
d2 = border_width;
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
}
else
{
d1 = 0.5;
d2 = 1;
}
GtkThemingEngine: Add vmethod to render frames.
2010-03-27 19:11:31 +00:00
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
cairo_save (cr);
GtkThemingEngine: Improve rendering of inset/outset borders.
2010-10-23 16:33:07 +00:00
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
m = MIN (width, height);
m /= 2;
GtkThemingEngine: render 0-radius frames with 3D-like 45° corner effect
2010-10-25 08:24:15 +00:00
theming: Implement non-uniform border-width in the theming engine. The border-width CSS parameter takes up to 4 values, but it was being ignored by the theming engine until now.
2011-03-28 22:59:49 +00:00
if (uniform_border)
{
if (border_style == GTK_BORDER_STYLE_INSET)
gdk_cairo_set_source_rgba (cr, &lighter);
else
gdk_cairo_set_source_rgba (cr, &border_color);
GtkThemingEngine: Cairo-ify frame rendering from GtkStyle.
2010-07-19 09:59:27 +00:00
theming: Implement non-uniform border-width in the theming engine. The border-width CSS parameter takes up to 4 values, but it was being ignored by the theming engine until now.
2011-03-28 22:59:49 +00:00
_cairo_round_rectangle_sides (cr, (gdouble) radius,
x + d1, y + d1,
width - d2, height - d2,
(SIDE_BOTTOM | SIDE_RIGHT) & ~(hidden_side),
junction);
cairo_stroke (cr);
if (border_style == GTK_BORDER_STYLE_INSET)
gdk_cairo_set_source_rgba (cr, &border_color);
else
gdk_cairo_set_source_rgba (cr, &lighter);
GtkThemingEngine: render 0-radius frames with 3D-like 45° corner effect
2010-10-25 08:24:15 +00:00
theming: Implement non-uniform border-width in the theming engine. The border-width CSS parameter takes up to 4 values, but it was being ignored by the theming engine until now.
2011-03-28 22:59:49 +00:00
_cairo_round_rectangle_sides (cr, (gdouble) radius,
x + d1, y + d1,
width - d2, height - d2,
(SIDE_TOP | SIDE_LEFT) & ~(hidden_side),
junction);
cairo_stroke (cr);
}
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
else
theming: Implement non-uniform border-width in the theming engine. The border-width CSS parameter takes up to 4 values, but it was being ignored by the theming engine until now.
2011-03-28 22:59:49 +00:00
{
cairo_save (cr);
GtkThemingEngine: render 0-radius frames with 3D-like 45° corner effect
2010-10-25 08:24:15 +00:00
theming: Implement non-uniform border-width in the theming engine. The border-width CSS parameter takes up to 4 values, but it was being ignored by the theming engine until now.
2011-03-28 22:59:49 +00:00
/* Bottom/right */
if (border_style == GTK_BORDER_STYLE_INSET)
gdk_cairo_set_source_rgba (cr, &lighter);
else
gdk_cairo_set_source_rgba (cr, &border_color);
_cairo_uneven_frame (cr, (gdouble) radius,
x, y, width, height,
&border, junction);
cairo_fill (cr);
/* Top/left */
cairo_move_to (cr, x, y);
cairo_line_to (cr, x + width, y);
cairo_line_to (cr, x + width - border.right - radius / 2, y + border.top + radius / 2);
cairo_line_to (cr, x + width - border.right - radius / 2, y + height - border.bottom - radius / 2);
cairo_line_to (cr, x + border.left + radius / 2, y + height - border.bottom - radius / 2);
cairo_line_to (cr, x, y + height);
cairo_close_path (cr);
cairo_clip (cr);
if (border_style == GTK_BORDER_STYLE_INSET)
gdk_cairo_set_source_rgba (cr, &border_color);
else
gdk_cairo_set_source_rgba (cr, &lighter);
_cairo_uneven_frame (cr, (gdouble) radius,
x, y, width, height,
&border, junction);
cairo_fill (cr);
cairo_restore (cr);
}
GtkThemingEngine: Add vmethod to render frames.
2010-03-27 19:11:31 +00:00
GtkThemingEngine: Also render topright and bottomleft corners if junction sides say so
2010-11-24 22:20:15 +00:00
if (border_width > 1)
GtkThemingEngine: Draw 3D-like effects on square frames with lines.
2010-11-24 00:19:06 +00:00
{
/* overprint top/right and bottom/left corner
GtkThemingEngine: Also render topright and bottomleft corners if junction sides say so
2010-11-24 22:20:15 +00:00
* triangles if there are square corners there,
* to give the box a 3D-like appearance.
GtkThemingEngine: Draw 3D-like effects on square frames with lines.
2010-11-24 00:19:06 +00:00
*/
GtkThemingEngine: Also render topright and bottomleft corners if junction sides say so
2010-11-24 22:20:15 +00:00
cairo_save (cr);
GtkThemingEngine: Draw 3D-like effects on square frames with lines.
2010-11-24 00:19:06 +00:00
if (border_style == GTK_BORDER_STYLE_INSET)
gdk_cairo_set_source_rgba (cr, &lighter);
else
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gdk_cairo_set_source_rgba (cr, &border_color);
GtkThemingEngine: Draw 3D-like effects on square frames with lines.
2010-11-24 00:19:06 +00:00
cairo_set_line_width (cr, 1);
GtkThemingEngine: Also render topright and bottomleft corners if junction sides say so
2010-11-24 22:20:15 +00:00
if (radius == 0 ||
(junction & GTK_JUNCTION_CORNER_TOPRIGHT) != 0)
_cairo_corner_triangle (cr,
x + width - border_width, y,
border_width);
if (radius == 0 ||
(junction & GTK_JUNCTION_CORNER_BOTTOMLEFT) != 0)
_cairo_corner_triangle (cr,
x, y + height - border_width,
border_width);
GtkThemingEngine: Draw 3D-like effects on square frames with lines.
2010-11-24 00:19:06 +00:00
cairo_stroke (cr);
cairo_restore (cr);
}
GtkStyleSet: Register the border-style and border-color properties This is also implemented in the theming engine, although the default CSS should be using it in order to theme buttons, troughs, sliders and such.
2010-10-22 08:38:21 +00:00
cairo_restore (cr);
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
break;
GtkStyleSet: Register the border-style and border-color properties This is also implemented in the theming engine, although the default CSS should be using it in order to theme buttons, troughs, sliders and such.
2010-10-22 08:38:21 +00:00
}
GtkThemingEngine: Cairo-ify frame rendering from GtkStyle.
2010-07-19 09:59:27 +00:00
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
cairo_restore (cr);
GtkThemingEngine: Add vmethod to render frames.
2010-03-27 19:11:31 +00:00
}
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
static void
gtk_theming_engine_render_frame (GtkThemingEngine *engine,
cairo_t *cr,
gdouble x,
gdouble y,
gdouble width,
gdouble height)
{
GtkStateFlags flags;
Gtk9Slice *slice;
GtkBorderStyle border_style;
GtkJunctionSides junction;
flags = gtk_theming_engine_get_state (engine);
junction = gtk_theming_engine_get_junction_sides (engine);
gtk_theming_engine_get (engine, flags,
"border-image", &slice,
"border-style", &border_style,
NULL);
if (slice)
{
Fix abi check after recent merges
2010-12-05 17:18:30 +00:00
_gtk_9slice_render (slice, cr, x, y, width, height);
_gtk_9slice_unref (slice);
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
}
else if (border_style != GTK_BORDER_STYLE_NONE)
render_frame_internal (engine, cr,
x, y, width, height,
0, junction);
}
GtkThemingEngine: Add vmethod to render expanders.
2010-03-27 19:15:45 +00:00
static void
gtk_theming_engine_render_expander (GtkThemingEngine *engine,
cairo_t *cr,
gdouble x,
gdouble y,
gdouble width,
gdouble height)
{
GtkStateFlags flags;
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
GdkRGBA outline_color, fg_color;
GtkThemingEngine: Rip out expander rendering from old code.
2010-08-02 13:49:45 +00:00
double vertical_overshoot;
int diameter;
double radius;
double interp; /* interpolation factor for center position */
double x_double_horz, y_double_horz;
double x_double_vert, y_double_vert;
double x_double, y_double;
GtkThemingEngine: Add vmethod to render expanders.
2010-03-27 19:15:45 +00:00
gdouble angle;
GtkThemingEngine: Rip out expander rendering from old code.
2010-08-02 13:49:45 +00:00
gint line_width;
GtkThemingEngine: handle expander transitions to active, and rtl
2010-12-13 11:37:40 +00:00
gboolean running, is_rtl;
gdouble progress;
GtkThemingEngine: Add vmethod to render expanders.
2010-03-27 19:15:45 +00:00
cairo_save (cr);
flags = gtk_theming_engine_get_state (engine);
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gtk_theming_engine_get_color (engine, flags, &fg_color);
gtk_theming_engine_get_border_color (engine, flags, &outline_color);
GtkThemingEngine: Add vmethod to render expanders.
2010-03-27 19:15:45 +00:00
GtkThemingEngine: handle expander transitions to active, and rtl
2010-12-13 11:37:40 +00:00
running = gtk_theming_engine_state_is_running (engine, GTK_STATE_ACTIVE, &progress);
is_rtl = (gtk_theming_engine_get_direction (engine) == GTK_TEXT_DIR_RTL);
GtkThemingEngine: Rip out expander rendering from old code.
2010-08-02 13:49:45 +00:00
line_width = 1;
GtkThemingEngine: handle expander transitions to active, and rtl
2010-12-13 11:37:40 +00:00
if (!running)
progress = (flags & GTK_STATE_FLAG_ACTIVE) ? 1 : 0;
Deal with the abscence of horizontal/vertical class when rendering an expander
2011-01-12 21:07:34 +00:00
if (!gtk_theming_engine_has_class (engine, GTK_STYLE_CLASS_HORIZONTAL))
Make GtkToolItemGroup use GtkStyleContext
2011-01-12 01:35:19 +00:00
{
if (is_rtl)
angle = (G_PI) - ((G_PI / 2) * progress);
else
angle = (G_PI / 2) * progress;
}
GtkThemingEngine: Rip out expander rendering from old code.
2010-08-02 13:49:45 +00:00
else
Make GtkToolItemGroup use GtkStyleContext
2011-01-12 01:35:19 +00:00
{
if (is_rtl)
angle = (G_PI / 2) + ((G_PI / 2) * progress);
else
angle = (G_PI / 2) - ((G_PI / 2) * progress);
}
GtkThemingEngine: handle expander transitions to active, and rtl
2010-12-13 11:37:40 +00:00
interp = progress;
GtkThemingEngine: Rip out expander rendering from old code.
2010-08-02 13:49:45 +00:00
/* Compute distance that the stroke extends beyonds the end
* of the triangle we draw.
*/
vertical_overshoot = line_width / 2.0 * (1. / tan (G_PI / 8));
/* For odd line widths, we end the vertical line of the triangle
* at a half pixel, so we round differently.
*/
if (line_width % 2 == 1)
vertical_overshoot = ceil (0.5 + vertical_overshoot) - 0.5;
GtkThemingEngine: Add vmethod to render expanders.
2010-03-27 19:15:45 +00:00
else
GtkThemingEngine: Rip out expander rendering from old code.
2010-08-02 13:49:45 +00:00
vertical_overshoot = ceil (vertical_overshoot);
GtkThemingEngine: Add vmethod to render expanders.
2010-03-27 19:15:45 +00:00
GtkThemingEngine: Rip out expander rendering from old code.
2010-08-02 13:49:45 +00:00
/* Adjust the size of the triangle we draw so that the entire stroke fits
*/
diameter = (gint) MAX (3, width - 2 * vertical_overshoot);
/* If the line width is odd, we want the diameter to be even,
* and vice versa, so force the sum to be odd. This relationship
* makes the point of the triangle look right.
*/
diameter -= (1 - (diameter + line_width) % 2);
radius = diameter / 2.;
/* Adjust the center so that the stroke is properly aligned with
* the pixel grid. The center adjustment is different for the
* horizontal and vertical orientations. For intermediate positions
* we interpolate between the two.
*/
x_double_vert = floor ((x + width / 2) - (radius + line_width) / 2.) + (radius + line_width) / 2.;
y_double_vert = (y + height / 2) - 0.5;
x_double_horz = (x + width / 2) - 0.5;
y_double_horz = floor ((y + height / 2) - (radius + line_width) / 2.) + (radius + line_width) / 2.;
x_double = x_double_vert * (1 - interp) + x_double_horz * interp;
y_double = y_double_vert * (1 - interp) + y_double_horz * interp;
cairo_translate (cr, x_double, y_double);
cairo_rotate (cr, angle);
cairo_move_to (cr, - radius / 2., - radius);
cairo_line_to (cr, radius / 2., 0);
cairo_line_to (cr, - radius / 2., radius);
cairo_close_path (cr);
cairo_set_line_width (cr, line_width);
GtkThemingEngine: Add vmethod to render expanders.
2010-03-27 19:15:45 +00:00
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gdk_cairo_set_source_rgba (cr, &fg_color);
GtkThemingEngine: Add vmethod to render expanders.
2010-03-27 19:15:45 +00:00
cairo_fill_preserve (cr);
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gdk_cairo_set_source_rgba (cr, &outline_color);
GtkThemingEngine: Add vmethod to render expanders.
2010-03-27 19:15:45 +00:00
cairo_stroke (cr);
cairo_restore (cr);
}
GtkThemingEngine: Add vmethod to render focus indicator.
2010-03-27 19:18:38 +00:00
static void
gtk_theming_engine_render_focus (GtkThemingEngine *engine,
cairo_t *cr,
gdouble x,
gdouble y,
gdouble width,
gdouble height)
{
GtkStateFlags flags;
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
GdkRGBA color;
GtkThemingEngine: Rip out focus rendering from old code.
2010-08-02 13:50:37 +00:00
gint line_width;
gint8 *dash_list;
GtkThemingEngine: Add vmethod to render focus indicator.
2010-03-27 19:18:38 +00:00
cairo_save (cr);
flags = gtk_theming_engine_get_state (engine);
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gtk_theming_engine_get_color (engine, flags, &color);
GtkThemingEngine: Add vmethod to render focus indicator.
2010-03-27 19:18:38 +00:00
GtkThemingEngine: Rip out focus rendering from old code.
2010-08-02 13:50:37 +00:00
gtk_theming_engine_get_style (engine,
"focus-line-width", &line_width,
"focus-line-pattern", (gchar *) &dash_list,
NULL);
cairo_set_line_width (cr, (gdouble) line_width);
if (dash_list[0])
{
gint n_dashes = strlen ((const gchar *) dash_list);
gdouble *dashes = g_new (gdouble, n_dashes);
gdouble total_length = 0;
gdouble dash_offset;
gint i;
for (i = 0; i < n_dashes; i++)
{
dashes[i] = dash_list[i];
total_length += dash_list[i];
}
/* The dash offset here aligns the pattern to integer pixels
* by starting the dash at the right side of the left border
* Negative dash offsets in cairo don't work
* (https://bugs.freedesktop.org/show_bug.cgi?id=2729)
*/
dash_offset = - line_width / 2.;
while (dash_offset < 0)
dash_offset += total_length;
cairo_set_dash (cr, dashes, n_dashes, dash_offset);
g_free (dashes);
}
GtkThemingEngine: Add vmethod to render focus indicator.
2010-03-27 19:18:38 +00:00
cairo_rectangle (cr,
GtkThemingEngine: Rip out focus rendering from old code.
2010-08-02 13:50:37 +00:00
x + line_width / 2.,
y + line_width / 2.,
width - line_width,
height - line_width);
GtkThemingEngine: Add vmethod to render focus indicator.
2010-03-27 19:18:38 +00:00
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gdk_cairo_set_source_rgba (cr, &color);
GtkThemingEngine: Add vmethod to render focus indicator.
2010-03-27 19:18:38 +00:00
cairo_stroke (cr);
cairo_restore (cr);
GtkThemingEngine: Rip out focus rendering from old code.
2010-08-02 13:50:37 +00:00
g_free (dash_list);
GtkThemingEngine: Add vmethod to render focus indicator.
2010-03-27 19:18:38 +00:00
}
GtkThemingEngine: Add vmethod to render lines.
2010-03-27 20:17:22 +00:00
static void
gtk_theming_engine_render_line (GtkThemingEngine *engine,
cairo_t *cr,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1)
{
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
GdkRGBA bg_color, darker, lighter;
GtkThemingEngine: Add vmethod to render lines.
2010-03-27 20:17:22 +00:00
GtkStateFlags flags;
GtkThemingEngine: Unify code to render lines.
2010-07-19 09:54:31 +00:00
gint i, thickness, thickness_dark, thickness_light, len;
cairo_matrix_t matrix;
gdouble angle;
GtkThemingEngine: Add vmethod to render lines.
2010-03-27 20:17:22 +00:00
GtkThemingEngine: Unify code to render lines.
2010-07-19 09:54:31 +00:00
/* FIXME: thickness */
GtkThemingEngine: Add vmethod to render lines.
2010-03-27 20:17:22 +00:00
thickness = 2;
thickness_dark = thickness / 2;
thickness_light = thickness - thickness_dark;
flags = gtk_theming_engine_get_state (engine);
cairo_save (cr);
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gtk_theming_engine_get_background_color (engine, flags, &bg_color);
color_shade (&bg_color, 0.7, &darker);
color_shade (&bg_color, 1.3, &lighter);
GtkThemingEngine: Add vmethod to render lines.
2010-03-27 20:17:22 +00:00
cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
cairo_set_line_width (cr, 1);
GtkThemingEngine: Unify code to render lines.
2010-07-19 09:54:31 +00:00
angle = atan2 (x1 - x0, y1 - y0);
angle = (2 * G_PI) - angle;
angle += G_PI / 2;
GtkThemingEngine: Add vmethod to render lines.
2010-03-27 20:17:22 +00:00
GtkThemingEngine: Unify code to render lines.
2010-07-19 09:54:31 +00:00
cairo_get_matrix (cr, &matrix);
cairo_matrix_translate (&matrix, x0, y0);
cairo_matrix_rotate (&matrix, angle);
cairo_set_matrix (cr, &matrix);
x1 -= x0;
y1 -= y0;
len = (gint) sqrt ((x1 * x1) + (y1 * y1));
y0 = -thickness_dark;
for (i = 0; i < thickness_dark; i++)
GtkThemingEngine: Add vmethod to render lines.
2010-03-27 20:17:22 +00:00
{
Use GdkRGBA all around in GtkStyleContext.
2010-10-22 10:41:19 +00:00
gdk_cairo_set_source_rgba (cr, &lighter);
GtkThemingEngine: Unify code to render lines.
2010-07-19 09:54:31 +00:00
add_path_line (cr, len - i - 1.5, y0, len - 0.5, y0);
cairo_stroke (cr);
GtkThemingEngine: Add vmethod to render lines.
2010-03-27 20:17:22 +00:00
Use GdkRGBA all around in GtkStyleContext.
2010-10-22 10:41:19 +00:00
gdk_cairo_set_source_rgba (cr, &darker);
GtkThemingEngine: Unify code to render lines.
2010-07-19 09:54:31 +00:00
add_path_line (cr, 0.5, y0, len - i - 1.5, y0);
cairo_stroke (cr);
y0++;
GtkThemingEngine: Add vmethod to render lines.
2010-03-27 20:17:22 +00:00
}
GtkThemingEngine: Unify code to render lines.
2010-07-19 09:54:31 +00:00
for (i = 0; i < thickness_light; i++)
GtkThemingEngine: Add vmethod to render lines.
2010-03-27 20:17:22 +00:00
{
Use GdkRGBA all around in GtkStyleContext.
2010-10-22 10:41:19 +00:00
gdk_cairo_set_source_rgba (cr, &darker);
GtkThemingEngine: Unify code to render lines.
2010-07-19 09:54:31 +00:00
add_path_line (cr, 0.5, y0, thickness_light - i + 0.5, y0);
GtkThemingEngine: Add vmethod to render lines.
2010-03-27 20:17:22 +00:00
cairo_stroke (cr);
GtkThemingEngine: Unify code to render lines.
2010-07-19 09:54:31 +00:00
Use GdkRGBA all around in GtkStyleContext.
2010-10-22 10:41:19 +00:00
gdk_cairo_set_source_rgba (cr, &lighter);
GtkThemingEngine: Unify code to render lines.
2010-07-19 09:54:31 +00:00
add_path_line (cr, thickness_light - i + 0.5, y0, len - 0.5, y0);
cairo_stroke (cr);
y0++;
GtkThemingEngine: Add vmethod to render lines.
2010-03-27 20:17:22 +00:00
}
cairo_restore (cr);
}
GtkThemingEngine: Add vmethod to render layouts.
2010-03-27 19:21:55 +00:00
static void
gtk_theming_engine_render_layout (GtkThemingEngine *engine,
cairo_t *cr,
gdouble x,
gdouble y,
PangoLayout *layout)
{
Get rid of GdkPangoRenderer code in GtkThemingEngine.
2010-08-20 12:58:54 +00:00
const PangoMatrix *matrix;
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
GdkRGBA fg_color;
GtkThemingEngine: Add vmethod to render layouts.
2010-03-27 19:21:55 +00:00
GtkStateFlags flags;
GtkThemingEngine: Handle prelight transitions in render_layout()
2010-11-24 22:21:03 +00:00
gdouble progress;
gboolean running;
GtkThemingEngine: Add vmethod to render layouts.
2010-03-27 19:21:55 +00:00
cairo_save (cr);
flags = gtk_theming_engine_get_state (engine);
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gtk_theming_engine_get_color (engine, flags, &fg_color);
GtkThemingEngine: Add vmethod to render layouts.
2010-03-27 19:21:55 +00:00
Get rid of GdkPangoRenderer code in GtkThemingEngine.
2010-08-20 12:58:54 +00:00
matrix = pango_context_get_matrix (pango_layout_get_context (layout));
GtkThemingEngine: Use GdkPangoRenderer when painting layouts.
2010-07-03 18:55:38 +00:00
GtkThemingEngine: Handle prelight transitions in render_layout()
2010-11-24 22:21:03 +00:00
running = gtk_theming_engine_state_is_running (engine, GTK_STATE_PRELIGHT, &progress);
if (running)
{
GtkStateFlags other_flags;
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
GdkRGBA other_fg;
GtkThemingEngine: Handle prelight transitions in render_layout()
2010-11-24 22:21:03 +00:00
if (flags & GTK_STATE_FLAG_PRELIGHT)
{
other_flags = flags & ~(GTK_STATE_FLAG_PRELIGHT);
progress = 1 - progress;
}
else
other_flags = flags | GTK_STATE_FLAG_PRELIGHT;
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gtk_theming_engine_get_color (engine, other_flags, &other_fg);
GtkThemingEngine: Handle prelight transitions in render_layout()
2010-11-24 22:21:03 +00:00
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
fg_color.red = CLAMP (fg_color.red + ((other_fg.red - fg_color.red) * progress), 0, 1);
fg_color.green = CLAMP (fg_color.green + ((other_fg.green - fg_color.green) * progress), 0, 1);
fg_color.blue = CLAMP (fg_color.blue + ((other_fg.blue - fg_color.blue) * progress), 0, 1);
fg_color.alpha = CLAMP (fg_color.alpha + ((other_fg.alpha - fg_color.alpha) * progress), 0, 1);
GtkThemingEngine: Handle prelight transitions in render_layout()
2010-11-24 22:21:03 +00:00
}
Get rid of GdkPangoRenderer code in GtkThemingEngine.
2010-08-20 12:58:54 +00:00
if (matrix)
GtkThemingEngine: Use GdkPangoRenderer when painting layouts.
2010-07-03 18:55:38 +00:00
{
Get rid of GdkPangoRenderer code in GtkThemingEngine.
2010-08-20 12:58:54 +00:00
cairo_matrix_t cairo_matrix;
PangoRectangle rect;
cairo_matrix_init (&cairo_matrix,
matrix->xx, matrix->yx,
matrix->xy, matrix->yy,
matrix->x0, matrix->y0);
pango_layout_get_extents (layout, NULL, &rect);
pango_matrix_transform_rectangle (matrix, &rect);
pango_extents_to_pixels (&rect, NULL);
cairo_matrix.x0 += x - rect.x;
cairo_matrix.y0 += y - rect.y;
cairo_set_matrix (cr, &cairo_matrix);
GtkThemingEngine: Use GdkPangoRenderer when painting layouts.
2010-07-03 18:55:38 +00:00
}
else
Make GtkCalendar use GtkStyleContext
2011-01-10 19:40:37 +00:00
cairo_move_to (cr, x, y);
Get rid of GdkPangoRenderer code in GtkThemingEngine.
2010-08-20 12:58:54 +00:00
Change semantics of the methods to check whether an animation is running. It actually messed up with the state being actually set, and having a transition animation running for it. Now this dichotomy is removed, and gtk_style_context_state_is_running() only checks whether an animation is running, leaving state checking to flags & GTK_STATE_FLAG_*.
2010-10-19 10:09:23 +00:00
if (flags & GTK_STATE_FLAG_INSENSITIVE)
Get rid of GdkPangoRenderer code in GtkThemingEngine.
2010-08-20 12:58:54 +00:00
{
themingengine: don't hardcode white to draw insensitive labels shadow Use the background color instead. I think the optimal solution would be delegating the shadow rendering to the theme completely, and removing this in GtkThemingEngine, but for now, this simple fix makes the dark variant more usable. https://bugzilla.gnome.org/show_bug.cgi?id=645405
2011-03-21 14:53:12 +00:00
GdkRGBA bg;
gtk_theming_engine_get_background_color (engine, flags, &bg);
Get rid of GdkPangoRenderer code in GtkThemingEngine.
2010-08-20 12:58:54 +00:00
cairo_save (cr);
themingengine: don't hardcode white to draw insensitive labels shadow Use the background color instead. I think the optimal solution would be delegating the shadow rendering to the theme completely, and removing this in GtkThemingEngine, but for now, this simple fix makes the dark variant more usable. https://bugzilla.gnome.org/show_bug.cgi?id=645405
2011-03-21 14:53:12 +00:00
gdk_cairo_set_source_rgba (cr, &bg);
Make GtkCalendar use GtkStyleContext
2011-01-10 19:40:37 +00:00
cairo_move_to (cr, x + 1, y + 1);
Get rid of GdkPangoRenderer code in GtkThemingEngine.
2010-08-20 12:58:54 +00:00
_gtk_pango_fill_layout (cr, layout);
cairo_restore (cr);
}
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gdk_cairo_set_source_rgba (cr, &fg_color);
Get rid of GdkPangoRenderer code in GtkThemingEngine.
2010-08-20 12:58:54 +00:00
pango_cairo_show_layout (cr, layout);
GtkThemingEngine: Add vmethod to render layouts.
2010-03-27 19:21:55 +00:00
cairo_restore (cr);
}
GtkThemingEngine: Add vmethod to render sliders.
2010-03-27 20:20:21 +00:00
static void
gtk_theming_engine_render_slider (GtkThemingEngine *engine,
cairo_t *cr,
gdouble x,
gdouble y,
gdouble width,
gdouble height,
GtkOrientation orientation)
{
const GtkWidgetPath *path;
GtkThemingEngine: Improve slider rendering.
2010-07-19 10:00:07 +00:00
gint thickness;
GtkThemingEngine: Add vmethod to render sliders.
2010-03-27 20:20:21 +00:00
path = gtk_theming_engine_get_path (engine);
gtk_theming_engine_render_background (engine, cr, x, y, width, height);
gtk_theming_engine_render_frame (engine, cr, x, y, width, height);
GtkThemingEngine: Improve slider rendering.
2010-07-19 10:00:07 +00:00
/* FIXME: thickness */
thickness = 2;
if (gtk_widget_path_is_type (path, GTK_TYPE_SCALE))
GtkThemingEngine: Add vmethod to render sliders.
2010-03-27 20:20:21 +00:00
{
if (orientation == GTK_ORIENTATION_VERTICAL)
gtk_theming_engine_render_line (engine, cr,
GtkThemingEngine: Improve slider rendering.
2010-07-19 10:00:07 +00:00
x + thickness,
y + (gint) height / 2,
x + width - thickness - 1,
y + (gint) height / 2);
GtkThemingEngine: Add vmethod to render sliders.
2010-03-27 20:20:21 +00:00
else
gtk_theming_engine_render_line (engine, cr,
GtkThemingEngine: Improve slider rendering.
2010-07-19 10:00:07 +00:00
x + (gint) width / 2,
y + thickness,
x + (gint) width / 2,
y + height - thickness - 1);
GtkThemingEngine: Add vmethod to render sliders.
2010-03-27 20:20:21 +00:00
}
}
GtkThemingEngine: Add vmethod to render frames with a gap.
2010-03-27 20:23:13 +00:00
static void
gtk_theming_engine_render_frame_gap (GtkThemingEngine *engine,
cairo_t *cr,
gdouble x,
gdouble y,
gdouble width,
gdouble height,
GtkPositionType gap_side,
gdouble xy0_gap,
gdouble xy1_gap)
{
GtkThemingEngine: render square corner if the gap is too close on render_frame_gap()
2010-11-24 15:23:37 +00:00
GtkJunctionSides junction;
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
GtkStateFlags state;
GtkThemingEngine: render square corner if the gap is too close on render_frame_gap()
2010-11-24 15:23:37 +00:00
gint border_width, radius;
Improve frame-gap drawing Instead of overdrawing the gap with bg-color, clip it away.
2010-11-24 03:51:40 +00:00
gdouble x0, y0, x1, y1, xc, yc, wc, hc;
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
GtkBorder border;
GtkThemingEngine: Add vmethod to render frames with a gap.
2010-03-27 20:23:13 +00:00
GtkThemingEngine: Remove unused variables
2010-12-01 00:26:03 +00:00
xc = yc = wc = hc = 0;
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
state = gtk_theming_engine_get_state (engine);
GtkThemingEngine: render square corner if the gap is too close on render_frame_gap()
2010-11-24 15:23:37 +00:00
junction = gtk_theming_engine_get_junction_sides (engine);
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gtk_theming_engine_get_border (engine, state, &border);
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
gtk_theming_engine_get (engine, state,
GtkThemingEngine: render square corner if the gap is too close on render_frame_gap()
2010-11-24 15:23:37 +00:00
"border-radius", &radius,
GtkThemingEngine: Add vmethod to render frames with a gap.
2010-03-27 20:23:13 +00:00
NULL);
GtkThemingEngine: Add code to render GtkFrame frame with gap.
2010-08-02 13:52:26 +00:00
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
border_width = MIN (MIN (border.top, border.bottom),
MIN (border.left, border.right));
GtkStyleProperties: Turn border-width into a GtkBorder property. All current users of this CSS property have been updated to deal with a GtkBorder. Also a 0 border width has been set in the default CSS to ensure GtkStyleContext and GtkThemingEngine always provide a non-NULL pointer for this property.
2010-11-30 23:55:14 +00:00
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
cairo_save (cr);
GtkThemingEngine: Add code to render GtkFrame frame with gap.
2010-08-02 13:52:26 +00:00
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
switch (gap_side)
GtkThemingEngine: Cairo-ify frame_gap rendering from GtkStyle.
2010-07-19 09:58:13 +00:00
{
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
case GTK_POS_TOP:
Improve frame-gap drawing Instead of overdrawing the gap with bg-color, clip it away.
2010-11-24 03:51:40 +00:00
xc = x + xy0_gap + border_width;
yc = y;
wc = MAX (xy1_gap - xy0_gap - 2 * border_width, 0);
hc = border_width;
GtkThemingEngine: render square corner if the gap is too close on render_frame_gap()
2010-11-24 15:23:37 +00:00
if (xy0_gap < radius)
junction |= GTK_JUNCTION_CORNER_TOPLEFT;
if (xy1_gap > width - radius)
junction |= GTK_JUNCTION_CORNER_TOPRIGHT;
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
break;
case GTK_POS_BOTTOM:
Improve frame-gap drawing Instead of overdrawing the gap with bg-color, clip it away.
2010-11-24 03:51:40 +00:00
xc = x + xy0_gap + border_width;
yc = y + height - border_width;
wc = MAX (xy1_gap - xy0_gap - 2 * border_width, 0);
hc = border_width;
GtkThemingEngine: render square corner if the gap is too close on render_frame_gap()
2010-11-24 15:23:37 +00:00
if (xy0_gap < radius)
junction |= GTK_JUNCTION_CORNER_BOTTOMLEFT;
if (xy1_gap > width - radius)
junction |= GTK_JUNCTION_CORNER_BOTTOMRIGHT;
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
break;
case GTK_POS_LEFT:
Improve frame-gap drawing Instead of overdrawing the gap with bg-color, clip it away.
2010-11-24 03:51:40 +00:00
xc = x;
yc = y + xy0_gap + border_width;
wc = border_width;
hc = MAX (xy1_gap - xy0_gap - 2 * border_width, 0);
GtkThemingEngine: render square corner if the gap is too close on render_frame_gap()
2010-11-24 15:23:37 +00:00
if (xy0_gap < radius)
junction |= GTK_JUNCTION_CORNER_TOPLEFT;
if (xy1_gap > height - radius)
junction |= GTK_JUNCTION_CORNER_BOTTOMLEFT;
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
break;
case GTK_POS_RIGHT:
Improve frame-gap drawing Instead of overdrawing the gap with bg-color, clip it away.
2010-11-24 03:51:40 +00:00
xc = x + width - border_width;
yc = y + xy0_gap + border_width;
wc = border_width;
hc = MAX (xy1_gap - xy0_gap - 2 * border_width, 0);
GtkThemingEngine: render square corner if the gap is too close on render_frame_gap()
2010-11-24 15:23:37 +00:00
if (xy0_gap < radius)
junction |= GTK_JUNCTION_CORNER_TOPRIGHT;
if (xy1_gap > height - radius)
junction |= GTK_JUNCTION_CORNER_BOTTOMRIGHT;
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
break;
}
GtkThemingEngine: Add code to render GtkFrame frame with gap.
2010-08-02 13:52:26 +00:00
Improve frame-gap drawing Instead of overdrawing the gap with bg-color, clip it away.
2010-11-24 03:51:40 +00:00
cairo_clip_extents (cr, &x0, &y0, &x1, &y1);
cairo_rectangle (cr, x0, y0, x1 - x0, yc - y0);
cairo_rectangle (cr, x0, yc, xc - x0, hc);
cairo_rectangle (cr, xc + wc, yc, x1 - (xc + wc), hc);
cairo_rectangle (cr, x0, yc + hc, x1 - x0, y1 - (yc + hc));
cairo_clip (cr);
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
render_frame_internal (engine, cr,
x, y, width, height,
0, junction);
GtkThemingEngine: Add vmethod to render frames with a gap.
2010-03-27 20:23:13 +00:00
cairo_restore (cr);
}
GtkThemingEngine: Add vmethod to render an extension.
2010-03-27 20:25:33 +00:00
static void
gtk_theming_engine_render_extension (GtkThemingEngine *engine,
cairo_t *cr,
gdouble x,
gdouble y,
gdouble width,
gdouble height,
GtkPositionType gap_side)
{
Fix compile warnings
2010-11-17 01:56:49 +00:00
GtkJunctionSides junction = 0;
guint hidden_side = 0;
GtkThemingEngine: Add vmethod to render an extension.
2010-03-27 20:25:33 +00:00
cairo_save (cr);
GtkThemingEngine: Cairo-ify extension rendering from GtkStyle.
2010-07-19 09:57:25 +00:00
switch (gap_side)
{
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
case GTK_POS_LEFT:
junction = GTK_JUNCTION_LEFT;
hidden_side = SIDE_LEFT;
GtkThemingEngine: Render gradients in tabs. Background will be actually rotated in tabs, so the "bottom" side coincides with the junction point, this makes gradients work as expected in rotated tabs.
2010-11-29 10:25:09 +00:00
cairo_translate (cr, x + width, y);
cairo_rotate (cr, G_PI / 2);
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
break;
case GTK_POS_RIGHT:
junction = GTK_JUNCTION_RIGHT;
hidden_side = SIDE_RIGHT;
GtkThemingEngine: Render gradients in tabs. Background will be actually rotated in tabs, so the "bottom" side coincides with the junction point, this makes gradients work as expected in rotated tabs.
2010-11-29 10:25:09 +00:00
cairo_translate (cr, x, y + height);
cairo_rotate (cr, - G_PI / 2);
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
break;
GtkThemingEngine: Cairo-ify extension rendering from GtkStyle.
2010-07-19 09:57:25 +00:00
case GTK_POS_TOP:
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
junction = GTK_JUNCTION_TOP;
hidden_side = SIDE_TOP;
GtkThemingEngine: Render gradients in tabs. Background will be actually rotated in tabs, so the "bottom" side coincides with the junction point, this makes gradients work as expected in rotated tabs.
2010-11-29 10:25:09 +00:00
cairo_translate (cr, x + width, y + height);
cairo_rotate (cr, G_PI);
GtkThemingEngine: Cairo-ify extension rendering from GtkStyle.
2010-07-19 09:57:25 +00:00
break;
case GTK_POS_BOTTOM:
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
junction = GTK_JUNCTION_BOTTOM;
hidden_side = SIDE_BOTTOM;
GtkThemingEngine: Render gradients in tabs. Background will be actually rotated in tabs, so the "bottom" side coincides with the junction point, this makes gradients work as expected in rotated tabs.
2010-11-29 10:25:09 +00:00
cairo_translate (cr, x, y);
GtkThemingEngine: Cairo-ify extension rendering from GtkStyle.
2010-07-19 09:57:25 +00:00
break;
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
}
GtkThemingEngine: Cairo-ify extension rendering from GtkStyle.
2010-07-19 09:57:25 +00:00
GtkThemingEngine: Render gradients in tabs. Background will be actually rotated in tabs, so the "bottom" side coincides with the junction point, this makes gradients work as expected in rotated tabs.
2010-11-29 10:25:09 +00:00
if (gap_side == GTK_POS_TOP ||
gap_side == GTK_POS_BOTTOM)
render_background_internal (engine, cr,
0, 0, width, height,
GtkThemingEngine: Render tabs background in the correct direction. The cairo context has been already rotated, so using GTK_JUNCTION_BOTTOM is expected to be used there.
2010-12-13 11:38:37 +00:00
GTK_JUNCTION_BOTTOM);
GtkThemingEngine: Render gradients in tabs. Background will be actually rotated in tabs, so the "bottom" side coincides with the junction point, this makes gradients work as expected in rotated tabs.
2010-11-29 10:25:09 +00:00
else
render_background_internal (engine, cr,
0, 0, height, width,
GtkThemingEngine: Render tabs background in the correct direction. The cairo context has been already rotated, so using GTK_JUNCTION_BOTTOM is expected to be used there.
2010-12-13 11:38:37 +00:00
GTK_JUNCTION_BOTTOM);
GtkThemingEngine: Render gradients in tabs. Background will be actually rotated in tabs, so the "bottom" side coincides with the junction point, this makes gradients work as expected in rotated tabs.
2010-11-29 10:25:09 +00:00
cairo_restore (cr);
cairo_save (cr);
GtkThemingEngine: Cairo-ify extension rendering from GtkStyle.
2010-07-19 09:57:25 +00:00
GtkThemingEngine: Use border settings on render_extension/frame_gap()
2010-11-15 22:28:06 +00:00
render_frame_internal (engine, cr,
x, y, width, height,
hidden_side, junction);
GtkThemingEngine: Add vmethod to render an extension.
2010-03-27 20:25:33 +00:00
cairo_restore (cr);
}
GtkThemingEngine: Add vmethod to render a handle area.
2010-03-27 20:27:52 +00:00
static void
Use GdkRGBA all around in GtkStyleContext.
2010-10-22 10:41:19 +00:00
render_dot (cairo_t *cr,
const GdkRGBA *lighter,
const GdkRGBA *darker,
gdouble x,
gdouble y,
gdouble size)
GtkThemingEngine: Add vmethod to render a handle area.
2010-03-27 20:27:52 +00:00
{
GtkThemingEngine: Cairo-ify handle rendering from GtkStyle.
2010-07-19 09:47:37 +00:00
size = CLAMP ((gint) size, 2, 3);
GtkThemingEngine: Add vmethod to render a handle area.
2010-03-27 20:27:52 +00:00
GtkThemingEngine: Cairo-ify handle rendering from GtkStyle.
2010-07-19 09:47:37 +00:00
if (size == 2)
{
Use GdkRGBA all around in GtkStyleContext.
2010-10-22 10:41:19 +00:00
gdk_cairo_set_source_rgba (cr, lighter);
GtkThemingEngine: Cairo-ify handle rendering from GtkStyle.
2010-07-19 09:47:37 +00:00
cairo_rectangle (cr, x, y, 1, 1);
cairo_rectangle (cr, x + 1, y + 1, 1, 1);
cairo_fill (cr);
}
else if (size == 3)
{
Use GdkRGBA all around in GtkStyleContext.
2010-10-22 10:41:19 +00:00
gdk_cairo_set_source_rgba (cr, lighter);
GtkThemingEngine: Cairo-ify handle rendering from GtkStyle.
2010-07-19 09:47:37 +00:00
cairo_rectangle (cr, x, y, 2, 1);
cairo_rectangle (cr, x, y, 1, 2);
cairo_fill (cr);
Use GdkRGBA all around in GtkStyleContext.
2010-10-22 10:41:19 +00:00
gdk_cairo_set_source_rgba (cr, darker);
GtkThemingEngine: Cairo-ify handle rendering from GtkStyle.
2010-07-19 09:47:37 +00:00
cairo_rectangle (cr, x + 1, y + 1, 2, 1);
cairo_rectangle (cr, x + 2, y, 1, 2);
cairo_fill (cr);
}
GtkThemingEngine: Add vmethod to render a handle area.
2010-03-27 20:27:52 +00:00
}
static void
gtk_theming_engine_render_handle (GtkThemingEngine *engine,
cairo_t *cr,
gdouble x,
gdouble y,
gdouble width,
Remove GtkOrientation parameter from gtk_render_handle(). The case for paned can be guessed out from the height and width, for handlebox the orientation parameter doesn't make much sense, and this way it could also be used for resize grips.
2010-10-12 22:52:50 +00:00
gdouble height)
GtkThemingEngine: Add vmethod to render a handle area.
2010-03-27 20:27:52 +00:00
{
GtkStateFlags flags;
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
GdkRGBA bg_color, lighter, darker;
themingengine: Use render_background_internal() to render handle background Instead of using always the background color. This fixes handles that have a background image like gnome-panel applets in a transparent panel. https://bugzilla.gnome.org/show_bug.cgi?id=644570
2011-03-12 16:02:49 +00:00
GtkJunctionSides sides;
GtkThemingEngine: Add vmethod to render a handle area.
2010-03-27 20:27:52 +00:00
gint xx, yy;
cairo_save (cr);
flags = gtk_theming_engine_get_state (engine);
themingengine: Use render_background_internal() to render handle background Instead of using always the background color. This fixes handles that have a background image like gnome-panel applets in a transparent panel. https://bugzilla.gnome.org/show_bug.cgi?id=644570
2011-03-12 16:02:49 +00:00
cairo_set_line_width (cr, 1.0);
sides = gtk_theming_engine_get_junction_sides (engine);
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gtk_theming_engine_get_background_color (engine, flags, &bg_color);
GtkThemingEngine: Add vmethod to render a handle area.
2010-03-27 20:27:52 +00:00
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
color_shade (&bg_color, 0.7, &darker);
color_shade (&bg_color, 1.3, &lighter);
GtkThemingEngine: Add vmethod to render a handle area.
2010-03-27 20:27:52 +00:00
themingengine: Use render_background_internal() to render handle background Instead of using always the background color. This fixes handles that have a background image like gnome-panel applets in a transparent panel. https://bugzilla.gnome.org/show_bug.cgi?id=644570
2011-03-12 16:02:49 +00:00
render_background_internal (engine, cr, x, y, width, height, sides);
GtkThemingEngine: Add vmethod to render a handle area.
2010-03-27 20:27:52 +00:00
GtkThemingEngine: Fix handles rendering The wrong class was being used, so the theming engine didn't match it properly.
2011-01-10 22:23:54 +00:00
if (gtk_theming_engine_has_class (engine, GTK_STYLE_CLASS_GRIP))
GtkThemingEngine: draw resize grip through render_handle(). GtkJunctionSides is used instead of GdkWindowEdge, GtkStyle implementation has changed to use GtkStyleContext's.
2010-11-01 01:42:08 +00:00
{
/* reduce confusing values to a meaningful state */
Fix resize grip drawing There was some confusion about junctions...
2010-11-23 03:37:19 +00:00
if ((sides & (GTK_JUNCTION_CORNER_TOPLEFT | GTK_JUNCTION_CORNER_BOTTOMRIGHT)) == (GTK_JUNCTION_CORNER_TOPLEFT | GTK_JUNCTION_CORNER_BOTTOMRIGHT))
sides &= ~GTK_JUNCTION_CORNER_TOPLEFT;
GtkThemingEngine: draw resize grip through render_handle(). GtkJunctionSides is used instead of GdkWindowEdge, GtkStyle implementation has changed to use GtkStyleContext's.
2010-11-01 01:42:08 +00:00
Fix resize grip drawing There was some confusion about junctions...
2010-11-23 03:37:19 +00:00
if ((sides & (GTK_JUNCTION_CORNER_TOPRIGHT | GTK_JUNCTION_CORNER_BOTTOMLEFT)) == (GTK_JUNCTION_CORNER_TOPRIGHT | GTK_JUNCTION_CORNER_BOTTOMLEFT))
sides &= ~GTK_JUNCTION_CORNER_TOPRIGHT;
GtkThemingEngine: draw resize grip through render_handle(). GtkJunctionSides is used instead of GdkWindowEdge, GtkStyle implementation has changed to use GtkStyleContext's.
2010-11-01 01:42:08 +00:00
if (sides == 0)
Fix resize grip drawing There was some confusion about junctions...
2010-11-23 03:37:19 +00:00
sides = GTK_JUNCTION_CORNER_BOTTOMRIGHT;
GtkThemingEngine: draw resize grip through render_handle(). GtkJunctionSides is used instead of GdkWindowEdge, GtkStyle implementation has changed to use GtkStyleContext's.
2010-11-01 01:42:08 +00:00
/* align drawing area to the connected side */
if (sides == GTK_JUNCTION_LEFT)
{
if (height < width)
width = height;
}
Fix resize grip drawing There was some confusion about junctions...
2010-11-23 03:37:19 +00:00
else if (sides == GTK_JUNCTION_CORNER_TOPLEFT)
GtkThemingEngine: draw resize grip through render_handle(). GtkJunctionSides is used instead of GdkWindowEdge, GtkStyle implementation has changed to use GtkStyleContext's.
2010-11-01 01:42:08 +00:00
{
if (width < height)
height = width;
else if (height < width)
width = height;
}
Fix resize grip drawing There was some confusion about junctions...
2010-11-23 03:37:19 +00:00
else if (sides == GTK_JUNCTION_CORNER_BOTTOMLEFT)
GtkThemingEngine: draw resize grip through render_handle(). GtkJunctionSides is used instead of GdkWindowEdge, GtkStyle implementation has changed to use GtkStyleContext's.
2010-11-01 01:42:08 +00:00
{
/* make it square, aligning to bottom left */
if (width < height)
{
y += (height - width);
height = width;
}
else if (height < width)
width = height;
}
Fix the resize handle drawing
2010-11-17 05:44:36 +00:00
else if (sides == GTK_JUNCTION_RIGHT)
GtkThemingEngine: draw resize grip through render_handle(). GtkJunctionSides is used instead of GdkWindowEdge, GtkStyle implementation has changed to use GtkStyleContext's.
2010-11-01 01:42:08 +00:00
{
/* aligning to right */
if (height < width)
{
x += (width - height);
width = height;
}
}
Fix resize grip drawing There was some confusion about junctions...
2010-11-23 03:37:19 +00:00
else if (sides == GTK_JUNCTION_CORNER_TOPRIGHT)
GtkThemingEngine: draw resize grip through render_handle(). GtkJunctionSides is used instead of GdkWindowEdge, GtkStyle implementation has changed to use GtkStyleContext's.
2010-11-01 01:42:08 +00:00
{
if (width < height)
height = width;
else if (height < width)
{
x += (width - height);
width = height;
}
}
Fix resize grip drawing There was some confusion about junctions...
2010-11-23 03:37:19 +00:00
else if (sides == GTK_JUNCTION_CORNER_BOTTOMRIGHT)
GtkThemingEngine: draw resize grip through render_handle(). GtkJunctionSides is used instead of GdkWindowEdge, GtkStyle implementation has changed to use GtkStyleContext's.
2010-11-01 01:42:08 +00:00
{
/* make it square, aligning to bottom right */
if (width < height)
{
y += (height - width);
height = width;
}
else if (height < width)
{
x += (width - height);
width = height;
}
}
else if (sides == GTK_JUNCTION_TOP)
{
if (width < height)
height = width;
}
else if (sides == GTK_JUNCTION_BOTTOM)
{
/* align to bottom */
if (width < height)
{
y += (height - width);
height = width;
}
}
else
g_assert_not_reached ();
if (sides == GTK_JUNCTION_LEFT ||
sides == GTK_JUNCTION_RIGHT)
{
gint xi;
xi = x;
while (xi < x + width)
{
gdk_cairo_set_source_rgba (cr, &lighter);
add_path_line (cr, x, y, x, y + height);
cairo_stroke (cr);
xi++;
gdk_cairo_set_source_rgba (cr, &darker);
add_path_line (cr, xi, y, xi, y + height);
cairo_stroke (cr);
xi += 2;
}
}
else if (sides == GTK_JUNCTION_TOP ||
sides == GTK_JUNCTION_BOTTOM)
{
gint yi;
yi = y;
while (yi < y + height)
{
gdk_cairo_set_source_rgba (cr, &lighter);
add_path_line (cr, x, yi, x + width, yi);
cairo_stroke (cr);
yi++;
gdk_cairo_set_source_rgba (cr, &darker);
add_path_line (cr, x, yi, x + width, yi);
cairo_stroke (cr);
Silence new gcc warnings gcc 4.6.0 has started to warn about set-but-unused variables. So don't do that, then.
2011-01-24 02:50:39 +00:00
yi += 2;
GtkThemingEngine: draw resize grip through render_handle(). GtkJunctionSides is used instead of GdkWindowEdge, GtkStyle implementation has changed to use GtkStyleContext's.
2010-11-01 01:42:08 +00:00
}
}
Fix resize grip drawing There was some confusion about junctions...
2010-11-23 03:37:19 +00:00
else if (sides == GTK_JUNCTION_CORNER_TOPLEFT)
GtkThemingEngine: draw resize grip through render_handle(). GtkJunctionSides is used instead of GdkWindowEdge, GtkStyle implementation has changed to use GtkStyleContext's.
2010-11-01 01:42:08 +00:00
{
gint xi, yi;
xi = x + width;
yi = y + height;
while (xi > x + 3)
{
gdk_cairo_set_source_rgba (cr, &darker);
add_path_line (cr, xi, y, x, yi);
cairo_stroke (cr);
--xi;
--yi;
add_path_line (cr, xi, y, x, yi);
cairo_stroke (cr);
--xi;
--yi;
gdk_cairo_set_source_rgba (cr, &lighter);
add_path_line (cr, xi, y, x, yi);
cairo_stroke (cr);
xi -= 3;
yi -= 3;
}
}
Fix resize grip drawing There was some confusion about junctions...
2010-11-23 03:37:19 +00:00
else if (sides == GTK_JUNCTION_CORNER_TOPRIGHT)
GtkThemingEngine: draw resize grip through render_handle(). GtkJunctionSides is used instead of GdkWindowEdge, GtkStyle implementation has changed to use GtkStyleContext's.
2010-11-01 01:42:08 +00:00
{
gint xi, yi;
xi = x;
yi = y + height;
while (xi < (x + width - 3))
{
gdk_cairo_set_source_rgba (cr, &lighter);
add_path_line (cr, xi, y, x + width, yi);
cairo_stroke (cr);
++xi;
--yi;
gdk_cairo_set_source_rgba (cr, &darker);
add_path_line (cr, xi, y, x + width, yi);
cairo_stroke (cr);
++xi;
--yi;
add_path_line (cr, xi, y, x + width, yi);
cairo_stroke (cr);
xi += 3;
yi -= 3;
}
}
Fix resize grip drawing There was some confusion about junctions...
2010-11-23 03:37:19 +00:00
else if (sides == GTK_JUNCTION_CORNER_BOTTOMLEFT)
GtkThemingEngine: draw resize grip through render_handle(). GtkJunctionSides is used instead of GdkWindowEdge, GtkStyle implementation has changed to use GtkStyleContext's.
2010-11-01 01:42:08 +00:00
{
gint xi, yi;
xi = x + width;
yi = y;
while (xi > x + 3)
{
gdk_cairo_set_source_rgba (cr, &darker);
add_path_line (cr, x, yi, xi, y + height);
cairo_stroke (cr);
--xi;
++yi;
add_path_line (cr, x, yi, xi, y + height);
cairo_stroke (cr);
--xi;
++yi;
gdk_cairo_set_source_rgba (cr, &lighter);
add_path_line (cr, x, yi, xi, y + height);
cairo_stroke (cr);
xi -= 3;
yi += 3;
}
}
Fix resize grip drawing There was some confusion about junctions...
2010-11-23 03:37:19 +00:00
else if (sides == GTK_JUNCTION_CORNER_BOTTOMRIGHT)
GtkThemingEngine: draw resize grip through render_handle(). GtkJunctionSides is used instead of GdkWindowEdge, GtkStyle implementation has changed to use GtkStyleContext's.
2010-11-01 01:42:08 +00:00
{
gint xi, yi;
xi = x;
yi = y;
while (xi < (x + width - 3))
{
gdk_cairo_set_source_rgba (cr, &lighter);
add_path_line (cr, xi, y + height, x + width, yi);
cairo_stroke (cr);
++xi;
++yi;
gdk_cairo_set_source_rgba (cr, &darker);
add_path_line (cr, xi, y + height, x + width, yi);
cairo_stroke (cr);
++xi;
++yi;
add_path_line (cr, xi, y + height, x + width, yi);
cairo_stroke (cr);
xi += 3;
yi += 3;
}
}
}
GtkThemingEngine: Fix handles rendering The wrong class was being used, so the theming engine didn't match it properly.
2011-01-10 22:23:54 +00:00
else if (gtk_theming_engine_has_class (engine, GTK_STYLE_CLASS_PANE_SEPARATOR))
GtkThemingEngine: Cairo-ify handle rendering from GtkStyle.
2010-07-19 09:47:37 +00:00
{
Remove GtkOrientation parameter from gtk_render_handle(). The case for paned can be guessed out from the height and width, for handlebox the orientation parameter doesn't make much sense, and this way it could also be used for resize grips.
2010-10-12 22:52:50 +00:00
if (width > height)
GtkThemingEngine: Cairo-ify handle rendering from GtkStyle.
2010-07-19 09:47:37 +00:00
for (xx = x + width / 2 - 15; xx <= x + width / 2 + 15; xx += 5)
render_dot (cr, &lighter, &darker, xx, y + height / 2 - 1, 3);
else
for (yy = y + height / 2 - 15; yy <= y + height / 2 + 15; yy += 5)
render_dot (cr, &lighter, &darker, x + width / 2 - 1, yy, 3);
}
GtkThemingEngine: Add vmethod to render a handle area.
2010-03-27 20:27:52 +00:00
else
GtkThemingEngine: Cairo-ify handle rendering from GtkStyle.
2010-07-19 09:47:37 +00:00
{
for (yy = y; yy < y + height; yy += 3)
Silence new gcc warnings gcc 4.6.0 has started to warn about set-but-unused variables. So don't do that, then.
2011-01-24 02:50:39 +00:00
for (xx = x; xx < x + width; xx += 6)
{
render_dot (cr, &lighter, &darker, xx, yy, 2);
render_dot (cr, &lighter, &darker, xx + 3, yy + 1, 2);
}
GtkThemingEngine: Cairo-ify handle rendering from GtkStyle.
2010-07-19 09:47:37 +00:00
}
GtkThemingEngine: Add vmethod to render a handle area.
2010-03-27 20:27:52 +00:00
cairo_restore (cr);
}
Add gtk_render_activity() This method will render progress bars and spinners, these should handle active and inconsistent states' animation progress in order to perform animations.
2010-11-01 01:46:35 +00:00
static void
gtk_theming_engine_render_activity (GtkThemingEngine *engine,
cairo_t *cr,
gdouble x,
gdouble y,
gdouble width,
gdouble height)
{
Add #define for the "spinner" style class
2010-11-24 22:00:47 +00:00
if (gtk_theming_engine_has_class (engine, GTK_STYLE_CLASS_SPINNER))
Add gtk_render_activity() This method will render progress bars and spinners, these should handle active and inconsistent states' animation progress in order to perform animations.
2010-11-01 01:46:35 +00:00
{
GtkStateFlags state;
guint num_steps, step;
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
GdkRGBA color;
Add gtk_render_activity() This method will render progress bars and spinners, these should handle active and inconsistent states' animation progress in order to perform animations.
2010-11-01 01:46:35 +00:00
gdouble progress;
gdouble radius;
gdouble half;
gint i;
Remove deprecated GtkSpinner style properties
2011-01-06 04:21:52 +00:00
num_steps = 12;
Add gtk_render_activity() This method will render progress bars and spinners, these should handle active and inconsistent states' animation progress in order to perform animations.
2010-11-01 01:46:35 +00:00
state = gtk_theming_engine_get_state (engine);
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
gtk_theming_engine_get_color (engine, state, &color);
Add gtk_render_activity() This method will render progress bars and spinners, these should handle active and inconsistent states' animation progress in order to perform animations.
2010-11-01 01:46:35 +00:00
if (gtk_theming_engine_state_is_running (engine, GTK_STATE_ACTIVE, &progress))
step = (guint) (progress * num_steps);
else
step = 0;
cairo_save (cr);
cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
theme: Do general cairo setup in one place Also remove wrong comment.
2011-03-05 13:47:55 +00:00
cairo_set_line_width (cr, 2.0);
cairo_translate (cr, x + width / 2, y + height / 2);
Add gtk_render_activity() This method will render progress bars and spinners, these should handle active and inconsistent states' animation progress in order to perform animations.
2010-11-01 01:46:35 +00:00
radius = MIN (width / 2, height / 2);
half = num_steps / 2;
for (i = 0; i < num_steps; i++)
{
gint inset = 0.7 * radius;
/* transparency is a function of time and intial value */
theme: Make spinner steps count forward, not backward This makes the spinner roate the right way again.
2011-03-05 13:57:55 +00:00
gdouble t = 1.0 - (gdouble) ((i + step) % num_steps) / num_steps;
theme: Fix spinner for inactive state. Previously, the inactive state caused the spinner's solid line to be drawn to the right. Now it's drawn to the top instead, which makes the inactive state look more natural.
2011-03-05 14:01:19 +00:00
gdouble xscale = - sin (i * G_PI / half);
gdouble yscale = - cos (i * G_PI / half);
Add gtk_render_activity() This method will render progress bars and spinners, these should handle active and inconsistent states' animation progress in order to perform animations.
2010-11-01 01:46:35 +00:00
cairo_set_source_rgba (cr,
theming: Avoid boxed struct copies throughout the default engine
2011-03-28 17:34:40 +00:00
color.red,
color.green,
color.blue,
color.alpha * t);
Add gtk_render_activity() This method will render progress bars and spinners, these should handle active and inconsistent states' animation progress in order to perform animations.
2010-11-01 01:46:35 +00:00
cairo_move_to (cr,
theme: Compute scale values once Use a local variable to store the xscale and yscale, so that it's only computed once. Makes it easier to do the changes I'm about to do.
2011-03-05 13:49:19 +00:00
(radius - inset) * xscale,
(radius - inset) * yscale);
Add gtk_render_activity() This method will render progress bars and spinners, these should handle active and inconsistent states' animation progress in order to perform animations.
2010-11-01 01:46:35 +00:00
cairo_line_to (cr,
theme: Compute scale values once Use a local variable to store the xscale and yscale, so that it's only computed once. Makes it easier to do the changes I'm about to do.
2011-03-05 13:49:19 +00:00
radius * xscale,
radius * yscale);
Add gtk_render_activity() This method will render progress bars and spinners, these should handle active and inconsistent states' animation progress in order to perform animations.
2010-11-01 01:46:35 +00:00
cairo_stroke (cr);
}
cairo_restore (cr);
}
else
{
gtk_theming_engine_render_background (engine, cr, x, y, width, height);
gtk_theming_engine_render_frame (engine, cr, x, y, width, height);
}
}
GtkStyleContext: Add gtk_render_icon_pixbuf() This function is similar to gtk_style_render_icon(), which is now implemented on top of this one.
2010-11-03 20:14:08 +00:00
static GdkPixbuf *
scale_or_ref (GdkPixbuf *src,
gint width,
gint height)
{
if (width == gdk_pixbuf_get_width (src) &&
height == gdk_pixbuf_get_height (src))
return g_object_ref (src);
else
return gdk_pixbuf_scale_simple (src,
width, height,
GDK_INTERP_BILINEAR);
}
static gboolean
lookup_icon_size (GtkThemingEngine *engine,
GtkIconSize size,
gint *width,
gint *height)
{
GdkScreen *screen;
GtkSettings *settings;
screen = gtk_theming_engine_get_screen (engine);
settings = gtk_settings_get_for_screen (screen);
return gtk_icon_size_lookup_for_settings (settings, size, width, height);
}
Unify handling of prelighted icons Make GtkEntry use gtk_render_icon_pixbuf for rendering the icons, and move the working icon prelighting code from GtkEntry to GtkThemingEngine. https://bugzilla.gnome.org/show_bug.cgi?id=636691
2011-01-15 04:51:41 +00:00
/* Kudos to the gnome-panel guys. */
static void
colorshift_pixbuf (GdkPixbuf *src,
GdkPixbuf *dest,
gint shift)
{
gint i, j;
gint width, height, has_alpha, src_rowstride, dest_rowstride;
guchar *target_pixels;
guchar *original_pixels;
guchar *pix_src;
guchar *pix_dest;
int val;
guchar r, g, b;
has_alpha = gdk_pixbuf_get_has_alpha (src);
width = gdk_pixbuf_get_width (src);
height = gdk_pixbuf_get_height (src);
src_rowstride = gdk_pixbuf_get_rowstride (src);
dest_rowstride = gdk_pixbuf_get_rowstride (dest);
original_pixels = gdk_pixbuf_get_pixels (src);
target_pixels = gdk_pixbuf_get_pixels (dest);
for (i = 0; i < height; i++)
{
pix_dest = target_pixels + i * dest_rowstride;
pix_src = original_pixels + i * src_rowstride;
for (j = 0; j < width; j++)
{
r = *(pix_src++);
g = *(pix_src++);
b = *(pix_src++);
val = r + shift;
*(pix_dest++) = CLAMP (val, 0, 255);
val = g + shift;
*(pix_dest++) = CLAMP (val, 0, 255);
val = b + shift;
*(pix_dest++) = CLAMP (val, 0, 255);
if (has_alpha)
*(pix_dest++) = *(pix_src++);
}
}
}
GtkStyleContext: Add gtk_render_icon_pixbuf() This function is similar to gtk_style_render_icon(), which is now implemented on top of this one.
2010-11-03 20:14:08 +00:00
static GdkPixbuf *
gtk_theming_engine_render_icon_pixbuf (GtkThemingEngine *engine,
const GtkIconSource *source,
GtkIconSize size)
{
GdkPixbuf *scaled;
GdkPixbuf *stated;
GdkPixbuf *base_pixbuf;
GtkStateFlags state;
gint width = 1;
gint height = 1;
base_pixbuf = gtk_icon_source_get_pixbuf (source);
state = gtk_theming_engine_get_state (engine);
g_return_val_if_fail (base_pixbuf != NULL, NULL);
if (size != (GtkIconSize) -1 &&
!lookup_icon_size (engine, size, &width, &height))
{
g_warning (G_STRLOC ": invalid icon size '%d'", size);
return NULL;
}
/* If the size was wildcarded, and we're allowed to scale, then scale; otherwise,
* leave it alone.
*/
if (size != (GtkIconSize) -1 &&
gtk_icon_source_get_size_wildcarded (source))
scaled = scale_or_ref (base_pixbuf, width, height);
else
scaled = g_object_ref (base_pixbuf);
/* If the state was wildcarded, then generate a state. */
if (gtk_icon_source_get_state_wildcarded (source))
{
if (state & GTK_STATE_FLAG_INSENSITIVE)
{
stated = gdk_pixbuf_copy (scaled);
gdk_pixbuf_saturate_and_pixelate (scaled, stated,
0.8, TRUE);
g_object_unref (scaled);
}
else if (state & GTK_STATE_FLAG_PRELIGHT)
{
stated = gdk_pixbuf_copy (scaled);
Unify handling of prelighted icons Make GtkEntry use gtk_render_icon_pixbuf for rendering the icons, and move the working icon prelighting code from GtkEntry to GtkThemingEngine. https://bugzilla.gnome.org/show_bug.cgi?id=636691
2011-01-15 04:51:41 +00:00
colorshift_pixbuf (scaled, stated, 30);
GtkStyleContext: Add gtk_render_icon_pixbuf() This function is similar to gtk_style_render_icon(), which is now implemented on top of this one.
2010-11-03 20:14:08 +00:00
g_object_unref (scaled);
}
else
stated = scaled;
}
else
stated = scaled;
return stated;
}
Reference in New Issue Copy Permalink