mirror of
https://github.com/reactos/reactos.git
synced 2024-10-30 11:35:58 +00:00
527f2f9057
* Create a branch for some evul shell experiments. svn path=/branches/shell-experiments/; revision=61927
877 lines
14 KiB
C++
877 lines
14 KiB
C++
/*
|
|
* GdiPlusHeaders.h
|
|
*
|
|
* Windows GDI+
|
|
*
|
|
* This file is part of the w32api package.
|
|
*
|
|
* THIS SOFTWARE IS NOT COPYRIGHTED
|
|
*
|
|
* This source code is offered for use in the public domain. You may
|
|
* use, modify or distribute it freely.
|
|
*
|
|
* This code is distributed in the hope that it will be useful but
|
|
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
|
|
* DISCLAIMED. This includes but is not limited to warranties of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
*/
|
|
|
|
#ifndef _GDIPLUSHEADERS_H
|
|
#define _GDIPLUSHEADERS_H
|
|
|
|
class Image : public GdiplusBase
|
|
{
|
|
public:
|
|
friend class Graphics;
|
|
|
|
Image(IStream *stream, BOOL useEmbeddedColorManagement)
|
|
{
|
|
}
|
|
|
|
Image(const WCHAR *filename, BOOL useEmbeddedColorManagement)
|
|
{
|
|
}
|
|
|
|
Image *Clone(VOID)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static Image *FromFile(const WCHAR *filename, BOOL useEmbeddedColorManagement)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static Image *FromStream(IStream *stream, BOOL useEmbeddedColorManagement)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
Status GetAllPropertyItems(UINT totalBufferSize, UINT numProperties, PropertyItem *allItems)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status GetBounds(RectF *srcRect, Unit *srcUnit)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status GetEncoderParameterList(const CLSID *clsidEncoder, UINT size, EncoderParameters *buffer)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
UINT GetEncoderParameterListSize(const CLSID *clsidEncoder)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
UINT GetFlags(VOID)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
UINT GetFrameCount(const GUID *dimensionID)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
UINT GetFrameDimensionsCount(VOID)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
Status GetFrameDimensionsList(GUID *dimensionIDs, UINT count)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
UINT GetHeight(VOID)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
REAL GetHorizontalResolution(VOID)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
Status GetLastStatus(VOID)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status GetPalette(ColorPalette *palette, INT size)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
INT GetPaletteSize(VOID)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
Status GetPhysicalDimension(SizeF *size)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
PixelFormat GetPixelFormat(VOID)
|
|
{
|
|
return PixelFormatUndefined;
|
|
}
|
|
|
|
UINT GetPropertyCount(VOID)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
Status GetPropertyIdList(UINT numOfProperty, PROPID *list)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status GetPropertyItem(PROPID propId, UINT propSize, PropertyItem *buffer)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
UINT GetPropertyItemSize(PROPID propId)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
Status GetPropertySize(UINT *totalBufferSize, UINT *numProperties)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status GetRawFormat(GUID *format)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Image *GetThumbnailImage(UINT thumbWidth, UINT thumbHeight, GetThumbnailImageAbort callback, VOID *callbackData)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
ImageType GetType(VOID)
|
|
{
|
|
return ImageTypeUnknown;
|
|
}
|
|
|
|
REAL GetVerticalResolution(VOID)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
UINT GetWidth(VOID)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
Status RemovePropertyItem(PROPID propId)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status RotateFlip(RotateFlipType rotateFlipType)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status Save(IStream *stream, const CLSID *clsidEncoder, const EncoderParameters *encoderParams)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status Save(const WCHAR *filename, const CLSID *clsidEncoder, const EncoderParameters *encoderParams)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status SaveAdd(const EncoderParameters* encoderParams)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status SaveAdd(Image *newImage, const EncoderParameters *encoderParams)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status SelectActiveFrame(const GUID *dimensionID, UINT frameIndex)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status SetPalette(const ColorPalette* palette)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status SetPropertyItem(const PropertyItem* item)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
protected:
|
|
Image()
|
|
{
|
|
}
|
|
};
|
|
|
|
|
|
class Bitmap : public Image
|
|
{
|
|
public:
|
|
Bitmap(IDirectDrawSurface7 *surface)
|
|
{
|
|
}
|
|
|
|
Bitmap(INT width, INT height, Graphics *target)
|
|
{
|
|
}
|
|
|
|
Bitmap(const BITMAPINFO *gdiBitmapInfo, VOID *gdiBitmapData)
|
|
{
|
|
}
|
|
|
|
Bitmap(INT width, INT height, PixelFormat format)
|
|
{
|
|
}
|
|
|
|
Bitmap(HBITMAP hbm, HPALETTE hpal)
|
|
{
|
|
}
|
|
|
|
Bitmap(INT width, INT height, INT stride, PixelFormat format, BYTE *scan0)
|
|
{
|
|
}
|
|
|
|
Bitmap(const WCHAR *filename, BOOL useIcm)
|
|
{
|
|
}
|
|
|
|
Bitmap(HINSTANCE hInstance, const WCHAR *bitmapName)
|
|
{
|
|
}
|
|
|
|
Bitmap(HICON hicon)
|
|
{
|
|
}
|
|
|
|
Bitmap(IStream *stream, BOOL useIcm)
|
|
{
|
|
}
|
|
|
|
Bitmap *Clone(const Rect &rect, PixelFormat format)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
Bitmap *Clone(const RectF &rect, PixelFormat format)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
Bitmap *Clone(REAL x, REAL y, REAL width, REAL height, PixelFormat format)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
Bitmap *Clone(INT x, INT y, INT width, INT height, PixelFormat format)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static Bitmap *FromBITMAPINFO(const BITMAPINFO *gdiBitmapInfo, VOID *gdiBitmapData)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static Bitmap *FromDirectDrawSurface7(IDirectDrawSurface7 *surface)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static Bitmap *FromFile(const WCHAR *filename, BOOL useEmbeddedColorManagement)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static Bitmap *FromHBITMAP(HBITMAP hbm, HPALETTE hpal)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static Bitmap *FromHICON(HICON hicon)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static Bitmap *FromResource(HINSTANCE hInstance, const WCHAR *bitmapName)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static Bitmap *FromStream(IStream *stream, BOOL useEmbeddedColorManagement)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
Status GetHBITMAP(const Color &colorBackground, HBITMAP *hbmReturn)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status GetHICON(HICON *hicon)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status GetPixel(INT x, INT y, Color *color)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status LockBits(const Rect *rect, UINT flags, PixelFormat format, BitmapData *lockedBitmapData)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status SetPixel(INT x, INT y, const Color &color)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status SetResolution(REAL xdpi, REAL ydpi)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status UnlockBits(BitmapData *lockedBitmapData)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
};
|
|
|
|
|
|
class CachedBitmap : public GdiplusBase
|
|
{
|
|
public:
|
|
CachedBitmap(Bitmap *bitmap, Graphics *graphics)
|
|
{
|
|
}
|
|
|
|
Status GetLastStatus(VOID)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
};
|
|
|
|
|
|
class Font : public GdiplusBase
|
|
{
|
|
public:
|
|
friend class FontFamily;
|
|
friend class FontCollection;
|
|
|
|
Font(const FontFamily *family, REAL emSize, INT style, Unit unit)
|
|
{
|
|
}
|
|
|
|
Font(HDC hdc, const HFONT hfont)
|
|
{
|
|
}
|
|
|
|
Font(HDC hdc, const LOGFONTA *logfont)
|
|
{
|
|
}
|
|
|
|
Font(HDC hdc, const LOGFONTW *logfont)
|
|
{
|
|
}
|
|
|
|
Font(const WCHAR *familyName, REAL emSize, INT style, Unit unit, const FontCollection *fontCollection)
|
|
{
|
|
}
|
|
|
|
Font(HDC hdc)
|
|
{
|
|
}
|
|
|
|
Font *Clone(VOID) const
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
Status GetFamily(FontFamily* family) const
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
REAL GetHeight(const Graphics* graphics) const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
REAL GetHeight(REAL dpi) const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
Status GetLastStatus(VOID) const
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status GetLogFontA(const Graphics *g, LOGFONTA *logfontA) const
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status GetLogFontW(const Graphics *g, LOGFONTW *logfontW) const
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
REAL GetSize(VOID) const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
INT GetStyle(VOID) const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
Unit GetUnit(VOID) const
|
|
{
|
|
return UnitWorld;
|
|
}
|
|
|
|
BOOL IsAvailable(VOID) const
|
|
{
|
|
return FALSE;
|
|
}
|
|
};
|
|
|
|
|
|
class FontCollection : public GdiplusBase
|
|
{
|
|
public:
|
|
FontCollection(VOID)
|
|
{
|
|
}
|
|
|
|
Status GetFamilies(INT numSought, FontFamily *gpfamilies, INT *numFound) const
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
INT GetFamilyCount(VOID) const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
Status GetLastStatus(VOID)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
};
|
|
|
|
|
|
class FontFamily : public GdiplusBase
|
|
{
|
|
public:
|
|
FontFamily(VOID)
|
|
{
|
|
}
|
|
|
|
FontFamily(const WCHAR *name, const FontCollection *fontCollection)
|
|
{
|
|
}
|
|
|
|
FontFamily *Clone(VOID)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static const FontFamily *GenericMonospace(VOID)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static const FontFamily *GenericSansSerif(VOID)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static const FontFamily *GenericSerif(VOID)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
UINT16 GetCellAscent(INT style) const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
UINT16 GetCellDescent(INT style) const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
UINT16 GetEmHeight(INT style)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
Status GetFamilyName(WCHAR name[LF_FACESIZE], WCHAR language) const
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status GetLastStatus(VOID) const
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
UINT16 GetLineSpacing(INT style) const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
BOOL IsAvailable(VOID) const
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL IsStyleAvailable(INT style) const
|
|
{
|
|
return FALSE;
|
|
}
|
|
};
|
|
|
|
|
|
class InstalledFontFamily : public FontFamily
|
|
{
|
|
public:
|
|
InstalledFontFamily(VOID)
|
|
{
|
|
}
|
|
};
|
|
|
|
|
|
class PrivateFontCollection : public FontCollection
|
|
{
|
|
public:
|
|
PrivateFontCollection(VOID)
|
|
{
|
|
}
|
|
|
|
Status AddFontFile(const WCHAR* filename)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status AddMemoryFont(const VOID *memory, INT length)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
};
|
|
|
|
|
|
class Region : public GdiplusBase
|
|
{
|
|
public:
|
|
friend class GraphicsPath;
|
|
friend class Matrix;
|
|
|
|
Region(const Rect &rect)
|
|
{
|
|
}
|
|
|
|
Region(VOID)
|
|
{
|
|
}
|
|
|
|
Region(const BYTE *regionData, INT size)
|
|
{
|
|
}
|
|
|
|
Region(const GraphicsPath *path)
|
|
{
|
|
}
|
|
|
|
Region(HRGN hRgn)
|
|
{
|
|
}
|
|
|
|
Region(const RectF &rect)
|
|
{
|
|
}
|
|
|
|
Region *Clone(VOID)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
Status Complement(const GraphicsPath *path)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status Complement(const Region *region)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status Complement(const Rect &rect)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status Complement(const RectF &rect)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
BOOL Equals(const Region *region, const Graphics *g) const
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
Status Exclude(const GraphicsPath *path)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status Exclude(const RectF &rect)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status Exclude(const Rect &rect)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status Exclude(const Region *region)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
static Region *FromHRGN(HRGN hRgn)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
Status GetBounds(Rect *rect, const Graphics *g) const
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status GetBounds(RectF *rect, const Graphics *g) const
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status GetData(BYTE *buffer, UINT bufferSize, UINT *sizeFilled) const
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
UINT GetDataSize(VOID) const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
HRGN GetHRGN(const Graphics *g) const
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
Status GetLastStatus(VOID)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status GetRegionScans(const Matrix *matrix, Rect *rects, INT *count) const
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status GetRegionScans(const Matrix *matrix, RectF *rects, INT *count) const
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
UINT GetRegionScansCount(const Matrix *matrix) const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
Status Intersect(const Rect &rect)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status Intersect(const GraphicsPath *path)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status Intersect(const RectF &rect)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status Intersect(const Region *region)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
BOOL IsEmpty(const Graphics *g) const
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
BOOL IsInfinite(const Graphics *g) const
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL IsVisible(const PointF &point, const Graphics *g) const
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL IsVisible(const RectF &rect, const Graphics *g) const
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL IsVisible(const Rect &rect, const Graphics *g) const
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL IsVisible(INT x, INT y, const Graphics *g) const
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL IsVisible(REAL x, REAL y, const Graphics *g) const
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL IsVisible(INT x, INT y, INT width, INT height, const Graphics *g) const
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL IsVisible(const Point &point, const Graphics *g) const
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL IsVisible(REAL x, REAL y, REAL width, REAL height, const Graphics *g) const
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
Status MakeEmpty(VOID)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status MakeInfinite(VOID)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status Transform(const Matrix *matrix)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status Translate(REAL dx, REAL dy)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status Translate(INT dx, INT dy)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status Union(const Rect &rect)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status Union(const Region *region)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status Union(const RectF &rect)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status Union(const GraphicsPath *path)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status Xor(const GraphicsPath *path)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status Xor(const RectF &rect)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status Xor(const Rect &rect)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
Status Xor(const Region *region)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
};
|
|
|
|
|
|
class CustomLineCap : public GdiplusBase
|
|
{
|
|
public:
|
|
CustomLineCap(const GraphicsPath *fillPath, const GraphicsPath *strokePath, LineCap baseCap, REAL baseInset);
|
|
CustomLineCap *Clone(VOID);
|
|
LineCap GetBaseCap(VOID);
|
|
REAL GetBaseInset(VOID);
|
|
Status GetLastStatus(VOID);
|
|
Status GetStrokeCaps(LineCap *startCap, LineCap *endCap);
|
|
LineJoin GetStrokeJoin(VOID);
|
|
REAL GetWidthScale(VOID);
|
|
Status SetBaseCap(LineCap baseCap);
|
|
Status SetBaseInset(REAL inset);
|
|
Status SetStrokeCap(LineCap strokeCap);
|
|
Status SetStrokeCaps(LineCap startCap, LineCap endCap);
|
|
Status SetStrokeJoin(LineJoin lineJoin);
|
|
Status SetWidthScale(IN REAL widthScale);
|
|
protected:
|
|
CustomLineCap();
|
|
};
|
|
|
|
#endif /* _GDIPLUSHEADERS_H */
|