[USB-BRINGUP-TRUNK]

- Create a branch to do a proper merge of USB work from a trunk base instead of from cmake-bringup - In the future, DO NOT under any circumstances branch another branch. This leads to merge problems! svn path=/branches/usb-bringup-trunk/; revision=55018
2025-06-25 11:49:42 +00:00 · 2012-01-20 20:58:46 +00:00 · 2012-01-20 20:58:46 +00:00 · c2d0d784c7
commit c2d0d784c7
parent f65034e760
20461 changed files with 0 additions and 1213965 deletions
--- a/include/psdk/gdiplusheaders.h
+++ b/include/psdk/gdiplusheaders.h
@ -0,0 +1,876 @@
+/*
+ * 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 */