983 lines
33 KiB
Rust
983 lines
33 KiB
Rust
// Licensed under the Apache License, Version 2.0
|
|
// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
|
|
// All files in the project carrying such notice may not be copied, modified, or distributed
|
|
// except according to those terms
|
|
//! Mappings for the contents of d2d1.h
|
|
use ctypes::c_void;
|
|
use shared::basetsd::{UINT32, UINT64};
|
|
use shared::dxgi::IDXGISurface;
|
|
use shared::guiddef::REFIID;
|
|
use shared::minwindef::{BOOL, DWORD, FLOAT};
|
|
use shared::windef::{HDC, HWND, RECT};
|
|
use um::d2dbasetypes::{
|
|
D2D_COLOR_F, D2D_MATRIX_3X2_F, D2D_POINT_2F, D2D_POINT_2U, D2D_RECT_F, D2D_RECT_U, D2D_SIZE_F,
|
|
D2D_SIZE_U,
|
|
};
|
|
use um::d3dcommon::{D3D_FEATURE_LEVEL_10_0, D3D_FEATURE_LEVEL_9_1};
|
|
use um::dcommon::{D2D1_PIXEL_FORMAT, DWRITE_MEASURING_MODE};
|
|
use um::dwrite::{DWRITE_GLYPH_RUN, IDWriteRenderingParams, IDWriteTextFormat, IDWriteTextLayout};
|
|
use um::unknwnbase::{IUnknown, IUnknownVtbl};
|
|
use um::wincodec::{IWICBitmap, IWICBitmapSource};
|
|
use um::winnt::{HRESULT, WCHAR};
|
|
// Types confirmed affected by the ABI issue:
|
|
// D2D1_SIZE_F, D2D1_SIZE_U, D2D1_COLOR_F, D2D1_PIXEL_FORMAT, D2D1_POINT_2F
|
|
pub const D2D1_DEFAULT_FLATTENING_TOLERANCE: FLOAT = 0.25;
|
|
pub const D2D1_INTERPOLATION_MODE_DEFINITION_NEAREST_NEIGHBOR: DWORD = 0;
|
|
pub const D2D1_INTERPOLATION_MODE_DEFINITION_LINEAR: DWORD = 1;
|
|
pub const D2D1_INTERPOLATION_MODE_DEFINITION_CUBIC: DWORD = 2;
|
|
pub const D2D1_INTERPOLATION_MODE_DEFINITION_MULTI_SAMPLE_LINEAR: DWORD = 3;
|
|
pub const D2D1_INTERPOLATION_MODE_DEFINITION_ANISOTROPIC: DWORD = 4;
|
|
pub const D2D1_INTERPOLATION_MODE_DEFINITION_HIGH_QUALITY_CUBIC: DWORD = 5;
|
|
pub const D2D1_INTERPOLATION_MODE_DEFINITION_FANT: DWORD = 6;
|
|
pub const D2D1_INTERPOLATION_MODE_DEFINITION_MIPMAP_LINEAR: DWORD = 7;
|
|
ENUM!{enum D2D1_GAMMA {
|
|
D2D1_GAMMA_2_2 = 0,
|
|
D2D1_GAMMA_1_0 = 1,
|
|
}}
|
|
ENUM!{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,
|
|
}}
|
|
ENUM!{enum D2D1_EXTEND_MODE {
|
|
D2D1_EXTEND_MODE_CLAMP = 0,
|
|
D2D1_EXTEND_MODE_WRAP = 1,
|
|
D2D1_EXTEND_MODE_MIRROR = 2,
|
|
}}
|
|
ENUM!{enum D2D1_ANTIALIAS_MODE {
|
|
D2D1_ANTIALIAS_MODE_PER_PRIMITIVE = 0,
|
|
D2D1_ANTIALIAS_MODE_ALIASED = 1,
|
|
}}
|
|
ENUM!{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,
|
|
}}
|
|
ENUM!{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,
|
|
}}
|
|
ENUM!{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_NONE = 0x00000000,
|
|
}}
|
|
pub type D2D1_POINT_2U = D2D_POINT_2U;
|
|
pub type D2D1_POINT_2F = D2D_POINT_2F;
|
|
pub type D2D1_RECT_F = D2D_RECT_F;
|
|
pub type D2D1_RECT_U = D2D_RECT_U;
|
|
pub type D2D1_SIZE_F = D2D_SIZE_F;
|
|
pub type D2D1_SIZE_U = D2D_SIZE_U;
|
|
pub type D2D1_COLOR_F = D2D_COLOR_F;
|
|
pub type D2D1_MATRIX_3X2_F = D2D_MATRIX_3X2_F;
|
|
pub type D2D1_TAG = UINT64;
|
|
STRUCT!{struct D2D1_BITMAP_PROPERTIES {
|
|
pixelFormat: D2D1_PIXEL_FORMAT,
|
|
dpiX: FLOAT,
|
|
dpiY: FLOAT,
|
|
}}
|
|
STRUCT!{struct D2D1_GRADIENT_STOP {
|
|
position: FLOAT,
|
|
color: D2D1_COLOR_F,
|
|
}}
|
|
STRUCT!{struct D2D1_BRUSH_PROPERTIES {
|
|
opacity: FLOAT,
|
|
transform: D2D1_MATRIX_3X2_F,
|
|
}}
|
|
STRUCT!{struct D2D1_BITMAP_BRUSH_PROPERTIES {
|
|
extendModeX: D2D1_EXTEND_MODE,
|
|
extendModeY: D2D1_EXTEND_MODE,
|
|
interpolationMode: D2D1_BITMAP_INTERPOLATION_MODE,
|
|
}}
|
|
STRUCT!{struct D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES {
|
|
startPoint: D2D1_POINT_2F,
|
|
endPoint: D2D1_POINT_2F,
|
|
}}
|
|
STRUCT!{struct D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES {
|
|
center: D2D1_POINT_2F,
|
|
gradientOriginOffset: D2D1_POINT_2F,
|
|
radiusX: FLOAT,
|
|
radiusY: FLOAT,
|
|
}}
|
|
ENUM!{enum D2D1_ARC_SIZE {
|
|
D2D1_ARC_SIZE_SMALL = 0,
|
|
D2D1_ARC_SIZE_LARGE = 1,
|
|
}}
|
|
ENUM!{enum D2D1_CAP_STYLE {
|
|
D2D1_CAP_STYLE_FLAT = 0,
|
|
D2D1_CAP_STYLE_SQUARE = 1,
|
|
D2D1_CAP_STYLE_ROUND = 2,
|
|
D2D1_CAP_STYLE_TRIANGLE = 3,
|
|
}}
|
|
ENUM!{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,
|
|
}}
|
|
ENUM!{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,
|
|
}}
|
|
ENUM!{enum D2D1_COMBINE_MODE {
|
|
D2D1_COMBINE_MODE_UNION = 0,
|
|
D2D1_COMBINE_MODE_INTERSECT = 1,
|
|
D2D1_COMBINE_MODE_XOR = 2,
|
|
D2D1_COMBINE_MODE_EXCLUDE = 3,
|
|
}}
|
|
ENUM!{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,
|
|
}}
|
|
ENUM!{enum D2D1_GEOMETRY_SIMPLIFICATION_OPTION {
|
|
D2D1_GEOMETRY_SIMPLIFICATION_OPTION_CUBICS_AND_LINES = 0,
|
|
D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES = 1,
|
|
}}
|
|
ENUM!{enum D2D1_FIGURE_BEGIN {
|
|
D2D1_FIGURE_BEGIN_FILLED = 0,
|
|
D2D1_FIGURE_BEGIN_HOLLOW = 1,
|
|
}}
|
|
ENUM!{enum D2D1_FIGURE_END {
|
|
D2D1_FIGURE_END_OPEN = 0,
|
|
D2D1_FIGURE_END_CLOSED = 1,
|
|
}}
|
|
STRUCT!{struct D2D1_BEZIER_SEGMENT {
|
|
point1: D2D1_POINT_2F,
|
|
point2: D2D1_POINT_2F,
|
|
point3: D2D1_POINT_2F,
|
|
}}
|
|
STRUCT!{struct D2D1_TRIANGLE {
|
|
point1: D2D1_POINT_2F,
|
|
point2: D2D1_POINT_2F,
|
|
point3: D2D1_POINT_2F,
|
|
}}
|
|
ENUM!{enum D2D1_PATH_SEGMENT {
|
|
D2D1_PATH_SEGMENT_NONE = 0x00000000,
|
|
D2D1_PATH_SEGMENT_FORCE_UNSTROKED = 0x00000001,
|
|
D2D1_PATH_SEGMENT_FORCE_ROUND_LINE_JOIN = 0x00000002,
|
|
}}
|
|
ENUM!{enum D2D1_SWEEP_DIRECTION {
|
|
D2D1_SWEEP_DIRECTION_COUNTER_CLOCKWISE = 0,
|
|
D2D1_SWEEP_DIRECTION_CLOCKWISE = 1,
|
|
}}
|
|
ENUM!{enum D2D1_FILL_MODE {
|
|
D2D1_FILL_MODE_ALTERNATE = 0,
|
|
D2D1_FILL_MODE_WINDING = 1,
|
|
}}
|
|
STRUCT!{struct D2D1_ARC_SEGMENT {
|
|
point: D2D1_POINT_2F,
|
|
size: D2D1_SIZE_F,
|
|
rotationAngle: FLOAT,
|
|
sweepDirection: D2D1_SWEEP_DIRECTION,
|
|
arcSize: D2D1_ARC_SIZE,
|
|
}}
|
|
STRUCT!{struct D2D1_QUADRATIC_BEZIER_SEGMENT {
|
|
point1: D2D1_POINT_2F,
|
|
point2: D2D1_POINT_2F,
|
|
}}
|
|
STRUCT!{struct D2D1_ELLIPSE {
|
|
point: D2D1_POINT_2F,
|
|
radiusX: FLOAT,
|
|
radiusY: FLOAT,
|
|
}}
|
|
STRUCT!{struct D2D1_ROUNDED_RECT {
|
|
rect: D2D1_RECT_F,
|
|
radiusX: FLOAT,
|
|
radiusY: FLOAT,
|
|
}}
|
|
STRUCT!{struct D2D1_STROKE_STYLE_PROPERTIES {
|
|
startCap: D2D1_CAP_STYLE,
|
|
endCap: D2D1_CAP_STYLE,
|
|
dashCap: D2D1_CAP_STYLE,
|
|
lineJoin: D2D1_LINE_JOIN,
|
|
miterLimit: FLOAT,
|
|
dashStyle: D2D1_DASH_STYLE,
|
|
dashOffset: FLOAT,
|
|
}}
|
|
ENUM!{enum D2D1_LAYER_OPTIONS {
|
|
D2D1_LAYER_OPTIONS_NONE = 0x00000000,
|
|
D2D1_LAYER_OPTIONS_INITIALIZE_FOR_CLEARTYPE = 0x00000001,
|
|
}}
|
|
STRUCT!{struct D2D1_LAYER_PARAMETERS {
|
|
contentBounds: D2D1_RECT_F,
|
|
geometricMask: *mut ID2D1Geometry,
|
|
maskAntialiasMode: D2D1_ANTIALIAS_MODE,
|
|
maskTransform: D2D1_MATRIX_3X2_F,
|
|
opacity: FLOAT,
|
|
opacityBrush: *mut ID2D1Brush,
|
|
layerOptions: D2D1_LAYER_OPTIONS,
|
|
}}
|
|
ENUM!{enum D2D1_WINDOW_STATE {
|
|
D2D1_WINDOW_STATE_NONE = 0x0000000,
|
|
D2D1_WINDOW_STATE_OCCLUDED = 0x0000001,
|
|
}}
|
|
ENUM!{enum D2D1_RENDER_TARGET_TYPE {
|
|
D2D1_RENDER_TARGET_TYPE_DEFAULT = 0,
|
|
D2D1_RENDER_TARGET_TYPE_SOFTWARE = 1,
|
|
D2D1_RENDER_TARGET_TYPE_HARDWARE = 2,
|
|
}}
|
|
ENUM!{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,
|
|
}}
|
|
ENUM!{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,
|
|
}}
|
|
ENUM!{enum D2D1_PRESENT_OPTIONS {
|
|
D2D1_PRESENT_OPTIONS_NONE = 0x00000000,
|
|
D2D1_PRESENT_OPTIONS_RETAIN_CONTENTS = 0x00000001,
|
|
D2D1_PRESENT_OPTIONS_IMMEDIATELY = 0x00000002,
|
|
}}
|
|
STRUCT!{struct D2D1_RENDER_TARGET_PROPERTIES {
|
|
_type: D2D1_RENDER_TARGET_TYPE,
|
|
pixelFormat: D2D1_PIXEL_FORMAT,
|
|
dpiX: FLOAT,
|
|
dpiY: FLOAT,
|
|
usage: D2D1_RENDER_TARGET_USAGE,
|
|
minLevel: D2D1_FEATURE_LEVEL,
|
|
}}
|
|
STRUCT!{struct D2D1_HWND_RENDER_TARGET_PROPERTIES {
|
|
hwnd: HWND,
|
|
pixelSize: D2D1_SIZE_U,
|
|
presentOptions: D2D1_PRESENT_OPTIONS,
|
|
}}
|
|
ENUM!{enum D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS {
|
|
D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE = 0x00000000,
|
|
D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_GDI_COMPATIBLE = 0x00000001,
|
|
}}
|
|
STRUCT!{struct D2D1_DRAWING_STATE_DESCRIPTION {
|
|
antialiasMode: D2D1_ANTIALIAS_MODE,
|
|
textAntialiasMode: D2D1_TEXT_ANTIALIAS_MODE,
|
|
tag1: D2D1_TAG,
|
|
tag2: D2D1_TAG,
|
|
transform: D2D1_MATRIX_3X2_F,
|
|
}}
|
|
ENUM!{enum D2D1_DC_INITIALIZE_MODE {
|
|
D2D1_DC_INITIALIZE_MODE_COPY = 0,
|
|
D2D1_DC_INITIALIZE_MODE_CLEAR = 1,
|
|
}}
|
|
ENUM!{enum D2D1_DEBUG_LEVEL {
|
|
D2D1_DEBUG_LEVEL_NONE = 0,
|
|
D2D1_DEBUG_LEVEL_ERROR = 1,
|
|
D2D1_DEBUG_LEVEL_WARNING = 2,
|
|
D2D1_DEBUG_LEVEL_INFORMATION = 3,
|
|
}}
|
|
ENUM!{enum D2D1_FACTORY_TYPE {
|
|
D2D1_FACTORY_TYPE_SINGLE_THREADED = 0,
|
|
D2D1_FACTORY_TYPE_MULTI_THREADED = 1,
|
|
}}
|
|
STRUCT!{struct D2D1_FACTORY_OPTIONS {
|
|
debugLevel: D2D1_DEBUG_LEVEL,
|
|
}}
|
|
RIDL!{#[uuid(0x2cd90691, 0x12e2, 0x11dc, 0x9f, 0xed, 0x00, 0x11, 0x43, 0xa0, 0x55, 0xf9)]
|
|
interface ID2D1Resource(ID2D1ResourceVtbl): IUnknown(IUnknownVtbl) {
|
|
fn GetFactory(
|
|
factory: *mut *mut ID2D1Factory,
|
|
) -> (),
|
|
}}
|
|
RIDL!{#[uuid(0x65019f75, 0x8da2, 0x497c, 0xb3, 0x2c, 0xdf, 0xa3, 0x4e, 0x48, 0xed, 0xe6)]
|
|
interface ID2D1Image(ID2D1ImageVtbl): ID2D1Resource(ID2D1ResourceVtbl) {}}
|
|
RIDL!{#[uuid(0xa2296057, 0xea42, 0x4099, 0x98, 0x3b, 0x53, 0x9f, 0xb6, 0x50, 0x54, 0x26)]
|
|
interface ID2D1Bitmap(ID2D1BitmapVtbl): ID2D1Image(ID2D1ImageVtbl) {
|
|
#[fixme] fn GetSize() -> D2D1_SIZE_F,
|
|
#[fixme] fn GetPixelSize() -> D2D1_SIZE_U,
|
|
#[fixme] fn GetPixelFormat() -> D2D1_PIXEL_FORMAT,
|
|
fn GetDpi(
|
|
dpiX: *mut FLOAT,
|
|
dpiY: *mut FLOAT,
|
|
) -> (),
|
|
fn CopyFromBitmap(
|
|
destPoint: *const D2D1_POINT_2U,
|
|
bitmap: *mut ID2D1Bitmap,
|
|
srcRect: *const D2D1_RECT_U,
|
|
) -> HRESULT,
|
|
fn CopyFromRenderTarget(
|
|
destPoint: *const D2D1_POINT_2U,
|
|
renderTarget: *mut ID2D1RenderTarget,
|
|
srcRect: *const D2D1_RECT_U,
|
|
) -> HRESULT,
|
|
fn CopyFromMemory(
|
|
dstRect: *const D2D1_RECT_U,
|
|
srcData: *const c_void,
|
|
pitch: UINT32,
|
|
) -> HRESULT,
|
|
}}
|
|
RIDL!{#[uuid(0x2cd906a7, 0x12e2, 0x11dc, 0x9f, 0xed, 0x00, 0x11, 0x43, 0xa0, 0x55, 0xf9)]
|
|
interface ID2D1GradientStopCollection(ID2D1GradientStopCollectionVtbl):
|
|
ID2D1Resource(ID2D1ResourceVtbl) {
|
|
fn GetGradientStopCount() -> UINT32,
|
|
fn GetGradientStops(
|
|
gradientStops: *mut D2D1_GRADIENT_STOP,
|
|
gradientStopsCount: UINT32,
|
|
) -> (),
|
|
fn GetColorInterpolationGamma() -> D2D1_GAMMA,
|
|
fn GetExtendMode() -> D2D1_EXTEND_MODE,
|
|
}}
|
|
RIDL!{#[uuid(0x2cd906a8, 0x12e2, 0x11dc, 0x9f, 0xed, 0x00, 0x11, 0x43, 0xa0, 0x55, 0xf9)]
|
|
interface ID2D1Brush(ID2D1BrushVtbl): ID2D1Resource(ID2D1ResourceVtbl) {
|
|
fn SetOpacity(
|
|
opacity: FLOAT,
|
|
) -> (),
|
|
fn SetTransform(
|
|
transform: *const D2D1_MATRIX_3X2_F,
|
|
) -> (),
|
|
fn GetOpacity() -> FLOAT,
|
|
fn GetTransform(
|
|
transform: *mut D2D1_MATRIX_3X2_F,
|
|
) -> (),
|
|
}}
|
|
RIDL!{#[uuid(0x2cd906aa, 0x12e2, 0x11dc, 0x9f, 0xed, 0x00, 0x11, 0x43, 0xa0, 0x55, 0xf9)]
|
|
interface ID2D1BitmapBrush(ID2D1BitmapBrushVtbl): ID2D1Brush(ID2D1BrushVtbl) {
|
|
fn SetExtendModeX(
|
|
extendModeX: D2D1_EXTEND_MODE,
|
|
) -> (),
|
|
fn SetExtendModeY(
|
|
extendModeY: D2D1_EXTEND_MODE,
|
|
) -> (),
|
|
fn SetInterpolationMode(
|
|
interpolationMode: D2D1_BITMAP_INTERPOLATION_MODE,
|
|
) -> (),
|
|
fn SetBitmap(
|
|
bitmap: *mut ID2D1Bitmap,
|
|
) -> (),
|
|
fn GetExtendModeX() -> D2D1_EXTEND_MODE,
|
|
fn GetExtendModeY() -> D2D1_EXTEND_MODE,
|
|
fn GetInterpolationMode() -> D2D1_BITMAP_INTERPOLATION_MODE,
|
|
fn GetBitmap(
|
|
bitmap: *mut *mut ID2D1Bitmap,
|
|
) -> (),
|
|
}}
|
|
RIDL!{#[uuid(0x2cd906a9, 0x12e2, 0x11dc, 0x9f, 0xed, 0x00, 0x11, 0x43, 0xa0, 0x55, 0xf9)]
|
|
interface ID2D1SolidColorBrush(ID2D1SolidColorBrushVtbl): ID2D1Brush(ID2D1BrushVtbl) {
|
|
fn SetColor(
|
|
color: *const D2D1_COLOR_F,
|
|
) -> (),
|
|
#[fixme] fn GetColor() -> D2D1_COLOR_F,
|
|
}}
|
|
RIDL!{#[uuid(0x2cd906ab, 0x12e2, 0x11dc, 0x9f, 0xed, 0x00, 0x11, 0x43, 0xa0, 0x55, 0xf9)]
|
|
interface ID2D1LinearGradientBrush(ID2D1LinearGradientBrushVtbl): ID2D1Brush(ID2D1BrushVtbl) {
|
|
fn SetStartPoint(
|
|
startPoint: D2D1_POINT_2F,
|
|
) -> (),
|
|
fn SetEndPoint(
|
|
endPoint: D2D1_POINT_2F,
|
|
) -> (),
|
|
#[fixme] fn GetStartPoint() -> D2D1_POINT_2F,
|
|
#[fixme] fn GetEndPoint() -> D2D1_POINT_2F,
|
|
fn GetGradientStopCollection(
|
|
gradientStopCollection: *mut *mut ID2D1GradientStopCollection,
|
|
) -> (),
|
|
}}
|
|
RIDL!{#[uuid(0x2cd906ac, 0x12e2, 0x11dc, 0x9f, 0xed, 0x00, 0x11, 0x43, 0xa0, 0x55, 0xf9)]
|
|
interface ID2D1RadialGradientBrush(ID2D1RadialGradientBrushVtbl): ID2D1Brush(ID2D1BrushVtbl) {
|
|
fn SetCenter(
|
|
center: D2D1_POINT_2F,
|
|
) -> (),
|
|
fn SetGradientOriginOffset(
|
|
gradientOriginOffset: D2D1_POINT_2F,
|
|
) -> (),
|
|
fn SetRadiusX(
|
|
radiusX: FLOAT,
|
|
) -> (),
|
|
fn SetRadiusY(
|
|
radiusY: FLOAT,
|
|
) -> (),
|
|
#[fixme] fn GetCenter() -> D2D1_POINT_2F,
|
|
#[fixme] fn GetGradientOriginOffset() -> D2D1_POINT_2F,
|
|
fn GetRadiusX() -> FLOAT,
|
|
fn GetRadiusY() -> FLOAT,
|
|
fn GetGradientStopCollection(
|
|
gradientStopCollection: *mut *mut ID2D1GradientStopCollection,
|
|
) -> (),
|
|
}}
|
|
RIDL!{#[uuid(0x2cd9069d, 0x12e2, 0x11dc, 0x9f, 0xed, 0x00, 0x11, 0x43, 0xa0, 0x55, 0xf9)]
|
|
interface ID2D1StrokeStyle(ID2D1StrokeStyleVtbl): ID2D1Resource(ID2D1ResourceVtbl) {
|
|
fn GetStartCap() -> D2D1_CAP_STYLE,
|
|
fn GetEndCap() -> D2D1_CAP_STYLE,
|
|
fn GetDashCap() -> D2D1_CAP_STYLE,
|
|
fn GetMiterLimit() -> FLOAT,
|
|
fn GetLineJoin() -> D2D1_LINE_JOIN,
|
|
fn GetDashOffset() -> FLOAT,
|
|
fn GetDashStyle() -> D2D1_DASH_STYLE,
|
|
fn GetDashesCount() -> UINT32,
|
|
fn GetDashes(
|
|
dashes: *mut FLOAT,
|
|
dashesCount: UINT32,
|
|
) -> (),
|
|
}}
|
|
RIDL!{#[uuid(0x2cd906a1, 0x12e2, 0x11dc, 0x9f, 0xed, 0x00, 0x11, 0x43, 0xa0, 0x55, 0xf9)]
|
|
interface ID2D1Geometry(ID2D1GeometryVtbl): ID2D1Resource(ID2D1ResourceVtbl) {
|
|
fn GetBounds(
|
|
worldTransform: *const D2D1_MATRIX_3X2_F,
|
|
bounds: *mut D2D1_RECT_F,
|
|
) -> HRESULT,
|
|
fn GetWidenedBounds(
|
|
strokeWidth: FLOAT,
|
|
strokeStyle: *mut ID2D1StrokeStyle,
|
|
worldTransform: *const D2D1_MATRIX_3X2_F,
|
|
flatteningTolerance: FLOAT,
|
|
bounds: *mut D2D1_RECT_F,
|
|
) -> HRESULT,
|
|
fn StrokeContainsPoint(
|
|
point: D2D1_POINT_2F,
|
|
strokeWidth: FLOAT,
|
|
strokeStyle: *mut ID2D1StrokeStyle,
|
|
worldTransform: *const D2D1_MATRIX_3X2_F,
|
|
flatteningTolerance: FLOAT,
|
|
contains: *mut BOOL,
|
|
) -> HRESULT,
|
|
fn FillContainsPoint(
|
|
point: D2D1_POINT_2F,
|
|
worldTransform: *const D2D1_MATRIX_3X2_F,
|
|
flatteningTolerance: FLOAT,
|
|
contains: *mut BOOL,
|
|
) -> HRESULT,
|
|
fn CompareWithGeometry(
|
|
inputGeometry: *mut ID2D1Geometry,
|
|
inputGeometryTransform: *const D2D1_MATRIX_3X2_F,
|
|
flatteningTolerance: FLOAT,
|
|
relation: *mut D2D1_GEOMETRY_RELATION,
|
|
) -> HRESULT,
|
|
fn Simplify(
|
|
simplificationOption: D2D1_GEOMETRY_SIMPLIFICATION_OPTION,
|
|
worldTransform: *const D2D1_MATRIX_3X2_F,
|
|
flatteningTolerance: FLOAT,
|
|
geometrySink: *mut ID2D1SimplifiedGeometrySink,
|
|
) -> HRESULT,
|
|
fn Tessellate(
|
|
worldTransform: *const D2D1_MATRIX_3X2_F,
|
|
flatteningTolerance: FLOAT,
|
|
tessellationSink: *mut ID2D1TessellationSink,
|
|
) -> HRESULT,
|
|
fn CombineWithGeometry(
|
|
inputGeometry: *mut ID2D1Geometry,
|
|
combineMode: D2D1_COMBINE_MODE,
|
|
inputGeometryTransform: *const D2D1_MATRIX_3X2_F,
|
|
flatteningTolerance: FLOAT,
|
|
geometrySink: *mut ID2D1SimplifiedGeometrySink,
|
|
) -> HRESULT,
|
|
fn Outline(
|
|
worldTransform: *const D2D1_MATRIX_3X2_F,
|
|
flatteningTolerance: FLOAT,
|
|
geometrySink: *mut ID2D1SimplifiedGeometrySink,
|
|
) -> HRESULT,
|
|
fn ComputeArea(
|
|
worldTransform: *const D2D1_MATRIX_3X2_F,
|
|
flatteningTolerance: FLOAT,
|
|
area: *mut FLOAT,
|
|
) -> HRESULT,
|
|
fn ComputeLength(
|
|
worldTransform: *const D2D1_MATRIX_3X2_F,
|
|
flatteningTolerance: FLOAT,
|
|
length: *mut FLOAT,
|
|
) -> HRESULT,
|
|
fn ComputePointAtLength(
|
|
length: FLOAT,
|
|
worldTransform: *const D2D1_MATRIX_3X2_F,
|
|
flatteningTolerance: FLOAT,
|
|
point: *mut D2D1_POINT_2F,
|
|
unitTangentVector: *mut D2D1_POINT_2F,
|
|
) -> HRESULT,
|
|
fn Widen(
|
|
strokeWidth: FLOAT,
|
|
strokeStyle: *mut ID2D1StrokeStyle,
|
|
worldTransform: *const D2D1_MATRIX_3X2_F,
|
|
flatteningTolerance: FLOAT,
|
|
geometrySink: *mut ID2D1SimplifiedGeometrySink,
|
|
) -> HRESULT,
|
|
}}
|
|
RIDL!{#[uuid(0x2cd906a2, 0x12e2, 0x11dc, 0x9f, 0xed, 0x00, 0x11, 0x43, 0xa0, 0x55, 0xf9)]
|
|
interface ID2D1RectangleGeometry(ID2D1RectangleGeometryVtbl): ID2D1Geometry(ID2D1GeometryVtbl) {
|
|
fn GetRect(
|
|
rect: *mut D2D1_RECT_F,
|
|
) -> (),
|
|
}}
|
|
RIDL!{#[uuid(0x2cd906a3, 0x12e2, 0x11dc, 0x9f, 0xed, 0x00, 0x11, 0x43, 0xa0, 0x55, 0xf9)]
|
|
interface ID2D1RoundedRectangleGeometry(ID2D1RoundedRectangleGeometryVtbl):
|
|
ID2D1Geometry(ID2D1GeometryVtbl) {
|
|
fn GetRoundedRect(
|
|
roundedRect: *mut D2D1_ROUNDED_RECT,
|
|
) -> (),
|
|
}}
|
|
RIDL!{#[uuid(0x2cd906a4, 0x12e2, 0x11dc, 0x9f, 0xed, 0x00, 0x11, 0x43, 0xa0, 0x55, 0xf9)]
|
|
interface ID2D1EllipseGeometry(ID2D1EllipseGeometryVtbl): ID2D1Geometry(ID2D1GeometryVtbl) {
|
|
fn GetEllipse(
|
|
ellipse: *mut D2D1_ELLIPSE,
|
|
) -> (),
|
|
}}
|
|
RIDL!{#[uuid(0x2cd906a6, 0x12e2, 0x11dc, 0x9f, 0xed, 0x00, 0x11, 0x43, 0xa0, 0x55, 0xf9)]
|
|
interface ID2D1GeometryGroup(ID2D1GeometryGroupVtbl): ID2D1Geometry(ID2D1GeometryVtbl) {
|
|
fn GetFillMode() -> D2D1_FILL_MODE,
|
|
fn GetSourceGeometryCount() -> UINT32,
|
|
fn GetSourceGeometries(
|
|
geometries: *mut *mut ID2D1Geometry,
|
|
geometriesCount: UINT32,
|
|
) -> (),
|
|
}}
|
|
RIDL!{#[uuid(0x2cd906bb, 0x12e2, 0x11dc, 0x9f, 0xed, 0x00, 0x11, 0x43, 0xa0, 0x55, 0xf9)]
|
|
interface ID2D1TransformedGeometry(ID2D1TransformedGeometryVtbl):
|
|
ID2D1Geometry(ID2D1GeometryVtbl) {
|
|
fn GetSourceGeometry(
|
|
sourceGeometry: *mut *mut ID2D1Geometry,
|
|
) -> (),
|
|
fn GetTransform(
|
|
transform: *mut D2D1_MATRIX_3X2_F,
|
|
) -> (),
|
|
}}
|
|
RIDL!{#[uuid(0x2cd9069e, 0x12e2, 0x11dc, 0x9f, 0xed, 0x00, 0x11, 0x43, 0xa0, 0x55, 0xf9)]
|
|
interface ID2D1SimplifiedGeometrySink(ID2D1SimplifiedGeometrySinkVtbl): IUnknown(IUnknownVtbl) {
|
|
fn SetFillMode(
|
|
fillMode: D2D1_FILL_MODE,
|
|
) -> (),
|
|
fn SetSegmentFlags(
|
|
vertexFlags: D2D1_PATH_SEGMENT,
|
|
) -> (),
|
|
fn BeginFigure(
|
|
startPoint: D2D1_POINT_2F,
|
|
figureBegin: D2D1_FIGURE_BEGIN,
|
|
) -> (),
|
|
fn AddLines(
|
|
points: *const D2D1_POINT_2F,
|
|
pointsCount: UINT32,
|
|
) -> (),
|
|
fn AddBeziers(
|
|
beziers: *const D2D1_BEZIER_SEGMENT,
|
|
beziersCount: UINT32,
|
|
) -> (),
|
|
fn EndFigure(
|
|
figureEnd: D2D1_FIGURE_END,
|
|
) -> (),
|
|
fn Close() -> HRESULT,
|
|
}}
|
|
RIDL!{#[uuid(0x2cd9069f, 0x12e2, 0x11dc, 0x9f, 0xed, 0x00, 0x11, 0x43, 0xa0, 0x55, 0xf9)]
|
|
interface ID2D1GeometrySink(ID2D1GeometrySinkVtbl):
|
|
ID2D1SimplifiedGeometrySink(ID2D1SimplifiedGeometrySinkVtbl) {
|
|
fn AddLine(
|
|
point: D2D1_POINT_2F,
|
|
) -> (),
|
|
fn AddBezier(
|
|
bezier: *const D2D1_BEZIER_SEGMENT,
|
|
) -> (),
|
|
fn AddQuadraticBezier(
|
|
bezier: *const D2D1_QUADRATIC_BEZIER_SEGMENT,
|
|
) -> (),
|
|
fn AddQuadraticBeziers(
|
|
beziers: *const D2D1_QUADRATIC_BEZIER_SEGMENT,
|
|
beziersCount: UINT32,
|
|
) -> (),
|
|
fn AddArc(
|
|
arc: *const D2D1_ARC_SEGMENT,
|
|
) -> (),
|
|
}}
|
|
RIDL!{#[uuid(0x2cd906c1, 0x12e2, 0x11dc, 0x9f, 0xed, 0x00, 0x11, 0x43, 0xa0, 0x55, 0xf9)]
|
|
interface ID2D1TessellationSink(ID2D1TessellationSinkVtbl): IUnknown(IUnknownVtbl) {
|
|
fn AddTriangles(
|
|
triangles: *const D2D1_TRIANGLE,
|
|
triangleCount: UINT32,
|
|
) -> (),
|
|
fn Close() -> HRESULT,
|
|
}}
|
|
RIDL!{#[uuid(0x2cd906a5, 0x12e2, 0x11dc, 0x9f, 0xed, 0x00, 0x11, 0x43, 0xa0, 0x55, 0xf9)]
|
|
interface ID2D1PathGeometry(ID2D1PathGeometryVtbl): ID2D1Geometry(ID2D1GeometryVtbl) {
|
|
fn Open(
|
|
geometrySink: *mut *mut ID2D1GeometrySink,
|
|
) -> HRESULT,
|
|
fn Stream(
|
|
geometrySink: *mut ID2D1GeometrySink,
|
|
) -> HRESULT,
|
|
fn GetSegmentCount(
|
|
count: *mut UINT32,
|
|
) -> HRESULT,
|
|
fn GetFigureCount(
|
|
count: *mut UINT32,
|
|
) -> HRESULT,
|
|
}}
|
|
RIDL!{#[uuid(0x2cd906c2, 0x12e2, 0x11dc, 0x9f, 0xed, 0x00, 0x11, 0x43, 0xa0, 0x55, 0xf9)]
|
|
interface ID2D1Mesh(ID2D1MeshVtbl): ID2D1Resource(ID2D1ResourceVtbl) {
|
|
fn Open(
|
|
tessellationSink: *mut *mut ID2D1TessellationSink,
|
|
) -> HRESULT,
|
|
}}
|
|
RIDL!{#[uuid(0x2cd9069b, 0x12e2, 0x11dc, 0x9f, 0xed, 0x00, 0x11, 0x43, 0xa0, 0x55, 0xf9)]
|
|
interface ID2D1Layer(ID2D1LayerVtbl): ID2D1Resource(ID2D1ResourceVtbl) {
|
|
#[fixme] fn GetSize() -> D2D1_SIZE_F,
|
|
}}
|
|
RIDL!{#[uuid(0x28506e39, 0xebf6, 0x46a1, 0xbb, 0x47, 0xfd, 0x85, 0x56, 0x5a, 0xb9, 0x57)]
|
|
interface ID2D1DrawingStateBlock(ID2D1DrawingStateBlockVtbl): ID2D1Resource(ID2D1ResourceVtbl) {
|
|
fn GetDescription(
|
|
stateDescription: *mut D2D1_DRAWING_STATE_DESCRIPTION,
|
|
) -> (),
|
|
fn SetDescription(
|
|
stateDescription: *const D2D1_DRAWING_STATE_DESCRIPTION,
|
|
) -> (),
|
|
fn SetTextRenderingParams(
|
|
textRenderingParams: *mut IDWriteRenderingParams,
|
|
) -> (),
|
|
fn GetTextRenderingParams(
|
|
textRenderingParams: *mut *mut IDWriteRenderingParams,
|
|
) -> (),
|
|
}}
|
|
RIDL!{#[uuid(0x2cd90694, 0x12e2, 0x11dc, 0x9f, 0xed, 0x00, 0x11, 0x43, 0xa0, 0x55, 0xf9)]
|
|
interface ID2D1RenderTarget(ID2D1RenderTargetVtbl): ID2D1Resource(ID2D1ResourceVtbl) {
|
|
fn CreateBitmap(
|
|
size: D2D1_SIZE_U,
|
|
srcData: *const c_void,
|
|
pitch: UINT32,
|
|
bitmapProperties: *const D2D1_BITMAP_PROPERTIES,
|
|
bitmap: *mut *mut ID2D1Bitmap,
|
|
) -> HRESULT,
|
|
fn CreateBitmapFromWicBitmap(
|
|
wicBitmapSource: *mut IWICBitmapSource,
|
|
bitmapProperties: *const D2D1_BITMAP_PROPERTIES,
|
|
bitmap: *mut *mut ID2D1Bitmap,
|
|
) -> HRESULT,
|
|
fn CreateSharedBitmap(
|
|
riid: REFIID,
|
|
data: *const c_void,
|
|
bitmapProperties: *const D2D1_BITMAP_PROPERTIES,
|
|
bitmap: *mut *mut ID2D1Bitmap,
|
|
) -> HRESULT,
|
|
fn CreateBitmapBrush(
|
|
bitmap: *mut ID2D1Bitmap,
|
|
bitmapBrushProperties: *const D2D1_BITMAP_BRUSH_PROPERTIES,
|
|
brushProperties: *const D2D1_BRUSH_PROPERTIES,
|
|
bitmapBrush: *mut *mut ID2D1BitmapBrush,
|
|
) -> HRESULT,
|
|
fn CreateSolidColorBrush(
|
|
color: *const D2D1_COLOR_F,
|
|
brushProperties: *const D2D1_BRUSH_PROPERTIES,
|
|
solidColorBrush: *mut *mut ID2D1SolidColorBrush,
|
|
) -> HRESULT,
|
|
fn CreateGradientStopCollection(
|
|
gradientStops: *const D2D1_GRADIENT_STOP,
|
|
gradientStopsCount: UINT32,
|
|
colorInterpolationGamma: D2D1_GAMMA,
|
|
extendMode: D2D1_EXTEND_MODE,
|
|
gradientStopCollection: *mut *mut ID2D1GradientStopCollection,
|
|
) -> HRESULT,
|
|
fn CreateLinearGradientBrush(
|
|
linearGradientBrushProperties: *const D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES,
|
|
brushProperties: *const D2D1_BRUSH_PROPERTIES,
|
|
gradientStopCollection: *mut ID2D1GradientStopCollection,
|
|
linearGradientBrush: *mut *mut ID2D1LinearGradientBrush,
|
|
) -> HRESULT,
|
|
fn CreateRadialGradientBrush(
|
|
radialGradientBrushProperties: *const D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES,
|
|
brushProperties: *const D2D1_BRUSH_PROPERTIES,
|
|
gradientStopCollection: *mut ID2D1GradientStopCollection,
|
|
radialGradientBrush: *mut *mut ID2D1RadialGradientBrush,
|
|
) -> HRESULT,
|
|
fn CreateCompatibleRenderTarget(
|
|
desiredSize: *const D2D1_SIZE_F,
|
|
desiredPixelSize: *const D2D1_SIZE_U,
|
|
desiredFormat: *const D2D1_PIXEL_FORMAT,
|
|
options: D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS,
|
|
bitmapRenderTarget: *mut *mut ID2D1BitmapRenderTarget,
|
|
) -> HRESULT,
|
|
fn CreateLayer(
|
|
size: *const D2D1_SIZE_F,
|
|
layer: *mut *mut ID2D1Layer,
|
|
) -> HRESULT,
|
|
fn CreateMesh(
|
|
mesh: *mut *mut ID2D1Mesh,
|
|
) -> HRESULT,
|
|
fn DrawLine(
|
|
point0: D2D1_POINT_2F,
|
|
point1: D2D1_POINT_2F,
|
|
brush: *mut ID2D1Brush,
|
|
strokeWidth: FLOAT,
|
|
strokeStype: *mut ID2D1StrokeStyle,
|
|
) -> (),
|
|
fn DrawRectangle(
|
|
rect: *const D2D1_RECT_F,
|
|
brush: *mut ID2D1Brush,
|
|
strokeWidth: FLOAT,
|
|
strokeStyle: *mut ID2D1StrokeStyle,
|
|
) -> (),
|
|
fn FillRectangle(
|
|
rect: *const D2D1_RECT_F,
|
|
brush: *mut ID2D1Brush,
|
|
) -> (),
|
|
fn DrawRoundedRectangle(
|
|
roundedRect: *const D2D1_ROUNDED_RECT,
|
|
brush: *mut ID2D1Brush,
|
|
strokeWidth: FLOAT,
|
|
strokeStyle: *mut ID2D1StrokeStyle,
|
|
) -> (),
|
|
fn FillRoundedRectangle(
|
|
roundedRect: *const D2D1_ROUNDED_RECT,
|
|
brush: *mut ID2D1Brush,
|
|
) -> (),
|
|
fn DrawEllipse(
|
|
ellipse: *const D2D1_ELLIPSE,
|
|
brush: *mut ID2D1Brush,
|
|
strokeWidth: FLOAT,
|
|
strokeStyle: *mut ID2D1StrokeStyle,
|
|
) -> (),
|
|
fn FillEllipse(
|
|
ellipse: *const D2D1_ELLIPSE,
|
|
brush: *mut ID2D1Brush,
|
|
) -> (),
|
|
fn DrawGeometry(
|
|
geometry: *mut ID2D1Geometry,
|
|
brush: *mut ID2D1Brush,
|
|
strokeWidth: FLOAT,
|
|
strokeStyle: *mut ID2D1StrokeStyle,
|
|
) -> (),
|
|
fn FillGeometry(
|
|
geometry: *mut ID2D1Geometry,
|
|
brush: *mut ID2D1Brush,
|
|
opacityBrush: *mut ID2D1Brush,
|
|
) -> (),
|
|
fn FillMesh(
|
|
mesh: *mut ID2D1Mesh,
|
|
brush: *const ID2D1Brush,
|
|
) -> (),
|
|
fn FillOpacityMask(
|
|
opacityMask: *mut ID2D1Bitmap,
|
|
brush: *mut ID2D1Brush,
|
|
content: D2D1_OPACITY_MASK_CONTENT,
|
|
destinationRectangle: *const D2D1_RECT_F,
|
|
sourceRectangle: *const D2D1_RECT_F,
|
|
) -> (),
|
|
fn DrawBitmap(
|
|
bitmap: *mut ID2D1Bitmap,
|
|
destinationRectangle: *const D2D1_RECT_F,
|
|
opacity: FLOAT,
|
|
interpolationMode: D2D1_BITMAP_INTERPOLATION_MODE,
|
|
sourceRectangle: *const D2D1_RECT_F,
|
|
) -> (),
|
|
fn DrawText(
|
|
string: *const WCHAR,
|
|
stringLength: UINT32,
|
|
textFormat: *mut IDWriteTextFormat,
|
|
layoutRect: *const D2D1_RECT_F,
|
|
defaultForegroundBrush: *mut ID2D1Brush,
|
|
options: D2D1_DRAW_TEXT_OPTIONS,
|
|
measuringMode: DWRITE_MEASURING_MODE,
|
|
) -> (),
|
|
fn DrawTextLayout(
|
|
origin: D2D1_POINT_2F,
|
|
textLayout: *mut IDWriteTextLayout,
|
|
defaultForegroundBrush: *mut ID2D1Brush,
|
|
options: D2D1_DRAW_TEXT_OPTIONS,
|
|
) -> (),
|
|
fn DrawGlyphRun(
|
|
baselineOrigin: D2D1_POINT_2F,
|
|
glyphRun: *const DWRITE_GLYPH_RUN,
|
|
foregroundBrush: *mut ID2D1Brush,
|
|
measuringMode: DWRITE_MEASURING_MODE,
|
|
) -> (),
|
|
fn SetTransform(
|
|
transform: *const D2D1_MATRIX_3X2_F,
|
|
) -> (),
|
|
fn GetTransform(
|
|
transform: *mut D2D1_MATRIX_3X2_F,
|
|
) -> (),
|
|
fn SetAntialiasMode(
|
|
antialiasMode: D2D1_ANTIALIAS_MODE,
|
|
) -> (),
|
|
fn GetAntialiasMode() -> D2D1_ANTIALIAS_MODE,
|
|
fn SetTextAntialiasMode(
|
|
textAntialiasMode: D2D1_TEXT_ANTIALIAS_MODE,
|
|
) -> (),
|
|
fn GetTextAntialiasMode() -> D2D1_TEXT_ANTIALIAS_MODE,
|
|
fn SetTextRenderingParams(
|
|
textRenderingParams: *mut IDWriteRenderingParams,
|
|
) -> (),
|
|
fn GetTextRenderingParams(
|
|
textRenderingParams: *mut *mut IDWriteRenderingParams,
|
|
) -> (),
|
|
fn SetTags(
|
|
tag1: D2D1_TAG,
|
|
tag2: D2D1_TAG,
|
|
) -> (),
|
|
fn GetTags(
|
|
tag1: *mut D2D1_TAG,
|
|
tag2: *mut D2D1_TAG,
|
|
) -> (),
|
|
fn PushLayer(
|
|
layerParameters: *const D2D1_LAYER_PARAMETERS,
|
|
layer: *mut ID2D1Layer,
|
|
) -> (),
|
|
fn PopLayer() -> (),
|
|
fn Flush(
|
|
tag1: *mut D2D1_TAG,
|
|
tag2: *mut D2D1_TAG,
|
|
) -> HRESULT,
|
|
fn SaveDrawingState(
|
|
drawingStateBlock: *mut ID2D1DrawingStateBlock,
|
|
) -> (),
|
|
fn RestoreDrawingState(
|
|
drawingStateBlock: *mut ID2D1DrawingStateBlock,
|
|
) -> (),
|
|
fn PushAxisAlignedClip(
|
|
clipRect: *const D2D1_RECT_F,
|
|
antialiasMode: D2D1_ANTIALIAS_MODE,
|
|
) -> (),
|
|
fn PopAxisAlignedClip() -> (),
|
|
fn Clear(
|
|
clearColor: *const D2D1_COLOR_F,
|
|
) -> (),
|
|
fn BeginDraw() -> (),
|
|
fn EndDraw(
|
|
tag1: *mut D2D1_TAG,
|
|
tag2: *mut D2D1_TAG,
|
|
) -> HRESULT,
|
|
#[fixme] fn GetPixelFormat() -> D2D1_PIXEL_FORMAT,
|
|
fn SetDpi(
|
|
dpiX: FLOAT,
|
|
dpiY: FLOAT,
|
|
) -> (),
|
|
fn GetDpi(
|
|
dpiX: *mut FLOAT,
|
|
dpiY: *mut FLOAT,
|
|
) -> (),
|
|
#[fixme] fn GetSize() -> D2D1_SIZE_F,
|
|
#[fixme] fn GetPixelSize() -> D2D1_SIZE_U,
|
|
fn GetMaximumBitmapSize() -> UINT32,
|
|
fn IsSupported(
|
|
renderTargetProperties: *const D2D1_RENDER_TARGET_PROPERTIES,
|
|
) -> BOOL,
|
|
}}
|
|
RIDL!{#[uuid(0x2cd90695, 0x12e2, 0x11dc, 0x9f, 0xed, 0x00, 0x11, 0x43, 0xa0, 0x55, 0xf9)]
|
|
interface ID2D1BitmapRenderTarget(ID2D1BitmapRenderTargetVtbl):
|
|
ID2D1RenderTarget(ID2D1RenderTargetVtbl) {
|
|
fn GetBitmap(
|
|
bitmap: *mut *mut ID2D1Bitmap,
|
|
) -> HRESULT,
|
|
}}
|
|
RIDL!{#[uuid(0x2cd90698, 0x12e2, 0x11dc, 0x9f, 0xed, 0x00, 0x11, 0x43, 0xa0, 0x55, 0xf9)]
|
|
interface ID2D1HwndRenderTarget(ID2D1HwndRenderTargetVtbl):
|
|
ID2D1RenderTarget(ID2D1RenderTargetVtbl) {
|
|
fn CheckWindowState() -> D2D1_WINDOW_STATE,
|
|
fn Resize(
|
|
pixelSize: *const D2D1_SIZE_U,
|
|
) -> HRESULT,
|
|
fn GetHwnd() -> HWND,
|
|
}}
|
|
RIDL!{#[uuid(0xe0db51c3, 0x6f77, 0x4bae, 0xb3, 0xd5, 0xe4, 0x75, 0x09, 0xb3, 0x58, 0x38)]
|
|
interface ID2D1GdiInteropRenderTarget(ID2D1GdiInteropRenderTargetVtbl): IUnknown(IUnknownVtbl) {
|
|
fn GetDC(
|
|
mode: D2D1_DC_INITIALIZE_MODE,
|
|
hdc: *mut HDC,
|
|
) -> HRESULT,
|
|
fn ReleaseDC(
|
|
update: *const RECT,
|
|
) -> HRESULT,
|
|
}}
|
|
RIDL!{#[uuid(0x1c51bc64, 0xde61, 0x46fd, 0x98, 0x99, 0x63, 0xa5, 0xd8, 0xf0, 0x39, 0x50)]
|
|
interface ID2D1DCRenderTarget(ID2D1DCRenderTargetVtbl): ID2D1RenderTarget(ID2D1RenderTargetVtbl) {
|
|
fn BindDC(
|
|
hDC: HDC,
|
|
pSubRect: *const RECT,
|
|
) -> HRESULT,
|
|
}}
|
|
RIDL!{#[uuid(0x06152247, 0x6f50, 0x465a, 0x92, 0x45, 0x11, 0x8b, 0xfd, 0x3b, 0x60, 0x07)]
|
|
interface ID2D1Factory(ID2D1FactoryVtbl): IUnknown(IUnknownVtbl) {
|
|
fn ReloadSystemMetrics() -> HRESULT,
|
|
fn GetDesktopDpi(
|
|
dpiX: *mut FLOAT,
|
|
dpiY: *mut FLOAT,
|
|
) -> (),
|
|
fn CreateRectangleGeometry(
|
|
rectangle: *const D2D1_RECT_F,
|
|
rectangleGeometry: *mut *mut ID2D1RectangleGeometry,
|
|
) -> HRESULT,
|
|
fn CreateRoundedRectangleGeometry(
|
|
roundedRectangle: *const D2D1_ROUNDED_RECT,
|
|
roundedRectangleGeometry: *mut *mut ID2D1RoundedRectangleGeometry,
|
|
) -> HRESULT,
|
|
fn CreateEllipseGeometry(
|
|
ellipse: *const D2D1_ELLIPSE,
|
|
ellipseGeometry: *mut *mut ID2D1EllipseGeometry,
|
|
) -> HRESULT,
|
|
fn CreateGeometryGroup(
|
|
fillMode: D2D1_FILL_MODE,
|
|
geometries: *mut *mut ID2D1Geometry,
|
|
geometriesCount: UINT32,
|
|
geometryGroup: *mut *mut ID2D1GeometryGroup,
|
|
) -> HRESULT,
|
|
fn CreateTransformedGeometry(
|
|
sourceGeometry: *mut ID2D1Geometry,
|
|
transform: *const D2D1_MATRIX_3X2_F,
|
|
transformedGeometry: *mut *mut ID2D1TransformedGeometry,
|
|
) -> HRESULT,
|
|
fn CreatePathGeometry(
|
|
pathGeometry: *mut *mut ID2D1PathGeometry,
|
|
) -> HRESULT,
|
|
fn CreateStrokeStyle(
|
|
strokeStyleProperties: *const D2D1_STROKE_STYLE_PROPERTIES,
|
|
dashes: *const FLOAT,
|
|
dashesCount: UINT32,
|
|
strokeStyle: *mut *mut ID2D1StrokeStyle,
|
|
) -> HRESULT,
|
|
fn CreateDrawingStateBlock(
|
|
drawingStateDescription: *const D2D1_DRAWING_STATE_DESCRIPTION,
|
|
textRenderingParams: *mut IDWriteRenderingParams,
|
|
drawingStateBlock: *mut *mut ID2D1DrawingStateBlock,
|
|
) -> HRESULT,
|
|
fn CreateWicBitmapRenderTarget(
|
|
target: *mut IWICBitmap,
|
|
renderTargetProperties: *const D2D1_RENDER_TARGET_PROPERTIES,
|
|
renderTarget: *mut *mut ID2D1RenderTarget,
|
|
) -> HRESULT,
|
|
fn CreateHwndRenderTarget(
|
|
renderTargetProperties: *const D2D1_RENDER_TARGET_PROPERTIES,
|
|
hwndRenderTargetProperties: *const D2D1_HWND_RENDER_TARGET_PROPERTIES,
|
|
hwndRenderTarget: *mut *mut ID2D1HwndRenderTarget,
|
|
) -> HRESULT,
|
|
fn CreateDxgiSurfaceRenderTarget(
|
|
dxgiSurface: *mut IDXGISurface,
|
|
renderTargetProperties: *const D2D1_RENDER_TARGET_PROPERTIES,
|
|
renderTarget: *mut *mut ID2D1RenderTarget,
|
|
) -> HRESULT,
|
|
fn CreateDCRenderTarget(
|
|
renderTargetProperties: *const D2D1_RENDER_TARGET_PROPERTIES,
|
|
dcRenderTarget: *mut *mut ID2D1DCRenderTarget,
|
|
) -> HRESULT,
|
|
}}
|
|
extern "system" {
|
|
pub fn D2D1CreateFactory(
|
|
factoryType: D2D1_FACTORY_TYPE,
|
|
riid: REFIID,
|
|
pFactoryOptions: *const D2D1_FACTORY_OPTIONS,
|
|
ppIFactory: *mut *mut c_void,
|
|
) -> HRESULT;
|
|
pub fn D2D1MakeRotateMatrix(
|
|
angle: FLOAT,
|
|
center: D2D1_POINT_2F,
|
|
matrix: *mut D2D1_MATRIX_3X2_F,
|
|
);
|
|
pub fn D2D1MakeSkewMatrix(
|
|
angleX: FLOAT,
|
|
angleY: FLOAT,
|
|
center: D2D1_POINT_2F,
|
|
matrix: *mut D2D1_MATRIX_3X2_F,
|
|
);
|
|
pub fn D2D1IsMatrixInvertible(
|
|
matrix: *const D2D1_MATRIX_3X2_F,
|
|
) -> BOOL;
|
|
pub fn D2D1InvertMatrix(
|
|
matrix: *mut D2D1_MATRIX_3X2_F,
|
|
) -> BOOL;
|
|
pub fn D2D1ComputeMaximumScaleFactor(
|
|
matrix: *const D2D1_MATRIX_3X2_F,
|
|
) -> FLOAT;
|
|
}
|