d2d1.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// This file is automatically generated. Please do not edit it directly.
//
// File name: D2D1.h
//---------------------------------------------------------------------------
#ifdef _MSC_VER
#pragma once
#endif // #ifdef _MSC_VER

#ifndef _D2D1_H_
#define _D2D1_H_

#ifndef COM_NO_WINDOWS_H
#include <windows.h>
#endif // #ifndef COM_NO_WINDOWS_H
#include <unknwn.h>
#include <dcommon.h>
#include <d2derr.h>
#include <d2dbasetypes.h>
#include <dxgiformat.h>
/*#pragma region Desktop Family*/
/*#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)*/
#include <d3d10_1.h>
/*#else*/
/*#include <d3dcommon.h>*/
/*#endif*/ /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */

#ifndef D2D_USE_C_DEFINITIONS

//
// We use the 'C' definitions if C++ is not defined
//
#ifndef __cplusplus
#define D2D_USE_C_DEFINITIONS
#endif

#endif // #ifndef D2D_USE_C_DEFINITIONS

/*#include <winapifamily.h>*/

//
// Forward declarations here
//

/*#pragma region Application Family*/
/*#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)*/

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;

#ifndef D2D_USE_C_DEFINITIONS

interface ID2D1Factory;
interface ID2D1RenderTarget;
interface ID2D1BitmapRenderTarget;
interface ID2D1SimplifiedGeometrySink;
interface ID2D1TessellationSink;
interface ID2D1Geometry;
interface ID2D1Brush;

#else

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;

#endif
 
#define D2D1_INVALID_TAG ULONGLONG_MAX
#define D2D1_DEFAULT_FLATTENING_TOLERANCE (0.25f)


enum 
{
 D2D1_INTERPOLATION_MODE_DEFINITION_NEAREST_NEIGHBOR = 0,
 D2D1_INTERPOLATION_MODE_DEFINITION_LINEAR = 1,
 D2D1_INTERPOLATION_MODE_DEFINITION_CUBIC = 2,
 D2D1_INTERPOLATION_MODE_DEFINITION_MULTI_SAMPLE_LINEAR = 3,
 D2D1_INTERPOLATION_MODE_DEFINITION_ANISOTROPIC = 4,
 D2D1_INTERPOLATION_MODE_DEFINITION_HIGH_QUALITY_CUBIC = 5,
 D2D1_INTERPOLATION_MODE_DEFINITION_FANT = 6,
 D2D1_INTERPOLATION_MODE_DEFINITION_MIPMAP_LINEAR = 7

};


typedef enum D2D1_GAMMA
{
 
 D2D1_GAMMA_2_2 = 0,
 
 D2D1_GAMMA_1_0 = 1,
 D2D1_GAMMA_FORCE_DWORD = 0xffffffff

} D2D1_GAMMA;


typedef enum D2D1_OPACITY_MASK_CONTENT
{
 
 D2D1_OPACITY_MASK_CONTENT_GRAPHICS = 0,
 
 D2D1_OPACITY_MASK_CONTENT_TEXT_NATURAL = 1,
 
 D2D1_OPACITY_MASK_CONTENT_TEXT_GDI_COMPATIBLE = 2,
 D2D1_OPACITY_MASK_CONTENT_FORCE_DWORD = 0xffffffff

} D2D1_OPACITY_MASK_CONTENT;


typedef enum D2D1_EXTEND_MODE
{
 
 D2D1_EXTEND_MODE_CLAMP = 0,
 
 D2D1_EXTEND_MODE_WRAP = 1,
 
 D2D1_EXTEND_MODE_MIRROR = 2,
 D2D1_EXTEND_MODE_FORCE_DWORD = 0xffffffff

} D2D1_EXTEND_MODE;


typedef enum D2D1_ANTIALIAS_MODE
{
 
 D2D1_ANTIALIAS_MODE_PER_PRIMITIVE = 0,
 
 D2D1_ANTIALIAS_MODE_ALIASED = 1,
 D2D1_ANTIALIAS_MODE_FORCE_DWORD = 0xffffffff

} D2D1_ANTIALIAS_MODE;


typedef enum D2D1_TEXT_ANTIALIAS_MODE
{
 
 D2D1_TEXT_ANTIALIAS_MODE_DEFAULT = 0,
 
 D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE = 1,
 
 D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE = 2,
 
 D2D1_TEXT_ANTIALIAS_MODE_ALIASED = 3,
 D2D1_TEXT_ANTIALIAS_MODE_FORCE_DWORD = 0xffffffff

} D2D1_TEXT_ANTIALIAS_MODE;


typedef enum D2D1_BITMAP_INTERPOLATION_MODE
{
 
 D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR = D2D1_INTERPOLATION_MODE_DEFINITION_NEAREST_NEIGHBOR,
 
 D2D1_BITMAP_INTERPOLATION_MODE_LINEAR = D2D1_INTERPOLATION_MODE_DEFINITION_LINEAR,
 D2D1_BITMAP_INTERPOLATION_MODE_FORCE_DWORD = 0xffffffff

} D2D1_BITMAP_INTERPOLATION_MODE;


typedef enum D2D1_DRAW_TEXT_OPTIONS
{
 
 D2D1_DRAW_TEXT_OPTIONS_NO_SNAP = 0x00000001,
 
 D2D1_DRAW_TEXT_OPTIONS_CLIP = 0x00000002,
 
 D2D1_DRAW_TEXT_OPTIONS_ENABLE_COLOR_FONT = 0x00000004,
 
 D2D1_DRAW_TEXT_OPTIONS_DISABLE_COLOR_BITMAP_SNAPPING = 0x00000008,
 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 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
{
 
 D2D1_CAP_STYLE_FLAT = 0,
 
 D2D1_CAP_STYLE_SQUARE = 1,
 
 D2D1_CAP_STYLE_ROUND = 2,
 
 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
{
 
 D2D1_LINE_JOIN_MITER = 0,
 
 D2D1_LINE_JOIN_BEVEL = 1,
 
 D2D1_LINE_JOIN_ROUND = 2,
 
 D2D1_LINE_JOIN_MITER_OR_BEVEL = 3,
 D2D1_LINE_JOIN_FORCE_DWORD = 0xffffffff

} D2D1_LINE_JOIN;


typedef enum D2D1_COMBINE_MODE
{
 
 D2D1_COMBINE_MODE_UNION = 0,
 
 D2D1_COMBINE_MODE_INTERSECT = 1,
 
 D2D1_COMBINE_MODE_XOR = 2,
 
 D2D1_COMBINE_MODE_EXCLUDE = 3,
 D2D1_COMBINE_MODE_FORCE_DWORD = 0xffffffff

} D2D1_COMBINE_MODE;


typedef enum D2D1_GEOMETRY_RELATION
{
 
 D2D1_GEOMETRY_RELATION_UNKNOWN = 0,
 
 D2D1_GEOMETRY_RELATION_DISJOINT = 1,
 
 D2D1_GEOMETRY_RELATION_IS_CONTAINED = 2,
 
 D2D1_GEOMETRY_RELATION_CONTAINS = 3,
 
 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,
 
 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
{
 
 D2D1_RECT_F contentBounds;
 
 _Field_size_opt_(1) ID2D1Geometry *geometricMask;
 
 D2D1_ANTIALIAS_MODE maskAntialiasMode;
 
 D2D1_MATRIX_3X2_F maskTransform;
 
 FLOAT opacity;
 
 _Field_size_opt_(1) ID2D1Brush *opacityBrush;
 
 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
{
 
 D2D1_RENDER_TARGET_TYPE_DEFAULT = 0,
 
 D2D1_RENDER_TARGET_TYPE_SOFTWARE = 1,
 
 D2D1_RENDER_TARGET_TYPE_HARDWARE = 2,
 D2D1_RENDER_TARGET_TYPE_FORCE_DWORD = 0xffffffff

} D2D1_RENDER_TARGET_TYPE;


typedef enum D2D1_FEATURE_LEVEL
{
 
 D2D1_FEATURE_LEVEL_DEFAULT = 0,
 
 D2D1_FEATURE_LEVEL_9 = D3D_FEATURE_LEVEL_9_1,
 
 D2D1_FEATURE_LEVEL_10 = D3D_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,
 
 D2D1_RENDER_TARGET_USAGE_FORCE_BITMAP_REMOTING = 0x00000001,
 
 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,
 
 D2D1_PRESENT_OPTIONS_RETAIN_CONTENTS = 0x00000001,
 
 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,
 
 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
{
 
 D2D1_DC_INITIALIZE_MODE_COPY = 0,
 
 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
{
 
 D2D1_FACTORY_TYPE_SINGLE_THREADED = 0,
 
 D2D1_FACTORY_TYPE_MULTI_THREADED = 1,
 D2D1_FACTORY_TYPE_FORCE_DWORD = 0xffffffff

} D2D1_FACTORY_TYPE;


typedef struct D2D1_FACTORY_OPTIONS
{
 
 D2D1_DEBUG_LEVEL debugLevel;

} D2D1_FACTORY_OPTIONS;


/*#endif*/ /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */
/*#pragma endregion*/


/*#pragma region Application Family*/
/*#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)*/


EXTERN_C CONST IID IID_ID2D1Resource;
EXTERN_C CONST IID IID_ID2D1Image;
EXTERN_C CONST IID IID_ID2D1Bitmap;
EXTERN_C CONST IID IID_ID2D1GradientStopCollection;
EXTERN_C CONST IID IID_ID2D1Brush;
EXTERN_C CONST IID IID_ID2D1BitmapBrush;
EXTERN_C CONST IID IID_ID2D1SolidColorBrush;
EXTERN_C CONST IID IID_ID2D1LinearGradientBrush;
EXTERN_C CONST IID IID_ID2D1RadialGradientBrush;
EXTERN_C CONST IID IID_ID2D1StrokeStyle;
EXTERN_C CONST IID IID_ID2D1Geometry;
EXTERN_C CONST IID IID_ID2D1RectangleGeometry;
EXTERN_C CONST IID IID_ID2D1RoundedRectangleGeometry;
EXTERN_C CONST IID IID_ID2D1EllipseGeometry;
EXTERN_C CONST IID IID_ID2D1GeometryGroup;
EXTERN_C CONST IID IID_ID2D1TransformedGeometry;
EXTERN_C CONST IID IID_ID2D1SimplifiedGeometrySink;
EXTERN_C CONST IID IID_ID2D1GeometrySink;
EXTERN_C CONST IID IID_ID2D1TessellationSink;
EXTERN_C CONST IID IID_ID2D1PathGeometry;
EXTERN_C CONST IID IID_ID2D1Mesh;
EXTERN_C CONST IID IID_ID2D1Layer;
EXTERN_C CONST IID IID_ID2D1DrawingStateBlock;
EXTERN_C CONST IID IID_ID2D1RenderTarget;
EXTERN_C CONST IID IID_ID2D1BitmapRenderTarget;
EXTERN_C CONST IID IID_ID2D1HwndRenderTarget;
EXTERN_C CONST IID IID_ID2D1DCRenderTarget;
EXTERN_C CONST IID IID_ID2D1Factory;


/*#endif*/ /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */
/*#pragma endregion*/

/*#pragma region Desktop Family*/
/*#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)*/


EXTERN_C CONST IID IID_ID2D1GdiInteropRenderTarget;


/*#endif*/ /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */
/*#pragma endregion*/


#ifndef D2D_USE_C_DEFINITIONS


/*#pragma region Application Family*/
/*#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)*/

interface DX_DECLARE_INTERFACE("2cd90691-12e2-11dc-9fed-001143a055f9") ID2D1Resource : public IUnknown
{
 
 STDMETHOD_(void, GetFactory)(
 _Outptr_ ID2D1Factory **factory 
 ) CONST PURE;
}; // interface ID2D1Resource


interface DX_DECLARE_INTERFACE("65019f75-8da2-497c-b32c-dfa34e48ede6") ID2D1Image : public ID2D1Resource
{
}; // interface ID2D1Image


interface DX_DECLARE_INTERFACE("a2296057-ea42-4099-983b-539fb6505426") ID2D1Bitmap : public ID2D1Image
{
 
 STDMETHOD_(D2D1_SIZE_F, GetSize)(
 ) CONST PURE;
 
 STDMETHOD_(D2D1_SIZE_U, GetPixelSize)(
 ) CONST PURE;
 
 STDMETHOD_(D2D1_PIXEL_FORMAT, GetPixelFormat)(
 ) CONST PURE;
 
 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 DX_DECLARE_INTERFACE("2cd906a7-12e2-11dc-9fed-001143a055f9") ID2D1GradientStopCollection : public ID2D1Resource
{
 
 STDMETHOD_(UINT32, GetGradientStopCount)(
 ) CONST PURE;
 
 STDMETHOD_(void, GetGradientStops)(
 _Out_writes_to_(gradientStopsCount, _Inexpressible_("Retrieved through GetGradientStopCount()") ) D2D1_GRADIENT_STOP *gradientStops,
 UINT32 gradientStopsCount 
 ) CONST PURE;
 
 STDMETHOD_(D2D1_GAMMA, GetColorInterpolationGamma)(
 ) CONST PURE;
 
 STDMETHOD_(D2D1_EXTEND_MODE, GetExtendMode)(
 ) CONST PURE;
}; // interface ID2D1GradientStopCollection


interface DX_DECLARE_INTERFACE("2cd906a8-12e2-11dc-9fed-001143a055f9") ID2D1Brush : public ID2D1Resource
{
 
 STDMETHOD_(void, SetOpacity)(
 FLOAT opacity 
 ) PURE;
 
 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;
 
 COM_DECLSPEC_NOTHROW
 void
 SetTransform(
 CONST D2D1_MATRIX_3X2_F &transform 
 ) 
 {
 SetTransform(&transform);
 }
}; // interface ID2D1Brush


interface DX_DECLARE_INTERFACE("2cd906aa-12e2-11dc-9fed-001143a055f9") ID2D1BitmapBrush : public ID2D1Brush
{
 
 STDMETHOD_(void, SetExtendModeX)(
 D2D1_EXTEND_MODE extendModeX 
 ) PURE;
 
 STDMETHOD_(void, SetExtendModeY)(
 D2D1_EXTEND_MODE extendModeY 
 ) PURE;
 
 STDMETHOD_(void, SetInterpolationMode)(
 D2D1_BITMAP_INTERPOLATION_MODE interpolationMode 
 ) PURE;
 
 STDMETHOD_(void, SetBitmap)(
 _In_opt_ 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)(
 _Outptr_result_maybenull_ ID2D1Bitmap **bitmap 
 ) CONST PURE;
}; // interface ID2D1BitmapBrush


interface DX_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;
 
 COM_DECLSPEC_NOTHROW
 void
 SetColor(
 CONST D2D1_COLOR_F &color 
 ) 
 {
 SetColor(&color);
 }
}; // interface ID2D1SolidColorBrush


interface DX_DECLARE_INTERFACE("2cd906ab-12e2-11dc-9fed-001143a055f9") ID2D1LinearGradientBrush : public ID2D1Brush
{
 
 STDMETHOD_(void, SetStartPoint)(
 D2D1_POINT_2F startPoint 
 ) PURE;
 
 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)(
 _Outptr_ ID2D1GradientStopCollection **gradientStopCollection 
 ) CONST PURE;
}; // interface ID2D1LinearGradientBrush


interface DX_DECLARE_INTERFACE("2cd906ac-12e2-11dc-9fed-001143a055f9") ID2D1RadialGradientBrush : public ID2D1Brush
{
 
 STDMETHOD_(void, SetCenter)(
 D2D1_POINT_2F center 
 ) PURE;
 
 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)(
 _Outptr_ ID2D1GradientStopCollection **gradientStopCollection 
 ) CONST PURE;
}; // interface ID2D1RadialGradientBrush


interface DX_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;
 
 STDMETHOD_(void, GetDashes)(
 _Out_writes_(dashesCount) FLOAT *dashes,
 UINT32 dashesCount 
 ) CONST PURE;
}; // interface ID2D1StrokeStyle


interface DX_DECLARE_INTERFACE("2cd906a1-12e2-11dc-9fed-001143a055f9") ID2D1Geometry : public ID2D1Resource
{
 
 STDMETHOD(GetBounds)(
 _In_opt_ CONST D2D1_MATRIX_3X2_F *worldTransform,
 _Out_ D2D1_RECT_F *bounds 
 ) CONST PURE;
 
 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;
 
 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;
 
 STDMETHOD(FillContainsPoint)(
 D2D1_POINT_2F point,
 _In_opt_ CONST D2D1_MATRIX_3X2_F *worldTransform,
 FLOAT flatteningTolerance,
 _Out_ BOOL *contains 
 ) CONST PURE;
 
 STDMETHOD(CompareWithGeometry)(
 _In_ ID2D1Geometry *inputGeometry,
 _In_opt_ CONST D2D1_MATRIX_3X2_F *inputGeometryTransform,
 FLOAT flatteningTolerance,
 _Out_ D2D1_GEOMETRY_RELATION *relation 
 ) CONST PURE;
 
 STDMETHOD(Simplify)(
 D2D1_GEOMETRY_SIMPLIFICATION_OPTION simplificationOption,
 _In_opt_ CONST D2D1_MATRIX_3X2_F *worldTransform,
 FLOAT flatteningTolerance,
 _In_ ID2D1SimplifiedGeometrySink *geometrySink 
 ) CONST PURE;
 
 STDMETHOD(Tessellate)(
 _In_opt_ CONST D2D1_MATRIX_3X2_F *worldTransform,
 FLOAT flatteningTolerance,
 _In_ ID2D1TessellationSink *tessellationSink 
 ) CONST PURE;
 
 STDMETHOD(CombineWithGeometry)(
 _In_ ID2D1Geometry *inputGeometry,
 D2D1_COMBINE_MODE combineMode,
 _In_opt_ CONST D2D1_MATRIX_3X2_F *inputGeometryTransform,
 FLOAT flatteningTolerance,
 _In_ ID2D1SimplifiedGeometrySink *geometrySink 
 ) CONST PURE;
 
 STDMETHOD(Outline)(
 _In_opt_ CONST D2D1_MATRIX_3X2_F *worldTransform,
 FLOAT flatteningTolerance,
 _In_ ID2D1SimplifiedGeometrySink *geometrySink 
 ) CONST PURE;
 
 STDMETHOD(ComputeArea)(
 _In_opt_ CONST D2D1_MATRIX_3X2_F *worldTransform,
 FLOAT flatteningTolerance,
 _Out_ FLOAT *area 
 ) CONST PURE;
 
 STDMETHOD(ComputeLength)(
 _In_opt_ CONST D2D1_MATRIX_3X2_F *worldTransform,
 FLOAT flatteningTolerance,
 _Out_ FLOAT *length 
 ) CONST PURE;
 
 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;
 
 STDMETHOD(Widen)(
 FLOAT strokeWidth,
 _In_opt_ ID2D1StrokeStyle *strokeStyle,
 _In_opt_ CONST D2D1_MATRIX_3X2_F *worldTransform,
 FLOAT flatteningTolerance,
 _In_ ID2D1SimplifiedGeometrySink *geometrySink 
 ) CONST PURE;
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 GetBounds(
 CONST D2D1_MATRIX_3X2_F &worldTransform,
 _Out_ D2D1_RECT_F *bounds 
 ) CONST 
 {
 return GetBounds(&worldTransform, bounds);
 }
 
 COM_DECLSPEC_NOTHROW
 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);
 }
 
 COM_DECLSPEC_NOTHROW
 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);
 }
 
 COM_DECLSPEC_NOTHROW
 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);
 }
 
 COM_DECLSPEC_NOTHROW
 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);
 }
 
 COM_DECLSPEC_NOTHROW
 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);
 }
 
 COM_DECLSPEC_NOTHROW
 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);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 FillContainsPoint(
 D2D1_POINT_2F point,
 CONST D2D1_MATRIX_3X2_F &worldTransform,
 FLOAT flatteningTolerance,
 _Out_ BOOL *contains 
 ) CONST 
 {
 return FillContainsPoint(point, &worldTransform, flatteningTolerance, contains);
 }
 
 COM_DECLSPEC_NOTHROW
 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);
 }
 
 COM_DECLSPEC_NOTHROW
 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);
 }
 
 COM_DECLSPEC_NOTHROW
 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);
 }
 
 COM_DECLSPEC_NOTHROW
 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);
 }
 
 COM_DECLSPEC_NOTHROW
 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);
 }
 
 COM_DECLSPEC_NOTHROW
 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);
 }
 
 COM_DECLSPEC_NOTHROW
 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);
 }
 
 COM_DECLSPEC_NOTHROW
 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);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 Tessellate(
 CONST D2D1_MATRIX_3X2_F &worldTransform,
 FLOAT flatteningTolerance,
 _In_ ID2D1TessellationSink *tessellationSink 
 ) CONST 
 {
 return Tessellate(&worldTransform, flatteningTolerance, tessellationSink);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 Tessellate(
 _In_opt_ CONST D2D1_MATRIX_3X2_F *worldTransform,
 _In_ ID2D1TessellationSink *tessellationSink 
 ) CONST 
 {
 return Tessellate(worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, tessellationSink);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 Tessellate(
 CONST D2D1_MATRIX_3X2_F &worldTransform,
 _In_ ID2D1TessellationSink *tessellationSink 
 ) CONST 
 {
 return Tessellate(&worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, tessellationSink);
 }
 
 COM_DECLSPEC_NOTHROW
 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);
 }
 
 COM_DECLSPEC_NOTHROW
 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);
 }
 
 COM_DECLSPEC_NOTHROW
 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);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 Outline(
 CONST D2D1_MATRIX_3X2_F &worldTransform,
 FLOAT flatteningTolerance,
 _In_ ID2D1SimplifiedGeometrySink *geometrySink 
 ) CONST 
 {
 return Outline(&worldTransform, flatteningTolerance, geometrySink);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 Outline(
 _In_opt_ CONST D2D1_MATRIX_3X2_F *worldTransform,
 _In_ ID2D1SimplifiedGeometrySink *geometrySink 
 ) CONST 
 {
 return Outline(worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, geometrySink);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 Outline(
 CONST D2D1_MATRIX_3X2_F &worldTransform,
 _In_ ID2D1SimplifiedGeometrySink *geometrySink 
 ) CONST 
 {
 return Outline(&worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, geometrySink);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 ComputeArea(
 CONST D2D1_MATRIX_3X2_F &worldTransform,
 FLOAT flatteningTolerance,
 _Out_ FLOAT *area 
 ) CONST 
 {
 return ComputeArea(&worldTransform, flatteningTolerance, area);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 ComputeArea(
 _In_opt_ CONST D2D1_MATRIX_3X2_F *worldTransform,
 _Out_ FLOAT *area 
 ) CONST 
 {
 return ComputeArea(worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, area);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 ComputeArea(
 CONST D2D1_MATRIX_3X2_F &worldTransform,
 _Out_ FLOAT *area 
 ) CONST 
 {
 return ComputeArea(&worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, area);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 ComputeLength(
 CONST D2D1_MATRIX_3X2_F &worldTransform,
 FLOAT flatteningTolerance,
 _Out_ FLOAT *length 
 ) CONST 
 {
 return ComputeLength(&worldTransform, flatteningTolerance, length);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 ComputeLength(
 _In_opt_ CONST D2D1_MATRIX_3X2_F *worldTransform,
 _Out_ FLOAT *length 
 ) CONST 
 {
 return ComputeLength(worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, length);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 ComputeLength(
 CONST D2D1_MATRIX_3X2_F &worldTransform,
 _Out_ FLOAT *length 
 ) CONST 
 {
 return ComputeLength(&worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, length);
 }
 
 COM_DECLSPEC_NOTHROW
 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);
 }
 
 COM_DECLSPEC_NOTHROW
 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);
 }
 
 COM_DECLSPEC_NOTHROW
 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);
 }
 
 COM_DECLSPEC_NOTHROW
 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);
 }
 
 COM_DECLSPEC_NOTHROW
 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);
 }
 
 COM_DECLSPEC_NOTHROW
 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 DX_DECLARE_INTERFACE("2cd906a2-12e2-11dc-9fed-001143a055f9") ID2D1RectangleGeometry : public ID2D1Geometry
{
 
 STDMETHOD_(void, GetRect)(
 _Out_ D2D1_RECT_F *rect 
 ) CONST PURE;
}; // interface ID2D1RectangleGeometry


interface DX_DECLARE_INTERFACE("2cd906a3-12e2-11dc-9fed-001143a055f9") ID2D1RoundedRectangleGeometry : public ID2D1Geometry
{
 
 STDMETHOD_(void, GetRoundedRect)(
 _Out_ D2D1_ROUNDED_RECT *roundedRect 
 ) CONST PURE;
}; // interface ID2D1RoundedRectangleGeometry


interface DX_DECLARE_INTERFACE("2cd906a4-12e2-11dc-9fed-001143a055f9") ID2D1EllipseGeometry : public ID2D1Geometry
{
 
 STDMETHOD_(void, GetEllipse)(
 _Out_ D2D1_ELLIPSE *ellipse 
 ) CONST PURE;
}; // interface ID2D1EllipseGeometry


interface DX_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_writes_(geometriesCount) ID2D1Geometry **geometries,
 UINT32 geometriesCount 
 ) CONST PURE;
}; // interface ID2D1GeometryGroup


interface DX_DECLARE_INTERFACE("2cd906bb-12e2-11dc-9fed-001143a055f9") ID2D1TransformedGeometry : public ID2D1Geometry
{
 
 STDMETHOD_(void, GetSourceGeometry)(
 _Outptr_ ID2D1Geometry **sourceGeometry 
 ) CONST PURE;
 
 STDMETHOD_(void, GetTransform)(
 _Out_ D2D1_MATRIX_3X2_F *transform 
 ) CONST PURE;
}; // interface ID2D1TransformedGeometry


interface DX_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_reads_(pointsCount) CONST D2D1_POINT_2F *points,
 UINT32 pointsCount 
 ) PURE;
 
 STDMETHOD_(void, AddBeziers)(
 _In_reads_(beziersCount) CONST D2D1_BEZIER_SEGMENT *beziers,
 UINT32 beziersCount 
 ) PURE;
 
 STDMETHOD_(void, EndFigure)(
 D2D1_FIGURE_END figureEnd 
 ) PURE;
 
 STDMETHOD(Close)(
 ) PURE;
}; // interface ID2D1SimplifiedGeometrySink


interface DX_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_reads_(beziersCount) CONST D2D1_QUADRATIC_BEZIER_SEGMENT *beziers,
 UINT32 beziersCount 
 ) PURE;
 
 STDMETHOD_(void, AddArc)(
 _In_ CONST D2D1_ARC_SEGMENT *arc 
 ) PURE;
 
 COM_DECLSPEC_NOTHROW
 void
 AddBezier(
 CONST D2D1_BEZIER_SEGMENT &bezier 
 ) 
 {
 AddBezier(&bezier);
 }
 
 COM_DECLSPEC_NOTHROW
 void
 AddQuadraticBezier(
 CONST D2D1_QUADRATIC_BEZIER_SEGMENT &bezier 
 ) 
 {
 AddQuadraticBezier(&bezier);
 }
 
 COM_DECLSPEC_NOTHROW
 void
 AddArc(
 CONST D2D1_ARC_SEGMENT &arc 
 ) 
 {
 AddArc(&arc);
 }
}; // interface ID2D1GeometrySink


interface DX_DECLARE_INTERFACE("2cd906c1-12e2-11dc-9fed-001143a055f9") ID2D1TessellationSink : public IUnknown
{
 
 STDMETHOD_(void, AddTriangles)(
 _In_reads_(trianglesCount) CONST D2D1_TRIANGLE *triangles,
 UINT32 trianglesCount 
 ) PURE;
 
 STDMETHOD(Close)(
 ) PURE;
}; // interface ID2D1TessellationSink


interface DX_DECLARE_INTERFACE("2cd906a5-12e2-11dc-9fed-001143a055f9") ID2D1PathGeometry : public ID2D1Geometry
{
 
 STDMETHOD(Open)(
 _COM_Outptr_ ID2D1GeometrySink **geometrySink 
 ) PURE;
 
 STDMETHOD(Stream)(
 _In_ ID2D1GeometrySink *geometrySink 
 ) CONST PURE;
 
 STDMETHOD(GetSegmentCount)(
 _Out_ UINT32 *count 
 ) CONST PURE;
 
 STDMETHOD(GetFigureCount)(
 _Out_ UINT32 *count 
 ) CONST PURE;
}; // interface ID2D1PathGeometry


interface DX_DECLARE_INTERFACE("2cd906c2-12e2-11dc-9fed-001143a055f9") ID2D1Mesh : public ID2D1Resource
{
 
 STDMETHOD(Open)(
 _COM_Outptr_ ID2D1TessellationSink **tessellationSink 
 ) PURE;
}; // interface ID2D1Mesh


interface DX_DECLARE_INTERFACE("2cd9069b-12e2-11dc-9fed-001143a055f9") ID2D1Layer : public ID2D1Resource
{
 
 STDMETHOD_(D2D1_SIZE_F, GetSize)(
 ) CONST PURE;
}; // interface ID2D1Layer


interface DX_DECLARE_INTERFACE("28506e39-ebf6-46a1-bb47-fd85565ab957") ID2D1DrawingStateBlock : public ID2D1Resource
{
 
 STDMETHOD_(void, GetDescription)(
 _Out_ D2D1_DRAWING_STATE_DESCRIPTION *stateDescription 
 ) CONST PURE;
 
 STDMETHOD_(void, SetDescription)(
 _In_ CONST D2D1_DRAWING_STATE_DESCRIPTION *stateDescription 
 ) PURE;
 
 STDMETHOD_(void, SetTextRenderingParams)(
 _In_opt_ IDWriteRenderingParams *textRenderingParams = NULL 
 ) PURE;
 
 STDMETHOD_(void, GetTextRenderingParams)(
 _Outptr_result_maybenull_ IDWriteRenderingParams **textRenderingParams 
 ) CONST PURE;
 
 COM_DECLSPEC_NOTHROW
 void
 SetDescription(
 CONST D2D1_DRAWING_STATE_DESCRIPTION &stateDescription 
 ) 
 {
 SetDescription(&stateDescription);
 }
}; // interface ID2D1DrawingStateBlock


interface DX_DECLARE_INTERFACE("2cd90694-12e2-11dc-9fed-001143a055f9") ID2D1RenderTarget : public ID2D1Resource
{
 
 STDMETHOD(CreateBitmap)(
 D2D1_SIZE_U size,
 _In_opt_ CONST void *srcData,
 UINT32 pitch,
 _In_ CONST D2D1_BITMAP_PROPERTIES *bitmapProperties,
 _COM_Outptr_ ID2D1Bitmap **bitmap 
 ) PURE;
 
 STDMETHOD(CreateBitmapFromWicBitmap)(
 _In_ IWICBitmapSource *wicBitmapSource,
 _In_opt_ CONST D2D1_BITMAP_PROPERTIES *bitmapProperties,
 _COM_Outptr_ ID2D1Bitmap **bitmap 
 ) PURE;
 
 STDMETHOD(CreateSharedBitmap)(
 _In_ REFIID riid,
 _Inout_ void *data,
 _In_opt_ CONST D2D1_BITMAP_PROPERTIES *bitmapProperties,
 _COM_Outptr_ ID2D1Bitmap **bitmap 
 ) PURE;
 
 STDMETHOD(CreateBitmapBrush)(
 _In_opt_ ID2D1Bitmap *bitmap,
 _In_opt_ CONST D2D1_BITMAP_BRUSH_PROPERTIES *bitmapBrushProperties,
 _In_opt_ CONST D2D1_BRUSH_PROPERTIES *brushProperties,
 _COM_Outptr_ ID2D1BitmapBrush **bitmapBrush 
 ) PURE;
 
 STDMETHOD(CreateSolidColorBrush)(
 _In_ CONST D2D1_COLOR_F *color,
 _In_opt_ CONST D2D1_BRUSH_PROPERTIES *brushProperties,
 _COM_Outptr_ ID2D1SolidColorBrush **solidColorBrush 
 ) PURE;
 
 STDMETHOD(CreateGradientStopCollection)(
 _In_reads_(gradientStopsCount) CONST D2D1_GRADIENT_STOP *gradientStops,
 _In_range_(>=,1) UINT32 gradientStopsCount,
 D2D1_GAMMA colorInterpolationGamma,
 D2D1_EXTEND_MODE extendMode,
 _COM_Outptr_ ID2D1GradientStopCollection **gradientStopCollection 
 ) PURE;
 
 STDMETHOD(CreateLinearGradientBrush)(
 _In_ CONST D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES *linearGradientBrushProperties,
 _In_opt_ CONST D2D1_BRUSH_PROPERTIES *brushProperties,
 _In_ ID2D1GradientStopCollection *gradientStopCollection,
 _COM_Outptr_ ID2D1LinearGradientBrush **linearGradientBrush 
 ) PURE;
 
 STDMETHOD(CreateRadialGradientBrush)(
 _In_ CONST D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES *radialGradientBrushProperties,
 _In_opt_ CONST D2D1_BRUSH_PROPERTIES *brushProperties,
 _In_ ID2D1GradientStopCollection *gradientStopCollection,
 _COM_Outptr_ ID2D1RadialGradientBrush **radialGradientBrush 
 ) PURE;
 
 STDMETHOD(CreateCompatibleRenderTarget)(
 _In_opt_ CONST D2D1_SIZE_F *desiredSize,
 _In_opt_ CONST D2D1_SIZE_U *desiredPixelSize,
 _In_opt_ CONST D2D1_PIXEL_FORMAT *desiredFormat,
 D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS options,
 _COM_Outptr_ ID2D1BitmapRenderTarget **bitmapRenderTarget 
 ) PURE;
 
 STDMETHOD(CreateLayer)(
 _In_opt_ CONST D2D1_SIZE_F *size,
 _COM_Outptr_ ID2D1Layer **layer 
 ) PURE;
 
 STDMETHOD(CreateMesh)(
 _COM_Outptr_ ID2D1Mesh **mesh 
 ) PURE;
 
 STDMETHOD_(void, DrawLine)(
 D2D1_POINT_2F point0,
 D2D1_POINT_2F point1,
 _In_ ID2D1Brush *brush,
 FLOAT strokeWidth = 1.0f,
 _In_opt_ ID2D1StrokeStyle *strokeStyle = NULL 
 ) PURE;
 
 STDMETHOD_(void, DrawRectangle)(
 _In_ CONST D2D1_RECT_F *rect,
 _In_ ID2D1Brush *brush,
 FLOAT strokeWidth = 1.0f,
 _In_opt_ ID2D1StrokeStyle *strokeStyle = NULL 
 ) PURE;
 
 STDMETHOD_(void, FillRectangle)(
 _In_ CONST D2D1_RECT_F *rect,
 _In_ ID2D1Brush *brush 
 ) PURE;
 
 STDMETHOD_(void, DrawRoundedRectangle)(
 _In_ CONST D2D1_ROUNDED_RECT *roundedRect,
 _In_ ID2D1Brush *brush,
 FLOAT strokeWidth = 1.0f,
 _In_opt_ ID2D1StrokeStyle *strokeStyle = NULL 
 ) PURE;
 
 STDMETHOD_(void, FillRoundedRectangle)(
 _In_ CONST D2D1_ROUNDED_RECT *roundedRect,
 _In_ ID2D1Brush *brush 
 ) PURE;
 
 STDMETHOD_(void, DrawEllipse)(
 _In_ CONST D2D1_ELLIPSE *ellipse,
 _In_ ID2D1Brush *brush,
 FLOAT strokeWidth = 1.0f,
 _In_opt_ ID2D1StrokeStyle *strokeStyle = NULL 
 ) PURE;
 
 STDMETHOD_(void, FillEllipse)(
 _In_ CONST D2D1_ELLIPSE *ellipse,
 _In_ ID2D1Brush *brush 
 ) PURE;
 
 STDMETHOD_(void, DrawGeometry)(
 _In_ ID2D1Geometry *geometry,
 _In_ ID2D1Brush *brush,
 FLOAT strokeWidth = 1.0f,
 _In_opt_ ID2D1StrokeStyle *strokeStyle = NULL 
 ) PURE;
 
 STDMETHOD_(void, FillGeometry)(
 _In_ ID2D1Geometry *geometry,
 _In_ ID2D1Brush *brush,
 _In_opt_ ID2D1Brush *opacityBrush = NULL 
 ) PURE;
 
 STDMETHOD_(void, FillMesh)(
 _In_ ID2D1Mesh *mesh,
 _In_ ID2D1Brush *brush 
 ) PURE;
 
 STDMETHOD_(void, FillOpacityMask)(
 _In_ ID2D1Bitmap *opacityMask,
 _In_ ID2D1Brush *brush,
 D2D1_OPACITY_MASK_CONTENT content,
 _In_opt_ CONST D2D1_RECT_F *destinationRectangle = NULL,
 _In_opt_ CONST D2D1_RECT_F *sourceRectangle = NULL 
 ) PURE;
 
 STDMETHOD_(void, DrawBitmap)(
 _In_ ID2D1Bitmap *bitmap,
 _In_opt_ CONST D2D1_RECT_F *destinationRectangle = NULL,
 FLOAT opacity = 1.0f,
 D2D1_BITMAP_INTERPOLATION_MODE interpolationMode = D2D1_BITMAP_INTERPOLATION_MODE_LINEAR,
 _In_opt_ CONST D2D1_RECT_F *sourceRectangle = NULL 
 ) PURE;
 
 STDMETHOD_(void, DrawText)(
 _In_reads_(stringLength) CONST WCHAR *string,
 UINT32 stringLength,
 _In_ IDWriteTextFormat *textFormat,
 _In_ CONST D2D1_RECT_F *layoutRect,
 _In_ ID2D1Brush *defaultFillBrush,
 D2D1_DRAW_TEXT_OPTIONS options = D2D1_DRAW_TEXT_OPTIONS_NONE,
 DWRITE_MEASURING_MODE measuringMode = DWRITE_MEASURING_MODE_NATURAL 
 ) PURE;
 
 STDMETHOD_(void, DrawTextLayout)(
 D2D1_POINT_2F origin,
 _In_ IDWriteTextLayout *textLayout,
 _In_ ID2D1Brush *defaultFillBrush,
 D2D1_DRAW_TEXT_OPTIONS options = D2D1_DRAW_TEXT_OPTIONS_NONE 
 ) PURE;
 
 STDMETHOD_(void, DrawGlyphRun)(
 D2D1_POINT_2F baselineOrigin,
 _In_ CONST DWRITE_GLYPH_RUN *glyphRun,
 _In_ ID2D1Brush *foregroundBrush,
 DWRITE_MEASURING_MODE measuringMode = DWRITE_MEASURING_MODE_NATURAL 
 ) PURE;
 
 STDMETHOD_(void, SetTransform)(
 _In_ CONST D2D1_MATRIX_3X2_F *transform 
 ) PURE;
 
 STDMETHOD_(void, GetTransform)(
 _Out_ D2D1_MATRIX_3X2_F *transform 
 ) CONST PURE;
 
 STDMETHOD_(void, SetAntialiasMode)(
 D2D1_ANTIALIAS_MODE antialiasMode 
 ) PURE;
 
 STDMETHOD_(D2D1_ANTIALIAS_MODE, GetAntialiasMode)(
 ) CONST PURE;
 
 STDMETHOD_(void, SetTextAntialiasMode)(
 D2D1_TEXT_ANTIALIAS_MODE textAntialiasMode 
 ) PURE;
 
 STDMETHOD_(D2D1_TEXT_ANTIALIAS_MODE, GetTextAntialiasMode)(
 ) CONST PURE;
 
 STDMETHOD_(void, SetTextRenderingParams)(
 _In_opt_ IDWriteRenderingParams *textRenderingParams = NULL 
 ) PURE;
 
 STDMETHOD_(void, GetTextRenderingParams)(
 _Outptr_result_maybenull_ IDWriteRenderingParams **textRenderingParams 
 ) CONST PURE;
 
 STDMETHOD_(void, SetTags)(
 D2D1_TAG tag1,
 D2D1_TAG tag2 
 ) PURE;
 
 STDMETHOD_(void, GetTags)(
 _Out_opt_ D2D1_TAG *tag1 = NULL,
 _Out_opt_ D2D1_TAG *tag2 = NULL 
 ) CONST PURE;
 
 STDMETHOD_(void, PushLayer)(
 _In_ CONST D2D1_LAYER_PARAMETERS *layerParameters,
 _In_opt_ ID2D1Layer *layer 
 ) PURE;
 
 STDMETHOD_(void, PopLayer)(
 ) PURE;
 
 STDMETHOD(Flush)(
 _Out_opt_ D2D1_TAG *tag1 = NULL,
 _Out_opt_ D2D1_TAG *tag2 = NULL 
 ) PURE;
 
 STDMETHOD_(void, SaveDrawingState)(
 _Inout_ ID2D1DrawingStateBlock *drawingStateBlock 
 ) CONST PURE;
 
 STDMETHOD_(void, RestoreDrawingState)(
 _In_ ID2D1DrawingStateBlock *drawingStateBlock 
 ) PURE;
 
 STDMETHOD_(void, PushAxisAlignedClip)(
 _In_ CONST D2D1_RECT_F *clipRect,
 D2D1_ANTIALIAS_MODE antialiasMode 
 ) PURE;
 
 STDMETHOD_(void, PopAxisAlignedClip)(
 ) PURE;
 
 STDMETHOD_(void, Clear)(
 _In_opt_ CONST D2D1_COLOR_F *clearColor = NULL 
 ) PURE;
 
 STDMETHOD_(void, BeginDraw)(
 ) PURE;
 
 STDMETHOD(EndDraw)(
 _Out_opt_ D2D1_TAG *tag1 = NULL,
 _Out_opt_ D2D1_TAG *tag2 = NULL 
 ) PURE;
 
 STDMETHOD_(D2D1_PIXEL_FORMAT, GetPixelFormat)(
 ) CONST PURE;
 
 STDMETHOD_(void, SetDpi)(
 FLOAT dpiX,
 FLOAT dpiY 
 ) PURE;
 
 STDMETHOD_(void, GetDpi)(
 _Out_ FLOAT *dpiX,
 _Out_ FLOAT *dpiY 
 ) CONST PURE;
 
 STDMETHOD_(D2D1_SIZE_F, GetSize)(
 ) CONST PURE;
 
 STDMETHOD_(D2D1_SIZE_U, GetPixelSize)(
 ) CONST PURE;
 
 STDMETHOD_(UINT32, GetMaximumBitmapSize)(
 ) CONST PURE;
 
 STDMETHOD_(BOOL, IsSupported)(
 _In_ CONST D2D1_RENDER_TARGET_PROPERTIES *renderTargetProperties 
 ) CONST PURE;
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateBitmap(
 D2D1_SIZE_U size,
 _In_opt_ CONST void *srcData,
 UINT32 pitch,
 CONST D2D1_BITMAP_PROPERTIES &bitmapProperties,
 _COM_Outptr_ ID2D1Bitmap **bitmap 
 ) 
 {
 return CreateBitmap(size, srcData, pitch, &bitmapProperties, bitmap);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateBitmap(
 D2D1_SIZE_U size,
 CONST D2D1_BITMAP_PROPERTIES &bitmapProperties,
 _COM_Outptr_ ID2D1Bitmap **bitmap 
 ) 
 {
 return CreateBitmap(size, NULL, 0, &bitmapProperties, bitmap);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateBitmapFromWicBitmap(
 _In_ IWICBitmapSource *wicBitmapSource,
 CONST D2D1_BITMAP_PROPERTIES &bitmapProperties,
 _COM_Outptr_ ID2D1Bitmap **bitmap 
 ) 
 {
 return CreateBitmapFromWicBitmap(wicBitmapSource, &bitmapProperties, bitmap);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateBitmapFromWicBitmap(
 _In_ IWICBitmapSource *wicBitmapSource,
 _COM_Outptr_ ID2D1Bitmap **bitmap 
 ) 
 {
 return CreateBitmapFromWicBitmap(wicBitmapSource, NULL, bitmap);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateBitmapBrush(
 _In_opt_ ID2D1Bitmap *bitmap,
 _COM_Outptr_ ID2D1BitmapBrush **bitmapBrush 
 ) 
 {
 return CreateBitmapBrush(bitmap, NULL, NULL, bitmapBrush);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateBitmapBrush(
 _In_opt_ ID2D1Bitmap *bitmap,
 CONST D2D1_BITMAP_BRUSH_PROPERTIES &bitmapBrushProperties,
 _COM_Outptr_ ID2D1BitmapBrush **bitmapBrush 
 ) 
 {
 return CreateBitmapBrush(bitmap, &bitmapBrushProperties, NULL, bitmapBrush);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateBitmapBrush(
 _In_opt_ ID2D1Bitmap *bitmap,
 CONST D2D1_BITMAP_BRUSH_PROPERTIES &bitmapBrushProperties,
 CONST D2D1_BRUSH_PROPERTIES &brushProperties,
 _COM_Outptr_ ID2D1BitmapBrush **bitmapBrush 
 ) 
 {
 return CreateBitmapBrush(bitmap, &bitmapBrushProperties, &brushProperties, bitmapBrush);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateSolidColorBrush(
 CONST D2D1_COLOR_F &color,
 _COM_Outptr_ ID2D1SolidColorBrush **solidColorBrush 
 ) 
 {
 return CreateSolidColorBrush(&color, NULL, solidColorBrush);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateSolidColorBrush(
 CONST D2D1_COLOR_F &color,
 CONST D2D1_BRUSH_PROPERTIES &brushProperties,
 _COM_Outptr_ ID2D1SolidColorBrush **solidColorBrush 
 ) 
 {
 return CreateSolidColorBrush(&color, &brushProperties, solidColorBrush);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateGradientStopCollection(
 _In_reads_(gradientStopsCount) CONST D2D1_GRADIENT_STOP *gradientStops,
 UINT32 gradientStopsCount,
 _COM_Outptr_ ID2D1GradientStopCollection **gradientStopCollection 
 ) 
 {
 return CreateGradientStopCollection(gradientStops, gradientStopsCount, D2D1_GAMMA_2_2, D2D1_EXTEND_MODE_CLAMP, gradientStopCollection);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateLinearGradientBrush(
 CONST D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES &linearGradientBrushProperties,
 _In_ ID2D1GradientStopCollection *gradientStopCollection,
 _COM_Outptr_ ID2D1LinearGradientBrush **linearGradientBrush 
 ) 
 {
 return CreateLinearGradientBrush(&linearGradientBrushProperties, NULL, gradientStopCollection, linearGradientBrush);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateLinearGradientBrush(
 CONST D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES &linearGradientBrushProperties,
 CONST D2D1_BRUSH_PROPERTIES &brushProperties,
 _In_ ID2D1GradientStopCollection *gradientStopCollection,
 _COM_Outptr_ ID2D1LinearGradientBrush **linearGradientBrush 
 ) 
 {
 return CreateLinearGradientBrush(&linearGradientBrushProperties, &brushProperties, gradientStopCollection, linearGradientBrush);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateRadialGradientBrush(
 CONST D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES &radialGradientBrushProperties,
 _In_ ID2D1GradientStopCollection *gradientStopCollection,
 _COM_Outptr_ ID2D1RadialGradientBrush **radialGradientBrush 
 ) 
 {
 return CreateRadialGradientBrush(&radialGradientBrushProperties, NULL, gradientStopCollection, radialGradientBrush);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateRadialGradientBrush(
 CONST D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES &radialGradientBrushProperties,
 CONST D2D1_BRUSH_PROPERTIES &brushProperties,
 _In_ ID2D1GradientStopCollection *gradientStopCollection,
 _COM_Outptr_ ID2D1RadialGradientBrush **radialGradientBrush 
 ) 
 {
 return CreateRadialGradientBrush(&radialGradientBrushProperties, &brushProperties, gradientStopCollection, radialGradientBrush);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateCompatibleRenderTarget(
 _COM_Outptr_ ID2D1BitmapRenderTarget **bitmapRenderTarget 
 ) 
 {
 return CreateCompatibleRenderTarget(NULL, NULL, NULL, D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE, bitmapRenderTarget);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateCompatibleRenderTarget(
 D2D1_SIZE_F desiredSize,
 _COM_Outptr_ ID2D1BitmapRenderTarget **bitmapRenderTarget 
 ) 
 {
 return CreateCompatibleRenderTarget(&desiredSize, NULL, NULL, D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE, bitmapRenderTarget);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateCompatibleRenderTarget(
 D2D1_SIZE_F desiredSize,
 D2D1_SIZE_U desiredPixelSize,
 _COM_Outptr_ ID2D1BitmapRenderTarget **bitmapRenderTarget 
 ) 
 {
 return CreateCompatibleRenderTarget(&desiredSize, &desiredPixelSize, NULL, D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE, bitmapRenderTarget);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateCompatibleRenderTarget(
 D2D1_SIZE_F desiredSize,
 D2D1_SIZE_U desiredPixelSize,
 D2D1_PIXEL_FORMAT desiredFormat,
 _COM_Outptr_ ID2D1BitmapRenderTarget **bitmapRenderTarget 
 ) 
 {
 return CreateCompatibleRenderTarget(&desiredSize, &desiredPixelSize, &desiredFormat, D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE, bitmapRenderTarget);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateCompatibleRenderTarget(
 D2D1_SIZE_F desiredSize,
 D2D1_SIZE_U desiredPixelSize,
 D2D1_PIXEL_FORMAT desiredFormat,
 D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS options,
 _COM_Outptr_ ID2D1BitmapRenderTarget **bitmapRenderTarget 
 ) 
 {
 return CreateCompatibleRenderTarget(&desiredSize, &desiredPixelSize, &desiredFormat, options, bitmapRenderTarget);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateLayer(
 D2D1_SIZE_F size,
 _COM_Outptr_ ID2D1Layer **layer 
 ) 
 {
 return CreateLayer(&size, layer);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateLayer(
 _COM_Outptr_ ID2D1Layer **layer 
 ) 
 {
 return CreateLayer(NULL, layer);
 }
 
 COM_DECLSPEC_NOTHROW
 void
 DrawRectangle(
 CONST D2D1_RECT_F &rect,
 _In_ ID2D1Brush *brush,
 FLOAT strokeWidth = 1.0f,
 _In_opt_ ID2D1StrokeStyle *strokeStyle = NULL 
 ) 
 {
 DrawRectangle(&rect, brush, strokeWidth, strokeStyle);
 }
 
 COM_DECLSPEC_NOTHROW
 void
 FillRectangle(
 CONST D2D1_RECT_F &rect,
 _In_ ID2D1Brush *brush 
 ) 
 {
 FillRectangle(&rect, brush);
 }
 
 COM_DECLSPEC_NOTHROW
 void
 DrawRoundedRectangle(
 CONST D2D1_ROUNDED_RECT &roundedRect,
 _In_ ID2D1Brush *brush,
 FLOAT strokeWidth = 1.0f,
 _In_opt_ ID2D1StrokeStyle *strokeStyle = NULL 
 ) 
 {
 DrawRoundedRectangle(&roundedRect, brush, strokeWidth, strokeStyle);
 }
 
 COM_DECLSPEC_NOTHROW
 void
 FillRoundedRectangle(
 CONST D2D1_ROUNDED_RECT &roundedRect,
 _In_ ID2D1Brush *brush 
 ) 
 {
 FillRoundedRectangle(&roundedRect, brush);
 }
 
 COM_DECLSPEC_NOTHROW
 void
 DrawEllipse(
 CONST D2D1_ELLIPSE &ellipse,
 _In_ ID2D1Brush *brush,
 FLOAT strokeWidth = 1.0f,
 _In_opt_ ID2D1StrokeStyle *strokeStyle = NULL 
 ) 
 {
 DrawEllipse(&ellipse, brush, strokeWidth, strokeStyle);
 }
 
 COM_DECLSPEC_NOTHROW
 void
 FillEllipse(
 CONST D2D1_ELLIPSE &ellipse,
 _In_ ID2D1Brush *brush 
 ) 
 {
 FillEllipse(&ellipse, brush);
 }
 
 COM_DECLSPEC_NOTHROW
 void
 FillOpacityMask(
 _In_ ID2D1Bitmap *opacityMask,
 _In_ ID2D1Brush *brush,
 D2D1_OPACITY_MASK_CONTENT content,
 CONST D2D1_RECT_F &destinationRectangle,
 CONST D2D1_RECT_F &sourceRectangle 
 ) 
 {
 FillOpacityMask(opacityMask, brush, content, &destinationRectangle, &sourceRectangle);
 }
 
 COM_DECLSPEC_NOTHROW
 void
 DrawBitmap(
 _In_ ID2D1Bitmap *bitmap,
 CONST D2D1_RECT_F &destinationRectangle,
 FLOAT opacity = 1.0f,
 D2D1_BITMAP_INTERPOLATION_MODE interpolationMode = D2D1_BITMAP_INTERPOLATION_MODE_LINEAR,
 _In_opt_ CONST D2D1_RECT_F *sourceRectangle = NULL 
 ) 
 {
 DrawBitmap(bitmap, &destinationRectangle, opacity, interpolationMode, sourceRectangle);
 }
 
 COM_DECLSPEC_NOTHROW
 void
 DrawBitmap(
 _In_ ID2D1Bitmap *bitmap,
 CONST D2D1_RECT_F &destinationRectangle,
 FLOAT opacity,
 D2D1_BITMAP_INTERPOLATION_MODE interpolationMode,
 CONST D2D1_RECT_F &sourceRectangle 
 ) 
 {
 DrawBitmap(bitmap, &destinationRectangle, opacity, interpolationMode, &sourceRectangle);
 }
 
 COM_DECLSPEC_NOTHROW
 void
 SetTransform(
 CONST D2D1_MATRIX_3X2_F &transform 
 ) 
 {
 SetTransform(&transform);
 }
 
 COM_DECLSPEC_NOTHROW
 void
 PushLayer(
 CONST D2D1_LAYER_PARAMETERS &layerParameters,
 _In_opt_ ID2D1Layer *layer 
 ) 
 {
 PushLayer(&layerParameters, layer);
 }
 
 COM_DECLSPEC_NOTHROW
 void
 PushAxisAlignedClip(
 CONST D2D1_RECT_F &clipRect,
 D2D1_ANTIALIAS_MODE antialiasMode 
 ) 
 {
 return PushAxisAlignedClip(&clipRect, antialiasMode);
 }
 
 COM_DECLSPEC_NOTHROW
 void
 Clear(
 CONST D2D1_COLOR_F &clearColor 
 ) 
 {
 return Clear(&clearColor);
 }
 
 COM_DECLSPEC_NOTHROW
 void
 DrawText(
 _In_reads_(stringLength) CONST WCHAR *string,
 UINT32 stringLength,
 _In_ IDWriteTextFormat *textFormat,
 CONST D2D1_RECT_F &layoutRect,
 _In_ ID2D1Brush *defaultFillBrush,
 D2D1_DRAW_TEXT_OPTIONS options = D2D1_DRAW_TEXT_OPTIONS_NONE,
 DWRITE_MEASURING_MODE measuringMode = DWRITE_MEASURING_MODE_NATURAL 
 ) 
 {
 return DrawText(string, stringLength, textFormat, &layoutRect, defaultFillBrush, options, measuringMode);
 }
 
 COM_DECLSPEC_NOTHROW
 BOOL
 IsSupported(
 CONST D2D1_RENDER_TARGET_PROPERTIES &renderTargetProperties 
 ) CONST 
 {
 return IsSupported(&renderTargetProperties);
 }
}; // interface ID2D1RenderTarget


interface DX_DECLARE_INTERFACE("2cd90695-12e2-11dc-9fed-001143a055f9") ID2D1BitmapRenderTarget : public ID2D1RenderTarget
{
 
 STDMETHOD(GetBitmap)(
 _COM_Outptr_ ID2D1Bitmap **bitmap 
 ) PURE;
}; // interface ID2D1BitmapRenderTarget


interface DX_DECLARE_INTERFACE("2cd90698-12e2-11dc-9fed-001143a055f9") ID2D1HwndRenderTarget : public ID2D1RenderTarget
{
 
 STDMETHOD_(D2D1_WINDOW_STATE, CheckWindowState)(
 ) PURE;
 
 STDMETHOD(Resize)(
 _In_ CONST D2D1_SIZE_U *pixelSize 
 ) PURE;
 
 STDMETHOD_(HWND, GetHwnd)(
 ) CONST PURE;
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 Resize(
 CONST D2D1_SIZE_U &pixelSize 
 ) 
 {
 return Resize(&pixelSize);
 }
}; // interface ID2D1HwndRenderTarget



/*#endif*/ /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */
/*#pragma endregion*/

/*#pragma region Desktop Family*/
/*#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)*/

interface DX_DECLARE_INTERFACE("e0db51c3-6f77-4bae-b3d5-e47509b35838") ID2D1GdiInteropRenderTarget : public IUnknown
{
 
 STDMETHOD(GetDC)(
 D2D1_DC_INITIALIZE_MODE mode,
 _Out_ HDC *hdc 
 ) PURE;
 
 STDMETHOD(ReleaseDC)(
 _In_opt_ CONST RECT *update 
 ) PURE;
}; // interface ID2D1GdiInteropRenderTarget



/*#endif*/ /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */
/*#pragma endregion*/

/*#pragma region Application Family*/
/*#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)*/

interface DX_DECLARE_INTERFACE("1c51bc64-de61-46fd-9899-63a5d8f03950") ID2D1DCRenderTarget : public ID2D1RenderTarget
{
 
 STDMETHOD(BindDC)(
 _In_ CONST HDC hDC,
 _In_ CONST RECT *pSubRect 
 ) PURE;
}; // interface ID2D1DCRenderTarget


interface DX_DECLARE_INTERFACE("06152247-6f50-465a-9245-118bfd3b6007") ID2D1Factory : public IUnknown
{
 
 STDMETHOD(ReloadSystemMetrics)(
 ) PURE;
 
 STDMETHOD_(void, GetDesktopDpi)(
 _Out_ FLOAT *dpiX,
 _Out_ FLOAT *dpiY 
 ) PURE;
 
 STDMETHOD(CreateRectangleGeometry)(
 _In_ CONST D2D1_RECT_F *rectangle,
 _COM_Outptr_ ID2D1RectangleGeometry **rectangleGeometry 
 ) PURE;
 
 STDMETHOD(CreateRoundedRectangleGeometry)(
 _In_ CONST D2D1_ROUNDED_RECT *roundedRectangle,
 _COM_Outptr_ ID2D1RoundedRectangleGeometry **roundedRectangleGeometry 
 ) PURE;
 
 STDMETHOD(CreateEllipseGeometry)(
 _In_ CONST D2D1_ELLIPSE *ellipse,
 _COM_Outptr_ ID2D1EllipseGeometry **ellipseGeometry 
 ) PURE;
 
 STDMETHOD(CreateGeometryGroup)(
 D2D1_FILL_MODE fillMode,
 _In_reads_(geometriesCount) ID2D1Geometry **geometries,
 UINT32 geometriesCount,
 _COM_Outptr_ ID2D1GeometryGroup **geometryGroup 
 ) PURE;
 
 STDMETHOD(CreateTransformedGeometry)(
 _In_ ID2D1Geometry *sourceGeometry,
 _In_ CONST D2D1_MATRIX_3X2_F *transform,
 _COM_Outptr_ ID2D1TransformedGeometry **transformedGeometry 
 ) PURE;
 
 STDMETHOD(CreatePathGeometry)(
 _COM_Outptr_ ID2D1PathGeometry **pathGeometry 
 ) PURE;
 
 STDMETHOD(CreateStrokeStyle)(
 _In_ CONST D2D1_STROKE_STYLE_PROPERTIES *strokeStyleProperties,
 _In_reads_opt_(dashesCount) CONST FLOAT *dashes,
 UINT32 dashesCount,
 _COM_Outptr_ ID2D1StrokeStyle **strokeStyle 
 ) PURE;
 
 STDMETHOD(CreateDrawingStateBlock)(
 _In_opt_ CONST D2D1_DRAWING_STATE_DESCRIPTION *drawingStateDescription,
 _In_opt_ IDWriteRenderingParams *textRenderingParams,
 _COM_Outptr_ ID2D1DrawingStateBlock **drawingStateBlock 
 ) PURE;
 
 STDMETHOD(CreateWicBitmapRenderTarget)(
 _In_ IWICBitmap *target,
 _In_ CONST D2D1_RENDER_TARGET_PROPERTIES *renderTargetProperties,
 _COM_Outptr_ ID2D1RenderTarget **renderTarget 
 ) PURE;
 
 STDMETHOD(CreateHwndRenderTarget)(
 _In_ CONST D2D1_RENDER_TARGET_PROPERTIES *renderTargetProperties,
 _In_ CONST D2D1_HWND_RENDER_TARGET_PROPERTIES *hwndRenderTargetProperties,
 _COM_Outptr_ ID2D1HwndRenderTarget **hwndRenderTarget 
 ) PURE;
 
 STDMETHOD(CreateDxgiSurfaceRenderTarget)(
 _In_ IDXGISurface *dxgiSurface,
 _In_ CONST D2D1_RENDER_TARGET_PROPERTIES *renderTargetProperties,
 _COM_Outptr_ ID2D1RenderTarget **renderTarget 
 ) PURE;
 
 STDMETHOD(CreateDCRenderTarget)(
 _In_ CONST D2D1_RENDER_TARGET_PROPERTIES *renderTargetProperties,
 _COM_Outptr_ ID2D1DCRenderTarget **dcRenderTarget 
 ) PURE;
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateRectangleGeometry(
 CONST D2D1_RECT_F &rectangle,
 _COM_Outptr_ ID2D1RectangleGeometry **rectangleGeometry 
 ) 
 {
 return CreateRectangleGeometry(&rectangle, rectangleGeometry);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateRoundedRectangleGeometry(
 CONST D2D1_ROUNDED_RECT &roundedRectangle,
 _COM_Outptr_ ID2D1RoundedRectangleGeometry **roundedRectangleGeometry 
 ) 
 {
 return CreateRoundedRectangleGeometry(&roundedRectangle, roundedRectangleGeometry);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateEllipseGeometry(
 CONST D2D1_ELLIPSE &ellipse,
 _COM_Outptr_ ID2D1EllipseGeometry **ellipseGeometry 
 ) 
 {
 return CreateEllipseGeometry(&ellipse, ellipseGeometry);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateTransformedGeometry(
 _In_ ID2D1Geometry *sourceGeometry,
 CONST D2D1_MATRIX_3X2_F &transform,
 _COM_Outptr_ ID2D1TransformedGeometry **transformedGeometry 
 ) 
 {
 return CreateTransformedGeometry(sourceGeometry, &transform, transformedGeometry);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateStrokeStyle(
 CONST D2D1_STROKE_STYLE_PROPERTIES &strokeStyleProperties,
 _In_reads_opt_(dashesCount) CONST FLOAT *dashes,
 UINT32 dashesCount,
 _COM_Outptr_ ID2D1StrokeStyle **strokeStyle 
 ) 
 {
 return CreateStrokeStyle(&strokeStyleProperties, dashes, dashesCount, strokeStyle);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateDrawingStateBlock(
 CONST D2D1_DRAWING_STATE_DESCRIPTION &drawingStateDescription,
 _COM_Outptr_ ID2D1DrawingStateBlock **drawingStateBlock 
 ) 
 {
 return CreateDrawingStateBlock(&drawingStateDescription, NULL, drawingStateBlock);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateDrawingStateBlock(
 _COM_Outptr_ ID2D1DrawingStateBlock **drawingStateBlock 
 ) 
 {
 return CreateDrawingStateBlock(NULL, NULL, drawingStateBlock);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateWicBitmapRenderTarget(
 _In_ IWICBitmap *target,
 CONST D2D1_RENDER_TARGET_PROPERTIES &renderTargetProperties,
 _COM_Outptr_ ID2D1RenderTarget **renderTarget 
 ) 
 {
 return CreateWicBitmapRenderTarget(target, &renderTargetProperties, renderTarget);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateHwndRenderTarget(
 CONST D2D1_RENDER_TARGET_PROPERTIES &renderTargetProperties,
 CONST D2D1_HWND_RENDER_TARGET_PROPERTIES &hwndRenderTargetProperties,
 _COM_Outptr_ ID2D1HwndRenderTarget **hwndRenderTarget 
 ) 
 {
 return CreateHwndRenderTarget(&renderTargetProperties, &hwndRenderTargetProperties, hwndRenderTarget);
 }
 
 COM_DECLSPEC_NOTHROW
 HRESULT
 CreateDxgiSurfaceRenderTarget(
 _In_ IDXGISurface *dxgiSurface,
 CONST D2D1_RENDER_TARGET_PROPERTIES &renderTargetProperties,
 _COM_Outptr_ ID2D1RenderTarget **renderTarget 
 ) 
 {
 return CreateDxgiSurfaceRenderTarget(dxgiSurface, &renderTargetProperties, renderTarget);
 }
}; // interface ID2D1Factory



/*#endif*/ /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */
/*#pragma endregion*/


#endif


#ifdef D2D_USE_C_DEFINITIONS


/*#pragma region Application Family*/
/*#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)*/

typedef interface ID2D1Resource ID2D1Resource;

typedef interface ID2D1Image ID2D1Image;

typedef interface ID2D1Bitmap ID2D1Bitmap;

typedef interface ID2D1GradientStopCollection ID2D1GradientStopCollection;

typedef interface ID2D1Brush ID2D1Brush;

typedef interface ID2D1BitmapBrush ID2D1BitmapBrush;

typedef interface ID2D1SolidColorBrush ID2D1SolidColorBrush;

typedef interface ID2D1LinearGradientBrush ID2D1LinearGradientBrush;

typedef interface ID2D1RadialGradientBrush ID2D1RadialGradientBrush;

typedef interface ID2D1StrokeStyle ID2D1StrokeStyle;

typedef interface ID2D1Geometry ID2D1Geometry;

typedef interface ID2D1RectangleGeometry ID2D1RectangleGeometry;

typedef interface ID2D1RoundedRectangleGeometry ID2D1RoundedRectangleGeometry;

typedef interface ID2D1EllipseGeometry ID2D1EllipseGeometry;

typedef interface ID2D1GeometryGroup ID2D1GeometryGroup;

typedef interface ID2D1TransformedGeometry ID2D1TransformedGeometry;

typedef interface ID2D1SimplifiedGeometrySink ID2D1SimplifiedGeometrySink;

typedef interface ID2D1GeometrySink ID2D1GeometrySink;

typedef interface ID2D1TessellationSink ID2D1TessellationSink;

typedef interface ID2D1PathGeometry ID2D1PathGeometry;

typedef interface ID2D1Mesh ID2D1Mesh;

typedef interface ID2D1Layer ID2D1Layer;

typedef interface ID2D1DrawingStateBlock ID2D1DrawingStateBlock;

typedef interface ID2D1RenderTarget ID2D1RenderTarget;

typedef interface ID2D1BitmapRenderTarget ID2D1BitmapRenderTarget;

typedef interface ID2D1HwndRenderTarget ID2D1HwndRenderTarget;

/*#endif*/ /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */
/*#pragma endregion*/

/*#pragma region Application Family*/
/*#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)*/

typedef interface ID2D1GdiInteropRenderTarget ID2D1GdiInteropRenderTarget;

/*#endif*/ /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */
/*#pragma endregion*/

/*#pragma region Application Family*/
/*#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)*/

typedef interface ID2D1DCRenderTarget ID2D1DCRenderTarget;

typedef interface ID2D1Factory ID2D1Factory;

/*#endif*/ /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */
/*#pragma endregion*/


#endif


/*#pragma region Application Family*/
/*#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)*/
 
#ifdef __cplusplus
extern "C"
{
#endif

 //
 // This export cannot be in a namespace because compiler name mangling isn't consistent
 // also, this must be 'C' callable.
 //
 HRESULT WINAPI
 D2D1CreateFactory(
 _In_ D2D1_FACTORY_TYPE factoryType,
 _In_ REFIID riid,
 _In_opt_ CONST D2D1_FACTORY_OPTIONS *pFactoryOptions,
 _Out_ void **ppIFactory
 );


 void WINAPI
 D2D1MakeRotateMatrix(
 _In_ FLOAT angle,
 _In_ D2D1_POINT_2F center,
 _Out_ D2D1_MATRIX_3X2_F *matrix
 );

 void WINAPI
 D2D1MakeSkewMatrix(
 _In_ FLOAT angleX,
 _In_ FLOAT angleY,
 _In_ D2D1_POINT_2F center,
 _Out_ D2D1_MATRIX_3X2_F *matrix
 );

 BOOL WINAPI
 D2D1IsMatrixInvertible(
 _In_ CONST D2D1_MATRIX_3X2_F *matrix
 );

 BOOL WINAPI
 D2D1InvertMatrix(
 _Inout_ D2D1_MATRIX_3X2_F *matrix
 );

#ifdef __cplusplus
}
#endif

#ifndef D2D1FORCEINLINE
#define D2D1FORCEINLINE FORCEINLINE
#endif // #ifndef D2D1FORCEINLINE

 
#include <d2d1helper.h>


#ifndef D2D_USE_C_DEFINITIONS

COM_DECLSPEC_NOTHROW
inline
HRESULT
D2D1CreateFactory(
 _In_ D2D1_FACTORY_TYPE factoryType,
 _In_ REFIID riid,
 _Out_ void **factory
 )
{
 return
 D2D1CreateFactory(
 factoryType,
 riid,
 NULL,
 factory);
}


template<class Factory>
COM_DECLSPEC_NOTHROW
HRESULT
D2D1CreateFactory(
 _In_ D2D1_FACTORY_TYPE factoryType,
 _Out_ Factory **factory
 )
{
 return
 D2D1CreateFactory(
 factoryType,
 __uuidof(Factory),
 reinterpret_cast<void **>(factory));
}

template<class Factory>
COM_DECLSPEC_NOTHROW
HRESULT
D2D1CreateFactory(
 _In_ D2D1_FACTORY_TYPE factoryType,
 _In_ CONST D2D1_FACTORY_OPTIONS &factoryOptions,
 _Out_ Factory **ppFactory
 )
{
 return
 D2D1CreateFactory(
 factoryType,
 __uuidof(Factory),
 &factoryOptions,
 reinterpret_cast<void **>(ppFactory));
}

#endif // #ifndef D2D_USE_C_DEFINITIONS

/*#endif*/ /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */
/*#pragma endregion*/

#endif // #ifndef _D2D1_H_