358 lines
12 KiB
C
358 lines
12 KiB
C
/*
|
|
* Copyright (C) 2010-2011 Daiki Ueno <ueno@unixuser.org>
|
|
* Copyright (C) 2010-2011 Red Hat, Inc.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public License
|
|
* as published by the Free Software Foundation; either version 2 of
|
|
* the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
* 02110-1301 USA
|
|
*/
|
|
|
|
#include <math.h>
|
|
#include <string.h>
|
|
#include <gdk-pixbuf/gdk-pixbuf.h>
|
|
|
|
#include "eek-keyboard.h"
|
|
#include "eek-renderer.h"
|
|
#include "src/style.h"
|
|
|
|
|
|
/* eek-keyboard-drawing.c */
|
|
static void render_button_label (cairo_t *cr, GtkStyleContext *ctx,
|
|
const gchar *label, EekBounds bounds);
|
|
|
|
static void
|
|
render_outline (cairo_t *cr,
|
|
GtkStyleContext *ctx,
|
|
EekBounds bounds)
|
|
{
|
|
GtkBorder margin, border;
|
|
gtk_style_context_get_margin(ctx, GTK_STATE_FLAG_NORMAL, &margin);
|
|
gtk_style_context_get_border(ctx, GTK_STATE_FLAG_NORMAL, &border);
|
|
|
|
gdouble x = margin.left + border.left;
|
|
gdouble y = margin.top + border.top;
|
|
EekBounds position = {
|
|
.x = x,
|
|
.y = y,
|
|
.width = bounds.width - x - (margin.right + border.right),
|
|
.height = bounds.height - y - (margin.bottom + border.bottom),
|
|
};
|
|
gtk_render_background (ctx, cr,
|
|
position.x, position.y, position.width, position.height);
|
|
gtk_render_frame (ctx, cr,
|
|
position.x, position.y, position.width, position.height);
|
|
}
|
|
|
|
/// Rust interface
|
|
void eek_render_button_in_context(uint32_t scale_factor,
|
|
cairo_t *cr,
|
|
GtkStyleContext *ctx,
|
|
EekBounds bounds,
|
|
const char *icon_name,
|
|
const gchar *label) {
|
|
/* blank background */
|
|
cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 0.0);
|
|
cairo_paint (cr);
|
|
|
|
render_outline (cr, ctx, bounds);
|
|
cairo_paint (cr);
|
|
|
|
/* render icon (if any) */
|
|
if (icon_name) {
|
|
cairo_surface_t *icon_surface =
|
|
eek_renderer_get_icon_surface (icon_name, 16, scale_factor);
|
|
if (icon_surface) {
|
|
gint width = cairo_image_surface_get_width (icon_surface);
|
|
gint height = cairo_image_surface_get_height (icon_surface);
|
|
|
|
cairo_save (cr);
|
|
cairo_translate (cr,
|
|
(bounds.width - (double)width / scale_factor) / 2,
|
|
(bounds.height - (double)height / scale_factor) / 2);
|
|
cairo_rectangle (cr, 0, 0, width, height);
|
|
cairo_clip (cr);
|
|
/* Draw the shape of the icon using the foreground color */
|
|
GdkRGBA color = {0};
|
|
gtk_style_context_get_color (ctx, GTK_STATE_FLAG_NORMAL, &color);
|
|
|
|
cairo_set_source_rgba (cr, color.red,
|
|
color.green,
|
|
color.blue,
|
|
color.alpha);
|
|
cairo_mask_surface (cr, icon_surface, 0.0, 0.0);
|
|
cairo_surface_destroy(icon_surface);
|
|
cairo_fill (cr);
|
|
cairo_restore (cr);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (label) {
|
|
render_button_label (cr, ctx, label, bounds);
|
|
}
|
|
}
|
|
|
|
/// Prepare context for drawing the button.
|
|
/// The context MUST be released using the corresponing "put" procedure
|
|
/// before drawing the next button.
|
|
/// Interface for Rust.
|
|
GtkStyleContext *
|
|
eek_get_style_context_for_button (EekRenderer *self,
|
|
const char *name,
|
|
const char *outline_name,
|
|
const char *locked_class,
|
|
uint64_t pressed)
|
|
{
|
|
GtkStyleContext *ctx = self->button_context;
|
|
/* Set the name of the button on the widget path, using the name obtained
|
|
from the button's symbol. */
|
|
g_autoptr (GtkWidgetPath) path = NULL;
|
|
path = gtk_widget_path_copy (gtk_style_context_get_path (ctx));
|
|
gtk_widget_path_iter_set_name (path, -1, name);
|
|
|
|
/* Update the style context with the updated widget path. */
|
|
gtk_style_context_set_path (ctx, path);
|
|
/* Set the state to take into account whether the button is active
|
|
(pressed) or normal. */
|
|
gtk_style_context_set_state(ctx,
|
|
pressed ? GTK_STATE_FLAG_ACTIVE : GTK_STATE_FLAG_NORMAL);
|
|
if (locked_class) {
|
|
gtk_style_context_add_class(ctx, locked_class);
|
|
}
|
|
gtk_style_context_add_class(ctx, outline_name);
|
|
return ctx;
|
|
}
|
|
|
|
/// Interface for Rust.
|
|
void eek_put_style_context_for_button(GtkStyleContext *ctx,
|
|
const char *outline_name,
|
|
const char *locked_class) {
|
|
// Save and restore functions don't work if gtk_render_* was used in between
|
|
gtk_style_context_set_state(ctx, GTK_STATE_FLAG_NORMAL);
|
|
gtk_style_context_remove_class(ctx, outline_name);
|
|
if (locked_class) {
|
|
gtk_style_context_remove_class(ctx, locked_class);
|
|
}
|
|
}
|
|
|
|
static void
|
|
render_button_label (cairo_t *cr,
|
|
GtkStyleContext *ctx,
|
|
const gchar *label,
|
|
EekBounds bounds)
|
|
{
|
|
PangoFontDescription *font;
|
|
gtk_style_context_get(ctx,
|
|
gtk_style_context_get_state(ctx),
|
|
"font", &font,
|
|
NULL);
|
|
PangoLayout *layout = pango_cairo_create_layout (cr);
|
|
pango_layout_set_font_description (layout, font);
|
|
pango_font_description_free (font);
|
|
|
|
pango_layout_set_text (layout, label, -1);
|
|
PangoLayoutLine *line = pango_layout_get_line_readonly(layout, 0);
|
|
if (line->resolved_dir == PANGO_DIRECTION_RTL) {
|
|
pango_layout_set_alignment (layout, PANGO_ALIGN_RIGHT);
|
|
}
|
|
pango_layout_set_width (layout, PANGO_SCALE * bounds.width);
|
|
|
|
PangoRectangle extents = { 0, };
|
|
pango_layout_get_extents (layout, NULL, &extents);
|
|
|
|
cairo_save (cr);
|
|
cairo_move_to
|
|
(cr,
|
|
(bounds.width - (double)extents.width / PANGO_SCALE) / 2,
|
|
(bounds.height - (double)extents.height / PANGO_SCALE) / 2);
|
|
|
|
GdkRGBA color = {0};
|
|
gtk_style_context_get_color (ctx, GTK_STATE_FLAG_NORMAL, &color);
|
|
|
|
cairo_set_source_rgba (cr,
|
|
color.red,
|
|
color.green,
|
|
color.blue,
|
|
color.alpha);
|
|
pango_cairo_show_layout (cr, layout);
|
|
cairo_restore (cr);
|
|
g_object_unref (layout);
|
|
}
|
|
|
|
// FIXME: Pass just the active modifiers instead of entire submission
|
|
void
|
|
eek_renderer_render_keyboard (EekRenderer *self,
|
|
struct render_geometry geometry,
|
|
struct submission *submission,
|
|
cairo_t *cr,
|
|
LevelKeyboard *keyboard)
|
|
{
|
|
g_return_if_fail (geometry.allocation_width > 0.0);
|
|
g_return_if_fail (geometry.allocation_height > 0.0);
|
|
|
|
/* Paint the background covering the entire widget area */
|
|
gtk_render_background (self->view_context,
|
|
cr,
|
|
0, 0,
|
|
geometry.allocation_width, geometry.allocation_height);
|
|
|
|
cairo_save(cr);
|
|
cairo_translate (cr, geometry.widget_to_layout.origin_x, geometry.widget_to_layout.origin_y);
|
|
cairo_scale (cr, geometry.widget_to_layout.scale, geometry.widget_to_layout.scale);
|
|
|
|
squeek_draw_layout_base_view(keyboard->layout, self, cr);
|
|
squeek_layout_draw_all_changed(keyboard->layout, self, cr, submission);
|
|
cairo_restore (cr);
|
|
}
|
|
|
|
void
|
|
eek_renderer_free (EekRenderer *self)
|
|
{
|
|
if (self->pcontext) {
|
|
g_object_unref (self->pcontext);
|
|
self->pcontext = NULL;
|
|
}
|
|
g_object_unref(self->css_provider);
|
|
g_object_unref(self->view_context);
|
|
g_object_unref(self->button_context);
|
|
// this is where renderer-specific surfaces would be released
|
|
|
|
free(self);
|
|
}
|
|
|
|
static GType new_type(char *name) {
|
|
GTypeInfo info = {0};
|
|
info.class_size = sizeof(GtkWidgetClass);
|
|
info.instance_size = sizeof(GtkWidget);
|
|
|
|
return g_type_register_static(GTK_TYPE_WIDGET, name, &info,
|
|
G_TYPE_FLAG_ABSTRACT
|
|
);
|
|
}
|
|
|
|
static GType view_type(void) {
|
|
static GType type = 0;
|
|
if (!type) {
|
|
type = new_type("sq_view");
|
|
}
|
|
return type;
|
|
}
|
|
|
|
static GType button_type(void) {
|
|
static GType type = 0;
|
|
if (!type) {
|
|
type = new_type("sq_button");
|
|
}
|
|
return type;
|
|
}
|
|
|
|
static void
|
|
renderer_init (EekRenderer *self)
|
|
{
|
|
self->pcontext = NULL;
|
|
self->scale_factor = 1;
|
|
|
|
self->css_provider = squeek_load_style();
|
|
}
|
|
|
|
EekRenderer *
|
|
eek_renderer_new (LevelKeyboard *keyboard,
|
|
PangoContext *pcontext)
|
|
{
|
|
EekRenderer *renderer = calloc(1, sizeof(EekRenderer));
|
|
renderer_init(renderer);
|
|
renderer->pcontext = pcontext;
|
|
g_object_ref (renderer->pcontext);
|
|
|
|
/* Create a style context for the layout */
|
|
GtkWidgetPath *path = gtk_widget_path_new();
|
|
gtk_widget_path_append_type(path, view_type());
|
|
|
|
renderer->view_context = gtk_style_context_new();
|
|
gtk_style_context_set_path(renderer->view_context, path);
|
|
gtk_widget_path_unref(path);
|
|
if (squeek_layout_get_kind(keyboard->layout) == ARRANGEMENT_KIND_WIDE) {
|
|
gtk_style_context_add_class(renderer->view_context, "wide");
|
|
}
|
|
gtk_style_context_add_provider (renderer->view_context,
|
|
GTK_STYLE_PROVIDER(renderer->css_provider),
|
|
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
|
|
|
|
/* Create a style context for the buttons */
|
|
path = gtk_widget_path_new();
|
|
gtk_widget_path_append_type(path, view_type());
|
|
if (squeek_layout_get_kind(keyboard->layout) == ARRANGEMENT_KIND_WIDE) {
|
|
gtk_widget_path_iter_add_class(path, -1, "wide");
|
|
}
|
|
gtk_widget_path_append_type(path, button_type());
|
|
renderer->button_context = gtk_style_context_new ();
|
|
gtk_style_context_set_path(renderer->button_context, path);
|
|
gtk_widget_path_unref(path);
|
|
gtk_style_context_set_parent(renderer->button_context, renderer->view_context);
|
|
gtk_style_context_set_state (renderer->button_context, GTK_STATE_FLAG_NORMAL);
|
|
gtk_style_context_add_provider (renderer->button_context,
|
|
GTK_STYLE_PROVIDER(renderer->css_provider),
|
|
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
|
|
return renderer;
|
|
}
|
|
|
|
struct render_geometry
|
|
eek_render_geometry_from_allocation_size (struct squeek_layout *layout,
|
|
gdouble width,
|
|
gdouble height)
|
|
{
|
|
struct render_geometry ret = {
|
|
.allocation_width = width,
|
|
.allocation_height = height,
|
|
.widget_to_layout = squeek_layout_calculate_transformation(
|
|
layout, width, height),
|
|
};
|
|
return ret;
|
|
}
|
|
|
|
void
|
|
eek_renderer_set_scale_factor (EekRenderer *renderer, gint scale)
|
|
{
|
|
renderer->scale_factor = scale;
|
|
}
|
|
|
|
/// Rust interface.
|
|
uint32_t eek_renderer_get_scale_factor(EekRenderer *renderer) {
|
|
return renderer->scale_factor;
|
|
}
|
|
|
|
cairo_surface_t *
|
|
eek_renderer_get_icon_surface (const gchar *icon_name,
|
|
gint size,
|
|
gint scale)
|
|
{
|
|
GError *error = NULL;
|
|
cairo_surface_t *surface = gtk_icon_theme_load_surface (gtk_icon_theme_get_default (),
|
|
icon_name,
|
|
size,
|
|
scale,
|
|
NULL,
|
|
0,
|
|
&error);
|
|
|
|
if (surface == NULL) {
|
|
g_warning ("can't get icon surface for %s: %s",
|
|
icon_name,
|
|
error->message);
|
|
g_error_free (error);
|
|
return NULL;
|
|
}
|
|
return surface;
|
|
}
|