* 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.
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include "gtkmodulesprivate.h"
#include "gtkborderimageprivate.h"
#include "gtkpango.h"
-#include "gtkshadowprivate.h"
+#include "gtkcssarrayvalueprivate.h"
+#include "gtkcsscornervalueprivate.h"
+#include "gtkcssenumvalueprivate.h"
+#include "gtkcssnumbervalueprivate.h"
+#include "gtkcssrgbavalueprivate.h"
+#include "gtkcssshadowsvalueprivate.h"
#include "gtkcsstypesprivate.h"
+#include "gtkhslaprivate.h"
#include "gtkthemingengineprivate.h"
#include "gtkroundedboxprivate.h"
#include "gtkthemingbackgroundprivate.h"
+#include "fallback-c89.c"
+
/**
* SECTION:gtkthemingengine
* @Short_description: Theming renderers
* style information contained in the rendered object's #GtkStyleContext.
*/
-enum {
- SIDE_LEFT = 1,
- SIDE_BOTTOM = 1 << 1,
- SIDE_RIGHT = 1 << 2,
- SIDE_TOP = 1 << 3,
- SIDE_ALL = 0xF
-};
-
enum {
PROP_0,
PROP_NAME
#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))
+GType gtk_theming_module_get_type (void);
+
G_DEFINE_TYPE (GtkThemingModule, gtk_theming_module, G_TYPE_TYPE_MODULE);
static void
priv->context = context;
}
+GtkStyleContext *
+_gtk_theming_engine_get_context (GtkThemingEngine *engine)
+{
+ g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), NULL);
+
+ return engine->priv->context;
+}
+
+GtkCssValue *
+_gtk_theming_engine_peek_property (GtkThemingEngine *engine,
+ guint property_id)
+{
+ g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), NULL);
+
+ return _gtk_style_context_peek_property (engine->priv->context, property_id);
+}
+
/**
* gtk_theming_engine_get_property:
* @engine: a #GtkThemingEngine
gtk_style_context_get_valist (priv->context, state, args);
}
-void
-_gtk_theming_engine_get (GtkThemingEngine *engine,
- GtkStateFlags state,
- GtkStylePropertyContext *property_context,
- ...)
-{
- GtkThemingEnginePrivate *priv;
- va_list args;
-
- g_return_if_fail (GTK_IS_THEMING_ENGINE (engine));
-
- priv = engine->priv;
-
- va_start (args, property_context);
- _gtk_style_context_get_valist (priv->context, state, property_context, args);
- va_end (args);
-}
-
-
/**
* gtk_theming_engine_get:
* @engine: a #GtkThemingEngine
* Returns: %TRUE if there is a running transition animation for @state.
*
* Since: 3.0
+ *
+ * Deprecated: 3.6: Always returns %FALSE
**/
gboolean
gtk_theming_engine_state_is_running (GtkThemingEngine *engine,
GtkStateType state,
gdouble *progress)
{
- GtkThemingEnginePrivate *priv;
-
g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), FALSE);
- priv = engine->priv;
- return gtk_style_context_state_is_running (priv->context, state, progress);
+ return FALSE;
}
/**
* Returns: the widget direction
*
* Since: 3.0
+ *
+ * Deprecated: 3.8: Use gtk_theming_engine_get_state() and
+ * check for #GTK_STATE_FLAG_DIR_LTR and
+ * #GTK_STATE_FLAG_DIR_RTL instead.
**/
GtkTextDirection
gtk_theming_engine_get_direction (GtkThemingEngine *engine)
g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), GTK_TEXT_DIR_LTR);
priv = engine->priv;
+ G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
return gtk_style_context_get_direction (priv->context);
+ G_GNUC_END_IGNORE_DEPRECATIONS;
}
/**
/**
* gtk_theming_engine_get_border:
- * @engine: a #GtkthemingEngine
+ * @engine: a #GtkThemingEngine
* @state: state to retrieve the border for
* @border: (out): return value for the border settings
*
/**
* gtk_theming_engine_get_padding:
- * @engine: a #GtkthemingEngine
+ * @engine: a #GtkThemingEngine
* @state: state to retrieve the padding for
* @padding: (out): return value for the padding settings
*
* freed.
*
* Since: 3.0
+ *
+ * Deprecated: 3.8: Use gtk_theming_engine_get()
**/
const PangoFontDescription *
gtk_theming_engine_get_font (GtkThemingEngine *engine,
g_return_val_if_fail (GTK_IS_THEMING_ENGINE (engine), NULL);
+ G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
priv = engine->priv;
return gtk_style_context_get_font (priv->context, state);
+ G_GNUC_END_IGNORE_DEPRECATIONS;
}
/* GtkThemingModule */
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);
-
- gtk_theming_engine_get (engine, flags,
- "border-style", &border_style,
- NULL);
+ border_style = _gtk_css_border_style_value_get
+ (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_TOP_STYLE));
border_width = MIN (MIN (border.top, border.bottom),
MIN (border.left, border.right));
}
else
{
- gdouble progress;
- gboolean running;
-
- running = gtk_theming_engine_state_is_running (engine, GTK_STATE_ACTIVE, &progress);
-
- if ((flags & GTK_STATE_FLAG_ACTIVE) || running)
+ if (flags & GTK_STATE_FLAG_ACTIVE)
{
- if (!running)
- progress = 1;
-
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_rectangle (cr, 0, 0, 7, 7);
cairo_clip (cr);
cairo_move_to (cr, 7.0, 0.0);
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);
-
- gtk_theming_engine_get (engine, flags,
- "border-style", &border_style,
- NULL);
+ border_style = _gtk_css_border_style_value_get
+ (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_TOP_STYLE));
exterior_size = MIN (width, height);
border_width = MIN (MIN (border.top, border.bottom),
gdouble factor,
GdkRGBA *color_return)
{
- GtkSymbolicColor *literal, *shade;
-
- literal = gtk_symbolic_color_new_literal (color);
- shade = gtk_symbolic_color_new_shade (literal, factor);
- gtk_symbolic_color_unref (literal);
+ GtkHSLA hsla;
- gtk_symbolic_color_resolve (shade, NULL, color_return);
- gtk_symbolic_color_unref (shade);
+ _gtk_hsla_init_from_rgba (&hsla, color);
+ _gtk_hsla_shade (&hsla, &hsla, factor);
+ _gdk_rgba_init_from_hsla (color_return, &hsla);
}
static void
}
static void
-gtk_theming_engine_hide_border_sides (GtkBorder *border,
- guint hidden_side)
+gtk_theming_engine_hide_border_sides (double border[4],
+ GtkBorderStyle border_style[4],
+ guint hidden_side)
{
- if (hidden_side & SIDE_TOP)
- border->top = 0;
- if (hidden_side & SIDE_RIGHT)
- border->right = 0;
- if (hidden_side & SIDE_BOTTOM)
- border->bottom = 0;
- if (hidden_side & SIDE_LEFT)
- border->left = 0;
+ guint i;
+
+ for (i = 0; i < 4; i++)
+ {
+ if (hidden_side & (1 << i) ||
+ border_style[i] == GTK_BORDER_STYLE_NONE ||
+ border_style[i] == GTK_BORDER_STYLE_HIDDEN)
+ border[i] = 0;
+ }
}
static void
-render_frame_internal (GtkThemingEngine *engine,
- cairo_t *cr,
- gdouble x,
- gdouble y,
- gdouble width,
- gdouble height,
- guint hidden_side,
- GtkJunctionSides junction)
+render_frame_fill (cairo_t *cr,
+ GtkRoundedBox *border_box,
+ const double border_width[4],
+ GdkRGBA colors[4],
+ guint hidden_side)
{
- GtkStateFlags state;
- GtkBorderStyle border_style;
- GtkRoundedBox border_box, padding_box;
- gdouble progress;
- gboolean running;
- GtkBorder border;
- static const guint current_side[4] = { SIDE_TOP, SIDE_RIGHT, SIDE_BOTTOM, SIDE_LEFT };
- GdkRGBA *colors[4];
+ GtkRoundedBox padding_box;
guint i, j;
- state = gtk_theming_engine_get_state (engine);
+ padding_box = *border_box;
+ _gtk_rounded_box_shrink (&padding_box,
+ border_width[GTK_CSS_TOP],
+ border_width[GTK_CSS_RIGHT],
+ border_width[GTK_CSS_BOTTOM],
+ border_width[GTK_CSS_LEFT]);
+
+ if (hidden_side == 0 &&
+ gdk_rgba_equal (&colors[0], &colors[1]) &&
+ gdk_rgba_equal (&colors[0], &colors[2]) &&
+ gdk_rgba_equal (&colors[0], &colors[3]))
+ {
+ gdk_cairo_set_source_rgba (cr, &colors[0]);
- gtk_theming_engine_get_border (engine, state, &border);
- gtk_theming_engine_hide_border_sides (&border, hidden_side);
+ _gtk_rounded_box_path (border_box, cr);
+ _gtk_rounded_box_path (&padding_box, cr);
+ cairo_fill (cr);
+ }
+ else
+ {
+ for (i = 0; i < 4; i++)
+ {
+ if (hidden_side & (1 << i))
+ continue;
+
+ for (j = 0; j < 4; j++)
+ {
+ if (hidden_side & (1 << j))
+ continue;
+
+ if (i == j ||
+ (gdk_rgba_equal (&colors[i], &colors[j])))
+ {
+ /* We were already painted when i == j */
+ if (i > j)
+ break;
+
+ if (j == 0)
+ _gtk_rounded_box_path_top (border_box, &padding_box, cr);
+ else if (j == 1)
+ _gtk_rounded_box_path_right (border_box, &padding_box, cr);
+ else if (j == 2)
+ _gtk_rounded_box_path_bottom (border_box, &padding_box, cr);
+ else if (j == 3)
+ _gtk_rounded_box_path_left (border_box, &padding_box, cr);
+ }
+ }
+ /* We were already painted when i == j */
+ if (i > j)
+ continue;
+
+ gdk_cairo_set_source_rgba (cr, &colors[i]);
+
+ cairo_fill (cr);
+ }
+ }
+}
- gtk_theming_engine_get (engine, state,
- "border-style", &border_style,
- "border-top-color", &colors[0],
- "border-right-color", &colors[1],
- "border-bottom-color", &colors[2],
- "border-left-color", &colors[3],
- NULL);
+static void
+set_stroke_style (cairo_t *cr,
+ double line_width,
+ GtkBorderStyle style,
+ double length)
+{
+ double segments[2];
+ double n;
- running = gtk_theming_engine_state_is_running (engine, GTK_STATE_PRELIGHT, &progress);
+ cairo_set_line_width (cr, line_width);
- if (running)
+ if (style == GTK_BORDER_STYLE_DOTTED)
{
- GtkStateFlags other_state;
- GdkRGBA *other_colors[4];
+ n = round (0.5 * length / line_width);
- if (state & GTK_STATE_FLAG_PRELIGHT)
+ segments[0] = 0;
+ segments[1] = n ? length / n : 2;
+ cairo_set_dash (cr, segments, G_N_ELEMENTS (segments), 0);
+
+ cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
+ cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);
+ }
+ else
+ {
+ n = length / line_width;
+ /* Optimize the common case of an integer-sized rectangle
+ * Again, we care about focus rectangles.
+ */
+ if (n == nearbyint (n))
{
- other_state = state & ~(GTK_STATE_FLAG_PRELIGHT);
- progress = 1 - progress;
+ segments[0] = 1;
+ segments[1] = 2;
}
else
- other_state = state | GTK_STATE_FLAG_PRELIGHT;
+ {
+ n = round ((1. / 3) * n);
- gtk_theming_engine_get (engine, other_state,
- "border-top-color", &other_colors[0],
- "border-right-color", &other_colors[1],
- "border-bottom-color", &other_colors[2],
- "border-left-color", &other_colors[3],
- NULL);
+ segments[0] = n ? (1. / 3) * length / n : 1;
+ segments[1] = 2 * segments[1];
+ }
+ cairo_set_dash (cr, segments, G_N_ELEMENTS (segments), 0);
- for (i = 0; i < 4; i++)
+ cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
+ cairo_set_line_join (cr, CAIRO_LINE_JOIN_MITER);
+ }
+}
+
+static void
+render_frame_stroke (cairo_t *cr,
+ GtkRoundedBox *border_box,
+ const double border_width[4],
+ GdkRGBA colors[4],
+ guint hidden_side,
+ GtkBorderStyle stroke_style)
+{
+ gboolean different_colors, different_borders;
+ GtkRoundedBox stroke_box;
+ guint i;
+
+ different_colors = !gdk_rgba_equal (&colors[0], &colors[1]) ||
+ !gdk_rgba_equal (&colors[0], &colors[2]) ||
+ !gdk_rgba_equal (&colors[0], &colors[3]);
+ different_borders = border_width[0] != border_width[1] ||
+ border_width[0] != border_width[2] ||
+ border_width[0] != border_width[3] ;
+
+ stroke_box = *border_box;
+ _gtk_rounded_box_shrink (&stroke_box,
+ border_width[GTK_CSS_TOP] / 2.0,
+ border_width[GTK_CSS_RIGHT] / 2.0,
+ border_width[GTK_CSS_BOTTOM] / 2.0,
+ border_width[GTK_CSS_LEFT] / 2.0);
+
+ if (!different_colors && !different_borders && hidden_side == 0)
+ {
+ double length = 0;
+
+ /* FAST PATH:
+ * Mostly expected to trigger for focus rectangles */
+ for (i = 0; i < 4; i++)
{
- colors[i]->red = CLAMP (colors[i]->red + ((other_colors[i]->red - colors[i]->red) * progress), 0, 1);
- colors[i]->green = CLAMP (colors[i]->green + ((other_colors[i]->green - colors[i]->green) * progress), 0, 1);
- colors[i]->blue = CLAMP (colors[i]->blue + ((other_colors[i]->blue - colors[i]->blue) * progress), 0, 1);
- colors[i]->alpha = CLAMP (colors[i]->alpha + ((other_colors[i]->alpha - colors[i]->alpha) * progress), 0, 1);
- gdk_rgba_free (other_colors[i]);
+ length += _gtk_rounded_box_guess_length (&stroke_box, i);
+ _gtk_rounded_box_path_side (&stroke_box, cr, i);
}
- }
- switch (border_style)
+ gdk_cairo_set_source_rgba (cr, &colors[0]);
+ set_stroke_style (cr, border_width[0], stroke_style, length);
+ cairo_stroke (cr);
+ }
+ else
{
- default:
- g_assert_not_reached ();
- case GTK_BORDER_STYLE_NONE:
- case GTK_BORDER_STYLE_SOLID:
- break;
- case GTK_BORDER_STYLE_INSET:
- color_shade (colors[1], 1.8, colors[1]);
- color_shade (colors[2], 1.8, colors[2]);
- break;
- case GTK_BORDER_STYLE_OUTSET:
- color_shade (colors[0], 1.8, colors[0]);
- color_shade (colors[3], 1.8, colors[3]);
- break;
+ GtkRoundedBox padding_box;
+
+ padding_box = *border_box;
+ _gtk_rounded_box_path (&padding_box, cr);
+ _gtk_rounded_box_shrink (&padding_box,
+ border_width[GTK_CSS_TOP],
+ border_width[GTK_CSS_RIGHT],
+ border_width[GTK_CSS_BOTTOM],
+ border_width[GTK_CSS_LEFT]);
+
+ for (i = 0; i < 4; i++)
+ {
+ if (hidden_side & (1 << i))
+ continue;
+
+ cairo_save (cr);
+
+ if (i == 0)
+ _gtk_rounded_box_path_top (border_box, &padding_box, cr);
+ else if (i == 1)
+ _gtk_rounded_box_path_right (border_box, &padding_box, cr);
+ else if (i == 2)
+ _gtk_rounded_box_path_bottom (border_box, &padding_box, cr);
+ else if (i == 3)
+ _gtk_rounded_box_path_left (border_box, &padding_box, cr);
+ cairo_clip (cr);
+
+ _gtk_rounded_box_path_side (&stroke_box, cr, i);
+
+ gdk_cairo_set_source_rgba (cr, &colors[i]);
+ set_stroke_style (cr,
+ border_width[i],
+ stroke_style,
+ _gtk_rounded_box_guess_length (&stroke_box, i));
+ cairo_stroke (cr);
+
+ cairo_restore (cr);
+ }
}
+}
+
+static void
+render_border (cairo_t *cr,
+ GtkRoundedBox *border_box,
+ const double border_width[4],
+ guint hidden_side,
+ GdkRGBA colors[4],
+ GtkBorderStyle border_style[4])
+{
+ guint i, j;
cairo_save (cr);
cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
- _gtk_rounded_box_init_rect (&border_box, x, y, width, height);
- _gtk_rounded_box_apply_border_radius (&border_box, engine, state, junction);
- padding_box = border_box;
- _gtk_rounded_box_shrink (&padding_box, border.top, border.right, border.bottom, border.left);
-
- switch (border_style)
+ for (i = 0; i < 4; i++)
{
- case GTK_BORDER_STYLE_NONE:
- break;
- case GTK_BORDER_STYLE_SOLID:
- case GTK_BORDER_STYLE_INSET:
- case GTK_BORDER_STYLE_OUTSET:
+ if (hidden_side & (1 << i))
+ continue;
- if (gdk_rgba_equal (colors[0], colors[1]) &&
- gdk_rgba_equal (colors[0], colors[2]) &&
- gdk_rgba_equal (colors[0], colors[3]))
+ switch (border_style[i])
{
- gdk_cairo_set_source_rgba (cr, colors[0]);
-
- _gtk_rounded_box_path (&border_box, cr);
- _gtk_rounded_box_path (&padding_box, cr);
- cairo_fill (cr);
+ case GTK_BORDER_STYLE_NONE:
+ case GTK_BORDER_STYLE_HIDDEN:
+ case GTK_BORDER_STYLE_SOLID:
+ break;
+ case GTK_BORDER_STYLE_INSET:
+ if (i == 1 || i == 2)
+ color_shade (&colors[i], 1.8, &colors[i]);
+ break;
+ case GTK_BORDER_STYLE_OUTSET:
+ if (i == 0 || i == 3)
+ color_shade (&colors[i], 1.8, &colors[i]);
+ break;
+ case GTK_BORDER_STYLE_DOTTED:
+ case GTK_BORDER_STYLE_DASHED:
+ {
+ guint dont_draw = hidden_side;
+
+ for (j = 0; j < 4; j++)
+ {
+ if (border_style[j] == border_style[i])
+ hidden_side |= (1 << j);
+ else
+ dont_draw |= (1 << j);
+ }
+
+ render_frame_stroke (cr, border_box, border_width, colors, dont_draw, border_style[i]);
+ }
+ break;
+ case GTK_BORDER_STYLE_DOUBLE:
+ {
+ GtkRoundedBox other_box;
+ double other_border[4];
+ guint dont_draw = hidden_side;
+
+ for (j = 0; j < 4; j++)
+ {
+ if (border_style[j] == GTK_BORDER_STYLE_DOUBLE)
+ hidden_side |= (1 << j);
+ else
+ dont_draw |= (1 << j);
+
+ other_border[i] = border_width[i] / 3;
+ }
+
+ render_frame_fill (cr, border_box, other_border, colors, dont_draw);
+
+ other_box = *border_box;
+ _gtk_rounded_box_shrink (&other_box,
+ 2 * other_border[GTK_CSS_TOP],
+ 2 * other_border[GTK_CSS_RIGHT],
+ 2 * other_border[GTK_CSS_BOTTOM],
+ 2 * other_border[GTK_CSS_LEFT]);
+ render_frame_fill (cr, &other_box, other_border, colors, dont_draw);
+ }
+ break;
+ case GTK_BORDER_STYLE_GROOVE:
+ case GTK_BORDER_STYLE_RIDGE:
+ {
+ GtkRoundedBox other_box;
+ GdkRGBA other_colors[4];
+ guint dont_draw = hidden_side;
+ double other_border[4];
+
+ for (j = 0; j < 4; j++)
+ {
+ other_colors[j] = colors[j];
+ if ((j == 0 || j == 3) ^ (border_style[j] == GTK_BORDER_STYLE_RIDGE))
+ color_shade (&other_colors[j], 1.8, &other_colors[j]);
+ else
+ color_shade (&colors[j], 1.8, &colors[j]);
+ if (border_style[j] == GTK_BORDER_STYLE_GROOVE ||
+ border_style[j] == GTK_BORDER_STYLE_RIDGE)
+ hidden_side |= (1 << j);
+ else
+ dont_draw |= (1 << j);
+ other_border[i] = border_width[i] / 2;
+ }
+
+ render_frame_fill (cr, border_box, other_border, colors, dont_draw);
+
+ other_box = *border_box;
+ _gtk_rounded_box_shrink (&other_box,
+ other_border[GTK_CSS_TOP],
+ other_border[GTK_CSS_RIGHT],
+ other_border[GTK_CSS_BOTTOM],
+ other_border[GTK_CSS_LEFT]);
+ render_frame_fill (cr, &other_box, other_border, other_colors, dont_draw);
+ }
+ break;
+ default:
+ g_assert_not_reached ();
+ break;
}
- else
- {
- for (i = 0; i < 4; i++)
- {
- if (hidden_side & current_side[i])
- continue;
+ }
+
+ render_frame_fill (cr, border_box, border_width, colors, hidden_side);
- for (j = 0; j < 4; j++)
- {
- if (hidden_side & current_side[j])
- continue;
-
- if (i == j ||
- gdk_rgba_equal (colors[i], colors[j]))
- {
- /* We were already painted when i == j */
- if (i > j)
- break;
-
- if (j == 0)
- _gtk_rounded_box_path_top (&border_box, &padding_box, cr);
- else if (j == 1)
- _gtk_rounded_box_path_right (&border_box, &padding_box, cr);
- else if (j == 2)
- _gtk_rounded_box_path_bottom (&border_box, &padding_box, cr);
- else if (j == 3)
- _gtk_rounded_box_path_left (&border_box, &padding_box, cr);
- }
- }
- /* We were already painted when i == j */
- if (i > j)
- continue;
+ cairo_restore (cr);
+}
- gdk_cairo_set_source_rgba (cr, colors[i]);
+static void
+render_frame_internal (GtkThemingEngine *engine,
+ cairo_t *cr,
+ gdouble x,
+ gdouble y,
+ gdouble width,
+ gdouble height,
+ guint hidden_side,
+ GtkJunctionSides junction)
+{
+ GtkBorderImage border_image;
+ GtkBorderStyle border_style[4];
+ GtkRoundedBox border_box;
+ double border_width[4];
+ GdkRGBA colors[4];
- cairo_fill (cr);
- }
- }
- break;
- }
+ border_width[0] = _gtk_css_number_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_TOP_WIDTH), 100);
+ border_width[1] = _gtk_css_number_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_RIGHT_WIDTH), 100);
+ border_width[2] = _gtk_css_number_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_BOTTOM_WIDTH), 100);
+ border_width[3] = _gtk_css_number_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_LEFT_WIDTH), 100);
- cairo_restore (cr);
+ border_style[0] = _gtk_css_border_style_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_TOP_STYLE));
+ border_style[1] = _gtk_css_border_style_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_RIGHT_STYLE));
+ border_style[2] = _gtk_css_border_style_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_BOTTOM_STYLE));
+ border_style[3] = _gtk_css_border_style_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_LEFT_STYLE));
- for (i = 0; i < 4; i++)
- gdk_rgba_free (colors[i]);
+ gtk_theming_engine_hide_border_sides (border_width, border_style, hidden_side);
+
+ if (_gtk_border_image_init (&border_image, engine))
+ _gtk_border_image_render (&border_image, border_width, cr, x, y, width, height);
+ else
+ {
+ colors[0] = *_gtk_css_rgba_value_get_rgba (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_TOP_COLOR));
+ colors[1] = *_gtk_css_rgba_value_get_rgba (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_RIGHT_COLOR));
+ colors[2] = *_gtk_css_rgba_value_get_rgba (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_BOTTOM_COLOR));
+ colors[3] = *_gtk_css_rgba_value_get_rgba (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_LEFT_COLOR));
+
+ _gtk_rounded_box_init_rect (&border_box, x, y, width, height);
+ _gtk_rounded_box_apply_border_radius_for_engine (&border_box, engine, junction);
+
+ render_border (cr, &border_box, border_width, hidden_side, colors, border_style);
+ }
+
+ border_style[0] = _gtk_css_border_style_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_OUTLINE_STYLE));
+ if (border_style[0] != GTK_BORDER_STYLE_NONE)
+ {
+ int offset;
+
+ border_style[1] = border_style[2] = border_style[3] = border_style[0];
+ border_width[0] = _gtk_css_number_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_OUTLINE_WIDTH), 100);
+ border_width[3] = border_width[2] = border_width[1] = border_width[0];
+ colors[0] = *_gtk_css_rgba_value_get_rgba (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_OUTLINE_COLOR));
+ colors[3] = colors[2] = colors[1] = colors[0];
+ offset = _gtk_css_number_value_get (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_OUTLINE_OFFSET), 100);
+
+ /* reinit box here - outlines don't have a border radius */
+ _gtk_rounded_box_init_rect (&border_box, x, y, width, height);
+ _gtk_rounded_box_shrink (&border_box,
+ - border_width[GTK_CSS_TOP] - offset,
+ - border_width[GTK_CSS_RIGHT] - offset,
+ - border_width[GTK_CSS_LEFT] - offset,
+ - border_width[GTK_CSS_BOTTOM] - offset);
+
+ render_border (cr, &border_box, border_width, hidden_side, colors, border_style);
+ }
}
static void
gdouble width,
gdouble height)
{
- GtkStateFlags flags;
- GtkBorderStyle border_style;
GtkJunctionSides junction;
- GtkBorderImage *border_image;
- GtkBorder border;
- GtkStylePropertyContext context;
- flags = gtk_theming_engine_get_state (engine);
junction = gtk_theming_engine_get_junction_sides (engine);
- gtk_theming_engine_get_border (engine, flags, &border);
-
- context.width = width;
- context.height = height;
- _gtk_theming_engine_get (engine, flags, &context,
- "border-image", &border_image,
- "border-style", &border_style,
- NULL);
-
- if (border_image != NULL)
- {
- _gtk_border_image_render (border_image, &border,
- cr, x, y, width, height);
- _gtk_border_image_unref (border_image);
- }
- else if (border_style != GTK_BORDER_STYLE_NONE)
- render_frame_internal (engine, cr,
- x, y, width, height,
- 0, junction);
+ render_frame_internal (engine, cr,
+ x, y, width, height,
+ 0, junction);
}
static void
double x_double, y_double;
gdouble angle;
gint line_width;
- gboolean running, is_rtl;
+ gboolean is_rtl;
gdouble progress;
cairo_save (cr);
gtk_theming_engine_get_color (engine, flags, &fg_color);
gtk_theming_engine_get_border_color (engine, flags, &outline_color);
- running = gtk_theming_engine_state_is_running (engine, GTK_STATE_ACTIVE, &progress);
- is_rtl = (gtk_theming_engine_get_direction (engine) == GTK_TEXT_DIR_RTL);
+ is_rtl = (gtk_theming_engine_get_state (engine) & GTK_STATE_FLAG_DIR_RTL);
line_width = 1;
-
- if (!running)
- progress = (flags & GTK_STATE_FLAG_ACTIVE) ? 1 : 0;
+ progress = (flags & GTK_STATE_FLAG_ACTIVE) ? 1 : 0;
if (!gtk_theming_engine_has_class (engine, GTK_STYLE_CLASS_HORIZONTAL))
{
PangoLayout *layout)
{
GdkRGBA fg_color;
- GtkShadow *text_shadow = NULL;
GtkStateFlags flags;
- gdouble progress;
- gboolean running;
cairo_save (cr);
flags = gtk_theming_engine_get_state (engine);
gtk_theming_engine_get_color (engine, flags, &fg_color);
- running = gtk_theming_engine_state_is_running (engine, GTK_STATE_PRELIGHT, &progress);
-
- if (running)
- {
- GtkStateFlags other_flags;
- GdkRGBA other_fg;
-
- if (flags & GTK_STATE_FLAG_PRELIGHT)
- {
- other_flags = flags & ~(GTK_STATE_FLAG_PRELIGHT);
- progress = 1 - progress;
- }
- else
- other_flags = flags | GTK_STATE_FLAG_PRELIGHT;
-
- gtk_theming_engine_get_color (engine, other_flags, &other_fg);
-
- 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);
- }
-
- gtk_theming_engine_get (engine, flags,
- "text-shadow", &text_shadow,
- NULL);
-
prepare_context_for_layout (cr, x, y, layout);
- if (text_shadow != NULL)
- {
- _gtk_text_shadow_paint_layout (text_shadow, cr, layout);
- _gtk_shadow_unref (text_shadow);
- }
+ _gtk_css_shadows_value_paint_layout (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_TEXT_SHADOW),
+ cr, layout);
gdk_cairo_set_source_rgba (cr, &fg_color);
pango_cairo_show_layout (cr, layout);
gdouble height,
GtkOrientation orientation)
{
- const GtkWidgetPath *path;
- gint thickness;
-
- 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);
-
- /* FIXME: thickness */
- thickness = 2;
-
- if (gtk_widget_path_is_type (path, GTK_TYPE_SCALE))
- {
- if (orientation == GTK_ORIENTATION_VERTICAL)
- gtk_theming_engine_render_line (engine, cr,
- x + thickness,
- y + (gint) height / 2,
- x + width - thickness - 1,
- y + (gint) height / 2);
- else
- gtk_theming_engine_render_line (engine, cr,
- x + (gint) width / 2,
- y + thickness,
- x + (gint) width / 2,
- y + height - thickness - 1);
- }
}
static void
GtkJunctionSides junction;
GtkStateFlags state;
gint border_width;
- GtkCssBorderCornerRadius *top_left_radius, *top_right_radius;
- GtkCssBorderCornerRadius *bottom_left_radius, *bottom_right_radius;
- GtkCssBorderRadius border_radius = { { 0, }, };
+ GtkCssValue *corner[4];
gdouble x0, y0, x1, y1, xc, yc, wc, hc;
- GtkStylePropertyContext context;
- GtkBorderImage *border_image;
GtkBorder border;
xc = yc = wc = hc = 0;
state = gtk_theming_engine_get_state (engine);
junction = gtk_theming_engine_get_junction_sides (engine);
- context.width = width;
- context.height = height;
-
gtk_theming_engine_get_border (engine, state, &border);
- _gtk_theming_engine_get (engine, state, &context,
- "border-image", &border_image,
- /* Can't use border-radius as it's an int for
- * backwards compat */
- "border-top-left-radius", &top_left_radius,
- "border-top-right-radius", &top_right_radius,
- "border-bottom-right-radius", &bottom_right_radius,
- "border-bottom-left-radius", &bottom_left_radius,
- NULL);
-
- if (top_left_radius)
- border_radius.top_left = *top_left_radius;
- g_free (top_left_radius);
- if (top_right_radius)
- border_radius.top_right = *top_right_radius;
- g_free (top_right_radius);
- if (bottom_right_radius)
- border_radius.bottom_right = *bottom_right_radius;
- g_free (bottom_right_radius);
- if (bottom_left_radius)
- border_radius.bottom_left = *bottom_left_radius;
- g_free (bottom_left_radius);
+ corner[GTK_CSS_TOP_LEFT] = _gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_TOP_LEFT_RADIUS);
+ corner[GTK_CSS_TOP_RIGHT] = _gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_TOP_RIGHT_RADIUS);
+ corner[GTK_CSS_BOTTOM_LEFT] = _gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_BOTTOM_LEFT_RADIUS);
+ corner[GTK_CSS_BOTTOM_RIGHT] = _gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_BORDER_BOTTOM_RIGHT_RADIUS);
border_width = MIN (MIN (border.top, border.bottom),
MIN (border.left, border.right));
wc = MAX (xy1_gap - xy0_gap - 2 * border_width, 0);
hc = border_width;
- if (xy0_gap < border_radius.top_left.horizontal)
+ if (xy0_gap < _gtk_css_corner_value_get_x (corner[GTK_CSS_TOP_LEFT], width))
junction |= GTK_JUNCTION_CORNER_TOPLEFT;
- if (xy1_gap > width - border_radius.top_right.horizontal)
+ if (xy1_gap > width - _gtk_css_corner_value_get_x (corner[GTK_CSS_TOP_RIGHT], width))
junction |= GTK_JUNCTION_CORNER_TOPRIGHT;
break;
case GTK_POS_BOTTOM:
wc = MAX (xy1_gap - xy0_gap - 2 * border_width, 0);
hc = border_width;
- if (xy0_gap < border_radius.bottom_left.horizontal)
+ if (xy0_gap < _gtk_css_corner_value_get_x (corner[GTK_CSS_BOTTOM_LEFT], width))
junction |= GTK_JUNCTION_CORNER_BOTTOMLEFT;
- if (xy1_gap > width - border_radius.bottom_right.horizontal)
+ if (xy1_gap > width - _gtk_css_corner_value_get_x (corner[GTK_CSS_BOTTOM_RIGHT], width))
junction |= GTK_JUNCTION_CORNER_BOTTOMRIGHT;
break;
wc = border_width;
hc = MAX (xy1_gap - xy0_gap - 2 * border_width, 0);
- if (xy0_gap < border_radius.top_left.vertical)
+ if (xy0_gap < _gtk_css_corner_value_get_y (corner[GTK_CSS_TOP_LEFT], height))
junction |= GTK_JUNCTION_CORNER_TOPLEFT;
- if (xy1_gap > height - border_radius.bottom_left.vertical)
+ if (xy1_gap > height - _gtk_css_corner_value_get_y (corner[GTK_CSS_BOTTOM_LEFT], height))
junction |= GTK_JUNCTION_CORNER_BOTTOMLEFT;
break;
wc = border_width;
hc = MAX (xy1_gap - xy0_gap - 2 * border_width, 0);
- if (xy0_gap < border_radius.top_right.vertical)
+ if (xy0_gap < _gtk_css_corner_value_get_y (corner[GTK_CSS_TOP_RIGHT], height))
junction |= GTK_JUNCTION_CORNER_TOPRIGHT;
- if (xy1_gap > height - border_radius.bottom_right.vertical)
+ if (xy1_gap > height - _gtk_css_corner_value_get_y (corner[GTK_CSS_BOTTOM_RIGHT], height))
junction |= GTK_JUNCTION_CORNER_BOTTOMRIGHT;
break;
cairo_rectangle (cr, x0, yc + hc, x1 - x0, y1 - (yc + hc));
cairo_clip (cr);
- if (border_image != NULL)
- {
- _gtk_border_image_render (border_image, &border,
- cr, x, y, width, height);
- _gtk_border_image_unref (border_image);
- }
- else
- render_frame_internal (engine, cr,
- x, y, width, height,
- 0, junction);
+ render_frame_internal (engine, cr,
+ x, y, width, height,
+ 0, junction);
cairo_restore (cr);
}
GtkJunctionSides junction = 0;
guint hidden_side = 0;
- cairo_save (cr);
-
switch (gap_side)
{
case GTK_POS_LEFT:
junction = GTK_JUNCTION_LEFT;
- hidden_side = SIDE_LEFT;
-
- cairo_translate (cr, x + width, y);
- cairo_rotate (cr, G_PI / 2);
+ hidden_side = (1 << GTK_CSS_LEFT);
break;
case GTK_POS_RIGHT:
junction = GTK_JUNCTION_RIGHT;
- hidden_side = SIDE_RIGHT;
-
- cairo_translate (cr, x, y + height);
- cairo_rotate (cr, - G_PI / 2);
+ hidden_side = (1 << GTK_CSS_RIGHT);
break;
case GTK_POS_TOP:
junction = GTK_JUNCTION_TOP;
- hidden_side = SIDE_TOP;
-
- cairo_translate (cr, x + width, y + height);
- cairo_rotate (cr, G_PI);
+ hidden_side = (1 << GTK_CSS_TOP);
break;
case GTK_POS_BOTTOM:
junction = GTK_JUNCTION_BOTTOM;
- hidden_side = SIDE_BOTTOM;
-
- cairo_translate (cr, x, y);
+ hidden_side = (1 << GTK_CSS_BOTTOM);
break;
}
- if (gap_side == GTK_POS_TOP ||
- gap_side == GTK_POS_BOTTOM)
- _gtk_theming_background_init (&bg, engine,
- 0, 0,
- width, height,
- GTK_JUNCTION_BOTTOM);
- else
- _gtk_theming_background_init (&bg, engine,
- 0, 0,
- height, width,
- GTK_JUNCTION_BOTTOM);
-
+ _gtk_theming_background_init (&bg, engine,
+ x, y,
+ width, height,
+ junction);
_gtk_theming_background_render (&bg, cr);
- cairo_restore (cr);
-
- cairo_save (cr);
-
render_frame_internal (engine, cr,
x, y, width, height,
hidden_side, junction);
-
- cairo_restore (cr);
}
static void
GtkJunctionSides sides;
GtkThemingBackground bg;
gint xx, yy;
+ gboolean has_image;
cairo_save (cr);
flags = gtk_theming_engine_get_state (engine);
color_shade (&bg_color, 1.3, &lighter);
_gtk_theming_background_init (&bg, engine, x, y, width, height, sides);
+ has_image = _gtk_theming_background_has_background_image (&bg);
_gtk_theming_background_render (&bg, cr);
+ gtk_theming_engine_render_frame (engine, cr, x, y, width, height);
+
if (gtk_theming_engine_has_class (engine, GTK_STYLE_CLASS_GRIP))
{
/* reduce confusing values to a meaningful state */
}
else if (gtk_theming_engine_has_class (engine, GTK_STYLE_CLASS_PANE_SEPARATOR))
{
- if (width > height)
- 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);
+ if (!has_image)
+ {
+ if (width > height)
+ 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);
+ }
}
else
{
}
void
-_gtk_theming_engine_paint_spinner (cairo_t *cr,
- gdouble radius,
- gdouble progress,
- GdkRGBA *color)
+_gtk_theming_engine_paint_spinner (cairo_t *cr,
+ gdouble radius,
+ gdouble progress,
+ const GdkRGBA *color)
{
guint num_steps, step;
gdouble half;
gdouble height)
{
GtkStateFlags state;
- GtkShadow *shadow;
GdkRGBA color;
- gdouble progress;
gdouble radius;
state = gtk_theming_engine_get_state (engine);
-
- if (!gtk_theming_engine_state_is_running (engine, GTK_STATE_ACTIVE, &progress))
- progress = -1;
-
radius = MIN (width / 2, height / 2);
gtk_theming_engine_get_color (engine, state, &color);
- gtk_theming_engine_get (engine, state,
- "icon-shadow", &shadow,
- NULL);
cairo_save (cr);
cairo_translate (cr, x + width / 2, y + height / 2);
- if (shadow != NULL)
- {
- _gtk_icon_shadow_paint_spinner (shadow, cr,
- radius,
- progress);
- _gtk_shadow_unref (shadow);
- }
+ _gtk_css_shadows_value_paint_spinner (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_ICON_SHADOW),
+ cr,
+ radius,
+ -1);
_gtk_theming_engine_paint_spinner (cr,
radius,
- progress,
+ -1,
&color);
cairo_restore (cr);
gdouble width,
gdouble height)
{
- if (gtk_theming_engine_has_class (engine, GTK_STYLE_CLASS_SPINNER))
+ GtkThemingBackground bg;
+
+ _gtk_theming_background_init (&bg, engine, x, y, width, height, 0);
+
+ if (gtk_theming_engine_has_class (engine, GTK_STYLE_CLASS_SPINNER) &&
+ !_gtk_theming_background_has_background_image (&bg))
{
render_spinner (engine, cr, x, y, width, height);
}
else
{
- gtk_theming_engine_render_background (engine, cr, x, y, width, height);
+ _gtk_theming_background_render (&bg, cr);
gtk_theming_engine_render_frame (engine, cr, x, y, width, height);
}
}
gdouble x,
gdouble y)
{
- GtkStateFlags state;
- GtkShadow *icon_shadow;
-
- state = gtk_theming_engine_get_state (engine);
-
cairo_save (cr);
gdk_cairo_set_source_pixbuf (cr, pixbuf, x, y);
- gtk_theming_engine_get (engine, state,
- "icon-shadow", &icon_shadow,
- NULL);
-
- if (icon_shadow != NULL)
- {
- _gtk_icon_shadow_paint (icon_shadow, cr);
- _gtk_shadow_unref (icon_shadow);
- }
+ _gtk_css_shadows_value_paint_icon (_gtk_theming_engine_peek_property (engine, GTK_CSS_PROPERTY_ICON_SHADOW), cr);
cairo_paint (cr);
projects / ~andy / gtk / blobdiff