static GF_Err gdip_get_text_size(GF_FontReader *dr, const unsigned short *string, Fixed *width, Fixed *height)
{
GpPath *path_tmp;
GpStringFormat *fmt;
FontPriv *ctx = (FontPriv *)dr->udta;
*width = *height = 0;
if (!ctx->font) return GF_BAD_PARAM;
GdipCreateStringFormat(StringFormatFlagsNoWrap, LANG_NEUTRAL, &fmt);
GdipCreatePath(FillModeAlternate, &path_tmp);
RectF rc;
rc.X = rc.Y = 0;
rc.Width = rc.Height = 0;
GdipAddPathString(path_tmp, (const WCHAR *)string, -1, ctx->font, ctx->font_style, ctx->em_size, &rc, fmt);
GdipGetPathWorldBounds(path_tmp, &rc, NULL, NULL);
adjust_white_space(string, &rc.Width, ctx->whitespace_width);
*width = FLT2FIX(rc.Width);
*height = FLT2FIX(rc.Height);
GdipDeleteStringFormat(fmt);
GdipDeletePath(path_tmp);
return GF_OK;
}
static M4Err gdip_get_text_size(FontRaster *dr, const unsigned short *string, Float *width, Float *height)
{
GpPath *path_tmp;
GpStringFormat *fmt;
FontPriv *ctx = (FontPriv *)dr->priv;
*width = *height = 0.0;
if (!ctx->font) return M4BadParam;
GdipCreateStringFormat(StringFormatFlagsNoWrap, LANG_NEUTRAL, &fmt);
GdipCreatePath(FillModeAlternate, &path_tmp);
RectF rc;
rc.X = rc.Y = 0;
rc.Width = rc.Height = 0;
GdipAddPathString(path_tmp, string, -1, ctx->font, ctx->font_style, ctx->font_size, &rc, fmt);
GdipGetPathWorldBounds(path_tmp, &rc, NULL, NULL);
*width = rc.Width;
*height = rc.Height;
adjust_white_space(string, width, ctx->whitespace_width );
GdipDeleteStringFormat(fmt);
GdipDeletePath(path_tmp);
return M4OK;
}
GpStatus WINGDIPAPI GdipGetPathWorldBoundsI(GpPath* path, GpRect* bounds,
GDIPCONST GpMatrix *matrix, GDIPCONST GpPen *pen)
{
GpStatus ret;
GpRectF boundsF;
ret = GdipGetPathWorldBounds(path,&boundsF,matrix,pen);
if(ret == Ok){
bounds->X = roundr(boundsF.X);
bounds->Y = roundr(boundsF.Y);
bounds->Width = roundr(boundsF.Width);
bounds->Height = roundr(boundsF.Height);
}
return ret;
}
static void test_worldbounds(void)
{
GpStatus status;
GpPath *path;
GpPen *pen;
GpMatrix *matrix;
GpRectF bounds;
GpPointF line2_points[10];
int i;
for(i = 0; i < 10; i ++){
line2_points[i].X = 200.0 + i * 50.0 * (i % 2);
line2_points[i].Y = 200.0 + i * 50.0 * !(i % 2);
}
GdipCreatePen1((ARGB)0xdeadbeef, 20.0, UnitWorld, &pen);
GdipSetPenEndCap(pen, LineCapSquareAnchor);
GdipCreateMatrix2(1.5, 0.0, 1.0, 1.2, 10.4, 10.2, &matrix);
GdipCreatePath(FillModeAlternate, &path);
GdipAddPathArc(path, 100.0, 100.0, 500.0, 700.0, 0.0, 100.0);
GdipAddPathLine2(path, &(line2_points[0]), 10);
status = GdipGetPathWorldBounds(path, &bounds, NULL, NULL);
expect(Ok, status);
GdipDeletePath(path);
expectf(200.0, bounds.X);
expectf(200.0, bounds.Y);
expectf(450.0, bounds.Width);
expectf(600.0, bounds.Height);
GdipCreatePath(FillModeAlternate, &path);
GdipAddPathArc(path, 100.0, 100.0, 500.0, 700.0, 0.0, 100.0);
GdipAddPathLine2(path, &(line2_points[0]), 10);
status = GdipGetPathWorldBounds(path, &bounds, matrix, NULL);
expect(Ok, status);
GdipDeletePath(path);
expectf(510.4, bounds.X);
expectf(250.2, bounds.Y);
expectf(1275.0, bounds.Width);
expectf(720.0, bounds.Height);
GdipCreatePath(FillModeAlternate, &path);
GdipAddPathArc(path, 100.0, 100.0, 500.0, 700.0, 0.0, 100.0);
GdipAddPathLine2(path, &(line2_points[0]), 10);
status = GdipGetPathWorldBounds(path, &bounds, NULL, pen);
expect(Ok, status);
GdipDeletePath(path);
expectf(100.0, bounds.X);
expectf(100.0, bounds.Y);
expectf(650.0, bounds.Width);
expectf(800.0, bounds.Height);
GdipCreatePath(FillModeAlternate, &path);
GdipAddPathLine2(path, &(line2_points[0]), 2);
status = GdipGetPathWorldBounds(path, &bounds, NULL, pen);
expect(Ok, status);
GdipDeletePath(path);
expectf(156.0, bounds.X);
expectf(156.0, bounds.Y);
expectf(138.0, bounds.Width);
expectf(88.0, bounds.Height);
line2_points[2].X = 2 * line2_points[1].X - line2_points[0].X;
line2_points[2].Y = 2 * line2_points[1].Y - line2_points[0].Y;
GdipCreatePath(FillModeAlternate, &path);
GdipAddPathLine2(path, &(line2_points[0]), 3);
status = GdipGetPathWorldBounds(path, &bounds, NULL, pen);
expect(Ok, status);
GdipDeletePath(path);
expectf(100.0, bounds.X);
expectf(100.0, bounds.Y);
expectf(300.0, bounds.Width);
expectf(200.0, bounds.Height);
GdipCreatePath(FillModeAlternate, &path);
GdipAddPathArc(path, 100.0, 100.0, 500.0, 700.0, 45.0, 20.0);
status = GdipGetPathWorldBounds(path, &bounds, NULL, pen);
expect(Ok, status);
GdipDeletePath(path);
expectf(386.7, bounds.X);
expectf(553.4, bounds.Y);
expectf(266.8, bounds.Width);
expectf(289.6, bounds.Height);
GdipCreatePath(FillModeAlternate, &path);
status = GdipGetPathWorldBounds(path, &bounds, matrix, pen);
expect(Ok, status);
GdipDeletePath(path);
expectf(0.0, bounds.X);
expectf(0.0, bounds.Y);
expectf(0.0, bounds.Width);
expectf(0.0, bounds.Height);
GdipCreatePath(FillModeAlternate, &path);
GdipAddPathLine2(path, &(line2_points[0]), 2);
status = GdipGetPathWorldBounds(path, &bounds, matrix, pen);
expect(Ok, status);
GdipDeletePath(path);
todo_wine{
expectf(427.9, bounds.X);
expectf(167.7, bounds.Y);
expectf(239.9, bounds.Width);
expectf(164.9, bounds.Height);
}
GdipDeleteMatrix(matrix);
GdipCreateMatrix2(0.9, -0.5, -0.5, -1.2, 10.4, 10.2, &matrix);
GdipCreatePath(FillModeAlternate, &path);
GdipAddPathArc(path, 100.0, 100.0, 500.0, 700.0, 0.0, 100.0);
GdipAddPathLine2(path, &(line2_points[0]), 10);
status = GdipGetPathWorldBounds(path, &bounds, matrix, NULL);
expect(Ok, status);
GdipDeletePath(path);
GdipDeleteMatrix(matrix);
expectf(-209.6, bounds.X);
expectf(-1274.8, bounds.Y);
expectf(705.0, bounds.Width);
expectf(945.0, bounds.Height);
GdipDeletePen(pen);
}
static GF_Glyph *gdip_load_glyph(GF_FontReader *dr, u32 glyph_name)
{
GF_Rect bounds;
GF_Glyph *glyph;
GpPath *path_tmp;
GpStringFormat *fmt;
GpMatrix *mat;
Float est_advance_h;
unsigned short str[4];
int i;
FontPriv *ctx = (FontPriv *)dr->udta;
if (!ctx->font) return NULL;
RectF rc;
rc.X = rc.Y = 0;
rc.Width = rc.Height = 0;
GdipCreateStringFormat(StringFormatFlagsNoWrap | StringFormatFlagsNoFitBlackBox | StringFormatFlagsMeasureTrailingSpaces, LANG_NEUTRAL, &fmt);
GdipSetStringFormatAlign(fmt, StringAlignmentNear);
GdipCreatePath(FillModeAlternate, &path_tmp);
if (glyph_name==0x20) {
est_advance_h = ctx->whitespace_width;
} else {
/*to compute first glyph alignment (say 'x', we figure out its bounding full box by using the '_' char as wrapper (eg, "_x_")
then the bounding box starting from xMin of the glyph ('x_'). The difference between both will give us a good approx
of the glyph alignment*/
str[0] = glyph_name;
str[1] = (unsigned short) '_';
str[2] = (unsigned short) 0;
GdipAddPathString(path_tmp, (const WCHAR *)str, -1, ctx->font, ctx->font_style, ctx->em_size, &rc, fmt);
GdipGetPathWorldBounds(path_tmp, &rc, NULL, NULL);
est_advance_h = rc.Width - ctx->underscore_width;
}
GdipResetPath(path_tmp);
str[0] = glyph_name;
str[1] = (unsigned short) 0;
rc.X = rc.Y = 0;
rc.Width = rc.Height = 0;
GdipAddPathString(path_tmp, (const WCHAR *)str, -1, ctx->font, ctx->font_style, ctx->em_size, &rc, fmt);
GdipGetPathWorldBounds(path_tmp, &rc, NULL, NULL);
/*flip so that we are in a font coordinate system - also move back the glyph to x=0 and y=baseline, GdiPlus doesn't do so*/
GdipCreateMatrix(&mat);
GdipTranslateMatrix(mat, - rc.X, -ctx->ascent, MatrixOrderAppend);
GdipScaleMatrix(mat, 1, -1, MatrixOrderAppend);
GdipTransformPath(path_tmp, mat);
GdipDeleteMatrix(mat);
/*start enum*/
s32 count;
GdipGetPointCount(path_tmp, &count);
GpPointF *pts = new GpPointF[count];
BYTE *types = new BYTE[count];
GdipGetPathTypes(path_tmp, types, count);
GdipGetPathPoints(path_tmp, pts, count);
GF_SAFEALLOC(glyph, GF_Glyph);
GF_SAFEALLOC(glyph->path, GF_Path);
for (i=0; i<count; ) {
BOOL closed = 0;
s32 sub_type;
sub_type = types[i] & PathPointTypePathTypeMask;
if (sub_type == PathPointTypeStart) {
gf_path_add_move_to(glyph->path, FLT2FIX(pts[i].X), FLT2FIX(pts[i].Y));
i++;
}
else if (sub_type == PathPointTypeLine) {
gf_path_add_line_to(glyph->path, FLT2FIX(pts[i].X), FLT2FIX(pts[i].Y));
if (types[i] & PathPointTypeCloseSubpath) gf_path_close(glyph->path);
i++;
}
else if (sub_type == PathPointTypeBezier) {
assert(i+2<=count);
gf_path_add_cubic_to(glyph->path, FLT2FIX(pts[i].X), FLT2FIX(pts[i].Y), FLT2FIX(pts[i+1].X), FLT2FIX(pts[i+1].Y), FLT2FIX(pts[i+2].X), FLT2FIX(pts[i+2].Y));
if (types[i+2] & PathPointTypeCloseSubpath) gf_path_close(glyph->path);
i += 3;
} else {
assert(0);
break;
}
}
delete [] pts;
delete [] types;
GdipDeleteStringFormat(fmt);
GdipDeletePath(path_tmp);
glyph->ID = glyph_name;
glyph->utf_name = glyph_name;
glyph->vert_advance = (s32) (ctx->ascent-ctx->descent);
glyph->horiz_advance = (s32) est_advance_h;
gf_path_get_bounds(glyph->path, &bounds);
glyph->width = FIX2INT(bounds.width);
glyph->height = FIX2INT(bounds.height);
return glyph;
}
static M4Err gdip_add_text_to_path(FontRaster *dr, LPM4PATH path, Bool flipText,
const unsigned short* string, Float left, Float top, Float x_scaling, Float y_scaling,
Float ascent, M4Rect *bounds)
{
GpPath *path_tmp;
GpMatrix *mat;
GpStringFormat *fmt;
Float real_start;
unsigned short str[4];
FontPriv *ctx = (FontPriv *)dr->priv;
if (!ctx->font) return M4BadParam;
RectF rc;
rc.X = rc.Y = 0;
rc.Width = rc.Height = 0;
/*find first non-space char and estimate its glyph pos since GDIplus doesn't give this info*/
s32 len = utf8_wcslen(string);
s32 i=0;
for (; i<len; i++) {
if (string[i] != (unsigned short) ' ') break;
}
if (i>=len) return M4OK;
GdipCreateStringFormat(StringFormatFlagsNoWrap | StringFormatFlagsNoFitBlackBox | StringFormatFlagsMeasureTrailingSpaces, LANG_NEUTRAL, &fmt);
GdipSetStringFormatAlign(fmt, StringAlignmentNear);
GdipCreatePath(FillModeAlternate, &path_tmp);
/*to compute first glyph alignment (say 'x', we figure out its bounding full box by using the '_' char as wrapper (eg, "_x_")
then the bounding box starting from xMin of the glyph ('x_'). The difference between both will give us a good approx
of the glyph alignment*/
str[0] = (unsigned short) '_';
str[1] = string[i];
str[2] = (unsigned short) '_';
str[3] = (unsigned short) 0;
GdipAddPathString(path_tmp, str, -1, ctx->font, ctx->font_style, ctx->font_size, &rc, fmt);
GdipGetPathWorldBounds(path_tmp, &rc, NULL, NULL);
Float w1 = rc.Width - 2 * ctx->underscore_width;
GdipResetPath(path_tmp);
str[0] = string[i];
str[1] = (unsigned short) '_';
str[2] = (unsigned short) 0;
rc.X = rc.Y = 0;
rc.Width = rc.Height = 0;
GdipAddPathString(path_tmp, str, -1, ctx->font, ctx->font_style, ctx->font_size, &rc, fmt);
GdipGetPathWorldBounds(path_tmp, &rc, NULL, NULL);
real_start = w1 - (rc.Width - ctx->underscore_width);
GdipResetPath(path_tmp);
rc.X = rc.Y = 0;
rc.Width = rc.Height = 0;
GdipAddPathString(path_tmp, string, -1, ctx->font, ctx->font_style, ctx->font_size, &rc, fmt);
GdipGetPathWorldBounds(path_tmp, &rc, NULL, NULL);
GdipCreateMatrix(&mat);
Float off_left = rc.X;
Float off_left_real = rc.X;
/*adjust all white space at begin*/
adjust_white_space(string, &off_left, -1*ctx->whitespace_width);
if (flipText) {
/*first translate in local system*/
GdipTranslateMatrix(mat, left - off_left + real_start, -top, MatrixOrderAppend);
/*then scale as specified*/
GdipScaleMatrix(mat, x_scaling, -y_scaling, MatrixOrderAppend);
} else {
/*first translate in local system*/
GdipTranslateMatrix(mat, left - off_left + real_start, top-ascent, MatrixOrderAppend);
/*then scale as specified*/
GdipScaleMatrix(mat, x_scaling, y_scaling, MatrixOrderAppend);
}
GdipTransformPath(path_tmp, mat);
/*start enum*/
s32 count;
GdipGetPointCount(path_tmp, &count);
GpPointF *pts = new GpPointF[count];
BYTE *types = new BYTE[count];
GdipGetPathTypes(path_tmp, types, count);
GdipGetPathPoints(path_tmp, pts, count);
for (i=0; i<count; ) {
BOOL closed = 0;
s32 sub_type;
sub_type = types[i] & PathPointTypePathTypeMask;
if (sub_type == PathPointTypeStart) {
m4_path_add_move_to(path, pts[i].X, pts[i].Y);
i++;
}
else if (sub_type == PathPointTypeLine) {
m4_path_add_line_to(path, pts[i].X, pts[i].Y);
if (types[i] & PathPointTypeCloseSubpath) m4_path_close(path);
i++;
}
else if (sub_type == PathPointTypeBezier) {
assert(i+2<=count);
m4_path_add_cubic_to(path, pts[i].X, pts[i].Y, pts[i+1].X, pts[i+1].Y, pts[i+2].X, pts[i+2].Y);
if (types[i+2] & PathPointTypeCloseSubpath) m4_path_close(path);
i += 3;
} else {
assert(0);
break;
}
}
delete [] pts;
delete [] types;
GdipResetPath(path_tmp);
adjust_white_space(string, &rc.Width, ctx->whitespace_width);
rc.X = off_left_real;
rc.X = off_left;
/*special case where string is just space*/
if (!rc.Height) rc.Height = 1;
GdipAddPathRectangles(path_tmp, &rc, 1);
GdipGetPathWorldBounds(path_tmp, &rc, mat, NULL);
bounds->x = rc.X;
bounds->y = rc.Y;
bounds->width = rc.Width;
bounds->height = rc.Height;
GdipDeleteStringFormat(fmt);
GdipDeletePath(path_tmp);
GdipDeleteMatrix(mat);
return M4OK;
}
