static VALUE
rg_iter(VALUE self)
{
return BOXED2RVAL(pango_layout_get_iter(_SELF(self)),
PANGO_TYPE_LAYOUT_ITER);
}
PangoLayout*
gdip_pango_setup_layout (GpGraphics *graphics, GDIPCONST WCHAR *stringUnicode, int length, GDIPCONST GpFont *font,
GDIPCONST RectF *rc, RectF *box, GDIPCONST GpStringFormat *format, int **charsRemoved)
{
GpStringFormat *fmt;
PangoLayout *layout;
PangoContext *context;
PangoRectangle logical; /* logical size of text (used for alignment) */
PangoRectangle ink; /* ink size of text (to pixel boundaries) */
PangoAttrList *list = NULL;
GString *ftext;
PangoTabArray *tabs;
PangoLayoutIter *iter;
int i;
int FrameWidth; /* rc->Width (or rc->Height if vertical) */
int FrameHeight; /* rc->Height (or rc->Width if vertical) */
int FrameX; /* rc->X (or rc->Y if vertical) */
int FrameY; /* rc->Y (or rc->X if vertical) */
int y0; /* y0,y1,clipNN used for checking line positions vs. clip rectangle */
int y1;
double clipx1;
double clipx2;
double clipy1;
double clipy2;
int trimSpace; /* whether or not to trim the space */
gchar *text = ucs2_to_utf8 (stringUnicode, length);
if (!text)
return NULL;
length = strlen(text);
if (charsRemoved) {
(*charsRemoved) = GdipAlloc (sizeof (int) * length);
if (!*charsRemoved) {
GdipFree (text);
return NULL;
}
memset (*charsRemoved, 0, sizeof (int) * length);
}
/* TODO - Digit substitution */
// g_warning ("layout >%s< (%d) [x %g, y %g, w %g, h %g] [font %s, %g points]", text, length, rc->X, rc->Y, rc->Width, FrameHeight, font->face, font->emSize);
/* a NULL format is valid, it means get the generic default values (and free them later) */
if (!format) {
GpStatus status = GdipStringFormatGetGenericDefault ((GpStringFormat **)&fmt);
if (status != Ok) {
GdipFree (text);
return NULL;
}
} else {
fmt = (GpStringFormat *)format;
}
layout = pango_cairo_create_layout (graphics->ct);
/* context is owned by Pango (i.e. not referenced counted) do not free */
context = pango_layout_get_context (layout);
pango_layout_set_font_description (layout, gdip_get_pango_font_description ((GpFont*) font));
if (fmt->formatFlags & StringFormatFlagsDirectionVertical) {
FrameWidth = MAKE_SAFE_FOR_PANGO (SAFE_FLOAT_TO_UINT32 (rc->Height));
FrameHeight = MAKE_SAFE_FOR_PANGO (SAFE_FLOAT_TO_UINT32 (rc->Width));
FrameX = SAFE_FLOAT_TO_UINT32 (rc->Y);
FrameY = SAFE_FLOAT_TO_UINT32 (rc->X);
} else {
FrameWidth = MAKE_SAFE_FOR_PANGO (SAFE_FLOAT_TO_UINT32 (rc->Width));
FrameHeight = MAKE_SAFE_FOR_PANGO (SAFE_FLOAT_TO_UINT32 (rc->Height));
FrameX = SAFE_FLOAT_TO_UINT32 (rc->X);
FrameY = SAFE_FLOAT_TO_UINT32 (rc->Y);
}
//g_warning("FW: %d\tFH: %d", FrameWidth, FrameHeight);
if ((FrameWidth <= 0) || (fmt->formatFlags & StringFormatFlagsNoWrap)) {
pango_layout_set_width (layout, -1);
//g_warning ("Setting width: %d", -1);
} else {
pango_layout_set_width (layout, FrameWidth * PANGO_SCALE);
//g_warning ("Setting width: %d", FrameWidth * PANGO_SCALE);
}
if ((rc->Width != 0) && (rc->Height != 0) && ((fmt->formatFlags & StringFormatFlagsNoClip) == 0)) {
// g_warning ("\tclip [%g %g %g %g]", rc->X, rc->Y, rc->Width, rc->Height);
/* We do not call cairo_reset_clip because we want to take previous clipping into account */
/* Use rc instead of frame variables because this is pre-transform */
gdip_cairo_rectangle (graphics, rc->X, rc->Y, rc->Width, rc->Height, TRUE);
cairo_clip (graphics->ct);
}
/* with GDI+ the API not the renderer makes the direction decision */
pango_layout_set_auto_dir (layout, FALSE);
if (!(fmt->formatFlags & StringFormatFlagsDirectionRightToLeft) != !(fmt->formatFlags & StringFormatFlagsDirectionVertical)) {
pango_context_set_base_dir (context, PANGO_DIRECTION_WEAK_RTL);
pango_layout_context_changed (layout);
/* horizontal alignment */
switch (fmt->alignment) {
case StringAlignmentNear:
pango_layout_set_alignment (layout, PANGO_ALIGN_RIGHT);
break;
case StringAlignmentCenter:
pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER);
break;
case StringAlignmentFar:
pango_layout_set_alignment (layout, PANGO_ALIGN_LEFT);
break;
}
} else {
/* pango default base dir is WEAK_LTR, which is what we want */
/* horizontal alignment */
switch (fmt->alignment) {
case StringAlignmentNear:
pango_layout_set_alignment (layout, PANGO_ALIGN_LEFT);
break;
case StringAlignmentCenter:
pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER);
break;
case StringAlignmentFar:
pango_layout_set_alignment (layout, PANGO_ALIGN_RIGHT);
break;
}
}
#ifdef PANGO_VERSION_CHECK
#if PANGO_VERSION_CHECK(1,16,0)
if (fmt->formatFlags & StringFormatFlagsDirectionVertical) {
if (fmt->formatFlags & StringFormatFlagsDirectionRightToLeft) {
cairo_rotate (graphics->ct, M_PI/2.0);
cairo_translate (graphics->ct, 0, -FrameHeight);
pango_cairo_update_context (graphics->ct, context);
} else {
cairo_rotate (graphics->ct, 3.0*M_PI/2.0);
cairo_translate (graphics->ct, -FrameWidth, 0);
pango_cairo_update_context (graphics->ct, context);
}
/* only since Pango 1.16 */
pango_context_set_base_gravity (context, PANGO_GRAVITY_AUTO);
pango_context_set_gravity_hint (context, PANGO_GRAVITY_HINT_LINE);
pango_layout_context_changed (layout);
}
#endif
#endif
/* TODO - StringFormatFlagsDisplayFormatControl
scan and replace them ??? */
/* Trimming options seem to apply only to the end of the string - gdi+ will still wrap
* with preference to word first, then character. Unfortunately, pango doesn't have
* any way to differentiate wrapping behavior from trimming behavior that I could find */
pango_layout_set_wrap (layout, PANGO_WRAP_WORD_CHAR);
switch (fmt->trimming) {
case StringTrimmingNone:
pango_layout_set_ellipsize (layout, PANGO_ELLIPSIZE_NONE);
break;
case StringTrimmingCharacter:
pango_layout_set_ellipsize (layout, PANGO_ELLIPSIZE_NONE);
break;
case StringTrimmingWord:
pango_layout_set_ellipsize (layout, PANGO_ELLIPSIZE_NONE);
break;
case StringTrimmingEllipsisCharacter:
pango_layout_set_ellipsize (layout, PANGO_ELLIPSIZE_END);
if (!(fmt->formatFlags & StringFormatFlagsNoWrap))
pango_layout_set_height (layout, FrameHeight == 0 ? G_MAXINT32 : FrameHeight * PANGO_SCALE);
break;
case StringTrimmingEllipsisWord:
pango_layout_set_ellipsize (layout, PANGO_ELLIPSIZE_END);
if (!(fmt->formatFlags & StringFormatFlagsNoWrap))
pango_layout_set_height (layout, FrameHeight == 0 ? G_MAXINT32 : FrameHeight * PANGO_SCALE);
break;
case StringTrimmingEllipsisPath:
pango_layout_set_ellipsize (layout, PANGO_ELLIPSIZE_MIDDLE);
if (!(fmt->formatFlags & StringFormatFlagsNoWrap))
pango_layout_set_height (layout, FrameHeight == 0 ? G_MAXINT32 : FrameHeight * PANGO_SCALE);
break;
}
/* some stuff can only be done by manipulating the attributes (but we can avoid this most of the time) */
if ((fmt->formatFlags & StringFormatFlagsNoFontFallback) || (font->style & (FontStyleUnderline | FontStyleStrikeout))) {
list = gdip_get_layout_attributes (layout);
/* StringFormatFlagsNoFontFallback */
if (fmt->formatFlags & StringFormatFlagsNoFontFallback) {
PangoAttribute *attr = pango_attr_fallback_new (FALSE);
attr->start_index = 0;
attr->end_index = length;
pango_attr_list_insert (list, attr);
}
if (font->style & FontStyleUnderline) {
PangoAttribute *attr = pango_attr_underline_new (PANGO_UNDERLINE_SINGLE);
attr->start_index = 0;
attr->end_index = length;
pango_attr_list_insert (list, attr);
}
if (font->style & FontStyleStrikeout) {
PangoAttribute *attr = pango_attr_strikethrough_new (TRUE);
attr->start_index = 0;
attr->end_index = length;
pango_attr_list_insert (list, attr);
}
}
if (fmt->numtabStops > 0) {
float tabPosition;
tabs = pango_tab_array_new (fmt->numtabStops, FALSE);
tabPosition = fmt->firstTabOffset;
for (i = 0; i < fmt->numtabStops; i++) {
tabPosition += fmt->tabStops[i];
pango_tab_array_set_tab (tabs, i, PANGO_TAB_LEFT, (gint)min (tabPosition, PANGO_MAX) * PANGO_SCALE);
}
pango_layout_set_tabs (layout, tabs);
pango_tab_array_free (tabs);
}
//g_warning ("length before ws removal: %d", length);
trimSpace = (fmt->formatFlags & StringFormatFlagsMeasureTrailingSpaces) == 0;
switch (fmt->hotkeyPrefix) {
case HotkeyPrefixHide:
/* we need to remove any accelerator from the string */
ftext = gdip_process_string (text, length, 1, trimSpace, NULL, charsRemoved);
break;
case HotkeyPrefixShow:
/* optimization: is seems that we never see the hotkey when using an underline font */
if (font->style & FontStyleUnderline) {
/* so don't bother drawing it (and simply add the '&' character) */
ftext = gdip_process_string (text, length, 1, trimSpace, NULL, charsRemoved);
} else {
/* find accelerator and add attribute to the next character (unless it's the prefix too) */
if (!list)
list = gdip_get_layout_attributes (layout);
ftext = gdip_process_string (text, length, 1, trimSpace, list, charsRemoved);
}
break;
default:
ftext = gdip_process_string (text, length, 0, trimSpace, NULL, charsRemoved);
break;
}
length = ftext->len;
//g_warning ("length after ws removal: %d", length);
if (list) {
pango_layout_set_attributes (layout, list);
pango_attr_list_unref (list);
}
// g_warning("\tftext>%s< (%d)", ftext->str, -1);
pango_layout_set_text (layout, ftext->str, ftext->len);
GdipFree (text);
g_string_free(ftext, TRUE);
/* Trim the text after the last line for ease of counting lines/characters */
/* Also prevents drawing whole lines outside the boundaries if NoClip was specified */
/* In case of pre-existing clipping, use smaller of clip rectangle or our specified height */
if (FrameHeight > 0) {
cairo_clip_extents (graphics->ct, &clipx1, &clipy1, &clipx2, &clipy2);
if (clipy2 > 0 && !(fmt->formatFlags & StringFormatFlagsNoClip))
clipy2 = min (clipy2, FrameHeight + FrameY);
else
clipy2 = FrameHeight + FrameY;
iter = pango_layout_get_iter (layout);
do {
if (iter == NULL)
break;
pango_layout_iter_get_line_yrange (iter, &y0, &y1);
//g_warning("yrange: %d %d clipy2: %f", y0 / PANGO_SCALE, y1 / PANGO_SCALE, clipy2);
/* StringFormatFlagsLineLimit */
if (((fmt->formatFlags & StringFormatFlagsLineLimit) && y1 / PANGO_SCALE > clipy2) || (y0 / PANGO_SCALE > clipy2)) {
PangoLayoutLine *line = pango_layout_iter_get_line_readonly (iter);
pango_layout_set_text (layout, pango_layout_get_text (layout), line->start_index);
break;
}
} while (pango_layout_iter_next_line (iter));
pango_layout_iter_free (iter);
}
pango_layout_get_pixel_extents (layout, &ink, &logical);
// g_warning ("\tlogical\t[x %d, y %d, w %d, h %d][x %d, y %d, w %d, h %d]", logical.x, logical.y, logical.width, logical.height, ink.x, ink.y, ink.width, ink.height);
if ((fmt->formatFlags & StringFormatFlagsNoFitBlackBox) == 0) {
/* By default don't allow overhang - ink space may be larger than logical space */
if (fmt->formatFlags & StringFormatFlagsDirectionVertical) {
box->X = min (ink.y, logical.y);
box->Y = min (ink.x, logical.x);
box->Height = max (ink.width, logical.width);
box->Width = max (ink.height, logical.height);
} else {
box->X = min (ink.x, logical.x);
box->Y = min (ink.y, logical.y);
box->Height = max (ink.height, logical.height);
box->Width = max (ink.width, logical.width);
}
} else {
/* Allow overhang */
if (fmt->formatFlags & StringFormatFlagsDirectionVertical) {
box->X = logical.y;
box->Y = logical.x;
box->Height = logical.width;
box->Width = logical.height;
} else {
box->X = logical.x;
box->Y = logical.y;
box->Height = logical.height;
box->Width = logical.width;
}
}
// g_warning ("\tbox\t[x %g, y %g, w %g, h %g]", box->X, box->Y, box->Width, box->Height);
/* vertical alignment*/
if (fmt->formatFlags & StringFormatFlagsDirectionVertical) {
switch (fmt->lineAlignment) {
case StringAlignmentNear:
break;
case StringAlignmentCenter:
box->X += (rc->Width - box->Width) / 2;
break;
case StringAlignmentFar:
box->X += (rc->Width - box->Width);
break;
}
} else {
switch (fmt->lineAlignment) {
case StringAlignmentNear:
break;
case StringAlignmentCenter:
box->Y += (rc->Height - box->Height) / 2;
break;
case StringAlignmentFar:
box->Y += (rc->Height - box->Height);
break;
}
}
// g_warning ("va-box\t[x %g, y %g, w %g, h %g]", box->X, box->Y, box->Width, box->Height);
pango_cairo_update_layout (graphics->ct, layout);
return layout;
}
static boolean pango_textlayout(textspan_t * span, char **fontpath)
{
static char buf[1024]; /* returned in fontpath, only good until next call */
static PangoFontMap *fontmap;
static PangoContext *context;
static PangoFontDescription *desc;
static char *fontname;
static double fontsize;
static gv_font_map* gv_fmap;
char *fnt, *psfnt = NULL;
PangoLayout *layout;
PangoRectangle logical_rect;
cairo_font_options_t* options;
PangoFont *font;
#ifdef ENABLE_PANGO_MARKUP
PangoAttrList *attrs;
GError *error = NULL;
int flags;
#endif
char *text;
double textlayout_scale;
PostscriptAlias *pA;
if (!context) {
fontmap = pango_cairo_font_map_new();
gv_fmap = get_font_mapping(fontmap);
#ifdef HAVE_PANGO_FONT_MAP_CREATE_CONTEXT
context = pango_font_map_create_context (fontmap);
#else
context = pango_cairo_font_map_create_context (PANGO_CAIRO_FONT_MAP(fontmap));
#endif
options=cairo_font_options_create();
cairo_font_options_set_antialias(options,CAIRO_ANTIALIAS_GRAY);
cairo_font_options_set_hint_style(options,CAIRO_HINT_STYLE_FULL);
cairo_font_options_set_hint_metrics(options,CAIRO_HINT_METRICS_ON);
cairo_font_options_set_subpixel_order(options,CAIRO_SUBPIXEL_ORDER_BGR);
pango_cairo_context_set_font_options(context, options);
pango_cairo_context_set_resolution(context, FONT_DPI);
cairo_font_options_destroy(options);
g_object_unref(fontmap);
}
if (!fontname || strcmp(fontname, span->font->name) != 0 || fontsize != span->font->size) {
fontname = span->font->name;
fontsize = span->font->size;
pango_font_description_free (desc);
pA = span->font->postscript_alias;
if (pA) {
psfnt = fnt = gv_fmap[pA->xfig_code].gv_font;
if(!psfnt)
psfnt = fnt = pango_psfontResolve (pA);
}
else
fnt = fontname;
desc = pango_font_description_from_string(fnt);
/* all text layout is done at a scale of FONT_DPI (nominaly 96.) */
pango_font_description_set_size (desc, (gint)(fontsize * PANGO_SCALE));
if (fontpath && (font = pango_font_map_load_font(fontmap, context, desc))) { /* -v support */
const char *fontclass;
fontclass = G_OBJECT_CLASS_NAME(G_OBJECT_GET_CLASS(font));
buf[0] = '\0';
if (psfnt) {
strcat(buf, "(ps:pango ");
strcat(buf, psfnt);
strcat(buf, ") ");
}
strcat(buf, "(");
strcat(buf, fontclass);
strcat(buf, ") ");
#ifdef HAVE_PANGO_FC_FONT_LOCK_FACE
if (strcmp(fontclass, "PangoCairoFcFont") == 0) {
FT_Face face;
PangoFcFont *fcfont;
FT_Stream stream;
FT_StreamDesc streamdesc;
fcfont = PANGO_FC_FONT(font);
face = pango_fc_font_lock_face(fcfont);
if (face) {
strcat(buf, "\"");
strcat(buf, face->family_name);
strcat(buf, ", ");
strcat(buf, face->style_name);
strcat(buf, "\" ");
stream = face->stream;
if (stream) {
streamdesc = stream->pathname;
if (streamdesc.pointer)
strcat(buf, (char*)streamdesc.pointer);
else
strcat(buf, "*no pathname available*");
}
else
strcat(buf, "*no stream available*");
}
pango_fc_font_unlock_face(fcfont);
}
else
#endif
{
PangoFontDescription *tdesc;
char *tfont;
tdesc = pango_font_describe(font);
tfont = pango_font_description_to_string(tdesc);
strcat(buf, "\"");
strcat(buf, tfont);
strcat(buf, "\" ");
g_free(tfont);
}
*fontpath = buf;
}
}
#ifdef ENABLE_PANGO_MARKUP
if ((span->font) && (flags = span->font->flags)) {
unsigned char buf[BUFSIZ];
agxbuf xb;
agxbinit(&xb, BUFSIZ, buf);
agxbput(&xb,"<span");
if (flags & HTML_BF)
agxbput(&xb," weight=\"bold\"");
if (flags & HTML_IF)
agxbput(&xb," style=\"italic\"");
if (flags & HTML_UL)
agxbput(&xb," underline=\"single\"");
if (flags & HTML_S)
agxbput(&xb," strikethrough=\"true\"");
agxbput (&xb,">");
if (flags & HTML_SUP)
agxbput(&xb,"<sup>");
if (flags & HTML_SUB)
agxbput(&xb,"<sub>");
agxbput (&xb,xml_string0(span->str, TRUE));
if (flags & HTML_SUB)
agxbput(&xb,"</sub>");
if (flags & HTML_SUP)
agxbput(&xb,"</sup>");
agxbput (&xb,"</span>");
if (!pango_parse_markup (agxbuse(&xb), -1, 0, &attrs, &text, NULL, &error)) {
fprintf (stderr, "Error - pango_parse_markup: %s\n", error->message);
text = span->str;
attrs = NULL;
}
agxbfree (&xb);
}
else {
text = span->str;
attrs = NULL;
}
#else
text = span->str;
#endif
layout = pango_layout_new (context);
span->layout = (void *)layout; /* layout free with textspan - see labels.c */
span->free_layout = pango_free_layout; /* function for freeing pango layout */
pango_layout_set_text (layout, text, -1);
pango_layout_set_font_description (layout, desc);
#ifdef ENABLE_PANGO_MARKUP
if (attrs)
pango_layout_set_attributes (layout, attrs);
#endif
pango_layout_get_extents (layout, NULL, &logical_rect);
/* if pango doesn't like the font then it sets width=0 but height = garbage */
if (logical_rect.width == 0)
logical_rect.height = 0;
textlayout_scale = POINTS_PER_INCH / (FONT_DPI * PANGO_SCALE);
span->size.x = (int)(logical_rect.width * textlayout_scale + 1); /* round up so that width/height are never too small */
span->size.y = (int)(logical_rect.height * textlayout_scale + 1);
/* FIXME -- Horrible kluge !!! */
/* For now we are using pango for single line blocks only.
* The logical_rect.height seems to be too high from the font metrics on some platforms.
* Use an assumed height based on the point size.
*/
span->size.y = (int)(span->font->size * 1.1 + .5);
/* The y offset from baseline to 0,0 of the bitmap representation */
#if !defined(WIN32) && defined PANGO_VERSION_MAJOR && (PANGO_VERSION_MAJOR >= 1)
span->yoffset_layout = pango_layout_get_baseline (layout) * textlayout_scale;
#else
{
/* do it the hard way on rhel5/centos5 */
PangoLayoutIter *iter = pango_layout_get_iter (layout);
span->yoffset_layout = pango_layout_iter_get_baseline (iter) * textlayout_scale;
}
#endif
/* The distance below midline for y centering of text strings */
span->yoffset_centerline = 0.2 * span->font->size;
if (logical_rect.width == 0)
return FALSE;
return TRUE;
}
static gboolean
layout_is_ellipsized(PangoLayout *layout)
{
/* pango_layout_is_ellipsized() is a new function in Pango-1.16; we
* emulate it here by trying to look for the ellipsis run
*/
PangoLogAttr *log_attrs;
int n_attrs;
PangoLayoutIter *iter;
gboolean result = FALSE;
/* Short circuit when we aren't ellipsizing at all */
if (pango_layout_get_ellipsize(layout) == PANGO_ELLIPSIZE_NONE)
return FALSE;
pango_layout_get_log_attrs(layout, &log_attrs, &n_attrs);
iter = pango_layout_get_iter(layout);
do {
PangoGlyphItem *run;
int n_glyphs;
int start_index;
int n_graphemes;
int i;
run = pango_layout_iter_get_run(iter);
if (!run)
continue;
n_glyphs = run->glyphs->num_glyphs;
start_index = pango_layout_iter_get_index(iter);
/* Check the number of clusters in the run ... if it is greater
* than 1, then it isn't an ellipsis
*/
if (run->glyphs->log_clusters[0] != run->glyphs->log_clusters[n_glyphs - 1])
continue;
/* Now check the number of graphemes in the run ... if it is less
* than 3, it's probably an isolated 'fi' ligature or something
* like that rather than an ellipsis.
*/
n_graphemes = 0;
for (i = 0; i < run->item->num_chars && i + start_index < n_attrs; i++)
if (log_attrs[i + start_index].is_cursor_position)
n_graphemes++;
if (n_graphemes < 3)
continue;
/* OK, at this point it is probably an ellipsis; it's possible that
* the text consists of just the letters 'ffi' and the font has a ligature
* for that or something, but it's not too likely.
*/
result = TRUE;
break;
} while (pango_layout_iter_next_run(iter));
pango_layout_iter_free(iter);
g_free(log_attrs);
return result;
}
void text_wrapper::DoLayout(void)
{
// THE function
// first some sanity checks
if ( default_font == NULL ) return;
if ( uni32_length <= 0 || utf8_length <= 0 ) return;
// prepare the pangolayout object
{
//char *tc = pango_font_description_to_string(default_font->descr);
//printf("layout with %s\n", tc);
//free(tc);
}
pango_layout_set_font_description(pLayout, default_font->descr);
pango_layout_set_text(pLayout, utf8_text, utf8_length);
// reset the glyph string
if ( glyph_text ) free(glyph_text);
glyph_text = NULL;
glyph_length = 0;
double pango_to_ink = (1.0 / ((double)PANGO_SCALE)); // utility
int max_g = 0;
PangoLayoutIter *pIter = pango_layout_get_iter(pLayout); // and go!
do {
PangoLayoutLine *pLine = pango_layout_iter_get_line(pIter); // no need for unref
int plOffset = pLine->start_index; // start of the line in the uni32_text
PangoRectangle ink_r, log_r;
pango_layout_iter_get_line_extents(pIter, &ink_r, &log_r);
double plY = (1.0 / ((double)PANGO_SCALE)) * ((double)log_r.y); // start position of this line of the layout
double plX = (1.0 / ((double)PANGO_SCALE)) * ((double)log_r.x);
GSList *curR = pLine->runs; // get ready to iterate over the runs of this line
while ( curR ) {
PangoLayoutRun *pRun = (PangoLayoutRun*)curR->data;
if ( pRun ) {
int prOffset = pRun->item->offset; // start of the run in the line
// a run has uniform font/directionality/etc...
int o_g_l = glyph_length; // save the index of the first glyph we'll add
for (int i = 0; i < pRun->glyphs->num_glyphs; i++) { // add glyph sequentially, reading them from the run
// realloc the structures
if ( glyph_length >= max_g ) {
max_g = 2 * glyph_length + 1;
one_glyph *newdata = static_cast<one_glyph*>(realloc(glyph_text, (max_g + 1) * sizeof(one_glyph)));
if (newdata != NULL)
{
glyph_text = newdata;
}
else
{
g_warning("Failed to reallocate glyph_text");
}
}
// fill the glyph info
glyph_text[glyph_length].font = pRun->item->analysis.font;
glyph_text[glyph_length].gl = pRun->glyphs->glyphs[i].glyph;
glyph_text[glyph_length].uni_st = plOffset + prOffset + pRun->glyphs->log_clusters[i];
// depending on the directionality, the last uni32 codepoint for this glyph is the first of the next char
// or the first of the previous
if ( pRun->item->analysis.level == 1 ) {
// rtl
if ( i < pRun->glyphs->num_glyphs - 1 ) {
glyph_text[glyph_length + 1].uni_en = glyph_text[glyph_length].uni_st;
}
glyph_text[glyph_length].uni_dir = 1;
glyph_text[glyph_length + 1].uni_dir = 1; // set the directionality for the next too, so that the last glyph in
// the array has the correct direction
} else {
// ltr
if ( i > 0 ) {
glyph_text[glyph_length - 1].uni_en = glyph_text[glyph_length].uni_st;
}
glyph_text[glyph_length].uni_dir = 0;
glyph_text[glyph_length + 1].uni_dir = 0;
}
// set the position
// the layout is an infinite line
glyph_text[glyph_length].x = plX + pango_to_ink * ((double)pRun->glyphs->glyphs[i].geometry.x_offset);
glyph_text[glyph_length].y = plY + pango_to_ink * ((double)pRun->glyphs->glyphs[i].geometry.y_offset);
// advance to the next glyph
plX += pango_to_ink * ((double)pRun->glyphs->glyphs[i].geometry.width);
// and set the next glyph's position, in case it's the terminating glyph
glyph_text[glyph_length + 1].x = plX;
glyph_text[glyph_length + 1].y = plY;
glyph_length++;
}
// and finish filling the info
// notably, the uni_en of the last char in ltr text and the uni_en of the first in rtl are still not set
if ( pRun->item->analysis.level == 1 ) {
// rtl
if ( glyph_length > o_g_l ) glyph_text[o_g_l].uni_en = plOffset + prOffset + pRun->item->length;
} else {
if ( glyph_length > 0 ) glyph_text[glyph_length - 1].uni_en = plOffset + prOffset + pRun->item->length;
}
// the terminating glyph has glyph_id=0 because it means 'no glyph'
glyph_text[glyph_length].gl = 0;
// and is associated with no text (but you cannot set uni_st=uni_en=0, because the termination
// is expected to be the glyph for the termination of the uni32_text)
glyph_text[glyph_length].uni_st = glyph_text[glyph_length].uni_en = plOffset + prOffset + pRun->item->length;
}
curR = curR->next;
}
} while ( pango_layout_iter_next_line(pIter) );
pango_layout_iter_free(pIter);
// grunt work done. now some additional info for layout: computing letters, mostly (one letter = several glyphs sometimes)
PangoLogAttr *pAttrs = NULL;
int nbAttr = 0;
// get the layout attrs, they hold the boundaries pango computed
pango_layout_get_log_attrs(pLayout, &pAttrs, &nbAttr);
// feed to MakeTextBoundaries which knows what to do with these
MakeTextBoundaries(pAttrs, nbAttr);
// the array of boundaries is full, but out-of-order
SortBoundaries();
// boundary array is ready to be used, call chunktext to fill the *_start fields of the glyphs, and compute
// the boxed version of the text for sp-typeset
ChunkText();
// get rid of the attributes
if ( pAttrs ) g_free(pAttrs);
// cleaning up
for (int i = 0; i < glyph_length; i++) {
glyph_text[i].uni_st = uni32_codepoint[glyph_text[i].uni_st];
glyph_text[i].uni_en = uni32_codepoint[glyph_text[i].uni_en];
glyph_text[i].x /= 512; // why is this not default_font->daddy->fontsize?
glyph_text[i].y /= 512;
}
if ( glyph_length > 0 ) {
glyph_text[glyph_length].x /= 512;
glyph_text[glyph_length].y /= 512;
}
}
static void
dump_runs (PangoLayout *layout, GString *string)
{
PangoLayoutIter *iter;
PangoLayoutRun *run;
PangoItem *item;
const gchar *text;
gint index, index2;
gboolean has_more;
gchar *char_str;
gint i;
gchar *font;
text = pango_layout_get_text (layout);
iter = pango_layout_get_iter (layout);
has_more = TRUE;
index = pango_layout_iter_get_index (iter);
i = 0;
while (has_more)
{
run = pango_layout_iter_get_run (iter);
has_more = pango_layout_iter_next_run (iter);
i++;
if (has_more)
{
index2 = pango_layout_iter_get_index (iter);
char_str = g_strndup (text + index, index2 - index);
}
else
{
char_str = g_strdup (text + index);
}
if (run)
{
item = ((PangoGlyphItem*)run)->item;
font = font_name (item->analysis.font);
g_string_append_printf (string, "i=%d, index=%d, chars=%d, level=%d, gravity=%s, flags=%d, font=%s, script=%s, language=%s, '%s'\n",
i, index, item->num_chars, item->analysis.level,
gravity_name (item->analysis.gravity),
item->analysis.flags,
"OMITTED", /* for some reason, this fails on build.gnome.org, so leave it out */
script_name (item->analysis.script),
pango_language_to_string (item->analysis.language),
char_str);
dump_extra_attrs (item->analysis.extra_attrs, string);
g_free (font);
}
else
{
g_string_append_printf (string, "i=%d, index=%d, no run, line end\n",
i, index);
}
g_free (char_str);
index = index2;
}
pango_layout_iter_free (iter);
}
static void
render_para (GdkDrawable *drawable,
GtkTextRenderState *render_state,
GtkTextLineDisplay *line_display,
/* Top-left corner of paragraph including all margins */
int x,
int y,
int selection_start_index,
int selection_end_index,
GList **widgets)
{
GSList *shaped_pointer = line_display->shaped_objects;
PangoLayout *layout = line_display->layout;
int byte_offset = 0;
PangoLayoutIter *iter;
PangoRectangle layout_logical;
int screen_width;
GdkGC *fg_gc, *bg_gc;
gint state;
gboolean first = TRUE;
iter = pango_layout_get_iter (layout);
pango_layout_iter_get_layout_extents (iter, NULL, &layout_logical);
/* Adjust for margins */
layout_logical.x += line_display->x_offset * PANGO_SCALE;
layout_logical.y += line_display->top_margin * PANGO_SCALE;
screen_width = line_display->total_width;
if (GTK_WIDGET_HAS_FOCUS (render_state->widget))
state = GTK_STATE_SELECTED;
else
state = GTK_STATE_ACTIVE;
fg_gc = render_state->widget->style->text_gc [state];
bg_gc = render_state->widget->style->base_gc [state];
do
{
PangoLayoutLine *line = pango_layout_iter_get_line (iter);
int selection_y, selection_height;
int first_y, last_y;
PangoRectangle line_rect;
int baseline;
pango_layout_iter_get_line_extents (iter, NULL, &line_rect);
baseline = pango_layout_iter_get_baseline (iter);
pango_layout_iter_get_line_yrange (iter, &first_y, &last_y);
/* Adjust for margins */
line_rect.x += line_display->x_offset * PANGO_SCALE;
line_rect.y += line_display->top_margin * PANGO_SCALE;
baseline += line_display->top_margin * PANGO_SCALE;
/* Selection is the height of the line, plus top/bottom
* margin if we're the first/last line
*/
selection_y = y + PANGO_PIXELS (first_y) + line_display->top_margin;
selection_height = PANGO_PIXELS (last_y) - PANGO_PIXELS (first_y);
if (first)
{
selection_y -= line_display->top_margin;
selection_height += line_display->top_margin;
}
if (pango_layout_iter_at_last_line (iter))
selection_height += line_display->bottom_margin;
first = FALSE;
if (selection_start_index < byte_offset &&
selection_end_index > line->length + byte_offset) /* All selected */
{
gdk_draw_rectangle (drawable,
bg_gc,
TRUE,
x + line_display->left_margin,
selection_y,
screen_width,
selection_height);
render_layout_line (drawable, render_state, line, &shaped_pointer,
x + PANGO_PIXELS (line_rect.x),
y + PANGO_PIXELS (baseline),
TRUE,
widgets);
}
else
{
GSList *shaped_pointer_tmp = shaped_pointer;
render_layout_line (drawable, render_state,
line, &shaped_pointer,
x + PANGO_PIXELS (line_rect.x),
y + PANGO_PIXELS (baseline),
FALSE,
widgets);
if (selection_start_index <= byte_offset + line->length &&
selection_end_index > byte_offset) /* Some selected */
{
GdkRegion *clip_region = get_selected_clip (render_state, layout, line,
x + line_display->x_offset,
selection_y,
selection_height,
selection_start_index, selection_end_index);
gdk_gc_set_clip_region (fg_gc, clip_region);
gdk_gc_set_clip_region (bg_gc, clip_region);
gdk_draw_rectangle (drawable,
bg_gc,
TRUE,
x + PANGO_PIXELS (line_rect.x),
selection_y,
PANGO_PIXELS (line_rect.width),
selection_height);
render_layout_line (drawable, render_state, line, &shaped_pointer_tmp,
x + PANGO_PIXELS (line_rect.x),
y + PANGO_PIXELS (baseline),
TRUE,
widgets);
gdk_gc_set_clip_region (fg_gc, NULL);
gdk_gc_set_clip_region (bg_gc, NULL);
gdk_region_destroy (clip_region);
/* Paint in the ends of the line */
if (line_rect.x > line_display->left_margin * PANGO_SCALE &&
((line_display->direction == GTK_TEXT_DIR_LTR && selection_start_index < byte_offset) ||
(line_display->direction == GTK_TEXT_DIR_RTL && selection_end_index > byte_offset + line->length)))
{
gdk_draw_rectangle (drawable,
bg_gc,
TRUE,
x + line_display->left_margin,
selection_y,
PANGO_PIXELS (line_rect.x) - line_display->left_margin,
selection_height);
}
if (line_rect.x + line_rect.width <
(screen_width + line_display->left_margin) * PANGO_SCALE &&
((line_display->direction == GTK_TEXT_DIR_LTR && selection_end_index > byte_offset + line->length) ||
(line_display->direction == GTK_TEXT_DIR_RTL && selection_start_index < byte_offset)))
{
int nonlayout_width;
nonlayout_width =
line_display->left_margin + screen_width -
PANGO_PIXELS (line_rect.x) - PANGO_PIXELS (line_rect.width);
gdk_draw_rectangle (drawable,
bg_gc,
TRUE,
x + PANGO_PIXELS (line_rect.x) + PANGO_PIXELS (line_rect.width),
selection_y,
nonlayout_width,
selection_height);
}
}
}
byte_offset += line->length;
}
while (pango_layout_iter_next_line (iter));
pango_layout_iter_free (iter);
}
static PyObject *
pango_GetLayoutCharPos(PyObject *self, PyObject *args) {
int i, len, w, h;
double baseline, x, y, width, height, dx, dy;
void *LayoutObj;
PangoLayout *layout;
PangoLayoutIter *iter;
PangoRectangle rect;
PyObject *ret;
PyObject *glyph_data;
if (!PyArg_ParseTuple(args, "Oi", &LayoutObj, &len)) {
return NULL;
}
layout = PyCObject_AsVoidPtr(LayoutObj);
pango_layout_get_size(layout, &w, &h);
dx = 0.0;
if (pango_layout_get_alignment(layout) == PANGO_ALIGN_CENTER) {
dx = -0.5 * ((double) w) / PANGO_SCALE;
} else if (pango_layout_get_alignment(layout) == PANGO_ALIGN_RIGHT) {
dx = -1.0 * ((double) w) / PANGO_SCALE;
}
ret = PyTuple_New(len);
iter = pango_layout_get_iter(layout);
dy = ((double) pango_layout_iter_get_baseline(iter)) / PANGO_SCALE;
for (i = 0; i < len; i++) {
glyph_data = PyTuple_New(5);
pango_layout_iter_get_char_extents(iter, &rect);
x = ((double) rect.x) / PANGO_SCALE + dx;
PyTuple_SetItem(glyph_data, 0, PyFloat_FromDouble(x));
y = -1.0 * ((double) rect.y) / PANGO_SCALE + dy;
PyTuple_SetItem(glyph_data, 1, PyFloat_FromDouble(y));
width = ((double) rect.width) / PANGO_SCALE;
PyTuple_SetItem(glyph_data, 2, PyFloat_FromDouble(width));
height = ((double) rect.height) / PANGO_SCALE;
PyTuple_SetItem(glyph_data, 3, PyFloat_FromDouble(height));
baseline = -1.0 * ((double) pango_layout_iter_get_baseline(iter))
/ PANGO_SCALE + dy;
PyTuple_SetItem(glyph_data, 4, PyFloat_FromDouble(baseline));
pango_layout_iter_next_char(iter);
PyTuple_SetItem(ret, i, glyph_data);
}
pango_layout_iter_free(iter);
return ret;
}
static void
draw_string(DiaRenderer *self,
const char *text,
Point *pos, Alignment alignment,
Color *color)
{
DiaCairoRenderer *renderer = DIA_CAIRO_RENDERER (self);
int len = strlen(text);
DIAG_NOTE(g_message("draw_string(%d) %f,%f %s",
len, pos->x, pos->y, text));
if (len < 1) return; /* shouldn't this be handled by Dia's core ? */
cairo_set_source_rgba (renderer->cr, color->red, color->green, color->blue, 1.0);
#ifdef HAVE_PANGOCAIRO_H
cairo_save (renderer->cr);
/* alignment calculation done by pangocairo? */
pango_layout_set_alignment (renderer->layout, alignment == ALIGN_CENTER ? PANGO_ALIGN_CENTER :
alignment == ALIGN_RIGHT ? PANGO_ALIGN_RIGHT : PANGO_ALIGN_LEFT);
pango_layout_set_text (renderer->layout, text, len);
{
PangoLayoutIter *iter = pango_layout_get_iter(renderer->layout);
int bline = pango_layout_iter_get_baseline(iter);
/* although we give the alignment above we need to adjust the start point */
PangoRectangle extents;
int shift;
pango_layout_iter_get_line_extents (iter, NULL, &extents);
shift = alignment == ALIGN_CENTER ? PANGO_RBEARING(extents)/2 :
alignment == ALIGN_RIGHT ? PANGO_RBEARING(extents) : 0;
cairo_move_to (renderer->cr, pos->x - (double)shift / PANGO_SCALE, pos->y - (double)bline / PANGO_SCALE);
pango_layout_iter_free (iter);
}
/* does this hide bug #341481? */
pango_cairo_update_context (renderer->cr, pango_layout_get_context (renderer->layout));
pango_layout_context_changed (renderer->layout);
pango_cairo_show_layout (renderer->cr, renderer->layout);
cairo_restore (renderer->cr);
#else
/* using the 'toy API' */
{
cairo_text_extents_t extents;
double x = 0, y = 0;
cairo_set_source_rgba (renderer->cr, color->red, color->green, color->blue, 1.0);
cairo_text_extents (renderer->cr,
text,
&extents);
y = pos->y; /* ?? */
switch (alignment) {
case ALIGN_LEFT:
x = pos->x;
break;
case ALIGN_CENTER:
x = pos->x - extents.width / 2 + +extents.x_bearing;
break;
case ALIGN_RIGHT:
x = pos->x - extents.width + extents.x_bearing;
break;
}
cairo_move_to (renderer->cr, x, y);
cairo_show_text (renderer->cr, text);
}
#endif
DIAG_STATE(renderer->cr)
}
static void
gimp_text_tool_move_cursor (GimpTextTool *text_tool,
GtkMovementStep step,
gint count,
gboolean extend_selection)
{
GtkTextBuffer *buffer = GTK_TEXT_BUFFER (text_tool->buffer);
GtkTextIter cursor;
GtkTextIter selection;
GtkTextIter *sel_start;
gboolean cancel_selection = FALSE;
gint x_pos = -1;
GIMP_LOG (TEXT_EDITING, "%s count = %d, select = %s",
g_enum_get_value (g_type_class_ref (GTK_TYPE_MOVEMENT_STEP),
step)->value_name,
count,
extend_selection ? "TRUE" : "FALSE");
gtk_text_buffer_get_iter_at_mark (buffer, &cursor,
gtk_text_buffer_get_insert (buffer));
gtk_text_buffer_get_iter_at_mark (buffer, &selection,
gtk_text_buffer_get_selection_bound (buffer));
if (extend_selection)
{
sel_start = &selection;
}
else
{
/* when there is a selection, moving the cursor without
* extending it should move the cursor to the end of the
* selection that is in moving direction
*/
if (count > 0)
gtk_text_iter_order (&selection, &cursor);
else
gtk_text_iter_order (&cursor, &selection);
sel_start = &cursor;
/* if we actually have a selection, just move *to* the beginning/end
* of the selection and not *from* there on LOGICAL_POSITIONS
* and VISUAL_POSITIONS movement
*/
if (! gtk_text_iter_equal (&cursor, &selection))
cancel_selection = TRUE;
}
switch (step)
{
case GTK_MOVEMENT_LOGICAL_POSITIONS:
if (! cancel_selection)
gtk_text_iter_forward_visible_cursor_positions (&cursor, count);
break;
case GTK_MOVEMENT_VISUAL_POSITIONS:
if (! cancel_selection)
{
PangoLayout *layout;
const gchar *text;
if (! gimp_text_tool_ensure_layout (text_tool))
break;
layout = gimp_text_layout_get_pango_layout (text_tool->layout);
text = pango_layout_get_text (layout);
while (count != 0)
{
const gunichar word_joiner = 8288; /*g_utf8_get_char(WORD_JOINER);*/
gint index;
gint trailing = 0;
gint new_index;
index = gimp_text_buffer_get_iter_index (text_tool->buffer,
&cursor, TRUE);
if (count > 0)
{
if (g_utf8_get_char (text + index) == word_joiner)
pango_layout_move_cursor_visually (layout, TRUE,
index, 0, 1,
&new_index, &trailing);
else
new_index = index;
pango_layout_move_cursor_visually (layout, TRUE,
new_index, trailing, 1,
&new_index, &trailing);
count--;
}
else
{
pango_layout_move_cursor_visually (layout, TRUE,
index, 0, -1,
&new_index, &trailing);
if (new_index != -1 && new_index != G_MAXINT &&
g_utf8_get_char (text + new_index) == word_joiner)
{
pango_layout_move_cursor_visually (layout, TRUE,
new_index, trailing, -1,
&new_index, &trailing);
}
count++;
}
if (new_index != G_MAXINT && new_index != -1)
index = new_index;
else
break;
gimp_text_buffer_get_iter_at_index (text_tool->buffer,
&cursor, index, TRUE);
gtk_text_iter_forward_chars (&cursor, trailing);
}
}
break;
case GTK_MOVEMENT_WORDS:
if (count < 0)
{
gtk_text_iter_backward_visible_word_starts (&cursor, -count);
}
else if (count > 0)
{
if (! gtk_text_iter_forward_visible_word_ends (&cursor, count))
gtk_text_iter_forward_to_line_end (&cursor);
}
break;
case GTK_MOVEMENT_DISPLAY_LINES:
{
GtkTextIter start;
GtkTextIter end;
gint cursor_index;
PangoLayout *layout;
PangoLayoutLine *layout_line;
PangoLayoutIter *layout_iter;
PangoRectangle logical;
gint line;
gint trailing;
gint i;
gtk_text_buffer_get_bounds (buffer, &start, &end);
cursor_index = gimp_text_buffer_get_iter_index (text_tool->buffer,
&cursor, TRUE);
if (! gimp_text_tool_ensure_layout (text_tool))
break;
layout = gimp_text_layout_get_pango_layout (text_tool->layout);
pango_layout_index_to_line_x (layout, cursor_index, FALSE,
&line, &x_pos);
layout_iter = pango_layout_get_iter (layout);
for (i = 0; i < line; i++)
pango_layout_iter_next_line (layout_iter);
pango_layout_iter_get_line_extents (layout_iter, NULL, &logical);
x_pos += logical.x;
pango_layout_iter_free (layout_iter);
/* try to go to the remembered x_pos if it exists *and* we are at
* the beginning or at the end of the current line
*/
if (text_tool->x_pos != -1 && (x_pos <= logical.x ||
x_pos >= logical.x + logical.width))
x_pos = text_tool->x_pos;
line += count;
if (line < 0)
{
cursor = start;
break;
}
else if (line >= pango_layout_get_line_count (layout))
{
cursor = end;
break;
}
layout_iter = pango_layout_get_iter (layout);
for (i = 0; i < line; i++)
pango_layout_iter_next_line (layout_iter);
layout_line = pango_layout_iter_get_line_readonly (layout_iter);
pango_layout_iter_get_line_extents (layout_iter, NULL, &logical);
pango_layout_iter_free (layout_iter);
pango_layout_line_x_to_index (layout_line, x_pos - logical.x,
&cursor_index, &trailing);
gimp_text_buffer_get_iter_at_index (text_tool->buffer, &cursor,
cursor_index, TRUE);
while (trailing--)
gtk_text_iter_forward_char (&cursor);
}
break;
case GTK_MOVEMENT_PAGES: /* well... */
case GTK_MOVEMENT_BUFFER_ENDS:
if (count < 0)
{
gtk_text_buffer_get_start_iter (buffer, &cursor);
}
else if (count > 0)
{
gtk_text_buffer_get_end_iter (buffer, &cursor);
}
break;
case GTK_MOVEMENT_PARAGRAPH_ENDS:
if (count < 0)
{
gtk_text_iter_set_line_offset (&cursor, 0);
}
else if (count > 0)
{
if (! gtk_text_iter_ends_line (&cursor))
gtk_text_iter_forward_to_line_end (&cursor);
}
break;
case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
if (count < 0)
{
gtk_text_iter_set_line_offset (&cursor, 0);
}
else if (count > 0)
{
if (! gtk_text_iter_ends_line (&cursor))
gtk_text_iter_forward_to_line_end (&cursor);
}
break;
default:
return;
}
text_tool->x_pos = x_pos;
gimp_draw_tool_pause (GIMP_DRAW_TOOL (text_tool));
gimp_text_tool_reset_im_context (text_tool);
gtk_text_buffer_select_range (buffer, &cursor, sel_start);
gimp_draw_tool_resume (GIMP_DRAW_TOOL (text_tool));
}
bool PangoFontInfo::CanRenderString(const char* utf8_word, int len,
vector<string>* graphemes) const {
if (graphemes) graphemes->clear();
// We check for font coverage of the text first, as otherwise Pango could
// (undesirably) fall back to another font that does have the required
// coverage.
if (!CoversUTF8Text(utf8_word, len)) {
return false;
}
// U+25CC dotted circle character that often (but not always) gets rendered
// when there is an illegal grapheme sequence.
const char32 kDottedCircleGlyph = 9676;
bool bad_glyph = false;
PangoFontMap* font_map = pango_cairo_font_map_get_default();
PangoContext* context = pango_context_new();
pango_context_set_font_map(context, font_map);
PangoLayout* layout;
{
// Pango is not relasing the cached layout.
DISABLE_HEAP_LEAK_CHECK;
layout = pango_layout_new(context);
}
if (desc_) {
pango_layout_set_font_description(layout, desc_);
} else {
PangoFontDescription *desc = pango_font_description_from_string(
DescriptionName().c_str());
pango_layout_set_font_description(layout, desc);
pango_font_description_free(desc);
}
pango_layout_set_text(layout, utf8_word, len);
PangoLayoutIter* run_iter = NULL;
{ // Fontconfig caches some information here that is not freed before exit.
DISABLE_HEAP_LEAK_CHECK;
run_iter = pango_layout_get_iter(layout);
}
do {
PangoLayoutRun* run = pango_layout_iter_get_run_readonly(run_iter);
if (!run) {
tlog(2, "Found end of line NULL run marker\n");
continue;
}
PangoGlyph dotted_circle_glyph;
PangoFont* font = run->item->analysis.font;
dotted_circle_glyph = pango_fc_font_get_glyph(
reinterpret_cast<PangoFcFont*>(font), kDottedCircleGlyph);
if (TLOG_IS_ON(2)) {
PangoFontDescription* desc = pango_font_describe(font);
char* desc_str = pango_font_description_to_string(desc);
tlog(2, "Desc of font in run: %s\n", desc_str);
g_free(desc_str);
pango_font_description_free(desc);
}
PangoGlyphItemIter cluster_iter;
gboolean have_cluster;
for (have_cluster = pango_glyph_item_iter_init_start(&cluster_iter,
run, utf8_word);
have_cluster && !bad_glyph;
have_cluster = pango_glyph_item_iter_next_cluster(&cluster_iter)) {
const int start_byte_index = cluster_iter.start_index;
const int end_byte_index = cluster_iter.end_index;
int start_glyph_index = cluster_iter.start_glyph;
int end_glyph_index = cluster_iter.end_glyph;
string cluster_text = string(utf8_word + start_byte_index,
end_byte_index - start_byte_index);
if (graphemes) graphemes->push_back(cluster_text);
if (IsUTF8Whitespace(cluster_text.c_str())) {
tlog(2, "Skipping whitespace\n");
continue;
}
if (TLOG_IS_ON(2)) {
printf("start_byte=%d end_byte=%d start_glyph=%d end_glyph=%d ",
start_byte_index, end_byte_index,
start_glyph_index, end_glyph_index);
}
for (int i = start_glyph_index,
step = (end_glyph_index > start_glyph_index) ? 1 : -1;
!bad_glyph && i != end_glyph_index; i+= step) {
const bool unknown_glyph =
(cluster_iter.glyph_item->glyphs->glyphs[i].glyph &
PANGO_GLYPH_UNKNOWN_FLAG);
const bool illegal_glyph =
(cluster_iter.glyph_item->glyphs->glyphs[i].glyph ==
dotted_circle_glyph);
bad_glyph = unknown_glyph || illegal_glyph;
if (TLOG_IS_ON(2)) {
printf("(%d=%d)", cluster_iter.glyph_item->glyphs->glyphs[i].glyph,
bad_glyph ? 1 : 0);
}
}
if (TLOG_IS_ON(2)) {
printf(" '%s'\n", cluster_text.c_str());
}
if (bad_glyph)
tlog(1, "Found illegal glyph!\n");
}
} while (!bad_glyph && pango_layout_iter_next_run(run_iter));
pango_layout_iter_free(run_iter);
g_object_unref(context);
g_object_unref(layout);
if (bad_glyph && graphemes) graphemes->clear();
return !bad_glyph;
}
static void
draw_str(struct gra2cairo_local *local, int draw, char *str, struct fontmap *font, int size, int space, int *fw, int *ah, int *dh)
{
PangoAttribute *attr;
PangoAttrList *alist;
PangoLayoutIter *piter;
int w, h, baseline;
if (size == 0 || str == NULL) {
if (fw)
*fw = 0;
if (ah)
*ah = 0;
if (dh)
*dh = 0;
return;
}
if (local->layout == NULL) {
local->layout = pango_cairo_create_layout(local->cairo);
}
alist = pango_attr_list_new();
attr = pango_attr_size_new_absolute(mxd2ph(local, size) * PANGO_SCALE);
pango_attr_list_insert(alist, attr);
attr = pango_attr_letter_spacing_new(mxd2ph(local, space) * PANGO_SCALE);
pango_attr_list_insert(alist, attr);
pango_layout_set_font_description(local->layout, font->font);
pango_layout_set_attributes(local->layout, alist);
pango_attr_list_unref(alist);
pango_layout_set_text(local->layout, str, -1);
pango_layout_get_pixel_size(local->layout, &w, &h);
piter = pango_layout_get_iter(local->layout);
baseline = pango_layout_iter_get_baseline(piter) / PANGO_SCALE;
if (fw)
*fw = w;
if (ah)
*ah = baseline;
if (dh)
*dh = h - baseline;
if (draw && str) {
double x, y;
double cx, cy;
x = - local->fontsin * baseline;
y = - local->fontcos * baseline;
cairo_get_current_point(local->cairo, &cx, &cy);
relative_move(local->cairo, x, y);
cairo_save(local->cairo);
cairo_rotate(local->cairo, -local->fontdir * G_PI / 180.);
pango_cairo_update_layout(local->cairo, local->layout);
if (local->text2path) {
pango_cairo_layout_path(local->cairo, local->layout);
cairo_fill(local->cairo);
cairo_restore(local->cairo);
cairo_move_to(local->cairo, cx + w * local->fontcos, cy - w * local->fontsin);
} else {
pango_cairo_show_layout(local->cairo, local->layout);
cairo_restore(local->cairo);
relative_move(local->cairo, w * local->fontcos - x, - w * local->fontsin - y);
}
}
pango_layout_iter_free(piter);
}
static VALUE
rg_iter(VALUE self)
{
return PANGOLAYOUTITER2RVAL(pango_layout_get_iter(_SELF(self)));
}
GpStatus
pango_MeasureString (GpGraphics *graphics, GDIPCONST WCHAR *stringUnicode, int length, GDIPCONST GpFont *font, GDIPCONST RectF *rc,
GDIPCONST GpStringFormat *format, RectF *boundingBox, int *codepointsFitted, int *linesFilled)
{
PangoLayout *layout;
PangoLayoutLine *line;
PangoRectangle logical;
PangoLayoutIter *iter;
int *charsRemoved = NULL;
cairo_save (graphics->ct);
layout = gdip_pango_setup_layout (graphics, stringUnicode, length, font, rc, boundingBox, format, &charsRemoved);
if (!layout) {
cairo_restore (graphics->ct);
return OutOfMemory;
}
if (codepointsFitted) {
int charsFitted;
int lastIndex;
int y0;
int y1;
double min_x;
double max_x;
double max_y;
const char *layoutText;
if (boundingBox && format && (format->formatFlags & StringFormatFlagsDirectionVertical)) {
min_x = boundingBox->Y;
max_x = boundingBox->Y + boundingBox->Height;
max_y = boundingBox->X + boundingBox->Width;
} else if (boundingBox) {
min_x = boundingBox->X;
max_x = boundingBox->X + boundingBox->Width;
max_y = boundingBox->Y + boundingBox->Height;
} else if (format && (format->formatFlags & StringFormatFlagsDirectionVertical)) {
min_x = rc->Y;
max_x = rc->Y + rc->Height;
max_y = rc->X + rc->Width;
} else {
min_x = rc->X;
max_x = rc->X + rc->Width;
max_y = rc->Y + rc->Height;
}
lastIndex = 0;
iter = pango_layout_get_iter (layout);
do {
if (iter == NULL)
break;
pango_layout_iter_get_line_yrange (iter, &y0, &y1);
if (y0 / PANGO_SCALE >= max_y)
break;
if (pango_layout_iter_at_last_line (iter)) {
do {
pango_layout_iter_get_char_extents (iter, &logical);
/* check both max and min to catch right-to-left text, also width may be negative */
if ((logical.x / PANGO_SCALE > max_x || (logical.x + logical.width) / PANGO_SCALE > max_x) || (logical.x / PANGO_SCALE < min_x || (logical.x + logical.width) / PANGO_SCALE < min_x))
break;
lastIndex = pango_layout_iter_get_index (iter);
} while (pango_layout_iter_next_char (iter));
break;
} else {
line = pango_layout_iter_get_line_readonly (iter);
lastIndex = line->start_index + line->length - 1;
}
} while (pango_layout_iter_next_line (iter));
pango_layout_iter_free (iter);
layoutText = pango_layout_get_text (layout);
/* this can happen when the string ends in a newline */
if (lastIndex >= strlen (layoutText))
lastIndex = strlen (layoutText) - 1;
/* Add back in any & characters removed and the final newline characters (if any) */
charsFitted = g_utf8_strlen (layoutText, lastIndex + 1) + charsRemoved [lastIndex];
//g_warning("lastIndex: %d\t\tcharsRemoved: %d", lastIndex, charsRemoved[lastIndex]);
/* safe because of null termination */
switch (layoutText [lastIndex + 1]) {
case '\r':
charsFitted++;
if (layoutText [lastIndex + 2] == '\n')
charsFitted++;
break;
case '\n':
charsFitted++;
break;
}
*codepointsFitted = charsFitted;
}
GdipFree (charsRemoved);
if (linesFilled) {
*linesFilled = pango_layout_get_line_count (layout);
// g_warning ("linesFilled %d", *linesFilled);
}
// else g_warning ("linesFilled %d", pango_layout_get_line_count (layout));
g_object_unref (layout);
cairo_restore (graphics->ct);
return Ok;
}
static void
create_pages (Pqueue * queue)
{
gchar * msg;
gdouble line_height;
guint i, id;
glong index;
PangoLayoutLine * line;
PangoRectangle ink_rect, logical_rect;
g_return_if_fail (queue);
g_return_if_fail (queue->pos < strlen(queue->text));
while (queue->pos < strlen (queue->text))
{
while (gtk_events_pending ())
gtk_main_iteration ();
for (i = 0; i < queue->lines_per_page; i++)
{
line = pango_layout_iter_get_line (queue->iter);
pango_layout_iter_next_line (queue->iter);
pango_layout_iter_get_line_extents (queue->iter, &ink_rect, &logical_rect);
index = pango_layout_iter_get_index (queue->iter);
if (index == 0)
{
i = queue->lines_per_page;
queue->pos = strlen (queue->text);
g_message ("%s", _("Error: Pango iter index is zero."));
continue;
}
line_height = logical_rect.height / PANGO_SCALE;
if ((queue->page_height + line_height) > (queue->height - (EDGE_MARGIN/2)))
{
queue->pos += index;
queue->page_height = EDGE_MARGIN;
gtk_progress_bar_pulse (queue->progressbar);
pango_cairo_update_layout (queue->cr, queue->layout);
queue->layout = make_new_page (queue->context, queue->desc, queue->height, queue->width);
i = queue->lines_per_page;
queue->page_count++;
pango_layout_set_text (queue->layout, (queue->text+queue->pos), -1);
queue->iter = pango_layout_get_iter (queue->layout);
pango_cairo_show_layout_line (queue->cr, line);
pango_cairo_update_layout (queue->cr, queue->layout);
cairo_show_page (queue->cr);
}
else
pango_cairo_show_layout_line (queue->cr, line);
queue->page_height += line_height;
cairo_move_to (queue->cr, SIDE_MARGIN / 2, queue->page_height);
}
}
pango_layout_iter_free (queue->iter);
gtk_progress_bar_set_fraction (queue->progressbar, 0.0);
cairo_surface_destroy(queue->surface);
pango_font_description_free (queue->desc);
g_object_unref (queue->context);
g_object_unref (queue->layout);
cairo_destroy (queue->cr);
id = gtk_statusbar_get_context_id (queue->statusbar, PACKAGE);
msg = g_strdup_printf (ngettext("Saved PDF file. (%ld page)",
"Saved PDF file (%ld pages).", queue->page_count), queue->page_count);
gtk_statusbar_push (queue->statusbar, id, msg);
g_free (msg);
}
/* split a text buffer into chunks using the passed Pango layout */
GList *
split_for_layout(PangoLayout * layout, const gchar * text,
PangoAttrList * attributes, BalsaPrintSetup * psetup,
gboolean is_header, GArray ** offsets)
{
GList *split_list = NULL;
PangoLayoutIter *iter;
const gchar *start;
gint p_offset;
gboolean add_tab;
gint p_y0;
gint p_y1;
gint p_y_pos;
gint p_height;
/* set the text and its attributes, then get an iter */
pango_layout_set_text(layout, text, -1);
if (attributes)
pango_layout_set_attributes(layout, attributes);
if (offsets)
*offsets = g_array_new(FALSE, FALSE, sizeof(guint));
iter = pango_layout_get_iter(layout);
/* loop over lines */
start = text;
p_offset = 0;
add_tab = FALSE;
p_y_pos = C_TO_P(psetup->c_y_pos);
p_height = C_TO_P(psetup->c_height);
do {
pango_layout_iter_get_line_yrange(iter, &p_y0, &p_y1);
if (p_y_pos + p_y1 - p_offset > p_height) {
gint index;
gint tr;
gchar *chunk;
gboolean ends_with_nl;
if (offsets) {
guint offs = start - text;
*offsets = g_array_append_val(*offsets, offs);
}
pango_layout_xy_to_index(layout, 0, p_y0, &index, &tr);
ends_with_nl = text[index - 1] == '\n';
if (ends_with_nl)
index--;
chunk = g_strndup(start, text + index - start);
if (add_tab)
split_list =
g_list_append(split_list,
g_strconcat("\t", chunk, NULL));
else
split_list = g_list_append(split_list, g_strdup(chunk));
add_tab = is_header && !ends_with_nl;
g_free(chunk);
start = text + index;
if (ends_with_nl)
start++;
if (*start == '\0')
p_y_pos = p_height;
else {
p_y_pos = 0;
psetup->page_count++;
}
p_offset = p_y0;
}
} while (pango_layout_iter_next_line(iter));
pango_layout_iter_free(iter);
/* append any remaining stuff */
if (*start != '\0') {
p_y_pos += p_y1 - p_offset;
if (offsets) {
guint offs = start - text;
*offsets = g_array_append_val(*offsets, offs);
}
if (add_tab)
split_list =
g_list_append(split_list, g_strconcat("\t", start, NULL));
else
split_list = g_list_append(split_list, g_strdup(start));
}
/* remember the new y position in cairo units */
psetup->c_y_pos = P_TO_C(p_y_pos);
/* return the list */
return split_list;
}
gboolean
text_get_extents (const gchar *fontname,
const gchar *text,
gint *width,
gint *height,
gint *ascent,
gint *descent)
{
PangoFontDescription *font_desc;
PangoContext *context;
PangoLayout *layout;
PangoFontMap *fontmap;
PangoRectangle rect;
g_return_val_if_fail (fontname != NULL, FALSE);
g_return_val_if_fail (text != NULL, FALSE);
fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
if (! fontmap)
g_error ("You are using a Pango that has been built against a cairo "
"that lacks the Freetype font backend");
pango_cairo_font_map_set_resolution (PANGO_CAIRO_FONT_MAP (fontmap),
72.0); /* FIXME: resolution */
context = pango_font_map_create_context (fontmap);
g_object_unref (fontmap);
layout = pango_layout_new (context);
g_object_unref (context);
font_desc = pango_font_description_from_string (fontname);
pango_layout_set_font_description (layout, font_desc);
pango_font_description_free (font_desc);
pango_layout_set_text (layout, text, -1);
pango_layout_get_pixel_extents (layout, NULL, &rect);
if (width)
*width = rect.width;
if (height)
*height = rect.height;
if (ascent || descent)
{
PangoLayoutIter *iter;
PangoLayoutLine *line;
iter = pango_layout_get_iter (layout);
line = pango_layout_iter_get_line_readonly (iter);
pango_layout_iter_free (iter);
pango_layout_line_get_pixel_extents (line, NULL, &rect);
if (ascent)
*ascent = PANGO_ASCENT (rect);
if (descent)
*descent = - PANGO_DESCENT (rect);
}
g_object_unref (layout);
return TRUE;
}
static PyObject *
pango_GetLayoutClusterPos(PyObject *self, PyObject *args) {
int i, len, w, h, index, prev_index;
int ltr_flag, rtl_flag;
double baseline, x, y, width, height, char_width, dx, dy;
void *LayoutObj;
PangoLayout *layout;
PangoLayoutIter *iter;
PangoLayoutIter *cluster_iter;
PangoRectangle rect, cluster_rect;
PangoDirection dir;
PyObject *ret;
PyObject *layout_data;
PyObject *cluster_data;
PyObject *cluster_range;
PyObject *cluster_index_data;
PyObject *cluster_index_range;
PyObject *glyph_data;
if (!PyArg_ParseTuple(args, "Oi", &LayoutObj, &len)) {
return NULL;
}
layout = PyCObject_AsVoidPtr(LayoutObj);
pango_layout_get_size(layout, &w, &h);
dx = 0.0;
if (pango_layout_get_alignment(layout) == PANGO_ALIGN_CENTER) {
dx = -0.5 * ((double) w) / PANGO_SCALE;
} else if (pango_layout_get_alignment(layout) == PANGO_ALIGN_RIGHT) {
dx = -1.0 * ((double) w) / PANGO_SCALE;
}
ret = PyTuple_New(5);
layout_data = PyList_New(0);
cluster_data = PyList_New(0);
cluster_index_data = PyList_New(0);
PyTuple_SetItem(ret, 0, layout_data);
PyTuple_SetItem(ret, 1, cluster_data);
PyTuple_SetItem(ret, 2, cluster_index_data);
iter = pango_layout_get_iter(layout);
cluster_iter = pango_layout_get_iter(layout);
prev_index = -1;
rtl_flag = 0;
ltr_flag = 0;
dy = ((double) pango_layout_iter_get_baseline(iter)) / PANGO_SCALE;
for (i = 0; i < len; i++) {
glyph_data = PyTuple_New(6);
//Processing EOL
while (pango_layout_iter_get_baseline(cluster_iter) !=
pango_layout_iter_get_baseline(iter)) {
pango_layout_iter_get_char_extents(iter, &rect);
x = ((double) rect.x) / PANGO_SCALE + dx;
PyTuple_SetItem(glyph_data, 0, PyFloat_FromDouble(x));
y = -1.0 * ((double) rect.y) / PANGO_SCALE + dy;
PyTuple_SetItem(glyph_data, 1, PyFloat_FromDouble(y));
width = ((double) rect.width) / PANGO_SCALE;
PyTuple_SetItem(glyph_data, 2, PyFloat_FromDouble(width));
height = ((double) rect.height) / PANGO_SCALE;
PyTuple_SetItem(glyph_data, 3, PyFloat_FromDouble(height));
baseline = -1.0 * ((double) pango_layout_iter_get_baseline(iter))
/ PANGO_SCALE + dy;
PyTuple_SetItem(glyph_data, 4, PyFloat_FromDouble(baseline));
//index processing
index=pango_layout_iter_get_index(iter);
prev_index = index;
PyTuple_SetItem(glyph_data, 5, PyInt_FromLong(index));
PyList_Append(layout_data, glyph_data);
pango_layout_iter_next_char(iter);
i++;
glyph_data = PyTuple_New(6);
}
pango_layout_iter_get_char_extents(iter, &rect);
pango_layout_iter_get_cluster_extents(cluster_iter, NULL, &cluster_rect);
//Processing cluster data
//Layout_data: (x,y,width,height,base_line,byte_index)
x = ((double) cluster_rect.x) / PANGO_SCALE + dx;
PyTuple_SetItem(glyph_data, 0, PyFloat_FromDouble(x));
y = -1.0 * ((double) cluster_rect.y) / PANGO_SCALE + dy;
PyTuple_SetItem(glyph_data, 1, PyFloat_FromDouble(y));
width = ((double) cluster_rect.width) / PANGO_SCALE;
PyTuple_SetItem(glyph_data, 2, PyFloat_FromDouble(width));
height = ((double) cluster_rect.height) / PANGO_SCALE;
PyTuple_SetItem(glyph_data, 3, PyFloat_FromDouble(height));
baseline = -1.0 * ((double) pango_layout_iter_get_baseline(cluster_iter))
/ PANGO_SCALE + dy;
PyTuple_SetItem(glyph_data, 4, PyFloat_FromDouble(baseline));
//index processing
index=pango_layout_iter_get_index(iter);
if (prev_index != -1){
if(index < prev_index){
rtl_flag=1;
}else if(index > prev_index){
ltr_flag=1;
}
}
prev_index = index;
PyTuple_SetItem(glyph_data, 5, PyInt_FromLong(index));
PyList_Append(layout_data, glyph_data);
//Iterating over chars to next cluster
if(cluster_rect.width > rect.width){
char_width = rect.width;
cluster_range = PyTuple_New(2);
cluster_index_range = PyTuple_New(2);
PyTuple_SetItem(cluster_range, 0, PyInt_FromLong(i));
PyTuple_SetItem(cluster_index_range, 0,
PyInt_FromLong(pango_layout_iter_get_index(iter)));
while(cluster_rect.width > char_width){
pango_layout_iter_next_char(iter);
pango_layout_iter_get_char_extents(iter, &rect);
char_width = char_width + rect.width;
i++;
}
PyTuple_SetItem(cluster_range, 1, PyInt_FromLong(i + 1));
PyTuple_SetItem(cluster_index_range, 1,
PyInt_FromLong(pango_layout_iter_get_index(iter)));
PyList_Append(cluster_data, cluster_range);
PyList_Append(cluster_index_data, cluster_index_range);
}
pango_layout_iter_next_char(iter);
pango_layout_iter_next_cluster(cluster_iter);
}
pango_layout_iter_free(iter);
pango_layout_iter_free(cluster_iter);
if(rtl_flag + ltr_flag == 2){
PyTuple_SetItem(ret, 3, PyBool_FromLong(1));
}else{
PyTuple_SetItem(ret, 3, PyBool_FromLong(0));
}
dir = pango_find_base_dir(pango_layout_get_text(layout),-1);
if(dir == PANGO_DIRECTION_RTL) {
PyTuple_SetItem(ret, 4, PyBool_FromLong(1));
} else {
PyTuple_SetItem(ret, 4, PyBool_FromLong(0));
}
return ret;
}
void text_widget_draw_text ( struct TEXT_WIDGET_HANDLE handle )
{
if ( handle.d == NULL || handle.d->layout == NULL )
return;
vgSetPaint( handle.d->foreground, VG_FILL_PATH );
vgSeti( VG_MATRIX_MODE, VG_MATRIX_GLYPH_USER_TO_SURFACE );
vgLoadIdentity();
#if 0
// Overscan (in dots, evidently).
vgTranslate( 14.f, 8.f );
#endif
// Offset in mm.
vgScale( handle.d->dpmm_x, handle.d->dpmm_y );
// Move to the corner.
vgTranslate( handle.d->x_mm, handle.d->y_mm );
// Back to dots.
vgScale( 1.f/handle.d->dpmm_x, 1.f/handle.d->dpmm_y );
int height = PANGO_PIXELS( pango_layout_get_height( handle.d->layout ) );
PangoLayoutIter* li = pango_layout_get_iter( handle.d->layout );
do {
PangoLayoutRun* run = pango_layout_iter_get_run( li );
if ( run == NULL )
continue;
PangoRectangle logical_rect;
int baseline_pango = pango_layout_iter_get_baseline( li );
int baseline_pixel = PANGO_PIXELS( baseline_pango );
pango_layout_iter_get_run_extents( li, NULL, &logical_rect );
int x_pixel = PANGO_PIXELS( logical_rect.x );
PangoFont* pg_font = run->item->analysis.font;
FT_Face face = pango_fc_font_lock_face( (PangoFcFont*)pg_font );
if ( face != NULL ) {
struct VG_DATA* vg_data = face->size->generic.data;
if ( vg_data != NULL ) {
// About the only extra attribute we can manage is the foreground
// color. But, it might be nice to render a background color
// to see just how badly the text is fitted into the widget
// box.
GSList* attr_item = run->item->analysis.extra_attrs;
while ( attr_item ) {
PangoAttribute* attr = attr_item->data;
switch ( attr->klass->type ) {
case PANGO_ATTR_FOREGROUND:
{
PangoColor color = ((PangoAttrColor*)attr)->color;
VGfloat new_color[] = { (float)color.red / 65535.f,
(float)color.green / 65535.f,
(float)color.blue / 65535.f, 1.f };
VGPaint new_paint = vgCreatePaint();
vgSetParameterfv( new_paint, VG_PAINT_COLOR, 4, new_color );
vgSetPaint( new_paint, VG_FILL_PATH );
vgDestroyPaint( new_paint );
}
break;
default:
printf( "\tHmm. Unknown attribute: %d\n", attr->klass->type );
}
attr_item = attr_item->next;
}
// Note: inverted Y coordinate
VGfloat point[2] = { x_pixel, height - baseline_pixel };
vgSetfv( VG_GLYPH_ORIGIN, 2, point );
VGFont vg_font = vg_data->font;
int g;
for ( g = 0; g < run->glyphs->num_glyphs; g++ ) {
vgDrawGlyph( vg_font, run->glyphs->glyphs[g].glyph, VG_FILL_PATH,
VG_TRUE );
}
if ( vgGetPaint( VG_FILL_PATH ) != handle.d->foreground ) {
vgSetPaint( handle.d->foreground, VG_FILL_PATH );
}
}
pango_fc_font_unlock_face( (PangoFcFont*)pg_font );
}
} while ( pango_layout_iter_next_run( li ) );
// Iterators are not free.
pango_layout_iter_free( li);
}
void
gnm_rendered_value_remeasure (GnmRenderedValue *rv)
{
if (rv->rotation) {
GnmRenderedRotatedValue *rrv = (GnmRenderedRotatedValue *)rv;
PangoContext *context = pango_layout_get_context (rv->layout);
double sin_a, abs_sin_a, cos_a;
int sdx = 0;
int x0 = 0, x1 = 0;
PangoLayoutIter *iter;
int l = 0;
int lwidth;
sin_a = rrv->rotmat.xy;
abs_sin_a = fabs (sin_a);
cos_a = rrv->rotmat.xx;
pango_context_set_matrix (context, &rrv->rotmat);
pango_layout_context_changed (rv->layout);
rrv->linecount = pango_layout_get_line_count (rv->layout);
rrv->lines = g_new (struct GnmRenderedRotatedValueInfo, rrv->linecount);
pango_layout_get_size (rv->layout, &lwidth, NULL);
rv->layout_natural_height = 0;
iter = pango_layout_get_iter (rv->layout);
do {
PangoRectangle logical;
int x, dx, dy, indent;
int h, ytop, ybot, baseline;
pango_layout_iter_get_line_extents (iter, NULL, &logical);
pango_layout_iter_get_line_yrange (iter, &ytop, &ybot);
baseline = pango_layout_iter_get_baseline (iter);
indent = logical.x;
if (sin_a < 0)
indent -= lwidth;
if (l == 0 && rv->noborders)
sdx = (int)(baseline * sin_a - ybot / sin_a);
dx = sdx + (int)(ybot / sin_a + indent * cos_a);
dy = (int)((baseline - ybot) * cos_a - indent * sin_a);
rrv->lines[l].dx = dx;
rrv->lines[l].dy = dy;
/* Left edge. */
x = dx - (int)((baseline - ytop) * sin_a);
x0 = MIN (x0, x);
/* Right edge. */
x = dx + (int)(logical.width * cos_a + (ybot - baseline) * sin_a);
x1 = MAX (x1, x);
h = logical.width * abs_sin_a + logical.height * cos_a;
if (h > rv->layout_natural_height)
rv->layout_natural_height = h;
l++;
} while (pango_layout_iter_next_line (iter));
pango_layout_iter_free (iter);
rv->layout_natural_width = x1 - x0;
if (sin_a < 0) {
int dx = rv->layout_natural_width;
for (l = 0; l < rrv->linecount; l++)
rrv->lines[l].dx += dx;
}
for (l = 0; l < rrv->linecount; l++)
rrv->lines[l].dy += rv->layout_natural_height;
#if 0
g_print ("Natural size: %d x %d\n", rv->layout_natural_width, rv->layout_natural_height);
#endif
pango_context_set_matrix (context, NULL);
pango_layout_context_changed (rv->layout);
} else
static void
_vte_pango_x_set_text_font(struct _vte_draw *draw,
const PangoFontDescription *fontdesc,
VteTerminalAntiAlias antialias)
{
PangoContext *ctx;
Display *display;
PangoLayout *layout;
PangoLayoutIter *iter;
PangoRectangle ink, logical;
gunichar full_codepoints[] = {VTE_DRAW_DOUBLE_WIDE_IDEOGRAPHS};
GString *full_string;
gint full_width;
guint i;
struct _vte_pango_x_data *data;
data = (struct _vte_pango_x_data*) draw->impl_data;
display = gdk_x11_display_get_xdisplay(gtk_widget_get_display(draw->widget));
if (data->ctx != NULL) {
g_object_unref(data->ctx);
}
ctx = pango_x_get_context(display);
layout = pango_layout_new(ctx);
if (data->font != NULL) {
pango_font_description_free(data->font);
}
data->font = pango_font_description_copy(fontdesc);
pango_layout_set_font_description(layout, data->font);
/* Estimate for ASCII characters. */
pango_layout_set_text(layout,
VTE_DRAW_SINGLE_WIDE_CHARACTERS,
strlen(VTE_DRAW_SINGLE_WIDE_CHARACTERS));
pango_layout_get_extents(layout, &ink, &logical);
draw->width = logical.width;
draw->width = howmany(draw->width,
strlen(VTE_DRAW_SINGLE_WIDE_CHARACTERS));
iter = pango_layout_get_iter(layout);
draw->height = PANGO_PIXELS(logical.height);
draw->ascent = PANGO_PIXELS(pango_layout_iter_get_baseline(iter));
pango_layout_iter_free(iter);
/* Estimate for CJK characters. */
full_string = g_string_new(NULL);
for (i = 0; i < G_N_ELEMENTS(full_codepoints); i++) {
g_string_append_unichar(full_string, full_codepoints[i]);
}
pango_layout_set_text(layout, full_string->str, full_string->len);
pango_layout_get_extents(layout, &ink, &logical);
full_width = howmany(logical.width, G_N_ELEMENTS(full_codepoints));
g_string_free(full_string, TRUE);
/* If they're the same, then we have a screwy font. */
if (full_width == draw->width) {
/* add 1 to round up when dividing by 2 */
draw->width = (draw->width + 1) / 2;
}
draw->width = PANGO_PIXELS(draw->width);
iter = pango_layout_get_iter(layout);
if (draw->height == 0) {
draw->height = PANGO_PIXELS(logical.height);
}
if (draw->ascent == 0) {
draw->ascent = PANGO_PIXELS(pango_layout_iter_get_baseline(iter));
}
pango_layout_iter_free(iter);
_vte_debug_print(VTE_DEBUG_MISC,
"VtePangoX font metrics = %dx%d (%d).\n",
draw->width, draw->height, draw->ascent);
g_object_unref(layout);
g_object_unref(ctx);
}
