sungmg/mutter-performance-source
1
0
Fork 0
Code Activity

cogl-pango: Updates to no longer require a default context

Browse source 
This updates the Cogl Pango api to no longer require a default context
and also cleans up the public api a bit.

The CoglPangoRenderer type has been made private to be
consistent with other pango backends where the renderer is merely an
implementation detail.

The drawing apis such as cogl_pango_render_layout where made more
consistent with other pango backend apis so we now have replacements
like cogl_pango_show_layout().

Reviewed-by: Neil Roberts <neil@linux.intel.com>

(cherry picked from commit bba2defe8c08a498b2dcb84bcf5b5a33f16eed27)

Note: API changes were reverting in cherry-picking this patch
This commit is contained in:
Robert Bragg 2012-05-10 12:16:03 +01:00
parent cd7b15b7df
commit 579db9083d
8 changed files with 552 additions and 299 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

55
cogl-pango/cogl-pango-display-list.c
View file

@ -236,17 +236,24 @@ _cogl_pango_display_list_add_trapezoid (CoglPangoDisplayList *dl,
} }
static void static void
emit_rectangles_through_journal (CoglPangoDisplayListNode *node) emit_rectangles_through_journal (CoglFramebuffer *fb,
CoglPipeline *pipeline,
CoglPangoDisplayListNode *node)
{ {
cogl_rectangles_with_texture_coords ((float *) const float *rectangles = (const float *)node->d.texture.rectangles->data;
node->d.texture.rectangles->data,
node->d.texture.rectangles->len); cogl_framebuffer_draw_textured_rectangles (fb,
pipeline,
rectangles,
node->d.texture.rectangles->len);
} }
static void static void
emit_vertex_buffer_geometry (CoglPangoDisplayListNode *node) emit_vertex_buffer_geometry (CoglFramebuffer *fb,
CoglPipeline *pipeline,
CoglPangoDisplayListNode *node)
{ {
_COGL_GET_CONTEXT (ctx, NO_RETVAL); CoglContext *ctx = fb->context;
/* It's expensive to go through the Cogl journal for large runs /* It's expensive to go through the Cogl journal for large runs
* of text in part because the journal transforms the quads in software * of text in part because the journal transforms the quads in software
@ -366,13 +373,15 @@ emit_vertex_buffer_geometry (CoglPangoDisplayListNode *node)
cogl_object_unref (attributes[1]); cogl_object_unref (attributes[1]);
} }
cogl_framebuffer_draw_primitive (cogl_get_draw_framebuffer (), cogl_framebuffer_draw_primitive (fb,
cogl_get_source (), pipeline,
node->d.texture.primitive); node->d.texture.primitive);
} }
static void static void
_cogl_pango_display_list_render_texture (CoglPangoDisplayListNode *node) _cogl_framebuffer_draw_display_list_texture (CoglFramebuffer *fb,
CoglPipeline *pipeline,
CoglPangoDisplayListNode *node)
{ {
/* For small runs of text like icon labels, we can get better performance /* For small runs of text like icon labels, we can get better performance
* going through the Cogl journal since text may then be batched together * going through the Cogl journal since text may then be batched together
@ -380,13 +389,14 @@ _cogl_pango_display_list_render_texture (CoglPangoDisplayListNode *node)
/* FIXME: 25 is a number I plucked out of thin air; it would be good /* FIXME: 25 is a number I plucked out of thin air; it would be good
* to determine this empirically! */ * to determine this empirically! */
if (node->d.texture.rectangles->len < 25) if (node->d.texture.rectangles->len < 25)
emit_rectangles_through_journal (node); emit_rectangles_through_journal (fb, pipeline, node);
else else
emit_vertex_buffer_geometry (node); emit_vertex_buffer_geometry (fb, pipeline, node);
} }
void void
_cogl_pango_display_list_render (CoglPangoDisplayList *dl, _cogl_pango_display_list_render (CoglFramebuffer *fb,
CoglPangoDisplayList *dl,
const CoglColor *color) const CoglColor *color)
{ {
GSList *l; GSList *l;
@ -421,28 +431,27 @@ _cogl_pango_display_list_render (CoglPangoDisplayList *dl,
cogl_color_premultiply (&draw_color); cogl_color_premultiply (&draw_color);
cogl_pipeline_set_color (node->pipeline, &draw_color); cogl_pipeline_set_color (node->pipeline, &draw_color);
cogl_push_source (node->pipeline);
switch (node->type) switch (node->type)
{ {
case COGL_PANGO_DISPLAY_LIST_TEXTURE: case COGL_PANGO_DISPLAY_LIST_TEXTURE:
_cogl_pango_display_list_render_texture (node); _cogl_framebuffer_draw_display_list_texture (fb, node->pipeline, node);
break; break;
case COGL_PANGO_DISPLAY_LIST_RECTANGLE: case COGL_PANGO_DISPLAY_LIST_RECTANGLE:
cogl_rectangle (node->d.rectangle.x_1, cogl_framebuffer_draw_rectangle (fb,
node->d.rectangle.y_1, node->pipeline,
node->d.rectangle.x_2, node->d.rectangle.x_1,
node->d.rectangle.y_2); node->d.rectangle.y_1,
node->d.rectangle.x_2,
node->d.rectangle.y_2);
break; break;
case COGL_PANGO_DISPLAY_LIST_TRAPEZOID: case COGL_PANGO_DISPLAY_LIST_TRAPEZOID:
{ {
CoglFramebuffer *framebuffer = cogl_get_draw_framebuffer ();
float points[8]; float points[8];
CoglPath *path; CoglPath *path;
CoglContext *ctx = fb->context;
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
points[0] = node->d.trapezoid.x_11; points[0] = node->d.trapezoid.x_11;
points[1] = node->d.trapezoid.y_1; points[1] = node->d.trapezoid.y_1;
@ -455,13 +464,11 @@ _cogl_pango_display_list_render (CoglPangoDisplayList *dl,
path = cogl_path_new (); path = cogl_path_new ();
cogl_path_polygon (path, points, 4); cogl_path_polygon (path, points, 4);
cogl_framebuffer_fill_path (framebuffer, node->pipeline, path); cogl_framebuffer_fill_path (fb, node->pipeline, path);
cogl_object_unref (path); cogl_object_unref (path);
} }
break; break;
} }
cogl_pop_source ();
} }
} }

59
cogl-pango/cogl-pango-display-list.h
View file

@ -32,37 +32,48 @@ COGL_BEGIN_DECLS
typedef struct _CoglPangoDisplayList CoglPangoDisplayList; typedef struct _CoglPangoDisplayList CoglPangoDisplayList;
CoglPangoDisplayList *_cogl_pango_display_list_new (CoglPangoPipelineCache *); CoglPangoDisplayList *
_cogl_pango_display_list_new (CoglPangoPipelineCache *);
void _cogl_pango_display_list_set_color_override (CoglPangoDisplayList *dl, void
const CoglColor *color); _cogl_pango_display_list_set_color_override (CoglPangoDisplayList *dl,
void _cogl_pango_display_list_remove_color_override (CoglPangoDisplayList *dl); const CoglColor *color);
void _cogl_pango_display_list_add_texture (CoglPangoDisplayList *dl, void
CoglTexture *texture, _cogl_pango_display_list_remove_color_override (CoglPangoDisplayList *dl);
float x_1, float y_1,
float x_2, float y_2,
float tx_1, float ty_1,
float tx_2, float ty_2);
void _cogl_pango_display_list_add_rectangle (CoglPangoDisplayList *dl, void
float x_1, float y_1, _cogl_pango_display_list_add_texture (CoglPangoDisplayList *dl,
float x_2, float y_2); CoglTexture *texture,
float x_1, float y_1,
float x_2, float y_2,
float tx_1, float ty_1,
float tx_2, float ty_2);
void _cogl_pango_display_list_add_trapezoid (CoglPangoDisplayList *dl, void
float y_1, _cogl_pango_display_list_add_rectangle (CoglPangoDisplayList *dl,
float x_11, float x_1, float y_1,
float x_21, float x_2, float y_2);
float y_2,
float x_12,
float x_22);
void _cogl_pango_display_list_render (CoglPangoDisplayList *dl, void
const CoglColor *color); _cogl_pango_display_list_add_trapezoid (CoglPangoDisplayList *dl,
float y_1,
float x_11,
float x_21,
float y_2,
float x_12,
float x_22);
void _cogl_pango_display_list_clear (CoglPangoDisplayList *dl); void
_cogl_pango_display_list_render (CoglFramebuffer *framebuffer,
CoglPangoDisplayList *dl,
const CoglColor *color);
void _cogl_pango_display_list_free (CoglPangoDisplayList *dl); void
_cogl_pango_display_list_clear (CoglPangoDisplayList *dl);
void
_cogl_pango_display_list_free (CoglPangoDisplayList *dl);
COGL_END_DECLS COGL_END_DECLS

182
cogl-pango/cogl-pango-fontmap.c
View file

@ -45,165 +45,131 @@
#include "cogl-pango.h" #include "cogl-pango.h"
#include "cogl-pango-private.h" #include "cogl-pango-private.h"
#include "cogl-util.h"
#include "cogl/cogl-context-private.h"
static GQuark cogl_pango_font_map_get_renderer_key (void) G_GNUC_CONST; static GQuark cogl_pango_font_map_get_priv_key (void) G_GNUC_CONST;
typedef struct _CoglPangoFontMapPriv
{
CoglContext *ctx;
PangoRenderer *renderer;
} CoglPangoFontMapPriv;
static void
free_priv (gpointer data)
{
CoglPangoFontMapPriv *priv = data;
cogl_object_unref (priv->ctx);
cogl_object_unref (priv->renderer);
g_free (priv);
}
/**
* cogl_pango_font_map_new:
*
* Creates a new font map.
*
* Return value: (transfer full): the newly created #PangoFontMap
*
* Since: 1.0
*/
PangoFontMap * PangoFontMap *
cogl_pango_font_map_new (void) cogl_pango_font_map_new (void)
{ {
return pango_cairo_font_map_new (); PangoFontMap *fm = pango_cairo_font_map_new ();
CoglPangoFontMapPriv *priv = g_new0 (CoglPangoFontMapPriv, 1);
_COGL_GET_CONTEXT (context, NULL);
priv->ctx = cogl_object_ref (context);
/* XXX: The public pango api doesn't let us sub-class
* PangoCairoFontMap so we attach our own private data using qdata
* for now. */
g_object_set_qdata_full (G_OBJECT (fm),
cogl_pango_font_map_get_priv_key (),
priv,
free_priv);
return fm;
} }
/**
* cogl_pango_font_map_create_context:
* @fm: a #CoglPangoFontMap
*
* Creates a new #PangoContext from the passed font map.
*
* Return value: (transfer full): the newly created #PangoContext
*
* Since: 1.0
*/
PangoContext * PangoContext *
cogl_pango_font_map_create_context (CoglPangoFontMap *fm) cogl_pango_font_map_create_context (CoglPangoFontMap *fm)
{ {
g_return_val_if_fail (COGL_PANGO_IS_FONT_MAP (fm), NULL); _COGL_RETURN_VAL_IF_FAIL (COGL_PANGO_IS_FONT_MAP (fm), NULL);
/* We can just directly use the pango context from the Cairo font /* We can just directly use the pango context from the Cairo font
map */ map */
return pango_cairo_font_map_create_context (PANGO_CAIRO_FONT_MAP (fm)); return pango_cairo_font_map_create_context (PANGO_CAIRO_FONT_MAP (fm));
} }
/** static CoglPangoFontMapPriv *
* cogl_pango_font_map_get_renderer: _cogl_pango_font_map_get_priv (CoglPangoFontMap *fm)
* @fm: a #CoglPangoFontMap {
* return g_object_get_qdata (G_OBJECT (fm),
* Retrieves the #CoglPangoRenderer for the passed font map. cogl_pango_font_map_get_priv_key ());
* }
* Return value: (transfer none): a #PangoRenderer
* PangoRenderer *
* Since: 1.0 _cogl_pango_font_map_get_renderer (CoglPangoFontMap *fm)
*/ {
CoglPangoFontMapPriv *priv = _cogl_pango_font_map_get_priv (fm);
if (G_UNLIKELY (!priv->renderer))
priv->renderer = _cogl_pango_renderer_new (priv->ctx);
return priv->renderer;
}
PangoRenderer * PangoRenderer *
cogl_pango_font_map_get_renderer (CoglPangoFontMap *fm) cogl_pango_font_map_get_renderer (CoglPangoFontMap *fm)
{ {
PangoRenderer *renderer; return _cogl_pango_font_map_get_renderer (fm);
}
g_return_val_if_fail (COGL_PANGO_IS_FONT_MAP (fm), NULL);
CoglContext *
/* We want to keep a cached pointer to the renderer from the font _cogl_pango_font_map_get_cogl_context (CoglPangoFontMap *fm)
map instance but as we don't have a proper subclass we have to {
store it in the object data instead */ CoglPangoFontMapPriv *priv = _cogl_pango_font_map_get_priv (fm);
return priv->ctx;
renderer = g_object_get_qdata (G_OBJECT (fm),
cogl_pango_font_map_get_renderer_key ());
if (G_UNLIKELY (renderer == NULL))
{
renderer = g_object_new (COGL_PANGO_TYPE_RENDERER, NULL);
g_object_set_qdata_full (G_OBJECT (fm),
cogl_pango_font_map_get_renderer_key (),
renderer,
g_object_unref);
}
return renderer;
} }
/**
* cogl_pango_font_map_set_resolution:
* @font_map: a #CoglPangoFontMap
* @dpi: DPI to set
*
* Sets the resolution to be used by @font_map at @dpi.
*
* Since: 1.0
*/
void void
cogl_pango_font_map_set_resolution (CoglPangoFontMap *font_map, cogl_pango_font_map_set_resolution (CoglPangoFontMap *font_map,
double dpi) double dpi)
{ {
g_return_if_fail (COGL_PANGO_IS_FONT_MAP (font_map)); _COGL_RETURN_IF_FAIL (COGL_PANGO_IS_FONT_MAP (font_map));
pango_cairo_font_map_set_resolution (PANGO_CAIRO_FONT_MAP (font_map), dpi); pango_cairo_font_map_set_resolution (PANGO_CAIRO_FONT_MAP (font_map), dpi);
} }
/**
* cogl_pango_font_map_clear_glyph_cache:
* @fm: a #CoglPangoFontMap
*
* Clears the glyph cache for @fm.
*
* Since: 1.0
*/
void void
cogl_pango_font_map_clear_glyph_cache (CoglPangoFontMap *fm) cogl_pango_font_map_clear_glyph_cache (CoglPangoFontMap *fm)
{ {
PangoRenderer *renderer; PangoRenderer *renderer = _cogl_pango_font_map_get_renderer (fm);
renderer = cogl_pango_font_map_get_renderer (fm);
_cogl_pango_renderer_clear_glyph_cache (COGL_PANGO_RENDERER (renderer)); _cogl_pango_renderer_clear_glyph_cache (COGL_PANGO_RENDERER (renderer));
} }
/**
* cogl_pango_font_map_set_use_mipmapping:
* @fm: a #CoglPangoFontMap
* @value: %TRUE to enable the use of mipmapping
*
* Sets whether the renderer for the passed font map should use
* mipmapping when rendering a #PangoLayout.
*
* Since: 1.0
*/
void void
cogl_pango_font_map_set_use_mipmapping (CoglPangoFontMap *fm, cogl_pango_font_map_set_use_mipmapping (CoglPangoFontMap *fm,
CoglBool value) CoglBool value)
{ {
CoglPangoRenderer *renderer; PangoRenderer *renderer = _cogl_pango_font_map_get_renderer (fm);
renderer = COGL_PANGO_RENDERER (cogl_pango_font_map_get_renderer (fm)); _cogl_pango_renderer_set_use_mipmapping (COGL_PANGO_RENDERER (renderer),
value);
_cogl_pango_renderer_set_use_mipmapping (renderer, value);
} }
/**
* cogl_pango_font_map_get_use_mipmapping:
* @fm: a #CoglPangoFontMap
*
* Retrieves whether the #CoglPangoRenderer used by @fm will
* use mipmapping when rendering the glyphs.
*
* Return value: %TRUE if mipmapping is used, %FALSE otherwise.
*
* Since: 1.0
*/
CoglBool CoglBool
cogl_pango_font_map_get_use_mipmapping (CoglPangoFontMap *fm) cogl_pango_font_map_get_use_mipmapping (CoglPangoFontMap *fm)
{ {
CoglPangoRenderer *renderer; PangoRenderer *renderer = _cogl_pango_font_map_get_renderer (fm);
renderer = COGL_PANGO_RENDERER (cogl_pango_font_map_get_renderer (fm)); return
_cogl_pango_renderer_get_use_mipmapping (COGL_PANGO_RENDERER (renderer));
return _cogl_pango_renderer_get_use_mipmapping (renderer);
} }
static GQuark static GQuark
cogl_pango_font_map_get_renderer_key (void) cogl_pango_font_map_get_priv_key (void)
{ {
static GQuark renderer_key = 0; static GQuark priv_key = 0;
if (G_UNLIKELY (renderer_key == 0)) if (G_UNLIKELY (priv_key == 0))
renderer_key = g_quark_from_static_string ("CoglPangoFontMap"); priv_key = g_quark_from_static_string ("CoglPangoFontMap");
return renderer_key; return priv_key;
} }

18
cogl-pango/cogl-pango-pipeline-cache.c
View file

@ -39,6 +39,8 @@ typedef struct _CoglPangoPipelineCacheEntry CoglPangoPipelineCacheEntry;
struct _CoglPangoPipelineCache struct _CoglPangoPipelineCache
{ {
CoglContext *ctx;
GHashTable *hash_table; GHashTable *hash_table;
CoglPipeline *base_texture_alpha_pipeline; CoglPipeline *base_texture_alpha_pipeline;
@ -79,10 +81,13 @@ _cogl_pango_pipeline_cache_value_destroy (void *data)
} }
CoglPangoPipelineCache * CoglPangoPipelineCache *
_cogl_pango_pipeline_cache_new (CoglBool use_mipmapping) _cogl_pango_pipeline_cache_new (CoglContext *ctx,
CoglBool use_mipmapping)
{ {
CoglPangoPipelineCache *cache = g_new (CoglPangoPipelineCache, 1); CoglPangoPipelineCache *cache = g_new (CoglPangoPipelineCache, 1);
cache->ctx = cogl_object_ref (ctx);
/* The key is the pipeline pointer. A reference is taken when the /* The key is the pipeline pointer. A reference is taken when the
pipeline is used as a key so we should unref it again in the pipeline is used as a key so we should unref it again in the
destroy function */ destroy function */
@ -107,9 +112,8 @@ get_base_texture_rgba_pipeline (CoglPangoPipelineCache *cache)
{ {
CoglPipeline *pipeline; CoglPipeline *pipeline;
_COGL_GET_CONTEXT (ctx, NULL); pipeline = cache->base_texture_rgba_pipeline =
cogl_pipeline_new (cache->ctx);
pipeline = cache->base_texture_rgba_pipeline = cogl_pipeline_new (ctx);
cogl_pipeline_set_layer_wrap_mode (pipeline, 0, cogl_pipeline_set_layer_wrap_mode (pipeline, 0,
COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE); COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE);
@ -205,10 +209,8 @@ _cogl_pango_pipeline_cache_get (CoglPangoPipelineCache *cache,
} }
else else
{ {
_COGL_GET_CONTEXT (ctx, NULL);
entry->texture = NULL; entry->texture = NULL;
entry->pipeline = cogl_pipeline_new (ctx); entry->pipeline = cogl_pipeline_new (cache->ctx);
} }
/* Add a weak reference to the pipeline so we can remove it from the /* Add a weak reference to the pipeline so we can remove it from the
@ -240,5 +242,7 @@ _cogl_pango_pipeline_cache_free (CoglPangoPipelineCache *cache)
g_hash_table_destroy (cache->hash_table); g_hash_table_destroy (cache->hash_table);
cogl_object_unref (cache->ctx);
g_free (cache); g_free (cache);
} }

3
cogl-pango/cogl-pango-pipeline-cache.h
View file

@ -36,7 +36,8 @@ COGL_BEGIN_DECLS
typedef struct _CoglPangoPipelineCache CoglPangoPipelineCache; typedef struct _CoglPangoPipelineCache CoglPangoPipelineCache;
CoglPangoPipelineCache * CoglPangoPipelineCache *
_cogl_pango_pipeline_cache_new (CoglBool use_mipmapping); _cogl_pango_pipeline_cache_new (CoglContext *ctx,
CoglBool use_mipmapping);
/* Returns a pipeline that can be used to render glyphs in the given /* Returns a pipeline that can be used to render glyphs in the given
texture. The pipeline has a new reference so it is up to the caller texture. The pipeline has a new reference so it is up to the caller

39
cogl-pango/cogl-pango-private.h
View file

@ -1,11 +1,10 @@
/* /*
* Clutter. * Cogl
* *
* An OpenGL based 'interactive canvas' library. * An object oriented GL/GLES Abstraction/Utility Layer
*
* Authored By Matthew Allum <mallum@openedhand.com>
* *
* Copyright (C) 2008 OpenedHand * Copyright (C) 2008 OpenedHand
* Copyright (C) 2012 Intel Corporation.
* *
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
@ -18,7 +17,14 @@
* Lesser General Public License for more details. * Lesser General Public License for more details.
* *
* You should have received a copy of the GNU Lesser General Public * You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>. * License along with this library. If not, see
* <http://www.gnu.org/licenses/>.
*
*
* Authors:
* Neil Roberts <neil@linux.intel.com>
* Robert Bragg <robert@linux.intel.com>
* Matthew Allum <mallum@openedhand.com>
*/ */
#ifndef __COGL_PANGO_PRIVATE_H__ #ifndef __COGL_PANGO_PRIVATE_H__
@ -28,10 +34,25 @@
COGL_BEGIN_DECLS COGL_BEGIN_DECLS
void _cogl_pango_renderer_clear_glyph_cache (CoglPangoRenderer *renderer); PangoRenderer *
void _cogl_pango_renderer_set_use_mipmapping (CoglPangoRenderer *renderer, _cogl_pango_renderer_new (CoglContext *context);
CoglBool value);
CoglBool _cogl_pango_renderer_get_use_mipmapping (CoglPangoRenderer *renderer); void
_cogl_pango_renderer_clear_glyph_cache (CoglPangoRenderer *renderer);
void
_cogl_pango_renderer_set_use_mipmapping (CoglPangoRenderer *renderer,
CoglBool value);
CoglBool
_cogl_pango_renderer_get_use_mipmapping (CoglPangoRenderer *renderer);
CoglContext *
_cogl_pango_font_map_get_cogl_context (CoglPangoFontMap *fm);
PangoRenderer *
_cogl_pango_font_map_get_renderer (CoglPangoFontMap *fm);
COGL_END_DECLS COGL_END_DECLS

268
cogl-pango/cogl-pango-render.c
View file

@ -1,11 +1,10 @@
/* /*
* Clutter. * Cogl
* *
* An OpenGL based 'interactive canvas' library. * An object oriented GL/GLES Abstraction/Utility Layer
*
* Authored By Matthew Allum <mallum@openedhand.com>
* *
* Copyright (C) 2008 OpenedHand * Copyright (C) 2008 OpenedHand
* Copyright (C) 2012 Intel Corporation.
* *
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
@ -18,7 +17,14 @@
* Lesser General Public License for more details. * Lesser General Public License for more details.
* *
* You should have received a copy of the GNU Lesser General Public * You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>. * License along with this library. If not, see
* <http://www.gnu.org/licenses/>.
*
*
* Authors:
* Neil Roberts <neil@linux.intel.com>
* Robert Bragg <robert@linux.intel.com>
* Matthew Allum <mallum@openedhand.com>
*/ */
#ifdef HAVE_CONFIG_H #ifdef HAVE_CONFIG_H
@ -41,6 +47,14 @@
#include "cogl-pango-glyph-cache.h" #include "cogl-pango-glyph-cache.h"
#include "cogl-pango-display-list.h" #include "cogl-pango-display-list.h"
enum
{
PROP_0,
PROP_COGL_CONTEXT,
PROP_LAST
};
typedef struct typedef struct
{ {
CoglPangoGlyphCache *glyph_cache; CoglPangoGlyphCache *glyph_cache;
@ -51,6 +65,8 @@ struct _CoglPangoRenderer
{ {
PangoRenderer parent_instance; PangoRenderer parent_instance;
CoglContext *ctx;
/* Two caches of glyphs as textures and their corresponding pipeline /* Two caches of glyphs as textures and their corresponding pipeline
caches, one with mipmapped textures and one without */ caches, one with mipmapped textures and one without */
CoglPangoRendererCaches no_mipmap_caches; CoglPangoRendererCaches no_mipmap_caches;
@ -67,11 +83,11 @@ struct _CoglPangoRendererClass
PangoRendererClass class_instance; PangoRendererClass class_instance;
}; };
typedef struct _CoglPangoRendererQdata CoglPangoRendererQdata; typedef struct _CoglPangoLayoutQdata CoglPangoLayoutQdata;
/* An instance of this struct gets attached to each PangoLayout to /* An instance of this struct gets attached to each PangoLayout to
cache the VBO and to detect changes to the layout */ cache the VBO and to detect changes to the layout */
struct _CoglPangoRendererQdata struct _CoglPangoLayoutQdata
{ {
CoglPangoRenderer *renderer; CoglPangoRenderer *renderer;
/* The cache of the geometry for the layout */ /* The cache of the geometry for the layout */
@ -94,6 +110,13 @@ typedef struct
float x1, y1, x2, y2; float x1, y1, x2, y2;
} CoglPangoRendererSliceCbData; } CoglPangoRendererSliceCbData;
PangoRenderer *
_cogl_pango_renderer_new (CoglContext *context)
{
return PANGO_RENDERER (g_object_new (COGL_PANGO_TYPE_RENDERER,
"context", context, NULL));
}
static void static void
cogl_pango_renderer_slice_cb (CoglTexture *texture, cogl_pango_renderer_slice_cb (CoglTexture *texture,
const float *slice_coords, const float *slice_coords,
@ -126,7 +149,7 @@ cogl_pango_renderer_draw_glyph (CoglPangoRenderer *priv,
{ {
CoglPangoRendererSliceCbData data; CoglPangoRendererSliceCbData data;
g_return_if_fail (priv->display_list != NULL); _COGL_RETURN_IF_FAIL (priv->display_list != NULL);
data.display_list = priv->display_list; data.display_list = priv->display_list;
data.x1 = x1; data.x1 = x1;
@ -151,6 +174,7 @@ cogl_pango_renderer_draw_glyph (CoglPangoRenderer *priv,
&data); &data);
} }
static void cogl_pango_renderer_dispose (GObject *object);
static void cogl_pango_renderer_finalize (GObject *object); static void cogl_pango_renderer_finalize (GObject *object);
static void cogl_pango_renderer_draw_glyphs (PangoRenderer *renderer, static void cogl_pango_renderer_draw_glyphs (PangoRenderer *renderer,
PangoFont *font, PangoFont *font,
@ -177,15 +201,46 @@ G_DEFINE_TYPE (CoglPangoRenderer, cogl_pango_renderer, PANGO_TYPE_RENDERER);
static void static void
cogl_pango_renderer_init (CoglPangoRenderer *priv) cogl_pango_renderer_init (CoglPangoRenderer *priv)
{ {
priv->no_mipmap_caches.pipeline_cache = }
_cogl_pango_pipeline_cache_new (FALSE);
priv->mipmap_caches.pipeline_cache =
_cogl_pango_pipeline_cache_new (TRUE);
priv->no_mipmap_caches.glyph_cache = cogl_pango_glyph_cache_new (FALSE); static void
priv->mipmap_caches.glyph_cache = cogl_pango_glyph_cache_new (TRUE); _cogl_pango_renderer_constructed (GObject *gobject)
{
CoglPangoRenderer *renderer = COGL_PANGO_RENDERER (gobject);
CoglContext *ctx = renderer->ctx;
_cogl_pango_renderer_set_use_mipmapping (priv, FALSE); renderer->no_mipmap_caches.pipeline_cache =
_cogl_pango_pipeline_cache_new (ctx, FALSE);
renderer->mipmap_caches.pipeline_cache =
_cogl_pango_pipeline_cache_new (ctx, TRUE);
renderer->no_mipmap_caches.glyph_cache = cogl_pango_glyph_cache_new (FALSE);
renderer->mipmap_caches.glyph_cache = cogl_pango_glyph_cache_new (TRUE);
_cogl_pango_renderer_set_use_mipmapping (renderer, FALSE);
if (G_OBJECT_CLASS (cogl_pango_renderer_parent_class)->constructed)
G_OBJECT_CLASS (cogl_pango_renderer_parent_class)->constructed (gobject);
}
static void
cogl_pango_renderer_set_property (GObject *object,
unsigned int prop_id,
const GValue *value,
GParamSpec *pspec)
{
CoglPangoRenderer *renderer = COGL_PANGO_RENDERER (object);
switch (prop_id)
{
case PROP_COGL_CONTEXT:
renderer->ctx = g_value_get_pointer (value);
cogl_object_ref (renderer->ctx);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
} }
static void static void
@ -193,14 +248,39 @@ cogl_pango_renderer_class_init (CoglPangoRendererClass *klass)
{ {
GObjectClass *object_class = G_OBJECT_CLASS (klass); GObjectClass *object_class = G_OBJECT_CLASS (klass);
PangoRendererClass *renderer_class = PANGO_RENDERER_CLASS (klass); PangoRendererClass *renderer_class = PANGO_RENDERER_CLASS (klass);
GParamSpec *pspec;
object_class->set_property = cogl_pango_renderer_set_property;
object_class->constructed = _cogl_pango_renderer_constructed;
object_class->dispose = cogl_pango_renderer_dispose;
object_class->finalize = cogl_pango_renderer_finalize; object_class->finalize = cogl_pango_renderer_finalize;
pspec = g_param_spec_pointer ("context",
"Context",
"The Cogl Context",
G_PARAM_WRITABLE |
G_PARAM_STATIC_STRINGS |
G_PARAM_CONSTRUCT_ONLY);
g_object_class_install_property (object_class, PROP_COGL_CONTEXT, pspec);
renderer_class->draw_glyphs = cogl_pango_renderer_draw_glyphs; renderer_class->draw_glyphs = cogl_pango_renderer_draw_glyphs;
renderer_class->draw_rectangle = cogl_pango_renderer_draw_rectangle; renderer_class->draw_rectangle = cogl_pango_renderer_draw_rectangle;
renderer_class->draw_trapezoid = cogl_pango_renderer_draw_trapezoid; renderer_class->draw_trapezoid = cogl_pango_renderer_draw_trapezoid;
} }
static void
cogl_pango_renderer_dispose (GObject *object)
{
CoglPangoRenderer *priv = COGL_PANGO_RENDERER (object);
if (priv->ctx)
{
cogl_object_unref (priv->ctx);
priv->ctx = NULL;
}
}
static void static void
cogl_pango_renderer_finalize (GObject *object) cogl_pango_renderer_finalize (GObject *object)
{ {
@ -218,22 +298,24 @@ cogl_pango_renderer_finalize (GObject *object)
static CoglPangoRenderer * static CoglPangoRenderer *
cogl_pango_get_renderer_from_context (PangoContext *context) cogl_pango_get_renderer_from_context (PangoContext *context)
{ {
PangoFontMap *font_map; PangoFontMap *font_map;
PangoRenderer *renderer; CoglPangoFontMap *cogl_font_map;
CoglPangoFontMap *font_map_priv; PangoRenderer *renderer;
font_map = pango_context_get_font_map (context); font_map = pango_context_get_font_map (context);
g_return_val_if_fail (COGL_PANGO_IS_FONT_MAP (font_map), NULL); g_return_val_if_fail (COGL_PANGO_IS_FONT_MAP (font_map), NULL);
font_map_priv = COGL_PANGO_FONT_MAP (font_map); cogl_font_map = COGL_PANGO_FONT_MAP (font_map);
renderer = cogl_pango_font_map_get_renderer (font_map_priv);
renderer = _cogl_pango_font_map_get_renderer (cogl_font_map);
g_return_val_if_fail (COGL_PANGO_IS_RENDERER (renderer), NULL); g_return_val_if_fail (COGL_PANGO_IS_RENDERER (renderer), NULL);
return COGL_PANGO_RENDERER (renderer); return COGL_PANGO_RENDERER (renderer);
} }
static GQuark static GQuark
cogl_pango_render_get_qdata_key (void) cogl_pango_layout_get_qdata_key (void)
{ {
static GQuark key = 0; static GQuark key = 0;
@ -244,7 +326,7 @@ cogl_pango_render_get_qdata_key (void)
} }
static void static void
cogl_pango_render_qdata_forget_display_list (CoglPangoRendererQdata *qdata) cogl_pango_layout_qdata_forget_display_list (CoglPangoLayoutQdata *qdata)
{ {
if (qdata->display_list) if (qdata->display_list)
{ {
@ -254,7 +336,7 @@ cogl_pango_render_qdata_forget_display_list (CoglPangoRendererQdata *qdata)
_cogl_pango_glyph_cache_remove_reorganize_callback _cogl_pango_glyph_cache_remove_reorganize_callback
(caches->glyph_cache, (caches->glyph_cache,
(GHookFunc) cogl_pango_render_qdata_forget_display_list, (GHookFunc) cogl_pango_layout_qdata_forget_display_list,
qdata); qdata);
_cogl_pango_display_list_free (qdata->display_list); _cogl_pango_display_list_free (qdata->display_list);
@ -264,36 +346,24 @@ cogl_pango_render_qdata_forget_display_list (CoglPangoRendererQdata *qdata)
} }
static void static void
cogl_pango_render_qdata_destroy (CoglPangoRendererQdata *qdata) cogl_pango_render_qdata_destroy (CoglPangoLayoutQdata *qdata)
{ {
cogl_pango_render_qdata_forget_display_list (qdata); cogl_pango_layout_qdata_forget_display_list (qdata);
if (qdata->first_line) if (qdata->first_line)
pango_layout_line_unref (qdata->first_line); pango_layout_line_unref (qdata->first_line);
g_slice_free (CoglPangoRendererQdata, qdata); g_slice_free (CoglPangoLayoutQdata, qdata);
} }
/**
* cogl_pango_render_layout_subpixel:
* @layout: a #PangoLayout
* @x: FIXME
* @y: FIXME
* @color: color to use when rendering the layout
* @flags: flags to pass to the renderer
*
* FIXME
*
* Since: 1.0
*/
void void
cogl_pango_render_layout_subpixel (PangoLayout *layout, cogl_pango_show_layout (CoglFramebuffer *fb,
int x, PangoLayout *layout,
int y, float x,
const CoglColor *color, float y,
int flags) const CoglColor *color)
{ {
PangoContext *context; PangoContext *context;
CoglPangoRenderer *priv; CoglPangoRenderer *priv;
CoglPangoRendererQdata *qdata; CoglPangoLayoutQdata *qdata;
context = pango_layout_get_context (layout); context = pango_layout_get_context (layout);
priv = cogl_pango_get_renderer_from_context (context); priv = cogl_pango_get_renderer_from_context (context);
@ -301,14 +371,14 @@ cogl_pango_render_layout_subpixel (PangoLayout *layout,
return; return;
qdata = g_object_get_qdata (G_OBJECT (layout), qdata = g_object_get_qdata (G_OBJECT (layout),
cogl_pango_render_get_qdata_key ()); cogl_pango_layout_get_qdata_key ());
if (qdata == NULL) if (qdata == NULL)
{ {
qdata = g_slice_new0 (CoglPangoRendererQdata); qdata = g_slice_new0 (CoglPangoLayoutQdata);
qdata->renderer = priv; qdata->renderer = priv;
g_object_set_qdata_full (G_OBJECT (layout), g_object_set_qdata_full (G_OBJECT (layout),
cogl_pango_render_get_qdata_key (), cogl_pango_layout_get_qdata_key (),
qdata, qdata,
(GDestroyNotify) (GDestroyNotify)
cogl_pango_render_qdata_destroy); cogl_pango_render_qdata_destroy);
@ -321,7 +391,7 @@ cogl_pango_render_layout_subpixel (PangoLayout *layout,
((qdata->first_line && ((qdata->first_line &&
qdata->first_line->layout != layout) || qdata->first_line->layout != layout) ||
qdata->mipmapping_used != priv->use_mipmapping)) qdata->mipmapping_used != priv->use_mipmapping))
cogl_pango_render_qdata_forget_display_list (qdata); cogl_pango_layout_qdata_forget_display_list (qdata);
if (qdata->display_list == NULL) if (qdata->display_list == NULL)
{ {
@ -338,7 +408,7 @@ cogl_pango_render_layout_subpixel (PangoLayout *layout,
we can rebuild the display list */ we can rebuild the display list */
_cogl_pango_glyph_cache_add_reorganize_callback _cogl_pango_glyph_cache_add_reorganize_callback
(caches->glyph_cache, (caches->glyph_cache,
(GHookFunc) cogl_pango_render_qdata_forget_display_list, (GHookFunc) cogl_pango_layout_qdata_forget_display_list,
qdata); qdata);
priv->display_list = qdata->display_list; priv->display_list = qdata->display_list;
@ -348,11 +418,14 @@ cogl_pango_render_layout_subpixel (PangoLayout *layout,
qdata->mipmapping_used = priv->use_mipmapping; qdata->mipmapping_used = priv->use_mipmapping;
} }
cogl_push_matrix (); cogl_framebuffer_push_matrix (fb);
cogl_translate (x / (gfloat) PANGO_SCALE, y / (gfloat) PANGO_SCALE, 0); cogl_framebuffer_translate (fb, x, y, 0);
_cogl_pango_display_list_render (qdata->display_list,
_cogl_pango_display_list_render (fb,
qdata->display_list,
color); color);
cogl_pop_matrix ();
cogl_framebuffer_pop_matrix (fb);
/* Keep a reference to the first line of the layout so we can detect /* Keep a reference to the first line of the layout so we can detect
changes */ changes */
@ -368,24 +441,26 @@ cogl_pango_render_layout_subpixel (PangoLayout *layout,
} }
} }
/**
* cogl_pango_render_layout:
* @layout: a #PangoLayout
* @x: X coordinate to render the layout at
* @y: Y coordinate to render the layout at
* @color: color to use when rendering the layout
* @flags: flags to pass to the renderer
*
* Renders @layout.
*
* Since: 1.0
*/
void void
cogl_pango_render_layout (PangoLayout *layout, cogl_pango_render_layout_subpixel (PangoLayout *layout,
int x, int x,
int y, int y,
const CoglColor *color,
int flags)
{
cogl_pango_show_layout (cogl_get_draw_framebuffer (),
layout,
x / (float) PANGO_SCALE,
y / (float) PANGO_SCALE,
color);
}
void
cogl_pango_render_layout (PangoLayout *layout,
int x,
int y,
const CoglColor *color, const CoglColor *color,
int flags) int flags)
{ {
cogl_pango_render_layout_subpixel (layout, cogl_pango_render_layout_subpixel (layout,
x * PANGO_SCALE, x * PANGO_SCALE,
@ -394,26 +469,18 @@ cogl_pango_render_layout (PangoLayout *layout,
flags); flags);
} }
/**
* cogl_pango_render_layout_line:
* @line: a #PangoLayoutLine
* @x: X coordinate to render the line at
* @y: Y coordinate to render the line at
* @color: color to use when rendering the line
*
* Renders @line at the given coordinates using the given color.
*
* Since: 1.0
*/
void void
cogl_pango_render_layout_line (PangoLayoutLine *line, cogl_pango_show_layout_line (CoglFramebuffer *fb,
int x, PangoLayoutLine *line,
int y, float x,
const CoglColor *color) float y,
const CoglColor *color)
{ {
PangoContext *context; PangoContext *context;
CoglPangoRenderer *priv; CoglPangoRenderer *priv;
CoglPangoRendererCaches *caches; CoglPangoRendererCaches *caches;
int pango_x = x * PANGO_SCALE;
int pango_y = y * PANGO_SCALE;
context = pango_layout_get_context (line->layout); context = pango_layout_get_context (line->layout);
priv = cogl_pango_get_renderer_from_context (context); priv = cogl_pango_get_renderer_from_context (context);
@ -428,15 +495,30 @@ cogl_pango_render_layout_line (PangoLayoutLine *line,
_cogl_pango_ensure_glyph_cache_for_layout_line (line); _cogl_pango_ensure_glyph_cache_for_layout_line (line);
pango_renderer_draw_layout_line (PANGO_RENDERER (priv), line, x, y); pango_renderer_draw_layout_line (PANGO_RENDERER (priv), line,
pango_x, pango_y);
_cogl_pango_display_list_render (priv->display_list, _cogl_pango_display_list_render (fb,
priv->display_list,
color); color);
_cogl_pango_display_list_free (priv->display_list); _cogl_pango_display_list_free (priv->display_list);
priv->display_list = NULL; priv->display_list = NULL;
} }
void
cogl_pango_render_layout_line (PangoLayoutLine *line,
int x,
int y,
const CoglColor *color)
{
cogl_pango_show_layout_line (cogl_get_draw_framebuffer (),
line,
x / (float) PANGO_SCALE,
y / (float) PANGO_SCALE,
color);
}
void void
_cogl_pango_renderer_clear_glyph_cache (CoglPangoRenderer *renderer) _cogl_pango_renderer_clear_glyph_cache (CoglPangoRenderer *renderer)
{ {
@ -489,7 +571,7 @@ cogl_pango_renderer_set_dirty_glyph (PangoFont *font,
/* Glyphs that don't take up any space will end up without a /* Glyphs that don't take up any space will end up without a
texture. These should never become dirty so they shouldn't end up texture. These should never become dirty so they shouldn't end up
here */ here */
g_return_if_fail (value->texture != NULL); _COGL_RETURN_IF_FAIL (value->texture != NULL);
if (cogl_texture_get_format (value->texture) == COGL_PIXEL_FORMAT_A_8) if (cogl_texture_get_format (value->texture) == COGL_PIXEL_FORMAT_A_8)
{ {
@ -617,7 +699,7 @@ cogl_pango_ensure_glyph_cache_for_layout (PangoLayout *layout)
context = pango_layout_get_context (layout); context = pango_layout_get_context (layout);
priv = cogl_pango_get_renderer_from_context (context); priv = cogl_pango_get_renderer_from_context (context);
g_return_if_fail (PANGO_IS_LAYOUT (layout)); _COGL_RETURN_IF_FAIL (PANGO_IS_LAYOUT (layout));
if ((iter = pango_layout_get_iter (layout)) == NULL) if ((iter = pango_layout_get_iter (layout)) == NULL)
return; return;
@ -671,7 +753,7 @@ cogl_pango_renderer_draw_box (PangoRenderer *renderer,
{ {
CoglPangoRenderer *priv = COGL_PANGO_RENDERER (renderer); CoglPangoRenderer *priv = COGL_PANGO_RENDERER (renderer);
g_return_if_fail (priv->display_list != NULL); _COGL_RETURN_IF_FAIL (priv->display_list != NULL);
_cogl_pango_display_list_add_rectangle (priv->display_list, _cogl_pango_display_list_add_rectangle (priv->display_list,
x, x,
@ -715,7 +797,7 @@ cogl_pango_renderer_draw_rectangle (PangoRenderer *renderer,
CoglPangoRenderer *priv = COGL_PANGO_RENDERER (renderer); CoglPangoRenderer *priv = COGL_PANGO_RENDERER (renderer);
float x1, x2, y1, y2; float x1, x2, y1, y2;
g_return_if_fail (priv->display_list != NULL); _COGL_RETURN_IF_FAIL (priv->display_list != NULL);
cogl_pango_renderer_set_color_for_part (renderer, part); cogl_pango_renderer_set_color_for_part (renderer, part);
@ -743,7 +825,7 @@ cogl_pango_renderer_draw_trapezoid (PangoRenderer *renderer,
CoglPangoRenderer *priv = COGL_PANGO_RENDERER (renderer); CoglPangoRenderer *priv = COGL_PANGO_RENDERER (renderer);
float points[8]; float points[8];
g_return_if_fail (priv->display_list != NULL); _COGL_RETURN_IF_FAIL (priv->display_list != NULL);
points[0] = (x11); points[0] = (x11);
points[1] = (y1); points[1] = (y1);

227
cogl-pango/cogl-pango.h
View file

@ -1,11 +1,10 @@
/* /*
* Clutter. * Cogl
* *
* An OpenGL based 'interactive canvas' library. * An object oriented GL/GLES Abstraction/Utility Layer
*
* Authored By Matthew Allum <mallum@openedhand.com>
* *
* Copyright (C) 2008 OpenedHand * Copyright (C) 2008 OpenedHand
* Copyright (C) 2012 Intel Corporation.
* *
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
@ -18,11 +17,17 @@
* Lesser General Public License for more details. * Lesser General Public License for more details.
* *
* You should have received a copy of the GNU Lesser General Public * You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>. * License along with this library. If not, see
* <http://www.gnu.org/licenses/>.
*
* Authors:
* Neil Roberts <neil@linux.intel.com>
* Robert Bragg <robert@linux.intel.com>
* Matthew Allum <mallum@openedhand.com>
*/ */
#ifndef __PANGO_CLUTTER_H__ #ifndef __COGL_PANGO_H__
#define __PANGO_CLUTTER_H__ #define __COGL_PANGO_H__
#include <glib-object.h> #include <glib-object.h>
#include <pango/pango.h> #include <pango/pango.h>
@ -41,19 +46,159 @@ COGL_BEGIN_DECLS
typedef PangoCairoFontMap CoglPangoFontMap; typedef PangoCairoFontMap CoglPangoFontMap;
PangoFontMap * cogl_pango_font_map_new (void); /**
PangoContext * cogl_pango_font_map_create_context (CoglPangoFontMap *fm); * cogl_pango_font_map_new:
void cogl_pango_font_map_set_resolution (CoglPangoFontMap *font_map, * @context: A #CoglContext
double dpi); *
void cogl_pango_font_map_clear_glyph_cache (CoglPangoFontMap *fm); * Creates a new font map.
void cogl_pango_ensure_glyph_cache_for_layout (PangoLayout *layout); *
void cogl_pango_font_map_set_use_mipmapping (CoglPangoFontMap *fm, * Return value: (transfer full): the newly created #PangoFontMap
CoglBool value); *
CoglBool cogl_pango_font_map_get_use_mipmapping (CoglPangoFontMap *fm); * Since: 2.0
PangoRenderer *cogl_pango_font_map_get_renderer (CoglPangoFontMap *fm); */
PangoFontMap *
cogl_pango_font_map_new (void);
/**
* cogl_pango_font_map_create_context:
* @font_map: a #CoglPangoFontMap
*
* Create a #PangoContext for the given @font_map.
*
* Returns: the newly created context: free with g_object_unref().
*/
PangoContext *
cogl_pango_font_map_create_context (CoglPangoFontMap *font_map);
/**
* cogl_pango_font_map_set_resolution:
* @font_map: a #CoglPangoFontMap
* @dpi: The resolution in "dots per inch". (Physical inches aren't
* actually involved; the terminology is conventional.)
*
* Sets the resolution for the @font_map. This is a scale factor
* between points specified in a #PangoFontDescription and Cogl units.
* The default value is %96, meaning that a 10 point font will be 13
* units high. (10 * 96. / 72. = 13.3).
*
* Since: 2.0
*/
void
cogl_pango_font_map_set_resolution (CoglPangoFontMap *font_map,
double dpi);
/**
* cogl_pango_font_map_clear_glyph_cache:
* @font_map: a #CoglPangoFontMap
*
* Clears the glyph cache for @font_map.
*
* Since: 1.0
*/
void
cogl_pango_font_map_clear_glyph_cache (CoglPangoFontMap *font_map);
/**
* cogl_pango_ensure_glyph_cache_for_layout:
* @layout: A #PangoLayout
*
* This updates any internal glyph cache textures as necessary to be
* able to render the given @layout.
*
* This api should be used to avoid mid-scene modifications of
* glyph-cache textures which can lead to undefined rendering results.
*
* Since: 1.0
*/
void
cogl_pango_ensure_glyph_cache_for_layout (PangoLayout *layout);
/**
* cogl_pango_font_map_set_use_mipmapping:
* @font_map: a #CoglPangoFontMap
* @value: %TRUE to enable the use of mipmapping
*
* Sets whether the renderer for the passed font map should use
* mipmapping when rendering a #PangoLayout.
*
* Since: 1.0
*/
void
cogl_pango_font_map_set_use_mipmapping (CoglPangoFontMap *font_map,
CoglBool value);
/**
* cogl_pango_font_map_get_use_mipmapping:
* @font_map: a #CoglPangoFontMap
*
* Retrieves whether the #CoglPangoRenderer used by @font_map will use
* mipmapping when rendering the glyphs.
*
* Return value: %TRUE if mipmapping is used, %FALSE otherwise.
*
* Since: 1.0
*/
CoglBool
cogl_pango_font_map_get_use_mipmapping (CoglPangoFontMap *font_map);
/**
* cogl_pango_font_map_get_renderer:
* @font_map: a #CoglPangoFontMap
*
* Retrieves the #CoglPangoRenderer for the passed @font_map.
*
* Return value: (transfer none): a #PangoRenderer
*
* Since: 1.0
*/
PangoRenderer *
cogl_pango_font_map_get_renderer (CoglPangoFontMap *font_map);
/**
* cogl_pango_show_layout:
* @framebuffer: A #CoglFramebuffer to draw too.
* @layout: a #PangoLayout
* @x: X coordinate to render the layout at
* @y: Y coordinate to render the layout at
* @color: color to use when rendering the layout
*
* Draws a solidly coloured @layout on the given @framebuffer at (@x,
* @y) within the @framebuffer<!-- -->'s current model-view coordinate
* space.
*
* Since: 2.0
*/
void
cogl_pango_show_layout (CoglFramebuffer *framebuffer,
PangoLayout *layout,
float x,
float y,
const CoglColor *color);
/**
* cogl_pango_render_layout_line:
* @framebuffer: A #CoglFramebuffer to draw too.
* @line: a #PangoLayoutLine
* @x: X coordinate to render the line at
* @y: Y coordinate to render the line at
* @color: color to use when rendering the line
*
* Draws a solidly coloured @line on the given @framebuffer at (@x,
* @y) within the @framebuffer<!-- -->'s current model-view coordinate
* space.
*
* Since: 2.0
*/
void
cogl_pango_show_layout_line (CoglFramebuffer *framebuffer,
PangoLayoutLine *line,
float x,
float y,
const CoglColor *color);
#define COGL_PANGO_TYPE_RENDERER (cogl_pango_renderer_get_type ()) #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(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_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(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_IS_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), COGL_PANGO_TYPE_RENDERER))
@ -65,21 +210,37 @@ typedef struct _CoglPangoRendererClass CoglPangoRendererClass;
GType cogl_pango_renderer_get_type (void) G_GNUC_CONST; GType cogl_pango_renderer_get_type (void) G_GNUC_CONST;
void cogl_pango_render_layout_subpixel (PangoLayout *layout, void
int x, cogl_pango_render_layout_subpixel (PangoLayout *layout,
int y, int x,
const CoglColor *color, int y,
int flags); const CoglColor *color,
void cogl_pango_render_layout (PangoLayout *layout, int flags);
int x,
int y, void
const CoglColor *color, cogl_pango_render_layout (PangoLayout *layout,
int flags); int x,
void cogl_pango_render_layout_line (PangoLayoutLine *line, int y,
int x, const CoglColor *color,
int y, int flags);
const CoglColor *color);
/**
* cogl_pango_render_layout_line:
* @line: a #PangoLayoutLine
* @x: X coordinate to render the line at
* @y: Y coordinate to render the line at
* @color: color to use when rendering the line
*
* Renders @line at the given coordinates using the given color.
*
* Since: 1.0
*/
void
cogl_pango_render_layout_line (PangoLayoutLine *line,
int x,
int y,
const CoglColor *color);
COGL_END_DECLS COGL_END_DECLS
#endif /* __PANGO_CLUTTER_H__ */ #endif /* __COGL_PANGO_H__ */