2007-03-22 18:21:59 +00:00
|
|
|
/*
|
|
|
|
* Clutter.
|
|
|
|
*
|
|
|
|
* An OpenGL based 'interactive canvas' library.
|
|
|
|
*
|
2010-03-01 12:56:10 +00:00
|
|
|
* Authored By:
|
|
|
|
* Matthew Allum <mallum@openedhand.com>
|
|
|
|
* Emmanuele Bassi <ebassi@linux.intel.com>
|
2007-03-22 18:21:59 +00:00
|
|
|
*
|
2010-03-01 12:56:10 +00:00
|
|
|
* Copyright (C) 2006, 2007, 2008 OpenedHand Ltd
|
|
|
|
* Copyright (C) 2009, 2010 Intel Corp
|
2007-03-22 18:21:59 +00:00
|
|
|
*
|
|
|
|
* 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
|
2010-03-01 12:56:10 +00:00
|
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
2007-03-22 18:21:59 +00:00
|
|
|
*/
|
|
|
|
|
2007-07-04 14:00:41 +00:00
|
|
|
/**
|
|
|
|
* SECTION:clutter-backend
|
|
|
|
* @short_description: Backend abstraction
|
|
|
|
*
|
|
|
|
* Clutter can be compiled against different backends. Each backend
|
|
|
|
* has to implement a set of functions, in order to be used by Clutter.
|
|
|
|
*
|
|
|
|
* #ClutterBackend is the base class abstracting the various implementation;
|
|
|
|
* it provides a basic API to query the backend for generic information
|
|
|
|
* and settings.
|
|
|
|
*
|
|
|
|
* #ClutterBackend is available since Clutter 0.4
|
|
|
|
*/
|
|
|
|
|
2007-10-12 08:17:00 +00:00
|
|
|
#ifdef HAVE_CONFIG_H
|
2007-03-22 18:21:59 +00:00
|
|
|
#include "config.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include "clutter-backend.h"
|
2008-04-04 15:02:11 +00:00
|
|
|
#include "clutter-debug.h"
|
2008-05-28 Emmanuele Bassi <ebassi@openedhand.com>
Bug #919 - Replacement pango renderer (Neil Roberts)
* clutter/clutter-backend.h:
* clutter/clutter-backend.c:
(clutter_backend_set_font_options),
(clutter_backend_get_font_options): Add the ability to set
the cairo_font_options_t* for the backend at construction
time, so that backend implementations can have their own
options.
* clutter/clutter-color.c: Include pango/pango-attributes.h
for the pango_color_parse() function.
* clutter/clutter-label.c:
(clutter_label_ensure_layout),
(clutter_label_init), (clutter_label_set_text),
(clutter_label_set_font_name), (clutter_label_set_ellipsize),
(clutter_label_set_use_markup): Ensure that the cache is
always primed when the Label changes; this makes sure that
the cache is rebuilt outside the paint run, which should
make the painting perform better especially on embedded
devices.
* clutter/clutter-entry.c:
(clutter_entry_ensure_layout),
(clutter_entry_init), (clutter_entry_set_text),
(clutter_entry_set_font_name): Ditto as above.
* clutter/clutter-private.h:
* clutter/clutter-main.[ch]: Create the font-map inside the
main context; add two new functions:
clutter_clear_glyph_cache()
clutter_set_use_mipmapped_text()
that control the glyphs cache.
* clutter/pango/Makefile.am:
* clutter/pango/pangoclutter-fontmap.c:
* clutter/pango/pangoclutter-private.h:
* clutter/pango/pangoclutter-render.c:
* clutter/pango/pangoclutter.h: Rewrite the Pango renderer
using a PangoCairo context and saving the glyphs inside a
more efficient cache.
* configure.ac: Depend on pangocairo instead of pangoft2.
2008-05-28 14:03:28 +00:00
|
|
|
#include "clutter-fixed.h"
|
2008-12-23 13:55:51 +00:00
|
|
|
#include "clutter-marshal.h"
|
2008-05-28 Emmanuele Bassi <ebassi@openedhand.com>
Bug #919 - Replacement pango renderer (Neil Roberts)
* clutter/clutter-backend.h:
* clutter/clutter-backend.c:
(clutter_backend_set_font_options),
(clutter_backend_get_font_options): Add the ability to set
the cairo_font_options_t* for the backend at construction
time, so that backend implementations can have their own
options.
* clutter/clutter-color.c: Include pango/pango-attributes.h
for the pango_color_parse() function.
* clutter/clutter-label.c:
(clutter_label_ensure_layout),
(clutter_label_init), (clutter_label_set_text),
(clutter_label_set_font_name), (clutter_label_set_ellipsize),
(clutter_label_set_use_markup): Ensure that the cache is
always primed when the Label changes; this makes sure that
the cache is rebuilt outside the paint run, which should
make the painting perform better especially on embedded
devices.
* clutter/clutter-entry.c:
(clutter_entry_ensure_layout),
(clutter_entry_init), (clutter_entry_set_text),
(clutter_entry_set_font_name): Ditto as above.
* clutter/clutter-private.h:
* clutter/clutter-main.[ch]: Create the font-map inside the
main context; add two new functions:
clutter_clear_glyph_cache()
clutter_set_use_mipmapped_text()
that control the glyphs cache.
* clutter/pango/Makefile.am:
* clutter/pango/pangoclutter-fontmap.c:
* clutter/pango/pangoclutter-private.h:
* clutter/pango/pangoclutter-render.c:
* clutter/pango/pangoclutter.h: Rewrite the Pango renderer
using a PangoCairo context and saving the glyphs inside a
more efficient cache.
* configure.ac: Depend on pangocairo instead of pangoft2.
2008-05-28 14:03:28 +00:00
|
|
|
#include "clutter-private.h"
|
2009-03-30 15:41:02 +00:00
|
|
|
#include "clutter-profile.h"
|
2007-03-22 18:21:59 +00:00
|
|
|
|
2009-10-21 22:24:49 +00:00
|
|
|
#include <cogl/cogl.h>
|
|
|
|
|
2007-07-24 16:22:29 +00:00
|
|
|
G_DEFINE_ABSTRACT_TYPE (ClutterBackend, clutter_backend, G_TYPE_OBJECT);
|
2007-03-22 18:21:59 +00:00
|
|
|
|
2008-12-23 15:03:11 +00:00
|
|
|
#define DEFAULT_FONT_NAME "Sans 10"
|
|
|
|
|
2007-05-09 23:31:08 +00:00
|
|
|
#define CLUTTER_BACKEND_GET_PRIVATE(obj) \
|
|
|
|
(G_TYPE_INSTANCE_GET_PRIVATE ((obj), CLUTTER_TYPE_BACKEND, ClutterBackendPrivate))
|
|
|
|
|
|
|
|
struct _ClutterBackendPrivate
|
|
|
|
{
|
2010-06-21 14:42:20 +00:00
|
|
|
cairo_font_options_t *font_options;
|
2007-05-09 23:31:08 +00:00
|
|
|
|
2010-06-21 14:42:20 +00:00
|
|
|
gchar *font_name;
|
Remove Units from the public API
With the recent change to internal floating point values, ClutterUnit
has become a redundant type, defined to be a float. All integer entry
points are being internally converted to floating point values to be
passed to the GL pipeline with the least amount of conversion.
ClutterUnit is thus exposed as just a "pixel with fractionary bits",
and not -- as users might think -- as generic, resolution and device
independent units. not that it was the case, but a definitive amount
of people was convinced it did provide this "feature", and was flummoxed
about the mere existence of this type.
So, having ClutterUnit exposed in the public API doubles the entry
points and has the following disadvantages:
- we have to maintain twice the amount of entry points in ClutterActor
- we still do an integer-to-float implicit conversion
- we introduce a weird impedance between pixels and "pixels with
fractionary bits"
- language bindings will have to choose what to bind, and resort
to manually overriding the API
+ *except* for language bindings based on GObject-Introspection, as
they cannot do manual overrides, thus will replicate the entire
set of entry points
For these reason, we should coalesces every Actor entry point for
pixels and for ClutterUnit into a single entry point taking a float,
like:
void clutter_actor_set_x (ClutterActor *self,
gfloat x);
void clutter_actor_get_size (ClutterActor *self,
gfloat *width,
gfloat *height);
gfloat clutter_actor_get_height (ClutterActor *self);
etc.
The issues I have identified are:
- we'll have a two cases of compiler warnings:
- printf() format of the return values from %d to %f
- clutter_actor_get_size() taking floats instead of unsigned ints
- we'll have a problem with varargs when passing an integer instead
of a floating point value, except on 64bit platforms where the
size of a float is the same as the size of an int
To be clear: the *intent* of the API should not change -- we still use
pixels everywhere -- but:
- we remove ambiguity in the API with regard to pixels and units
- we remove entry points we get to maintain for the whole 1.0
version of the API
- we make things simpler to bind for both manual language bindings
and automatic (gobject-introspection based) ones
- we have the simplest API possible while still exposing the
capabilities of the underlying GL implementation
2009-05-06 15:44:47 +00:00
|
|
|
|
|
|
|
gfloat units_per_em;
|
2009-10-16 14:25:37 +00:00
|
|
|
gint32 units_serial;
|
2007-05-09 23:31:08 +00:00
|
|
|
};
|
|
|
|
|
2008-12-23 13:55:51 +00:00
|
|
|
enum
|
|
|
|
{
|
|
|
|
RESOLUTION_CHANGED,
|
|
|
|
FONT_CHANGED,
|
2010-06-21 14:42:20 +00:00
|
|
|
SETTINGS_CHANGED,
|
2008-12-23 13:55:51 +00:00
|
|
|
|
|
|
|
LAST_SIGNAL
|
|
|
|
};
|
|
|
|
|
|
|
|
static guint backend_signals[LAST_SIGNAL] = { 0, };
|
|
|
|
|
2007-03-23 23:57:24 +00:00
|
|
|
static void
|
|
|
|
clutter_backend_dispose (GObject *gobject)
|
|
|
|
{
|
2007-05-09 23:31:08 +00:00
|
|
|
ClutterMainContext *clutter_context;
|
|
|
|
|
2009-06-17 16:59:54 +00:00
|
|
|
clutter_context = _clutter_context_get_default ();
|
2007-03-23 23:57:24 +00:00
|
|
|
|
2007-05-09 23:31:08 +00:00
|
|
|
if (clutter_context && clutter_context->events_queue)
|
2007-03-23 23:57:24 +00:00
|
|
|
{
|
2009-01-22 11:37:52 +00:00
|
|
|
g_queue_foreach (clutter_context->events_queue,
|
|
|
|
(GFunc) clutter_event_free,
|
|
|
|
NULL);
|
2007-05-09 23:31:08 +00:00
|
|
|
g_queue_free (clutter_context->events_queue);
|
|
|
|
clutter_context->events_queue = NULL;
|
2007-03-23 23:57:24 +00:00
|
|
|
}
|
|
|
|
|
2010-06-30 14:00:01 +00:00
|
|
|
G_OBJECT_CLASS (clutter_backend_parent_class)->dispose (gobject);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
clutter_backend_finalize (GObject *gobject)
|
|
|
|
{
|
|
|
|
ClutterBackend *backend = CLUTTER_BACKEND (gobject);
|
2008-12-23 15:03:11 +00:00
|
|
|
|
2010-06-30 14:00:01 +00:00
|
|
|
g_free (backend->priv->font_name);
|
2010-06-21 14:42:20 +00:00
|
|
|
clutter_backend_set_font_options (backend, NULL);
|
2008-05-28 Emmanuele Bassi <ebassi@openedhand.com>
Bug #919 - Replacement pango renderer (Neil Roberts)
* clutter/clutter-backend.h:
* clutter/clutter-backend.c:
(clutter_backend_set_font_options),
(clutter_backend_get_font_options): Add the ability to set
the cairo_font_options_t* for the backend at construction
time, so that backend implementations can have their own
options.
* clutter/clutter-color.c: Include pango/pango-attributes.h
for the pango_color_parse() function.
* clutter/clutter-label.c:
(clutter_label_ensure_layout),
(clutter_label_init), (clutter_label_set_text),
(clutter_label_set_font_name), (clutter_label_set_ellipsize),
(clutter_label_set_use_markup): Ensure that the cache is
always primed when the Label changes; this makes sure that
the cache is rebuilt outside the paint run, which should
make the painting perform better especially on embedded
devices.
* clutter/clutter-entry.c:
(clutter_entry_ensure_layout),
(clutter_entry_init), (clutter_entry_set_text),
(clutter_entry_set_font_name): Ditto as above.
* clutter/clutter-private.h:
* clutter/clutter-main.[ch]: Create the font-map inside the
main context; add two new functions:
clutter_clear_glyph_cache()
clutter_set_use_mipmapped_text()
that control the glyphs cache.
* clutter/pango/Makefile.am:
* clutter/pango/pangoclutter-fontmap.c:
* clutter/pango/pangoclutter-private.h:
* clutter/pango/pangoclutter-render.c:
* clutter/pango/pangoclutter.h: Rewrite the Pango renderer
using a PangoCairo context and saving the glyphs inside a
more efficient cache.
* configure.ac: Depend on pangocairo instead of pangoft2.
2008-05-28 14:03:28 +00:00
|
|
|
|
2010-06-30 14:00:01 +00:00
|
|
|
G_OBJECT_CLASS (clutter_backend_parent_class)->finalize (gobject);
|
2007-03-23 23:57:24 +00:00
|
|
|
}
|
|
|
|
|
2009-06-02 17:44:30 +00:00
|
|
|
static gfloat
|
2009-05-07 13:16:01 +00:00
|
|
|
get_units_per_em (ClutterBackend *backend,
|
|
|
|
PangoFontDescription *font_desc)
|
2009-01-22 11:37:52 +00:00
|
|
|
{
|
2009-06-02 17:44:30 +00:00
|
|
|
gfloat units_per_em = -1.0;
|
2009-05-07 13:16:01 +00:00
|
|
|
gboolean free_font_desc = FALSE;
|
2009-01-22 11:37:52 +00:00
|
|
|
gdouble dpi;
|
|
|
|
|
|
|
|
dpi = clutter_backend_get_resolution (backend);
|
|
|
|
|
2009-05-07 13:16:01 +00:00
|
|
|
if (font_desc == NULL)
|
2009-01-22 11:37:52 +00:00
|
|
|
{
|
2009-05-07 13:16:01 +00:00
|
|
|
const gchar *font_name = clutter_backend_get_font_name (backend);
|
2009-01-22 11:37:52 +00:00
|
|
|
|
2009-05-07 13:16:01 +00:00
|
|
|
if (G_LIKELY (font_name != NULL && *font_name != '\0'))
|
2009-01-22 11:37:52 +00:00
|
|
|
{
|
2009-05-07 13:16:01 +00:00
|
|
|
font_desc = pango_font_description_from_string (font_name);
|
|
|
|
free_font_desc = TRUE;
|
|
|
|
}
|
|
|
|
}
|
2009-01-22 11:37:52 +00:00
|
|
|
|
2009-05-07 13:16:01 +00:00
|
|
|
if (font_desc != NULL)
|
|
|
|
{
|
|
|
|
gdouble font_size = 0;
|
|
|
|
gint pango_size;
|
|
|
|
gboolean is_absolute;
|
2009-01-22 11:37:52 +00:00
|
|
|
|
2009-05-07 13:16:01 +00:00
|
|
|
pango_size = pango_font_description_get_size (font_desc);
|
|
|
|
is_absolute = pango_font_description_get_size_is_absolute (font_desc);
|
2009-01-22 11:37:52 +00:00
|
|
|
|
2009-05-07 13:16:01 +00:00
|
|
|
/* "absolute" means "device units" (usually, pixels); otherwise,
|
|
|
|
* it means logical units (points)
|
|
|
|
*/
|
|
|
|
if (is_absolute)
|
|
|
|
font_size = (gdouble) pango_size / PANGO_SCALE;
|
|
|
|
else
|
|
|
|
font_size = (gdouble) pango_size / PANGO_SCALE
|
|
|
|
* dpi
|
|
|
|
/ 96.0f;
|
|
|
|
|
|
|
|
/* 10 points at 96 DPI is 13.3 pixels */
|
|
|
|
units_per_em = (1.2f * font_size)
|
|
|
|
* dpi
|
|
|
|
/ 96.0f;
|
2009-01-22 11:37:52 +00:00
|
|
|
}
|
|
|
|
else
|
2009-05-07 13:16:01 +00:00
|
|
|
units_per_em = -1.0f;
|
|
|
|
|
|
|
|
if (free_font_desc)
|
|
|
|
pango_font_description_free (font_desc);
|
|
|
|
|
|
|
|
return units_per_em;
|
2009-01-22 11:37:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
clutter_backend_real_resolution_changed (ClutterBackend *backend)
|
|
|
|
{
|
2009-10-16 14:25:37 +00:00
|
|
|
ClutterBackendPrivate *priv = backend->priv;
|
2010-06-21 14:42:20 +00:00
|
|
|
ClutterMainContext *context;
|
|
|
|
ClutterSettings *settings;
|
|
|
|
gint dpi;
|
|
|
|
|
|
|
|
context = _clutter_context_get_default ();
|
|
|
|
|
|
|
|
settings = clutter_settings_get_default ();
|
|
|
|
g_object_get (settings, "font-dpi", &dpi, NULL);
|
|
|
|
|
|
|
|
if (context->font_map != NULL)
|
|
|
|
cogl_pango_font_map_set_resolution (context->font_map, dpi / 1024.0);
|
2009-10-16 14:25:37 +00:00
|
|
|
|
|
|
|
priv->units_per_em = get_units_per_em (backend, NULL);
|
|
|
|
priv->units_serial += 1;
|
2009-05-07 13:16:01 +00:00
|
|
|
|
2010-06-21 14:42:20 +00:00
|
|
|
CLUTTER_NOTE (BACKEND, "Units per em: %.2f", priv->units_per_em);
|
2009-01-22 11:37:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
clutter_backend_real_font_changed (ClutterBackend *backend)
|
|
|
|
{
|
2009-10-16 14:25:37 +00:00
|
|
|
ClutterBackendPrivate *priv = backend->priv;
|
|
|
|
|
|
|
|
priv->units_per_em = get_units_per_em (backend, NULL);
|
|
|
|
priv->units_serial += 1;
|
2009-05-07 13:16:01 +00:00
|
|
|
|
2010-06-21 14:42:20 +00:00
|
|
|
CLUTTER_NOTE (BACKEND, "Units per em: %.2f", priv->units_per_em);
|
2009-01-22 11:37:52 +00:00
|
|
|
}
|
|
|
|
|
2007-03-22 18:21:59 +00:00
|
|
|
static void
|
|
|
|
clutter_backend_class_init (ClutterBackendClass *klass)
|
|
|
|
{
|
2007-03-23 23:57:24 +00:00
|
|
|
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
|
2007-03-22 18:21:59 +00:00
|
|
|
|
2007-03-23 23:57:24 +00:00
|
|
|
gobject_class->dispose = clutter_backend_dispose;
|
2010-06-30 14:00:01 +00:00
|
|
|
gobject_class->finalize = clutter_backend_finalize;
|
2007-05-09 23:31:08 +00:00
|
|
|
|
|
|
|
g_type_class_add_private (gobject_class, sizeof (ClutterBackendPrivate));
|
2008-12-23 13:55:51 +00:00
|
|
|
|
|
|
|
backend_signals[RESOLUTION_CHANGED] =
|
|
|
|
g_signal_new (I_("resolution-changed"),
|
|
|
|
G_TYPE_FROM_CLASS (klass),
|
2009-01-22 11:37:52 +00:00
|
|
|
G_SIGNAL_RUN_FIRST,
|
2008-12-23 13:55:51 +00:00
|
|
|
G_STRUCT_OFFSET (ClutterBackendClass, resolution_changed),
|
|
|
|
NULL, NULL,
|
2010-06-11 14:49:46 +00:00
|
|
|
_clutter_marshal_VOID__VOID,
|
2008-12-23 13:55:51 +00:00
|
|
|
G_TYPE_NONE, 0);
|
|
|
|
|
|
|
|
backend_signals[FONT_CHANGED] =
|
|
|
|
g_signal_new (I_("font-changed"),
|
|
|
|
G_TYPE_FROM_CLASS (klass),
|
2009-01-22 11:37:52 +00:00
|
|
|
G_SIGNAL_RUN_FIRST,
|
2008-12-23 13:55:51 +00:00
|
|
|
G_STRUCT_OFFSET (ClutterBackendClass, font_changed),
|
|
|
|
NULL, NULL,
|
2010-06-11 14:49:46 +00:00
|
|
|
_clutter_marshal_VOID__VOID,
|
2008-12-23 13:55:51 +00:00
|
|
|
G_TYPE_NONE, 0);
|
2009-01-22 11:37:52 +00:00
|
|
|
|
2010-06-21 14:42:20 +00:00
|
|
|
backend_signals[SETTINGS_CHANGED] =
|
|
|
|
g_signal_new (I_("settings-changed"),
|
|
|
|
G_TYPE_FROM_CLASS (klass),
|
|
|
|
G_SIGNAL_RUN_FIRST,
|
|
|
|
G_STRUCT_OFFSET (ClutterBackendClass, settings_changed),
|
|
|
|
NULL, NULL,
|
|
|
|
_clutter_marshal_VOID__VOID,
|
|
|
|
G_TYPE_NONE, 0);
|
|
|
|
|
2009-01-22 11:37:52 +00:00
|
|
|
klass->resolution_changed = clutter_backend_real_resolution_changed;
|
|
|
|
klass->font_changed = clutter_backend_real_font_changed;
|
2007-03-22 18:21:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
clutter_backend_init (ClutterBackend *backend)
|
|
|
|
{
|
2007-05-09 23:31:08 +00:00
|
|
|
ClutterBackendPrivate *priv;
|
2007-03-22 18:21:59 +00:00
|
|
|
|
2009-01-22 11:37:52 +00:00
|
|
|
priv = backend->priv = CLUTTER_BACKEND_GET_PRIVATE (backend);
|
|
|
|
|
|
|
|
priv->units_per_em = -1.0;
|
2009-10-16 14:25:37 +00:00
|
|
|
priv->units_serial = 1;
|
2007-03-22 18:21:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2007-03-23 17:55:13 +00:00
|
|
|
_clutter_backend_add_options (ClutterBackend *backend,
|
|
|
|
GOptionGroup *group)
|
2007-03-22 18:21:59 +00:00
|
|
|
{
|
2007-07-09 21:56:06 +00:00
|
|
|
ClutterBackendClass *klass;
|
|
|
|
|
2007-03-22 18:21:59 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_BACKEND (backend));
|
|
|
|
|
2007-07-09 21:56:06 +00:00
|
|
|
klass = CLUTTER_BACKEND_GET_CLASS (backend);
|
|
|
|
if (klass->add_options)
|
2007-07-24 16:22:29 +00:00
|
|
|
klass->add_options (backend, group);
|
2007-03-22 18:21:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
gboolean
|
2007-03-23 17:55:13 +00:00
|
|
|
_clutter_backend_pre_parse (ClutterBackend *backend,
|
|
|
|
GError **error)
|
2007-03-22 18:21:59 +00:00
|
|
|
{
|
|
|
|
ClutterBackendClass *klass;
|
|
|
|
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_BACKEND (backend), FALSE);
|
|
|
|
|
|
|
|
klass = CLUTTER_BACKEND_GET_CLASS (backend);
|
|
|
|
if (klass->pre_parse)
|
|
|
|
return klass->pre_parse (backend, error);
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
gboolean
|
2007-03-23 17:55:13 +00:00
|
|
|
_clutter_backend_post_parse (ClutterBackend *backend,
|
|
|
|
GError **error)
|
2007-03-22 18:21:59 +00:00
|
|
|
{
|
|
|
|
ClutterBackendClass *klass;
|
|
|
|
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_BACKEND (backend), FALSE);
|
|
|
|
|
|
|
|
klass = CLUTTER_BACKEND_GET_CLASS (backend);
|
|
|
|
if (klass->post_parse)
|
|
|
|
return klass->post_parse (backend, error);
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2009-08-13 11:34:07 +00:00
|
|
|
ClutterStageWindow *
|
2008-03-28 22:50:55 +00:00
|
|
|
_clutter_backend_create_stage (ClutterBackend *backend,
|
2008-04-04 15:02:11 +00:00
|
|
|
ClutterStage *wrapper,
|
2008-03-28 22:50:55 +00:00
|
|
|
GError **error)
|
2007-03-22 18:21:59 +00:00
|
|
|
{
|
|
|
|
ClutterBackendClass *klass;
|
2009-06-19 13:19:39 +00:00
|
|
|
ClutterStageManager *stage_manager;
|
2009-08-13 11:34:07 +00:00
|
|
|
ClutterStageWindow *stage_window;
|
2007-03-22 18:21:59 +00:00
|
|
|
|
2010-05-27 07:28:29 +00:00
|
|
|
g_return_val_if_fail (CLUTTER_IS_BACKEND (backend), NULL);
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_STAGE (wrapper), NULL);
|
2007-03-22 18:21:59 +00:00
|
|
|
|
2009-06-19 13:19:39 +00:00
|
|
|
stage_manager = clutter_stage_manager_get_default ();
|
2008-03-28 22:50:55 +00:00
|
|
|
|
2007-03-22 18:21:59 +00:00
|
|
|
klass = CLUTTER_BACKEND_GET_CLASS (backend);
|
2010-02-09 16:57:14 +00:00
|
|
|
if (klass->create_stage != NULL)
|
2009-08-13 11:34:07 +00:00
|
|
|
stage_window = klass->create_stage (backend, wrapper, error);
|
2010-02-09 16:57:14 +00:00
|
|
|
else
|
|
|
|
stage_window = NULL;
|
2007-03-22 18:21:59 +00:00
|
|
|
|
2010-02-09 18:33:09 +00:00
|
|
|
if (stage_window == NULL)
|
2008-03-28 22:50:55 +00:00
|
|
|
return NULL;
|
|
|
|
|
2009-08-13 11:34:07 +00:00
|
|
|
g_assert (CLUTTER_IS_STAGE_WINDOW (stage_window));
|
|
|
|
_clutter_stage_set_window (wrapper, stage_window);
|
2009-06-19 13:19:39 +00:00
|
|
|
_clutter_stage_manager_add_stage (stage_manager, wrapper);
|
2008-04-04 15:02:11 +00:00
|
|
|
|
2009-08-13 11:34:07 +00:00
|
|
|
return stage_window;
|
2007-03-22 18:21:59 +00:00
|
|
|
}
|
|
|
|
|
2007-05-28 18:49:34 +00:00
|
|
|
void
|
2008-04-04 15:02:11 +00:00
|
|
|
_clutter_backend_redraw (ClutterBackend *backend,
|
|
|
|
ClutterStage *stage)
|
2007-05-28 18:49:34 +00:00
|
|
|
{
|
|
|
|
ClutterBackendClass *klass;
|
2009-03-30 15:41:02 +00:00
|
|
|
CLUTTER_STATIC_COUNTER (redraw_counter,
|
|
|
|
"_clutter_backend_redraw counter",
|
|
|
|
"Increments for each _clutter_backend_redraw call",
|
|
|
|
0 /* no application private data */);
|
|
|
|
CLUTTER_STATIC_TIMER (redraw_timer,
|
2010-02-10 11:57:58 +00:00
|
|
|
"Master Clock", /* parent */
|
2009-03-30 15:41:02 +00:00
|
|
|
"Redrawing",
|
|
|
|
"The time spent redrawing everything",
|
|
|
|
0 /* no application private data */);
|
|
|
|
|
|
|
|
CLUTTER_COUNTER_INC (_clutter_uprof_context, redraw_counter);
|
|
|
|
CLUTTER_TIMER_START (_clutter_uprof_context, redraw_timer);
|
2007-05-28 18:49:34 +00:00
|
|
|
|
|
|
|
klass = CLUTTER_BACKEND_GET_CLASS (backend);
|
2008-04-04 15:02:11 +00:00
|
|
|
if (G_LIKELY (klass->redraw))
|
2008-03-28 22:50:55 +00:00
|
|
|
klass->redraw (backend, stage);
|
2009-03-30 15:41:02 +00:00
|
|
|
|
|
|
|
CLUTTER_TIMER_STOP (_clutter_uprof_context, redraw_timer);
|
2007-05-28 18:49:34 +00:00
|
|
|
}
|
|
|
|
|
2009-05-13 21:21:48 +00:00
|
|
|
gboolean
|
|
|
|
_clutter_backend_create_context (ClutterBackend *backend,
|
|
|
|
GError **error)
|
|
|
|
{
|
|
|
|
ClutterBackendClass *klass;
|
|
|
|
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_BACKEND (backend), FALSE);
|
|
|
|
|
|
|
|
klass = CLUTTER_BACKEND_GET_CLASS (backend);
|
|
|
|
if (klass->create_context)
|
2009-07-31 17:34:51 +00:00
|
|
|
return klass->create_context (backend, error);
|
2009-05-13 21:21:48 +00:00
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2009-11-11 13:26:54 +00:00
|
|
|
void
|
|
|
|
_clutter_backend_ensure_context_internal (ClutterBackend *backend,
|
|
|
|
ClutterStage *stage)
|
|
|
|
{
|
|
|
|
ClutterBackendClass *klass = CLUTTER_BACKEND_GET_CLASS (backend);
|
|
|
|
if (G_LIKELY (klass->ensure_context))
|
|
|
|
klass->ensure_context (backend, stage);
|
|
|
|
}
|
|
|
|
|
2008-03-28 22:50:55 +00:00
|
|
|
void
|
2008-04-04 15:02:11 +00:00
|
|
|
_clutter_backend_ensure_context (ClutterBackend *backend,
|
|
|
|
ClutterStage *stage)
|
2008-03-28 22:50:55 +00:00
|
|
|
{
|
|
|
|
static ClutterStage *current_context_stage = NULL;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_BACKEND (backend));
|
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
|
|
|
|
2008-04-04 17:26:26 +00:00
|
|
|
if (current_context_stage != stage || !CLUTTER_ACTOR_IS_REALIZED (stage))
|
2008-03-28 22:50:55 +00:00
|
|
|
{
|
2009-05-11 11:36:55 +00:00
|
|
|
ClutterStage *new_stage = NULL;
|
|
|
|
|
2008-04-04 15:02:11 +00:00
|
|
|
if (!CLUTTER_ACTOR_IS_REALIZED (stage))
|
|
|
|
{
|
2009-05-11 11:36:55 +00:00
|
|
|
new_stage = NULL;
|
|
|
|
|
2009-05-08 16:17:48 +00:00
|
|
|
CLUTTER_NOTE (MULTISTAGE,
|
2009-05-11 11:36:55 +00:00
|
|
|
"Stage [%p] is not realized, unsetting the stage",
|
2009-05-08 16:17:48 +00:00
|
|
|
stage);
|
2008-04-04 15:02:11 +00:00
|
|
|
}
|
2008-04-04 17:26:26 +00:00
|
|
|
else
|
2009-05-11 11:36:55 +00:00
|
|
|
{
|
|
|
|
new_stage = stage;
|
|
|
|
|
|
|
|
CLUTTER_NOTE (MULTISTAGE,
|
|
|
|
"Setting the new stage [%p]",
|
|
|
|
new_stage);
|
|
|
|
}
|
|
|
|
|
2009-11-11 13:26:54 +00:00
|
|
|
_clutter_backend_ensure_context_internal (backend, new_stage);
|
2009-10-21 22:24:49 +00:00
|
|
|
|
|
|
|
/* XXX: Until Cogl becomes fully responsible for backend windows
|
|
|
|
* Clutter need to manually keep it informed of the current window size
|
|
|
|
*
|
|
|
|
* NB: This must be done after we ensure_context above because Cogl
|
|
|
|
* always assumes there is a current GL context.
|
|
|
|
*/
|
|
|
|
if (new_stage)
|
|
|
|
{
|
|
|
|
float width, height;
|
|
|
|
|
|
|
|
clutter_actor_get_size (CLUTTER_ACTOR (stage), &width, &height);
|
|
|
|
|
|
|
|
_cogl_onscreen_clutter_backend_set_size (width, height);
|
|
|
|
}
|
|
|
|
|
2008-04-01 14:04:46 +00:00
|
|
|
/* FIXME: With a NULL stage and thus no active context it may make more
|
|
|
|
* sense to clean the context but then re call with the default stage
|
|
|
|
* so at least there is some kind of context in place (as to avoid
|
|
|
|
* potential issue of GL calls with no context)
|
2008-04-04 17:26:26 +00:00
|
|
|
*/
|
2009-05-11 11:36:55 +00:00
|
|
|
current_context_stage = new_stage;
|
2009-02-20 15:39:32 +00:00
|
|
|
|
|
|
|
/* if the new stage has a different size than the previous one
|
|
|
|
* we need to update the viewport; we do it by simply setting the
|
|
|
|
* SYNC_MATRICES flag and letting the next redraw cycle take care
|
|
|
|
* of calling glViewport()
|
|
|
|
*/
|
|
|
|
if (current_context_stage)
|
|
|
|
{
|
|
|
|
CLUTTER_SET_PRIVATE_FLAGS (current_context_stage,
|
2010-07-21 15:10:46 +00:00
|
|
|
CLUTTER_SYNC_MATRICES);
|
2009-02-20 15:39:32 +00:00
|
|
|
}
|
2008-03-28 22:50:55 +00:00
|
|
|
}
|
2008-04-04 17:26:26 +00:00
|
|
|
else
|
|
|
|
CLUTTER_NOTE (MULTISTAGE, "Stage is the same");
|
2008-03-28 22:50:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-05-16 09:08:30 +00:00
|
|
|
ClutterFeatureFlags
|
|
|
|
_clutter_backend_get_features (ClutterBackend *backend)
|
2007-03-22 18:21:59 +00:00
|
|
|
{
|
|
|
|
ClutterBackendClass *klass;
|
2010-03-17 17:28:20 +00:00
|
|
|
GError *error;
|
2007-03-22 18:21:59 +00:00
|
|
|
|
2007-05-25 10:56:09 +00:00
|
|
|
g_return_val_if_fail (CLUTTER_IS_BACKEND (backend), 0);
|
2007-03-22 18:21:59 +00:00
|
|
|
|
|
|
|
klass = CLUTTER_BACKEND_GET_CLASS (backend);
|
2009-12-03 17:13:44 +00:00
|
|
|
|
|
|
|
/* we need to have a context here; so we create the
|
|
|
|
* GL context first and the ask for features. if the
|
|
|
|
* context already exists this should be a no-op
|
|
|
|
*/
|
2010-03-17 17:28:20 +00:00
|
|
|
error = NULL;
|
2009-12-03 17:13:44 +00:00
|
|
|
if (klass->create_context)
|
2010-03-17 17:28:20 +00:00
|
|
|
{
|
|
|
|
gboolean res;
|
|
|
|
|
|
|
|
res = klass->create_context (backend, &error);
|
|
|
|
if (!res)
|
|
|
|
{
|
|
|
|
if (error)
|
|
|
|
{
|
|
|
|
g_critical ("Unable to create a context: %s", error->message);
|
|
|
|
g_error_free (error);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
g_critical ("Unable to create a context: unknown error");
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
2009-12-03 17:13:44 +00:00
|
|
|
|
2007-05-16 09:08:30 +00:00
|
|
|
if (klass->get_features)
|
|
|
|
return klass->get_features (backend);
|
|
|
|
|
|
|
|
return 0;
|
2007-03-22 18:21:59 +00:00
|
|
|
}
|
|
|
|
|
2007-03-23 17:55:13 +00:00
|
|
|
void
|
2007-05-09 23:31:08 +00:00
|
|
|
_clutter_backend_init_events (ClutterBackend *backend)
|
2007-03-23 17:55:13 +00:00
|
|
|
{
|
|
|
|
ClutterBackendClass *klass;
|
2007-05-09 23:31:08 +00:00
|
|
|
ClutterMainContext *clutter_context;
|
|
|
|
|
2009-06-17 16:59:54 +00:00
|
|
|
clutter_context = _clutter_context_get_default ();
|
2007-03-23 17:55:13 +00:00
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_BACKEND (backend));
|
2007-05-09 23:31:08 +00:00
|
|
|
g_return_if_fail (clutter_context != NULL);
|
|
|
|
|
|
|
|
clutter_context->events_queue = g_queue_new ();
|
2007-03-23 17:55:13 +00:00
|
|
|
|
|
|
|
klass = CLUTTER_BACKEND_GET_CLASS (backend);
|
2007-05-09 23:31:08 +00:00
|
|
|
if (klass->init_events)
|
|
|
|
klass->init_events (backend);
|
2007-03-23 17:55:13 +00:00
|
|
|
}
|
|
|
|
|
Remove Units from the public API
With the recent change to internal floating point values, ClutterUnit
has become a redundant type, defined to be a float. All integer entry
points are being internally converted to floating point values to be
passed to the GL pipeline with the least amount of conversion.
ClutterUnit is thus exposed as just a "pixel with fractionary bits",
and not -- as users might think -- as generic, resolution and device
independent units. not that it was the case, but a definitive amount
of people was convinced it did provide this "feature", and was flummoxed
about the mere existence of this type.
So, having ClutterUnit exposed in the public API doubles the entry
points and has the following disadvantages:
- we have to maintain twice the amount of entry points in ClutterActor
- we still do an integer-to-float implicit conversion
- we introduce a weird impedance between pixels and "pixels with
fractionary bits"
- language bindings will have to choose what to bind, and resort
to manually overriding the API
+ *except* for language bindings based on GObject-Introspection, as
they cannot do manual overrides, thus will replicate the entire
set of entry points
For these reason, we should coalesces every Actor entry point for
pixels and for ClutterUnit into a single entry point taking a float,
like:
void clutter_actor_set_x (ClutterActor *self,
gfloat x);
void clutter_actor_get_size (ClutterActor *self,
gfloat *width,
gfloat *height);
gfloat clutter_actor_get_height (ClutterActor *self);
etc.
The issues I have identified are:
- we'll have a two cases of compiler warnings:
- printf() format of the return values from %d to %f
- clutter_actor_get_size() taking floats instead of unsigned ints
- we'll have a problem with varargs when passing an integer instead
of a floating point value, except on 64bit platforms where the
size of a float is the same as the size of an int
To be clear: the *intent* of the API should not change -- we still use
pixels everywhere -- but:
- we remove ambiguity in the API with regard to pixels and units
- we remove entry points we get to maintain for the whole 1.0
version of the API
- we make things simpler to bind for both manual language bindings
and automatic (gobject-introspection based) ones
- we have the simplest API possible while still exposing the
capabilities of the underlying GL implementation
2009-05-06 15:44:47 +00:00
|
|
|
gfloat
|
2009-05-07 13:16:01 +00:00
|
|
|
_clutter_backend_get_units_per_em (ClutterBackend *backend,
|
|
|
|
PangoFontDescription *font_desc)
|
2009-01-22 11:37:52 +00:00
|
|
|
{
|
|
|
|
ClutterBackendPrivate *priv;
|
|
|
|
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_BACKEND (backend), 0);
|
|
|
|
|
|
|
|
priv = backend->priv;
|
|
|
|
|
2009-05-07 13:16:01 +00:00
|
|
|
/* recompute for the font description, but do not cache the result */
|
|
|
|
if (font_desc != NULL)
|
|
|
|
return get_units_per_em (backend, font_desc);
|
|
|
|
|
|
|
|
if (priv->units_per_em < 0)
|
|
|
|
priv->units_per_em = get_units_per_em (backend, NULL);
|
2009-01-22 11:37:52 +00:00
|
|
|
|
|
|
|
return priv->units_per_em;
|
|
|
|
}
|
2007-05-09 23:31:08 +00:00
|
|
|
|
2010-06-14 17:01:17 +00:00
|
|
|
void
|
2010-09-08 14:15:57 +00:00
|
|
|
_clutter_backend_copy_event_data (ClutterBackend *backend,
|
|
|
|
const ClutterEvent *src,
|
|
|
|
ClutterEvent *dest)
|
2010-06-14 17:01:17 +00:00
|
|
|
{
|
|
|
|
ClutterBackendClass *klass;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_BACKEND (backend));
|
|
|
|
g_return_if_fail (src != NULL);
|
|
|
|
g_return_if_fail (dest != NULL);
|
|
|
|
|
|
|
|
klass = CLUTTER_BACKEND_GET_CLASS (backend);
|
|
|
|
if (klass->copy_event_data != NULL)
|
|
|
|
klass->copy_event_data (backend, src, dest);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
_clutter_backend_free_event_data (ClutterBackend *backend,
|
|
|
|
ClutterEvent *event)
|
|
|
|
{
|
|
|
|
ClutterBackendClass *klass;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_BACKEND (backend));
|
|
|
|
g_return_if_fail (event != NULL);
|
|
|
|
|
|
|
|
klass = CLUTTER_BACKEND_GET_CLASS (backend);
|
|
|
|
if (klass->free_event_data != NULL)
|
|
|
|
klass->free_event_data (backend, event);
|
|
|
|
}
|
|
|
|
|
2007-03-23 17:55:13 +00:00
|
|
|
/**
|
2009-03-16 15:00:55 +00:00
|
|
|
* clutter_get_default_backend:
|
2007-03-23 17:55:13 +00:00
|
|
|
*
|
2009-01-22 11:37:52 +00:00
|
|
|
* Retrieves the default #ClutterBackend used by Clutter. The
|
|
|
|
* #ClutterBackend holds backend-specific configuration options.
|
2007-03-23 17:55:13 +00:00
|
|
|
*
|
2009-02-17 00:25:20 +00:00
|
|
|
* Return value: (transfer none): the default backend. You should
|
|
|
|
* not ref or unref the returned object. Applications should rarely
|
|
|
|
* need to use this.
|
2007-05-09 23:31:08 +00:00
|
|
|
*
|
2007-03-23 17:55:13 +00:00
|
|
|
* Since: 0.4
|
|
|
|
*/
|
|
|
|
ClutterBackend *
|
|
|
|
clutter_get_default_backend (void)
|
|
|
|
{
|
|
|
|
ClutterMainContext *clutter_context;
|
|
|
|
|
2009-06-17 16:59:54 +00:00
|
|
|
clutter_context = _clutter_context_get_default ();
|
2007-03-23 17:55:13 +00:00
|
|
|
|
|
|
|
return clutter_context->backend;
|
|
|
|
}
|
|
|
|
|
2007-05-09 23:31:08 +00:00
|
|
|
/* FIXME: below should probably be moved into clutter_main */
|
2007-04-19 15:25:34 +00:00
|
|
|
|
2007-04-19 15:25:53 +00:00
|
|
|
/**
|
|
|
|
* clutter_backend_set_double_click_time:
|
|
|
|
* @backend: a #ClutterBackend
|
|
|
|
* @msec: milliseconds between two button press events
|
|
|
|
*
|
|
|
|
* Sets the maximum time between two button press events, used to
|
|
|
|
* verify whether it's a double click event or not.
|
|
|
|
*
|
|
|
|
* Since: 0.4
|
2010-06-21 14:42:20 +00:00
|
|
|
*
|
|
|
|
* Deprecated: 1.4: Use #ClutterSettings:double-click-time instead
|
2007-04-19 15:25:53 +00:00
|
|
|
*/
|
2007-04-19 15:25:34 +00:00
|
|
|
void
|
|
|
|
clutter_backend_set_double_click_time (ClutterBackend *backend,
|
|
|
|
guint msec)
|
|
|
|
{
|
2010-06-21 14:42:20 +00:00
|
|
|
ClutterSettings *settings = clutter_settings_get_default ();
|
2007-04-19 15:25:34 +00:00
|
|
|
|
2010-06-21 14:42:20 +00:00
|
|
|
g_object_set (settings, "double-click-time", msec, NULL);
|
2007-04-19 15:25:34 +00:00
|
|
|
}
|
|
|
|
|
2007-04-19 15:25:53 +00:00
|
|
|
/**
|
|
|
|
* clutter_backend_get_double_click_time:
|
|
|
|
* @backend: a #ClutterBackend
|
|
|
|
*
|
|
|
|
* Gets the maximum time between two button press events, as set
|
|
|
|
* by clutter_backend_set_double_click_time().
|
|
|
|
*
|
|
|
|
* Return value: a time in milliseconds
|
|
|
|
*
|
|
|
|
* Since: 0.4
|
2010-06-21 14:42:20 +00:00
|
|
|
*
|
|
|
|
* Deprecated: 1.4: Use #ClutterSettings:double-click-time instead
|
2007-04-19 15:25:53 +00:00
|
|
|
*/
|
2007-04-19 15:25:34 +00:00
|
|
|
guint
|
|
|
|
clutter_backend_get_double_click_time (ClutterBackend *backend)
|
|
|
|
{
|
2010-06-21 14:42:20 +00:00
|
|
|
ClutterSettings *settings = clutter_settings_get_default ();
|
|
|
|
gint retval;
|
|
|
|
|
|
|
|
g_object_get (settings, "double-click-time", &retval, NULL);
|
2007-04-19 15:25:34 +00:00
|
|
|
|
2010-06-21 14:42:20 +00:00
|
|
|
return retval;
|
2007-04-19 15:25:34 +00:00
|
|
|
}
|
|
|
|
|
2007-04-19 15:25:53 +00:00
|
|
|
/**
|
|
|
|
* clutter_backend_set_double_click_distance:
|
|
|
|
* @backend: a #ClutterBackend
|
|
|
|
* @distance: a distance, in pixels
|
|
|
|
*
|
|
|
|
* Sets the maximum distance used to verify a double click event.
|
|
|
|
*
|
|
|
|
* Since: 0.4
|
2010-06-21 14:42:20 +00:00
|
|
|
*
|
|
|
|
* Deprecated: 1.4: Use #ClutterSettings:double-click-distance instead
|
2007-04-19 15:25:53 +00:00
|
|
|
*/
|
2007-04-19 15:25:34 +00:00
|
|
|
void
|
|
|
|
clutter_backend_set_double_click_distance (ClutterBackend *backend,
|
|
|
|
guint distance)
|
|
|
|
{
|
2010-06-21 14:42:20 +00:00
|
|
|
ClutterSettings *settings = clutter_settings_get_default ();
|
|
|
|
|
|
|
|
g_object_set (settings, "double-click-distance", distance, NULL);
|
2007-04-19 15:25:34 +00:00
|
|
|
}
|
|
|
|
|
2007-04-19 15:25:53 +00:00
|
|
|
/**
|
|
|
|
* clutter_backend_get_double_click_distance:
|
|
|
|
* @backend: a #ClutterBackend
|
|
|
|
*
|
|
|
|
* Retrieves the distance used to verify a double click event
|
|
|
|
*
|
|
|
|
* Return value: a distance, in pixels.
|
|
|
|
*
|
|
|
|
* Since: 0.4
|
2010-06-21 14:42:20 +00:00
|
|
|
*
|
|
|
|
* Deprecated: 1.4: Use #ClutterSettings:double-click-distance instead
|
2007-04-19 15:25:53 +00:00
|
|
|
*/
|
2007-04-19 15:25:34 +00:00
|
|
|
guint
|
|
|
|
clutter_backend_get_double_click_distance (ClutterBackend *backend)
|
|
|
|
{
|
2010-06-21 14:42:20 +00:00
|
|
|
ClutterSettings *settings = clutter_settings_get_default ();
|
|
|
|
gint retval;
|
2007-04-19 15:25:34 +00:00
|
|
|
|
2010-06-21 14:42:20 +00:00
|
|
|
g_object_get (settings, "double-click-distance", &retval, NULL);
|
|
|
|
|
|
|
|
return retval;
|
2007-04-19 15:25:34 +00:00
|
|
|
}
|
2007-07-31 10:38:23 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_backend_set_resolution:
|
|
|
|
* @backend: a #ClutterBackend
|
|
|
|
* @dpi: the resolution in "dots per inch" (Physical inches aren't
|
|
|
|
* actually involved; the terminology is conventional).
|
|
|
|
*
|
|
|
|
* Sets the resolution for font handling on the screen. This is a
|
|
|
|
* scale factor between points specified in a #PangoFontDescription
|
|
|
|
* and cairo units. The default value is 96, meaning that a 10 point
|
|
|
|
* font will be 13 units high. (10 * 96. / 72. = 13.3).
|
|
|
|
*
|
|
|
|
* Applications should never need to call this function.
|
|
|
|
*
|
|
|
|
* Since: 0.4
|
2010-06-21 14:42:20 +00:00
|
|
|
*
|
|
|
|
* Deprecated: Use #ClutterSettings:font-dpi instead
|
2007-07-31 10:38:23 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_backend_set_resolution (ClutterBackend *backend,
|
|
|
|
gdouble dpi)
|
|
|
|
{
|
2010-06-21 14:42:20 +00:00
|
|
|
ClutterSettings *settings;
|
|
|
|
gint resolution;
|
2007-07-31 10:38:23 +00:00
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_BACKEND (backend));
|
|
|
|
|
|
|
|
if (dpi < 0)
|
2010-06-21 14:42:20 +00:00
|
|
|
resolution = -1;
|
|
|
|
else
|
|
|
|
resolution = dpi * 1024;
|
2008-12-23 13:55:51 +00:00
|
|
|
|
2010-06-21 14:42:20 +00:00
|
|
|
settings = clutter_settings_get_default ();
|
|
|
|
g_object_set (settings, "font-dpi", resolution, NULL);
|
2007-07-31 10:38:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_backend_get_resolution:
|
|
|
|
* @backend: a #ClutterBackend
|
|
|
|
*
|
2010-06-21 17:01:57 +00:00
|
|
|
* Gets the resolution for font handling on the screen.
|
|
|
|
*
|
|
|
|
* The resolution is a scale factor between points specified in a
|
|
|
|
* #PangoFontDescription and cairo units. The default value is 96.0,
|
|
|
|
* meaning that a 10 point font will be 13 units
|
|
|
|
* high (10 * 96. / 72. = 13.3).
|
|
|
|
*
|
|
|
|
* Clutter will set the resolution using the current backend when
|
|
|
|
* initializing; the resolution is also stored in the
|
|
|
|
* #ClutterSettings:font-dpi property.
|
|
|
|
*
|
2007-07-31 10:38:23 +00:00
|
|
|
* Return value: the current resolution, or -1 if no resolution
|
|
|
|
* has been set.
|
|
|
|
*
|
|
|
|
* Since: 0.4
|
|
|
|
*/
|
|
|
|
gdouble
|
|
|
|
clutter_backend_get_resolution (ClutterBackend *backend)
|
|
|
|
{
|
2010-06-21 14:42:20 +00:00
|
|
|
ClutterSettings *settings;
|
|
|
|
gint resolution;
|
|
|
|
|
2007-07-31 10:38:23 +00:00
|
|
|
g_return_val_if_fail (CLUTTER_IS_BACKEND (backend), -1.0);
|
|
|
|
|
2010-06-21 14:42:20 +00:00
|
|
|
settings = clutter_settings_get_default ();
|
|
|
|
g_object_get (settings, "font-dpi", &resolution, NULL);
|
|
|
|
|
|
|
|
return resolution / 1024.0;
|
2007-07-31 10:38:23 +00:00
|
|
|
}
|
2008-05-28 Emmanuele Bassi <ebassi@openedhand.com>
Bug #919 - Replacement pango renderer (Neil Roberts)
* clutter/clutter-backend.h:
* clutter/clutter-backend.c:
(clutter_backend_set_font_options),
(clutter_backend_get_font_options): Add the ability to set
the cairo_font_options_t* for the backend at construction
time, so that backend implementations can have their own
options.
* clutter/clutter-color.c: Include pango/pango-attributes.h
for the pango_color_parse() function.
* clutter/clutter-label.c:
(clutter_label_ensure_layout),
(clutter_label_init), (clutter_label_set_text),
(clutter_label_set_font_name), (clutter_label_set_ellipsize),
(clutter_label_set_use_markup): Ensure that the cache is
always primed when the Label changes; this makes sure that
the cache is rebuilt outside the paint run, which should
make the painting perform better especially on embedded
devices.
* clutter/clutter-entry.c:
(clutter_entry_ensure_layout),
(clutter_entry_init), (clutter_entry_set_text),
(clutter_entry_set_font_name): Ditto as above.
* clutter/clutter-private.h:
* clutter/clutter-main.[ch]: Create the font-map inside the
main context; add two new functions:
clutter_clear_glyph_cache()
clutter_set_use_mipmapped_text()
that control the glyphs cache.
* clutter/pango/Makefile.am:
* clutter/pango/pangoclutter-fontmap.c:
* clutter/pango/pangoclutter-private.h:
* clutter/pango/pangoclutter-render.c:
* clutter/pango/pangoclutter.h: Rewrite the Pango renderer
using a PangoCairo context and saving the glyphs inside a
more efficient cache.
* configure.ac: Depend on pangocairo instead of pangoft2.
2008-05-28 14:03:28 +00:00
|
|
|
|
2008-06-12 11:43:25 +00:00
|
|
|
/**
|
|
|
|
* clutter_backend_set_font_options:
|
|
|
|
* @backend: a #ClutterBackend
|
|
|
|
* @options: Cairo font options for the backend, or %NULL
|
|
|
|
*
|
2009-02-26 15:32:48 +00:00
|
|
|
* Sets the new font options for @backend. The #ClutterBackend will
|
|
|
|
* copy the #cairo_font_options_t.
|
|
|
|
*
|
|
|
|
* If @options is %NULL, the first following call to
|
|
|
|
* clutter_backend_get_font_options() will return the default font
|
|
|
|
* options for @backend.
|
2008-06-12 11:43:25 +00:00
|
|
|
*
|
|
|
|
* This function is intended for actors creating a Pango layout
|
|
|
|
* using the PangoCairo API.
|
|
|
|
*
|
|
|
|
* Since: 0.8
|
|
|
|
*/
|
2008-05-28 Emmanuele Bassi <ebassi@openedhand.com>
Bug #919 - Replacement pango renderer (Neil Roberts)
* clutter/clutter-backend.h:
* clutter/clutter-backend.c:
(clutter_backend_set_font_options),
(clutter_backend_get_font_options): Add the ability to set
the cairo_font_options_t* for the backend at construction
time, so that backend implementations can have their own
options.
* clutter/clutter-color.c: Include pango/pango-attributes.h
for the pango_color_parse() function.
* clutter/clutter-label.c:
(clutter_label_ensure_layout),
(clutter_label_init), (clutter_label_set_text),
(clutter_label_set_font_name), (clutter_label_set_ellipsize),
(clutter_label_set_use_markup): Ensure that the cache is
always primed when the Label changes; this makes sure that
the cache is rebuilt outside the paint run, which should
make the painting perform better especially on embedded
devices.
* clutter/clutter-entry.c:
(clutter_entry_ensure_layout),
(clutter_entry_init), (clutter_entry_set_text),
(clutter_entry_set_font_name): Ditto as above.
* clutter/clutter-private.h:
* clutter/clutter-main.[ch]: Create the font-map inside the
main context; add two new functions:
clutter_clear_glyph_cache()
clutter_set_use_mipmapped_text()
that control the glyphs cache.
* clutter/pango/Makefile.am:
* clutter/pango/pangoclutter-fontmap.c:
* clutter/pango/pangoclutter-private.h:
* clutter/pango/pangoclutter-render.c:
* clutter/pango/pangoclutter.h: Rewrite the Pango renderer
using a PangoCairo context and saving the glyphs inside a
more efficient cache.
* configure.ac: Depend on pangocairo instead of pangoft2.
2008-05-28 14:03:28 +00:00
|
|
|
void
|
2010-06-21 14:42:20 +00:00
|
|
|
clutter_backend_set_font_options (ClutterBackend *backend,
|
2009-02-26 15:32:48 +00:00
|
|
|
const cairo_font_options_t *options)
|
2008-05-28 Emmanuele Bassi <ebassi@openedhand.com>
Bug #919 - Replacement pango renderer (Neil Roberts)
* clutter/clutter-backend.h:
* clutter/clutter-backend.c:
(clutter_backend_set_font_options),
(clutter_backend_get_font_options): Add the ability to set
the cairo_font_options_t* for the backend at construction
time, so that backend implementations can have their own
options.
* clutter/clutter-color.c: Include pango/pango-attributes.h
for the pango_color_parse() function.
* clutter/clutter-label.c:
(clutter_label_ensure_layout),
(clutter_label_init), (clutter_label_set_text),
(clutter_label_set_font_name), (clutter_label_set_ellipsize),
(clutter_label_set_use_markup): Ensure that the cache is
always primed when the Label changes; this makes sure that
the cache is rebuilt outside the paint run, which should
make the painting perform better especially on embedded
devices.
* clutter/clutter-entry.c:
(clutter_entry_ensure_layout),
(clutter_entry_init), (clutter_entry_set_text),
(clutter_entry_set_font_name): Ditto as above.
* clutter/clutter-private.h:
* clutter/clutter-main.[ch]: Create the font-map inside the
main context; add two new functions:
clutter_clear_glyph_cache()
clutter_set_use_mipmapped_text()
that control the glyphs cache.
* clutter/pango/Makefile.am:
* clutter/pango/pangoclutter-fontmap.c:
* clutter/pango/pangoclutter-private.h:
* clutter/pango/pangoclutter-render.c:
* clutter/pango/pangoclutter.h: Rewrite the Pango renderer
using a PangoCairo context and saving the glyphs inside a
more efficient cache.
* configure.ac: Depend on pangocairo instead of pangoft2.
2008-05-28 14:03:28 +00:00
|
|
|
{
|
|
|
|
ClutterBackendPrivate *priv;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_BACKEND (backend));
|
|
|
|
|
|
|
|
priv = backend->priv;
|
|
|
|
|
|
|
|
if (priv->font_options != options)
|
|
|
|
{
|
|
|
|
if (priv->font_options)
|
|
|
|
cairo_font_options_destroy (priv->font_options);
|
|
|
|
|
|
|
|
if (options)
|
|
|
|
priv->font_options = cairo_font_options_copy (options);
|
|
|
|
else
|
|
|
|
priv->font_options = NULL;
|
2008-12-23 13:55:51 +00:00
|
|
|
|
|
|
|
g_signal_emit (backend, backend_signals[FONT_CHANGED], 0);
|
2008-05-28 Emmanuele Bassi <ebassi@openedhand.com>
Bug #919 - Replacement pango renderer (Neil Roberts)
* clutter/clutter-backend.h:
* clutter/clutter-backend.c:
(clutter_backend_set_font_options),
(clutter_backend_get_font_options): Add the ability to set
the cairo_font_options_t* for the backend at construction
time, so that backend implementations can have their own
options.
* clutter/clutter-color.c: Include pango/pango-attributes.h
for the pango_color_parse() function.
* clutter/clutter-label.c:
(clutter_label_ensure_layout),
(clutter_label_init), (clutter_label_set_text),
(clutter_label_set_font_name), (clutter_label_set_ellipsize),
(clutter_label_set_use_markup): Ensure that the cache is
always primed when the Label changes; this makes sure that
the cache is rebuilt outside the paint run, which should
make the painting perform better especially on embedded
devices.
* clutter/clutter-entry.c:
(clutter_entry_ensure_layout),
(clutter_entry_init), (clutter_entry_set_text),
(clutter_entry_set_font_name): Ditto as above.
* clutter/clutter-private.h:
* clutter/clutter-main.[ch]: Create the font-map inside the
main context; add two new functions:
clutter_clear_glyph_cache()
clutter_set_use_mipmapped_text()
that control the glyphs cache.
* clutter/pango/Makefile.am:
* clutter/pango/pangoclutter-fontmap.c:
* clutter/pango/pangoclutter-private.h:
* clutter/pango/pangoclutter-render.c:
* clutter/pango/pangoclutter.h: Rewrite the Pango renderer
using a PangoCairo context and saving the glyphs inside a
more efficient cache.
* configure.ac: Depend on pangocairo instead of pangoft2.
2008-05-28 14:03:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-06-12 11:43:25 +00:00
|
|
|
/**
|
|
|
|
* clutter_backend_get_font_options:
|
|
|
|
* @backend: a #ClutterBackend
|
|
|
|
*
|
|
|
|
* Retrieves the font options for @backend.
|
|
|
|
*
|
2009-02-26 15:32:48 +00:00
|
|
|
* Return value: (transfer none): the font options of the #ClutterBackend.
|
|
|
|
* The returned #cairo_font_options_t is owned by the backend and should
|
|
|
|
* not be modified or freed
|
2008-06-12 11:43:25 +00:00
|
|
|
*
|
|
|
|
* Since: 0.8
|
|
|
|
*/
|
2009-02-26 15:32:48 +00:00
|
|
|
const cairo_font_options_t *
|
2008-05-28 Emmanuele Bassi <ebassi@openedhand.com>
Bug #919 - Replacement pango renderer (Neil Roberts)
* clutter/clutter-backend.h:
* clutter/clutter-backend.c:
(clutter_backend_set_font_options),
(clutter_backend_get_font_options): Add the ability to set
the cairo_font_options_t* for the backend at construction
time, so that backend implementations can have their own
options.
* clutter/clutter-color.c: Include pango/pango-attributes.h
for the pango_color_parse() function.
* clutter/clutter-label.c:
(clutter_label_ensure_layout),
(clutter_label_init), (clutter_label_set_text),
(clutter_label_set_font_name), (clutter_label_set_ellipsize),
(clutter_label_set_use_markup): Ensure that the cache is
always primed when the Label changes; this makes sure that
the cache is rebuilt outside the paint run, which should
make the painting perform better especially on embedded
devices.
* clutter/clutter-entry.c:
(clutter_entry_ensure_layout),
(clutter_entry_init), (clutter_entry_set_text),
(clutter_entry_set_font_name): Ditto as above.
* clutter/clutter-private.h:
* clutter/clutter-main.[ch]: Create the font-map inside the
main context; add two new functions:
clutter_clear_glyph_cache()
clutter_set_use_mipmapped_text()
that control the glyphs cache.
* clutter/pango/Makefile.am:
* clutter/pango/pangoclutter-fontmap.c:
* clutter/pango/pangoclutter-private.h:
* clutter/pango/pangoclutter-render.c:
* clutter/pango/pangoclutter.h: Rewrite the Pango renderer
using a PangoCairo context and saving the glyphs inside a
more efficient cache.
* configure.ac: Depend on pangocairo instead of pangoft2.
2008-05-28 14:03:28 +00:00
|
|
|
clutter_backend_get_font_options (ClutterBackend *backend)
|
|
|
|
{
|
|
|
|
ClutterBackendPrivate *priv;
|
|
|
|
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_BACKEND (backend), NULL);
|
|
|
|
|
|
|
|
priv = backend->priv;
|
|
|
|
|
|
|
|
if (G_LIKELY (priv->font_options))
|
|
|
|
return priv->font_options;
|
|
|
|
|
|
|
|
priv->font_options = cairo_font_options_create ();
|
|
|
|
|
|
|
|
cairo_font_options_set_hint_style (priv->font_options,
|
|
|
|
CAIRO_HINT_STYLE_NONE);
|
|
|
|
cairo_font_options_set_subpixel_order (priv->font_options,
|
|
|
|
CAIRO_SUBPIXEL_ORDER_DEFAULT);
|
|
|
|
cairo_font_options_set_antialias (priv->font_options,
|
|
|
|
CAIRO_ANTIALIAS_DEFAULT);
|
|
|
|
|
2009-05-07 13:16:01 +00:00
|
|
|
g_signal_emit (backend, backend_signals[FONT_CHANGED], 0);
|
|
|
|
|
2008-05-28 Emmanuele Bassi <ebassi@openedhand.com>
Bug #919 - Replacement pango renderer (Neil Roberts)
* clutter/clutter-backend.h:
* clutter/clutter-backend.c:
(clutter_backend_set_font_options),
(clutter_backend_get_font_options): Add the ability to set
the cairo_font_options_t* for the backend at construction
time, so that backend implementations can have their own
options.
* clutter/clutter-color.c: Include pango/pango-attributes.h
for the pango_color_parse() function.
* clutter/clutter-label.c:
(clutter_label_ensure_layout),
(clutter_label_init), (clutter_label_set_text),
(clutter_label_set_font_name), (clutter_label_set_ellipsize),
(clutter_label_set_use_markup): Ensure that the cache is
always primed when the Label changes; this makes sure that
the cache is rebuilt outside the paint run, which should
make the painting perform better especially on embedded
devices.
* clutter/clutter-entry.c:
(clutter_entry_ensure_layout),
(clutter_entry_init), (clutter_entry_set_text),
(clutter_entry_set_font_name): Ditto as above.
* clutter/clutter-private.h:
* clutter/clutter-main.[ch]: Create the font-map inside the
main context; add two new functions:
clutter_clear_glyph_cache()
clutter_set_use_mipmapped_text()
that control the glyphs cache.
* clutter/pango/Makefile.am:
* clutter/pango/pangoclutter-fontmap.c:
* clutter/pango/pangoclutter-private.h:
* clutter/pango/pangoclutter-render.c:
* clutter/pango/pangoclutter.h: Rewrite the Pango renderer
using a PangoCairo context and saving the glyphs inside a
more efficient cache.
* configure.ac: Depend on pangocairo instead of pangoft2.
2008-05-28 14:03:28 +00:00
|
|
|
return priv->font_options;
|
|
|
|
}
|
2008-06-25 13:05:59 +00:00
|
|
|
|
2008-12-23 16:59:14 +00:00
|
|
|
/**
|
|
|
|
* clutter_backend_set_font_name:
|
|
|
|
* @backend: a #ClutterBackend
|
|
|
|
* @font_name: the name of the font
|
|
|
|
*
|
|
|
|
* Sets the default font to be used by Clutter. The @font_name string
|
|
|
|
* must either be %NULL, which means that the font name from the
|
|
|
|
* default #ClutterBackend will be used; or be something that can
|
|
|
|
* be parsed by the pango_font_description_from_string() function.
|
|
|
|
*
|
|
|
|
* Since: 1.0
|
2010-06-21 14:42:20 +00:00
|
|
|
*
|
|
|
|
* Deprecated: 1.4: Use #ClutterSettings:font-name instead
|
2008-12-23 16:59:14 +00:00
|
|
|
*/
|
2008-12-23 15:03:11 +00:00
|
|
|
void
|
|
|
|
clutter_backend_set_font_name (ClutterBackend *backend,
|
|
|
|
const gchar *font_name)
|
|
|
|
{
|
2010-06-21 14:42:20 +00:00
|
|
|
ClutterSettings *settings = clutter_settings_get_default ();
|
2008-12-23 15:03:11 +00:00
|
|
|
|
2010-06-21 14:42:20 +00:00
|
|
|
g_object_set (settings, "font-name", font_name, NULL);
|
2008-12-23 15:03:11 +00:00
|
|
|
}
|
|
|
|
|
2008-12-23 16:59:14 +00:00
|
|
|
/**
|
|
|
|
* clutter_backend_get_font_name:
|
|
|
|
* @backend: a #ClutterBackend
|
|
|
|
*
|
|
|
|
* Retrieves the default font name as set by
|
|
|
|
* clutter_backend_set_font_name().
|
|
|
|
*
|
|
|
|
* Return value: the font name for the backend. The returned string is
|
|
|
|
* owned by the #ClutterBackend and should never be modified or freed
|
|
|
|
*
|
|
|
|
* Since: 1.0
|
2010-06-21 14:42:20 +00:00
|
|
|
*
|
|
|
|
* Deprecated: 1.4: Use #ClutterSettings:font-name instead
|
2008-12-23 16:59:14 +00:00
|
|
|
*/
|
2008-12-23 15:03:11 +00:00
|
|
|
G_CONST_RETURN gchar *
|
|
|
|
clutter_backend_get_font_name (ClutterBackend *backend)
|
|
|
|
{
|
2008-12-23 16:27:54 +00:00
|
|
|
ClutterBackendPrivate *priv;
|
2010-06-21 14:42:20 +00:00
|
|
|
ClutterSettings *settings;
|
2008-12-23 16:27:54 +00:00
|
|
|
|
2008-12-23 15:03:11 +00:00
|
|
|
g_return_val_if_fail (CLUTTER_IS_BACKEND (backend), NULL);
|
|
|
|
|
2008-12-23 16:27:54 +00:00
|
|
|
priv = backend->priv;
|
|
|
|
|
2010-06-21 14:42:20 +00:00
|
|
|
settings = clutter_settings_get_default ();
|
2008-12-23 16:27:54 +00:00
|
|
|
|
2010-06-21 14:42:20 +00:00
|
|
|
/* XXX yuck. but we return a const pointer, so we need to
|
|
|
|
* store it in the backend
|
2009-05-07 13:16:01 +00:00
|
|
|
*/
|
2010-06-21 14:42:20 +00:00
|
|
|
g_free (priv->font_name);
|
|
|
|
g_object_get (settings, "font-name", &priv->font_name, NULL);
|
2008-12-23 16:27:54 +00:00
|
|
|
|
|
|
|
return priv->font_name;
|
2008-12-23 15:03:11 +00:00
|
|
|
}
|
2009-10-16 14:25:37 +00:00
|
|
|
|
|
|
|
gint32
|
|
|
|
_clutter_backend_get_units_serial (ClutterBackend *backend)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_BACKEND (backend), 0);
|
|
|
|
|
|
|
|
return backend->priv->units_serial;
|
|
|
|
}
|