static GpStatus
MeasureString (GpGraphics *graphics, GDIPCONST WCHAR *stringUnicode, int *length, GDIPCONST GpFont *font,
GDIPCONST RectF *rc_org, GDIPCONST GpStringFormat *format, GpBrush *brush, RectF *boundingBox,
int *codepointsFitted, int *linesFilled,
WCHAR *CleanString, GpStringDetailStruct* StringDetails, GpDrawTextData *data)
{
BYTE *String; /* Holds the UTF8 version of our sanitized string */
unsigned long StringLen; /* Length of CleanString */
GDIPCONST WCHAR *Src;
WCHAR *Dest;
unsigned long i;
unsigned long j;
GpStringDetailStruct *CurrentDetail;
GpStringDetailStruct *CurrentLineStart; /* For rendering engine, to bump LineLen */
float *TabStops;
int NumOfTabStops;
int WrapPoint; /* Array index of wrap character */
int WrapX; /* Width of text at wrap character */
float CursorX; /* Current X position of drawing cursor */
float CursorY; /* Current Y position of drawing cursor */
int MaxX; /* Largest X of cursor */
int MaxXatY; /* Y coordinate of line with largest X, needed for MaxX resetting on wrap */
int MaxY; /* Largest Y of cursor */
int FrameWidth; /* rc->Width (or rc->Height if vertical) */
int FrameHeight; /* rc->Height (or rc->Width if vertical) */
int AlignHorz; /* Horizontal Alignment mode */
int AlignVert; /* Vertical Alignment mode */
int LineHeight; /* Height of a line with given font */
cairo_font_extents_t FontExtent; /* Info about our font */
cairo_font_options_t *FontOptions;
RectF rc_coords, *rc = &rc_coords;
float FontSize;
if (OPTIMIZE_CONVERSION (graphics)) {
rc->X = rc_org->X;
rc->Y = rc_org->Y;
rc->Width = rc_org->Width;
rc->Height = rc_org->Height;
} else {
rc->X = gdip_unitx_convgr (graphics, rc_org->X);
rc->Y = gdip_unity_convgr (graphics, rc_org->Y);
rc->Width = gdip_unitx_convgr (graphics, rc_org->Width);
rc->Height = gdip_unity_convgr (graphics, rc_org->Height);
}
#ifdef DRAWSTRING_DEBUG
printf("GdipDrawString(...) called (length=%d, fontsize=%d)\n", length, (int)font->sizeInPixels);
#endif
TabStops = format->tabStops;
NumOfTabStops = format->numtabStops;
/* Prepare our various buffers and variables */
StringLen = *length;
if (data)
data->has_hotkeys = FALSE;
/*
Set aliasing mode
*/
FontOptions = cairo_font_options_create();
switch(graphics->text_mode) {
default:
case TextRenderingHintSystemDefault: {
cairo_font_options_set_antialias(FontOptions, CAIRO_ANTIALIAS_DEFAULT);
//cairo_font_options_set_hint_style(FontOptions, CAIRO_HINT_STYLE_NONE);
//cairo_font_options_set_subpixel_order(FontOptions, CAIRO_SUBPIXEL_ORDER_DEFAULT);
//cairo_font_options_set_hint_style(FontOptions, CAIRO_HINT_STYLE_DEFAULT);
//cairo_font_options_set_hint_metrics(FontOptions, CAIRO_HINT_METRICS_DEFAULT);
break;
}
// FIXME - pick matching settings for each text mode
case TextRenderingHintSingleBitPerPixelGridFit:
case TextRenderingHintSingleBitPerPixel:
case TextRenderingHintAntiAliasGridFit:
case TextRenderingHintAntiAlias: {
cairo_font_options_set_antialias(FontOptions, CAIRO_ANTIALIAS_DEFAULT);
break;
}
case TextRenderingHintClearTypeGridFit: {
cairo_font_options_set_antialias(FontOptions, CAIRO_ANTIALIAS_DEFAULT);
break;
}
}
cairo_set_font_options(graphics->ct, FontOptions);
cairo_font_options_destroy(FontOptions);
// Do we want this here?
/* Commented out until we properly save/restore AA settings; should fix bug #76135
cairo_set_antialias(graphics->ct, CAIRO_ANTIALIAS_NONE);
*/
/*
Get font size information; how expensive is the cairo stuff here?
*/
cairo_set_font_face (graphics->ct, (cairo_font_face_t*) font->cairofnt); /* Set our font; this will also be used for later drawing */
/* this will always return the same value, except when printing */
FontSize = (graphics->type == gtPostScript) ? font->emSize : font->sizeInPixels;
cairo_set_font_size (graphics->ct, FontSize);
cairo_font_extents (graphics->ct, &FontExtent); /* Get the size we're looking for */
/* cairo_font_set_transform(font->cairofnt, SavedMatrix);*/ /* Restore the matrix */
if ((LineHeight=FontExtent.ascent)<1) {
LineHeight=1;
}
#ifdef DRAWSTRING_DEBUG
printf("Font extents: ascent:%d, descent: %d, height:%d, maxXadvance:%d, maxYadvance:%d\n", (int)FontExtent.ascent, (int)FontExtent.descent, (int)FontExtent.height, (int)FontExtent.max_x_advance, (int)FontExtent.max_y_advance);
#endif
/* Sanitize string, remove formatting chars and build description array */
#ifdef DRAWSTRING_DEBUG
printf("GdipDrawString(...) Sanitizing string, StringLen=%d\n", StringLen);
#endif
Src=stringUnicode;
/* unless specified we don't consider the trailing spaces, unless there is just one space (#80680) */
if ((format->formatFlags & StringFormatFlagsMeasureTrailingSpaces) == 0) {
while ((StringLen > 0) && (isspace ((int) ( *(Src + StringLen - 1)))))
StringLen--;
if (StringLen == 0)
StringLen = 1;
}
Dest=CleanString;
CurrentDetail=StringDetails;
for (i=0; i<StringLen; i++) {
switch(*Src) {
case '\r': { /* CR */
Src++;
continue;
}
case '\t': { /* Tab */
if (NumOfTabStops > 0) {
CurrentDetail->Flags |= STRING_DETAIL_TAB;
}
Src++;
continue;
}
case '\n': { /* LF */
CurrentDetail->Flags |= STRING_DETAIL_LF;
CurrentDetail->Linefeeds++;
Src++;
continue;
}
case '&': {
/* We print *all* chars if no hotkeys */
if (format->hotkeyPrefix==HotkeyPrefixNone) {
break;
}
Src++;
if (*Src=='&') {
/* We skipped the first '&', the break will
make us drop to copying the second */
break;
}
CurrentDetail->Flags |= STRING_DETAIL_HOTKEY;
if (data)
data->has_hotkeys = TRUE;
continue;
}
/* Boy, this must be slow, FIXME somehow */
default: {
if (((format->formatFlags & StringFormatFlagsNoWrap)==0) || ((format->trimming != StringTrimmingCharacter) && (format->trimming != StringTrimmingNone))) {
break;
}
/* Fall through */
}
case ' ':
case '.':
{
/* Mark where we can break for a new line */
CurrentDetail->Flags |= STRING_DETAIL_BREAK;
break;
}
}
*Dest=*Src;
Src++;
Dest++;
CurrentDetail++;
}
*Dest='\0';
/* Recalculate StringLen; we may have shortened String */
Dest=CleanString;
StringLen=0;
while (*Dest!=0) {
StringLen++;
Dest++;
}
/* Don't bother doing anything else if the length is 0 */
if (StringLen == 0) {
*length = 0;
return Ok;
}
/* Convert string from Gdiplus format to UTF8, suitable for cairo */
String = (BYTE*) ucs2_to_utf8 ((const gunichar2 *)CleanString, -1);
if (!String)
return OutOfMemory;
#ifdef DRAWSTRING_DEBUG
printf("Sanitized string: >%s<, length %d (utf8-length:%d)\n", String, StringLen, strlen((char *)String));
#endif
/* Generate size array */
if (CalculateStringWidths (graphics->ct, font, CleanString, StringLen, StringDetails)==0) {
/* FIXME; pick right return code */
GdipFree(String);
return Ok;
}
GdipFree (String);
CursorX=0;
CursorY=0;
MaxX=0;
MaxXatY=0;
MaxY=0;
CurrentLineStart=StringDetails;
CurrentDetail=StringDetails;
CurrentDetail->Flags |= STRING_DETAIL_LINESTART;
WrapPoint=-1;
WrapX=0;
if (format->formatFlags & StringFormatFlagsDirectionVertical) {
FrameWidth = SAFE_FLOAT_TO_UINT32 (rc->Height);
FrameHeight = SAFE_FLOAT_TO_UINT32 (rc->Width);
} else {
FrameWidth = SAFE_FLOAT_TO_UINT32 (rc->Width);
FrameHeight = SAFE_FLOAT_TO_UINT32 (rc->Height);
}
#ifdef DRAWSTRING_DEBUG
printf("Frame %d x %d\n", FrameWidth, FrameHeight);
#endif
for (i=0; i<StringLen; i++) {
/* Handle tabs and new lines */
if (CurrentDetail->Flags & STRING_DETAIL_TAB) {
float tab_pos;
int tab_index;
tab_pos = format->firstTabOffset;
tab_index = 0;
while (CursorX > tab_pos) {
tab_pos += TabStops[tab_index % NumOfTabStops];
tab_index++;
}
CursorX = tab_pos;
CurrentLineStart = CurrentDetail;
CurrentDetail->Flags |= STRING_DETAIL_LINESTART;
}
if (CurrentDetail->Flags & STRING_DETAIL_LF) {
CursorX = 0;
CursorY += LineHeight * CurrentDetail->Linefeeds;
CurrentDetail->Flags |= STRING_DETAIL_LINESTART;
CurrentLineStart = CurrentDetail;
#ifdef DRAWSTRING_DEBUG
{
int j;
for (j=0; j<CurrentDetail->Linefeeds; j++) {
printf("<LF>\n");
}
}
#endif
}
#ifdef DRAWSTRING_DEBUG
printf("[%3d] X: %3d, Y:%3d, '%c' | ", i, (int)CursorX, (int)CursorY, CleanString[i]>=32 ? CleanString[i] : '?');
#endif
/* Remember where to wrap next, but only if wrapping allowed */
if (((format->formatFlags & StringFormatFlagsNoWrap)==0) && (CurrentDetail->Flags & STRING_DETAIL_BREAK)) {
if (CleanString[i] == ' ') {
WrapPoint=i+1; /* We skip the break char itself, keeping it at the end of the old line */
} else {
WrapPoint=i;
}
if (CursorX>MaxX) {
WrapX=CursorX;
} else {
WrapX=MaxX;
}
#ifdef DRAWSTRING_DEBUG
printf("<W>");
#endif
}
/* New line voids any previous wrap point */
if (CurrentDetail->Flags & STRING_DETAIL_LINESTART) {
WrapPoint=-1;
}
CurrentDetail->PosX=CursorX;
CurrentDetail->PosY=CursorY;
/* Advance cursor */
CursorX+=CurrentDetail->Width;
if (MaxX<CursorX) {
MaxX=CursorX;
MaxXatY=CursorY;
}
/* Time for a new line? Go back to last WrapPoint and wrap */
if (FrameWidth && CursorX>FrameWidth) {
if (WrapPoint!=-1) {
/** Re-Calculate line lengths **/
/* Old line */
CurrentLineStart->LineLen-=i-WrapPoint;
if (MaxXatY==CursorY) {
MaxX=WrapX;
}
/* Remove the trailing space from being counted if we're not supposed to */
if (((format->formatFlags & StringFormatFlagsMeasureTrailingSpaces)==0) && (WrapPoint>0)) {
if (CleanString[WrapPoint-1]==' ') {
if (MaxXatY==CursorY) {
MaxX-=StringDetails[WrapPoint-1].Width;
}
StringDetails[WrapPoint-1].Width=0;
CurrentLineStart->LineLen--;
}
}
/* New line */
CurrentLineStart=&(StringDetails[WrapPoint]);
CurrentLineStart->Flags|=STRING_DETAIL_LINESTART;
CurrentLineStart->LineLen=0;
/* Generate CursorX/Y for new line */
CursorY+=LineHeight;
CursorX=CurrentLineStart->Width;
i=WrapPoint;
#ifdef DRAWSTRING_DEBUG
printf("\n<Forcing break at index %d, CursorX:%f, LineLen:%d>\n", WrapPoint, CursorX, CurrentLineStart->LineLen);
#endif
CurrentDetail=&(StringDetails[WrapPoint]);
CurrentDetail->PosX=0;
CurrentDetail->PosY=CursorY;
WrapPoint=-1;
} else {
/*
This line is too long and has no wrap points, check if we need to insert ellipsis.
To keep at least a bit of performance, we cheat - we don't actually calculate the
size of the elipsis chars but assume that they're always smaller than any other
character. And we don't try to hard to fit as many chars as possible.
*/
int EndOfLine;
#ifdef DRAWSTRING_DEBUG
printf("No wrappoint (yet) set\n");
#endif
/* Find end of line, index i is the first char no longer visible on the line */
EndOfLine=i;
if ((format->formatFlags & StringFormatFlagsNoWrap)==0) {
while (EndOfLine<StringLen && ((StringDetails[EndOfLine].Flags & STRING_DETAIL_LF)==0)) {
EndOfLine++;
}
} else {
while (EndOfLine<StringLen && ((StringDetails[EndOfLine].Flags & (STRING_DETAIL_LF | STRING_DETAIL_BREAK))==0)) {
EndOfLine++;
}
if (EndOfLine<StringLen) {
if (StringDetails[EndOfLine].Flags & STRING_DETAIL_BREAK) {
EndOfLine++;
}
}
}
if ((format->trimming==StringTrimmingEllipsisWord) || (format->trimming==StringTrimmingEllipsisCharacter)) {
if (CurrentLineStart->LineLen>3) {
if (format->trimming==StringTrimmingEllipsisCharacter) {
CleanString[i-1]='.';
CleanString[i-2]='.';
CleanString[i-3]='.';
} else {
int found=0;
j=i;
while(j>(i-CurrentLineStart->LineLen)) {
if (CleanString[j]==' ') {
CleanString[j]='.';
CurrentLineStart->LineLen-=i-j-1;
if ((j+1)<EndOfLine) {
CleanString[j+1]='.';
CurrentLineStart->LineLen++;
}
if ((j+2)<EndOfLine) {
CleanString[j+2]='.';
CurrentLineStart->LineLen++;
}
found=1;
break;
}
j--;
}
if (!found) {
CleanString[i-1]='.';
CleanString[i-2]='.';
CleanString[i-3]='.';
}
}
}
} else if (format->trimming==StringTrimmingEllipsisPath) {
int k;
float LineWidth;
/* Find end of line, index i is the first char no longer visible on the line */
EndOfLine=i;
while (EndOfLine<StringLen && ((StringDetails[EndOfLine].Flags & (STRING_DETAIL_LF | STRING_DETAIL_BREAK))==0)) {
EndOfLine++;
}
/* Whack the center, make sure we've got space in the string */
if (CurrentLineStart->LineLen>3) {
j=i-(CurrentLineStart->LineLen/2);
CleanString[j-1]='.';
CleanString[j]='.';
CleanString[j+1]='.';
/* Have just enough to include our ellipsis */
LineWidth=0;
for (k=i-CurrentLineStart->LineLen; k<(j+1); k++) {
LineWidth+=StringDetails[k].Width;
}
CurrentLineStart->LineLen=i-j+3; /* 3=ellipsis */
/* Now figure out how many chars from the end of the string we have to copy */
j+=2; /* Points to the char behind the last ellipsis */
k=EndOfLine-1;
while ((LineWidth+StringDetails[k].Width)<FrameWidth) {
LineWidth+=StringDetails[k].Width;
k--;
}
memcpy (&CleanString[j], &CleanString[k+1], sizeof(WCHAR)*(EndOfLine-k-1));
CurrentLineStart->LineLen+=EndOfLine-k-1;
}
} else {
#ifdef DRAWSTRING_DEBUG
/* Just cut off the text */
printf("End of line at index:%d\n", EndOfLine);
#endif
CurrentLineStart->LineLen=EndOfLine;
}
if ((format->formatFlags & StringFormatFlagsNoWrap)!=0) {
// Avoid endless loops, always print at least one char
if (CurrentLineStart->LineLen == 0) {
CurrentLineStart->LineLen = 1;
}
break;
}
/* avoid endless loop when wrapping is allowed */
if (CurrentLineStart->LineLen == 0) {
CurrentLineStart->LineLen = 1;
}
/* New line */
CurrentLineStart=&(StringDetails[EndOfLine]);
CurrentLineStart->Flags|=STRING_DETAIL_LINESTART;
CurrentLineStart->LineLen=0;
/* Generate CursorX/Y for new line */
CursorY+=LineHeight;
CursorX=CurrentLineStart->Width;
i=EndOfLine;
CurrentDetail=&(StringDetails[EndOfLine]);
CurrentDetail->PosX=0;
CurrentDetail->PosY=CursorY;
}
}
/* Still visible? */
if ((FrameWidth && CursorX>FrameWidth) || (FrameHeight && ((CursorY>FrameHeight) || ((format->formatFlags & StringFormatFlagsLineLimit) && (CursorY+LineHeight)>FrameHeight)))) {
CurrentDetail->Flags|=STRING_DETAIL_HIDDEN;
#ifdef DRAWSTRING_DEBUG
if (CurrentDetail->Flags & STRING_DETAIL_LINESTART) {
printf("<LSTART-H>");
} else {
printf("<H>");
}
#endif
} else {
if (MaxY<CursorY) {
MaxY=CursorY;
}
}
#ifdef DRAWSTRING_DEBUG
if (i % 3 == 2) {
printf("\n");
}
#endif
CurrentDetail++;
CurrentLineStart->LineLen++;
}
/* We ignored it above, for shorter of calculations, also, add a bit of padding */
MaxY+=LineHeight+FontExtent.descent;
#ifdef DRAWSTRING_DEBUG
printf("\n");
printf("Bounding box: %d x %d\n", MaxX, MaxY);
printf("Line layout [Total len %d]:\n", StringLen);
for (i=0; i<StringLen; i++) {
if (StringDetails[i].Flags & STRING_DETAIL_LF) {
for (j=0; j<StringDetails[i].Linefeeds; j++) {
printf("\n");
}
}
if (StringDetails[i].Flags & STRING_DETAIL_LINESTART) {
printf("[Len %2d %dx%d] ", StringDetails[i].LineLen, (int)StringDetails[i].PosX, (int)StringDetails[i].PosY);
for (j=0; j<StringDetails[i].LineLen; j++) {
printf("%c", CleanString[i+j]);
}
if (j == 0) {
break;
}
i+=j-1;
printf("\n");
}
}
#endif
/* Prepare alignment handling */
AlignHorz = format->alignment;
if (format->formatFlags & StringFormatFlagsDirectionRightToLeft) {
if (format->alignment==StringAlignmentNear) {
AlignHorz=StringAlignmentFar;
} else if (format->alignment==StringAlignmentFar) {
AlignHorz=StringAlignmentNear;
}
}
AlignVert = format->lineAlignment;
/*
At this point we know our bounding box, what characters
are to be displayed and where every character goes
*/
if (boundingBox) {
boundingBox->X = rc->X;
boundingBox->Y = rc->Y;
if (format->formatFlags & StringFormatFlagsDirectionVertical) {
boundingBox->Width = MaxY;
boundingBox->Height = MaxX;
} else {
boundingBox->Width = MaxX;
boundingBox->Height = MaxY;
}
if ((rc->Width > 0) && (boundingBox->Width > rc->Width)) {
boundingBox->Width = rc->Width;
}
if ((rc->Height > 0) && (boundingBox->Height > rc->Height)) {
boundingBox->Height = rc->Height;
}
/* avoid conversion computations if possible */
if (!OPTIMIZE_CONVERSION (graphics)) {
boundingBox->X = gdip_convgr_unitx (graphics, boundingBox->X);
boundingBox->Y = gdip_convgr_unity (graphics, boundingBox->Y);
boundingBox->Width = gdip_convgr_unitx (graphics, boundingBox->Width);
boundingBox->Height = gdip_convgr_unity (graphics, boundingBox->Height);
}
switch (AlignVert) {
case StringAlignmentCenter:
if (format->formatFlags & StringFormatFlagsDirectionVertical) {
boundingBox->X += (FrameHeight - MaxY) * 0.5;
} else {
boundingBox->Y += (FrameHeight - MaxY) * 0.5;
}
break;
case StringAlignmentFar:
if (format->formatFlags & StringFormatFlagsDirectionVertical) {
boundingBox->X += (FrameHeight - MaxY);
} else {
boundingBox->Y += (FrameHeight - MaxY);
}
break;
}
switch (AlignHorz) {
case StringAlignmentCenter:
if (format->formatFlags & StringFormatFlagsDirectionVertical) {
boundingBox->Y += (FrameWidth - MaxX) * 0.5;
} else {
boundingBox->X += (FrameWidth - MaxX) * 0.5;
}
break;
case StringAlignmentFar:
if (format->formatFlags & StringFormatFlagsDirectionVertical) {
boundingBox->Y += (FrameWidth - MaxX);
} else {
boundingBox->X += (FrameWidth - MaxX);
}
break;
}
}
if (codepointsFitted) {
/* how many characters from the string can be drawn in the boundingBox (#76664) */
double max_width = boundingBox ? (boundingBox->X + boundingBox->Width) : rc->X + min (MaxX, rc->Width);
double max_height = boundingBox ? (boundingBox->Y + boundingBox->Height) : rc->Y + min (MaxY, rc->Height);
int charactersFitted;
for (charactersFitted = 0; charactersFitted < StringLen; charactersFitted++) {
if ((StringDetails[charactersFitted].PosX + StringDetails[charactersFitted].Width) > max_width)
break;
if (StringDetails[charactersFitted].PosY + LineHeight > max_height)
break;
}
*codepointsFitted = charactersFitted;
}
if (linesFilled) {
/* how many *complete* lines fits in our calculated boundingBox */
double height = (boundingBox) ? boundingBox->Height : min (MaxY, rc->Height);
*linesFilled = floor (height / LineHeight);
}
if (AlignHorz != StringAlignmentNear || AlignVert != StringAlignmentNear) {
// Update alignment
int length = 0;
int current_line_length = 0;
for (i = 0; i < StringLen; i++) {
if (i == current_line_length) {
length = StringDetails[i].LineLen;
current_line_length = min(length + i, StringLen);
}
switch (AlignHorz) {
case StringAlignmentNear:
break;
case StringAlignmentCenter:
if ((current_line_length == 1) || (StringDetails [current_line_length - 1].PosX > 0)) {
StringDetails[i].PosX += (FrameWidth - StringDetails [current_line_length - 1].PosX -
StringDetails [current_line_length - 1].Width) / 2;
}
break;
case StringAlignmentFar:
StringDetails[i].PosX += FrameWidth - StringDetails [current_line_length - 1].PosX -
StringDetails [current_line_length - 1].Width;
break;
}
switch (AlignVert) {
case StringAlignmentNear:
break;
case StringAlignmentCenter:
StringDetails[i].PosY += (FrameHeight - MaxY) / 2;
break;
case StringAlignmentFar:
StringDetails[i].PosY += FrameHeight - MaxY;
break;
}
}
}
/* if asked, supply extra data to be reused when drawing the same string */
if (data) {
data->align_horz = AlignHorz;
data->align_vert = AlignVert;
data->line_height = LineHeight;
data->max_y = MaxY;
data->descent = FontExtent.descent;
}
return Ok;
}
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;
}