GpStatus WINGDIPAPI GdipCreateFontFamilyFromName(GDIPCONST WCHAR *name, GpFontCollection *fontCollection, GpFontFamily **FontFamily) { GpStatus stat; GpFontFamily* ffamily; struct font_metrics fm; TRACE("%s, %p %p\n", debugstr_w(name), fontCollection, FontFamily); if (!(name && FontFamily)) return InvalidParameter; if (fontCollection) FIXME("No support for FontCollections yet!\n"); stat = find_installed_font(name, &fm); if (stat != Ok) return stat; ffamily = GdipAlloc(sizeof (GpFontFamily)); if (!ffamily) return OutOfMemory; lstrcpynW(ffamily->FamilyName, name, LF_FACESIZE); ffamily->em_height = fm.em_height; ffamily->ascent = fm.ascent; ffamily->descent = fm.descent; ffamily->line_spacing = fm.line_spacing; ffamily->dpi = fm.dpi; *FontFamily = ffamily; TRACE("<-- %p\n", ffamily); return Ok; }
GpStatus WINGDIPAPI GdipSetStringFormatTabStops(GpStringFormat *format, REAL firsttab, INT count, GDIPCONST REAL *tabs) { TRACE("(%p, %0.2f, %i, %p)\n", format, firsttab, count, tabs); if(!format || !tabs) return InvalidParameter; if(count > 0){ if(firsttab < 0.0) return NotImplemented; /* first time allocation */ if(format->tabcount == 0){ format->tabs = GdipAlloc(sizeof(REAL)*count); if(!format->tabs) return OutOfMemory; } /* reallocation */ if((format->tabcount < count) && (format->tabcount > 0)){ REAL *ptr; ptr = HeapReAlloc(GetProcessHeap(), 0, format->tabs, sizeof(REAL)*count); if(!ptr) return OutOfMemory; format->tabs = ptr; } format->firsttab = firsttab; format->tabcount = count; memcpy(format->tabs, tabs, sizeof(REAL)*count); } return Ok; }
/***************************************************************************** * GdipCreateRegionRect [GDIPLUS.@] */ GpStatus WINGDIPAPI GdipCreateRegionRect(GDIPCONST GpRectF *rect, GpRegion **region) { GpStatus stat; TRACE("%p, %p\n", rect, region); if (!(rect && region)) return InvalidParameter; *region = GdipAlloc(sizeof(GpRegion)); stat = init_region(*region, RegionDataRect); if(stat != Ok) { GdipDeleteRegion(*region); return stat; } (*region)->node.elementdata.rect.X = rect->X; (*region)->node.elementdata.rect.Y = rect->Y; (*region)->node.elementdata.rect.Width = rect->Width; (*region)->node.elementdata.rect.Height = rect->Height; return Ok; }
GpStatus WINGDIPAPI GdipCreateStringFormat(INT attr, LANGID lang, GpStringFormat **format) { TRACE("(%i, %x, %p)\n", attr, lang, format); if(!format) return InvalidParameter; *format = GdipAlloc(sizeof(GpStringFormat)); if(!*format) return OutOfMemory; (*format)->attr = attr; (*format)->lang = lang; (*format)->digitlang = LANG_NEUTRAL; (*format)->trimming = StringTrimmingCharacter; (*format)->digitsub = StringDigitSubstituteUser; (*format)->character_ranges = NULL; (*format)->range_count = 0; (*format)->generic_typographic = FALSE; /* tabstops */ (*format)->tabcount = 0; (*format)->firsttab = 0.0; (*format)->tabs = NULL; TRACE("<-- %p\n", *format); return Ok; }
/* FIXME: Sometimes when fillPath is non-null and stroke path is null, the native * version of this function returns NotImplemented. I cannot figure out why. */ GpStatus WINGDIPAPI GdipCreateCustomLineCap(GpPath* fillPath, GpPath* strokePath, GpLineCap baseCap, REAL baseInset, GpCustomLineCap **customCap) { GpPathData *pathdata; TRACE("%p %p %d %f %p\n", fillPath, strokePath, baseCap, baseInset, customCap); if(!customCap || !(fillPath || strokePath)) return InvalidParameter; *customCap = GdipAlloc(sizeof(GpCustomLineCap)); if(!*customCap) return OutOfMemory; if(strokePath){ (*customCap)->fill = FALSE; pathdata = &strokePath->pathdata; } else{ (*customCap)->fill = TRUE; pathdata = &fillPath->pathdata; } (*customCap)->pathdata.Points = GdipAlloc(pathdata->Count * sizeof(PointF)); (*customCap)->pathdata.Types = GdipAlloc(pathdata->Count); if((!(*customCap)->pathdata.Types || !(*customCap)->pathdata.Points) && pathdata->Count){ GdipFree((*customCap)->pathdata.Points); GdipFree((*customCap)->pathdata.Types); GdipFree(*customCap); return OutOfMemory; } memcpy((*customCap)->pathdata.Points, pathdata->Points, pathdata->Count * sizeof(PointF)); memcpy((*customCap)->pathdata.Types, pathdata->Types, pathdata->Count); (*customCap)->pathdata.Count = pathdata->Count; (*customCap)->inset = baseInset; (*customCap)->cap = baseCap; (*customCap)->join = LineJoinMiter; (*customCap)->scale = 1.0; TRACE("<-- %p\n", *customCap); return Ok; }
/* coverity[+alloc : arg-*1] */ GpStatus WINGDIPAPI GdipCloneStringFormat (GDIPCONST GpStringFormat *format, GpStringFormat **newFormat) { GpStringFormat *result; if (!format || !newFormat) return InvalidParameter; result = gdip_string_format_new (); if (!result) goto error; result->alignment = format->alignment; result->lineAlignment = format->lineAlignment; result->hotkeyPrefix = format->hotkeyPrefix; result->formatFlags = format->formatFlags; result->trimming = format->trimming; result->substitute = format->substitute; result->language = format->language; result->firstTabOffset = format->firstTabOffset; result->numtabStops = format->numtabStops; result->charRangeCount = format->charRangeCount; /* Create a copy of tab stops for the clone */ result->tabStops = (float *) GdipAlloc (sizeof (float) * format->numtabStops); if (!result->tabStops) goto error; memcpy (result->tabStops, format->tabStops, format->numtabStops * sizeof (float)); /* Create a copy of char ranges for the clone */ result->charRanges = (CharacterRange *) GdipAlloc (format->charRangeCount * sizeof (CharacterRange)); if (result->charRanges == NULL) goto error; memcpy (result->charRanges, format->charRanges, format->charRangeCount * sizeof (CharacterRange)); *newFormat = result; return Ok; error: if (result) GdipDeleteStringFormat (result); *newFormat = NULL; return OutOfMemory; }
GpStatus WINGDIPAPI GdipClonePen(GpPen *pen, GpPen **clonepen) { GpStatus stat; TRACE("(%p, %p)\n", pen, clonepen); if(!pen || !clonepen) return InvalidParameter; *clonepen = GdipAlloc(sizeof(GpPen)); if(!*clonepen) return OutOfMemory; **clonepen = *pen; (*clonepen)->customstart = NULL; (*clonepen)->customend = NULL; (*clonepen)->brush = NULL; (*clonepen)->dashes = NULL; stat = GdipCloneBrush(pen->brush, &(*clonepen)->brush); if (stat == Ok && pen->customstart) stat = GdipCloneCustomLineCap(pen->customstart, &(*clonepen)->customstart); if (stat == Ok && pen->customend) stat = GdipCloneCustomLineCap(pen->customend, &(*clonepen)->customend); if (stat == Ok && pen->dashes) { (*clonepen)->dashes = GdipAlloc(pen->numdashes * sizeof(REAL)); if ((*clonepen)->dashes) memcpy((*clonepen)->dashes, pen->dashes, pen->numdashes * sizeof(REAL)); else stat = OutOfMemory; } if (stat != Ok) { GdipDeletePen(*clonepen); *clonepen = NULL; return stat; } TRACE("<-- %p\n", *clonepen); return Ok; }
static GpTexture* gdip_texture_new (void) { GpTexture *result = (GpTexture *) GdipAlloc (sizeof (GpTexture)); if (result) gdip_texture_init (result); return result; }
static GpStatus clone_font_family(const GpFontFamily *family, GpFontFamily **clone) { *clone = GdipAlloc(sizeof(GpFontFamily)); if (!*clone) return OutOfMemory; **clone = *family; return Ok; }
static GpStringFormat * gdip_string_format_new () { GpStringFormat *result = GdipAlloc (sizeof (GpStringFormat)); if (result) gdip_string_format_init (result); return result; }
GpStatus WINGDIPAPI GdipCreatePathGradient(GDIPCONST GpPointF* points, INT count, GpWrapMode wrap, GpPathGradient **grad) { COLORREF col = ARGB2COLORREF(0xffffffff); if(!points || !grad) return InvalidParameter; if(count <= 0) return OutOfMemory; *grad = GdipAlloc(sizeof(GpPathGradient)); if (!*grad) return OutOfMemory; (*grad)->pathdata.Count = count; (*grad)->pathdata.Points = GdipAlloc(count * sizeof(PointF)); (*grad)->pathdata.Types = GdipAlloc(count); if(!(*grad)->pathdata.Points || !(*grad)->pathdata.Types){ GdipFree((*grad)->pathdata.Points); GdipFree((*grad)->pathdata.Types); GdipFree(*grad); return OutOfMemory; } memcpy((*grad)->pathdata.Points, points, count * sizeof(PointF)); memset((*grad)->pathdata.Types, PathPointTypeLine, count); (*grad)->brush.lb.lbStyle = BS_SOLID; (*grad)->brush.lb.lbColor = col; (*grad)->brush.lb.lbHatch = 0; (*grad)->brush.gdibrush = CreateSolidBrush(col); (*grad)->brush.bt = BrushTypePathGradient; (*grad)->centercolor = 0xffffffff; (*grad)->wrap = wrap; (*grad)->gamma = FALSE; (*grad)->center.X = 0.0; (*grad)->center.Y = 0.0; (*grad)->focus.X = 0.0; (*grad)->focus.Y = 0.0; return Ok; }
static GpAdjustableArrowCap* gdip_adjust_arrowcap_new (void) { GpAdjustableArrowCap *result = (GpAdjustableArrowCap *) GdipAlloc (sizeof (GpAdjustableArrowCap)); if (result) gdip_adjust_arrowcap_init (result); return result; }
/* FIXME: path gradient brushes not truly supported (drawn as solid brushes) */ GpStatus WINGDIPAPI GdipCreatePathGradientFromPath(GDIPCONST GpPath* path, GpPathGradient **grad) { COLORREF col = ARGB2COLORREF(0xffffffff); if(!path || !grad) return InvalidParameter; *grad = GdipAlloc(sizeof(GpPathGradient)); if (!*grad) return OutOfMemory; (*grad)->pathdata.Count = path->pathdata.Count; (*grad)->pathdata.Points = GdipAlloc(path->pathdata.Count * sizeof(PointF)); (*grad)->pathdata.Types = GdipAlloc(path->pathdata.Count); if(!(*grad)->pathdata.Points || !(*grad)->pathdata.Types){ GdipFree((*grad)->pathdata.Points); GdipFree((*grad)->pathdata.Types); GdipFree(*grad); return OutOfMemory; } memcpy((*grad)->pathdata.Points, path->pathdata.Points, path->pathdata.Count * sizeof(PointF)); memcpy((*grad)->pathdata.Types, path->pathdata.Types, path->pathdata.Count); (*grad)->brush.lb.lbStyle = BS_SOLID; (*grad)->brush.lb.lbColor = col; (*grad)->brush.lb.lbHatch = 0; (*grad)->brush.gdibrush = CreateSolidBrush(col); (*grad)->brush.bt = BrushTypePathGradient; (*grad)->centercolor = 0xffffffff; (*grad)->wrap = WrapModeClamp; (*grad)->gamma = FALSE; /* FIXME: this should be set to the "centroid" of the path by default */ (*grad)->center.X = 0.0; (*grad)->center.Y = 0.0; (*grad)->focus.X = 0.0; (*grad)->focus.Y = 0.0; return Ok; }
static GpPen* gdip_pen_new (void) { GpPen *result = (GpPen *) GdipAlloc (sizeof (GpPen)); if (result) gdip_pen_init (result); return result; }
/******************************************************************************* * GdipCreateFont [GDIPLUS.@] * * Create a new font based off of a FontFamily * * PARAMS * *fontFamily [I] Family to base the font off of * emSize [I] Size of the font * style [I] Bitwise OR of FontStyle enumeration * unit [I] Unit emSize is measured in * **font [I] the resulting Font object * * RETURNS * SUCCESS: Ok * FAILURE: InvalidParameter if fontfamily or font is NULL. * FAILURE: FontFamilyNotFound if an invalid FontFamily is given * * NOTES * UnitDisplay is unsupported. * emSize is stored separately from lfHeight, to hold the fraction. */ GpStatus WINGDIPAPI GdipCreateFont(GDIPCONST GpFontFamily *fontFamily, REAL emSize, INT style, Unit unit, GpFont **font) { HFONT hfont; OUTLINETEXTMETRICW otm; LOGFONTW lfw; HDC hdc; GpStatus stat; int ret; if (!fontFamily || !font || emSize < 0.0) return InvalidParameter; TRACE("%p (%s), %f, %d, %d, %p\n", fontFamily, debugstr_w(fontFamily->FamilyName), emSize, style, unit, font); memset(&lfw, 0, sizeof(lfw)); stat = GdipGetFamilyName(fontFamily, lfw.lfFaceName, LANG_NEUTRAL); if (stat != Ok) return stat; lfw.lfHeight = -units_to_pixels(emSize, unit, fontFamily->dpi); lfw.lfWeight = style & FontStyleBold ? FW_BOLD : FW_REGULAR; lfw.lfItalic = style & FontStyleItalic; lfw.lfUnderline = style & FontStyleUnderline; lfw.lfStrikeOut = style & FontStyleStrikeout; hfont = CreateFontIndirectW(&lfw); hdc = CreateCompatibleDC(0); SelectObject(hdc, hfont); otm.otmSize = sizeof(otm); ret = GetOutlineTextMetricsW(hdc, otm.otmSize, &otm); DeleteDC(hdc); DeleteObject(hfont); if (!ret) return NotTrueTypeFont; *font = GdipAlloc(sizeof(GpFont)); if (!*font) return OutOfMemory; (*font)->unit = unit; (*font)->emSize = emSize; (*font)->otm = otm; stat = clone_font_family(fontFamily, &(*font)->family); if (stat != Ok) { GdipFree(*font); return stat; } TRACE("<-- %p\n", *font); return Ok; }
/* init list */ static BOOL init_path_list(path_list_node_t **node, REAL x, REAL y) { *node = GdipAlloc(sizeof(path_list_node_t)); if(!*node) return FALSE; (*node)->pt.X = x; (*node)->pt.Y = y; (*node)->type = PathPointTypeStart; (*node)->next = NULL; return TRUE; }
/***************************************************************************** * GdipCreateRegion [GDIPLUS.@] */ GpStatus WINGDIPAPI GdipCreateRegion(GpRegion **region) { TRACE("%p\n", region); if(!region) return InvalidParameter; *region = GdipAlloc(sizeof(GpRegion)); if(!*region) return OutOfMemory; return init_region(*region, RegionDataInfiniteRect); }
GpStatus WINGDIPAPI GdipCreatePath(GpFillMode fill, GpPath **path) { if(!path) return InvalidParameter; *path = GdipAlloc(sizeof(GpPath)); if(!*path) return OutOfMemory; (*path)->fill = fill; (*path)->newfigure = TRUE; return Ok; }
GpStatus WINGDIPAPI GdipCloneStringFormat(GDIPCONST GpStringFormat *format, GpStringFormat **newFormat) { if(!format || !newFormat) return InvalidParameter; *newFormat = GdipAlloc(sizeof(GpStringFormat)); if(!*newFormat) return OutOfMemory; **newFormat = *format; if(format->tabcount > 0){ (*newFormat)->tabs = GdipAlloc(sizeof(REAL) * format->tabcount); if(!(*newFormat)->tabs){ GdipFree(*newFormat); return OutOfMemory; } memcpy((*newFormat)->tabs, format->tabs, sizeof(REAL) * format->tabcount); } else (*newFormat)->tabs = NULL; if(format->range_count > 0){ (*newFormat)->character_ranges = GdipAlloc(sizeof(CharacterRange) * format->range_count); if(!(*newFormat)->character_ranges){ GdipFree((*newFormat)->tabs); GdipFree(*newFormat); return OutOfMemory; } memcpy((*newFormat)->character_ranges, format->character_ranges, sizeof(CharacterRange) * format->range_count); } else (*newFormat)->character_ranges = NULL; TRACE("%p %p\n",format,newFormat); return Ok; }
/* * gdip_region_copy_tree: * @source: the GpPathTree to copy * @dest: the GpPathTree copy * * Recursively copy (and allocate) the @source path tree into @dest. * If @source is present then we must have a valid @dest. */ GpStatus gdip_region_copy_tree (GpPathTree *source, GpPathTree *dest) { GpStatus status; if (!source) return Ok; g_assert (dest); if (source->path) { status = GdipClonePath (source->path, &dest->path); if (status != Ok) return status; dest->branch1 = NULL; dest->branch2 = NULL; } else { dest->path = NULL; dest->mode = source->mode; dest->branch1 = (GpPathTree *) GdipAlloc (sizeof (GpPathTree)); if (!dest->branch1) return OutOfMemory; status = gdip_region_copy_tree (source->branch1, dest->branch1); if (status != Ok) return status; dest->branch2 = (GpPathTree *) GdipAlloc (sizeof (GpPathTree)); if (!dest->branch2) return OutOfMemory; status = gdip_region_copy_tree (source->branch2, dest->branch2); if (status != Ok) return status; } return Ok; }
/******************************************************************************* * GdipCloneFont [GDIPLUS.@] */ GpStatus WINGDIPAPI GdipCloneFont(GpFont *font, GpFont **cloneFont) { TRACE("(%p, %p)\n", font, cloneFont); if(!font || !cloneFont) return InvalidParameter; *cloneFont = GdipAlloc(sizeof(GpFont)); if(!*cloneFont) return OutOfMemory; **cloneFont = *font; return Ok; }
static double * convert_dash_array (float *f, double width, int count) { double *retval = GdipAlloc (sizeof (double) * count); if (!retval) return NULL; int i; for (i = 0; i < count; i++) { retval[i] = (double) f[i] * width; } return retval; }
static void gdip_createFontFamily (GpFontFamily **family) { GpFontFamily *result = (GpFontFamily *) GdipAlloc (sizeof (GpFontFamily)); if (result) { result->height = -1; result->linespacing = -1; result->celldescent = -1; result->cellascent = -1; result->pattern = NULL; result->allocated = FALSE; } *family = result; }
/***************************************************************************** * GdipGetGenericFontFamilySansSerif [GDIPLUS.@] */ GpStatus WINGDIPAPI GdipNewPrivateFontCollection(GpFontCollection** fontCollection) { TRACE("%p\n", fontCollection); if (!fontCollection) return InvalidParameter; *fontCollection = GdipAlloc(sizeof(GpFontCollection)); if (!*fontCollection) return OutOfMemory; (*fontCollection)->FontFamilies = NULL; (*fontCollection)->count = 0; return Ok; }
static GpStatus AllocStringData (WCHAR **clean_string, GpStringDetailStruct **details, int length) { *details = gdip_calloc (length + 1, sizeof (GpStringDetailStruct)); if (!*details) return OutOfMemory; *clean_string = GdipAlloc (sizeof (WCHAR) * (length + 1)); if (!*clean_string) { GdipFree (*details); return OutOfMemory; } return Ok; }
GpPointF * convert_points (const GpPoint *point, int count) { int i; GpPointF *retval = (GpPointF *) GdipAlloc (sizeof (GpPointF) * count); if (!retval) return NULL; for (i = 0; i < count; i++) { retval [i].X = (float) point [i].X; retval [i].Y = (float) point [i].Y; } return retval; }
/******************************************************************************* * GdipCloneFontFamily [GDIPLUS.@] * * Creates a deep copy of a Font Family object * * PARAMS * FontFamily [I] Font to clone * clonedFontFamily [O] The resulting cloned font * * RETURNS * SUCCESS: Ok */ GpStatus WINGDIPAPI GdipCloneFontFamily(GpFontFamily* FontFamily, GpFontFamily** clonedFontFamily) { if (!(FontFamily && clonedFontFamily)) return InvalidParameter; TRACE("stub: %p (%s), %p\n", FontFamily, debugstr_w(FontFamily->FamilyName), clonedFontFamily); *clonedFontFamily = GdipAlloc(sizeof(GpFontFamily)); if (!*clonedFontFamily) return OutOfMemory; (*clonedFontFamily)->tmw = FontFamily->tmw; lstrcpyW((*clonedFontFamily)->FamilyName, FontFamily->FamilyName); return Ok; }
static inline GpStatus clone_element(const region_element* element, region_element** element2) { GpStatus stat; /* root node is allocated with GpRegion */ if(!*element2){ *element2 = GdipAlloc(sizeof(region_element)); if (!*element2) return OutOfMemory; } (*element2)->type = element->type; switch (element->type) { case RegionDataRect: (*element2)->elementdata.rect = element->elementdata.rect; break; case RegionDataEmptyRect: case RegionDataInfiniteRect: break; case RegionDataPath: (*element2)->elementdata.pathdata.pathheader = element->elementdata.pathdata.pathheader; stat = GdipClonePath(element->elementdata.pathdata.path, &(*element2)->elementdata.pathdata.path); if (stat != Ok) goto clone_out; break; default: (*element2)->elementdata.combine.left = NULL; (*element2)->elementdata.combine.right = NULL; stat = clone_element(element->elementdata.combine.left, &(*element2)->elementdata.combine.left); if (stat != Ok) goto clone_out; stat = clone_element(element->elementdata.combine.right, &(*element2)->elementdata.combine.right); if (stat != Ok) goto clone_out; break; } return Ok; clone_out: delete_element(*element2); *element2 = NULL; return stat; }
// coverity[+alloc : arg-*0] GpStatus GdipNewPrivateFontCollection (GpFontCollection **font_collection) { GpFontCollection *result; if (!font_collection) return InvalidParameter; result = (GpFontCollection *) GdipAlloc (sizeof (GpFontCollection)); if (result) { result->fontset = NULL; result->config = FcConfigCreate (); } *font_collection = result; return Ok; }
static GpRectF * convert_rects (GDIPCONST GpRect *rects, int count) { int i; GpRectF *result = (GpRectF *) GdipAlloc (sizeof (GpRectF) * count); if (!result) return NULL; for (i = 0; i < count; i++) { result [i].X = rects [i].X; result [i].Y = rects [i].Y; result [i].Width = rects [i].Width; result [i].Height = rects [i].Height; } return result; }