Subversion Repositories Games.Chess Giants

 

 

 

 

 

 

 

 

 

typedef interface IDWriteTextFormat IDWriteTextFormat;

typedef interface IDWriteTextLayout IDWriteTextLayout;

typedef interface IDWriteRenderingParams IDWriteRenderingParams;

typedef interface IDXGISurface IDXGISurface;

typedef interface IWICBitmap IWICBitmap;

typedef interface IWICBitmapSource IWICBitmapSource;

 

typedef struct DWRITE_GLYPH_RUN DWRITE_GLYPH_RUN;

 

 

interface ID2D1Factory;

interface ID2D1RenderTarget;

interface ID2D1BitmapRenderTarget;

interface ID2D1SimplifiedGeometrySink;

interface ID2D1TessellationSink;

interface ID2D1Geometry;

interface ID2D1Brush;

 

 

typedef interface ID2D1Factory ID2D1Factory;

typedef interface ID2D1RenderTarget ID2D1RenderTarget;

typedef interface ID2D1BitmapRenderTarget ID2D1BitmapRenderTarget;

typedef interface ID2D1SimplifiedGeometrySink ID2D1SimplifiedGeometrySink;;

typedef interface ID2D1TessellationSink ID2D1TessellationSink;

typedef interface ID2D1Geometry ID2D1Geometry;

typedef interface ID2D1Brush ID2D1Brush;

 

       

 

typedef enum D2D1_ALPHA_MODE

       

        //

        // Alpha mode should be determined implicitly. Some target surfaces do not supply

        // or imply this information in which case alpha must be specified.

        //

        D2D1_ALPHA_MODE_UNKNOWN = 0,

       

        //

        // Treat the alpha as premultipled.

        //

        D2D1_ALPHA_MODE_PREMULTIPLIED = 1,

       

        //

        // Opacity is in the 'A' component only.

        //

        D2D1_ALPHA_MODE_STRAIGHT = 2,

       

        //

        // Ignore any alpha channel information.

        //

        D2D1_ALPHA_MODE_IGNORE = 3,

        D2D1_ALPHA_MODE_FORCE_DWORD = 0xffffffff

 

} D2D1_ALPHA_MODE;

 

 

typedef enum D2D1_GAMMA

       

        //

        // Colors are manipulated in 2.2 gamma color space.

        //

        D2D1_GAMMA_2_2 = 0,

       

        //

        // Colors are manipulated in 1.0 gamma color space.

        //

        D2D1_GAMMA_1_0 = 1,

        D2D1_GAMMA_FORCE_DWORD = 0xffffffff

 

} D2D1_GAMMA;

 

 

typedef enum D2D1_OPACITY_MASK_CONTENT

       

        //

        // The mask contains geometries or bitmaps.

        //

        D2D1_OPACITY_MASK_CONTENT_GRAPHICS = 0,

       

        //

        // The mask contains text rendered using one of the natural text modes.

        //

        D2D1_OPACITY_MASK_CONTENT_TEXT_NATURAL = 1,

       

        //

        // The mask contains text rendered using one of the GDI compatible text modes.

        //

        D2D1_OPACITY_MASK_CONTENT_TEXT_GDI_COMPATIBLE = 2,

        D2D1_OPACITY_MASK_CONTENT_FORCE_DWORD = 0xffffffff

 

} D2D1_OPACITY_MASK_CONTENT;

 

 

typedef enum D2D1_EXTEND_MODE

       

        //

        // Extend the edges of the source out by clamping sample points outside the source

        // to the edges.

        //

        D2D1_EXTEND_MODE_CLAMP = 0,

       

        //

        // The base tile is drawn untransformed and the remainder are filled by repeating

        // the base tile.

        //

        D2D1_EXTEND_MODE_WRAP = 1,

       

        //

        // The same as wrap, but alternate tiles are flipped  The base tile is drawn

        // untransformed.

        //

        D2D1_EXTEND_MODE_MIRROR = 2,

        D2D1_EXTEND_MODE_FORCE_DWORD = 0xffffffff

 

} D2D1_EXTEND_MODE;

 

 

typedef enum D2D1_ANTIALIAS_MODE

       

        //

        // The edges of each primitive are antialiased sequentially.

        //

        D2D1_ANTIALIAS_MODE_PER_PRIMITIVE = 0,

       

        //

        // Each pixel is rendered if its pixel center is contained by the geometry.

        //

        D2D1_ANTIALIAS_MODE_ALIASED = 1,

        D2D1_ANTIALIAS_MODE_FORCE_DWORD = 0xffffffff

 

} D2D1_ANTIALIAS_MODE;

 

 

typedef enum D2D1_TEXT_ANTIALIAS_MODE

       

        //

        // Render text using the current system setting.

        //

        D2D1_TEXT_ANTIALIAS_MODE_DEFAULT = 0,

       

        //

        // Render text using ClearType.

        //

        D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE = 1,

       

        //

        // Render text using gray-scale.

        //

        D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE = 2,

       

        //

        // Render text aliased.

        //

        D2D1_TEXT_ANTIALIAS_MODE_ALIASED = 3,

        D2D1_TEXT_ANTIALIAS_MODE_FORCE_DWORD = 0xffffffff

 

} D2D1_TEXT_ANTIALIAS_MODE;

 

 

typedef enum D2D1_BITMAP_INTERPOLATION_MODE

       

        //

        // Nearest Neighbor filtering. Also known as nearest pixel or nearest point

        // sampling.

        //

        D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR = 0,

       

        //

        // Linear filtering.

        //

        D2D1_BITMAP_INTERPOLATION_MODE_LINEAR = 1,

        D2D1_BITMAP_INTERPOLATION_MODE_FORCE_DWORD = 0xffffffff

 

} D2D1_BITMAP_INTERPOLATION_MODE;

 

 

typedef enum D2D1_DRAW_TEXT_OPTIONS

       

        //

        // Do not snap the baseline of the text vertically.

        //

        D2D1_DRAW_TEXT_OPTIONS_NO_SNAP = 0x00000001,

       

        //

        // Clip the text to the content bounds.

        //

        D2D1_DRAW_TEXT_OPTIONS_CLIP = 0x00000002,

        D2D1_DRAW_TEXT_OPTIONS_NONE = 0x00000000,

        D2D1_DRAW_TEXT_OPTIONS_FORCE_DWORD = 0xffffffff

 

} D2D1_DRAW_TEXT_OPTIONS;

 

DEFINE_ENUM_FLAG_OPERATORS(D2D1_DRAW_TEXT_OPTIONS);

 

 

typedef struct D2D1_PIXEL_FORMAT

    DXGI_FORMAT format;

    D2D1_ALPHA_MODE alphaMode;

 

} D2D1_PIXEL_FORMAT;

 

typedef D2D_POINT_2U D2D1_POINT_2U;

typedef D2D_POINT_2F D2D1_POINT_2F;

typedef D2D_RECT_F D2D1_RECT_F;

typedef D2D_RECT_U D2D1_RECT_U;

typedef D2D_SIZE_F D2D1_SIZE_F;

typedef D2D_SIZE_U D2D1_SIZE_U;

typedef D2D_COLOR_F D2D1_COLOR_F;

typedef D2D_MATRIX_3X2_F D2D1_MATRIX_3X2_F;

typedef UINT64 D2D1_TAG;

 

typedef struct D2D1_BITMAP_PROPERTIES

    D2D1_PIXEL_FORMAT pixelFormat;

    FLOAT dpiX;

    FLOAT dpiY;

 

} D2D1_BITMAP_PROPERTIES;

 

 

typedef struct D2D1_GRADIENT_STOP

    FLOAT position;

    D2D1_COLOR_F color;

 

} D2D1_GRADIENT_STOP;

 

 

typedef struct D2D1_BRUSH_PROPERTIES

    FLOAT opacity;

    D2D1_MATRIX_3X2_F transform;

 

} D2D1_BRUSH_PROPERTIES;

 

 

typedef struct D2D1_BITMAP_BRUSH_PROPERTIES

    D2D1_EXTEND_MODE extendModeX;

    D2D1_EXTEND_MODE extendModeY;

    D2D1_BITMAP_INTERPOLATION_MODE interpolationMode;

 

} D2D1_BITMAP_BRUSH_PROPERTIES;

 

 

typedef struct D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES

    D2D1_POINT_2F startPoint;

    D2D1_POINT_2F endPoint;

 

} D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES;

 

 

typedef struct D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES

    D2D1_POINT_2F center;

    D2D1_POINT_2F gradientOriginOffset;

    FLOAT radiusX;

    FLOAT radiusY;

 

} D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES;

 

 

typedef enum D2D1_ARC_SIZE

        D2D1_ARC_SIZE_SMALL = 0,

        D2D1_ARC_SIZE_LARGE = 1,

        D2D1_ARC_SIZE_FORCE_DWORD = 0xffffffff

 

} D2D1_ARC_SIZE;

 

 

typedef enum D2D1_CAP_STYLE

       

        //

        // Flat line cap.

        //

        D2D1_CAP_STYLE_FLAT = 0,

       

        //

        // Square line cap.

        //

        D2D1_CAP_STYLE_SQUARE = 1,

       

        //

        // Round line cap.

        //

        D2D1_CAP_STYLE_ROUND = 2,

       

        //

        // Triangle line cap.

        //

        D2D1_CAP_STYLE_TRIANGLE = 3,

        D2D1_CAP_STYLE_FORCE_DWORD = 0xffffffff

 

} D2D1_CAP_STYLE;

 

 

typedef enum D2D1_DASH_STYLE

        D2D1_DASH_STYLE_SOLID = 0,

        D2D1_DASH_STYLE_DASH = 1,

        D2D1_DASH_STYLE_DOT = 2,

        D2D1_DASH_STYLE_DASH_DOT = 3,

        D2D1_DASH_STYLE_DASH_DOT_DOT = 4,

        D2D1_DASH_STYLE_CUSTOM = 5,

        D2D1_DASH_STYLE_FORCE_DWORD = 0xffffffff

 

} D2D1_DASH_STYLE;

 

 

typedef enum D2D1_LINE_JOIN

       

        //

        // Miter join.

        //

        D2D1_LINE_JOIN_MITER = 0,

       

        //

        // Bevel join.

        //

        D2D1_LINE_JOIN_BEVEL = 1,

       

        //

        // Round join.

        //

        D2D1_LINE_JOIN_ROUND = 2,

       

        //

        // Miter/Bevel join.

        //

        D2D1_LINE_JOIN_MITER_OR_BEVEL = 3,

        D2D1_LINE_JOIN_FORCE_DWORD = 0xffffffff

 

} D2D1_LINE_JOIN;

 

 

typedef enum D2D1_COMBINE_MODE

       

        //

        // Produce a geometry representing the set of points contained in either

        // the first or the second geometry.

        //

        D2D1_COMBINE_MODE_UNION = 0,

       

        //

        // Produce a geometry representing the set of points common to the first

        // and the second geometries.

        //

        D2D1_COMBINE_MODE_INTERSECT = 1,

       

        //

        // Produce a geometry representing the set of points contained in the

        // first geometry or the second geometry, but not both.

        //

        D2D1_COMBINE_MODE_XOR = 2,

       

        //

        // Produce a geometry representing the set of points contained in the

        // first geometry but not the second geometry.

        //

        D2D1_COMBINE_MODE_EXCLUDE = 3,

        D2D1_COMBINE_MODE_FORCE_DWORD = 0xffffffff

 

} D2D1_COMBINE_MODE;

 

 

typedef enum D2D1_GEOMETRY_RELATION

       

        //

        // The relation between the geometries couldn't be determined. This value is never

        // returned by any D2D method.

        //

        D2D1_GEOMETRY_RELATION_UNKNOWN = 0,

       

        //

        // The two geometries do not intersect at all.

        //

        D2D1_GEOMETRY_RELATION_DISJOINT = 1,

       

        //

        // The passed in geometry is entirely contained by the object.

        //

        D2D1_GEOMETRY_RELATION_IS_CONTAINED = 2,

       

        //

        // The object entirely contains the passed in geometry.

        //

        D2D1_GEOMETRY_RELATION_CONTAINS = 3,

       

        //

        // The two geometries overlap but neither completely contains the other.

        //

        D2D1_GEOMETRY_RELATION_OVERLAP = 4,

        D2D1_GEOMETRY_RELATION_FORCE_DWORD = 0xffffffff

 

} D2D1_GEOMETRY_RELATION;

 

 

typedef enum D2D1_GEOMETRY_SIMPLIFICATION_OPTION

        D2D1_GEOMETRY_SIMPLIFICATION_OPTION_CUBICS_AND_LINES = 0,

        D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES = 1,

        D2D1_GEOMETRY_SIMPLIFICATION_OPTION_FORCE_DWORD = 0xffffffff

 

} D2D1_GEOMETRY_SIMPLIFICATION_OPTION;

 

 

typedef enum D2D1_FIGURE_BEGIN

        D2D1_FIGURE_BEGIN_FILLED = 0,

        D2D1_FIGURE_BEGIN_HOLLOW = 1,

        D2D1_FIGURE_BEGIN_FORCE_DWORD = 0xffffffff

 

} D2D1_FIGURE_BEGIN;

 

 

typedef enum D2D1_FIGURE_END

        D2D1_FIGURE_END_OPEN = 0,

        D2D1_FIGURE_END_CLOSED = 1,

        D2D1_FIGURE_END_FORCE_DWORD = 0xffffffff

 

} D2D1_FIGURE_END;

 

 

typedef struct D2D1_BEZIER_SEGMENT

    D2D1_POINT_2F point1;

    D2D1_POINT_2F point2;

    D2D1_POINT_2F point3;

 

} D2D1_BEZIER_SEGMENT;

 

 

typedef struct D2D1_TRIANGLE

    D2D1_POINT_2F point1;

    D2D1_POINT_2F point2;

    D2D1_POINT_2F point3;

 

} D2D1_TRIANGLE;

 

 

typedef enum D2D1_PATH_SEGMENT

        D2D1_PATH_SEGMENT_NONE = 0x00000000,

        D2D1_PATH_SEGMENT_FORCE_UNSTROKED = 0x00000001,

        D2D1_PATH_SEGMENT_FORCE_ROUND_LINE_JOIN = 0x00000002,

        D2D1_PATH_SEGMENT_FORCE_DWORD = 0xffffffff

 

} D2D1_PATH_SEGMENT;

 

DEFINE_ENUM_FLAG_OPERATORS(D2D1_PATH_SEGMENT);

 

 

typedef enum D2D1_SWEEP_DIRECTION

        D2D1_SWEEP_DIRECTION_COUNTER_CLOCKWISE = 0,

        D2D1_SWEEP_DIRECTION_CLOCKWISE = 1,

        D2D1_SWEEP_DIRECTION_FORCE_DWORD = 0xffffffff

 

} D2D1_SWEEP_DIRECTION;

 

 

typedef enum D2D1_FILL_MODE

        D2D1_FILL_MODE_ALTERNATE = 0,

        D2D1_FILL_MODE_WINDING = 1,

        D2D1_FILL_MODE_FORCE_DWORD = 0xffffffff

 

} D2D1_FILL_MODE;

 

 

typedef struct D2D1_ARC_SEGMENT

    D2D1_POINT_2F point;

    D2D1_SIZE_F size;

    FLOAT rotationAngle;

    D2D1_SWEEP_DIRECTION sweepDirection;

    D2D1_ARC_SIZE arcSize;

 

} D2D1_ARC_SEGMENT;

 

 

typedef struct D2D1_QUADRATIC_BEZIER_SEGMENT

    D2D1_POINT_2F point1;

    D2D1_POINT_2F point2;

 

} D2D1_QUADRATIC_BEZIER_SEGMENT;

 

 

typedef struct D2D1_ELLIPSE

    D2D1_POINT_2F point;

    FLOAT radiusX;

    FLOAT radiusY;

 

} D2D1_ELLIPSE;

 

 

typedef struct D2D1_ROUNDED_RECT

    D2D1_RECT_F rect;

    FLOAT radiusX;

    FLOAT radiusY;

 

} D2D1_ROUNDED_RECT;

 

 

typedef struct D2D1_STROKE_STYLE_PROPERTIES

    D2D1_CAP_STYLE startCap;

    D2D1_CAP_STYLE endCap;

    D2D1_CAP_STYLE dashCap;

    D2D1_LINE_JOIN lineJoin;

    FLOAT miterLimit;

    D2D1_DASH_STYLE dashStyle;

    FLOAT dashOffset;

 

} D2D1_STROKE_STYLE_PROPERTIES;

 

 

typedef enum D2D1_LAYER_OPTIONS

        D2D1_LAYER_OPTIONS_NONE = 0x00000000,

       

        //

        // The layer will render correctly for ClearType text. If the render target was set

        // to ClearType previously, the layer will continue to render ClearType. If the

        // render target was set to ClearType and this option is not specified, the render

        // target will be set to render gray-scale until the layer is popped. The caller

        // can override this default by calling SetTextAntialiasMode while within the

        // layer. This flag is slightly slower than the default.

        //

        D2D1_LAYER_OPTIONS_INITIALIZE_FOR_CLEARTYPE = 0x00000001,

        D2D1_LAYER_OPTIONS_FORCE_DWORD = 0xffffffff

 

} D2D1_LAYER_OPTIONS;

 

DEFINE_ENUM_FLAG_OPERATORS(D2D1_LAYER_OPTIONS);

 

 

typedef struct D2D1_LAYER_PARAMETERS

   

    //

    // The rectangular clip that will be applied to the layer. The clip is affected by

    // the world transform. Content outside of the content bounds will not render.

    //

    D2D1_RECT_F contentBounds;

   

    //

    // A general mask that can be optionally applied to the content. Content not inside

    // the fill of the mask will not be rendered.

    //

    __field_ecount_opt(1) ID2D1Geometry *geometricMask;

   

    //

    // Specifies whether the mask should be aliased or antialiased.

    //

    D2D1_ANTIALIAS_MODE maskAntialiasMode;

   

    //

    // An additional transform that may be applied to the mask in addition to the

    // current world transform.

    //

    D2D1_MATRIX_3X2_F maskTransform;

   

    //

    // The opacity with which all of the content in the layer will be blended back to

    // the target when the layer is popped.

    //

    FLOAT opacity;

   

    //

    // An additional brush that can be applied to the layer. Only the opacity channel

    // is sampled from this brush and multiplied both with the layer content and the

    // over-all layer opacity.

    //

    __field_ecount_opt(1) ID2D1Brush *opacityBrush;

   

    //

    // Specifies if ClearType will be rendered into the layer.

    //

    D2D1_LAYER_OPTIONS layerOptions;

 

} D2D1_LAYER_PARAMETERS;

 

 

typedef enum D2D1_WINDOW_STATE

        D2D1_WINDOW_STATE_NONE = 0x0000000,

        D2D1_WINDOW_STATE_OCCLUDED = 0x0000001,

        D2D1_WINDOW_STATE_FORCE_DWORD = 0xffffffff

 

} D2D1_WINDOW_STATE;

 

DEFINE_ENUM_FLAG_OPERATORS(D2D1_WINDOW_STATE);

 

 

typedef enum D2D1_RENDER_TARGET_TYPE

       

        //

        // D2D is free to choose the render target type for the caller.

        //

        D2D1_RENDER_TARGET_TYPE_DEFAULT = 0,

       

        //

        // The render target will render using the CPU.

        //

        D2D1_RENDER_TARGET_TYPE_SOFTWARE = 1,

       

        //

        // The render target will render using the GPU.

        //

        D2D1_RENDER_TARGET_TYPE_HARDWARE = 2,

        D2D1_RENDER_TARGET_TYPE_FORCE_DWORD = 0xffffffff

 

} D2D1_RENDER_TARGET_TYPE;

 

 

typedef enum D2D1_FEATURE_LEVEL

       

        //

        // The caller does not require a particular underlying D3D device level.

        //

        D2D1_FEATURE_LEVEL_DEFAULT = 0,

       

        //

        // The D3D device level is DX9 compatible.

        //

        D2D1_FEATURE_LEVEL_9 = D3D10_FEATURE_LEVEL_9_1,

       

        //

        // The D3D device level is DX10 compatible.

        //

        D2D1_FEATURE_LEVEL_10 = D3D10_FEATURE_LEVEL_10_0,

        D2D1_FEATURE_LEVEL_FORCE_DWORD = 0xffffffff

 

} D2D1_FEATURE_LEVEL;

 

 

typedef enum D2D1_RENDER_TARGET_USAGE

        D2D1_RENDER_TARGET_USAGE_NONE = 0x00000000,

       

        //

        // Rendering will occur locally, if a terminal-services session is established, the

        // bitmap updates will be sent to the terminal services client.

        //

        D2D1_RENDER_TARGET_USAGE_FORCE_BITMAP_REMOTING = 0x00000001,

       

        //

        // The render target will allow a call to GetDC on the IGdiInteropRenderTarget

        // interface. Rendering will also occur locally.

        //

        D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE = 0x00000002,

        D2D1_RENDER_TARGET_USAGE_FORCE_DWORD = 0xffffffff

 

} D2D1_RENDER_TARGET_USAGE;

 

DEFINE_ENUM_FLAG_OPERATORS(D2D1_RENDER_TARGET_USAGE);

 

 

typedef enum D2D1_PRESENT_OPTIONS

        D2D1_PRESENT_OPTIONS_NONE = 0x00000000,

       

        //

        // Keep the target contents intact through present.

        //

        D2D1_PRESENT_OPTIONS_RETAIN_CONTENTS = 0x00000001,

       

        //

        // Do not wait for display refresh to commit changes to display.

        //

        D2D1_PRESENT_OPTIONS_IMMEDIATELY = 0x00000002,

        D2D1_PRESENT_OPTIONS_FORCE_DWORD = 0xffffffff

 

} D2D1_PRESENT_OPTIONS;

 

DEFINE_ENUM_FLAG_OPERATORS(D2D1_PRESENT_OPTIONS);

 

 

typedef struct D2D1_RENDER_TARGET_PROPERTIES

    D2D1_RENDER_TARGET_TYPE type;

    D2D1_PIXEL_FORMAT pixelFormat;

    FLOAT dpiX;

    FLOAT dpiY;

    D2D1_RENDER_TARGET_USAGE usage;

    D2D1_FEATURE_LEVEL minLevel;

 

} D2D1_RENDER_TARGET_PROPERTIES;

 

 

typedef struct D2D1_HWND_RENDER_TARGET_PROPERTIES

    HWND hwnd;

    D2D1_SIZE_U pixelSize;

    D2D1_PRESENT_OPTIONS presentOptions;

 

} D2D1_HWND_RENDER_TARGET_PROPERTIES;

 

 

typedef enum D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS

        D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE = 0x00000000,

       

        //

        // The compatible render target will allow a call to GetDC on the

        // IGdiInteropRenderTarget interface. This can be specified even if the parent

        // render target is not GDI compatible.

        //

        D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_GDI_COMPATIBLE = 0x00000001,

        D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_FORCE_DWORD = 0xffffffff

 

} D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS;

 

DEFINE_ENUM_FLAG_OPERATORS(D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS);

 

 

typedef struct D2D1_DRAWING_STATE_DESCRIPTION

    D2D1_ANTIALIAS_MODE antialiasMode;

    D2D1_TEXT_ANTIALIAS_MODE textAntialiasMode;

    D2D1_TAG tag1;

    D2D1_TAG tag2;

    D2D1_MATRIX_3X2_F transform;

 

} D2D1_DRAWING_STATE_DESCRIPTION;

 

 

typedef enum D2D1_DC_INITIALIZE_MODE

       

        //

        // The contents of the D2D render target will be copied to the DC.

        //

        D2D1_DC_INITIALIZE_MODE_COPY = 0,

       

        //

        // The contents of the DC will be cleared.

        //

        D2D1_DC_INITIALIZE_MODE_CLEAR = 1,

        D2D1_DC_INITIALIZE_MODE_FORCE_DWORD = 0xffffffff

 

} D2D1_DC_INITIALIZE_MODE;

 

 

typedef enum D2D1_DEBUG_LEVEL

        D2D1_DEBUG_LEVEL_NONE = 0,

        D2D1_DEBUG_LEVEL_ERROR = 1,

        D2D1_DEBUG_LEVEL_WARNING = 2,

        D2D1_DEBUG_LEVEL_INFORMATION = 3,

        D2D1_DEBUG_LEVEL_FORCE_DWORD = 0xffffffff

 

} D2D1_DEBUG_LEVEL;

 

 

typedef enum D2D1_FACTORY_TYPE

       

        //

        // The resulting factory and derived resources may only be invoked serially.

        // Reference counts on resources are interlocked, however, resource and render

        // target state is not protected from multi-threaded access.

        //

        D2D1_FACTORY_TYPE_SINGLE_THREADED = 0,

       

        //

        // The resulting factory may be invoked from multiple threads. Returned resources

        // use interlocked reference counting and their state is protected.

        //

        D2D1_FACTORY_TYPE_MULTI_THREADED = 1,

        D2D1_FACTORY_TYPE_FORCE_DWORD = 0xffffffff

 

} D2D1_FACTORY_TYPE;

 

 

typedef struct D2D1_FACTORY_OPTIONS

   

    //

    // Requests a certain level of debugging information from the debug layer. This

    // parameter is ignored if the debug layer DLL is not present.

    //

    D2D1_DEBUG_LEVEL debugLevel;

 

} D2D1_FACTORY_OPTIONS;

 

 

 

 

 

interface D2D1_DECLARE_INTERFACE("2cd90691-12e2-11dc-9fed-001143a055f9") ID2D1Resource  : public IUnknown

   

   

    //

    // Retrieve the factory associated with this resource.

    //

    STDMETHOD_(void, GetFactory)(

        __deref_out ID2D1Factory **factory

        ) CONST PURE;

}; // interface ID2D1Resource

 

 

 

interface D2D1_DECLARE_INTERFACE("a2296057-ea42-4099-983b-539fb6505426") ID2D1Bitmap  : public ID2D1Resource

   

   

    //

    // Returns the size of the bitmap in resolution independent units.

    //

    STDMETHOD_(D2D1_SIZE_F, GetSize)(

        ) CONST PURE;

   

   

    //

    // Returns the size of the bitmap in resolution dependent units, (pixels).

    //

    STDMETHOD_(D2D1_SIZE_U, GetPixelSize)(

        ) CONST PURE;

   

   

    //

    // Retrieve the format of the bitmap.

    //

    STDMETHOD_(D2D1_PIXEL_FORMAT, GetPixelFormat)(

        ) CONST PURE;

   

   

    //

    // Return the DPI of the bitmap.

    //

    STDMETHOD_(void, GetDpi)(

        __out FLOAT *dpiX,

        __out FLOAT *dpiY

        ) CONST PURE;

   

    STDMETHOD(CopyFromBitmap)(

        __in_opt CONST D2D1_POINT_2U *destPoint,

        __in ID2D1Bitmap *bitmap,

        __in_opt CONST D2D1_RECT_U *srcRect

        ) PURE;

   

    STDMETHOD(CopyFromRenderTarget)(

        __in_opt CONST D2D1_POINT_2U *destPoint,

        __in ID2D1RenderTarget *renderTarget,

        __in_opt CONST D2D1_RECT_U *srcRect

        ) PURE;

   

    STDMETHOD(CopyFromMemory)(

        __in_opt CONST D2D1_RECT_U *dstRect,

        __in CONST void *srcData,

        UINT32 pitch

        ) PURE;

}; // interface ID2D1Bitmap

 

 

 

interface D2D1_DECLARE_INTERFACE("2cd906a7-12e2-11dc-9fed-001143a055f9") ID2D1GradientStopCollection  : public ID2D1Resource

   

   

    //

    // Returns the number of stops in the gradient.

    //

    STDMETHOD_(UINT32, GetGradientStopCount)(

        ) CONST PURE;

   

   

    //

    // Copies the gradient stops from the collection into the caller's interface.

    //

    STDMETHOD_(void, GetGradientStops)(

        __out_ecount(gradientStopsCount) D2D1_GRADIENT_STOP *gradientStops,

        UINT gradientStopsCount

        ) CONST PURE;

   

   

    //

    // Returns whether the interpolation occurs with 1.0 or 2.2 gamma.

    //

    STDMETHOD_(D2D1_GAMMA, GetColorInterpolationGamma)(

        ) CONST PURE;

   

    STDMETHOD_(D2D1_EXTEND_MODE, GetExtendMode)(

        ) CONST PURE;

}; // interface ID2D1GradientStopCollection

 

 

 

interface D2D1_DECLARE_INTERFACE("2cd906a8-12e2-11dc-9fed-001143a055f9") ID2D1Brush  : public ID2D1Resource

   

   

    //

    // Sets the opacity for when the brush is drawn over the entire fill of the brush.

    //

    STDMETHOD_(void, SetOpacity)(

        FLOAT opacity

        ) PURE;

   

   

    //

    // Sets the transform that applies to everything drawn by the brush.

    //

    STDMETHOD_(void, SetTransform)(

        __in CONST D2D1_MATRIX_3X2_F *transform

        ) PURE;

   

    STDMETHOD_(FLOAT, GetOpacity)(

        ) CONST PURE;

   

    STDMETHOD_(void, GetTransform)(

        __out D2D1_MATRIX_3X2_F *transform

        ) CONST PURE;

   

    void

    SetTransform(

        CONST D2D1_MATRIX_3X2_F &transform

        )

    {

        SetTransform(&transform);

    }

}; // interface ID2D1Brush

 

 

 

interface D2D1_DECLARE_INTERFACE("2cd906aa-12e2-11dc-9fed-001143a055f9") ID2D1BitmapBrush  : public ID2D1Brush

   

   

    //

    // Sets how the bitmap is to be treated outside of its natural extent on the X

    // axis.

    //

    STDMETHOD_(void, SetExtendModeX)(

        D2D1_EXTEND_MODE extendModeX

        ) PURE;

   

   

    //

    // Sets how the bitmap is to be treated outside of its natural extent on the X

    // axis.

    //

    STDMETHOD_(void, SetExtendModeY)(

        D2D1_EXTEND_MODE extendModeY

        ) PURE;

   

   

    //

    // Sets the interpolation mode used when this brush is used.

    //

    STDMETHOD_(void, SetInterpolationMode)(

        D2D1_BITMAP_INTERPOLATION_MODE interpolationMode

        ) PURE;

   

   

    //

    // Sets the bitmap associated as the source of this brush.

    //

    STDMETHOD_(void, SetBitmap)(

        __in ID2D1Bitmap *bitmap

        ) PURE;

   

    STDMETHOD_(D2D1_EXTEND_MODE, GetExtendModeX)(

        ) CONST PURE;

   

    STDMETHOD_(D2D1_EXTEND_MODE, GetExtendModeY)(

        ) CONST PURE;

   

    STDMETHOD_(D2D1_BITMAP_INTERPOLATION_MODE, GetInterpolationMode)(

        ) CONST PURE;

   

    STDMETHOD_(void, GetBitmap)(

        __deref_out ID2D1Bitmap **bitmap

        ) CONST PURE;

}; // interface ID2D1BitmapBrush

 

 

 

interface D2D1_DECLARE_INTERFACE("2cd906a9-12e2-11dc-9fed-001143a055f9") ID2D1SolidColorBrush  : public ID2D1Brush

   

    STDMETHOD_(void, SetColor)(

        __in CONST D2D1_COLOR_F *color

        ) PURE;

   

    STDMETHOD_(D2D1_COLOR_F, GetColor)(

        ) CONST PURE;

   

    void

    SetColor(

        CONST D2D1_COLOR_F &color

        )

    {

        SetColor(&color);

    }

}; // interface ID2D1SolidColorBrush

 

 

 

interface D2D1_DECLARE_INTERFACE("2cd906ab-12e2-11dc-9fed-001143a055f9") ID2D1LinearGradientBrush  : public ID2D1Brush

   

    STDMETHOD_(void, SetStartPoint)(

        D2D1_POINT_2F startPoint

        ) PURE;

   

   

    //

    // Sets the end point of the gradient in local coordinate space. This is not

    // influenced by the geometry being filled.

    //

    STDMETHOD_(void, SetEndPoint)(

        D2D1_POINT_2F endPoint

        ) PURE;

   

    STDMETHOD_(D2D1_POINT_2F, GetStartPoint)(

        ) CONST PURE;

   

    STDMETHOD_(D2D1_POINT_2F, GetEndPoint)(

        ) CONST PURE;

   

    STDMETHOD_(void, GetGradientStopCollection)(

        __deref_out ID2D1GradientStopCollection **gradientStopCollection

        ) CONST PURE;

}; // interface ID2D1LinearGradientBrush

 

 

 

interface D2D1_DECLARE_INTERFACE("2cd906ac-12e2-11dc-9fed-001143a055f9") ID2D1RadialGradientBrush  : public ID2D1Brush

   

   

    //

    // Sets the center of the radial gradient. This will be in local coordinates and

    // will not depend on the geometry being filled.

    //

    STDMETHOD_(void, SetCenter)(

        D2D1_POINT_2F center

        ) PURE;

   

   

    //

    // Sets offset of the origin relative to the radial gradient center.

    //

    STDMETHOD_(void, SetGradientOriginOffset)(

        D2D1_POINT_2F gradientOriginOffset

        ) PURE;

   

    STDMETHOD_(void, SetRadiusX)(

        FLOAT radiusX

        ) PURE;

   

    STDMETHOD_(void, SetRadiusY)(

        FLOAT radiusY

        ) PURE;

   

    STDMETHOD_(D2D1_POINT_2F, GetCenter)(

        ) CONST PURE;

   

    STDMETHOD_(D2D1_POINT_2F, GetGradientOriginOffset)(

        ) CONST PURE;

   

    STDMETHOD_(FLOAT, GetRadiusX)(

        ) CONST PURE;

   

    STDMETHOD_(FLOAT, GetRadiusY)(

        ) CONST PURE;

   

    STDMETHOD_(void, GetGradientStopCollection)(

        __deref_out ID2D1GradientStopCollection **gradientStopCollection

        ) CONST PURE;

}; // interface ID2D1RadialGradientBrush

 

 

 

interface D2D1_DECLARE_INTERFACE("2cd9069d-12e2-11dc-9fed-001143a055f9") ID2D1StrokeStyle  : public ID2D1Resource

   

    STDMETHOD_(D2D1_CAP_STYLE, GetStartCap)(

        ) CONST PURE;

   

    STDMETHOD_(D2D1_CAP_STYLE, GetEndCap)(

        ) CONST PURE;

   

    STDMETHOD_(D2D1_CAP_STYLE, GetDashCap)(

        ) CONST PURE;

   

    STDMETHOD_(FLOAT, GetMiterLimit)(

        ) CONST PURE;

   

    STDMETHOD_(D2D1_LINE_JOIN, GetLineJoin)(

        ) CONST PURE;

   

    STDMETHOD_(FLOAT, GetDashOffset)(

        ) CONST PURE;

   

    STDMETHOD_(D2D1_DASH_STYLE, GetDashStyle)(

        ) CONST PURE;

   

    STDMETHOD_(UINT32, GetDashesCount)(

        ) CONST PURE;

   

   

    //

    // Returns the dashes from the object into a user allocated array. The user must

    // call GetDashesCount to retrieve the required size.

    //

    STDMETHOD_(void, GetDashes)(

        __out_ecount(dashesCount) FLOAT *dashes,

        UINT dashesCount

        ) CONST PURE;

}; // interface ID2D1StrokeStyle

 

 

 

interface D2D1_DECLARE_INTERFACE("2cd906a1-12e2-11dc-9fed-001143a055f9") ID2D1Geometry  : public ID2D1Resource

   

   

    //

    // Retrieve the bounds of the geometry, with an optional applied transform.

    //

    STDMETHOD(GetBounds)(

        __in_opt CONST D2D1_MATRIX_3X2_F *worldTransform,

        __out D2D1_RECT_F *bounds

        ) CONST PURE;

   

   

    //

    // Get the bounds of the corresponding geometry after it has been widened or have

    // an optional pen style applied.

    //

    STDMETHOD(GetWidenedBounds)(

        FLOAT strokeWidth,

        __in_opt ID2D1StrokeStyle *strokeStyle,

        __in_opt CONST D2D1_MATRIX_3X2_F *worldTransform,

        FLOAT flatteningTolerance,

        __out D2D1_RECT_F *bounds

        ) CONST PURE;

   

   

    //

    // Checks to see whether the corresponding penned and widened geometry contains the

    // given point.

    //

    STDMETHOD(StrokeContainsPoint)(

        D2D1_POINT_2F point,

        FLOAT strokeWidth,

        __in_opt ID2D1StrokeStyle *strokeStyle,

        __in_opt CONST D2D1_MATRIX_3X2_F *worldTransform,

        FLOAT flatteningTolerance,

        __out BOOL *contains

        ) CONST PURE;

   

   

    //

    // Test whether the given fill of this geometry would contain this point.

    //

    STDMETHOD(FillContainsPoint)(

        D2D1_POINT_2F point,

        __in_opt CONST D2D1_MATRIX_3X2_F *worldTransform,

        FLOAT flatteningTolerance,

        __out BOOL *contains

        ) CONST PURE;

   

   

    //

    // Compare how one geometry intersects or contains another geometry.

    //

    STDMETHOD(CompareWithGeometry)(

        __in ID2D1Geometry *inputGeometry,

        __in_opt CONST D2D1_MATRIX_3X2_F *inputGeometryTransform,

        FLOAT flatteningTolerance,

        __out D2D1_GEOMETRY_RELATION *relation

        ) CONST PURE;

   

   

    //

    // Converts a geometry to a simplified geometry that has arcs and quadratic beziers

    // removed.

    //

    STDMETHOD(Simplify)(

        D2D1_GEOMETRY_SIMPLIFICATION_OPTION simplificationOption,

        __in_opt CONST D2D1_MATRIX_3X2_F *worldTransform,

        FLOAT flatteningTolerance,

        __in ID2D1SimplifiedGeometrySink *geometrySink

        ) CONST PURE;

   

   

    //

    // Tessellates a geometry into triangles.

    //

    STDMETHOD(Tessellate)(

        __in_opt CONST D2D1_MATRIX_3X2_F *worldTransform,

        FLOAT flatteningTolerance,

        __in ID2D1TessellationSink *tessellationSink

        ) CONST PURE;

   

   

    //

    // Performs a combine operation between the two geometries to produce a resulting

    // geometry.

    //

    STDMETHOD(CombineWithGeometry)(

        __in ID2D1Geometry *inputGeometry,

        D2D1_COMBINE_MODE combineMode,

        __in_opt CONST D2D1_MATRIX_3X2_F *inputGeometryTransform,

        FLOAT flatteningTolerance,

        __in ID2D1SimplifiedGeometrySink *geometrySink

        ) CONST PURE;

   

   

    //

    // Computes the outline of the geometry. The result is written back into a

    // simplified geometry sink.

    //

    STDMETHOD(Outline)(

        __in_opt CONST D2D1_MATRIX_3X2_F *worldTransform,

        FLOAT flatteningTolerance,

        __in ID2D1SimplifiedGeometrySink *geometrySink

        ) CONST PURE;

   

   

    //

    // Computes the area of the geometry.

    //

    STDMETHOD(ComputeArea)(

        __in_opt CONST D2D1_MATRIX_3X2_F *worldTransform,

        FLOAT flatteningTolerance,

        __out FLOAT *area

        ) CONST PURE;

   

   

    //

    // Computes the length of the geometry.

    //

    STDMETHOD(ComputeLength)(

        __in_opt CONST D2D1_MATRIX_3X2_F *worldTransform,

        FLOAT flatteningTolerance,

        __out FLOAT *length

        ) CONST PURE;

   

   

    //

    // Computes the point and tangent a given distance along the path.

    //

    STDMETHOD(ComputePointAtLength)(

        FLOAT length,

        __in_opt CONST D2D1_MATRIX_3X2_F *worldTransform,

        FLOAT flatteningTolerance,

        __out_opt D2D1_POINT_2F *point,

        __out_opt D2D1_POINT_2F *unitTangentVector

        ) CONST PURE;

   

   

    //

    // Get the geometry and widen it as well as apply an optional pen style.

    //

    STDMETHOD(Widen)(

        FLOAT strokeWidth,

        __in_opt ID2D1StrokeStyle *strokeStyle,

        __in_opt CONST D2D1_MATRIX_3X2_F *worldTransform,

        FLOAT flatteningTolerance,

        __in ID2D1SimplifiedGeometrySink *geometrySink

        ) CONST PURE;

   

   

    //

    // Retrieve the bounds of the geometry, with an optional applied transform.

    //

    HRESULT

    GetBounds(

        CONST D2D1_MATRIX_3X2_F &worldTransform,

        __out D2D1_RECT_F *bounds

        ) CONST

    {

        return GetBounds(&worldTransform, bounds);

    }

   

   

    //

    // Get the bounds of the corresponding geometry after it has been widened or have

    // an optional pen style applied.

    //

    HRESULT

    GetWidenedBounds(

        FLOAT strokeWidth,

        __in_opt ID2D1StrokeStyle *strokeStyle,

        CONST D2D1_MATRIX_3X2_F &worldTransform,

        FLOAT flatteningTolerance,

        __out D2D1_RECT_F *bounds

        ) CONST

    {

        return GetWidenedBounds(strokeWidth, strokeStyle, &worldTransform, flatteningTolerance, bounds);

    }

   

   

    //

    // Get the bounds of the corresponding geometry after it has been widened or have

    // an optional pen style applied.

    //

    HRESULT

    GetWidenedBounds(

        FLOAT strokeWidth,

        __in_opt ID2D1StrokeStyle *strokeStyle,

        __in_opt CONST D2D1_MATRIX_3X2_F *worldTransform,

        __out D2D1_RECT_F *bounds

        ) CONST

    {

        return GetWidenedBounds(strokeWidth, strokeStyle, worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, bounds);

    }

   

   

    //

    // Get the bounds of the corresponding geometry after it has been widened or have

    // an optional pen style applied.

    //

    HRESULT

    GetWidenedBounds(

        FLOAT strokeWidth,

        __in_opt ID2D1StrokeStyle *strokeStyle,

        CONST D2D1_MATRIX_3X2_F &worldTransform,

        __out D2D1_RECT_F *bounds

        ) CONST

    {

        return GetWidenedBounds(strokeWidth, strokeStyle, &worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, bounds);

    }

   

    HRESULT

    StrokeContainsPoint(

        D2D1_POINT_2F point,

        FLOAT strokeWidth,

        __in_opt ID2D1StrokeStyle *strokeStyle,

        CONST D2D1_MATRIX_3X2_F &worldTransform,

        FLOAT flatteningTolerance,

        __out BOOL *contains

        ) CONST

    {

        return StrokeContainsPoint(point, strokeWidth, strokeStyle, &worldTransform, flatteningTolerance, contains);

    }

   

   

    //

    // Checks to see whether the corresponding penned and widened geometry contains the

    // given point.

    //

    HRESULT

    StrokeContainsPoint(

        D2D1_POINT_2F point,

        FLOAT strokeWidth,

        __in_opt ID2D1StrokeStyle *strokeStyle,

        __in_opt CONST D2D1_MATRIX_3X2_F *worldTransform,

        __out BOOL *contains

        ) CONST

    {

        return StrokeContainsPoint(point, strokeWidth, strokeStyle, worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, contains);

    }

   

    HRESULT

    StrokeContainsPoint(

        D2D1_POINT_2F point,

        FLOAT strokeWidth,

        __in_opt ID2D1StrokeStyle *strokeStyle,

        CONST D2D1_MATRIX_3X2_F &worldTransform,

        __out BOOL *contains

        ) CONST

    {

        return StrokeContainsPoint(point, strokeWidth, strokeStyle, &worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, contains);

    }

   

    HRESULT

    FillContainsPoint(

        D2D1_POINT_2F point,

        CONST D2D1_MATRIX_3X2_F &worldTransform,

        FLOAT flatteningTolerance,

        __out BOOL *contains

        ) CONST

    {

        return FillContainsPoint(point, &worldTransform, flatteningTolerance, contains);

    }

   

   

    //

    // Test whether the given fill of this geometry would contain this point.

    //

    HRESULT

    FillContainsPoint(

        D2D1_POINT_2F point,

        __in_opt CONST D2D1_MATRIX_3X2_F *worldTransform,

        __out BOOL *contains

        ) CONST

    {

        return FillContainsPoint(point, worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, contains);

    }

   

    HRESULT

    FillContainsPoint(

        D2D1_POINT_2F point,

        CONST D2D1_MATRIX_3X2_F &worldTransform,

        __out BOOL *contains

        ) CONST

    {

        return FillContainsPoint(point, &worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, contains);

    }

   

   

    //

    // Compare how one geometry intersects or contains another geometry.

    //

    HRESULT

    CompareWithGeometry(

        __in ID2D1Geometry *inputGeometry,

        CONST D2D1_MATRIX_3X2_F &inputGeometryTransform,

        FLOAT flatteningTolerance,

        __out D2D1_GEOMETRY_RELATION *relation

        ) CONST

    {

        return CompareWithGeometry(inputGeometry, &inputGeometryTransform, flatteningTolerance, relation);

    }

   

   

    //

    // Compare how one geometry intersects or contains another geometry.

    //

    HRESULT

    CompareWithGeometry(

        __in ID2D1Geometry *inputGeometry,

        __in_opt CONST D2D1_MATRIX_3X2_F *inputGeometryTransform,

        __out D2D1_GEOMETRY_RELATION *relation

        ) CONST

    {

        return CompareWithGeometry(inputGeometry, inputGeometryTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, relation);

    }

   

   

    //

    // Compare how one geometry intersects or contains another geometry.

    //

    HRESULT

    CompareWithGeometry(

        __in ID2D1Geometry *inputGeometry,

        CONST D2D1_MATRIX_3X2_F &inputGeometryTransform,

        __out D2D1_GEOMETRY_RELATION *relation

        ) CONST

    {

        return CompareWithGeometry(inputGeometry, &inputGeometryTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, relation);

    }

   

   

    //

    // Converts a geometry to a simplified geometry that has arcs and quadratic beziers

    // removed.

    //

    HRESULT

    Simplify(

        D2D1_GEOMETRY_SIMPLIFICATION_OPTION simplificationOption,

        CONST D2D1_MATRIX_3X2_F &worldTransform,

        FLOAT flatteningTolerance,

        __in ID2D1SimplifiedGeometrySink *geometrySink

        ) CONST

    {

        return Simplify(simplificationOption, &worldTransform, flatteningTolerance, geometrySink);

    }

   

   

    //

    // Converts a geometry to a simplified geometry that has arcs and quadratic beziers

    // removed.

    //

    HRESULT

    Simplify(

        D2D1_GEOMETRY_SIMPLIFICATION_OPTION simplificationOption,

        __in_opt CONST D2D1_MATRIX_3X2_F *worldTransform,

        __in ID2D1SimplifiedGeometrySink *geometrySink

        ) CONST

    {

        return Simplify(simplificationOption, worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, geometrySink);

    }

   

   

    //

    // Converts a geometry to a simplified geometry that has arcs and quadratic beziers

    // removed.

    //

    HRESULT

    Simplify(

        D2D1_GEOMETRY_SIMPLIFICATION_OPTION simplificationOption,

        CONST D2D1_MATRIX_3X2_F &worldTransform,

        __in ID2D1SimplifiedGeometrySink *geometrySink

        ) CONST

    {

        return Simplify(simplificationOption, &worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, geometrySink);

    }

   

   

    //

    // Tessellates a geometry into triangles.

    //

    HRESULT

    Tessellate(

        CONST D2D1_MATRIX_3X2_F &worldTransform,

        FLOAT flatteningTolerance,

        __in ID2D1TessellationSink *tessellationSink

        ) CONST

    {

        return Tessellate(&worldTransform, flatteningTolerance, tessellationSink);

    }

   

   

    //

    // Tessellates a geometry into triangles.

    //

    HRESULT

    Tessellate(

        __in_opt CONST D2D1_MATRIX_3X2_F *worldTransform,

        __in ID2D1TessellationSink *tessellationSink

        ) CONST

    {

        return Tessellate(worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, tessellationSink);

    }

   

   

    //

    // Tessellates a geometry into triangles.

    //

    HRESULT

    Tessellate(

        CONST D2D1_MATRIX_3X2_F &worldTransform,

        __in ID2D1TessellationSink *tessellationSink

        ) CONST

    {

        return Tessellate(&worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, tessellationSink);

    }

   

   

    //

    // Performs a combine operation between the two geometries to produce a resulting

    // geometry.

    //

    HRESULT

    CombineWithGeometry(

        __in ID2D1Geometry *inputGeometry,

        D2D1_COMBINE_MODE combineMode,

        CONST D2D1_MATRIX_3X2_F &inputGeometryTransform,

        FLOAT flatteningTolerance,

        __in ID2D1SimplifiedGeometrySink *geometrySink

        ) CONST

    {

        return CombineWithGeometry(inputGeometry, combineMode, &inputGeometryTransform, flatteningTolerance, geometrySink);

    }

   

   

    //

    // Performs a combine operation between the two geometries to produce a resulting

    // geometry.

    //

    HRESULT

    CombineWithGeometry(

        __in ID2D1Geometry *inputGeometry,

        D2D1_COMBINE_MODE combineMode,

        __in_opt CONST D2D1_MATRIX_3X2_F *inputGeometryTransform,

        __in ID2D1SimplifiedGeometrySink *geometrySink

        ) CONST

    {

        return CombineWithGeometry(inputGeometry, combineMode, inputGeometryTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, geometrySink);

    }

   

   

    //

    // Performs a combine operation between the two geometries to produce a resulting

    // geometry.

    //

    HRESULT

    CombineWithGeometry(

        __in ID2D1Geometry *inputGeometry,

        D2D1_COMBINE_MODE combineMode,

        CONST D2D1_MATRIX_3X2_F &inputGeometryTransform,

        __in ID2D1SimplifiedGeometrySink *geometrySink

        ) CONST

    {

        return CombineWithGeometry(inputGeometry, combineMode, &inputGeometryTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, geometrySink);

    }

   

   

    //

    // Computes the outline of the geometry. The result is written back into a

    // simplified geometry sink.

    //

    HRESULT

    Outline(

        CONST D2D1_MATRIX_3X2_F &worldTransform,

        FLOAT flatteningTolerance,

        __in ID2D1SimplifiedGeometrySink *geometrySink

        ) CONST

    {

        return Outline(&worldTransform, flatteningTolerance, geometrySink);

    }

   

   

    //

    // Computes the outline of the geometry. The result is written back into a

    // simplified geometry sink.

    //

    HRESULT

    Outline(

        __in_opt CONST D2D1_MATRIX_3X2_F *worldTransform,

        __in ID2D1SimplifiedGeometrySink *geometrySink

        ) CONST

    {

        return Outline(worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, geometrySink);

    }

   

   

    //

    // Computes the outline of the geometry. The result is written back into a

    // simplified geometry sink.

    //

    HRESULT

    Outline(

        CONST D2D1_MATRIX_3X2_F &worldTransform,

        __in ID2D1SimplifiedGeometrySink *geometrySink

        ) CONST

    {

        return Outline(&worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, geometrySink);

    }

   

   

    //

    // Computes the area of the geometry.

    //

    HRESULT

    ComputeArea(

        CONST D2D1_MATRIX_3X2_F &worldTransform,

        FLOAT flatteningTolerance,

        __out FLOAT *area

        ) CONST

    {

        return ComputeArea(&worldTransform, flatteningTolerance, area);

    }

   

   

    //

    // Computes the area of the geometry.

    //

    HRESULT

    ComputeArea(

        __in_opt CONST D2D1_MATRIX_3X2_F *worldTransform,

        __out FLOAT *area

        ) CONST

    {

        return ComputeArea(worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, area);

    }

   

   

    //

    // Computes the area of the geometry.

    //

    HRESULT

    ComputeArea(

        CONST D2D1_MATRIX_3X2_F &worldTransform,

        __out FLOAT *area

        ) CONST

    {

        return ComputeArea(&worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, area);

    }

   

   

    //

    // Computes the length of the geometry.

    //

    HRESULT

    ComputeLength(

        CONST D2D1_MATRIX_3X2_F &worldTransform,

        FLOAT flatteningTolerance,

        __out FLOAT *length

        ) CONST

    {

        return ComputeLength(&worldTransform, flatteningTolerance, length);

    }

   

   

    //

    // Computes the length of the geometry.

    //

    HRESULT

    ComputeLength(

        __in_opt CONST D2D1_MATRIX_3X2_F *worldTransform,

        __out FLOAT *length

        ) CONST

    {

        return ComputeLength(worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, length);

    }

   

   

    //

    // Computes the length of the geometry.

    //

    HRESULT

    ComputeLength(

        CONST D2D1_MATRIX_3X2_F &worldTransform,

        __out FLOAT *length

        ) CONST

    {

        return ComputeLength(&worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, length);

    }

   

   

    //

    // Computes the point and tangent a given distance along the path.

    //

    HRESULT

    ComputePointAtLength(

        FLOAT length,

        CONST D2D1_MATRIX_3X2_F &worldTransform,

        FLOAT flatteningTolerance,

        __out_opt D2D1_POINT_2F *point,

        __out_opt D2D1_POINT_2F *unitTangentVector

        ) CONST

    {

        return ComputePointAtLength(length, &worldTransform, flatteningTolerance, point, unitTangentVector);

    }

   

   

    //

    // Computes the point and tangent a given distance along the path.

    //

    HRESULT

    ComputePointAtLength(

        FLOAT length,

        __in_opt CONST D2D1_MATRIX_3X2_F *worldTransform,

        __out_opt D2D1_POINT_2F *point,

        __out_opt D2D1_POINT_2F *unitTangentVector

        ) CONST

    {

        return ComputePointAtLength(length, worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, point, unitTangentVector);

    }

   

   

    //

    // Computes the point and tangent a given distance along the path.

    //

    HRESULT

    ComputePointAtLength(

        FLOAT length,

        CONST D2D1_MATRIX_3X2_F &worldTransform,

        __out_opt D2D1_POINT_2F *point,

        __out_opt D2D1_POINT_2F *unitTangentVector

        ) CONST

    {

        return ComputePointAtLength(length, &worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, point, unitTangentVector);

    }

   

   

    //

    // Get the geometry and widen it as well as apply an optional pen style.

    //

    HRESULT

    Widen(

        FLOAT strokeWidth,

        __in_opt ID2D1StrokeStyle *strokeStyle,

        CONST D2D1_MATRIX_3X2_F &worldTransform,

        FLOAT flatteningTolerance,

        __in ID2D1SimplifiedGeometrySink *geometrySink

        ) CONST

    {

        return Widen(strokeWidth, strokeStyle, &worldTransform, flatteningTolerance, geometrySink);

    }

   

   

    //

    // Get the geometry and widen it as well as apply an optional pen style.

    //

    HRESULT

    Widen(

        FLOAT strokeWidth,

        __in_opt ID2D1StrokeStyle *strokeStyle,

        __in_opt CONST D2D1_MATRIX_3X2_F *worldTransform,

        __in ID2D1SimplifiedGeometrySink *geometrySink

        ) CONST

    {

        return Widen(strokeWidth, strokeStyle, worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, geometrySink);

    }

   

   

    //

    // Get the geometry and widen it as well as apply an optional pen style.

    //

    HRESULT

    Widen(

        FLOAT strokeWidth,

        __in_opt ID2D1StrokeStyle *strokeStyle,

        CONST D2D1_MATRIX_3X2_F &worldTransform,

        __in ID2D1SimplifiedGeometrySink *geometrySink

        ) CONST

    {

        return Widen(strokeWidth, strokeStyle, &worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, geometrySink);

    }

}; // interface ID2D1Geometry

 

 

 

interface D2D1_DECLARE_INTERFACE("2cd906a2-12e2-11dc-9fed-001143a055f9") ID2D1RectangleGeometry  : public ID2D1Geometry

   

    STDMETHOD_(void, GetRect)(

        __out D2D1_RECT_F *rect

        ) CONST PURE;

}; // interface ID2D1RectangleGeometry

 

 

 

interface D2D1_DECLARE_INTERFACE("2cd906a3-12e2-11dc-9fed-001143a055f9") ID2D1RoundedRectangleGeometry  : public ID2D1Geometry

   

    STDMETHOD_(void, GetRoundedRect)(

        __out D2D1_ROUNDED_RECT *roundedRect

        ) CONST PURE;

}; // interface ID2D1RoundedRectangleGeometry

 

 

 

interface D2D1_DECLARE_INTERFACE("2cd906a4-12e2-11dc-9fed-001143a055f9") ID2D1EllipseGeometry  : public ID2D1Geometry

   

    STDMETHOD_(void, GetEllipse)(

        __out D2D1_ELLIPSE *ellipse

        ) CONST PURE;

}; // interface ID2D1EllipseGeometry

 

 

 

interface D2D1_DECLARE_INTERFACE("2cd906a6-12e2-11dc-9fed-001143a055f9") ID2D1GeometryGroup  : public ID2D1Geometry

   

    STDMETHOD_(D2D1_FILL_MODE, GetFillMode)(

        ) CONST PURE;

   

    STDMETHOD_(UINT32, GetSourceGeometryCount)(

        ) CONST PURE;

   

    STDMETHOD_(void, GetSourceGeometries)(

        __out_ecount(geometriesCount) ID2D1Geometry **geometries,

        UINT geometriesCount

        ) CONST PURE;

}; // interface ID2D1GeometryGroup

 

 

 

interface D2D1_DECLARE_INTERFACE("2cd906bb-12e2-11dc-9fed-001143a055f9") ID2D1TransformedGeometry  : public ID2D1Geometry

   

    STDMETHOD_(void, GetSourceGeometry)(

        __deref_out ID2D1Geometry **sourceGeometry

        ) CONST PURE;

   

    STDMETHOD_(void, GetTransform)(

        __out D2D1_MATRIX_3X2_F *transform

        ) CONST PURE;

}; // interface ID2D1TransformedGeometry

 

 

 

interface D2D1_DECLARE_INTERFACE("2cd9069e-12e2-11dc-9fed-001143a055f9") ID2D1SimplifiedGeometrySink  : public IUnknown

   

    STDMETHOD_(void, SetFillMode)(

        D2D1_FILL_MODE fillMode

        ) PURE;

   

    STDMETHOD_(void, SetSegmentFlags)(

        D2D1_PATH_SEGMENT vertexFlags

        ) PURE;

   

    STDMETHOD_(void, BeginFigure)(

        D2D1_POINT_2F startPoint,

        D2D1_FIGURE_BEGIN figureBegin

        ) PURE;

   

    STDMETHOD_(void, AddLines)(

        __in_ecount(pointsCount) CONST D2D1_POINT_2F *points,

        UINT pointsCount

        ) PURE;

   

    STDMETHOD_(void, AddBeziers)(

        __in_ecount(beziersCount) CONST D2D1_BEZIER_SEGMENT *beziers,

        UINT beziersCount

        ) PURE;

   

    STDMETHOD_(void, EndFigure)(

        D2D1_FIGURE_END figureEnd

        ) PURE;

   

    STDMETHOD(Close)(

        ) PURE;

}; // interface ID2D1SimplifiedGeometrySink

 

 

 

interface D2D1_DECLARE_INTERFACE("2cd9069f-12e2-11dc-9fed-001143a055f9") ID2D1GeometrySink  : public ID2D1SimplifiedGeometrySink

   

    STDMETHOD_(void, AddLine)(

        D2D1_POINT_2F point

        ) PURE;

   

    STDMETHOD_(void, AddBezier)(

        __in CONST D2D1_BEZIER_SEGMENT *bezier

        ) PURE;

   

    STDMETHOD_(void, AddQuadraticBezier)(

        __in CONST D2D1_QUADRATIC_BEZIER_SEGMENT *bezier

        ) PURE;

   

    STDMETHOD_(void, AddQuadraticBeziers)(

        __in_ecount(beziersCount) CONST D2D1_QUADRATIC_BEZIER_SEGMENT *beziers,

        UINT beziersCount

        ) PURE;

   

    STDMETHOD_(void, AddArc)(

        __in CONST D2D1_ARC_SEGMENT *arc

        ) PURE;

   

    void

    AddBezier(

        CONST D2D1_BEZIER_SEGMENT &bezier

        )

    {

        AddBezier(&bezier);

    }

   

    void

    AddQuadraticBezier(

        CONST D2D1_QUADRATIC_BEZIER_SEGMENT &bezier

        )

    {

        AddQuadraticBezier(&bezier);

    }

   

    void

    AddArc(

        CONST D2D1_ARC_SEGMENT &arc

        )

    {

        AddArc(&arc);

    }

}; // interface ID2D1GeometrySink

 

 

 

interface D2D1_DECLARE_INTERFACE("2cd906c1-12e2-11dc-9fed-001143a055f9") ID2D1TessellationSink  : public IUnknown

   

    STDMETHOD_(void, AddTriangles)(

        __in_ecount(trianglesCount) CONST D2D1_TRIANGLE *triangles,

        UINT trianglesCount

        ) PURE;

   

    STDMETHOD(Close)(

        ) PURE;

}; // interface ID2D1TessellationSink

 

 

 

interface D2D1_DECLARE_INTERFACE("2cd906a5-12e2-11dc-9fed-001143a055f9") ID2D1PathGeometry  : public ID2D1Geometry

   

   

    //

    // Opens a geometry sink that will be used to create this path geometry.

    //

    STDMETHOD(Open)(

        __deref_out ID2D1GeometrySink **geometrySink

        ) PURE;

   

   

    //

    // Retrieve the contents of this geometry. The caller passes an implementation of a

    // ID2D1GeometrySink interface to receive the data.

    //

    STDMETHOD(Stream)(

        __in ID2D1GeometrySink *geometrySink

        ) CONST PURE;

   

    STDMETHOD(GetSegmentCount)(

        __out UINT32 *count