struct TEXT_WIDGET_HANDLE text_widget_init ( float x_mm, float y_mm,
float width_mm,
float height_mm,
float dpmm_x,
float dpmm_y )
{
struct TEXT_WIDGET_HANDLE handle;
handle.d = malloc( sizeof( struct TEXT_WIDGET_PRIVATE ) );
handle.d->x_mm = x_mm;
handle.d->y_mm = y_mm;
handle.d->dpmm_x = dpmm_x;
handle.d->dpmm_y = dpmm_y;
handle.d->font_map = pango_ft2_font_map_new();
// Note: FreeType works in DPI.
pango_ft2_font_map_set_resolution( (PangoFT2FontMap*)handle.d->font_map,
dpmm_x * 25.4, dpmm_y * 25.4 );
handle.d->context = pango_font_map_create_context( handle.d->font_map );
handle.d->layout = pango_layout_new( handle.d->context );
// Pango works in Pango Units. Not exactly clear how the resolution of
// the font and the size of the rendering box fit together.
int width = pango_units_from_double( dpmm_x * width_mm );
int height = pango_units_from_double( dpmm_y * height_mm );
pango_layout_set_width( handle.d->layout, width );
pango_layout_set_height( handle.d->layout, height );
handle.d->foreground = vgCreatePaint();
vgSetParameterfv( handle.d->foreground, VG_PAINT_COLOR, 4, DEFAULT_FOREGROUND );
return handle;
}
font_factory::font_factory(void) :
nbEnt(0), // Note: this "ents" cache only keeps fonts from being unreffed, does not speed up access
maxEnt(32),
ents(static_cast<font_entry*>(g_malloc(maxEnt*sizeof(font_entry)))),
#ifdef USE_PANGO_WIN32
fontServer(pango_win32_font_map_for_display()),
fontContext(pango_win32_get_context()),
pangoFontCache(pango_win32_font_map_get_font_cache(fontServer)),
hScreenDC(pango_win32_get_dc()),
#else
fontServer(pango_ft2_font_map_new()),
fontContext(0),
#endif
fontSize(512),
loadedPtr(new FaceMapType())
{
#ifdef USE_PANGO_WIN32
#else
pango_ft2_font_map_set_resolution(PANGO_FT2_FONT_MAP(fontServer),
72, 72);
fontContext = pango_font_map_create_context(fontServer);
pango_ft2_font_map_set_default_substitute(PANGO_FT2_FONT_MAP(fontServer),
FactorySubstituteFunc,
this,
NULL);
#endif
}
static gpointer
pangoft2_view_create (const PangoViewer *klass)
{
PangoFontMap *fontmap;
fontmap = pango_ft2_font_map_new ();
pango_ft2_font_map_set_resolution (PANGO_FT2_FONT_MAP (fontmap), opt_dpi, opt_dpi);
pango_ft2_font_map_set_default_substitute (PANGO_FT2_FONT_MAP (fontmap), substitute_func, NULL, NULL);
return fontmap;
}
FontSupport::FontSupport(WPaintDevice *paintDevice)
: device_(paintDevice),
matchFont_(0)
{
PANGO_LOCK;
if (!pangoFontMap)
pangoFontMap = pango_ft2_font_map_new();
context_
= pango_ft2_font_map_create_context((PangoFT2FontMap*)pangoFontMap);
currentFont_ = 0;
}
/**
* gnome_print_pango_font_map_new:
*
* Creates a new #PangoFontMap object suitable for use with
* gnome-print. In most cases, you probably want to use
* gnome_print_pango_get_default_font_map () instead.
*
* Return value: a newly created #PangoFontMap object
**/
PangoFontMap *
gnome_print_pango_font_map_new (void)
{
PangoFontMap *fontmap = NULL;
PangoFT2FontMap *ft2fontmap;
fontmap = pango_ft2_font_map_new ();
ft2fontmap = PANGO_FT2_FONT_MAP (fontmap);
pango_ft2_font_map_set_resolution (ft2fontmap, 72, 72);
pango_ft2_font_map_set_default_substitute (ft2fontmap, substitute_func, NULL, NULL);
set_is_gnome_print_object (G_OBJECT (fontmap));
return fontmap;
}
FontSupport::FontSupport(WPaintDevice *paintDevice)
: device_(paintDevice),
cache_(10)
{
PANGO_LOCK;
if (!pangoFontMap)
pangoFontMap = pango_ft2_font_map_new();
#if PANGO_VERSION_MAJOR > 1 || PANGO_VERSION_MINOR > 21
context_ = pango_font_map_create_context(pangoFontMap);
#else
context_ = pango_ft2_font_map_create_context(PANGO_FT2_FONT_MAP(pangoFontMap));
#endif
currentFont_ = 0;
}
constructor_tables(void)
{
// hash tables
pp_to_np_ht = g_hash_table_new(g_direct_hash, g_direct_equal);
npobj_to_npp_ht = g_hash_table_new(g_direct_hash, g_direct_equal);
// pango
pango_fm = pango_ft2_font_map_new();
pango_ctx = pango_font_map_create_context(pango_fm);
// mutex
pthread_mutex_init(&lock, NULL);
// urandom
urandom_fd = open("/dev/urandom", O_RDONLY);
srand(time(NULL) + 42);
}
void
gimp_font_list_restore (GimpFontList *list)
{
PangoFontMap *fontmap;
PangoContext *context;
g_return_if_fail (GIMP_IS_FONT_LIST (list));
if (font_desc_to_string == NULL)
{
PangoFontDescription *desc;
gchar *name;
gchar last_char;
desc = pango_font_description_new ();
pango_font_description_set_family (desc, "Wilber 12");
name = pango_font_description_to_string (desc);
last_char = name[strlen (name) - 1];
g_free (name);
pango_font_description_free (desc);
if (last_char != ',')
font_desc_to_string = &gimp_font_util_pango_font_description_to_string;
else
font_desc_to_string = &pango_font_description_to_string;
}
fontmap = pango_ft2_font_map_new ();
pango_ft2_font_map_set_resolution (PANGO_FT2_FONT_MAP (fontmap),
list->xresolution, list->yresolution);
context = pango_ft2_font_map_create_context (PANGO_FT2_FONT_MAP (fontmap));
g_object_unref (fontmap);
gimp_container_freeze (GIMP_CONTAINER (list));
gimp_font_list_load_names (list, fontmap, context);
g_object_unref (context);
gimp_list_sort_by_name (GIMP_LIST (list));
gimp_container_thaw (GIMP_CONTAINER (list));
}
static bool lnx_pango_objects_intialize()
{
bool t_success;
t_success = true;
PangoFontMap *t_font_map;
PangoContext *t_pango;
PangoLayout *t_layout;
if (t_success)
{
t_font_map = (PangoFontMap *)pthread_getspecific(s_font_map_key);
t_pango = (PangoContext *)pthread_getspecific(s_pango_key);
t_layout = (PangoLayout *)pthread_getspecific(s_layout_key);
}
if (t_success)
if (t_font_map == NULL)
{
t_font_map = pango_ft2_font_map_new();
t_success = t_font_map != NULL;
if (t_success)
pthread_setspecific(s_font_map_key, t_font_map);
}
if (t_success)
if (t_pango == NULL)
{
t_pango = pango_ft2_font_map_create_context((PangoFT2FontMap *) t_font_map);
t_success = t_pango != NULL;
if (t_success)
pthread_setspecific(s_pango_key, t_pango);
}
if (t_success)
if (t_layout == NULL)
{
t_layout = pango_layout_new(t_pango);
t_success = t_layout != NULL;
if (t_success)
pthread_setspecific(s_layout_key, t_layout);
}
return t_success;
}
MapPainterSVG::MapPainterSVG(const StyleConfigRef& styleConfig)
: MapPainter(styleConfig,
new CoordBufferImpl<Vertex2D>()),
coordBuffer((CoordBufferImpl<Vertex2D>*)transBuffer.buffer),
stream(NULL),
typeConfig(NULL)
{
#if defined(OSMSCOUT_MAP_SVG_HAVE_LIB_PANGO)
#if !defined(GLIB_VERSION_2_36)
/* Compatibility call for glibc versions prior to 2.36 */
g_type_init();
#endif
pangoContext=pango_context_new();
pangoFontMap=pango_ft2_font_map_new();
pango_context_set_font_map(pangoContext,
pangoFontMap);
#endif
}
void gtk_glwidget_create_font(){
PangoFontDescription *font_desc;
PangoLayout *layout;
PangoRectangle log_rect;
int font_ascent_pango_units;
int font_descent_pango_units;
if ( _debug_font_created ) {
Error( "Programming error: gtk_glwidget_create_font() was already called; "
"you must call gtk_glwidget_destroy_font() before creating font again" );
}
_debug_font_created = 1;
font_map = pango_ft2_font_map_new();
pango_ft2_font_map_set_resolution( PANGO_FT2_FONT_MAP( font_map ), 72, 72 );
ft2_context = pango_font_map_create_context( PANGO_FONT_MAP( font_map ));
font_desc = pango_font_description_from_string( font_string );
pango_font_description_set_size( font_desc, font_height * PANGO_SCALE );
pango_context_set_font_description( ft2_context, font_desc );
pango_font_description_free( font_desc );
layout = pango_layout_new( ft2_context );
// I don't believe that's standard preprocessor syntax?
#if !PANGO_VERSION_CHECK( 1,22,0 )
PangoLayoutIter *iter;
iter = pango_layout_get_iter( layout );
font_ascent_pango_units = pango_layout_iter_get_baseline( iter );
pango_layout_iter_free( iter );
#else
font_ascent_pango_units = pango_layout_get_baseline( layout );
#endif
pango_layout_get_extents( layout, NULL, &log_rect );
g_object_unref( G_OBJECT( layout ) );
font_descent_pango_units = log_rect.height - font_ascent_pango_units;
font_ascent = PANGO_PIXELS_CEIL( font_ascent_pango_units );
font_descent = PANGO_PIXELS_CEIL( font_descent_pango_units );
y_offset_bitmap_render_pango_units = ( font_ascent * PANGO_SCALE ) - font_ascent_pango_units;
}
FontSupport::FontSupport(WPaintDevice *paintDevice, EnabledFontFormats enabledFontFormats)
: device_(paintDevice),
enabledFontFormats_(enabledFontFormats),
cache_(10)
{
PANGO_LOCK;
if (!pangoFontMap) {
pangoFontMap = pango_ft2_font_map_new();
pango_ft2_font_map_set_default_substitute(PANGO_FT2_FONT_MAP(pangoFontMap),
addTrueTypePattern, NULL, NULL);
}
#if PANGO_VERSION_MAJOR > 1 || PANGO_VERSION_MINOR > 21
context_ = pango_font_map_create_context(pangoFontMap);
#else
context_ = pango_ft2_font_map_create_context(PANGO_FT2_FONT_MAP(pangoFontMap));
#endif
currentFont_ = nullptr;
}
static bool lnx_pango_initialize(void)
{
bool t_success;
t_success = true;
// MW-2013-12-19: [[ Bug 11559 ]] Use '=' not '=='!
if (t_success)
t_success =
initialise_weak_link_pango() != 0 &&
initialise_weak_link_pangoft2() != 0 &&
initialise_weak_link_gobject() != 0 &&
initialise_weak_link_glib() != 0;
if (t_success)
if (s_font_map == NULL)
{
s_font_map = pango_ft2_font_map_new();
t_success = s_font_map != NULL;
}
if (t_success)
if (s_pango == NULL)
{
s_pango = pango_ft2_font_map_create_context((PangoFT2FontMap *) s_font_map);
t_success = s_pango != nil;
}
if (t_success)
if (s_layout == NULL)
{
s_layout = pango_layout_new(s_pango);
t_success = s_layout != NULL;
}
return t_success;
}
int main(int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *canvas;
GtkWidget *font_button;
GtkWidget *g_button;
GtkWidget *d_button;
GtkWidget *str;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *label1, *label2;
GtkWidget *spin;
PangoFontDescription *desc;
if (argc == 2) {
if (get_conf (argv[1]))
printf ("Error reading configuration. Use defaults\n");
}
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW(window), "Font converter");
hbox = gtk_hbox_new (FALSE, 10);
label1 = gtk_label_new ("Text: ");
font_button = gtk_font_button_new_with_font (get_fontname());
d_button = gtk_button_new_with_label ("Draw");
g_button = gtk_button_new_with_label ("G Code");
str = gtk_entry_new ();
gtk_entry_set_max_length (GTK_ENTRY (str), 15);
gtk_entry_set_text (GTK_ENTRY (str), get_string());
label2 = gtk_label_new ("Width (inch): ");
spin = gtk_spin_button_new_with_range (3, 120, 1);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spin), 2);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin), (double)10);
gtk_box_pack_start (GTK_BOX (hbox), label1, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), str, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), font_button, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), d_button, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), g_button, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), label2, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), spin, FALSE, FALSE, 0);
canvas = gtk_drawing_area_new();
gtk_widget_set_size_request (canvas, 1200, 600);
vbox = gtk_vbox_new (FALSE, 5);
gtk_box_pack_start (GTK_BOX (vbox), canvas, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (g_button), "spin", spin);
gtk_container_add (GTK_CONTAINER (window), vbox);
g_signal_connect(window, "destroy",
G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(G_OBJECT (canvas), "expose_event",
G_CALLBACK(expose_event), str);
g_signal_connect(G_OBJECT (font_button), "font_set",
G_CALLBACK(font_button_clicked), NULL);
g_signal_connect(G_OBJECT (g_button), "clicked",
G_CALLBACK(g_button_clicked), str);
g_signal_connect(G_OBJECT (d_button), "clicked",
G_CALLBACK(d_button_clicked), canvas);
gtk_widget_show_all(window);
map = pango_ft2_font_map_new ();
ctx = pango_font_map_create_context (map);
desc = pango_font_description_from_string (get_fontname());
set_font (desc);
gtk_main();
g_object_unref (map);
g_object_unref (ctx);
return 0;
}
mlt_producer producer_pango_init( const char *filename )
{
producer_pango this = calloc( sizeof( struct producer_pango_s ), 1 );
if ( this != NULL && mlt_producer_init( &this->parent, this ) == 0 )
{
mlt_producer producer = &this->parent;
pthread_mutex_lock( &pango_mutex );
if ( fontmap == NULL )
fontmap = (PangoFT2FontMap*) pango_ft2_font_map_new();
g_type_init();
pthread_mutex_unlock( &pango_mutex );
producer->get_frame = producer_get_frame;
producer->close = ( mlt_destructor )producer_close;
// Get the properties interface
mlt_properties properties = MLT_PRODUCER_PROPERTIES( &this->parent );
// Set the default properties
mlt_properties_set( properties, "fgcolour", "0xffffffff" );
mlt_properties_set( properties, "bgcolour", "0x00000000" );
mlt_properties_set( properties, "olcolour", "0x00000000" );
mlt_properties_set_int( properties, "align", pango_align_left );
mlt_properties_set_int( properties, "pad", 0 );
mlt_properties_set_int( properties, "outline", 0 );
mlt_properties_set( properties, "text", "" );
mlt_properties_set( properties, "font", NULL );
mlt_properties_set( properties, "family", "Sans" );
mlt_properties_set_int( properties, "size", 48 );
mlt_properties_set( properties, "style", "normal" );
mlt_properties_set( properties, "encoding", "UTF-8" );
mlt_properties_set_int( properties, "weight", PANGO_WEIGHT_NORMAL );
mlt_properties_set_int( properties, "seekable", 1 );
if ( filename == NULL || ( filename && ( !strcmp( filename, "" )
// workaround for old kdenlive countdown generator
|| strstr( filename, "<producer>" ) ) ) )
{
mlt_properties_set( properties, "markup", "" );
}
else if ( filename[ 0 ] == '+' || strstr( filename, "/+" ) )
{
char *copy = strdup( filename + 1 );
char *markup = copy;
if ( strstr( markup, "/+" ) )
markup = strstr( markup, "/+" ) + 2;
( *strrchr( markup, '.' ) ) = '\0';
while ( strchr( markup, '~' ) )
( *strchr( markup, '~' ) ) = '\n';
mlt_properties_set( properties, "resource", filename );
mlt_properties_set( properties, "markup", markup );
free( copy );
}
else if ( strstr( filename, ".mpl" ) )
{
int i = 0;
mlt_properties contents = mlt_properties_load( filename );
mlt_geometry key_frames = mlt_geometry_init( );
struct mlt_geometry_item_s item;
mlt_properties_set( properties, "resource", filename );
mlt_properties_set_data( properties, "contents", contents, 0, ( mlt_destructor )mlt_properties_close, NULL );
mlt_properties_set_data( properties, "key_frames", key_frames, 0, ( mlt_destructor )mlt_geometry_close, NULL );
// Make sure we have at least one entry
if ( mlt_properties_get( contents, "0" ) == NULL )
mlt_properties_set( contents, "0", "" );
for ( i = 0; i < mlt_properties_count( contents ); i ++ )
{
char *name = mlt_properties_get_name( contents, i );
char *value = mlt_properties_get_value( contents, i );
while ( value != NULL && strchr( value, '~' ) )
( *strchr( value, '~' ) ) = '\n';
item.frame = atoi( name );
mlt_geometry_insert( key_frames, &item );
}
mlt_geometry_interpolate( key_frames );
}
else
{
FILE *f = fopen( filename, "r" );
if ( f != NULL )
{
char line[81];
char *markup = NULL;
size_t size = 0;
line[80] = '\0';
while ( fgets( line, 80, f ) )
{
size += strlen( line ) + 1;
if ( markup )
{
markup = realloc( markup, size );
strcat( markup, line );
}
else
{
markup = strdup( line );
}
}
fclose( f );
if ( markup[ strlen( markup ) - 1 ] == '\n' )
markup[ strlen( markup ) - 1 ] = '\0';
mlt_properties_set( properties, "resource", filename );
mlt_properties_set( properties, "markup", ( markup == NULL ? "" : markup ) );
free( markup );
}
else
{
producer->close = NULL;
mlt_producer_close( producer );
producer = NULL;
free( this );
}
}
return producer;
}
free( this );
return NULL;
}
static Image *ReadCAPTIONImage(const ImageInfo *image_info,
ExceptionInfo *exception)
{
char
*caption,
*property;
const char
*option;
DrawInfo
*draw_info;
FT_Bitmap
*canvas;
Image
*image;
PangoAlignment
align;
PangoContext
*context;
PangoFontDescription
*description;
PangoFontMap
*fontmap;
PangoGravity
gravity;
PangoLayout
*layout;
PangoRectangle
extent;
PixelPacket
fill_color;
RectangleInfo
page;
register PixelPacket
*q;
register unsigned char
*p;
ssize_t
y;
/*
Initialize Image structure.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
image=AcquireImage(image_info);
(void) ResetImagePage(image,"0x0+0+0");
/*
Get context.
*/
fontmap=(PangoFontMap *) pango_ft2_font_map_new();
pango_ft2_font_map_set_resolution((PangoFT2FontMap *) fontmap,
image->x_resolution,image->y_resolution);
option=GetImageOption(image_info,"caption:hinting");
pango_ft2_font_map_set_default_substitute((PangoFT2FontMap *) fontmap,
PangoSubstitute,(char *) option,NULL);
context=pango_font_map_create_context(fontmap);
option=GetImageOption(image_info,"caption:language");
if (option != (const char *) NULL)
pango_context_set_language(context,pango_language_from_string(option));
draw_info=CloneDrawInfo(image_info,(DrawInfo *) NULL);
pango_context_set_base_dir(context,draw_info->direction ==
RightToLeftDirection ? PANGO_DIRECTION_RTL : PANGO_DIRECTION_LTR);
switch (draw_info->gravity)
{
case NorthGravity: gravity=PANGO_GRAVITY_NORTH; break;
case WestGravity: gravity=PANGO_GRAVITY_WEST; break;
case EastGravity: gravity=PANGO_GRAVITY_EAST; break;
case SouthGravity: gravity=PANGO_GRAVITY_SOUTH; break;
default: gravity=PANGO_GRAVITY_AUTO; break;
}
pango_context_set_base_gravity(context,gravity);
option=GetImageOption(image_info,"caption:gravity-hint");
if (option != (const char *) NULL)
{
if (LocaleCompare(option,"line") == 0)
pango_context_set_gravity_hint(context,PANGO_GRAVITY_HINT_LINE);
if (LocaleCompare(option,"natural") == 0)
pango_context_set_gravity_hint(context,PANGO_GRAVITY_HINT_NATURAL);
if (LocaleCompare(option,"strong") == 0)
pango_context_set_gravity_hint(context,PANGO_GRAVITY_HINT_STRONG);
}
/*
Configure layout.
*/
layout=pango_layout_new(context);
option=GetImageOption(image_info,"caption:auto-dir");
if (option != (const char *) NULL)
pango_layout_set_auto_dir(layout,1);
option=GetImageOption(image_info,"caption:ellipsize");
if (option != (const char *) NULL)
{
if (LocaleCompare(option,"end") == 0)
pango_layout_set_ellipsize(layout,PANGO_ELLIPSIZE_END);
if (LocaleCompare(option,"middle") == 0)
pango_layout_set_ellipsize(layout,PANGO_ELLIPSIZE_MIDDLE);
if (LocaleCompare(option,"none") == 0)
pango_layout_set_ellipsize(layout,PANGO_ELLIPSIZE_NONE);
if (LocaleCompare(option,"start") == 0)
pango_layout_set_ellipsize(layout,PANGO_ELLIPSIZE_START);
}
option=GetImageOption(image_info,"caption:justify");
if ((option != (const char *) NULL) && (IsMagickTrue(option) != MagickFalse))
pango_layout_set_justify(layout,1);
option=GetImageOption(image_info,"caption:single-paragraph");
if ((option != (const char *) NULL) && (IsMagickTrue(option) != MagickFalse))
pango_layout_set_single_paragraph_mode(layout,1);
option=GetImageOption(image_info,"caption:wrap");
if (option != (const char *) NULL)
{
if (LocaleCompare(option,"char") == 0)
pango_layout_set_wrap(layout,PANGO_WRAP_CHAR);
if (LocaleCompare(option,"word") == 0)
pango_layout_set_wrap(layout,PANGO_WRAP_WORD);
if (LocaleCompare(option,"word-char") == 0)
pango_layout_set_wrap(layout,PANGO_WRAP_WORD_CHAR);
}
option=GetImageOption(image_info,"caption:indent");
if (option != (const char *) NULL)
pango_layout_set_indent(layout,(StringToLong(option)*image->x_resolution*
PANGO_SCALE+36)/72);
switch (draw_info->align)
{
case CenterAlign: align=PANGO_ALIGN_CENTER; break;
case RightAlign: align=PANGO_ALIGN_RIGHT; break;
case LeftAlign:
default: align=PANGO_ALIGN_LEFT; break;
}
if ((align != PANGO_ALIGN_CENTER) &&
(draw_info->direction == RightToLeftDirection))
align=(PangoAlignment) (PANGO_ALIGN_LEFT+PANGO_ALIGN_RIGHT-align);
pango_layout_set_alignment(layout,align);
description=pango_font_description_from_string(draw_info->font ==
(char *) NULL ? "helvetica" : draw_info->font);
pango_font_description_set_size(description,PANGO_SCALE*draw_info->pointsize);
pango_layout_set_font_description(layout,description);
pango_font_description_free(description);
property=InterpretImageProperties(image_info,image,image_info->filename);
(void) SetImageProperty(image,"caption",property);
property=DestroyString(property);
caption=ConstantString(GetImageProperty(image,"caption"));
/*
Render caption.
*/
option=GetImageOption(image_info,"caption:markup");
if ((option != (const char *) NULL) && (IsMagickTrue(option) != MagickFalse))
pango_layout_set_markup(layout,caption,-1);
else
pango_layout_set_text(layout,caption,-1);
pango_layout_context_changed(layout);
page.x=0;
page.y=0;
if (image_info->page != (char *) NULL)
(void) ParseAbsoluteGeometry(image_info->page,&page);
if (image->columns == 0)
{
pango_layout_get_pixel_extents(layout,NULL,&extent);
image->columns=extent.x+extent.width;
}
else
{
image->columns-=2*page.x;
pango_layout_set_width(layout,(PANGO_SCALE*image->columns*
image->x_resolution+36.0)/72.0);
}
if (image->rows == 0)
{
pango_layout_get_pixel_extents(layout,NULL,&extent);
image->rows=extent.y+extent.height;
}
else
{
image->rows-=2*page.y;
pango_layout_set_height(layout,(PANGO_SCALE*image->rows*
image->y_resolution+36.0)/72.0);
}
/*
Create canvas.
*/
canvas=(FT_Bitmap *) AcquireMagickMemory(sizeof(*canvas));
if (canvas == (FT_Bitmap *) NULL)
{
draw_info=DestroyDrawInfo(draw_info);
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
}
canvas->width=image->columns;
canvas->pitch=(canvas->width+3) & ~3;
canvas->rows=image->rows;
canvas->buffer=(unsigned char *) AcquireQuantumMemory(canvas->pitch,
canvas->rows*sizeof(*canvas->buffer));
if (canvas->buffer == (unsigned char *) NULL)
{
draw_info=DestroyDrawInfo(draw_info);
canvas=(FT_Bitmap *) RelinquishMagickMemory(canvas);
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
}
canvas->num_grays=256;
canvas->pixel_mode=ft_pixel_mode_grays;
ResetMagickMemory(canvas->buffer,0x00,canvas->pitch*canvas->rows);
pango_ft2_render_layout(canvas,layout,0,0);
/*
Convert caption to image.
*/
image->columns+=2*page.x;
image->rows+=2*page.y;
if (SetImageBackgroundColor(image) == MagickFalse)
{
draw_info=DestroyDrawInfo(draw_info);
canvas->buffer=(unsigned char *) RelinquishMagickMemory(canvas->buffer);
canvas=(FT_Bitmap *) RelinquishMagickMemory(canvas);
caption=DestroyString(caption);
image=DestroyImageList(image);
return((Image *) NULL);
}
p=canvas->buffer;
for (y=page.y; y < (ssize_t) (image->rows-page.y); y++)
{
register ssize_t
x;
q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
if (q == (PixelPacket *) NULL)
break;
q+=page.x;
for (x=page.x; x < (ssize_t) (image->columns-page.x); x++)
{
MagickRealType
fill_opacity;
(void) GetFillColor(draw_info,x,y,&fill_color);
fill_opacity=QuantumRange-(*p)/canvas->num_grays*(QuantumRange-
fill_color.opacity);
if (draw_info->text_antialias == MagickFalse)
fill_opacity=fill_opacity >= 0.5 ? 1.0 : 0.0;
MagickCompositeOver(&fill_color,fill_opacity,q,q->opacity,q);
p++;
q++;
}
for ( ; x < (ssize_t) ((canvas->width+3) & ~3); x++)
p++;
}
/*
Relinquish resources.
*/
draw_info=DestroyDrawInfo(draw_info);
canvas->buffer=(unsigned char *) RelinquishMagickMemory(canvas->buffer);
canvas=(FT_Bitmap *) RelinquishMagickMemory(canvas);
caption=DestroyString(caption);
return(GetFirstImageInList(image));
}
{
if (opt_hinting != HINT_DEFAULT)
{
FcPatternDel (pattern, FC_HINTING);
FcPatternAddBool (pattern, FC_HINTING, opt_hinting != HINT_NONE);
FcPatternDel (pattern, FC_AUTOHINT);
FcPatternAddBool (pattern, FC_AUTOHINT, opt_hinting == HINT_AUTO);
}
}
static gpointer
pangoft2_view_create (const PangoViewer *klass G_GNUC_UNUSED)
{
PangoFontMap *fontmap;
fontmap = pango_ft2_font_map_new ();
pango_ft2_font_map_set_resolution (PANGO_FT2_FONT_MAP (fontmap), opt_dpi, opt_dpi);
pango_ft2_font_map_set_default_substitute (PANGO_FT2_FONT_MAP (fontmap), substitute_func, NULL, NULL);
return fontmap;
}
static void
pangoft2_view_destroy (gpointer instance)
{
g_object_unref (instance);
}
static PangoContext *
pangoft2_view_get_context (gpointer instance)
