dlls/gdiplus/gdiplus_private.h

   1 /*
   2  * Copyright (C) 2007 Google (Evan Stade)
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #ifndef __WINE_GP_PRIVATE_H_
  20 #define __WINE_GP_PRIVATE_H_
  21
  22 #include <math.h>
  23 #include <stdarg.h>
  24
  25 #include "windef.h"
  26 #include "wingdi.h"
  27 #include "winbase.h"
  28 #include "winuser.h"
  29
  30 #include "objbase.h"
  31 #include "ocidl.h"
  32 #include "wincodecsdk.h"
  33 #include "wine/list.h"
  34
  35 #include "gdiplus.h"
  36
  37 #define GP_DEFAULT_PENSTYLE (PS_GEOMETRIC | PS_SOLID | PS_ENDCAP_FLAT | PS_JOIN_MITER)
  38 #define MAX_ARC_PTS (13)
  39 #define MAX_DASHLEN (16) /* this is a limitation of gdi */
  40 #define INCH_HIMETRIC (2540)
  41
  42 #define VERSION_MAGIC  0xdbc01001
  43 #define VERSION_MAGIC2 0xdbc01002
  44 #define TENSION_CONST (0.3)
  45
  46 #define GIF_DISPOSE_UNSPECIFIED 0
  47 #define GIF_DISPOSE_DO_NOT_DISPOSE 1
  48 #define GIF_DISPOSE_RESTORE_TO_BKGND 2
  49 #define GIF_DISPOSE_RESTORE_TO_PREV 3
  50
  51 static void *heap_alloc(size_t len) __WINE_ALLOC_SIZE(1);
  52 static inline void *heap_alloc(size_t len)
  53 {
  54     return HeapAlloc(GetProcessHeap(), 0, len);
  55 }
  56
  57 static void *heap_alloc_zero(size_t len) __WINE_ALLOC_SIZE(1);
  58 static inline void *heap_alloc_zero(size_t len)
  59 {
  60     return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len);
  61 }
  62
  63 static void *heap_realloc(void *mem, size_t len) __WINE_ALLOC_SIZE(2);
  64 static inline void *heap_realloc(void *mem, size_t len)
  65 {
  66     return HeapReAlloc(GetProcessHeap(), 0, mem, len);
  67 }
  68
  69 static inline BOOL heap_free(void *mem)
  70 {
  71     return HeapFree(GetProcessHeap(), 0, mem);
  72 }
  73
  74 COLORREF ARGB2COLORREF(ARGB color) DECLSPEC_HIDDEN;
  75 HBITMAP ARGB2BMP(ARGB color) DECLSPEC_HIDDEN;
  76 extern INT arc2polybezier(GpPointF * points, REAL x1, REAL y1, REAL x2, REAL y2,
  77     REAL startAngle, REAL sweepAngle) DECLSPEC_HIDDEN;
  78 extern REAL gdiplus_atan2(REAL dy, REAL dx) DECLSPEC_HIDDEN;
  79 extern GpStatus hresult_to_status(HRESULT res) DECLSPEC_HIDDEN;
  80 extern REAL units_to_pixels(REAL units, GpUnit unit, REAL dpi) DECLSPEC_HIDDEN;
  81 extern REAL pixels_to_units(REAL pixels, GpUnit unit, REAL dpi) DECLSPEC_HIDDEN;
  82 extern REAL units_scale(GpUnit from, GpUnit to, REAL dpi) DECLSPEC_HIDDEN;
  83
  84 extern GpStatus get_graphics_transform(GpGraphics *graphics, GpCoordinateSpace dst_space,
  85         GpCoordinateSpace src_space, GpMatrix *matrix) DECLSPEC_HIDDEN;
  86
  87 extern GpStatus graphics_from_image(GpImage *image, GpGraphics **graphics) DECLSPEC_HIDDEN;
  88
  89 extern GpStatus METAFILE_GetGraphicsContext(GpMetafile* metafile, GpGraphics **result) DECLSPEC_HIDDEN;
  90 extern GpStatus METAFILE_GetDC(GpMetafile* metafile, HDC *hdc) DECLSPEC_HIDDEN;
  91 extern GpStatus METAFILE_ReleaseDC(GpMetafile* metafile, HDC hdc) DECLSPEC_HIDDEN;
  92 extern GpStatus METAFILE_GraphicsClear(GpMetafile* metafile, ARGB color) DECLSPEC_HIDDEN;
  93 extern GpStatus METAFILE_FillRectangles(GpMetafile* metafile, GpBrush* brush,
  94     GDIPCONST GpRectF* rects, INT count) DECLSPEC_HIDDEN;
  95 extern GpStatus METAFILE_SetClipRect(GpMetafile* metafile,
  96     REAL x, REAL y, REAL width, REAL height, CombineMode mode) DECLSPEC_HIDDEN;
  97 extern GpStatus METAFILE_SetPageTransform(GpMetafile* metafile, GpUnit unit, REAL scale) DECLSPEC_HIDDEN;
  98 extern GpStatus METAFILE_SetWorldTransform(GpMetafile* metafile, GDIPCONST GpMatrix* transform) DECLSPEC_HIDDEN;
  99 extern GpStatus METAFILE_ScaleWorldTransform(GpMetafile* metafile, REAL sx, REAL sy, MatrixOrder order) DECLSPEC_HIDDEN;
 100 extern GpStatus METAFILE_MultiplyWorldTransform(GpMetafile* metafile, GDIPCONST GpMatrix* matrix, MatrixOrder order) DECLSPEC_HIDDEN;
 101 extern GpStatus METAFILE_RotateWorldTransform(GpMetafile* metafile, REAL angle, MatrixOrder order) DECLSPEC_HIDDEN;
 102 extern GpStatus METAFILE_TranslateWorldTransform(GpMetafile* metafile, REAL dx, REAL dy, MatrixOrder order) DECLSPEC_HIDDEN;
 103 extern GpStatus METAFILE_ResetWorldTransform(GpMetafile* metafile) DECLSPEC_HIDDEN;
 104 extern GpStatus METAFILE_BeginContainer(GpMetafile* metafile, GDIPCONST GpRectF *dstrect,
 105     GDIPCONST GpRectF *srcrect, GpUnit unit, DWORD StackIndex) DECLSPEC_HIDDEN;
 106 extern GpStatus METAFILE_BeginContainerNoParams(GpMetafile* metafile, DWORD StackIndex) DECLSPEC_HIDDEN;
 107 extern GpStatus METAFILE_EndContainer(GpMetafile* metafile, DWORD StackIndex) DECLSPEC_HIDDEN;
 108 extern GpStatus METAFILE_SaveGraphics(GpMetafile* metafile, DWORD StackIndex) DECLSPEC_HIDDEN;
 109 extern GpStatus METAFILE_RestoreGraphics(GpMetafile* metafile, DWORD StackIndex) DECLSPEC_HIDDEN;
 110 extern GpStatus METAFILE_GraphicsDeleted(GpMetafile* metafile) DECLSPEC_HIDDEN;
 111
 112 extern void calc_curve_bezier(const GpPointF *pts, REAL tension, REAL *x1,
 113     REAL *y1, REAL *x2, REAL *y2) DECLSPEC_HIDDEN;
 114 extern void calc_curve_bezier_endp(REAL xend, REAL yend, REAL xadj, REAL yadj,
 115     REAL tension, REAL *x, REAL *y) DECLSPEC_HIDDEN;
 116
 117 extern void free_installed_fonts(void) DECLSPEC_HIDDEN;
 118
 119 extern BOOL lengthen_path(GpPath *path, INT len) DECLSPEC_HIDDEN;
 120
 121 extern GpStatus trace_path(GpGraphics *graphics, GpPath *path) DECLSPEC_HIDDEN;
 122
 123 typedef struct region_element region_element;
 124 extern void delete_element(region_element *element) DECLSPEC_HIDDEN;
 125
 126 extern GpStatus get_hatch_data(HatchStyle hatchstyle, const char **result) DECLSPEC_HIDDEN;
 127
 128 static inline INT gdip_round(REAL x)
 129 {
 130     return (INT) floorf(x + 0.5);
 131 }
 132
 133 static inline INT ceilr(REAL x)
 134 {
 135     return (INT) ceilf(x);
 136 }
 137
 138 static inline REAL deg2rad(REAL degrees)
 139 {
 140     return M_PI * degrees / 180.0;
 141 }
 142
 143 static inline ARGB color_over(ARGB bg, ARGB fg)
 144 {
 145     BYTE b, g, r, a;
 146     BYTE bg_alpha, fg_alpha;
 147
 148     fg_alpha = (fg>>24)&0xff;
 149
 150     if (fg_alpha == 0xff) return fg;
 151
 152     if (fg_alpha == 0) return bg;
 153
 154     bg_alpha = (((bg>>24)&0xff) * (0xff-fg_alpha)) / 0xff;
 155
 156     if (bg_alpha == 0) return fg;
 157
 158     a = bg_alpha + fg_alpha;
 159     b = ((bg&0xff)*bg_alpha + (fg&0xff)*fg_alpha)/a;
 160     g = (((bg>>8)&0xff)*bg_alpha + ((fg>>8)&0xff)*fg_alpha)/a;
 161     r = (((bg>>16)&0xff)*bg_alpha + ((fg>>16)&0xff)*fg_alpha)/a;
 162
 163     return (a<<24)|(r<<16)|(g<<8)|b;
 164 }
 165
 166 /* fg is premult, bg and return value are not */
 167 static inline ARGB color_over_fgpremult(ARGB bg, ARGB fg)
 168 {
 169     BYTE b, g, r, a;
 170     BYTE bg_alpha, fg_alpha;
 171
 172     fg_alpha = (fg>>24)&0xff;
 173
 174     if (fg_alpha == 0) return bg;
 175
 176     bg_alpha = (((bg>>24)&0xff) * (0xff-fg_alpha)) / 0xff;
 177
 178     a = bg_alpha + fg_alpha;
 179     b = ((bg&0xff)*bg_alpha + (fg&0xff)*0xff)/a;
 180     g = (((bg>>8)&0xff)*bg_alpha + ((fg>>8)&0xff)*0xff)/a;
 181     r = (((bg>>16)&0xff)*bg_alpha + ((fg>>16)&0xff)*0xff)/a;
 182
 183     return (a<<24)|(r<<16)|(g<<8)|b;
 184 }
 185
 186 extern const char *debugstr_rectf(const RectF* rc) DECLSPEC_HIDDEN;
 187
 188 extern const char *debugstr_pointf(const PointF* pt) DECLSPEC_HIDDEN;
 189
 190 extern void convert_32bppARGB_to_32bppPARGB(UINT width, UINT height,
 191     BYTE *dst_bits, INT dst_stride, const BYTE *src_bits, INT src_stride) DECLSPEC_HIDDEN;
 192
 193 extern GpStatus convert_pixels(INT width, INT height,
 194     INT dst_stride, BYTE *dst_bits, PixelFormat dst_format,
 195     INT src_stride, const BYTE *src_bits, PixelFormat src_format, ColorPalette *palette) DECLSPEC_HIDDEN;
 196
 197 extern PixelFormat apply_image_attributes(const GpImageAttributes *attributes, LPBYTE data,
 198     UINT width, UINT height, INT stride, ColorAdjustType type, PixelFormat fmt) DECLSPEC_HIDDEN;
 199
 200 struct GpMatrix{
 201     REAL matrix[6];
 202 };
 203
 204 struct GpPen{
 205     UINT style;
 206     GpUnit unit;
 207     REAL width;
 208     GpLineCap endcap;
 209     GpLineCap startcap;
 210     GpDashCap dashcap;
 211     GpCustomLineCap *customstart;
 212     GpCustomLineCap *customend;
 213     GpLineJoin join;
 214     REAL miterlimit;
 215     GpDashStyle dash;
 216     REAL *dashes;
 217     INT numdashes;
 218     REAL offset;    /* dash offset */
 219     GpBrush *brush;
 220     GpPenAlignment align;
 221     GpMatrix transform;
 222 };
 223
 224 struct GpGraphics{
 225     HDC hdc;
 226     HWND hwnd;
 227     BOOL owndc;
 228     BOOL alpha_hdc;
 229     GpImage *image;
 230     ImageType image_type;
 231     SmoothingMode smoothing;
 232     CompositingQuality compqual;
 233     InterpolationMode interpolation;
 234     PixelOffsetMode pixeloffset;
 235     CompositingMode compmode;
 236     TextRenderingHint texthint;
 237     GpUnit unit;    /* page unit */
 238     REAL scale;     /* page scale */
 239     REAL xres, yres;
 240     GpMatrix worldtrans; /* world transform */
 241     BOOL busy;      /* hdc handle obtained by GdipGetDC */
 242     GpRegion *clip; /* in device coords */
 243     UINT textcontrast; /* not used yet. get/set only */
 244     struct list containers;
 245     GraphicsContainer contid; /* last-issued container ID */
 246     INT origin_x, origin_y;
 247     /* For giving the caller an HDC when we technically can't: */
 248     HBITMAP temp_hbitmap;
 249     int temp_hbitmap_width;
 250     int temp_hbitmap_height;
 251     BYTE *temp_bits;
 252     HDC temp_hdc;
 253 };
 254
 255 struct GpBrush{
 256     GpBrushType bt;
 257 };
 258
 259 struct GpHatch{
 260     GpBrush brush;
 261     HatchStyle hatchstyle;
 262     ARGB forecol;
 263     ARGB backcol;
 264 };
 265
 266 struct GpSolidFill{
 267     GpBrush brush;
 268     ARGB color;
 269 };
 270
 271 struct GpPathGradient{
 272     GpBrush brush;
 273     GpPath* path;
 274     ARGB centercolor;
 275     GpWrapMode wrap;
 276     BOOL gamma;
 277     GpPointF center;
 278     GpPointF focus;
 279     REAL* blendfac;  /* blend factors */
 280     REAL* blendpos;  /* blend positions */
 281     INT blendcount;
 282     ARGB *surroundcolors;
 283     INT surroundcolorcount;
 284     ARGB* pblendcolor; /* preset blend colors */
 285     REAL* pblendpos; /* preset blend positions */
 286     INT pblendcount;
 287     GpMatrix transform;
 288 };
 289
 290 struct GpLineGradient{
 291     GpBrush brush;
 292     GpPointF startpoint;
 293     GpPointF endpoint;
 294     ARGB startcolor;
 295     ARGB endcolor;
 296     RectF rect;
 297     GpWrapMode wrap;
 298     BOOL gamma;
 299     REAL* blendfac;  /* blend factors */
 300     REAL* blendpos;  /* blend positions */
 301     INT blendcount;
 302     ARGB* pblendcolor; /* preset blend colors */
 303     REAL* pblendpos; /* preset blend positions */
 304     INT pblendcount;
 305 };
 306
 307 struct GpTexture{
 308     GpBrush brush;
 309     GpMatrix transform;
 310     GpImage *image;
 311     GpImageAttributes *imageattributes;
 312     BYTE *bitmap_bits; /* image bits converted to ARGB and run through imageattributes */
 313 };
 314
 315 struct GpPath{
 316     GpFillMode fill;
 317     GpPathData pathdata;
 318     BOOL newfigure; /* whether the next drawing action starts a new figure */
 319     INT datalen; /* size of the arrays in pathdata */
 320 };
 321
 322 struct GpPathIterator{
 323     GpPathData pathdata;
 324     INT subpath_pos;    /* for NextSubpath methods */
 325     INT marker_pos;     /* for NextMarker methods */
 326     INT pathtype_pos;   /* for NextPathType methods */
 327 };
 328
 329 struct GpCustomLineCap{
 330     GpPathData pathdata;
 331     BOOL fill;      /* TRUE for fill, FALSE for stroke */
 332     GpLineCap cap;  /* as far as I can tell, this value is ignored */
 333     REAL inset;     /* how much to adjust the end of the line */
 334     GpLineJoin join;
 335     REAL scale;
 336 };
 337
 338 struct GpAdjustableArrowCap{
 339     GpCustomLineCap cap;
 340 };
 341
 342 struct GpImage{
 343     IWICBitmapDecoder *decoder;
 344     ImageType type;
 345     GUID format;
 346     UINT flags;
 347     UINT frame_count, current_frame;
 348     ColorPalette *palette;
 349     REAL xres, yres;
 350 };
 351
 352 struct GpMetafile{
 353     GpImage image;
 354     GpRectF bounds;
 355     GpUnit unit;
 356     MetafileType metafile_type;
 357     HENHMETAFILE hemf;
 358     int preserve_hemf; /* if true, hemf belongs to the app and should not be deleted */
 359
 360     /* recording */
 361     HDC record_dc;
 362     GpGraphics *record_graphics;
 363     BYTE *comment_data;
 364     DWORD comment_data_size;
 365     DWORD comment_data_length;
 366     IStream *record_stream;
 367     BOOL auto_frame; /* If true, determine the frame automatically */
 368     GpPointF auto_frame_min, auto_frame_max;
 369
 370     /* playback */
 371     GpGraphics *playback_graphics;
 372     HDC playback_dc;
 373     GpPointF playback_points[3];
 374     GpRectF src_rect;
 375     HANDLETABLE *handle_table;
 376     int handle_count;
 377     GpMatrix *world_transform;
 378     GpUnit page_unit;
 379     REAL page_scale;
 380     GpRegion *base_clip; /* clip region in device space for all metafile output */
 381     GpRegion *clip; /* clip region within the metafile */
 382     struct list containers;
 383 };
 384
 385 struct GpBitmap{
 386     GpImage image;
 387     INT width;
 388     INT height;
 389     PixelFormat format;
 390     ImageLockMode lockmode;
 391     INT numlocks;
 392     BYTE *bitmapbits;   /* pointer to the buffer we passed in BitmapLockBits */
 393     HBITMAP hbitmap;
 394     HDC hdc;
 395     BYTE *bits; /* actual image bits if this is a DIB */
 396     INT stride; /* stride of bits if this is a DIB */
 397     BYTE *own_bits; /* image bits that need to be freed with this object */
 398     INT lockx, locky; /* X and Y coordinates of the rect when a bitmap is locked for writing. */
 399     IWICMetadataReader *metadata_reader; /* NULL if there is no metadata */
 400     UINT prop_count;
 401     PropertyItem *prop_item; /* cached image properties */
 402 };
 403
 404 struct GpCachedBitmap{
 405     GpImage *image;
 406 };
 407
 408 struct color_key{
 409     BOOL enabled;
 410     ARGB low;
 411     ARGB high;
 412 };
 413
 414 struct color_matrix{
 415     BOOL enabled;
 416     ColorMatrixFlags flags;
 417     ColorMatrix colormatrix;
 418     ColorMatrix graymatrix;
 419 };
 420
 421 struct color_remap_table{
 422     BOOL enabled;
 423     INT mapsize;
 424     ColorMap *colormap;
 425 };
 426
 427 struct GpImageAttributes{
 428     WrapMode wrap;
 429     ARGB outside_color;
 430     BOOL clamp;
 431     struct color_key colorkeys[ColorAdjustTypeCount];
 432     struct color_matrix colormatrices[ColorAdjustTypeCount];
 433     struct color_remap_table colorremaptables[ColorAdjustTypeCount];
 434     BOOL gamma_enabled[ColorAdjustTypeCount];
 435     REAL gamma[ColorAdjustTypeCount];
 436 };
 437
 438 struct GpFont{
 439     GpFontFamily *family;
 440     OUTLINETEXTMETRICW otm;
 441     REAL emSize; /* in font units */
 442     Unit unit;
 443 };
 444
 445 struct GpStringFormat{
 446     INT attr;
 447     LANGID lang;
 448     LANGID digitlang;
 449     StringAlignment align;
 450     StringTrimming trimming;
 451     HotkeyPrefix hkprefix;
 452     StringAlignment vertalign;
 453     StringDigitSubstitute digitsub;
 454     INT tabcount;
 455     REAL firsttab;
 456     REAL *tabs;
 457     CharacterRange *character_ranges;
 458     INT range_count;
 459     BOOL generic_typographic;
 460 };
 461
 462 struct GpFontCollection{
 463     GpFontFamily **FontFamilies;
 464     INT count;
 465     INT allocated;
 466 };
 467
 468 struct GpFontFamily{
 469     WCHAR FamilyName[LF_FACESIZE];
 470     UINT16 em_height, ascent, descent, line_spacing; /* in font units */
 471     int dpi;
 472 };
 473
 474 /* internal use */
 475 typedef enum RegionType
 476 {
 477     RegionDataRect          = 0x10000000,
 478     RegionDataPath          = 0x10000001,
 479     RegionDataEmptyRect     = 0x10000002,
 480     RegionDataInfiniteRect  = 0x10000003,
 481 } RegionType;
 482
 483 struct region_element
 484 {
 485     DWORD type; /* Rectangle, Path, SpecialRectangle, or CombineMode */
 486     union
 487     {
 488         GpRectF rect;
 489         GpPath *path;
 490         struct
 491         {
 492             struct region_element *left;  /* the original region */
 493             struct region_element *right; /* what *left was combined with */
 494         } combine;
 495     } elementdata;
 496 };
 497
 498 struct GpRegion{
 499     DWORD num_children;
 500     region_element node;
 501 };
 502
 503 typedef GpStatus (*gdip_format_string_callback)(HDC hdc,
 504     GDIPCONST WCHAR *string, INT index, INT length, GDIPCONST GpFont *font,
 505     GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format,
 506     INT lineno, const RectF *bounds, INT *underlined_indexes,
 507     INT underlined_index_count, void *user_data);
 508
 509 GpStatus gdip_format_string(HDC hdc,
 510     GDIPCONST WCHAR *string, INT length, GDIPCONST GpFont *font,
 511     GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format, int ignore_empty_clip,
 512     gdip_format_string_callback callback, void *user_data) DECLSPEC_HIDDEN;
 513
 514 void get_log_fontW(const GpFont *, GpGraphics *, LOGFONTW *) DECLSPEC_HIDDEN;
 515
 516 #endif