- Remove old gdiplus
authorDmitry Chapyshev <dmitry@reactos.org>
Tue, 25 Mar 2008 17:34:57 +0000 (17:34 +0000)
committerDmitry Chapyshev <dmitry@reactos.org>
Tue, 25 Mar 2008 17:34:57 +0000 (17:34 +0000)
- Add gdiplus from wine (Part 1/2)

svn path=/trunk/; revision=32764

50 files changed:
reactos/dll/win32/gdiplus/brush.c [new file with mode: 0644]
reactos/dll/win32/gdiplus/customlinecap.c [new file with mode: 0644]
reactos/dll/win32/gdiplus/font.c [new file with mode: 0644]
reactos/dll/win32/gdiplus/gdiplus.c [new file with mode: 0644]
reactos/dll/win32/gdiplus/gdiplus.def [deleted file]
reactos/dll/win32/gdiplus/gdiplus.rbuild
reactos/dll/win32/gdiplus/gdiplus.rc [deleted file]
reactos/dll/win32/gdiplus/gdiplus.spec [new file with mode: 0644]
reactos/dll/win32/gdiplus/gdiplus/arrow.c [deleted file]
reactos/dll/win32/gdiplus/gdiplus/bitmap.c [deleted file]
reactos/dll/win32/gdiplus/gdiplus/brush.c [deleted file]
reactos/dll/win32/gdiplus/gdiplus/clip.c [deleted file]
reactos/dll/win32/gdiplus/gdiplus/codec.c [deleted file]
reactos/dll/win32/gdiplus/gdiplus/container.c [deleted file]
reactos/dll/win32/gdiplus/gdiplus/dllmain.c [deleted file]
reactos/dll/win32/gdiplus/gdiplus/draw.c [deleted file]
reactos/dll/win32/gdiplus/gdiplus/effect.c [deleted file]
reactos/dll/win32/gdiplus/gdiplus/fill.c [deleted file]
reactos/dll/win32/gdiplus/gdiplus/font.c [deleted file]
reactos/dll/win32/gdiplus/gdiplus/graphics.c [deleted file]
reactos/dll/win32/gdiplus/gdiplus/image.c [deleted file]
reactos/dll/win32/gdiplus/gdiplus/linecap.c [deleted file]
reactos/dll/win32/gdiplus/gdiplus/linegradient.c [deleted file]
reactos/dll/win32/gdiplus/gdiplus/matrix.c [deleted file]
reactos/dll/win32/gdiplus/gdiplus/memory.c [deleted file]
reactos/dll/win32/gdiplus/gdiplus/metafile.c [deleted file]
reactos/dll/win32/gdiplus/gdiplus/palette.c [deleted file]
reactos/dll/win32/gdiplus/gdiplus/path.c [deleted file]
reactos/dll/win32/gdiplus/gdiplus/pathgradient.c [deleted file]
reactos/dll/win32/gdiplus/gdiplus/pathiterator.c [deleted file]
reactos/dll/win32/gdiplus/gdiplus/pen.c [deleted file]
reactos/dll/win32/gdiplus/gdiplus/region.c [deleted file]
reactos/dll/win32/gdiplus/gdiplus/string.c [deleted file]
reactos/dll/win32/gdiplus/gdiplus/texture.c [deleted file]
reactos/dll/win32/gdiplus/gdiplus/transform.c [deleted file]
reactos/dll/win32/gdiplus/gdiplus_private.h [new file with mode: 0644]
reactos/dll/win32/gdiplus/gdiplus_ros.diff [new file with mode: 0644]
reactos/dll/win32/gdiplus/graphics.c [new file with mode: 0644]
reactos/dll/win32/gdiplus/graphicspath.c [new file with mode: 0644]
reactos/dll/win32/gdiplus/image.c [new file with mode: 0644]
reactos/dll/win32/gdiplus/imageattributes.c [new file with mode: 0644]
reactos/dll/win32/gdiplus/include/debug.h [deleted file]
reactos/dll/win32/gdiplus/include/gdiplusprivate.h [deleted file]
reactos/dll/win32/gdiplus/matrix.c [new file with mode: 0644]
reactos/dll/win32/gdiplus/pathiterator.c [new file with mode: 0644]
reactos/dll/win32/gdiplus/pen.c [new file with mode: 0644]
reactos/dll/win32/gdiplus/stringformat.c [new file with mode: 0644]
reactos/dll/win32/gdiplus/tests/setup.c [deleted file]
reactos/dll/win32/gdiplus/tests/stubs.tst [deleted file]
reactos/dll/win32/gdiplus/tests/tests/test-1.c [deleted file]

diff --git a/reactos/dll/win32/gdiplus/brush.c b/reactos/dll/win32/gdiplus/brush.c
new file mode 100644 (file)
index 0000000..45de034
--- /dev/null
@@ -0,0 +1,655 @@
+/*
+ * Copyright (C) 2007 Google (Evan Stade)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <stdarg.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "winuser.h"
+#include "wingdi.h"
+
+#define COBJMACROS
+#include "objbase.h"
+#include "olectl.h"
+#include "ole2.h"
+
+#include "gdiplus.h"
+#include "gdiplus_private.h"
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
+
+GpStatus WINGDIPAPI GdipCloneBrush(GpBrush *brush, GpBrush **clone)
+{
+    if(!brush || !clone)
+        return InvalidParameter;
+
+    switch(brush->bt){
+        case BrushTypeSolidColor:
+            *clone = GdipAlloc(sizeof(GpSolidFill));
+            if (!*clone) return OutOfMemory;
+
+            memcpy(*clone, brush, sizeof(GpSolidFill));
+
+            (*clone)->gdibrush = CreateBrushIndirect(&(*clone)->lb);
+            break;
+        case BrushTypePathGradient:{
+            GpPathGradient *src, *dest;
+            INT count;
+
+            *clone = GdipAlloc(sizeof(GpPathGradient));
+            if (!*clone) return OutOfMemory;
+
+            src = (GpPathGradient*) brush,
+            dest = (GpPathGradient*) *clone;
+            count = src->pathdata.Count;
+
+            memcpy(dest, src, sizeof(GpPathGradient));
+
+            dest->pathdata.Count = count;
+            dest->pathdata.Points = GdipAlloc(count * sizeof(PointF));
+            dest->pathdata.Types = GdipAlloc(count);
+
+            if(!dest->pathdata.Points || !dest->pathdata.Types){
+                GdipFree(dest->pathdata.Points);
+                GdipFree(dest->pathdata.Types);
+                GdipFree(dest);
+                return OutOfMemory;
+            }
+
+            memcpy(dest->pathdata.Points, src->pathdata.Points, count * sizeof(PointF));
+            memcpy(dest->pathdata.Types, src->pathdata.Types, count);
+
+            break;
+        }
+        case BrushTypeLinearGradient:
+            *clone = GdipAlloc(sizeof(GpLineGradient));
+            if(!*clone)    return OutOfMemory;
+
+            memcpy(*clone, brush, sizeof(GpLineGradient));
+
+            (*clone)->gdibrush = CreateSolidBrush((*clone)->lb.lbColor);
+            break;
+        case BrushTypeTextureFill:
+            *clone = GdipAlloc(sizeof(GpTexture));
+            if(!*clone)    return OutOfMemory;
+
+            memcpy(*clone, brush, sizeof(GpTexture));
+
+            (*clone)->gdibrush = CreateBrushIndirect(&(*clone)->lb);
+            break;
+        default:
+            ERR("not implemented for brush type %d\n", brush->bt);
+            return NotImplemented;
+    }
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipCreateLineBrush(GDIPCONST GpPointF* startpoint,
+    GDIPCONST GpPointF* endpoint, ARGB startcolor, ARGB endcolor,
+    GpWrapMode wrap, GpLineGradient **line)
+{
+    COLORREF col = ARGB2COLORREF(startcolor);
+
+    if(!line || !startpoint || !endpoint || wrap == WrapModeClamp)
+        return InvalidParameter;
+
+    *line = GdipAlloc(sizeof(GpLineGradient));
+    if(!*line)  return OutOfMemory;
+
+    (*line)->brush.lb.lbStyle = BS_SOLID;
+    (*line)->brush.lb.lbColor = col;
+    (*line)->brush.lb.lbHatch = 0;
+    (*line)->brush.gdibrush = CreateSolidBrush(col);
+    (*line)->brush.bt = BrushTypeLinearGradient;
+
+    (*line)->startpoint.X = startpoint->X;
+    (*line)->startpoint.Y = startpoint->Y;
+    (*line)->endpoint.X = endpoint->X;
+    (*line)->endpoint.Y = endpoint->Y;
+    (*line)->startcolor = startcolor;
+    (*line)->endcolor = endcolor;
+    (*line)->wrap = wrap;
+    (*line)->gamma = FALSE;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipCreateLineBrushFromRectI(GDIPCONST GpRect* rect,
+    ARGB startcolor, ARGB endcolor, LinearGradientMode mode, GpWrapMode wrap,
+    GpLineGradient **line)
+{
+    GpPointF start, end;
+
+    if(!line || !rect)
+        return InvalidParameter;
+
+    start.X = (REAL) rect->X;
+    start.Y = (REAL) rect->Y;
+    end.X = (REAL) (rect->X + rect->Width);
+    end.Y = (REAL) (rect->Y + rect->Height);
+
+    return GdipCreateLineBrush(&start, &end, startcolor, endcolor, wrap, line);
+}
+
+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;
+}
+
+/* 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;
+}
+
+GpStatus WINGDIPAPI GdipCreateSolidFill(ARGB color, GpSolidFill **sf)
+{
+    COLORREF col = ARGB2COLORREF(color);
+
+    if(!sf)  return InvalidParameter;
+
+    *sf = GdipAlloc(sizeof(GpSolidFill));
+    if (!*sf) return OutOfMemory;
+
+    (*sf)->brush.lb.lbStyle = BS_SOLID;
+    (*sf)->brush.lb.lbColor = col;
+    (*sf)->brush.lb.lbHatch = 0;
+
+    (*sf)->brush.gdibrush = CreateSolidBrush(col);
+    (*sf)->brush.bt = BrushTypeSolidColor;
+    (*sf)->color = color;
+
+    return Ok;
+}
+
+/* FIXME: imageattr ignored */
+GpStatus WINGDIPAPI GdipCreateTextureIA(GpImage *image,
+    GDIPCONST GpImageAttributes *imageattr, REAL x, REAL y, REAL width,
+    REAL height, GpTexture **texture)
+{
+    HDC hdc;
+    OLE_HANDLE hbm;
+    HBITMAP old = NULL;
+    BITMAPINFO bmi;
+    BITMAPINFOHEADER *bmih;
+    INT n_x, n_y, n_width, n_height, abs_height, stride, image_stride, i, bytespp;
+    BOOL bm_is_selected;
+    BYTE *dibits, *buff, *textbits;
+
+    if(!image || !texture || x < 0.0 || y < 0.0 || width < 0.0 || height < 0.0)
+        return InvalidParameter;
+
+    if(image->type != ImageTypeBitmap){
+        FIXME("not implemented for image type %d\n", image->type);
+        return NotImplemented;
+    }
+
+    n_x = roundr(x);
+    n_y = roundr(y);
+    n_width = roundr(width);
+    n_height = roundr(height);
+
+    if(n_x + n_width > ((GpBitmap*)image)->width ||
+       n_y + n_height > ((GpBitmap*)image)->height)
+        return InvalidParameter;
+
+    IPicture_get_Handle(image->picture, &hbm);
+    if(!hbm)   return GenericError;
+    IPicture_get_CurDC(image->picture, &hdc);
+    bm_is_selected = (hdc != 0);
+
+    bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+    bmi.bmiHeader.biBitCount = 0;
+
+    if(!bm_is_selected){
+        hdc = CreateCompatibleDC(0);
+        old = SelectObject(hdc, (HBITMAP)hbm);
+    }
+
+    /* fill out bmi */
+    GetDIBits(hdc, (HBITMAP)hbm, 0, 0, NULL, &bmi, DIB_RGB_COLORS);
+
+    bytespp = bmi.bmiHeader.biBitCount / 8;
+    abs_height = abs(bmi.bmiHeader.biHeight);
+
+    if(n_x > bmi.bmiHeader.biWidth || n_x + n_width > bmi.bmiHeader.biWidth ||
+       n_y > abs_height || n_y + n_height > abs_height)
+        return InvalidParameter;
+
+    dibits = GdipAlloc(bmi.bmiHeader.biSizeImage);
+
+    if(dibits)  /* this is not a good place to error out */
+        GetDIBits(hdc, (HBITMAP)hbm, 0, abs_height, dibits, &bmi, DIB_RGB_COLORS);
+
+    if(!bm_is_selected){
+        SelectObject(hdc, old);
+        DeleteDC(hdc);
+    }
+
+    if(!dibits)
+        return OutOfMemory;
+
+    image_stride = (bmi.bmiHeader.biWidth * bytespp + 3) & ~3;
+    stride = (n_width * bytespp + 3) & ~3;
+    buff = GdipAlloc(sizeof(BITMAPINFOHEADER) + stride * n_height);
+    if(!buff){
+        GdipFree(dibits);
+        return OutOfMemory;
+    }
+
+    bmih = (BITMAPINFOHEADER*)buff;
+    textbits = (BYTE*) (bmih + 1);
+    bmih->biSize = sizeof(BITMAPINFOHEADER);
+    bmih->biWidth = n_width;
+    bmih->biHeight = n_height;
+    bmih->biCompression = BI_RGB;
+    bmih->biSizeImage = stride * n_height;
+    bmih->biBitCount = bmi.bmiHeader.biBitCount;
+    bmih->biClrUsed = 0;
+    bmih->biPlanes = 1;
+
+    /* image is flipped */
+    if(bmi.bmiHeader.biHeight > 0){
+        dibits += bmi.bmiHeader.biSizeImage;
+        image_stride *= -1;
+        textbits += stride * (n_height - 1);
+        stride *= -1;
+    }
+
+    for(i = 0; i < n_height; i++)
+        memcpy(&textbits[i * stride],
+               &dibits[n_x * bytespp + (n_y + i) * image_stride],
+               abs(stride));
+
+    *texture = GdipAlloc(sizeof(GpTexture));
+    if (!*texture) return OutOfMemory;
+
+    (*texture)->brush.lb.lbStyle = BS_DIBPATTERNPT;
+    (*texture)->brush.lb.lbColor = DIB_RGB_COLORS;
+    (*texture)->brush.lb.lbHatch = (ULONG_PTR)buff;
+
+    (*texture)->brush.gdibrush = CreateBrushIndirect(&(*texture)->brush.lb);
+    (*texture)->brush.bt = BrushTypeTextureFill;
+
+    GdipFree(dibits);
+    GdipFree(buff);
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetBrushType(GpBrush *brush, GpBrushType *type)
+{
+    if(!brush || !type)  return InvalidParameter;
+
+    *type = brush->bt;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipDeleteBrush(GpBrush *brush)
+{
+    if(!brush)  return InvalidParameter;
+
+    switch(brush->bt)
+    {
+        case BrushTypePathGradient:
+            GdipFree(((GpPathGradient*) brush)->pathdata.Points);
+            GdipFree(((GpPathGradient*) brush)->pathdata.Types);
+            break;
+        case BrushTypeSolidColor:
+        case BrushTypeLinearGradient:
+        case BrushTypeTextureFill:
+        default:
+            break;
+    }
+
+    DeleteObject(brush->gdibrush);
+    GdipFree(brush);
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetLineGammaCorrection(GpLineGradient *line,
+    BOOL *usinggamma)
+{
+    if(!line)
+        return InvalidParameter;
+
+    *usinggamma = line->gamma;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetPathGradientCenterPoint(GpPathGradient *grad,
+    GpPointF *point)
+{
+    if(!grad || !point)
+        return InvalidParameter;
+
+    point->X = grad->center.X;
+    point->Y = grad->center.Y;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetPathGradientFocusScales(GpPathGradient *grad,
+    REAL *x, REAL *y)
+{
+    if(!grad || !x || !y)
+        return InvalidParameter;
+
+    *x = grad->focus.X;
+    *y = grad->focus.Y;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetPathGradientGammaCorrection(GpPathGradient *grad,
+    BOOL *gamma)
+{
+    if(!grad || !gamma)
+        return InvalidParameter;
+
+    *gamma = grad->gamma;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetPathGradientPointCount(GpPathGradient *grad,
+    INT *count)
+{
+    if(!grad || !count)
+        return InvalidParameter;
+
+    *count = grad->pathdata.Count;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetPathGradientSurroundColorsWithCount(GpPathGradient
+    *grad, ARGB *argb, INT *count)
+{
+    static int calls;
+
+    if(!grad || !argb || !count || (*count < grad->pathdata.Count))
+        return InvalidParameter;
+
+    if(!(calls++))
+        FIXME("not implemented\n");
+
+    return NotImplemented;
+}
+
+GpStatus WINGDIPAPI GdipGetSolidFillColor(GpSolidFill *sf, ARGB *argb)
+{
+    if(!sf || !argb)
+        return InvalidParameter;
+
+    *argb = sf->color;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipSetLineBlend(GpLineGradient *brush,
+    GDIPCONST REAL *blend, GDIPCONST REAL* positions, INT count)
+{
+    static int calls;
+
+    if(!brush || !blend || !positions || count <= 0)
+        return InvalidParameter;
+
+    if(!(calls++))
+        FIXME("not implemented\n");
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipSetLineGammaCorrection(GpLineGradient *line,
+    BOOL usegamma)
+{
+    if(!line)
+        return InvalidParameter;
+
+    line->gamma = usegamma;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipSetLineSigmaBlend(GpLineGradient *line, REAL focus,
+    REAL scale)
+{
+    static int calls;
+
+    if(!line || focus < 0.0 || focus > 1.0 || scale < 0.0 || scale > 1.0)
+        return InvalidParameter;
+
+    if(!(calls++))
+        FIXME("not implemented\n");
+
+    return NotImplemented;
+}
+
+GpStatus WINGDIPAPI GdipSetLineWrapMode(GpLineGradient *line,
+    GpWrapMode wrap)
+{
+    if(!line || wrap == WrapModeClamp)
+        return InvalidParameter;
+
+    line->wrap = wrap;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipSetPathGradientCenterColor(GpPathGradient *grad,
+    ARGB argb)
+{
+    if(!grad)
+        return InvalidParameter;
+
+    grad->centercolor = argb;
+    grad->brush.lb.lbColor = ARGB2COLORREF(argb);
+
+    DeleteObject(grad->brush.gdibrush);
+    grad->brush.gdibrush = CreateSolidBrush(grad->brush.lb.lbColor);
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipSetPathGradientCenterPoint(GpPathGradient *grad,
+    GpPointF *point)
+{
+    if(!grad || !point)
+        return InvalidParameter;
+
+    grad->center.X = point->X;
+    grad->center.Y = point->Y;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipSetPathGradientFocusScales(GpPathGradient *grad,
+    REAL x, REAL y)
+{
+    if(!grad)
+        return InvalidParameter;
+
+    grad->focus.X = x;
+    grad->focus.Y = y;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipSetPathGradientGammaCorrection(GpPathGradient *grad,
+    BOOL gamma)
+{
+    if(!grad)
+        return InvalidParameter;
+
+    grad->gamma = gamma;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipSetPathGradientSigmaBlend(GpPathGradient *grad,
+    REAL focus, REAL scale)
+{
+    static int calls;
+
+    if(!grad || focus < 0.0 || focus > 1.0 || scale < 0.0 || scale > 1.0)
+        return InvalidParameter;
+
+    if(!(calls++))
+        FIXME("not implemented\n");
+
+    return NotImplemented;
+}
+
+GpStatus WINGDIPAPI GdipSetPathGradientSurroundColorsWithCount(GpPathGradient
+    *grad, ARGB *argb, INT *count)
+{
+    static int calls;
+
+    if(!grad || !argb || !count || (*count <= 0) ||
+        (*count > grad->pathdata.Count))
+        return InvalidParameter;
+
+    if(!(calls++))
+        FIXME("not implemented\n");
+
+    return NotImplemented;
+}
+
+GpStatus WINGDIPAPI GdipSetPathGradientWrapMode(GpPathGradient *grad,
+    GpWrapMode wrap)
+{
+    if(!grad)
+        return InvalidParameter;
+
+    grad->wrap = wrap;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipSetSolidFillColor(GpSolidFill *sf, ARGB argb)
+{
+    if(!sf)
+        return InvalidParameter;
+
+    sf->color = argb;
+    sf->brush.lb.lbColor = ARGB2COLORREF(argb);
+
+    DeleteObject(sf->brush.gdibrush);
+    sf->brush.gdibrush = CreateSolidBrush(sf->brush.lb.lbColor);
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipSetTextureTransform(GpTexture *texture,
+    GDIPCONST GpMatrix *matrix)
+{
+    static int calls;
+
+    if(!texture || !matrix)
+        return InvalidParameter;
+
+    if(!(calls++))
+        FIXME("not implemented\n");
+
+    return Ok;
+}
diff --git a/reactos/dll/win32/gdiplus/customlinecap.c b/reactos/dll/win32/gdiplus/customlinecap.c
new file mode 100644 (file)
index 0000000..e161e1b
--- /dev/null
@@ -0,0 +1,131 @@
+/*
+ * Copyright (C) 2007 Google (Evan Stade)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <stdarg.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "wingdi.h"
+
+#include "objbase.h"
+
+#include "gdiplus.h"
+#include "gdiplus_private.h"
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
+
+GpStatus WINGDIPAPI GdipCloneCustomLineCap(GpCustomLineCap* from,
+    GpCustomLineCap** to)
+{
+    if(!from || !to)
+        return InvalidParameter;
+
+    *to = GdipAlloc(sizeof(GpCustomLineCap));
+    if(!*to)   return OutOfMemory;
+
+    memcpy(*to, from, sizeof(GpCustomLineCap));
+
+    (*to)->pathdata.Points = GdipAlloc(from->pathdata.Count * sizeof(PointF));
+    (*to)->pathdata.Types = GdipAlloc(from->pathdata.Count);
+
+    if((!(*to)->pathdata.Types  || !(*to)->pathdata.Points) && (*to)->pathdata.Count){
+        GdipFree((*to)->pathdata.Points);
+        GdipFree((*to)->pathdata.Types);
+        GdipFree(*to);
+        return OutOfMemory;
+    }
+
+    memcpy((*to)->pathdata.Points, from->pathdata.Points, from->pathdata.Count
+           * sizeof(PointF));
+    memcpy((*to)->pathdata.Types, from->pathdata.Types, from->pathdata.Count);
+
+    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;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipDeleteCustomLineCap(GpCustomLineCap *customCap)
+{
+    if(!customCap)
+        return InvalidParameter;
+
+    GdipFree(customCap->pathdata.Points);
+    GdipFree(customCap->pathdata.Types);
+    GdipFree(customCap);
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipSetCustomLineCapStrokeCaps(GpCustomLineCap* custom,
+    GpLineCap start, GpLineCap end)
+{
+    static int calls;
+
+    if(!custom)
+        return InvalidParameter;
+
+    if(!(calls++))
+        FIXME("not implemented\n");
+
+    return NotImplemented;
+}
diff --git a/reactos/dll/win32/gdiplus/font.c b/reactos/dll/win32/gdiplus/font.c
new file mode 100644 (file)
index 0000000..be60843
--- /dev/null
@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2007 Google (Evan Stade)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <stdarg.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "wingdi.h"
+#include "winnls.h"
+
+#include "objbase.h"
+
+#include "gdiplus.h"
+#include "gdiplus_private.h"
+
+GpStatus WINGDIPAPI GdipCreateFontFromLogfontW(HDC hdc,
+    GDIPCONST LOGFONTW *logfont, GpFont **font)
+{
+    HFONT hfont, oldfont;
+    TEXTMETRICW textmet;
+
+    if(!logfont || !font)
+        return InvalidParameter;
+
+    *font = GdipAlloc(sizeof(GpFont));
+    if(!*font)  return OutOfMemory;
+
+    memcpy(&(*font)->lfw.lfFaceName, logfont->lfFaceName, LF_FACESIZE *
+           sizeof(WCHAR));
+    (*font)->lfw.lfHeight = logfont->lfHeight;
+    (*font)->lfw.lfItalic = logfont->lfItalic;
+    (*font)->lfw.lfUnderline = logfont->lfUnderline;
+    (*font)->lfw.lfStrikeOut = logfont->lfStrikeOut;
+
+    hfont = CreateFontIndirectW(&(*font)->lfw);
+    oldfont = SelectObject(hdc, hfont);
+    GetTextMetricsW(hdc, &textmet);
+
+    (*font)->lfw.lfHeight = -textmet.tmHeight;
+    (*font)->lfw.lfWeight = textmet.tmWeight;
+
+    SelectObject(hdc, oldfont);
+    DeleteObject(hfont);
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipCreateFontFromLogfontA(HDC hdc,
+    GDIPCONST LOGFONTA *lfa, GpFont **font)
+{
+    LOGFONTW lfw;
+
+    if(!lfa || !font)
+        return InvalidParameter;
+
+    memcpy(&lfw, lfa, sizeof(LOGFONTA));
+
+    if(!MultiByteToWideChar(CP_ACP, 0, lfa->lfFaceName, -1, lfw.lfFaceName, LF_FACESIZE))
+        return GenericError;
+
+    GdipCreateFontFromLogfontW(hdc, &lfw, font);
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipDeleteFont(GpFont* font)
+{
+    if(!font)
+        return InvalidParameter;
+
+    GdipFree(font);
+
+    return Ok;
+}
+
+/* FIXME: use graphics */
+GpStatus WINGDIPAPI GdipGetLogFontW(GpFont *font, GpGraphics *graphics,
+    LOGFONTW *lfw)
+{
+    if(!font || !graphics || !lfw)
+        return InvalidParameter;
+
+    *lfw = font->lfw;
+
+    return Ok;
+}
diff --git a/reactos/dll/win32/gdiplus/gdiplus.c b/reactos/dll/win32/gdiplus/gdiplus.c
new file mode 100644 (file)
index 0000000..f897eb5
--- /dev/null
@@ -0,0 +1,287 @@
+/*
+ * Copyright (C) 2007 Google (Evan Stade)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <stdarg.h>
+#include <math.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "winerror.h"
+#include "wine/debug.h"
+#include "wingdi.h"
+
+#include "objbase.h"
+
+#include "winreg.h"
+#include "shlwapi.h"
+
+#include "gdiplus.h"
+#include "gdiplus_private.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
+
+static Status WINAPI NotificationHook(ULONG_PTR *token)
+{
+    TRACE("%p\n", token);
+    if(!token)
+        return InvalidParameter;
+
+    return Ok;
+}
+
+static void WINAPI NotificationUnhook(ULONG_PTR token)
+{
+    TRACE("%ld\n", token);
+}
+
+/*****************************************************
+ *      DllMain
+ */
+BOOL WINAPI DllMain(HINSTANCE hinst, DWORD reason, LPVOID reserved)
+{
+    TRACE("(%p, %d, %p)\n", hinst, reason, reserved);
+
+    switch(reason)
+    {
+    case DLL_WINE_PREATTACH:
+        return FALSE;  /* prefer native version */
+
+    case DLL_PROCESS_ATTACH:
+        DisableThreadLibraryCalls( hinst );
+        break;
+    }
+    return TRUE;
+}
+
+/*****************************************************
+ *      GdiplusStartup [GDIPLUS.@]
+ */
+Status WINAPI GdiplusStartup(ULONG_PTR *token, const struct GdiplusStartupInput *input,
+                             struct GdiplusStartupOutput *output)
+{
+    if(!token || !input)
+        return InvalidParameter;
+
+    TRACE("%p %p %p\n", token, input, output);
+    TRACE("GdiplusStartupInput %d %p %d %d\n", input->GdiplusVersion,
+          input->DebugEventCallback, input->SuppressBackgroundThread,
+          input->SuppressExternalCodecs);
+
+    if(input->GdiplusVersion != 1)
+        return UnsupportedGdiplusVersion;
+
+    if(input->SuppressBackgroundThread){
+        if(!output)
+            return InvalidParameter;
+
+        output->NotificationHook = NotificationHook;
+        output->NotificationUnhook = NotificationUnhook;
+    }
+
+    /* FIXME: DebugEventCallback ignored */
+
+    return Ok;
+}
+
+/*****************************************************
+ *      GdiplusShutdown [GDIPLUS.@]
+ */
+void WINAPI GdiplusShutdown(ULONG_PTR token)
+{
+    /* FIXME: no object tracking */
+}
+
+/*****************************************************
+ *      GdipAlloc [GDIPLUS.@]
+ */
+void* WINGDIPAPI GdipAlloc(SIZE_T size)
+{
+    return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
+}
+
+/*****************************************************
+ *      GdipFree [GDIPLUS.@]
+ */
+void WINGDIPAPI GdipFree(void* ptr)
+{
+    HeapFree(GetProcessHeap(), 0, ptr);
+}
+
+/* Calculates the bezier points needed to fill in the arc portion starting at
+ * angle start and ending at end.  These two angles should be no more than 90
+ * degrees from each other.  x1, y1, x2, y2 describes the bounding box (upper
+ * left and width and height).  Angles must be in radians. write_first indicates
+ * that the first bezier point should be written out (usually this is false).
+ * pt is the array of GpPointFs that gets written to.
+ **/
+static void add_arc_part(GpPointF * pt, REAL x1, REAL y1, REAL x2, REAL y2,
+    REAL start, REAL end, BOOL write_first)
+{
+    REAL center_x, center_y, rad_x, rad_y, cos_start, cos_end,
+        sin_start, sin_end, a, half;
+    INT i;
+
+    rad_x = x2 / 2.0;
+    rad_y = y2 / 2.0;
+    center_x = x1 + rad_x;
+    center_y = y1 + rad_y;
+
+    cos_start = cos(start);
+    cos_end = cos(end);
+    sin_start = sin(start);
+    sin_end = sin(end);
+
+    half = (end - start) / 2.0;
+    a = 4.0 / 3.0 * (1 - cos(half)) / sin(half);
+
+    if(write_first){
+        pt[0].X = cos_start;
+        pt[0].Y = sin_start;
+    }
+    pt[1].X = cos_start - a * sin_start;
+    pt[1].Y = sin_start + a * cos_start;
+
+    pt[3].X = cos_end;
+    pt[3].Y = sin_end;
+    pt[2].X = cos_end + a * sin_end;
+    pt[2].Y = sin_end - a * cos_end;
+
+    /* expand the points back from the unit circle to the ellipse */
+    for(i = (write_first ? 0 : 1); i < 4; i ++){
+        pt[i].X = pt[i].X * rad_x + center_x;
+        pt[i].Y = pt[i].Y * rad_y + center_y;
+    }
+}
+
+/* We plot the curve as if it is on a circle then stretch the points.  This
+ * adjusts the angles so that when we stretch the points they will end in the
+ * right place. This is only complicated because atan and atan2 do not behave
+ * conveniently. */
+static void unstretch_angle(REAL * angle, REAL rad_x, REAL rad_y)
+{
+    REAL stretched;
+    INT revs_off;
+
+    *angle = deg2rad(*angle);
+
+    if(fabs(cos(*angle)) < 0.00001 || fabs(sin(*angle)) < 0.00001)
+        return;
+
+    stretched = gdiplus_atan2(sin(*angle) / fabs(rad_y), cos(*angle) / fabs(rad_x));
+    revs_off = roundr(*angle / (2.0 * M_PI)) - roundr(stretched / (2.0 * M_PI));
+    stretched += ((REAL)revs_off) * M_PI * 2.0;
+    *angle = stretched;
+}
+
+/* Stores the bezier points that correspond to the arc in points.  If points is
+ * null, just return the number of points needed to represent the arc. */
+INT arc2polybezier(GpPointF * points, REAL x1, REAL y1, REAL x2, REAL y2,
+    REAL startAngle, REAL sweepAngle)
+{
+    INT i, count;
+    REAL end_angle, start_angle, endAngle;
+
+    endAngle = startAngle + sweepAngle;
+    unstretch_angle(&startAngle, x2 / 2.0, y2 / 2.0);
+    unstretch_angle(&endAngle, x2 / 2.0, y2 / 2.0);
+
+    count = ceil(fabs(endAngle - startAngle) / M_PI_2) * 3 + 1;
+    /* don't make more than a full circle */
+    count = min(MAX_ARC_PTS, count);
+
+    if(count == 1)
+        return 0;
+    if(!points)
+        return count;
+
+    /* start_angle and end_angle are the iterative variables */
+    start_angle = startAngle;
+
+    for(i = 0; i < count - 1; i += 3){
+        /* check if we've overshot the end angle */
+        if( sweepAngle > 0.0 )
+            end_angle = min(start_angle + M_PI_2, endAngle);
+        else
+            end_angle = max(start_angle - M_PI_2, endAngle);
+
+        add_arc_part(&points[i], x1, y1, x2, y2, start_angle, end_angle, i == 0);
+
+        start_angle += M_PI_2 * (sweepAngle < 0.0 ? -1.0 : 1.0);
+    }
+
+    return count;
+}
+
+COLORREF ARGB2COLORREF(ARGB color)
+{
+    /*
+    Packing of these color structures:
+    COLORREF:   00bbggrr
+    ARGB:       aarrggbb
+    FIXME:doesn't handle alpha channel
+    */
+    return ((color & 0x0000ff) << 16) +
+           (color & 0x00ff00) +
+           ((color & 0xff0000) >> 16);
+}
+
+/* Like atan2, but puts angle in correct quadrant if dx is 0. */
+REAL gdiplus_atan2(REAL dy, REAL dx)
+{
+    if((dx == 0.0) && (dy != 0.0))
+        return dy > 0.0 ? M_PI_2 : -M_PI_2;
+
+    return atan2(dy, dx);
+}
+
+GpStatus hresult_to_status(HRESULT res)
+{
+    switch(res){
+        case S_OK:
+            return Ok;
+        case E_OUTOFMEMORY:
+            return OutOfMemory;
+        case E_INVALIDARG:
+            return InvalidParameter;
+        default:
+            return GenericError;
+    }
+}
+
+/* converts a given unit to its value in pixels */
+REAL convert_unit(HDC hdc, GpUnit unit)
+{
+    switch(unit)
+    {
+        case UnitInch:
+            return (REAL) GetDeviceCaps(hdc, LOGPIXELSX);
+        case UnitPoint:
+            return ((REAL)GetDeviceCaps(hdc, LOGPIXELSX)) / 72.0;
+        case UnitDocument:
+            return ((REAL)GetDeviceCaps(hdc, LOGPIXELSX)) / 300.0;
+        case UnitMillimeter:
+            return ((REAL)GetDeviceCaps(hdc, LOGPIXELSX)) / 25.4;
+        case UnitWorld:
+            ERR("cannot convert UnitWorld\n");
+            return 0.0;
+        case UnitPixel:
+        case UnitDisplay:
+        default:
+            return 1.0;
+    }
+}
diff --git a/reactos/dll/win32/gdiplus/gdiplus.def b/reactos/dll/win32/gdiplus/gdiplus.def
deleted file mode 100644 (file)
index ff4cd59..0000000
+++ /dev/null
@@ -1,632 +0,0 @@
-LIBRARY gdiplus.dll
-EXPORTS
-GdiplusStartup@12
-GdiplusShutdown@4
-GdipCreateAdjustableArrowCap@16
-GdipSetAdjustableArrowCapHeight@8
-GdipGetAdjustableArrowCapHeight@8
-GdipSetAdjustableArrowCapWidth@8
-GdipGetAdjustableArrowCapWidth@8
-GdipSetAdjustableArrowCapMiddleInset@8
-GdipGetAdjustableArrowCapMiddleInset@8
-GdipSetAdjustableArrowCapFillState@8
-GdipGetAdjustableArrowCapFillState@8
-GdipCreateBitmapFromStream@8
-GdipCreateBitmapFromFile@8
-GdipCreateBitmapFromStreamICM@8
-GdipCreateBitmapFromFileICM@8
-GdipCreateBitmapFromScan0@24
-GdipCreateBitmapFromGraphics@16
-GdipCreateBitmapFromDirectDrawSurface@8
-GdipCreateBitmapFromGdiDib@12
-GdipCreateBitmapFromHBITMAP@12
-GdipCreateHBITMAPFromBitmap@12
-GdipCreateBitmapFromHICON@8
-GdipCreateHICONFromBitmap@8
-GdipCreateBitmapFromResource@12
-GdipCloneBitmapArea@28
-GdipCloneBitmapAreaI@28
-GdipBitmapLockBits@20
-GdipBitmapUnlockBits@8
-GdipBitmapGetPixel@16
-GdipBitmapSetPixel@16
-GdipBitmapSetResolution@12
-GdipBitmapConvertFormat@24
-GdipInitializePalette@20
-GdipBitmapApplyEffect@24
-GdipBitmapCreateApplyEffect@36
-GdipBitmapGetHistogram@28
-GdipBitmapGetHistogramSize@8
-GdipCreateEffect@20
-GdipDeleteEffect@4
-GdipGetEffectParameterSize@8
-GdipSetEffectParameters@12
-GdipGetEffectParameters@12
-GdipTestControl@8
-GdipCloneBrush@8
-GdipDeleteBrush@4
-GdipGetBrushType@8
-GdipCreateCachedBitmap@12
-GdipDeleteCachedBitmap@4
-GdipDrawCachedBitmap@16
-GdipEmfToWmfBits@20
-GdipCreateCustomLineCap@20
-GdipDeleteCustomLineCap@4
-GdipCloneCustomLineCap@8
-GdipGetCustomLineCapType@8
-GdipSetCustomLineCapStrokeCaps@12
-GdipGetCustomLineCapStrokeCaps@12
-GdipSetCustomLineCapStrokeJoin@8
-GdipGetCustomLineCapStrokeJoin@8
-GdipSetCustomLineCapBaseCap@8
-GdipGetCustomLineCapBaseCap@8
-GdipSetCustomLineCapBaseInset@8
-GdipGetCustomLineCapBaseInset@8
-GdipSetCustomLineCapWidthScale@8
-GdipGetCustomLineCapWidthScale@8
-GdipCreateFontFromDC@8
-GdipCreateFontFromLogfontA@12
-GdipCreateFontFromLogfontW@12
-GdipCreateFont@20
-GdipCloneFont@8
-GdipDeleteFont@4
-GdipGetFamily@8
-GdipGetFontStyle@8
-GdipGetFontSize@8
-GdipGetFontUnit@8
-GdipGetFontHeight@12
-GdipGetFontHeightGivenDPI@12
-GdipGetLogFontA@12
-GdipGetLogFontW@12
-GdipNewInstalledFontCollection@4
-GdipNewPrivateFontCollection@4
-GdipDeletePrivateFontCollection@4
-GdipGetFontCollectionFamilyCount@8
-GdipGetFontCollectionFamilyList@16
-GdipPrivateAddFontFile@8
-GdipPrivateAddMemoryFont@12
-GdipCreateFontFamilyFromName@12
-GdipDeleteFontFamily@4
-GdipCloneFontFamily@8
-GdipGetGenericFontFamilySansSerif@4
-GdipGetGenericFontFamilySerif@4
-GdipGetGenericFontFamilyMonospace@4
-GdipGetFamilyName@12
-GdipIsStyleAvailable@12
-GdipFontCollectionEnumerable@12
-GdipFontCollectionEnumerate@20
-GdipGetEmHeight@12
-GdipGetCellAscent@12
-GdipGetCellDescent@12
-GdipGetLineSpacing@12
-GdipFlush@8
-GdipCreateFromHDC@8
-GdipCreateFromHDC2@12
-GdipCreateFromHWND@8
-GdipCreateFromHWNDICM@8
-GdipDeleteGraphics@4
-GdipGetDC@8
-GdipReleaseDC@8
-GdipSetCompositingMode@8
-GdipGetCompositingMode@8
-GdipSetRenderingOrigin@12
-GdipGetRenderingOrigin@12
-GdipSetCompositingQuality@8
-GdipGetCompositingQuality@8
-GdipSetSmoothingMode@8
-GdipGetSmoothingMode@8
-GdipSetPixelOffsetMode@8
-GdipGetPixelOffsetMode@8
-GdipSetTextRenderingHint@8
-GdipGetTextRenderingHint@8
-GdipSetTextContrast@8
-GdipGetTextContrast@8
-GdipSetInterpolationMode@8
-GdipGetInterpolationMode@8
-GdipSetWorldTransform@8
-GdipResetWorldTransform@4
-GdipMultiplyWorldTransform@12
-GdipTranslateWorldTransform@16
-GdipScaleWorldTransform@16
-GdipRotateWorldTransform@12
-GdipGetWorldTransform@8
-GdipResetPageTransform@4
-GdipGetPageUnit@8
-GdipGetPageScale@8
-GdipSetPageUnit@8
-GdipSetPageScale@8
-GdipGetDpiX@8
-GdipGetDpiY@8
-GdipTransformPoints@20
-GdipTransformPointsI@20
-GdipGetNearestColor@8
-GdipCreateHalftonePalette@0
-GdipDrawLine@24
-GdipDrawLineI@24
-GdipDrawLines@16
-GdipDrawLinesI@16
-GdipDrawArc@32
-GdipDrawArcI@32
-GdipDrawBezier@40
-GdipDrawBezierI@40
-GdipDrawBeziers@16
-GdipDrawBeziersI@16
-GdipDrawRectangle@24
-GdipDrawRectangleI@24
-GdipDrawRectangles@16
-GdipDrawRectanglesI@16
-GdipDrawEllipse@24
-GdipDrawEllipseI@24
-GdipDrawPie@32
-GdipDrawPieI@32
-GdipDrawPolygon@16
-GdipDrawPolygonI@16
-GdipDrawPath@12
-GdipDrawCurve@16
-GdipDrawCurveI@16
-GdipDrawCurve2@20
-GdipDrawCurve2I@20
-GdipDrawCurve3@28
-GdipDrawCurve3I@28
-GdipDrawClosedCurve@16
-GdipDrawClosedCurveI@16
-GdipDrawClosedCurve2@20
-GdipDrawClosedCurve2I@20
-GdipGraphicsClear@8
-GdipFillRectangle@24
-GdipFillRectangleI@24
-GdipFillRectangles@16
-GdipFillRectanglesI@16
-GdipFillPolygon@20
-GdipFillPolygonI@20
-GdipFillPolygon2@16
-GdipFillPolygon2I@16
-GdipFillEllipse@24
-GdipFillEllipseI@24
-GdipFillPie@32
-GdipFillPieI@32
-GdipFillPath@12
-GdipFillClosedCurve@16
-GdipFillClosedCurveI@16
-GdipFillClosedCurveI@16
-GdipFillClosedCurve2I@24
-GdipFillRegion@12
-GdipDrawImage@16
-GdipDrawImageI@16
-GdipDrawImageRect@24
-GdipDrawImageRectI@24
-GdipDrawImagePoints@16
-GdipDrawImagePointsI@16
-GdipDrawImagePointRect@36
-GdipDrawImagePointRectI@36
-GdipDrawImageRectRect@56
-GdipDrawImageRectRectI@56
-GdipDrawImagePointsRect@48
-GdipDrawImagePointsRectI@48
-GdipDrawImageFX@28
-GdipEnumerateMetafileDestPoint@24
-GdipEnumerateMetafileDestPointI@24
-GdipEnumerateMetafileDestRect@24
-GdipEnumerateMetafileDestRectI@24
-GdipEnumerateMetafileDestPoints@28
-GdipEnumerateMetafileDestPointsI@28
-GdipEnumerateMetafileSrcRectDestPoint@32
-GdipEnumerateMetafileSrcRectDestPointI@32
-GdipEnumerateMetafileSrcRectDestRect@32
-GdipEnumerateMetafileSrcRectDestRectI@32
-GdipEnumerateMetafileSrcRectDestPoints@36
-GdipEnumerateMetafileSrcRectDestPointsI@36
-GdipPlayMetafileRecord@20
-GdipSetClipGraphics@12
-GdipSetClipRect@24
-GdipSetClipRectI@24
-GdipSetClipPath@12
-GdipSetClipRegion@12
-GdipSetClipHrgn@12
-GdipResetClip@4
-GdipTranslateClip@12
-GdipTranslateClipI@12
-GdipGetClip@8
-GdipGetClipBounds@8
-GdipGetClipBoundsI@8
-GdipIsClipEmpty@8
-GdipGetVisibleClipBounds@8
-GdipGetVisibleClipBoundsI@8
-GdipIsVisibleClipEmpty@8
-GdipIsVisiblePoint@16
-GdipIsVisiblePointI@16
-GdipIsVisibleRect@24
-GdipIsVisibleRectI@24
-GdipSaveGraphics@8
-GdipRestoreGraphics@8
-GdipBeginContainer@20
-GdipBeginContainerI@20
-GdipBeginContainer2@8
-GdipEndContainer@8
-GdipGetMetafileHeaderFromEmf@8
-GdipGetMetafileHeaderFromFile@8
-GdipGetMetafileHeaderFromStream@8
-GdipGetMetafileHeaderFromMetafile@8
-GdipGetHemfFromMetafile@8
-GdipCreateStreamOnFile@12
-GdipCreateMetafileFromWmf@16
-GdipCreateMetafileFromEmf@12
-GdipCreateMetafileFromFile@8
-GdipCreateMetafileFromWmfFile@12
-GdipCreateMetafileFromStream@8
-GdipRecordMetafile@24
-GdipRecordMetafileI@24
-GdipRecordMetafileFileName@28
-GdipRecordMetafileFileNameI@28
-GdipRecordMetafileStream@28
-GdipRecordMetafileStreamI@28
-GdipSetMetafileDownLevelRasterizationLimit@8
-GdipGetMetafileDownLevelRasterizationLimit@8
-GdipGetImageDecodersSize@8
-GdipGetImageDecoders@12
-GdipGetImageEncodersSize@8
-GdipGetImageEncoders@12
-GdipComment@12
-GdipComment@12
-GdipCreatePath@8
-GdipCreatePath2@20
-GdipCreatePath2I@20
-GdipClonePath@8
-GdipDeletePath@4
-GdipResetPath@4
-GdipGetPointCount@8
-GdipGetPathTypes@12
-GdipGetPathPoints@12
-GdipGetPathPointsI@12
-GdipGetPathFillMode@8
-GdipSetPathFillMode@8
-GdipGetPathData@8
-GdipStartPathFigure@4
-GdipClosePathFigure@4
-GdipClosePathFigures@4
-GdipSetPathMarker@4
-GdipClearPathMarkers@4
-GdipReversePath@4
-GdipGetPathLastPoint@8
-GdipAddPathLine@20
-GdipAddPathLine2@12
-GdipAddPathArc@28
-GdipAddPathBezier@36
-GdipAddPathBeziers@12
-GdipAddPathCurve@12
-GdipAddPathCurve2@16
-GdipAddPathCurve3@24
-GdipAddPathClosedCurve@12
-GdipAddPathClosedCurve2@16
-GdipAddPathRectangle@20
-GdipAddPathRectangles@12
-GdipAddPathEllipse@20
-GdipAddPathPie@28
-GdipAddPathPolygon@12
-GdipAddPathPath@12
-GdipAddPathString@32
-GdipAddPathStringI@32
-GdipAddPathLineI@20
-GdipAddPathLine2I@12
-GdipAddPathArcI@28
-GdipAddPathBezierI@36
-GdipAddPathBeziersI@12
-GdipAddPathCurveI@12
-GdipAddPathCurve2I@16
-GdipAddPathCurve3I@24
-GdipAddPathClosedCurveI@12
-GdipAddPathClosedCurve2I@16
-GdipAddPathRectangleI@20
-GdipAddPathRectanglesI@12
-GdipAddPathEllipseI@20
-GdipAddPathPieI@28
-GdipAddPathPolygonI@12
-GdipFlattenPath@12
-GdipWindingModeOutline@12
-GdipWidenPath@16
-GdipWarpPath@40
-GdipTransformPath@8
-GdipGetPathWorldBounds@16
-GdipGetPathWorldBoundsI@16
-GdipIsVisiblePathPoint@20
-GdipIsVisiblePathPointI@20
-GdipIsOutlineVisiblePathPoint@24
-GdipIsOutlineVisiblePathPointI@24
-GdipCreateHatchBrush@16
-GdipGetHatchStyle@8
-GdipGetHatchForegroundColor@8
-GdipGetHatchBackgroundColor@8
-GdipLoadImageFromStream@8
-GdipLoadImageFromFile@8
-GdipLoadImageFromStreamICM@8
-GdipLoadImageFromFileICM@8
-GdipCloneImage@8
-GdipDisposeImage@4
-GdipSaveImageToFile@16
-GdipSaveImageToStream@16
-GdipSaveAdd@8
-GdipSaveAddImage@12
-GdipGetImageGraphicsContext@8
-GdipGetImageBounds@12
-GdipGetImageDimension@12
-GdipGetImageType@8
-GdipGetImageWidth@8
-GdipGetImageHeight@8
-GdipGetImageHorizontalResolution@8
-GdipGetImageVerticalResolution@8
-GdipGetImageFlags@8
-GdipGetImageRawFormat@8
-GdipGetImagePixelFormat@8
-GdipGetImageThumbnail@24
-GdipGetEncoderParameterListSize@12
-GdipGetEncoderParameterList@16
-GdipImageGetFrameDimensionsCount@8
-GdipImageGetFrameDimensionsList@12
-GdipImageGetFrameCount@12
-GdipImageSelectActiveFrame@12
-GdipImageRotateFlip@8
-GdipGetImagePalette@12
-GdipSetImagePalette@8
-GdipGetImagePaletteSize@8
-GdipGetPropertyCount@8
-GdipGetPropertyIdList@12
-GdipGetPropertyItemSize@12
-GdipGetPropertyItem@16
-GdipGetPropertySize@12
-GdipGetAllPropertyItems@16
-GdipRemovePropertyItem@8
-GdipSetPropertyItem@8
-GdipFindFirstImageItem@8
-GdipFindNextImageItem@8
-GdipGetImageItemData@8
-GdipConvertToEmfPlus@24
-GdipConvertToEmfPlusToFile@28
-GdipConvertToEmfPlusToStream@28
-GdipImageForceValidation@4
-GdipCreateImageAttributes@4
-GdipCloneImageAttributes@8
-GdipDisposeImageAttributes@4
-GdipSetImageAttributesToIdentity@8
-GdipResetImageAttributes@8
-GdipSetImageAttributesColorMatrix@24
-GdipSetImageAttributesThreshold@16
-GdipSetImageAttributesGamma@16
-GdipSetImageAttributesNoOp@12
-GdipSetImageAttributesColorKeys@20
-GdipSetImageAttributesOutputChannel@16
-GdipSetImageAttributesOutputChannelColorProfile@16
-GdipSetImageAttributesRemapTable@20
-GdipSetImageAttributesWrapMode@16
-GdipSetImageAttributesICMMode@8
-GdipGetImageAttributesAdjustedPalette@12
-GdipSetImageAttributesCachedBackground@8
-GdipCreateLineBrush@24
-GdipCreateLineBrushI@24
-GdipCreateLineBrushFromRect@24
-GdipCreateLineBrushFromRectI@24
-GdipCreateLineBrushFromRectWithAngle@28
-GdipCreateLineBrushFromRectWithAngleI@28
-GdipSetLineColors@12
-GdipGetLineColors@8
-GdipGetLineRect@8
-GdipGetLineRectI@8
-GdipSetLineGammaCorrection@8
-GdipGetLineGammaCorrection@8
-GdipGetLineBlendCount@8
-GdipGetLineBlend@16
-GdipSetLineBlend@16
-GdipGetLinePresetBlendCount@8
-GdipGetLinePresetBlend@16
-GdipSetLinePresetBlend@16
-GdipSetLineSigmaBlend@12
-GdipSetLineLinearBlend@12
-GdipSetLineWrapMode@8
-GdipGetLineWrapMode@8
-GdipGetLineTransform@8
-GdipSetLineTransform@8
-GdipResetLineTransform@4
-GdipMultiplyLineTransform@12
-GdipTranslateLineTransform@16
-GdipScaleLineTransform@16
-GdipRotateLineTransform@12
-GdipCreateMatrix@4
-GdipCreateMatrix2@28
-GdipCreateMatrix3@12
-GdipCreateMatrix3I@12
-GdipCloneMatrix@8
-GdipDeleteMatrix@4
-GdipSetMatrixElements@28
-GdipMultiplyMatrix@12
-GdipTranslateMatrix@16
-GdipScaleMatrix@16
-GdipRotateMatrix@12
-GdipShearMatrix@16
-GdipInvertMatrix@4
-GdipTransformMatrixPoints@12
-GdipTransformMatrixPointsI@12
-GdipVectorTransformMatrixPoints@12
-GdipVectorTransformMatrixPointsI@12
-GdipGetMatrixElements@8
-GdipIsMatrixInvertible@8
-GdipIsMatrixIdentity@8
-GdipIsMatrixEqual@12
-GdipAlloc@4
-GdipFree@4
-GdiplusNotificationHook@4
-GdiplusNotificationUnhook@4
-GdipCreatePathGradient@16
-GdipCreatePathGradientI@16
-GdipCreatePathGradientFromPath@8
-GdipGetPathGradientCenterColor@8
-GdipSetPathGradientCenterColor@8
-GdipGetPathGradientSurroundColorsWithCount@12
-GdipSetPathGradientSurroundColorsWithCount@12
-GdipGetPathGradientPath@8
-GdipSetPathGradientPath@8
-GdipGetPathGradientCenterPoint@8
-GdipGetPathGradientCenterPointI@8
-GdipSetPathGradientCenterPoint@8
-GdipSetPathGradientCenterPointI@8
-GdipGetPathGradientRect@8
-GdipGetPathGradientRectI@8
-GdipGetPathGradientPointCount@8
-GdipGetPathGradientSurroundColorCount@8
-GdipSetPathGradientGammaCorrection@8
-GdipGetPathGradientGammaCorrection@8
-GdipGetPathGradientBlendCount@8
-GdipGetPathGradientBlend@16
-GdipSetPathGradientBlend@16
-GdipGetPathGradientPresetBlendCount@8
-GdipGetPathGradientPresetBlend@16
-GdipSetPathGradientPresetBlend@16
-GdipSetPathGradientSigmaBlend@12
-GdipSetPathGradientSigmaBlend@12
-GdipGetPathGradientWrapMode@8
-GdipSetPathGradientWrapMode@8
-GdipGetPathGradientTransform@8
-GdipSetPathGradientTransform@8
-GdipResetPathGradientTransform@4
-GdipMultiplyPathGradientTransform@12
-GdipTranslatePathGradientTransform@16
-GdipScalePathGradientTransform@16
-GdipRotatePathGradientTransform@12
-GdipGetPathGradientFocusScales@12
-GdipSetPathGradientFocusScales@12
-GdipCreatePathIter@8
-GdipDeletePathIter@4
-GdipPathIterNextSubpath@20
-GdipPathIterNextSubpathPath@16
-GdipPathIterNextPathType@20
-GdipPathIterNextMarker@16
-GdipPathIterNextMarkerPath@12
-GdipPathIterGetCount@8
-GdipPathIterGetSubpathCount@8
-GdipPathIterIsValid@8
-GdipPathIterHasCurve@8
-GdipPathIterRewind@4
-GdipPathIterEnumerate@20
-GdipPathIterCopyData@24
-GdipCreatePen1@16
-GdipCreatePen2@16
-GdipClonePen@8
-GdipDeletePen@4
-GdipSetPenWidth@8
-GdipGetPenWidth@8
-GdipSetPenUnit@8
-GdipGetPenUnit@8
-GdipSetPenLineCap197819@16
-GdipSetPenStartCap@8
-GdipSetPenEndCap@8
-GdipSetPenDashCap197819@8
-GdipGetPenStartCap@8
-GdipGetPenEndCap@8
-GdipGetPenDashCap197819@8
-GdipSetPenLineJoin@8
-GdipGetPenLineJoin@8
-GdipSetPenCustomStartCap@8
-GdipGetPenCustomStartCap@8
-GdipSetPenCustomEndCap@8
-GdipGetPenCustomEndCap@8
-GdipSetPenMiterLimit@8
-GdipGetPenMiterLimit@8
-GdipSetPenMode@8
-GdipGetPenMode@8
-GdipSetPenTransform@8
-GdipGetPenTransform@8
-GdipResetPenTransform@4
-GdipMultiplyPenTransform@12
-GdipTranslatePenTransform@16
-GdipScalePenTransform@16
-GdipRotatePenTransform@12
-GdipSetPenColor@8
-GdipGetPenColor@8
-GdipSetPenBrushFill@8
-GdipGetPenBrushFill@8
-GdipGetPenFillType@8
-GdipGetPenDashStyle@8
-GdipSetPenDashStyle@8
-GdipGetPenDashOffset@8
-GdipSetPenDashOffset@8
-GdipGetPenDashCount@8
-GdipSetPenDashArray@12
-GdipGetPenDashArray@12
-GdipGetPenCompoundCount@8
-GdipSetPenCompoundArray@12
-GdipGetPenCompoundArray@12
-GdipCreateRegion@4
-GdipCreateRegionRect@8
-GdipCreateRegionRectI@8
-GdipCreateRegionPath@8
-GdipCreateRegionRgnData@12
-GdipCreateRegionHrgn@8
-GdipCloneRegion@8
-GdipDeleteRegion@4
-GdipSetInfinite@4
-GdipSetEmpty@4
-GdipCombineRegionRect@12
-GdipCombineRegionRectI@12
-GdipCombineRegionPath@12
-GdipCombineRegionRegion@12
-GdipTranslateRegion@12
-GdipTranslateRegionI@12
-GdipTransformRegion@8
-GdipGetRegionBounds@12
-GdipGetRegionBoundsI@12
-GdipGetRegionHRgn@12
-GdipIsEmptyRegion@12
-GdipIsInfiniteRegion@12
-GdipIsEqualRegion@16
-GdipGetRegionDataSize@8
-GdipGetRegionData@16
-GdipIsVisibleRegionPoint@20
-GdipIsVisibleRegionPointI@20
-GdipIsVisibleRegionRect@28
-GdipIsVisibleRegionRectI@28
-GdipGetRegionScansCount@12
-GdipGetRegionScans@16
-GdipGetRegionScansI@16
-GdipCreateSolidFill@8
-GdipSetSolidFillColor@8
-GdipGetSolidFillColor@8
-GdipCreateStringFormat@12
-GdipStringFormatGetGenericDefault@4
-GdipStringFormatGetGenericTypographic@4
-GdipDeleteStringFormat@4
-GdipCloneStringFormat@8
-GdipSetStringFormatFlags@8
-GdipGetStringFormatFlags@8
-GdipSetStringFormatAlign@8
-GdipGetStringFormatAlign@8
-GdipSetStringFormatLineAlign@8
-GdipGetStringFormatLineAlign@8
-GdipSetStringFormatTrimming@8
-GdipGetStringFormatTrimming@8
-GdipSetStringFormatHotkeyPrefix@8
-GdipGetStringFormatHotkeyPrefix@8
-GdipSetStringFormatTabStops@16
-GdipGetStringFormatTabStops@16
-GdipGetStringFormatTabStopCount@8
-GdipSetStringFormatDigitSubstitution@12
-GdipGetStringFormatDigitSubstitution@12
-GdipGetStringFormatMeasurableCharacterRangeCount@8
-GdipSetStringFormatMeasurableCharacterRanges@12
-GdipDrawString@28
-GdipMeasureString@36
-GdipMeasureCharacterRanges@32
-GdipDrawDriverString@32
-GdipMeasureDriverString@32
-GdipCreateTexture@12
-GdipCreateTexture2@28
-GdipCreateTextureIA@28
-GdipCreateTexture2I@28
-GdipCreateTextureIAI@28
-GdipGetTextureTransform@8
-GdipSetTextureTransform@8
-GdipResetTextureTransform@4
-GdipMultiplyTextureTransform@12
-GdipTranslateTextureTransform@16
-GdipScaleTextureTransform@16
-GdipRotateTextureTransform@12
-GdipSetTextureWrapMode@8
-GdipGetTextureWrapMode@8
-GdipGetTextureImage@8
\ No newline at end of file
index 633da24..518cb70 100644 (file)
@@ -1,48 +1,33 @@
-<?xml version="1.0"?>
-<!DOCTYPE module SYSTEM "../../../tools/rbuild/project.dtd">
-<module name="gdiplus" type="win32dll" baseaddress="${BASEADDRESS_GDIPLUS}" installbase="system32" installname="gdiplus.dll">
-       <importlibrary definition="gdiplus.def" />
-       <include base="gdiplus">include</include>
-       <define name="_DISABLE_TIDENTS" />
-       <define name="UNICODE" />
-       <define name="_UNICODE" />
-       <define name="_WIN32_IE">0x600</define>
-       <define name="_WIN32_WINNT">0x501</define>
-       <define name="WINVER">0x501</define>
-       <library>ntdll</library>
-       <library>kernel32</library>
-       <library>gdi32</library>
-       <library>msvcrt</library>
-       <directory name="gdiplus">
-               <compilationunit name="unit.c">
-                       <file>arrow.c</file>
-                       <file>bitmap.c</file>
-                       <file>brush.c</file>
-                       <file>clip.c</file>
-                       <file>codec.c</file>
-                       <file>container.c</file>
-                       <file>dllmain.c</file>
-                       <file>draw.c</file>
-                       <file>effect.c</file>
-                       <file>fill.c</file>
-                       <file>font.c</file>
-                       <file>graphics.c</file>
-                       <file>image.c</file>
-                       <file>linecap.c</file>
-                       <file>linegradient.c</file>
-                       <file>matrix.c</file>
-                       <file>memory.c</file>
-                       <file>metafile.c</file>
-                       <file>palette.c</file>
-                       <file>path.c</file>
-                       <file>pathgradient.c</file>
-                       <file>pathiterator.c</file>
-                       <file>pen.c</file>
-                       <file>region.c</file>
-                       <file>string.c</file>
-                       <file>texture.c</file>
-                       <file>transform.c</file>
-               </compilationunit>
-       </directory>
-       <file>gdiplus.rc</file>
-</module>
+<module name="gdiplus" type="win32dll" baseaddress="${BASEADDRESS_GDIPLUS}" installbase="system32" installname="gdiplus.dll" allowwarnings="true" entrypoint="0">
+        <importlibrary definition="gdiplus.spec.def" />
+        <include base="gdiplus">.</include>
+        <include base="ReactOS">include/reactos/wine</include>
+        <define name="__REACTOS__" />
+        <define name="__WINESRC__" />
+        <define name="__USE_W32API" />
+        <define name="_WIN32_IE">0x600</define>
+        <define name="_WIN32_WINNT">0x501</define>
+        <define name="WINVER">0x501</define>
+        <library>wine</library>
+        <library>shlwapi</library>
+        <library>oleaut32</library>
+        <library>ole32</library>
+        <library>user32</library>
+        <library>gdi32</library>
+        <library>kernel32</library>
+        <library>uuid</library>
+        <library>ntdll</library>
+        <file>brush.c</file>
+        <file>customlinecap.c</file>
+        <file>font.c</file>
+        <file>gdiplus.c</file>
+        <file>graphics.c</file>
+        <file>graphicspath.c</file>
+        <file>image.c</file>
+        <file>imageattributes.c</file>
+        <file>matrix.c</file>
+        <file>pathiterator.c</file>
+        <file>pen.c</file>
+        <file>stringformat.c</file>
+        <file>gdiplus.spec</file>
+</module>
\ No newline at end of file
diff --git a/reactos/dll/win32/gdiplus/gdiplus.rc b/reactos/dll/win32/gdiplus/gdiplus.rc
deleted file mode 100644 (file)
index 719da45..0000000
+++ /dev/null
@@ -1,5 +0,0 @@
-#define REACTOS_VERSION_DLL
-#define REACTOS_STR_FILE_DESCRIPTION   "GDI+\0"
-#define REACTOS_STR_INTERNAL_NAME      "gdiplus\0"
-#define REACTOS_STR_ORIGINAL_FILENAME  "gdiplus.dll\0"
-#include <reactos/version.rc>
diff --git a/reactos/dll/win32/gdiplus/gdiplus.spec b/reactos/dll/win32/gdiplus/gdiplus.spec
new file mode 100644 (file)
index 0000000..4aac0df
--- /dev/null
@@ -0,0 +1,630 @@
+@ stdcall GdipAddPathArc(ptr long long long long long long)
+@ stub GdipAddPathArcI
+@ stub GdipAddPathBezier
+@ stdcall GdipAddPathBezierI(ptr long long long long long long long long)
+@ stdcall GdipAddPathBeziers(ptr ptr long)
+@ stub GdipAddPathBeziersI
+@ stub GdipAddPathClosedCurve2
+@ stub GdipAddPathClosedCurve2I
+@ stub GdipAddPathClosedCurve
+@ stub GdipAddPathClosedCurveI
+@ stub GdipAddPathCurve2
+@ stub GdipAddPathCurve2I
+@ stub GdipAddPathCurve3
+@ stub GdipAddPathCurve3I
+@ stub GdipAddPathCurve
+@ stub GdipAddPathCurveI
+@ stdcall GdipAddPathEllipse(ptr long long long long)
+@ stub GdipAddPathEllipseI
+@ stdcall GdipAddPathLine2(ptr ptr long)
+@ stub GdipAddPathLine2I
+@ stub GdipAddPathLine
+@ stdcall GdipAddPathLineI(ptr long long long long)
+@ stdcall GdipAddPathPath(ptr ptr long)
+@ stub GdipAddPathPie
+@ stub GdipAddPathPieI
+@ stub GdipAddPathPolygon
+@ stub GdipAddPathPolygonI
+@ stub GdipAddPathRectangle
+@ stub GdipAddPathRectangleI
+@ stub GdipAddPathRectangles
+@ stub GdipAddPathRectanglesI
+@ stub GdipAddPathString
+@ stub GdipAddPathStringI
+@ stdcall GdipAlloc(long)
+@ stub GdipBeginContainer2
+@ stub GdipBeginContainer
+@ stub GdipBeginContainerI
+@ stub GdipBitmapApplyEffect
+@ stub GdipBitmapConvertFormat
+@ stub GdipBitmapCreateApplyEffect
+@ stub GdipBitmapGetHistogram
+@ stub GdipBitmapGetHistogramSize
+@ stdcall GdipBitmapGetPixel(ptr long long ptr)
+@ stdcall GdipBitmapLockBits(ptr ptr long long ptr)
+@ stub GdipBitmapSetPixel
+@ stub GdipBitmapSetResolution
+@ stdcall GdipBitmapUnlockBits(ptr ptr)
+@ stub GdipClearPathMarkers
+@ stub GdipCloneBitmapArea
+@ stub GdipCloneBitmapAreaI
+@ stdcall GdipCloneBrush(ptr ptr)
+@ stdcall GdipCloneCustomLineCap(ptr ptr)
+@ stub GdipCloneFont
+@ stub GdipCloneFontFamily
+@ stub GdipCloneImage
+@ stub GdipCloneImageAttributes
+@ stdcall GdipCloneMatrix(ptr ptr)
+@ stdcall GdipClonePath(ptr ptr)
+@ stdcall GdipClonePen(ptr ptr)
+@ stub GdipCloneRegion
+@ stub GdipCloneStringFormat
+@ stdcall GdipClosePathFigure(ptr)
+@ stdcall GdipClosePathFigures(ptr)
+@ stub GdipCombineRegionPath
+@ stub GdipCombineRegionRect
+@ stub GdipCombineRegionRectI
+@ stub GdipCombineRegionRegion
+@ stub GdipComment
+@ stdcall GdipConvertToEmfPlus(ptr ptr ptr long ptr ptr)
+@ stub GdipConvertToEmfPlusToFile
+@ stub GdipConvertToEmfPlusToStream
+@ stub GdipCreateAdjustableArrowCap
+@ stub GdipCreateBitmapFromDirectDrawSurface
+@ stdcall GdipCreateBitmapFromFile(wstr ptr)
+@ stdcall GdipCreateBitmapFromFileICM(wstr ptr)
+@ stub GdipCreateBitmapFromGdiDib
+@ stdcall GdipCreateBitmapFromGraphics(long long ptr ptr)
+@ stub GdipCreateBitmapFromHBITMAP
+@ stub GdipCreateBitmapFromHICON
+@ stub GdipCreateBitmapFromResource
+@ stdcall GdipCreateBitmapFromScan0(long long long long ptr ptr)
+@ stdcall GdipCreateBitmapFromStream(ptr ptr)
+@ stdcall GdipCreateBitmapFromStreamICM(ptr ptr)
+@ stub GdipCreateCachedBitmap
+@ stdcall GdipCreateCustomLineCap(ptr ptr long long ptr)
+@ stub GdipCreateEffect
+@ stub GdipCreateFont
+@ stub GdipCreateFontFamilyFromName
+@ stub GdipCreateFontFromDC
+@ stdcall GdipCreateFontFromLogfontA(ptr ptr ptr)
+@ stdcall GdipCreateFontFromLogfontW(ptr ptr ptr)
+@ stdcall GdipCreateFromHDC2(long long ptr)
+@ stdcall GdipCreateFromHDC(long ptr)
+@ stdcall GdipCreateFromHWND(long ptr)
+@ stub GdipCreateFromHWNDICM
+@ stdcall GdipCreateHBITMAPFromBitmap(ptr ptr long)
+@ stub GdipCreateHICONFromBitmap
+@ stub GdipCreateHalftonePalette
+@ stub GdipCreateHatchBrush
+@ stdcall GdipCreateImageAttributes(ptr)
+@ stdcall GdipCreateLineBrush(ptr ptr long long long ptr)
+@ stub GdipCreateLineBrushFromRect
+@ stdcall GdipCreateLineBrushFromRectI(ptr long long long long ptr)
+@ stub GdipCreateLineBrushFromRectWithAngle
+@ stub GdipCreateLineBrushFromRectWithAngleI
+@ stub GdipCreateLineBrushI
+@ stdcall GdipCreateMatrix2(long long long long long long ptr)
+@ stdcall GdipCreateMatrix3(ptr ptr ptr)
+@ stub GdipCreateMatrix3I
+@ stdcall GdipCreateMatrix(ptr)
+@ stdcall GdipCreateMetafileFromEmf(ptr long ptr)
+@ stub GdipCreateMetafileFromFile
+@ stub GdipCreateMetafileFromStream
+@ stdcall GdipCreateMetafileFromWmf(ptr long ptr ptr)
+@ stub GdipCreateMetafileFromWmfFile
+@ stdcall GdipCreatePath2(ptr ptr long long ptr)
+@ stub GdipCreatePath2I
+@ stdcall GdipCreatePath(long ptr)
+@ stdcall GdipCreatePathGradient(ptr long long ptr)
+@ stdcall GdipCreatePathGradientFromPath(ptr ptr)
+@ stub GdipCreatePathGradientI
+@ stdcall GdipCreatePathIter(ptr ptr)
+@ stdcall GdipCreatePen1(long long long ptr)
+@ stdcall GdipCreatePen2(ptr long long ptr)
+@ stub GdipCreateRegion
+@ stub GdipCreateRegionHrgn
+@ stub GdipCreateRegionPath
+@ stub GdipCreateRegionRect
+@ stub GdipCreateRegionRectI
+@ stub GdipCreateRegionRgnData
+@ stdcall GdipCreateSolidFill(long ptr)
+@ stdcall GdipCreateStreamOnFile(ptr long ptr)
+@ stdcall GdipCreateStringFormat(long long ptr)
+@ stub GdipCreateTexture2
+@ stub GdipCreateTexture2I
+@ stub GdipCreateTexture
+@ stdcall GdipCreateTextureIA(ptr ptr long long long long ptr)
+@ stub GdipCreateTextureIAI
+@ stdcall GdipDeleteBrush(ptr)
+@ stub GdipDeleteCachedBitmap
+@ stdcall GdipDeleteCustomLineCap(ptr)
+@ stub GdipDeleteEffect
+@ stdcall GdipDeleteFont(ptr)
+@ stub GdipDeleteFontFamily
+@ stdcall GdipDeleteGraphics(ptr)
+@ stdcall GdipDeleteMatrix(ptr)
+@ stdcall GdipDeletePath(ptr)
+@ stdcall GdipDeletePathIter(ptr)
+@ stdcall GdipDeletePen(ptr)
+@ stub GdipDeletePrivateFontCollection
+@ stub GdipDeleteRegion
+@ stdcall GdipDeleteStringFormat(ptr)
+@ stdcall GdipDisposeImage(ptr)
+@ stdcall GdipDisposeImageAttributes(ptr)
+@ stdcall GdipDrawArc(ptr ptr long long long long long long)
+@ stdcall GdipDrawArcI(ptr ptr long long long long long long)
+@ stdcall GdipDrawBezier(ptr ptr long long long long long long long long)
+@ stdcall GdipDrawBezierI(ptr ptr long long long long long long long long)
+@ stub GdipDrawBeziers
+@ stub GdipDrawBeziersI
+@ stub GdipDrawCachedBitmap
+@ stub GdipDrawClosedCurve2
+@ stub GdipDrawClosedCurve2I
+@ stub GdipDrawClosedCurve
+@ stub GdipDrawClosedCurveI
+@ stdcall GdipDrawCurve2(ptr ptr ptr long long)
+@ stub GdipDrawCurve2I
+@ stub GdipDrawCurve3
+@ stub GdipDrawCurve3I
+@ stub GdipDrawCurve
+@ stub GdipDrawCurveI
+@ stub GdipDrawDriverString
+@ stub GdipDrawEllipse
+@ stub GdipDrawEllipseI
+@ stub GdipDrawImage
+@ stub GdipDrawImageFX
+@ stdcall GdipDrawImageI(ptr ptr long long)
+@ stub GdipDrawImagePointRect
+@ stub GdipDrawImagePointRectI
+@ stub GdipDrawImagePoints
+@ stub GdipDrawImagePointsI
+@ stdcall GdipDrawImagePointsRect(ptr ptr ptr long long long long long long ptr ptr ptr)
+@ stub GdipDrawImagePointsRectI
+@ stub GdipDrawImageRect
+@ stub GdipDrawImageRectI
+@ stdcall GdipDrawImageRectRect(ptr ptr long long long long long long long long long ptr long ptr)
+@ stdcall GdipDrawImageRectRectI(ptr ptr long long long long long long long long long ptr long ptr)
+@ stdcall GdipDrawLine(ptr ptr long long long long)
+@ stdcall GdipDrawLineI(ptr ptr long long long long)
+@ stdcall GdipDrawLines(ptr ptr ptr long)
+@ stdcall GdipDrawLinesI(ptr ptr ptr long)
+@ stdcall GdipDrawPath(ptr ptr ptr)
+@ stdcall GdipDrawPie(ptr ptr long long long long long long)
+@ stub GdipDrawPieI
+@ stub GdipDrawPolygon
+@ stub GdipDrawPolygonI
+@ stub GdipDrawRectangle
+@ stdcall GdipDrawRectangleI(ptr ptr long long long long)
+@ stdcall GdipDrawRectangles(ptr ptr ptr long)
+@ stub GdipDrawRectanglesI
+@ stdcall GdipDrawString(ptr ptr long ptr ptr ptr ptr)
+@ stub GdipEmfToWmfBits
+@ stub GdipEndContainer
+@ stub GdipEnumerateMetafileDestPoint
+@ stub GdipEnumerateMetafileDestPointI
+@ stub GdipEnumerateMetafileDestPoints
+@ stub GdipEnumerateMetafileDestPointsI
+@ stub GdipEnumerateMetafileDestRect
+@ stub GdipEnumerateMetafileDestRectI
+@ stub GdipEnumerateMetafileSrcRectDestPoint
+@ stub GdipEnumerateMetafileSrcRectDestPointI
+@ stub GdipEnumerateMetafileSrcRectDestPoints
+@ stub GdipEnumerateMetafileSrcRectDestPointsI
+@ stub GdipEnumerateMetafileSrcRectDestRect
+@ stub GdipEnumerateMetafileSrcRectDestRectI
+@ stub GdipFillClosedCurve2
+@ stub GdipFillClosedCurve2I
+@ stub GdipFillClosedCurve
+@ stub GdipFillClosedCurveI
+@ stub GdipFillEllipse
+@ stub GdipFillEllipseI
+@ stdcall GdipFillPath(ptr ptr ptr)
+@ stdcall GdipFillPie(ptr ptr long long long long long long)
+@ stub GdipFillPieI
+@ stub GdipFillPolygon2
+@ stub GdipFillPolygon2I
+@ stdcall GdipFillPolygon(ptr ptr ptr long long)
+@ stdcall GdipFillPolygonI(ptr ptr ptr long long)
+@ stdcall GdipFillRectangle(ptr ptr long long long long)
+@ stdcall GdipFillRectangleI(ptr ptr long long long long)
+@ stub GdipFillRectangles
+@ stub GdipFillRectanglesI
+@ stub GdipFillRegion
+@ stdcall GdipFindFirstImageItem(ptr ptr)
+@ stub GdipFindNextImageItem
+@ stub GdipFlattenPath
+@ stub GdipFlush
+@ stdcall GdipFree(ptr)
+@ stub GdipGetAdjustableArrowCapFillState
+@ stub GdipGetAdjustableArrowCapHeight
+@ stub GdipGetAdjustableArrowCapMiddleInset
+@ stub GdipGetAdjustableArrowCapWidth
+@ stub GdipGetAllPropertyItems
+@ stdcall GdipGetBrushType(ptr ptr)
+@ stub GdipGetCellAscent
+@ stub GdipGetCellDescent
+@ stub GdipGetClip
+@ stub GdipGetClipBounds
+@ stub GdipGetClipBoundsI
+@ stdcall GdipGetCompositingMode(ptr ptr)
+@ stdcall GdipGetCompositingQuality(ptr ptr)
+@ stub GdipGetCustomLineCapBaseCap
+@ stub GdipGetCustomLineCapBaseInset
+@ stub GdipGetCustomLineCapStrokeCaps
+@ stub GdipGetCustomLineCapStrokeJoin
+@ stub GdipGetCustomLineCapType
+@ stub GdipGetCustomLineCapWidthScale
+@ stub GdipGetDC
+@ stub GdipGetDpiX
+@ stub GdipGetDpiY
+@ stub GdipGetEffectParameterSize
+@ stub GdipGetEffectParameters
+@ stub GdipGetEmHeight
+@ stub GdipGetEncoderParameterList
+@ stub GdipGetEncoderParameterListSize
+@ stub GdipGetFamily
+@ stub GdipGetFamilyName
+@ stub GdipGetFontCollectionFamilyCount
+@ stub GdipGetFontCollectionFamilyList
+@ stub GdipGetFontHeight
+@ stub GdipGetFontHeightGivenDPI
+@ stub GdipGetFontSize
+@ stub GdipGetFontStyle
+@ stub GdipGetFontUnit
+@ stub GdipGetGenericFontFamilyMonospace
+@ stub GdipGetGenericFontFamilySansSerif
+@ stub GdipGetGenericFontFamilySerif
+@ stub GdipGetHatchBackgroundColor
+@ stub GdipGetHatchForegroundColor
+@ stub GdipGetHatchStyle
+@ stub GdipGetHemfFromMetafile
+@ stub GdipGetImageAttributesAdjustedPalette
+@ stdcall GdipGetImageBounds(ptr ptr ptr)
+@ stub GdipGetImageDecoders
+@ stub GdipGetImageDecodersSize
+@ stdcall GdipGetImageDimension(ptr ptr ptr)
+@ stdcall GdipGetImageEncoders(long long ptr)
+@ stdcall GdipGetImageEncodersSize(ptr ptr)
+@ stub GdipGetImageFlags
+@ stdcall GdipGetImageGraphicsContext(ptr ptr)
+@ stdcall GdipGetImageHeight(ptr ptr)
+@ stdcall GdipGetImageHorizontalResolution(ptr ptr)
+@ stub GdipGetImageItemData
+@ stub GdipGetImagePalette
+@ stub GdipGetImagePaletteSize
+@ stdcall GdipGetImagePixelFormat(ptr ptr)
+@ stdcall GdipGetImageRawFormat(ptr ptr)
+@ stub GdipGetImageThumbnail
+@ stdcall GdipGetImageType(ptr ptr)
+@ stdcall GdipGetImageVerticalResolution(ptr ptr)
+@ stdcall GdipGetImageWidth(ptr ptr)
+@ stdcall GdipGetInterpolationMode(ptr ptr)
+@ stub GdipGetLineBlend
+@ stub GdipGetLineBlendCount
+@ stub GdipGetLineColors
+@ stdcall GdipGetLineGammaCorrection(ptr ptr)
+@ stub GdipGetLinePresetBlend
+@ stub GdipGetLinePresetBlendCount
+@ stub GdipGetLineRect
+@ stub GdipGetLineRectI
+@ stub GdipGetLineSpacing
+@ stub GdipGetLineTransform
+@ stub GdipGetLineWrapMode
+@ stub GdipGetLogFontA
+@ stdcall GdipGetLogFontW(ptr ptr ptr)
+@ stdcall GdipGetMatrixElements(ptr ptr)
+@ stub GdipGetMetafileDownLevelRasterizationLimit
+@ stub GdipGetMetafileHeaderFromEmf
+@ stub GdipGetMetafileHeaderFromFile
+@ stdcall GdipGetMetafileHeaderFromMetafile(ptr ptr)
+@ stub GdipGetMetafileHeaderFromStream
+@ stub GdipGetMetafileHeaderFromWmf
+@ stub GdipGetNearestColor
+@ stdcall GdipGetPageScale(ptr ptr)
+@ stdcall GdipGetPageUnit(ptr ptr)
+@ stub GdipGetPathData
+@ stdcall GdipGetPathFillMode(ptr ptr)
+@ stub GdipGetPathGradientBlend
+@ stub GdipGetPathGradientBlendCount
+@ stub GdipGetPathGradientCenterColor
+@ stdcall GdipGetPathGradientCenterPoint(ptr ptr)
+@ stub GdipGetPathGradientCenterPointI
+@ stdcall GdipGetPathGradientFocusScales(ptr ptr ptr)
+@ stdcall GdipGetPathGradientGammaCorrection(ptr ptr)
+@ stub GdipGetPathGradientPath
+@ stdcall GdipGetPathGradientPointCount(ptr ptr)
+@ stub GdipGetPathGradientPresetBlend
+@ stub GdipGetPathGradientPresetBlendCount
+@ stub GdipGetPathGradientRect
+@ stub GdipGetPathGradientRectI
+@ stub GdipGetPathGradientSurroundColorCount
+@ stdcall GdipGetPathGradientSurroundColorsWithCount(ptr ptr ptr)
+@ stub GdipGetPathGradientTransform
+@ stub GdipGetPathGradientWrapMode
+@ stub GdipGetPathLastPoint
+@ stdcall GdipGetPathPoints(ptr ptr long)
+@ stub GdipGetPathPointsI
+@ stdcall GdipGetPathTypes(ptr ptr long)
+@ stdcall GdipGetPathWorldBounds(ptr ptr ptr ptr)
+@ stub GdipGetPathWorldBoundsI
+@ stdcall GdipGetPenBrushFill(ptr ptr)
+@ stdcall GdipGetPenColor(ptr ptr)
+@ stub GdipGetPenCompoundArray
+@ stub GdipGetPenCompoundCount
+@ stub GdipGetPenCustomEndCap
+@ stub GdipGetPenCustomStartCap
+@ stdcall GdipGetPenDashArray(ptr ptr long)
+@ stub GdipGetPenDashCap197819
+@ stub GdipGetPenDashCount
+@ stdcall GdipGetPenDashOffset(ptr ptr)
+@ stdcall GdipGetPenDashStyle(ptr ptr)
+@ stub GdipGetPenEndCap
+@ stub GdipGetPenFillType
+@ stub GdipGetPenLineJoin
+@ stub GdipGetPenMiterLimit
+@ stub GdipGetPenMode
+@ stub GdipGetPenStartCap
+@ stub GdipGetPenTransform
+@ stub GdipGetPenUnit
+@ stub GdipGetPenWidth
+@ stdcall GdipGetPixelOffsetMode(ptr ptr)
+@ stdcall GdipGetPointCount(ptr ptr)
+@ stub GdipGetPropertyCount
+@ stub GdipGetPropertyIdList
+@ stub GdipGetPropertyItem
+@ stdcall GdipGetPropertyItemSize(ptr long ptr)
+@ stub GdipGetPropertySize
+@ stub GdipGetRegionBounds
+@ stub GdipGetRegionBoundsI
+@ stub GdipGetRegionData
+@ stub GdipGetRegionDataSize
+@ stub GdipGetRegionHRgn
+@ stub GdipGetRegionScans
+@ stub GdipGetRegionScansCount
+@ stub GdipGetRegionScansI
+@ stub GdipGetRenderingOrigin
+@ stdcall GdipGetSmoothingMode(ptr ptr)
+@ stdcall GdipGetSolidFillColor(ptr ptr)
+@ stdcall GdipGetStringFormatAlign(ptr ptr)
+@ stub GdipGetStringFormatDigitSubstitution
+@ stub GdipGetStringFormatFlags
+@ stdcall GdipGetStringFormatHotkeyPrefix(ptr ptr)
+@ stdcall GdipGetStringFormatLineAlign(ptr ptr)
+@ stub GdipGetStringFormatMeasurableCharacterRangeCount
+@ stub GdipGetStringFormatTabStopCount
+@ stub GdipGetStringFormatTabStops
+@ stdcall GdipGetStringFormatTrimming(ptr ptr)
+@ stub GdipGetTextContrast
+@ stdcall GdipGetTextRenderingHint(ptr ptr)
+@ stub GdipGetTextureImage
+@ stub GdipGetTextureTransform
+@ stub GdipGetTextureWrapMode
+@ stub GdipGetVisibleClipBounds
+@ stub GdipGetVisibleClipBoundsI
+@ stdcall GdipGetWorldTransform(ptr ptr)
+@ stub GdipGraphicsClear
+@ stub GdipGraphicsSetAbort
+@ stub GdipImageForceValidation
+@ stdcall GdipImageGetFrameCount(ptr ptr ptr)
+@ stub GdipImageGetFrameDimensionsCount
+@ stdcall GdipImageGetFrameDimensionsList(ptr ptr long)
+@ stub GdipImageRotateFlip
+@ stdcall GdipImageSelectActiveFrame(ptr ptr long)
+@ stub GdipImageSetAbort
+@ stub GdipInitializePalette
+@ stub GdipInvertMatrix
+@ stub GdipIsClipEmpty
+@ stub GdipIsEmptyRegion
+@ stub GdipIsEqualRegion
+@ stub GdipIsInfiniteRegion
+@ stub GdipIsMatrixEqual
+@ stub GdipIsMatrixIdentity
+@ stub GdipIsMatrixInvertible
+@ stub GdipIsOutlineVisiblePathPoint
+@ stdcall GdipIsOutlineVisiblePathPointI(ptr long long ptr ptr ptr)
+@ stub GdipIsStyleAvailable
+@ stub GdipIsVisibleClipEmpty
+@ stub GdipIsVisiblePathPoint
+@ stub GdipIsVisiblePathPointI
+@ stub GdipIsVisiblePoint
+@ stub GdipIsVisiblePointI
+@ stub GdipIsVisibleRect
+@ stub GdipIsVisibleRectI
+@ stub GdipIsVisibleRegionPoint
+@ stub GdipIsVisibleRegionPointI
+@ stub GdipIsVisibleRegionRect
+@ stub GdipIsVisibleRegionRectI
+@ stdcall GdipLoadImageFromFile(wstr ptr)
+@ stub GdipLoadImageFromFileICM
+@ stdcall GdipLoadImageFromStream(ptr ptr)
+@ stdcall GdipLoadImageFromStreamICM(ptr ptr)
+@ stub GdipMeasureCharacterRanges
+@ stub GdipMeasureDriverString
+@ stdcall GdipMeasureString(ptr ptr long ptr ptr ptr ptr ptr ptr)
+@ stub GdipMultiplyLineTransform
+@ stdcall GdipMultiplyMatrix(ptr ptr long)
+@ stub GdipMultiplyPathGradientTransform
+@ stub GdipMultiplyPenTransform
+@ stub GdipMultiplyTextureTransform
+@ stub GdipMultiplyWorldTransform
+@ stub GdipNewInstalledFontCollection
+@ stub GdipNewPrivateFontCollection
+@ stdcall GdipPathIterCopyData(ptr ptr ptr ptr long long)
+@ stub GdipPathIterEnumerate
+@ stub GdipPathIterGetCount
+@ stub GdipPathIterGetSubpathCount
+@ stub GdipPathIterHasCurve
+@ stub GdipPathIterIsValid
+@ stub GdipPathIterNextMarker
+@ stub GdipPathIterNextMarkerPath
+@ stub GdipPathIterNextPathType
+@ stdcall GdipPathIterNextSubpath(ptr ptr ptr ptr ptr)
+@ stub GdipPathIterNextSubpathPath
+@ stdcall GdipPathIterRewind(ptr)
+@ stub GdipPlayMetafileRecord
+@ stub GdipPlayTSClientRecord
+@ stub GdipPrivateAddFontFile
+@ stub GdipPrivateAddMemoryFont
+@ stub GdipRecordMetafile
+@ stub GdipRecordMetafileFileName
+@ stub GdipRecordMetafileFileNameI
+@ stub GdipRecordMetafileI
+@ stub GdipRecordMetafileStream
+@ stub GdipRecordMetafileStreamI
+@ stub GdipReleaseDC
+@ stdcall GdipRemovePropertyItem(ptr long)
+@ stub GdipResetClip
+@ stub GdipResetImageAttributes
+@ stub GdipResetLineTransform
+@ stub GdipResetPageTransform
+@ stdcall GdipResetPath(ptr)
+@ stub GdipResetPathGradientTransform
+@ stub GdipResetPenTransform
+@ stub GdipResetTextureTransform
+@ stub GdipResetWorldTransform
+@ stdcall GdipRestoreGraphics(ptr long)
+@ stub GdipReversePath
+@ stub GdipRotateLineTransform
+@ stdcall GdipRotateMatrix(ptr long long)
+@ stub GdipRotatePathGradientTransform
+@ stub GdipRotatePenTransform
+@ stub GdipRotateTextureTransform
+@ stdcall GdipRotateWorldTransform(ptr long long)
+@ stub GdipSaveAdd
+@ stub GdipSaveAddImage
+@ stdcall GdipSaveGraphics(ptr ptr)
+@ stdcall GdipSaveImageToFile(ptr ptr ptr ptr)
+@ stdcall GdipSaveImageToStream(ptr ptr ptr ptr)
+@ stub GdipScaleLineTransform
+@ stdcall GdipScaleMatrix(ptr long long long)
+@ stub GdipScalePathGradientTransform
+@ stub GdipScalePenTransform
+@ stub GdipScaleTextureTransform
+@ stdcall GdipScaleWorldTransform(ptr long long long)
+@ stub GdipSetAdjustableArrowCapFillState
+@ stub GdipSetAdjustableArrowCapHeight
+@ stub GdipSetAdjustableArrowCapMiddleInset
+@ stub GdipSetAdjustableArrowCapWidth
+@ stub GdipSetClipGraphics
+@ stub GdipSetClipHrgn
+@ stub GdipSetClipPath
+@ stub GdipSetClipRect
+@ stub GdipSetClipRectI
+@ stub GdipSetClipRegion
+@ stdcall GdipSetCompositingMode(ptr long)
+@ stdcall GdipSetCompositingQuality(ptr long)
+@ stub GdipSetCustomLineCapBaseCap
+@ stub GdipSetCustomLineCapBaseInset
+@ stdcall GdipSetCustomLineCapStrokeCaps(ptr long long)
+@ stub GdipSetCustomLineCapStrokeJoin
+@ stub GdipSetCustomLineCapWidthScale
+@ stub GdipSetEffectParameters
+@ stub GdipSetEmpty
+@ stub GdipSetImageAttributesCachedBackground
+@ stdcall GdipSetImageAttributesColorKeys(ptr long long long long)
+@ stdcall GdipSetImageAttributesColorMatrix(ptr long long ptr ptr long)
+@ stub GdipSetImageAttributesGamma
+@ stub GdipSetImageAttributesNoOp
+@ stub GdipSetImageAttributesOutputChannel
+@ stub GdipSetImageAttributesOutputChannelColorProfile
+@ stub GdipSetImageAttributesRemapTable
+@ stub GdipSetImageAttributesThreshold
+@ stub GdipSetImageAttributesToIdentity
+@ stdcall GdipSetImageAttributesWrapMode(ptr long long long)
+@ stdcall GdipSetImagePalette(ptr ptr)
+@ stub GdipSetInfinite
+@ stdcall GdipSetInterpolationMode(ptr long)
+@ stdcall GdipSetLineBlend(ptr ptr ptr long)
+@ stub GdipSetLineColors
+@ stdcall GdipSetLineGammaCorrection(ptr long)
+@ stub GdipSetLineLinearBlend
+@ stub GdipSetLinePresetBlend
+@ stdcall GdipSetLineSigmaBlend(ptr long long)
+@ stub GdipSetLineTransform
+@ stdcall GdipSetLineWrapMode(ptr long)
+@ stdcall GdipSetMatrixElements(ptr long long long long long long)
+@ stub GdipSetMetafileDownLevelRasterizationLimit
+@ stdcall GdipSetPageScale(ptr long)
+@ stdcall GdipSetPageUnit(ptr long)
+@ stdcall GdipSetPathFillMode(ptr long)
+@ stub GdipSetPathGradientBlend
+@ stdcall GdipSetPathGradientCenterColor(ptr long)
+@ stdcall GdipSetPathGradientCenterPoint(ptr ptr)
+@ stub GdipSetPathGradientCenterPointI
+@ stdcall GdipSetPathGradientFocusScales(ptr long long)
+@ stdcall GdipSetPathGradientGammaCorrection(ptr long)
+@ stub GdipSetPathGradientLinearBlend
+@ stub GdipSetPathGradientPath
+@ stub GdipSetPathGradientPresetBlend
+@ stdcall GdipSetPathGradientSigmaBlend(ptr long long)
+@ stdcall GdipSetPathGradientSurroundColorsWithCount(ptr ptr ptr)
+@ stub GdipSetPathGradientTransform
+@ stdcall GdipSetPathGradientWrapMode(ptr long)
+@ stub GdipSetPathMarker
+@ stdcall GdipSetPenBrushFill(ptr ptr)
+@ stdcall GdipSetPenColor(ptr long)
+@ stub GdipSetPenCompoundArray
+@ stdcall GdipSetPenCustomEndCap(ptr ptr)
+@ stdcall GdipSetPenCustomStartCap(ptr ptr)
+@ stdcall GdipSetPenDashArray(ptr ptr long)
+@ stub GdipSetPenDashCap197819
+@ stdcall GdipSetPenDashOffset(ptr long)
+@ stdcall GdipSetPenDashStyle(ptr long)
+@ stdcall GdipSetPenEndCap(ptr long)
+@ stdcall GdipSetPenLineCap197819(ptr long long long)
+@ stdcall GdipSetPenLineJoin(ptr long)
+@ stdcall GdipSetPenMiterLimit(ptr long)
+@ stdcall GdipSetPenMode(ptr long)
+@ stdcall GdipSetPenStartCap(ptr long)
+@ stub GdipSetPenTransform
+@ stub GdipSetPenUnit
+@ stdcall GdipSetPenWidth(ptr long)
+@ stdcall GdipSetPixelOffsetMode(ptr long)
+@ stub GdipSetPropertyItem
+@ stub GdipSetRenderingOrigin
+@ stdcall GdipSetSmoothingMode(ptr long)
+@ stdcall GdipSetSolidFillColor(ptr ptr)
+@ stdcall GdipSetStringFormatAlign(ptr long)
+@ stub GdipSetStringFormatDigitSubstitution
+@ stdcall GdipSetStringFormatFlags(ptr long)
+@ stdcall GdipSetStringFormatHotkeyPrefix(ptr long)
+@ stdcall GdipSetStringFormatLineAlign(ptr long)
+@ stub GdipSetStringFormatMeasurableCharacterRanges
+@ stub GdipSetStringFormatTabStops
+@ stdcall GdipSetStringFormatTrimming(ptr long)
+@ stub GdipSetTextContrast
+@ stdcall GdipSetTextRenderingHint(ptr long)
+@ stdcall GdipSetTextureTransform(ptr ptr)
+@ stub GdipSetTextureWrapMode
+@ stdcall GdipSetWorldTransform(ptr ptr)
+@ stub GdipShearMatrix
+@ stdcall GdipStartPathFigure(ptr)
+@ stub GdipStringFormatGetGenericDefault
+@ stub GdipStringFormatGetGenericTypographic
+@ stub GdipTestControl
+@ stdcall GdipTransformMatrixPoints(ptr ptr long)
+@ stub GdipTransformMatrixPointsI
+@ stdcall GdipTransformPath(ptr ptr)
+@ stub GdipTransformPoints
+@ stub GdipTransformPointsI
+@ stub GdipTransformRegion
+@ stub GdipTranslateClip
+@ stub GdipTranslateClipI
+@ stub GdipTranslateLineTransform
+@ stdcall GdipTranslateMatrix(ptr long long long)
+@ stub GdipTranslatePathGradientTransform
+@ stub GdipTranslatePenTransform
+@ stub GdipTranslateRegion
+@ stub GdipTranslateRegionI
+@ stub GdipTranslateTextureTransform
+@ stdcall GdipTranslateWorldTransform(ptr long long long)
+@ stub GdipVectorTransformMatrixPoints
+@ stub GdipVectorTransformMatrixPointsI
+@ stub GdipWarpPath
+@ stub GdipWidenPath
+@ stub GdipWindingModeOutline
+@ stub GdiplusNotificationHook
+@ stub GdiplusNotificationUnhook
+@ stdcall GdiplusShutdown(ptr)
+@ stdcall GdiplusStartup(ptr ptr ptr)
diff --git a/reactos/dll/win32/gdiplus/gdiplus/arrow.c b/reactos/dll/win32/gdiplus/gdiplus/arrow.c
deleted file mode 100644 (file)
index 8ad6740..0000000
+++ /dev/null
@@ -1,90 +0,0 @@
-#include <windows.h>
-#include <gdiplusprivate.h>
-#include <debug.h>
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateAdjustableArrowCap(REAL height,
-  REAL width,
-  BOOL isFilled,
-  GpAdjustableArrowCap **cap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetAdjustableArrowCapHeight(GpAdjustableArrowCap* cap,
-  REAL height)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetAdjustableArrowCapHeight(GpAdjustableArrowCap* cap, REAL* height)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetAdjustableArrowCapWidth(GpAdjustableArrowCap* cap,
-  REAL width)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI GdipGetAdjustableArrowCapWidth(GpAdjustableArrowCap* cap,
-  REAL* width)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI GdipSetAdjustableArrowCapMiddleInset(GpAdjustableArrowCap* cap,
-  REAL middleInset)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI GdipGetAdjustableArrowCapMiddleInset(GpAdjustableArrowCap* cap,
-  REAL* middleInset)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI GdipSetAdjustableArrowCapFillState(GpAdjustableArrowCap* cap,
-  BOOL fillState)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetAdjustableArrowCapFillState(GpAdjustableArrowCap* cap,
-  BOOL* fillState)
-{
-  return NotImplemented;
-}
diff --git a/reactos/dll/win32/gdiplus/gdiplus/bitmap.c b/reactos/dll/win32/gdiplus/gdiplus/bitmap.c
deleted file mode 100644 (file)
index 56a4697..0000000
+++ /dev/null
@@ -1,346 +0,0 @@
-#include <windows.h>
-#include <gdiplusprivate.h>
-#include <debug.h>
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateBitmapFromStream(IStream* stream,
-  GpBitmap **bitmap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateBitmapFromFile(GDIPCONST WCHAR* filename,
-  GpBitmap **bitmap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateBitmapFromStreamICM(IStream* stream,
-  GpBitmap **bitmap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateBitmapFromFileICM(GDIPCONST WCHAR* filename,
-  GpBitmap **bitmap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateBitmapFromScan0(INT width,
-  INT height,
-  INT stride,
-  PixelFormat format,
-  BYTE* scan0,
-  GpBitmap** bitmap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateBitmapFromGraphics(INT width,
-  INT height,
-  GpGraphics* target,
-  GpBitmap** bitmap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateBitmapFromDirectDrawSurface(IDirectDrawSurface7* surface,
-GpBitmap** bitmap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateBitmapFromGdiDib(GDIPCONST BITMAPINFO* gdiBitmapInfo,
-  VOID* gdiBitmapData,
-  GpBitmap** bitmap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateBitmapFromHBITMAP(HBITMAP hbm,
-  HPALETTE hpal,
-  GpBitmap** bitmap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateHBITMAPFromBitmap(GpBitmap* bitmap,
-  HBITMAP* hbmReturn,
-  ARGB background)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateBitmapFromHICON(HICON hicon,
-  GpBitmap** bitmap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateHICONFromBitmap(GpBitmap* bitmap,
-  HICON* hbmReturn)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateBitmapFromResource(HINSTANCE hInstance,
-  GDIPCONST WCHAR* lpBitmapName,
-  GpBitmap** bitmap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCloneBitmapArea(REAL x,
-  REAL y,
-  REAL width,
-  REAL height,
-  PixelFormat format,
-  GpBitmap *srcBitmap,
-  GpBitmap **dstBitmap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCloneBitmapAreaI(INT x,
-  INT y,
-  INT width,
-  INT height,
-  PixelFormat format,
-  GpBitmap *srcBitmap,
-  GpBitmap **dstBitmap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipBitmapLockBits(GpBitmap* bitmap,
-  GDIPCONST GpRect* rect,
-  UINT flags,
-  PixelFormat format,
-  BitmapData* lockedBitmapData)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipBitmapUnlockBits(GpBitmap* bitmap,
-  BitmapData* lockedBitmapData)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipBitmapGetPixel(GpBitmap* bitmap,
-  INT x,
-  INT y,
-  ARGB *color)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipBitmapSetPixel(GpBitmap* bitmap,
-  INT x,
-  INT y,
-  ARGB color)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipBitmapSetResolution(GpBitmap* bitmap,
-  REAL xdpi,
-  REAL ydpi)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipBitmapConvertFormat(IN GpBitmap *pInputBitmap,
-  PixelFormat format,
-  DitherType dithertype,
-  PaletteType palettetype,
-  ColorPalette *palette,
-  REAL alphaThresholdPercent)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipInitializePalette(OUT ColorPalette *palette,
-  PaletteType palettetype,
-  INT optimalColors,
-  BOOL useTransparentColor,
-  GpBitmap *bitmap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipBitmapApplyEffect(GpBitmap* bitmap,
-  CGpEffect *effect,
-  RECT *roi,
-  BOOL useAuxData,
-  VOID **auxData,
-  INT *auxDataSize)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipBitmapCreateApplyEffect(GpBitmap **inputBitmaps,
-  INT numInputs,
-  CGpEffect *effect,
-  RECT *roi,
-  RECT *outputRect,
-  GpBitmap **outputBitmap,
-  BOOL useAuxData,
-  VOID **auxData,
-  INT *auxDataSize)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipBitmapGetHistogram(GpBitmap* bitmap,
-  IN HistogramFormat format,
-  IN UINT NumberOfEntries,
-  OUT UINT *channel0,
-  OUT UINT *channel1,
-  OUT UINT *channel2,
-  OUT UINT *channel3)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipBitmapGetHistogramSize(IN HistogramFormat format,
-  OUT UINT *NumberOfEntries)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateCachedBitmap(GpBitmap *bitmap,
-  GpGraphics *graphics,
-  GpCachedBitmap **cachedBitmap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDeleteCachedBitmap(GpCachedBitmap *cachedBitmap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawCachedBitmap(GpGraphics *graphics,
-  GpCachedBitmap *cachedBitmap,
-  INT x,
-  INT y)
-{
-  return NotImplemented;
-}
diff --git a/reactos/dll/win32/gdiplus/gdiplus/brush.c b/reactos/dll/win32/gdiplus/gdiplus/brush.c
deleted file mode 100644 (file)
index 8db1001..0000000
+++ /dev/null
@@ -1,74 +0,0 @@
-#include <windows.h>
-#include <gdiplusprivate.h>
-#include <debug.h>
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCloneBrush(GpBrush *brush,
-  GpBrush **cloneBrush)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDeleteBrush(GpBrush *brush)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetBrushType(GpBrush *brush,
-  GpBrushType *type)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateHatchBrush(GpHatchStyle hatchstyle,
-  ARGB forecol,
-  ARGB backcol,
-  GpHatch **brush)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetHatchStyle(GpHatch *brush,
-  GpHatchStyle *hatchstyle)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetHatchForegroundColor(GpHatch *brush,
-  ARGB* forecol)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetHatchBackgroundColor(GpHatch *brush,
-  ARGB* backcol)
-{
-  return NotImplemented;
-}
diff --git a/reactos/dll/win32/gdiplus/gdiplus/clip.c b/reactos/dll/win32/gdiplus/gdiplus/clip.c
deleted file mode 100644 (file)
index 458655e..0000000
+++ /dev/null
@@ -1,228 +0,0 @@
-#include <windows.h>
-#include <gdiplusprivate.h>
-#include <debug.h>
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetClipGraphics(GpGraphics *graphics,
-  GpGraphics *srcgraphics,
-  CombineMode combineMode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetClipRect(GpGraphics *graphics,
-  REAL x,
-  REAL y,
-  REAL width,
-  REAL height,
-  CombineMode combineMode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetClipRectI(GpGraphics *graphics,
-  INT x,
-  INT y,
-  INT width,
-  INT height,
-  CombineMode combineMode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetClipPath(GpGraphics *graphics,
-  GpPath *path,
-  CombineMode combineMode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetClipRegion(GpGraphics *graphics,
-  GpRegion *region,
-  CombineMode combineMode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetClipHrgn(GpGraphics *graphics,
-  HRGN hRgn,
-  CombineMode combineMode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipResetClip(GpGraphics *graphics)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipTranslateClip(GpGraphics *graphics,
-  REAL dx,
-  REAL dy)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipTranslateClipI(GpGraphics *graphics,
-  INT dx,
-  INT dy)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetClip(GpGraphics *graphics,
-  GpRegion *region)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetClipBounds(GpGraphics *graphics,
-  GpRectF *rect)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetClipBoundsI(GpGraphics *graphics,
-  GpRect *rect)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipIsClipEmpty(GpGraphics *graphics,
-  BOOL *result)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetVisibleClipBounds(GpGraphics *graphics,
-  GpRectF *rect)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetVisibleClipBoundsI(GpGraphics *graphics,
-  GpRect *rect)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipIsVisibleClipEmpty(GpGraphics *graphics,
-  BOOL *result)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipIsVisiblePoint(GpGraphics *graphics,
-  REAL x,
-  REAL y,
-  BOOL *result)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipIsVisiblePointI(GpGraphics *graphics,
-  INT x,
-  INT y,
-  BOOL *result)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipIsVisibleRect(GpGraphics *graphics,
-  REAL x,
-  REAL y,
-  REAL width,
-  REAL height,
-  BOOL *result)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipIsVisibleRectI(GpGraphics *graphics,
-  INT x,
-  INT y,
-  INT width,
-  INT height,
-  BOOL *result)
-{
-  return NotImplemented;
-}
diff --git a/reactos/dll/win32/gdiplus/gdiplus/codec.c b/reactos/dll/win32/gdiplus/gdiplus/codec.c
deleted file mode 100644 (file)
index 541d869..0000000
+++ /dev/null
@@ -1,45 +0,0 @@
-#include <windows.h>
-#include <gdiplusprivate.h>
-#include <debug.h>
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetImageDecodersSize(UINT *numDecoders,
-  UINT *size)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetImageDecoders(UINT numDecoders,
-  UINT size,
-  ImageCodecInfo *decoders)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetImageEncodersSize(UINT *numEncoders,
-  UINT *size)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetImageEncoders(UINT numEncoders,
-  UINT size,
-  ImageCodecInfo *encoders)
-{
-  return NotImplemented;
-}
diff --git a/reactos/dll/win32/gdiplus/gdiplus/container.c b/reactos/dll/win32/gdiplus/gdiplus/container.c
deleted file mode 100644 (file)
index 9f2ce7e..0000000
+++ /dev/null
@@ -1,49 +0,0 @@
-#include <windows.h>
-#include <gdiplusprivate.h>
-#include <debug.h>
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipBeginContainer(GpGraphics *graphics,
-  GDIPCONST GpRectF* dstrect,
-  GDIPCONST GpRectF *srcrect,
-  GpUnit unit,
-  GraphicsContainer *state)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipBeginContainerI(GpGraphics *graphics,
-  GDIPCONST GpRect* dstrect,
-  GDIPCONST GpRect *srcrect,
-  GpUnit unit,
-  GraphicsContainer *state)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipBeginContainer2(GpGraphics *graphics,
-  GraphicsContainer* state)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipEndContainer(GpGraphics *graphics,
-  GraphicsContainer state)
-{
-  return NotImplemented;
-}
diff --git a/reactos/dll/win32/gdiplus/gdiplus/dllmain.c b/reactos/dll/win32/gdiplus/gdiplus/dllmain.c
deleted file mode 100644 (file)
index e892eb9..0000000
+++ /dev/null
@@ -1,50 +0,0 @@
-#include <windows.h>
-#include <gdiplusprivate.h>
-#include <debug.h>
-
-#ifdef DBG
-
-/* See debug.h for debug/trace constants */
-DWORD DebugTraceLevel = MIN_TRACE;
-
-#endif /* DBG */
-
-/*
- * @unimplemented
- */
-Status WINAPI
-GdiplusStartup(ULONG_PTR *token,
-  const GdiplusStartupInput *input,
-  GdiplusStartupOutput *output)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-VOID WINAPI
-GdiplusShutdown(ULONG_PTR token)
-{
-}
-
-INT STDCALL
-DllMain(
-       PVOID hinstDll,
-       ULONG dwReason,
-       PVOID reserved)
-{
-  switch (dwReason)
-    {
-      case DLL_PROCESS_ATTACH:
-        break;
-      case DLL_THREAD_ATTACH:
-        break;
-      case DLL_THREAD_DETACH:
-        break;
-      case DLL_PROCESS_DETACH:
-        break;
-    }
-
-  return 1;
-}
diff --git a/reactos/dll/win32/gdiplus/gdiplus/draw.c b/reactos/dll/win32/gdiplus/gdiplus/draw.c
deleted file mode 100644 (file)
index 23c1e28..0000000
+++ /dev/null
@@ -1,420 +0,0 @@
-#include <windows.h>
-#include <gdiplusprivate.h>
-#include <debug.h>
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawLine(GpGraphics *graphics,
-  GpPen *pen,
-  REAL x1,
-  REAL y1,
-  REAL x2,
-  REAL y2)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawLineI(GpGraphics *graphics,
-  GpPen *pen,
-  INT x1,
-  INT y1,
-  INT x2,
-  INT y2)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawLines(GpGraphics *graphics,
-  GpPen *pen,
-  GDIPCONST GpPointF *points,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawLinesI(GpGraphics *graphics,
-  GpPen *pen,
-  GDIPCONST GpPoint *points,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawArc(GpGraphics *graphics,
-  GpPen *pen,
-  REAL x,
-  REAL y,
-  REAL width,
-  REAL height,
-  REAL startAngle,
-  REAL sweepAngle)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawArcI(GpGraphics *graphics,
-  GpPen *pen,
-  INT x,
-  INT y,
-  INT width,
-  INT height,
-  REAL startAngle,
-  REAL sweepAngle)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawBezier(GpGraphics *graphics,
-  GpPen *pen,
-  REAL x1,
-  REAL y1,
-  REAL x2,
-  REAL y2,
-  REAL x3,
-  REAL y3,
-  REAL x4,
-  REAL y4)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawBezierI(GpGraphics *graphics,
-  GpPen *pen,
-  INT x1,
-  INT y1,
-  INT x2,
-  INT y2,
-  INT x3,
-  INT y3,
-  INT x4,
-  INT y4)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawBeziers(GpGraphics *graphics,
-  GpPen *pen,
-  GDIPCONST GpPointF *points,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawBeziersI(GpGraphics *graphics,
-  GpPen *pen,
-  GDIPCONST GpPoint *points,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawRectangle(GpGraphics *graphics,
-  GpPen *pen,
-  REAL x,
-  REAL y,
-  REAL width,
-  REAL height)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawRectangleI(GpGraphics *graphics,
-  GpPen *pen,
-  INT x,
-  INT y,
-  INT width,
-  INT height)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawRectangles(GpGraphics *graphics,
-  GpPen *pen,
-  GDIPCONST GpRectF *rects,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawRectanglesI(GpGraphics *graphics,
-  GpPen *pen,
-  GDIPCONST GpRect *rects,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawEllipse(GpGraphics *graphics,
-  GpPen *pen,
-  REAL x,
-  REAL y,
-  REAL width,
-  REAL height)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawEllipseI(GpGraphics *graphics,
-  GpPen *pen,
-  INT x,
-  INT y,
-  INT width,
-  INT height)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawPie(GpGraphics *graphics,
-  GpPen *pen,
-  REAL x,
-  REAL y,
-  REAL width,
-  REAL height,
-  REAL startAngle,
-  REAL sweepAngle)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawPieI(GpGraphics *graphics,
-  GpPen *pen,
-  INT x,
-  INT y,
-  INT width,
-  INT height,
-  REAL startAngle,
-  REAL sweepAngle)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawPolygon(GpGraphics *graphics,
-  GpPen *pen,
-  GDIPCONST GpPointF *points,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawPolygonI(GpGraphics *graphics,
-  GpPen *pen,
-  GDIPCONST GpPoint *points,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawPath(GpGraphics *graphics,
-  GpPen *pen,
-  GpPath *path)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawCurve(GpGraphics *graphics,
-  GpPen *pen,
-  GDIPCONST GpPointF *points,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawCurveI(GpGraphics *graphics,
-  GpPen *pen,
-  GDIPCONST GpPoint *points,
-  INT count)
-{
-  return NotImplemented;
-}
-
-GpStatus WINGDIPAPI GdipDrawCurve2(GpGraphics *graphics,
-  GpPen *pen,
-  GDIPCONST GpPointF *points,
-  INT count,
-  REAL tension)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawCurve2I(GpGraphics *graphics,
-  GpPen *pen,
-  GDIPCONST GpPoint *points,
-  INT count,
-  REAL tension)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawCurve3(GpGraphics *graphics,
-  GpPen *pen,
-  GDIPCONST GpPointF *points,
-  INT count,
-  INT offset,
-  INT numberOfSegments,
-  REAL tension)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawCurve3I(GpGraphics *graphics,
-  GpPen *pen,
-  GDIPCONST GpPoint *points,
-  INT count,
-  INT offset,
-  INT numberOfSegments,
-  REAL tension)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawClosedCurve(GpGraphics *graphics,
-  GpPen *pen,
-  GDIPCONST GpPointF *points,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawClosedCurveI(GpGraphics *graphics,
-  GpPen *pen,
-  GDIPCONST GpPoint *points,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawClosedCurve2(GpGraphics *graphics,
-  GpPen *pen,
-  GDIPCONST GpPointF *points,
-  INT count,
-  REAL tension)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawClosedCurve2I(GpGraphics *graphics,
-  GpPen *pen,
-  GDIPCONST GpPoint *points,
-  INT count,
-  REAL tension)
-{
-  return NotImplemented;
-}
diff --git a/reactos/dll/win32/gdiplus/gdiplus/effect.c b/reactos/dll/win32/gdiplus/gdiplus/effect.c
deleted file mode 100644 (file)
index 1422e65..0000000
+++ /dev/null
@@ -1,54 +0,0 @@
-#include <windows.h>
-#include <gdiplusprivate.h>
-#include <debug.h>
-
-/*
- * @unimplemented
- */
-Status __stdcall
-GdipCreateEffect(const GUID guid,
-  CGpEffect **effect)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-Status __stdcall
-GdipDeleteEffect(CGpEffect *effect)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-Status __stdcall
-GdipGetEffectParameterSize(CGpEffect *effect,
-  UINT *size)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-Status __stdcall
-GdipSetEffectParameters(CGpEffect *effect,
-  const VOID *params,
-  const UINT size)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-Status __stdcall
-GdipGetEffectParameters(CGpEffect *effect,
-  UINT *size,
-  VOID *params)
-{
-  return NotImplemented;
-}
diff --git a/reactos/dll/win32/gdiplus/gdiplus/fill.c b/reactos/dll/win32/gdiplus/gdiplus/fill.c
deleted file mode 100644 (file)
index f61b406..0000000
+++ /dev/null
@@ -1,256 +0,0 @@
-#include <windows.h>
-#include <gdiplusprivate.h>
-#include <debug.h>
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipFillRectangle(GpGraphics *graphics,
-  GpBrush *brush,
-  REAL x,
-  REAL y,
-  REAL width,
-  REAL height)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipFillRectangleI(GpGraphics *graphics,
-  GpBrush *brush,
-  INT x,
-  INT y,
-  INT width,
-  INT height)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipFillRectangles(GpGraphics *graphics,
-  GpBrush *brush,
-  GDIPCONST GpRectF *rects,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipFillRectanglesI(GpGraphics *graphics,
-  GpBrush *brush,
-  GDIPCONST GpRect *rects,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipFillPolygon(GpGraphics *graphics,
-  GpBrush *brush,
-  GDIPCONST GpPointF *points,
-  INT count,
-  GpFillMode fillMode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipFillPolygonI(GpGraphics *graphics,
-  GpBrush *brush,
-  GDIPCONST GpPoint *points,
-  INT count,
-  GpFillMode fillMode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipFillPolygon2(GpGraphics *graphics,
-  GpBrush *brush,
-  GDIPCONST GpPointF *points,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipFillPolygon2I(GpGraphics *graphics,
-  GpBrush *brush,
-  GDIPCONST GpPoint *points,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipFillEllipse(GpGraphics *graphics,
-  GpBrush *brush,
-  REAL x,
-  REAL y,
-  REAL width,
-  REAL height)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipFillEllipseI(GpGraphics *graphics,
-  GpBrush *brush,
-  INT x,
-  INT y,
-  INT width,
-  INT height)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipFillPie(GpGraphics *graphics,
-  GpBrush *brush,
-  REAL x,
-  REAL y,
-  REAL width,
-  REAL height,
-  REAL startAngle,
-  REAL sweepAngle)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipFillPieI(GpGraphics *graphics,
-  GpBrush *brush,
-  INT x,
-  INT y,
-  INT width,
-  INT height,
-  REAL startAngle,
-  REAL sweepAngle)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipFillPath(GpGraphics *graphics,
-  GpBrush *brush,
-  GpPath *path)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipFillClosedCurve(GpGraphics *graphics,
-  GpBrush *brush,
-  GDIPCONST GpPointF *points,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipFillClosedCurveI(GpGraphics *graphics,
-  GpBrush *brush,
-  GDIPCONST GpPoint *points,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipFillClosedCurve2I(GpGraphics *graphics,
-  GpBrush *brush,
-  GDIPCONST GpPoint *points,
-  INT count,
-  REAL tension,
-  GpFillMode fillMode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipFillRegion(GpGraphics *graphics,
-  GpBrush *brush,
-  GpRegion *region)
-{
-  return NotImplemented;
-}
-
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateSolidFill(ARGB color,
-  GpSolidFill **brush)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetSolidFillColor(GpSolidFill *brush,
-  ARGB color)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetSolidFillColor(GpSolidFill *brush,
-  ARGB *color)
-{
-  return NotImplemented;
-}
diff --git a/reactos/dll/win32/gdiplus/gdiplus/font.c b/reactos/dll/win32/gdiplus/gdiplus/font.c
deleted file mode 100644 (file)
index c4e4fe6..0000000
+++ /dev/null
@@ -1,369 +0,0 @@
-#include <windows.h>
-#include <gdiplusprivate.h>
-#include <debug.h>
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateFontFromDC(HDC hdc,
-  GpFont **font)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateFontFromLogfontA(HDC hdc,
-  GDIPCONST LOGFONTA *logfont,
-  GpFont **font)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateFontFromLogfontW(HDC hdc,
-  GDIPCONST LOGFONTW *logfont,
-  GpFont **font)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateFont(GDIPCONST GpFontFamily *fontFamily,
-  REAL emSize,
-  INT style,
-  Unit unit,
-  GpFont **font)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCloneFont(GpFont* font,
-  GpFont** cloneFont)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDeleteFont(GpFont* font)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetFamily(GpFont *font,
-  GpFontFamily **family)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetFontStyle(GpFont *font,
-  INT *style)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetFontSize(GpFont *font,
-  REAL *size)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetFontUnit(GpFont *font,
-  Unit *unit)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetFontHeight(GDIPCONST GpFont *font,
-  GDIPCONST GpGraphics *graphics,
-  REAL *height)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetFontHeightGivenDPI(GDIPCONST GpFont *font,
-  REAL dpi,
-  REAL *height)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetLogFontA(GpFont * font,
-  GpGraphics *graphics,
-  LOGFONTA * logfontA)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetLogFontW(GpFont * font,
-  GpGraphics *graphics,
-  LOGFONTW * logfontW)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipNewInstalledFontCollection(GpFontCollection** fontCollection)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipNewPrivateFontCollection(GpFontCollection** fontCollection)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDeletePrivateFontCollection(GpFontCollection** fontCollection)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetFontCollectionFamilyCount(GpFontCollection* fontCollection,
-  INT * numFound)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetFontCollectionFamilyList(GpFontCollection* fontCollection,
-  INT numSought,
-  GpFontFamily* gpfamilies[],
-  INT* numFound)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipPrivateAddFontFile(GpFontCollection* fontCollection,
-  GDIPCONST WCHAR* filename)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipPrivateAddMemoryFont(GpFontCollection* fontCollection,
-  GDIPCONST void* memory,
-  INT length)
-{
-  return NotImplemented;
-}
-
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateFontFamilyFromName(GDIPCONST WCHAR *name,
-  GpFontCollection *fontCollection,
-  GpFontFamily **FontFamily)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDeleteFontFamily(GpFontFamily *FontFamily)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCloneFontFamily(GpFontFamily *FontFamily,
-  GpFontFamily **clonedFontFamily)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetGenericFontFamilySansSerif(GpFontFamily **nativeFamily)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetGenericFontFamilySerif(GpFontFamily **nativeFamily)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetGenericFontFamilyMonospace(GpFontFamily **nativeFamily)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetFamilyName(GDIPCONST GpFontFamily *family,
-  WCHAR name[LF_FACESIZE],
-  LANGID language)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipIsStyleAvailable(GDIPCONST GpFontFamily *family,
-  INT style,
-  BOOL * IsStyleAvailable)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipFontCollectionEnumerable(GpFontCollection* fontCollection,
-  GpGraphics* graphics,
-  INT * numFound)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipFontCollectionEnumerate(GpFontCollection* fontCollection,
-  INT numSought,
-  GpFontFamily* gpfamilies[],
-  INT* numFound,
-  GpGraphics* graphics)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetEmHeight(GDIPCONST GpFontFamily *family,
-  INT style,
-  UINT16 * EmHeight)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetCellAscent(GDIPCONST GpFontFamily *family,
-  INT style,
-  UINT16 * CellAscent)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetCellDescent(GDIPCONST GpFontFamily *family,
-  INT style,
-  UINT16 * CellDescent)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetLineSpacing(GDIPCONST GpFontFamily *family,
-  INT style,
-  UINT16 * LineSpacing)
-{
-  return NotImplemented;
-}
diff --git a/reactos/dll/win32/gdiplus/gdiplus/graphics.c b/reactos/dll/win32/gdiplus/gdiplus/graphics.c
deleted file mode 100644 (file)
index ca98281..0000000
+++ /dev/null
@@ -1,363 +0,0 @@
-#include <windows.h>
-#include <gdiplusprivate.h>
-#include <debug.h>
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipFlush(GpGraphics *graphics,
-  GpFlushIntention intention)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateFromHDC(HDC hdc,
-  GpGraphics **graphics)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateFromHDC2(HDC hdc,
-  HANDLE hDevice,
-  GpGraphics **graphics)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateFromHWND(HWND hwnd,
-  GpGraphics **graphics)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateFromHWNDICM(HWND hwnd,
-  GpGraphics **graphics)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDeleteGraphics(GpGraphics *graphics)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetDC(GpGraphics* graphics,
-  HDC * hdc)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipReleaseDC(GpGraphics* graphics,
-  HDC hdc)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetCompositingMode(GpGraphics *graphics,
-  CompositingMode compositingMode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetCompositingMode(GpGraphics *graphics,
-  CompositingMode *compositingMode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetRenderingOrigin(GpGraphics *graphics,
-  INT x,
-  INT y)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetRenderingOrigin(GpGraphics *graphics,
-  INT *x,
-  INT *y)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetCompositingQuality(GpGraphics *graphics,
-  CompositingQuality compositingQuality)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetCompositingQuality(GpGraphics *graphics,
-  CompositingQuality *compositingQuality)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetSmoothingMode(GpGraphics *graphics,
-  SmoothingMode smoothingMode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetSmoothingMode(GpGraphics *graphics,
-  SmoothingMode *smoothingMode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPixelOffsetMode(GpGraphics* graphics,
-  PixelOffsetMode pixelOffsetMode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPixelOffsetMode(GpGraphics *graphics,
-  PixelOffsetMode *pixelOffsetMode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetTextRenderingHint(GpGraphics *graphics,
-  TextRenderingHint mode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetTextRenderingHint(GpGraphics *graphics,
-  TextRenderingHint *mode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetTextContrast(GpGraphics *graphics,
-  UINT contrast)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetTextContrast(GpGraphics *graphics,
-  UINT * contrast)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetInterpolationMode(GpGraphics *graphics,
-  InterpolationMode interpolationMode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetInterpolationMode(GpGraphics *graphics,
-  InterpolationMode *interpolationMode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPageUnit(GpGraphics *graphics,
-  GpUnit *unit)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPageScale(GpGraphics *graphics,
-  REAL *scale)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPageUnit(GpGraphics *graphics,
-  GpUnit unit)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPageScale(GpGraphics *graphics,
-  REAL scale)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetDpiX(GpGraphics *graphics,
-  REAL* dpi)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetDpiY(GpGraphics *graphics,
-  REAL* dpi)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGraphicsClear(GpGraphics *graphics,
-  ARGB color)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSaveGraphics(GpGraphics *graphics,
-  GraphicsState *state)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipRestoreGraphics(GpGraphics *graphics,
-  GraphicsState state)
-{
-  return NotImplemented;
-}
-
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipTestControl(enum GpTestControlEnum control,
-  void * param)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdiplusNotificationHook(OUT ULONG_PTR *token)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-VOID WINGDIPAPI
-GdiplusNotificationUnhook(ULONG_PTR token)
-{
-}
diff --git a/reactos/dll/win32/gdiplus/gdiplus/image.c b/reactos/dll/win32/gdiplus/gdiplus/image.c
deleted file mode 100644 (file)
index 95af8b1..0000000
+++ /dev/null
@@ -1,865 +0,0 @@
-#include <windows.h>
-#include <gdiplusprivate.h>
-#include <debug.h>
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawImage(GpGraphics *graphics,
-  GpImage *image,
-  REAL x,
-  REAL y)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawImageI(GpGraphics *graphics,
-  GpImage *image,
-  INT x,
-  INT y)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawImageRect(GpGraphics *graphics,
-  GpImage *image,
-  REAL x,
-  REAL y,
-  REAL width,
-  REAL height)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawImageRectI(GpGraphics *graphics,
-  GpImage *image,
-  INT x,
-  INT y,
-  INT width,
-  INT height)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawImagePoints(GpGraphics *graphics,
-  GpImage *image,
-  GDIPCONST GpPointF *dstpoints,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawImagePointsI(GpGraphics *graphics,
-  GpImage *image,
-  GDIPCONST GpPoint *dstpoints,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawImagePointRect(GpGraphics *graphics,
-  GpImage *image,
-  REAL x,
-  REAL y,
-  REAL srcx,
-  REAL srcy,
-  REAL srcwidth,
-  REAL srcheight,
-  GpUnit srcUnit)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawImagePointRectI(GpGraphics *graphics,
-  GpImage *image,
-  INT x,
-  INT y,
-  INT srcx,
-  INT srcy,
-  INT srcwidth,
-  INT srcheight,
-  GpUnit srcUnit)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawImageRectRect(GpGraphics *graphics,
-  GpImage *image,
-  REAL dstx,
-  REAL dsty,
-  REAL dstwidth,
-  REAL dstheight,
-  REAL srcx,
-  REAL srcy,
-  REAL srcwidth,
-  REAL srcheight,
-  GpUnit srcUnit,
-  GDIPCONST GpImageAttributes* imageAttributes,
-  DrawImageAbort callback,
-  VOID * callbackData)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawImageRectRectI(GpGraphics *graphics,
-  GpImage *image,
-  INT dstx,
-  INT dsty,
-  INT dstwidth,
-  INT dstheight,
-  INT srcx,
-  INT srcy,
-  INT srcwidth,
-  INT srcheight,
-  GpUnit srcUnit,
-  GDIPCONST GpImageAttributes* imageAttributes,
-  DrawImageAbort callback,
-  VOID * callbackData)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawImagePointsRect(GpGraphics *graphics,
-  GpImage *image,
-  GDIPCONST GpPointF *points,
-  INT count,
-  REAL srcx,
-  REAL srcy,
-  REAL srcwidth,
-  REAL srcheight,
-  GpUnit srcUnit,
-  GDIPCONST GpImageAttributes* imageAttributes,
-  DrawImageAbort callback,
-  VOID * callbackData)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawImagePointsRectI(GpGraphics *graphics,
-  GpImage *image,
-  GDIPCONST GpPoint *points,
-  INT count,
-  INT srcx,
-  INT srcy,
-  INT srcwidth,
-  INT srcheight,
-  GpUnit srcUnit,
-  GDIPCONST GpImageAttributes* imageAttributes,
-  DrawImageAbort callback,
-  VOID * callbackData)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawImageFX(GpGraphics *graphics,
-  GpImage *image,
-  GpRectF *source,
-  GpMatrix *xForm,
-  CGpEffect *effect,
-  GpImageAttributes *imageAttributes,
-  GpUnit srcUnit)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipLoadImageFromStream(IStream* stream,
-  GpImage **image)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipLoadImageFromFile(GDIPCONST WCHAR* filename,
-  GpImage **image)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipLoadImageFromStreamICM(IStream* stream,
-  GpImage **image)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipLoadImageFromFileICM(GDIPCONST WCHAR* filename,
-  GpImage **image)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCloneImage(GpImage *image,
-  GpImage **cloneImage)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDisposeImage(GpImage *image)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSaveImageToFile(GpImage *image,
-  GDIPCONST WCHAR* filename,
-  GDIPCONST CLSID* clsidEncoder,
-  GDIPCONST EncoderParameters* encoderParams)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSaveImageToStream(GpImage *image,
-  IStream* stream,
-  GDIPCONST CLSID* clsidEncoder,
-  GDIPCONST EncoderParameters* encoderParams)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSaveAdd(GpImage *image,
-  GDIPCONST EncoderParameters* encoderParams)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSaveAddImage(GpImage *image,
-  GpImage* newImage,
-  GDIPCONST EncoderParameters* encoderParams)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetImageGraphicsContext(GpImage *image,
-  GpGraphics **graphics)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetImageBounds(GpImage *image,
-  GpRectF *srcRect,
-  GpUnit *srcUnit)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetImageDimension(GpImage *image,
-  REAL *width,
-  REAL *height)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetImageType(GpImage *image,
-  ImageType *type)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetImageWidth(GpImage *image,
-  UINT *width)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetImageHeight(GpImage *image,
-  UINT *height)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetImageHorizontalResolution(GpImage *image,
-  REAL *resolution)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetImageVerticalResolution(GpImage *image,
-  REAL *resolution)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetImageFlags(GpImage *image,
-  UINT *flags)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetImageRawFormat(GpImage *image,
-  GUID *format)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetImagePixelFormat(GpImage *image,
-  PixelFormat *format)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetImageThumbnail(GpImage *image,
-  UINT thumbWidth,
-  UINT thumbHeight,
-  GpImage **thumbImage,
-  GetThumbnailImageAbort callback,
-  VOID * callbackData)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetEncoderParameterListSize(GpImage *image,
-  GDIPCONST CLSID* clsidEncoder,
-  UINT* size)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetEncoderParameterList(GpImage *image,
-  GDIPCONST CLSID* clsidEncoder,
-  UINT size,
-  EncoderParameters* buffer)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipImageGetFrameDimensionsCount(GpImage* image,
-  UINT* count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipImageGetFrameDimensionsList(GpImage* image,
-  GUID* dimensionIDs,
-  UINT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipImageGetFrameCount(GpImage *image,
-  GDIPCONST GUID* dimensionID,
-  UINT* count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipImageSelectActiveFrame(GpImage *image,
-  GDIPCONST GUID* dimensionID,
-  UINT frameIndex)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipImageRotateFlip(GpImage *image,
-  RotateFlipType rfType)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetImagePalette(GpImage *image,
-  ColorPalette *palette,
-  INT size)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetImagePalette(GpImage *image,
-  GDIPCONST ColorPalette *palette)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetImagePaletteSize(GpImage *image,
-  INT *size)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPropertyCount(GpImage *image,
-  UINT* numOfProperty)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPropertyIdList(GpImage *image,
-  UINT numOfProperty,
-  PROPID* list)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPropertyItemSize(GpImage *image,
-  PROPID propId,
-  UINT* size)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPropertyItem(GpImage *image,
-  PROPID propId,
-  UINT propSize,
-  PropertyItem* buffer)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPropertySize(GpImage *image,
-  UINT* totalBufferSize,
-  UINT* numProperties)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetAllPropertyItems(GpImage *image,
-  UINT totalBufferSize,
-  UINT numProperties,
-  PropertyItem* allItems)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipRemovePropertyItem(GpImage *image,
-  PROPID propId)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPropertyItem(GpImage *image,
-  GDIPCONST PropertyItem* item)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipFindFirstImageItem(GpImage *image,
-  ImageItemData* item)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipFindNextImageItem(GpImage *image,
-  ImageItemData* item)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetImageItemData(GpImage *image,
-  ImageItemData* item)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipImageForceValidation(GpImage *image)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateImageAttributes(GpImageAttributes **imageattr)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCloneImageAttributes(GDIPCONST GpImageAttributes *imageattr,
-  GpImageAttributes **cloneImageattr)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDisposeImageAttributes(GpImageAttributes *imageattr)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetImageAttributesToIdentity(GpImageAttributes *imageattr,
-  ColorAdjustType type)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipResetImageAttributes(GpImageAttributes *imageattr,
-  ColorAdjustType type)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetImageAttributesColorMatrix(GpImageAttributes *imageattr,
-  ColorAdjustType type,
-  BOOL enableFlag,
-  GDIPCONST struct ColorMatrix* colorMatrix,
-  GDIPCONST struct ColorMatrix* grayMatrix,
-  ColorMatrixFlags flags)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetImageAttributesThreshold(GpImageAttributes *imageattr,
-  ColorAdjustType type,
-  BOOL enableFlag,
-  REAL threshold)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetImageAttributesGamma(GpImageAttributes *imageattr,
-  ColorAdjustType type,
-  BOOL enableFlag,
-  REAL gamma)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetImageAttributesNoOp(GpImageAttributes *imageattr,
-  ColorAdjustType type,
-  BOOL enableFlag)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetImageAttributesColorKeys(GpImageAttributes *imageattr,
-  ColorAdjustType type,
-  BOOL enableFlag,
-  ARGB colorLow,
-  ARGB colorHigh)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetImageAttributesOutputChannel(GpImageAttributes *imageattr,
-  ColorAdjustType type,
-  BOOL enableFlag,
-  ColorChannelFlags channelFlags)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetImageAttributesOutputChannelColorProfile(GpImageAttributes *imageattr,
-  ColorAdjustType type,
-  BOOL enableFlag,
-  GDIPCONST WCHAR *colorProfileFilename)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetImageAttributesRemapTable(GpImageAttributes *imageattr,
-  ColorAdjustType type,
-  BOOL enableFlag,
-  UINT mapSize,
-  GDIPCONST ColorMap *map)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetImageAttributesWrapMode(GpImageAttributes *imageAttr,
-  WrapMode wrap,
-  ARGB argb,
-  BOOL clamp)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetImageAttributesICMMode(GpImageAttributes *imageAttr,
-  BOOL on)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetImageAttributesAdjustedPalette(GpImageAttributes *imageAttr,
-  ColorPalette * colorPalette,
-  ColorAdjustType colorAdjustType)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetImageAttributesCachedBackground(GpImageAttributes *imageattr,
-  BOOL enableFlag)
-{
-  return NotImplemented;
-}
diff --git a/reactos/dll/win32/gdiplus/gdiplus/linecap.c b/reactos/dll/win32/gdiplus/gdiplus/linecap.c
deleted file mode 100644 (file)
index 00419a9..0000000
+++ /dev/null
@@ -1,147 +0,0 @@
-#include <windows.h>
-#include <gdiplusprivate.h>
-#include <debug.h>
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateCustomLineCap(GpPath* fillPath,
-  GpPath* strokePath,
-  GpLineCap baseCap,
-  REAL baseInset,
-  GpCustomLineCap **customCap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDeleteCustomLineCap(GpCustomLineCap* customCap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCloneCustomLineCap(GpCustomLineCap* customCap,
-  GpCustomLineCap** clonedCap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetCustomLineCapType(GpCustomLineCap* customCap,
-  enum CustomLineCapType* capType)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetCustomLineCapStrokeCaps(GpCustomLineCap* customCap,
-  GpLineCap startCap,
-  GpLineCap endCap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetCustomLineCapStrokeCaps(GpCustomLineCap* customCap,
-  GpLineCap* startCap,
-  GpLineCap* endCap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetCustomLineCapStrokeJoin(GpCustomLineCap* customCap,
-  GpLineJoin lineJoin)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetCustomLineCapStrokeJoin(GpCustomLineCap* customCap,
-  GpLineJoin* lineJoin)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetCustomLineCapBaseCap(GpCustomLineCap* customCap,
-  GpLineCap baseCap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetCustomLineCapBaseCap(GpCustomLineCap* customCap,
-  GpLineCap* baseCap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetCustomLineCapBaseInset(GpCustomLineCap* customCap,
-  REAL inset)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetCustomLineCapBaseInset(GpCustomLineCap* customCap,
-  REAL* inset)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetCustomLineCapWidthScale(GpCustomLineCap* customCap,
-  REAL widthScale)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetCustomLineCapWidthScale(GpCustomLineCap* customCap,
-  REAL* widthScale)
-{
-  return NotImplemented;
-}
diff --git a/reactos/dll/win32/gdiplus/gdiplus/linegradient.c b/reactos/dll/win32/gdiplus/gdiplus/linegradient.c
deleted file mode 100644 (file)
index 5b51377..0000000
+++ /dev/null
@@ -1,335 +0,0 @@
-#include <windows.h>
-#include <gdiplusprivate.h>
-#include <debug.h>
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateLineBrush(GDIPCONST GpPointF* point1,
-  GDIPCONST GpPointF* point2,
-  ARGB color1,
-  ARGB color2,
-  GpWrapMode wrapMode,
-  GpLineGradient **lineGradient)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateLineBrushI(GDIPCONST GpPoint* point1,
-  GDIPCONST GpPoint* point2,
-  ARGB color1,
-  ARGB color2,
-  GpWrapMode wrapMode,
-  GpLineGradient **lineGradient)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateLineBrushFromRect(GDIPCONST GpRectF* rect,
-  ARGB color1,
-  ARGB color2,
-  LinearGradientMode mode,
-  GpWrapMode wrapMode,
-  GpLineGradient **lineGradient)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateLineBrushFromRectI(GDIPCONST GpRect* rect,
-  ARGB color1,
-  ARGB color2,
-  LinearGradientMode mode,
-  GpWrapMode wrapMode,
-  GpLineGradient **lineGradient)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateLineBrushFromRectWithAngle(GDIPCONST GpRectF* rect,
-  ARGB color1,
-  ARGB color2,
-  REAL angle,
-  BOOL isAngleScalable,
-  GpWrapMode wrapMode,
-  GpLineGradient **lineGradient)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateLineBrushFromRectWithAngleI(GDIPCONST GpRect* rect,
-  ARGB color1,
-  ARGB color2,
-  REAL angle,
-  BOOL isAngleScalable,
-  GpWrapMode wrapMode,
-  GpLineGradient **lineGradient)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetLineColors(GpLineGradient *brush,
-  ARGB color1,
-  ARGB color2)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetLineColors(GpLineGradient *brush,
-  ARGB* colors)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetLineRect(GpLineGradient *brush,
-  GpRectF *rect)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetLineRectI(GpLineGradient *brush,
-  GpRect *rect)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetLineGammaCorrection(GpLineGradient *brush,
-  BOOL useGammaCorrection)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetLineGammaCorrection(GpLineGradient *brush,
-  BOOL *useGammaCorrection)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetLineBlendCount(GpLineGradient *brush,
-  INT *count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetLineBlend(GpLineGradient *brush,
-  REAL *blend,
-  REAL* positions,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetLineBlend(GpLineGradient *brush,
-  GDIPCONST REAL *blend,
-  GDIPCONST REAL* positions,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetLinePresetBlendCount(GpLineGradient *brush,
-  INT *count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetLinePresetBlend(GpLineGradient *brush,
-  ARGB *blend,
-  REAL* positions,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetLinePresetBlend(GpLineGradient *brush,
-  GDIPCONST ARGB *blend,
-  GDIPCONST REAL* positions,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetLineSigmaBlend(GpLineGradient *brush,
-  REAL focus,
-  REAL scale)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetLineLinearBlend(GpLineGradient *brush,
-  REAL focus,
-  REAL scale)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetLineWrapMode(GpLineGradient *brush,
-  GpWrapMode wrapmode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetLineWrapMode(GpLineGradient *brush,
-  GpWrapMode *wrapmode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetLineTransform(GpLineGradient *brush,
-  GpMatrix *matrix)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetLineTransform(GpLineGradient *brush,
-  GDIPCONST GpMatrix *matrix)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipResetLineTransform(GpLineGradient* brush)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipMultiplyLineTransform(GpLineGradient* brush,
-  GDIPCONST GpMatrix *matrix,
-  GpMatrixOrder order)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipTranslateLineTransform(GpLineGradient* brush,
-  REAL dx,
-  REAL dy,
-  GpMatrixOrder order)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipScaleLineTransform(GpLineGradient* brush,
-  REAL sx,
-  REAL sy,
-  GpMatrixOrder order)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipRotateLineTransform(GpLineGradient* brush,
-  REAL angle,
-  GpMatrixOrder order)
-{
-  return NotImplemented;
-}
diff --git a/reactos/dll/win32/gdiplus/gdiplus/matrix.c b/reactos/dll/win32/gdiplus/gdiplus/matrix.c
deleted file mode 100644 (file)
index ded74b1..0000000
+++ /dev/null
@@ -1,235 +0,0 @@
-#include <windows.h>
-#include <gdiplusprivate.h>
-#include <debug.h>
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateMatrix(GpMatrix **matrix)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateMatrix2(REAL m11,
-  REAL m12,
-  REAL m21,
-  REAL m22,
-  REAL dx,
-  REAL dy,
-  GpMatrix **matrix)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateMatrix3(GDIPCONST GpRectF *rect,
-  GDIPCONST GpPointF *dstplg,
-  GpMatrix **matrix)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateMatrix3I(GDIPCONST GpRect *rect,
-  GDIPCONST GpPoint *dstplg,
-  GpMatrix **matrix)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCloneMatrix(GpMatrix *matrix,
-  GpMatrix **cloneMatrix)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDeleteMatrix(GpMatrix *matrix)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetMatrixElements(GpMatrix *matrix,
-  REAL m11,
-  REAL m12,
-  REAL m21,
-  REAL m22,
-  REAL dx,
-  REAL dy)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipMultiplyMatrix(GpMatrix *matrix,
-  GpMatrix* matrix2,
-  GpMatrixOrder order)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipTranslateMatrix(GpMatrix *matrix,
-  REAL offsetX,
-  REAL offsetY,
-  GpMatrixOrder order)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipScaleMatrix(GpMatrix *matrix,
-  REAL scaleX,
-  REAL scaleY,
-  GpMatrixOrder order)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipRotateMatrix(GpMatrix *matrix,
-  REAL angle,
-  GpMatrixOrder order)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipShearMatrix(GpMatrix *matrix,
-  REAL shearX,
-  REAL shearY,
-  GpMatrixOrder order)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipInvertMatrix(GpMatrix *matrix)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipTransformMatrixPoints(GpMatrix *matrix,
-  GpPointF *pts,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipTransformMatrixPointsI(GpMatrix *matrix,
-  GpPoint *pts,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipVectorTransformMatrixPoints(GpMatrix *matrix,
-  GpPointF *pts,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipVectorTransformMatrixPointsI(GpMatrix *matrix,
-  GpPoint *pts,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetMatrixElements(GDIPCONST GpMatrix *matrix,
-  REAL *matrixOut)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipIsMatrixInvertible(GDIPCONST GpMatrix *matrix,
-  BOOL *result)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipIsMatrixIdentity(GDIPCONST GpMatrix *matrix,
-  BOOL *result)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipIsMatrixEqual(GDIPCONST GpMatrix *matrix,
-  GDIPCONST GpMatrix *matrix2,
-  BOOL *result)
-{
-  return NotImplemented;
-}
diff --git a/reactos/dll/win32/gdiplus/gdiplus/memory.c b/reactos/dll/win32/gdiplus/gdiplus/memory.c
deleted file mode 100644 (file)
index 6fb54d9..0000000
+++ /dev/null
@@ -1,20 +0,0 @@
-#include <windows.h>
-#include <gdiplusprivate.h>
-#include <debug.h>
-
-/*
- * @unimplemented
- */
-void* WINGDIPAPI
-GdipAlloc(size_t size)
-{
-  return NULL;
-}
-
-/*
- * @unimplemented
- */
-void WINGDIPAPI
-GdipFree(void* ptr)
-{
-}
diff --git a/reactos/dll/win32/gdiplus/gdiplus/metafile.c b/reactos/dll/win32/gdiplus/gdiplus/metafile.c
deleted file mode 100644 (file)
index cccd1de..0000000
+++ /dev/null
@@ -1,491 +0,0 @@
-#include <windows.h>
-#include <gdiplusprivate.h>
-#include <debug.h>
-
-/*
- * @unimplemented
- */
-UINT WINGDIPAPI
-GdipEmfToWmfBits(HENHMETAFILE hemf,
-  UINT cbData16,
-  LPBYTE pData16,
-  INT iMapMode,
-  INT eFlags)
-{
-  return 0;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipEnumerateMetafileDestPoint(GpGraphics * graphics,
-  GDIPCONST GpMetafile * metafile,
-  GDIPCONST PointF * destPoint,
-  EnumerateMetafileProc callback,
-  VOID * callbackData,
-  GDIPCONST GpImageAttributes * imageAttributes)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipEnumerateMetafileDestPointI(GpGraphics * graphics,
-  GDIPCONST GpMetafile * metafile,
-  GDIPCONST Point * destPoint,
-  EnumerateMetafileProc callback,
-  VOID * callbackData,
-  GDIPCONST GpImageAttributes * imageAttributes)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipEnumerateMetafileDestRect(GpGraphics * graphics,
-  GDIPCONST GpMetafile * metafile,
-  GDIPCONST RectF * destRect,
-  EnumerateMetafileProc callback,
-  VOID * callbackData,
-  GDIPCONST GpImageAttributes * imageAttributes)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipEnumerateMetafileDestRectI(GpGraphics * graphics,
-  GDIPCONST GpMetafile * metafile,
-  GDIPCONST Rect * destRect,
-  EnumerateMetafileProc callback,
-  VOID * callbackData,
-  GDIPCONST GpImageAttributes * imageAttributes)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipEnumerateMetafileDestPoints(GpGraphics * graphics,
-  GDIPCONST GpMetafile * metafile,
-  GDIPCONST PointF * destPoints,
-  INT count,
-  EnumerateMetafileProc callback,
-  VOID * callbackData,
-  GDIPCONST GpImageAttributes * imageAttributes)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipEnumerateMetafileDestPointsI(GpGraphics * graphics,
-  GDIPCONST GpMetafile * metafile,
-  GDIPCONST Point * destPoints,
-  INT count,
-  EnumerateMetafileProc callback,
-  VOID * callbackData,
-  GDIPCONST GpImageAttributes * imageAttributes)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipEnumerateMetafileSrcRectDestPoint(GpGraphics * graphics,
-  GDIPCONST GpMetafile * metafile,
-  GDIPCONST PointF * destPoint,
-  GDIPCONST RectF * srcRect,
-  Unit srcUnit,
-  EnumerateMetafileProc callback,
-  VOID * callbackData,
-  GDIPCONST GpImageAttributes * imageAttributes)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipEnumerateMetafileSrcRectDestPointI(GpGraphics * graphics,
-  GDIPCONST GpMetafile * metafile,
-  GDIPCONST Point * destPoint,
-  GDIPCONST Rect * srcRect,
-  Unit srcUnit,
-  EnumerateMetafileProc callback,
-  VOID * callbackData,
-  GDIPCONST GpImageAttributes * imageAttributes)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipEnumerateMetafileSrcRectDestRect(GpGraphics * graphics,
-  GDIPCONST GpMetafile * metafile,
-  GDIPCONST RectF * destRect,
-  GDIPCONST RectF * srcRect,
-  Unit srcUnit,
-  EnumerateMetafileProc callback,
-  VOID * callbackData,
-  GDIPCONST GpImageAttributes * imageAttributes)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipEnumerateMetafileSrcRectDestRectI(GpGraphics * graphics,
-  GDIPCONST GpMetafile * metafile,
-  GDIPCONST Rect * destRect,
-  GDIPCONST Rect * srcRect,
-  Unit srcUnit,
-  EnumerateMetafileProc callback,
-  VOID * callbackData,
-  GDIPCONST GpImageAttributes * imageAttributes)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipEnumerateMetafileSrcRectDestPoints(GpGraphics * graphics,
-  GDIPCONST GpMetafile * metafile,
-  GDIPCONST PointF * destPoints,
-  INT count,
-  GDIPCONST RectF * srcRect,
-  Unit srcUnit,
-  EnumerateMetafileProc callback,
-  VOID * callbackData,
-  GDIPCONST GpImageAttributes * imageAttributes)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipEnumerateMetafileSrcRectDestPointsI(GpGraphics * graphics,
-  GDIPCONST GpMetafile * metafile,
-  GDIPCONST Point * destPoints,
-  INT count,
-  GDIPCONST Rect * srcRect,
-  Unit srcUnit,
-  EnumerateMetafileProc callback,
-  VOID * callbackData,
-  GDIPCONST GpImageAttributes * imageAttributes)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipPlayMetafileRecord(GDIPCONST GpMetafile * metafile,
-  EmfPlusRecordType recordType,
-  UINT flags,
-  UINT dataSize,
-  GDIPCONST BYTE * data)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetMetafileHeaderFromEmf(HENHMETAFILE hEmf,
-  MetafileHeader * header)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetMetafileHeaderFromFile(GDIPCONST WCHAR* filename,
-  MetafileHeader * header)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetMetafileHeaderFromStream(IStream * stream,
-  MetafileHeader * header)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetMetafileHeaderFromMetafile(GpMetafile * metafile,
-  MetafileHeader * header)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetHemfFromMetafile(GpMetafile * metafile,
-  HENHMETAFILE * hEmf)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateStreamOnFile(GDIPCONST WCHAR * filename,
-  UINT access,
-  IStream **stream)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateMetafileFromWmf(HMETAFILE hWmf,
-  BOOL deleteWmf,
-  GDIPCONST WmfPlaceableFileHeader * wmfPlaceableFileHeader,
-  GpMetafile **metafile)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateMetafileFromEmf(HENHMETAFILE hEmf,
-  BOOL deleteEmf,
-  GpMetafile **metafile)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateMetafileFromFile(GDIPCONST WCHAR* file,
-  GpMetafile **metafile)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateMetafileFromWmfFile(GDIPCONST WCHAR* file,
-  GDIPCONST WmfPlaceableFileHeader * wmfPlaceableFileHeader,
-  GpMetafile **metafile)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateMetafileFromStream(IStream * stream,
-  GpMetafile **metafile)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipRecordMetafile(HDC referenceHdc,
-  EmfType type,
-  GDIPCONST GpRectF * frameRect,
-  MetafileFrameUnit frameUnit,
-  GDIPCONST WCHAR * description,
-  GpMetafile ** metafile)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipRecordMetafileI(HDC referenceHdc,
-  EmfType type,
-  GDIPCONST GpRect * frameRect,
-  MetafileFrameUnit frameUnit,
-  GDIPCONST WCHAR * description,
-  GpMetafile ** metafile)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipRecordMetafileFileName(GDIPCONST WCHAR* fileName,
-  HDC referenceHdc,
-  EmfType type,
-  GDIPCONST GpRectF * frameRect,
-  MetafileFrameUnit frameUnit,
-  GDIPCONST WCHAR * description,
-  GpMetafile ** metafile)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipRecordMetafileFileNameI(GDIPCONST WCHAR* fileName,
-  HDC referenceHdc,
-  EmfType type,
-  GDIPCONST GpRect * frameRect,
-  MetafileFrameUnit frameUnit,
-  GDIPCONST WCHAR * description,
-  GpMetafile ** metafile)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipRecordMetafileStream(IStream * stream,
-  HDC referenceHdc,
-  EmfType type,
-  GDIPCONST GpRectF * frameRect,
-  MetafileFrameUnit frameUnit,
-  GDIPCONST WCHAR * description,
-  GpMetafile ** metafile)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipRecordMetafileStreamI(IStream * stream,
-  HDC referenceHdc,
-  EmfType type,
-  GDIPCONST GpRect * frameRect,
-  MetafileFrameUnit frameUnit,
-  GDIPCONST WCHAR * description,
-  GpMetafile ** metafile)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetMetafileDownLevelRasterizationLimit(GpMetafile * metafile,
-  UINT metafileRasterizationLimitDpi)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetMetafileDownLevelRasterizationLimit(GDIPCONST GpMetafile * metafile,
-  UINT * metafileRasterizationLimitDpi)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipComment(GpGraphics* graphics,
-  UINT sizeData,
-  GDIPCONST BYTE * data)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipConvertToEmfPlus(const GpGraphics* refGraphics,
-  GpMetafile* metafile,
-  BOOL* conversionSuccess,
-  EmfType emfType,
-  const WCHAR* description,
-  GpMetafile** out_metafile)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipConvertToEmfPlusToFile(const GpGraphics* refGraphics,
-  GpMetafile* metafile,
-  BOOL* conversionSuccess,
-  const WCHAR* filename,
-  EmfType emfType,
-  const WCHAR* description,
-  GpMetafile** out_metafile)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipConvertToEmfPlusToStream(const GpGraphics* refGraphics,
-  GpMetafile* metafile,
-  BOOL* conversionSuccess,
-  IStream* stream,
-  EmfType emfType,
-  const WCHAR* description,
-  GpMetafile** out_metafile)
-{
-  return NotImplemented;
-}
diff --git a/reactos/dll/win32/gdiplus/gdiplus/palette.c b/reactos/dll/win32/gdiplus/gdiplus/palette.c
deleted file mode 100644 (file)
index bc0cb60..0000000
+++ /dev/null
@@ -1,22 +0,0 @@
-#include <windows.h>
-#include <gdiplusprivate.h>
-#include <debug.h>
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetNearestColor(GpGraphics *graphics,
-  ARGB* argb)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-HPALETTE WINGDIPAPI
-GdipCreateHalftonePalette()
-{
-  return NULL;
-}
diff --git a/reactos/dll/win32/gdiplus/gdiplus/path.c b/reactos/dll/win32/gdiplus/gdiplus/path.c
deleted file mode 100644 (file)
index 1201763..0000000
+++ /dev/null
@@ -1,769 +0,0 @@
-#include <windows.h>
-#include <gdiplusprivate.h>
-#include <debug.h>
-
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreatePath( GpFillMode brushMode,GpPath **path)
-{
-    return NotImplemented;
-}
-
-
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreatePath2(GDIPCONST GpPointF* points,
-  GDIPCONST BYTE* types,
-  INT count,
-  GpFillMode fillMode,
-  GpPath **path)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreatePath2I(GDIPCONST GpPoint* points,
-  GDIPCONST BYTE* types,
-  INT count,
-  GpFillMode fillMode,
-  GpPath **path)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipClonePath(GpPath* path,
-  GpPath **clonePath)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDeletePath(GpPath* path)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipResetPath(GpPath* path)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPointCount(GpPath* path,
-  INT* count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPathTypes(GpPath* path,
-  BYTE* types,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPathPoints(GpPath* path,
-  GpPointF* points,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPathPointsI(GpPath* path,
-  GpPoint* points,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPathFillMode(GpPath *path,
-  GpFillMode *fillmode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPathFillMode(GpPath *path,
-  GpFillMode fillmode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPathData(GpPath *path,
-  GpPathData* pathData)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipStartPathFigure(GpPath *path)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipClosePathFigure(GpPath *path)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipClosePathFigures(GpPath *path)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPathMarker(GpPath* path)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipClearPathMarkers(GpPath* path)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipReversePath(GpPath* path)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPathLastPoint(GpPath* path,
-  GpPointF* lastPoint)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathLine(GpPath *path,
-  REAL x1,
-  REAL y1,
-  REAL x2,
-  REAL y2)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathLine2(GpPath *path,
-  GDIPCONST GpPointF *points,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathArc(GpPath *path,
-  REAL x,
-  REAL y,
-  REAL width,
-  REAL height,
-  REAL startAngle,
-  REAL sweepAngle)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathBezier(GpPath *path,
-  REAL x1,
-  REAL y1,
-  REAL x2,
-  REAL y2,
-  REAL x3,
-  REAL y3,
-  REAL x4,
-  REAL y4)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathBeziers(GpPath *path,
-  GDIPCONST GpPointF *points,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathCurve(GpPath *path,
-  GDIPCONST GpPointF *points,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathCurve2(GpPath *path,
-  GDIPCONST GpPointF *points,
-  INT count,
-  REAL tension)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathCurve3(GpPath *path,
-  GDIPCONST GpPointF *points,
-  INT count,
-  INT offset,
-  INT numberOfSegments,
-  REAL tension)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathClosedCurve(GpPath *path,
-  GDIPCONST GpPointF *points,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathClosedCurve2(GpPath *path,
-  GDIPCONST GpPointF *points,
-  INT count,
-  REAL tension)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathRectangle(GpPath *path,
-  REAL x,
-  REAL y,
-  REAL width,
-  REAL height)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathRectangles(GpPath *path,
-  GDIPCONST GpRectF *rects,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathEllipse(GpPath *path,
-  REAL x,
-  REAL y,
-  REAL width,
-  REAL height)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathPie(GpPath *path,
-  REAL x,
-  REAL y,
-  REAL width,
-  REAL height,
-  REAL startAngle,
-  REAL sweepAngle)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathPolygon(GpPath *path,
-  GDIPCONST GpPointF *points,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathPath(GpPath *path,
-  GDIPCONST GpPath* addingPath,
-  BOOL connect)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathString(GpPath *path,
-  GDIPCONST WCHAR *string,
-  INT length,
-  GDIPCONST GpFontFamily *family,
-  INT style,
-  REAL emSize,
-  GDIPCONST RectF *layoutRect,
-  GDIPCONST GpStringFormat *format)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathStringI(GpPath *path,
-  GDIPCONST WCHAR *string,
-  INT length,
-  GDIPCONST GpFontFamily *family,
-  INT style,
-  REAL emSize,
-  GDIPCONST Rect *layoutRect,
-  GDIPCONST GpStringFormat *format)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathLineI(GpPath *path,
-  INT x1,
-  INT y1,
-  INT x2,
-  INT y2)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathLine2I(GpPath *path,
-  GDIPCONST GpPoint *points,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathArcI(GpPath *path,
-  INT x,
-  INT y,
-  INT width,
-  INT height,
-  REAL startAngle,
-  REAL sweepAngle)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathBezierI(GpPath *path,
-  INT x1,
-  INT y1,
-  INT x2,
-  INT y2,
-  INT x3,
-  INT y3,
-  INT x4,
-  INT y4)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathBeziersI(GpPath *path,
-  GDIPCONST GpPoint *points,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathCurveI(GpPath *path,
-  GDIPCONST GpPoint *points,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathCurve2I(GpPath *path,
-  GDIPCONST GpPoint *points,
-  INT count,
-  REAL tension)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathCurve3I(GpPath *path,
-  GDIPCONST GpPoint *points,
-  INT count,
-  INT offset,
-  INT numberOfSegments,
-  REAL tension)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathClosedCurveI(GpPath *path,
-  GDIPCONST GpPoint *points,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathClosedCurve2I(GpPath *path,
-  GDIPCONST GpPoint *points,
-  INT count,
-  REAL tension)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathRectangleI(GpPath *path,
-  INT x,
-  INT y,
-  INT width,
-  INT height)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathRectanglesI(GpPath *path,
-  GDIPCONST GpRect *rects,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathEllipseI(GpPath *path,
-  INT x,
-  INT y,
-  INT width,
-  INT height)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathPieI(GpPath *path,
-  INT x,
-  INT y,
-  INT width,
-  INT height,
-  REAL startAngle,
-  REAL sweepAngle)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipAddPathPolygonI(GpPath *path,
-  GDIPCONST GpPoint *points,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipFlattenPath(GpPath *path,
-  GpMatrix* matrix,
-  REAL flatness)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipWindingModeOutline(GpPath *path,
-  GpMatrix *matrix,
-  REAL flatness)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipWidenPath(GpPath *nativePath,
-  GpPen *pen,
-  GpMatrix *matrix,
-  REAL flatness)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipWarpPath(GpPath *path,
-  GpMatrix* matrix,
-  GDIPCONST GpPointF *points,
-  INT count,
-  REAL srcx,
-  REAL srcy,
-  REAL srcwidth,
-  REAL srcheight,
-  WarpMode warpMode,
-  REAL flatness)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipTransformPath(GpPath* path,
-  GpMatrix* matrix)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPathWorldBounds(GpPath* path,
-  GpRectF* bounds,
-  GDIPCONST GpMatrix *matrix,
-  GDIPCONST GpPen *pen)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPathWorldBoundsI(GpPath* path,
-  GpRect* bounds,
-  GDIPCONST GpMatrix *matrix,
-  GDIPCONST GpPen *pen)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipIsVisiblePathPoint(GpPath* path,
-  REAL x,
-  REAL y,
-  GpGraphics *graphics,
-  BOOL *result)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipIsVisiblePathPointI(GpPath* path,
-  INT x,
-  INT y,
-  GpGraphics *graphics,
-  BOOL *result)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipIsOutlineVisiblePathPoint(GpPath* path,
-  REAL x,
-  REAL y,
-  GpPen *pen,
-  GpGraphics *graphics,
-  BOOL *result)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipIsOutlineVisiblePathPointI(GpPath* path,
-  INT x,
-  INT y,
-  GpPen *pen,
-  GpGraphics *graphics,
-  BOOL *result)
-{
-  return NotImplemented;
-}
diff --git a/reactos/dll/win32/gdiplus/gdiplus/pathgradient.c b/reactos/dll/win32/gdiplus/gdiplus/pathgradient.c
deleted file mode 100644 (file)
index 22f87c9..0000000
+++ /dev/null
@@ -1,395 +0,0 @@
-#include <windows.h>
-#include <gdiplusprivate.h>
-#include <debug.h>
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreatePathGradient(GDIPCONST GpPointF* points,
-  INT count,
-  GpWrapMode wrapMode,
-  GpPathGradient **polyGradient)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreatePathGradientI(GDIPCONST GpPoint* points,
-  INT count,
-  GpWrapMode wrapMode,
-  GpPathGradient **polyGradient)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreatePathGradientFromPath(GDIPCONST GpPath* path,
-  GpPathGradient **polyGradient)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPathGradientCenterColor(GpPathGradient *brush,
-  ARGB* colors)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPathGradientCenterColor(GpPathGradient *brush,
-  ARGB colors)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPathGradientSurroundColorsWithCount(GpPathGradient *brush,
-  ARGB* color,
-  INT* count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPathGradientSurroundColorsWithCount(GpPathGradient *brush,
-  GDIPCONST ARGB* color,
-  INT* count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPathGradientPath(GpPathGradient *brush,
-  GpPath *path)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPathGradientPath(GpPathGradient *brush,
-  GDIPCONST GpPath *path)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPathGradientCenterPoint(GpPathGradient *brush,
-  GpPointF* points)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPathGradientCenterPointI(GpPathGradient *brush,
-  GpPoint* points)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPathGradientCenterPoint(GpPathGradient *brush,
-  GDIPCONST GpPointF* points)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPathGradientCenterPointI(GpPathGradient *brush,
-  GDIPCONST GpPoint* points)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPathGradientRect(GpPathGradient *brush,
-  GpRectF *rect)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPathGradientRectI(GpPathGradient *brush,
-  GpRect *rect)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPathGradientPointCount(GpPathGradient *brush,
-  INT* count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPathGradientSurroundColorCount(GpPathGradient *brush,
-  INT* count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPathGradientGammaCorrection(GpPathGradient *brush,
-  BOOL useGammaCorrection)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPathGradientGammaCorrection(GpPathGradient *brush,
-  BOOL *useGammaCorrection)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPathGradientBlendCount(GpPathGradient *brush,
-  INT *count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPathGradientBlend(GpPathGradient *brush,
-  REAL *blend,
-  REAL *positions,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPathGradientBlend(GpPathGradient *brush,
-  GDIPCONST REAL *blend,
-  GDIPCONST REAL *positions,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPathGradientPresetBlendCount(GpPathGradient *brush,
-  INT *count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPathGradientPresetBlend(GpPathGradient *brush,
-  ARGB *blend,
-  REAL* positions,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPathGradientPresetBlend(GpPathGradient *brush,
-  GDIPCONST ARGB *blend,
-  GDIPCONST REAL* positions,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPathGradientSigmaBlend(GpPathGradient *brush,
-  REAL focus,
-  REAL scale)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPathGradientWrapMode(GpPathGradient *brush,
-  GpWrapMode *wrapmode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPathGradientWrapMode(GpPathGradient *brush,
-  GpWrapMode wrapmode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPathGradientTransform(GpPathGradient *brush,
-  GpMatrix *matrix)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPathGradientTransform(GpPathGradient *brush,
-  GpMatrix *matrix)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipResetPathGradientTransform(GpPathGradient* brush)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipMultiplyPathGradientTransform(GpPathGradient* brush,
-  GDIPCONST GpMatrix *matrix,
-  GpMatrixOrder order)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipTranslatePathGradientTransform(GpPathGradient* brush,
-  REAL dx,
-  REAL dy,
-  GpMatrixOrder order)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipScalePathGradientTransform(GpPathGradient* brush,
-  REAL sx,
-  REAL sy,
-  GpMatrixOrder order)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipRotatePathGradientTransform(GpPathGradient* brush,
-  REAL angle,
-  GpMatrixOrder order)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPathGradientFocusScales(GpPathGradient *brush,
-  REAL* xScale,
-  REAL* yScale)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPathGradientFocusScales(GpPathGradient *brush,
-  REAL xScale,
-  REAL yScale)
-{
-  return NotImplemented;
-}
diff --git a/reactos/dll/win32/gdiplus/gdiplus/pathiterator.c b/reactos/dll/win32/gdiplus/gdiplus/pathiterator.c
deleted file mode 100644 (file)
index 6a6db71..0000000
+++ /dev/null
@@ -1,159 +0,0 @@
-#include <windows.h>
-#include <gdiplusprivate.h>
-#include <debug.h>
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreatePathIter(GpPathIterator **iterator,
-  GpPath* path)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDeletePathIter(GpPathIterator *iterator)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipPathIterNextSubpath(GpPathIterator* iterator,
-  INT *resultCount,
-  INT* startIndex,
-  INT* endIndex,
-  BOOL* isClosed)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipPathIterNextSubpathPath(GpPathIterator* iterator,
-  INT* resultCount,
-  GpPath* path,
-  BOOL* isClosed)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipPathIterNextPathType(GpPathIterator* iterator,
-  INT* resultCount,
-  BYTE* pathType,
-  INT* startIndex,
-  INT* endIndex)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipPathIterNextMarker(GpPathIterator* iterator,
-  INT *resultCount,
-  INT* startIndex,
-  INT* endIndex)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipPathIterNextMarkerPath(GpPathIterator* iterator,
-  INT* resultCount,
-  GpPath* path)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipPathIterGetCount(GpPathIterator* iterator,
-  INT* count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipPathIterGetSubpathCount(GpPathIterator* iterator,
-  INT* count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipPathIterIsValid(GpPathIterator* iterator,
-  BOOL* valid)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipPathIterHasCurve(GpPathIterator* iterator,
-  BOOL* hasCurve)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipPathIterRewind(GpPathIterator* iterator)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipPathIterEnumerate(GpPathIterator* iterator,
-  INT* resultCount,
-  GpPointF *points,
-  BYTE *types,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipPathIterCopyData(GpPathIterator* iterator,
-  INT* resultCount,
-  GpPointF* points,
-  BYTE* types,
-  INT startIndex,
-  INT endIndex)
-{
-  return NotImplemented;
-}
diff --git a/reactos/dll/win32/gdiplus/gdiplus/pen.c b/reactos/dll/win32/gdiplus/gdiplus/pen.c
deleted file mode 100644 (file)
index 16347e5..0000000
+++ /dev/null
@@ -1,487 +0,0 @@
-#include <windows.h>
-#include <gdiplusprivate.h>
-#include <debug.h>
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreatePen1(ARGB color,
-  REAL width,
-  GpUnit unit,
-  GpPen **pen)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreatePen2(GpBrush *brush,
-  REAL width,
-  GpUnit unit,
-  GpPen **pen)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipClonePen(GpPen *pen,
-  GpPen **clonepen)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDeletePen(GpPen *pen)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPenWidth(GpPen *pen,
-  REAL width)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPenWidth(GpPen *pen,
-  REAL *width)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPenUnit(GpPen *pen,
-  GpUnit unit)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPenUnit(GpPen *pen,
-  GpUnit *unit)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPenLineCap197819(GpPen *pen,
-  GpLineCap startCap,
-  GpLineCap endCap,
-  GpDashCap dashCap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPenStartCap(GpPen *pen,
-  GpLineCap startCap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPenEndCap(GpPen *pen,
-  GpLineCap endCap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPenDashCap197819(GpPen *pen,
-  GpDashCap dashCap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPenStartCap(GpPen *pen,
-  GpLineCap *startCap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPenEndCap(GpPen *pen,
-  GpLineCap *endCap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPenDashCap197819(GpPen *pen,
-  GpDashCap *dashCap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPenLineJoin(GpPen *pen,
-  GpLineJoin lineJoin)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPenLineJoin(GpPen *pen,
-  GpLineJoin *lineJoin)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPenCustomStartCap(GpPen *pen,
-  GpCustomLineCap* customCap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPenCustomStartCap(GpPen *pen,
-  GpCustomLineCap** customCap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPenCustomEndCap(GpPen *pen,
-  GpCustomLineCap* customCap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPenCustomEndCap(GpPen *pen,
-  GpCustomLineCap** customCap)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPenMiterLimit(GpPen *pen,
-  REAL miterLimit)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPenMiterLimit(GpPen *pen,
-  REAL *miterLimit)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPenMode(GpPen *pen,
-  GpPenAlignment penMode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPenMode(GpPen *pen,
-  GpPenAlignment *penMode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPenTransform(GpPen *pen,
-  GpMatrix *matrix)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPenTransform(GpPen *pen,
-  GpMatrix *matrix)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipResetPenTransform(GpPen *pen)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipMultiplyPenTransform(GpPen *pen,
-  GDIPCONST GpMatrix *matrix,
-  GpMatrixOrder order)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipTranslatePenTransform(GpPen *pen,
-  REAL dx,
-  REAL dy,
-  GpMatrixOrder order)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipScalePenTransform(GpPen *pen,
-  REAL sx,
-  REAL sy,
-  GpMatrixOrder order)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipRotatePenTransform(GpPen *pen,
-  REAL angle,
-  GpMatrixOrder order)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPenColor(GpPen *pen,
-  ARGB argb)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPenColor(GpPen *pen,
-  ARGB *argb)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPenBrushFill(GpPen *pen,
-  GpBrush *brush)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPenBrushFill(GpPen *pen,
-  GpBrush **brush)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPenFillType(GpPen *pen,
-  GpPenType* type)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPenDashStyle(GpPen *pen,
-  GpDashStyle *dashstyle)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPenDashStyle(GpPen *pen,
-  GpDashStyle dashstyle)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPenDashOffset(GpPen *pen,
-  REAL *offset)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPenDashOffset(GpPen *pen,
-  REAL offset)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPenDashCount(GpPen *pen,
-  INT *count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPenDashArray(GpPen *pen,
-  GDIPCONST REAL *dash,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPenDashArray(GpPen *pen,
-  REAL *dash,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPenCompoundCount(GpPen *pen,
-  INT *count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetPenCompoundArray(GpPen *pen,
-  GDIPCONST REAL *dash,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetPenCompoundArray(GpPen *pen,
-  REAL *dash,
-  INT count)
-{
-  return NotImplemented;
-}
diff --git a/reactos/dll/win32/gdiplus/gdiplus/region.c b/reactos/dll/win32/gdiplus/gdiplus/region.c
deleted file mode 100644 (file)
index 4430320..0000000
+++ /dev/null
@@ -1,356 +0,0 @@
-#include <windows.h>
-#include <gdiplusprivate.h>
-#include <debug.h>
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateRegion(GpRegion **region)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateRegionRect(GDIPCONST GpRectF *rect,
-  GpRegion **region)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateRegionRectI(GDIPCONST GpRect *rect,
-  GpRegion **region)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateRegionPath(GpPath *path,
-  GpRegion **region)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateRegionRgnData(GDIPCONST BYTE *regionData,
-  INT size,
-  GpRegion **region)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateRegionHrgn(HRGN hRgn,
-  GpRegion **region)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCloneRegion(GpRegion *region,
-  GpRegion **cloneRegion)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDeleteRegion(GpRegion *region)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetInfinite(GpRegion *region)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetEmpty(GpRegion *region)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCombineRegionRect(GpRegion *region,
-  GDIPCONST GpRectF *rect,
-  CombineMode combineMode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCombineRegionRectI(GpRegion *region,
-  GDIPCONST GpRect *rect,
-  CombineMode combineMode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCombineRegionPath(GpRegion *region,
-  GpPath *path,
-  CombineMode combineMode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCombineRegionRegion(GpRegion *region,
-  GpRegion *region2,
-  CombineMode combineMode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipTranslateRegion(GpRegion *region,
-  REAL dx,
-  REAL dy)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipTranslateRegionI(GpRegion *region,
-  INT dx,
-  INT dy)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipTransformRegion(GpRegion *region,
-  GpMatrix *matrix)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetRegionBounds(GpRegion *region,
-  GpGraphics *graphics,
-  GpRectF *rect)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetRegionBoundsI(GpRegion *region,
-  GpGraphics *graphics,
-  GpRect *rect)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetRegionHRgn(GpRegion *region,
-  GpGraphics *graphics,
-  HRGN *hRgn)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipIsEmptyRegion(GpRegion *region,
-  GpGraphics *graphics,
-  BOOL *result)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipIsInfiniteRegion(GpRegion *region,
-  GpGraphics *graphics,
-  BOOL *result)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipIsEqualRegion(GpRegion *region,
-  GpRegion *region2,
-  GpGraphics *graphics,
-  BOOL *result)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetRegionDataSize(GpRegion *region,
-  UINT * bufferSize)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetRegionData(GpRegion *region,
-  BYTE * buffer,
-  UINT bufferSize,
-  UINT * sizeFilled)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipIsVisibleRegionPoint(GpRegion *region,
-  REAL x,
-  REAL y,
-  GpGraphics *graphics,
-  BOOL *result)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipIsVisibleRegionPointI(GpRegion *region,
-  INT x,
-  INT y,
-  GpGraphics *graphics,
-  BOOL *result)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipIsVisibleRegionRect(GpRegion *region,
-  REAL x,
-  REAL y,
-  REAL width,
-  REAL height,
-  GpGraphics *graphics,
-  BOOL *result)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipIsVisibleRegionRectI(GpRegion *region,
-  INT x,
-  INT y,
-  INT width,
-  INT height,
-  GpGraphics *graphics,
-  BOOL *result)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetRegionScansCount(GpRegion *region,
-  UINT* count,
-  GpMatrix* matrix)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetRegionScans(GpRegion *region,
-  GpRectF* rects,
-  INT* count,
-  GpMatrix* matrix)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetRegionScansI(GpRegion *region,
-  GpRect* rects,
-  INT* count,
-  GpMatrix* matrix)
-{
-  return NotImplemented;
-}
diff --git a/reactos/dll/win32/gdiplus/gdiplus/string.c b/reactos/dll/win32/gdiplus/gdiplus/string.c
deleted file mode 100644 (file)
index 2c731e1..0000000
+++ /dev/null
@@ -1,308 +0,0 @@
-#include <windows.h>
-#include <gdiplusprivate.h>
-#include <debug.h>
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateStringFormat(INT formatAttributes,
-  LANGID language,
-  GpStringFormat **format)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipStringFormatGetGenericDefault(GpStringFormat **format)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipStringFormatGetGenericTypographic(GpStringFormat **format)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDeleteStringFormat(GpStringFormat *format)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCloneStringFormat(GDIPCONST GpStringFormat *format,
-  GpStringFormat **newFormat)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetStringFormatFlags(GpStringFormat *format,
-  INT flags)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetStringFormatFlags(GDIPCONST GpStringFormat *format,
-  INT *flags)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetStringFormatAlign(GpStringFormat *format,
-  StringAlignment align)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetStringFormatAlign(GDIPCONST GpStringFormat *format,
-  StringAlignment *align)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetStringFormatLineAlign(GpStringFormat *format,
-  StringAlignment align)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetStringFormatLineAlign(GDIPCONST GpStringFormat *format,
-  StringAlignment *align)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetStringFormatTrimming(GpStringFormat *format,
-  StringTrimming trimming)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetStringFormatTrimming(GDIPCONST GpStringFormat *format,
-  StringTrimming *trimming)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetStringFormatHotkeyPrefix(GpStringFormat *format,
-  INT hotkeyPrefix)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetStringFormatHotkeyPrefix(GDIPCONST GpStringFormat *format,
-  INT *hotkeyPrefix)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetStringFormatTabStops(GpStringFormat *format,
-  REAL firstTabOffset,
-  INT count,
-  GDIPCONST REAL *tabStops)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetStringFormatTabStops(GDIPCONST GpStringFormat *format,
-  INT count,
-  REAL *firstTabOffset,
-  REAL *tabStops)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetStringFormatTabStopCount(GDIPCONST GpStringFormat *format,
-  INT * count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetStringFormatDigitSubstitution(GpStringFormat *format,
-  LANGID language,
-  StringDigitSubstitute substitute)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetStringFormatDigitSubstitution(GDIPCONST GpStringFormat *format,
-  LANGID *language,
-  StringDigitSubstitute *substitute)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetStringFormatMeasurableCharacterRangeCount(GDIPCONST GpStringFormat *format,
-  INT *count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetStringFormatMeasurableCharacterRanges(GpStringFormat *format,
-  INT rangeCount,
-  GDIPCONST CharacterRange *ranges)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawString(GpGraphics *graphics,
-  GDIPCONST WCHAR *string,
-  INT length,
-  GDIPCONST GpFont *font,
-  GDIPCONST RectF *layoutRect,
-  GDIPCONST GpStringFormat *stringFormat,
-  GDIPCONST GpBrush *brush)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipMeasureString(GpGraphics *graphics,
-  GDIPCONST WCHAR *string,
-  INT length,
-  GDIPCONST GpFont *font,
-  GDIPCONST RectF *layoutRect,
-  GDIPCONST GpStringFormat *stringFormat,
-  RectF *boundingBox,
-  INT *codepointsFitted,
-  INT *linesFilled)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipMeasureCharacterRanges(GpGraphics *graphics,
-  GDIPCONST WCHAR *string,
-  INT length,
-  GDIPCONST GpFont *font,
-  GDIPCONST RectF *layoutRect,
-  GDIPCONST GpStringFormat *stringFormat,
-  INT regionCount,
-  GpRegion **regions)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipDrawDriverString(GpGraphics *graphics,
-  GDIPCONST UINT16 *text,
-  INT length,
-  GDIPCONST GpFont *font,
-  GDIPCONST GpBrush *brush,
-  GDIPCONST PointF *positions,
-  INT flags,
-  GDIPCONST GpMatrix *matrix)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipMeasureDriverString(GpGraphics *graphics,
-  GDIPCONST UINT16 *text,
-  INT length,
-  GDIPCONST GpFont *font,
-  GDIPCONST PointF *positions,
-  INT flags,
-  GDIPCONST GpMatrix *matrix,
-  RectF *boundingBox)
-{
-  return NotImplemented;
-}
diff --git a/reactos/dll/win32/gdiplus/gdiplus/texture.c b/reactos/dll/win32/gdiplus/gdiplus/texture.c
deleted file mode 100644 (file)
index 5e1ac77..0000000
+++ /dev/null
@@ -1,179 +0,0 @@
-#include <windows.h>
-#include <gdiplusprivate.h>
-#include <debug.h>
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateTexture(GpImage *image,
-  GpWrapMode wrapmode,
-  GpTexture **texture)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateTexture2(GpImage *image,
-  GpWrapMode wrapmode,
-  REAL x,
-  REAL y,
-  REAL width,
-  REAL height,
-  GpTexture **texture)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateTextureIA(GpImage *image,
-  GDIPCONST GpImageAttributes *imageAttributes,
-  REAL x,
-  REAL y,
-  REAL width,
-  REAL height,
-  GpTexture **texture)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateTexture2I(GpImage *image,
-  GpWrapMode wrapmode,
-  INT x,
-  INT y,
-  INT width,
-  INT height,
-  GpTexture **texture)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipCreateTextureIAI(GpImage *image,
-  GDIPCONST GpImageAttributes *imageAttributes,
-  INT x,
-  INT y,
-  INT width,
-  INT height,
-  GpTexture **texture)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetTextureTransform(GpTexture *brush,
-  GpMatrix *matrix)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetTextureTransform(GpTexture *brush,
-  GDIPCONST GpMatrix *matrix)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipResetTextureTransform(GpTexture* brush)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipMultiplyTextureTransform(GpTexture* brush,
-  GDIPCONST GpMatrix *matrix,
-  GpMatrixOrder order)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipTranslateTextureTransform(GpTexture* brush,
-  REAL dx,
-  REAL dy,
-  GpMatrixOrder order)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipScaleTextureTransform(GpTexture* brush,
-  REAL sx,
-  REAL sy,
-  GpMatrixOrder order)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipRotateTextureTransform(GpTexture* brush,
-  REAL angle,
-  GpMatrixOrder order)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetTextureWrapMode(GpTexture *brush,
-  GpWrapMode wrapmode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetTextureWrapMode(GpTexture *brush,
-  GpWrapMode *wrapmode)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetTextureImage(GpTexture *brush,
-  GpImage **image)
-{
-  return NotImplemented;
-}
diff --git a/reactos/dll/win32/gdiplus/gdiplus/transform.c b/reactos/dll/win32/gdiplus/gdiplus/transform.c
deleted file mode 100644 (file)
index 67adcdb..0000000
+++ /dev/null
@@ -1,113 +0,0 @@
-#include <windows.h>
-#include <gdiplusprivate.h>
-#include <debug.h>
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipSetWorldTransform(GpGraphics *graphics,
-  GpMatrix *matrix)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipResetWorldTransform(GpGraphics *graphics)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipMultiplyWorldTransform(GpGraphics *graphics,
-  GDIPCONST GpMatrix *matrix,
-  GpMatrixOrder order)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipTranslateWorldTransform(GpGraphics *graphics,
-  REAL dx,
-  REAL dy,
-  GpMatrixOrder order)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipScaleWorldTransform(GpGraphics *graphics,
-  REAL sx,
-  REAL sy,
-  GpMatrixOrder order)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipRotateWorldTransform(GpGraphics *graphics,
-  REAL angle,
-  GpMatrixOrder order)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipGetWorldTransform(GpGraphics *graphics,
-  GpMatrix *matrix)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipResetPageTransform(GpGraphics *graphics)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipTransformPoints(GpGraphics *graphics,
-  GpCoordinateSpace destSpace,
-  GpCoordinateSpace srcSpace,
-  GpPointF *points,
-  INT count)
-{
-  return NotImplemented;
-}
-
-/*
- * @unimplemented
- */
-GpStatus WINGDIPAPI
-GdipTransformPointsI(GpGraphics *graphics,
-  GpCoordinateSpace destSpace,
-  GpCoordinateSpace srcSpace,
-  GpPoint *points,
-  INT count)
-{
-  return NotImplemented;
-}
diff --git a/reactos/dll/win32/gdiplus/gdiplus_private.h b/reactos/dll/win32/gdiplus/gdiplus_private.h
new file mode 100644 (file)
index 0000000..149d540
--- /dev/null
@@ -0,0 +1,187 @@
+/*
+ * Copyright (C) 2007 Google (Evan Stade)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#ifndef __WINE_GP_PRIVATE_H_
+#define __WINE_GP_PRIVATE_H_
+
+#include <math.h>
+#include <stdarg.h>
+
+#include "windef.h"
+#include "wingdi.h"
+#include "winbase.h"
+#include "winuser.h"
+
+#include "objbase.h"
+#include "ocidl.h"
+
+#include "gdiplus.h"
+
+#define GP_DEFAULT_PENSTYLE (PS_GEOMETRIC | PS_SOLID | PS_ENDCAP_FLAT | PS_JOIN_MITER)
+#define MAX_ARC_PTS (13)
+#define MAX_DASHLEN (16) /* this is a limitation of gdi */
+#define INCH_HIMETRIC (2540)
+
+COLORREF ARGB2COLORREF(ARGB color);
+extern INT arc2polybezier(GpPointF * points, REAL x1, REAL y1, REAL x2, REAL y2,
+    REAL startAngle, REAL sweepAngle);
+extern REAL gdiplus_atan2(REAL dy, REAL dx);
+extern GpStatus hresult_to_status(HRESULT res);
+extern REAL convert_unit(HDC hdc, GpUnit unit);
+
+static inline INT roundr(REAL x)
+{
+    return (INT) floor(x + 0.5);
+}
+
+static inline REAL deg2rad(REAL degrees)
+{
+    return M_PI * degrees / 180.0;
+}
+
+struct GpPen{
+    UINT style;
+    GpUnit unit;
+    REAL width;
+    GpLineCap endcap;
+    GpLineCap startcap;
+    GpDashCap dashcap;
+    GpCustomLineCap *customstart;
+    GpCustomLineCap *customend;
+    GpLineJoin join;
+    REAL miterlimit;
+    GpDashStyle dash;
+    REAL *dashes;
+    INT numdashes;
+    REAL offset;    /* dash offset */
+    GpBrush *brush;
+};
+
+struct GpGraphics{
+    HDC hdc;
+    HWND hwnd;
+    SmoothingMode smoothing;
+    CompositingQuality compqual;
+    InterpolationMode interpolation;
+    PixelOffsetMode pixeloffset;
+    CompositingMode compmode;
+    TextRenderingHint texthint;
+    GpUnit unit;    /* page unit */
+    REAL scale;     /* page scale */
+    GpMatrix * worldtrans; /* world transform */
+};
+
+struct GpBrush{
+    HBRUSH gdibrush;
+    GpBrushType bt;
+    LOGBRUSH lb;
+};
+
+struct GpSolidFill{
+    GpBrush brush;
+    ARGB color;
+};
+
+struct GpPathGradient{
+    GpBrush brush;
+    PathData pathdata;
+    ARGB centercolor;
+    GpWrapMode wrap;
+    BOOL gamma;
+    GpPointF center;
+    GpPointF focus;
+};
+
+struct GpLineGradient{
+    GpBrush brush;
+    GpPointF startpoint;
+    GpPointF endpoint;
+    ARGB startcolor;
+    ARGB endcolor;
+    GpWrapMode wrap;
+    BOOL gamma;
+};
+
+struct GpTexture{
+    GpBrush brush;
+};
+
+struct GpPath{
+    GpFillMode fill;
+    GpPathData pathdata;
+    BOOL newfigure; /* whether the next drawing action starts a new figure */
+    INT datalen; /* size of the arrays in pathdata */
+};
+
+struct GpMatrix{
+    REAL matrix[6];
+};
+
+struct GpPathIterator{
+    GpPathData pathdata;
+    INT subpath_pos;    /* for NextSubpath methods */
+    INT marker_pos;     /* for NextMarker methods */
+    INT pathtype_pos;   /* for NextPathType methods */
+};
+
+struct GpCustomLineCap{
+    GpPathData pathdata;
+    BOOL fill;      /* TRUE for fill, FALSE for stroke */
+    GpLineCap cap;  /* as far as I can tell, this value is ignored */
+    REAL inset;     /* how much to adjust the end of the line */
+};
+
+struct GpImage{
+    IPicture* picture;
+    ImageType type;
+};
+
+struct GpMetafile{
+    GpImage image;
+    GpRectF bounds;
+    GpUnit unit;
+};
+
+struct GpBitmap{
+    GpImage image;
+    INT width;
+    INT height;
+    PixelFormat format;
+    ImageLockMode lockmode;
+    INT numlocks;
+    BYTE *bitmapbits;   /* pointer to the buffer we passed in BitmapLockBits */
+};
+
+struct GpImageAttributes{
+    WrapMode wrap;
+};
+
+struct GpFont{
+    LOGFONTW lfw;
+};
+
+struct GpStringFormat{
+    INT attr;
+    LANGID lang;
+    StringAlignment align;
+    StringTrimming trimming;
+    HotkeyPrefix hkprefix;
+    StringAlignment vertalign;
+};
+
+#endif
diff --git a/reactos/dll/win32/gdiplus/gdiplus_ros.diff b/reactos/dll/win32/gdiplus/gdiplus_ros.diff
new file mode 100644 (file)
index 0000000..904a12a
--- /dev/null
@@ -0,0 +1,58 @@
+Index: gdiplus.c
+===================================================================
+RCS file: /home/wine/wine/dlls/gdiplus/gdiplus.c,v
+retrieving revision 1.15
+diff -u -r1.15 gdiplus.c
+--- gdiplus.c  8 Jan 2008 16:22:52 -0000       1.15
++++ gdiplus.c  23 Mar 2008 21:21:23 -0000
+@@ -200,7 +200,7 @@
+     unstretch_angle(&startAngle, x2 / 2.0, y2 / 2.0);
+     unstretch_angle(&endAngle, x2 / 2.0, y2 / 2.0);
+-    count = ceilf(fabs(endAngle - startAngle) / M_PI_2) * 3 + 1;
++    count = ceil(fabs(endAngle - startAngle) / M_PI_2) * 3 + 1;
+     /* don't make more than a full circle */
+     count = min(MAX_ARC_PTS, count);
+Index: gdiplus_private.h
+===================================================================
+RCS file: /home/wine/wine/dlls/gdiplus/gdiplus_private.h,v
+retrieving revision 1.58
+diff -u -r1.58 gdiplus_private.h
+--- gdiplus_private.h  15 Aug 2007 09:36:31 -0000      1.58
++++ gdiplus_private.h  23 Mar 2008 09:25:54 -0000
+@@ -46,7 +46,7 @@
+ static inline INT roundr(REAL x)
+ {
+-    return (INT) floorf(x + 0.5);
++    return (INT) floor(x + 0.5);
+ }
+ static inline REAL deg2rad(REAL degrees)
+Index: graphics.c
+===================================================================
+RCS file: /home/wine/wine/dlls/gdiplus/graphics.c,v
+retrieving revision 1.102
+diff -u -r1.102 graphics.c
+--- graphics.c 1 Mar 2008 12:15:48 -0000       1.102
++++ graphics.c 23 Mar 2008 21:21:23 -0000
+@@ -1464,7 +1464,7 @@
+     DeleteObject(SelectObject(graphics->hdc, CreateFontIndirectW(&lfw)));
+     for(i = 0, j = 0; i < length; i++){
+-        if(!isprintW(string[i]) && (string[i] != '\n'))
++        if(!isprint(string[i]) && (string[i] != '\n'))
+             continue;
+         stringdup[j] = string[i];
+@@ -1873,7 +1873,7 @@
+         nwidth = nheight = INT_MAX;
+     for(i = 0, j = 0; i < length; i++){
+-        if(!isprintW(string[i]) && (string[i] != '\n'))
++        if(!isprint(string[i]) && (string[i] != '\n'))
+             continue;
+         stringdup[j] = string[i];
+
diff --git a/reactos/dll/win32/gdiplus/graphics.c b/reactos/dll/win32/gdiplus/graphics.c
new file mode 100644 (file)
index 0000000..4609a31
--- /dev/null
@@ -0,0 +1,2090 @@
+/*
+ * Copyright (C) 2007 Google (Evan Stade)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <stdarg.h>
+#include <math.h>
+#include <limits.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "winuser.h"
+#include "wingdi.h"
+#include "wine/unicode.h"
+
+#define COBJMACROS
+#include "objbase.h"
+#include "ocidl.h"
+#include "olectl.h"
+#include "ole2.h"
+
+#include "winreg.h"
+#include "shlwapi.h"
+
+#include "gdiplus.h"
+#include "gdiplus_private.h"
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
+
+/* looks-right constants */
+#define TENSION_CONST (0.3)
+#define ANCHOR_WIDTH (2.0)
+#define MAX_ITERS (50)
+
+/* Converts angle (in degrees) to x/y coordinates */
+static void deg2xy(REAL angle, REAL x_0, REAL y_0, REAL *x, REAL *y)
+{
+    REAL radAngle, hypotenuse;
+
+    radAngle = deg2rad(angle);
+    hypotenuse = 50.0; /* arbitrary */
+
+    *x = x_0 + cos(radAngle) * hypotenuse;
+    *y = y_0 + sin(radAngle) * hypotenuse;
+}
+
+/* Converts from gdiplus path point type to gdi path point type. */
+static BYTE convert_path_point_type(BYTE type)
+{
+    BYTE ret;
+
+    switch(type & PathPointTypePathTypeMask){
+        case PathPointTypeBezier:
+            ret = PT_BEZIERTO;
+            break;
+        case PathPointTypeLine:
+            ret = PT_LINETO;
+            break;
+        case PathPointTypeStart:
+            ret = PT_MOVETO;
+            break;
+        default:
+            ERR("Bad point type\n");
+            return 0;
+    }
+
+    if(type & PathPointTypeCloseSubpath)
+        ret |= PT_CLOSEFIGURE;
+
+    return ret;
+}
+
+static INT prepare_dc(GpGraphics *graphics, GpPen *pen)
+{
+    HPEN gdipen;
+    REAL width;
+    INT save_state = SaveDC(graphics->hdc), i, numdashes;
+    GpPointF pt[2];
+    DWORD dash_array[MAX_DASHLEN];
+
+    EndPath(graphics->hdc);
+
+    if(pen->unit == UnitPixel){
+        width = pen->width;
+    }
+    else{
+        /* Get an estimate for the amount the pen width is affected by the world
+         * transform. (This is similar to what some of the wine drivers do.) */
+        pt[0].X = 0.0;
+        pt[0].Y = 0.0;
+        pt[1].X = 1.0;
+        pt[1].Y = 1.0;
+        GdipTransformMatrixPoints(graphics->worldtrans, pt, 2);
+        width = sqrt((pt[1].X - pt[0].X) * (pt[1].X - pt[0].X) +
+                     (pt[1].Y - pt[0].Y) * (pt[1].Y - pt[0].Y)) / sqrt(2.0);
+
+        width *= pen->width * convert_unit(graphics->hdc,
+                              pen->unit == UnitWorld ? graphics->unit : pen->unit);
+    }
+
+    if(pen->dash == DashStyleCustom){
+        numdashes = min(pen->numdashes, MAX_DASHLEN);
+
+        TRACE("dashes are: ");
+        for(i = 0; i < numdashes; i++){
+            dash_array[i] = roundr(width * pen->dashes[i]);
+            TRACE("%d, ", dash_array[i]);
+        }
+        TRACE("\n and the pen style is %x\n", pen->style);
+
+        gdipen = ExtCreatePen(pen->style, roundr(width), &pen->brush->lb,
+                              numdashes, dash_array);
+    }
+    else
+        gdipen = ExtCreatePen(pen->style, roundr(width), &pen->brush->lb, 0, NULL);
+
+    SelectObject(graphics->hdc, gdipen);
+
+    return save_state;
+}
+
+static void restore_dc(GpGraphics *graphics, INT state)
+{
+    DeleteObject(SelectObject(graphics->hdc, GetStockObject(NULL_PEN)));
+    RestoreDC(graphics->hdc, state);
+}
+
+/* This helper applies all the changes that the points listed in ptf need in
+ * order to be drawn on the device context.  In the end, this should include at
+ * least:
+ *  -scaling by page unit
+ *  -applying world transformation
+ *  -converting from float to int
+ * Native gdiplus uses gdi32 to do all this (via SetMapMode, SetViewportExtEx,
+ * SetWindowExtEx, SetWorldTransform, etc.) but we cannot because we are using
+ * gdi to draw, and these functions would irreparably mess with line widths.
+ */
+static void transform_and_round_points(GpGraphics *graphics, POINT *pti,
+    GpPointF *ptf, INT count)
+{
+    REAL unitscale;
+    GpMatrix *matrix;
+    int i;
+
+    unitscale = convert_unit(graphics->hdc, graphics->unit);
+
+    /* apply page scale */
+    if(graphics->unit != UnitDisplay)
+        unitscale *= graphics->scale;
+
+    GdipCloneMatrix(graphics->worldtrans, &matrix);
+    GdipScaleMatrix(matrix, unitscale, unitscale, MatrixOrderAppend);
+    GdipTransformMatrixPoints(matrix, ptf, count);
+    GdipDeleteMatrix(matrix);
+
+    for(i = 0; i < count; i++){
+        pti[i].x = roundr(ptf[i].X);
+        pti[i].y = roundr(ptf[i].Y);
+    }
+}
+
+/* GdipDrawPie/GdipFillPie helper function */
+static void draw_pie(GpGraphics *graphics, REAL x, REAL y, REAL width,
+    REAL height, REAL startAngle, REAL sweepAngle)
+{
+    GpPointF ptf[4];
+    POINT pti[4];
+
+    ptf[0].X = x;
+    ptf[0].Y = y;
+    ptf[1].X = x + width;
+    ptf[1].Y = y + height;
+
+    deg2xy(startAngle+sweepAngle, x + width / 2.0, y + width / 2.0, &ptf[2].X, &ptf[2].Y);
+    deg2xy(startAngle, x + width / 2.0, y + width / 2.0, &ptf[3].X, &ptf[3].Y);
+
+    transform_and_round_points(graphics, pti, ptf, 4);
+
+    Pie(graphics->hdc, pti[0].x, pti[0].y, pti[1].x, pti[1].y, pti[2].x,
+        pti[2].y, pti[3].x, pti[3].y);
+}
+
+/* GdipDrawCurve helper function.
+ * Calculates Bezier points from cardinal spline points. */
+static void calc_curve_bezier(CONST GpPointF *pts, REAL tension, REAL *x1,
+    REAL *y1, REAL *x2, REAL *y2)
+{
+    REAL xdiff, ydiff;
+
+    /* calculate tangent */
+    xdiff = pts[2].X - pts[0].X;
+    ydiff = pts[2].Y - pts[0].Y;
+
+    /* apply tangent to get control points */
+    *x1 = pts[1].X - tension * xdiff;
+    *y1 = pts[1].Y - tension * ydiff;
+    *x2 = pts[1].X + tension * xdiff;
+    *y2 = pts[1].Y + tension * ydiff;
+}
+
+/* GdipDrawCurve helper function.
+ * Calculates Bezier points from cardinal spline endpoints. */
+static void calc_curve_bezier_endp(REAL xend, REAL yend, REAL xadj, REAL yadj,
+    REAL tension, REAL *x, REAL *y)
+{
+    /* tangent at endpoints is the line from the endpoint to the adjacent point */
+    *x = roundr(tension * (xadj - xend) + xend);
+    *y = roundr(tension * (yadj - yend) + yend);
+}
+
+/* Draws the linecap the specified color and size on the hdc.  The linecap is in
+ * direction of the line from x1, y1 to x2, y2 and is anchored on x2, y2. Probably
+ * should not be called on an hdc that has a path you care about. */
+static void draw_cap(GpGraphics *graphics, COLORREF color, GpLineCap cap, REAL size,
+    const GpCustomLineCap *custom, REAL x1, REAL y1, REAL x2, REAL y2)
+{
+    HGDIOBJ oldbrush = NULL, oldpen = NULL;
+    GpMatrix *matrix = NULL;
+    HBRUSH brush = NULL;
+    HPEN pen = NULL;
+    PointF ptf[4], *custptf = NULL;
+    POINT pt[4], *custpt = NULL;
+    BYTE *tp = NULL;
+    REAL theta, dsmall, dbig, dx, dy = 0.0;
+    INT i, count;
+    LOGBRUSH lb;
+    BOOL customstroke;
+
+    if((x1 == x2) && (y1 == y2))
+        return;
+
+    theta = gdiplus_atan2(y2 - y1, x2 - x1);
+
+    customstroke = (cap == LineCapCustom) && custom && (!custom->fill);
+    if(!customstroke){
+        brush = CreateSolidBrush(color);
+        lb.lbStyle = BS_SOLID;
+        lb.lbColor = color;
+        lb.lbHatch = 0;
+        pen = ExtCreatePen(PS_GEOMETRIC | PS_SOLID | PS_ENDCAP_FLAT |
+                           PS_JOIN_MITER, 1, &lb, 0,
+                           NULL);
+        oldbrush = SelectObject(graphics->hdc, brush);
+        oldpen = SelectObject(graphics->hdc, pen);
+    }
+
+    switch(cap){
+        case LineCapFlat:
+            break;
+        case LineCapSquare:
+        case LineCapSquareAnchor:
+        case LineCapDiamondAnchor:
+            size = size * (cap & LineCapNoAnchor ? ANCHOR_WIDTH : 1.0) / 2.0;
+            if(cap == LineCapDiamondAnchor){
+                dsmall = cos(theta + M_PI_2) * size;
+                dbig = sin(theta + M_PI_2) * size;
+            }
+            else{
+                dsmall = cos(theta + M_PI_4) * size;
+                dbig = sin(theta + M_PI_4) * size;
+            }
+
+            ptf[0].X = x2 - dsmall;
+            ptf[1].X = x2 + dbig;
+
+            ptf[0].Y = y2 - dbig;
+            ptf[3].Y = y2 + dsmall;
+
+            ptf[1].Y = y2 - dsmall;
+            ptf[2].Y = y2 + dbig;
+
+            ptf[3].X = x2 - dbig;
+            ptf[2].X = x2 + dsmall;
+
+            transform_and_round_points(graphics, pt, ptf, 4);
+            Polygon(graphics->hdc, pt, 4);
+
+            break;
+        case LineCapArrowAnchor:
+            size = size * 4.0 / sqrt(3.0);
+
+            dx = cos(M_PI / 6.0 + theta) * size;
+            dy = sin(M_PI / 6.0 + theta) * size;
+
+            ptf[0].X = x2 - dx;
+            ptf[0].Y = y2 - dy;
+
+            dx = cos(- M_PI / 6.0 + theta) * size;
+            dy = sin(- M_PI / 6.0 + theta) * size;
+
+            ptf[1].X = x2 - dx;
+            ptf[1].Y = y2 - dy;
+
+            ptf[2].X = x2;
+            ptf[2].Y = y2;
+
+            transform_and_round_points(graphics, pt, ptf, 3);
+            Polygon(graphics->hdc, pt, 3);
+
+            break;
+        case LineCapRoundAnchor:
+            dx = dy = ANCHOR_WIDTH * size / 2.0;
+
+            ptf[0].X = x2 - dx;
+            ptf[0].Y = y2 - dy;
+            ptf[1].X = x2 + dx;
+            ptf[1].Y = y2 + dy;
+
+            transform_and_round_points(graphics, pt, ptf, 2);
+            Ellipse(graphics->hdc, pt[0].x, pt[0].y, pt[1].x, pt[1].y);
+
+            break;
+        case LineCapTriangle:
+            size = size / 2.0;
+            dx = cos(M_PI_2 + theta) * size;
+            dy = sin(M_PI_2 + theta) * size;
+
+            ptf[0].X = x2 - dx;
+            ptf[0].Y = y2 - dy;
+            ptf[1].X = x2 + dx;
+            ptf[1].Y = y2 + dy;
+
+            dx = cos(theta) * size;
+            dy = sin(theta) * size;
+
+            ptf[2].X = x2 + dx;
+            ptf[2].Y = y2 + dy;
+
+            transform_and_round_points(graphics, pt, ptf, 3);
+            Polygon(graphics->hdc, pt, 3);
+
+            break;
+        case LineCapRound:
+            dx = dy = size / 2.0;
+
+            ptf[0].X = x2 - dx;
+            ptf[0].Y = y2 - dy;
+            ptf[1].X = x2 + dx;
+            ptf[1].Y = y2 + dy;
+
+            dx = -cos(M_PI_2 + theta) * size;
+            dy = -sin(M_PI_2 + theta) * size;
+
+            ptf[2].X = x2 - dx;
+            ptf[2].Y = y2 - dy;
+            ptf[3].X = x2 + dx;
+            ptf[3].Y = y2 + dy;
+
+            transform_and_round_points(graphics, pt, ptf, 4);
+            Pie(graphics->hdc, pt[0].x, pt[0].y, pt[1].x, pt[1].y, pt[2].x,
+                pt[2].y, pt[3].x, pt[3].y);
+
+            break;
+        case LineCapCustom:
+            if(!custom)
+                break;
+
+            count = custom->pathdata.Count;
+            custptf = GdipAlloc(count * sizeof(PointF));
+            custpt = GdipAlloc(count * sizeof(POINT));
+            tp = GdipAlloc(count);
+
+            if(!custptf || !custpt || !tp || (GdipCreateMatrix(&matrix) != Ok))
+                goto custend;
+
+            memcpy(custptf, custom->pathdata.Points, count * sizeof(PointF));
+
+            GdipScaleMatrix(matrix, size, size, MatrixOrderAppend);
+            GdipRotateMatrix(matrix, (180.0 / M_PI) * (theta - M_PI_2),
+                             MatrixOrderAppend);
+            GdipTranslateMatrix(matrix, x2, y2, MatrixOrderAppend);
+            GdipTransformMatrixPoints(matrix, custptf, count);
+
+            transform_and_round_points(graphics, custpt, custptf, count);
+
+            for(i = 0; i < count; i++)
+                tp[i] = convert_path_point_type(custom->pathdata.Types[i]);
+
+            if(custom->fill){
+                BeginPath(graphics->hdc);
+                PolyDraw(graphics->hdc, custpt, tp, count);
+                EndPath(graphics->hdc);
+                StrokeAndFillPath(graphics->hdc);
+            }
+            else
+                PolyDraw(graphics->hdc, custpt, tp, count);
+
+custend:
+            GdipFree(custptf);
+            GdipFree(custpt);
+            GdipFree(tp);
+            GdipDeleteMatrix(matrix);
+            break;
+        default:
+            break;
+    }
+
+    if(!customstroke){
+        SelectObject(graphics->hdc, oldbrush);
+        SelectObject(graphics->hdc, oldpen);
+        DeleteObject(brush);
+        DeleteObject(pen);
+    }
+}
+
+/* Shortens the line by the given percent by changing x2, y2.
+ * If percent is > 1.0 then the line will change direction.
+ * If percent is negative it can lengthen the line. */
+static void shorten_line_percent(REAL x1, REAL  y1, REAL *x2, REAL *y2, REAL percent)
+{
+    REAL dist, theta, dx, dy;
+
+    if((y1 == *y2) && (x1 == *x2))
+        return;
+
+    dist = sqrt((*x2 - x1) * (*x2 - x1) + (*y2 - y1) * (*y2 - y1)) * -percent;
+    theta = gdiplus_atan2((*y2 - y1), (*x2 - x1));
+    dx = cos(theta) * dist;
+    dy = sin(theta) * dist;
+
+    *x2 = *x2 + dx;
+    *y2 = *y2 + dy;
+}
+
+/* Shortens the line by the given amount by changing x2, y2.
+ * If the amount is greater than the distance, the line will become length 0.
+ * If the amount is negative, it can lengthen the line. */
+static void shorten_line_amt(REAL x1, REAL y1, REAL *x2, REAL *y2, REAL amt)
+{
+    REAL dx, dy, percent;
+
+    dx = *x2 - x1;
+    dy = *y2 - y1;
+    if(dx == 0 && dy == 0)
+        return;
+
+    percent = amt / sqrt(dx * dx + dy * dy);
+    if(percent >= 1.0){
+        *x2 = x1;
+        *y2 = y1;
+        return;
+    }
+
+    shorten_line_percent(x1, y1, x2, y2, percent);
+}
+
+/* Draws lines between the given points, and if caps is true then draws an endcap
+ * at the end of the last line. */
+static GpStatus draw_polyline(GpGraphics *graphics, GpPen *pen,
+    GDIPCONST GpPointF * pt, INT count, BOOL caps)
+{
+    POINT *pti = NULL;
+    GpPointF *ptcopy = NULL;
+    GpStatus status = GenericError;
+
+    if(!count)
+        return Ok;
+
+    pti = GdipAlloc(count * sizeof(POINT));
+    ptcopy = GdipAlloc(count * sizeof(GpPointF));
+
+    if(!pti || !ptcopy){
+        status = OutOfMemory;
+        goto end;
+    }
+
+    memcpy(ptcopy, pt, count * sizeof(GpPointF));
+
+    if(caps){
+        if(pen->endcap == LineCapArrowAnchor)
+            shorten_line_amt(ptcopy[count-2].X, ptcopy[count-2].Y,
+                             &ptcopy[count-1].X, &ptcopy[count-1].Y, pen->width);
+        else if((pen->endcap == LineCapCustom) && pen->customend)
+            shorten_line_amt(ptcopy[count-2].X, ptcopy[count-2].Y,
+                             &ptcopy[count-1].X, &ptcopy[count-1].Y,
+                             pen->customend->inset * pen->width);
+
+        if(pen->startcap == LineCapArrowAnchor)
+            shorten_line_amt(ptcopy[1].X, ptcopy[1].Y,
+                             &ptcopy[0].X, &ptcopy[0].Y, pen->width);
+        else if((pen->startcap == LineCapCustom) && pen->customstart)
+            shorten_line_amt(ptcopy[1].X, ptcopy[1].Y,
+                             &ptcopy[0].X, &ptcopy[0].Y,
+                             pen->customstart->inset * pen->width);
+
+        draw_cap(graphics, pen->brush->lb.lbColor, pen->endcap, pen->width, pen->customend,
+                 pt[count - 2].X, pt[count - 2].Y, pt[count - 1].X, pt[count - 1].Y);
+        draw_cap(graphics, pen->brush->lb.lbColor, pen->startcap, pen->width, pen->customstart,
+                         pt[1].X, pt[1].Y, pt[0].X, pt[0].Y);
+    }
+
+    transform_and_round_points(graphics, pti, ptcopy, count);
+
+    if(Polyline(graphics->hdc, pti, count))
+        status = Ok;
+
+end:
+    GdipFree(pti);
+    GdipFree(ptcopy);
+
+    return status;
+}
+
+/* Conducts a linear search to find the bezier points that will back off
+ * the endpoint of the curve by a distance of amt. Linear search works
+ * better than binary in this case because there are multiple solutions,
+ * and binary searches often find a bad one. I don't think this is what
+ * Windows does but short of rendering the bezier without GDI's help it's
+ * the best we can do. If rev then work from the start of the passed points
+ * instead of the end. */
+static void shorten_bezier_amt(GpPointF * pt, REAL amt, BOOL rev)
+{
+    GpPointF origpt[4];
+    REAL percent = 0.00, dx, dy, origx, origy, diff = -1.0;
+    INT i, first = 0, second = 1, third = 2, fourth = 3;
+
+    if(rev){
+        first = 3;
+        second = 2;
+        third = 1;
+        fourth = 0;
+    }
+
+    origx = pt[fourth].X;
+    origy = pt[fourth].Y;
+    memcpy(origpt, pt, sizeof(GpPointF) * 4);
+
+    for(i = 0; (i < MAX_ITERS) && (diff < amt); i++){
+        /* reset bezier points to original values */
+        memcpy(pt, origpt, sizeof(GpPointF) * 4);
+        /* Perform magic on bezier points. Order is important here.*/
+        shorten_line_percent(pt[third].X, pt[third].Y, &pt[fourth].X, &pt[fourth].Y, percent);
+        shorten_line_percent(pt[second].X, pt[second].Y, &pt[third].X, &pt[third].Y, percent);
+        shorten_line_percent(pt[third].X, pt[third].Y, &pt[fourth].X, &pt[fourth].Y, percent);
+        shorten_line_percent(pt[first].X, pt[first].Y, &pt[second].X, &pt[second].Y, percent);
+        shorten_line_percent(pt[second].X, pt[second].Y, &pt[third].X, &pt[third].Y, percent);
+        shorten_line_percent(pt[third].X, pt[third].Y, &pt[fourth].X, &pt[fourth].Y, percent);
+
+        dx = pt[fourth].X - origx;
+        dy = pt[fourth].Y - origy;
+
+        diff = sqrt(dx * dx + dy * dy);
+        percent += 0.0005 * amt;
+    }
+}
+
+/* Draws bezier curves between given points, and if caps is true then draws an
+ * endcap at the end of the last line. */
+static GpStatus draw_polybezier(GpGraphics *graphics, GpPen *pen,
+    GDIPCONST GpPointF * pt, INT count, BOOL caps)
+{
+    POINT *pti;
+    GpPointF *ptcopy;
+    GpStatus status = GenericError;
+
+    if(!count)
+        return Ok;
+
+    pti = GdipAlloc(count * sizeof(POINT));
+    ptcopy = GdipAlloc(count * sizeof(GpPointF));
+
+    if(!pti || !ptcopy){
+        status = OutOfMemory;
+        goto end;
+    }
+
+    memcpy(ptcopy, pt, count * sizeof(GpPointF));
+
+    if(caps){
+        if(pen->endcap == LineCapArrowAnchor)
+            shorten_bezier_amt(&ptcopy[count-4], pen->width, FALSE);
+        else if((pen->endcap == LineCapCustom) && pen->customend)
+            shorten_bezier_amt(&ptcopy[count-4], pen->width * pen->customend->inset,
+                               FALSE);
+
+        if(pen->startcap == LineCapArrowAnchor)
+            shorten_bezier_amt(ptcopy, pen->width, TRUE);
+        else if((pen->startcap == LineCapCustom) && pen->customstart)
+            shorten_bezier_amt(ptcopy, pen->width * pen->customstart->inset, TRUE);
+
+        /* the direction of the line cap is parallel to the direction at the
+         * end of the bezier (which, if it has been shortened, is not the same
+         * as the direction from pt[count-2] to pt[count-1]) */
+        draw_cap(graphics, pen->brush->lb.lbColor, pen->endcap, pen->width, pen->customend,
+            pt[count - 1].X - (ptcopy[count - 1].X - ptcopy[count - 2].X),
+            pt[count - 1].Y - (ptcopy[count - 1].Y - ptcopy[count - 2].Y),
+            pt[count - 1].X, pt[count - 1].Y);
+
+        draw_cap(graphics, pen->brush->lb.lbColor, pen->startcap, pen->width, pen->customstart,
+            pt[0].X - (ptcopy[0].X - ptcopy[1].X),
+            pt[0].Y - (ptcopy[0].Y - ptcopy[1].Y), pt[0].X, pt[0].Y);
+    }
+
+    transform_and_round_points(graphics, pti, ptcopy, count);
+
+    PolyBezier(graphics->hdc, pti, count);
+
+    status = Ok;
+
+end:
+    GdipFree(pti);
+    GdipFree(ptcopy);
+
+    return status;
+}
+
+/* Draws a combination of bezier curves and lines between points. */
+static GpStatus draw_poly(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPointF * pt,
+    GDIPCONST BYTE * types, INT count, BOOL caps)
+{
+    POINT *pti = GdipAlloc(count * sizeof(POINT));
+    BYTE *tp = GdipAlloc(count);
+    GpPointF *ptcopy = GdipAlloc(count * sizeof(GpPointF));
+    INT i, j;
+    GpStatus status = GenericError;
+
+    if(!count){
+        status = Ok;
+        goto end;
+    }
+    if(!pti || !tp || !ptcopy){
+        status = OutOfMemory;
+        goto end;
+    }
+
+    for(i = 1; i < count; i++){
+        if((types[i] & PathPointTypePathTypeMask) == PathPointTypeBezier){
+            if((i + 2 >= count) || !(types[i + 1] & PathPointTypeBezier)
+                || !(types[i + 1] & PathPointTypeBezier)){
+                ERR("Bad bezier points\n");
+                goto end;
+            }
+            i += 2;
+        }
+    }
+
+    memcpy(ptcopy, pt, count * sizeof(GpPointF));
+
+    /* If we are drawing caps, go through the points and adjust them accordingly,
+     * and draw the caps. */
+    if(caps){
+        switch(types[count - 1] & PathPointTypePathTypeMask){
+            case PathPointTypeBezier:
+                if(pen->endcap == LineCapArrowAnchor)
+                    shorten_bezier_amt(&ptcopy[count - 4], pen->width, FALSE);
+                else if((pen->endcap == LineCapCustom) && pen->customend)
+                    shorten_bezier_amt(&ptcopy[count - 4],
+                                       pen->width * pen->customend->inset, FALSE);
+
+                draw_cap(graphics, pen->brush->lb.lbColor, pen->endcap, pen->width, pen->customend,
+                    pt[count - 1].X - (ptcopy[count - 1].X - ptcopy[count - 2].X),
+                    pt[count - 1].Y - (ptcopy[count - 1].Y - ptcopy[count - 2].Y),
+                    pt[count - 1].X, pt[count - 1].Y);
+
+                break;
+            case PathPointTypeLine:
+                if(pen->endcap == LineCapArrowAnchor)
+                    shorten_line_amt(ptcopy[count - 2].X, ptcopy[count - 2].Y,
+                                     &ptcopy[count - 1].X, &ptcopy[count - 1].Y,
+                                     pen->width);
+                else if((pen->endcap == LineCapCustom) && pen->customend)
+                    shorten_line_amt(ptcopy[count - 2].X, ptcopy[count - 2].Y,
+                                     &ptcopy[count - 1].X, &ptcopy[count - 1].Y,
+                                     pen->customend->inset * pen->width);
+
+                draw_cap(graphics, pen->brush->lb.lbColor, pen->endcap, pen->width, pen->customend,
+                         pt[count - 2].X, pt[count - 2].Y, pt[count - 1].X,
+                         pt[count - 1].Y);
+
+                break;
+            default:
+                ERR("Bad path last point\n");
+                goto end;
+        }
+
+        /* Find start of points */
+        for(j = 1; j < count && ((types[j] & PathPointTypePathTypeMask)
+            == PathPointTypeStart); j++);
+
+        switch(types[j] & PathPointTypePathTypeMask){
+            case PathPointTypeBezier:
+                if(pen->startcap == LineCapArrowAnchor)
+                    shorten_bezier_amt(&ptcopy[j - 1], pen->width, TRUE);
+                else if((pen->startcap == LineCapCustom) && pen->customstart)
+                    shorten_bezier_amt(&ptcopy[j - 1],
+                                       pen->width * pen->customstart->inset, TRUE);
+
+                draw_cap(graphics, pen->brush->lb.lbColor, pen->startcap, pen->width, pen->customstart,
+                    pt[j - 1].X - (ptcopy[j - 1].X - ptcopy[j].X),
+                    pt[j - 1].Y - (ptcopy[j - 1].Y - ptcopy[j].Y),
+                    pt[j - 1].X, pt[j - 1].Y);
+
+                break;
+            case PathPointTypeLine:
+                if(pen->startcap == LineCapArrowAnchor)
+                    shorten_line_amt(ptcopy[j].X, ptcopy[j].Y,
+                                     &ptcopy[j - 1].X, &ptcopy[j - 1].Y,
+                                     pen->width);
+                else if((pen->startcap == LineCapCustom) && pen->customstart)
+                    shorten_line_amt(ptcopy[j].X, ptcopy[j].Y,
+                                     &ptcopy[j - 1].X, &ptcopy[j - 1].Y,
+                                     pen->customstart->inset * pen->width);
+
+                draw_cap(graphics, pen->brush->lb.lbColor, pen->startcap, pen->width, pen->customstart,
+                         pt[j].X, pt[j].Y, pt[j - 1].X,
+                         pt[j - 1].Y);
+
+                break;
+            default:
+                ERR("Bad path points\n");
+                goto end;
+        }
+    }
+
+    transform_and_round_points(graphics, pti, ptcopy, count);
+
+    for(i = 0; i < count; i++){
+        tp[i] = convert_path_point_type(types[i]);
+    }
+
+    PolyDraw(graphics->hdc, pti, tp, count);
+
+    status = Ok;
+
+end:
+    GdipFree(pti);
+    GdipFree(ptcopy);
+    GdipFree(tp);
+
+    return status;
+}
+
+GpStatus WINGDIPAPI GdipCreateFromHDC(HDC hdc, GpGraphics **graphics)
+{
+    return GdipCreateFromHDC2(hdc, NULL, graphics);
+}
+
+GpStatus WINGDIPAPI GdipCreateFromHDC2(HDC hdc, HANDLE hDevice, GpGraphics **graphics)
+{
+    GpStatus retval;
+
+    if(hDevice != NULL) {
+        FIXME("Don't know how to hadle parameter hDevice\n");
+        return NotImplemented;
+    }
+
+    if(hdc == NULL)
+        return OutOfMemory;
+
+    if(graphics == NULL)
+        return InvalidParameter;
+
+    *graphics = GdipAlloc(sizeof(GpGraphics));
+    if(!*graphics)  return OutOfMemory;
+
+    if((retval = GdipCreateMatrix(&(*graphics)->worldtrans)) != Ok){
+        GdipFree(*graphics);
+        return retval;
+    }
+
+    (*graphics)->hdc = hdc;
+    (*graphics)->hwnd = NULL;
+    (*graphics)->smoothing = SmoothingModeDefault;
+    (*graphics)->compqual = CompositingQualityDefault;
+    (*graphics)->interpolation = InterpolationModeDefault;
+    (*graphics)->pixeloffset = PixelOffsetModeDefault;
+    (*graphics)->compmode = CompositingModeSourceOver;
+    (*graphics)->unit = UnitDisplay;
+    (*graphics)->scale = 1.0;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipCreateFromHWND(HWND hwnd, GpGraphics **graphics)
+{
+    GpStatus ret;
+
+    if((ret = GdipCreateFromHDC(GetDC(hwnd), graphics)) != Ok)
+        return ret;
+
+    (*graphics)->hwnd = hwnd;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipCreateMetafileFromEmf(HENHMETAFILE hemf, BOOL delete,
+    GpMetafile **metafile)
+{
+    static int calls;
+
+    if(!hemf || !metafile)
+        return InvalidParameter;
+
+    if(!(calls++))
+        FIXME("not implemented\n");
+
+    return NotImplemented;
+}
+
+GpStatus WINGDIPAPI GdipCreateMetafileFromWmf(HMETAFILE hwmf, BOOL delete,
+    GDIPCONST WmfPlaceableFileHeader * placeable, GpMetafile **metafile)
+{
+    IStream *stream = NULL;
+    UINT read;
+    BYTE* copy;
+    HENHMETAFILE hemf;
+    GpStatus retval = GenericError;
+
+    if(!hwmf || !metafile || !placeable)
+        return InvalidParameter;
+
+    *metafile = NULL;
+    read = GetMetaFileBitsEx(hwmf, 0, NULL);
+    if(!read)
+        return GenericError;
+    copy = GdipAlloc(read);
+    GetMetaFileBitsEx(hwmf, read, copy);
+
+    hemf = SetWinMetaFileBits(read, copy, NULL, NULL);
+    GdipFree(copy);
+
+    read = GetEnhMetaFileBits(hemf, 0, NULL);
+    copy = GdipAlloc(read);
+    GetEnhMetaFileBits(hemf, read, copy);
+    DeleteEnhMetaFile(hemf);
+
+    if(CreateStreamOnHGlobal(copy, TRUE, &stream) != S_OK){
+        ERR("could not make stream\n");
+        GdipFree(copy);
+        goto err;
+    }
+
+    *metafile = GdipAlloc(sizeof(GpMetafile));
+    if(!*metafile){
+        retval = OutOfMemory;
+        goto err;
+    }
+
+    if(OleLoadPicture(stream, 0, FALSE, &IID_IPicture,
+        (LPVOID*) &((*metafile)->image.picture)) != S_OK)
+        goto err;
+
+
+    (*metafile)->image.type = ImageTypeMetafile;
+    (*metafile)->bounds.X = ((REAL) placeable->BoundingBox.Left) / ((REAL) placeable->Inch);
+    (*metafile)->bounds.Y = ((REAL) placeable->BoundingBox.Right) / ((REAL) placeable->Inch);
+    (*metafile)->bounds.Width = ((REAL) (placeable->BoundingBox.Right
+                    - placeable->BoundingBox.Left)) / ((REAL) placeable->Inch);
+    (*metafile)->bounds.Height = ((REAL) (placeable->BoundingBox.Bottom
+                   - placeable->BoundingBox.Top)) / ((REAL) placeable->Inch);
+    (*metafile)->unit = UnitInch;
+
+    if(delete)
+        DeleteMetaFile(hwmf);
+
+    return Ok;
+
+err:
+    GdipFree(*metafile);
+    IStream_Release(stream);
+    return retval;
+}
+
+GpStatus WINGDIPAPI GdipCreateStreamOnFile(GDIPCONST WCHAR * filename,
+    UINT access, IStream **stream)
+{
+    DWORD dwMode;
+    HRESULT ret;
+
+    if(!stream || !filename)
+        return InvalidParameter;
+
+    if(access & GENERIC_WRITE)
+        dwMode = STGM_SHARE_DENY_WRITE | STGM_WRITE | STGM_CREATE;
+    else if(access & GENERIC_READ)
+        dwMode = STGM_SHARE_DENY_WRITE | STGM_READ | STGM_FAILIFTHERE;
+    else
+        return InvalidParameter;
+
+    ret = SHCreateStreamOnFileW(filename, dwMode, stream);
+
+    return hresult_to_status(ret);
+}
+
+GpStatus WINGDIPAPI GdipDeleteGraphics(GpGraphics *graphics)
+{
+    if(!graphics) return InvalidParameter;
+    if(graphics->hwnd)
+        ReleaseDC(graphics->hwnd, graphics->hdc);
+
+    GdipDeleteMatrix(graphics->worldtrans);
+    HeapFree(GetProcessHeap(), 0, graphics);
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipDrawArc(GpGraphics *graphics, GpPen *pen, REAL x,
+    REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
+{
+    INT save_state, num_pts;
+    GpPointF points[MAX_ARC_PTS];
+    GpStatus retval;
+
+    if(!graphics || !pen || width <= 0 || height <= 0)
+        return InvalidParameter;
+
+    num_pts = arc2polybezier(points, x, y, width, height, startAngle, sweepAngle);
+
+    save_state = prepare_dc(graphics, pen);
+
+    retval = draw_polybezier(graphics, pen, points, num_pts, TRUE);
+
+    restore_dc(graphics, save_state);
+
+    return retval;
+}
+
+GpStatus WINGDIPAPI GdipDrawArcI(GpGraphics *graphics, GpPen *pen, INT x,
+    INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
+{
+    INT save_state, num_pts;
+    GpPointF points[MAX_ARC_PTS];
+    GpStatus retval;
+
+    if(!graphics || !pen || width <= 0 || height <= 0)
+        return InvalidParameter;
+
+    num_pts = arc2polybezier(points, x, y, width, height, startAngle, sweepAngle);
+
+    save_state = prepare_dc(graphics, pen);
+
+    retval = draw_polybezier(graphics, pen, points, num_pts, TRUE);
+
+    restore_dc(graphics, save_state);
+
+    return retval;
+}
+
+GpStatus WINGDIPAPI GdipDrawBezier(GpGraphics *graphics, GpPen *pen, REAL x1,
+    REAL y1, REAL x2, REAL y2, REAL x3, REAL y3, REAL x4, REAL y4)
+{
+    INT save_state;
+    GpPointF pt[4];
+    GpStatus retval;
+
+    if(!graphics || !pen)
+        return InvalidParameter;
+
+    pt[0].X = x1;
+    pt[0].Y = y1;
+    pt[1].X = x2;
+    pt[1].Y = y2;
+    pt[2].X = x3;
+    pt[2].Y = y3;
+    pt[3].X = x4;
+    pt[3].Y = y4;
+
+    save_state = prepare_dc(graphics, pen);
+
+    retval = draw_polybezier(graphics, pen, pt, 4, TRUE);
+
+    restore_dc(graphics, save_state);
+
+    return retval;
+}
+
+GpStatus WINGDIPAPI GdipDrawBezierI(GpGraphics *graphics, GpPen *pen, INT x1,
+    INT y1, INT x2, INT y2, INT x3, INT y3, INT x4, INT y4)
+{
+    INT save_state;
+    GpPointF pt[4];
+    GpStatus retval;
+
+    if(!graphics || !pen)
+        return InvalidParameter;
+
+    pt[0].X = x1;
+    pt[0].Y = y1;
+    pt[1].X = x2;
+    pt[1].Y = y2;
+    pt[2].X = x3;
+    pt[2].Y = y3;
+    pt[3].X = x4;
+    pt[3].Y = y4;
+
+    save_state = prepare_dc(graphics, pen);
+
+    retval = draw_polybezier(graphics, pen, pt, 4, TRUE);
+
+    restore_dc(graphics, save_state);
+
+    return retval;
+}
+
+/* Approximates cardinal spline with Bezier curves. */
+GpStatus WINGDIPAPI GdipDrawCurve2(GpGraphics *graphics, GpPen *pen,
+    GDIPCONST GpPointF *points, INT count, REAL tension)
+{
+    /* PolyBezier expects count*3-2 points. */
+    INT i, len_pt = count*3-2, save_state;
+    GpPointF *pt;
+    REAL x1, x2, y1, y2;
+    GpStatus retval;
+
+    if(!graphics || !pen)
+        return InvalidParameter;
+
+    pt = GdipAlloc(len_pt * sizeof(GpPointF));
+    tension = tension * TENSION_CONST;
+
+    calc_curve_bezier_endp(points[0].X, points[0].Y, points[1].X, points[1].Y,
+        tension, &x1, &y1);
+
+    pt[0].X = points[0].X;
+    pt[0].Y = points[0].Y;
+    pt[1].X = x1;
+    pt[1].Y = y1;
+
+    for(i = 0; i < count-2; i++){
+        calc_curve_bezier(&(points[i]), tension, &x1, &y1, &x2, &y2);
+
+        pt[3*i+2].X = x1;
+        pt[3*i+2].Y = y1;
+        pt[3*i+3].X = points[i+1].X;
+        pt[3*i+3].Y = points[i+1].Y;
+        pt[3*i+4].X = x2;
+        pt[3*i+4].Y = y2;
+    }
+
+    calc_curve_bezier_endp(points[count-1].X, points[count-1].Y,
+        points[count-2].X, points[count-2].Y, tension, &x1, &y1);
+
+    pt[len_pt-2].X = x1;
+    pt[len_pt-2].Y = y1;
+    pt[len_pt-1].X = points[count-1].X;
+    pt[len_pt-1].Y = points[count-1].Y;
+
+    save_state = prepare_dc(graphics, pen);
+
+    retval = draw_polybezier(graphics, pen, pt, len_pt, TRUE);
+
+    GdipFree(pt);
+    restore_dc(graphics, save_state);
+
+    return retval;
+}
+
+GpStatus WINGDIPAPI GdipDrawImageI(GpGraphics *graphics, GpImage *image, INT x,
+    INT y)
+{
+    UINT width, height, srcw, srch;
+
+    if(!graphics || !image)
+        return InvalidParameter;
+
+    GdipGetImageWidth(image, &width);
+    GdipGetImageHeight(image, &height);
+
+    srcw = width * (((REAL) INCH_HIMETRIC) /
+            ((REAL) GetDeviceCaps(graphics->hdc, LOGPIXELSX)));
+    srch = height * (((REAL) INCH_HIMETRIC) /
+            ((REAL) GetDeviceCaps(graphics->hdc, LOGPIXELSY)));
+
+    if(image->type != ImageTypeMetafile){
+        y += height;
+        height *= -1;
+    }
+
+    IPicture_Render(image->picture, graphics->hdc, x, y, width, height,
+                    0, 0, srcw, srch, NULL);
+
+    return Ok;
+}
+
+/* FIXME: partially implemented (only works for rectangular parallelograms) */
+GpStatus WINGDIPAPI GdipDrawImagePointsRect(GpGraphics *graphics, GpImage *image,
+     GDIPCONST GpPointF *points, INT count, REAL srcx, REAL srcy, REAL srcwidth,
+     REAL srcheight, GpUnit srcUnit, GDIPCONST GpImageAttributes* imageAttributes,
+     DrawImageAbort callback, VOID * callbackData)
+{
+    GpPointF ptf[3];
+    POINT pti[3];
+    REAL dx, dy;
+
+    TRACE("%p %p %p %d %f %f %f %f %d %p %p %p\n", graphics, image, points, count,
+          srcx, srcy, srcwidth, srcheight, srcUnit, imageAttributes, callback,
+          callbackData);
+
+    if(!graphics || !image || !points || !imageAttributes || count != 3)
+         return InvalidParameter;
+
+    if(srcUnit == UnitInch)
+        dx = dy = (REAL) INCH_HIMETRIC;
+    else if(srcUnit == UnitPixel){
+        dx = ((REAL) INCH_HIMETRIC) /
+             ((REAL) GetDeviceCaps(graphics->hdc, LOGPIXELSX));
+        dy = ((REAL) INCH_HIMETRIC) /
+             ((REAL) GetDeviceCaps(graphics->hdc, LOGPIXELSY));
+    }
+    else
+        return NotImplemented;
+
+    memcpy(ptf, points, 3 * sizeof(GpPointF));
+    transform_and_round_points(graphics, pti, ptf, 3);
+
+    /* IPicture renders bitmaps with the y-axis reversed
+     * FIXME: flipping for unknown image type might not be correct. */
+    if(image->type != ImageTypeMetafile){
+        INT temp;
+        temp = pti[0].y;
+        pti[0].y = pti[2].y;
+        pti[2].y = temp;
+    }
+
+    if(IPicture_Render(image->picture, graphics->hdc,
+        pti[0].x, pti[0].y, pti[1].x - pti[0].x, pti[2].y - pti[0].y,
+        srcx * dx, srcy * dy,
+        srcwidth * dx, srcheight * dy,
+        NULL) != S_OK){
+        if(callback)
+            callback(callbackData);
+        return GenericError;
+    }
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipDrawImageRectRect(GpGraphics *graphics, GpImage *image,
+    REAL dstx, REAL dsty, REAL dstwidth, REAL dstheight, REAL srcx, REAL srcy,
+    REAL srcwidth, REAL srcheight, GpUnit srcUnit,
+    GDIPCONST GpImageAttributes* imageattr, DrawImageAbort callback,
+    VOID * callbackData)
+{
+    GpPointF points[3];
+
+    points[0].X = dstx;
+    points[0].Y = dsty;
+    points[1].X = dstx + dstwidth;
+    points[1].Y = dsty;
+    points[2].X = dstx;
+    points[2].Y = dsty + dstheight;
+
+    return GdipDrawImagePointsRect(graphics, image, points, 3, srcx, srcy,
+               srcwidth, srcheight, srcUnit, imageattr, callback, callbackData);
+}
+
+GpStatus WINGDIPAPI GdipDrawImageRectRectI(GpGraphics *graphics, GpImage *image,
+       INT dstx, INT dsty, INT dstwidth, INT dstheight, INT srcx, INT srcy,
+       INT srcwidth, INT srcheight, GpUnit srcUnit,
+       GDIPCONST GpImageAttributes* imageAttributes, DrawImageAbort callback,
+       VOID * callbackData)
+{
+   GpPointF points[3];
+
+    points[0].X = dstx;
+    points[0].Y = dsty;
+    points[1].X = dstx + dstwidth;
+    points[1].Y = dsty;
+    points[2].X = dstx;
+    points[2].Y = dsty + dstheight;
+
+    return GdipDrawImagePointsRect(graphics, image, points, 3, srcx, srcy,
+               srcwidth, srcheight, srcUnit, imageAttributes, callback, callbackData);
+}
+
+GpStatus WINGDIPAPI GdipDrawLine(GpGraphics *graphics, GpPen *pen, REAL x1,
+    REAL y1, REAL x2, REAL y2)
+{
+    INT save_state;
+    GpPointF pt[2];
+    GpStatus retval;
+
+    if(!pen || !graphics)
+        return InvalidParameter;
+
+    pt[0].X = x1;
+    pt[0].Y = y1;
+    pt[1].X = x2;
+    pt[1].Y = y2;
+
+    save_state = prepare_dc(graphics, pen);
+
+    retval = draw_polyline(graphics, pen, pt, 2, TRUE);
+
+    restore_dc(graphics, save_state);
+
+    return retval;
+}
+
+GpStatus WINGDIPAPI GdipDrawLineI(GpGraphics *graphics, GpPen *pen, INT x1,
+    INT y1, INT x2, INT y2)
+{
+    INT save_state;
+    GpPointF pt[2];
+    GpStatus retval;
+
+    if(!pen || !graphics)
+        return InvalidParameter;
+
+    pt[0].X = (REAL)x1;
+    pt[0].Y = (REAL)y1;
+    pt[1].X = (REAL)x2;
+    pt[1].Y = (REAL)y2;
+
+    save_state = prepare_dc(graphics, pen);
+
+    retval = draw_polyline(graphics, pen, pt, 2, TRUE);
+
+    restore_dc(graphics, save_state);
+
+    return retval;
+}
+
+GpStatus WINGDIPAPI GdipDrawLines(GpGraphics *graphics, GpPen *pen, GDIPCONST
+    GpPointF *points, INT count)
+{
+    INT save_state;
+    GpStatus retval;
+
+    if(!pen || !graphics || (count < 2))
+        return InvalidParameter;
+
+    save_state = prepare_dc(graphics, pen);
+
+    retval = draw_polyline(graphics, pen, points, count, TRUE);
+
+    restore_dc(graphics, save_state);
+
+    return retval;
+}
+
+GpStatus WINGDIPAPI GdipDrawLinesI(GpGraphics *graphics, GpPen *pen, GDIPCONST
+    GpPoint *points, INT count)
+{
+    INT save_state;
+    GpStatus retval;
+    GpPointF *ptf = NULL;
+    int i;
+
+    if(!pen || !graphics || (count < 2))
+        return InvalidParameter;
+
+    ptf = GdipAlloc(count * sizeof(GpPointF));
+    if(!ptf) return OutOfMemory;
+
+    for(i = 0; i < count; i ++){
+        ptf[i].X = (REAL) points[i].X;
+        ptf[i].Y = (REAL) points[i].Y;
+    }
+
+    save_state = prepare_dc(graphics, pen);
+
+    retval = draw_polyline(graphics, pen, ptf, count, TRUE);
+
+    restore_dc(graphics, save_state);
+
+    GdipFree(ptf);
+    return retval;
+}
+
+GpStatus WINGDIPAPI GdipDrawPath(GpGraphics *graphics, GpPen *pen, GpPath *path)
+{
+    INT save_state;
+    GpStatus retval;
+
+    if(!pen || !graphics)
+        return InvalidParameter;
+
+    save_state = prepare_dc(graphics, pen);
+
+    retval = draw_poly(graphics, pen, path->pathdata.Points,
+                       path->pathdata.Types, path->pathdata.Count, TRUE);
+
+    restore_dc(graphics, save_state);
+
+    return retval;
+}
+
+GpStatus WINGDIPAPI GdipDrawPie(GpGraphics *graphics, GpPen *pen, REAL x,
+    REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
+{
+    INT save_state;
+
+    if(!graphics || !pen)
+        return InvalidParameter;
+
+    save_state = prepare_dc(graphics, pen);
+    SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
+
+    draw_pie(graphics, x, y, width, height, startAngle, sweepAngle);
+
+    restore_dc(graphics, save_state);
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipDrawRectangleI(GpGraphics *graphics, GpPen *pen, INT x,
+    INT y, INT width, INT height)
+{
+    INT save_state;
+    GpPointF ptf[4];
+    POINT pti[4];
+
+    if(!pen || !graphics)
+        return InvalidParameter;
+
+    ptf[0].X = x;
+    ptf[0].Y = y;
+    ptf[1].X = x + width;
+    ptf[1].Y = y;
+    ptf[2].X = x + width;
+    ptf[2].Y = y + height;
+    ptf[3].X = x;
+    ptf[3].Y = y + height;
+
+    save_state = prepare_dc(graphics, pen);
+    SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
+
+    transform_and_round_points(graphics, pti, ptf, 4);
+    Polygon(graphics->hdc, pti, 4);
+
+    restore_dc(graphics, save_state);
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipDrawRectangles(GpGraphics *graphics, GpPen *pen,
+    GDIPCONST GpRectF* rects, INT count)
+{
+    GpPointF *ptf;
+    POINT *pti;
+    INT save_state, i;
+
+    if(!graphics || !pen || !rects || count < 1)
+        return InvalidParameter;
+
+    ptf = GdipAlloc(4 * count * sizeof(GpPointF));
+    pti = GdipAlloc(4 * count * sizeof(POINT));
+
+    if(!ptf || !pti){
+        GdipFree(ptf);
+        GdipFree(pti);
+        return OutOfMemory;
+    }
+
+    for(i = 0; i < count; i++){
+        ptf[4 * i + 3].X = ptf[4 * i].X = rects[i].X;
+        ptf[4 * i + 1].Y = ptf[4 * i].Y = rects[i].Y;
+        ptf[4 * i + 2].X = ptf[4 * i + 1].X = rects[i].X + rects[i].Width;
+        ptf[4 * i + 3].Y = ptf[4 * i + 2].Y = rects[i].Y + rects[i].Height;
+    }
+
+    save_state = prepare_dc(graphics, pen);
+    SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
+
+    transform_and_round_points(graphics, pti, ptf, 4 * count);
+
+    for(i = 0; i < count; i++)
+        Polygon(graphics->hdc, &pti[4 * i], 4);
+
+    restore_dc(graphics, save_state);
+
+    GdipFree(ptf);
+    GdipFree(pti);
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipDrawString(GpGraphics *graphics, GDIPCONST WCHAR *string,
+    INT length, GDIPCONST GpFont *font, GDIPCONST RectF *rect,
+    GDIPCONST GpStringFormat *format, GDIPCONST GpBrush *brush)
+{
+    HRGN rgn = NULL;
+    HFONT gdifont;
+    LOGFONTW lfw;
+    TEXTMETRICW textmet;
+    GpPointF pt[2], rectcpy[4];
+    POINT corners[4];
+    WCHAR* stringdup;
+    REAL angle, ang_cos, ang_sin, rel_width, rel_height;
+    INT sum = 0, height = 0, fit, fitcpy, save_state, i, j, lret, nwidth,
+        nheight;
+    SIZE size;
+    RECT drawcoord;
+
+    if(!graphics || !string || !font || !brush || !rect)
+        return InvalidParameter;
+
+    if((brush->bt != BrushTypeSolidColor)){
+        FIXME("not implemented for given parameters\n");
+        return NotImplemented;
+    }
+
+    if(format)
+        TRACE("may be ignoring some format flags: attr %x\n", format->attr);
+
+    if(length == -1) length = lstrlenW(string);
+
+    stringdup = GdipAlloc(length * sizeof(WCHAR));
+    if(!stringdup) return OutOfMemory;
+
+    save_state = SaveDC(graphics->hdc);
+    SetBkMode(graphics->hdc, TRANSPARENT);
+    SetTextColor(graphics->hdc, brush->lb.lbColor);
+
+    rectcpy[3].X = rectcpy[0].X = rect->X;
+    rectcpy[1].Y = rectcpy[0].Y = rect->Y;
+    rectcpy[2].X = rectcpy[1].X = rect->X + rect->Width;
+    rectcpy[3].Y = rectcpy[2].Y = rect->Y + rect->Height;
+    transform_and_round_points(graphics, corners, rectcpy, 4);
+
+    if(roundr(rect->Width) == 0 && roundr(rect->Height) == 0){
+        rel_width = rel_height = 1.0;
+        nwidth = nheight = INT_MAX;
+    }
+    else{
+        rel_width = sqrt((corners[1].x - corners[0].x) * (corners[1].x - corners[0].x) +
+                         (corners[1].y - corners[0].y) * (corners[1].y - corners[0].y))
+                         / rect->Width;
+        rel_height = sqrt((corners[2].x - corners[1].x) * (corners[2].x - corners[1].x) +
+                          (corners[2].y - corners[1].y) * (corners[2].y - corners[1].y))
+                          / rect->Height;
+
+        nwidth = roundr(rel_width * rect->Width);
+        nheight = roundr(rel_height * rect->Height);
+        rgn = CreatePolygonRgn(corners, 4, ALTERNATE);
+        SelectClipRgn(graphics->hdc, rgn);
+    }
+
+    /* Use gdi to find the font, then perform transformations on it (height,
+     * width, angle). */
+    SelectObject(graphics->hdc, CreateFontIndirectW(&font->lfw));
+    GetTextMetricsW(graphics->hdc, &textmet);
+    lfw = font->lfw;
+
+    lfw.lfHeight = roundr(((REAL)lfw.lfHeight) * rel_height);
+    lfw.lfWidth = roundr(textmet.tmAveCharWidth * rel_width);
+
+    pt[0].X = 0.0;
+    pt[0].Y = 0.0;
+    pt[1].X = 1.0;
+    pt[1].Y = 0.0;
+    GdipTransformMatrixPoints(graphics->worldtrans, pt, 2);
+    angle = gdiplus_atan2((pt[1].Y - pt[0].Y), (pt[1].X - pt[0].X));
+    ang_cos = cos(angle);
+    ang_sin = sin(angle);
+    lfw.lfEscapement = lfw.lfOrientation = -roundr((angle / M_PI) * 1800.0);
+
+    gdifont = CreateFontIndirectW(&lfw);
+    DeleteObject(SelectObject(graphics->hdc, CreateFontIndirectW(&lfw)));
+
+    for(i = 0, j = 0; i < length; i++){
+        if(!isprint(string[i]) && (string[i] != '\n'))
+            continue;
+
+        stringdup[j] = string[i];
+        j++;
+    }
+
+    stringdup[j] = 0;
+    length = j;
+
+    while(sum < length){
+        drawcoord.left = corners[0].x + roundr(ang_sin * (REAL) height);
+        drawcoord.top = corners[0].y + roundr(ang_cos * (REAL) height);
+
+        GetTextExtentExPointW(graphics->hdc, stringdup + sum, length - sum,
+                              nwidth, &fit, NULL, &size);
+        fitcpy = fit;
+
+        if(fit == 0){
+            DrawTextW(graphics->hdc, stringdup + sum, 1, &drawcoord, DT_NOCLIP |
+                      DT_EXPANDTABS);
+            break;
+        }
+
+        for(lret = 0; lret < fit; lret++)
+            if(*(stringdup + sum + lret) == '\n')
+                break;
+
+        /* Line break code (may look strange, but it imitates windows). */
+        if(lret < fit)
+            fit = lret;    /* this is not an off-by-one error */
+        else if(fit < (length - sum)){
+            if(*(stringdup + sum + fit) == ' ')
+                while(*(stringdup + sum + fit) == ' ')
+                    fit++;
+            else
+                while(*(stringdup + sum + fit - 1) != ' '){
+                    fit--;
+
+                    if(*(stringdup + sum + fit) == '\t')
+                        break;
+
+                    if(fit == 0){
+                        fit = fitcpy;
+                        break;
+                    }
+                }
+        }
+        DrawTextW(graphics->hdc, stringdup + sum, min(length - sum, fit),
+                  &drawcoord, DT_NOCLIP | DT_EXPANDTABS);
+
+        sum += fit + (lret < fitcpy ? 1 : 0);
+        height += size.cy;
+
+        if(height > nheight)
+            break;
+
+        /* Stop if this was a linewrap (but not if it was a linebreak). */
+        if((lret == fitcpy) && format && (format->attr & StringFormatFlagsNoWrap))
+            break;
+    }
+
+    GdipFree(stringdup);
+    DeleteObject(rgn);
+    DeleteObject(gdifont);
+
+    RestoreDC(graphics->hdc, save_state);
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipFillPath(GpGraphics *graphics, GpBrush *brush, GpPath *path)
+{
+    INT save_state;
+    GpStatus retval;
+
+    if(!brush || !graphics || !path)
+        return InvalidParameter;
+
+    save_state = SaveDC(graphics->hdc);
+    EndPath(graphics->hdc);
+    SelectObject(graphics->hdc, brush->gdibrush);
+    SetPolyFillMode(graphics->hdc, (path->fill == FillModeAlternate ? ALTERNATE
+                                                                    : WINDING));
+
+    BeginPath(graphics->hdc);
+    retval = draw_poly(graphics, NULL, path->pathdata.Points,
+                       path->pathdata.Types, path->pathdata.Count, FALSE);
+
+    if(retval != Ok)
+        goto end;
+
+    EndPath(graphics->hdc);
+    FillPath(graphics->hdc);
+
+    retval = Ok;
+
+end:
+    RestoreDC(graphics->hdc, save_state);
+
+    return retval;
+}
+
+GpStatus WINGDIPAPI GdipFillPie(GpGraphics *graphics, GpBrush *brush, REAL x,
+    REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
+{
+    INT save_state;
+
+    if(!graphics || !brush)
+        return InvalidParameter;
+
+    save_state = SaveDC(graphics->hdc);
+    EndPath(graphics->hdc);
+    SelectObject(graphics->hdc, brush->gdibrush);
+    SelectObject(graphics->hdc, GetStockObject(NULL_PEN));
+
+    draw_pie(graphics, x, y, width, height, startAngle, sweepAngle);
+
+    RestoreDC(graphics->hdc, save_state);
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipFillPolygon(GpGraphics *graphics, GpBrush *brush,
+    GDIPCONST GpPointF *points, INT count, GpFillMode fillMode)
+{
+    INT save_state;
+    GpPointF *ptf = NULL;
+    POINT *pti = NULL;
+    GpStatus retval = Ok;
+
+    if(!graphics || !brush || !points || !count)
+        return InvalidParameter;
+
+    ptf = GdipAlloc(count * sizeof(GpPointF));
+    pti = GdipAlloc(count * sizeof(POINT));
+    if(!ptf || !pti){
+        retval = OutOfMemory;
+        goto end;
+    }
+
+    memcpy(ptf, points, count * sizeof(GpPointF));
+
+    save_state = SaveDC(graphics->hdc);
+    EndPath(graphics->hdc);
+    SelectObject(graphics->hdc, brush->gdibrush);
+    SelectObject(graphics->hdc, GetStockObject(NULL_PEN));
+    SetPolyFillMode(graphics->hdc, (fillMode == FillModeAlternate ? ALTERNATE
+                                                                  : WINDING));
+
+    transform_and_round_points(graphics, pti, ptf, count);
+    Polygon(graphics->hdc, pti, count);
+
+    RestoreDC(graphics->hdc, save_state);
+
+end:
+    GdipFree(ptf);
+    GdipFree(pti);
+
+    return retval;
+}
+
+GpStatus WINGDIPAPI GdipFillPolygonI(GpGraphics *graphics, GpBrush *brush,
+    GDIPCONST GpPoint *points, INT count, GpFillMode fillMode)
+{
+    INT save_state, i;
+    GpPointF *ptf = NULL;
+    POINT *pti = NULL;
+    GpStatus retval = Ok;
+
+    if(!graphics || !brush || !points || !count)
+        return InvalidParameter;
+
+    ptf = GdipAlloc(count * sizeof(GpPointF));
+    pti = GdipAlloc(count * sizeof(POINT));
+    if(!ptf || !pti){
+        retval = OutOfMemory;
+        goto end;
+    }
+
+    for(i = 0; i < count; i ++){
+        ptf[i].X = (REAL) points[i].X;
+        ptf[i].Y = (REAL) points[i].Y;
+    }
+
+    save_state = SaveDC(graphics->hdc);
+    EndPath(graphics->hdc);
+    SelectObject(graphics->hdc, brush->gdibrush);
+    SelectObject(graphics->hdc, GetStockObject(NULL_PEN));
+    SetPolyFillMode(graphics->hdc, (fillMode == FillModeAlternate ? ALTERNATE
+                                                                  : WINDING));
+
+    transform_and_round_points(graphics, pti, ptf, count);
+    Polygon(graphics->hdc, pti, count);
+
+    RestoreDC(graphics->hdc, save_state);
+
+end:
+    GdipFree(ptf);
+    GdipFree(pti);
+
+    return retval;
+}
+
+GpStatus WINGDIPAPI GdipFillRectangle(GpGraphics *graphics, GpBrush *brush,
+    REAL x, REAL y, REAL width, REAL height)
+{
+    INT save_state;
+    GpPointF ptf[4];
+    POINT pti[4];
+
+    if(!graphics || !brush)
+        return InvalidParameter;
+
+    ptf[0].X = x;
+    ptf[0].Y = y;
+    ptf[1].X = x + width;
+    ptf[1].Y = y;
+    ptf[2].X = x + width;
+    ptf[2].Y = y + height;
+    ptf[3].X = x;
+    ptf[3].Y = y + height;
+
+    save_state = SaveDC(graphics->hdc);
+    EndPath(graphics->hdc);
+    SelectObject(graphics->hdc, brush->gdibrush);
+    SelectObject(graphics->hdc, GetStockObject(NULL_PEN));
+
+    transform_and_round_points(graphics, pti, ptf, 4);
+
+    Polygon(graphics->hdc, pti, 4);
+
+    RestoreDC(graphics->hdc, save_state);
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipFillRectangleI(GpGraphics *graphics, GpBrush *brush,
+    INT x, INT y, INT width, INT height)
+{
+    INT save_state;
+    GpPointF ptf[4];
+    POINT pti[4];
+
+    if(!graphics || !brush)
+        return InvalidParameter;
+
+    ptf[0].X = x;
+    ptf[0].Y = y;
+    ptf[1].X = x + width;
+    ptf[1].Y = y;
+    ptf[2].X = x + width;
+    ptf[2].Y = y + height;
+    ptf[3].X = x;
+    ptf[3].Y = y + height;
+
+    save_state = SaveDC(graphics->hdc);
+    EndPath(graphics->hdc);
+    SelectObject(graphics->hdc, brush->gdibrush);
+    SelectObject(graphics->hdc, GetStockObject(NULL_PEN));
+
+    transform_and_round_points(graphics, pti, ptf, 4);
+
+    Polygon(graphics->hdc, pti, 4);
+
+    RestoreDC(graphics->hdc, save_state);
+
+    return Ok;
+}
+
+/* FIXME: Compositing mode is not used anywhere except the getter/setter. */
+GpStatus WINGDIPAPI GdipGetCompositingMode(GpGraphics *graphics,
+    CompositingMode *mode)
+{
+    if(!graphics || !mode)
+        return InvalidParameter;
+
+    *mode = graphics->compmode;
+
+    return Ok;
+}
+
+/* FIXME: Compositing quality is not used anywhere except the getter/setter. */
+GpStatus WINGDIPAPI GdipGetCompositingQuality(GpGraphics *graphics,
+    CompositingQuality *quality)
+{
+    if(!graphics || !quality)
+        return InvalidParameter;
+
+    *quality = graphics->compqual;
+
+    return Ok;
+}
+
+/* FIXME: Interpolation mode is not used anywhere except the getter/setter. */
+GpStatus WINGDIPAPI GdipGetInterpolationMode(GpGraphics *graphics,
+    InterpolationMode *mode)
+{
+    if(!graphics || !mode)
+        return InvalidParameter;
+
+    *mode = graphics->interpolation;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetPageScale(GpGraphics *graphics, REAL *scale)
+{
+    if(!graphics || !scale)
+        return InvalidParameter;
+
+    *scale = graphics->scale;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetPageUnit(GpGraphics *graphics, GpUnit *unit)
+{
+    if(!graphics || !unit)
+        return InvalidParameter;
+
+    *unit = graphics->unit;
+
+    return Ok;
+}
+
+/* FIXME: Pixel offset mode is not used anywhere except the getter/setter. */
+GpStatus WINGDIPAPI GdipGetPixelOffsetMode(GpGraphics *graphics, PixelOffsetMode
+    *mode)
+{
+    if(!graphics || !mode)
+        return InvalidParameter;
+
+    *mode = graphics->pixeloffset;
+
+    return Ok;
+}
+
+/* FIXME: Smoothing mode is not used anywhere except the getter/setter. */
+GpStatus WINGDIPAPI GdipGetSmoothingMode(GpGraphics *graphics, SmoothingMode *mode)
+{
+    if(!graphics || !mode)
+        return InvalidParameter;
+
+    *mode = graphics->smoothing;
+
+    return Ok;
+}
+
+/* FIXME: Text rendering hint is not used anywhere except the getter/setter. */
+GpStatus WINGDIPAPI GdipGetTextRenderingHint(GpGraphics *graphics,
+    TextRenderingHint *hint)
+{
+    if(!graphics || !hint)
+        return InvalidParameter;
+
+    *hint = graphics->texthint;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetWorldTransform(GpGraphics *graphics, GpMatrix *matrix)
+{
+    if(!graphics || !matrix)
+        return InvalidParameter;
+
+    *matrix = *graphics->worldtrans;
+    return Ok;
+}
+
+/* Find the smallest rectangle that bounds the text when it is printed in rect
+ * according to the format options listed in format. If rect has 0 width and
+ * height, then just find the smallest rectangle that bounds the text when it's
+ * printed at location (rect->X, rect-Y). */
+GpStatus WINGDIPAPI GdipMeasureString(GpGraphics *graphics,
+    GDIPCONST WCHAR *string, INT length, GDIPCONST GpFont *font,
+    GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format, RectF *bounds,
+    INT *codepointsfitted, INT *linesfilled)
+{
+    HFONT oldfont;
+    WCHAR* stringdup;
+    INT sum = 0, height = 0, fit, fitcpy, max_width = 0, i, j, lret, nwidth,
+        nheight;
+    SIZE size;
+
+    if(!graphics || !string || !font || !rect)
+        return InvalidParameter;
+
+    if(codepointsfitted || linesfilled){
+        FIXME("not implemented for given parameters\n");
+        return NotImplemented;
+    }
+
+    if(format)
+        TRACE("may be ignoring some format flags: attr %x\n", format->attr);
+
+    if(length == -1) length = lstrlenW(string);
+
+    stringdup = GdipAlloc(length * sizeof(WCHAR));
+    if(!stringdup) return OutOfMemory;
+
+    oldfont = SelectObject(graphics->hdc, CreateFontIndirectW(&font->lfw));
+    nwidth = roundr(rect->Width);
+    nheight = roundr(rect->Height);
+
+    if((nwidth == 0) && (nheight == 0))
+        nwidth = nheight = INT_MAX;
+
+    for(i = 0, j = 0; i < length; i++){
+        if(!isprint(string[i]) && (string[i] != '\n'))
+            continue;
+
+        stringdup[j] = string[i];
+        j++;
+    }
+
+    stringdup[j] = 0;
+    length = j;
+
+    while(sum < length){
+        GetTextExtentExPointW(graphics->hdc, stringdup + sum, length - sum,
+                              nwidth, &fit, NULL, &size);
+        fitcpy = fit;
+
+        if(fit == 0)
+            break;
+
+        for(lret = 0; lret < fit; lret++)
+            if(*(stringdup + sum + lret) == '\n')
+                break;
+
+        /* Line break code (may look strange, but it imitates windows). */
+        if(lret < fit)
+            fit = lret;    /* this is not an off-by-one error */
+        else if(fit < (length - sum)){
+            if(*(stringdup + sum + fit) == ' ')
+                while(*(stringdup + sum + fit) == ' ')
+                    fit++;
+            else
+                while(*(stringdup + sum + fit - 1) != ' '){
+                    fit--;
+
+                    if(*(stringdup + sum + fit) == '\t')
+                        break;
+
+                    if(fit == 0){
+                        fit = fitcpy;
+                        break;
+                    }
+                }
+        }
+
+        GetTextExtentExPointW(graphics->hdc, stringdup + sum, fit,
+                              nwidth, &j, NULL, &size);
+
+        sum += fit + (lret < fitcpy ? 1 : 0);
+        height += size.cy;
+        max_width = max(max_width, size.cx);
+
+        if(height > nheight)
+            break;
+
+        /* Stop if this was a linewrap (but not if it was a linebreak). */
+        if((lret == fitcpy) && format && (format->attr & StringFormatFlagsNoWrap))
+            break;
+    }
+
+    bounds->X = rect->X;
+    bounds->Y = rect->Y;
+    bounds->Width = (REAL)max_width;
+    bounds->Height = (REAL) min(height, nheight);
+
+    GdipFree(stringdup);
+    DeleteObject(SelectObject(graphics->hdc, oldfont));
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipRestoreGraphics(GpGraphics *graphics, GraphicsState state)
+{
+    static int calls;
+
+    if(!graphics)
+        return InvalidParameter;
+
+    if(!(calls++))
+        FIXME("graphics state not implemented\n");
+
+    return NotImplemented;
+}
+
+GpStatus WINGDIPAPI GdipRotateWorldTransform(GpGraphics *graphics, REAL angle,
+    GpMatrixOrder order)
+{
+    if(!graphics)
+        return InvalidParameter;
+
+    return GdipRotateMatrix(graphics->worldtrans, angle, order);
+}
+
+GpStatus WINGDIPAPI GdipSaveGraphics(GpGraphics *graphics, GraphicsState *state)
+{
+    static int calls;
+
+    if(!graphics || !state)
+        return InvalidParameter;
+
+    if(!(calls++))
+        FIXME("graphics state not implemented\n");
+
+    return NotImplemented;
+}
+
+GpStatus WINGDIPAPI GdipScaleWorldTransform(GpGraphics *graphics, REAL sx,
+    REAL sy, GpMatrixOrder order)
+{
+    if(!graphics)
+        return InvalidParameter;
+
+    return GdipScaleMatrix(graphics->worldtrans, sx, sy, order);
+}
+
+GpStatus WINGDIPAPI GdipSetCompositingMode(GpGraphics *graphics,
+    CompositingMode mode)
+{
+    if(!graphics)
+        return InvalidParameter;
+
+    graphics->compmode = mode;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipSetCompositingQuality(GpGraphics *graphics,
+    CompositingQuality quality)
+{
+    if(!graphics)
+        return InvalidParameter;
+
+    graphics->compqual = quality;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipSetInterpolationMode(GpGraphics *graphics,
+    InterpolationMode mode)
+{
+    if(!graphics)
+        return InvalidParameter;
+
+    graphics->interpolation = mode;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipSetPageScale(GpGraphics *graphics, REAL scale)
+{
+    if(!graphics || (scale <= 0.0))
+        return InvalidParameter;
+
+    graphics->scale = scale;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipSetPageUnit(GpGraphics *graphics, GpUnit unit)
+{
+    if(!graphics || (unit == UnitWorld))
+        return InvalidParameter;
+
+    graphics->unit = unit;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipSetPixelOffsetMode(GpGraphics *graphics, PixelOffsetMode
+    mode)
+{
+    if(!graphics)
+        return InvalidParameter;
+
+    graphics->pixeloffset = mode;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipSetSmoothingMode(GpGraphics *graphics, SmoothingMode mode)
+{
+    if(!graphics)
+        return InvalidParameter;
+
+    graphics->smoothing = mode;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipSetTextRenderingHint(GpGraphics *graphics,
+    TextRenderingHint hint)
+{
+    if(!graphics)
+        return InvalidParameter;
+
+    graphics->texthint = hint;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipSetWorldTransform(GpGraphics *graphics, GpMatrix *matrix)
+{
+    if(!graphics || !matrix)
+        return InvalidParameter;
+
+    GdipDeleteMatrix(graphics->worldtrans);
+    return GdipCloneMatrix(matrix, &graphics->worldtrans);
+}
+
+GpStatus WINGDIPAPI GdipTranslateWorldTransform(GpGraphics *graphics, REAL dx,
+    REAL dy, GpMatrixOrder order)
+{
+    if(!graphics)
+        return InvalidParameter;
+
+    return GdipTranslateMatrix(graphics->worldtrans, dx, dy, order);
+}
diff --git a/reactos/dll/win32/gdiplus/graphicspath.c b/reactos/dll/win32/gdiplus/graphicspath.c
new file mode 100644 (file)
index 0000000..69a9526
--- /dev/null
@@ -0,0 +1,575 @@
+/*
+ * Copyright (C) 2007 Google (Evan Stade)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ *
+ */
+
+#include <stdarg.h>
+#include <math.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "winuser.h"
+#include "wingdi.h"
+
+#include "objbase.h"
+
+#include "gdiplus.h"
+#include "gdiplus_private.h"
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
+
+/* make sure path has enough space for len more points */
+static BOOL lengthen_path(GpPath *path, INT len)
+{
+    /* initial allocation */
+    if(path->datalen == 0){
+        path->datalen = len * 2;
+
+        path->pathdata.Points = GdipAlloc(path->datalen * sizeof(PointF));
+        if(!path->pathdata.Points)   return FALSE;
+
+        path->pathdata.Types = GdipAlloc(path->datalen);
+        if(!path->pathdata.Types){
+            GdipFree(path->pathdata.Points);
+            return FALSE;
+        }
+    }
+    /* reallocation, double size of arrays */
+    else if(path->datalen - path->pathdata.Count < len){
+        while(path->datalen - path->pathdata.Count < len)
+            path->datalen *= 2;
+
+        path->pathdata.Points = HeapReAlloc(GetProcessHeap(), 0,
+            path->pathdata.Points, path->datalen * sizeof(PointF));
+        if(!path->pathdata.Points)  return FALSE;
+
+        path->pathdata.Types = HeapReAlloc(GetProcessHeap(), 0,
+            path->pathdata.Types, path->datalen);
+        if(!path->pathdata.Types)   return FALSE;
+    }
+
+    return TRUE;
+}
+
+GpStatus WINGDIPAPI GdipAddPathArc(GpPath *path, REAL x1, REAL y1, REAL x2,
+    REAL y2, REAL startAngle, REAL sweepAngle)
+{
+    INT count, old_count, i;
+
+    if(!path)
+        return InvalidParameter;
+
+    count = arc2polybezier(NULL, x1, y1, x2, y2, startAngle, sweepAngle);
+
+    if(count == 0)
+        return Ok;
+    if(!lengthen_path(path, count))
+        return OutOfMemory;
+
+    old_count = path->pathdata.Count;
+    arc2polybezier(&path->pathdata.Points[old_count], x1, y1, x2, y2,
+                   startAngle, sweepAngle);
+
+    for(i = 0; i < count; i++){
+        path->pathdata.Types[old_count + i] = PathPointTypeBezier;
+    }
+
+    path->pathdata.Types[old_count] =
+        (path->newfigure ? PathPointTypeStart : PathPointTypeLine);
+    path->newfigure = FALSE;
+    path->pathdata.Count += count;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipAddPathBezierI(GpPath *path, INT x1, INT y1, INT x2,
+    INT y2, INT x3, INT y3, INT x4, INT y4)
+{
+    INT old_count;
+
+    if(!path)
+        return InvalidParameter;
+
+    if(!lengthen_path(path, 4))
+        return OutOfMemory;
+
+    old_count = path->pathdata.Count;
+
+    path->pathdata.Points[old_count].X = (REAL) x1;
+    path->pathdata.Points[old_count].Y = (REAL) y1;
+    path->pathdata.Points[old_count + 1].X = (REAL) x2;
+    path->pathdata.Points[old_count + 1].Y = (REAL) y2;
+    path->pathdata.Points[old_count + 2].X = (REAL) x3;
+    path->pathdata.Points[old_count + 2].Y = (REAL) y3;
+    path->pathdata.Points[old_count + 3].X = (REAL) x4;
+    path->pathdata.Points[old_count + 3].Y = (REAL) y4;
+
+    path->pathdata.Types[old_count] =
+        (path->newfigure ? PathPointTypeStart : PathPointTypeLine);
+    path->pathdata.Types[old_count + 1] = PathPointTypeBezier;
+    path->pathdata.Types[old_count + 2] = PathPointTypeBezier;
+    path->pathdata.Types[old_count + 3] = PathPointTypeBezier;
+
+    path->newfigure = FALSE;
+    path->pathdata.Count += 4;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipAddPathBeziers(GpPath *path, GDIPCONST GpPointF *points,
+    INT count)
+{
+    INT i, old_count;
+
+    if(!path || !points || ((count - 1) % 3))
+        return InvalidParameter;
+
+    if(!lengthen_path(path, count))
+        return OutOfMemory;
+
+    old_count = path->pathdata.Count;
+
+    for(i = 0; i < count; i++){
+        path->pathdata.Points[old_count + i].X = points[i].X;
+        path->pathdata.Points[old_count + i].Y = points[i].Y;
+        path->pathdata.Types[old_count + i] = PathPointTypeBezier;
+    }
+
+    path->pathdata.Types[old_count] =
+        (path->newfigure ? PathPointTypeStart : PathPointTypeLine);
+    path->newfigure = FALSE;
+    path->pathdata.Count += count;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipAddPathEllipse(GpPath *path, REAL x, REAL y, REAL width,
+    REAL height)
+{
+    INT old_count, numpts;
+
+    if(!path)
+        return InvalidParameter;
+
+    if(!lengthen_path(path, MAX_ARC_PTS))
+        return OutOfMemory;
+
+    old_count = path->pathdata.Count;
+    if((numpts = arc2polybezier(&path->pathdata.Points[old_count],  x, y, width,
+                               height, 0.0, 360.0)) != MAX_ARC_PTS){
+        ERR("expected %d points but got %d\n", MAX_ARC_PTS, numpts);
+        return GenericError;
+    }
+
+    memset(&path->pathdata.Types[old_count + 1], PathPointTypeBezier,
+           MAX_ARC_PTS - 1);
+
+    /* An ellipse is an instrinsic figure (always its own subpath). */
+    path->pathdata.Types[old_count] = PathPointTypeStart;
+    path->pathdata.Types[old_count + MAX_ARC_PTS - 1] |= PathPointTypeCloseSubpath;
+    path->newfigure = TRUE;
+    path->pathdata.Count += MAX_ARC_PTS;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipAddPathLine2(GpPath *path, GDIPCONST GpPointF *points,
+    INT count)
+{
+    INT i, old_count;
+
+    if(!path || !points)
+        return InvalidParameter;
+
+    if(!lengthen_path(path, count))
+        return OutOfMemory;
+
+    old_count = path->pathdata.Count;
+
+    for(i = 0; i < count; i++){
+        path->pathdata.Points[old_count + i].X = points[i].X;
+        path->pathdata.Points[old_count + i].Y = points[i].Y;
+        path->pathdata.Types[old_count + i] = PathPointTypeLine;
+    }
+
+    if(path->newfigure){
+        path->pathdata.Types[old_count] = PathPointTypeStart;
+        path->newfigure = FALSE;
+    }
+
+    path->pathdata.Count += count;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipAddPathLineI(GpPath *path, INT x1, INT y1, INT x2, INT y2)
+{
+    INT old_count;
+
+    if(!path)
+        return InvalidParameter;
+
+    if(!lengthen_path(path, 2))
+        return OutOfMemory;
+
+    old_count = path->pathdata.Count;
+
+    path->pathdata.Points[old_count].X = (REAL) x1;
+    path->pathdata.Points[old_count].Y = (REAL) y1;
+    path->pathdata.Points[old_count + 1].X = (REAL) x2;
+    path->pathdata.Points[old_count + 1].Y = (REAL) y2;
+
+    path->pathdata.Types[old_count] =
+        (path->newfigure ? PathPointTypeStart : PathPointTypeLine);
+    path->pathdata.Types[old_count + 1] = PathPointTypeLine;
+
+    path->newfigure = FALSE;
+    path->pathdata.Count += 2;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipAddPathPath(GpPath *path, GDIPCONST GpPath* addingPath,
+    BOOL connect)
+{
+    INT old_count, count;
+
+    if(!path || !addingPath)
+        return InvalidParameter;
+
+    old_count = path->pathdata.Count;
+    count = addingPath->pathdata.Count;
+
+    if(!lengthen_path(path, count))
+        return OutOfMemory;
+
+    memcpy(&path->pathdata.Points[old_count], addingPath->pathdata.Points,
+           count * sizeof(GpPointF));
+    memcpy(&path->pathdata.Types[old_count], addingPath->pathdata.Types, count);
+
+    if(path->newfigure || !connect)
+        path->pathdata.Types[old_count] = PathPointTypeStart;
+    else
+        path->pathdata.Types[old_count] = PathPointTypeLine;
+
+    path->newfigure = FALSE;
+    path->pathdata.Count += count;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipClonePath(GpPath* path, GpPath **clone)
+{
+    if(!path || !clone)
+        return InvalidParameter;
+
+    *clone = GdipAlloc(sizeof(GpPath));
+    if(!*clone) return OutOfMemory;
+
+    **clone = *path;
+
+    (*clone)->pathdata.Points = GdipAlloc(path->datalen * sizeof(PointF));
+    (*clone)->pathdata.Types = GdipAlloc(path->datalen);
+    if(!(*clone)->pathdata.Points || !(*clone)->pathdata.Types){
+        GdipFree(*clone);
+        GdipFree((*clone)->pathdata.Points);
+        GdipFree((*clone)->pathdata.Types);
+        return OutOfMemory;
+    }
+
+    memcpy((*clone)->pathdata.Points, path->pathdata.Points,
+           path->datalen * sizeof(PointF));
+    memcpy((*clone)->pathdata.Types, path->pathdata.Types, path->datalen);
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipClosePathFigure(GpPath* path)
+{
+    if(!path)
+        return InvalidParameter;
+
+    if(path->pathdata.Count > 0){
+        path->pathdata.Types[path->pathdata.Count - 1] |= PathPointTypeCloseSubpath;
+        path->newfigure = TRUE;
+    }
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipClosePathFigures(GpPath* path)
+{
+    INT i;
+
+    if(!path)
+        return InvalidParameter;
+
+    for(i = 1; i < path->pathdata.Count; i++){
+        if(path->pathdata.Types[i] == PathPointTypeStart)
+            path->pathdata.Types[i-1] |= PathPointTypeCloseSubpath;
+    }
+
+    path->newfigure = TRUE;
+
+    return Ok;
+}
+
+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 GdipCreatePath2(GDIPCONST GpPointF* points,
+    GDIPCONST BYTE* types, INT count, GpFillMode fill, GpPath **path)
+{
+    if(!path)
+        return InvalidParameter;
+
+    *path = GdipAlloc(sizeof(GpPath));
+    if(!*path)  return OutOfMemory;
+
+    (*path)->pathdata.Points = GdipAlloc(count * sizeof(PointF));
+    (*path)->pathdata.Types = GdipAlloc(count);
+
+    if(!(*path)->pathdata.Points || !(*path)->pathdata.Types){
+        GdipFree((*path)->pathdata.Points);
+        GdipFree((*path)->pathdata.Types);
+        GdipFree(*path);
+        return OutOfMemory;
+    }
+
+    memcpy((*path)->pathdata.Points, points, count * sizeof(PointF));
+    memcpy((*path)->pathdata.Types, types, count);
+    (*path)->pathdata.Count = count;
+    (*path)->datalen = count;
+
+    (*path)->fill = fill;
+    (*path)->newfigure = TRUE;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipDeletePath(GpPath *path)
+{
+    if(!path)
+        return InvalidParameter;
+
+    GdipFree(path->pathdata.Points);
+    GdipFree(path->pathdata.Types);
+    GdipFree(path);
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetPathFillMode(GpPath *path, GpFillMode *fillmode)
+{
+    if(!path || !fillmode)
+        return InvalidParameter;
+
+    *fillmode = path->fill;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetPathPoints(GpPath *path, GpPointF* points, INT count)
+{
+    if(!path)
+        return InvalidParameter;
+
+    if(count < path->pathdata.Count)
+        return InsufficientBuffer;
+
+    memcpy(points, path->pathdata.Points, path->pathdata.Count * sizeof(GpPointF));
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetPathTypes(GpPath *path, BYTE* types, INT count)
+{
+    if(!path)
+        return InvalidParameter;
+
+    if(count < path->pathdata.Count)
+        return InsufficientBuffer;
+
+    memcpy(types, path->pathdata.Types, path->pathdata.Count);
+
+    return Ok;
+}
+
+/* Windows expands the bounding box to the maximum possible bounding box
+ * for a given pen.  For example, if a line join can extend past the point
+ * it's joining by x units, the bounding box is extended by x units in every
+ * direction (even though this is too conservative for most cases). */
+GpStatus WINGDIPAPI GdipGetPathWorldBounds(GpPath* path, GpRectF* bounds,
+    GDIPCONST GpMatrix *matrix, GDIPCONST GpPen *pen)
+{
+    GpPointF * points, temp_pts[4];
+    INT count, i;
+    REAL path_width = 1.0, width, height, temp, low_x, low_y, high_x, high_y;
+
+    /* Matrix and pen can be null. */
+    if(!path || !bounds)
+        return InvalidParameter;
+
+    /* If path is empty just return. */
+    count = path->pathdata.Count;
+    if(count == 0){
+        bounds->X = bounds->Y = bounds->Width = bounds->Height = 0.0;
+        return Ok;
+    }
+
+    points = path->pathdata.Points;
+
+    low_x = high_x = points[0].X;
+    low_y = high_y = points[0].Y;
+
+    for(i = 1; i < count; i++){
+        low_x = min(low_x, points[i].X);
+        low_y = min(low_y, points[i].Y);
+        high_x = max(high_x, points[i].X);
+        high_y = max(high_y, points[i].Y);
+    }
+
+    width = high_x - low_x;
+    height = high_y - low_y;
+
+    /* This looks unusual but it's the only way I can imitate windows. */
+    if(matrix){
+        temp_pts[0].X = low_x;
+        temp_pts[0].Y = low_y;
+        temp_pts[1].X = low_x;
+        temp_pts[1].Y = high_y;
+        temp_pts[2].X = high_x;
+        temp_pts[2].Y = high_y;
+        temp_pts[3].X = high_x;
+        temp_pts[3].Y = low_y;
+
+        GdipTransformMatrixPoints((GpMatrix*)matrix, temp_pts, 4);
+        low_x = temp_pts[0].X;
+        low_y = temp_pts[0].Y;
+
+        for(i = 1; i < 4; i++){
+            low_x = min(low_x, temp_pts[i].X);
+            low_y = min(low_y, temp_pts[i].Y);
+        }
+
+        temp = width;
+        width = height * fabs(matrix->matrix[2]) + width * fabs(matrix->matrix[0]);
+        height = height * fabs(matrix->matrix[3]) + temp * fabs(matrix->matrix[1]);
+    }
+
+    if(pen){
+        path_width = pen->width / 2.0;
+
+        if(count > 2)
+            path_width = max(path_width,  pen->width * pen->miterlimit / 2.0);
+        /* FIXME: this should probably also check for the startcap */
+        if(pen->endcap & LineCapNoAnchor)
+            path_width = max(path_width,  pen->width * 2.2);
+
+        low_x -= path_width;
+        low_y -= path_width;
+        width += 2.0 * path_width;
+        height += 2.0 * path_width;
+    }
+
+    bounds->X = low_x;
+    bounds->Y = low_y;
+    bounds->Width = width;
+    bounds->Height = height;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetPointCount(GpPath *path, INT *count)
+{
+    if(!path)
+        return InvalidParameter;
+
+    *count = path->pathdata.Count;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipIsOutlineVisiblePathPointI(GpPath* path, INT x, INT y,
+    GpPen *pen, GpGraphics *graphics, BOOL *result)
+{
+    static int calls;
+
+    if(!path || !pen)
+        return InvalidParameter;
+
+    if(!(calls++))
+        FIXME("not implemented\n");
+
+    return NotImplemented;
+}
+
+GpStatus WINGDIPAPI GdipStartPathFigure(GpPath *path)
+{
+    if(!path)
+        return InvalidParameter;
+
+    path->newfigure = TRUE;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipResetPath(GpPath *path)
+{
+    if(!path)
+        return InvalidParameter;
+
+    path->pathdata.Count = 0;
+    path->newfigure = TRUE;
+    path->fill = FillModeAlternate;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipSetPathFillMode(GpPath *path, GpFillMode fill)
+{
+    if(!path)
+        return InvalidParameter;
+
+    path->fill = fill;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipTransformPath(GpPath *path, GpMatrix *matrix)
+{
+    if(!path)
+        return InvalidParameter;
+
+    if(path->pathdata.Count == 0)
+        return Ok;
+
+    return GdipTransformMatrixPoints(matrix, path->pathdata.Points,
+                                     path->pathdata.Count);
+}
diff --git a/reactos/dll/win32/gdiplus/image.c b/reactos/dll/win32/gdiplus/image.c
new file mode 100644 (file)
index 0000000..b1ec2c7
--- /dev/null
@@ -0,0 +1,1098 @@
+/*
+ * Copyright (C) 2007 Google (Evan Stade)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <stdarg.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "winuser.h"
+#include "wingdi.h"
+
+#define COBJMACROS
+#include "objbase.h"
+#include "olectl.h"
+#include "ole2.h"
+
+#include "gdiplus.h"
+#include "gdiplus_private.h"
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
+
+#define PIXELFORMATBPP(x) ((x) ? ((x) >> 8) & 255 : 24)
+
+static INT ipicture_pixel_height(IPicture *pic)
+{
+    HDC hdcref;
+    OLE_YSIZE_HIMETRIC y;
+
+    IPicture_get_Height(pic, &y);
+
+    hdcref = GetDC(0);
+
+    y = MulDiv(y, GetDeviceCaps(hdcref, LOGPIXELSY), INCH_HIMETRIC);
+    ReleaseDC(0, hdcref);
+
+    return y;
+}
+
+static INT ipicture_pixel_width(IPicture *pic)
+{
+    HDC hdcref;
+    OLE_XSIZE_HIMETRIC x;
+
+    IPicture_get_Width(pic, &x);
+
+    hdcref = GetDC(0);
+
+    x = MulDiv(x, GetDeviceCaps(hdcref, LOGPIXELSX), INCH_HIMETRIC);
+
+    ReleaseDC(0, hdcref);
+
+    return x;
+}
+
+GpStatus WINGDIPAPI GdipBitmapGetPixel(GpBitmap* bitmap, INT x, INT y,
+    ARGB *color)
+{
+    static int calls;
+    TRACE("%p %d %d %p\n", bitmap, x, y, color);
+
+    if(!bitmap || !color)
+        return InvalidParameter;
+
+    if(!(calls++))
+        FIXME("not implemented\n");
+
+    *color = 0xdeadbeef;
+
+    return NotImplemented;
+}
+
+/* This function returns a pointer to an array of pixels that represents the
+ * bitmap. The *entire* bitmap is locked according to the lock mode specified by
+ * flags.  It is correct behavior that a user who calls this function with write
+ * privileges can write to the whole bitmap (not just the area in rect).
+ *
+ * FIXME: only used portion of format is bits per pixel. */
+GpStatus WINGDIPAPI GdipBitmapLockBits(GpBitmap* bitmap, GDIPCONST GpRect* rect,
+    UINT flags, PixelFormat format, BitmapData* lockeddata)
+{
+    BOOL bm_is_selected;
+    INT stride, bitspp = PIXELFORMATBPP(format);
+    OLE_HANDLE hbm;
+    HDC hdc;
+    HBITMAP old = NULL;
+    BITMAPINFO bmi;
+    BYTE *buff = NULL;
+    UINT abs_height;
+
+    TRACE("%p %p %d %d %p\n", bitmap, rect, flags, format, lockeddata);
+
+    if(!lockeddata || !bitmap || !rect)
+        return InvalidParameter;
+
+    if(rect->X < 0 || rect->Y < 0 || (rect->X + rect->Width > bitmap->width) ||
+       (rect->Y + rect->Height > bitmap->height) || !flags)
+        return InvalidParameter;
+
+    if(flags & ImageLockModeUserInputBuf)
+        return NotImplemented;
+
+    if(bitmap->lockmode)
+        return WrongState;
+
+    IPicture_get_Handle(bitmap->image.picture, &hbm);
+    IPicture_get_CurDC(bitmap->image.picture, &hdc);
+    bm_is_selected = (hdc != 0);
+
+    bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+    bmi.bmiHeader.biBitCount = 0;
+
+    if(!bm_is_selected){
+        hdc = CreateCompatibleDC(0);
+        old = SelectObject(hdc, (HBITMAP)hbm);
+    }
+
+    /* fill out bmi */
+    GetDIBits(hdc, (HBITMAP)hbm, 0, 0, NULL, &bmi, DIB_RGB_COLORS);
+
+    abs_height = abs(bmi.bmiHeader.biHeight);
+    stride = bmi.bmiHeader.biWidth * bitspp / 8;
+    stride = (stride + 3) & ~3;
+
+    buff = GdipAlloc(stride * abs_height);
+
+    bmi.bmiHeader.biBitCount = bitspp;
+
+    if(buff)
+        GetDIBits(hdc, (HBITMAP)hbm, 0, abs_height, buff, &bmi, DIB_RGB_COLORS);
+
+    if(!bm_is_selected){
+        SelectObject(hdc, old);
+        DeleteDC(hdc);
+    }
+
+    if(!buff)
+        return OutOfMemory;
+
+    lockeddata->Width = rect->Width;
+    lockeddata->Height = rect->Height;
+    lockeddata->PixelFormat = format;
+    lockeddata->Reserved = flags;
+
+    if(bmi.bmiHeader.biHeight > 0){
+        lockeddata->Stride = -stride;
+        lockeddata->Scan0 = buff + (bitspp / 8) * rect->X +
+                            stride * (abs_height - 1 - rect->Y);
+    }
+    else{
+        lockeddata->Stride = stride;
+        lockeddata->Scan0 = buff + (bitspp / 8) * rect->X + stride * rect->Y;
+    }
+
+    bitmap->lockmode = flags;
+    bitmap->numlocks++;
+
+    bitmap->bitmapbits = buff;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipBitmapUnlockBits(GpBitmap* bitmap,
+    BitmapData* lockeddata)
+{
+    OLE_HANDLE hbm;
+    HDC hdc;
+    HBITMAP old = NULL;
+    BOOL bm_is_selected;
+    BITMAPINFO bmi;
+
+    if(!bitmap || !lockeddata)
+        return InvalidParameter;
+
+    if(!bitmap->lockmode)
+        return WrongState;
+
+    if(lockeddata->Reserved & ImageLockModeUserInputBuf)
+        return NotImplemented;
+
+    if(lockeddata->Reserved & ImageLockModeRead){
+        if(!(--bitmap->numlocks))
+            bitmap->lockmode = 0;
+
+        GdipFree(bitmap->bitmapbits);
+        bitmap->bitmapbits = NULL;
+        return Ok;
+    }
+
+    IPicture_get_Handle(bitmap->image.picture, &hbm);
+    IPicture_get_CurDC(bitmap->image.picture, &hdc);
+    bm_is_selected = (hdc != 0);
+
+    bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+    bmi.bmiHeader.biBitCount = 0;
+
+    if(!bm_is_selected){
+        hdc = CreateCompatibleDC(0);
+        old = SelectObject(hdc, (HBITMAP)hbm);
+    }
+
+    GetDIBits(hdc, (HBITMAP)hbm, 0, 0, NULL, &bmi, DIB_RGB_COLORS);
+    bmi.bmiHeader.biBitCount = PIXELFORMATBPP(lockeddata->PixelFormat);
+    SetDIBits(hdc, (HBITMAP)hbm, 0, abs(bmi.bmiHeader.biHeight),
+              bitmap->bitmapbits, &bmi, DIB_RGB_COLORS);
+
+    if(!bm_is_selected){
+        SelectObject(hdc, old);
+        DeleteDC(hdc);
+    }
+
+    GdipFree(bitmap->bitmapbits);
+    bitmap->bitmapbits = NULL;
+    bitmap->lockmode = 0;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipCreateBitmapFromFile(GDIPCONST WCHAR* filename,
+    GpBitmap **bitmap)
+{
+    GpStatus stat;
+    IStream *stream;
+
+    if(!filename || !bitmap)
+        return InvalidParameter;
+
+    stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
+
+    if(stat != Ok)
+        return stat;
+
+    stat = GdipCreateBitmapFromStream(stream, bitmap);
+
+    IStream_Release(stream);
+
+    return stat;
+}
+
+/* FIXME: no icm */
+GpStatus WINGDIPAPI GdipCreateBitmapFromFileICM(GDIPCONST WCHAR* filename,
+    GpBitmap **bitmap)
+{
+    return GdipCreateBitmapFromFile(filename, bitmap);
+}
+
+GpStatus WINGDIPAPI GdipCreateHBITMAPFromBitmap(GpBitmap* bitmap,
+    HBITMAP* hbmReturn, ARGB background)
+{
+    FIXME("stub\n");
+
+    hbmReturn = NULL;
+
+    return NotImplemented;
+}
+
+GpStatus WINGDIPAPI GdipConvertToEmfPlus(const GpGraphics* ref,
+    GpMetafile* metafile, BOOL* succ, EmfType emfType,
+    const WCHAR* description, GpMetafile** out_metafile)
+{
+    static int calls;
+
+    if(!ref || !metafile || !out_metafile)
+        return InvalidParameter;
+
+    *succ = FALSE;
+    *out_metafile = NULL;
+
+    if(!(calls++))
+        FIXME("not implemented\n");
+
+    return NotImplemented;
+}
+
+/* FIXME: this should create a bitmap in the given size with the attributes
+ * (resolution etc.) of the graphics object */
+GpStatus WINGDIPAPI GdipCreateBitmapFromGraphics(INT width, INT height,
+    GpGraphics* target, GpBitmap** bitmap)
+{
+    static int calls;
+    GpStatus ret;
+
+    if(!target || !bitmap)
+        return InvalidParameter;
+
+    if(!(calls++))
+        FIXME("hacked stub\n");
+
+    ret = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat24bppRGB,
+                                    NULL, bitmap);
+
+    return ret;
+}
+
+GpStatus WINGDIPAPI GdipCreateBitmapFromScan0(INT width, INT height, INT stride,
+    PixelFormat format, BYTE* scan0, GpBitmap** bitmap)
+{
+    BITMAPFILEHEADER *bmfh;
+    BITMAPINFOHEADER *bmih;
+    BYTE *buff;
+    INT datalen, size;
+    IStream *stream;
+
+    TRACE("%d %d %d %d %p %p\n", width, height, stride, format, scan0, bitmap);
+
+    if(!bitmap || width <= 0 || height <= 0 || (scan0 && (stride % 4))){
+        *bitmap = NULL;
+        return InvalidParameter;
+    }
+
+    if(scan0 && !stride)
+        return InvalidParameter;
+
+    /* FIXME: windows allows negative stride (reads backwards from scan0) */
+    if(stride < 0){
+        FIXME("negative stride\n");
+        return InvalidParameter;
+    }
+
+    *bitmap = GdipAlloc(sizeof(GpBitmap));
+    if(!*bitmap)    return OutOfMemory;
+
+    if(stride == 0){
+        stride = width * (PIXELFORMATBPP(format) / 8);
+        stride = (stride + 3) & ~3;
+    }
+
+    datalen = abs(stride * height);
+    size = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + datalen;
+    buff = GdipAlloc(size);
+    if(!buff){
+        GdipFree(*bitmap);
+        return OutOfMemory;
+    }
+
+    bmfh = (BITMAPFILEHEADER*) buff;
+    bmih = (BITMAPINFOHEADER*) (bmfh + 1);
+
+    bmfh->bfType    = (((WORD)'M') << 8) + (WORD)'B';
+    bmfh->bfSize    = size;
+    bmfh->bfOffBits = size - datalen;
+
+    bmih->biSize            = sizeof(BITMAPINFOHEADER);
+    bmih->biWidth           = width;
+    bmih->biHeight          = -height;
+    /* FIXME: use the rest of the data from format */
+    bmih->biBitCount        = PIXELFORMATBPP(format);
+    bmih->biCompression     = BI_RGB;
+    bmih->biSizeImage       = datalen;
+
+    if(scan0)
+        memcpy(bmih + 1, scan0, datalen);
+    else
+        memset(bmih + 1, 0, datalen);
+
+    if(CreateStreamOnHGlobal(buff, TRUE, &stream) != S_OK){
+        ERR("could not make stream\n");
+        GdipFree(*bitmap);
+        GdipFree(buff);
+        return GenericError;
+    }
+
+    if(OleLoadPicture(stream, 0, FALSE, &IID_IPicture,
+        (LPVOID*) &((*bitmap)->image.picture)) != S_OK){
+        TRACE("Could not load picture\n");
+        IStream_Release(stream);
+        GdipFree(*bitmap);
+        GdipFree(buff);
+        return GenericError;
+    }
+
+    (*bitmap)->image.type = ImageTypeBitmap;
+    (*bitmap)->width = width;
+    (*bitmap)->height = height;
+    (*bitmap)->format = format;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipCreateBitmapFromStream(IStream* stream,
+    GpBitmap **bitmap)
+{
+    GpStatus stat;
+
+    stat = GdipLoadImageFromStream(stream, (GpImage**) bitmap);
+
+    if(stat != Ok)
+        return stat;
+
+    if((*bitmap)->image.type != ImageTypeBitmap){
+        IPicture_Release((*bitmap)->image.picture);
+        GdipFree(bitmap);
+        return GenericError; /* FIXME: what error to return? */
+    }
+
+    return Ok;
+}
+
+/* FIXME: no icm */
+GpStatus WINGDIPAPI GdipCreateBitmapFromStreamICM(IStream* stream,
+    GpBitmap **bitmap)
+{
+    return GdipCreateBitmapFromStream(stream, bitmap);
+}
+
+GpStatus WINGDIPAPI GdipDisposeImage(GpImage *image)
+{
+    HDC hdc;
+
+    if(!image)
+        return InvalidParameter;
+
+    IPicture_get_CurDC(image->picture, &hdc);
+    DeleteDC(hdc);
+    IPicture_Release(image->picture);
+    if (image->type == ImageTypeBitmap)
+        GdipFree(((GpBitmap*)image)->bitmapbits);
+    GdipFree(image);
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipFindFirstImageItem(GpImage *image, ImageItemData* item)
+{
+    if(!image || !item)
+        return InvalidParameter;
+
+    return NotImplemented;
+}
+
+GpStatus WINGDIPAPI GdipGetImageBounds(GpImage *image, GpRectF *srcRect,
+    GpUnit *srcUnit)
+{
+    if(!image || !srcRect || !srcUnit)
+        return InvalidParameter;
+    if(image->type == ImageTypeMetafile){
+        *srcRect = ((GpMetafile*)image)->bounds;
+        *srcUnit = ((GpMetafile*)image)->unit;
+    }
+    else if(image->type == ImageTypeBitmap){
+        srcRect->X = srcRect->Y = 0.0;
+        srcRect->Width = (REAL) ((GpBitmap*)image)->width;
+        srcRect->Height = (REAL) ((GpBitmap*)image)->height;
+        *srcUnit = UnitPixel;
+    }
+    else{
+        srcRect->X = srcRect->Y = 0.0;
+        srcRect->Width = ipicture_pixel_width(image->picture);
+        srcRect->Height = ipicture_pixel_height(image->picture);
+        *srcUnit = UnitPixel;
+    }
+
+    TRACE("returning (%f, %f) (%f, %f) unit type %d\n", srcRect->X, srcRect->Y,
+          srcRect->Width, srcRect->Height, *srcUnit);
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetImageDimension(GpImage *image, REAL *width,
+    REAL *height)
+{
+    if(!image || !height || !width)
+        return InvalidParameter;
+
+    if(image->type == ImageTypeMetafile){
+        HDC hdc = GetDC(0);
+
+        *height = convert_unit(hdc, ((GpMetafile*)image)->unit) *
+                        ((GpMetafile*)image)->bounds.Height;
+
+        *width = convert_unit(hdc, ((GpMetafile*)image)->unit) *
+                        ((GpMetafile*)image)->bounds.Width;
+
+        ReleaseDC(0, hdc);
+    }
+
+    else if(image->type == ImageTypeBitmap){
+        *height = ((GpBitmap*)image)->height;
+        *width = ((GpBitmap*)image)->width;
+    }
+    else{
+        *height = ipicture_pixel_height(image->picture);
+        *width = ipicture_pixel_width(image->picture);
+    }
+
+    TRACE("returning (%f, %f)\n", *height, *width);
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetImageGraphicsContext(GpImage *image,
+    GpGraphics **graphics)
+{
+    HDC hdc;
+
+    if(!image || !graphics)
+        return InvalidParameter;
+
+    if(image->type != ImageTypeBitmap){
+        FIXME("not implemented for image type %d\n", image->type);
+        return NotImplemented;
+    }
+
+    IPicture_get_CurDC(image->picture, &hdc);
+
+    if(!hdc){
+        hdc = CreateCompatibleDC(0);
+        IPicture_SelectPicture(image->picture, hdc, NULL, NULL);
+    }
+
+    return GdipCreateFromHDC(hdc, graphics);
+}
+
+GpStatus WINGDIPAPI GdipGetImageHeight(GpImage *image, UINT *height)
+{
+    if(!image || !height)
+        return InvalidParameter;
+
+    if(image->type == ImageTypeMetafile){
+        HDC hdc = GetDC(0);
+
+        *height = roundr(convert_unit(hdc, ((GpMetafile*)image)->unit) *
+                        ((GpMetafile*)image)->bounds.Height);
+
+        ReleaseDC(0, hdc);
+    }
+    else if(image->type == ImageTypeBitmap)
+        *height = ((GpBitmap*)image)->height;
+    else
+        *height = ipicture_pixel_height(image->picture);
+
+    TRACE("returning %d\n", *height);
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetImageHorizontalResolution(GpImage *image, REAL *res)
+{
+    static int calls;
+
+    if(!image || !res)
+        return InvalidParameter;
+
+    if(!(calls++))
+        FIXME("not implemented\n");
+
+    return NotImplemented;
+}
+
+/* FIXME: test this function for non-bitmap types */
+GpStatus WINGDIPAPI GdipGetImagePixelFormat(GpImage *image, PixelFormat *format)
+{
+    if(!image || !format)
+        return InvalidParameter;
+
+    if(image->type != ImageTypeBitmap)
+        *format = PixelFormat24bppRGB;
+    else
+        *format = ((GpBitmap*) image)->format;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetImageRawFormat(GpImage *image, GUID *format)
+{
+    static int calls;
+
+    if(!image || !format)
+        return InvalidParameter;
+
+    if(!(calls++))
+        FIXME("not implemented\n");
+
+    return NotImplemented;
+}
+
+GpStatus WINGDIPAPI GdipGetImageType(GpImage *image, ImageType *type)
+{
+    if(!image || !type)
+        return InvalidParameter;
+
+    *type = image->type;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetImageVerticalResolution(GpImage *image, REAL *res)
+{
+    static int calls;
+
+    if(!image || !res)
+        return InvalidParameter;
+
+    if(!(calls++))
+        FIXME("not implemented\n");
+
+    return NotImplemented;
+}
+
+GpStatus WINGDIPAPI GdipGetImageWidth(GpImage *image, UINT *width)
+{
+    if(!image || !width)
+        return InvalidParameter;
+
+    if(image->type == ImageTypeMetafile){
+        HDC hdc = GetDC(0);
+
+        *width = roundr(convert_unit(hdc, ((GpMetafile*)image)->unit) *
+                        ((GpMetafile*)image)->bounds.Width);
+
+        ReleaseDC(0, hdc);
+    }
+    else if(image->type == ImageTypeBitmap)
+        *width = ((GpBitmap*)image)->width;
+    else
+        *width = ipicture_pixel_width(image->picture);
+
+    TRACE("returning %d\n", *width);
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetMetafileHeaderFromMetafile(GpMetafile * metafile,
+    MetafileHeader * header)
+{
+    static int calls;
+
+    if(!metafile || !header)
+        return InvalidParameter;
+
+    if(!(calls++))
+        FIXME("not implemented\n");
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetPropertyItemSize(GpImage *image, PROPID pid,
+    UINT* size)
+{
+    static int calls;
+
+    TRACE("%p %x %p\n", image, pid, size);
+
+    if(!size || !image)
+        return InvalidParameter;
+
+    if(!(calls++))
+        FIXME("not implemented\n");
+
+    return NotImplemented;
+}
+
+GpStatus WINGDIPAPI GdipImageGetFrameCount(GpImage *image,
+    GDIPCONST GUID* dimensionID, UINT* count)
+{
+    static int calls;
+
+    if(!image || !dimensionID || !count)
+        return InvalidParameter;
+
+    if(!(calls++))
+        FIXME("not implemented\n");
+
+    return NotImplemented;
+}
+
+GpStatus WINGDIPAPI GdipImageGetFrameDimensionsList(GpImage* image,
+    GUID* dimensionIDs, UINT count)
+{
+    static int calls;
+
+    if(!image || !dimensionIDs)
+        return InvalidParameter;
+
+    if(!(calls++))
+        FIXME("not implemented\n");
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipImageSelectActiveFrame(GpImage *image,
+    GDIPCONST GUID* dimensionID, UINT frameidx)
+{
+    static int calls;
+
+    if(!image || !dimensionID)
+        return InvalidParameter;
+
+    if(!(calls++))
+        FIXME("not implemented\n");
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipLoadImageFromFile(GDIPCONST WCHAR* filename,
+                                          GpImage **image)
+{
+    GpStatus stat;
+    IStream *stream;
+
+    if (!filename || !image)
+        return InvalidParameter;
+
+    stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
+
+    if (stat != Ok)
+        return stat;
+
+    stat = GdipLoadImageFromStream(stream, image);
+
+    IStream_Release(stream);
+
+    return stat;
+}
+
+GpStatus WINGDIPAPI GdipLoadImageFromStream(IStream* stream, GpImage **image)
+{
+    IPicture *pic;
+    short type;
+
+    if(!stream || !image)
+        return InvalidParameter;
+
+    if(OleLoadPicture(stream, 0, FALSE, &IID_IPicture,
+        (LPVOID*) &pic) != S_OK){
+        TRACE("Could not load picture\n");
+        return GenericError;
+    }
+
+    IPicture_get_Type(pic, &type);
+
+    if(type == PICTYPE_BITMAP){
+        BITMAPINFO bmi;
+        BITMAPCOREHEADER* bmch;
+        OLE_HANDLE hbm;
+        HDC hdc;
+
+        *image = GdipAlloc(sizeof(GpBitmap));
+        if(!*image) return OutOfMemory;
+        (*image)->type = ImageTypeBitmap;
+
+        (*((GpBitmap**) image))->width = ipicture_pixel_width(pic);
+        (*((GpBitmap**) image))->height = ipicture_pixel_height(pic);
+
+        /* get the pixel format */
+        IPicture_get_Handle(pic, &hbm);
+        IPicture_get_CurDC(pic, &hdc);
+
+        bmch = (BITMAPCOREHEADER*) (&bmi.bmiHeader);
+        bmch->bcSize = sizeof(BITMAPCOREHEADER);
+
+        if(!hdc){
+            HBITMAP old;
+            hdc = CreateCompatibleDC(0);
+            old = SelectObject(hdc, (HBITMAP)hbm);
+            GetDIBits(hdc, (HBITMAP)hbm, 0, 0, NULL, &bmi, DIB_RGB_COLORS);
+            SelectObject(hdc, old);
+            DeleteDC(hdc);
+        }
+        else
+            GetDIBits(hdc, (HBITMAP)hbm, 0, 0, NULL, &bmi, DIB_RGB_COLORS);
+
+        (*((GpBitmap**) image))->format = (bmch->bcBitCount << 8) | PixelFormatGDI;
+    }
+    else if(type == PICTYPE_METAFILE || type == PICTYPE_ENHMETAFILE){
+        /* FIXME: missing initialization code */
+        *image = GdipAlloc(sizeof(GpMetafile));
+        if(!*image) return OutOfMemory;
+        (*image)->type = ImageTypeMetafile;
+    }
+    else{
+        *image = GdipAlloc(sizeof(GpImage));
+        if(!*image) return OutOfMemory;
+        (*image)->type = ImageTypeUnknown;
+    }
+
+    (*image)->picture = pic;
+
+    return Ok;
+}
+
+/* FIXME: no ICM */
+GpStatus WINGDIPAPI GdipLoadImageFromStreamICM(IStream* stream, GpImage **image)
+{
+    return GdipLoadImageFromStream(stream, image);
+}
+
+GpStatus WINGDIPAPI GdipRemovePropertyItem(GpImage *image, PROPID propId)
+{
+    static int calls;
+
+    if(!image)
+        return InvalidParameter;
+
+    if(!(calls++))
+        FIXME("not implemented\n");
+
+    return NotImplemented;
+}
+
+GpStatus WINGDIPAPI GdipSaveImageToFile(GpImage *image, GDIPCONST WCHAR* filename,
+                                        GDIPCONST CLSID *clsidEncoder,
+                                        GDIPCONST EncoderParameters *encoderParams)
+{
+    GpStatus stat;
+    IStream *stream;
+
+    if (!image || !filename|| !clsidEncoder)
+        return InvalidParameter;
+
+    if (!(image->picture))
+        return InvalidParameter;
+
+    stat = GdipCreateStreamOnFile(filename, GENERIC_WRITE, &stream);
+    if (stat != Ok)
+        return GenericError;
+
+    stat = GdipSaveImageToStream(image, stream, clsidEncoder, encoderParams);
+
+    IStream_Release(stream);
+    return stat;
+}
+
+/*************************************************************************
+ * Encoding functions -
+ *   These functions encode an image in different image file formats.
+ */
+#define BITMAP_FORMAT_BMP   0x4d42 /* "BM" */
+#define BITMAP_FORMAT_JPEG  0xd8ff
+#define BITMAP_FORMAT_GIF   0x4947
+#define BITMAP_FORMAT_PNG   0x5089
+#define BITMAP_FORMAT_APM   0xcdd7
+
+static GpStatus encode_image_BMP(LPVOID bitmap_bits, LPBITMAPINFO bitmap_info,
+                                 void **output, unsigned int *output_size)
+{
+    int num_palette_entries;
+    BITMAPFILEHEADER *bmp_file_hdr;
+    BITMAPINFO *bmp_info_hdr;
+
+    if (bitmap_info->bmiHeader.biClrUsed) {
+        num_palette_entries = bitmap_info->bmiHeader.biClrUsed;
+        if (num_palette_entries > 256) num_palette_entries = 256;
+    } else {
+        if (bitmap_info->bmiHeader.biBitCount <= 8)
+            num_palette_entries = 1 << bitmap_info->bmiHeader.biBitCount;
+        else
+            num_palette_entries = 0;
+    }
+
+    *output_size =
+        sizeof(BITMAPFILEHEADER) +
+        sizeof(BITMAPINFOHEADER) +
+        num_palette_entries * sizeof(RGBQUAD) +
+        bitmap_info->bmiHeader.biSizeImage;
+
+    *output = GdipAlloc(*output_size);
+
+    bmp_file_hdr = (BITMAPFILEHEADER*) *output;
+    bmp_file_hdr->bfType = BITMAP_FORMAT_BMP;
+    bmp_file_hdr->bfSize = *output_size;
+    bmp_file_hdr->bfOffBits =
+        sizeof(BITMAPFILEHEADER) +
+        sizeof(BITMAPINFOHEADER) +
+        num_palette_entries * sizeof (RGBQUAD);
+
+    bmp_info_hdr = (BITMAPINFO*) ((unsigned char*)(*output) + sizeof(BITMAPFILEHEADER));
+    memcpy(bmp_info_hdr, bitmap_info, sizeof(BITMAPINFOHEADER) + num_palette_entries * sizeof(RGBQUAD));
+    memcpy((unsigned char *)(*output) +
+           sizeof(BITMAPFILEHEADER) +
+           sizeof(BITMAPINFOHEADER) +
+           num_palette_entries * sizeof(RGBQUAD),
+           bitmap_bits, bitmap_info->bmiHeader.biSizeImage);
+
+    return Ok;
+}
+
+typedef GpStatus encode_image_func(LPVOID bitmap_bits, LPBITMAPINFO bitmap_info,
+                                   void **output, unsigned int *output_size);
+
+typedef enum {
+    BMP,
+    NUM_ENCODERS_SUPPORTED
+} ImageFormat;
+
+static const ImageCodecInfo codecs[NUM_ENCODERS_SUPPORTED];
+static encode_image_func *const encode_image_funcs[NUM_ENCODERS_SUPPORTED] = {
+    encode_image_BMP,
+};
+
+GpStatus WINGDIPAPI GdipSaveImageToStream(GpImage *image, IStream* stream,
+    GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
+{
+    GpStatus stat;
+    HRESULT hr;
+    short type;
+    HBITMAP hbmp;
+    HBITMAP old_hbmp;
+    HDC hdc;
+    int bm_is_selected;
+    BITMAPINFO bmp_info;
+    LPVOID bmp_bits;
+    encode_image_func* encode_image;
+    LPVOID output;
+    unsigned int output_size;
+    unsigned int dummy;
+    int i;
+
+    old_hbmp = 0;
+    output = NULL;
+    output_size = 0;
+
+    if(!image || !stream)
+        return InvalidParameter;
+
+    if (!image->picture)
+        return GenericError;
+
+    hr = IPicture_get_Type(image->picture, &type);
+    if (FAILED(hr) || type != PICTYPE_BITMAP)
+        return GenericError;
+
+    /* select correct encoder */
+    encode_image = NULL;
+    for (i = 0; i < NUM_ENCODERS_SUPPORTED; i++) {
+        if (IsEqualCLSID(clsid, &codecs[i].Clsid))
+            encode_image = encode_image_funcs[i];
+    }
+    if (encode_image == NULL)
+        return UnknownImageFormat;
+
+    /* extract underlying hbitmap representation from the IPicture */
+    hr = IPicture_get_Handle(image->picture, (OLE_HANDLE*)&hbmp);
+    if (FAILED(hr) || !hbmp)
+        return GenericError;
+    hr = IPicture_get_CurDC(image->picture, &hdc);
+    if (FAILED(hr))
+        return GenericError;
+    bm_is_selected = (hdc != 0);
+    if (!bm_is_selected) {
+        hdc = CreateCompatibleDC(0);
+        old_hbmp = SelectObject(hdc, hbmp);
+    }
+
+    /* get bits from HBITMAP */
+    bmp_info.bmiHeader.biSize = sizeof(bmp_info.bmiHeader);
+    bmp_info.bmiHeader.biBitCount = 0;
+    GetDIBits(hdc, hbmp, 0, 0, NULL, &bmp_info, DIB_RGB_COLORS);
+
+    bmp_bits = GdipAlloc(bmp_info.bmiHeader.biSizeImage);
+
+    if (bmp_bits)
+        GetDIBits(hdc, hbmp, 0, abs(bmp_info.bmiHeader.biHeight), bmp_bits, &bmp_info, DIB_RGB_COLORS);
+
+    if (!bm_is_selected) {
+        SelectObject(hdc, old_hbmp);
+        DeleteDC(hdc);
+    }
+
+    if (!bmp_bits)
+        return OutOfMemory;
+
+    stat = encode_image(bmp_bits, &bmp_info, &output, &output_size);
+    if (stat == Ok)
+        IStream_Write(stream, output, output_size, &dummy);
+
+    GdipFree(output);
+    GdipFree(bmp_bits);
+
+    return stat;
+}
+
+GpStatus WINGDIPAPI GdipSetImagePalette(GpImage *image,
+    GDIPCONST ColorPalette *palette)
+{
+    static int calls;
+
+    if(!image || !palette)
+        return InvalidParameter;
+
+    if(!(calls++))
+        FIXME("not implemented\n");
+
+    return NotImplemented;
+}
+
+/*************************************************************************
+ * Encoders -
+ *   Structures that represent which formats we support for encoding.
+ */
+
+/* ImageCodecInfo creation routines taken from libgdiplus */
+static const WCHAR bmp_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'B', 'M', 'P', 0}; /* Built-in BMP */
+static const WCHAR bmp_extension[] = {'*','.','B', 'M', 'P',';', '*','.', 'D','I', 'B',';', '*','.', 'R', 'L', 'E',0}; /* *.BMP;*.DIB;*.RLE */
+static const WCHAR bmp_mimetype[] = {'i', 'm', 'a','g', 'e', '/', 'b', 'm', 'p', 0}; /* image/bmp */
+static const WCHAR bmp_format[] = {'B', 'M', 'P', 0}; /* BMP */
+static const BYTE bmp_sig_pattern[] = { 0x42, 0x4D };
+static const BYTE bmp_sig_mask[] = { 0xFF, 0xFF };
+
+static const ImageCodecInfo codecs[NUM_ENCODERS_SUPPORTED] =
+    {
+        { /* BMP */
+            /* Clsid */              { 0x557cf400, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
+            /* FormatID */           { 0xb96b3cabU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
+            /* CodecName */          bmp_codecname,
+            /* DllName */            NULL,
+            /* FormatDescription */  bmp_format,
+            /* FilenameExtension */  bmp_extension,
+            /* MimeType */           bmp_mimetype,
+            /* Flags */              ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
+            /* Version */            1,
+            /* SigCount */           1,
+            /* SigSize */            2,
+            /* SigPattern */         bmp_sig_pattern,
+            /* SigMask */            bmp_sig_mask,
+        },
+    };
+
+GpStatus WINGDIPAPI GdipGetImageEncodersSize(UINT *numEncoders, UINT *size)
+{
+    if (!numEncoders || !size)
+        return InvalidParameter;
+
+    *numEncoders = NUM_ENCODERS_SUPPORTED;
+    *size = sizeof (codecs);
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetImageEncoders(UINT numEncoders, UINT size, ImageCodecInfo *encoders)
+{
+    if (!encoders ||
+        (numEncoders != NUM_ENCODERS_SUPPORTED) ||
+        (size != sizeof (codecs)))
+        return GenericError;
+
+    memcpy(encoders, codecs, sizeof (codecs));
+
+    return Ok;
+}
+GpStatus WINGDIPAPI GdipCreateBitmapFromHBITMAP(HBITMAP hbm, HPALETTE hpal, GpBitmap** bitmap)
+{
+    BITMAP bm;
+    GpStatus retval;
+    PixelFormat format;
+
+    if(!hbm || !bitmap)
+        return InvalidParameter;
+
+    /* TODO: Support for device-dependent bitmaps */
+    if(hpal){
+        FIXME("no support for device-dependent bitmaps\n");
+        return NotImplemented;
+    }
+
+    if (GetObjectA(hbm, sizeof(bm), &bm) != sizeof(bm))
+            return InvalidParameter;
+
+    /* TODO: Figure out the correct format for 16, 32, 64 bpp */
+    switch(bm.bmBitsPixel) {
+        case 1:
+            format = PixelFormat1bppIndexed;
+            break;
+        case 4:
+            format = PixelFormat4bppIndexed;
+            break;
+        case 8:
+            format = PixelFormat8bppIndexed;
+            break;
+        case 24:
+            format = PixelFormat24bppRGB;
+            break;
+        case 48:
+            format = PixelFormat48bppRGB;
+            break;
+        default:
+            FIXME("don't know how to handle %d bpp\n", bm.bmBitsPixel);
+            return InvalidParameter;
+    }
+
+    retval = GdipCreateBitmapFromScan0(bm.bmWidth, bm.bmHeight, bm.bmWidthBytes,
+        format, bm.bmBits, bitmap);
+
+    return retval;
+}
diff --git a/reactos/dll/win32/gdiplus/imageattributes.c b/reactos/dll/win32/gdiplus/imageattributes.c
new file mode 100644 (file)
index 0000000..ac6caa5
--- /dev/null
@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2007 Google (Evan Stade)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "windef.h"
+#include "wingdi.h"
+
+#include "objbase.h"
+
+#include "gdiplus.h"
+#include "gdiplus_private.h"
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
+
+GpStatus WINGDIPAPI GdipCreateImageAttributes(GpImageAttributes **imageattr)
+{
+    if(!imageattr)
+        return InvalidParameter;
+
+    *imageattr = GdipAlloc(sizeof(GpImageAttributes));
+    if(!*imageattr)    return OutOfMemory;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipDisposeImageAttributes(GpImageAttributes *imageattr)
+{
+    if(!imageattr)
+        return InvalidParameter;
+
+    GdipFree(imageattr);
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipSetImageAttributesColorKeys(GpImageAttributes *imageattr,
+    ColorAdjustType type, BOOL enableFlag, ARGB colorLow, ARGB colorHigh)
+{
+    static int calls;
+
+    if(!imageattr)
+        return InvalidParameter;
+
+    if(!(calls++))
+        FIXME("not implemented\n");
+
+    return NotImplemented;
+}
+
+GpStatus WINGDIPAPI GdipSetImageAttributesColorMatrix(GpImageAttributes *imageattr,
+    ColorAdjustType type, BOOL enableFlag, GDIPCONST ColorMatrix* colorMatrix,
+    GDIPCONST ColorMatrix* grayMatrix, ColorMatrixFlags flags)
+{
+    static int calls;
+
+    if(!imageattr || !colorMatrix || !grayMatrix)
+        return InvalidParameter;
+
+    if(!(calls++))
+        FIXME("not implemented\n");
+
+    return NotImplemented;
+}
+
+GpStatus WINGDIPAPI GdipSetImageAttributesWrapMode(GpImageAttributes *imageAttr,
+    WrapMode wrap, ARGB argb, BOOL clamp)
+{
+    static int calls;
+
+    if(!imageAttr)
+        return InvalidParameter;
+
+    if(!(calls++))
+        FIXME("not implemented\n");
+
+    return NotImplemented;
+}
diff --git a/reactos/dll/win32/gdiplus/include/debug.h b/reactos/dll/win32/gdiplus/include/debug.h
deleted file mode 100644 (file)
index ee6aafe..0000000
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * COPYRIGHT:   See COPYING in the top level directory
- * PROJECT:     ReactOS gdiplus.dll
- * FILE:        include/debug.h
- * PURPOSE:     Debugging support macros
- * DEFINES:     DBG     - Enable debug output
- *              NASSERT - Disable assertions
- */
-#ifndef __DEBUG_H
-#define __DEBUG_H
-
-#define NORMAL_MASK    0x000000FF
-#define SPECIAL_MASK   0xFFFFFF00
-#define MIN_TRACE      0x00000001
-#define MID_TRACE      0x00000002
-#define MAX_TRACE      0x00000003
-
-#define DEBUG_ULTRA    0xFFFFFFFF
-
-#ifdef ASSERT
-#undef ASSERT
-#endif
-
-#ifdef DBG
-
-extern DWORD DebugTraceLevel;
-
-#define D(_t_, _x_) \
-    if (((DebugTraceLevel & NORMAL_MASK) >= _t_) || \
-        ((DebugTraceLevel & _t_) > NORMAL_MASK)) { \
-        DbgPrint("(%hS:%d)(%hS) ", __FILE__, __LINE__, __FUNCTION__); \
-                   DbgPrint _x_; \
-    }
-
-#ifdef NASSERT
-#define ASSERT(x)
-#else /* NASSERT */
-#define ASSERT(x) if (!(x)) { D(MIN_TRACE, ("Assertion "#x" failed at %s:%d\n", __FILE__, __LINE__)); }
-#endif /* NASSERT */
-
-#else /* DBG */
-
-#define D(_t_, _x_)
-
-#define ASSERT(x)
-
-#endif /* DBG */
-
-#ifdef assert
-#undef assert
-#endif
-#define assert(x) ASSERT(x)
-
-
-#define UNIMPLEMENTED \
-    D(MIN_TRACE, ("is unimplemented, please try again later.\n"));
-
-#define CHECKPOINT \
-    D(DEBUG_CHECK, ("\n"));
-
-#define DPRINT(X...) D(DEBUG_CHECK, (X))
-
-#define CP CHECKPOINT
-
-#endif /* __DEBUG_H */
diff --git a/reactos/dll/win32/gdiplus/include/gdiplusprivate.h b/reactos/dll/win32/gdiplus/include/gdiplusprivate.h
deleted file mode 100644 (file)
index 4bb40c9..0000000
+++ /dev/null
@@ -1,342 +0,0 @@
-/*
- * COPYRIGHT:   See COPYING in the top level directory
- * PROJECT:     ReactOS gdiplus.dll
- * FILE:        include/GdiPlusPrivate.h
- * PURPOSE:     GDI+ private definitions
- */
-#ifndef __GDIPLUSPRIVATE_H
-#define __GDIPLUSPRIVATE_H
-
-#include <gdiplusenums.h>
-#include <gdipluspixelformats.h>
-
-typedef float REAL;
-typedef ARGB Color;
-#include <gdipluscolormatrix.h>
-
-#define WINGDIPAPI __stdcall
-#define GDIPCONST const
-
-typedef BOOL (CALLBACK * ImageAbort)(VOID *);
-typedef ImageAbort DrawImageAbort;
-typedef ImageAbort GetThumbnailImageAbort;
-typedef BOOL (CALLBACK * EnumerateMetafileProc)(EmfPlusRecordType,
-  UINT,
-  UINT,
-  const BYTE*,
-  VOID*);
-
-typedef enum {
-  Ok = 0,
-  GenericError = 1,
-  InvalidParameter = 2,
-  OutOfMemory = 3,
-  ObjectBusy = 4,
-  InsufficientBuffer = 5,
-  NotImplemented = 6,
-  Win32Error = 7,
-  WrongState = 8,
-  Aborted = 9,
-  FileNotFound = 10,
-  ValueOverflow = 11,
-  AccessDenied = 12,
-  UnknownImageFormat = 13,
-  FontFamilyNotFound = 14,
-  FontStyleNotFound = 15,
-  NotTrueTypeFont = 16,
-  UnsupportedGdiplusVersion = 17,
-  GdiplusNotInitialized = 18,
-  PropertyNotFound = 19,
-  PropertyNotSupported = 20,
-  ProfileNotFound = 21
-} GpStatus;
-
-typedef GpStatus Status;
-
-typedef struct
-{
-} GpAdjustableArrowCap;
-
-typedef struct
-{
-} GpBitmap;
-
-typedef struct
-{
-} GpGraphics;
-
-typedef struct
-{
-} BitmapData;
-
-typedef struct
-{
-} CGpEffect;
-
-typedef struct
-{
-} GpCachedBitmap;
-
-typedef struct
-{
-} IDirectDrawSurface7;
-
-typedef struct
-{
-} GpBrush;
-
-typedef BrushType GpBrushType;
-
-typedef HatchStyle GpHatchStyle;
-
-typedef struct
-{
-} GpHatch;
-
-typedef struct
-{
-} GpPath;
-
-typedef struct
-{
-} GpRegion;
-
-typedef struct
-{
-  CLSID Clsid;
-  GUID FormatID;
-  WCHAR *CodecName;
-  WCHAR *DllName;
-  WCHAR *FormatDescription;
-  WCHAR *FilenameExtension;
-  WCHAR *MimeType;
-  DWORD Flags;
-  DWORD Version;
-  DWORD SigCount;
-  DWORD SigSize;
-  BYTE *SigPattern;
-  BYTE *SigMask;
-} ImageCodecInfo;
-
-typedef Unit GpUnit;
-
-typedef struct
-{
-} GpPen;
-
-typedef struct
-{
-  REAL X;
-  REAL Y;
-} GpPointF;
-
-typedef struct
-{
-  INT X;
-  INT Y;
-} GpPoint;
-
-typedef FillMode GpFillMode;
-
-typedef struct
-{
-} GpSolidFill;
-
-typedef struct
-{
-} GpFont;
-
-typedef struct
-{
-} GpFontFamily;
-
-typedef struct
-{
-} GpFontCollection;
-
-typedef FlushIntention GpFlushIntention;
-
-typedef struct
-{
-} GpImage;
-
-typedef struct
-{
-} GpImageAttributes;
-
-typedef struct
-{
-} GpMatrix;
-
-typedef struct
-{
-  GUID Guid;
-  ULONG NumberOfValues;
-  ULONG Type;
-  VOID *Value;
-} EncoderParameter;
-
-typedef struct
-{
-  UINT Count;
-  EncoderParameter Parameter[1];
-} EncoderParameters;
-
-typedef struct
-{
-  PROPID id;
-  ULONG length;
-  WORD type;
-  VOID *value;
-} PropertyItem;
-
-typedef struct
-{
-  UINT Size;
-  UINT Position;
-  VOID *Desc;
-  UINT DescSize;
-  UINT *Data;
-  UINT DataSize;
-  UINT Cookie;
-} ImageItemData;
-
-typedef enum {
-  ColorChannelFlagsC = 0,
-  ColorChannelFlagsM = 1,
-  ColorChannelFlagsY = 2,
-  ColorChannelFlagsK = 3,
-  ColorChannelFlagsLast = 4
-} ColorChannelFlags;
-
-typedef LineCap GpLineCap;
-
-typedef struct
-{
-} GpCustomLineCap;
-
-typedef LineJoin GpLineJoin;
-
-typedef WrapMode GpWrapMode;
-
-typedef struct
-{
-} GpLineGradient;
-
-typedef MatrixOrder GpMatrixOrder;
-
-typedef struct
-{
-} GpMetafile;
-
-typedef struct
-{
-  REAL X;
-  REAL Y;
-} PointF;
-
-typedef struct
-{
-  INT X;
-  INT Y;
-} Point;
-
-typedef struct
-{
-  REAL X;
-  REAL Y;
-  REAL Width;
-  REAL Height;
-} RectF;
-
-typedef RectF GpRectF;
-
-typedef struct
-{
-  INT X;
-  INT Y;
-  INT Width;
-  INT Height;
-} Rect;
-
-typedef Rect GpRect;
-
-typedef struct
-{
-} MetafileHeader;
-
-typedef struct {
-  INT16 Left;
-  INT16 Top;
-  INT16 Right;
-  INT16 Bottom;
-} PWMFRect16;
-
-typedef struct {
-  UINT32 Key;
-  INT16 Hmf;
-  PWMFRect16 BoundingBox;
-  INT16 Inch;
-  UINT32 Reserved;
-  INT16 Checksum;
-} WmfPlaceableFileHeader;
-
-typedef struct
-{
-} GpPathData;
-
-typedef struct
-{
-} GpStringFormat;
-
-typedef struct
-{
-} GpPathGradient;
-
-typedef struct
-{
-} GpPathIterator;
-
-typedef DashCap GpDashCap;
-
-typedef PenAlignment GpPenAlignment;
-
-typedef PenType GpPenType;
-
-typedef DashStyle GpDashStyle;
-
-typedef struct
-{
-} CharacterRange;
-
-typedef struct
-{
-} GpTexture;
-
-typedef CoordinateSpace GpCoordinateSpace;
-
-typedef enum {
-  DebugEventLevelFatal,
-  DebugEventLevelWarning
-} DebugEventLevel;
-
-typedef VOID (WINAPI *DebugEventProc)(DebugEventLevel level,
-  CHAR *message);
-
-typedef struct
-{
-  UINT32 GdiplusVersion;
-  DebugEventProc DebugEventCallback;
-  BOOL SuppressBackgroundThread;
-  BOOL SuppressExternalCodecs;
-} GdiplusStartupInput;
-
-typedef Status (WINAPI *NotificationHookProc)(OUT ULONG_PTR *token);
-typedef VOID (WINAPI *NotificationUnhookProc)(ULONG_PTR token);
-
-typedef struct {
-  NotificationHookProc NotificationHook;
-  NotificationUnhookProc NotificationUnhook;
-} GdiplusStartupOutput;
-
-#endif /* __GDIPLUSPRIVATE_H */
diff --git a/reactos/dll/win32/gdiplus/matrix.c b/reactos/dll/win32/gdiplus/matrix.c
new file mode 100644 (file)
index 0000000..2ee4458
--- /dev/null
@@ -0,0 +1,266 @@
+/*
+ * Copyright (C) 2007 Google (Evan Stade)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <stdarg.h>
+#include <math.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "wingdi.h"
+
+#include "objbase.h"
+
+#include "gdiplus.h"
+#include "gdiplus_private.h"
+
+/* Multiplies two matrices of the form
+ *
+ * idx:0 idx:1     0
+ * idx:2 idx:3     0
+ * idx:4 idx:5     1
+ *
+ * and puts the output in out.
+ * */
+static void matrix_multiply(GDIPCONST REAL * left, GDIPCONST REAL * right, REAL * out)
+{
+    REAL temp[6];
+    int i, odd;
+
+    for(i = 0; i < 6; i++){
+        odd = i % 2;
+        temp[i] = left[i - odd] * right[odd] + left[i - odd + 1] * right[odd + 2] +
+                  (i >= 4 ? right[odd + 4] : 0.0);
+    }
+
+    memcpy(out, temp, 6 * sizeof(REAL));
+}
+
+GpStatus WINGDIPAPI GdipCreateMatrix2(REAL m11, REAL m12, REAL m21, REAL m22,
+    REAL dx, REAL dy, GpMatrix **matrix)
+{
+    if(!matrix)
+        return InvalidParameter;
+
+    *matrix = GdipAlloc(sizeof(GpMatrix));
+    if(!*matrix)    return OutOfMemory;
+
+    /* first row */
+    (*matrix)->matrix[0] = m11;
+    (*matrix)->matrix[1] = m12;
+    /* second row */
+    (*matrix)->matrix[2] = m21;
+    (*matrix)->matrix[3] = m22;
+    /* third row */
+    (*matrix)->matrix[4] = dx;
+    (*matrix)->matrix[5] = dy;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipCreateMatrix3(GDIPCONST GpRectF *rect,
+    GDIPCONST GpPointF *pt, GpMatrix **matrix)
+{
+    if(!matrix)
+        return InvalidParameter;
+
+    *matrix = GdipAlloc(sizeof(GpMatrix));
+    if(!*matrix)    return OutOfMemory;
+
+    memcpy((*matrix)->matrix, rect, 4 * sizeof(REAL));
+
+    (*matrix)->matrix[4] = pt->X;
+    (*matrix)->matrix[5] = pt->Y;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipCloneMatrix(GpMatrix *matrix, GpMatrix **clone)
+{
+    if(!matrix || !clone)
+        return InvalidParameter;
+
+    *clone = GdipAlloc(sizeof(GpMatrix));
+    if(!*clone)    return OutOfMemory;
+
+    **clone = *matrix;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipCreateMatrix(GpMatrix **matrix)
+{
+    if(!matrix)
+        return InvalidParameter;
+
+    *matrix = GdipAlloc(sizeof(GpMatrix));
+    if(!*matrix)    return OutOfMemory;
+
+    (*matrix)->matrix[0] = 1.0;
+    (*matrix)->matrix[1] = 0.0;
+    (*matrix)->matrix[2] = 0.0;
+    (*matrix)->matrix[3] = 1.0;
+    (*matrix)->matrix[4] = 0.0;
+    (*matrix)->matrix[5] = 0.0;
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipDeleteMatrix(GpMatrix *matrix)
+{
+    if(!matrix)
+        return InvalidParameter;
+
+    GdipFree(matrix);
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetMatrixElements(GDIPCONST GpMatrix *matrix,
+    REAL *out)
+{
+    if(!matrix || !out)
+        return InvalidParameter;
+
+    memcpy(out, matrix->matrix, sizeof(matrix->matrix));
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipMultiplyMatrix(GpMatrix *matrix, GpMatrix* matrix2,
+    GpMatrixOrder order)
+{
+    if(!matrix || !matrix2)
+        return InvalidParameter;
+
+    if(order == MatrixOrderAppend)
+        matrix_multiply(matrix->matrix, matrix2->matrix, matrix->matrix);
+    else
+        matrix_multiply(matrix2->matrix, matrix->matrix, matrix->matrix);
+
+    return Ok;
+}
+
+GpStatus WINGDIPAPI GdipRotateMatrix(GpMatrix *matrix, REAL angle,
+    GpMatrixOrder order)
+{
+    REAL cos_theta, sin_theta, rotate[6];
+
+    if(!matrix)