s3rius/squeekboard
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add border style configuration (WIP).

Browse Source
This commit is contained in:
Daiki Ueno
2011-03-07 19:01:10 +09:00
parent cadb0f18a9
commit f1b91c0223
8 changed files with 1448 additions and 746 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
data/themes/default.css
View File

@ -1,8 +1,17 @@
.key { .key {
color: #ffffff; color: #ffffff;
background-gradient-direction: radial; background-gradient-direction: vertical;
background-gradient-start: #000000; background-gradient-start: #000000;
background-gradient-end: #232323; background-gradient-end: #555555;
border-width: 2px;
border-color: #777777;
border-radius: 3px;
}
.key:active {
background-gradient-direction: vertical;
background-gradient-start: #FF0000;
background-gradient-end: #FF0000;
} }
.keyboard { .keyboard {

361
eek/eek-renderer.c
View File

@ -45,8 +45,8 @@ struct _EekRendererPrivate
EekKeyboard *keyboard; EekKeyboard *keyboard;
PangoContext *pcontext; PangoContext *pcontext;
EekColor *default_foreground; EekColor default_foreground_color;
EekColor *default_background; EekColor default_background_color;
gdouble border_width; gdouble border_width;
gdouble allocation_width; gdouble allocation_width;
@ -62,6 +62,9 @@ struct _EekRendererPrivate
EekTheme *theme; EekTheme *theme;
}; };
static const EekColor DEFAULT_FOREGROUND_COLOR = {0.3, 0.3, 0.3, 1.0};
static const EekColor DEFAULT_BACKGROUND_COLOR = {1.0, 1.0, 1.0, 1.0};
struct { struct {
gint category; gint category;
gdouble scale; gdouble scale;
@ -150,14 +153,14 @@ create_keyboard_surface (EekRenderer *renderer)
EekBounds bounds; EekBounds bounds;
cairo_surface_t *keyboard_surface; cairo_surface_t *keyboard_surface;
CreateKeyboardSurfaceCallbackData data; CreateKeyboardSurfaceCallbackData data;
EekColor *foreground, *background; EekColor foreground, background;
foreground = eek_renderer_get_foreground_color (renderer,
eek_renderer_get_foreground_color (renderer, EEK_ELEMENT(priv->keyboard),
EEK_ELEMENT(priv->keyboard)); &foreground);
background = eek_renderer_get_background_color (renderer,
eek_renderer_get_background_color (renderer, EEK_ELEMENT(priv->keyboard),
EEK_ELEMENT(priv->keyboard)); &background);
eek_element_get_bounds (EEK_ELEMENT(priv->keyboard), &bounds); eek_element_get_bounds (EEK_ELEMENT(priv->keyboard), &bounds);
keyboard_surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, keyboard_surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
@ -170,10 +173,10 @@ create_keyboard_surface (EekRenderer *renderer)
/* blank background */ /* blank background */
cairo_set_source_rgba (data.cr, cairo_set_source_rgba (data.cr,
background->red, background.red,
background->green, background.green,
background->blue, background.blue,
background->alpha); background.alpha);
cairo_rectangle (data.cr, cairo_rectangle (data.cr,
0.0, 0.0,
0.0, 0.0,
@ -182,10 +185,10 @@ create_keyboard_surface (EekRenderer *renderer)
cairo_fill (data.cr); cairo_fill (data.cr);
cairo_set_source_rgba (data.cr, cairo_set_source_rgba (data.cr,
foreground->red, foreground.red,
foreground->green, foreground.green,
foreground->blue, foreground.blue,
foreground->alpha); foreground.alpha);
/* draw sections */ /* draw sections */
eek_container_foreach_child (EEK_CONTAINER(priv->keyboard), eek_container_foreach_child (EEK_CONTAINER(priv->keyboard),
@ -193,9 +196,6 @@ create_keyboard_surface (EekRenderer *renderer)
&data); &data);
cairo_destroy (data.cr); cairo_destroy (data.cr);
eek_color_free (foreground);
eek_color_free (background);
return keyboard_surface; return keyboard_surface;
} }
@ -210,20 +210,51 @@ render_key_outline (EekRenderer *renderer,
gdouble scale; gdouble scale;
gint i; gint i;
gulong oref; gulong oref;
EekColor *foreground, *background;
EekGradient *gradient;
EekThemeNode *theme_node; EekThemeNode *theme_node;
EekColor foreground, background, gradient_start, gradient_end, border_color;
/* need to rescale so that the border fit inside the clipping EekGradientType gradient_type;
region */ gint border_width;
eek_element_get_bounds (EEK_ELEMENT(key), &bounds); gint border_radius;
scale = MIN((bounds.width - priv->border_width) / bounds.width,
(bounds.height - priv->border_width) / bounds.height);
oref = eek_key_get_oref (key); oref = eek_key_get_oref (key);
if (oref == 0) if (oref == 0)
return; return;
if (eek_key_is_pressed (key))
theme_node = g_object_get_data (G_OBJECT(key), "theme-node-pressed");
else
theme_node = g_object_get_data (G_OBJECT(key), "theme-node");
if (theme_node) {
eek_theme_node_get_foreground_color (theme_node, &foreground);
eek_theme_node_get_background_color (theme_node, &background);
eek_theme_node_get_background_gradient (theme_node,
&gradient_type,
&gradient_start,
&gradient_end);
border_width = eek_theme_node_get_border_width (theme_node,
EEK_SIDE_TOP);
border_radius = eek_theme_node_get_border_radius (theme_node,
EEK_SIDE_TOP);
eek_theme_node_get_border_color (theme_node, EEK_SIDE_TOP,
&border_color);
} else {
foreground = priv->default_foreground_color;
background = priv->default_background_color;
gradient_type = EEK_GRADIENT_NONE;
border_width = priv->border_width;
border_radius = -1;
border_color.red = ABS(background.red - foreground.red) * 0.7;
border_color.green = ABS(background.green - foreground.green) * 0.7;
border_color.blue = ABS(background.blue - foreground.blue) * 0.7;
border_color.alpha = foreground.alpha;
}
/* need to rescale so that the border fit inside the clipping
region */
eek_element_get_bounds (EEK_ELEMENT(key), &bounds);
scale = MIN((bounds.width - border_width) / bounds.width,
(bounds.height - border_width) / bounds.height);
outline = eek_keyboard_get_outline (priv->keyboard, oref); outline = eek_keyboard_get_outline (priv->keyboard, oref);
outline = eek_outline_copy (outline); outline = eek_outline_copy (outline);
for (i = 0; i < outline->num_points; i++) { for (i = 0; i < outline->num_points; i++) {
@ -232,28 +263,14 @@ render_key_outline (EekRenderer *renderer,
} }
cairo_translate (cr, cairo_translate (cr,
priv->border_width / 2 * priv->scale, border_width / 2 * priv->scale,
priv->border_width / 2 * priv->scale); border_width / 2 * priv->scale);
theme_node = g_object_get_qdata (G_OBJECT(key), if (gradient_type != EEK_GRADIENT_NONE) {
g_quark_from_static_string ("theme-node"));
if (theme_node) {
eek_theme_node_set_pseudo_class (theme_node,
eek_key_is_pressed (key) ?
"active" : NULL);
}
foreground = eek_renderer_get_foreground_color (renderer, EEK_ELEMENT(key));
background = eek_renderer_get_background_color (renderer, EEK_ELEMENT(key));
gradient = eek_renderer_get_background_gradient (renderer,
EEK_ELEMENT(key));
if (gradient) {
cairo_pattern_t *pat; cairo_pattern_t *pat;
gdouble cx, cy; gdouble cx, cy;
switch (gradient->type) { switch (gradient_type) {
case EEK_GRADIENT_VERTICAL: case EEK_GRADIENT_VERTICAL:
pat = cairo_pattern_create_linear (0.0, pat = cairo_pattern_create_linear (0.0,
0.0, 0.0,
@ -283,54 +300,49 @@ render_key_outline (EekRenderer *renderer,
cairo_pattern_add_color_stop_rgba (pat, cairo_pattern_add_color_stop_rgba (pat,
1, 1,
gradient->start->red * 0.5, gradient_start.red * 0.5,
gradient->start->green * 0.5, gradient_start.green * 0.5,
gradient->start->blue * 0.5, gradient_start.blue * 0.5,
gradient->start->alpha); gradient_start.alpha);
cairo_pattern_add_color_stop_rgba (pat, cairo_pattern_add_color_stop_rgba (pat,
0, 0,
gradient->end->red, gradient_end.red,
gradient->end->green, gradient_end.green,
gradient->end->blue, gradient_end.blue,
gradient->end->alpha); gradient_end.alpha);
eek_gradient_free (gradient);
cairo_set_source (cr, pat); cairo_set_source (cr, pat);
cairo_pattern_destroy (pat); cairo_pattern_destroy (pat);
} else { } else {
cairo_set_source_rgba (cr, cairo_set_source_rgba (cr,
background->red, background.red,
background->green, background.green,
background->blue, background.blue,
background->alpha); background.alpha);
} }
_eek_rounded_polygon (cr, _eek_rounded_polygon (cr,
outline->corner_radius, border_radius >= 0 ? border_radius : outline->corner_radius,
outline->points, outline->points,
outline->num_points); outline->num_points);
cairo_fill (cr); cairo_fill (cr);
/* paint the border - FIXME: should be configured through theme */ /* paint the border */
cairo_set_line_width (cr, priv->border_width); cairo_set_line_width (cr, border_width);
cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND); cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);
cairo_set_source_rgba cairo_set_source_rgba (cr,
(cr, border_color.red,
ABS(background->red - foreground->red) * 0.7, border_color.green,
ABS(background->green - foreground->green) * 0.7, border_color.blue,
ABS(background->blue - foreground->blue) * 0.7, border_color.alpha);
foreground->alpha);
_eek_rounded_polygon (cr, _eek_rounded_polygon (cr,
outline->corner_radius, border_radius >= 0 ? border_radius : outline->corner_radius,
outline->points, outline->points,
outline->num_points); outline->num_points);
cairo_stroke (cr); cairo_stroke (cr);
eek_outline_free (outline); eek_outline_free (outline);
eek_color_free (foreground);
eek_color_free (background);
} }
struct _CalculateFontSizeCallbackData { struct _CalculateFontSizeCallbackData {
@ -479,7 +491,7 @@ render_key (EekRenderer *self,
} else { } else {
PangoLayout *layout; PangoLayout *layout;
PangoRectangle extents = { 0, }; PangoRectangle extents = { 0, };
EekColor *foreground; EekColor foreground;
EekThemeNode *theme_node; EekThemeNode *theme_node;
layout = pango_cairo_create_layout (cr); layout = pango_cairo_create_layout (cr);
@ -492,21 +504,17 @@ render_key (EekRenderer *self,
(bounds.width * priv->scale - extents.width / PANGO_SCALE) / 2, (bounds.width * priv->scale - extents.width / PANGO_SCALE) / 2,
(bounds.height * priv->scale - extents.height / PANGO_SCALE) / 2); (bounds.height * priv->scale - extents.height / PANGO_SCALE) / 2);
theme_node = g_object_get_qdata (G_OBJECT(key), if (eek_key_is_pressed (key))
g_quark_from_static_string ("theme-node")); theme_node = g_object_get_data (G_OBJECT(key), "theme-node-pressed");
if (theme_node) { else
eek_theme_node_set_pseudo_class (theme_node, theme_node = g_object_get_data (G_OBJECT(key), "theme-node");
eek_key_is_pressed (key) ?
"active" : NULL);
}
foreground = eek_renderer_get_foreground_color (self, EEK_ELEMENT(key)); eek_renderer_get_foreground_color (self, EEK_ELEMENT(key), &foreground);
cairo_set_source_rgba (cr, cairo_set_source_rgba (cr,
foreground->red, foreground.red,
foreground->green, foreground.green,
foreground->blue, foreground.blue,
foreground->alpha); foreground.alpha);
eek_color_free (foreground);
pango_cairo_show_layout (cr, layout); pango_cairo_show_layout (cr, layout);
cairo_restore (cr); cairo_restore (cr);
@ -627,7 +635,7 @@ eek_renderer_real_render_keyboard (EekRenderer *self,
cairo_t *cr) cairo_t *cr)
{ {
EekRendererPrivate *priv = EEK_RENDERER_GET_PRIVATE(self); EekRendererPrivate *priv = EEK_RENDERER_GET_PRIVATE(self);
EekColor *background; EekColor background;
g_return_if_fail (priv->keyboard); g_return_if_fail (priv->keyboard);
g_return_if_fail (priv->allocation_width > 0.0); g_return_if_fail (priv->allocation_width > 0.0);
@ -637,14 +645,14 @@ eek_renderer_real_render_keyboard (EekRenderer *self,
priv->keyboard_surface = create_keyboard_surface (self); priv->keyboard_surface = create_keyboard_surface (self);
/* blank background */ /* blank background */
background = eek_renderer_get_background_color (self, eek_renderer_get_background_color (self,
EEK_ELEMENT(priv->keyboard)); EEK_ELEMENT(priv->keyboard),
&background);
cairo_set_source_rgba (cr, cairo_set_source_rgba (cr,
background->red, background.red,
background->green, background.green,
background->blue, background.blue,
background->alpha); background.alpha);
eek_color_free (background);
cairo_rectangle (cr, cairo_rectangle (cr,
0.0, 0.0,
@ -737,8 +745,6 @@ eek_renderer_finalize (GObject *object)
EekRendererPrivate *priv = EEK_RENDERER_GET_PRIVATE(object); EekRendererPrivate *priv = EEK_RENDERER_GET_PRIVATE(object);
g_hash_table_destroy (priv->outline_surface_cache); g_hash_table_destroy (priv->outline_surface_cache);
g_hash_table_destroy (priv->active_outline_surface_cache); g_hash_table_destroy (priv->active_outline_surface_cache);
eek_color_free (priv->default_foreground);
eek_color_free (priv->default_background);
pango_font_description_free (priv->font); pango_font_description_free (priv->font);
G_OBJECT_CLASS (eek_renderer_parent_class)->finalize (object); G_OBJECT_CLASS (eek_renderer_parent_class)->finalize (object);
} }
@ -789,8 +795,8 @@ eek_renderer_init (EekRenderer *self)
priv = self->priv = EEK_RENDERER_GET_PRIVATE(self); priv = self->priv = EEK_RENDERER_GET_PRIVATE(self);
priv->keyboard = NULL; priv->keyboard = NULL;
priv->pcontext = NULL; priv->pcontext = NULL;
priv->default_foreground = eek_color_new (0.3, 0.3, 0.3, 1.0); priv->default_foreground_color = DEFAULT_FOREGROUND_COLOR;
priv->default_background = eek_color_new (1.0, 1.0, 1.0, 1.0); priv->default_background_color = DEFAULT_BACKGROUND_COLOR;
priv->border_width = 1.0; priv->border_width = 1.0;
priv->allocation_width = 0.0; priv->allocation_width = 0.0;
priv->allocation_height = 0.0; priv->allocation_height = 0.0;
@ -1062,93 +1068,94 @@ eek_renderer_render_keyboard (EekRenderer *renderer,
} }
void void
eek_renderer_set_default_foreground_color (EekRenderer *renderer, eek_renderer_set_default_foreground_color (EekRenderer *renderer,
EekColor *foreground) const EekColor *color)
{ {
EekRendererPrivate *priv; EekRendererPrivate *priv;
g_return_if_fail (EEK_IS_RENDERER(renderer)); g_return_if_fail (EEK_IS_RENDERER(renderer));
g_return_if_fail (foreground); g_return_if_fail (color);
priv = EEK_RENDERER_GET_PRIVATE(renderer); priv = EEK_RENDERER_GET_PRIVATE(renderer);
if (priv->default_foreground) priv->default_foreground_color = *color;
eek_color_free (priv->default_foreground);
priv->default_foreground = eek_color_copy (foreground);
} }
void void
eek_renderer_set_default_background_color (EekRenderer *renderer, eek_renderer_set_default_background_color (EekRenderer *renderer,
EekColor *background) const EekColor *color)
{ {
EekRendererPrivate *priv; EekRendererPrivate *priv;
g_return_if_fail (EEK_IS_RENDERER(renderer)); g_return_if_fail (EEK_IS_RENDERER(renderer));
g_return_if_fail (background); g_return_if_fail (color);
priv = EEK_RENDERER_GET_PRIVATE(renderer); priv = EEK_RENDERER_GET_PRIVATE(renderer);
if (priv->default_background) priv->default_background_color = *color;
eek_color_free (priv->default_background);
priv->default_background = eek_color_copy (background);
} }
EekColor * void
eek_renderer_get_foreground_color (EekRenderer *renderer, EekElement *element) eek_renderer_get_foreground_color (EekRenderer *renderer,
EekElement *element,
EekColor *color)
{ {
EekRendererPrivate *priv; EekRendererPrivate *priv;
EekThemeNode *theme_node; EekThemeNode *theme_node;
g_assert (EEK_IS_RENDERER(renderer)); g_return_if_fail (EEK_IS_RENDERER(renderer));
g_return_if_fail (color);
priv = EEK_RENDERER_GET_PRIVATE(renderer); priv = EEK_RENDERER_GET_PRIVATE(renderer);
theme_node = g_object_get_qdata (G_OBJECT(element), theme_node = g_object_get_data (G_OBJECT(element), "theme-node");
g_quark_from_static_string ("theme-node"));
if (theme_node) {
EekColor *color = eek_theme_node_get_foreground_color (theme_node);
if (color)
return color;
}
return eek_color_copy (priv->default_foreground);
}
EekColor *
eek_renderer_get_background_color (EekRenderer *renderer, EekElement *element)
{
EekRendererPrivate *priv;
EekThemeNode *theme_node;
g_assert (EEK_IS_RENDERER(renderer));
priv = EEK_RENDERER_GET_PRIVATE(renderer);
theme_node = g_object_get_qdata (G_OBJECT(element),
g_quark_from_static_string ("theme-node"));
if (theme_node) {
EekColor *color = eek_theme_node_get_background_color (theme_node);
if (color)
return color;
}
return eek_color_copy (priv->default_background);
}
EekGradient *
eek_renderer_get_background_gradient (EekRenderer *renderer, EekElement *element)
{
EekRendererPrivate *priv;
EekThemeNode *theme_node;
g_assert (EEK_IS_RENDERER(renderer));
priv = EEK_RENDERER_GET_PRIVATE(renderer);
theme_node = g_object_get_qdata (G_OBJECT(element),
g_quark_from_static_string ("theme-node"));
if (theme_node) if (theme_node)
return eek_theme_node_get_background_gradient (theme_node); eek_theme_node_get_foreground_color (theme_node, color);
else
*color = priv->default_foreground_color;
}
return NULL; void
eek_renderer_get_background_color (EekRenderer *renderer,
EekElement *element,
EekColor *color)
{
EekRendererPrivate *priv;
EekThemeNode *theme_node;
g_return_if_fail (EEK_IS_RENDERER(renderer));
g_return_if_fail (color);
priv = EEK_RENDERER_GET_PRIVATE(renderer);
theme_node = g_object_get_data (G_OBJECT(element), "theme-node");
if (theme_node)
eek_theme_node_get_background_color (theme_node, color);
else
*color = priv->default_background_color;
}
void
eek_renderer_get_background_gradient (EekRenderer *renderer,
EekElement *element,
EekGradientType *type,
EekColor *start,
EekColor *end)
{
EekRendererPrivate *priv;
EekThemeNode *theme_node;
g_return_if_fail (EEK_IS_RENDERER(renderer));
g_return_if_fail (EEK_IS_ELEMENT(element));
g_return_if_fail (type);
g_return_if_fail (start);
g_return_if_fail (end);
priv = EEK_RENDERER_GET_PRIVATE(renderer);
theme_node = g_object_get_data (G_OBJECT(element), "theme-node");
if (theme_node)
eek_theme_node_get_background_gradient (theme_node, type, start, end);
else
*type = EEK_GRADIENT_NONE;
} }
struct _FindKeyByPositionCallbackData { struct _FindKeyByPositionCallbackData {
@ -1300,10 +1307,22 @@ create_theme_node_key_callback (EekElement *element,
"key", "key",
NULL, NULL,
NULL); NULL);
g_object_set_qdata_full (G_OBJECT(element), g_object_set_data_full (G_OBJECT(element),
g_quark_from_static_string ("theme-node"), "theme-node",
theme_node, theme_node,
(GDestroyNotify)g_object_unref); (GDestroyNotify)g_object_unref);
theme_node = eek_theme_node_new (data->parent,
priv->theme,
EEK_TYPE_KEY,
eek_element_get_name (element),
"key",
"active",
NULL);
g_object_set_data_full (G_OBJECT(element),
"theme-node-pressed",
theme_node,
(GDestroyNotify)g_object_unref);
} }
void void
@ -1323,10 +1342,10 @@ create_theme_node_section_callback (EekElement *element,
"section", "section",
NULL, NULL,
NULL); NULL);
g_object_set_qdata_full (G_OBJECT(element), g_object_set_data_full (G_OBJECT(element),
g_quark_from_static_string ("theme-node"), "theme-node",
theme_node, theme_node,
(GDestroyNotify)g_object_unref); (GDestroyNotify)g_object_unref);
parent = data->parent; parent = data->parent;
data->parent = theme_node; data->parent = theme_node;
@ -1361,10 +1380,10 @@ eek_renderer_set_theme (EekRenderer *renderer,
"keyboard", "keyboard",
NULL, NULL,
NULL); NULL);
g_object_set_qdata_full (G_OBJECT(priv->keyboard), g_object_set_data_full (G_OBJECT(priv->keyboard),
g_quark_from_static_string ("theme-node"), "theme-node",
theme_node, theme_node,
(GDestroyNotify)g_object_unref); (GDestroyNotify)g_object_unref);
data.parent = theme_node; data.parent = theme_node;
data.renderer = renderer; data.renderer = renderer;

120
eek/eek-renderer.h
View File

@ -80,74 +80,80 @@ struct _EekRendererClass
gpointer pdummy[23]; gpointer pdummy[23];
}; };
GType eek_renderer_get_type (void) G_GNUC_CONST; GType eek_renderer_get_type (void) G_GNUC_CONST;
EekRenderer *eek_renderer_new (EekKeyboard *keyboard, EekRenderer *eek_renderer_new (EekKeyboard *keyboard,
PangoContext *pcontext); PangoContext *pcontext);
void eek_renderer_set_allocation_size (EekRenderer *renderer, void eek_renderer_set_allocation_size (EekRenderer *renderer,
gdouble width, gdouble width,
gdouble height); gdouble height);
void eek_renderer_get_size (EekRenderer *renderer, void eek_renderer_get_size (EekRenderer *renderer,
gdouble *width, gdouble *width,
gdouble *height); gdouble *height);
void eek_renderer_get_key_bounds (EekRenderer *renderer, void eek_renderer_get_key_bounds (EekRenderer *renderer,
EekKey *key, EekKey *key,
EekBounds *bounds, EekBounds *bounds,
gboolean rotate); gboolean rotate);
gdouble eek_renderer_get_scale (EekRenderer *renderer); gdouble eek_renderer_get_scale (EekRenderer *renderer);
PangoLayout *eek_renderer_create_pango_layout (EekRenderer *renderer); PangoLayout *eek_renderer_create_pango_layout (EekRenderer *renderer);
void eek_renderer_render_key_label (EekRenderer *renderer, void eek_renderer_render_key_label (EekRenderer *renderer,
PangoLayout *layout, PangoLayout *layout,
EekKey *key); EekKey *key);
void eek_renderer_render_key_outline (EekRenderer *renderer, void eek_renderer_render_key_outline (EekRenderer *renderer,
cairo_t *cr, cairo_t *cr,
EekKey *key, EekKey *key,
gdouble scale, gdouble scale,
gboolean rotate); gboolean rotate);
void eek_renderer_render_key (EekRenderer *renderer, void eek_renderer_render_key (EekRenderer *renderer,
cairo_t *cr, cairo_t *cr,
EekKey *key, EekKey *key,
gdouble scale, gdouble scale,
gboolean rotate); gboolean rotate);
void eek_renderer_render_key_icon (EekRenderer *renderer, void eek_renderer_render_key_icon (EekRenderer *renderer,
cairo_t *cr, cairo_t *cr,
EekKey *key, EekKey *key,
gdouble scale, gdouble scale,
gboolean rotate); gboolean rotate);
void eek_renderer_render_keyboard (EekRenderer *renderer, void eek_renderer_render_keyboard (EekRenderer *renderer,
cairo_t *cr); cairo_t *cr);
void eek_renderer_set_default_foreground_color void eek_renderer_set_default_foreground_color
(EekRenderer *renderer, (EekRenderer *renderer,
EekColor *foreground); const EekColor *color);
void eek_renderer_set_default_background_color void eek_renderer_set_default_background_color
(EekRenderer *renderer, (EekRenderer *renderer,
EekColor *background); const EekColor *color);
EekColor *eek_renderer_get_foreground_color (EekRenderer *renderer, void eek_renderer_get_foreground_color (EekRenderer *renderer,
EekElement *element); EekElement *element,
EekColor *eek_renderer_get_background_color (EekRenderer *renderer, EekColor *color);
EekElement *element); void eek_renderer_get_background_color (EekRenderer *renderer,
EekGradient *eek_renderer_get_background_gradient (EekRenderer *renderer, EekElement *element,
EekElement *element); EekColor *color);
void eek_renderer_set_border_width (EekRenderer *renderer, void eek_renderer_get_background_gradient
gdouble border_width); (EekRenderer *renderer,
EekKey *eek_renderer_find_key_by_position (EekRenderer *renderer, EekElement *element,
gdouble x, EekGradientType *type,
gdouble y); EekColor *start,
EekColor *end);
void eek_renderer_set_border_width (EekRenderer *renderer,
gdouble border_width);
EekKey *eek_renderer_find_key_by_position (EekRenderer *renderer,
gdouble x,
gdouble y);
void eek_renderer_apply_transformation_for_key void eek_renderer_apply_transformation_for_key
(EekRenderer *renderer, (EekRenderer *renderer,
cairo_t *cr, cairo_t *cr,
EekKey *key, EekKey *key,
gdouble scale, gdouble scale,
gboolean rotate); gboolean rotate);
void eek_renderer_set_theme (EekRenderer *renderer, void eek_renderer_set_theme (EekRenderer *renderer,
EekTheme *theme); EekTheme *theme);
G_END_DECLS G_END_DECLS
#endif /* EEK_RENDERER_H */ #endif /* EEK_RENDERER_H */

1590
eek/eek-theme-node.c
View File

File diff suppressed because it is too large Load Diff

49
eek/eek-theme-node.h
View File

@ -43,6 +43,20 @@ G_BEGIN_DECLS
* borders and padding. * borders and padding.
*/ */
typedef enum {
EEK_SIDE_TOP,
EEK_SIDE_RIGHT,
EEK_SIDE_BOTTOM,
EEK_SIDE_LEFT
} EekSide;
typedef enum {
EEK_CORNER_TOPLEFT,
EEK_CORNER_TOPRIGHT,
EEK_CORNER_BOTTOMRIGHT,
EEK_CORNER_BOTTOMLEFT
} EekCorner;
#define EEK_TYPE_THEME_NODE (eek_theme_node_get_type()) #define EEK_TYPE_THEME_NODE (eek_theme_node_get_type())
#define EEK_THEME_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EEK_TYPE_THEME_NODE, EekThemeNode)) #define EEK_THEME_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EEK_TYPE_THEME_NODE, EekThemeNode))
#define EEK_THEME_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EEK_TYPE_THEME_NODE, EekThemeNodeClass)) #define EEK_THEME_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EEK_TYPE_THEME_NODE, EekThemeNodeClass))
@ -86,9 +100,6 @@ const char *eek_theme_node_get_element_id
(EekThemeNode *node); (EekThemeNode *node);
const char *eek_theme_node_get_element_class const char *eek_theme_node_get_element_class
(EekThemeNode *node); (EekThemeNode *node);
void eek_theme_node_set_pseudo_class
(EekThemeNode *node,
const gchar *pseudo_class);
const char *eek_theme_node_get_pseudo_class const char *eek_theme_node_get_pseudo_class
(EekThemeNode *node); (EekThemeNode *node);
@ -97,20 +108,34 @@ const char *eek_theme_node_get_pseudo_class
* details of the actual CSS rules, which can be complicated, especially * details of the actual CSS rules, which can be complicated, especially
* for fonts * for fonts
*/ */
gboolean eek_theme_node_get_color void eek_theme_node_get_color
(EekThemeNode *node, (EekThemeNode *node,
const char *property_name, const char *property_name,
gboolean inherit, EekColor *color);
EekColor **color);
/* Specific getters for particular properties: cached /* Specific getters for particular properties: cached
*/ */
EekColor *eek_theme_node_get_background_color void eek_theme_node_get_background_color
(EekThemeNode *node); (EekThemeNode *node,
EekColor *eek_theme_node_get_foreground_color EekColor *color);
(EekThemeNode *node); void eek_theme_node_get_foreground_color
EekGradient *eek_theme_node_get_background_gradient (EekThemeNode *node,
(EekThemeNode *node); EekColor *color);
void eek_theme_node_get_background_gradient
(EekThemeNode *node,
EekGradientType *type,
EekColor *start,
EekColor *end);
int eek_theme_node_get_border_width
(EekThemeNode *node,
EekSide side);
int eek_theme_node_get_border_radius
(EekThemeNode *node,
EekCorner corner);
void eek_theme_node_get_border_color
(EekThemeNode *node,
EekSide side,
EekColor *color);
G_END_DECLS G_END_DECLS

42
eek/eek-types.c
View File

@ -222,45 +222,3 @@ eek_color_new (gdouble red,
return color; return color;
} }
GType
eek_gradient_get_type (void)
{
static GType our_type = 0;
if (our_type == 0)
our_type =
g_boxed_type_register_static ("EekGradient",
(GBoxedCopyFunc)eek_gradient_copy,
(GBoxedFreeFunc)eek_gradient_free);
return our_type;
}
EekGradient *
eek_gradient_new (EekGradientType type,
EekColor *start,
EekColor *end)
{
EekGradient *gradient;
gradient = g_slice_new (EekGradient);
gradient->type = type;
gradient->start = eek_color_copy (start);
gradient->end = eek_color_copy (end);
return gradient;
}
EekGradient *
eek_gradient_copy (const EekGradient *gradient)
{
return eek_gradient_new (gradient->type, gradient->start, gradient->end);
}
void
eek_gradient_free (EekGradient *gradient)
{
eek_color_free (gradient->start);
eek_color_free (gradient->end);
g_slice_free (EekGradient, gradient);
}

16
eek/eek-types.h
View File

@ -262,21 +262,5 @@ typedef enum {
EEK_GRADIENT_RADIAL EEK_GRADIENT_RADIAL
} EekGradientType; } EekGradientType;
struct _EekGradient
{
EekGradientType type;
EekColor *start;
EekColor *end;
};
typedef struct _EekGradient EekGradient;
GType eek_gradient_get_type (void) G_GNUC_CONST;
EekGradient *eek_gradient_new (EekGradientType type,
EekColor *start,
EekColor *end);
EekGradient *eek_gradient_copy (const EekGradient *gradient);
void eek_gradient_free (EekGradient *gradient);
G_END_DECLS G_END_DECLS
#endif /* EEK_TYPES_H */ #endif /* EEK_TYPES_H */

3
src/server-context.c
View File

@ -189,6 +189,8 @@ on_realize (GtkWidget *widget,
GDK_FUNC_MOVE | GDK_FUNC_MOVE |
GDK_FUNC_MINIMIZE | GDK_FUNC_MINIMIZE |
GDK_FUNC_CLOSE); GDK_FUNC_CLOSE);
gtk_window_set_opacity (GTK_WINDOW(context->window), 0.9);
} }
#define DEFAULT_THEME (THEMEDIR "/default.css") #define DEFAULT_THEME (THEMEDIR "/default.css")
@ -249,6 +251,7 @@ update_widget (ServerContext *context)
gtk_window_set_title (GTK_WINDOW(context->window), _("Keyboard")); gtk_window_set_title (GTK_WINDOW(context->window), _("Keyboard"));
gtk_window_set_icon_name (GTK_WINDOW(context->window), "eekboard"); gtk_window_set_icon_name (GTK_WINDOW(context->window), "eekboard");
gtk_window_set_keep_above (GTK_WINDOW(context->window), TRUE); gtk_window_set_keep_above (GTK_WINDOW(context->window), TRUE);
gtk_window_set_decorated (GTK_WINDOW(context->window), FALSE);
g_signal_connect (context->window, "realize", g_signal_connect (context->window, "realize",
G_CALLBACK(on_realize), context); G_CALLBACK(on_realize), context);