* Boston, MA 02111-1307, USA.
*/
-#include "config.h"
+#include <config.h>
#ifdef HAVE_ANIMATION
#include <gtk/gtk.h>
+++ /dev/null
-static unsigned char dot_intensity[] = {
-0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,
-0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,
-0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,
-0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,
-0x6e,0x6e,0x6e,0x6e,0x98,0xb9,0xc6,0xb9,0x91,0x6e,0x6e,0x6e,0x6e,
-0x6e,0x6e,0x6e,0x6e,0xb9,0xbd,0xac,0x9e,0x65,0x6e,0x6e,0x6e,0x6e,
-0x6e,0x6e,0x6e,0x6e,0xc6,0xac,0x9e,0x96,0x5c,0x6e,0x6e,0x6e,0x6e,
-0x6e,0x6e,0x6e,0x6e,0xb9,0x9e,0x96,0x62,0x55,0x6e,0x6e,0x6e,0x6e,
-0x6e,0x6e,0x6e,0x6e,0x91,0x65,0x5c,0x55,0x68,0x6e,0x6e,0x6e,0x6e,
-0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,
-0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,
-0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,
-0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,0x6e,
-};
-static unsigned char dot_alpha[] = {
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x66,0xc4,0xff,0xc4,0x66,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x66,0xdf,0xff,0xff,0xff,0xdf,0x66,0x00,0x00,0x00,
-0x00,0x00,0x00,0xc4,0xff,0xff,0xff,0xff,0xff,0xc4,0x00,0x00,0x00,
-0x00,0x00,0x00,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00,0x00,0x00,
-0x00,0x00,0x00,0xc4,0xff,0xff,0xff,0xff,0xff,0xc4,0x00,0x00,0x00,
-0x00,0x00,0x00,0x66,0xdf,0xff,0xff,0xff,0xdf,0x66,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x66,0xc4,0xff,0xc4,0x66,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-};
-
-static unsigned char circle_alpha[] = {
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x23,0x62,0x92,0xb3,0xb2,0x95,0x2b,0x00,0x00,0x00,
-0x00,0x00,0x3e,0xab,0xc9,0xeb,0xf9,0xf5,0xfd,0xff,0x57,0x00,0x00,
-0x00,0x1f,0xb5,0xd8,0xfc,0xff,0xff,0xff,0xff,0xff,0xff,0x2b,0x00,
-0x00,0x67,0xb9,0xf2,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x9c,0x00,
-0x00,0x9a,0xe2,0xfc,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xe5,0x00,
-0x00,0xba,0xeb,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00,
-0x00,0xc0,0xfa,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xe5,0x00,
-0x00,0x9b,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x9c,0x00,
-0x00,0x2b,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x2b,0x00,
-0x00,0x00,0x57,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x57,0x00,0x00,
-0x00,0x00,0x00,0x2b,0x9c,0xe5,0xff,0xe5,0x9c,0x2b,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-};
-static unsigned char outline_alpha[] = {
-0x00,0x00,0x00,0x4a,0xac,0xe9,0xff,0xe9,0xac,0x4a,0x00,0x00,0x00,
-0x00,0x00,0x98,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x98,0x00,0x00,
-0x00,0x98,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x98,0x00,
-0x4a,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x4a,
-0xac,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xac,
-0xe9,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xe9,
-0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
-0xe9,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xe9,
-0xac,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xac,
-0x4a,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x4a,
-0x00,0x98,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x98,0x00,
-0x00,0x00,0x98,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x98,0x00,0x00,
-0x00,0x00,0x00,0x4a,0xac,0xe9,0xff,0xe9,0xac,0x4a,0x00,0x00,0x00,
-};
-static unsigned char inconsistent_alpha[] = {
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0xfe,0xff,0xff,0xff,0xff,0xff,0xff,0x00,0x00,0x00,
-0x00,0x00,0x00,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00,0x00,0x00,
-0x00,0x00,0x00,0xff,0xff,0xff,0xff,0xff,0xff,0xf8,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-};
-static unsigned char check_base_alpha[] = {
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0xea,0xea,0xea,0xea,0xea,0xea,0xea,0xea,0xea,0xea,0xea,0x00,
-0x00,0xea,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00,
-0x00,0xea,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00,
-0x00,0xea,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00,
-0x00,0xea,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00,
-0x00,0xea,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00,
-0x00,0xea,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00,
-0x00,0xea,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00,
-0x00,0xea,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00,
-0x00,0xea,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00,
-0x00,0xea,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-};
-static unsigned char check_alpha[] = {
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 11, 137, 151,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00, 9, 183, 172, 7,0x00,0x00,
-0x00,0x00, 12, 18,0x00,0x00, 3, 161, 233, 27,0x00,0x00,0x00,
-0x00,0x00, 199, 239, 101,0x00, 85, 253, 108,0x00,0x00,0x00,0x00,
-0x00,0x00, 83, 245, 250, 75, 206, 230, 8,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00, 104, 252, 243, 253, 124,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00, 2, 162, 255, 241, 28,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00, 18, 228, 163,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00, 78, 62,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-};
-static unsigned char check_inconsistent_alpha[] = {
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00,0x00,
-0x00,0x00,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00,0x00,
-0x00,0x00,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-};
gdouble m1, m2, m3;
if (!color) return;
-
+
if (brightness <= 0.5)
m2 = brightness * (1 + saturation);
else
m2 = brightness + saturation - brightness * saturation;
-
+
m1 = 2 * brightness - m2;
-
+
hue_shift[0] = hue + 120;
hue_shift[1] = hue;
hue_shift[2] = hue - 120;
-
+
color_shift[0] = color_shift[1] = color_shift[2] = brightness;
-
+
i = (saturation == 0)?3:0;
-
+
for (; i < 3; i++)
{
m3 = hue_shift[i];
-
+
if (m3 > 360)
m3 = MODULA(m3, 360);
else if (m3 < 0)
m3 = 360 - MODULA(ABS(m3), 360);
-
+
if (m3 < 60)
color_shift[i] = m1 + (m2 - m1) * m3 / 60;
else if (m3 < 180)
color_shift[i] = m1 + (m2 - m1) * (240 - m3) / 60;
else
color_shift[i] = m1;
- }
-
+ }
+
color->r = color_shift[0];
color->g = color_shift[1];
color->b = color_shift[2];
g_return_if_fail (style && cube);
for (i = 0; i < 5; i++)
- {
+ {
ge_gdk_color_to_cairo (&style->bg[i], &cube->bg[i]);
ge_gdk_color_to_cairo (&style->fg[i], &cube->fg[i]);
ge_gdk_color_to_cairo (&style->base[i], &cube->base[i]);
ge_gdk_color_to_cairo (&style->text[i], &cube->text[i]);
ge_gdk_color_to_cairo (&style->text_aa[i], &cube->text_aa[i]);
- }
+ }
cube->black.r = cube->black.g = cube->black.b = 0;
cube->black.a = 1;
gdouble hue = 0;
gdouble saturation = 0;
gdouble brightness = 0;
-
+
g_return_if_fail (base && composite);
+
+ if (shade_ratio == 1.0)
+ {
+ composite->r = base->r;
+ composite->g = base->g;
+ composite->b = base->b;
+ composite->a = base->a;
+
+ return;
+ }
ge_hsb_from_color (base, &hue, &saturation, &brightness);
-
+
brightness = MIN(brightness*shade_ratio, 1.0);
brightness = MAX(brightness, 0.0);
-
+
saturation = MIN(saturation*shade_ratio, 1.0);
saturation = MAX(saturation, 0.0);
-
+
ge_color_from_hsb (hue, saturation, brightness, composite);
composite->a = base->a;
}
gdouble hue = 0;
gdouble saturation = 0;
gdouble brightness = 0;
-
+
g_return_if_fail (base && composite);
ge_hsb_from_color (base, &hue, &saturation, &brightness);
}
void
-ge_mix_color (const CairoColor *color1, const CairoColor *color2,
+ge_mix_color (const CairoColor *color1, const CairoColor *color2,
gdouble mix_factor, CairoColor *composite)
{
g_return_if_fail (color1 && color2 && composite);
cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
cairo_set_line_join (cr, CAIRO_LINE_JOIN_MITER);
- if (area)
+ if (area)
{
cairo_rectangle (cr, area->x, area->y, area->width, area->height);
cairo_clip_preserve (cr);
void
ge_cairo_pattern_add_color_stop_color (cairo_pattern_t *pattern,
- gfloat offset,
- const CairoColor *color)
+ gfloat offset,
+ const CairoColor *color)
{
g_return_if_fail (pattern && color);
}
void
-ge_cairo_pattern_add_color_stop_shade(cairo_pattern_t *pattern,
- gdouble offset,
- const CairoColor *color,
- gdouble shade)
+ge_cairo_pattern_add_color_stop_shade (cairo_pattern_t *pattern,
+ gdouble offset,
+ const CairoColor *color,
+ gdouble shade)
{
CairoColor shaded;
ge_shade_color(color, shade, &shaded);
}
- ge_cairo_pattern_add_color_stop_color(pattern, offset, &shaded);
+ ge_cairo_pattern_add_color_stop_color(pattern, offset, &shaded);
}
-/* This function will draw a rounded corner at position x,y. If the radius
+/*
+ * This function will draw a rounded corner at position x,y. If the radius
* is very small (or negative) it will instead just do a line_to.
- * ge_cairo_rounded_corner assumes clockwise drawing. */
+ * ge_cairo_rounded_corner assumes clockwise drawing.
+ */
void
ge_cairo_rounded_corner (cairo_t *cr,
double x,
}
else
{
- switch (corner) {
- case CR_CORNER_NONE:
- cairo_line_to (cr, x, y);
- break;
- case CR_CORNER_TOPLEFT:
- cairo_arc (cr, x + radius, y + radius, radius, G_PI, G_PI * 3/2);
- break;
- case CR_CORNER_TOPRIGHT:
- cairo_arc (cr, x - radius, y + radius, radius, G_PI * 3/2, G_PI * 2);
- break;
- case CR_CORNER_BOTTOMRIGHT:
- cairo_arc (cr, x - radius, y - radius, radius, 0, G_PI * 1/2);
- break;
- case CR_CORNER_BOTTOMLEFT:
- cairo_arc (cr, x + radius, y - radius, radius, G_PI * 1/2, G_PI);
- break;
-
- default:
- /* A bitfield and not a sane value ... */
- g_assert_not_reached ();
- cairo_line_to (cr, x, y);
- return;
+ switch (corner)
+ {
+ case CR_CORNER_NONE:
+ cairo_line_to (cr, x, y);
+ break;
+ case CR_CORNER_TOPLEFT:
+ cairo_arc (cr, x + radius, y + radius, radius, G_PI, G_PI * 3/2);
+ break;
+ case CR_CORNER_TOPRIGHT:
+ cairo_arc (cr, x - radius, y + radius, radius, G_PI * 3/2, G_PI * 2);
+ break;
+ case CR_CORNER_BOTTOMRIGHT:
+ cairo_arc (cr, x - radius, y - radius, radius, 0, G_PI * 1/2);
+ break;
+ case CR_CORNER_BOTTOMLEFT:
+ cairo_arc (cr, x + radius, y - radius, radius, G_PI * 1/2, G_PI);
+ break;
+
+ default:
+ /* A bitfield and not a sane value ... */
+ g_assert_not_reached ();
+ cairo_line_to (cr, x, y);
+ return;
}
}
}
/* ge_cairo_stroke_rectangle.
*
- * A simple function to stroke the rectangle { x, y, w, h}.
- * (This function only exists because of a cairo performance bug that
- * has been fixed and it may be a good idea to get rid of it again.)
+ * A simple function to stroke the rectangle { x, y, w, h}.
+ * (This function only exists because of a cairo performance bug that
+ * has been fixed and it may be a good idea to get rid of it again.)
*/
void
ge_cairo_stroke_rectangle (cairo_t *cr, double x, double y, double w, double h)
cairo_stroke (cr);
}
+void
+ge_cairo_inner_rectangle (cairo_t *cr,
+ double x, double y,
+ double width, double height)
+{
+ double line_width = cairo_get_line_width (cr);
+
+ cairo_rectangle (cr, x + line_width / 2.0,
+ y + line_width / 2.0,
+ width - line_width,
+ height - line_width);
+}
+
+void
+ge_cairo_inner_rounded_rectangle (cairo_t *cr,
+ double x, double y,
+ double width, double height,
+ double radius, CairoCorners corners)
+{
+ double line_width = cairo_get_line_width (cr);
+
+ ge_cairo_rounded_rectangle (cr,
+ x + line_width / 2.0,
+ y + line_width / 2.0,
+ width - line_width,
+ height - line_width,
+ radius, corners);
+}
+
/***********************************************
* ge_cairo_simple_border -
*
* A simple routine to draw thin squared
* borders with a topleft and bottomright color.
- *
+ *
* It originated in Smooth-Engine.
***********************************************/
void
ge_cairo_simple_border (cairo_t *cr,
- const CairoColor * tl, const CairoColor * br,
- gint x, gint y, gint width, gint height,
- gboolean topleft_overlap)
+ const CairoColor * tl, const CairoColor * br,
+ gint x, gint y, gint width, gint height,
+ gboolean topleft_overlap)
{
gboolean solid_color;
cairo_stroke (cr);
}
-
+
ge_cairo_set_color(cr, tl);
cairo_move_to(cr, x + 0.5, y + height - 0.5);
}
void ge_cairo_polygon (cairo_t *cr,
- const CairoColor *color,
- GdkPoint *points,
- gint npoints)
+ const CairoColor *color,
+ GdkPoint *points,
+ gint npoints)
{
int i = 0;
}
void ge_cairo_line (cairo_t *cr,
- const CairoColor *color,
- gint x1,
- gint y1,
- gint x2,
- gint y2)
-{
+ const CairoColor *color,
+ gint x1,
+ gint y1,
+ gint x2,
+ gint y2)
+{
cairo_save(cr);
ge_cairo_set_color(cr, color);
***********************************************/
void
ge_cairo_pattern_fill(cairo_t *canvas,
- CairoPattern *pattern,
- gint x,
- gint y,
- gint width,
- gint height)
+ CairoPattern *pattern,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
{
cairo_matrix_t original_matrix, current_matrix;
if (pattern->operator == CAIRO_OPERATOR_DEST)
- {
return;
- }
+
+ if (width <= 0 || height <= 0)
+ return;
cairo_pattern_get_matrix(pattern->handle, &original_matrix);
current_matrix = original_matrix;
cairo_save(canvas);
cairo_set_source(canvas, pattern->handle);
- cairo_set_operator(canvas, pattern->operator);
+ cairo_set_operator(canvas, pattern->operator);
cairo_rectangle(canvas, x, y, width, height);
cairo_fill (canvas);
***********************************************/
CairoPattern*
ge_cairo_color_pattern(CairoColor *base)
-{
+{
CairoPattern * result = g_new0(CairoPattern, 1);
#if ((CAIRO_VERSION_MAJOR < 1) || ((CAIRO_VERSION_MAJOR == 1) && (CAIRO_VERSION_MINOR < 2)))
result->scale = GE_DIRECTION_NONE;
result->translate = GE_DIRECTION_NONE;
- result->handle = cairo_pattern_create_rgba(base->r,
- base->g,
- base->b,
- base->a);
+ result->handle = cairo_pattern_create_rgba(base->r,
+ base->g,
+ base->b,
+ base->a);
result->operator = CAIRO_OPERATOR_SOURCE;
***********************************************/
CairoPattern*
ge_cairo_pixbuf_pattern(GdkPixbuf *pixbuf)
-{
+{
CairoPattern * result = g_new0(CairoPattern, 1);
cairo_t *canvas;
cairo_surface_t * surface;
gint width, height;
- #if ((CAIRO_VERSION_MAJOR < 1) || ((CAIRO_VERSION_MAJOR == 1) && (CAIRO_VERSION_MINOR < 2)))
+ #if ((CAIRO_VERSION_MAJOR < 1) || ((CAIRO_VERSION_MAJOR == 1) && (CAIRO_VERSION_MINOR < 2)))
result->type = CAIRO_PATTERN_TYPE_SURFACE;
#endif
gdk_drawable_get_size (GDK_DRAWABLE (pixmap), &width, &height);
pixbuf = gdk_pixbuf_get_from_drawable(NULL, GDK_DRAWABLE (pixmap),
- gdk_drawable_get_colormap(GDK_DRAWABLE (pixmap)),
- 0, 0, 0, 0, width, height);
+ gdk_drawable_get_colormap(GDK_DRAWABLE (pixmap)),
+ 0, 0, 0, 0, width, height);
result = ge_cairo_pixbuf_pattern(pixbuf);
***********************************************/
CairoPattern *
ge_cairo_linear_shade_gradient_pattern(CairoColor *base,
- gdouble shade1,
- gdouble shade2,
- gboolean vertical)
+ gdouble shade1,
+ gdouble shade2,
+ gboolean vertical)
{
CairoPattern * result = g_new0(CairoPattern, 1);
{
if (pattern->handle)
cairo_pattern_destroy(pattern->handle);
-
+
g_free(pattern);
}
}
-/* The following function will be called by GTK+ when the module
+/*
+ * The following function will be called by GTK+ when the module
* is loaded and checks to see if we are compatible with the
* version of GTK+ that loads us.
*/
const gchar*
g_module_check_init (GModule *module)
{
- return gtk_check_version (GTK_MAJOR_VERSION,
- GTK_MINOR_VERSION,
- GTK_MICRO_VERSION - GTK_INTERFACE_AGE);
+ return gtk_check_version (GTK_MAJOR_VERSION,
+ GTK_MINOR_VERSION,
+ GTK_MICRO_VERSION - GTK_INTERFACE_AGE);
}
GE_INTERNAL void ge_cairo_rounded_rectangle (cairo_t *cr, double x, double y, double w, double h, double radius, CairoCorners corners);
GE_INTERNAL void ge_cairo_stroke_rectangle (cairo_t *cr, double x, double y, double w, double h);
+GE_INTERNAL void ge_cairo_inner_rectangle (cairo_t *cr, double x, double y, double width, double height);
+GE_INTERNAL void ge_cairo_inner_rounded_rectangle (cairo_t *cr, double x, double y, double width, double height, double radius, CairoCorners corners);
GE_INTERNAL void ge_cairo_simple_border (cairo_t *cr, const CairoColor * tl, const CairoColor * br, gint x, gint y, gint width, gint height, gboolean topleft_overlap);
GE_INTERNAL void ge_cairo_line (cairo_t *cr, const CairoColor *color, gint x1, gint y1, gint x2, gint y2);
#include <cairo.h>
+/* Normal shadings */
+#define SHADE_TOP 1.055
+#define SHADE_CENTER_TOP 1.01
+#define SHADE_CENTER_BOTTOM 0.98
+#define SHADE_BOTTOM 0.90
+
typedef void (*menubar_draw_proto) (cairo_t *cr,
const ClearlooksColors *colors,
const WidgetParameters *params,
int x, int y, int width, int height);
static void
-clearlooks_draw_inset (cairo_t *cr,
- const CairoColor *bg_color,
- double x, double y, double w, double h,
+clearlooks_draw_inset (cairo_t *cr,
+ const CairoColor *bg_color,
+ double x, double y, double width, double height,
double radius, uint8 corners)
{
CairoColor shadow;
CairoColor highlight;
+ double line_width;
+ double min = MIN (width, height);
+
+ line_width = cairo_get_line_width (cr);
/* not really sure of shading ratios... we will think */
ge_shade_color (bg_color, 0.94, &shadow);
ge_shade_color (bg_color, 1.06, &highlight);
/* highlight */
- cairo_move_to (cr, x + w + (radius * -0.2928932188), y - (radius * -0.2928932188)); /* 0.2928932... 1-sqrt(2)/2 gives middle of curve */
-
- if (corners & CR_CORNER_TOPRIGHT)
- cairo_arc (cr, x + w - radius, y + radius, radius, G_PI * 1.75, G_PI * 2);
- else
- cairo_line_to (cr, x + w, y);
+ cairo_save (cr);
- if (corners & CR_CORNER_BOTTOMRIGHT)
- cairo_arc (cr, x + w - radius, y + h - radius, radius, 0, G_PI * 0.5);
- else
- cairo_line_to (cr, x + w, y + h);
+ cairo_move_to (cr, x, y + height);
+ cairo_line_to (cr, x + min / 2.0, y + height - min / 2.0);
+ cairo_line_to (cr, x + width - min / 2.0, y + min / 2.0);
+ cairo_line_to (cr, x + width, y);
+ cairo_line_to (cr, x, y);
+ cairo_close_path (cr);
+
+ cairo_clip (cr);
- if (corners & CR_CORNER_BOTTOMLEFT)
- cairo_arc (cr, x + radius, y + h - radius, radius, G_PI * 0.5, G_PI * 0.75);
- else
- cairo_line_to (cr, x, y + h);
+ ge_cairo_rounded_rectangle (cr, x + line_width / 2.0, y + line_width / 2.0,
+ width - line_width, height - line_width,
+ radius, corners);
- ge_cairo_set_color (cr, &highlight);
+ ge_cairo_set_color (cr, &shadow);
cairo_stroke (cr);
+
+ cairo_restore (cr);
/* shadow */
- cairo_move_to (cr, x + (radius * 0.2928932188), y + h + (radius * -0.2928932188));
+ cairo_save (cr);
- if (corners & CR_CORNER_BOTTOMLEFT)
- cairo_arc (cr, x + radius, y + h - radius, radius, M_PI * 0.75, M_PI);
- else
- cairo_line_to (cr, x, y + h);
+ cairo_move_to (cr, x, y + height);
+ cairo_line_to (cr, x + min / 2.0, y + height - min / 2.0);
+ cairo_line_to (cr, x + width - min / 2.0, y + min / 2.0);
+ cairo_line_to (cr, x + width, y);
+ cairo_line_to (cr, x + width, y + height);
+ cairo_close_path (cr);
+
+ cairo_clip (cr);
- if (corners & CR_CORNER_TOPLEFT)
- cairo_arc (cr, x + radius, y + radius, radius, M_PI, M_PI * 1.5);
- else
- cairo_line_to (cr, x, y);
+ ge_cairo_rounded_rectangle (cr, x + line_width / 2.0, y + line_width / 2.0,
+ width - line_width, height - line_width,
+ radius, corners);
- if (corners & CR_CORNER_TOPRIGHT)
- cairo_arc (cr, x + w - radius, y + radius, radius, M_PI * 1.5, M_PI * 1.75);
- else
- cairo_line_to (cr, x + w, y);
-
- ge_cairo_set_color (cr, &shadow);
+ ge_cairo_set_color (cr, &highlight);
cairo_stroke (cr);
+
+ cairo_restore (cr);
}
static void
clearlooks_draw_shadow (cairo_t *cr, const ClearlooksColors *colors, gfloat radius, int width, int height)
{
- CairoColor shadow;
+ CairoColor shadow;
+ cairo_save (cr);
+
ge_shade_color (&colors->shade[6], 0.92, &shadow);
cairo_set_line_width (cr, 1.0);
-
+ cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT);
+
cairo_set_source_rgba (cr, shadow.r, shadow.g, shadow.b, 0.1);
-
- cairo_move_to (cr, width, radius);
- ge_cairo_rounded_corner (cr, width, height, radius, CR_CORNER_BOTTOMRIGHT);
- cairo_line_to (cr, radius, height);
+
+ cairo_move_to (cr, width - 0.5, radius);
+ ge_cairo_rounded_corner (cr, width - 0.5, height - 0.5, radius, CR_CORNER_BOTTOMRIGHT);
+ cairo_line_to (cr, radius, height - 0.5);
cairo_stroke (cr);
+ cairo_restore (cr);
}
+/* This is copied at least in clearlooks_draw_gummy.c.
+ * KEEP IN SYNC IF POSSIBLE! */
static void
clearlooks_draw_top_left_highlight (cairo_t *cr, const CairoColor *color,
const WidgetParameters *params,
- int width, int height, gdouble radius)
+ int x, int y, int width, int height,
+ gdouble radius, CairoCorners corners)
{
- CairoColor hilight;
+ CairoColor hilight;
+
+ double line_width = cairo_get_line_width (cr);
+ double offset = line_width / 2.0;
+ double light_top, light_bottom, light_left, light_right;
+
+ cairo_save (cr);
- double light_top = params->ythickness-1,
- light_bottom = height - params->ythickness - 1,
- light_left = params->xthickness-1,
- light_right = width - params->xthickness - 1;
+ cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT);
- ge_shade_color (color, 1.3, &hilight);
- cairo_move_to (cr, light_left, light_bottom - (int)radius/2);
+ light_top = y + offset;
+ light_bottom = y + height;
+ light_left = x + offset;
+ light_right = x + width;
+
+ if (corners & CR_CORNER_BOTTOMLEFT)
+ light_bottom -= radius;
+ if (corners & CR_CORNER_TOPRIGHT)
+ light_right -= radius;
- ge_cairo_rounded_corner (cr, light_left, light_top, radius, params->corners & CR_CORNER_TOPLEFT);
+ ge_shade_color (color, params->style_constants->topleft_highlight_shade, &hilight);
+ cairo_move_to (cr, light_left, light_bottom);
- cairo_line_to (cr, light_right - (int)radius/2, light_top);
- cairo_set_source_rgba (cr, hilight.r, hilight.g, hilight.b, 0.5);
+ ge_cairo_rounded_corner (cr, light_left, light_top, radius, corners & CR_CORNER_TOPLEFT);
+
+ cairo_line_to (cr, light_right, light_top);
+ cairo_set_source_rgba (cr, hilight.r, hilight.g, hilight.b, params->style_constants->topleft_highlight_alpha);
cairo_stroke (cr);
+
+ cairo_restore (cr);
}
#ifdef DEVELOPMENT
double x = 1.0;
double y = 1.0;
- ge_shade_color (&colors->bg[GTK_STATE_NORMAL], 1.06, &hilight);
- ge_shade_color (&colors->bg[GTK_STATE_NORMAL], 0.94, &shadow);
+ ge_shade_color (&colors->bg[0], 1.06, &hilight);
+ ge_shade_color (&colors->bg[0], 0.94, &shadow);
+
+ width -= 2;
+ height -= 2;
- width -= 3;
- height -= 3;
-
cairo_save (cr);
-
+
/* Top/Left highlight */
if (corners & CR_CORNER_BOTTOMLEFT)
- cairo_move_to (cr, x, y+height-radius);
+ cairo_move_to (cr, x + 0.5, y+height-radius);
else
- cairo_move_to (cr, x, y+height);
-
- ge_cairo_rounded_corner (cr, x, y, radius, corners & CR_CORNER_TOPLEFT);
+ cairo_move_to (cr, x + 0.5, y+height);
+
+ ge_cairo_rounded_corner (cr, x + 0.5, y + 0.5, radius, corners & CR_CORNER_TOPLEFT);
if (corners & CR_CORNER_TOPRIGHT)
- cairo_line_to (cr, x+width-radius, y);
+ cairo_line_to (cr, x+width-radius, y + 0.5);
else
- cairo_line_to (cr, x+width, y);
-
+ cairo_line_to (cr, x+width, y + 0.5);
+
if (params->shadow & CL_SHADOW_OUT)
ge_cairo_set_color (cr, &hilight);
else
ge_cairo_set_color (cr, &shadow);
-
+
cairo_stroke (cr);
-
+
/* Bottom/Right highlight -- this includes the corners */
- cairo_move_to (cr, x+width-radius, y); /* topright and by radius to the left */
- ge_cairo_rounded_corner (cr, x+width, y, radius, corners & CR_CORNER_TOPRIGHT);
- ge_cairo_rounded_corner (cr, x+width, y+height, radius, corners & CR_CORNER_BOTTOMRIGHT);
- ge_cairo_rounded_corner (cr, x, y+height, radius, corners & CR_CORNER_BOTTOMLEFT);
-
+ cairo_arc (cr, x + width - 0.5 - radius, y + radius, radius, G_PI * (3/2.0+1/4.0), G_PI * 2);
+ ge_cairo_rounded_corner (cr, x+width - 0.5, y+height - 0.5, radius, corners & CR_CORNER_BOTTOMRIGHT);
+ cairo_arc (cr, x + radius, y + height - 0.5 - radius, radius, G_PI * 1/2, G_PI * 3/4);
+
if (params->shadow & CL_SHADOW_OUT)
ge_cairo_set_color (cr, &shadow);
else
ge_cairo_set_color (cr, &hilight);
-
+
cairo_stroke (cr);
-
+
cairo_restore (cr);
}
pattern = cairo_pattern_create_linear (0, 0, width, height);
cairo_pattern_add_color_stop_rgb (pattern, 0, color->r, color->g, color->b);
cairo_pattern_add_color_stop_rgb (pattern, 1, bottom_shade.r, bottom_shade.g, bottom_shade.b);
-
+
cairo_set_source (cr, pattern);
cairo_pattern_destroy (pattern);
}
CairoColor hilight;
int i, j;
int xoff, yoff;
+ int x_start, y_start;
ge_shade_color (dark, 1.5, &hilight);
-
- for ( i = 0; i < xr; i++ )
+
+ /* The "- 1" is because there is no space in front of the first dot. */
+ x_start = x + width / 2 - ((xr * 3 - 1) / 2);
+ y_start = y + height / 2 - ((yr * 3 - 1) / 2);
+
+ for ( i = 0; i < xr; i++ )
{
for ( j = 0; j < yr; j++ )
{
- xoff = x -(xr * 3 / 2) + 3 * i;
- yoff = y -(yr * 3 / 2) + 3 * j;
-
- cairo_rectangle (cr, width/2+0.5+xoff, height/2+0.5+yoff, 2, 2);
+ xoff = 3 * i;
+ yoff = 3 * j;
+
+ cairo_rectangle (cr, x_start + xoff, y_start + yoff, 2, 2);
cairo_set_source_rgba (cr, hilight.r, hilight.g, hilight.b, 0.8+contrast);
cairo_fill (cr);
- cairo_rectangle (cr, width/2+0.5+xoff, height/2+0.5+yoff, 1, 1);
+ cairo_rectangle (cr, x_start + xoff, y_start + yoff, 1, 1);
cairo_set_source_rgba (cr, dark->r, dark->g, dark->b, 0.8+contrast);
cairo_fill (cr);
}
double xoffset = 0, yoffset = 0;
double radius = params->radius;
const CairoColor *fill = &colors->bg[params->state_type];
- const CairoColor *border_normal = &colors->shade[6];
- const CairoColor *border_disabled = &colors->shade[4];
+ CairoColor border_normal = colors->shade[6];
+ CairoColor border_disabled = colors->shade[4];
CairoColor shadow;
- ge_shade_color (border_normal, 0.925, &shadow);
-
+ ge_shade_color (&border_normal, 1.04, &border_normal);
+ ge_shade_color (&border_normal, 0.94, &shadow);
+ ge_shade_color (&border_disabled, 1.08, &border_disabled);
+
cairo_save (cr);
-
+
cairo_translate (cr, x, y);
cairo_set_line_width (cr, 1.0);
if (params->xthickness == 3 || params->ythickness == 3)
{
- cairo_translate (cr, 0.5, 0.5);
- params->style_functions->draw_inset (cr, ¶ms->parentbg, 0, 0, width-1, height-1, radius+1, params->corners);
- cairo_translate (cr, -0.5, -0.5);
- }
-
+ params->style_functions->draw_inset (cr, ¶ms->parentbg, 0, 0, width, height, radius+1, params->corners);
+ }
+
ge_cairo_rounded_rectangle (cr, xoffset+1, yoffset+1,
width-(xoffset*2)-2,
height-(yoffset*2)-2,
radius, params->corners);
-
+
if (!params->active)
{
cairo_pattern_t *pattern;
- gdouble shade_size = ((100.0/height)*8.0)/100.0;
- CairoColor top_shade, bottom_shade, middle_shade;
-
- ge_shade_color (fill, 1.1, &top_shade);
- ge_shade_color (fill, 0.98, &middle_shade);
- ge_shade_color (fill, 0.93, &bottom_shade);
-
+ CairoColor top_shade, topmiddle_shade, bottom_shade, middle_shade;
+
+ ge_shade_color (fill, SHADE_TOP, &top_shade);
+ ge_shade_color (fill, SHADE_CENTER_TOP, &topmiddle_shade);
+ ge_shade_color (fill, SHADE_CENTER_BOTTOM, &middle_shade);
+ ge_shade_color (fill, SHADE_BOTTOM, &bottom_shade);
+
+ cairo_save (cr);
+ cairo_clip_preserve (cr);
+
pattern = cairo_pattern_create_linear (0, 0, 0, height);
cairo_pattern_add_color_stop_rgb (pattern, 0.0, top_shade.r, top_shade.g, top_shade.b);
- cairo_pattern_add_color_stop_rgb (pattern, shade_size, fill->r, fill->g, fill->b);
- cairo_pattern_add_color_stop_rgb (pattern, 1.0 - shade_size, middle_shade.r, middle_shade.g, middle_shade.b);
- cairo_pattern_add_color_stop_rgb (pattern, (height-(yoffset*2)-1)/height, bottom_shade.r, bottom_shade.g, bottom_shade.b);
- cairo_pattern_add_color_stop_rgba (pattern, (height-(yoffset*2)-1)/height, bottom_shade.r, bottom_shade.g, bottom_shade.b, 0.7);
- cairo_pattern_add_color_stop_rgba (pattern, 1.0, bottom_shade.r, bottom_shade.g, bottom_shade.b, 0.7);
-
+ cairo_pattern_add_color_stop_rgb (pattern, 0.3, topmiddle_shade.r, topmiddle_shade.g, topmiddle_shade.b);
+ cairo_pattern_add_color_stop_rgb (pattern, 0.7, middle_shade.r, middle_shade.g, middle_shade.b);
+ cairo_pattern_add_color_stop_rgb (pattern, 1.0, bottom_shade.r, bottom_shade.g, bottom_shade.b);
cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
+
+ cairo_move_to (cr, width-(xoffset*2)-0.5, 0);
+ cairo_line_to (cr, width-(xoffset*2)-0.5, height);
+ ge_cairo_set_color (cr, &bottom_shade);
+ cairo_stroke (cr);
+
+ /* Draw topleft shadow */
+ params->style_functions->draw_top_left_highlight (cr, fill, params, xoffset + 1, yoffset + 1,
+ width - 2*(xoffset + 1), height - 2*(yoffset + 1),
+ MAX(radius-1, 0), params->corners);
+
+ cairo_restore (cr);
}
else
{
cairo_pattern_t *pattern;
-
+
ge_cairo_set_color (cr, fill);
cairo_fill_preserve (cr);
cairo_pattern_destroy (pattern);
pattern = cairo_pattern_create_linear (0, yoffset+1, 0, 3+yoffset);
- cairo_pattern_add_color_stop_rgba (pattern, 0.0, shadow.r, shadow.g, shadow.b, params->disabled ? 0.125 : 0.3);
+ cairo_pattern_add_color_stop_rgba (pattern, 0.0, shadow.r, shadow.g, shadow.b, params->disabled ? 0.125 : 0.32);
cairo_pattern_add_color_stop_rgba (pattern, 1.0, shadow.r, shadow.g, shadow.b, 0.0);
cairo_set_source (cr, pattern);
cairo_fill_preserve (cr);
cairo_pattern_destroy (pattern);
pattern = cairo_pattern_create_linear (xoffset+1, 0, 3+xoffset, 0);
- cairo_pattern_add_color_stop_rgba (pattern, 0.0, shadow.r, shadow.g, shadow.b, params->disabled ? 0.125 : 0.3);
+ cairo_pattern_add_color_stop_rgba (pattern, 0.0, shadow.r, shadow.g, shadow.b, params->disabled ? 0.125 : 0.32);
cairo_pattern_add_color_stop_rgba (pattern, 1.0, shadow.r, shadow.g, shadow.b, 0.0);
cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
}
-
/* Drawing the border */
if (!params->active && params->is_default)
{
- const CairoColor *l = &colors->shade[4];
- const CairoColor *d = &colors->shade[4];
- ge_cairo_set_color (cr, l);
- ge_cairo_stroke_rectangle (cr, 2.5, 2.5, width-5, height-5);
-
- ge_cairo_set_color (cr, d);
- ge_cairo_stroke_rectangle (cr, 3.5, 3.5, width-7, height-7);
+ ge_shade_color (&border_normal, 0.74, &border_normal);
}
-
- ge_cairo_rounded_rectangle (cr, xoffset + 0.5, yoffset + 0.5, width-(xoffset*2)-1, height-(yoffset*2)-1, radius, params->corners);
+
+ ge_cairo_inner_rounded_rectangle (cr, xoffset, yoffset, width-(xoffset*2), height-(yoffset*2), radius, params->corners);
if (params->disabled)
- ge_cairo_set_color (cr, border_disabled);
+ {
+ ge_cairo_set_color (cr, &border_disabled);
+ }
else
+ {
if (!params->active)
- clearlooks_set_border_gradient (cr, border_normal, 1.32, 0, height);
+ clearlooks_set_border_gradient (cr, &border_normal,
+ params->is_default ? 1.1 : 1.3, 0, height);
else
- ge_cairo_set_color (cr, border_normal);
-
- cairo_stroke (cr);
-
- /* Draw the "shadow" */
- if (!params->active)
- {
- cairo_translate (cr, 0.5, 0.5);
- /* Draw right shadow */
- cairo_move_to (cr, width-params->xthickness, params->ythickness - 1);
- cairo_line_to (cr, width-params->xthickness, height - params->ythickness - 1);
- cairo_set_source_rgba (cr, shadow.r, shadow.g, shadow.b, 0.1);
- cairo_stroke (cr);
-
- /* Draw topleft shadow */
- clearlooks_draw_top_left_highlight (cr, fill, params, width, height, radius);
+ {
+ ge_shade_color (&border_normal, 1.08, &border_normal);
+ ge_cairo_set_color (cr, &border_normal);
+ }
}
+
+ cairo_stroke (cr);
+
cairo_restore (cr);
}
int x, int y, int width, int height)
{
const CairoColor *base = &colors->base[params->state_type];
- CairoColor border = colors->shade[params->disabled ? 4 : 6];
+ CairoColor border = colors->shade[params->disabled ? 3 : 6];
double radius = MIN (params->radius, MIN ((width - 4.0) / 2.0, (height - 4.0) / 2.0));
-
+
if (params->focus)
border = colors->spot[2];
- cairo_translate (cr, x+0.5, y+0.5);
+ cairo_save (cr);
+
+ cairo_translate (cr, x, y);
cairo_set_line_width (cr, 1.0);
-
- /* Fill the background (shouldn't have to) */
- cairo_rectangle (cr, -0.5, -0.5, width, height);
- ge_cairo_set_color (cr, ¶ms->parentbg);
- cairo_fill (cr);
- /* Fill the entry's base color (why isn't is large enough by default?) */
- cairo_rectangle (cr, 1.5, 1.5, width-4, height-4);
+ /* Now fill the area we want to be base[NORMAL]. */
+ ge_cairo_rounded_rectangle (cr, 2, 2, width-4, height-4, MAX(0, radius-1), params->corners);
ge_cairo_set_color (cr, base);
cairo_fill (cr);
-
- params->style_functions->draw_inset (cr, ¶ms->parentbg, 0, 0, width-1, height-1, radius+1, params->corners);
+
+ params->style_functions->draw_inset (cr, ¶ms->parentbg, 0, 0, width, height, radius+1, params->corners);
/* Draw the inner shadow */
if (params->focus)
{
- /* ge_cairo_rounded_rectangle (cr, 2, 2, width-5, height-5, RADIUS-1, params->corners); */
ge_cairo_set_color (cr, &colors->spot[0]);
- ge_cairo_stroke_rectangle (cr, 2, 2, width-5, height-5);
+ ge_cairo_inner_rounded_rectangle (cr, 2, 2, width-4, height-4, MAX(0, radius-1), params->corners);
+ cairo_stroke (cr);
}
else
{
- CairoColor shadow;
+ CairoColor shadow;
ge_shade_color (&border, 0.925, &shadow);
cairo_set_source_rgba (cr, shadow.r, shadow.g, shadow.b, params->disabled ? 0.05 : 0.1);
- /*
- cairo_move_to (cr, 2, height-3);
- cairo_arc (cr, params->xthickness+RADIUS-1, params->ythickness+RADIUS-1, RADIUS, G_PI, 270*(G_PI/180));
- cairo_line_to (cr, width-3, 2);*/
- cairo_move_to (cr, 2, height-3);
- cairo_line_to (cr, 2, 2);
- cairo_line_to (cr, width-3, 2);
+
+ cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT);
+ cairo_move_to (cr, 2.5, height-radius);
+ cairo_arc (cr, 2.5+MAX(0, radius-1), 2.5+MAX(0, radius-1), MAX(0, radius-1), G_PI, 270*(G_PI/180));
+ cairo_line_to (cr, width-radius, 2.5);
cairo_stroke (cr);
}
- ge_cairo_rounded_rectangle (cr, 1, 1, width-3, height-3, radius, params->corners);
+ ge_cairo_inner_rounded_rectangle (cr, 1, 1, width-2, height-2, radius, params->corners);
if (params->focus || params->disabled)
ge_cairo_set_color (cr, &border);
else
- clearlooks_set_border_gradient (cr, &border, 1.32, 0, height);
+ clearlooks_set_border_gradient (cr, &border, 1.32, 0, height);
cairo_stroke (cr);
+
+ cairo_restore (cr);
}
static void
int x, int y, int width, int height)
{
const CairoColor *border = &colors->shade[!params->disabled ? 5 : 3];
- CairoColor hilight;
+ CairoColor hilight;
params->style_functions->draw_button (cr, colors, params, x, y, width, height);
- ge_shade_color (border, 1.5, &hilight);
+ ge_shade_color (&colors->bg[0], params->style_constants->topleft_highlight_shade, &hilight);
+ hilight.a = params->style_constants->topleft_highlight_alpha;
cairo_translate (cr, x, y);
{
cairo_pattern_t *pattern;
double radius = MIN (params->radius, MIN ((width - 4.0) / 2.0, (height - 4.0) / 2.0));
- CairoColor shadow;
- ge_shade_color (&colors->bg[GTK_STATE_NORMAL], 0.8, &shadow);
+ CairoColor shadow;
+ ge_shade_color (&colors->bg[0], 0.8, &shadow);
cairo_translate (cr, x+1, y+1);
-
+
ge_cairo_rounded_rectangle (cr, 1, 1, width-4, height-4, radius, params->corners);
-
+
ge_cairo_set_color (cr, &colors->bg[params->state_type]);
-
+
cairo_fill_preserve (cr);
-
+
pattern = cairo_pattern_create_linear (0, 0, 0, height);
cairo_pattern_add_color_stop_rgb (pattern, 0.0, shadow.r, shadow.g, shadow.b);
cairo_pattern_add_color_stop_rgba (pattern, 1.0, shadow.r, shadow.g, shadow.b, 0.0);
-
+
cairo_set_source (cr, pattern);
cairo_fill (cr);
-
+
cairo_pattern_destroy (pattern);
}
{
cairo_pattern_t *pattern;
- pattern = cairo_pattern_create_linear (0, 0, horizontal ? 0 : width, horizontal ? height : 0);
+ pattern = cairo_pattern_create_linear (0.5, 0.5, horizontal ? 0.5 : width + 1, horizontal ? height + 1: 0.5);
cairo_pattern_add_color_stop_rgb (pattern, 0.0, c1->r, c1->g, c1->b);
cairo_pattern_add_color_stop_rgb (pattern, 1.0, c2->r, c2->g, c2->b);
- cairo_rectangle (cr, x+0.5, y+0.5, width-1, height-1);
+ cairo_rectangle (cr, x, y, width, height);
cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
-
+
ge_cairo_set_color (cr, c3);
- ge_cairo_stroke_rectangle (cr, x, y, width, height);
+ ge_cairo_inner_rectangle (cr, x, y, width, height);
+ cairo_stroke (cr);
}
-#define TROUGH_SIZE 6
+#define TROUGH_SIZE 7
static void
clearlooks_draw_scale_trough (cairo_t *cr,
const ClearlooksColors *colors,
int trough_width, trough_height;
double translate_x, translate_y;
+ cairo_save (cr);
+
if (slider->horizontal)
{
- trough_width = width-3;
- trough_height = TROUGH_SIZE-2;
+ trough_width = width;
+ trough_height = TROUGH_SIZE;
- translate_x = x + 0.5;
- translate_y = y + 0.5 + (height/2) - (TROUGH_SIZE/2);
+ translate_x = x;
+ translate_y = y + (height/2) - (TROUGH_SIZE/2);
}
else
{
- trough_width = TROUGH_SIZE-2;
- trough_height = height-3;
+ trough_width = TROUGH_SIZE;
+ trough_height = height;
- translate_x = x + 0.5 + (width/2) - (TROUGH_SIZE/2);
- translate_y = y + 0.5;
+ translate_x = x + (width/2) - (TROUGH_SIZE/2);
+ translate_y = y;
}
cairo_set_line_width (cr, 1.0);
cairo_translate (cr, translate_x, translate_y);
-
+
if (!slider->fill_level)
- params->style_functions->draw_inset (cr, ¶ms->parentbg, 0, 0, trough_width+2, trough_height+2, 0, 0);
+ params->style_functions->draw_inset (cr, ¶ms->parentbg, 0, 0, trough_width, trough_height, 0, 0);
- cairo_translate (cr, 1, 1);
-
- if (!slider->lower && ! slider->fill_level)
- clearlooks_scale_draw_gradient (cr, &colors->shade[3], /* top */
- &colors->shade[2], /* bottom */
- &colors->shade[6], /* border */
- 0, 0, trough_width, trough_height,
- slider->horizontal);
+ if (!slider->lower && !slider->fill_level)
+ {
+ CairoColor shadow;
+ ge_shade_color (&colors->shade[2], 0.96, &shadow);
+
+ clearlooks_scale_draw_gradient (cr, &shadow, /* top */
+ &colors->shade[2], /* bottom */
+ &colors->shade[4], /* border */
+ 1.0, 1.0, trough_width - 2, trough_height - 2,
+ slider->horizontal);
+ }
else
- clearlooks_scale_draw_gradient (cr, &colors->spot[1], /* top */
- &colors->spot[0], /* bottom */
- &colors->spot[2], /* border */
- 0, 0, trough_width, trough_height,
- slider->horizontal);
+ {
+ CairoColor border = colors->spot[2];
+ border.a = 0.64;
+
+ clearlooks_scale_draw_gradient (cr, &colors->spot[1], /* top */
+ &colors->spot[0], /* bottom */
+ &border, /* border */
+ 1.0, 1.0, trough_width - 2, trough_height - 2,
+ slider->horizontal);
+ }
+ cairo_restore (cr);
}
static void
const WidgetParameters *params,
int x, int y, int width, int height)
{
- const CairoColor *border = &colors->shade[params->disabled ? 4 : 6];
const CairoColor *spot = &colors->spot[1];
const CairoColor *fill = &colors->shade[2];
+ CairoColor border = colors->shade[params->disabled ? 4 : 6];
double radius = MIN (params->radius, MIN ((width - 1.0) / 2.0, (height - 1.0) / 2.0));
cairo_pattern_t *pattern;
- cairo_set_line_width (cr, 1.0);
+ cairo_set_line_width (cr, 1.0);
cairo_translate (cr, x, y);
if (params->prelight)
- border = &colors->spot[2];
+ border = colors->spot[2];
/* fill the widget */
- cairo_rectangle (cr, 0.5, 0.5, width-2, height-2);
+ ge_cairo_rounded_rectangle (cr, 1.0, 1.0, width-2, height-2, radius, params->corners);
/* Fake light */
if (!params->disabled)
else
{
ge_cairo_set_color (cr, fill);
- cairo_rectangle (cr, 0.5, 0.5, width-2, height-2);
cairo_fill (cr);
}
/* Set the clip */
cairo_save (cr);
- cairo_rectangle (cr, 0.5, 0.5, 6, height-2);
- cairo_rectangle (cr, width-7.5, 0.5, 6 , height-2);
+ cairo_rectangle (cr, 1.0, 1.0, 6, height-2);
+ cairo_rectangle (cr, width-7.0, 1.0, 6, height-2);
cairo_clip_preserve (cr);
cairo_new_path (cr);
/* Draw the handles */
- ge_cairo_rounded_rectangle (cr, 0.5, 0.5, width-1, height-1, radius, params->corners);
- pattern = cairo_pattern_create_linear (0.5, 0.5, 0.5, 0.5+height);
+ ge_cairo_rounded_rectangle (cr, 1.0, 1.0, width-1, height-1, radius, params->corners);
+ pattern = cairo_pattern_create_linear (1.0, 1.0, 1.0, 1.0+height);
if (params->prelight)
{
CairoColor highlight;
- ge_shade_color (spot, 1.5, &highlight);
+ ge_shade_color (spot, 1.3, &highlight);
cairo_pattern_add_color_stop_rgb (pattern, 0.0, highlight.r, highlight.g, highlight.b);
cairo_pattern_add_color_stop_rgb (pattern, 1.0, spot->r, spot->g, spot->b);
cairo_set_source (cr, pattern);
}
- else
+ else
{
- CairoColor hilight;
- ge_shade_color (fill, 1.5, &hilight);
+ CairoColor hilight;
+ ge_shade_color (fill, 1.3, &hilight);
cairo_set_source_rgba (cr, hilight.r, hilight.g, hilight.b, 0.5);
}
cairo_restore (cr);
/* Draw the border */
- ge_cairo_rounded_rectangle (cr, 0, 0, width-1, height-1, radius, params->corners);
+ ge_cairo_inner_rounded_rectangle (cr, 0, 0, width, height, radius, params->corners);
if (params->prelight || params->disabled)
- ge_cairo_set_color (cr, border);
+ ge_cairo_set_color (cr, &border);
else
- clearlooks_set_border_gradient (cr, border, 1.2, 0, height);
+ clearlooks_set_border_gradient (cr, &border, 1.2, 0, height);
cairo_stroke (cr);
/* Draw handle lines */
if (width > 14)
{
- cairo_move_to (cr, 6, 0.5);
- cairo_line_to (cr, 6, height-1);
-
- cairo_move_to (cr, width-7, 0.5);
- cairo_line_to (cr, width-7, height-1);
-
+ cairo_move_to (cr, 6.5, 1.0);
+ cairo_line_to (cr, 6.5, height-1);
+
+ cairo_move_to (cr, width-6.5, 1.0);
+ cairo_line_to (cr, width-6.5, height-1);
+
cairo_set_line_width (cr, 1.0);
- cairo_set_source_rgba (cr, border->r,
- border->g,
- border->b,
- 0.3);
+ border.a = params->disabled ? 0.6 : 0.3;
+ ge_cairo_set_color (cr, &border);
cairo_stroke (cr);
}
}
const SliderParameters *slider,
int x, int y, int width, int height)
{
- double radius = MIN (params->radius, MIN ((width - 2.0) / 2.0, (height - 2.0) / 2.0));
+ double radius = MIN (params->radius, MIN ((width - 1.0) / 2.0, (height - 1.0) / 2.0));
+
+ cairo_save (cr);
cairo_set_line_width (cr, 1.0);
-
+
if (!slider->horizontal)
ge_cairo_exchange_axis (cr, &x, &y, &width, &height);
- cairo_translate (cr, x+0.5, y+0.5);
+ cairo_translate (cr, x, y);
- params->style_functions->draw_shadow (cr, colors, radius, width-1, height-1);
+ params->style_functions->draw_shadow (cr, colors, radius, width, height);
params->style_functions->draw_slider (cr, colors, params, 1, 1, width-2, height-2);
if (width > 24)
- params->style_functions->draw_gripdots (cr, colors, 0, 0, width-2, height-2, 3, 3, 0);
+ params->style_functions->draw_gripdots (cr, colors, 1, 1, width-2, height-2, 3, 3, 0);
+
+ cairo_restore (cr);
}
static void
const WidgetParameters *params,
int x, int y, int width, int height)
{
- const CairoColor *border = &colors->shade[6];
- CairoColor shadow;
- cairo_pattern_t *pattern;
- double radius = MIN (params->radius, MIN ((height-2.0) / 2.0, (width-2.0) / 2.0));
-
+ const CairoColor *border = &colors->shade[4];
+ CairoColor shadow;
+ cairo_pattern_t *pattern;
+ double radius = MIN (params->radius, MIN ((height-2.0) / 2.0, (width-2.0) / 2.0));
+
cairo_save (cr);
cairo_set_line_width (cr, 1.0);
-
- /* Fill with bg color */
- ge_cairo_set_color (cr, &colors->bg[params->state_type]);
-
- cairo_rectangle (cr, x, y, width, height);
- cairo_fill (cr);
/* Create trough box */
ge_cairo_rounded_rectangle (cr, x+1, y+1, width-2, height-2, radius, params->corners);
- ge_cairo_set_color (cr, &colors->shade[3]);
+ ge_cairo_set_color (cr, &colors->shade[2]);
cairo_fill (cr);
/* Draw border */
/* Top shadow */
cairo_rectangle (cr, x+1, y+1, width-2, 4);
pattern = cairo_pattern_create_linear (x, y, x, y+4);
- cairo_pattern_add_color_stop_rgba (pattern, 0.0, shadow.r, shadow.g, shadow.b, 0.3);
- cairo_pattern_add_color_stop_rgba (pattern, 1.0, shadow.r, shadow.g, shadow.b, 0.);
+ cairo_pattern_add_color_stop_rgba (pattern, 0.0, shadow.r, shadow.g, shadow.b, 0.2);
+ cairo_pattern_add_color_stop_rgba (pattern, 1.0, shadow.r, shadow.g, shadow.b, 0);
cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
/* Left shadow */
cairo_rectangle (cr, x+1, y+1, 4, height-2);
pattern = cairo_pattern_create_linear (x, y, x+4, y);
- cairo_pattern_add_color_stop_rgba (pattern, 0.0, shadow.r, shadow.g, shadow.b, 0.3);
- cairo_pattern_add_color_stop_rgba (pattern, 1.0, shadow.r, shadow.g, shadow.b, 0.);
+ cairo_pattern_add_color_stop_rgba (pattern, 0.0, shadow.r, shadow.g, shadow.b, 0.2);
+ cairo_pattern_add_color_stop_rgba (pattern, 1.0, shadow.r, shadow.g, shadow.b, 0);
cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
/* Clamp the radius so that the _height_ fits ... */
radius = MIN (radius, height / 2.0);
- stroke_width = height*2;
+ stroke_width = height;
x_step = (((float)stroke_width/10)*offset); /* This looks weird ... */
-
+
cairo_translate (cr, x, y);
cairo_save (cr);
/* Draw the background gradient */
ge_shade_color (&colors->spot[1], 1.1, &bg_shade);
- pattern = cairo_pattern_create_linear (0, 0, 0, height);
- cairo_pattern_add_color_stop_rgb (pattern, 0.0, bg_shade.r, bg_shade.g, bg_shade.b);
- cairo_pattern_add_color_stop_rgb (pattern, 0.6, colors->spot[1].r, colors->spot[1].g, colors->spot[1].b);
- cairo_pattern_add_color_stop_rgb (pattern, 1.0, bg_shade.r, bg_shade.g, bg_shade.b);
- cairo_set_source (cr, pattern);
+
+ /* Just leave this disabled, maybe we could use the same gradient
+ * as the buttons in the future, not flat fill */
+/* pattern = cairo_pattern_create_linear (0, 0, 0, height);*/
+/* cairo_pattern_add_color_stop_rgb (pattern, 0.0, bg_shade.r, bg_shade.g, bg_shade.b);*/
+/* cairo_pattern_add_color_stop_rgb (pattern, 0.6, colors->spot[1].r, colors->spot[1].g, colors->spot[1].b);*/
+/* cairo_pattern_add_color_stop_rgb (pattern, 1.0, bg_shade.r, bg_shade.g, bg_shade.b);*/
+/* cairo_set_source (cr, pattern);*/
+/* cairo_paint (cr);*/
+/* cairo_pattern_destroy (pattern);*/
+
+ ge_cairo_set_color (cr, &bg_shade);
cairo_paint (cr);
- cairo_pattern_destroy (pattern);
/* Draw the Strokes */
while (tile_pos <= width+x_step)
cairo_line_to (cr, stroke_width-x_step, 0);
cairo_line_to (cr, stroke_width/2-x_step, height);
cairo_line_to (cr, -x_step, height);
-
+
cairo_translate (cr, stroke_width, 0);
tile_pos += stroke_width;
}
-
- cairo_set_source_rgba (cr, colors->spot[2].r,
- colors->spot[2].g,
- colors->spot[2].b,
- 0.15);
-
- cairo_fill (cr);
- cairo_restore (cr); /* rounded clip region */
-
- /* inner highlight border
- * This is again kinda ugly. Draw once from each side, clipping away the other. */
- cairo_set_source_rgba (cr, colors->spot[0].r, colors->spot[0].g, colors->spot[0].b, 0.5);
- /* left side */
- cairo_save (cr);
- cairo_rectangle (cr, 0, 0, width / 2, height);
- cairo_clip (cr);
-
- if (progressbar->pulsing)
- ge_cairo_rounded_rectangle (cr, 1.5, 0.5, width + radius, height - 1, radius, CR_CORNER_TOPLEFT | CR_CORNER_BOTTOMLEFT);
- else
- ge_cairo_rounded_rectangle (cr, 0.5, 0.5, width + radius, height - 1, radius, CR_CORNER_TOPLEFT | CR_CORNER_BOTTOMLEFT);
-
- cairo_stroke (cr);
- cairo_restore (cr); /* clip */
-
- /* right side */
- cairo_save (cr);
- cairo_rectangle (cr, width / 2, 0, (width+1) / 2, height);
- cairo_clip (cr);
-
- if (progressbar->value < 1.0 || progressbar->pulsing)
- ge_cairo_rounded_rectangle (cr, -1.5 - radius, 0.5, width + radius, height - 1, radius, CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMRIGHT);
- else
- ge_cairo_rounded_rectangle (cr, -0.5 - radius, 0.5, width + radius, height - 1, radius, CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMRIGHT);
-
- cairo_stroke (cr);
- cairo_restore (cr); /* clip */
+ pattern = cairo_pattern_create_linear (0, 0, 0, height);
+ cairo_pattern_add_color_stop_rgba (pattern, 0.0, colors->spot[2].r, colors->spot[2].g, colors->spot[2].b, 0);
+ cairo_pattern_add_color_stop_rgba (pattern, 1.0, colors->spot[2].r, colors->spot[2].g, colors->spot[2].b, 0.24);
+ cairo_set_source (cr, pattern);
+ cairo_fill (cr);
+ cairo_pattern_destroy (pattern);
+ cairo_restore (cr); /* rounded clip region */
/* Draw the dark lines and the shadow */
cairo_save (cr);
ge_cairo_rounded_rectangle (cr, -radius - 1.0, 0, width + radius + 2.0, height, radius, CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMRIGHT);
cairo_clip (cr);
- border = colors->spot[2];
- border.a = 0.5;
shadow.r = 0.0;
shadow.g = 0.0;
shadow.b = 0.0;
if (progressbar->pulsing)
{
/* At the beginning of the bar. */
- cairo_move_to (cr, 0.5 + radius, height + 0.5);
- ge_cairo_rounded_corner (cr, 0.5, height + 0.5, radius + 1, CR_CORNER_BOTTOMLEFT);
- ge_cairo_rounded_corner (cr, 0.5, -0.5, radius + 1, CR_CORNER_TOPLEFT);
- ge_cairo_set_color (cr, &border);
- cairo_stroke (cr);
-
cairo_move_to (cr, -0.5 + radius, height + 0.5);
ge_cairo_rounded_corner (cr, -0.5, height + 0.5, radius + 1, CR_CORNER_BOTTOMLEFT);
ge_cairo_rounded_corner (cr, -0.5, -0.5, radius + 1, CR_CORNER_TOPLEFT);
if (progressbar->value < 1.0 || progressbar->pulsing)
{
/* At the end of the bar. */
- cairo_move_to (cr, width - 0.5 - radius, -0.5);
- ge_cairo_rounded_corner (cr, width - 0.5, -0.5, radius + 1, CR_CORNER_TOPRIGHT);
- ge_cairo_rounded_corner (cr, width - 0.5, height + 0.5, radius + 1, CR_CORNER_BOTTOMRIGHT);
- ge_cairo_set_color (cr, &border);
- cairo_stroke (cr);
-
cairo_move_to (cr, width + 0.5 - radius, -0.5);
ge_cairo_rounded_corner (cr, width + 0.5, -0.5, radius + 1, CR_CORNER_TOPRIGHT);
ge_cairo_rounded_corner (cr, width + 0.5, height + 0.5, radius + 1, CR_CORNER_BOTTOMRIGHT);
ge_cairo_set_color (cr, &shadow);
cairo_stroke (cr);
}
-
+
+/* ge_cairo_rounded_rectangle (cr, 1.5,1.5, width-2, height-2, radius, CR_CORNER_ALL);*/
+/* cairo_set_source_rgba (cr, colors->spot[0].r, colors->spot[0].g, colors->spot[0].b, 1);*/
+/* cairo_stroke (cr);*/
+
+ params->style_functions->draw_top_left_highlight (cr, &colors->spot[1], params, 1.5, 1.5,
+ width - 1, height - 1,
+ radius, params->corners);
+
+ border = colors->spot[2];
+ border.a = 0.6;
+ ge_cairo_rounded_rectangle (cr, 0.5, 0.5, width-1, height-1, radius, CR_CORNER_ALL);
+ ge_cairo_set_color (cr, &border);
+ cairo_stroke (cr);
+
cairo_restore (cr);
cairo_restore (cr); /* rotation, mirroring */
int x, int y, int width, int height)
{
SeparatorParameters separator;
- int offset = params->ythickness + 1;
-
+ int offset = params->ythickness + 2;
+
params->style_functions->draw_button (cr, colors, params, x, y, width, height);
-
+
separator.horizontal = FALSE;
params->style_functions->draw_separator (cr, colors, params, &separator, x+optionmenu->linepos, y + offset, 2, height - offset*2);
}
const MenuBarParameters *menubar,
int x, int y, int width, int height)
{
-/* const CairoColor *light = &colors->shade[0]; */
const CairoColor *dark = &colors->shade[3];
- cairo_set_line_width (cr, 1);
- cairo_translate (cr, x, y+0.5);
+ cairo_save (cr);
-/* cairo_move_to (cr, 0, 0); */
-/* cairo_line_to (cr, width, 0); */
-/* ge_cairo_set_color (cr, light); */
-/* cairo_stroke (cr); */
+ cairo_set_line_width (cr, 1);
+ cairo_translate (cr, x, y);
- cairo_move_to (cr, 0, height-1);
- cairo_line_to (cr, width, height-1);
+ cairo_move_to (cr, 0, height-0.5);
+ cairo_line_to (cr, width, height-0.5);
ge_cairo_set_color (cr, dark);
cairo_stroke (cr);
+
+ cairo_restore (cr);
}
static void
CairoColor lower;
cairo_pattern_t *pattern;
+ cairo_save (cr);
+
ge_shade_color (&colors->bg[0], 0.96, &lower);
-
+
cairo_translate (cr, x, y);
cairo_rectangle (cr, 0, 0, width, height);
-
+
/* Draw the gradient */
pattern = cairo_pattern_create_linear (0, 0, 0, height);
cairo_pattern_add_color_stop_rgb (pattern, 0.0, colors->bg[0].r,
cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
-
+
/* Draw bottom line */
cairo_set_line_width (cr, 1.0);
cairo_move_to (cr, 0, height-0.5);
cairo_line_to (cr, width, height-0.5);
ge_cairo_set_color (cr, &colors->shade[3]);
cairo_stroke (cr);
+
+ cairo_restore (cr);
}
static void
static menubar_draw_proto clearlooks_menubar_draw[3] =
-{
- clearlooks_draw_menubar0,
+{
+ clearlooks_draw_menubar0,
clearlooks_draw_menubar1,
- clearlooks_draw_menubar2
+ clearlooks_draw_menubar2
};
static void
const MenuBarParameters *menubar,
int x, int y, int width, int height)
{
- if (menubar->style < 0 || menubar->style > 3)
+ if (menubar->style < 0 || menubar->style >= G_N_ELEMENTS (clearlooks_menubar_draw))
return;
clearlooks_menubar_draw[menubar->style](cr, colors, params, menubar,
}
static void
-clearlooks_get_frame_gap_clip (int x, int y, int width, int height,
+clearlooks_get_frame_gap_clip (int x, int y, int width, int height,
const FrameParameters *frame,
ClearlooksRectangle *bevel,
ClearlooksRectangle *border)
{
if (frame->gap_side == CL_GAP_TOP)
{
- CLEARLOOKS_RECTANGLE_SET ((*bevel), 1.5 + frame->gap_x, -0.5,
- frame->gap_width - 3, 2.0);
- CLEARLOOKS_RECTANGLE_SET ((*border), 0.5 + frame->gap_x, -0.5,
- frame->gap_width - 2, 2.0);
+ CLEARLOOKS_RECTANGLE_SET (*bevel, 2.0 + frame->gap_x, 0.0,
+ frame->gap_width - 3, 2.0);
+ CLEARLOOKS_RECTANGLE_SET (*border, 1.0 + frame->gap_x, 0.0,
+ frame->gap_width - 2, 2.0);
}
else if (frame->gap_side == CL_GAP_BOTTOM)
{
- CLEARLOOKS_RECTANGLE_SET ((*bevel), 1.5 + frame->gap_x, height - 2.5,
- frame->gap_width - 3, 2.0);
- CLEARLOOKS_RECTANGLE_SET ((*border), 0.5 + frame->gap_x, height - 1.5,
- frame->gap_width - 2, 2.0);
+ CLEARLOOKS_RECTANGLE_SET (*bevel, 2.0 + frame->gap_x, height - 2.0,
+ frame->gap_width - 3, 2.0);
+ CLEARLOOKS_RECTANGLE_SET (*border, 1.0 + frame->gap_x, height - 1.0,
+ frame->gap_width - 2, 2.0);
}
else if (frame->gap_side == CL_GAP_LEFT)
{
- CLEARLOOKS_RECTANGLE_SET ((*bevel), -0.5, 1.5 + frame->gap_x,
- 2.0, frame->gap_width - 3);
- CLEARLOOKS_RECTANGLE_SET ((*border), -0.5, 0.5 + frame->gap_x,
- 1.0, frame->gap_width - 2);
+ CLEARLOOKS_RECTANGLE_SET (*bevel, 0.0, 2.0 + frame->gap_x,
+ 2.0, frame->gap_width - 3);
+ CLEARLOOKS_RECTANGLE_SET (*border, 0.0, 1.0 + frame->gap_x,
+ 1.0, frame->gap_width - 2);
}
else if (frame->gap_side == CL_GAP_RIGHT)
{
- CLEARLOOKS_RECTANGLE_SET ((*bevel), width - 2.5, 1.5 + frame->gap_x,
- 2.0, frame->gap_width - 3);
- CLEARLOOKS_RECTANGLE_SET ((*border), width - 1.5, 0.5 + frame->gap_x,
- 1.0, frame->gap_width - 2);
+ CLEARLOOKS_RECTANGLE_SET (*bevel, width - 2.0, 2.0 + frame->gap_x,
+ 2.0, frame->gap_width - 3);
+ CLEARLOOKS_RECTANGLE_SET (*border, width - 1.0, 1.0 + frame->gap_x,
+ 1.0, frame->gap_width - 2);
}
}
double radius = MIN (params->radius, MIN ((width - 2.0) / 2.0, (height - 2.0) / 2.0));
CairoColor hilight;
- ge_shade_color (&colors->bg[GTK_STATE_NORMAL], 1.05, &hilight);
-
+ ge_shade_color (&colors->bg[0], 1.05, &hilight);
+
if (frame->shadow == CL_SHADOW_NONE)
return;
-
+
if (frame->gap_x != -1)
clearlooks_get_frame_gap_clip (x, y, width, height,
frame, &bevel_clip, &frame_clip);
-
+
cairo_set_line_width (cr, 1.0);
- cairo_translate (cr, x+0.5, y+0.5);
-
+ cairo_translate (cr, x, y);
+
/* save everything */
cairo_save (cr);
/* Set clip for the bevel */
{
/* Set clip for gap */
cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
- cairo_rectangle (cr, -0.5, -0.5, width, height);
+ cairo_rectangle (cr, 0, 0, width, height);
cairo_rectangle (cr, bevel_clip.x, bevel_clip.y, bevel_clip.width, bevel_clip.height);
cairo_clip (cr);
}
-
+
/* Draw the bevel */
if (frame->shadow == CL_SHADOW_ETCHED_IN || frame->shadow == CL_SHADOW_ETCHED_OUT)
{
ge_cairo_set_color (cr, &hilight);
if (frame->shadow == CL_SHADOW_ETCHED_IN)
- ge_cairo_rounded_rectangle (cr, 1, 1, width-2, height-2, radius, params->corners);
+ ge_cairo_inner_rounded_rectangle (cr, 1, 1, width-1, height-1, radius, params->corners);
else
- ge_cairo_rounded_rectangle (cr, 0, 0, width-2, height-2, radius, params->corners);
+ ge_cairo_inner_rounded_rectangle (cr, 0, 0, width-1, height-1, radius, params->corners);
cairo_stroke (cr);
}
else if (frame->shadow != CL_SHADOW_NONE)
ShadowParameters shadow;
shadow.corners = params->corners;
shadow.shadow = frame->shadow;
- clearlooks_draw_highlight_and_shade (cr, colors, &shadow, width, height, 0);
+ clearlooks_draw_highlight_and_shade (cr, colors, &shadow, width, height, radius);
}
-
+
/* restore the previous clip region */
cairo_restore (cr);
cairo_save (cr);
{
/* Set clip for gap */
cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
- cairo_rectangle (cr, -0.5, -0.5, width, height);
+ cairo_rectangle (cr, 0, 0, width, height);
cairo_rectangle (cr, frame_clip.x, frame_clip.y, frame_clip.width, frame_clip.height);
cairo_clip (cr);
}
{
ge_cairo_set_color (cr, dark);
if (frame->shadow == CL_SHADOW_ETCHED_IN)
- ge_cairo_rounded_rectangle (cr, 0, 0, width-2, height-2, radius, params->corners);
+ ge_cairo_inner_rounded_rectangle (cr, 0, 0, width-1, height-1, radius, params->corners);
else
- ge_cairo_rounded_rectangle (cr, 1, 1, width-2, height-2, radius, params->corners);
+ ge_cairo_inner_rounded_rectangle (cr, 1, 1, width-1, height-1, radius, params->corners);
}
else
{
ge_cairo_set_color (cr, border);
- ge_cairo_rounded_rectangle (cr, 0, 0, width-1, height-1, radius, params->corners);
+ ge_cairo_inner_rounded_rectangle (cr, 0, 0, width, height, radius, params->corners);
}
cairo_stroke (cr);
const TabParameters *tab,
int x, int y, int width, int height)
{
- const CairoColor *border1 = &colors->shade[6];
- const CairoColor *border2 = &colors->shade[5];
- const CairoColor *stripe_fill = &colors->spot[1];
- const CairoColor *stripe_border = &colors->spot[2];
- const CairoColor *fill;
- CairoColor hilight;
-
- cairo_pattern_t *pattern;
-
- double radius;
- double strip_size;
+ const CairoColor *border1 = &colors->shade[6];
+ const CairoColor *border2 = &colors->shade[5];
+ const CairoColor *stripe_fill = &colors->spot[1];
+ const CairoColor *stripe_border = &colors->spot[2];
+ const CairoColor *fill;
+ CairoColor hilight;
+
+ cairo_pattern_t *pattern;
+
+ double radius;
+ double stripe_size = 2.0;
+ double stripe_fill_size;
+ double length;
radius = MIN (params->radius, MIN ((width - 2.0) / 2.0, (height - 2.0) / 2.0));
+ cairo_save (cr);
+
/* Set clip */
cairo_rectangle (cr, x, y, width, height);
cairo_clip (cr);
cairo_new_path (cr);
- /* Translate and set line width */
+ /* Translate and set line width */
cairo_set_line_width (cr, 1.0);
- cairo_translate (cr, x+0.5, y+0.5);
+ cairo_translate (cr, x, y);
/* Make the tabs slightly bigger than they should be, to create a gap */
if (tab->gap_side == CL_GAP_TOP || tab->gap_side == CL_GAP_BOTTOM)
{
height += 3.0;
- strip_size = 2.0/height; /* 2 pixel high strip */
-
+ length = height;
+ stripe_fill_size = (tab->gap_side == CL_GAP_TOP ? stripe_size/height : stripe_size/(height-2));
+
if (tab->gap_side == CL_GAP_TOP)
cairo_translate (cr, 0.0, -3.0); /* gap at the other side */
}
else
{
width += 3.0;
- strip_size = 2.0/width;
-
- if (tab->gap_side == CL_GAP_LEFT)
+ length = width;
+ stripe_fill_size = (tab->gap_side == CL_GAP_LEFT ? stripe_size/width : stripe_size/(width-2));
+
+ if (tab->gap_side == CL_GAP_LEFT)
cairo_translate (cr, -3.0, 0.0); /* gap at the other side */
}
-
+
/* Set the fill color */
fill = &colors->bg[params->state_type];
/* Set tab shape */
- ge_cairo_rounded_rectangle (cr, 0, 0, width-1, height-1,
+ ge_cairo_rounded_rectangle (cr, 0.5, 0.5, width-1, height-1,
radius, params->corners);
-
+
/* Draw fill */
ge_cairo_set_color (cr, fill);
cairo_fill (cr);
if (!params->active)
{
ShadowParameters shadow;
-
+
shadow.shadow = CL_SHADOW_OUT;
shadow.corners = params->corners;
-
+
clearlooks_draw_highlight_and_shade (cr, colors, &shadow,
width,
height, radius);
}
-
+
if (params->active)
{
CairoColor shadow;
- pattern = cairo_pattern_create_linear ( tab->gap_side == CL_GAP_LEFT ? width-1 : 0,
- tab->gap_side == CL_GAP_TOP ? height-2 : 1,
- tab->gap_side == CL_GAP_RIGHT ? width : 0,
- tab->gap_side == CL_GAP_BOTTOM ? height : 0 );
+ switch (tab->gap_side)
+ {
+ case CL_GAP_TOP:
+ pattern = cairo_pattern_create_linear (0.5, height-1.5, 0.5, 0.5);
+ break;
+ case CL_GAP_BOTTOM:
+ pattern = cairo_pattern_create_linear (0.5, 1.5, 0.5, height+0.5);
+ break;
+ case CL_GAP_LEFT:
+ pattern = cairo_pattern_create_linear (width-1.5, 0.5, 1.5, 0.5);
+ break;
+ case CL_GAP_RIGHT:
+ pattern = cairo_pattern_create_linear (1.5, 0.5, width-1.5, 0.5);
+ break;
+ default:
+ pattern = NULL;
+ }
+
+ ge_cairo_rounded_rectangle (cr, 0.5, 0.5, width-1, height-1, radius, params->corners);
- ge_cairo_rounded_rectangle (cr, 0, 0, width-1, height-1, radius, params->corners);
-
ge_shade_color (fill, 0.92, &shadow);
- cairo_pattern_add_color_stop_rgba (pattern, 0.0, hilight.r, hilight.g, hilight.b, 0.4);
- cairo_pattern_add_color_stop_rgba (pattern, 1.0/height, hilight.r, hilight.g, hilight.b, 0.4);
- cairo_pattern_add_color_stop_rgb (pattern, 1.0/height, fill->r,fill->g,fill->b);
- cairo_pattern_add_color_stop_rgb (pattern, 1.0, shadow.r,shadow.g,shadow.b);
+ cairo_pattern_add_color_stop_rgba (pattern, 0.0, hilight.r, hilight.g, hilight.b, 0.4);
+ cairo_pattern_add_color_stop_rgba (pattern, 1.0/length, hilight.r, hilight.g, hilight.b, 0.4);
+ cairo_pattern_add_color_stop_rgb (pattern, 1.0/length, fill->r,fill->g,fill->b);
+ cairo_pattern_add_color_stop_rgb (pattern, 1.0, shadow.r,shadow.g,shadow.b);
cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
else
{
/* Draw shade */
- pattern = cairo_pattern_create_linear ( tab->gap_side == CL_GAP_LEFT ? width-2 : 0,
- tab->gap_side == CL_GAP_TOP ? height-2 : 0,
- tab->gap_side == CL_GAP_RIGHT ? width : 0,
- tab->gap_side == CL_GAP_BOTTOM ? height : 0 );
-
- ge_cairo_rounded_rectangle (cr, 0, 0, width-1, height-1, radius, params->corners);
-
+ switch (tab->gap_side)
+ {
+ case CL_GAP_TOP:
+ pattern = cairo_pattern_create_linear (0.5, height-1.5, 0.5, 0.5);
+ break;
+ case CL_GAP_BOTTOM:
+ pattern = cairo_pattern_create_linear (0.5, 0.5, 0.5, height+0.5);
+ break;
+ case CL_GAP_LEFT:
+ pattern = cairo_pattern_create_linear (width-1.5, 0.5, 0.5, 0.5);
+ break;
+ case CL_GAP_RIGHT:
+ pattern = cairo_pattern_create_linear (0.5, 0.5, width+0.5, 0.5);
+ break;
+ default:
+ pattern = NULL;
+ }
+
+ ge_cairo_rounded_rectangle (cr, 0.5, 0.5, width-1, height-1, radius, params->corners);
cairo_pattern_add_color_stop_rgb (pattern, 0.0, stripe_fill->r, stripe_fill->g, stripe_fill->b);
- cairo_pattern_add_color_stop_rgb (pattern, strip_size, stripe_fill->r, stripe_fill->g, stripe_fill->b);
- cairo_pattern_add_color_stop_rgba (pattern, strip_size, hilight.r, hilight.g, hilight.b, 0.5);
+ cairo_pattern_add_color_stop_rgb (pattern, stripe_fill_size, stripe_fill->r, stripe_fill->g, stripe_fill->b);
+ cairo_pattern_add_color_stop_rgba (pattern, stripe_fill_size, hilight.r, hilight.g, hilight.b, 0.5);
cairo_pattern_add_color_stop_rgba (pattern, 0.8, hilight.r, hilight.g, hilight.b, 0.0);
cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
}
- ge_cairo_rounded_rectangle (cr, 0, 0, width-1, height-1, radius, params->corners);
-
+ ge_cairo_inner_rounded_rectangle (cr, 0, 0, width, height, radius, params->corners);
+
if (params->active)
{
ge_cairo_set_color (cr, border2);
}
else
{
- pattern = cairo_pattern_create_linear ( tab->gap_side == CL_GAP_LEFT ? width-2 : 2,
- tab->gap_side == CL_GAP_TOP ? height-2 : 2,
- tab->gap_side == CL_GAP_RIGHT ? width : 2,
- tab->gap_side == CL_GAP_BOTTOM ? height : 2 );
-
+ switch (tab->gap_side)
+ {
+ case CL_GAP_TOP:
+ pattern = cairo_pattern_create_linear (2.5, height-1.5, 2.5, 2.5);
+ break;
+ case CL_GAP_BOTTOM:
+ pattern = cairo_pattern_create_linear (2.5, 2.5, 2.5, height+0.5);
+ break;
+ case CL_GAP_LEFT:
+ pattern = cairo_pattern_create_linear (width-1.5, 2.5, 2.5, 2.5);
+ break;
+ case CL_GAP_RIGHT:
+ pattern = cairo_pattern_create_linear (2.5, 2.5, width+0.5, 2.5);
+ break;
+ default:
+ pattern = NULL;
+ }
+
cairo_pattern_add_color_stop_rgb (pattern, 0.0, stripe_border->r, stripe_border->g, stripe_border->b);
- cairo_pattern_add_color_stop_rgb (pattern, strip_size, stripe_border->r, stripe_border->g, stripe_border->b);
- cairo_pattern_add_color_stop_rgb (pattern, strip_size, border1->r, border1->g, border1->b);
+ cairo_pattern_add_color_stop_rgb (pattern, stripe_fill_size, stripe_border->r, stripe_border->g, stripe_border->b);
+ cairo_pattern_add_color_stop_rgb (pattern, stripe_fill_size, border1->r, border1->g, border1->b);
cairo_pattern_add_color_stop_rgb (pattern, 1.0, border2->r, border2->g, border2->b);
cairo_set_source (cr, pattern);
cairo_stroke (cr);
cairo_pattern_destroy (pattern);
}
+
+ cairo_restore (cr);
}
static void
const SeparatorParameters *separator,
int x, int y, int width, int height)
{
- CairoColor color = colors->shade[3];
- CairoColor hilight;
- ge_shade_color (&color, 1.4, &hilight);
+ CairoColor color = colors->shade[2];
+ CairoColor hilight;
+ ge_shade_color (&colors->bg[0], 1.065, &hilight);
cairo_save (cr);
cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT);
{
cairo_set_line_width (cr, 1.0);
cairo_translate (cr, x, y+0.5);
-
+
cairo_move_to (cr, 0.0, 0.0);
cairo_line_to (cr, width, 0.0);
ge_cairo_set_color (cr, &color);
cairo_stroke (cr);
-
+
cairo_move_to (cr, 0.0, 1.0);
cairo_line_to (cr, width, 1.0);
ge_cairo_set_color (cr, &hilight);
{
cairo_set_line_width (cr, 1.0);
cairo_translate (cr, x+0.5, y);
-
+
cairo_move_to (cr, 0.0, 0.0);
cairo_line_to (cr, 0.0, height);
ge_cairo_set_color (cr, &color);
cairo_stroke (cr);
-
+
cairo_move_to (cr, 1.0, 0.0);
cairo_line_to (cr, 1.0, height);
ge_cairo_set_color (cr, &hilight);
const ListViewHeaderParameters *header,
int x, int y, int width, int height)
{
- const CairoColor *border = &colors->shade[5];
- cairo_pattern_t *pattern;
- CairoColor hilight;
- CairoColor shadow;
+ const CairoColor *border = &colors->shade[4];
+ CairoColor hilight;
- ge_shade_color (border, 1.5, &hilight);
- ge_shade_color (border, 0.925, &shadow);
+ ge_shade_color (&colors->bg[params->state_type],
+ params->style_constants->topleft_highlight_shade, &hilight);
+ hilight.a = params->style_constants->topleft_highlight_alpha;
cairo_translate (cr, x, y);
cairo_set_line_width (cr, 1.0);
-
+
/* Draw highlight */
- if (header->order == CL_ORDER_FIRST)
+ if (header->order & CL_ORDER_FIRST)
{
cairo_move_to (cr, 0.5, height-1);
cairo_line_to (cr, 0.5, 0.5);
}
else
cairo_move_to (cr, 0.0, 0.5);
-
+
cairo_line_to (cr, width, 0.5);
-
+
ge_cairo_set_color (cr, &hilight);
cairo_stroke (cr);
-
+
/* Draw bottom border */
cairo_move_to (cr, 0.0, height-0.5);
cairo_line_to (cr, width, height-0.5);
ge_cairo_set_color (cr, border);
cairo_stroke (cr);
- /* Draw bottom shade */
- pattern = cairo_pattern_create_linear (0.0, height-5.0, 0.0, height-1.0);
- cairo_pattern_add_color_stop_rgba (pattern, 0.0, shadow.r, shadow.g, shadow.b, 0.0);
- cairo_pattern_add_color_stop_rgba (pattern, 1.0, shadow.r, shadow.g, shadow.b, 0.3);
-
- cairo_rectangle (cr, 0.0, height-5.0, width, 4.0);
- cairo_set_source (cr, pattern);
- cairo_fill (cr);
- cairo_pattern_destroy (pattern);
-
/* Draw resize grip */
- if ((params->ltr && header->order != CL_ORDER_LAST) ||
- (!params->ltr && header->order != CL_ORDER_FIRST) || header->resizable)
+ if ((params->ltr && !(header->order & CL_ORDER_LAST)) ||
+ (!params->ltr && !(header->order & CL_ORDER_FIRST)) || header->resizable)
{
SeparatorParameters separator;
separator.horizontal = FALSE;
-
+
if (params->ltr)
params->style_functions->draw_separator (cr, colors, params, &separator,
width-1.5, 4.0, 2, height-8.0);
const ToolbarParameters *toolbar,
int x, int y, int width, int height)
{
- const CairoColor *fill = &colors->bg[GTK_STATE_NORMAL];
+ const CairoColor *fill = &colors->bg[0];
const CairoColor *dark = &colors->shade[3];
CairoColor light;
- ge_shade_color (fill, 1.1, &light);
-
+ ge_shade_color (fill, 1.065, &light);
+
cairo_set_line_width (cr, 1.0);
cairo_translate (cr, x, y);
ge_cairo_set_color (cr, fill);
cairo_paint (cr);
- if (!toolbar->topmost)
+ if (!toolbar->topmost)
{
/* Draw highlight */
cairo_move_to (cr, 0, 0.5);
CairoColor fill_shade;
CairoColor border = colors->spot[2];
cairo_pattern_t *pattern;
-
+
ge_shade_color (&border, 1.05, &border);
ge_shade_color (fill, 0.85, &fill_shade);
-
+
cairo_set_line_width (cr, 1.0);
ge_cairo_rounded_rectangle (cr, x + 0.5, y + 0.5, width - 1, height, widget->radius, widget->corners);
{
CairoColor upper_color;
CairoColor lower_color;
- CairoColor border;
cairo_pattern_t *pattern;
cairo_save (cr);
-
+
cairo_translate (cr, x, y);
if (params->focus)
cairo_fill (cr);
cairo_pattern_destroy (pattern);
-
- ge_shade_color(&upper_color, 0.8, &border);
-
- cairo_move_to (cr, 0, 0.5);
- cairo_rel_line_to (cr, width, 0);
- cairo_move_to (cr, 0, height-0.5);
- cairo_rel_line_to (cr, width, 0);
-
- ge_cairo_set_color (cr, &border);
- cairo_stroke (cr);
cairo_restore (cr);
}
const CairoColor *border = &colors->shade[5];
CairoColor bg_shade;
cairo_pattern_t *pattern;
-
+ double radius = MIN (widget->radius, MIN ((width - 2.0) / 2.0, (height - 2.0) / 2.0));
+
ge_shade_color (bg, 0.95, &bg_shade);
-
+
cairo_set_line_width (cr, 1);
/* cairo_translate (cr, x, y); */
-
+
if (scrollbar->horizontal)
ge_cairo_exchange_axis (cr, &x, &y, &width, &height);
- cairo_translate (cr, x, y);
+ cairo_translate (cr, x, y);
/* Draw fill */
- cairo_rectangle (cr, 1, 0, width-2, height);
+ if (radius > 3.0)
+ ge_cairo_rounded_rectangle (cr, 1, 0, width-2, height,
+ radius, widget->corners);
+ else
+ cairo_rectangle (cr, 1, 0, width-2, height);
ge_cairo_set_color (cr, bg);
cairo_fill (cr);
/* Draw shadow */
pattern = cairo_pattern_create_linear (1, 0, 3, 0);
cairo_pattern_add_color_stop_rgb (pattern, 0, bg_shade.r, bg_shade.g, bg_shade.b);
- cairo_pattern_add_color_stop_rgb (pattern, 1.0, bg->r, bg->g, bg->b);
+ cairo_pattern_add_color_stop_rgb (pattern, 1.0, bg->r, bg->g, bg->b);
cairo_rectangle (cr, 1, 0, 4, height);
cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
-
+
/* Draw border */
+ if (radius > 3.0)
+ ge_cairo_rounded_rectangle (cr, 0.5, 0.5, width-1, height-1,
+ radius, widget->corners);
+ else
+ cairo_rectangle (cr, 0.5, 0.5, width-1, height-1);
ge_cairo_set_color (cr, border);
- ge_cairo_stroke_rectangle (cr, 0.5, 0.5, width-1, height-1);
+ cairo_stroke (cr);
}
static void
CairoColor border;
CairoColor s1, s2, s3, s4;
cairo_pattern_t *pattern;
- ShadowParameters shadow;
double radius = MIN (widget->radius, MIN ((width - 2.0) / 2.0, (height - 2.0) / 2.0));
- ge_shade_color(&colors->shade[6], 1.05, &border);
-
+ ge_shade_color(&colors->shade[6], 1.08, &border);
+
if (scrollbar->horizontal)
{
if (stepper->stepper == CL_STEPPER_A)
else if (stepper->stepper == CL_STEPPER_D)
corners = CR_CORNER_BOTTOMLEFT | CR_CORNER_BOTTOMRIGHT;
}
-
+
cairo_translate (cr, x, y);
cairo_set_line_width (cr, 1);
-
+
ge_cairo_rounded_rectangle (cr, 1, 1, width-2, height-2, radius, corners);
-
+
if (scrollbar->horizontal)
pattern = cairo_pattern_create_linear (0, 0, 0, height);
else
pattern = cairo_pattern_create_linear (0, 0, width, 0);
-
- s2 = colors->bg[widget->state_type];
- ge_shade_color(&s2, 1.06, &s1);
- ge_shade_color(&s2, 0.98, &s3);
- ge_shade_color(&s2, 0.94, &s4);
-
- cairo_pattern_add_color_stop_rgb(pattern, 0, s1.r, s1.g, s1.b);
- cairo_pattern_add_color_stop_rgb(pattern, 0.5, s2.r, s2.g, s2.b);
- cairo_pattern_add_color_stop_rgb(pattern, 0.7, s3.r, s3.g, s3.b);
- cairo_pattern_add_color_stop_rgb(pattern, 1.0, s4.r, s4.g, s4.b);
+
+ ge_shade_color (&colors->bg[widget->state_type], SHADE_TOP, &s1);
+ ge_shade_color (&colors->bg[widget->state_type], SHADE_CENTER_TOP, &s2);
+ ge_shade_color (&colors->bg[widget->state_type], SHADE_CENTER_BOTTOM, &s3);
+ ge_shade_color (&colors->bg[widget->state_type], SHADE_BOTTOM, &s4);
+
+ cairo_pattern_add_color_stop_rgb(pattern, 0, s1.r, s1.g, s1.b);
+ cairo_pattern_add_color_stop_rgb(pattern, 0.3, s2.r, s2.g, s2.b);
+ cairo_pattern_add_color_stop_rgb(pattern, 0.7, s3.r, s3.g, s3.b);
+ cairo_pattern_add_color_stop_rgb(pattern, 1.0, s4.r, s4.g, s4.b);
cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
-
- cairo_translate (cr, 0.5, 0.5);
- clearlooks_draw_top_left_highlight (cr, &s2, widget, width, height, (stepper->stepper == CL_STEPPER_A) ? radius : 0);
- cairo_translate (cr, -0.5, -0.5);
-
- ge_cairo_rounded_rectangle (cr, 0.5, 0.5, width-1, height-1, radius, corners);
- clearlooks_set_border_gradient (cr, &border, 1.2, (scrollbar->horizontal ? 0 : width), (scrollbar->horizontal ? height: 0));
+
+ widget->style_functions->draw_top_left_highlight (cr, &s2, widget, 1, 1, width - 2, height - 2, MAX(radius - 1, 0), corners);
+
+ ge_cairo_inner_rounded_rectangle (cr, 0, 0, width, height, radius, corners);
+ clearlooks_set_border_gradient (cr, &border, 1.1, (scrollbar->horizontal ? 0 : width), (scrollbar->horizontal ? height: 0));
cairo_stroke (cr);
-
- cairo_translate (cr, 0.5, 0.5);
- shadow.shadow = CL_SHADOW_OUT;
- shadow.corners = corners;
- /*
- clearlooks_draw_highlight_and_shade (cr, &shadow,
- width,
- height, params->radius);*/
}
static void
const ScrollBarParameters *scrollbar,
int x, int y, int width, int height)
{
+ cairo_save (cr);
+
if (scrollbar->junction & CL_JUNCTION_BEGIN)
{
if (scrollbar->horizontal)
else
height += 1;
}
-
+
if (!scrollbar->horizontal)
ge_cairo_exchange_axis (cr, &x, &y, &width, &height);
- cairo_translate (cr, x, y);
+ cairo_translate (cr, x, y);
if (scrollbar->has_color)
{
if (widget->prelight)
ge_shade_color (&fill, 1.1, &fill);
-
+
cairo_set_line_width (cr, 1);
-
+
ge_shade_color (&fill, 1.3, &hilight);
ge_shade_color (&fill, 1.1, &shade1);
ge_shade_color (&fill, 1.05, &shade2);
ge_shade_color (&fill, 0.98, &shade3);
-
+
pattern = cairo_pattern_create_linear (1, 1, 1, height-2);
cairo_pattern_add_color_stop_rgb (pattern, 0, shade1.r, shade1.g, shade1.b);
cairo_pattern_add_color_stop_rgb (pattern, 0.5, shade2.r, shade2.g, shade2.b);
- cairo_pattern_add_color_stop_rgb (pattern, 0.5, shade3.r, shade3.g, shade3.b);
+ cairo_pattern_add_color_stop_rgb (pattern, 0.5, shade3.r, shade3.g, shade3.b);
cairo_pattern_add_color_stop_rgb (pattern, 1, fill.r, fill.g, fill.b);
cairo_rectangle (cr, 1, 1, width-2, height-2);
cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
-
+
cairo_set_source_rgba (cr, hilight.r, hilight.g, hilight.b, 0.5);
ge_cairo_stroke_rectangle (cr, 1.5, 1.5, width-3, height-3);
-
+
ge_cairo_set_color (cr, border);
ge_cairo_stroke_rectangle (cr, 0.5, 0.5, width-1, height-1);
}
cairo_pattern_t *pattern;
int bar_x, i;
- ge_shade_color(&colors->shade[6], 1.05, &border);
-
- s2 = colors->bg[widget->state_type];
- ge_shade_color(&s2, 1.06, &s1);
- ge_shade_color(&s2, 0.98, &s3);
- ge_shade_color(&s2, 0.94, &s4);
-
+ ge_shade_color (&colors->shade[6], 1.08, &border);
+ ge_shade_color (&colors->bg[widget->state_type], SHADE_TOP, &s1);
+ ge_shade_color (&colors->bg[widget->state_type], SHADE_CENTER_TOP, &s2);
+ ge_shade_color (&colors->bg[widget->state_type], SHADE_CENTER_BOTTOM, &s3);
+ ge_shade_color (&colors->bg[widget->state_type], SHADE_BOTTOM, &s4);
+
pattern = cairo_pattern_create_linear(1, 1, 1, height-1);
cairo_pattern_add_color_stop_rgb(pattern, 0, s1.r, s1.g, s1.b);
- cairo_pattern_add_color_stop_rgb(pattern, 0.5, s2.r, s2.g, s2.b);
+ cairo_pattern_add_color_stop_rgb(pattern, 0.3, s2.r, s2.g, s2.b);
cairo_pattern_add_color_stop_rgb(pattern, 0.7, s3.r, s3.g, s3.b);
cairo_pattern_add_color_stop_rgb(pattern, 1.0, s4.r, s4.g, s4.b);
cairo_set_source(cr, pattern);
cairo_fill(cr);
cairo_pattern_destroy(pattern);
-
- clearlooks_set_border_gradient (cr, &border, 1.2, 0, height);
+
+ clearlooks_set_border_gradient (cr, &border, 1.1, 0, height);
ge_cairo_stroke_rectangle (cr, 0.5, 0.5, width-1, height-1);
-
+
cairo_move_to (cr, 1.5, height-1.5);
cairo_line_to (cr, 1.5, 1.5);
cairo_line_to (cr, width-1.5, 1.5);
- ge_shade_color (&s2, 1.3, &s5);
- cairo_set_source_rgba (cr, s5.r, s5.g, s5.b, 0.5);
+ ge_shade_color (&s2, widget->style_constants->topleft_highlight_shade, &s5);
+ s5.a = widget->style_constants->topleft_highlight_alpha;
+ ge_cairo_set_color (cr, &s5);
cairo_stroke(cr);
-
+
/* draw handles */
cairo_set_line_width (cr, 1);
-
+ cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT);
+
bar_x = width/2 - 4;
- cairo_translate(cr, 0.5, 0.5);
+
for (i=0; i<3; i++)
{
- cairo_move_to (cr, bar_x, 4);
- cairo_line_to (cr, bar_x, height-5);
+ cairo_move_to (cr, bar_x + 0.5, 4);
+ cairo_line_to (cr, bar_x + 0.5, height-4);
ge_cairo_set_color (cr, dark);
cairo_stroke (cr);
-
- cairo_move_to (cr, bar_x+1, 4);
- cairo_line_to (cr, bar_x+1, height-5);
+
+ cairo_move_to (cr, bar_x+1.5, 4);
+ cairo_line_to (cr, bar_x+1.5, height-4);
ge_cairo_set_color (cr, light);
cairo_stroke (cr);
-
+
bar_x += 3;
}
}
-
+
+ cairo_restore (cr);
}
static void
cairo_translate (cr, x, y+0.5);
cairo_move_to (cr, 0, 0);
cairo_line_to (cr, width, 0);
- ge_cairo_set_color (cr, dark);
+ ge_cairo_set_color (cr, dark);
cairo_stroke (cr);
cairo_translate (cr, 0, 1);
const CairoColor *border = &colors->shade[5];
cairo_translate (cr, x, y);
cairo_set_line_width (cr, 1);
-/*
- cairo_set_source_rgba (cr, colors->bg[0].r, colors->bg[0].g, colors->bg[0].b, 0.9);
- cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
- cairo_paint (cr);
-*/
+
ge_cairo_set_color (cr, border);
ge_cairo_stroke_rectangle (cr, 0.5, 0.5, width-1, height-1);
}
{
const CairoColor *fill = &colors->bg[params->state_type];
int num_bars = 6; /* shut up gcc warnings */
- int bar_spacing;
-
+
+ cairo_save (cr);
+
switch (handle->type)
{
case CL_HANDLE_TOOLBAR:
num_bars = 6;
- bar_spacing = 3;
break;
case CL_HANDLE_SPLITTER:
num_bars = 16;
- bar_spacing = 3;
break;
}
ge_cairo_set_color (cr, fill);
cairo_fill (cr);
}
-
- cairo_translate (cr, x+0.5, y+0.5);
-
+
+ cairo_translate (cr, x, y);
+
cairo_set_line_width (cr, 1);
-
+
if (handle->horizontal)
{
params->style_functions->draw_gripdots (cr, colors, 0, 0, width, height, num_bars, 2, 0.1);
{
params->style_functions->draw_gripdots (cr, colors, 0, 0, width, height, 2, num_bars, 0.1);
}
+
+ cairo_restore (cr);
}
static void
int x_down;
int y_down;
int dots;
-
+
ge_shade_color (dark, 1.5, &hilight);
/* The number of dots fitting into the area. Just hardcoded to 4 right now. */
cairo_pattern_t *pt;
gboolean inconsistent;
gboolean draw_bullet = (checkbox->shadow_type == GTK_SHADOW_IN);
+ gdouble w, h, cx, cy, radius;
+
+ w = (gdouble) width;
+ h = (gdouble) height;
+ cx = width / 2.0;
+ cy = height / 2.0;
+ radius = MIN (width, height) / 2.0;
inconsistent = (checkbox->shadow_type == GTK_SHADOW_ETCHED_IN);
draw_bullet |= inconsistent;
ge_shade_color (&widget->parentbg, 0.9, &shadow);
ge_shade_color (&widget->parentbg, 1.1, &highlight);
- pt = cairo_pattern_create_linear (0, 0, 13, 13);
+ pt = cairo_pattern_create_linear (0, 0, radius * 2.0, radius * 2.0);
cairo_pattern_add_color_stop_rgb (pt, 0.0, shadow.r, shadow.b, shadow.g);
cairo_pattern_add_color_stop_rgba (pt, 0.5, shadow.r, shadow.b, shadow.g, 0.5);
cairo_pattern_add_color_stop_rgba (pt, 0.5, highlight.r, highlight.g, highlight.b, 0.5);
cairo_pattern_add_color_stop_rgb (pt, 1.0, highlight.r, highlight.g, highlight.b);
-
+
cairo_translate (cr, x, y);
-
- cairo_set_line_width (cr, 2);
- cairo_arc (cr, 7, 7, 6, 0, G_PI*2);
+
+ cairo_set_line_width (cr, MAX (1.0, floor (radius/3)));
+ cairo_arc (cr, ceil (cx), ceil (cy), floor (radius - 0.1), 0, G_PI*2);
cairo_set_source (cr, pt);
cairo_stroke (cr);
cairo_pattern_destroy (pt);
- cairo_set_line_width (cr, 1);
+ cairo_set_line_width (cr, MAX (1.0, floor (radius/6)));
+
+ cairo_arc (cr, ceil (cx), ceil (cy), MAX (1.0, ceil (radius) - 1.5), 0, G_PI*2);
- cairo_arc (cr, 7, 7, 5.5, 0, G_PI*2);
-
if (!widget->disabled)
{
ge_cairo_set_color (cr, &colors->base[0]);
cairo_fill_preserve (cr);
}
-
+
ge_cairo_set_color (cr, border);
cairo_stroke (cr);
-
+
if (draw_bullet)
{
if (inconsistent)
{
cairo_set_line_cap(cr, CAIRO_LINE_CAP_ROUND);
- cairo_set_line_width (cr, 4);
+ cairo_set_line_width (cr, ceil (radius * 2 / 3));
- cairo_move_to(cr, 5, 7);
- cairo_line_to(cr, 9, 7);
+ cairo_move_to (cr, ceil (cx - radius/3.0), ceil (cy));
+ cairo_line_to (cr, ceil (cx + radius/3.0), ceil (cy));
ge_cairo_set_color (cr, dot);
cairo_stroke (cr);
}
else
{
- cairo_arc (cr, 7, 7, 3, 0, G_PI*2);
+ cairo_arc (cr, ceil (cx), ceil (cy), floor (radius/2.0), 0, G_PI*2);
ge_cairo_set_color (cr, dot);
cairo_fill (cr);
-
- cairo_arc (cr, 6, 6, 1, 0, G_PI*2);
+
+ cairo_arc (cr, floor (cx - radius/10.0), floor (cy - radius/10.0), floor (radius/6.0), 0, G_PI*2);
cairo_set_source_rgba (cr, highlight.r, highlight.g, highlight.b, 0.5);
cairo_fill (cr);
}
inconsistent = (checkbox->shadow_type == GTK_SHADOW_ETCHED_IN);
draw_bullet |= inconsistent;
-
+
if (widget->disabled)
{
border = &colors->shade[5];
cairo_translate (cr, x, y);
cairo_set_line_width (cr, 1);
-
+
if (widget->xthickness > 2 && widget->ythickness > 2)
{
- widget->style_functions->draw_inset (cr, &widget->parentbg, 0.5, 0.5, width-1, height-1, 1, CR_CORNER_ALL);
-
+ widget->style_functions->draw_inset (cr, &widget->parentbg, 0, 0, width, height, 1, CR_CORNER_ALL);
+
/* Draw the rectangle for the checkbox itself */
ge_cairo_rounded_rectangle (cr, 1.5, 1.5, width-3, height-3, (widget->radius > 0)? 1 : 0, CR_CORNER_ALL);
}
/* Draw the rectangle for the checkbox itself */
ge_cairo_rounded_rectangle (cr, 0.5, 0.5, width-1, height-1, (widget->radius > 0)? 1 : 0, CR_CORNER_ALL);
}
-
+
if (!widget->disabled)
{
ge_cairo_set_color (cr, &colors->base[0]);
cairo_fill_preserve (cr);
}
-
+
ge_cairo_set_color (cr, border);
cairo_stroke (cr);
cairo_set_line_width (cr, 1.7);
cairo_move_to (cr, 0.5 + (width*0.2), (height*0.5));
cairo_line_to (cr, 0.5 + (width*0.4), (height*0.7));
-
+
cairo_curve_to (cr, 0.5 + (width*0.4), (height*0.7),
0.5 + (width*0.5), (height*0.4),
0.5 + (width*0.70), (height*0.25));
}
-
+
ge_cairo_set_color (cr, dot);
cairo_stroke (cr);
}
arrow_width = MIN (height * 2.0 + MAX (1.0, ceil (height * 2.0 / 6.0 * 2.0) / 2.0) / 2.0, width);
line_width_2 = MAX (1.0, ceil (arrow_width / 6.0 * 2.0) / 2.0) / 2.0;
arrow_height = arrow_width / 2.0 + line_width_2;
-
+
cairo_translate (cr, x, y - arrow_height / 2.0);
cairo_move_to (cr, -arrow_width / 2.0, line_width_2);
cairo_line_to (cr, arrow_width / 2.0, line_width_2);
cairo_line_to (cr, 0, arrow_height);
cairo_close_path (cr);
-
+
ge_cairo_set_color (cr, color);
cairo_fill (cr);
-
+
cairo_restore (cr);
}
double arrow_width = MIN (height * 2 / 3.0, width);
double arrow_height = arrow_width / 2.0;
double gap_size = 1.0 * arrow_height;
-
+
cairo_save (cr);
cairo_translate (cr, x, y - (arrow_height + gap_size) / 2.0);
cairo_rotate (cr, G_PI);
clearlooks_draw_normal_arrow (cr, color, 0, 0, arrow_width, arrow_height);
cairo_restore (cr);
-
+
clearlooks_draw_normal_arrow (cr, color, x, y + (arrow_height + gap_size) / 2.0, arrow_width, arrow_height);
}
double x, double y, double width, double height)
{
double rotate;
-
+
if (dir == CL_DIRECTION_LEFT)
rotate = G_PI*1.5;
else if (dir == CL_DIRECTION_RIGHT)
rotate = 0;
else
return;
-
+
if (type == CL_ARROW_NORMAL)
{
cairo_translate (cr, x, y);
- cairo_rotate (cr, -rotate);
+ cairo_rotate (cr, -rotate);
clearlooks_draw_normal_arrow (cr, color, 0, 0, width, height);
}
else if (type == CL_ARROW_COMBO)
static void
clearlooks_draw_arrow (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
- const ArrowParameters *arrow,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
+ const ArrowParameters *arrow,
int x, int y, int width, int height)
{
const CairoColor *color = &colors->fg[widget->state_type];
gdouble tx, ty;
-
+
tx = x + width/2.0;
ty = y + height/2.0;
-
+
if (widget->disabled)
{
_clearlooks_draw_arrow (cr, &colors->shade[0],
}
cairo_identity_matrix (cr);
-
+
_clearlooks_draw_arrow (cr, color, arrow->direction, arrow->type,
tx, ty, width, height);
}
void
-clearlooks_register_style_classic (ClearlooksStyleFunctions *functions)
+clearlooks_draw_focus (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
+ const FocusParameters *focus,
+ int x, int y, int width, int height)
+{
+ if (focus->has_color)
+ ge_cairo_set_color (cr, &focus->color);
+ else if (focus->type == CL_FOCUS_COLOR_WHEEL_LIGHT)
+ cairo_set_source_rgb (cr, 0., 0., 0.);
+ else if (focus->type == CL_FOCUS_COLOR_WHEEL_DARK)
+ cairo_set_source_rgb (cr, 1., 1., 1.);
+ else
+ cairo_set_source_rgba (cr,
+ colors->fg[widget->state_type].r,
+ colors->fg[widget->state_type].g,
+ colors->fg[widget->state_type].b,
+ 0.7);
+
+ cairo_set_line_width (cr, focus->line_width);
+
+ if (focus->dash_list[0])
+ {
+ gint n_dashes = strlen ((gchar *)focus->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] = focus->dash_list[i];
+ total_length += focus->dash_list[i];
+ }
+
+ dash_offset = -focus->line_width / 2.0;
+ while (dash_offset < 0)
+ dash_offset += total_length;
+
+ cairo_set_dash (cr, dashes, n_dashes, dash_offset);
+ g_free (dashes);
+ }
+
+ cairo_rectangle (cr,
+ x + focus->line_width / 2.0,
+ y + focus->line_width / 2.0,
+ width - focus->line_width, height - focus->line_width);
+ cairo_stroke (cr);
+}
+
+void
+clearlooks_register_style_classic (ClearlooksStyleFunctions *functions, ClearlooksStyleConstants *constants)
{
g_assert (functions);
- functions->draw_button = clearlooks_draw_button;
- functions->draw_scale_trough = clearlooks_draw_scale_trough;
- functions->draw_progressbar_trough = clearlooks_draw_progressbar_trough;
- functions->draw_progressbar_fill = clearlooks_draw_progressbar_fill;
- functions->draw_slider_button = clearlooks_draw_slider_button;
- functions->draw_entry = clearlooks_draw_entry;
- functions->draw_spinbutton = clearlooks_draw_spinbutton;
- functions->draw_spinbutton_down = clearlooks_draw_spinbutton_down;
- functions->draw_optionmenu = clearlooks_draw_optionmenu;
- functions->draw_inset = clearlooks_draw_inset;
- functions->draw_menubar = clearlooks_draw_menubar;
- functions->draw_tab = clearlooks_draw_tab;
- functions->draw_frame = clearlooks_draw_frame;
- functions->draw_separator = clearlooks_draw_separator;
+ functions->draw_top_left_highlight = clearlooks_draw_top_left_highlight;
+ functions->draw_button = clearlooks_draw_button;
+ functions->draw_scale_trough = clearlooks_draw_scale_trough;
+ functions->draw_progressbar_trough = clearlooks_draw_progressbar_trough;
+ functions->draw_progressbar_fill = clearlooks_draw_progressbar_fill;
+ functions->draw_slider_button = clearlooks_draw_slider_button;
+ functions->draw_entry = clearlooks_draw_entry;
+ functions->draw_spinbutton = clearlooks_draw_spinbutton;
+ functions->draw_spinbutton_down = clearlooks_draw_spinbutton_down;
+ functions->draw_optionmenu = clearlooks_draw_optionmenu;
+ functions->draw_inset = clearlooks_draw_inset;
+ functions->draw_menubar = clearlooks_draw_menubar;
+ functions->draw_tab = clearlooks_draw_tab;
+ functions->draw_frame = clearlooks_draw_frame;
+ functions->draw_separator = clearlooks_draw_separator;
functions->draw_menu_item_separator = clearlooks_draw_menu_item_separator;
- functions->draw_list_view_header = clearlooks_draw_list_view_header;
- functions->draw_toolbar = clearlooks_draw_toolbar;
- functions->draw_menuitem = clearlooks_draw_menuitem;
- functions->draw_menubaritem = clearlooks_draw_menubaritem;
- functions->draw_selected_cell = clearlooks_draw_selected_cell;
- functions->draw_scrollbar_stepper = clearlooks_draw_scrollbar_stepper;
- functions->draw_scrollbar_slider = clearlooks_draw_scrollbar_slider;
- functions->draw_scrollbar_trough = clearlooks_draw_scrollbar_trough;
- functions->draw_statusbar = clearlooks_draw_statusbar;
- functions->draw_menu_frame = clearlooks_draw_menu_frame;
- functions->draw_tooltip = clearlooks_draw_tooltip;
- functions->draw_handle = clearlooks_draw_handle;
- functions->draw_resize_grip = clearlooks_draw_resize_grip;
- functions->draw_arrow = clearlooks_draw_arrow;
- functions->draw_checkbox = clearlooks_draw_checkbox;
- functions->draw_radiobutton = clearlooks_draw_radiobutton;
- functions->draw_shadow = clearlooks_draw_shadow;
- functions->draw_slider = clearlooks_draw_slider;
- functions->draw_gripdots = clearlooks_draw_gripdots;
+ functions->draw_list_view_header = clearlooks_draw_list_view_header;
+ functions->draw_toolbar = clearlooks_draw_toolbar;
+ functions->draw_menuitem = clearlooks_draw_menuitem;
+ functions->draw_menubaritem = clearlooks_draw_menubaritem;
+ functions->draw_selected_cell = clearlooks_draw_selected_cell;
+ functions->draw_scrollbar_stepper = clearlooks_draw_scrollbar_stepper;
+ functions->draw_scrollbar_slider = clearlooks_draw_scrollbar_slider;
+ functions->draw_scrollbar_trough = clearlooks_draw_scrollbar_trough;
+ functions->draw_statusbar = clearlooks_draw_statusbar;
+ functions->draw_menu_frame = clearlooks_draw_menu_frame;
+ functions->draw_tooltip = clearlooks_draw_tooltip;
+ functions->draw_handle = clearlooks_draw_handle;
+ functions->draw_resize_grip = clearlooks_draw_resize_grip;
+ functions->draw_arrow = clearlooks_draw_arrow;
+ functions->draw_focus = clearlooks_draw_focus;
+ functions->draw_checkbox = clearlooks_draw_checkbox;
+ functions->draw_radiobutton = clearlooks_draw_radiobutton;
+ functions->draw_shadow = clearlooks_draw_shadow;
+ functions->draw_slider = clearlooks_draw_slider;
+ functions->draw_gripdots = clearlooks_draw_gripdots;
+
+ constants->topleft_highlight_shade = 1.3;
+ constants->topleft_highlight_alpha = 0.6;
}
#include <cairo.h>
-GE_INTERNAL void clearlooks_register_style_classic (ClearlooksStyleFunctions *functions);
-GE_INTERNAL void clearlooks_register_style_glossy (ClearlooksStyleFunctions *functions);
-GE_INTERNAL void clearlooks_register_style_gummy (ClearlooksStyleFunctions *functions);
-GE_INTERNAL void clearlooks_register_style_inverted (ClearlooksStyleFunctions *functions);
+GE_INTERNAL void clearlooks_register_style_classic (ClearlooksStyleFunctions *functions, ClearlooksStyleConstants *constants);
+GE_INTERNAL void clearlooks_register_style_glossy (ClearlooksStyleFunctions *functions, ClearlooksStyleConstants *constants);
+GE_INTERNAL void clearlooks_register_style_gummy (ClearlooksStyleFunctions *functions, ClearlooksStyleConstants *constants);
+GE_INTERNAL void clearlooks_register_style_inverted (ClearlooksStyleFunctions *functions, ClearlooksStyleConstants *constants);
+
+/* Fallback focus function */
+GE_INTERNAL void clearlooks_draw_focus (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
+ const FocusParameters *focus,
+ int x, int y, int width, int height);
#endif /* CLEARLOOKS_DRAW_H */
static void
clearlooks_draw_glossy_gradient (cairo_t *cr,
- double x, double y, int width, int height,
- const CairoColor *color,
- gboolean disabled, gboolean radius, CairoCorners corners)
+ double x, double y, int width, int height,
+ const CairoColor *color,
+ gboolean disabled, gboolean radius, CairoCorners corners)
{
CairoColor a, b, c, d;
cairo_pattern_t *pt;
ge_shade_color (color, disabled? 1.02 : 1.08, &d);
pt = cairo_pattern_create_linear (x, y, x, y+height);
- cairo_pattern_add_color_stop_rgb (pt, 0.0, a.r, a.g, a.b);
- cairo_pattern_add_color_stop_rgb (pt, 0.5, b.r, b.g, b.b);
- cairo_pattern_add_color_stop_rgb (pt, 0.5, c.r, c.g, c.b);
- cairo_pattern_add_color_stop_rgb (pt, 1.0, d.r, d.g, d.b);
+ cairo_pattern_add_color_stop_rgb (pt, 0.0, a.r, a.g, a.b);
+ cairo_pattern_add_color_stop_rgb (pt, 0.5, b.r, b.g, b.b);
+ cairo_pattern_add_color_stop_rgb (pt, 0.5, c.r, c.g, c.b);
+ cairo_pattern_add_color_stop_rgb (pt, 1.0, d.r, d.g, d.b);
cairo_set_source (cr, pt);
ge_cairo_rounded_rectangle (cr, x, y, width, height, radius, corners);
ge_cairo_set_color (cr, &composite);
}
+/* This draw_inset implementation only differes in the shades values from the
+ * default one. */
static void
clearlooks_glossy_draw_inset (cairo_t *cr,
const CairoColor *bg_color,
- double x, double y, double w, double h,
+ double x, double y, double width, double height,
double radius, uint8 corners)
{
CairoColor shadow;
CairoColor highlight;
+ double line_width;
+ double min = MIN (width, height);
+
+ line_width = cairo_get_line_width (cr);
/* not really sure of shading ratios... we will think */
ge_shade_color (bg_color, 0.93, &shadow);
ge_shade_color (bg_color, 1.07, &highlight);
/* highlight */
- cairo_move_to (cr, x + w + (radius * -0.2928932188), y - (radius * -0.2928932188)); /* 0.2928932... 1-sqrt(2)/2 gives middle of curve */
-
- if (corners & CR_CORNER_TOPRIGHT)
- cairo_arc (cr, x + w - radius, y + radius, radius, G_PI * 1.75, G_PI * 2);
- else
- cairo_line_to (cr, x + w, y);
+ cairo_save (cr);
- if (corners & CR_CORNER_BOTTOMRIGHT)
- cairo_arc (cr, x + w - radius, y + h - radius, radius, 0, G_PI * 0.5);
- else
- cairo_line_to (cr, x + w, y + h);
+ cairo_move_to (cr, x, y + height);
+ cairo_line_to (cr, x + min / 2.0, y + height - min / 2.0);
+ cairo_line_to (cr, x + width - min / 2.0, y + min / 2.0);
+ cairo_line_to (cr, x + width, y);
+ cairo_line_to (cr, x, y);
+ cairo_close_path (cr);
+
+ cairo_clip (cr);
- if (corners & CR_CORNER_BOTTOMLEFT)
- cairo_arc (cr, x + radius, y + h - radius, radius, G_PI * 0.5, G_PI * 0.75);
- else
- cairo_line_to (cr, x, y + h);
+ ge_cairo_rounded_rectangle (cr, x + line_width / 2.0, y + line_width / 2.0,
+ width - line_width, height - line_width,
+ radius, corners);
- ge_cairo_set_color (cr, &highlight);
+ ge_cairo_set_color (cr, &shadow);
cairo_stroke (cr);
+
+ cairo_restore (cr);
/* shadow */
- cairo_move_to (cr, x + (radius * 0.2928932188), y + h + (radius * -0.2928932188));
-
- if (corners & CR_CORNER_BOTTOMLEFT)
- cairo_arc (cr, x + radius, y + h - radius, radius, M_PI * 0.75, M_PI);
- else
- cairo_line_to (cr, x, y + h);
+ cairo_save (cr);
- if (corners & CR_CORNER_TOPLEFT)
- cairo_arc (cr, x + radius, y + radius, radius, M_PI, M_PI * 1.5);
- else
- cairo_line_to (cr, x, y);
+ cairo_move_to (cr, x, y + height);
+ cairo_line_to (cr, x + min / 2.0, y + height - min / 2.0);
+ cairo_line_to (cr, x + width - min / 2.0, y + min / 2.0);
+ cairo_line_to (cr, x + width, y);
+ cairo_line_to (cr, x + width, y + height);
+ cairo_close_path (cr);
+
+ cairo_clip (cr);
- if (corners & CR_CORNER_TOPRIGHT)
- cairo_arc (cr, x + w - radius, y + radius, radius, M_PI * 1.5, M_PI * 1.75);
- else
- cairo_line_to (cr, x + w, y);
+ ge_cairo_rounded_rectangle (cr, x + line_width / 2.0, y + line_width / 2.0,
+ width - line_width, height - line_width,
+ radius, corners);
- ge_cairo_set_color (cr, &shadow);
+ ge_cairo_set_color (cr, &highlight);
cairo_stroke (cr);
+
+ cairo_restore (cr);
}
static void
cairo_move_to (cr, x + (radius * 0.2928932188), y + h + (radius * -0.2928932188));
if (corners & CR_CORNER_BOTTOMLEFT)
- cairo_arc (cr, x + radius, y + h - radius, radius, M_PI * 0.75, M_PI);
+ cairo_arc (cr, x + radius, y + h - radius, radius, G_PI * 0.75, G_PI);
else
cairo_line_to (cr, x, y + h);
if (corners & CR_CORNER_TOPLEFT)
- cairo_arc (cr, x + radius, y + radius, radius, M_PI, M_PI * 1.5);
+ cairo_arc (cr, x + radius, y + radius, radius, G_PI, G_PI * 1.5);
else
cairo_line_to (cr, x, y);
if (corners & CR_CORNER_TOPRIGHT)
- cairo_arc (cr, x + w - radius, y + radius, radius, M_PI * 1.5, M_PI * 1.75);
+ cairo_arc (cr, x + w - radius, y + radius, radius, G_PI * 1.5, G_PI * 1.75);
else
cairo_line_to (cr, x + w, y);
cairo_stroke (cr);
}
+/* This function currently assumes that the input is translated by 0.5px! */
static void
clearlooks_glossy_draw_highlight_and_shade (cairo_t *cr,
const CairoColor *bg_color,
static void
clearlooks_glossy_draw_button (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *params,
- int x, int y, int width, int height)
+ const ClearlooksColors *colors,
+ const WidgetParameters *params,
+ int x, int y, int width, int height)
{
double xoffset = 0, yoffset = 0;
CairoColor fill = colors->bg[params->state_type];
cairo_translate (cr, x, y);
cairo_set_line_width (cr, 1.0);
- /* Shadows and Glow */
+ /* Shadows and shadow */
if (params->xthickness == 3 || params->ythickness == 3)
{
if (params->xthickness == 3)
if (params->xthickness == 3 || params->ythickness == 3)
{
- cairo_translate (cr, 0.5, 0.5);
-
- /* if (params->enable_glow && !params->active && !params->disabled) */
- if (params->prelight && params->enable_glow && !params->active)
+ /* if (params->enable_shadow && !params->active && !params->disabled) */
+ if (!params->active && (params->prelight || params->enable_shadow))
{
- /* Glow becomes a shadow to have 3d prelight buttons :) */
- CairoColor glow;
+ /* shadow becomes a shadow to have 3d prelight buttons :) */
+ CairoColor shadow;
radius = MIN (params->radius, MIN ((width - 2.0 - 2*xoffset) / 2.0 - 1.0, (height - 2.0 - 2*yoffset) / 2.0 - 1.0));
- ge_cairo_rounded_rectangle (cr, 0, 0, width-1, height-1, radius+1, params->corners);
- ge_shade_color (¶ms->parentbg, 0.96, &glow);
- ge_cairo_set_color (cr, &glow);
+ ge_cairo_rounded_rectangle (cr, 0.5, 0.5, width-1, height-1, radius+1, params->corners);
+ ge_shade_color (¶ms->parentbg, 0.96, &shadow);
+ ge_cairo_set_color (cr, &shadow);
cairo_stroke (cr);
- ge_cairo_rounded_rectangle (cr, 1, 1, width-2, height-2, radius+1, params->corners);
- ge_shade_color (¶ms->parentbg, 0.92, &glow);
- ge_cairo_set_color (cr, &glow);
+ ge_cairo_rounded_rectangle (cr, 1.5, 1.5, width-2, height-2, radius+1, params->corners);
+ ge_shade_color (¶ms->parentbg, 0.92, &shadow);
+ ge_cairo_set_color (cr, &shadow);
cairo_stroke (cr);
}
-
- /* if (!(params->enable_glow && !params->active && !params->disabled)) */
- if (!(params->prelight && params->enable_glow && !params->active))
+ else
+ {
if (!(params->disabled))
- params->style_functions->draw_inset (cr, ¶ms->parentbg, 0, 0, width-1, height-1, params->radius+1, params->corners);
+ params->style_functions->draw_inset (cr, ¶ms->parentbg, 0, 0, width, height, params->radius+1, params->corners);
else
/*Draw a lighter inset */
- clearlooks_glossy_draw_light_inset (cr, ¶ms->parentbg, 0, 0, width-1, height-1, params->radius+1, params->corners);
- cairo_translate (cr, -0.5, -0.5);
+ clearlooks_glossy_draw_light_inset (cr, ¶ms->parentbg, 0, 0, width, height, params->radius+1, params->corners);
+ }
}
clearlooks_draw_glossy_gradient (cr, xoffset+1, yoffset+1,
/* Default button highlight */
if (params->is_default && !params->active && !params->disabled)
{
- const CairoColor *glow = &colors->spot[0];
+ const CairoColor *shadow = &colors->spot[0];
double hh = (height-5)/2.0 + 1;
cairo_rectangle (cr, 3.5, 3.5, width-7, height-7);
- ge_cairo_set_color (cr, glow);
+ ge_cairo_set_color (cr, shadow);
cairo_stroke (cr);
- glow = &colors->spot[0];
+ shadow = &colors->spot[0];
cairo_move_to (cr, 2.5, 2.5+hh); cairo_rel_line_to (cr, 0, -hh);
cairo_rel_line_to (cr, width-5, 0); cairo_rel_line_to (cr, 0, hh);
- ge_cairo_set_color (cr, glow);
+ ge_cairo_set_color (cr, shadow);
cairo_stroke (cr);
hh--;
- glow = &colors->spot[1];
+ shadow = &colors->spot[1];
cairo_move_to (cr, 2.5, 2.5+hh); cairo_rel_line_to (cr, 0, hh);
cairo_rel_line_to (cr, width-5, 0); cairo_rel_line_to (cr, 0, -hh);
- ge_cairo_set_color (cr, glow);
+ ge_cairo_set_color (cr, shadow);
cairo_stroke (cr);
}
/* Border */
- if (params->is_default || (params->prelight && params->enable_glow))
+ if (params->is_default || (params->prelight && params->enable_shadow))
border_normal = colors->spot[2];
/* ge_mix_color (&border_normal, &colors->spot[2], 0.5, &border_normal); */
if (params->disabled)
cairo_set_line_width (cr, 1.0);
- /* Fill with bg color */
- ge_cairo_set_color (cr, &colors->bg[params->state_type]);
-
- cairo_rectangle (cr, x, y, width, height);
- cairo_fill (cr);
-
/* Create trough box */
ge_cairo_rounded_rectangle (cr, x+1, y+1, width-2, height-2, radius, params->corners);
ge_cairo_set_color (cr, &colors->shade[2]);
{
cairo_pattern_t *pattern;
- pattern = cairo_pattern_create_linear (0, 0, horizontal ? 0 : width, horizontal ? height : 0);
+ pattern = cairo_pattern_create_linear (0.5, 0.5, horizontal ? 0.5 : width + 1, horizontal ? height + 1 : 0.5);
cairo_pattern_add_color_stop_rgb (pattern, 0.0, c1->r, c1->g, c1->b);
cairo_pattern_add_color_stop_rgb (pattern, 1.0, c2->r, c2->g, c2->b);
- cairo_rectangle (cr, x+0.5, y+0.5, width-1, height-1);
+ cairo_rectangle (cr, x, y, width, height);
cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
clearlooks_set_mixed_color (cr, c3, c1, 0.3);
- ge_cairo_stroke_rectangle (cr, x, y, width, height);
+ ge_cairo_inner_rectangle (cr, x, y, width, height);
+ cairo_stroke (cr);
}
-#define TROUGH_SIZE 6
+#define TROUGH_SIZE 7
static void
clearlooks_glossy_draw_scale_trough (cairo_t *cr,
const ClearlooksColors *colors,
int trough_width, trough_height;
double translate_x, translate_y;
+ cairo_save (cr);
+
if (slider->horizontal)
{
- trough_width = width-3;
- trough_height = TROUGH_SIZE-2;
+ trough_width = width;
+ trough_height = TROUGH_SIZE;
- translate_x = x + 0.5;
- translate_y = y + 0.5 + (height/2) - (TROUGH_SIZE/2);
+ translate_x = x;
+ translate_y = y + (height/2) - (TROUGH_SIZE/2);
}
else
{
- trough_width = TROUGH_SIZE-2;
- trough_height = height-3;
+ trough_width = TROUGH_SIZE;
+ trough_height = height;
- translate_x = x + 0.5 + (width/2) - (TROUGH_SIZE/2);
- translate_y = y + 0.5;
+ translate_x = x + (width/2) - (TROUGH_SIZE/2);
+ translate_y = y;
}
cairo_set_line_width (cr, 1.0);
cairo_translate (cr, translate_x, translate_y);
if (!slider->fill_level)
- params->style_functions->draw_inset (cr, ¶ms->parentbg, 0, 0, trough_width+2, trough_height+2, 0, 0);
-
- cairo_translate (cr, 1, 1);
+ params->style_functions->draw_inset (cr, ¶ms->parentbg, 0, 0, trough_width, trough_height, 0, 0);
if (!slider->lower && !slider->fill_level)
clearlooks_glossy_scale_draw_gradient (cr, &colors->shade[3], /* top */
&colors->shade[2], /* bottom */
&colors->shade[6], /* border */
- 0, 0, trough_width, trough_height,
+ 1.0, 1.0, trough_width - 2, trough_height - 2,
slider->horizontal);
else
clearlooks_glossy_scale_draw_gradient (cr, &colors->spot[1], /* top */
&colors->spot[0], /* bottom */
&colors->spot[2], /* border */
- 0, 0, trough_width, trough_height,
+ 1.0, 1.0, trough_width - 2, trough_height - 2,
slider->horizontal);
+ cairo_restore (cr);
}
static void
double radius;
double strip_size;
+ double length;
radius = MIN (params->radius, MIN ((width - 2.0) / 2.0, (height - 2.0) / 2.0));
if (tab->gap_side == CL_GAP_TOP || tab->gap_side == CL_GAP_BOTTOM)
{
height += 3.0;
+ length = height;
strip_size = 2.0/height; /* 2 pixel high strip */
if (tab->gap_side == CL_GAP_TOP)
else
{
width += 3.0;
+ length = width;
strip_size = 2.0/width;
if (tab->gap_side == CL_GAP_LEFT)
shadow.shadow = CL_SHADOW_OUT;
shadow.corners = params->corners;
+ /* This is the only usage of clearlooks_glossy_draw_highlight_and_shade,
+ * the function assumes currently that the input is translated by 0.5 px. */
clearlooks_glossy_draw_highlight_and_shade (cr, &colors->bg[0], &shadow,
width,
height, radius);
{
CairoColor shadow, hilight, f1, f2;
- pattern = cairo_pattern_create_linear (tab->gap_side == CL_GAP_LEFT ? width-1 : 0,
- tab->gap_side == CL_GAP_TOP ? height-2 : 1,
- tab->gap_side == CL_GAP_RIGHT ? width : 0,
- tab->gap_side == CL_GAP_BOTTOM ? height : 0);
+ switch (tab->gap_side)
+ {
+ case CL_GAP_TOP:
+ pattern = cairo_pattern_create_linear (0, height-2, 0, 0);
+ break;
+ case CL_GAP_BOTTOM:
+ pattern = cairo_pattern_create_linear (0, 1, 0, height);
+ break;
+ case CL_GAP_LEFT:
+ pattern = cairo_pattern_create_linear (width-2, 0, 1, 0);
+ break;
+ case CL_GAP_RIGHT:
+ pattern = cairo_pattern_create_linear (1, 0, width-2, 0);
+ break;
+ default:
+ pattern = NULL;
+ }
ge_cairo_rounded_rectangle (cr, 0, 0, width-1, height-1, radius, params->corners);
ge_shade_color (fill, 1.06, &f2);
cairo_pattern_add_color_stop_rgb (pattern, 0.0, hilight.r, hilight.g, hilight.b);
- cairo_pattern_add_color_stop_rgb (pattern, 1.0/height, hilight.r, hilight.g, hilight.b);
- cairo_pattern_add_color_stop_rgb (pattern, 1.0/height, f1.r, f1.g, f1.b);
+ cairo_pattern_add_color_stop_rgb (pattern, 1.0/length, hilight.r, hilight.g, hilight.b);
+ cairo_pattern_add_color_stop_rgb (pattern, 1.0/length, f1.r, f1.g, f1.b);
cairo_pattern_add_color_stop_rgb (pattern, 0.45, f2.r, f2.g, f2.b);
cairo_pattern_add_color_stop_rgb (pattern, 0.45, fill->r, fill->g, fill->b);
cairo_pattern_add_color_stop_rgb (pattern, 1.0, shadow.r, shadow.g, shadow.b);
else
{
/* Draw shade */
- pattern = cairo_pattern_create_linear (tab->gap_side == CL_GAP_LEFT ? width-2 : 0,
- tab->gap_side == CL_GAP_TOP ? height-2 : 0,
- tab->gap_side == CL_GAP_RIGHT ? width : 0,
- tab->gap_side == CL_GAP_BOTTOM ? height : 0);
+ switch (tab->gap_side)
+ {
+ case CL_GAP_TOP:
+ pattern = cairo_pattern_create_linear (0, height-2, 0, 0);
+ break;
+ case CL_GAP_BOTTOM:
+ pattern = cairo_pattern_create_linear (0, 0, 0, height);
+ break;
+ case CL_GAP_LEFT:
+ pattern = cairo_pattern_create_linear (width-2, 0, 0, 0);
+ break;
+ case CL_GAP_RIGHT:
+ pattern = cairo_pattern_create_linear (0, 0, width, 0);
+ break;
+ default:
+ pattern = NULL;
+ }
ge_cairo_rounded_rectangle (cr, 0, 0, width-1, height-1, radius, params->corners);
}
else
{
- pattern = cairo_pattern_create_linear (tab->gap_side == CL_GAP_LEFT ? width-2 : 2,
- tab->gap_side == CL_GAP_TOP ? height-2 : 2,
- tab->gap_side == CL_GAP_RIGHT ? width : 2,
- tab->gap_side == CL_GAP_BOTTOM ? height : 2);
+ switch (tab->gap_side)
+ {
+ case CL_GAP_TOP:
+ pattern = cairo_pattern_create_linear (2, height-2, 2, 2);
+ break;
+ case CL_GAP_BOTTOM:
+ pattern = cairo_pattern_create_linear (2, 2, 2, height);
+ break;
+ case CL_GAP_LEFT:
+ pattern = cairo_pattern_create_linear (width-2, 2, 2, 2);
+ break;
+ case CL_GAP_RIGHT:
+ pattern = cairo_pattern_create_linear (2, 2, width, 2);
+ break;
+ default:
+ pattern = NULL;
+ }
cairo_pattern_add_color_stop_rgb (pattern, 0.0, stripe_border->r, stripe_border->g, stripe_border->b);
cairo_pattern_add_color_stop_rgb (pattern, 0.8, border->r, border->g, border->b);
cairo_set_line_width (cr, 1.0);
cairo_translate (cr, x, y);
- cairo_translate (cr, -0.5, -0.5);
-
ge_shade_color (&colors->bg[params->state_type], 1.0, &fill);
if (params->prelight)
ge_shade_color (&fill, 1.1, &fill);
if (!slider->horizontal)
ge_cairo_exchange_axis (cr, &x, &y, &width, &height);
- cairo_translate (cr, x+0.5, y+0.5);
-
- params->style_functions->draw_shadow (cr, colors, radius, width-1, height-1);
+ cairo_translate (cr, x, y);
+ params->style_functions->draw_shadow (cr, colors, radius, width, height);
params->style_functions->draw_slider (cr, colors, params, 1, 1, width-2, height-2);
}
cairo_fill (cr);
cairo_pattern_destroy (pattern);
- cairo_translate (cr, 0.5, 0.5);
- cairo_translate (cr, -0.5, -0.5);
-
- ge_cairo_rounded_rectangle (cr, 0.5, 0.5, width-1, height-1, radius, corners);
+ ge_cairo_inner_rounded_rectangle (cr, 0, 0, width, height, radius, corners);
clearlooks_set_mixed_color (cr, border, &fill, 0.2);
if (widget->prelight)
ge_cairo_set_color (cr, &colors->spot[2]);
cairo_stroke (cr);
- cairo_translate (cr, 0.5, 0.5);
shadow.shadow = CL_SHADOW_OUT;
shadow.corners = corners;
}
cairo_pattern_destroy (pattern);
/* Draw highlight */
- if (header->order == CL_ORDER_FIRST)
+ if (header->order & CL_ORDER_FIRST)
{
cairo_move_to (cr, 0.5, height-1);
cairo_line_to (cr, 0.5, 0.5);
cairo_stroke (cr);
/* Draw resize grip */
- if ((params->ltr && header->order != CL_ORDER_LAST) ||
- (!params->ltr && header->order != CL_ORDER_FIRST) || header->resizable)
+ if ((params->ltr && !(header->order & CL_ORDER_LAST)) ||
+ (!params->ltr && !(header->order & CL_ORDER_FIRST)) || header->resizable)
{
SeparatorParameters separator;
separator.horizontal = FALSE;
cairo_pattern_t *pt;
gboolean inconsistent;
gboolean draw_bullet = (checkbox->shadow_type == GTK_SHADOW_IN);
+ gdouble w, h, cx, cy, radius;
+
+ w = (gdouble) width;
+ h = (gdouble) height;
+ cx = width / 2.0;
+ cy = height / 2.0;
+ radius = MIN (width, height) / 2.0;
inconsistent = (checkbox->shadow_type == GTK_SHADOW_ETCHED_IN);
draw_bullet |= inconsistent;
ge_shade_color (&widget->parentbg, 0.9, &shadow);
ge_shade_color (&widget->parentbg, 1.1, &highlight);
- pt = cairo_pattern_create_linear (0, 0, 13, 13);
+ pt = cairo_pattern_create_linear (0, 0, radius * 2.0, radius * 2.0);
cairo_pattern_add_color_stop_rgb (pt, 0.0, shadow.r, shadow.b, shadow.g);
cairo_pattern_add_color_stop_rgba (pt, 0.5, shadow.r, shadow.b, shadow.g, 0.5);
cairo_pattern_add_color_stop_rgba (pt, 0.5, highlight.r, highlight.g, highlight.b, 0.5);
cairo_translate (cr, x, y);
- cairo_set_line_width (cr, 2);
- cairo_arc (cr, 7, 7, 6, 0, G_PI*2);
+ cairo_set_line_width (cr, MAX (1.0, floor (radius/3)));
+ cairo_arc (cr, ceil (cx), ceil (cy), floor (radius - 0.1), 0, G_PI*2);
cairo_set_source (cr, pt);
cairo_stroke (cr);
cairo_pattern_destroy (pt);
- cairo_set_line_width (cr, 1);
+ cairo_set_line_width (cr, MAX (1.0, floor (radius/6)));
- cairo_arc (cr, 7, 7, 5.5, 0, G_PI*2);
+ cairo_arc (cr, ceil (cx), ceil (cy), MAX (1.0, ceil (radius) - 1.5), 0, G_PI*2);
if (!widget->disabled)
{
if (inconsistent)
{
cairo_set_line_cap(cr, CAIRO_LINE_CAP_ROUND);
- cairo_set_line_width (cr, 4);
+ cairo_set_line_width (cr, ceil (radius * 2 / 3));
- cairo_move_to(cr, 5, 7);
- cairo_line_to(cr, 9, 7);
+ cairo_move_to (cr, ceil (cx - radius/3.0), ceil (cy));
+ cairo_line_to (cr, ceil (cx + radius/3.0), ceil (cy));
ge_cairo_set_color (cr, dot);
cairo_stroke (cr);
}
else
{
- cairo_arc (cr, 7, 7, 3, 0, G_PI*2);
+ cairo_arc (cr, ceil (cx), ceil (cy), floor (radius/2.0), 0, G_PI*2);
ge_cairo_set_color (cr, dot);
cairo_fill (cr);
- cairo_arc (cr, 6, 6, 1, 0, G_PI*2);
+ cairo_arc (cr, floor (cx - radius/10.0), floor (cy - radius/10.0), floor (radius/6.0), 0, G_PI*2);
cairo_set_source_rgba (cr, highlight.r, highlight.g, highlight.b, 0.5);
cairo_fill (cr);
}
if (widget->xthickness > 2 && widget->ythickness > 2)
{
- widget->style_functions->draw_inset (cr, &widget->parentbg, 0.5, 0.5,
- width-1, height-1, (widget->radius > 0)? 1 : 0, CR_CORNER_ALL);
+ widget->style_functions->draw_inset (cr, &widget->parentbg, 0, 0,
+ width, height, (widget->radius > 0)? 1 : 0, CR_CORNER_ALL);
/* Draw the rectangle for the checkbox itself */
ge_cairo_rounded_rectangle (cr, 1.5, 1.5,
}
void
-clearlooks_register_style_glossy (ClearlooksStyleFunctions *functions)
+clearlooks_register_style_glossy (ClearlooksStyleFunctions *functions, ClearlooksStyleConstants *constants)
{
functions->draw_inset = clearlooks_glossy_draw_inset;
functions->draw_button = clearlooks_glossy_draw_button;
#define SHADE_CENTER_TOP 1.02
#define SHADE_BOTTOM 0.94
-/* Topleft highlight */
-#define TOPLEFT_HIGHLIGHT_SHADE 1.3
-#define TOPLEFT_HIGHLIGHT_ALPHA 0.4
-
/* Listview */
#define LISTVIEW_SHADE_TOP 1.06
#define LISTVIEW_SHADE_CENTER_TOP 1.02
#define TOOLBAR_SHADE_CENTER_TOP 1.01
#define TOOLBAR_SHADE_BOTTOM 0.97
-
static void
clearlooks_draw_gummy_gradient (cairo_t *cr,
double x, double y, int width, int height,
}
static void
-clearlooks_set_mixed_color (cairo_t *cr,
- const CairoColor *color1,
- const CairoColor *color2,
+clearlooks_set_mixed_color (cairo_t *cr,
+ const CairoColor *color1,
+ const CairoColor *color2,
gdouble mix_factor)
{
CairoColor composite;
}
static void
-clearlooks_gummy_draw_highlight_and_shade (cairo_t *cr,
+clearlooks_gummy_draw_highlight_and_shade (cairo_t *cr,
const CairoColor *bg_color,
const ShadowParameters *params,
int width, int height, gdouble radius)
cairo_set_source_rgba (cr, highlight.r, highlight.g, highlight.b, 0.5);
else
cairo_set_source_rgba (cr, shadow.r, shadow.g, shadow.b, 0.5);
-
+
cairo_stroke (cr);
/* Bottom/Right highlight -- this includes the corners */
cairo_restore (cr);
}
-static void
-clearlooks_gummy_draw_top_left_highlight (cairo_t *cr, const CairoColor *color,
- const WidgetParameters *params,
- int width, int height, gdouble radius)
-{
- CairoColor hilight;
-
- double light_top = params->ythickness-1,
- light_bottom = height - params->ythickness - 1,
- light_left = params->xthickness-1,
- light_right = width - params->xthickness - 1;
-
- ge_shade_color (color, TOPLEFT_HIGHLIGHT_SHADE, &hilight);
- cairo_move_to (cr, light_left, light_bottom - (int)radius/2);
-
- ge_cairo_rounded_corner (cr, light_left, light_top, radius, params->corners & CR_CORNER_TOPLEFT);
-
- cairo_line_to (cr, light_right - (int)radius/2, light_top);
- cairo_set_source_rgba (cr, hilight.r, hilight.g, hilight.b, TOPLEFT_HIGHLIGHT_ALPHA);
- cairo_stroke (cr);
-}
-
static void
clearlooks_gummy_draw_button (cairo_t *cr,
const ClearlooksColors *colors,
cairo_translate (cr, x, y);
cairo_set_line_width (cr, 1.0);
- /* Shadows and Glow */
- if (params->xthickness == 3 || params->ythickness == 3)
- {
- if (params->xthickness == 3)
- xoffset = 1;
- if (params->ythickness == 3)
- yoffset = 1;
- }
+ if (params->xthickness == 3)
+ xoffset = 1;
+ if (params->ythickness == 3)
+ yoffset = 1;
radius = MIN (params->radius, MIN ((width - 2.0 - 2*xoffset) / 2.0, (height - 2.0 - 2*yoffset) / 2.0));
if (params->xthickness == 3 || params->ythickness == 3)
{
- cairo_translate (cr, 0.5, 0.5);
-
- if (params->enable_glow && !params->active && !params->disabled && !params->is_default)
+ if (params->enable_shadow && !params->active && !params->disabled && !params->is_default)
{
CairoColor shadow;
radius = MIN (params->radius, MIN ((width - 2.0 - 2*xoffset) / 2.0 - 1.0, (height - 2.0 - 2*yoffset) / 2.0 - 1.0));
- ge_cairo_rounded_rectangle (cr, 0, 0, width-1, height-1, radius+1, params->corners);
+ ge_cairo_inner_rounded_rectangle (cr, 0, 0, width, height, radius+1, params->corners);
ge_shade_color (¶ms->parentbg, 0.97, &shadow);
ge_cairo_set_color (cr, &shadow);
cairo_stroke (cr);
- ge_cairo_rounded_rectangle (cr, 1, 1, width-2, height-2, radius+1, params->corners);
+ ge_cairo_inner_rounded_rectangle (cr, 1, 1, width-1, height-1, radius+1, params->corners);
ge_shade_color (¶ms->parentbg, 0.93, &shadow);
ge_cairo_set_color (cr, &shadow);
cairo_stroke (cr);
radius = MIN (params->radius, MIN ((width - 2.0 - 2*xoffset) / 2.0 - 1.0, (height - 2.0 - 2*yoffset) / 2.0 - 1.0));
- ge_cairo_rounded_rectangle (cr, 0, 0, width-1, height-1, radius+1, params->corners);
+ ge_cairo_inner_rounded_rectangle (cr, 0, 0, width, height, radius+1, params->corners);
clearlooks_set_mixed_color (cr, ¶ms->parentbg, &shadow, 0.5);
cairo_stroke (cr);
}
- if (!(params->enable_glow && !params->active && !params->disabled))
- params->style_functions->draw_inset (cr, ¶ms->parentbg, 0, 0, width-1, height-1, params->radius+1, params->corners);
- cairo_translate (cr, -0.5, -0.5);
+ if (!(params->enable_shadow && !params->active && !params->disabled))
+ params->style_functions->draw_inset (cr, ¶ms->parentbg, 0, 0, width, height, params->radius+1, params->corners);
}
- clearlooks_draw_gummy_gradient (cr, xoffset+1, yoffset+1,
- width-(xoffset*2)-2, height-(yoffset*2)-2,
- &fill, params->disabled, radius, params->corners);
+ clearlooks_draw_gummy_gradient (cr, xoffset+1, yoffset+1,
+ width-(xoffset*2)-2, height-(yoffset*2)-2,
+ &fill, params->disabled, radius, params->corners);
/* Pressed button shadow */
if (params->active)
cairo_save (cr);
- ge_cairo_rounded_rectangle (cr, xoffset+1, yoffset+1, width-(xoffset*2)-2, height, radius,
+ ge_cairo_rounded_rectangle (cr, xoffset+1, yoffset+1, width-(xoffset*2)-2, height, radius,
params->corners & (CR_CORNER_TOPLEFT | CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMLEFT));
cairo_clip (cr);
cairo_rectangle (cr, xoffset+1, yoffset+1, width-(xoffset*2)-2, 3);
}
/* Border */
- if (params->is_default) /* || (params->prelight && params->enable_glow)) */
+ if (params->is_default) /* || (params->prelight && params->enable_shadow)) */
border_normal = colors->spot[2];
if (params->disabled)
ge_cairo_set_color (cr, &border_disabled);
else
clearlooks_set_mixed_color (cr, &border_normal, &fill, 0.2);
ge_cairo_rounded_rectangle (cr, xoffset + 0.5, yoffset + 0.5,
- width-(xoffset*2)-1, height-(yoffset*2)-1,
- radius, params->corners);
+ width-(xoffset*2)-1, height-(yoffset*2)-1,
+ radius, params->corners);
cairo_stroke (cr);
if (!params->active)
{
- cairo_translate (cr, 0.5, 0.5);
- clearlooks_gummy_draw_top_left_highlight (cr, &fill, params, width, height, radius);
+ params->style_functions->draw_top_left_highlight (cr, &fill, params, 1+xoffset, 1+xoffset,
+ width-(1+xoffset)*2, height-(1+xoffset)*2,
+ radius, params->corners);
}
cairo_restore (cr);
}
if (params->focus)
border = colors->spot[2];
- cairo_translate (cr, x+0.5, y+0.5);
- cairo_set_line_width (cr, 1.0);
+ cairo_save (cr);
- /* Fill the background to get the correct corners. */
- cairo_rectangle (cr, -0.5, -0.5, width, height);
- ge_cairo_set_color (cr, ¶ms->parentbg);
- cairo_fill (cr);
+ cairo_translate (cr, x, y);
+ cairo_set_line_width (cr, 1.0);
- /* Fill with the base color, because it was just cleared above */
- cairo_rectangle (cr, 1.5, 1.5, width-4, height-4);
+ /* Now fill the area we want to be base[NORMAL]. */
+ ge_cairo_rounded_rectangle (cr, 2, 2, width-4, height-4, MAX(0, radius-1), params->corners);
ge_cairo_set_color (cr, base);
cairo_fill (cr);
- params->style_functions->draw_inset (cr, ¶ms->parentbg, 0, 0, width-1, height-1, radius+1, params->corners);
+ params->style_functions->draw_inset (cr, ¶ms->parentbg, 0, 0, width, height, radius+1, params->corners);
/* Draw the inner shadow */
if (params->focus)
{
- /* ge_cairo_rounded_rectangle (cr, 2, 2, width-5, height-5, RADIUS-1, params->corners); */
- ge_cairo_set_color (cr, &colors->spot[0]);
- ge_cairo_stroke_rectangle (cr, 2, 2, width-5, height-5);
+ clearlooks_set_mixed_color (cr, base, &colors->spot[1], 0.5);
+ ge_cairo_inner_rounded_rectangle (cr, 2, 2, width-4, height-4, MAX(0, radius-1), params->corners);
+ cairo_stroke (cr);
}
else
{
- CairoColor shadow;
+ CairoColor shadow;
ge_shade_color (&border, 0.92, &shadow);
cairo_set_source_rgba (cr, shadow.r, shadow.g, shadow.b, params->disabled ? 0.09 : 0.18);
- /*
- cairo_move_to (cr, 2, height-3);
- cairo_arc (cr, params->xthickness+RADIUS-1, params->ythickness+RADIUS-1, RADIUS, G_PI, 270*(G_PI/180));
- cairo_line_to (cr, width-3, 2);
- */
- cairo_move_to (cr, 2, height-3);
- cairo_line_to (cr, 2, 2);
- cairo_line_to (cr, width-3, 2);
+
+ cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT);
+ cairo_move_to (cr, 2.5, height-radius);
+ cairo_arc (cr, 2.5+MAX(0, radius-1), 2.5+MAX(0, radius-1), MAX(0, radius-1), G_PI, 270*(G_PI/180));
+ cairo_line_to (cr, width-radius, 2.5);
cairo_stroke (cr);
}
- ge_cairo_rounded_rectangle (cr, 1, 1, width-3, height-3, radius, params->corners);
+ ge_cairo_inner_rounded_rectangle (cr, 1, 1, width-2, height-2, radius, params->corners);
ge_cairo_set_color (cr, &border);
cairo_stroke (cr);
+
+ cairo_restore (cr);
}
static void
cairo_set_line_width (cr, 1.0);
- /* Fill with bg color */
- ge_cairo_set_color (cr, &colors->bg[params->state_type]);
-
- cairo_rectangle (cr, x, y, width, height);
- cairo_fill (cr);
-
/* Create trough box */
ge_cairo_rounded_rectangle (cr, x+1, y+1, width-2, height-2, radius, params->corners);
ge_cairo_set_color (cr, &colors->shade[2]);
const ProgressBarParameters *progressbar,
int x, int y, int width, int height, gint offset)
{
- boolean is_horizontal = progressbar->orientation < 2;
- double tile_pos = 0;
- double stroke_width;
- double radius;
- int x_step;
+ boolean is_horizontal = progressbar->orientation < 2;
+ double tile_pos = 0;
+ double stroke_width;
+ double radius;
+ int x_step;
cairo_pattern_t *pattern;
CairoColor shade1, shade2, shade3;
cairo_paint (cr);
cairo_pattern_destroy (pattern);
- /* Draw the Strokes */
+ /* Draw the strokes */
while (tile_pos <= width+x_step)
{
cairo_move_to (cr, stroke_width/2-x_step, 0);
cairo_line_to (cr, stroke_width-x_step, 0);
cairo_line_to (cr, stroke_width/2-x_step, height);
cairo_line_to (cr, -x_step, height);
-
+
cairo_translate (cr, stroke_width, 0);
tile_pos += stroke_width;
}
ge_shade_color (fill, in? 0.95 : 1.1, &f1);
ge_shade_color (fill, in? 1.05 : 0.9, &f2);
- pattern = cairo_pattern_create_linear (0, 0, horizontal ? 0 : width, horizontal ? height : 0);
+ pattern = cairo_pattern_create_linear (0.5, 0.5, horizontal ? 0.5 : width + 1.0, horizontal ? height + 1.0 : 0.5);
cairo_pattern_add_color_stop_rgba (pattern, 0.0, f1.r, f1.g, f1.b, f1.a);
cairo_pattern_add_color_stop_rgba (pattern, 1.0, f2.r, f2.g, f2.b, f2.a);
- cairo_rectangle (cr, x+0.5, y+0.5, width-1, height-1);
+ cairo_rectangle (cr, x, y, width, height);
cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
clearlooks_set_mixed_color (cr, border, fill, 0.2);
- ge_cairo_stroke_rectangle (cr, x, y, width, height);
+ ge_cairo_inner_rectangle (cr, x, y, width, height);
+ cairo_stroke (cr);
}
-#define TROUGH_SIZE 6
+#define TROUGH_SIZE 7
static void
clearlooks_gummy_draw_scale_trough (cairo_t *cr,
const ClearlooksColors *colors,
const SliderParameters *slider,
int x, int y, int width, int height)
{
- int trough_width, trough_height;
- double translate_x, translate_y;
+ int trough_width, trough_height;
+ double translate_x, translate_y;
+ CairoColor fill, border;
+ gboolean in;
+
+ cairo_save (cr);
if (slider->horizontal)
{
- trough_width = width-3;
- trough_height = TROUGH_SIZE-2;
+ trough_width = width;
+ trough_height = TROUGH_SIZE;
- translate_x = x + 0.5;
- translate_y = y + 0.5 + (height/2) - (TROUGH_SIZE/2);
+ translate_x = x;
+ translate_y = y + (height/2) - (TROUGH_SIZE/2);
}
else
{
- trough_width = TROUGH_SIZE-2;
- trough_height = height-3;
+ trough_width = TROUGH_SIZE;
+ trough_height = height;
- translate_x = x + 0.5 + (width/2) - (TROUGH_SIZE/2);
- translate_y = y + 0.5;
+ translate_x = x + (width/2) - (TROUGH_SIZE/2);
+ translate_y = y;
}
cairo_set_line_width (cr, 1.0);
cairo_translate (cr, translate_x, translate_y);
if (!slider->fill_level)
- params->style_functions->draw_inset (cr, ¶ms->parentbg, 0, 0, trough_width+2, trough_height+2, 0, 0);
-
- cairo_translate (cr, 1, 1);
+ params->style_functions->draw_inset (cr, ¶ms->parentbg, 0, 0, trough_width, trough_height, 0, 0);
if (!slider->lower && !slider->fill_level)
- clearlooks_gummy_scale_draw_gradient (cr,
- &colors->shade[2], /* bottom */
- &colors->shade[6], /* border */
- 0, 0, trough_width, trough_height,
- slider->horizontal, TRUE);
+ {
+ ge_shade_color (¶ms->parentbg, 0.896, &fill);
+ border = colors->shade[6];
+ in = TRUE;
+ }
else if (!slider->fill_level)
- clearlooks_gummy_scale_draw_gradient (cr,
- &colors->spot[1], /* bottom */
- &colors->spot[2], /* border */
- 0, 0, trough_width, trough_height,
- slider->horizontal, FALSE);
- else {
- CairoColor c1 = colors->spot[1];
- CairoColor c2 = colors->spot[2];
-
- c1.a = 0.25;
- c2.a = 0.25;
-
- clearlooks_gummy_scale_draw_gradient (cr,
- &c1, /* bottom */
- &c2, /* border */
- 0, 0, trough_width, trough_height,
- slider->horizontal, FALSE);
+ {
+ fill = colors->spot[1];
+ border = colors->spot[2];
+ in = FALSE;
}
+ else
+ {
+ fill = colors->spot[1];
+ border = colors->spot[2];
+ fill.a = 0.25;
+ border.a = 0.25;
+
+ in = FALSE;
+ }
+
+ clearlooks_gummy_scale_draw_gradient (cr,
+ &fill,
+ &border,
+ 1, 1, trough_width - 2, trough_height - 2,
+ slider->horizontal, in);
+
+ cairo_restore (cr);
}
static void
const TabParameters *tab,
int x, int y, int width, int height)
{
+ const CairoColor *border = &colors->shade[5];
+ const CairoColor *stripe_fill = &colors->spot[1];
+ const CairoColor *stripe_border = &colors->spot[2];
+ const CairoColor *fill;
- const CairoColor *border = &colors->shade[5];
- const CairoColor *stripe_fill = &colors->spot[1];
- const CairoColor *stripe_border = &colors->spot[2];
- const CairoColor *fill;
+ cairo_pattern_t *pattern = NULL;
- cairo_pattern_t *pattern;
+ double radius;
+ double stripe_size = 2.0;
+ double stripe_fill_size;
+ double stripe_border_pos;
- double radius;
- double strip_size;
+ gboolean horizontal = FALSE;
radius = MIN (params->radius, MIN ((width - 2.0) / 2.0, (height - 2.0) / 2.0));
/* And calculate the strip size too, while you're at it */
if (tab->gap_side == CL_GAP_TOP || tab->gap_side == CL_GAP_BOTTOM)
{
+ if (params->ythickness == 3)
+ stripe_size = 3.0;
+
height += 3.0;
- strip_size = 2.0/height; /* 2 pixel high strip */
+ stripe_fill_size = (tab->gap_side == CL_GAP_TOP ? stripe_size/height : stripe_size/(height-2));
+ stripe_border_pos = (tab->gap_side == CL_GAP_TOP ? (stripe_size+1.0)/height : (stripe_size+1.0)/(height-2));
+
+ horizontal = TRUE;
if (tab->gap_side == CL_GAP_TOP)
cairo_translate (cr, 0.0, -3.0); /* gap at the other side */
}
else
{
+ if (params->xthickness == 3)
+ stripe_size = 3.0;
+
width += 3.0;
- strip_size = 2.0/width;
+ stripe_fill_size = (tab->gap_side == CL_GAP_LEFT ? stripe_size/width : stripe_size/(width-2));
+ stripe_border_pos = (tab->gap_side == CL_GAP_LEFT ? (stripe_size+1.0)/width : (stripe_size+1.0)/(width-2));
- if (tab->gap_side == CL_GAP_LEFT)
+ if (tab->gap_side == CL_GAP_LEFT)
cairo_translate (cr, -3.0, 0.0); /* gap at the other side */
}
shadow.corners = params->corners;
clearlooks_gummy_draw_highlight_and_shade (cr, &colors->bg[0], &shadow,
- width, height, radius);
+ width, height, radius);
}
if (params->active)
CairoColor hilight;
CairoColor shade1, shade2, shade3;
- pattern = cairo_pattern_create_linear (tab->gap_side == CL_GAP_LEFT ? width-1 : 0,
- tab->gap_side == CL_GAP_TOP ? height-2 : 1,
- tab->gap_side == CL_GAP_RIGHT ? width : 0,
- tab->gap_side == CL_GAP_BOTTOM ? height : 0);
-
- ge_cairo_rounded_rectangle (cr, 0, 0, width-1, height-1, radius, params->corners);
-
- ge_shade_color (fill, 1.14, &hilight);
+ ge_shade_color (fill, 1.15, &hilight);
ge_shade_color (fill, SHADE_TOP, &shade1);
ge_shade_color (fill, SHADE_CENTER_TOP, &shade2);
ge_shade_color (fill, SHADE_BOTTOM, &shade3);
- cairo_pattern_add_color_stop_rgb (pattern, 0.0, hilight.r, hilight.g, hilight.b);
- cairo_pattern_add_color_stop_rgb (pattern, 1.0/height, hilight.r, hilight.g, hilight.b);
- cairo_pattern_add_color_stop_rgb (pattern, 1.0/height, shade1.r, shade1.g, shade1.b);
- cairo_pattern_add_color_stop_rgb (pattern, 0.45, shade2.r, shade2.g, shade2.b);
- cairo_pattern_add_color_stop_rgb (pattern, 0.45, fill->r, fill->g, fill->b);
- cairo_pattern_add_color_stop_rgb (pattern, 1.0, shade3.r, shade3.g, shade3.b);
+ switch (tab->gap_side)
+ {
+ case CL_GAP_TOP:
+ pattern = cairo_pattern_create_linear (0, height-2, 0, 0);
+ break;
+ case CL_GAP_BOTTOM:
+ pattern = cairo_pattern_create_linear (0, 1, 0, height);
+ break;
+ case CL_GAP_LEFT:
+ pattern = cairo_pattern_create_linear (width-2, 0, 1, 0);
+ break;
+ case CL_GAP_RIGHT:
+ pattern = cairo_pattern_create_linear (1, 0, width-2, 0);
+ break;
+ }
+
+ ge_cairo_rounded_rectangle (cr, 0, 0, width-1, height-1, radius, params->corners);
+
+ cairo_pattern_add_color_stop_rgb (pattern, 0.0, hilight.r, hilight.g, hilight.b);
+ cairo_pattern_add_color_stop_rgb (pattern, 1.0/(horizontal ? height : width), hilight.r, hilight.g, hilight.b);
+ cairo_pattern_add_color_stop_rgb (pattern, 1.0/(horizontal ? height : width), shade1.r, shade1.g, shade1.b);
+ cairo_pattern_add_color_stop_rgb (pattern, 0.45, shade2.r, shade2.g, shade2.b);
+ cairo_pattern_add_color_stop_rgb (pattern, 0.45, fill->r, fill->g, fill->b);
+ cairo_pattern_add_color_stop_rgb (pattern, 1.0, shade3.r, shade3.g, shade3.b);
cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
}
else
{
- /* Draw shade */
- pattern = cairo_pattern_create_linear (tab->gap_side == CL_GAP_LEFT ? width-2 : 0,
- tab->gap_side == CL_GAP_TOP ? height-2 : 0,
- tab->gap_side == CL_GAP_RIGHT ? width : 0,
- tab->gap_side == CL_GAP_BOTTOM ? height : 0);
+ CairoColor shade1;
+
+ ge_shade_color (fill, SHADE_TOP, &shade1);
+
+ switch (tab->gap_side)
+ {
+ case CL_GAP_TOP:
+ pattern = cairo_pattern_create_linear (0, height-2, 0, 0);
+ break;
+ case CL_GAP_BOTTOM:
+ pattern = cairo_pattern_create_linear (0, 0, 0, height);
+ break;
+ case CL_GAP_LEFT:
+ pattern = cairo_pattern_create_linear (width-2, 0, 0, 0);
+ break;
+ case CL_GAP_RIGHT:
+ pattern = cairo_pattern_create_linear (0, 0, width, 0);
+ break;
+ }
ge_cairo_rounded_rectangle (cr, 0, 0, width-1, height-1, radius, params->corners);
- cairo_pattern_add_color_stop_rgba (pattern, 0.0, stripe_fill->r, stripe_fill->g, stripe_fill->b, 0.5);
+ cairo_pattern_add_color_stop_rgba (pattern, 0.0, stripe_fill->r, stripe_fill->g, stripe_fill->b, 0.6);
+ /* cairo_pattern_add_color_stop_rgba (pattern, 1.0/(horizontal ? height : width), stripe_fill->r, stripe_fill->g, stripe_fill->b, 0.34);
+ cairo_pattern_add_color_stop_rgba (pattern, 1.0/(horizontal ? height : width), stripe_fill->r, stripe_fill->g, stripe_fill->b, 0.5); */
+ cairo_pattern_add_color_stop_rgb (pattern, stripe_fill_size, stripe_fill->r, stripe_fill->g, stripe_fill->b);
+ cairo_pattern_add_color_stop_rgba (pattern, stripe_fill_size, stripe_border->r, stripe_border->g, stripe_border->b, 0.72);
+ cairo_pattern_add_color_stop_rgba (pattern, stripe_border_pos, stripe_border->r, stripe_border->g, stripe_border->b, 0.72);
+ cairo_pattern_add_color_stop_rgb (pattern, stripe_border_pos, shade1.r, shade1.g, shade1.b);
cairo_pattern_add_color_stop_rgba (pattern, 0.8, fill->r, fill->g, fill->b, 0.0);
cairo_set_source (cr, pattern);
cairo_fill (cr);
}
else
{
- pattern = cairo_pattern_create_linear (tab->gap_side == CL_GAP_LEFT ? width-2 : 2,
- tab->gap_side == CL_GAP_TOP ? height-2 : 2,
- tab->gap_side == CL_GAP_RIGHT ? width : 2,
- tab->gap_side == CL_GAP_BOTTOM ? height : 2);
+ switch (tab->gap_side)
+ {
+ case CL_GAP_TOP:
+ pattern = cairo_pattern_create_linear (2, height-2, 2, 2);
+ break;
+ case CL_GAP_BOTTOM:
+ pattern = cairo_pattern_create_linear (2, 2, 2, height);
+ break;
+ case CL_GAP_LEFT:
+ pattern = cairo_pattern_create_linear (width-2, 2, 2, 2);
+ break;
+ case CL_GAP_RIGHT:
+ pattern = cairo_pattern_create_linear (2, 2, width, 2);
+ break;
+ }
cairo_pattern_add_color_stop_rgb (pattern, 0.0, stripe_border->r, stripe_border->g, stripe_border->b);
cairo_pattern_add_color_stop_rgb (pattern, 0.8, border->r, border->g, border->b);
cairo_stroke (cr);
cairo_pattern_destroy (pattern);
}
+
+ /* In current GTK+ focus and active cannot happen together, but we are robust against it. */
+ if (params->focus && !params->active)
+ {
+ CairoColor focus_fill = tab->focus.color;
+ CairoColor fill_shade1, fill_shade2, fill_shade3;
+ CairoColor focus_border;
+
+ double focus_inset_x = ((tab->gap_side == CL_GAP_TOP || tab->gap_side == CL_GAP_BOTTOM) ? 4 : stripe_size + 3);
+ double focus_inset_y = ((tab->gap_side == CL_GAP_TOP || tab->gap_side == CL_GAP_BOTTOM) ? stripe_size + 3 : 4);
+ double border_alpha = 0.54;
+ double fill_alpha = 0.17;
+
+ ge_shade_color (&focus_fill, 0.65, &focus_border);
+ ge_shade_color (&focus_fill, 1.18, &fill_shade1);
+ ge_shade_color (&focus_fill, 1.02, &fill_shade2);
+ ge_shade_color (&focus_fill, 0.84, &fill_shade3);
+
+ ge_cairo_rounded_rectangle (cr, focus_inset_x, focus_inset_y, width-focus_inset_x*2-1, height-focus_inset_y*2-1, radius-1, CR_CORNER_ALL);
+ pattern = cairo_pattern_create_linear (0, 0, 0, height);
+
+ cairo_pattern_add_color_stop_rgba (pattern, 0.0, fill_shade1.r, fill_shade1.g, fill_shade1.b, fill_alpha);
+ cairo_pattern_add_color_stop_rgba (pattern, 0.5, fill_shade2.r, fill_shade2.g, fill_shade2.b, fill_alpha);
+ cairo_pattern_add_color_stop_rgba (pattern, 0.5, focus_fill.r, focus_fill.g, focus_fill.b, fill_alpha);
+ cairo_pattern_add_color_stop_rgba (pattern, 1.0, fill_shade3.r, fill_shade3.g, fill_shade3.b, fill_alpha);
+ cairo_set_source (cr, pattern);
+ cairo_fill_preserve (cr);
+
+ cairo_pattern_destroy (pattern);
+
+ clearlooks_set_mixed_color (cr, ¶ms->parentbg, &focus_border, border_alpha);
+ cairo_stroke (cr);
+ }
}
static void
if (separator->horizontal)
{
- cairo_set_line_width (cr, 1.0);
- cairo_translate (cr, x, y+0.5);
-
- cairo_move_to (cr, 0.0, 0.0);
- cairo_line_to (cr, width, 0.0);
- ge_cairo_set_color (cr, &color);
- cairo_stroke (cr);
-
- cairo_move_to (cr, 0.0, 1.0);
- cairo_line_to (cr, width, 1.0);
- ge_cairo_set_color (cr, &hilight);
- cairo_stroke (cr);
+ cairo_set_line_width (cr, 1.0);
+ cairo_translate (cr, x, y+0.5);
+
+ cairo_move_to (cr, 0.0, 0.0);
+ cairo_line_to (cr, width, 0.0);
+ ge_cairo_set_color (cr, &color);
+ cairo_stroke (cr);
+
+ cairo_move_to (cr, 0.0, 1.0);
+ cairo_line_to (cr, width, 1.0);
+ ge_cairo_set_color (cr, &hilight);
+ cairo_stroke (cr);
}
else
{
- cairo_set_line_width (cr, 1.0);
- cairo_translate (cr, x+0.5, y);
-
- cairo_move_to (cr, 0.0, 0.0);
- cairo_line_to (cr, 0.0, height);
- ge_cairo_set_color (cr, &color);
- cairo_stroke (cr);
-
- cairo_move_to (cr, 1.0, 0.0);
- cairo_line_to (cr, 1.0, height);
- ge_cairo_set_color (cr, &hilight);
- cairo_stroke (cr);
+ cairo_set_line_width (cr, 1.0);
+ cairo_translate (cr, x+0.5, y);
+
+ cairo_move_to (cr, 0.0, 0.0);
+ cairo_line_to (cr, 0.0, height);
+ ge_cairo_set_color (cr, &color);
+ cairo_stroke (cr);
+
+ cairo_move_to (cr, 1.0, 0.0);
+ cairo_line_to (cr, 1.0, height);
+ ge_cairo_set_color (cr, &hilight);
+ cairo_stroke (cr);
}
cairo_restore (cr);
int x, int y, int width, int height)
{
const CairoColor *border = &colors->shade[7];
- CairoColor fill;
- CairoColor shade1, shade2, shade3;
+ CairoColor fill;
+ CairoColor shade1, shade2, shade3;
cairo_pattern_t *pattern;
int bar_x, i;
int shift_x;
- cairo_set_line_width (cr, 1.0);
+ cairo_set_line_width (cr, 1.0);
cairo_translate (cr, x, y);
- cairo_translate (cr, -0.5, -0.5);
-
ge_shade_color (&colors->bg[params->state_type], 1.0, &fill);
if (params->prelight)
ge_shade_color (&fill, 1.04, &fill);
ge_shade_color (&fill, SHADE_BOTTOM, &shade3);
pattern = cairo_pattern_create_linear (1, 1, 1, height-2);
- cairo_pattern_add_color_stop_rgb(pattern, 0, shade1.r, shade1.g, shade1.b);
- cairo_pattern_add_color_stop_rgb(pattern, 0.5, shade2.r, shade2.g, shade2.b);
- cairo_pattern_add_color_stop_rgb(pattern, 0.5, fill.r, fill.g, fill.b);
- cairo_pattern_add_color_stop_rgb(pattern, 1.0, shade3.r, shade3.g, shade3.b);
+ cairo_pattern_add_color_stop_rgb (pattern, 0, shade1.r, shade1.g, shade1.b);
+ cairo_pattern_add_color_stop_rgb (pattern, 0.5, shade2.r, shade2.g, shade2.b);
+ cairo_pattern_add_color_stop_rgb (pattern, 0.5, fill.r, fill.g, fill.b);
+ cairo_pattern_add_color_stop_rgb (pattern, 1.0, shade3.r, shade3.g, shade3.b);
cairo_rectangle (cr, 1, 1, width-2, height-2);
cairo_set_source (cr, pattern);
cairo_fill (cr);
}
cairo_stroke (cr);
- clearlooks_gummy_draw_top_left_highlight (cr, &fill, params, width, height, 2.0);
+ params->style_functions->draw_top_left_highlight (cr, &fill, params, 1, 1, width-2, height-2, 2.0, params->corners);
}
static void
if (!slider->horizontal)
ge_cairo_exchange_axis (cr, &x, &y, &width, &height);
- cairo_translate (cr, x+0.5, y+0.5);
+ cairo_translate (cr, x, y);
- params->style_functions->draw_shadow (cr, colors, radius, width-1, height-1);
+ params->style_functions->draw_shadow (cr, colors, radius, width, height);
params->style_functions->draw_slider (cr, colors, params, 1, 1, width-2, height-2);
}
CairoColor fill;
CairoColor shade1, shade2, shade3;
cairo_pattern_t *pattern;
- ShadowParameters shadow;
double radius = MIN (widget->radius, MIN ((width - 2.0) / 2.0, (height - 2.0) / 2.0));
if (scrollbar->horizontal)
pattern = cairo_pattern_create_linear (0, 0, width, 0);
fill = colors->bg[widget->state_type];
- ge_shade_color(&fill, SHADE_TOP, &shade1);
- ge_shade_color(&fill, SHADE_CENTER_TOP, &shade2);
- ge_shade_color(&fill, SHADE_BOTTOM, &shade3);
-
- cairo_pattern_add_color_stop_rgb(pattern, 0, shade1.r, shade1.g, shade1.b);
- cairo_pattern_add_color_stop_rgb(pattern, 0.5, shade2.r, shade2.g, shade2.b);
- cairo_pattern_add_color_stop_rgb(pattern, 0.5, fill.r, fill.g, fill.b);
- cairo_pattern_add_color_stop_rgb(pattern, 1.0, shade3.r, shade3.g, shade3.b);
+ ge_shade_color (&fill, SHADE_TOP, &shade1);
+ ge_shade_color (&fill, SHADE_CENTER_TOP, &shade2);
+ ge_shade_color (&fill, SHADE_BOTTOM, &shade3);
+
+ cairo_pattern_add_color_stop_rgb (pattern, 0, shade1.r, shade1.g, shade1.b);
+ cairo_pattern_add_color_stop_rgb (pattern, 0.5, shade2.r, shade2.g, shade2.b);
+ cairo_pattern_add_color_stop_rgb (pattern, 0.5, fill.r, fill.g, fill.b);
+ cairo_pattern_add_color_stop_rgb (pattern, 1.0, shade3.r, shade3.g, shade3.b);
cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
- cairo_translate (cr, 0.5, 0.5);
- clearlooks_gummy_draw_top_left_highlight (cr, &fill, widget, width, height, (stepper->stepper == CL_STEPPER_A) ? radius : 0);
- cairo_translate (cr, -0.5, -0.5);
+ widget->style_functions->draw_top_left_highlight (cr, &fill, widget, 1, 1, width - 2, height - 2,
+ radius, corners);
ge_cairo_rounded_rectangle (cr, 0.5, 0.5, width-1, height-1, radius, corners);
clearlooks_set_mixed_color (cr, border, &fill, 0.2);
cairo_stroke (cr);
-
- cairo_translate (cr, 0.5, 0.5);
- shadow.shadow = CL_SHADOW_OUT;
- shadow.corners = corners;
}
static void
cairo_set_line_width (cr, 1);
- ge_shade_color (&fill, TOPLEFT_HIGHLIGHT_SHADE, &hilight);
+ ge_shade_color (&fill, widget->style_constants->topleft_highlight_shade, &hilight);
ge_shade_color (&fill, SHADE_TOP, &shade1);
ge_shade_color (&fill, SHADE_CENTER_TOP, &shade2);
ge_shade_color (&fill, SHADE_BOTTOM, &shade3);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
- if (scrollbar->has_color)
+ if (scrollbar->has_color)
{
cairo_set_source_rgba (cr, hilight.r, hilight.g, hilight.b, 0.2);
ge_cairo_stroke_rectangle (cr, 1.5, 1.5, width-3, height-3);
cairo_move_to (cr, 1.5, height-1.5);
cairo_line_to (cr, 1.5, 1.5);
cairo_line_to (cr, width-1.5, 1.5);
- cairo_set_source_rgba (cr, hilight.r, hilight.g, hilight.b, TOPLEFT_HIGHLIGHT_ALPHA);
- cairo_stroke(cr);
+ cairo_set_source_rgba (cr, hilight.r, hilight.g, hilight.b, widget->style_constants->topleft_highlight_alpha);
+ cairo_stroke (cr);
}
ge_cairo_set_color (cr, &border);
cairo_pattern_destroy (pattern);
/* Draw highlight */
- if (header->order == CL_ORDER_FIRST)
+ if (header->order & CL_ORDER_FIRST)
{
cairo_move_to (cr, 0.5, height-1.5);
cairo_line_to (cr, 0.5, 0.5);
cairo_stroke (cr);
/* Draw resize grip */
- if ((params->ltr && header->order != CL_ORDER_LAST) ||
- (!params->ltr && header->order != CL_ORDER_FIRST) || header->resizable)
+ if ((params->ltr && !(header->order & CL_ORDER_LAST)) ||
+ (!params->ltr && !(header->order & CL_ORDER_FIRST)) || header->resizable)
{
SeparatorParameters separator;
separator.horizontal = FALSE;
{
/* Draw highlight */
cairo_move_to (cr, 0, 0.5);
- cairo_line_to (cr, width-1, 0.5);
+ cairo_line_to (cr, width-0.5, 0.5);
ge_cairo_set_color (cr, &light);
cairo_stroke (cr);
}
/* Draw shadow */
cairo_move_to (cr, 0, height-0.5);
- cairo_line_to (cr, width-1, height-0.5);
+ cairo_line_to (cr, width-0.5, height-0.5);
ge_cairo_set_color (cr, dark);
cairo_stroke (cr);
}
cairo_pattern_add_color_stop_rgb (pattern, 1, shade3.r, shade3.g, shade3.b);
cairo_set_source (cr, pattern);
- cairo_fill_preserve (cr);
+ cairo_fill_preserve (cr);
cairo_pattern_destroy (pattern);
ge_cairo_set_color (cr, border);
cairo_pattern_add_color_stop_rgb (pattern, 1, shade3.r, shade3.g, shade3.b);
cairo_set_source (cr, pattern);
- cairo_fill_preserve (cr);
+ cairo_fill_preserve (cr);
cairo_pattern_destroy (pattern);
ge_cairo_set_color (cr, border);
cairo_pattern_t *pt;
gboolean inconsistent;
gboolean draw_bullet = (checkbox->shadow_type == GTK_SHADOW_IN);
+ gdouble w, h, cx, cy, radius;
+
+ w = (gdouble) width;
+ h = (gdouble) height;
+ cx = width / 2.0;
+ cy = height / 2.0;
+ radius = MIN (width, height) / 2.0;
inconsistent = (checkbox->shadow_type == GTK_SHADOW_ETCHED_IN);
draw_bullet |= inconsistent;
ge_shade_color (&widget->parentbg, 0.9, &shadow);
ge_shade_color (&widget->parentbg, 1.1, &highlight);
- pt = cairo_pattern_create_linear (0, 0, 13, 13);
+ pt = cairo_pattern_create_linear (0, 0, radius * 2.0, radius * 2.0);
cairo_pattern_add_color_stop_rgb (pt, 0.0, shadow.r, shadow.b, shadow.g);
cairo_pattern_add_color_stop_rgba (pt, 0.5, shadow.r, shadow.b, shadow.g, 0.5);
cairo_pattern_add_color_stop_rgba (pt, 0.5, highlight.r, highlight.g, highlight.b, 0.5);
cairo_translate (cr, x, y);
- cairo_set_line_width (cr, 2);
- cairo_arc (cr, 7, 7, 6, 0, G_PI*2);
+ cairo_set_line_width (cr, MAX (1.0, floor (radius/3)));
+ cairo_arc (cr, ceil (cx), ceil (cy), floor (radius - 0.1), 0, G_PI*2);
cairo_set_source (cr, pt);
cairo_stroke (cr);
cairo_pattern_destroy (pt);
- cairo_set_line_width (cr, 1);
+ cairo_set_line_width (cr, MAX (1.0, floor (radius/6)));
- cairo_arc (cr, 7, 7, 5.5, 0, G_PI*2);
+ cairo_arc (cr, ceil (cx), ceil (cy), MAX (1.0, ceil (radius) - 1.5), 0, G_PI*2);
if (!widget->disabled)
{
if (inconsistent)
{
cairo_set_line_cap(cr, CAIRO_LINE_CAP_ROUND);
- cairo_set_line_width (cr, 4);
+ cairo_set_line_width (cr, ceil (radius * 2 / 3));
- cairo_move_to(cr, 5, 7);
- cairo_line_to(cr, 9, 7);
+ cairo_move_to (cr, ceil (cx - radius/3.0), ceil (cy));
+ cairo_line_to (cr, ceil (cx + radius/3.0), ceil (cy));
ge_cairo_set_color (cr, dot);
cairo_stroke (cr);
}
else
{
- cairo_arc (cr, 7, 7, 3, 0, G_PI*2);
+ cairo_arc (cr, ceil (cx), ceil (cy), floor (radius/2.0), 0, G_PI*2);
ge_cairo_set_color (cr, dot);
cairo_fill (cr);
- cairo_arc (cr, 6, 6, 1, 0, G_PI*2);
+ cairo_arc (cr, floor (cx - radius/10.0), floor (cy - radius/10.0), floor (radius/6.0), 0, G_PI*2);
cairo_set_source_rgba (cr, highlight.r, highlight.g, highlight.b, 0.5);
cairo_fill (cr);
}
int x, int y, int width, int height)
{
const CairoColor *border;
- const CairoColor *dot;
+ const CairoColor *dot;
gboolean inconsistent = FALSE;
gboolean draw_bullet = (checkbox->shadow_type == GTK_SHADOW_IN);
{
if (widget->prelight)
border = &colors->spot[2];
- else
+ else
border = &colors->shade[6];
dot = &colors->text[GTK_STATE_NORMAL];
}
if (widget->xthickness > 2 && widget->ythickness > 2)
{
- widget->style_functions->draw_inset (cr, &widget->parentbg, 0.5, 0.5,
- width-1, height-1, (widget->radius > 0)? 1 : 0, CR_CORNER_ALL);
-
+ widget->style_functions->draw_inset (cr, &widget->parentbg, 0, 0,
+ width, height, (widget->radius > 0)? 1 : 0, CR_CORNER_ALL);
+
/* Draw the rectangle for the checkbox itself */
- ge_cairo_rounded_rectangle (cr, 1.5, 1.5,
- width-3, height-3, (widget->radius > 0)? 1 : 0, CR_CORNER_ALL);
+ ge_cairo_rounded_rectangle (cr, 1.5, 1.5,
+ width-3, height-3, (widget->radius > 0)? 1 : 0, CR_CORNER_ALL);
}
else
{
/* Draw the rectangle for the checkbox itself */
- ge_cairo_rounded_rectangle (cr, 0.5, 0.5,
- width-1, height-1, (widget->radius > 0)? 1 : 0, CR_CORNER_ALL);
+ ge_cairo_rounded_rectangle (cr, 0.5, 0.5,
+ width-1, height-1, (widget->radius > 0)? 1 : 0, CR_CORNER_ALL);
}
-
+
if (!widget->disabled)
- {
+ {
if (widget->prelight)
clearlooks_set_mixed_color (cr, &colors->base[0], &colors->spot[1], 0.5);
- else
+ else
ge_cairo_set_color (cr, &colors->base[0]);
cairo_fill_preserve (cr);
}
cairo_curve_to (cr, 0.5 + (width*0.4), (height*0.7),
0.5 + (width*0.5), (height*0.4),
0.5 + (width*0.70), (height*0.25));
-
}
ge_cairo_set_color (cr, dot);
}
}
+static void
+clearlooks_gummy_draw_focus (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
+ const FocusParameters *focus,
+ int x, int y, int width, int height)
+{
+ CairoColor fill = focus->color;
+ CairoColor fill_shade1, fill_shade2, fill_shade3;
+ CairoColor border;
+ CairoColor parentbg = widget->parentbg;
+
+ /* Default values */
+ double xoffset = 1.5;
+ double yoffset = 1.5;
+ double radius = widget->radius-1.0;
+ double border_alpha = 0.64;
+ double fill_alpha = 0.18;
+ double shadow_alpha = 0.5;
+ boolean focus_fill = TRUE;
+ boolean focus_border = TRUE;
+ boolean focus_shadow = FALSE;
+
+ ge_shade_color (&fill, 0.65, &border);
+ ge_shade_color (&fill, 1.18, &fill_shade1);
+ ge_shade_color (&fill, 1.02, &fill_shade2);
+ ge_shade_color (&fill, 0.84, &fill_shade3);
+
+ /* Do some useful things to adjust focus */
+ switch (focus->type)
+ {
+ case CL_FOCUS_BUTTON:
+ xoffset = -1.5-(focus->padding);
+ yoffset = -1.5-(focus->padding);
+ radius++;
+ border_alpha = 0.9;
+ fill_alpha = 0.12;
+ if (!widget->active)
+ focus_shadow = TRUE;
+ break;
+ case CL_FOCUS_BUTTON_FLAT:
+ xoffset = -1.5-(focus->padding);
+ yoffset = -1.5-(focus->padding);
+ radius++;
+ if (widget->active || widget->prelight)
+ {
+ border_alpha = 0.9;
+ fill_alpha = 0.12;
+ if (!widget->active)
+ focus_shadow = TRUE;
+ }
+ break;
+ case CL_FOCUS_LABEL:
+ xoffset = 0.5;
+ yoffset = 0.5;
+ break;
+ case CL_FOCUS_TREEVIEW:
+ parentbg = colors->base[widget->state_type];
+ xoffset = -1.5;
+ yoffset = -1.5;
+ fill_alpha = 0.08;
+ focus_border = FALSE;
+ break;
+ case CL_FOCUS_TREEVIEW_DND:
+ parentbg = colors->base[widget->state_type];
+ break;
+ case CL_FOCUS_TREEVIEW_HEADER:
+ cairo_translate (cr, -1, 0);
+ break;
+ case CL_FOCUS_TREEVIEW_ROW:
+ parentbg = colors->base[widget->state_type];
+ xoffset = -2.5; /* hack to hide vertical lines */
+ yoffset = 0.5;
+ radius = CLAMP (radius, 0.0, 2.0);
+ border_alpha = 0.7;
+ focus_fill = FALSE;
+ break;
+ case CL_FOCUS_TAB:
+ /* In current GTK+ focus and active cannot happen together, but we are robust against it.
+ * IF the application sets the state to ACTIVE while drawing the tabs focus. */
+ if (widget->focus && !widget->active)
+ return;
+ break;
+ case CL_FOCUS_SCALE:
+ break;
+ case CL_FOCUS_UNKNOWN:
+ /* Fallback to classic function, dots */
+ clearlooks_draw_focus (cr, colors, widget, focus, x, y, width, height);
+ return;
+ break;
+ default:
+ break;
+ };
+
+ cairo_translate (cr, x, y);
+ cairo_set_line_width (cr, focus->line_width);
+
+ ge_cairo_rounded_rectangle (cr, xoffset, yoffset, width-(xoffset*2), height-(yoffset*2), radius, widget->corners);
+
+ if (focus_fill)
+ {
+ cairo_pattern_t *pattern;
+
+ pattern = cairo_pattern_create_linear (0, 0, 0, height);
+ cairo_pattern_add_color_stop_rgba (pattern, 0.0, fill_shade1.r, fill_shade1.g, fill_shade1.b, fill_alpha);
+ cairo_pattern_add_color_stop_rgba (pattern, 0.5, fill_shade2.r, fill_shade2.g, fill_shade2.b, fill_alpha);
+ cairo_pattern_add_color_stop_rgba (pattern, 0.5, fill.r, fill.g, fill.b, fill_alpha);
+ cairo_pattern_add_color_stop_rgba (pattern, 1.0, fill_shade3.r, fill_shade3.g, fill_shade3.b, fill_alpha);
+ cairo_set_source (cr, pattern);
+ cairo_fill_preserve (cr);
+
+ cairo_pattern_destroy (pattern);
+ }
+
+ if (focus_border)
+ {
+ clearlooks_set_mixed_color (cr, &parentbg, &border, border_alpha);
+ cairo_stroke (cr);
+ }
+
+ if (focus_shadow)
+ {
+ if (radius > 0)
+ radius++;
+ ge_cairo_rounded_rectangle (cr, xoffset-1, yoffset-1, width-(xoffset*2)+2, height-(yoffset*2)+2, radius, widget->corners);
+ clearlooks_set_mixed_color (cr, &parentbg, &fill, shadow_alpha);
+ cairo_stroke (cr);
+ }
+}
+
void
-clearlooks_register_style_gummy (ClearlooksStyleFunctions *functions)
+clearlooks_register_style_gummy (ClearlooksStyleFunctions *functions, ClearlooksStyleConstants *constants)
{
- functions->draw_button = clearlooks_gummy_draw_button;
- functions->draw_entry = clearlooks_gummy_draw_entry;
- functions->draw_progressbar_trough = clearlooks_gummy_draw_progressbar_trough;
- functions->draw_progressbar_fill = clearlooks_gummy_draw_progressbar_fill;
- functions->draw_scale_trough = clearlooks_gummy_draw_scale_trough;
- functions->draw_tab = clearlooks_gummy_draw_tab;
- functions->draw_separator = clearlooks_gummy_draw_separator;
- functions->draw_slider = clearlooks_gummy_draw_slider;
- functions->draw_slider_button = clearlooks_gummy_draw_slider_button;
- functions->draw_scrollbar_stepper = clearlooks_gummy_draw_scrollbar_stepper;
- functions->draw_scrollbar_slider = clearlooks_gummy_draw_scrollbar_slider;
- functions->draw_list_view_header = clearlooks_gummy_draw_list_view_header;
- functions->draw_toolbar = clearlooks_gummy_draw_toolbar;
- functions->draw_menuitem = clearlooks_gummy_draw_menuitem;
- functions->draw_menubaritem = clearlooks_gummy_draw_menubaritem;
- functions->draw_selected_cell = clearlooks_gummy_draw_selected_cell;
- functions->draw_statusbar = clearlooks_gummy_draw_statusbar;
- functions->draw_checkbox = clearlooks_gummy_draw_checkbox;
- functions->draw_radiobutton = clearlooks_gummy_draw_radiobutton;
+ functions->draw_button = clearlooks_gummy_draw_button;
+ functions->draw_entry = clearlooks_gummy_draw_entry;
+ functions->draw_progressbar_trough = clearlooks_gummy_draw_progressbar_trough;
+ functions->draw_progressbar_fill = clearlooks_gummy_draw_progressbar_fill;
+ functions->draw_scale_trough = clearlooks_gummy_draw_scale_trough;
+ functions->draw_tab = clearlooks_gummy_draw_tab;
+ functions->draw_separator = clearlooks_gummy_draw_separator;
+ functions->draw_slider = clearlooks_gummy_draw_slider;
+ functions->draw_slider_button = clearlooks_gummy_draw_slider_button;
+ functions->draw_scrollbar_stepper = clearlooks_gummy_draw_scrollbar_stepper;
+ functions->draw_scrollbar_slider = clearlooks_gummy_draw_scrollbar_slider;
+ functions->draw_list_view_header = clearlooks_gummy_draw_list_view_header;
+ functions->draw_toolbar = clearlooks_gummy_draw_toolbar;
+ functions->draw_menuitem = clearlooks_gummy_draw_menuitem;
+ functions->draw_menubaritem = clearlooks_gummy_draw_menubaritem;
+ functions->draw_selected_cell = clearlooks_gummy_draw_selected_cell;
+ functions->draw_statusbar = clearlooks_gummy_draw_statusbar;
+ functions->draw_checkbox = clearlooks_gummy_draw_checkbox;
+ functions->draw_radiobutton = clearlooks_gummy_draw_radiobutton;
+ functions->draw_focus = clearlooks_gummy_draw_focus;
+
+ constants->topleft_highlight_shade = 1.3;
+ constants->topleft_highlight_alpha = 0.4;
}
#include <cairo.h>
-static void
-clearlooks_draw_top_left_highlight (cairo_t *cr,
- const CairoColor *color,
- const WidgetParameters *params,
- int width, int height, gdouble radius)
-{
- CairoColor hilight;
-
- double light_top = params->ythickness-1,
- light_bottom = height - params->ythickness - 1,
- light_left = params->xthickness-1,
- light_right = width - params->xthickness - 1;
-
- ge_shade_color (color, 1.3, &hilight);
- cairo_move_to (cr, light_left, light_bottom - (int)radius/2);
-
- ge_cairo_rounded_corner (cr, light_left, light_top, radius, params->corners & CR_CORNER_TOPLEFT);
-
- cairo_line_to (cr, light_right - (int)radius/2, light_top);
- cairo_set_source_rgba (cr, hilight.r, hilight.g, hilight.b, 0.7);
- cairo_stroke (cr);
-}
-
static void
clearlooks_set_border_gradient (cairo_t *cr, const CairoColor *color, double hilight, int width, int height)
{
if (params->xthickness == 3 || params->ythickness == 3)
{
- cairo_translate (cr, 0.5, 0.5);
- params->style_functions->draw_inset (cr, ¶ms->parentbg, 0, 0, width-1, height-1, radius+1, params->corners);
- cairo_translate (cr, -0.5, -0.5);
+ params->style_functions->draw_inset (cr, ¶ms->parentbg, 0, 0, width, height, radius+1, params->corners);
}
ge_cairo_rounded_rectangle (cr, xoffset+1, yoffset+1,
/* Draw the "shadow" */
if (!params->active)
{
- cairo_translate (cr, 0.5, 0.5);
/* Draw right shadow */
- cairo_move_to (cr, width-params->xthickness, params->ythickness - 1);
- cairo_line_to (cr, width-params->xthickness, height - params->ythickness - 1);
+ cairo_move_to (cr, width-xoffset-1.5, yoffset + radius);
+ cairo_line_to (cr, width-xoffset-1.5, height - yoffset - radius);
cairo_set_source_rgba (cr, shadow.r, shadow.g, shadow.b, 0.1);
cairo_stroke (cr);
/* Draw topleft shadow */
- clearlooks_draw_top_left_highlight (cr, fill, params, width, height, radius);
+ params->style_functions->draw_top_left_highlight (cr, fill, params,
+ xoffset+1, yoffset+1,
+ width-2*(xoffset+1), height-2*(yoffset+1),
+ radius, params->corners);
}
cairo_restore (cr);
}
double radius;
double strip_size;
+ double length;
radius = MIN (params->radius, MIN ((width - 2.0) / 2.0, (height - 2.0) / 2.0));
if (tab->gap_side == CL_GAP_TOP || tab->gap_side == CL_GAP_BOTTOM)
{
height += 3.0;
+ length = height;
strip_size = 2.0/height; /* 2 pixel high strip */
if (tab->gap_side == CL_GAP_TOP)
else
{
width += 3.0;
+ length = width;
strip_size = 2.0/width;
if (tab->gap_side == CL_GAP_LEFT)
if (params->active)
{
- pattern = cairo_pattern_create_linear ( tab->gap_side == CL_GAP_LEFT ? width-1 : 0,
- tab->gap_side == CL_GAP_TOP ? height-2 : 1,
- tab->gap_side == CL_GAP_RIGHT ? width : 0,
- tab->gap_side == CL_GAP_BOTTOM ? height : 0 );
+ switch (tab->gap_side)
+ {
+ case CL_GAP_TOP:
+ pattern = cairo_pattern_create_linear (0, height-2, 0, 0);
+ break;
+ case CL_GAP_BOTTOM:
+ pattern = cairo_pattern_create_linear (0, 1, 0, height);
+ break;
+ case CL_GAP_LEFT:
+ pattern = cairo_pattern_create_linear (width-2, 0, 1, 0);
+ break;
+ case CL_GAP_RIGHT:
+ pattern = cairo_pattern_create_linear (1, 0, width-2, 0);
+ break;
+ default:
+ pattern = NULL;
+ }
ge_cairo_rounded_rectangle (cr, 0, 0, width-1, height-1, radius, params->corners);
else
{
/* Draw shade */
- pattern = cairo_pattern_create_linear ( tab->gap_side == CL_GAP_LEFT ? width-2 : 0,
- tab->gap_side == CL_GAP_TOP ? height-2 : 0,
- tab->gap_side == CL_GAP_RIGHT ? width : 0,
- tab->gap_side == CL_GAP_BOTTOM ? height : 0 );
+ switch (tab->gap_side)
+ {
+ case CL_GAP_TOP:
+ pattern = cairo_pattern_create_linear (0, height-2, 0, 0);
+ break;
+ case CL_GAP_BOTTOM:
+ pattern = cairo_pattern_create_linear (0, 0, 0, height);
+ break;
+ case CL_GAP_LEFT:
+ pattern = cairo_pattern_create_linear (width-2, 0, 0, 0);
+ break;
+ case CL_GAP_RIGHT:
+ pattern = cairo_pattern_create_linear (0, 0, width, 0);
+ break;
+ default:
+ pattern = NULL;
+ }
ge_cairo_rounded_rectangle (cr, 0, 0, width-1, height-1, radius, params->corners);
}
else
{
- pattern = cairo_pattern_create_linear ( tab->gap_side == CL_GAP_LEFT ? width-2 : 2,
- tab->gap_side == CL_GAP_TOP ? height-2 : 2,
- tab->gap_side == CL_GAP_RIGHT ? width : 2,
- tab->gap_side == CL_GAP_BOTTOM ? height : 2 );
+ switch (tab->gap_side)
+ {
+ case CL_GAP_TOP:
+ pattern = cairo_pattern_create_linear (2, height-2, 2, 2);
+ break;
+ case CL_GAP_BOTTOM:
+ pattern = cairo_pattern_create_linear (2, 2, 2, height);
+ break;
+ case CL_GAP_LEFT:
+ pattern = cairo_pattern_create_linear (width-2, 2, 2, 2);
+ break;
+ case CL_GAP_RIGHT:
+ pattern = cairo_pattern_create_linear (2, 2, width, 2);
+ break;
+ default:
+ pattern = NULL;
+ }
cairo_pattern_add_color_stop_rgb (pattern, 0.0, stripe_border->r, stripe_border->g, stripe_border->b);
cairo_pattern_add_color_stop_rgb (pattern, strip_size, stripe_border->r, stripe_border->g, stripe_border->b);
border = &colors->shade[6];
/* fill the widget */
- cairo_rectangle (cr, 0.5, 0.5, width-2, height-2);
+ cairo_rectangle (cr, 1.0, 1.0, width-2, height-2);
/* Fake light */
if (!params->disabled)
else
{
ge_cairo_set_color (cr, fill);
- cairo_rectangle (cr, 0.5, 0.5, width-2, height-2);
+ cairo_rectangle (cr, 1.0, 1.0, width-2, height-2);
cairo_fill (cr);
}
/* Set the clip */
cairo_save (cr);
- cairo_rectangle (cr, 0.5, 0.5, 6, height-2);
- cairo_rectangle (cr, width-7.5, 0.5, 6 , height-2);
+ cairo_rectangle (cr, 1.0, 1.0, 6, height-2);
+ cairo_rectangle (cr, width-7.0, 1.0, 6, height-2);
cairo_clip_preserve (cr);
cairo_new_path (cr);
/* Draw the handles */
- ge_cairo_rounded_rectangle (cr, 0.5, 0.5, width-1, height-1, radius, params->corners);
+ ge_cairo_rounded_rectangle (cr, 1.0, 1.0, width-1, height-1, radius, params->corners);
pattern = cairo_pattern_create_linear (0.5, 0.5, 0.5, 0.5+height);
if (params->prelight)
cairo_restore (cr);
/* Draw the border */
- ge_cairo_rounded_rectangle (cr, 0, 0, width-1, height-1, radius, params->corners);
+ ge_cairo_inner_rounded_rectangle (cr, 0, 0, width, height, radius, params->corners);
if (params->prelight || params->disabled)
ge_cairo_set_color (cr, border);
else
/* Draw handle lines */
if (width > 14)
{
- cairo_move_to (cr, 6, 0.5);
- cairo_line_to (cr, 6, height-1);
+ cairo_move_to (cr, 6.5, 1.0);
+ cairo_line_to (cr, 6.5, height-1);
- cairo_move_to (cr, width-7, 0.5);
- cairo_line_to (cr, width-7, height-1);
+ cairo_move_to (cr, width-6.5, 1.0);
+ cairo_line_to (cr, width-6.5, height-1);
cairo_set_line_width (cr, 1.0);
cairo_set_source_rgba (cr, border->r,
}
}
-static void
-clearlooks_inverted_draw_slider_button (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *params,
- const SliderParameters *slider,
- int x, int y, int width, int height)
-{
- double radius = MIN (params->radius, MIN ((width - 2.0) / 2.0, (height - 2.0) / 2.0));
- cairo_set_line_width (cr, 1.0);
-
- if (!slider->horizontal)
- ge_cairo_exchange_axis (cr, &x, &y, &width, &height);
- cairo_translate (cr, x+0.5, y+0.5);
-
- params->style_functions->draw_shadow (cr, colors, radius, width-1, height-1);
- params->style_functions->draw_slider (cr, colors, params, 1, 1, width-2, height-2);
-
- if (width > 24)
- params->style_functions->draw_gripdots (cr, colors, 0, 0, width-2, height-2, 3, 3, 0);
-}
-
static void
clearlooks_inverted_draw_list_view_header (cairo_t *cr,
const ClearlooksColors *colors,
cairo_set_line_width (cr, 1.0);
/* Draw highlight */
- if (header->order == CL_ORDER_FIRST)
+ if (header->order & CL_ORDER_FIRST)
{
cairo_move_to (cr, 0.5, height-1);
cairo_line_to (cr, 0.5, 0.5);
cairo_pattern_destroy (pattern);
/* Draw resize grip */
- if ((params->ltr && header->order != CL_ORDER_LAST) ||
- (!params->ltr && header->order != CL_ORDER_FIRST) || header->resizable)
+ if ((params->ltr && !(header->order & CL_ORDER_LAST)) ||
+ (!params->ltr && !(header->order & CL_ORDER_FIRST)) || header->resizable)
{
SeparatorParameters separator;
separator.horizontal = FALSE;
CairoColor border;
CairoColor s1, s2, s3;
cairo_pattern_t *pattern;
- ShadowParameters shadow;
double radius = MIN (widget->radius, MIN ((width - 2.0) / 2.0, (height - 2.0) / 2.0));
ge_shade_color(&colors->shade[6], 1.05, &border);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
- clearlooks_draw_top_left_highlight (cr, &s1, widget, width, height, radius);
+ widget->style_functions->draw_top_left_highlight (cr, &s1, widget, 1, 1, width-2, height-2, radius, corners);
ge_cairo_rounded_rectangle (cr, 0.5, 0.5, width-1, height-1, radius, corners);
clearlooks_set_border_gradient (cr, &border, 1.2, (scrollbar->horizontal ? 0 : width), (scrollbar->horizontal ? height: 0));
cairo_stroke (cr);
-
- cairo_translate (cr, 0.5, 0.5);
- shadow.shadow = CL_SHADOW_OUT;
- shadow.corners = corners;
- /*
- clearlooks_draw_highlight_and_shade (cr, &shadow,
- width,
- height, params->radius);*/
}
static void
cairo_fill(cr);
cairo_pattern_destroy(pattern);
- clearlooks_draw_top_left_highlight (cr, &s2, widget, width, height, 0);
+ widget->style_functions->draw_top_left_highlight (cr, &s2, widget, 1, 1, width-2, height-2, 0, widget->corners);
clearlooks_set_border_gradient (cr, &border, 1.2, 0, height);
ge_cairo_stroke_rectangle (cr, 0.5, 0.5, width-1, height-1);
}
void
-clearlooks_register_style_inverted (ClearlooksStyleFunctions *functions)
+clearlooks_register_style_inverted (ClearlooksStyleFunctions *functions, ClearlooksStyleConstants *constants)
{
functions->draw_button = clearlooks_inverted_draw_button;
functions->draw_slider = clearlooks_inverted_draw_slider;
- functions->draw_slider_button = clearlooks_inverted_draw_slider_button;
functions->draw_progressbar_fill = clearlooks_inverted_draw_progressbar_fill;
functions->draw_menuitem = clearlooks_inverted_draw_menuitem;
functions->draw_menubaritem = clearlooks_inverted_draw_menubaritem;
functions->draw_scrollbar_stepper = clearlooks_inverted_draw_scrollbar_stepper;
functions->draw_scrollbar_slider = clearlooks_inverted_draw_scrollbar_slider;
functions->draw_selected_cell = clearlooks_inverted_draw_selected_cell;
+
+ constants->topleft_highlight_shade = 1.3;
+ constants->topleft_highlight_alpha = 0.7;
}
/* Clearlooks theme engine
- * Copyright (C) 2005 Richard Stellingwerff.
+ * Copyright (C) 2005 Richard Stellingwerff
+ * Copyright (C) 2007 Benjamin Berg
+ * Copyright (C) 2007 Andrea Cimitan
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* Modified by Kulyk Nazar <schamane@myeburg.net>
*/
+#include <string.h>
+#include <widget-information.h>
#include "clearlooks_style.h"
#include "clearlooks_rc_style.h"
#include "animation.h"
-static void clearlooks_rc_style_init (ClearlooksRcStyle *style);
#ifdef HAVE_ANIMATION
static void clearlooks_rc_style_finalize (GObject *object);
#endif
-static void clearlooks_rc_style_class_init (ClearlooksRcStyleClass *klass);
static GtkStyle *clearlooks_rc_style_create_style (GtkRcStyle *rc_style);
static guint clearlooks_rc_style_parse (GtkRcStyle *rc_style,
- GtkSettings *settings,
- GScanner *scanner);
+ GtkSettings *settings,
+ GScanner *scanner);
static void clearlooks_rc_style_merge (GtkRcStyle *dest,
- GtkRcStyle *src);
-
-
-static GtkRcStyleClass *clearlooks_parent_rc_class;
-
-GType clearlooks_type_rc_style = 0;
+ GtkRcStyle *src);
enum
{
- TOKEN_SCROLLBARCOLOR = G_TOKEN_LAST + 1,
+ TOKEN_FOCUSCOLOR = G_TOKEN_LAST + 1,
+ TOKEN_SCROLLBARCOLOR,
TOKEN_COLORIZESCROLLBAR,
TOKEN_CONTRAST,
TOKEN_SUNKENMENU,
TOKEN_PROGRESSBARSTYLE,
+ TOKEN_RELIEFSTYLE,
TOKEN_MENUBARSTYLE,
TOKEN_TOOLBARSTYLE,
TOKEN_MENUITEMSTYLE,
TOKEN_ANIMATION,
TOKEN_STYLE,
TOKEN_RADIUS,
+ TOKEN_HINT,
TOKEN_CLASSIC,
TOKEN_GLOSSY,
TOKEN_GUMMY,
TOKEN_TRUE,
- TOKEN_FALSE
-};
+ TOKEN_FALSE,
-static struct
-{
- const gchar *name;
- guint token;
-}
-clearlooks_gtk2_rc_symbols[] =
-{
- { "scrollbar_color", TOKEN_SCROLLBARCOLOR },
- { "colorize_scrollbar", TOKEN_COLORIZESCROLLBAR },
- { "contrast", TOKEN_CONTRAST },
- { "sunkenmenubar", TOKEN_SUNKENMENU },
- { "progressbarstyle", TOKEN_PROGRESSBARSTYLE },
- { "menubarstyle", TOKEN_MENUBARSTYLE },
- { "toolbarstyle", TOKEN_TOOLBARSTYLE },
- { "menuitemstyle", TOKEN_MENUITEMSTYLE },
- { "listviewitemstyle", TOKEN_LISTVIEWITEMSTYLE },
- { "animation", TOKEN_ANIMATION },
- { "style", TOKEN_STYLE },
- { "radius", TOKEN_RADIUS },
-
- { "CLASSIC", TOKEN_CLASSIC },
- { "GLOSSY", TOKEN_GLOSSY },
- { "INVERTED", TOKEN_INVERTED },
- { "GUMMY", TOKEN_GUMMY },
-
- { "TRUE", TOKEN_TRUE },
- { "FALSE", TOKEN_FALSE }
+ TOKEN_LAST
};
+static gchar* clearlooks_rc_symbols =
+ "focus_color\0"
+ "scrollbar_color\0"
+ "colorize_scrollbar\0"
+ "contrast\0"
+ "sunkenmenubar\0"
+ "progressbarstyle\0"
+ "reliefstyle\0"
+ "menubarstyle\0"
+ "toolbarstyle\0"
+ "menuitemstyle\0"
+ "listviewitemstyle\0"
+ "animation\0"
+ "style\0"
+ "radius\0"
+ "hint\0"
+
+ "CLASSIC\0"
+ "GLOSSY\0"
+ "INVERTED\0"
+ "GUMMY\0"
+
+ "TRUE\0"
+ "FALSE\0";
+
+G_DEFINE_DYNAMIC_TYPE (ClearlooksRcStyle, clearlooks_rc_style, GTK_TYPE_RC_STYLE)
void
-clearlooks_rc_style_register_type (GTypeModule *module)
+clearlooks_rc_style_register_types (GTypeModule *module)
{
- static const GTypeInfo object_info =
- {
- sizeof (ClearlooksRcStyleClass),
- (GBaseInitFunc) NULL,
- (GBaseFinalizeFunc) NULL,
- (GClassInitFunc) clearlooks_rc_style_class_init,
- NULL, /* class_finalize */
- NULL, /* class_data */
- sizeof (ClearlooksRcStyle),
- 0, /* n_preallocs */
- (GInstanceInitFunc) clearlooks_rc_style_init,
- NULL
- };
-
- clearlooks_type_rc_style = g_type_module_register_type (module,
- GTK_TYPE_RC_STYLE,
- "ClearlooksRcStyle",
- &object_info, 0);
+ clearlooks_rc_style_register_type (module);
}
static void
clearlooks_rc->flags = 0;
clearlooks_rc->contrast = 1.0;
+ clearlooks_rc->reliefstyle = 0;
clearlooks_rc->menubarstyle = 0;
clearlooks_rc->toolbarstyle = 0;
clearlooks_rc->animation = FALSE;
clearlooks_rc->colorize_scrollbar = FALSE;
clearlooks_rc->radius = 3.0;
+ clearlooks_rc->hint = 0;
}
#ifdef HAVE_ANIMATION
/* cleanup all the animation stuff */
clearlooks_animation_cleanup ();
- if (G_OBJECT_CLASS (clearlooks_parent_rc_class)->finalize != NULL)
- G_OBJECT_CLASS (clearlooks_parent_rc_class)->finalize(object);
+ if (G_OBJECT_CLASS (clearlooks_rc_style_parent_class)->finalize != NULL)
+ G_OBJECT_CLASS (clearlooks_rc_style_parent_class)->finalize (object);
}
#endif
GObjectClass *g_object_class = G_OBJECT_CLASS (klass);
#endif
- clearlooks_parent_rc_class = g_type_class_peek_parent (klass);
-
rc_style_class->parse = clearlooks_rc_style_parse;
rc_style_class->create_style = clearlooks_rc_style_create_style;
rc_style_class->merge = clearlooks_rc_style_merge;
#endif
}
+static void
+clearlooks_rc_style_class_finalize (ClearlooksRcStyleClass *klass)
+{
+}
+
static guint
clearlooks_gtk2_rc_parse_boolean (GtkSettings *settings,
- GScanner *scanner,
- gboolean *retval)
+ GScanner *scanner,
+ gboolean *retval)
{
guint token;
token = g_scanner_get_next_token(scanner);
static guint
clearlooks_gtk2_rc_parse_color(GtkSettings *settings,
- GScanner *scanner,
- GdkColor *color)
+ GScanner *scanner,
+ GtkRcStyle *style,
+ GdkColor *color)
{
guint token;
if (token != G_TOKEN_EQUAL_SIGN)
return G_TOKEN_EQUAL_SIGN;
- return gtk_rc_parse_color (scanner, color);
+ return gtk_rc_parse_color_full (scanner, style, color);
}
static guint
static guint
clearlooks_gtk2_rc_parse_int (GtkSettings *settings,
- GScanner *scanner,
- guint8 *progressbarstyle)
+ GScanner *scanner,
+ guint8 *progressbarstyle)
{
guint token;
- /* Skip 'sunkenmenubar' */
+ /* Skip option name */
token = g_scanner_get_next_token(scanner);
token = g_scanner_get_next_token(scanner);
return G_TOKEN_EQUAL_SIGN;
token = g_scanner_get_next_token (scanner);
-
+
switch (token)
{
case TOKEN_CLASSIC:
static guint
clearlooks_rc_style_parse (GtkRcStyle *rc_style,
- GtkSettings *settings,
- GScanner *scanner)
-
+ GtkSettings *settings,
+ GScanner *scanner)
{
static GQuark scope_id = 0;
ClearlooksRcStyle *clearlooks_style = CLEARLOOKS_RC_STYLE (rc_style);
guint old_scope;
guint token;
- guint i;
/* Set up a new scope in this scanner. */
* (in some previous call to clearlooks_rc_style_parse for the
* same scanner.
*/
+ if (!g_scanner_lookup_symbol(scanner, clearlooks_rc_symbols)) {
+ gchar *current_symbol = clearlooks_rc_symbols;
+ gint i = G_TOKEN_LAST + 1;
- if (!g_scanner_lookup_symbol(scanner, clearlooks_gtk2_rc_symbols[0].name))
- {
- for (i = 0; i < G_N_ELEMENTS (clearlooks_gtk2_rc_symbols); i++)
- g_scanner_scope_add_symbol(scanner, scope_id,
- clearlooks_gtk2_rc_symbols[i].name,
- GINT_TO_POINTER(clearlooks_gtk2_rc_symbols[i].token));
+ /* Add our symbols */
+ while ((current_symbol[0] != '\0') && (i < TOKEN_LAST)) {
+ g_scanner_scope_add_symbol(scanner, scope_id, current_symbol, GINT_TO_POINTER (i));
+
+ current_symbol += strlen(current_symbol) + 1;
+ i++;
+ }
+ g_assert (i == TOKEN_LAST && current_symbol[0] == '\0');
}
/* We're ready to go, now parse the top level */
{
switch (token)
{
+ case TOKEN_FOCUSCOLOR:
+ token = clearlooks_gtk2_rc_parse_color (settings, scanner, rc_style, &clearlooks_style->focus_color);
+ clearlooks_style->flags |= CL_FLAG_FOCUS_COLOR;
+ break;
case TOKEN_SCROLLBARCOLOR:
- token = clearlooks_gtk2_rc_parse_color (settings, scanner, &clearlooks_style->scrollbar_color);
+ token = clearlooks_gtk2_rc_parse_color (settings, scanner, rc_style, &clearlooks_style->scrollbar_color);
clearlooks_style->flags |= CL_FLAG_SCROLLBAR_COLOR;
break;
case TOKEN_COLORIZESCROLLBAR:
token = clearlooks_gtk2_rc_parse_double (settings, scanner, &clearlooks_style->contrast);
clearlooks_style->flags |= CL_FLAG_CONTRAST;
break;
+ case TOKEN_RELIEFSTYLE:
+ token = clearlooks_gtk2_rc_parse_int (settings, scanner, &clearlooks_style->reliefstyle);
+ clearlooks_style->flags |= CL_FLAG_RELIEFSTYLE;
+ break;
case TOKEN_MENUBARSTYLE:
token = clearlooks_gtk2_rc_parse_int (settings, scanner, &clearlooks_style->menubarstyle);
clearlooks_style->flags |= CL_FLAG_MENUBARSTYLE;
token = clearlooks_gtk2_rc_parse_double (settings, scanner, &clearlooks_style->radius);
clearlooks_style->flags |= CL_FLAG_RADIUS;
break;
+ case TOKEN_HINT:
+ token = ge_rc_parse_hint (scanner, &clearlooks_style->hint);
+ clearlooks_style->flags |= CL_FLAG_HINT;
+ break;
/* stuff to ignore */
case TOKEN_SUNKENMENU:
static void
clearlooks_rc_style_merge (GtkRcStyle *dest,
- GtkRcStyle *src)
+ GtkRcStyle *src)
{
ClearlooksRcStyle *dest_w, *src_w;
ClearlooksRcFlags flags;
- clearlooks_parent_rc_class->merge (dest, src);
+ GTK_RC_STYLE_CLASS (clearlooks_rc_style_parent_class)->merge (dest, src);
if (!CLEARLOOKS_IS_RC_STYLE (src))
return;
dest_w->style = src_w->style;
if (flags & CL_FLAG_CONTRAST)
dest_w->contrast = src_w->contrast;
+ if (flags & CL_FLAG_RELIEFSTYLE)
+ dest_w->reliefstyle = src_w->reliefstyle;
if (flags & CL_FLAG_MENUBARSTYLE)
dest_w->menubarstyle = src_w->menubarstyle;
if (flags & CL_FLAG_TOOLBARSTYLE)
dest_w->toolbarstyle = src_w->toolbarstyle;
+ if (flags & CL_FLAG_FOCUS_COLOR)
+ dest_w->focus_color = src_w->focus_color;
if (flags & CL_FLAG_SCROLLBAR_COLOR)
dest_w->scrollbar_color = src_w->scrollbar_color;
if (flags & CL_FLAG_COLORIZE_SCROLLBAR)
dest_w->animation = src_w->animation;
if (flags & CL_FLAG_RADIUS)
dest_w->radius = src_w->radius;
+ if (flags & CL_FLAG_HINT)
+ dest_w->hint = src_w->hint;
dest_w->flags |= src_w->flags;
}
-/* Clearlooks Theme Engine
- * Copyright (C) 2005 Richard Stellingwerff.
+/* Clearlooks theme engine
+ * Copyright (C) 2005 Richard Stellingwerff
+ * Copyright (C) 2007 Benjamin Berg
+ * Copyright (C) 2007 Andrea Cimitan
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
#include <gtk/gtkrc.h>
#include "clearlooks_types.h"
+#ifndef CLEARLOOKS_RC_STYLE_H
+#define CLEARLOOKS_RC_STYLE_H
+
typedef struct _ClearlooksRcStyle ClearlooksRcStyle;
typedef struct _ClearlooksRcStyleClass ClearlooksRcStyleClass;
-GE_INTERNAL extern GType clearlooks_type_rc_style;
-
-#define CLEARLOOKS_TYPE_RC_STYLE clearlooks_type_rc_style
+#define CLEARLOOKS_TYPE_RC_STYLE (clearlooks_rc_style_get_type ())
#define CLEARLOOKS_RC_STYLE(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), CLEARLOOKS_TYPE_RC_STYLE, ClearlooksRcStyle))
#define CLEARLOOKS_RC_STYLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLEARLOOKS_TYPE_RC_STYLE, ClearlooksRcStyleClass))
#define CLEARLOOKS_IS_RC_STYLE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), CLEARLOOKS_TYPE_RC_STYLE))
/* XXX: needs fixing! */
typedef enum {
CL_FLAG_STYLE = 1 << 0,
- CL_FLAG_SCROLLBAR_COLOR = 1 << 1,
- CL_FLAG_COLORIZE_SCROLLBAR = 1 << 2,
- CL_FLAG_CONTRAST = 1 << 3,
- CL_FLAG_MENUBARSTYLE = 1 << 4,
- CL_FLAG_TOOLBARSTYLE = 1 << 5,
- CL_FLAG_ANIMATION = 1 << 6,
- CL_FLAG_RADIUS = 1 << 7
+ CL_FLAG_FOCUS_COLOR = 1 << 1,
+ CL_FLAG_SCROLLBAR_COLOR = 1 << 2,
+ CL_FLAG_COLORIZE_SCROLLBAR = 1 << 3,
+ CL_FLAG_CONTRAST = 1 << 4,
+ CL_FLAG_RELIEFSTYLE = 1 << 5,
+ CL_FLAG_MENUBARSTYLE = 1 << 6,
+ CL_FLAG_TOOLBARSTYLE = 1 << 7,
+ CL_FLAG_ANIMATION = 1 << 8,
+ CL_FLAG_RADIUS = 1 << 9,
+ CL_FLAG_HINT = 1 << 10
} ClearlooksRcFlags;
+
struct _ClearlooksRcStyle
{
GtkRcStyle parent_instance;
ClearlooksStyles style;
+ GdkColor focus_color;
GdkColor scrollbar_color;
gboolean colorize_scrollbar;
double contrast;
+ guint8 reliefstyle;
guint8 menubarstyle;
guint8 toolbarstyle;
gboolean animation;
double radius;
+ GQuark hint;
};
struct _ClearlooksRcStyleClass
{
- GtkRcStyleClass parent_class;
+ GtkRcStyleClass parent_class;
};
-GE_INTERNAL void clearlooks_rc_style_register_type (GTypeModule *module);
+GE_INTERNAL void clearlooks_rc_style_register_types (GTypeModule *module);
+GE_INTERNAL GType clearlooks_rc_style_get_type (void);
+
+#endif /* CLEARLOOKS_RC_STYLE_H */
/* Clearlooks theme engine
- * Copyright (C) 2005 Richard Stellingwerff.
- * Copyright (C) 2007 Benjamin Berg <benjamin@sipsolutions.net>.
+ * Copyright (C) 2005 Richard Stellingwerff
+ * Copyright (C) 2007 Benjamin Berg
+ * Copyright (C) 2007 Andrea Cimitan
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
/* #define DEBUG 1 */
#define DETAIL(xx) ((detail) && (!strcmp(xx, detail)))
+#define CHECK_HINT(xx) (ge_check_hint ((xx), CLEARLOOKS_RC_STYLE ((style)->rc_style)->hint, widget))
#define DRAW_ARGS GtkStyle *style, \
GdkWindow *window, \
#include "animation.h"
#endif
-#define STYLE_FUNCTION(function) (clearlooks_style_class->style_functions[CLEARLOOKS_STYLE (style)->style].function)
+#define STYLE_FUNCTION(function) (CLEARLOOKS_STYLE_GET_CLASS (style)->style_functions[CLEARLOOKS_STYLE (style)->style].function)
-static ClearlooksStyleClass *clearlooks_style_class;
-static GtkStyleClass *clearlooks_parent_class;
+G_DEFINE_DYNAMIC_TYPE (ClearlooksStyle, clearlooks_style, GTK_TYPE_STYLE)
static void
clearlooks_set_widget_parameters (const GtkWidget *widget,
GtkStateType state_type,
WidgetParameters *params)
{
- params->style_functions = &(clearlooks_style_class->style_functions[CLEARLOOKS_STYLE (style)->style]);
-
- params->active = (state_type == GTK_STATE_ACTIVE);
- params->prelight = (state_type == GTK_STATE_PRELIGHT);
- params->disabled = (state_type == GTK_STATE_INSENSITIVE);
- params->state_type = (ClearlooksStateType)state_type;
- params->corners = CR_CORNER_ALL;
- params->ltr = ge_widget_is_ltr ((GtkWidget*)widget);
- params->focus = widget && GTK_WIDGET_HAS_FOCUS (widget);
- params->is_default = widget && GE_WIDGET_HAS_DEFAULT (widget);
- params->enable_glow = FALSE;
- params->radius = CLEARLOOKS_STYLE (style)->radius;
-
- if (!params->active && widget && GE_IS_TOGGLE_BUTTON (widget))
- params->active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
-
- params->xthickness = style->xthickness;
- params->ythickness = style->ythickness;
-
+ params->style_functions = &(CLEARLOOKS_STYLE_GET_CLASS (style)->style_functions[CLEARLOOKS_STYLE (style)->style]);
+ params->style_constants = &(CLEARLOOKS_STYLE_GET_CLASS (style)->style_constants[CLEARLOOKS_STYLE (style)->style]);
+
+ params->active = (state_type == GTK_STATE_ACTIVE);
+ params->prelight = (state_type == GTK_STATE_PRELIGHT);
+ params->disabled = (state_type == GTK_STATE_INSENSITIVE);
+ params->state_type = (ClearlooksStateType)state_type;
+ params->corners = CR_CORNER_ALL;
+ params->ltr = ge_widget_is_ltr ((GtkWidget*)widget);
+ params->focus = widget && GTK_WIDGET_HAS_FOCUS (widget);
+ params->is_default = widget && GE_WIDGET_HAS_DEFAULT (widget);
+ params->enable_shadow = FALSE;
+ params->radius = CLEARLOOKS_STYLE (style)->radius;
+
+ params->xthickness = style->xthickness;
+ params->ythickness = style->ythickness;
+
/* This is used in GtkEntry to fake transparency. The reason to do this
* is that the entry has it's entire background filled with base[STATE].
* This is not a very good solution as it will eg. fail if one changes
static void
clearlooks_style_draw_flat_box (DRAW_ARGS)
{
- if (detail &&
+ if (detail &&
state_type == GTK_STATE_SELECTED && (
!strncmp ("cell_even", detail, 9) ||
!strncmp ("cell_odd", detail, 8)))
}
else
{
- clearlooks_parent_class->draw_flat_box (style, window, state_type,
- shadow_type,
- area, widget, detail,
- x, y, width, height);
+ GTK_STYLE_CLASS (clearlooks_style_parent_class)->draw_flat_box (style, window, state_type,
+ shadow_type,
+ area, widget, detail,
+ x, y, width, height);
}
}
CHECK_ARGS
SANITIZE_SIZE
- if ((DETAIL ("entry") && !(widget && widget->parent && GE_IS_TREE_VIEW (widget->parent))) ||
- (DETAIL ("frame") && ge_is_in_combo_box (widget)))
+ /* The "frame" thing is a hack because of GtkCombo. */
+ if ((DETAIL ("entry") && !CHECK_HINT (GE_HINT_TREEVIEW)) ||
+ (DETAIL ("frame") && CHECK_HINT (GE_HINT_COMBOBOX_ENTRY)))
{
WidgetParameters params;
-
- clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
/* Override the entries state type, because we are too lame to handle this via
* the focus ring, and GtkEntry doesn't even set the INSENSITIVE state ... */
if (state_type == GTK_STATE_NORMAL && widget && GE_IS_ENTRY (widget))
- params.state_type = GTK_WIDGET_STATE (widget);
+ state_type = GTK_WIDGET_STATE (widget);
- if (widget && (ge_is_in_combo_box (widget) || GE_IS_SPIN_BUTTON (widget)))
+ clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
+
+ if (CHECK_HINT (GE_HINT_COMBOBOX_ENTRY) || CHECK_HINT (GE_HINT_SPINBUTTON))
{
width += style->xthickness;
if (!params.ltr)
x -= style->xthickness;
-
+
if (params.ltr)
params.corners = CR_CORNER_TOPLEFT | CR_CORNER_BOTTOMLEFT;
else
params.corners = CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMRIGHT;
}
+ /* Fill the background as it is initilized to base[NORMAL].
+ * Relevant GTK+ bug: http://bugzilla.gnome.org/show_bug.cgi?id=513471
+ * The fill only happens if no hint has been added by some application
+ * that is faking GTK+ widgets. */
+ if (!widget || !g_object_get_data(G_OBJECT (widget), "transparent-bg-hint"))
+ {
+ cairo_rectangle (cr, 0, 0, width, height);
+ ge_cairo_set_color (cr, ¶ms.parentbg);
+ cairo_fill (cr);
+ }
+
STYLE_FUNCTION (draw_entry) (cr, &clearlooks_style->colors, ¶ms,
- x, y, width, height);
+ x, y, width, height);
}
- else if (DETAIL ("frame") && widget && GE_IS_STATUSBAR (widget->parent))
+ else if (DETAIL ("frame") && CHECK_HINT (GE_HINT_STATUSBAR))
{
WidgetParameters params;
-
+
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
gtk_style_apply_default_background (style, window, TRUE, state_type,
area, x, y, width, height);
-
- STYLE_FUNCTION (draw_statusbar) (cr, colors, ¶ms,
- x, y, width, height);
+ if (shadow_type != GTK_SHADOW_NONE)
+ STYLE_FUNCTION (draw_statusbar) (cr, colors, ¶ms,
+ x, y, width, height);
}
- else if (DETAIL ("frame"))
+ else if (DETAIL ("frame") || DETAIL ("calendar"))
{
WidgetParameters params;
FrameParameters frame;
frame.shadow = shadow_type;
- frame.gap_x = -1; /* No gap will be drawn */
+ frame.gap_x = -1; /* No gap will be drawn */
frame.border = &colors->shade[4];
-
+
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
params.corners = CR_CORNER_NONE;
-
+
if (widget && !g_str_equal ("XfcePanelWindow", gtk_widget_get_name (gtk_widget_get_toplevel (widget))))
STYLE_FUNCTION(draw_frame) (cr, colors, ¶ms, &frame,
- x, y, width, height);
+ x, y, width, height);
}
else if (DETAIL ("scrolled_window") || DETAIL ("viewport") || detail == NULL)
{
- CairoColor *border = (CairoColor*)&colors->shade[5];
+ CairoColor border;
+
+ if (CLEARLOOKS_STYLE (style)->style == CL_STYLE_CLASSIC)
+ ge_shade_color ((CairoColor*)&colors->bg[0], 0.78, &border);
+ else
+ border = colors->shade[5];
+
cairo_rectangle (cr, x+0.5, y+0.5, width-1, height-1);
- ge_cairo_set_color (cr, border);
+ ge_cairo_set_color (cr, &border);
cairo_set_line_width (cr, 1);
cairo_stroke (cr);
}
frame.border = &colors->shade[5];
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
params.corners = CR_CORNER_ALL;
-
+
STYLE_FUNCTION(draw_frame) (cr, colors, ¶ms, &frame, x, y, width, height);
}
-
+
cairo_destroy (cr);
}
-static void
+static void
clearlooks_style_draw_box_gap (DRAW_ARGS,
- GtkPositionType gap_side,
- gint gap_x,
- gint gap_width)
+ GtkPositionType gap_side,
+ gint gap_x,
+ gint gap_width)
{
ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
ClearlooksColors *colors = &clearlooks_style->colors;
WidgetParameters params;
FrameParameters frame;
gboolean start, end;
-
+
frame.shadow = shadow_type;
frame.gap_side = gap_side;
frame.gap_x = gap_x;
frame.gap_width = gap_width;
frame.border = &colors->shade[5];
-
+
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
clearlooks_get_notebook_tab_position (widget, &start, &end);
params.corners = CR_CORNER_ALL;
- switch (gap_side) {
- case GTK_POS_LEFT:
- if (start)
- params.corners ^= CR_CORNER_TOPLEFT;
- if (end)
- params.corners ^= CR_CORNER_BOTTOMLEFT;
- break;
- case GTK_POS_RIGHT:
- if (start)
- params.corners ^= CR_CORNER_TOPRIGHT;
- if (end)
- params.corners ^= CR_CORNER_BOTTOMRIGHT;
- break;
+ switch (gap_side)
+ {
case GTK_POS_TOP:
- if (ge_widget_is_ltr (widget)) {
+ if (ge_widget_is_ltr (widget))
+ {
if (start)
params.corners ^= CR_CORNER_TOPLEFT;
if (end)
params.corners ^= CR_CORNER_TOPRIGHT;
- } else {
+ }
+ else
+ {
if (start)
params.corners ^= CR_CORNER_TOPRIGHT;
if (end)
}
break;
case GTK_POS_BOTTOM:
- if (ge_widget_is_ltr (widget)) {
+ if (ge_widget_is_ltr (widget))
+ {
if (start)
params.corners ^= CR_CORNER_BOTTOMLEFT;
if (end)
params.corners ^= CR_CORNER_BOTTOMRIGHT;
- } else {
+ }
+ else
+ {
if (start)
params.corners ^= CR_CORNER_BOTTOMRIGHT;
if (end)
params.corners ^= CR_CORNER_BOTTOMLEFT;
}
break;
+ case GTK_POS_LEFT:
+ if (start)
+ params.corners ^= CR_CORNER_TOPLEFT;
+ if (end)
+ params.corners ^= CR_CORNER_BOTTOMLEFT;
+ break;
+ case GTK_POS_RIGHT:
+ if (start)
+ params.corners ^= CR_CORNER_TOPRIGHT;
+ if (end)
+ params.corners ^= CR_CORNER_BOTTOMRIGHT;
+ break;
}
/* Fill the background with bg[NORMAL] */
ge_cairo_rounded_rectangle (cr, x, y, width, height, params.radius, params.corners);
ge_cairo_set_color (cr, &colors->bg[GTK_STATE_NORMAL]);
cairo_fill (cr);
-
+
STYLE_FUNCTION(draw_frame) (cr, colors, ¶ms, &frame,
- x, y, width, height);
+ x, y, width, height);
}
else
{
- clearlooks_parent_class->draw_box_gap (style, window, state_type, shadow_type,
- area, widget, detail,
- x, y, width, height,
- gap_side, gap_x, gap_width);
+ GTK_STYLE_CLASS (clearlooks_style_parent_class)->draw_box_gap (style, window, state_type, shadow_type,
+ area, widget, detail,
+ x, y, width, height,
+ gap_side, gap_x, gap_width);
}
-
- cairo_destroy (cr);
+
+ cairo_destroy (cr);
}
static void
SANITIZE_SIZE
cr = ge_gdk_drawable_to_cairo (window, area);
-
+
if (DETAIL ("tab"))
{
WidgetParameters params;
TabParameters tab;
-
+ FocusParameters focus;
+
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
-
+
tab.gap_side = (ClearlooksGapSide)gap_side;
-
+
switch (gap_side)
{
+ case CL_GAP_TOP:
+ params.corners = CR_CORNER_BOTTOMLEFT | CR_CORNER_BOTTOMRIGHT;
+ break;
case CL_GAP_BOTTOM:
params.corners = CR_CORNER_TOPLEFT | CR_CORNER_TOPRIGHT;
break;
- case CL_GAP_TOP:
- params.corners = CR_CORNER_BOTTOMLEFT | CR_CORNER_BOTTOMRIGHT;
+ case CL_GAP_LEFT:
+ params.corners = CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMRIGHT;
break;
case CL_GAP_RIGHT:
params.corners = CR_CORNER_TOPLEFT | CR_CORNER_BOTTOMLEFT;
break;
- case CL_GAP_LEFT:
- params.corners = CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMRIGHT;
}
-
+
+ /* Focus color */
+ if (clearlooks_style->has_focus_color)
+ {
+ ge_gdk_color_to_cairo (&clearlooks_style->focus_color, &focus.color);
+ focus.has_color = TRUE;
+ }
+ else
+ focus.color = colors->bg[GTK_STATE_SELECTED];
+
+ tab.focus = focus;
+
STYLE_FUNCTION(draw_tab) (cr, colors, ¶ms, &tab,
- x, y, width, height);
+ x, y, width, height);
}
else
{
- clearlooks_parent_class->draw_extension (style, window, state_type, shadow_type, area,
- widget, detail, x, y, width, height,
- gap_side);
-
+ GTK_STYLE_CLASS (clearlooks_style_parent_class)->draw_extension (style, window, state_type, shadow_type, area,
+ widget, detail, x, y, width, height,
+ gap_side);
}
-
+
cairo_destroy (cr);
}
-static void
+static void
clearlooks_style_draw_handle (DRAW_ARGS, GtkOrientation orientation)
{
ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
ClearlooksColors *colors = &clearlooks_style->colors;
cairo_t *cr;
- gboolean is_horizontal;
-
+
CHECK_ARGS
SANITIZE_SIZE
-
+
cr = ge_gdk_drawable_to_cairo (window, area);
-
- /* Evil hack to work around broken orientation for toolbars */
- is_horizontal = (width > height);
-
+
if (DETAIL ("handlebox"))
{
WidgetParameters params;
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
handle.type = CL_HANDLE_TOOLBAR;
- handle.horizontal = is_horizontal;
-
- /* Is this ever true? -Daniel */
- if (GE_IS_TOOLBAR (widget) && shadow_type != GTK_SHADOW_NONE)
- {
- ToolbarParameters toolbar;
+ handle.horizontal = (orientation == GTK_ORIENTATION_HORIZONTAL);
- clearlooks_set_toolbar_parameters (&toolbar, widget, window, x, y);
-
- toolbar.style = clearlooks_style->toolbarstyle;
-
- cairo_save (cr);
- STYLE_FUNCTION(draw_toolbar) (cr, colors, ¶ms, &toolbar, x, y, width, height);
- cairo_restore (cr);
- }
-
STYLE_FUNCTION(draw_handle) (cr, colors, ¶ms, &handle,
- x, y, width, height);
+ x, y, width, height);
}
else if (DETAIL ("paned"))
{
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
handle.type = CL_HANDLE_SPLITTER;
- handle.horizontal = orientation == GTK_ORIENTATION_HORIZONTAL;
-
+ handle.horizontal = (orientation == GTK_ORIENTATION_HORIZONTAL);
+
STYLE_FUNCTION(draw_handle) (cr, colors, ¶ms, &handle,
- x, y, width, height);
+ x, y, width, height);
}
else
{
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
handle.type = CL_HANDLE_TOOLBAR;
- handle.horizontal = is_horizontal;
-
- /* Is this ever true? -Daniel */
- if (GE_IS_TOOLBAR (widget) && shadow_type != GTK_SHADOW_NONE)
- {
- ToolbarParameters toolbar;
+ handle.horizontal = (orientation == GTK_ORIENTATION_HORIZONTAL);
- clearlooks_set_toolbar_parameters (&toolbar, widget, window, x, y);
-
- toolbar.style = clearlooks_style->toolbarstyle;
-
- cairo_save (cr);
- STYLE_FUNCTION(draw_toolbar) (cr, colors, ¶ms, &toolbar, x, y, width, height);
- cairo_restore (cr);
- }
-
STYLE_FUNCTION(draw_handle) (cr, colors, ¶ms, &handle,
- x, y, width, height);
+ x, y, width, height);
}
cairo_destroy (cr);
CHECK_ARGS
SANITIZE_SIZE
- if (DETAIL ("menubar") && !ge_is_panel_widget_item(widget))
+ if (DETAIL ("menubar"))
{
WidgetParameters params;
MenuBarParameters menubar;
-
+ gboolean horizontal;
+
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
menubar.style = clearlooks_style->menubarstyle;
- STYLE_FUNCTION(draw_menubar) (cr, colors, ¶ms, &menubar,
- x, y, width, height);
+ horizontal = height < 2*width;
+ /* This is not that great. Ideally we would have a nice vertical menubar. */
+ if ((shadow_type != GTK_SHADOW_NONE) && horizontal)
+ STYLE_FUNCTION(draw_menubar) (cr, colors, ¶ms, &menubar,
+ x, y, width, height);
}
- else if (DETAIL ("button") && widget && widget->parent &&
- (GE_IS_TREE_VIEW(widget->parent) ||
- GE_IS_CLIST (widget->parent) ||
- ge_object_is_a (G_OBJECT(widget->parent), "ETree"))) /* ECanvas inside ETree */
+ else if (DETAIL ("button") && CHECK_HINT (GE_HINT_TREEVIEW_HEADER))
{
WidgetParameters params;
ListViewHeaderParameters header;
-
+
gint columns, column_index;
gboolean resizable = TRUE;
-
- /* XXX: This makes unknown treeview header CL_ORDER_MIDDLE, in need for something nicer */
+
+ /* XXX: This makes unknown treeview header "middle", in need for something nicer */
columns = 3;
column_index = 1;
-
+
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
-
+
params.corners = CR_CORNER_NONE;
-
+
if (GE_IS_TREE_VIEW (widget->parent))
{
clearlooks_treeview_get_header_index (GTK_TREE_VIEW(widget->parent),
- widget, &column_index, &columns,
- &resizable);
+ widget, &column_index, &columns,
+ &resizable);
}
else if (GE_IS_CLIST (widget->parent))
{
clearlooks_clist_get_header_index (GTK_CLIST(widget->parent),
- widget, &column_index, &columns);
+ widget, &column_index, &columns);
}
-
+
header.resizable = resizable;
-
+
+ header.order = 0;
if (column_index == 0)
- header.order = params.ltr ? CL_ORDER_FIRST : CL_ORDER_LAST;
- else if (column_index == columns-1)
- header.order = params.ltr ? CL_ORDER_LAST : CL_ORDER_FIRST;
- else
- header.order = CL_ORDER_MIDDLE;
-
+ header.order |= params.ltr ? CL_ORDER_FIRST : CL_ORDER_LAST;
+ if (column_index == columns-1)
+ header.order |= params.ltr ? CL_ORDER_LAST : CL_ORDER_FIRST;
+
gtk_style_apply_default_background (style, window, FALSE, state_type, area, x, y, width, height);
-
+
STYLE_FUNCTION(draw_list_view_header) (cr, colors, ¶ms, &header,
- x, y, width, height);
+ x, y, width, height);
}
else if (DETAIL ("button") || DETAIL ("buttondefault"))
{
WidgetParameters params;
ShadowParameters shadow = { CR_CORNER_ALL, CL_SHADOW_NONE } ;
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
+ params.active = shadow_type == GTK_SHADOW_IN;
- if (ge_is_in_combo_box(widget))
+ if (CHECK_HINT (GE_HINT_COMBOBOX_ENTRY))
{
if (params.ltr)
params.corners = CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMRIGHT;
else
params.corners = CR_CORNER_TOPLEFT | CR_CORNER_BOTTOMLEFT;
-
+
shadow.shadow = CL_SHADOW_IN;
if (params.xthickness > 2)
if (params.ltr)
x--;
width++;
- }
+ }
}
else
{
- params.corners = CR_CORNER_ALL;
- /* if (!(ge_is_combo_box (widget, FALSE))) */
- params.enable_glow = TRUE;
- }
-
- if (GE_IS_TOGGLE_BUTTON (widget) &&
- gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
- params.active = TRUE;
-
+ params.corners = CR_CORNER_ALL;
+ if (clearlooks_style->reliefstyle != 0)
+ params.enable_shadow = TRUE;
+ }
+
STYLE_FUNCTION(draw_button) (cr, &clearlooks_style->colors, ¶ms,
x, y, width, height);
}
{
WidgetParameters params;
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
-
+
if (style->xthickness == 3)
{
width++;
if (params.ltr)
x--;
}
-
+
if (DETAIL ("spinbutton_up"))
{
height+=2;
else
params.corners = CR_CORNER_BOTTOMLEFT;
}
-
+
STYLE_FUNCTION(draw_spinbutton_down) (cr, &clearlooks_style->colors, ¶ms, x, y, width, height);
}
}
else if (DETAIL ("spinbutton"))
{
WidgetParameters params;
-
+
+ /* The "spinbutton" box is always drawn with state NORMAL, even if it is insensitive.
+ * So work around this here. */
+ if (state_type == GTK_STATE_NORMAL && widget && GE_IS_ENTRY (widget))
+ state_type = GTK_WIDGET_STATE (widget);
+
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
-
+
if (params.ltr)
params.corners = CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMRIGHT;
else
params.corners = CR_CORNER_TOPLEFT | CR_CORNER_BOTTOMLEFT;
-
+
if (style->xthickness == 3)
{
if (params.ltr)
x--;
width++;
}
-
+
STYLE_FUNCTION(draw_spinbutton) (cr, &clearlooks_style->colors, ¶ms,
- x, y, width, height);
+ x, y, width, height);
}
- else if (detail && g_str_has_prefix (detail, "trough") && GE_IS_SCALE (widget))
+ else if (detail && g_str_has_prefix (detail, "trough") && CHECK_HINT (GE_HINT_SCALE))
{
WidgetParameters params;
SliderParameters slider;
-
+
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
params.corners = CR_CORNER_NONE;
-
+
slider.lower = DETAIL ("trough-lower");
slider.fill_level = DETAIL ("trough-fill-level") || DETAIL ("trough-fill-level-full");
- slider.horizontal = (GTK_RANGE (widget)->orientation == GTK_ORIENTATION_HORIZONTAL);
-
+ if (CHECK_HINT (GE_HINT_HSCALE))
+ slider.horizontal = TRUE;
+ else if (CHECK_HINT (GE_HINT_VSCALE))
+ slider.horizontal = FALSE;
+ else /* Fallback based on the size... */
+ slider.horizontal = width >= height;
+
STYLE_FUNCTION(draw_scale_trough) (cr, &clearlooks_style->colors,
- ¶ms, &slider,
- x, y, width, height);
+ ¶ms, &slider,
+ x, y, width, height);
}
- else if (DETAIL ("trough") && widget && GE_IS_PROGRESS_BAR (widget))
+ else if (DETAIL ("trough") && CHECK_HINT (GE_HINT_PROGRESSBAR))
{
WidgetParameters params;
-
- clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
-
- STYLE_FUNCTION(draw_progressbar_trough) (cr, colors, ¶ms,
- x, y, width, height);
+
+ clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
+
+ /* Fill the background as it is initilized to base[NORMAL].
+ * Relevant GTK+ bug: http://bugzilla.gnome.org/show_bug.cgi?id=513476
+ * The fill only happens if no hint has been added by some application
+ * that is faking GTK+ widgets. */
+ if (!widget || !g_object_get_data(G_OBJECT (widget), "transparent-bg-hint"))
+ {
+ cairo_rectangle (cr, 0, 0, width, height);
+ ge_cairo_set_color (cr, ¶ms.parentbg);
+ cairo_fill (cr);
+ }
+ STYLE_FUNCTION(draw_progressbar_trough) (cr, colors, ¶ms,
+ x, y, width, height);
}
- else if (DETAIL ("trough") && widget && (GE_IS_VSCROLLBAR (widget) || GE_IS_HSCROLLBAR (widget)))
+ else if (DETAIL ("trough") && CHECK_HINT (GE_HINT_SCROLLBAR))
{
WidgetParameters params;
ScrollBarParameters scrollbar;
-
+ gboolean trough_under_steppers = TRUE;
+ ClearlooksStepper steppers;
+
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
- params.corners = CR_CORNER_NONE;
-
+ params.corners = CR_CORNER_ALL;
+
scrollbar.horizontal = TRUE;
scrollbar.junction = clearlooks_scrollbar_get_junction (widget);
- if (GE_IS_RANGE (widget))
- scrollbar.horizontal = GTK_RANGE (widget)->orientation == GTK_ORIENTATION_HORIZONTAL;
-
- if (scrollbar.horizontal)
- {
- x += 2;
- width -= 4;
- }
- else
+ steppers = clearlooks_scrollbar_visible_steppers (widget);
+
+ if (CHECK_HINT (GE_HINT_HSCROLLBAR))
+ scrollbar.horizontal = TRUE;
+ else if (CHECK_HINT (GE_HINT_VSCROLLBAR))
+ scrollbar.horizontal = FALSE;
+ else /* Fallback based on the size ... */
+ scrollbar.horizontal = width >= height;
+
+ if (widget)
+ gtk_widget_style_get (widget,
+ "trough-under-steppers", &trough_under_steppers,
+ NULL);
+
+ if (trough_under_steppers)
{
- y += 2;
- height -= 4;
+ /* If trough under steppers is set, then we decrease the size
+ * slightly. The size is decreased so that the trough is not
+ * visible underneath the steppers. This is not really needed
+ * as one can use the trough-under-steppers style property,
+ * but it needs to exist for backward compatibility. */
+ if (scrollbar.horizontal)
+ {
+ if (steppers & (CL_STEPPER_A | CL_STEPPER_B))
+ {
+ x += 2;
+ width -= 2;
+ }
+ if (steppers & (CL_STEPPER_C | CL_STEPPER_D))
+ {
+ width -= 2;
+ }
+ }
+ else
+ {
+ if (steppers & (CL_STEPPER_A | CL_STEPPER_B))
+ {
+ y += 2;
+ height -= 2;
+ }
+ if (steppers & (CL_STEPPER_C | CL_STEPPER_D))
+ {
+ height -= 2;
+ }
+ }
}
-
+
STYLE_FUNCTION(draw_scrollbar_trough) (cr, colors, ¶ms, &scrollbar,
- x, y, width, height);
+ x, y, width, height);
}
else if (DETAIL ("bar"))
{
#ifdef HAVE_ANIMATION
if(clearlooks_style->animation && CL_IS_PROGRESS_BAR (widget))
- {
+ {
gboolean activity_mode = GTK_PROGRESS (widget)->activity_mode;
-
- if (!activity_mode)
+
+ if (!activity_mode)
clearlooks_animation_progressbar_add ((gpointer)widget);
}
progressbar.value = 0;
progressbar.pulsing = FALSE;
}
-
+
if (!params.ltr)
{
if (progressbar.orientation == GTK_PROGRESS_LEFT_TO_RIGHT)
tmp.height += 2;
}
}
-
+
cairo_reset_clip (cr);
gdk_cairo_rectangle (cr, &tmp);
cairo_clip (cr);
}
-
+
STYLE_FUNCTION(draw_progressbar_fill) (cr, colors, ¶ms, &progressbar,
- x, y, width, height,
- 10 - (int)(elapsed * 10.0) % 10);
+ x, y, width, height,
+ 10 - (int)(elapsed * 10.0) % 10);
}
else if (DETAIL ("optionmenu"))
{
WidgetParameters params;
OptionMenuParameters optionmenu;
-
+
GtkRequisition indicator_size;
GtkBorder indicator_spacing;
-
+
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
-
- params.enable_glow = TRUE;
+
+ if (clearlooks_style->reliefstyle != 0)
+ params.enable_shadow = TRUE;
ge_option_menu_get_props (widget, &indicator_size, &indicator_spacing);
-
+
if (ge_widget_is_ltr (widget))
optionmenu.linepos = width - (indicator_size.width + indicator_spacing.left + indicator_spacing.right) - 1;
else
optionmenu.linepos = (indicator_size.width + indicator_spacing.left + indicator_spacing.right) + 1;
-
+
STYLE_FUNCTION(draw_optionmenu) (cr, colors, ¶ms, &optionmenu,
- x, y, width, height);
+ x, y, width, height);
}
else if (DETAIL ("menuitem"))
{
WidgetParameters params;
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
-
- if (widget && GE_IS_MENU_BAR (widget->parent))
+
+ if (CHECK_HINT (GE_HINT_MENUBAR))
{
params.corners = CR_CORNER_TOPLEFT | CR_CORNER_TOPRIGHT;
height += 1;
STYLE_FUNCTION(draw_menubaritem) (cr, colors, ¶ms, x, y, width, height);
}
else
- {
+ {
params.corners = CR_CORNER_ALL;
STYLE_FUNCTION(draw_menuitem) (cr, colors, ¶ms, x, y, width, height);
}
ScrollBarParameters scrollbar;
ScrollBarStepperParameters stepper;
GdkRectangle this_rectangle;
-
+
this_rectangle.x = x;
this_rectangle.y = y;
this_rectangle.width = width;
this_rectangle.height = height;
-
+
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
params.corners = CR_CORNER_NONE;
-
+
scrollbar.has_color = FALSE;
scrollbar.horizontal = TRUE;
scrollbar.junction = clearlooks_scrollbar_get_junction (widget);
- if (clearlooks_style->colorize_scrollbar || clearlooks_style->has_scrollbar_color) {
+ if (clearlooks_style->colorize_scrollbar || clearlooks_style->has_scrollbar_color)
scrollbar.has_color = TRUE;
- }
scrollbar.horizontal = DETAIL ("hscrollbar");
-
+
stepper.stepper = clearlooks_scrollbar_get_stepper (widget, &this_rectangle);
STYLE_FUNCTION(draw_scrollbar_stepper) (cr, colors, ¶ms, &scrollbar, &stepper,
- x, y, width, height);
+ x, y, width, height);
}
else if (DETAIL ("toolbar") || DETAIL ("handlebox_bin") || DETAIL ("dockitem_bin"))
{
WidgetParameters params;
ToolbarParameters toolbar;
+ gboolean horizontal;
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
clearlooks_set_toolbar_parameters (&toolbar, widget, window, x, y);
toolbar.style = clearlooks_style->toolbarstyle;
- /* Only draw the shadows on horizontal toolbars */
- if (shadow_type != GTK_SHADOW_NONE && height < 2*width )
+ if ((DETAIL ("handlebox_bin") || DETAIL ("dockitem_bin")) && GE_IS_BIN (widget))
+ {
+ GtkWidget* child = gtk_bin_get_child ((GtkBin*) widget);
+ /* This is to draw the correct shadow on the handlebox.
+ * We need to draw it here, as otherwise the handle will not get the
+ * background. */
+ if (GE_IS_TOOLBAR (child))
+ gtk_widget_style_get (child, "shadow-type", &shadow_type, NULL);
+ }
+
+ horizontal = height < 2*width;
+ /* This is not that great. Ideally we would have a nice vertical toolbar. */
+ if ((shadow_type != GTK_SHADOW_NONE) && horizontal)
STYLE_FUNCTION(draw_toolbar) (cr, colors, ¶ms, &toolbar, x, y, width, height);
}
else if (DETAIL ("trough"))
{
-
+ /* Nothing? Why benjamin? */
}
else if (DETAIL ("menu"))
{
WidgetParameters params;
-
+
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
-
+
STYLE_FUNCTION(draw_menu_frame) (cr, colors, ¶ms, x, y, width, height);
}
else if (DETAIL ("hseparator") || DETAIL ("vseparator"))
{
- const gchar *new_detail = detail;
+ gchar *new_detail = (gchar*) detail;
/* Draw a normal separator, we just use this because it gives more control
* over sizing (currently). */
if (GE_IS_MENU_ITEM (widget))
new_detail = "menuitem";
- if (DETAIL ("hseparator")) {
+ if (DETAIL ("hseparator"))
+ {
gtk_paint_hline (style, window, state_type, area, widget, new_detail,
x, x + width - 1, y + height/2);
- } else
+ }
+ else
gtk_paint_vline (style, window, state_type, area, widget, new_detail,
y, y + height - 1, x + width/2);
}
else
{
- clearlooks_parent_class->draw_box (style, window, state_type, shadow_type, area,
- widget, detail, x, y, width, height);
+ GTK_STYLE_CLASS (clearlooks_style_parent_class)->draw_box (style, window, state_type, shadow_type, area,
+ widget, detail, x, y, width, height);
}
-
+
cairo_destroy (cr);
}
CHECK_ARGS
SANITIZE_SIZE
-
+
if (DETAIL ("hscale") || DETAIL ("vscale"))
{
WidgetParameters params;
SliderParameters slider;
-
+
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
-
+
slider.horizontal = (orientation == GTK_ORIENTATION_HORIZONTAL);
slider.lower = FALSE;
slider.fill_level = FALSE;
-
+
if (clearlooks_style->style == CL_STYLE_GLOSSY) /* XXX! */
params.corners = CR_CORNER_ALL;
-
+
STYLE_FUNCTION(draw_slider_button) (cr, &clearlooks_style->colors,
- ¶ms, &slider,
- x, y, width, height);
+ ¶ms, &slider,
+ x, y, width, height);
}
else if (DETAIL ("slider"))
{
scrollbar.horizontal = (orientation == GTK_ORIENTATION_HORIZONTAL);
scrollbar.junction = clearlooks_scrollbar_get_junction (widget);
- if (clearlooks_style->colorize_scrollbar) {
+ if (clearlooks_style->colorize_scrollbar)
+ {
scrollbar.color = colors->spot[1];
scrollbar.has_color = TRUE;
}
if ((clearlooks_style->style == CL_STYLE_GLOSSY || clearlooks_style->style == CL_STYLE_GUMMY)
&& !scrollbar.has_color)
scrollbar.color = colors->bg[0];
-
+
STYLE_FUNCTION(draw_scrollbar_slider) (cr, colors, ¶ms, &scrollbar,
x, y, width, height);
}
else
{
- clearlooks_parent_class->draw_slider (style, window, state_type, shadow_type, area,
- widget, detail, x, y, width, height, orientation);
+ GTK_STYLE_CLASS (clearlooks_style_parent_class)->draw_slider (style, window, state_type, shadow_type, area,
+ widget, detail, x, y, width, height, orientation);
}
cairo_destroy (cr);
WidgetParameters params;
CheckboxParameters checkbox;
cairo_t *cr;
-
+
CHECK_ARGS
SANITIZE_SIZE
cr = ge_gdk_drawable_to_cairo (window, area);
colors = &clearlooks_style->colors;
-
+
checkbox.shadow_type = shadow_type;
checkbox.in_menu = (widget && GTK_IS_MENU(widget->parent));
-
+
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
-
+
STYLE_FUNCTION(draw_radiobutton) (cr, colors, ¶ms, &checkbox, x, y, width, height);
cairo_destroy (cr);
SANITIZE_SIZE
cr = ge_gdk_drawable_to_cairo (window, area);
-
+
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
-
+
params.corners = CR_CORNER_ALL;
-
+
checkbox.shadow_type = shadow_type;
checkbox.in_cell = DETAIL("cellcheck");
checkbox.in_menu = (widget && widget->parent && GTK_IS_MENU(widget->parent));
STYLE_FUNCTION(draw_checkbox) (cr, &clearlooks_style->colors, ¶ms, &checkbox,
- x, y, width, height);
-
+ x, y, width, height);
+
cairo_destroy (cr);
}
* (and even if, a normal one should be better on menu bars) */
STYLE_FUNCTION(draw_separator) (cr, colors, NULL, &separator,
x, y1, 2, y2-y1+1);
-
+
cairo_destroy (cr);
}
colors = &clearlooks_style->colors;
cr = ge_gdk_drawable_to_cairo (window, area);
-
+
separator.horizontal = TRUE;
-
+
if (!DETAIL ("menuitem"))
STYLE_FUNCTION(draw_separator) (cr, colors, NULL, &separator,
x1, y, x2-x1+1, 2);
else
STYLE_FUNCTION(draw_menu_item_separator) (cr, colors, NULL, &separator,
- x1, y, x2-x1+1, 2);
-
+ x1, y, x2-x1+1, 2);
+
cairo_destroy (cr);
}
-static void
+static void
clearlooks_style_draw_shadow_gap (DRAW_ARGS,
- GtkPositionType gap_side,
- gint gap_x,
- gint gap_width)
+ GtkPositionType gap_side,
+ gint gap_x,
+ gint gap_width)
{
ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
const ClearlooksColors *colors;
cr = ge_gdk_drawable_to_cairo (window, area);
colors = &clearlooks_style->colors;
-
+
if (DETAIL ("frame"))
{
WidgetParameters params;
FrameParameters frame;
-
+
frame.shadow = shadow_type;
frame.gap_side = gap_side;
frame.gap_x = gap_x;
frame.gap_width = gap_width;
frame.border = &colors->shade[5];
-
+
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
params.corners = CR_CORNER_ALL;
-
+
STYLE_FUNCTION(draw_frame) (cr, colors, ¶ms, &frame,
- x, y, width, height);
+ x, y, width, height);
}
else
{
- clearlooks_parent_class->draw_shadow_gap (style, window, state_type, shadow_type, area,
- widget, detail, x, y, width, height,
- gap_side, gap_x, gap_width);
+ GTK_STYLE_CLASS (clearlooks_style_parent_class)->draw_shadow_gap (style, window, state_type, shadow_type, area,
+ widget, detail, x, y, width, height,
+ gap_side, gap_x, gap_width);
}
-
+
cairo_destroy (cr);
}
static void
clearlooks_style_draw_resize_grip (GtkStyle *style,
- GdkWindow *window,
- GtkStateType state_type,
- GdkRectangle *area,
- GtkWidget *widget,
- const gchar *detail,
- GdkWindowEdge edge,
- gint x,
- gint y,
- gint width,
- gint height)
+ GdkWindow *window,
+ GtkStateType state_type,
+ GdkRectangle *area,
+ GtkWidget *widget,
+ const gchar *detail,
+ GdkWindowEdge edge,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
{
ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
ClearlooksColors *colors = &clearlooks_style->colors;
cr = ge_gdk_drawable_to_cairo (window, area);
- clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
+ clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
STYLE_FUNCTION(draw_resize_grip) (cr, colors, ¶ms, &grip,
- x, y, width, height);
+ x, y, width, height);
cairo_destroy (cr);
}
ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
ClearlooksColors *colors = &clearlooks_style->colors;
WidgetParameters params;
- ArrowParameters arrow;
+ ArrowParameters arrow;
cairo_t *cr;
CHECK_ARGS
SANITIZE_SIZE
-
+
cr = ge_gdk_drawable_to_cairo (window, area);
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
arrow.type = CL_ARROW_COMBO;
- arrow.direction = CL_DIRECTION_DOWN;
+ arrow.direction = CL_DIRECTION_DOWN;
STYLE_FUNCTION(draw_arrow) (cr, colors, ¶ms, &arrow, x, y, width, height);
static void
clearlooks_style_draw_arrow (GtkStyle *style,
- GdkWindow *window,
- GtkStateType state_type,
- GtkShadowType shadow,
- GdkRectangle *area,
- GtkWidget *widget,
- const gchar *detail,
- GtkArrowType arrow_type,
- gboolean fill,
- gint x,
- gint y,
- gint width,
- gint height)
+ GdkWindow *window,
+ GtkStateType state_type,
+ GtkShadowType shadow,
+ GdkRectangle *area,
+ GtkWidget *widget,
+ const gchar *detail,
+ GtkArrowType arrow_type,
+ gboolean fill,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
{
ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
ClearlooksColors *colors = &clearlooks_style->colors;
CHECK_ARGS
SANITIZE_SIZE
- if (arrow_type == GTK_ARROW_NONE) {
+ if (arrow_type == GTK_ARROW_NONE)
+ {
cairo_destroy (cr);
return;
}
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
arrow.type = CL_ARROW_NORMAL;
arrow.direction = (ClearlooksDirection)arrow_type;
-
+
if (ge_is_combo_box (widget, FALSE) && !ge_is_combo_box_entry (widget))
{
arrow.type = CL_ARROW_COMBO;
}
-
+
/* I have no idea why, but the arrow of GtkCombo is larger than in other places.
* Subtracting 3 seems to fix this. */
if (widget && widget->parent && GE_IS_COMBO (widget->parent->parent))
x += 2;
width -= 3;
}
-
+
STYLE_FUNCTION(draw_arrow) (cr, colors, ¶ms, &arrow, x, y, width, height);
-
+
cairo_destroy (cr);
}
static void
clearlooks_style_init_from_rc (GtkStyle * style,
- GtkRcStyle * rc_style)
+ GtkRcStyle * rc_style)
{
ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
-
- clearlooks_parent_class->init_from_rc (style, rc_style);
-
+
+ GTK_STYLE_CLASS (clearlooks_style_parent_class)->init_from_rc (style, rc_style);
+
g_assert ((CLEARLOOKS_RC_STYLE (rc_style)->style >= 0) && (CLEARLOOKS_RC_STYLE (rc_style)->style < CL_NUM_STYLES));
- clearlooks_style->style = CLEARLOOKS_RC_STYLE (rc_style)->style;
-
- clearlooks_style->menubarstyle = CLEARLOOKS_RC_STYLE (rc_style)->menubarstyle;
- clearlooks_style->toolbarstyle = CLEARLOOKS_RC_STYLE (rc_style)->toolbarstyle;
+ clearlooks_style->style = CLEARLOOKS_RC_STYLE (rc_style)->style;
+
+ clearlooks_style->reliefstyle = CLEARLOOKS_RC_STYLE (rc_style)->reliefstyle;
+ clearlooks_style->menubarstyle = CLEARLOOKS_RC_STYLE (rc_style)->menubarstyle;
+ clearlooks_style->toolbarstyle = CLEARLOOKS_RC_STYLE (rc_style)->toolbarstyle;
+ clearlooks_style->has_focus_color = CLEARLOOKS_RC_STYLE (rc_style)->flags & CL_FLAG_FOCUS_COLOR;
clearlooks_style->has_scrollbar_color = CLEARLOOKS_RC_STYLE (rc_style)->flags & CL_FLAG_SCROLLBAR_COLOR;
- clearlooks_style->colorize_scrollbar = CLEARLOOKS_RC_STYLE (rc_style)->colorize_scrollbar;
- clearlooks_style->animation = CLEARLOOKS_RC_STYLE (rc_style)->animation;
- clearlooks_style->radius = CLAMP (CLEARLOOKS_RC_STYLE (rc_style)->radius, 0.0, 10.0);
+ clearlooks_style->colorize_scrollbar = CLEARLOOKS_RC_STYLE (rc_style)->colorize_scrollbar;
+ clearlooks_style->animation = CLEARLOOKS_RC_STYLE (rc_style)->animation;
+ clearlooks_style->radius = CLAMP (CLEARLOOKS_RC_STYLE (rc_style)->radius, 0.0, 10.0);
+ if (clearlooks_style->has_focus_color)
+ clearlooks_style->focus_color = CLEARLOOKS_RC_STYLE (rc_style)->focus_color;
if (clearlooks_style->has_scrollbar_color)
clearlooks_style->scrollbar_color = CLEARLOOKS_RC_STYLE (rc_style)->scrollbar_color;
}
CairoColor bg_normal;
double contrast;
int i;
-
- clearlooks_parent_class->realize (style);
+
+ GTK_STYLE_CLASS (clearlooks_style_parent_class)->realize (style);
contrast = CLEARLOOKS_RC_STYLE (style->rc_style)->contrast;
-
+
/* Lighter to darker */
ge_gdk_color_to_cairo (&style->bg[GTK_STATE_NORMAL], &bg_normal);
for (i = 0; i < 9; i++)
{
- ge_shade_color(&bg_normal, (shades[i]-0.7) * contrast + 0.7, &clearlooks_style->colors.shade[i]);
+ ge_shade_color (&bg_normal, (shades[i] < 1.0) ?
+ (shades[i]/contrast) : (shades[i]*contrast),
+ &clearlooks_style->colors.shade[i]);
}
-
+
ge_gdk_color_to_cairo (&style->bg[GTK_STATE_SELECTED], &spot_color);
-
- ge_shade_color(&spot_color, 1.42, &clearlooks_style->colors.spot[0]);
- ge_shade_color(&spot_color, 1.05, &clearlooks_style->colors.spot[1]);
- ge_shade_color(&spot_color, 0.65, &clearlooks_style->colors.spot[2]);
-
+
+ /* Andrea Cimitan wants something like the following to handle dark themes.
+ * However, these two lines are broken currently, as ge_hsb_from_color expects
+ * a CairoColor and not GdkColor
+ * ge_hsb_from_color (&style->bg[GTK_STATE_SELECTED], &hue_spot, &saturation_spot, &brightness_spot);
+ * ge_hsb_from_color (&style->bg[GTK_STATE_NORMAL], &hue_bg, &saturation_bg, &brightness_bg);
+ */
+
+ /* Here to place some checks for dark themes.
+ * We should use a different shade value for spot[2]. */
+
+ ge_shade_color (&spot_color, 1.25, &clearlooks_style->colors.spot[0]);
+ ge_shade_color (&spot_color, 1.05, &clearlooks_style->colors.spot[1]);
+ ge_shade_color (&spot_color, 0.65, &clearlooks_style->colors.spot[2]);
+
for (i=0; i<5; i++)
{
ge_gdk_color_to_cairo (&style->fg[i], &clearlooks_style->colors.fg[i]);
static void
clearlooks_style_draw_focus (GtkStyle *style, GdkWindow *window, GtkStateType state_type,
- GdkRectangle *area, GtkWidget *widget, const gchar *detail,
- gint x, gint y, gint width, gint height)
+ GdkRectangle *area, GtkWidget *widget, const gchar *detail,
+ gint x, gint y, gint width, gint height)
{
+ ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
+ ClearlooksColors *colors = &clearlooks_style->colors;
+ WidgetParameters params;
+ FocusParameters focus;
+ guint8* dash_list;
+
cairo_t *cr;
- gboolean free_dash_list = FALSE;
- gint line_width = 1;
- gint8 *dash_list = (gint8 *)"\1\1";
- if (widget)
- {
- gtk_widget_style_get (widget,
- "focus-line-width", &line_width,
- "focus-line-pattern",
- (gchar *) & dash_list, NULL);
+ CHECK_ARGS
+ SANITIZE_SIZE
- free_dash_list = TRUE;
- }
+ cr = gdk_cairo_create (window);
- if (detail && !strcmp (detail, "add-mode"))
+ clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
+
+ /* Corners */
+ params.corners = CR_CORNER_ALL;
+ if (CHECK_HINT (GE_HINT_COMBOBOX_ENTRY))
{
- if (free_dash_list)
- g_free (dash_list);
+ if (params.ltr)
+ params.corners = CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMRIGHT;
+ else
+ params.corners = CR_CORNER_TOPLEFT | CR_CORNER_BOTTOMLEFT;
- dash_list = (gint8 *)"\4\4";
- free_dash_list = FALSE;
+ if (params.xthickness > 2)
+ {
+ if (params.ltr)
+ x--;
+ width++;
+ }
}
- CHECK_ARGS
- SANITIZE_SIZE
-
- cr = gdk_cairo_create (window);
+ focus.has_color = FALSE;
+ focus.interior = FALSE;
+ focus.line_width = 1;
+ focus.padding = 1;
+ dash_list = NULL;
- if (detail && !strcmp (detail, "colorwheel_light"))
- cairo_set_source_rgb (cr, 0., 0., 0.);
- else if (detail && !strcmp (detail, "colorwheel_dark"))
- cairo_set_source_rgb (cr, 1., 1., 1.);
+ if (widget)
+ {
+ gtk_widget_style_get (widget,
+ "focus-line-width", &focus.line_width,
+ "focus-line-pattern", &dash_list,
+ "focus-padding", &focus.padding,
+ "interior-focus", &focus.interior,
+ NULL);
+ }
+ if (dash_list)
+ focus.dash_list = dash_list;
else
- ge_cairo_set_gdk_color_with_alpha (cr, &style->fg[state_type],
- 0.7);
+ focus.dash_list = (guint8*) g_strdup ("\1\1");
- cairo_set_line_width (cr, line_width);
+ /* Focus type */
+ if (DETAIL("button"))
+ {
+ if (CHECK_HINT (GE_HINT_TREEVIEW_HEADER))
+ {
+ focus.type = CL_FOCUS_TREEVIEW_HEADER;
+ }
+ else
+ {
+ GtkReliefStyle relief = GTK_RELIEF_NORMAL;
+ /* Check for the shadow type. */
+ if (widget && GTK_IS_BUTTON (widget))
+ g_object_get (G_OBJECT (widget), "relief", &relief, NULL);
- if (dash_list[0])
+ if (relief == GTK_RELIEF_NORMAL)
+ focus.type = CL_FOCUS_BUTTON;
+ else
+ focus.type = CL_FOCUS_BUTTON_FLAT;
+
+ /* This is a workaround for the bogus focus handling that
+ * clearlooks has currently.
+ * I truely dislike putting it here, but I guess it is better
+ * then having such a visible bug. It should be removed in the
+ * next unstable release cycle. -- Benjamin */
+ if (ge_object_is_a (G_OBJECT (widget), "ButtonWidget"))
+ focus.type = CL_FOCUS_LABEL;
+ }
+ }
+ else if (detail && g_str_has_prefix (detail, "treeview"))
{
- gint n_dashes = strlen ((gchar *)dash_list);
- gdouble *dashes = g_new (gdouble, n_dashes);
- gdouble total_length = 0;
- gdouble dash_offset;
- gint i;
+ /* Focus in a treeview, and that means a lot of different detail strings. */
+ if (g_str_has_prefix (detail, "treeview-drop-indicator"))
+ focus.type = CL_FOCUS_TREEVIEW_DND;
+ else
+ focus.type = CL_FOCUS_TREEVIEW_ROW;
- for (i = 0; i < n_dashes; i++)
+ if (g_str_has_suffix (detail, "left"))
+ {
+ focus.continue_side = CL_CONT_RIGHT;
+ }
+ else if (g_str_has_suffix (detail, "right"))
+ {
+ focus.continue_side = CL_CONT_LEFT;
+ }
+ else if (g_str_has_suffix (detail, "middle"))
{
- dashes[i] = dash_list[i];
- total_length += dash_list[i];
+ focus.continue_side = CL_CONT_LEFT | CL_CONT_RIGHT;
+ }
+ else
+ {
+ /* This may either mean no continuation, or unknown ...
+ * if it is unknown we assume it continues on both sides */
+ gboolean row_ending_details = FALSE;
+
+ /* Try to get the style property. */
+ if (widget)
+ gtk_widget_style_get (widget,
+ "row-ending-details", &row_ending_details,
+ NULL);
+
+ if (row_ending_details)
+ focus.continue_side = CL_CONT_NONE;
+ else
+ focus.continue_side = CL_CONT_LEFT | CL_CONT_RIGHT;
}
- /* 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);
+ }
+ else if (detail && g_str_has_prefix (detail, "trough") && CHECK_HINT (GE_HINT_SCALE))
+ {
+ focus.type = CL_FOCUS_SCALE;
+ }
+ else if (DETAIL("tab"))
+ {
+ focus.type = CL_FOCUS_TAB;
+ }
+ else if (detail && g_str_has_prefix (detail, "colorwheel"))
+ {
+ if (DETAIL ("colorwheel_dark"))
+ focus.type = CL_FOCUS_COLOR_WHEEL_DARK;
+ else
+ focus.type = CL_FOCUS_COLOR_WHEEL_LIGHT;
+ }
+ else if (DETAIL("checkbutton") || DETAIL("radiobutton"))
+ {
+ focus.type = CL_FOCUS_LABEL; /* Let's call it "LABEL" :) */
+ }
+ else if (CHECK_HINT (GE_HINT_TREEVIEW))
+ {
+ focus.type = CL_FOCUS_TREEVIEW; /* Treeview without content is focused. */
+ }
+ else
+ {
+ focus.type = CL_FOCUS_UNKNOWN; /* Custom widgets (Beagle) and something unknown */
}
- if (area)
+ /* Focus color */
+ if (clearlooks_style->has_focus_color)
{
- gdk_cairo_rectangle (cr, area);
- cairo_clip (cr);
+ ge_gdk_color_to_cairo (&clearlooks_style->focus_color, &focus.color);
+ focus.has_color = TRUE;
}
+ else
+ focus.color = colors->bg[GTK_STATE_SELECTED];
- cairo_rectangle (cr,
- x + line_width / 2.,
- y + line_width / 2.,
- width - line_width, height - line_width);
- cairo_stroke (cr);
- cairo_destroy (cr);
+ STYLE_FUNCTION(draw_focus) (cr, colors, ¶ms, &focus, x, y, width, height);
+
+ g_free (focus.dash_list);
- if (free_dash_list)
- g_free (dash_list);
+ cairo_destroy (cr);
}
static void
{
ClearlooksStyle * cl_style = CLEARLOOKS_STYLE (style);
ClearlooksStyle * cl_src = CLEARLOOKS_STYLE (src);
-
+
cl_style->colors = cl_src->colors;
+ cl_style->reliefstyle = cl_src->reliefstyle;
cl_style->menubarstyle = cl_src->menubarstyle;
cl_style->toolbarstyle = cl_src->toolbarstyle;
+ cl_style->focus_color = cl_src->focus_color;
+ cl_style->has_focus_color = cl_src->has_focus_color;
cl_style->scrollbar_color = cl_src->scrollbar_color;
cl_style->has_scrollbar_color = cl_src->has_scrollbar_color;
cl_style->colorize_scrollbar = cl_src->colorize_scrollbar;
cl_style->animation = cl_src->animation;
cl_style->radius = cl_src->radius;
cl_style->style = cl_src->style;
-
- clearlooks_parent_class->copy (style, src);
+
+ GTK_STYLE_CLASS (clearlooks_style_parent_class)->copy (style, src);
}
static void
clearlooks_style_unrealize (GtkStyle * style)
{
- clearlooks_parent_class->unrealize (style);
+ GTK_STYLE_CLASS (clearlooks_style_parent_class)->unrealize (style);
}
static GdkPixbuf *
rowstride = gdk_pixbuf_get_rowstride (target);
data = gdk_pixbuf_get_pixels (target);
- for (y = 0; y < height; y++) {
- for (x = 0; x < width; x++) {
+ for (y = 0; y < height; y++)
+ {
+ for (x = 0; x < width; x++)
+ {
/* The "4" is the number of chars per pixel, in this case, RGBA,
the 3 means "skip to the alpha" */
- current = data + (y * rowstride) + (x * 4) + 3;
+ current = data + (y * rowstride) + (x * 4) + 3;
*(current) = (guchar) (*(current) * alpha_percent);
}
}
int height)
{
if (width == gdk_pixbuf_get_width (src) &&
- height == gdk_pixbuf_get_height (src)) {
+ height == gdk_pixbuf_get_height (src))
+ {
return g_object_ref (src);
- } else {
+ }
+ else
+ {
return gdk_pixbuf_scale_simple (src,
- width, height,
- GDK_INTERP_BILINEAR);
+ width, height,
+ GDK_INTERP_BILINEAR);
}
}
static void
clearlooks_style_draw_layout (GtkStyle * style,
- GdkWindow * window,
- GtkStateType state_type,
- gboolean use_text,
- GdkRectangle * area,
- GtkWidget * widget,
- const gchar * detail, gint x, gint y, PangoLayout * layout)
+ GdkWindow * window,
+ GtkStateType state_type,
+ gboolean use_text,
+ GdkRectangle * area,
+ GtkWidget * widget,
+ const gchar * detail, gint x, gint y, PangoLayout * layout)
{
GdkGC *gc;
if (area)
gdk_gc_set_clip_rectangle (gc, area);
- if (state_type == GTK_STATE_INSENSITIVE) {
+ if (state_type == GTK_STATE_INSENSITIVE)
+ {
ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
ClearlooksColors *colors = &clearlooks_style->colors;
ge_shade_color (¶ms.parentbg, 1.2, &temp);
else
ge_shade_color (&colors->bg[widget->state], 1.2, &temp);
-
+
etched.red = (int) (temp.r * 65535);
etched.green = (int) (temp.g * 65535);
etched.blue = (int) (temp.b * 65535);
static GdkPixbuf *
clearlooks_style_draw_render_icon (GtkStyle *style,
- const GtkIconSource *source,
- GtkTextDirection direction,
- GtkStateType state,
- GtkIconSize size,
- GtkWidget *widget,
- const char *detail)
+ const GtkIconSource *source,
+ GtkTextDirection direction,
+ GtkStateType state,
+ GtkIconSize size,
+ GtkWidget *widget,
+ const char *detail)
{
int width = 1;
int height = 1;
GdkPixbuf *base_pixbuf;
GdkScreen *screen;
GtkSettings *settings;
-
+
/* Oddly, style can be NULL in this function, because
* GtkIconSet can be used without a style and if so
* it uses this function.
*/
-
+
base_pixbuf = gtk_icon_source_get_pixbuf (source);
-
+
g_return_val_if_fail (base_pixbuf != NULL, NULL);
-
- if (widget && gtk_widget_has_screen (widget)) {
+
+ if (widget && gtk_widget_has_screen (widget))
+ {
screen = gtk_widget_get_screen (widget);
settings = gtk_settings_get_for_screen (screen);
- } else if (style->colormap) {
+ }
+ else if (style->colormap)
+ {
screen = gdk_colormap_get_screen (style->colormap);
settings = gtk_settings_get_for_screen (screen);
- } else {
+ }
+ else
+ {
settings = gtk_settings_get_default ();
GTK_NOTE (MULTIHEAD,
g_warning ("Using the default screen for gtk_default_render_icon()"));
}
-
-
- if (size != (GtkIconSize) -1 && !gtk_icon_size_lookup_for_settings (settings, size, &width, &height)) {
+
+ if (size != (GtkIconSize) -1 && !gtk_icon_size_lookup_for_settings (settings, size, &width, &height))
+ {
g_warning (G_STRLOC ": invalid icon size '%d'", size);
return NULL;
}
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_INSENSITIVE) {
+ if (gtk_icon_source_get_state_wildcarded (source))
+ {
+ if (state == GTK_STATE_INSENSITIVE)
+ {
stated = set_transparency (scaled, 0.3);
- gdk_pixbuf_saturate_and_pixelate (stated, stated,
- 0.1, FALSE);
-
+ gdk_pixbuf_saturate_and_pixelate (stated, stated, 0.1, FALSE);
+
g_object_unref (scaled);
- } else if (state == GTK_STATE_PRELIGHT) {
- stated = gdk_pixbuf_copy (scaled);
-
- gdk_pixbuf_saturate_and_pixelate (scaled, stated,
- 1.2, FALSE);
-
+ }
+ else if (state == GTK_STATE_PRELIGHT)
+ {
+ stated = gdk_pixbuf_copy (scaled);
+
+ gdk_pixbuf_saturate_and_pixelate (scaled, stated, 1.2, FALSE);
+
g_object_unref (scaled);
- } else {
+ }
+ else
+ {
stated = scaled;
}
}
else
stated = scaled;
-
- return stated;
+
+ return stated;
+}
+
+void
+clearlooks_style_register_types (GTypeModule *module)
+{
+ clearlooks_style_register_type (module);
}
static void
clearlooks_style_class_init (ClearlooksStyleClass * klass)
{
GtkStyleClass *style_class = GTK_STYLE_CLASS (klass);
-
- clearlooks_style_class = CLEARLOOKS_STYLE_CLASS (klass);
- clearlooks_parent_class = g_type_class_peek_parent (klass);
style_class->copy = clearlooks_style_copy;
style_class->realize = clearlooks_style_realize;
style_class->draw_layout = clearlooks_style_draw_layout;
style_class->render_icon = clearlooks_style_draw_render_icon;
- clearlooks_register_style_classic (&clearlooks_style_class->style_functions[CL_STYLE_CLASSIC]);
- clearlooks_style_class->style_functions[CL_STYLE_GLOSSY] = clearlooks_style_class->style_functions[CL_STYLE_CLASSIC];
- clearlooks_register_style_glossy (&clearlooks_style_class->style_functions[CL_STYLE_GLOSSY]);
- clearlooks_style_class->style_functions[CL_STYLE_INVERTED] = clearlooks_style_class->style_functions[CL_STYLE_CLASSIC];
- clearlooks_register_style_inverted (&clearlooks_style_class->style_functions[CL_STYLE_INVERTED]);
- clearlooks_style_class->style_functions[CL_STYLE_GUMMY] = clearlooks_style_class->style_functions[CL_STYLE_CLASSIC];
- clearlooks_register_style_gummy (&clearlooks_style_class->style_functions[CL_STYLE_GUMMY]);
-}
+ clearlooks_register_style_classic (&klass->style_functions[CL_STYLE_CLASSIC],
+ &klass->style_constants[CL_STYLE_CLASSIC]);
-GType clearlooks_type_style = 0;
+ klass->style_functions[CL_STYLE_GLOSSY] = klass->style_functions[CL_STYLE_CLASSIC];
+ klass->style_constants[CL_STYLE_GLOSSY] = klass->style_constants[CL_STYLE_CLASSIC];
+ clearlooks_register_style_glossy (&klass->style_functions[CL_STYLE_GLOSSY],
+ &klass->style_constants[CL_STYLE_GLOSSY]);
-void
-clearlooks_style_register_type (GTypeModule * module)
+ klass->style_functions[CL_STYLE_INVERTED] = klass->style_functions[CL_STYLE_CLASSIC];
+ klass->style_constants[CL_STYLE_INVERTED] = klass->style_constants[CL_STYLE_CLASSIC];
+ clearlooks_register_style_inverted (&klass->style_functions[CL_STYLE_INVERTED],
+ &klass->style_constants[CL_STYLE_INVERTED]);
+
+ klass->style_functions[CL_STYLE_GUMMY] = klass->style_functions[CL_STYLE_CLASSIC];
+ klass->style_constants[CL_STYLE_GUMMY] = klass->style_constants[CL_STYLE_CLASSIC];
+ clearlooks_register_style_gummy (&klass->style_functions[CL_STYLE_GUMMY],
+ &klass->style_constants[CL_STYLE_GUMMY]);
+}
+
+static void
+clearlooks_style_class_finalize (ClearlooksStyleClass *klass)
{
- static const GTypeInfo object_info =
- {
- sizeof (ClearlooksStyleClass),
- (GBaseInitFunc) NULL,
- (GBaseFinalizeFunc) NULL,
- (GClassInitFunc) clearlooks_style_class_init,
- NULL, /* class_finalize */
- NULL, /* class_data */
- sizeof (ClearlooksStyle),
- 0, /* n_preallocs */
- (GInstanceInitFunc) clearlooks_style_init,
- NULL
- };
-
- clearlooks_type_style = g_type_module_register_type (module,
- GTK_TYPE_STYLE,
- "ClearlooksStyle",
- &object_info, 0);
}
-/* Clearlooks Engine
+/* Clearlooks theme engine
* Copyright (C) 2005 Richard Stellingwerff.
- * Copyright (C) 2006 Benjamin Berg
+ * Copyright (C) 2007 Benjamin Berg
+ * Copyright (C) 2007 Andrea Cimitan
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* and by Alexander Larsson <alexl@redhat.com>
* Modified by Richard Stellingwerff <remenic@gmail.com>
*/
+
#include <gtk/gtkstyle.h>
#ifndef CLEARLOOKS_STYLE_H
typedef struct _ClearlooksStyle ClearlooksStyle;
typedef struct _ClearlooksStyleClass ClearlooksStyleClass;
-GE_INTERNAL extern GType clearlooks_type_style;
-
-#define CLEARLOOKS_TYPE_STYLE clearlooks_type_style
+#define CLEARLOOKS_TYPE_STYLE (clearlooks_style_get_type ())
#define CLEARLOOKS_STYLE(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), CLEARLOOKS_TYPE_STYLE, ClearlooksStyle))
#define CLEARLOOKS_STYLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLEARLOOKS_TYPE_STYLE, ClearlooksStyleClass))
#define CLEARLOOKS_IS_STYLE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), CLEARLOOKS_TYPE_STYLE))
ClearlooksColors colors;
ClearlooksStyles style;
-
+
+ guint8 reliefstyle;
guint8 menubarstyle;
guint8 toolbarstyle;
+ GdkColor focus_color;
+ gboolean has_focus_color;
GdkColor scrollbar_color;
gboolean colorize_scrollbar;
gboolean has_scrollbar_color;
GtkStyleClass parent_class;
ClearlooksStyleFunctions style_functions[CL_NUM_STYLES];
+ ClearlooksStyleConstants style_constants[CL_NUM_STYLES];
};
-GE_INTERNAL void clearlooks_style_register_type (GTypeModule *module);
+GE_INTERNAL void clearlooks_style_register_types (GTypeModule *module);
+GE_INTERNAL GType clearlooks_style_get_type (void);
#endif /* CLEARLOOKS_STYLE_H */
GE_EXPORT void
theme_init (GTypeModule *module)
{
- clearlooks_rc_style_register_type (module);
- clearlooks_style_register_type (module);
+ clearlooks_rc_style_register_types (module);
+ clearlooks_style_register_types (module);
}
GE_EXPORT void
typedef unsigned char boolean;
typedef unsigned char uint8;
typedef struct _ClearlooksStyleFunctions ClearlooksStyleFunctions;
+typedef struct _ClearlooksStyleConstants ClearlooksStyleConstants;
typedef enum
{
CL_NUM_STYLES = 4
} ClearlooksStyles;
-
typedef enum
{
CL_STATE_NORMAL,
typedef enum
{
- CL_ORDER_FIRST,
- CL_ORDER_MIDDLE,
- CL_ORDER_LAST
+ CL_ORDER_FIRST = 1 << 0,
+ CL_ORDER_LAST = 1 << 1,
} ClearlooksOrder;
+typedef enum
+{
+ CL_CONT_NONE = 0,
+ CL_CONT_LEFT = 1 << 0,
+ CL_CONT_RIGHT = 1 << 1
+} ClearlooksContinue;
+
typedef enum
{
CL_ORIENTATION_LEFT_TO_RIGHT,
CL_ARROW_COMBO
} ClearlooksArrowType;
+typedef enum
+{
+ CL_FOCUS_BUTTON,
+ CL_FOCUS_BUTTON_FLAT,
+ CL_FOCUS_LABEL,
+ CL_FOCUS_TREEVIEW,
+ CL_FOCUS_TREEVIEW_HEADER,
+ CL_FOCUS_TREEVIEW_ROW,
+ CL_FOCUS_TREEVIEW_DND,
+ CL_FOCUS_SCALE,
+ CL_FOCUS_TAB,
+ CL_FOCUS_COLOR_WHEEL_DARK,
+ CL_FOCUS_COLOR_WHEEL_LIGHT,
+ CL_FOCUS_UNKNOWN
+} ClearlooksFocusType;
+
+
typedef enum
{
CL_DIRECTION_UP,
boolean focus;
boolean is_default;
boolean ltr;
- boolean enable_glow;
+ boolean enable_shadow;
gfloat radius;
CairoColor parentbg;
ClearlooksStyleFunctions *style_functions;
+ ClearlooksStyleConstants *style_constants;
} WidgetParameters;
+typedef struct
+{
+ ClearlooksFocusType type;
+ ClearlooksContinue continue_side;
+ CairoColor color;
+ boolean has_color;
+ gint line_width;
+ gint padding;
+ guint8* dash_list;
+ boolean interior;
+} FocusParameters;
+
typedef struct
{
boolean lower;
typedef struct
{
ClearlooksGapSide gap_side;
+ FocusParameters focus;
} TabParameters;
typedef struct
{
CairoCorners corners;
- ClearlooksShadowType shadow;
+ ClearlooksShadowType shadow;
} ShadowParameters;
typedef struct
typedef struct
{
CairoColor color;
- ClearlooksJunction junction; /* On which sides the slider junctions */
+ ClearlooksJunction junction; /* On which sides the slider junctions */
boolean horizontal;
boolean has_color;
} ScrollBarParameters;
typedef struct
{
- ClearlooksStepper stepper; /* Which stepper to draw */
+ ClearlooksStepper stepper; /* Which stepper to draw */
} ScrollBarStepperParameters;
typedef struct
boolean topmost;
} ToolbarParameters;
+struct _ClearlooksStyleConstants
+{
+ gdouble topleft_highlight_shade;
+ gdouble topleft_highlight_alpha;
+};
+
struct _ClearlooksStyleFunctions
{
- void (*draw_button) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
+ void (*draw_top_left_highlight) (cairo_t *cr,
+ const CairoColor *color,
+ const WidgetParameters *params,
+ int x, int y, int width, int height,
+ gdouble radius,
+ CairoCorners corners);
+
+ void (*draw_button) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
int x, int y, int width, int height);
- void (*draw_scale_trough) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
- const SliderParameters *slider,
+ void (*draw_scale_trough) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
+ const SliderParameters *slider,
int x, int y, int width, int height);
- void (*draw_progressbar_trough) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
+ void (*draw_progressbar_trough) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
int x, int y, int width, int height);
- void (*draw_progressbar_fill) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
+ void (*draw_progressbar_fill) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
const ProgressBarParameters *progressbar,
int x, int y, int width, int height, gint offset);
- void (*draw_slider_button) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
- const SliderParameters *slider,
+ void (*draw_slider_button) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
+ const SliderParameters *slider,
int x, int y, int width, int height);
- void (*draw_entry) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
+ void (*draw_entry) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
int x, int y, int width, int height);
- void (*draw_spinbutton) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
+ void (*draw_spinbutton) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
int x, int y, int width, int height);
- void (*draw_spinbutton_down) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
+ void (*draw_spinbutton_down) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
int x, int y, int width, int height);
- void (*draw_optionmenu) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
+ void (*draw_optionmenu) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
const OptionMenuParameters *optionmenu,
int x, int y, int width, int height);
-
- void (*draw_inset) (cairo_t *cr,
- const CairoColor *bg_color,
+
+ void (*draw_inset) (cairo_t *cr,
+ const CairoColor *bg_color,
double x, double y, double w, double h,
double radius, uint8 corners);
- void (*draw_menubar) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
- const MenuBarParameters *menubar,
+ void (*draw_menubar) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
+ const MenuBarParameters *menubar,
int x, int y, int width, int height);
- void (*draw_tab) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
- const TabParameters *tab,
+ void (*draw_tab) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
+ const TabParameters *tab,
int x, int y, int width, int height);
- void (*draw_frame) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
- const FrameParameters *frame,
+ void (*draw_frame) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
+ const FrameParameters *frame,
int x, int y, int width, int height);
- void (*draw_separator) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
- const SeparatorParameters *separator,
+ void (*draw_separator) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
+ const SeparatorParameters *separator,
int x, int y, int width, int height);
- void (*draw_menu_item_separator) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
- const SeparatorParameters *separator,
+ void (*draw_menu_item_separator) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
+ const SeparatorParameters *separator,
int x, int y, int width, int height);
- void (*draw_list_view_header) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
- const ListViewHeaderParameters *header,
+ void (*draw_list_view_header) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
+ const ListViewHeaderParameters *header,
int x, int y, int width, int height);
- void (*draw_toolbar) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
- const ToolbarParameters *toolbar,
+ void (*draw_toolbar) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
+ const ToolbarParameters *toolbar,
int x, int y, int width, int height);
- void (*draw_menuitem) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
+ void (*draw_menuitem) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
int x, int y, int width, int height);
- void (*draw_menubaritem) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
+ void (*draw_menubaritem) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
int x, int y, int width, int height);
- void (*draw_selected_cell) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
+ void (*draw_selected_cell) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
int x, int y, int width, int height);
- void (*draw_scrollbar_stepper) (cairo_t *cr,
+ void (*draw_scrollbar_stepper) (cairo_t *cr,
const ClearlooksColors *colors,
const WidgetParameters *widget,
const ScrollBarParameters *scrollbar,
const ScrollBarStepperParameters *stepper,
int x, int y, int width, int height);
- void (*draw_scrollbar_slider) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
+ void (*draw_scrollbar_slider) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
const ScrollBarParameters *scrollbar,
int x, int y, int width, int height);
- void (*draw_scrollbar_trough) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
+ void (*draw_scrollbar_trough) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
const ScrollBarParameters *scrollbar,
int x, int y, int width, int height);
- void (*draw_statusbar) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
+ void (*draw_statusbar) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
int x, int y, int width, int height);
- void (*draw_menu_frame) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
+ void (*draw_menu_frame) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
int x, int y, int width, int height);
- void (*draw_tooltip) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
+ void (*draw_tooltip) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
int x, int y, int width, int height);
- void (*draw_handle) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
- const HandleParameters *handle,
+ void (*draw_handle) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
+ const HandleParameters *handle,
int x, int y, int width, int height);
- void (*draw_resize_grip) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
+ void (*draw_resize_grip) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
const ResizeGripParameters *grip,
int x, int y, int width, int height);
- void (*draw_arrow) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
- const ArrowParameters *arrow,
+ void (*draw_arrow) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
+ const ArrowParameters *arrow,
+ int x, int y, int width, int height);
+
+ void (*draw_focus) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
+ const FocusParameters *focus,
int x, int y, int width, int height);
-
- void (*draw_checkbox) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
+
+ void (*draw_checkbox) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
const CheckboxParameters *checkbox,
int x, int y, int width, int height);
- void (*draw_radiobutton) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
+ void (*draw_radiobutton) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
const CheckboxParameters *checkbox,
int x, int y, int width, int height);
/* Style internal functions */
/* XXX: Only used by slider_button, inline it? */
- void (*draw_shadow) (cairo_t *cr,
- const ClearlooksColors *colors,
- gfloat radius,
- int width, int height);
-
- void (*draw_slider) (cairo_t *cr,
- const ClearlooksColors *colors,
- const WidgetParameters *widget,
+ void (*draw_shadow) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ gfloat radius, int width, int height);
+
+ void (*draw_slider) (cairo_t *cr,
+ const ClearlooksColors *colors,
+ const WidgetParameters *widget,
int x, int y, int width, int height);
void (*draw_gripdots) (cairo_t *cr,
};
-#define CLEARLOOKS_RECTANGLE_SET(rect, _x, _y, _w, _h) rect.x = _x; \
- rect.y = _y; \
- rect.width = _w; \
- rect.height = _h;
+#define CLEARLOOKS_RECTANGLE_SET(rect, _x, _y, _w, _h) (rect).x = (_x); \
+ (rect).y = (_y); \
+ (rect).width = (_w); \
+ (rect).height = (_h);
#endif /* CLEARLOOKS_TYPES_H */
-/* engines/clearlooks/src/config.h. Generated from config.h.in by configure. */
-/* engines/clearlooks/src/config.h.in. Generated from configure.ac by autoheader. */
+/* engines/support/config.h. Generated from config.h.in by configure. */
+/* engines/support/config.h.in. Generated from configure.ac by autoheader. */
/* always defined to indicate that i18n is enabled */
#define ENABLE_NLS 1
+/* Defines whether to enable runtime widget checks as a fallback to hints from
+ the theme. */
+#define ENABLE_WIDGET_CHECKS 1
+
/* Gettext package */
#define GETTEXT_PACKAGE "gtk-engines"
/* Define to 1 if you have the <unistd.h> header file. */
#define HAVE_UNISTD_H 1
+/* Define to 1 if your C compiler doesn't accept -c and -o together. */
+/* #undef NO_MINUS_C_MINUS_O */
+
/* Name of package */
#define PACKAGE "gtk-engines"
#define PACKAGE_NAME "gtk-engines"
/* Define to the full name and version of this package. */
-#define PACKAGE_STRING "gtk-engines 2.12.2"
+#define PACKAGE_STRING "gtk-engines 2.16.0"
/* Define to the one symbol short name of this package. */
#define PACKAGE_TARNAME "gtk-engines"
/* Define to the version of this package. */
-#define PACKAGE_VERSION "2.12.2"
+#define PACKAGE_VERSION "2.16.0"
/* Define to 1 if you have the ANSI C header files. */
#define STDC_HEADERS 1
/* Version number of package */
-#define VERSION "2.12.2"
+#define VERSION "2.16.0"
#include "cairo-support.h"
#include "widget-information.h"
-
#endif /* GE_SUPPORT_H */
+#ifndef __GENERAL_SUPPORT_H
+#define __GENERAL_SUPPORT_H
#include <gmodule.h>
#include <glib.h>
# define GE_EXPORT __global
# define GE_INTERNAL __hidden
#endif
+
+#endif /* __GENERAL_SUPPORT_H */
GtkStateType state_type;
const GtkWidget *parent;
GdkColor *gcolor;
+ gboolean stop;
if (widget == NULL)
return;
parent = widget->parent;
+ stop = FALSE;
- while (parent && GTK_WIDGET_NO_WINDOW (parent) && !((GTK_IS_NOTEBOOK (parent)) || (GTK_IS_TOOLBAR (parent))))
- parent = parent->parent;
+ while (parent && !stop)
+ {
+ stop = FALSE;
+
+ stop |= !GTK_WIDGET_NO_WINDOW (parent);
+ stop |= GTK_IS_NOTEBOOK (parent) &&
+ gtk_notebook_get_show_tabs (GTK_NOTEBOOK (parent)) &&
+ gtk_notebook_get_show_border (GTK_NOTEBOOK (parent));
+
+ if (GTK_IS_TOOLBAR (parent))
+ {
+ GtkShadowType shadow = GTK_SHADOW_OUT;
+ gtk_widget_style_get (GTK_WIDGET (parent), "shadow-type", &shadow, NULL);
+
+ stop |= (shadow != GTK_SHADOW_NONE);
+ }
+
+ if (!stop)
+ parent = parent->parent;
+ }
if (parent == NULL)
return;
{
ClearlooksStepper steppers = 0;
+ /* If this is not a range widget, assume that the primary steppers
+ * are present. */
if (!GE_IS_RANGE (widget))
- return 0;
+ return CL_STEPPER_A | CL_STEPPER_D;
if (GTK_RANGE (widget)->has_stepper_a)
steppers |= CL_STEPPER_A;
if (adj->value <= adj->lower &&
(GTK_RANGE (widget)->has_stepper_a || GTK_RANGE (widget)->has_stepper_b))
{
- junction |= CL_JUNCTION_BEGIN;
+ if (!gtk_range_get_inverted (GTK_RANGE (widget)))
+ junction |= CL_JUNCTION_BEGIN;
+ else
+ junction |= CL_JUNCTION_END;
}
if (adj->value >= adj->upper - adj->page_size &&
(GTK_RANGE (widget)->has_stepper_c || GTK_RANGE (widget)->has_stepper_d))
{
- junction |= CL_JUNCTION_END;
+ if (!gtk_range_get_inverted (GTK_RANGE (widget)))
+ junction |= CL_JUNCTION_END;
+ else
+ junction |= CL_JUNCTION_BEGIN;
}
return junction;
}
void
-clearlooks_set_toolbar_parameters (ToolbarParameters *toolbar, GtkWidget *widget, GdkWindow *window, gint x, gint y)
+clearlooks_set_toolbar_parameters (ToolbarParameters *toolbar,
+ GtkWidget *widget,
+ GdkWindow *window,
+ gint x, gint y)
{
toolbar->topmost = FALSE;
#include "general-support.h"
#include "widget-information.h"
+#include "config.h"
#include <math.h>
#include <string.h>
+static gchar ge_widget_hints[] =
+ "treeview\0"
+ "treeview-header\0"
+ "statusbar\0"
+ "comboboxentry\0"
+ "spinbutton\0"
+ "scale\0"
+ "vscale\0"
+ "hscale\0"
+ "scrollbar\0"
+ "vscrollbar\0"
+ "hscrollbar\0"
+ "progressbar\0"
+ "menubar\0";
+
+gboolean
+ge_check_hint (GEHint hint,
+ GQuark style_hint,
+ GtkWidget *widget)
+{
+ static GEHint quark_hint_lookup[GE_HINT_COUNT] = {0};
+
+ g_assert ((hint >= 0) && (hint < GE_HINT_COUNT));
+
+ /* Initilize lookup table */
+ if (G_UNLIKELY (quark_hint_lookup[0] == 0))
+ {
+ guint i = 0;
+ gchar *cur_hint_str = ge_widget_hints;
+ while ((i < GE_HINT_COUNT) && cur_hint_str[0])
+ {
+ /* Can't use _from_static_string as the engine may be unloaded. */
+ quark_hint_lookup[i] = g_quark_from_string (cur_hint_str);
+ cur_hint_str += strlen(cur_hint_str) + 1;
+ i++;
+ }
+ g_assert (i == GE_HINT_COUNT && cur_hint_str[0] == '\0');
+ }
+
+
+ if (quark_hint_lookup[hint] == style_hint)
+ return TRUE;
+
+
+ /* Try to decide based on other hints, eg. hscale is also a scale. */
+ if (hint == GE_HINT_SCALE)
+ if (ge_check_hint (GE_HINT_VSCALE, style_hint, widget) ||
+ ge_check_hint (GE_HINT_HSCALE, style_hint, widget))
+ return TRUE;
+ if (hint == GE_HINT_SCROLLBAR)
+ if (ge_check_hint (GE_HINT_VSCROLLBAR, style_hint, widget) ||
+ ge_check_hint (GE_HINT_HSCROLLBAR, style_hint, widget))
+ return TRUE;
+ if (hint == GE_HINT_TREEVIEW)
+ if (ge_check_hint (GE_HINT_TREEVIEW_HEADER, style_hint, widget))
+ return TRUE;
+
+
+ /* These may be caused by applications so we never want to disable them.
+ * TODO: This does not catch the case where the theme uses appears-as-list
+ * and the application turns it off again. Though this case
+ * is even less likely. */
+ switch (hint) {
+ case GE_HINT_COMBOBOX_ENTRY:
+ if (widget && ge_object_is_a (G_OBJECT (widget), "GtkComboBox"))
+ {
+ gboolean appears_as_list = FALSE;
+
+ gtk_widget_style_get (widget, "appears-as-list", &appears_as_list, NULL);
+
+ if (appears_as_list)
+ return TRUE;
+ }
+ break;
+ default:
+ break;
+ }
+
+
+#ifdef ENABLE_WIDGET_CHECKS
+ /* If a style_hint *was* set, and nothing matched, just give up right away.
+ * A theme shall either support it fully, or not at all. */
+ if (style_hint != 0)
+ return FALSE;
+
+ /* No widget? Just give up. Nothing we can do. */
+ if (widget == NULL)
+ return FALSE;
+
+ /* Try to do something based on the passed in widget pointer. */
+ switch (hint) {
+ case GE_HINT_TREEVIEW:
+ if (widget->parent && (ge_object_is_a (G_OBJECT (widget->parent), "GtkTreeView")))
+ return TRUE;
+ break;
+ case GE_HINT_TREEVIEW_HEADER:
+ if (ge_object_is_a (G_OBJECT (widget), "GtkButton") && widget->parent &&
+ (ge_object_is_a (G_OBJECT (widget->parent), "GtkTreeView") || ge_object_is_a (G_OBJECT (widget->parent), "GtkCList") ||
+ ge_object_is_a (G_OBJECT (widget->parent), "GtkCTree")))
+ return TRUE;
+ if (widget->parent && ge_object_is_a (G_OBJECT (widget->parent), "ETreeView"))
+ return TRUE;
+ break;
+ case GE_HINT_COMBOBOX_ENTRY:
+ if (ge_is_in_combo_box (widget))
+ return TRUE;
+ break;
+ case GE_HINT_SPINBUTTON:
+ if (ge_object_is_a (G_OBJECT (widget), "GtkSpinButton"))
+ return TRUE;
+ break;
+ case GE_HINT_STATUSBAR:
+ if (widget->parent && ge_object_is_a (G_OBJECT (widget), "GtkStatusbar"))
+ return TRUE;
+ break;
+ case GE_HINT_SCALE:
+ if (ge_object_is_a (G_OBJECT (widget), "GtkScale"))
+ return TRUE;
+ break;
+ case GE_HINT_HSCALE:
+ if (ge_object_is_a (G_OBJECT (widget), "GtkHScale"))
+ return TRUE;
+ break;
+ case GE_HINT_VSCALE:
+ if (ge_object_is_a (G_OBJECT (widget), "GtkVScale"))
+ return TRUE;
+ break;
+ case GE_HINT_SCROLLBAR:
+ if (ge_object_is_a (G_OBJECT (widget), "GtkScrollbar"))
+ return TRUE;
+ break;
+ case GE_HINT_HSCROLLBAR:
+ if (ge_object_is_a (G_OBJECT (widget), "GtkHScrollbar"))
+ return TRUE;
+ break;
+ case GE_HINT_VSCROLLBAR:
+ if (ge_object_is_a (G_OBJECT (widget), "GtkVScrollbar"))
+ return TRUE;
+ break;
+ case GE_HINT_PROGRESSBAR:
+ if (ge_object_is_a (G_OBJECT (widget), "GtkProgressBar"))
+ return TRUE;
+ break;
+ case GE_HINT_MENUBAR:
+ if (ge_object_is_a (G_OBJECT (widget), "GtkMenuBar") ||
+ ge_object_is_a (G_OBJECT (widget->parent), "GtkMenuBar"))
+ return TRUE;
+ break;
+
+ default:
+ break;
+ }
+
+#endif
+
+
+ return FALSE;
+}
+
/* Widget Type Lookups/Macros
Based on/modified from functions in
}
return result;
}
-
+
static gboolean
ge_combo_box_is_using_list (GtkWidget * widget)
{
gboolean result = FALSE;
if (GE_IS_COMBO_BOX (widget))
- {
- gboolean *tmp = NULL;
-
- gtk_widget_style_get (widget, "appears-as-list", &result, NULL);
-
- if (tmp)
- result = *tmp;
- }
+ gtk_widget_style_get (widget, "appears-as-list", &result, NULL);
return result;
}
***********************************************/
void
ge_option_menu_get_props (GtkWidget * widget,
- GtkRequisition * indicator_size,
- GtkBorder * indicator_spacing)
+ GtkRequisition * indicator_size,
+ GtkBorder * indicator_spacing)
{
GtkRequisition default_size = { 9, 5 };
GtkBorder default_spacing = { 7, 5, 2, 2 };
}
}
-
gboolean
ge_widget_is_ltr (GtkWidget *widget)
{
else
return TRUE;
}
+
+guint
+ge_rc_parse_hint (GScanner *scanner,
+ GQuark *quark)
+{
+ guint token;
+
+ /* Skip 'hint' */
+ token = g_scanner_get_next_token(scanner);
+
+ token = g_scanner_get_next_token(scanner);
+ if (token != G_TOKEN_EQUAL_SIGN)
+ return G_TOKEN_EQUAL_SIGN;
+
+ token = g_scanner_get_next_token(scanner);
+ if (token != G_TOKEN_STRING)
+ return G_TOKEN_STRING;
+
+ *quark = g_quark_from_string (scanner->value.v_string);
+
+ return G_TOKEN_NONE;
+}
+
+#ifndef WIDGET_INFORMATION_H
+#define WIDGET_INFORMATION_H
+
+#include "general-support.h"
+#include <glib.h>
+#include <gtk/gtkwidget.h>
+
+typedef enum {
+ GE_HINT_TREEVIEW,
+ GE_HINT_TREEVIEW_HEADER,
+ GE_HINT_STATUSBAR,
+ GE_HINT_COMBOBOX_ENTRY,
+ GE_HINT_SPINBUTTON,
+ GE_HINT_SCALE,
+ GE_HINT_VSCALE,
+ GE_HINT_HSCALE,
+ GE_HINT_SCROLLBAR,
+ GE_HINT_VSCROLLBAR,
+ GE_HINT_HSCROLLBAR,
+ GE_HINT_PROGRESSBAR,
+ GE_HINT_MENUBAR,
+ GE_HINT_COUNT
+} GEHint;
+
+/* ALL OF THE FOLLOWING SHOULD DIE ...
+ * instead the hint system will be used, and a huge switch ;-) */
+
/* Object Type Lookups/Macros
Based on/modified from functions in
Smooth-Engine.
*/
-#define GE_IS_WIDGET(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkWidget"))
-#define GE_IS_CONTAINER(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkContainer"))
-#define GE_IS_BIN(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkBin"))
+#define GE_IS_WIDGET(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkWidget"))
+#define GE_IS_CONTAINER(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkContainer"))
+#define GE_IS_BIN(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkBin"))
-#define GE_IS_ARROW(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkArrow"))
+#define GE_IS_ARROW(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkArrow"))
-#define GE_IS_SEPARATOR(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkSeparator"))
-#define GE_IS_VSEPARATOR(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkVSeparator"))
-#define GE_IS_HSEPARATOR(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkHSeparator"))
+#define GE_IS_SEPARATOR(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkSeparator"))
+#define GE_IS_VSEPARATOR(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkVSeparator"))
+#define GE_IS_HSEPARATOR(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkHSeparator"))
#define GE_IS_HANDLE_BOX(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkHandleBox"))
#define GE_IS_HANDLE_BOX_ITEM(object) ((object) && GE_IS_HANDLE_BOX(object->parent))
#define GE_WIDGET_HAS_DEFAULT(object) ((object) && GE_IS_WIDGET(object) && GTK_WIDGET_HAS_DEFAULT(object))
+
+GE_INTERNAL gboolean ge_check_hint (GEHint hint, GQuark style_hint, GtkWidget *widget);
+
GE_INTERNAL gboolean ge_object_is_a (const GObject * object, const gchar * type_name);
GE_INTERNAL gboolean ge_is_combo_box_entry (GtkWidget * widget);
GE_INTERNAL gboolean ge_widget_is_ltr (GtkWidget *widget);
+GE_INTERNAL guint ge_rc_parse_hint (GScanner *scanner, GQuark *quark);
+
+#endif /* WIDGET_INFORMATION_H */
projects / ardour.git / commitdiff