diff --git a/ChangeLog b/ChangeLog index 3fc3586e3..eec71811d 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,19 @@ +2008-10-30 Emmanuele Bassi + + Bug 1215 - Move the Pango renderer to the public API + + * clutter/pango/*: Rename PangoClutter -> CoglPango. + + * clutter/Makefile.am: + * clutter/clutter-backend.c: + * clutter/clutter-entry.c: + * clutter/clutter-label.c: + * clutter/clutter-main.[ch]: + * clutter/clutter-private.h: Update the users of the Pango + renderer API. + + * README: Update release notes. + 2008-10-30 Emmanuele Bassi Bug 1212 - Allow only a single include file for Clutter diff --git a/README b/README index 9fc67a482..fc63d4108 100644 --- a/README +++ b/README @@ -170,6 +170,12 @@ wanting to port to newer releases (See NEWS for general new feature info). Release Notes for Clutter 1.0 ------------------------------- +* The Pango renderer API has been exposed as public API, after + a full rename from PangoClutter to CoglPango, to avoid namespace + collisions with upstream Pango. The Pango font map, renderer and + glyph cache can be used by third party code and depend only on + COGL. + * Both Clutter and COGL only allow including and directly, respectively. This allows avoiding breaking API every time a type definition is moved across diff --git a/clutter/Makefile.am b/clutter/Makefile.am index 39570c562..f2cca4968 100644 --- a/clutter/Makefile.am +++ b/clutter/Makefile.am @@ -189,14 +189,14 @@ source_h_priv = \ libclutter_@CLUTTER_FLAVOUR@_@CLUTTER_API_VERSION@_la_LIBADD = \ $(CLUTTER_LIBS) \ - $(top_builddir)/clutter/pango/libpangoclutter.la \ + $(top_builddir)/clutter/pango/libcoglpango.la \ $(top_builddir)/clutter/$(CLUTTER_FLAVOUR)/libclutter-$(CLUTTER_FLAVOUR).la \ $(top_builddir)/clutter/cogl/$(CLUTTER_COGL)/libclutter-cogl.la \ $(clutter_json_libadd) \ $(backendextralib) libclutter_@CLUTTER_FLAVOUR@_@CLUTTER_API_VERSION@_la_DEPENDENCIES = \ - pango/libpangoclutter.la \ + pango/libcoglpango.la \ $(CLUTTER_FLAVOUR)/libclutter-$(CLUTTER_FLAVOUR).la \ cogl/$(CLUTTER_COGL)/libclutter-cogl.la \ $(clutter_json_dep) \ diff --git a/clutter/clutter-backend.c b/clutter/clutter-backend.c index d4fa29a6b..9a599c16b 100644 --- a/clutter/clutter-backend.c +++ b/clutter/clutter-backend.c @@ -388,8 +388,8 @@ clutter_backend_set_resolution (ClutterBackend *backend, priv->resolution = fixed_dpi; if (CLUTTER_CONTEXT ()->font_map) - pango_clutter_font_map_set_resolution (CLUTTER_CONTEXT ()->font_map, - COGL_FIXED_TO_FLOAT (fixed_dpi)); + cogl_pango_font_map_set_resolution (CLUTTER_CONTEXT ()->font_map, + COGL_FIXED_TO_FLOAT (fixed_dpi)); } /** diff --git a/clutter/clutter-entry.c b/clutter/clutter-entry.c index dbe3a9c28..15b51969b 100644 --- a/clutter/clutter-entry.c +++ b/clutter/clutter-entry.c @@ -49,7 +49,8 @@ #include "clutter-private.h" #include "clutter-rectangle.h" #include "clutter-units.h" -#include "pangoclutter.h" + +#include "cogl-pango.h" #define DEFAULT_FONT_NAME "Sans 10" #define ENTRY_CURSOR_WIDTH 1 @@ -309,7 +310,7 @@ clutter_entry_ensure_layout (ClutterEntry *entry, gint width) pango_layout_set_width (priv->layout, -1); /* Prime the cache for the layout */ - pango_clutter_ensure_glyph_cache_for_layout (priv->layout); + cogl_pango_ensure_glyph_cache_for_layout (priv->layout); } } @@ -434,7 +435,7 @@ clutter_entry_paint (ClutterActor *self) gint width, actor_width; gint text_width; gint cursor_x; - ClutterColor color = { 0, }; + CoglColor color; entry = CLUTTER_ENTRY(self); priv = entry->priv; @@ -504,12 +505,15 @@ clutter_entry_paint (ClutterActor *self) priv->cursor_pos.x += priv->text_x + priv->entry_padding; } - memcpy (&color, &priv->fgcol, sizeof (ClutterColor)); - color.alpha = clutter_actor_get_paint_opacity (self); + cogl_color_set_from_4ub (&color, + priv->fgcol.red, + priv->fgcol.green, + priv->fgcol.blue, + clutter_actor_get_paint_opacity (self)); - pango_clutter_render_layout (priv->layout, - priv->text_x + priv->entry_padding, 0, - &color, 0); + cogl_pango_render_layout (priv->layout, + priv->text_x + priv->entry_padding, 0, + &color, 0); if (CLUTTER_ENTRY_GET_CLASS (entry)->paint_cursor) CLUTTER_ENTRY_GET_CLASS (entry)->paint_cursor (entry); diff --git a/clutter/clutter-label.c b/clutter/clutter-label.c index 8c1cfec08..73d5e28ba 100644 --- a/clutter/clutter-label.c +++ b/clutter/clutter-label.c @@ -41,7 +41,7 @@ #include "clutter-debug.h" #include "clutter-units.h" -#include "pangoclutter.h" +#include "cogl-pango.h" #define DEFAULT_FONT_NAME "Sans 10" @@ -265,7 +265,7 @@ clutter_label_create_layout (ClutterLabel *label, oldest_cache->layout = clutter_label_create_layout_no_cache (label, allocation_width); - pango_clutter_ensure_glyph_cache_for_layout (oldest_cache->layout); + cogl_pango_ensure_glyph_cache_for_layout (oldest_cache->layout); /* Mark the 'time' this cache was created and advance the time */ oldest_cache->age = priv->cache_age++; @@ -281,7 +281,7 @@ clutter_label_paint (ClutterActor *self) ClutterLabel *label = CLUTTER_LABEL (self); ClutterLabelPrivate *priv = label->priv; PangoLayout *layout; - ClutterColor color = { 0, }; + CoglColor color; ClutterActorBox alloc = { 0, }; if (priv->font_desc == NULL || priv->text == NULL) @@ -297,10 +297,13 @@ clutter_label_paint (ClutterActor *self) clutter_actor_get_allocation_box (self, &alloc); layout = clutter_label_create_layout (label, alloc.x2 - alloc.x1); - memcpy (&color, &priv->fgcol, sizeof (ClutterColor)); - color.alpha = clutter_actor_get_paint_opacity (self); + cogl_color_set_from_4ub (&color, + priv->fgcol.red, + priv->fgcol.green, + priv->fgcol.blue, + clutter_actor_get_paint_opacity (self)); - pango_clutter_render_layout (layout, 0, 0, &color, 0); + cogl_pango_render_layout (layout, 0, 0, &color, 0); } static void diff --git a/clutter/clutter-main.c b/clutter/clutter-main.c index c46b92e6a..0176e484c 100644 --- a/clutter/clutter-main.c +++ b/clutter/clutter-main.c @@ -50,6 +50,7 @@ #include "clutter-frame-source.h" #include "cogl/cogl.h" +#include "pango/cogl-pango.h" /* main context */ static ClutterMainContext *ClutterCntx = NULL; @@ -410,7 +411,7 @@ _clutter_context_create_pango_context (ClutterMainContext *self) if (resolution < 0) resolution = 96.0; /* fall back */ - context = pango_clutter_font_map_create_context (self->font_map); + context = cogl_pango_font_map_create_context (self->font_map); pango_cairo_context_set_resolution (context, resolution); @@ -1070,12 +1071,11 @@ clutter_init_real (GError **error) * Resolution requires display to be open, so can only be queried after * the post_parse hooks run. */ - ctx->font_map = PANGO_CLUTTER_FONT_MAP (pango_clutter_font_map_new ()); + ctx->font_map = COGL_PANGO_FONT_MAP (cogl_pango_font_map_new ()); resolution = clutter_backend_get_resolution (ctx->backend); - pango_clutter_font_map_set_resolution (ctx->font_map, resolution); - - pango_clutter_font_map_set_use_mipmapping (ctx->font_map, TRUE); + cogl_pango_font_map_set_resolution (ctx->font_map, resolution); + cogl_pango_font_map_set_use_mipmapping (ctx->font_map, TRUE); /* Stage will give us a GL Context etc */ stage = clutter_stage_get_default (); @@ -2491,7 +2491,7 @@ void clutter_clear_glyph_cache (void) { if (CLUTTER_CONTEXT ()->font_map) - pango_clutter_font_map_clear_glyph_cache (CLUTTER_CONTEXT ()->font_map); + cogl_pango_font_map_clear_glyph_cache (CLUTTER_CONTEXT ()->font_map); } /** @@ -2508,8 +2508,8 @@ void clutter_set_use_mipmapped_text (gboolean value) { if (CLUTTER_CONTEXT ()->font_map) - pango_clutter_font_map_set_use_mipmapping (CLUTTER_CONTEXT ()->font_map, - value); + cogl_pango_font_map_set_use_mipmapping (CLUTTER_CONTEXT ()->font_map, + value); } /** @@ -2526,12 +2526,12 @@ clutter_set_use_mipmapped_text (gboolean value) gboolean clutter_get_use_mipmapped_text (void) { - PangoClutterFontMap *font_map = NULL; + CoglPangoFontMap *font_map = NULL; font_map = CLUTTER_CONTEXT ()->font_map; - if (font_map) - return pango_clutter_font_map_get_use_mipmapping (font_map); + if (G_LIKELY (font_map)) + return cogl_pango_font_map_get_use_mipmapping (font_map); return FALSE; } @@ -2567,3 +2567,25 @@ clutter_get_input_device_for_id (gint id) return NULL; } + +/** + * clutter_get_font_map: + * + * Retrieves the #PangoFontMap instance used by Clutter. + * You can use the global font map object with the COGL + * Pango API. + * + * Return value: the #PangoFontMap instance. The returned + * value is owned by Clutter and it should never be + * unreferenced. + * + * Since: 1.0 + */ +PangoFontMap * +clutter_get_font_map (void) +{ + if (CLUTTER_CONTEXT ()->font_map) + return PANGO_FONT_MAP (CLUTTER_CONTEXT ()->font_map); + + return NULL; +} diff --git a/clutter/clutter-main.h b/clutter/clutter-main.h index 7a9106f82..9927d12fd 100644 --- a/clutter/clutter-main.h +++ b/clutter/clutter-main.h @@ -30,6 +30,7 @@ #include #include +#include G_BEGIN_DECLS @@ -164,6 +165,7 @@ void clutter_grab_pointer_for_device (ClutterActor *actor, void clutter_ungrab_pointer_for_device (gint id); +PangoFontMap * clutter_get_font_map (void); G_END_DECLS diff --git a/clutter/clutter-private.h b/clutter/clutter-private.h index 2ccb65d4c..74aac64aa 100644 --- a/clutter/clutter-private.h +++ b/clutter/clutter-private.h @@ -45,7 +45,7 @@ #include "clutter-stage-manager.h" #include "clutter-stage-window.h" #include "clutter-stage.h" -#include "pango/pangoclutter.h" +#include "pango/cogl-pango.h" G_BEGIN_DECLS @@ -124,7 +124,7 @@ struct _ClutterMainContext gint fb_r_mask, fb_g_mask, fb_b_mask; gint fb_r_mask_used, fb_g_mask_used, fb_b_mask_used; - PangoClutterFontMap *font_map; /* Global font map */ + CoglPangoFontMap *font_map; /* Global font map */ GSList *input_devices; /* For extra input devices, i.e MultiTouch */ diff --git a/clutter/pango/Makefile.am b/clutter/pango/Makefile.am index ef052d51e..021e35e49 100644 --- a/clutter/pango/Makefile.am +++ b/clutter/pango/Makefile.am @@ -1,25 +1,30 @@ -source_c = pangoclutter-fontmap.c \ - pangoclutter-render.c \ - pangoclutter-glyph-cache.c +source_c = \ + cogl-pango-fontmap.c \ + cogl-pango-render.c \ + cogl-pango-glyph-cache.c -source_h = pangoclutter.h +source_h = cogl-pango.h -source_h_priv = pangoclutter-private.h \ - pangoclutter-glyph-cache.h +source_h_priv = \ + cogl-pango-private.h \ + cogl-pango-glyph-cache.h -noinst_LTLIBRARIES = libpangoclutter.la +noinst_LTLIBRARIES = libcoglpango.la -libpangoclutter_la_SOURCES = $(source_c) \ - $(source_h) \ - $(source_h_priv) +libcoglpango_la_SOURCES = \ + $(source_c) \ + $(source_h) \ + $(source_h_priv) INCLUDES = \ @GCC_FLAGS@ @CLUTTER_CFLAGS@ \ $(CLUTTER_DEBUG_CFLAGS) \ - -DCLUTTER_COMPILATION \ - -I$(top_srcdir) \ + -DCLUTTER_COMPILATION \ + -I$(top_srcdir) \ -I$(top_srcdir)/clutter \ - -I$(top_builddir)/clutter + -I$(top_srcdir)/clutter/cogl \ + -I$(top_builddir)/clutter \ + -I$(top_builddir)/clutter/cogl -pangoclutterheadersdir = $(includedir)/clutter-@CLUTTER_MAJORMINOR@/clutter -pangoclutterheaders_HEADERS = $(source_h) +coglpangoheadersdir = $(includedir)/clutter-@CLUTTER_MAJORMINOR@/cogl +coglpangoheaders_HEADERS = $(source_h) diff --git a/clutter/pango/pangoclutter-fontmap.c b/clutter/pango/cogl-pango-fontmap.c similarity index 54% rename from clutter/pango/pangoclutter-fontmap.c rename to clutter/pango/cogl-pango-fontmap.c index 409815cca..f320c35d4 100644 --- a/clutter/pango/pangoclutter-fontmap.c +++ b/clutter/pango/cogl-pango-fontmap.c @@ -18,9 +18,7 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. + * License along with this library. If not, see . */ #ifdef HAVE_CONFIG_H @@ -37,21 +35,21 @@ #include #include -#include "pangoclutter.h" -#include "pangoclutter-private.h" +#include "cogl-pango.h" +#include "cogl-pango-private.h" -static GQuark pango_clutter_font_map_get_renderer_key (void) G_GNUC_CONST; +static GQuark cogl_pango_font_map_get_renderer_key (void) G_GNUC_CONST; PangoFontMap * -pango_clutter_font_map_new (void) +cogl_pango_font_map_new (void) { return pango_cairo_font_map_new (); } PangoContext * -pango_clutter_font_map_create_context (PangoClutterFontMap *fm) +cogl_pango_font_map_create_context (CoglPangoFontMap *fm) { - g_return_val_if_fail (PANGO_CLUTTER_IS_FONT_MAP (fm), NULL); + g_return_val_if_fail (COGL_PANGO_IS_FONT_MAP (fm), NULL); /* We can just directly use the pango context from the Cairo font map */ @@ -59,22 +57,24 @@ pango_clutter_font_map_create_context (PangoClutterFontMap *fm) } PangoRenderer * -_pango_clutter_font_map_get_renderer (PangoClutterFontMap *fm) +cogl_pango_font_map_get_renderer (CoglPangoFontMap *fm) { PangoRenderer *renderer; + g_return_val_if_fail (COGL_PANGO_IS_FONT_MAP (fm), NULL); + /* We want to keep a cached pointer to the renderer from the font map instance but as we don't have a proper subclass we have to store it in the object data instead */ renderer = g_object_get_qdata (G_OBJECT (fm), - pango_clutter_font_map_get_renderer_key ()); + cogl_pango_font_map_get_renderer_key ()); if (G_UNLIKELY (renderer == NULL)) { - renderer = g_object_new (PANGO_CLUTTER_TYPE_RENDERER, NULL); + renderer = g_object_new (COGL_PANGO_TYPE_RENDERER, NULL); g_object_set_qdata_full (G_OBJECT (fm), - pango_clutter_font_map_get_renderer_key (), + cogl_pango_font_map_get_renderer_key (), renderer, g_object_unref); } @@ -83,52 +83,52 @@ _pango_clutter_font_map_get_renderer (PangoClutterFontMap *fm) } void -pango_clutter_font_map_set_resolution (PangoClutterFontMap *font_map, - double dpi) +cogl_pango_font_map_set_resolution (CoglPangoFontMap *font_map, + double dpi) { - g_return_if_fail (PANGO_CLUTTER_IS_FONT_MAP (font_map)); + g_return_if_fail (COGL_PANGO_IS_FONT_MAP (font_map)); pango_cairo_font_map_set_resolution (PANGO_CAIRO_FONT_MAP (font_map), dpi); } void -pango_clutter_font_map_clear_glyph_cache (PangoClutterFontMap *fm) +cogl_pango_font_map_clear_glyph_cache (CoglPangoFontMap *fm) { PangoRenderer *renderer; - renderer = _pango_clutter_font_map_get_renderer (fm); + renderer = cogl_pango_font_map_get_renderer (fm); - _pango_clutter_renderer_clear_glyph_cache (PANGO_CLUTTER_RENDERER (renderer)); + _cogl_pango_renderer_clear_glyph_cache (COGL_PANGO_RENDERER (renderer)); } void -pango_clutter_font_map_set_use_mipmapping (PangoClutterFontMap *fm, - gboolean value) +cogl_pango_font_map_set_use_mipmapping (CoglPangoFontMap *fm, + gboolean value) { - PangoClutterRenderer *renderer; + CoglPangoRenderer *renderer; - renderer = PANGO_CLUTTER_RENDERER (_pango_clutter_font_map_get_renderer (fm)); + renderer = COGL_PANGO_RENDERER (cogl_pango_font_map_get_renderer (fm)); - _pango_clutter_renderer_set_use_mipmapping (renderer, value); + _cogl_pango_renderer_set_use_mipmapping (renderer, value); } gboolean -pango_clutter_font_map_get_use_mipmapping (PangoClutterFontMap *fm) +cogl_pango_font_map_get_use_mipmapping (CoglPangoFontMap *fm) { - PangoClutterRenderer *renderer; + CoglPangoRenderer *renderer; - renderer = PANGO_CLUTTER_RENDERER (_pango_clutter_font_map_get_renderer (fm)); + renderer = COGL_PANGO_RENDERER (cogl_pango_font_map_get_renderer (fm)); - return _pango_clutter_renderer_get_use_mipmapping (renderer); + return _cogl_pango_renderer_get_use_mipmapping (renderer); } static GQuark -pango_clutter_font_map_get_renderer_key (void) +cogl_pango_font_map_get_renderer_key (void) { static GQuark renderer_key = 0; if (G_UNLIKELY (renderer_key == 0)) - renderer_key = g_quark_from_static_string ("PangoClutterFontMap"); + renderer_key = g_quark_from_static_string ("CoglPangoFontMap"); return renderer_key; } diff --git a/clutter/pango/pangoclutter-glyph-cache.c b/clutter/pango/cogl-pango-glyph-cache.c similarity index 68% rename from clutter/pango/pangoclutter-glyph-cache.c rename to clutter/pango/cogl-pango-glyph-cache.c index 727a6a89c..7a2bf2f23 100644 --- a/clutter/pango/pangoclutter-glyph-cache.c +++ b/clutter/pango/cogl-pango-glyph-cache.c @@ -18,9 +18,7 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. + * License along with this library. If not, see . */ #ifdef HAVE_CONFIG_H @@ -29,8 +27,8 @@ #include -#include "pangoclutter-glyph-cache.h" -#include "cogl/cogl.h" +#include "cogl-pango-glyph-cache.h" +#include "cogl-pango-private.h" /* Minimum width/height for each texture */ #define MIN_TEXTURE_SIZE 256 @@ -38,28 +36,28 @@ put in the same band */ #define BAND_HEIGHT_ROUND 4 -typedef struct _PangoClutterGlyphCacheKey PangoClutterGlyphCacheKey; -typedef struct _PangoClutterGlyphCacheTexture PangoClutterGlyphCacheTexture; -typedef struct _PangoClutterGlyphCacheBand PangoClutterGlyphCacheBand; +typedef struct _CoglPangoGlyphCacheKey CoglPangoGlyphCacheKey; +typedef struct _CoglPangoGlyphCacheTexture CoglPangoGlyphCacheTexture; +typedef struct _CoglPangoGlyphCacheBand CoglPangoGlyphCacheBand; -struct _PangoClutterGlyphCache +struct _CoglPangoGlyphCache { /* Hash table to quickly check whether a particular glyph in a particular font is already cached */ GHashTable *hash_table; /* List of textures */ - PangoClutterGlyphCacheTexture *textures; + CoglPangoGlyphCacheTexture *textures; /* List of horizontal bands of glyphs */ - PangoClutterGlyphCacheBand *bands; + CoglPangoGlyphCacheBand *bands; /* If TRUE all of the textures will be created with automatic mipmap generation enabled */ gboolean use_mipmapping; }; -struct _PangoClutterGlyphCacheKey +struct _CoglPangoGlyphCacheKey { PangoFont *font; PangoGlyph glyph; @@ -68,7 +66,7 @@ struct _PangoClutterGlyphCacheKey /* Represents one texture that will be used to store glyphs. The texture is divided into horizontal bands which all contain glyphs of approximatly the same height */ -struct _PangoClutterGlyphCacheTexture +struct _CoglPangoGlyphCacheTexture { /* The width and height of the texture which should always be a power of two. This can vary so that glyphs larger than @@ -81,12 +79,12 @@ struct _PangoClutterGlyphCacheTexture /* The actual texture */ CoglHandle texture; - PangoClutterGlyphCacheTexture *next; + CoglPangoGlyphCacheTexture *next; }; /* Represents one horizontal band of a texture. Each band contains glyphs of a similar height */ -struct _PangoClutterGlyphCacheBand +struct _CoglPangoGlyphCacheBand { /* The y position of the top of the band */ int top; @@ -104,28 +102,28 @@ struct _PangoClutterGlyphCacheBand /* The texture containing this band */ CoglHandle texture; - PangoClutterGlyphCacheBand *next; + CoglPangoGlyphCacheBand *next; }; static void -pango_clutter_glyph_cache_value_free (PangoClutterGlyphCacheValue *value) +cogl_pango_glyph_cache_value_free (CoglPangoGlyphCacheValue *value) { cogl_texture_unref (value->texture); - g_slice_free (PangoClutterGlyphCacheValue, value); + g_slice_free (CoglPangoGlyphCacheValue, value); } static void -pango_clutter_glyph_cache_key_free (PangoClutterGlyphCacheKey *key) +cogl_pango_glyph_cache_key_free (CoglPangoGlyphCacheKey *key) { g_object_unref (key->font); - g_slice_free (PangoClutterGlyphCacheKey, key); + g_slice_free (CoglPangoGlyphCacheKey, key); } static guint -pango_clutter_glyph_cache_hash_func (gconstpointer key) +cogl_pango_glyph_cache_hash_func (gconstpointer key) { - const PangoClutterGlyphCacheKey *cache_key - = (const PangoClutterGlyphCacheKey *) key; + const CoglPangoGlyphCacheKey *cache_key + = (const CoglPangoGlyphCacheKey *) key; /* Generate a number affected by both the font and the glyph number. We can safely directly compare the pointers because the @@ -135,13 +133,13 @@ pango_clutter_glyph_cache_hash_func (gconstpointer key) } static gboolean -pango_clutter_glyph_cache_equal_func (gconstpointer a, +cogl_pango_glyph_cache_equal_func (gconstpointer a, gconstpointer b) { - const PangoClutterGlyphCacheKey *key_a - = (const PangoClutterGlyphCacheKey *) a; - const PangoClutterGlyphCacheKey *key_b - = (const PangoClutterGlyphCacheKey *) b; + const CoglPangoGlyphCacheKey *key_a + = (const CoglPangoGlyphCacheKey *) a; + const CoglPangoGlyphCacheKey *key_b + = (const CoglPangoGlyphCacheKey *) b; /* We can safely directly compare the pointers for the fonts because the key holds a reference to the font so it is not possible that @@ -151,45 +149,45 @@ pango_clutter_glyph_cache_equal_func (gconstpointer a, } static void -pango_clutter_glyph_cache_free_textures (PangoClutterGlyphCacheTexture *node) +cogl_pango_glyph_cache_free_textures (CoglPangoGlyphCacheTexture *node) { - PangoClutterGlyphCacheTexture *next; + CoglPangoGlyphCacheTexture *next; while (node) { next = node->next; cogl_texture_unref (node->texture); - g_slice_free (PangoClutterGlyphCacheTexture, node); + g_slice_free (CoglPangoGlyphCacheTexture, node); node = next; } } static void -pango_clutter_glyph_cache_free_bands (PangoClutterGlyphCacheBand *node) +cogl_pango_glyph_cache_free_bands (CoglPangoGlyphCacheBand *node) { - PangoClutterGlyphCacheBand *next; + CoglPangoGlyphCacheBand *next; while (node) { next = node->next; cogl_texture_unref (node->texture); - g_slice_free (PangoClutterGlyphCacheBand, node); + g_slice_free (CoglPangoGlyphCacheBand, node); node = next; } } -PangoClutterGlyphCache * -pango_clutter_glyph_cache_new (gboolean use_mipmapping) +CoglPangoGlyphCache * +cogl_pango_glyph_cache_new (gboolean use_mipmapping) { - PangoClutterGlyphCache *cache; + CoglPangoGlyphCache *cache; - cache = g_malloc (sizeof (PangoClutterGlyphCache)); + cache = g_malloc (sizeof (CoglPangoGlyphCache)); cache->hash_table = g_hash_table_new_full - (pango_clutter_glyph_cache_hash_func, - pango_clutter_glyph_cache_equal_func, - (GDestroyNotify) pango_clutter_glyph_cache_key_free, - (GDestroyNotify) pango_clutter_glyph_cache_value_free); + (cogl_pango_glyph_cache_hash_func, + cogl_pango_glyph_cache_equal_func, + (GDestroyNotify) cogl_pango_glyph_cache_key_free, + (GDestroyNotify) cogl_pango_glyph_cache_value_free); cache->textures = NULL; cache->bands = NULL; @@ -199,55 +197,55 @@ pango_clutter_glyph_cache_new (gboolean use_mipmapping) } void -pango_clutter_glyph_cache_clear (PangoClutterGlyphCache *cache) +cogl_pango_glyph_cache_clear (CoglPangoGlyphCache *cache) { - pango_clutter_glyph_cache_free_textures (cache->textures); + cogl_pango_glyph_cache_free_textures (cache->textures); cache->textures = NULL; - pango_clutter_glyph_cache_free_bands (cache->bands); + cogl_pango_glyph_cache_free_bands (cache->bands); cache->bands = NULL; g_hash_table_remove_all (cache->hash_table); } void -pango_clutter_glyph_cache_free (PangoClutterGlyphCache *cache) +cogl_pango_glyph_cache_free (CoglPangoGlyphCache *cache) { - pango_clutter_glyph_cache_clear (cache); + cogl_pango_glyph_cache_clear (cache); g_hash_table_unref (cache->hash_table); g_free (cache); } -PangoClutterGlyphCacheValue * -pango_clutter_glyph_cache_lookup (PangoClutterGlyphCache *cache, +CoglPangoGlyphCacheValue * +cogl_pango_glyph_cache_lookup (CoglPangoGlyphCache *cache, PangoFont *font, PangoGlyph glyph) { - PangoClutterGlyphCacheKey key; + CoglPangoGlyphCacheKey key; key.font = font; key.glyph = glyph; - return (PangoClutterGlyphCacheValue *) + return (CoglPangoGlyphCacheValue *) g_hash_table_lookup (cache->hash_table, &key); } -PangoClutterGlyphCacheValue * -pango_clutter_glyph_cache_set (PangoClutterGlyphCache *cache, - PangoFont *font, - PangoGlyph glyph, - gconstpointer pixels, - int width, - int height, - int stride, - int draw_x, - int draw_y) +CoglPangoGlyphCacheValue * +cogl_pango_glyph_cache_set (CoglPangoGlyphCache *cache, + PangoFont *font, + PangoGlyph glyph, + gconstpointer pixels, + int width, + int height, + int stride, + int draw_x, + int draw_y) { - int band_height; - PangoClutterGlyphCacheBand *band; - PangoClutterGlyphCacheKey *key; - PangoClutterGlyphCacheValue *value; + int band_height; + CoglPangoGlyphCacheBand *band; + CoglPangoGlyphCacheKey *key; + CoglPangoGlyphCacheValue *value; /* Reserve an extra pixel gap around the glyph so that it can pull in blank pixels when linear filtering is enabled */ @@ -264,7 +262,7 @@ pango_clutter_glyph_cache_set (PangoClutterGlyphCache *cache, band = band->next); if (band == NULL) { - PangoClutterGlyphCacheTexture *texture; + CoglPangoGlyphCacheTexture *texture; /* Look for a texture with enough vertical space left for a band with this height */ @@ -279,7 +277,7 @@ pango_clutter_glyph_cache_set (PangoClutterGlyphCache *cache, /* Allocate a new texture that is the nearest power of two greater than the band height or the minimum size, whichever is lower */ - texture = g_slice_new (PangoClutterGlyphCacheTexture); + texture = g_slice_new (CoglPangoGlyphCacheTexture); texture->texture_size = MIN_TEXTURE_SIZE; while (texture->texture_size < band_height @@ -312,7 +310,7 @@ pango_clutter_glyph_cache_set (PangoClutterGlyphCache *cache, CGL_LINEAR); } - band = g_slice_new (PangoClutterGlyphCacheBand); + band = g_slice_new (CoglPangoGlyphCacheBand); band->top = texture->texture_size - texture->space_remaining; band->height = band_height; band->space_remaining = texture->texture_size; @@ -338,11 +336,11 @@ pango_clutter_glyph_cache_set (PangoClutterGlyphCache *cache, stride, pixels); - key = g_slice_new (PangoClutterGlyphCacheKey); + key = g_slice_new (CoglPangoGlyphCacheKey); key->font = g_object_ref (font); key->glyph = glyph; - value = g_slice_new (PangoClutterGlyphCacheValue); + value = g_slice_new (CoglPangoGlyphCacheValue); value->texture = cogl_texture_ref (band->texture); value->tx1 = COGL_FIXED_FROM_INT (band->space_remaining) / band->texture_size; diff --git a/clutter/pango/cogl-pango-glyph-cache.h b/clutter/pango/cogl-pango-glyph-cache.h new file mode 100644 index 000000000..2f4b5798b --- /dev/null +++ b/clutter/pango/cogl-pango-glyph-cache.h @@ -0,0 +1,78 @@ +/* + * Clutter. + * + * An OpenGL based 'interactive canvas' library. + * + * Authored By Matthew Allum + * + * Copyright (C) 2008 OpenedHand + * + * 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, see . + */ + +#ifndef __COGL_PANGO_GLYPH_CACHE_H__ +#define __COGL_PANGO_GLYPH_CACHE_H__ + +#include +#include +#include + +G_BEGIN_DECLS + +typedef struct _CoglPangoGlyphCache CoglPangoGlyphCache; +typedef struct _CoglPangoGlyphCacheValue CoglPangoGlyphCacheValue; + +struct _CoglPangoGlyphCacheValue +{ + CoglHandle texture; + + CoglFixed tx1; + CoglFixed ty1; + CoglFixed tx2; + CoglFixed ty2; + + int draw_x; + int draw_y; + int draw_width; + int draw_height; +}; + +CoglPangoGlyphCache * +cogl_pango_glyph_cache_new (gboolean use_mipmapping); + +void +cogl_pango_glyph_cache_free (CoglPangoGlyphCache *cache); + +CoglPangoGlyphCacheValue * +cogl_pango_glyph_cache_lookup (CoglPangoGlyphCache *cache, + PangoFont *font, + PangoGlyph glyph); + +CoglPangoGlyphCacheValue * +cogl_pango_glyph_cache_set (CoglPangoGlyphCache *cache, + PangoFont *font, + PangoGlyph glyph, + gconstpointer pixels, + int width, + int height, + int stride, + int draw_x, + int draw_y); + +void +cogl_pango_glyph_cache_clear (CoglPangoGlyphCache *cache); + +G_END_DECLS + +#endif /* __COGL_PANGO_GLYPH_CACHE_H__ */ diff --git a/clutter/pango/pangoclutter-private.h b/clutter/pango/cogl-pango-private.h similarity index 51% rename from clutter/pango/pangoclutter-private.h rename to clutter/pango/cogl-pango-private.h index 969b0e844..447e853f3 100644 --- a/clutter/pango/pangoclutter-private.h +++ b/clutter/pango/cogl-pango-private.h @@ -18,26 +18,21 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. + * License along with this library. If not, see . */ -#ifndef _HAVE_PANGO_CLUTTER_PRIVATE_H -#define _HAVE_PANGO_CLUTTER_PRIVATE_H +#ifndef __COGL_PANGO_PRIVATE_H__ +#define __COGL_PANGO_PRIVATE_H__ -#include "pangoclutter.h" +#include "cogl-pango.h" G_BEGIN_DECLS -PangoRenderer *_pango_clutter_font_map_get_renderer (PangoClutterFontMap *fm); - -void _pango_clutter_renderer_clear_glyph_cache (PangoClutterRenderer *renderer); - -void _pango_clutter_renderer_set_use_mipmapping (PangoClutterRenderer *renderer, - gboolean value); -gboolean _pango_clutter_renderer_get_use_mipmapping (PangoClutterRenderer *renderer); +void _cogl_pango_renderer_clear_glyph_cache (CoglPangoRenderer *renderer); +void _cogl_pango_renderer_set_use_mipmapping (CoglPangoRenderer *renderer, + gboolean value); +gboolean _cogl_pango_renderer_get_use_mipmapping (CoglPangoRenderer *renderer); G_END_DECLS -#endif /* _HAVE_PANGO_CLUTTER_H */ +#endif /* __COGL_PANGO_PRIVATE_H__ */ diff --git a/clutter/pango/pangoclutter-render.c b/clutter/pango/cogl-pango-render.c similarity index 51% rename from clutter/pango/pangoclutter-render.c rename to clutter/pango/cogl-pango-render.c index 877ffac78..41041785f 100644 --- a/clutter/pango/pangoclutter-render.c +++ b/clutter/pango/cogl-pango-render.c @@ -18,9 +18,7 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. + * License along with this library. If not, see . */ #ifdef HAVE_CONFIG_H @@ -36,13 +34,11 @@ #include #include -#include "pangoclutter.h" -#include "pangoclutter-private.h" -#include "pangoclutter-glyph-cache.h" +#include "cogl-pango-private.h" +#include "cogl-pango-glyph-cache.h" #include "../clutter-debug.h" -#include "cogl/cogl.h" -struct _PangoClutterRenderer +struct _CoglPangoRenderer { PangoRenderer parent_instance; @@ -51,32 +47,32 @@ struct _PangoClutterRenderer /* Two caches of glyphs as textures, one with mipmapped textures and one without */ - PangoClutterGlyphCache *glyph_cache; - PangoClutterGlyphCache *mipmapped_glyph_cache; + CoglPangoGlyphCache *glyph_cache; + CoglPangoGlyphCache *mipmapped_glyph_cache; gboolean use_mipmapping; }; -struct _PangoClutterRendererClass +struct _CoglPangoRendererClass { PangoRendererClass class_instance; }; -#define CLUTTER_PANGO_UNIT_TO_FIXED(x) ((x) << (CFX_Q - 10)) +#define COGL_PANGO_UNIT_TO_FIXED(x) ((x) << (COGL_FIXED_Q - 10)) -static void pango_clutter_renderer_finalize (GObject *object); -static void pango_clutter_renderer_draw_glyphs (PangoRenderer *renderer, +static void cogl_pango_renderer_finalize (GObject *object); +static void cogl_pango_renderer_draw_glyphs (PangoRenderer *renderer, PangoFont *font, PangoGlyphString *glyphs, int x, int y); -static void pango_clutter_renderer_draw_rectangle (PangoRenderer *renderer, +static void cogl_pango_renderer_draw_rectangle (PangoRenderer *renderer, PangoRenderPart part, int x, int y, int width, int height); -static void pango_clutter_renderer_draw_trapezoid (PangoRenderer *renderer, +static void cogl_pango_renderer_draw_trapezoid (PangoRenderer *renderer, PangoRenderPart part, double y1, double x11, @@ -87,79 +83,75 @@ static void pango_clutter_renderer_draw_trapezoid (PangoRenderer *renderer, static GObjectClass *parent_class = NULL; -G_DEFINE_TYPE (PangoClutterRenderer, pango_clutter_renderer, +G_DEFINE_TYPE (CoglPangoRenderer, cogl_pango_renderer, PANGO_TYPE_RENDERER); static void -pango_clutter_renderer_init (PangoClutterRenderer *priv) +cogl_pango_renderer_init (CoglPangoRenderer *priv) { - priv->glyph_cache = pango_clutter_glyph_cache_new (FALSE); - priv->mipmapped_glyph_cache = pango_clutter_glyph_cache_new (TRUE); + priv->glyph_cache = cogl_pango_glyph_cache_new (FALSE); + priv->mipmapped_glyph_cache = cogl_pango_glyph_cache_new (TRUE); priv->use_mipmapping = FALSE; } static void -pango_clutter_renderer_class_init (PangoClutterRendererClass *klass) +cogl_pango_renderer_class_init (CoglPangoRendererClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); PangoRendererClass *renderer_class = PANGO_RENDERER_CLASS (klass); parent_class = g_type_class_peek_parent (klass); - object_class->finalize = pango_clutter_renderer_finalize; + object_class->finalize = cogl_pango_renderer_finalize; - renderer_class->draw_glyphs = pango_clutter_renderer_draw_glyphs; - renderer_class->draw_rectangle = pango_clutter_renderer_draw_rectangle; - renderer_class->draw_trapezoid = pango_clutter_renderer_draw_trapezoid; + renderer_class->draw_glyphs = cogl_pango_renderer_draw_glyphs; + renderer_class->draw_rectangle = cogl_pango_renderer_draw_rectangle; + renderer_class->draw_trapezoid = cogl_pango_renderer_draw_trapezoid; } static void -pango_clutter_renderer_finalize (GObject *object) +cogl_pango_renderer_finalize (GObject *object) { - PangoClutterRenderer *priv = PANGO_CLUTTER_RENDERER (object); + CoglPangoRenderer *priv = COGL_PANGO_RENDERER (object); - pango_clutter_glyph_cache_free (priv->mipmapped_glyph_cache); - pango_clutter_glyph_cache_free (priv->glyph_cache); + cogl_pango_glyph_cache_free (priv->mipmapped_glyph_cache); + cogl_pango_glyph_cache_free (priv->glyph_cache); G_OBJECT_CLASS (parent_class)->finalize (object); } void -pango_clutter_render_layout_subpixel (PangoLayout *layout, - int x, - int y, - ClutterColor *color, - int flags) +cogl_pango_render_layout_subpixel (PangoLayout *layout, + int x, + int y, + const CoglColor *color, + int flags) { PangoContext *context; PangoFontMap *font_map; PangoRenderer *renderer; - PangoClutterRenderer *priv; + CoglPangoRenderer *priv; context = pango_layout_get_context (layout); font_map = pango_context_get_font_map (context); - g_return_if_fail (PANGO_CLUTTER_IS_FONT_MAP (font_map)); - renderer = _pango_clutter_font_map_get_renderer - (PANGO_CLUTTER_FONT_MAP (font_map)); - priv = PANGO_CLUTTER_RENDERER (renderer); + g_return_if_fail (COGL_PANGO_IS_FONT_MAP (font_map)); + renderer = cogl_pango_font_map_get_renderer + (COGL_PANGO_FONT_MAP (font_map)); + priv = COGL_PANGO_RENDERER (renderer); - cogl_color_set_from_4ub (&priv->color, - color->red, - color->green, - color->blue, - color->alpha); + priv->color = *color; pango_renderer_draw_layout (renderer, layout, x, y); } void -pango_clutter_render_layout (PangoLayout *layout, - int x, - int y, - ClutterColor *color, - int flags) +cogl_pango_render_layout (PangoLayout *layout, + int x, + int y, + const CoglColor *color, + int flags) { - pango_clutter_render_layout_subpixel (layout, + cogl_pango_render_layout_subpixel (layout, x * PANGO_SCALE, y * PANGO_SCALE, color, @@ -167,65 +159,61 @@ pango_clutter_render_layout (PangoLayout *layout, } void -pango_clutter_render_layout_line (PangoLayoutLine *line, - int x, - int y, - ClutterColor *color) +cogl_pango_render_layout_line (PangoLayoutLine *line, + int x, + int y, + const CoglColor *color) { PangoContext *context; PangoFontMap *font_map; PangoRenderer *renderer; - PangoClutterRenderer *priv; + CoglPangoRenderer *priv; context = pango_layout_get_context (line->layout); font_map = pango_context_get_font_map (context); - g_return_if_fail (PANGO_CLUTTER_IS_FONT_MAP (font_map)); - renderer = _pango_clutter_font_map_get_renderer - (PANGO_CLUTTER_FONT_MAP (font_map)); - priv = PANGO_CLUTTER_RENDERER (renderer); + g_return_if_fail (COGL_PANGO_IS_FONT_MAP (font_map)); + renderer = cogl_pango_font_map_get_renderer + (COGL_PANGO_FONT_MAP (font_map)); + priv = COGL_PANGO_RENDERER (renderer); - cogl_color_set_from_4ub (&priv->color, - color->red, - color->green, - color->blue, - color->alpha); + priv->color = *color; pango_renderer_draw_layout_line (renderer, line, x, y); } void -_pango_clutter_renderer_clear_glyph_cache (PangoClutterRenderer *renderer) +_cogl_pango_renderer_clear_glyph_cache (CoglPangoRenderer *renderer) { - pango_clutter_glyph_cache_clear (renderer->glyph_cache); - pango_clutter_glyph_cache_clear (renderer->mipmapped_glyph_cache); + cogl_pango_glyph_cache_clear (renderer->glyph_cache); + cogl_pango_glyph_cache_clear (renderer->mipmapped_glyph_cache); } void -_pango_clutter_renderer_set_use_mipmapping (PangoClutterRenderer *renderer, +_cogl_pango_renderer_set_use_mipmapping (CoglPangoRenderer *renderer, gboolean value) { renderer->use_mipmapping = value; } gboolean -_pango_clutter_renderer_get_use_mipmapping (PangoClutterRenderer *renderer) +_cogl_pango_renderer_get_use_mipmapping (CoglPangoRenderer *renderer) { return renderer->use_mipmapping; } -static PangoClutterGlyphCacheValue * -pango_clutter_renderer_get_cached_glyph (PangoRenderer *renderer, +static CoglPangoGlyphCacheValue * +cogl_pango_renderer_get_cached_glyph (PangoRenderer *renderer, PangoFont *font, PangoGlyph glyph) { - PangoClutterRenderer *priv = PANGO_CLUTTER_RENDERER (renderer); - PangoClutterGlyphCacheValue *value; - PangoClutterGlyphCache *glyph_cache; + CoglPangoRenderer *priv = COGL_PANGO_RENDERER (renderer); + CoglPangoGlyphCacheValue *value; + CoglPangoGlyphCache *glyph_cache; glyph_cache = priv->use_mipmapping ? priv->mipmapped_glyph_cache : priv->glyph_cache; - if ((value = pango_clutter_glyph_cache_lookup (glyph_cache, + if ((value = cogl_pango_glyph_cache_lookup (glyph_cache, font, glyph)) == NULL) { @@ -257,7 +245,7 @@ pango_clutter_renderer_get_cached_glyph (PangoRenderer *renderer, cairo_surface_flush (surface); /* Copy the glyph to the cache */ - value = pango_clutter_glyph_cache_set + value = cogl_pango_glyph_cache_set (glyph_cache, font, glyph, cairo_image_surface_get_data (surface), cairo_image_surface_get_width (surface), @@ -276,7 +264,7 @@ pango_clutter_renderer_get_cached_glyph (PangoRenderer *renderer, } void -pango_clutter_ensure_glyph_cache_for_layout (PangoLayout *layout) +cogl_pango_ensure_glyph_cache_for_layout (PangoLayout *layout) { PangoContext *context; PangoFontMap *fontmap; @@ -287,9 +275,9 @@ pango_clutter_ensure_glyph_cache_for_layout (PangoLayout *layout) context = pango_layout_get_context (layout); fontmap = pango_context_get_font_map (context); - g_return_if_fail (PANGO_CLUTTER_IS_FONT_MAP (fontmap)); - renderer = _pango_clutter_font_map_get_renderer - (PANGO_CLUTTER_FONT_MAP (fontmap)); + g_return_if_fail (COGL_PANGO_IS_FONT_MAP (fontmap)); + renderer = cogl_pango_font_map_get_renderer + (COGL_PANGO_FONT_MAP (fontmap)); if ((iter = pango_layout_get_iter (layout)) == NULL) return; @@ -311,7 +299,7 @@ pango_clutter_ensure_glyph_cache_for_layout (PangoLayout *layout) { PangoGlyphInfo *gi = &glyphs->glyphs[i]; - pango_clutter_renderer_get_cached_glyph (renderer, + cogl_pango_renderer_get_cached_glyph (renderer, run->item->analysis.font, gi->glyph); } @@ -323,84 +311,84 @@ pango_clutter_ensure_glyph_cache_for_layout (PangoLayout *layout) } static void -pango_clutter_renderer_set_color_for_part (PangoRenderer *renderer, +cogl_pango_renderer_set_color_for_part (PangoRenderer *renderer, PangoRenderPart part) { PangoColor *pango_color = pango_renderer_get_color (renderer, part); - PangoClutterRenderer *priv = PANGO_CLUTTER_RENDERER (renderer); - CoglColor clutter_color; + CoglPangoRenderer *priv = COGL_PANGO_RENDERER (renderer); + CoglColor color; if (pango_color) { - cogl_color_set_from_4ub (&clutter_color, + cogl_color_set_from_4ub (&color, pango_color->red >> 8, pango_color->green >> 8, pango_color->blue >> 8, cogl_color_get_alpha_byte (&priv->color)); } else - clutter_color = priv->color; + color = priv->color; - cogl_color (&clutter_color); + cogl_color (&color); } static void -pango_clutter_renderer_draw_box (int x, int y, - int width, int height) +cogl_pango_renderer_draw_box (int x, int y, + int width, int height) { - cogl_path_rectangle (CLUTTER_INT_TO_FIXED (x), - CLUTTER_INT_TO_FIXED (y - height), - CLUTTER_INT_TO_FIXED (width), - CLUTTER_INT_TO_FIXED (height)); + cogl_path_rectangle (COGL_FIXED_FROM_INT (x), + COGL_FIXED_FROM_INT (y - height), + COGL_FIXED_FROM_INT (width), + COGL_FIXED_FROM_INT (height)); cogl_path_stroke (); } static void -pango_clutter_renderer_get_device_units (PangoRenderer *renderer, +cogl_pango_renderer_get_device_units (PangoRenderer *renderer, int xin, int yin, - ClutterFixed *xout, - ClutterFixed *yout) + CoglFixed *xout, + CoglFixed *yout) { const PangoMatrix *matrix; if ((matrix = pango_renderer_get_matrix (renderer))) { /* Convert user-space coords to device coords */ - *xout = CLUTTER_FLOAT_TO_FIXED ((xin * matrix->xx + yin * matrix->xy) - / PANGO_SCALE + matrix->x0); - *yout = CLUTTER_FLOAT_TO_FIXED ((yin * matrix->yy + xin * matrix->yx) - / PANGO_SCALE + matrix->y0); + *xout = COGL_FIXED_FROM_FLOAT ((xin * matrix->xx + yin * matrix->xy) + / PANGO_SCALE + matrix->x0); + *yout = COGL_FIXED_FROM_FLOAT ((yin * matrix->yy + xin * matrix->yx) + / PANGO_SCALE + matrix->y0); } else { - *xout = CLUTTER_PANGO_UNIT_TO_FIXED (xin); - *yout = CLUTTER_PANGO_UNIT_TO_FIXED (yin); + *xout = COGL_PANGO_UNIT_TO_FIXED (xin); + *yout = COGL_PANGO_UNIT_TO_FIXED (yin); } } static void -pango_clutter_renderer_draw_rectangle (PangoRenderer *renderer, +cogl_pango_renderer_draw_rectangle (PangoRenderer *renderer, PangoRenderPart part, int x, int y, int width, int height) { - ClutterFixed x1, x2, y1, y2; + CoglFixed x1, x2, y1, y2; - pango_clutter_renderer_set_color_for_part (renderer, part); + cogl_pango_renderer_set_color_for_part (renderer, part); - pango_clutter_renderer_get_device_units (renderer, x, y, + cogl_pango_renderer_get_device_units (renderer, x, y, &x1, &y1); - pango_clutter_renderer_get_device_units (renderer, x + width, y + height, + cogl_pango_renderer_get_device_units (renderer, x + width, y + height, &x2, &y2); cogl_rectanglex (x1, y1, x2 - x1, y2 - y1); } static void -pango_clutter_renderer_draw_trapezoid (PangoRenderer *renderer, +cogl_pango_renderer_draw_trapezoid (PangoRenderer *renderer, PangoRenderPart part, double y1, double x11, @@ -409,62 +397,65 @@ pango_clutter_renderer_draw_trapezoid (PangoRenderer *renderer, double x12, double x22) { - ClutterFixed points[8]; + CoglFixed points[8]; - points[0] = CLUTTER_FLOAT_TO_FIXED (x11); - points[1] = CLUTTER_FLOAT_TO_FIXED (y1); - points[2] = CLUTTER_FLOAT_TO_FIXED (x12); - points[3] = CLUTTER_FLOAT_TO_FIXED (y2); - points[4] = CLUTTER_FLOAT_TO_FIXED (x22); + points[0] = COGL_FIXED_FROM_FLOAT (x11); + points[1] = COGL_FIXED_FROM_FLOAT (y1); + points[2] = COGL_FIXED_FROM_FLOAT (x12); + points[3] = COGL_FIXED_FROM_FLOAT (y2); + points[4] = COGL_FIXED_FROM_FLOAT (x22); points[5] = points[3]; - points[6] = CLUTTER_FLOAT_TO_FIXED (x21); + points[6] = COGL_FIXED_FROM_FLOAT (x21); points[7] = points[1]; - pango_clutter_renderer_set_color_for_part (renderer, part); + cogl_pango_renderer_set_color_for_part (renderer, part); + cogl_path_polygon (points, 4); cogl_path_fill (); } static void -pango_clutter_renderer_draw_glyphs (PangoRenderer *renderer, +cogl_pango_renderer_draw_glyphs (PangoRenderer *renderer, PangoFont *font, PangoGlyphString *glyphs, int xi, int yi) { - PangoClutterGlyphCacheValue *cache_value; + CoglPangoGlyphCacheValue *cache_value; int i; - pango_clutter_renderer_set_color_for_part (renderer, - PANGO_RENDER_PART_FOREGROUND); + cogl_pango_renderer_set_color_for_part (renderer, + PANGO_RENDER_PART_FOREGROUND); for (i = 0; i < glyphs->num_glyphs; i++) { PangoGlyphInfo *gi = glyphs->glyphs + i; - ClutterFixed x, y; + CoglFixed x, y; - pango_clutter_renderer_get_device_units (renderer, - xi + gi->geometry.x_offset, - yi + gi->geometry.y_offset, - &x, &y); + cogl_pango_renderer_get_device_units (renderer, + xi + gi->geometry.x_offset, + yi + gi->geometry.y_offset, + &x, &y); if ((gi->glyph & PANGO_GLYPH_UNKNOWN_FLAG)) { PangoFontMetrics *metrics; - if (font == NULL - || (metrics = pango_font_get_metrics (font, NULL)) == NULL) - pango_clutter_renderer_draw_box (CLUTTER_FIXED_TO_INT (x), - CLUTTER_FIXED_TO_INT (y), - PANGO_UNKNOWN_GLYPH_WIDTH, - PANGO_UNKNOWN_GLYPH_HEIGHT); + if (font == NULL || + (metrics = pango_font_get_metrics (font, NULL)) == NULL) + { + cogl_pango_renderer_draw_box (COGL_FIXED_TO_INT (x), + COGL_FIXED_TO_INT (y), + PANGO_UNKNOWN_GLYPH_WIDTH, + PANGO_UNKNOWN_GLYPH_HEIGHT); + } else { - pango_clutter_renderer_draw_box (CLUTTER_FIXED_TO_INT (x), - CLUTTER_FIXED_TO_INT (y), - metrics->approximate_char_width - / PANGO_SCALE, - metrics->ascent / PANGO_SCALE); + cogl_pango_renderer_draw_box (COGL_FIXED_TO_INT (x), + COGL_FIXED_TO_INT (y), + metrics->approximate_char_width + / PANGO_SCALE, + metrics->ascent / PANGO_SCALE); pango_font_metrics_unref (metrics); } @@ -473,26 +464,30 @@ pango_clutter_renderer_draw_glyphs (PangoRenderer *renderer, { /* Get the texture containing the glyph. This will create the cache entry if there isn't already one */ - cache_value - = pango_clutter_renderer_get_cached_glyph (renderer, font, - gi->glyph); + cache_value = + cogl_pango_renderer_get_cached_glyph (renderer, + font, + gi->glyph); if (cache_value == NULL) - pango_clutter_renderer_draw_box (CLUTTER_FIXED_TO_INT (x), - CLUTTER_FIXED_TO_INT (y), - PANGO_UNKNOWN_GLYPH_WIDTH, - PANGO_UNKNOWN_GLYPH_HEIGHT); + cogl_pango_renderer_draw_box (COGL_FIXED_TO_INT (x), + COGL_FIXED_TO_INT (y), + PANGO_UNKNOWN_GLYPH_WIDTH, + PANGO_UNKNOWN_GLYPH_HEIGHT); else { - x += CLUTTER_INT_TO_FIXED (cache_value->draw_x); - y += CLUTTER_INT_TO_FIXED (cache_value->draw_y); + CoglFixed width, height; + + x += COGL_FIXED_FROM_INT (cache_value->draw_x); + y += COGL_FIXED_FROM_INT (cache_value->draw_y); + + width = x + COGL_FIXED_FROM_INT (cache_value->draw_width); + height = y + COGL_FIXED_FROM_INT (cache_value->draw_height); /* Render the glyph from the texture */ - cogl_texture_rectangle (cache_value->texture, x, y, - x + CLUTTER_INT_TO_FIXED (cache_value - ->draw_width), - y + CLUTTER_INT_TO_FIXED (cache_value - ->draw_height), + cogl_texture_rectangle (cache_value->texture, + x, y, + width, height, cache_value->tx1, cache_value->ty1, cache_value->tx2, cache_value->ty2); } diff --git a/clutter/pango/cogl-pango.h b/clutter/pango/cogl-pango.h new file mode 100644 index 000000000..58efb5bc0 --- /dev/null +++ b/clutter/pango/cogl-pango.h @@ -0,0 +1,84 @@ +/* + * Clutter. + * + * An OpenGL based 'interactive canvas' library. + * + * Authored By Matthew Allum + * + * Copyright (C) 2008 OpenedHand + * + * 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, see . + */ + +#ifndef __PANGO_CLUTTER_H__ +#define __PANGO_CLUTTER_H__ + +#include +#include +#include + +G_BEGIN_DECLS + +/* It's too difficult to actually subclass the pango cairo font + * map. Instead we just make a fake set of macros that actually just + * directly use the original type + */ +#define COGL_PANGO_TYPE_FONT_MAP PANGO_TYPE_CAIRO_FONT_MAP +#define COGL_PANGO_FONT_MAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), COGL_PANGO_TYPE_FONT_MAP, CoglPangoFontMap)) +#define COGL_PANGO_IS_FONT_MAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), COGL_PANGO_TYPE_FONT_MAP)) + +typedef PangoCairoFontMap CoglPangoFontMap; + +PangoFontMap * cogl_pango_font_map_new (void); +PangoContext * cogl_pango_font_map_create_context (CoglPangoFontMap *fm); +void cogl_pango_font_map_set_resolution (CoglPangoFontMap *font_map, + double dpi); +void cogl_pango_font_map_clear_glyph_cache (CoglPangoFontMap *fm); +void cogl_pango_ensure_glyph_cache_for_layout (PangoLayout *layout); +void cogl_pango_font_map_set_use_mipmapping (CoglPangoFontMap *fm, + gboolean value); +gboolean cogl_pango_font_map_get_use_mipmapping (CoglPangoFontMap *fm); +PangoRenderer *cogl_pango_font_map_get_renderer (CoglPangoFontMap *fm); + +#define COGL_PANGO_TYPE_RENDERER (cogl_pango_renderer_get_type ()) +#define COGL_PANGO_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), COGL_PANGO_TYPE_RENDERER, CoglPangoRenderer)) +#define COGL_PANGO_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), COGL_PANGO_TYPE_RENDERER, CoglPangoRendererClass)) +#define COGL_PANGO_IS_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), COGL_PANGO_TYPE_RENDERER)) +#define COGL_PANGO_IS_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), COGL_PANGO_TYPE_RENDERER)) +#define COGL_PANGO_RENDERER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), COGL_PANGO_TYPE_RENDERER, CoglPangoRendererClass)) + +/* opaque types */ +typedef struct _CoglPangoRenderer CoglPangoRenderer; +typedef struct _CoglPangoRendererClass CoglPangoRendererClass; + +GType cogl_pango_renderer_get_type (void) G_GNUC_CONST; + +void cogl_pango_render_layout_subpixel (PangoLayout *layout, + int x, + int y, + const CoglColor *color, + int flags); +void cogl_pango_render_layout (PangoLayout *layout, + int x, + int y, + const CoglColor *color, + int flags); +void cogl_pango_render_layout_line (PangoLayoutLine *line, + int x, + int y, + const CoglColor *color); + +G_END_DECLS + +#endif /* __PANGO_CLUTTER_H__ */ diff --git a/clutter/pango/pangoclutter-glyph-cache.h b/clutter/pango/pangoclutter-glyph-cache.h deleted file mode 100644 index 904d46b00..000000000 --- a/clutter/pango/pangoclutter-glyph-cache.h +++ /dev/null @@ -1,69 +0,0 @@ -/* - * Clutter. - * - * An OpenGL based 'interactive canvas' library. - * - * Authored By Matthew Allum - * - * Copyright (C) 2008 OpenedHand - * - * 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., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. - */ - -#ifndef _HAVE_PANGO_CLUTTER_GLYPH_CACHE_H -#define _HAVE_PANGO_CLUTTER_GLYPH_CACHE_H - -#include -#include -#include - -G_BEGIN_DECLS - -typedef struct _PangoClutterGlyphCache PangoClutterGlyphCache; -typedef struct _PangoClutterGlyphCacheValue PangoClutterGlyphCacheValue; - -struct _PangoClutterGlyphCacheValue -{ - CoglHandle texture; - CoglFixed tx1, ty1, tx2, ty2; - int draw_x, draw_y, draw_width, draw_height; -}; - -PangoClutterGlyphCache *pango_clutter_glyph_cache_new (gboolean use_mipmapping); - -void pango_clutter_glyph_cache_free (PangoClutterGlyphCache *cache); - -PangoClutterGlyphCacheValue * -pango_clutter_glyph_cache_lookup (PangoClutterGlyphCache *cache, - PangoFont *font, - PangoGlyph glyph); - -PangoClutterGlyphCacheValue * -pango_clutter_glyph_cache_set (PangoClutterGlyphCache *cache, - PangoFont *font, - PangoGlyph glyph, - gconstpointer pixels, - int width, - int height, - int stride, - int draw_x, - int draw_y); - -void pango_clutter_glyph_cache_clear (PangoClutterGlyphCache *cache); - -G_END_DECLS - -#endif /* _HAVE_PANGO_CLUTTER_GLYPH_CACHE_H */ diff --git a/clutter/pango/pangoclutter.h b/clutter/pango/pangoclutter.h deleted file mode 100644 index 1961b5ba8..000000000 --- a/clutter/pango/pangoclutter.h +++ /dev/null @@ -1,110 +0,0 @@ -/* - * Clutter. - * - * An OpenGL based 'interactive canvas' library. - * - * Authored By Matthew Allum - * - * Copyright (C) 2008 OpenedHand - * - * 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., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. - */ - -#ifndef _HAVE_PANGO_CLUTTER_H -#define _HAVE_PANGO_CLUTTER_H - -#include -#include -#include - -G_BEGIN_DECLS - -/* It's too difficult to actually subclass the pango cairo font - map. Instead we just make a fake set of macros that actually just - directly use the original type */ -#define PANGO_CLUTTER_TYPE_FONT_MAP PANGO_TYPE_CAIRO_FONT_MAP - -#define PANGO_CLUTTER_FONT_MAP(obj) \ - (G_TYPE_CHECK_INSTANCE_CAST ((obj), \ - PANGO_CLUTTER_TYPE_FONT_MAP, \ - PangoClutterFontMap)) -#define PANGO_CLUTTER_IS_FONT_MAP(obj) \ - (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \ - PANGO_CLUTTER_TYPE_FONT_MAP)) - -typedef PangoCairoFontMap PangoClutterFontMap; - -PangoFontMap *pango_clutter_font_map_new (void); - -PangoContext *pango_clutter_font_map_create_context (PangoClutterFontMap *fm); - -void pango_clutter_font_map_set_resolution (PangoClutterFontMap *font_map, - double dpi); - -void pango_clutter_font_map_clear_glyph_cache (PangoClutterFontMap *fm); - -void pango_clutter_font_map_set_use_mipmapping (PangoClutterFontMap *fm, - gboolean value); -gboolean pango_clutter_font_map_get_use_mipmapping (PangoClutterFontMap *fm); - -void pango_clutter_ensure_glyph_cache_for_layout (PangoLayout *layout); - -#define PANGO_CLUTTER_TYPE_RENDERER (pango_clutter_renderer_get_type ()) - -#define PANGO_CLUTTER_RENDERER(obj) \ - (G_TYPE_CHECK_INSTANCE_CAST ((obj), \ - PANGO_CLUTTER_TYPE_RENDERER, \ - PangoClutterRenderer)) -#define PANGO_CLUTTER_RENDERER_CLASS(klass) \ - (G_TYPE_CHECK_CLASS_CAST ((klass), \ - PANGO_CLUTTER_TYPE_RENDERER, \ - PangoClutterRendererClass)) -#define PANGO_CLUTTER_IS_RENDERER(obj) \ - (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \ - PANGO_CLUTTER_TYPE_RENDERER)) -#define PANGO_CLUTTER_IS_RENDERER_CLASS(klass) \ - (G_TYPE_CHECK_CLASS_TYPE ((klass), \ - PANGO_CLUTTER_TYPE_RENDERER)) -#define PANGO_CLUTTER_RENDERER_GET_CLASS(obj) \ - (G_TYPE_INSTANCE_GET_CLASS ((obj), \ - PANGO_CLUTTER_TYPE_RENDERER, \ - PangoClutterRendererClass)) - -typedef struct _PangoClutterRenderer PangoClutterRenderer; -typedef struct _PangoClutterRendererClass PangoClutterRendererClass; - -GType pango_clutter_renderer_get_type (void) G_GNUC_CONST; - -void pango_clutter_render_layout_subpixel (PangoLayout *layout, - int x, - int y, - ClutterColor *color, - int flags); - -void pango_clutter_render_layout (PangoLayout *layout, - int x, - int y, - ClutterColor *color, - int flags); - -void pango_clutter_render_layout_line (PangoLayoutLine *line, - int x, - int y, - ClutterColor *color); - -G_END_DECLS - -#endif /* _HAVE_PANGO_CLUTTER_H */