d2d1_private.h File Reference

#include "wine/debug.h"
#include "wine/list.h"
#include <assert.h>
#include <limits.h>
#include <stdint.h>
#include <stdbool.h>
#include <math.h>
#include "d2d1_3.h"
#include "d2d1effectauthor.h"
#include "d3d11_1.h"
#include "dwrite_2.h"

Include dependency graph for d2d1_private.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	d2d_settings
struct	d2d_clip_stack
struct	d2d_error_state
struct	d2d_shape_resources
struct	d2d_brush_cb
struct	d2d_ps_cb
struct	d2d_vec4
struct	d2d_vs_cb
struct	d2d_device_context_ops
struct	d2d_indexed_objects
struct	d2d_device_context
struct	d2d_wic_render_target
struct	d2d_dc_render_target
struct	d2d_hwnd_render_target
struct	d2d_bitmap_render_target
struct	d2d_gradient
struct	d2d_brush
struct	d2d_stroke_style
struct	d2d_layer
struct	d2d_mesh
struct	d2d_bitmap
struct	d2d_state_block
struct	d2d_curve_vertex
struct	d2d_face
struct	d2d_outline_vertex
struct	d2d_curve_outline_vertex
struct	d2d_geometry
struct	d2d_device
struct	d2d_effect_context
struct	d2d_effect_property
struct	d2d_effect_properties
struct	d2d_effect_registration
struct	d2d_factory
struct	d2d_transform
struct	d2d_render_info
struct	d2d_transform_node
struct	d2d_transform_node_connection
struct	d2d_transform_graph
struct	d2d_effect
struct	d2d_vertex_buffer
struct	d2d_command_list

Macros
#define	COBJMACROS

Enumerations
enum	d2d_brush_type {   D2D_BRUSH_TYPE_SOLID , D2D_BRUSH_TYPE_LINEAR , D2D_BRUSH_TYPE_RADIAL , D2D_BRUSH_TYPE_BITMAP ,   D2D_BRUSH_TYPE_IMAGE , D2D_BRUSH_TYPE_COUNT }
enum	d2d_shape_type {   D2D_SHAPE_TYPE_OUTLINE , D2D_SHAPE_TYPE_BEZIER_OUTLINE , D2D_SHAPE_TYPE_ARC_OUTLINE , D2D_SHAPE_TYPE_TRIANGLE ,   D2D_SHAPE_TYPE_CURVE , D2D_SHAPE_TYPE_COUNT }
enum	d2d_device_context_sampler_limits { D2D_SAMPLER_INTERPOLATION_MODE_COUNT = 2 , D2D_SAMPLER_EXTEND_MODE_COUNT = 3 }
enum	d2d_device_context_target_type { D2D_TARGET_UNKNOWN = 0 , D2D_TARGET_BITMAP , D2D_TARGET_COMMAND_LIST }
enum	d2d_geometry_state {   D2D_GEOMETRY_STATE_INITIAL = 0 , D2D_GEOMETRY_STATE_ERROR , D2D_GEOMETRY_STATE_OPEN , D2D_GEOMETRY_STATE_CLOSED ,   D2D_GEOMETRY_STATE_FIGURE }
enum	d2d_render_info_mask { D2D_RENDER_INFO_PIXEL_SHADER = 0x1 }
enum	d2d_command_list_state { D2D_COMMAND_LIST_STATE_INITIAL = 0 , D2D_COMMAND_LIST_STATE_ERROR , D2D_COMMAND_LIST_STATE_OPEN , D2D_COMMAND_LIST_STATE_CLOSED }

Functions
HRESULT	d2d_d3d_create_render_target (struct d2d_device *device, IDXGISurface *surface, IUnknown *outer_unknown, const struct d2d_device_context_ops *ops, const D2D1_RENDER_TARGET_PROPERTIES *desc, void **render_target)
static BOOL	d2d_device_context_is_dxgi_target (const struct d2d_device_context *context)
HRESULT	d2d_wic_render_target_init (struct d2d_wic_render_target *render_target, ID2D1Factory1 *factory, ID3D10Device1 *d3d_device, IWICBitmap *bitmap, const D2D1_RENDER_TARGET_PROPERTIES *desc)
HRESULT	d2d_dc_render_target_init (struct d2d_dc_render_target *render_target, ID2D1Factory1 *factory, ID3D10Device1 *d3d_device, const D2D1_RENDER_TARGET_PROPERTIES *desc)
HRESULT	d2d_hwnd_render_target_init (struct d2d_hwnd_render_target *render_target, ID2D1Factory1 *factory, ID3D10Device1 *d3d_device, const D2D1_RENDER_TARGET_PROPERTIES *desc, const D2D1_HWND_RENDER_TARGET_PROPERTIES *hwnd_desc)
HRESULT	d2d_bitmap_render_target_init (struct d2d_bitmap_render_target *render_target, const struct d2d_device_context *parent_target, const D2D1_SIZE_F *size, const D2D1_SIZE_U *pixel_size, const D2D1_PIXEL_FORMAT *format, D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS options)
HRESULT	d2d_gradient_create (ID2D1Factory *factory, ID3D11Device1 *device, const D2D1_GRADIENT_STOP *stops, UINT32 stop_count, D2D1_GAMMA gamma, D2D1_EXTEND_MODE extend_mode, struct d2d_gradient **gradient)
HRESULT	d2d_solid_color_brush_create (ID2D1Factory *factory, const D2D1_COLOR_F *color, const D2D1_BRUSH_PROPERTIES *desc, struct d2d_brush **brush)
HRESULT	d2d_linear_gradient_brush_create (ID2D1Factory *factory, const D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES *gradient_desc, const D2D1_BRUSH_PROPERTIES *brush_desc, ID2D1GradientStopCollection *gradient, struct d2d_brush **brush)
HRESULT	d2d_radial_gradient_brush_create (ID2D1Factory *factory, const D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES *gradient_desc, const D2D1_BRUSH_PROPERTIES *brush_desc, ID2D1GradientStopCollection *gradient, struct d2d_brush **brush)
HRESULT	d2d_bitmap_brush_create (ID2D1Factory *factory, ID2D1Bitmap *bitmap, const D2D1_BITMAP_BRUSH_PROPERTIES1 *bitmap_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc, struct d2d_brush **brush)
HRESULT	d2d_image_brush_create (ID2D1Factory *factory, ID2D1Image *image, const D2D1_IMAGE_BRUSH_PROPERTIES *image_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc, struct d2d_brush **brush)
void	d2d_brush_bind_resources (struct d2d_brush *brush, struct d2d_device_context *context, unsigned int brush_idx)
BOOL	d2d_brush_fill_cb (const struct d2d_brush *brush, struct d2d_brush_cb *cb)
struct d2d_brush *	unsafe_impl_from_ID2D1Brush (ID2D1Brush *iface)
HRESULT	d2d_stroke_style_init (struct d2d_stroke_style *style, ID2D1Factory *factory, const D2D1_STROKE_STYLE_PROPERTIES1 *desc, const float *dashes, UINT32 dash_count)
struct d2d_stroke_style *	unsafe_impl_from_ID2D1StrokeStyle (ID2D1StrokeStyle *iface)
HRESULT	d2d_layer_create (ID2D1Factory *factory, const D2D1_SIZE_F *size, struct d2d_layer **layer)
HRESULT	d2d_mesh_create (ID2D1Factory *factory, struct d2d_mesh **mesh)
HRESULT	d2d_bitmap_create (struct d2d_device_context *context, D2D1_SIZE_U size, const void *src_data, UINT32 pitch, const D2D1_BITMAP_PROPERTIES1 *desc, struct d2d_bitmap **bitmap)
HRESULT	d2d_bitmap_create_shared (struct d2d_device_context *context, REFIID iid, void *data, const D2D1_BITMAP_PROPERTIES1 *desc, struct d2d_bitmap **bitmap)
HRESULT	d2d_bitmap_create_from_wic_bitmap (struct d2d_device_context *context, IWICBitmapSource *bitmap_source, const D2D1_BITMAP_PROPERTIES1 *desc, struct d2d_bitmap **bitmap)
unsigned int	d2d_get_bitmap_options_for_surface (IDXGISurface *surface)
struct d2d_bitmap *	unsafe_impl_from_ID2D1Bitmap (ID2D1Bitmap *iface)
void	d2d_state_block_init (struct d2d_state_block *state_block, ID2D1Factory *factory, const D2D1_DRAWING_STATE_DESCRIPTION1 *desc, IDWriteRenderingParams *text_rendering_params)
struct d2d_state_block *	unsafe_impl_from_ID2D1DrawingStateBlock (ID2D1DrawingStateBlock *iface)
HRESULT	d2d_ellipse_geometry_init (struct d2d_geometry *geometry, ID2D1Factory *factory, const D2D1_ELLIPSE *ellipse)
void	d2d_path_geometry_init (struct d2d_geometry *geometry, ID2D1Factory *factory)
HRESULT	d2d_rectangle_geometry_init (struct d2d_geometry *geometry, ID2D1Factory *factory, const D2D1_RECT_F *rect)
HRESULT	d2d_rounded_rectangle_geometry_init (struct d2d_geometry *geometry, ID2D1Factory *factory, const D2D1_ROUNDED_RECT *rounded_rect)
void	d2d_transformed_geometry_init (struct d2d_geometry *geometry, ID2D1Factory *factory, ID2D1Geometry *src_geometry, const D2D_MATRIX_3X2_F *transform)
HRESULT	d2d_geometry_group_init (struct d2d_geometry *geometry, ID2D1Factory *factory, D2D1_FILL_MODE fill_mode, ID2D1Geometry **src_geometries, unsigned int geometry_count)
struct d2d_geometry *	unsafe_impl_from_ID2D1Geometry (ID2D1Geometry *iface)
struct d2d_device *	unsafe_impl_from_ID2D1Device (ID2D1Device1 *iface)
HRESULT	d2d_device_add_indexed_object (struct d2d_indexed_objects *objects, const GUID *id, IUnknown *object)
BOOL	d2d_device_get_indexed_object (struct d2d_indexed_objects *objects, const GUID *id, IUnknown **object)
void	d2d_device_indexed_objects_clear (struct d2d_indexed_objects *objects)
void	d2d_effect_context_init (struct d2d_effect_context *effect_context, struct d2d_device_context *device_context)
static struct d2d_factory *	unsafe_impl_from_ID2D1Factory (ID2D1Factory *iface)
void	d2d_effects_init_builtins (struct d2d_factory *factory)
HRESULT	d2d_factory_create_device (ID2D1Factory1 *factory, IDXGIDevice *dxgi_device, bool allow_get_dxgi_device, REFIID iid, void **device)
struct d2d_effect_registration *	d2d_factory_get_registered_effect (ID2D1Factory *factory, const GUID *effect_id)
void	d2d_factory_register_effect (struct d2d_factory *factory, struct d2d_effect_registration *effect)
HRESULT	d2d_effect_property_get_uint32_value (const struct d2d_effect_properties *properties, const struct d2d_effect_property *prop, UINT32 *value)
void	d2d_device_init (struct d2d_device *device, ID2D1Factory1 *factory, IDXGIDevice *dxgi_device, bool allow_get_dxgi_device)
HRESULT	d2d_effect_create (struct d2d_device_context *context, const CLSID *effect_id, ID2D1Effect **effect)
void	d2d_effect_init_properties (struct d2d_effect *effect, struct d2d_effect_properties *properties)
HRESULT	d2d_effect_properties_add (struct d2d_effect_properties *props, const WCHAR *name, UINT32 index, D2D1_PROPERTY_TYPE type, const WCHAR *value)
HRESULT	d2d_effect_subproperties_add (struct d2d_effect_properties *props, const WCHAR *name, UINT32 index, D2D1_PROPERTY_TYPE type, const WCHAR *value)
struct d2d_effect_property *	d2d_effect_properties_get_property_by_name (const struct d2d_effect_properties *properties, const WCHAR *name)
void	d2d_effect_properties_cleanup (struct d2d_effect_properties *props)
HRESULT	d2d_factory_register_builtin_effect (struct d2d_factory *factory, REFCLSID effect_id, const WCHAR *property_xml, const D2D1_PROPERTY_BINDING *bindings, UINT32 binding_count, PD2D1_EFFECT_FACTORY effect_factory)
HRESULT	d2d_command_list_create (ID2D1Factory *factory, struct d2d_command_list **command_list)
struct d2d_command_list *	unsafe_impl_from_ID2D1CommandList (ID2D1CommandList *iface)
void	d2d_command_list_begin_draw (struct d2d_command_list *command_list, const struct d2d_device_context *context)
void	d2d_command_list_set_antialias_mode (struct d2d_command_list *command_list, D2D1_ANTIALIAS_MODE mode)
void	d2d_command_list_set_primitive_blend (struct d2d_command_list *command_list, D2D1_PRIMITIVE_BLEND primitive_blend)
void	d2d_command_list_set_unit_mode (struct d2d_command_list *command_list, D2D1_UNIT_MODE mode)
void	d2d_command_list_set_text_antialias_mode (struct d2d_command_list *command_list, D2D1_TEXT_ANTIALIAS_MODE mode)
void	d2d_command_list_set_tags (struct d2d_command_list *command_list, D2D1_TAG tag1, D2D1_TAG tag2)
void	d2d_command_list_set_transform (struct d2d_command_list *command_list, const D2D1_MATRIX_3X2_F *transform)
void	d2d_command_list_push_clip (struct d2d_command_list *command_list, const D2D1_RECT_F *rect, D2D1_ANTIALIAS_MODE antialias_mode)
void	d2d_command_list_pop_clip (struct d2d_command_list *command_list)
void	d2d_command_list_clear (struct d2d_command_list *command_list, const D2D1_COLOR_F *color)
void	d2d_command_list_draw_line (struct d2d_command_list *command_list, const struct d2d_device_context *context, D2D1_POINT_2F p0, D2D1_POINT_2F p1, ID2D1Brush *orig_brush, float stroke_width, ID2D1StrokeStyle *stroke_style)
void	d2d_command_list_draw_geometry (struct d2d_command_list *command_list, const struct d2d_device_context *context, ID2D1Geometry *geometry, ID2D1Brush *orig_brush, float stroke_width, ID2D1StrokeStyle *stroke_style)
void	d2d_command_list_draw_rectangle (struct d2d_command_list *command_list, const struct d2d_device_context *context, const D2D1_RECT_F *rect, ID2D1Brush *orig_brush, float stroke_width, ID2D1StrokeStyle *stroke_style)
void	d2d_command_list_fill_geometry (struct d2d_command_list *command_list, const struct d2d_device_context *context, ID2D1Geometry *geometry, ID2D1Brush *orig_brush, ID2D1Brush *orig_opacity_brush)
void	d2d_command_list_fill_rectangle (struct d2d_command_list *command_list, const struct d2d_device_context *context, const D2D1_RECT_F *rect, ID2D1Brush *orig_brush)
void	d2d_command_list_set_text_rendering_params (struct d2d_command_list *command_list, IDWriteRenderingParams *params)
void	d2d_command_list_draw_glyph_run (struct d2d_command_list *command_list, const struct d2d_device_context *context, D2D1_POINT_2F origin, const DWRITE_GLYPH_RUN *run, const DWRITE_GLYPH_RUN_DESCRIPTION *run_desc, ID2D1Brush *orig_brush, DWRITE_MEASURING_MODE measuring_mode)
void	d2d_command_list_draw_bitmap (struct d2d_command_list *command_list, ID2D1Bitmap *bitmap, const D2D1_RECT_F *dst_rect, float opacity, D2D1_INTERPOLATION_MODE interpolation_mode, const D2D1_RECT_F *src_rect, const D2D1_MATRIX_4X4_F *perspective_transform)
void	d2d_command_list_draw_image (struct d2d_command_list *command_list, ID2D1Image *image, const D2D1_POINT_2F *target_offset, const D2D1_RECT_F *image_rect, D2D1_INTERPOLATION_MODE interpolation_mode, D2D1_COMPOSITE_MODE composite_mode)
void	d2d_command_list_fill_mesh (struct d2d_command_list *command_list, const struct d2d_device_context *context, ID2D1Mesh *mesh, ID2D1Brush *orig_brush)
void	d2d_command_list_fill_opacity_mask (struct d2d_command_list *command_list, const struct d2d_device_context *context, ID2D1Bitmap *bitmap, ID2D1Brush *orig_brush, const D2D1_RECT_F *dst_rect, const D2D1_RECT_F *src_rect)
void	d2d_command_list_push_layer (struct d2d_command_list *command_list, const struct d2d_device_context *context, const D2D1_LAYER_PARAMETERS1 *params, ID2D1Layer *layer)
void	d2d_command_list_pop_layer (struct d2d_command_list *command_list)
static BOOL	d2d_array_reserve (void **elements, size_t *capacity, size_t count, size_t size)
static void	d2d_matrix_multiply (D2D_MATRIX_3X2_F *a, const D2D_MATRIX_3X2_F *b)
static BOOL	d2d_matrix_invert (D2D_MATRIX_3X2_F *dst, const D2D_MATRIX_3X2_F *src)
static void	d2d_point_set (D2D1_POINT_2F *dst, float x, float y)
static float	d2d_point_dot (const D2D1_POINT_2F *p0, const D2D1_POINT_2F *p1)
static void	d2d_point_transform (D2D1_POINT_2F *dst, const D2D1_MATRIX_3X2_F *matrix, float x, float y)
static void	d2d_rect_expand (D2D1_RECT_F *dst, const D2D1_POINT_2F *point)
static D2D1_INTERPOLATION_MODE	d2d1_1_interp_mode_from_d2d1 (D2D1_BITMAP_INTERPOLATION_MODE mode)
static const char *	debug_d2d_color_f (const D2D1_COLOR_F *colour)
static const char *	debug_d2d_point_2f (const D2D1_POINT_2F *point)
static const char *	debug_d2d_point_2l (const D2D1_POINT_2L *point)
static const char *	debug_d2d_rect_f (const D2D1_RECT_F *rect)
static const char *	debug_d2d_rect_l (const D2D1_RECT_L *rect)
static const char *	debug_d2d_rounded_rect (const D2D1_ROUNDED_RECT *rounded_rect)
static const char *	debug_d2d_ellipse (const D2D1_ELLIPSE *ellipse)

Variables
struct d2d_settings	d2d_settings

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 30 of file d2d1_private.h.

Enumeration Type Documentation

d2d_brush_type

enum d2d_brush_type

Enumerator
D2D_BRUSH_TYPE_SOLID
D2D_BRUSH_TYPE_LINEAR
D2D_BRUSH_TYPE_RADIAL
D2D_BRUSH_TYPE_BITMAP
D2D_BRUSH_TYPE_IMAGE
D2D_BRUSH_TYPE_COUNT

Definition at line 39 of file d2d1_private.h.

{
    D2D_BRUSH_TYPE_SOLID,
    D2D_BRUSH_TYPE_LINEAR,
    D2D_BRUSH_TYPE_RADIAL,
    D2D_BRUSH_TYPE_BITMAP,
    D2D_BRUSH_TYPE_IMAGE,
    D2D_BRUSH_TYPE_COUNT,
};

d2d_command_list_state

enum d2d_command_list_state

Enumerator
D2D_COMMAND_LIST_STATE_INITIAL
D2D_COMMAND_LIST_STATE_ERROR
D2D_COMMAND_LIST_STATE_OPEN
D2D_COMMAND_LIST_STATE_CLOSED

Definition at line 822 of file d2d1_private.h.

{
    D2D_COMMAND_LIST_STATE_INITIAL = 0,
    D2D_COMMAND_LIST_STATE_ERROR,
    D2D_COMMAND_LIST_STATE_OPEN,
    D2D_COMMAND_LIST_STATE_CLOSED,
};

d2d_device_context_sampler_limits

enum d2d_device_context_sampler_limits

Enumerator
D2D_SAMPLER_INTERPOLATION_MODE_COUNT
D2D_SAMPLER_EXTEND_MODE_COUNT

Definition at line 149 of file d2d1_private.h.

{
    D2D_SAMPLER_INTERPOLATION_MODE_COUNT = 2,
    D2D_SAMPLER_EXTEND_MODE_COUNT = 3,
};

d2d_device_context_target_type

enum d2d_device_context_target_type

Enumerator
D2D_TARGET_UNKNOWN
D2D_TARGET_BITMAP
D2D_TARGET_COMMAND_LIST

Definition at line 155 of file d2d1_private.h.

{
    D2D_TARGET_UNKNOWN = 0,
    D2D_TARGET_BITMAP,
    D2D_TARGET_COMMAND_LIST,
};

d2d_geometry_state

enum d2d_geometry_state

Enumerator
D2D_GEOMETRY_STATE_INITIAL
D2D_GEOMETRY_STATE_ERROR
D2D_GEOMETRY_STATE_OPEN
D2D_GEOMETRY_STATE_CLOSED
D2D_GEOMETRY_STATE_FIGURE

Definition at line 464 of file d2d1_private.h.

{
    D2D_GEOMETRY_STATE_INITIAL = 0,
    D2D_GEOMETRY_STATE_ERROR,
    D2D_GEOMETRY_STATE_OPEN,
    D2D_GEOMETRY_STATE_CLOSED,
    D2D_GEOMETRY_STATE_FIGURE,
};

d2d_render_info_mask

enum d2d_render_info_mask

Enumerator
D2D_RENDER_INFO_PIXEL_SHADER

Definition at line 741 of file d2d1_private.h.

{
    D2D_RENDER_INFO_PIXEL_SHADER = 0x1,
};

d2d_shape_type

enum d2d_shape_type

Enumerator
D2D_SHAPE_TYPE_OUTLINE
D2D_SHAPE_TYPE_BEZIER_OUTLINE
D2D_SHAPE_TYPE_ARC_OUTLINE
D2D_SHAPE_TYPE_TRIANGLE
D2D_SHAPE_TYPE_CURVE
D2D_SHAPE_TYPE_COUNT

Definition at line 49 of file d2d1_private.h.

{
    D2D_SHAPE_TYPE_OUTLINE,
    D2D_SHAPE_TYPE_BEZIER_OUTLINE,
    D2D_SHAPE_TYPE_ARC_OUTLINE,
    D2D_SHAPE_TYPE_TRIANGLE,
    D2D_SHAPE_TYPE_CURVE,
    D2D_SHAPE_TYPE_COUNT,
};

Function Documentation

d2d1_1_interp_mode_from_d2d1()

static D2D1_INTERPOLATION_MODE d2d1_1_interp_mode_from_d2d1 ( D2D1_BITMAP_INTERPOLATION_MODE  mode )

inlinestatic

Definition at line 981 of file d2d1_private.h.

{
    return (D2D1_INTERPOLATION_MODE)mode;
}

Referenced by d2d_bitmap_brush_SetInterpolationMode(), and d2d_device_context_DrawBitmap().

d2d_array_reserve()

static BOOL d2d_array_reserve ( void **  elements, size_t *  capacity, size_t  count, size_t  size  )

inlinestatic

Definition at line 897 of file d2d1_private.h.

{
    size_t new_capacity, max_capacity;
    void *new_elements;
 
    if (count <= *capacity)
        return TRUE;
 
    max_capacity = ~(SIZE_T)0 / size;
    if (count > max_capacity)
        return FALSE;
 
    new_capacity = max(4, *capacity);
    while (new_capacity < count && new_capacity <= max_capacity / 2)
        new_capacity *= 2;
    if (new_capacity < count)
        new_capacity = max_capacity;
 
    if (!(new_elements = realloc(*elements, new_capacity * size)))
        return FALSE;
 
    *elements = new_elements;
    *capacity = new_capacity;
    return TRUE;
}

Referenced by d2d_cdt_create_edge(), d2d_clip_stack_push(), d2d_command_list_reference_object(), d2d_command_list_require_space(), d2d_device_add_indexed_object(), d2d_effect_properties_internal_add(), d2d_effect_set_input_count(), d2d_ellipse_geometry_init(), d2d_figure_add_bezier_controls(), d2d_figure_add_original_bezier_controls(), d2d_figure_add_vertex(), d2d_figure_insert_bezier_controls(), d2d_figure_insert_vertex(), d2d_geometry_fill_add_arc_triangle(), d2d_geometry_intersections_add(), d2d_geometry_outline_add_arc_quadrant(), d2d_geometry_outline_add_bezier_segment(), d2d_geometry_outline_add_join(), d2d_geometry_outline_add_line_segment(), d2d_path_geometry_add_figure(), d2d_path_geometry_add_fill_face(), d2d_rectangle_geometry_init(), and d2d_rounded_rectangle_geometry_init().

d2d_bitmap_brush_create()

HRESULT d2d_bitmap_brush_create	(	ID2D1Factory *	factory,
		ID2D1Bitmap *	bitmap,
		const D2D1_BITMAP_BRUSH_PROPERTIES1 *	bitmap_brush_desc,
		const D2D1_BRUSH_PROPERTIES *	brush_desc,
		struct d2d_brush **	brush
	)

Definition at line 1076 of file brush.c.

{
    if (!(*brush = calloc(1, sizeof(**brush))))
        return E_OUTOFMEMORY;
 
    d2d_brush_init(*brush, factory, D2D_BRUSH_TYPE_BITMAP,
            brush_desc, (ID2D1BrushVtbl *)&d2d_bitmap_brush_vtbl);
    if (((*brush)->u.bitmap.bitmap = unsafe_impl_from_ID2D1Bitmap(bitmap)))
        ID2D1Bitmap1_AddRef(&(*brush)->u.bitmap.bitmap->ID2D1Bitmap1_iface);
    if (bitmap_brush_desc)
    {
        (*brush)->u.bitmap.extend_mode_x = bitmap_brush_desc->extendModeX;
        (*brush)->u.bitmap.extend_mode_y = bitmap_brush_desc->extendModeY;
        (*brush)->u.bitmap.interpolation_mode = bitmap_brush_desc->interpolationMode;
    }
    else
    {
        (*brush)->u.bitmap.extend_mode_x = D2D1_EXTEND_MODE_CLAMP;
        (*brush)->u.bitmap.extend_mode_y = D2D1_EXTEND_MODE_CLAMP;
        (*brush)->u.bitmap.interpolation_mode = D2D1_INTERPOLATION_MODE_LINEAR;
    }
 
    TRACE("Created brush %p.\n", *brush);
    return S_OK;
}

Referenced by d2d_device_context_CreateBitmapBrush(), d2d_device_context_draw_bitmap(), and d2d_device_context_ID2D1DeviceContext_CreateBitmapBrush().

d2d_bitmap_create()

HRESULT d2d_bitmap_create	(	struct d2d_device_context *	context,
		D2D1_SIZE_U	size,
		const void *	src_data,
		UINT32	pitch,
		const D2D1_BITMAP_PROPERTIES1 *	desc,
		struct d2d_bitmap **	bitmap
	)

Definition at line 423 of file bitmap.c.

{
    D3D11_SUBRESOURCE_DATA resource_data;
    D2D1_BITMAP_PROPERTIES1 bitmap_desc;
    D3D11_TEXTURE2D_DESC texture_desc;
    ID3D11Texture2D *texture;
    HRESULT hr;
 
    if (!format_supported(&desc->pixelFormat))
    {
        WARN("Tried to create bitmap with unsupported format {%#x / %#x}.\n",
                desc->pixelFormat.format, desc->pixelFormat.alphaMode);
        return D2DERR_UNSUPPORTED_PIXEL_FORMAT;
    }
 
    if (desc->dpiX == 0.0f && desc->dpiY == 0.0f)
    {
        bitmap_desc = *desc;
        bitmap_desc.dpiX = context->desc.dpiX;
        bitmap_desc.dpiY = context->desc.dpiY;
        desc = &bitmap_desc;
    }
    else if (desc->dpiX <= 0.0f || desc->dpiY <= 0.0f)
    {
        return E_INVALIDARG;
    }
 
    if (!check_bitmap_options(desc->bitmapOptions))
        return E_INVALIDARG;
 
    texture_desc.Width = size.width;
    texture_desc.Height = size.height;
    if (!texture_desc.Width || !texture_desc.Height)
        texture_desc.Width = texture_desc.Height = 1;
    texture_desc.MipLevels = 1;
    texture_desc.ArraySize = 1;
    texture_desc.Format = desc->pixelFormat.format;
    texture_desc.SampleDesc.Count = 1;
    texture_desc.SampleDesc.Quality = 0;
    texture_desc.Usage = D3D11_USAGE_DEFAULT;
    if (desc->bitmapOptions & D2D1_BITMAP_OPTIONS_CPU_READ)
        texture_desc.Usage = D3D11_USAGE_STAGING;
    texture_desc.BindFlags = 0;
    if (desc->bitmapOptions & D2D1_BITMAP_OPTIONS_TARGET)
        texture_desc.BindFlags |= D3D11_BIND_RENDER_TARGET;
    if (!(desc->bitmapOptions & D2D1_BITMAP_OPTIONS_CANNOT_DRAW))
        texture_desc.BindFlags |= D3D11_BIND_SHADER_RESOURCE;
    texture_desc.CPUAccessFlags = 0;
    if (desc->bitmapOptions & D2D1_BITMAP_OPTIONS_CPU_READ)
        texture_desc.CPUAccessFlags |= D3D11_CPU_ACCESS_READ;
    texture_desc.MiscFlags = 0;
    if (desc->bitmapOptions & D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE)
        texture_desc.MiscFlags |= D3D11_RESOURCE_MISC_GDI_COMPATIBLE;
 
    resource_data.pSysMem = src_data;
    resource_data.SysMemPitch = pitch;
 
    if (FAILED(hr = ID3D11Device1_CreateTexture2D(context->d3d_device, &texture_desc,
            src_data ? &resource_data : NULL, &texture)))
    {
        ERR("Failed to create texture, hr %#lx.\n", hr);
        return hr;
    }
 
    if ((*bitmap = calloc(1, sizeof(**bitmap))))
    {
        d2d_bitmap_init(*bitmap, context, (ID3D11Resource *)texture, size, desc);
        TRACE("Created bitmap %p.\n", *bitmap);
    }
    ID3D11Texture2D_Release(texture);
 
    return *bitmap ? S_OK : E_OUTOFMEMORY;
}

Referenced by d2d_bitmap_create_from_wic_bitmap(), d2d_device_context_CreateBitmap(), and d2d_device_context_ID2D1DeviceContext_CreateBitmap().

d2d_bitmap_create_from_wic_bitmap()

HRESULT d2d_bitmap_create_from_wic_bitmap	(	struct d2d_device_context *	context,
		IWICBitmapSource *	bitmap_source,
		const D2D1_BITMAP_PROPERTIES1 *	desc,
		struct d2d_bitmap **	bitmap
	)

Definition at line 659 of file bitmap.c.

{
    const D2D1_PIXEL_FORMAT *d2d_format;
    D2D1_BITMAP_PROPERTIES1 bitmap_desc;
    WICPixelFormatGUID wic_format;
    unsigned int bpp, data_size;
    D2D1_SIZE_U size;
    unsigned int i;
    WICRect rect;
    UINT32 pitch;
    HRESULT hr;
    void *data;
 
    static const struct
    {
        const WICPixelFormatGUID *wic;
        D2D1_PIXEL_FORMAT d2d;
    }
    format_lookup[] =
    {
        {&GUID_WICPixelFormat32bppPBGRA, {DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED}},
        {&GUID_WICPixelFormat32bppPRGBA, {DXGI_FORMAT_R8G8B8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED}},
        {&GUID_WICPixelFormat32bppBGR,   {DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_IGNORE}},
        {&GUID_WICPixelFormat32bppRGB,   {DXGI_FORMAT_R8G8B8A8_UNORM, D2D1_ALPHA_MODE_IGNORE}},
    };
 
    if (FAILED(hr = IWICBitmapSource_GetSize(bitmap_source, &size.width, &size.height)))
    {
        WARN("Failed to get bitmap size, hr %#lx.\n", hr);
        return hr;
    }
 
    if (!desc)
    {
        bitmap_desc.pixelFormat.format = DXGI_FORMAT_UNKNOWN;
        bitmap_desc.pixelFormat.alphaMode = D2D1_ALPHA_MODE_UNKNOWN;
        bitmap_desc.dpiX = 0.0f;
        bitmap_desc.dpiY = 0.0f;
        bitmap_desc.bitmapOptions = 0;
        bitmap_desc.colorContext = NULL;
    }
    else
    {
        bitmap_desc = *desc;
    }
 
    if (FAILED(hr = IWICBitmapSource_GetPixelFormat(bitmap_source, &wic_format)))
    {
        WARN("Failed to get bitmap format, hr %#lx.\n", hr);
        return hr;
    }
 
    for (i = 0, d2d_format = NULL; i < ARRAY_SIZE(format_lookup); ++i)
    {
        if (IsEqualGUID(&wic_format, format_lookup[i].wic))
        {
            d2d_format = &format_lookup[i].d2d;
            break;
        }
    }
 
    if (!d2d_format)
    {
        WARN("Unsupported WIC bitmap format %s.\n", debugstr_guid(&wic_format));
        return D2DERR_UNSUPPORTED_PIXEL_FORMAT;
    }
 
    if (bitmap_desc.pixelFormat.format == DXGI_FORMAT_UNKNOWN)
        bitmap_desc.pixelFormat.format = d2d_format->format;
    if (bitmap_desc.pixelFormat.alphaMode == D2D1_ALPHA_MODE_UNKNOWN)
        bitmap_desc.pixelFormat.alphaMode = d2d_format->alphaMode;
 
    switch (bitmap_desc.pixelFormat.format)
    {
        case DXGI_FORMAT_B8G8R8A8_UNORM:
        case DXGI_FORMAT_R8G8B8A8_UNORM:
            bpp = 4;
            break;
 
        default:
            FIXME("Unhandled format %#x.\n", bitmap_desc.pixelFormat.format);
            return D2DERR_UNSUPPORTED_PIXEL_FORMAT;
    }
 
    pitch = ((bpp * size.width) + 15) & ~15;
    if (pitch / bpp < size.width)
        return E_OUTOFMEMORY;
    if (!(data = calloc(size.height, pitch)))
        return E_OUTOFMEMORY;
    data_size = size.height * pitch;
 
    rect.X = 0;
    rect.Y = 0;
    rect.Width = size.width;
    rect.Height = size.height;
    if (FAILED(hr = IWICBitmapSource_CopyPixels(bitmap_source, &rect, pitch, data_size, data)))
    {
        WARN("Failed to copy bitmap pixels, hr %#lx.\n", hr);
        free(data);
        return hr;
    }
 
    hr = d2d_bitmap_create(context, size, data, pitch, &bitmap_desc, bitmap);
 
    free(data);
 
    return hr;
}

Referenced by d2d_device_context_CreateBitmapFromWicBitmap(), and d2d_device_context_ID2D1DeviceContext_CreateBitmapFromWicBitmap().

d2d_bitmap_create_shared()

HRESULT d2d_bitmap_create_shared	(	struct d2d_device_context *	context,
		REFIID	iid,
		void *	data,
		const D2D1_BITMAP_PROPERTIES1 *	desc,
		struct d2d_bitmap **	bitmap
	)

Definition at line 522 of file bitmap.c.

{
    D2D1_BITMAP_PROPERTIES1 d;
 
    if (IsEqualGUID(iid, &IID_ID2D1Bitmap))
    {
        struct d2d_bitmap *src_impl = unsafe_impl_from_ID2D1Bitmap(data);
        ID3D11Device *device;
        HRESULT hr = S_OK;
 
        if (src_impl->factory != context->factory)
        {
            hr = D2DERR_WRONG_FACTORY;
            goto failed;
        }
 
        ID3D11Resource_GetDevice(src_impl->resource, &device);
        ID3D11Device_Release(device);
        if (device != (ID3D11Device *)context->d3d_device)
        {
            hr = D2DERR_UNSUPPORTED_OPERATION;
            goto failed;
        }
 
        if (desc)
        {
            d = *desc;
            if (d.pixelFormat.format == DXGI_FORMAT_UNKNOWN)
                d.pixelFormat.format = src_impl->format.format;
            if (d.pixelFormat.alphaMode == D2D1_ALPHA_MODE_UNKNOWN)
                d.pixelFormat.alphaMode = src_impl->format.alphaMode;
        }
        else
        {
            d.pixelFormat = src_impl->format;
            d.dpiX = src_impl->dpi_x;
            d.dpiY = src_impl->dpi_y;
            d.bitmapOptions = src_impl->options;
            d.colorContext = NULL;
        }
        desc = &d;
 
        if (!format_supported(&desc->pixelFormat))
        {
            WARN("Tried to create bitmap with unsupported format {%#x / %#x}.\n",
                    desc->pixelFormat.format, desc->pixelFormat.alphaMode);
            hr = D2DERR_UNSUPPORTED_PIXEL_FORMAT;
            goto failed;
        }
 
        if (!(*bitmap = calloc(1, sizeof(**bitmap))))
        {
            hr = E_OUTOFMEMORY;
            goto failed;
        }
 
        d2d_bitmap_init(*bitmap, context, src_impl->resource, src_impl->pixel_size, desc);
        TRACE("Created bitmap %p.\n", *bitmap);
 
    failed:
        return hr;
    }
 
    if (IsEqualGUID(iid, &IID_IDXGISurface) || IsEqualGUID(iid, &IID_IDXGISurface1))
    {
        DXGI_SURFACE_DESC surface_desc;
        IDXGISurface *surface = data;
        ID3D11Resource *resource;
        D2D1_SIZE_U pixel_size;
        ID3D11Device *device;
        HRESULT hr;
 
        if (FAILED(IDXGISurface_QueryInterface(surface, &IID_ID3D11Resource, (void **)&resource)))
        {
            WARN("Failed to get d3d resource from dxgi surface.\n");
            return E_FAIL;
        }
 
        ID3D11Resource_GetDevice(resource, &device);
        ID3D11Device_Release(device);
        if (device != (ID3D11Device *)context->d3d_device)
        {
            ID3D11Resource_Release(resource);
            return D2DERR_UNSUPPORTED_OPERATION;
        }
 
        if (!(*bitmap = calloc(1, sizeof(**bitmap))))
        {
            ID3D11Resource_Release(resource);
            return E_OUTOFMEMORY;
        }
 
 
        if (FAILED(hr = IDXGISurface_GetDesc(surface, &surface_desc)))
        {
            WARN("Failed to get surface desc, hr %#lx.\n", hr);
            ID3D11Resource_Release(resource);
            return hr;
        }
 
        if (!desc)
        {
            memset(&d, 0, sizeof(d));
            d.pixelFormat.format = surface_desc.Format;
            d.bitmapOptions = d2d_get_bitmap_options_for_surface(surface);
        }
        else
        {
            d = *desc;
            if (d.pixelFormat.format == DXGI_FORMAT_UNKNOWN)
                d.pixelFormat.format = surface_desc.Format;
        }
 
        if (d.dpiX == 0.0f || d.dpiY == 0.0f)
        {
            if (d.dpiX == 0.0f)
                d.dpiX = context->desc.dpiX;
            if (d.dpiY == 0.0f)
                d.dpiY = context->desc.dpiY;
        }
 
        pixel_size.width = surface_desc.Width;
        pixel_size.height = surface_desc.Height;
 
        d2d_bitmap_init(*bitmap, context, resource, pixel_size, &d);
        ID3D11Resource_Release(resource);
        TRACE("Created bitmap %p.\n", *bitmap);
 
        return S_OK;
    }
 
    WARN("Unhandled interface %s.\n", debugstr_guid(iid));
 
    return E_INVALIDARG;
}

Referenced by d2d_device_context_CreateBitmapFromDxgiSurface(), and d2d_device_context_CreateSharedBitmap().

d2d_bitmap_render_target_init()

HRESULT d2d_bitmap_render_target_init	(	struct d2d_bitmap_render_target *	render_target,
		const struct d2d_device_context *	parent_target,
		const D2D1_SIZE_F *	size,
		const D2D1_SIZE_U *	pixel_size,
		const D2D1_PIXEL_FORMAT *	format,
		D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS	options
	)

Definition at line 728 of file bitmap_render_target.c.

{
    D2D1_RENDER_TARGET_PROPERTIES dxgi_rt_desc;
    D2D1_BITMAP_PROPERTIES1 bitmap_desc;
    ID2D1DeviceContext *context;
    D2D1_SIZE_U bitmap_size;
    HRESULT hr;
 
    if (options)
        FIXME("Compatible target options are ignored, %#x.\n", options);
 
    render_target->ID2D1BitmapRenderTarget_iface.lpVtbl = &d2d_bitmap_render_target_vtbl;
 
    dxgi_rt_desc.type = parent_target->desc.type;
    dxgi_rt_desc.usage = parent_target->desc.usage;
    dxgi_rt_desc.minLevel = parent_target->desc.minLevel;
 
    if (pixel_size)
    {
        bitmap_size.width = pixel_size->width;
        bitmap_size.height = pixel_size->height;
    }
    else if (size)
    {
        bitmap_size.width = ceilf((size->width * parent_target->desc.dpiX) / 96.0f);
        bitmap_size.height = ceilf((size->height * parent_target->desc.dpiY) / 96.0f);
    }
    else
    {
        bitmap_size.width = parent_target->pixel_size.width;
        bitmap_size.height = parent_target->pixel_size.height;
    }
 
    if (size && size->width != 0.0f && size->height != 0.0f)
    {
        dxgi_rt_desc.dpiX = (bitmap_size.width * 96.0f) / size->width;
        dxgi_rt_desc.dpiY = (bitmap_size.height * 96.0f) / size->height;
    }
    else
    {
        dxgi_rt_desc.dpiX = parent_target->desc.dpiX;
        dxgi_rt_desc.dpiY = parent_target->desc.dpiY;
    }
 
    if (!pixel_format || pixel_format->format == DXGI_FORMAT_UNKNOWN)
        dxgi_rt_desc.pixelFormat.format = parent_target->desc.pixelFormat.format;
    else
        dxgi_rt_desc.pixelFormat.format = pixel_format->format;
 
    if (!pixel_format || pixel_format->alphaMode == D2D1_ALPHA_MODE_UNKNOWN)
        dxgi_rt_desc.pixelFormat.alphaMode = D2D1_ALPHA_MODE_PREMULTIPLIED;
    else
        dxgi_rt_desc.pixelFormat.alphaMode = pixel_format->alphaMode;
 
    if (FAILED(hr = d2d_d3d_create_render_target(parent_target->device, NULL,
            (IUnknown *)&render_target->ID2D1BitmapRenderTarget_iface,
            parent_target->ops ? &d2d_bitmap_render_target_ops : NULL,
            &dxgi_rt_desc, (void **)&render_target->dxgi_inner)))
    {
        WARN("Failed to create DXGI surface render target, hr %#lx.\n", hr);
        return hr;
    }
 
    /* Note that we should be a little careful with the "dxgi_target"
     * reference we get here. Because the object is aggregated, releasing the
     * interface in any error paths below would end up calling
     * d2d_bitmap_render_target_Release(). */
    if (FAILED(hr = IUnknown_QueryInterface(render_target->dxgi_inner,
            &IID_ID2D1RenderTarget, (void **)&render_target->dxgi_target)))
    {
        WARN("Failed to retrieve ID2D1RenderTarget interface, hr %#lx.\n", hr);
        IUnknown_Release(render_target->dxgi_inner);
        return hr;
    }
 
    bitmap_desc.pixelFormat = dxgi_rt_desc.pixelFormat;
    bitmap_desc.dpiX = dxgi_rt_desc.dpiX;
    bitmap_desc.dpiY = dxgi_rt_desc.dpiY;
    bitmap_desc.bitmapOptions = D2D1_BITMAP_OPTIONS_TARGET;
    bitmap_desc.colorContext = NULL;
 
    ID2D1RenderTarget_QueryInterface(render_target->dxgi_target, &IID_ID2D1DeviceContext, (void **)&context);
    hr = ID2D1DeviceContext_CreateBitmap(context, bitmap_size, NULL, 0, &bitmap_desc,
            (ID2D1Bitmap1 **)&render_target->bitmap);
    ID2D1DeviceContext_SetTarget(context, (ID2D1Image *)render_target->bitmap);
    ID2D1DeviceContext_Release(context);
    if (FAILED(hr))
    {
        WARN("Failed to create target bitmap, hr %#lx.\n", hr);
        IUnknown_Release(render_target->dxgi_inner);
        return hr;
    }
 
    return S_OK;
}

Referenced by d2d_device_context_CreateCompatibleRenderTarget().

d2d_brush_bind_resources()

void d2d_brush_bind_resources	(	struct d2d_brush *	brush,
		struct d2d_device_context *	context,
		unsigned int	brush_idx
	)

Definition at line 1573 of file brush.c.

{
    switch (brush->type)
    {
        case D2D_BRUSH_TYPE_SOLID:
            break;
 
        case D2D_BRUSH_TYPE_LINEAR:
            d2d_gradient_bind(brush->u.linear.gradient, context->d3d_device, brush_idx);
            break;
 
        case D2D_BRUSH_TYPE_RADIAL:
            d2d_gradient_bind(brush->u.radial.gradient, context->d3d_device, brush_idx);
            break;
 
        case D2D_BRUSH_TYPE_BITMAP:
            d2d_brush_bind_bitmap(brush->u.bitmap.bitmap, context, brush->u.bitmap.extend_mode_x,
                    brush->u.bitmap.extend_mode_y, brush->u.bitmap.interpolation_mode, brush_idx);
            break;
 
        case D2D_BRUSH_TYPE_IMAGE:
            d2d_brush_bind_image(brush, context, brush_idx);
            break;
 
        default:
            FIXME("Unhandled brush type %#x.\n", brush->type);
            break;
    }
}

Referenced by d2d_device_context_draw().

d2d_brush_fill_cb()

BOOL d2d_brush_fill_cb	(	const struct d2d_brush *	brush,
		struct d2d_brush_cb *	cb
	)

Definition at line 1372 of file brush.c.

{
    float theta, sin_theta, cos_theta;
    float dpi_scale, d, s1, s2, t, u;
    struct d2d_bitmap *bitmap;
    D2D1_POINT_2F v_p, v_q;
    D2D1_COLOR_F *colour;
    D2D_MATRIX_3X2_F b;
 
    if (!brush)
    {
        cb->type = D2D_BRUSH_TYPE_COUNT;
        return TRUE;
    }
 
    cb->type = brush->type;
    cb->opacity = brush->opacity;
 
    switch (brush->type)
    {
        case D2D_BRUSH_TYPE_SOLID:
            colour = &cb->u.solid.colour;
 
            *colour = brush->u.solid.color;
            colour->r *= colour->a;
            colour->g *= colour->a;
            colour->b *= colour->a;
 
            return TRUE;
 
        case D2D_BRUSH_TYPE_LINEAR:
            b = brush->transform;
            d2d_point_transform(&cb->u.linear.start, &b, brush->u.linear.start.x, brush->u.linear.start.y);
            d2d_point_transform(&cb->u.linear.end, &b, brush->u.linear.end.x, brush->u.linear.end.y);
            cb->u.linear.stop_count = brush->u.linear.gradient->stop_count;
 
            return TRUE;
 
        case D2D_BRUSH_TYPE_RADIAL:
            b = brush->transform;
            d2d_point_transform(&cb->u.radial.centre, &b, brush->u.radial.centre.x, brush->u.radial.centre.y);
            b._31 = b._32 = 0.0f;
            d2d_point_transform(&cb->u.radial.offset, &b, brush->u.radial.offset.x, brush->u.radial.offset.y);
 
            /* After a transformation, the axes of the ellipse are no longer
             * necessarily orthogonal, but they are conjugate diameters.
             *
             * A = ⎡a.x b.x⎤
             *     ⎣a.y b.y⎦
             *
             *   = ⎡cos(θ) -sin(θ)⎤⎡σ₁ 0 ⎤⎡cos(φ) -sin(φ)⎤
             *     ⎣sin(θ)  cos(θ)⎦⎣0  σ₂⎦⎣sin(φ)  cos(φ)⎦
             *
             * a' = [σ₁· cos(θ) σ₁·sin(θ)]
             * b' = [σ₂·-sin(θ) σ₂·cos(θ)] */
 
            d2d_point_set(&v_p, brush->u.radial.radius.x * b._11, brush->u.radial.radius.y * b._21);
            d2d_point_set(&v_q, brush->u.radial.radius.x * b._12, brush->u.radial.radius.y * b._22);
 
            t = 0.5f * d2d_point_dot(&v_p, &v_p);
            u = 0.5f * d2d_point_dot(&v_q, &v_q);
            s1 = t + u;
 
            t = t - u;
            u = d2d_point_dot(&v_p, &v_q);
            s2 = sqrtf(t * t + u * u);
 
            theta = 0.5f * atan2(u, t);
            sin_theta = sinf(theta);
            cos_theta = cosf(theta);
 
            t = sqrtf(s1 + s2);
            d2d_point_set(&cb->u.radial.ra, t * cos_theta, t * sin_theta);
            t = sqrtf(s1 - s2);
            d2d_point_set(&cb->u.radial.rb, t * -sin_theta, t * cos_theta);
 
            cb->u.radial.stop_count = brush->u.linear.gradient->stop_count;
 
            return TRUE;
 
        case D2D_BRUSH_TYPE_BITMAP:
        case D2D_BRUSH_TYPE_IMAGE:
        {
            ID2D1Bitmap *image_bitmap = NULL;
 
            if (brush->type == D2D_BRUSH_TYPE_BITMAP)
                bitmap = brush->u.bitmap.bitmap;
            else
            {
                if (FAILED(ID2D1Image_QueryInterface(brush->u.image.image, &IID_ID2D1Bitmap, (void **)&image_bitmap)))
                {
                    FIXME("Only image brushes with bitmaps are supported.\n");
                    return FALSE;
                }
 
                bitmap = unsafe_impl_from_ID2D1Bitmap(image_bitmap);
                cb->type = D2D_BRUSH_TYPE_BITMAP;
            }
 
            /* Scale for bitmap size and dpi. */
            b = brush->transform;
            dpi_scale = bitmap->pixel_size.width * (96.0f / bitmap->dpi_x);
            b._11 *= dpi_scale;
            b._21 *= dpi_scale;
            dpi_scale = bitmap->pixel_size.height * (96.0f / bitmap->dpi_y);
            b._12 *= dpi_scale;
            b._22 *= dpi_scale;
 
            /* Invert the matrix. (Because the matrix is applied to the
             * sampling coordinates. I.e., to scale the bitmap by 2 we need to
             * divide the coordinates by 2.) */
            d = b._11 * b._22 - b._21 * b._12;
            if (d != 0.0f)
            {
                cb->u.bitmap._11 = b._22 / d;
                cb->u.bitmap._21 = -b._21 / d;
                cb->u.bitmap._31 = (b._21 * b._32 - b._31 * b._22) / d;
                cb->u.bitmap._12 = -b._12 / d;
                cb->u.bitmap._22 = b._11 / d;
                cb->u.bitmap._32 = -(b._11 * b._32 - b._31 * b._12) / d;
            }
 
            cb->u.bitmap.ignore_alpha = bitmap->format.alphaMode == D2D1_ALPHA_MODE_IGNORE;
 
            if (image_bitmap)
                ID2D1Bitmap_Release(image_bitmap);
 
            return TRUE;
        }
 
        default:
            FIXME("Unhandled brush type %#x.\n", brush->type);
            return FALSE;
    }
}

Referenced by d2d_device_context_update_ps_cb().

d2d_command_list_begin_draw()

void d2d_command_list_begin_draw	(	struct d2d_command_list *	command_list,
		const struct d2d_device_context *	context
	)

Definition at line 676 of file command_list.c.

{
    if (command_list->state != D2D_COMMAND_LIST_STATE_INITIAL)
    {
        command_list->state = D2D_COMMAND_LIST_STATE_ERROR;
        return;
    }
 
    d2d_command_list_set_antialias_mode(command_list, context->drawing_state.antialiasMode);
    d2d_command_list_set_primitive_blend(command_list, context->drawing_state.primitiveBlend);
    d2d_command_list_set_unit_mode(command_list, context->drawing_state.unitMode);
    d2d_command_list_set_text_antialias_mode(command_list, context->drawing_state.textAntialiasMode);
    d2d_command_list_set_tags(command_list, context->drawing_state.tag1, context->drawing_state.tag2);
    d2d_command_list_set_transform(command_list, &context->drawing_state.transform);
    d2d_command_list_set_text_rendering_params(command_list, context->text_rendering_params);
 
    command_list->state = D2D_COMMAND_LIST_STATE_OPEN;
}

Referenced by d2d_device_context_BeginDraw().

d2d_command_list_clear()

void d2d_command_list_clear	(	struct d2d_command_list *	command_list,
		const D2D1_COLOR_F *	color
	)

Definition at line 746 of file command_list.c.

{
    struct d2d_command_clear *command;
 
    command = d2d_command_list_require_space(command_list, sizeof(*command));
    command->c.op = D2D_COMMAND_CLEAR;
    if (color) command->color = *color;
    else memset(&command->color, 0, sizeof(command->color));
}

Referenced by d2d_device_context_Clear().

d2d_command_list_create()

HRESULT d2d_command_list_create	(	ID2D1Factory *	factory,
		struct d2d_command_list **	command_list
	)

Definition at line 498 of file command_list.c.

{
    if (!(*command_list = calloc(1, sizeof(**command_list))))
        return E_OUTOFMEMORY;
 
    (*command_list)->ID2D1CommandList_iface.lpVtbl = &d2d_command_list_vtbl;
    (*command_list)->refcount = 1;
    ID2D1Factory_AddRef((*command_list)->factory = factory);
 
    TRACE("Created command list %p.\n", *command_list);
 
    return S_OK;
}

Referenced by d2d_device_context_CreateCommandList().

d2d_command_list_draw_bitmap()

void d2d_command_list_draw_bitmap	(	struct d2d_command_list *	command_list,
		ID2D1Bitmap *	bitmap,
		const D2D1_RECT_F *	dst_rect,
		float	opacity,
		D2D1_INTERPOLATION_MODE	interpolation_mode,
		const D2D1_RECT_F *	src_rect,
		const D2D1_MATRIX_4X4_F *	perspective_transform
	)

Definition at line 999 of file command_list.c.

{
    struct d2d_command_draw_bitmap *command;
    size_t size;
    BYTE *data;
 
    size = sizeof(*command);
    if (dst_rect) size += sizeof(*dst_rect);
    if (src_rect) size += sizeof(*src_rect);
    if (perspective_transform) size += sizeof(*perspective_transform);
 
    d2d_command_list_reference_object(command_list, bitmap);
 
    command = d2d_command_list_require_space(command_list, size);
    command->c.op = D2D_COMMAND_DRAW_BITMAP;
    command->bitmap = bitmap;
    command->opacity = opacity;
    command->interpolation_mode = interpolation_mode;
 
    data = (BYTE *)(command + 1);
 
    d2d_command_list_write_field(&data, &command->dst_rect, dst_rect, sizeof(*dst_rect));
    d2d_command_list_write_field(&data, &command->src_rect, src_rect, sizeof(*src_rect));
    d2d_command_list_write_field(&data, &command->perspective_transform, perspective_transform, sizeof(*perspective_transform));
}

Referenced by d2d_device_context_DrawBitmap(), and d2d_device_context_ID2D1DeviceContext_DrawBitmap().

d2d_command_list_draw_geometry()

void d2d_command_list_draw_geometry	(	struct d2d_command_list *	command_list,
		const struct d2d_device_context *	context,
		ID2D1Geometry *	geometry,
		ID2D1Brush *	orig_brush,
		float	stroke_width,
		ID2D1StrokeStyle *	stroke_style
	)

Definition at line 780 of file command_list.c.

{
    struct d2d_command_draw_geometry *command;
    ID2D1Brush *brush;
 
    if (FAILED(d2d_command_list_create_brush(command_list, context, orig_brush, &brush)))
    {
        command_list->state = D2D_COMMAND_LIST_STATE_ERROR;
        return;
    }
 
    d2d_command_list_reference_object(command_list, geometry);
    d2d_command_list_reference_object(command_list, stroke_style);
 
    command = d2d_command_list_require_space(command_list, sizeof(*command));
    command->c.op = D2D_COMMAND_DRAW_GEOMETRY;
    command->brush = brush;
    command->stroke_width = stroke_width;
    command->stroke_style = stroke_style;
}

Referenced by d2d_device_context_DrawGeometry().

d2d_command_list_draw_glyph_run()

void d2d_command_list_draw_glyph_run	(	struct d2d_command_list *	command_list,
		const struct d2d_device_context *	context,
		D2D1_POINT_2F	origin,
		const DWRITE_GLYPH_RUN *	run,
		const DWRITE_GLYPH_RUN_DESCRIPTION *	run_desc,
		ID2D1Brush *	orig_brush,
		DWRITE_MEASURING_MODE	measuring_mode
	)

Definition at line 919 of file command_list.c.

{
    struct d2d_command_draw_glyph_run *command;
    DWRITE_GLYPH_RUN_DESCRIPTION *d;
    DWRITE_GLYPH_RUN *r;
    UINT32 glyph_count;
    ID2D1Brush *brush;
    size_t size;
    BYTE *data;
 
    if (FAILED(d2d_command_list_create_brush(command_list, context, orig_brush, &brush)))
    {
        command_list->state = D2D_COMMAND_LIST_STATE_ERROR;
        return;
    }
 
    /* Set rendering parameters automatically. Explicitly set null parameters are not recorded,
       either separately or as a part of a restored state block. Forcing parameters update on
       DrawGlyphRun() ensures that state is reset correctly. */
 
    d2d_command_list_set_text_rendering_params_internal(command_list, TRUE,
            context->text_rendering_params);
 
    /* Get combined size of variable data. */
 
    glyph_count = run->glyphCount;
    size = sizeof(*command);
    if (run->glyphIndices) size += glyph_count * sizeof(*run->glyphIndices);
    if (run->glyphAdvances) size += glyph_count * sizeof(*run->glyphAdvances);
    if (run->glyphOffsets) size += glyph_count * sizeof(*run->glyphOffsets);
    if (run_desc)
    {
        size += sizeof(*run_desc);
        if (run_desc->localeName) size += (wcslen(run_desc->localeName) + 1) * sizeof(*run_desc->localeName);
        if (run_desc->string) size += run_desc->stringLength * sizeof(*run_desc->string);
        if (run_desc->clusterMap) size += run_desc->stringLength * sizeof(*run_desc->clusterMap);
        size += sizeof(run_desc->stringLength);
        size += sizeof(run_desc->textPosition);
    }
 
    d2d_command_list_reference_object(command_list, run->fontFace);
 
    command = d2d_command_list_require_space(command_list, size);
    command->c.op = D2D_COMMAND_DRAW_GLYPH_RUN;
    r = &command->run;
 
    r->fontFace = run->fontFace;
    r->fontEmSize = run->fontEmSize;
    r->glyphCount = run->glyphCount;
    r->isSideways = run->isSideways;
    r->bidiLevel = run->bidiLevel;
 
    data = (BYTE *)(command + 1);
 
    d2d_command_list_write_field(&data, &r->glyphIndices, run->glyphIndices, glyph_count * sizeof(*r->glyphIndices));
    d2d_command_list_write_field(&data, &r->glyphAdvances, run->glyphAdvances, glyph_count * sizeof(*r->glyphAdvances));
    d2d_command_list_write_field(&data, &r->glyphOffsets, run->glyphOffsets, glyph_count * sizeof(*r->glyphOffsets));
 
    command->run_desc = NULL;
    if (run_desc)
    {
        d = command->run_desc = (DWRITE_GLYPH_RUN_DESCRIPTION *)data;
        memset(d, 0, sizeof(*d));
        data += sizeof(*d);
 
        d2d_command_list_write_field(&data, &d->localeName, run_desc->localeName, (wcslen(run_desc->localeName) + 1) * sizeof(*run_desc->localeName));
        d2d_command_list_write_field(&data, &d->string, run_desc->string, run_desc->stringLength * sizeof(*run_desc->string));
        d->stringLength = run_desc->stringLength;
        d2d_command_list_write_field(&data, &d->clusterMap, run_desc->clusterMap, run_desc->stringLength * sizeof(*run_desc->clusterMap));
        d->textPosition = run_desc->textPosition;
    }
 
    command->brush = brush;
    command->origin = origin;
    command->measuring_mode = measuring_mode;
}

Referenced by d2d_device_context_draw_glyph_run().

d2d_command_list_draw_image()

void d2d_command_list_draw_image	(	struct d2d_command_list *	command_list,
		ID2D1Image *	image,
		const D2D1_POINT_2F *	target_offset,
		const D2D1_RECT_F *	image_rect,
		D2D1_INTERPOLATION_MODE	interpolation_mode,
		D2D1_COMPOSITE_MODE	composite_mode
	)

Definition at line 1027 of file command_list.c.

{
    struct d2d_command_draw_image *command;
    size_t size;
    BYTE *data;
 
    size = sizeof(*command);
    if (target_offset) size += sizeof(*target_offset);
    if (image_rect) size += sizeof(*image_rect);
 
    d2d_command_list_reference_object(command_list, image);
 
    command = d2d_command_list_require_space(command_list, size);
    command->c.op = D2D_COMMAND_DRAW_IMAGE;
    command->image = image;
    command->interpolation_mode = interpolation_mode;
    command->composite_mode = composite_mode;
 
    data = (BYTE *)(command + 1);
 
    d2d_command_list_write_field(&data, &command->target_offset, target_offset, sizeof(*target_offset));
    d2d_command_list_write_field(&data, &command->image_rect, image_rect, sizeof(*image_rect));
}

Referenced by d2d_device_context_DrawImage().

d2d_command_list_draw_line()

void d2d_command_list_draw_line	(	struct d2d_command_list *	command_list,
		const struct d2d_device_context *	context,
		D2D1_POINT_2F	p0,
		D2D1_POINT_2F	p1,
		ID2D1Brush *	orig_brush,
		float	stroke_width,
		ID2D1StrokeStyle *	stroke_style
	)

Definition at line 756 of file command_list.c.

{
    struct d2d_command_draw_line *command;
    ID2D1Brush *brush;
 
    if (FAILED(d2d_command_list_create_brush(command_list, context, orig_brush, &brush)))
    {
        command_list->state = D2D_COMMAND_LIST_STATE_ERROR;
        return;
    }
 
    d2d_command_list_reference_object(command_list, stroke_style);
 
    command = d2d_command_list_require_space(command_list, sizeof(*command));
    command->c.op = D2D_COMMAND_DRAW_LINE;
    command->p0 = p0;
    command->p1 = p1;
    command->brush = brush;
    command->stroke_width = stroke_width;
    command->stroke_style = stroke_style;
}

Referenced by d2d_device_context_DrawLine().

d2d_command_list_draw_rectangle()

void d2d_command_list_draw_rectangle	(	struct d2d_command_list *	command_list,
		const struct d2d_device_context *	context,
		const D2D1_RECT_F *	rect,
		ID2D1Brush *	orig_brush,
		float	stroke_width,
		ID2D1StrokeStyle *	stroke_style
	)

Definition at line 803 of file command_list.c.

{
    struct d2d_command_draw_rectangle *command;
    ID2D1Brush *brush;
 
    if (FAILED(d2d_command_list_create_brush(command_list, context, orig_brush, &brush)))
    {
        command_list->state = D2D_COMMAND_LIST_STATE_ERROR;
        return;
    }
 
    d2d_command_list_reference_object(command_list, stroke_style);
 
    command = d2d_command_list_require_space(command_list, sizeof(*command));
    command->c.op = D2D_COMMAND_DRAW_RECTANGLE;
    command->rect = *rect;
    command->brush = brush;
    command->stroke_width = stroke_width;
    command->stroke_style = stroke_style;
}

Referenced by d2d_device_context_DrawRectangle().

d2d_command_list_fill_geometry()

void d2d_command_list_fill_geometry	(	struct d2d_command_list *	command_list,
		const struct d2d_device_context *	context,
		ID2D1Geometry *	geometry,
		ID2D1Brush *	orig_brush,
		ID2D1Brush *	orig_opacity_brush
	)

Definition at line 825 of file command_list.c.

{
    ID2D1Brush *brush, *opacity_brush = NULL;
    struct d2d_command_fill_geometry *command;
 
    if (FAILED(d2d_command_list_create_brush(command_list, context, orig_brush, &brush)))
    {
        command_list->state = D2D_COMMAND_LIST_STATE_ERROR;
        return;
    }
 
    if (orig_opacity_brush && FAILED(d2d_command_list_create_brush(command_list, context,
            orig_opacity_brush, &opacity_brush)))
    {
        command_list->state = D2D_COMMAND_LIST_STATE_ERROR;
        ID2D1Brush_Release(brush);
        return;
    }
 
    d2d_command_list_reference_object(command_list, geometry);
 
    command = d2d_command_list_require_space(command_list, sizeof(*command));
    command->c.op = D2D_COMMAND_FILL_GEOMETRY;
    command->geometry = geometry;
    command->brush = brush;
    command->opacity_brush = opacity_brush;
}

Referenced by d2d_device_context_FillGeometry().

d2d_command_list_fill_mesh()

void d2d_command_list_fill_mesh	(	struct d2d_command_list *	command_list,
		const struct d2d_device_context *	context,
		ID2D1Mesh *	mesh,
		ID2D1Brush *	orig_brush
	)

Definition at line 1053 of file command_list.c.

{
    struct d2d_command_fill_mesh *command;
    ID2D1Brush *brush;
 
    if (FAILED(d2d_command_list_create_brush(command_list, context, orig_brush, &brush)))
    {
        command_list->state = D2D_COMMAND_LIST_STATE_ERROR;
        return;
    }
 
    d2d_command_list_reference_object(command_list, mesh);
 
    command = d2d_command_list_require_space(command_list, sizeof(*command));
    command->c.op = D2D_COMMAND_FILL_MESH;
    command->mesh = mesh;
    command->brush = brush;
}

Referenced by d2d_device_context_FillMesh().

d2d_command_list_fill_opacity_mask()

void d2d_command_list_fill_opacity_mask	(	struct d2d_command_list *	command_list,
		const struct d2d_device_context *	context,
		ID2D1Bitmap *	bitmap,
		ID2D1Brush *	orig_brush,
		const D2D1_RECT_F *	dst_rect,
		const D2D1_RECT_F *	src_rect
	)

Definition at line 1073 of file command_list.c.

{
    struct d2d_command_fill_opacity_mask *command;
    ID2D1Brush *brush;
    size_t size;
    BYTE *data;
 
    if (FAILED(d2d_command_list_create_brush(command_list, context, orig_brush, &brush)))
    {
        command_list->state = D2D_COMMAND_LIST_STATE_ERROR;
        return;
    }
 
    size = sizeof(*command);
    if (dst_rect) size += sizeof(*dst_rect);
    if (src_rect) size += sizeof(*src_rect);
 
    d2d_command_list_reference_object(command_list, bitmap);
 
    command = d2d_command_list_require_space(command_list, size);
    command->c.op = D2D_COMMAND_FILL_OPACITY_MASK;
    command->bitmap = bitmap;
    command->brush = brush;
 
    data = (BYTE *)(command + 1);
 
    d2d_command_list_write_field(&data, &command->dst_rect, dst_rect, sizeof(*dst_rect));
    d2d_command_list_write_field(&data, &command->src_rect, src_rect, sizeof(*src_rect));
}

Referenced by d2d_device_context_FillOpacityMask(), and d2d_device_context_ID2D1DeviceContext_FillOpacityMask().

d2d_command_list_fill_rectangle()

void d2d_command_list_fill_rectangle	(	struct d2d_command_list *	command_list,
		const struct d2d_device_context *	context,
		const D2D1_RECT_F *	rect,
		ID2D1Brush *	orig_brush
	)

Definition at line 855 of file command_list.c.

{
    struct d2d_command_fill_rectangle *command;
    ID2D1Brush *brush;
 
    if (FAILED(d2d_command_list_create_brush(command_list, context, orig_brush, &brush)))
    {
        command_list->state = D2D_COMMAND_LIST_STATE_ERROR;
        return;
    }
 
    command = d2d_command_list_require_space(command_list, sizeof(*command));
    command->c.op = D2D_COMMAND_FILL_RECTANGLE;
    command->rect = *rect;
    command->brush = brush;
}

Referenced by d2d_device_context_FillRectangle().

d2d_command_list_pop_clip()

void d2d_command_list_pop_clip

(

struct d2d_command_list *

command_list

)

Definition at line 707 of file command_list.c.

{
    struct d2d_command *command;
 
    command = d2d_command_list_require_space(command_list, sizeof(*command));
    command->op = D2D_COMMAND_POP_CLIP;
}

Referenced by d2d_device_context_PopAxisAlignedClip().

d2d_command_list_pop_layer()

void d2d_command_list_pop_layer

(

struct d2d_command_list *

command_list

)

Definition at line 738 of file command_list.c.

{
    struct d2d_command *command;
 
    command = d2d_command_list_require_space(command_list, sizeof(*command));
    command->op = D2D_COMMAND_POP_LAYER;
}

Referenced by d2d_device_context_PopLayer().

d2d_command_list_push_clip()

void d2d_command_list_push_clip	(	struct d2d_command_list *	command_list,
		const D2D1_RECT_F *	rect,
		D2D1_ANTIALIAS_MODE	antialias_mode
	)

Definition at line 696 of file command_list.c.

{
    struct d2d_command_push_clip *command;
 
    command = d2d_command_list_require_space(command_list, sizeof(*command));
    command->c.op = D2D_COMMAND_PUSH_CLIP;
    command->rect = *rect;
    command->mode = mode;
}

Referenced by d2d_device_context_PushAxisAlignedClip().

d2d_command_list_push_layer()

void d2d_command_list_push_layer	(	struct d2d_command_list *	command_list,
		const struct d2d_device_context *	context,
		const D2D1_LAYER_PARAMETERS1 *	params,
		ID2D1Layer *	layer
	)

Definition at line 715 of file command_list.c.

{
    struct d2d_command_push_layer *command;
    ID2D1Brush *opacity_brush = NULL;
 
    if (params->opacityBrush && FAILED(d2d_command_list_create_brush(command_list, context,
            params->opacityBrush, &opacity_brush)))
    {
        command_list->state = D2D_COMMAND_LIST_STATE_ERROR;
        return;
    }
 
    d2d_command_list_reference_object(command_list, layer);
    d2d_command_list_reference_object(command_list, params->geometricMask);
 
    command = d2d_command_list_require_space(command_list, sizeof(*command));
    command->c.op = D2D_COMMAND_PUSH_LAYER;
    command->params = *params;
    command->params.opacityBrush = opacity_brush;
    command->layer = layer;
}

Referenced by d2d_device_context_ID2D1DeviceContext_PushLayer(), and d2d_device_context_PushLayer().

d2d_command_list_set_antialias_mode()

void d2d_command_list_set_antialias_mode	(	struct d2d_command_list *	command_list,
		D2D1_ANTIALIAS_MODE	mode
	)

Definition at line 617 of file command_list.c.

{
    struct d2d_command_set_antialias_mode *command;
 
    command = d2d_command_list_require_space(command_list, sizeof(*command));
    command->c.op = D2D_COMMAND_SET_ANTIALIAS_MODE;
    command->mode = mode;
}

Referenced by d2d_command_list_begin_draw(), d2d_device_context_RestoreDrawingState(), and d2d_device_context_SetAntialiasMode().

d2d_command_list_set_primitive_blend()

void d2d_command_list_set_primitive_blend	(	struct d2d_command_list *	command_list,
		D2D1_PRIMITIVE_BLEND	primitive_blend
	)

Definition at line 627 of file command_list.c.

{
    struct d2d_command_set_primitive_blend *command;
 
    command = d2d_command_list_require_space(command_list, sizeof(*command));
    command->c.op = D2D_COMMAND_SET_PRIMITIVE_BLEND;
    command->primitive_blend = primitive_blend;
}

Referenced by d2d_command_list_begin_draw(), d2d_device_context_RestoreDrawingState(), and d2d_device_context_SetPrimitiveBlend().

d2d_command_list_set_tags()

void d2d_command_list_set_tags	(	struct d2d_command_list *	command_list,
		D2D1_TAG	tag1,
		D2D1_TAG	tag2
	)

Definition at line 656 of file command_list.c.

{
    struct d2d_command_set_tags *command;
 
    command = d2d_command_list_require_space(command_list, sizeof(*command));
    command->c.op = D2D_COMMAND_SET_TAGS;
    command->tag1 = tag1;
    command->tag2 = tag2;
}

Referenced by d2d_command_list_begin_draw(), d2d_device_context_RestoreDrawingState(), and d2d_device_context_SetTags().

d2d_command_list_set_text_antialias_mode()

void d2d_command_list_set_text_antialias_mode	(	struct d2d_command_list *	command_list,
		D2D1_TEXT_ANTIALIAS_MODE	mode
	)

Definition at line 646 of file command_list.c.

{
    struct d2d_command_set_text_antialias_mode *command;
 
    command = d2d_command_list_require_space(command_list, sizeof(*command));
    command->c.op = D2D_COMMAND_SET_TEXT_ANTIALIAS_MODE;
    command->mode = mode;
}

Referenced by d2d_command_list_begin_draw(), d2d_device_context_RestoreDrawingState(), and d2d_device_context_SetTextAntialiasMode().

d2d_command_list_set_text_rendering_params()

void d2d_command_list_set_text_rendering_params	(	struct d2d_command_list *	command_list,
		IDWriteRenderingParams *	params
	)

Definition at line 898 of file command_list.c.

{
    d2d_command_list_set_text_rendering_params_internal(command_list, FALSE, params);
}

Referenced by d2d_command_list_begin_draw(), d2d_device_context_RestoreDrawingState(), and d2d_device_context_SetTextRenderingParams().

d2d_command_list_set_transform()

void d2d_command_list_set_transform	(	struct d2d_command_list *	command_list,
		const D2D1_MATRIX_3X2_F *	transform
	)

Definition at line 666 of file command_list.c.

{
    struct d2d_command_set_transform *command;
 
    command = d2d_command_list_require_space(command_list, sizeof(*command));
    command->c.op = D2D_COMMAND_SET_TRANSFORM;
    command->transform = *transform;
}

Referenced by d2d_command_list_begin_draw(), d2d_device_context_RestoreDrawingState(), and d2d_device_context_SetTransform().

d2d_command_list_set_unit_mode()

void d2d_command_list_set_unit_mode	(	struct d2d_command_list *	command_list,
		D2D1_UNIT_MODE	mode
	)

Definition at line 637 of file command_list.c.

{
    struct d2d_command_set_unit_mode *command;
 
    command = d2d_command_list_require_space(command_list, sizeof(*command));
    command->c.op = D2D_COMMAND_SET_UNIT_MODE;
    command->mode = mode;
}

Referenced by d2d_command_list_begin_draw(), d2d_device_context_RestoreDrawingState(), and d2d_device_context_SetUnitMode().

d2d_d3d_create_render_target()

HRESULT d2d_d3d_create_render_target	(	struct d2d_device *	device,
		IDXGISurface *	surface,
		IUnknown *	outer_unknown,
		const struct d2d_device_context_ops *	ops,
		const D2D1_RENDER_TARGET_PROPERTIES *	desc,
		void **	render_target
	)

Definition at line 4183 of file device.c.

{
    D2D1_BITMAP_PROPERTIES1 bitmap_desc;
    struct d2d_device_context *object;
    ID2D1Bitmap1 *bitmap;
    HRESULT hr;
 
    if (desc->type != D2D1_RENDER_TARGET_TYPE_DEFAULT && desc->type != D2D1_RENDER_TARGET_TYPE_HARDWARE)
        WARN("Ignoring render target type %#x.\n", desc->type);
    if (desc->usage != D2D1_RENDER_TARGET_USAGE_NONE)
        FIXME("Ignoring render target usage %#x.\n", desc->usage);
    if (desc->minLevel != D2D1_FEATURE_LEVEL_DEFAULT)
        WARN("Ignoring feature level %#x.\n", desc->minLevel);
 
    bitmap_desc.dpiX = desc->dpiX;
    bitmap_desc.dpiY = desc->dpiY;
 
    if (bitmap_desc.dpiX == 0.0f && bitmap_desc.dpiY == 0.0f)
    {
        bitmap_desc.dpiX = 96.0f;
        bitmap_desc.dpiY = 96.0f;
    }
    else if (bitmap_desc.dpiX <= 0.0f || bitmap_desc.dpiY <= 0.0f)
        return E_INVALIDARG;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    if (FAILED(hr = d2d_device_context_init(object, device, outer_unknown, ops)))
    {
        WARN("Failed to initialise render target, hr %#lx.\n", hr);
        free(object);
        return hr;
    }
 
    ID2D1DeviceContext6_SetDpi(&object->ID2D1DeviceContext6_iface, bitmap_desc.dpiX, bitmap_desc.dpiY);
 
    if (surface)
    {
        bitmap_desc.pixelFormat = desc->pixelFormat;
        bitmap_desc.bitmapOptions = D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW;
        if (desc->usage & D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE)
            bitmap_desc.bitmapOptions |= D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE;
        bitmap_desc.colorContext = NULL;
 
        if (FAILED(hr = ID2D1DeviceContext6_CreateBitmapFromDxgiSurface(&object->ID2D1DeviceContext6_iface,
                surface, &bitmap_desc, &bitmap)))
        {
            WARN("Failed to create target bitmap, hr %#lx.\n", hr);
            IUnknown_Release(&object->IUnknown_iface);
            return hr;
        }
 
        ID2D1DeviceContext6_SetTarget(&object->ID2D1DeviceContext6_iface, (ID2D1Image *)bitmap);
        ID2D1Bitmap1_Release(bitmap);
    }
    else
        object->desc.pixelFormat = desc->pixelFormat;
 
    TRACE("Created render target %p.\n", object);
    *render_target = outer_unknown ? &object->IUnknown_iface : (IUnknown *)&object->ID2D1DeviceContext6_iface;
 
    return S_OK;
}

Referenced by d2d_bitmap_render_target_init(), d2d_dc_render_target_init(), d2d_factory_CreateDxgiSurfaceRenderTarget(), d2d_hwnd_render_target_init(), and d2d_wic_render_target_init().

d2d_dc_render_target_init()

HRESULT d2d_dc_render_target_init	(	struct d2d_dc_render_target *	render_target,
		ID2D1Factory1 *	factory,
		ID3D10Device1 *	d3d_device,
		const D2D1_RENDER_TARGET_PROPERTIES *	desc
	)

Definition at line 825 of file dc_render_target.c.

{
    IDXGIDevice *dxgi_device;
    ID2D1Device *device;
    HRESULT hr;
 
    render_target->ID2D1DCRenderTarget_iface.lpVtbl = &d2d_dc_render_target_vtbl;
 
    /* Set with BindDC(). */
    SetRectEmpty(&render_target->dst_rect);
    render_target->hdc = NULL;
 
    render_target->desc = *desc;
    render_target->desc.usage |= D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE;
 
    switch (desc->pixelFormat.format)
    {
        case DXGI_FORMAT_B8G8R8A8_UNORM:
            if (desc->pixelFormat.alphaMode == D2D1_ALPHA_MODE_PREMULTIPLIED
                    || desc->pixelFormat.alphaMode == D2D1_ALPHA_MODE_IGNORE)
                break;
 
        default:
            FIXME("Unhandled format %#x, alpha mode %u.\n", desc->pixelFormat.format, desc->pixelFormat.alphaMode);
            return D2DERR_UNSUPPORTED_PIXEL_FORMAT;
    }
 
    if (FAILED(hr = ID3D10Device1_QueryInterface(d3d_device, &IID_IDXGIDevice, (void **)&dxgi_device)))
    {
        WARN("Failed to get DXGI device interface, hr %#lx.\n", hr);
        return hr;
    }
 
    hr = d2d_factory_create_device(factory, dxgi_device, false, &IID_ID2D1Device, (void **)&device);
    IDXGIDevice_Release(dxgi_device);
    if (FAILED(hr))
    {
        WARN("Failed to create D2D device, hr %#lx.\n", hr);
        return hr;
    }
 
    hr = d2d_d3d_create_render_target(unsafe_impl_from_ID2D1Device((ID2D1Device1* )device), NULL,
            (IUnknown *)&render_target->ID2D1DCRenderTarget_iface, &d2d_dc_render_target_ops,
            desc, (void **)&render_target->dxgi_inner);
    ID2D1Device_Release(device);
    if (FAILED(hr))
    {
        WARN("Failed to create DXGI surface render target, hr %#lx.\n", hr);
        return hr;
    }
 
    if (FAILED(hr = IUnknown_QueryInterface(render_target->dxgi_inner,
            &IID_ID2D1RenderTarget, (void **)&render_target->dxgi_target)))
    {
        WARN("Failed to retrieve ID2D1RenderTarget interface, hr %#lx.\n", hr);
        IUnknown_Release(render_target->dxgi_inner);
        return hr;
    }
 
    render_target->d3d_device = d3d_device;
    ID3D10Device1_AddRef(render_target->d3d_device);
 
    return S_OK;
}

Referenced by d2d_factory_CreateDCRenderTarget().

d2d_device_add_indexed_object()

HRESULT d2d_device_add_indexed_object	(	struct d2d_indexed_objects *	objects,
		const GUID *	id,
		IUnknown *	object
	)

Definition at line 4542 of file device.c.

{
    if (!d2d_array_reserve((void **)&objects->elements, &objects->size, objects->count + 1,
            sizeof(*objects->elements)))
    {
        WARN("Failed to resize elements array.\n");
        return E_OUTOFMEMORY;
    }
 
    objects->elements[objects->count].id = *id;
    objects->elements[objects->count].object = object;
    IUnknown_AddRef(object);
    objects->count++;
 
    return S_OK;
}

Referenced by d2d_effect_context_CreateVertexBuffer(), d2d_effect_context_LoadComputeShader(), d2d_effect_context_LoadPixelShader(), and d2d_effect_context_LoadVertexShader().

d2d_device_context_is_dxgi_target()

static BOOL d2d_device_context_is_dxgi_target ( const struct d2d_device_context *  context )

inlinestatic

Definition at line 230 of file d2d1_private.h.

{
    return !context->ops;
}

Referenced by d2d_bitmap_init().

d2d_device_get_indexed_object()

BOOL d2d_device_get_indexed_object	(	struct d2d_indexed_objects *	objects,
		const GUID *	id,
		IUnknown **	object
	)

Definition at line 4560 of file device.c.

{
    size_t i;
 
    for (i = 0; i < objects->count; ++i)
    {
        if (IsEqualGUID(id, &objects->elements[i].id))
        {
            if (object)
            {
                *object = objects->elements[i].object;
                IUnknown_AddRef(*object);
            }
            return TRUE;
        }
    }
 
    if (object) *object = NULL;
    return FALSE;
}

Referenced by d2d_effect_context_CreateVertexBuffer(), d2d_effect_context_FindVertexBuffer(), d2d_effect_context_IsShaderLoaded(), d2d_effect_context_LoadComputeShader(), d2d_effect_context_LoadPixelShader(), and d2d_effect_context_LoadVertexShader().

d2d_device_indexed_objects_clear()

void d2d_device_indexed_objects_clear

(

struct d2d_indexed_objects *

objects

)

Definition at line 4284 of file device.c.

{
    size_t i;
 
    for (i = 0; i < objects->count; ++i)
        IUnknown_Release(objects->elements[i].object);
    free(objects->elements);
    objects->elements = NULL;
}

Referenced by d2d_device_context_inner_Release(), and d2d_device_Release().

d2d_device_init()

void d2d_device_init	(	struct d2d_device *	device,
		ID2D1Factory1 *	factory,
		IDXGIDevice *	dxgi_device,
		bool	allow_get_dxgi_device
	)

Definition at line 4530 of file device.c.

{
    device->ID2D1Device6_iface.lpVtbl = &d2d_device_vtbl;
    device->refcount = 1;
    device->factory = factory;
    ID2D1Factory1_AddRef(device->factory);
    device->dxgi_device = dxgi_device;
    IDXGIDevice_AddRef(device->dxgi_device);
    device->allow_get_dxgi_device = allow_get_dxgi_device;
}

Referenced by d2d_factory_create_device().

d2d_effect_context_init()

void d2d_effect_context_init	(	struct d2d_effect_context *	effect_context,
		struct d2d_device_context *	device_context
	)

Definition at line 1840 of file effect.c.

{
    effect_context->ID2D1EffectContext_iface.lpVtbl = &d2d_effect_context_vtbl;
    effect_context->refcount = 1;
    effect_context->device_context = device_context;
    ID2D1DeviceContext6_AddRef(&device_context->ID2D1DeviceContext6_iface);
}

Referenced by d2d_effect_create().

d2d_effect_create()

HRESULT d2d_effect_create	(	struct d2d_device_context *	context,
		const CLSID *	effect_id,
		ID2D1Effect **	effect
	)

Definition at line 2660 of file effect.c.

{
    struct d2d_effect_context *effect_context;
    const struct d2d_effect_registration *reg;
    struct d2d_effect *object;
    UINT32 input_count;
    WCHAR clsidW[39];
    HRESULT hr;
 
    if (!(reg = d2d_factory_get_registered_effect(context->factory, effect_id)))
    {
        WARN("Effect id %s not found.\n", wine_dbgstr_guid(effect_id));
        return D2DERR_EFFECT_IS_NOT_REGISTERED;
    }
 
    if (!(effect_context = calloc(1, sizeof(*effect_context))))
        return E_OUTOFMEMORY;
    d2d_effect_context_init(effect_context, context);
 
    if (!(object = calloc(1, sizeof(*object))))
    {
        ID2D1EffectContext_Release(&effect_context->ID2D1EffectContext_iface);
        return E_OUTOFMEMORY;
    }
 
    object->ID2D1Effect_iface.lpVtbl = &d2d_effect_vtbl;
    object->ID2D1Image_iface.lpVtbl = &d2d_effect_image_vtbl;
    object->refcount = 1;
    object->effect_context = effect_context;
 
    /* Create properties */
    d2d_effect_duplicate_properties(object, &object->properties, reg->properties);
 
    StringFromGUID2(effect_id, clsidW, ARRAY_SIZE(clsidW));
    d2d_effect_properties_add(&object->properties, L"CLSID", D2D1_PROPERTY_CLSID, D2D1_PROPERTY_TYPE_CLSID, clsidW);
    d2d_effect_properties_add(&object->properties, L"Cached", D2D1_PROPERTY_CACHED, D2D1_PROPERTY_TYPE_BOOL, L"false");
    d2d_effect_properties_add(&object->properties, L"Precision", D2D1_PROPERTY_PRECISION, D2D1_PROPERTY_TYPE_ENUM, L"0");
 
    /* Sync instance input count with default input count from the description. */
    d2d_effect_get_value(object, D2D1_PROPERTY_INPUTS, D2D1_PROPERTY_TYPE_ARRAY, (BYTE *)&input_count, sizeof(input_count));
    d2d_effect_set_input_count(object, input_count);
 
    if (FAILED(hr = d2d_transform_graph_create(input_count, &object->graph)))
    {
        ID2D1EffectContext_Release(&effect_context->ID2D1EffectContext_iface);
        return hr;
    }
 
    if (FAILED(hr = reg->factory((IUnknown **)&object->impl)))
    {
        WARN("Failed to create implementation object, hr %#lx.\n", hr);
        ID2D1Effect_Release(&object->ID2D1Effect_iface);
        return hr;
    }
 
    if (FAILED(hr = ID2D1EffectImpl_Initialize(object->impl, &effect_context->ID2D1EffectContext_iface,
            &object->graph->ID2D1TransformGraph_iface)))
    {
        WARN("Failed to initialize effect, hr %#lx.\n", hr);
        ID2D1Effect_Release(&object->ID2D1Effect_iface);
        return hr;
    }
 
    if (FAILED(hr = d2d_effect_transform_graph_initialize_nodes(object->graph)))
    {
        WARN("Failed to initialize graph nodes, hr %#lx.\n", hr);
        ID2D1Effect_Release(&object->ID2D1Effect_iface);
        return hr;
    }
 
    *effect = &object->ID2D1Effect_iface;
 
    TRACE("Created effect %p.\n", *effect);
 
    return S_OK;
}

Referenced by d2d_device_context_CreateEffect().

d2d_effect_init_properties()

void d2d_effect_init_properties	(	struct d2d_effect *	effect,
		struct d2d_effect_properties *	properties
	)

Definition at line 2440 of file effect.c.

{
    properties->ID2D1Properties_iface.lpVtbl = &d2d_effect_properties_vtbl;
    properties->effect = effect;
    properties->refcount = 1;
}

Referenced by d2d_factory_register_effect_from_stream(), and parse_effect_inputs().

d2d_effect_properties_add()

HRESULT d2d_effect_properties_add	(	struct d2d_effect_properties *	props,
		const WCHAR *	name,
		UINT32	index,
		D2D1_PROPERTY_TYPE	type,
		const WCHAR *	value
	)

Definition at line 1281 of file effect.c.

{
    return d2d_effect_properties_internal_add(props, name, index, FALSE, type, value);
}

Referenced by d2d_effect_create(), parse_effect_inputs(), and parse_effect_property().

d2d_effect_properties_cleanup()

void d2d_effect_properties_cleanup

(

struct d2d_effect_properties *

props

)

Definition at line 1457 of file effect.c.

{
    struct d2d_effect_property *p;
    size_t i;
 
    for (i = 0; i < props->count; ++i)
    {
        p = &props->properties[i];
        free(p->name);
        if (p->type == D2D1_PROPERTY_TYPE_STRING)
            free(p->data.ptr);
        if (p->subproperties)
        {
            d2d_effect_properties_cleanup(p->subproperties);
            free(p->subproperties);
        }
    }
    free(props->properties);
    free(props->data.ptr);
}

Referenced by d2d_effect_cleanup(), d2d_effect_properties_cleanup(), and d2d_effect_properties_Release().

d2d_effect_properties_get_property_by_name()

struct d2d_effect_property * d2d_effect_properties_get_property_by_name	(	const struct d2d_effect_properties *	properties,
		const WCHAR *	name
	)

Definition at line 1345 of file effect.c.

{
    unsigned int i;
 
    for (i = 0; i < properties->count; ++i)
    {
        if (!wcscmp(properties->properties[i].name, name))
            return &properties->properties[i];
    }
 
    return NULL;
}

Referenced by d2d_effect_properties_GetPropertyIndex(), d2d_effect_properties_GetValueByName(), d2d_effect_properties_SetValueByName(), and parse_effect_inputs().

d2d_effect_property_get_uint32_value()

HRESULT d2d_effect_property_get_uint32_value	(	const struct d2d_effect_properties *	properties,
		const struct d2d_effect_property *	prop,
		UINT32 *	value
	)

Definition at line 1422 of file effect.c.

{
    return d2d_effect_property_get_value(properties, prop, D2D1_PROPERTY_TYPE_UINT32,
            (BYTE *)value, sizeof(*value));
}

Referenced by parse_effect_inputs().

d2d_effect_subproperties_add()

HRESULT d2d_effect_subproperties_add	(	struct d2d_effect_properties *	props,
		const WCHAR *	name,
		UINT32	index,
		D2D1_PROPERTY_TYPE	type,
		const WCHAR *	value
	)

Definition at line 1287 of file effect.c.

{
    return d2d_effect_properties_internal_add(props, name, index, TRUE, type, value);
}

Referenced by parse_effect_inputs().

d2d_effects_init_builtins()

void d2d_effects_init_builtins

(

struct d2d_factory *

factory

)

Definition at line 1074 of file effect.c.

{
    static const struct builtin_description
    {
        const CLSID *clsid;
        const WCHAR *description;
    }
    builtin_effects[] =
    {
        { &CLSID_D2D12DAffineTransform, _2d_affine_transform_description },
        { &CLSID_D2D13DPerspectiveTransform, _3d_perspective_transform_description},
        { &CLSID_D2D1Composite, composite_description },
        { &CLSID_D2D1Crop, crop_description },
        { &CLSID_D2D1Shadow, shadow_description },
        { &CLSID_D2D1Grayscale, grayscale_description },
    };
    unsigned int i;
    HRESULT hr;
 
    for (i = 0; i < ARRAY_SIZE(builtin_effects); ++i)
    {
        if (FAILED(hr = d2d_factory_register_builtin_effect(factory, builtin_effects[i].clsid, builtin_effects[i].description,
                NULL, 0, builtin_factory_stub)))
        {
            WARN("Failed to register the effect %s, hr %#lx.\n", wine_dbgstr_guid(builtin_effects[i].clsid), hr);
        }
    }
}

Referenced by d2d_factory_builtins_initonce().

d2d_ellipse_geometry_init()

HRESULT d2d_ellipse_geometry_init	(	struct d2d_geometry *	geometry,
		ID2D1Factory *	factory,
		const D2D1_ELLIPSE *	ellipse
	)

Definition at line 4185 of file geometry.c.

{
    D2D1_POINT_2F *v, v1, v2, v3, v4;
    struct d2d_face *f;
    float l, r, t, b;
 
    d2d_geometry_init(geometry, factory, &identity, (ID2D1GeometryVtbl *)&d2d_ellipse_geometry_vtbl);
    geometry->u.ellipse.ellipse = *ellipse;
 
    if (!(geometry->fill.vertices = malloc(4 * sizeof(*geometry->fill.vertices))))
        goto fail;
    if (!d2d_array_reserve((void **)&geometry->fill.faces,
            &geometry->fill.faces_size, 2, sizeof(*geometry->fill.faces)))
        goto fail;
 
    l = ellipse->point.x - ellipse->radiusX;
    r = ellipse->point.x + ellipse->radiusX;
    t = ellipse->point.y - ellipse->radiusY;
    b = ellipse->point.y + ellipse->radiusY;
 
    d2d_point_set(&v1, r, t);
    d2d_point_set(&v2, r, b);
    d2d_point_set(&v3, l, b);
    d2d_point_set(&v4, l, t);
 
    v = geometry->fill.vertices;
    d2d_point_set(&v[0], ellipse->point.x, t);
    d2d_point_set(&v[1], r, ellipse->point.y);
    d2d_point_set(&v[2], ellipse->point.x, b);
    d2d_point_set(&v[3], l, ellipse->point.y);
    geometry->fill.vertex_count = 4;
 
    f = geometry->fill.faces;
    d2d_face_set(&f[0], 0, 3, 2);
    d2d_face_set(&f[1], 0, 2, 1);
    geometry->fill.face_count = 2;
 
    if (!d2d_geometry_fill_add_arc_triangle(geometry, &v[0], &v1, &v[1]))
        goto fail;
    if (!d2d_geometry_fill_add_arc_triangle(geometry, &v[1], &v2, &v[2]))
        goto fail;
    if (!d2d_geometry_fill_add_arc_triangle(geometry, &v[2], &v3, &v[3]))
        goto fail;
    if (!d2d_geometry_fill_add_arc_triangle(geometry, &v[3], &v4, &v[0]))
        goto fail;
 
    if (!d2d_geometry_outline_add_arc_quadrant(geometry, &v[0], &v1, &v[1]))
        goto fail;
    if (!d2d_geometry_outline_add_arc_quadrant(geometry, &v[1], &v2, &v[2]))
        goto fail;
    if (!d2d_geometry_outline_add_arc_quadrant(geometry, &v[2], &v3, &v[3]))
        goto fail;
    if (!d2d_geometry_outline_add_arc_quadrant(geometry, &v[3], &v4, &v[0]))
        goto fail;
 
    return S_OK;
 
fail:
    d2d_geometry_cleanup(geometry);
    return E_OUTOFMEMORY;
}

Referenced by d2d_factory_CreateEllipseGeometry().

d2d_factory_create_device()

HRESULT d2d_factory_create_device	(	ID2D1Factory1 *	factory,
		IDXGIDevice *	dxgi_device,
		bool	allow_get_dxgi_device,
		REFIID	iid,
		void **	device
	)

Definition at line 516 of file factory.c.

{
    struct d2d_device *object;
    HRESULT hr;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    d2d_device_init(object, factory, dxgi_device, allow_get_dxgi_device);
 
    TRACE("Create device %p.\n", object);
 
    hr = ID2D1Device6_QueryInterface(&object->ID2D1Device6_iface, iid, device);
    ID2D1Device6_Release(&object->ID2D1Device6_iface);
 
    return hr;
}

Referenced by d2d_dc_render_target_init(), d2d_factory_CreateDevice(), d2d_factory_ID2D1Factory2_CreateDevice(), d2d_factory_ID2D1Factory3_CreateDevice(), d2d_factory_ID2D1Factory4_CreateDevice(), d2d_factory_ID2D1Factory5_CreateDevice(), d2d_factory_ID2D1Factory6_CreateDevice(), d2d_factory_ID2D1Factory7_CreateDevice(), d2d_hwnd_render_target_init(), and d2d_wic_render_target_init().

d2d_factory_get_registered_effect()

struct d2d_effect_registration * d2d_factory_get_registered_effect	(	ID2D1Factory *	factory,
		const GUID *	effect_id
	)

Definition at line 66 of file factory.c.

{
    struct d2d_factory *factory = unsafe_impl_from_ID2D1Factory(iface);
    struct d2d_effect_registration *reg;
 
    d2d_factory_init_builtin_effects(factory);
 
    LIST_FOR_EACH_ENTRY(reg, &factory->effects, struct d2d_effect_registration, entry)
    {
        if (IsEqualGUID(id, &reg->id)) return reg;
    }
 
    return NULL;
}

Referenced by d2d_effect_create(), and d2d_factory_GetEffectProperties().

d2d_factory_register_builtin_effect()

HRESULT d2d_factory_register_builtin_effect	(	struct d2d_factory *	factory,
		REFCLSID	effect_id,
		const WCHAR *	property_xml,
		const D2D1_PROPERTY_BINDING *	bindings,
		UINT32	binding_count,
		PD2D1_EFFECT_FACTORY	effect_factory
	)

Definition at line 1081 of file factory.c.

{
    return d2d_factory_register_effect_from_string(factory, effect_id, property_xml, bindings,
            binding_count, effect_factory, TRUE);
}

Referenced by d2d_effects_init_builtins().

d2d_factory_register_effect()

void d2d_factory_register_effect	(	struct d2d_factory *	factory,
		struct d2d_effect_registration *	effect
	)

Definition at line 61 of file factory.c.

{
    list_add_tail(&factory->effects, &effect->entry);
}

Referenced by d2d_factory_register_effect_from_stream().

d2d_geometry_group_init()

HRESULT d2d_geometry_group_init	(	struct d2d_geometry *	geometry,
		ID2D1Factory *	factory,
		D2D1_FILL_MODE	fill_mode,
		ID2D1Geometry **	src_geometries,
		unsigned int	geometry_count
	)

Definition at line 5497 of file geometry.c.

{
    unsigned int i;
 
    d2d_geometry_init(geometry, factory, &identity, (ID2D1GeometryVtbl *)&d2d_geometry_group_vtbl);
 
    if (!(geometry->u.group.src_geometries = calloc(geometry_count, sizeof(*geometries))))
    {
        d2d_geometry_cleanup(geometry);
        return E_OUTOFMEMORY;
    }
 
    for (i = 0; i < geometry_count; ++i)
    {
        ID2D1Geometry_AddRef(geometry->u.group.src_geometries[i] = geometries[i]);
    }
    geometry->u.group.geometry_count = geometry_count;
    geometry->u.group.fill_mode = fill_mode;
 
    return S_OK;
}

Referenced by d2d_factory_CreateGeometryGroup().

d2d_get_bitmap_options_for_surface()

unsigned int d2d_get_bitmap_options_for_surface

(

IDXGISurface *

surface

)

Definition at line 498 of file bitmap.c.

{
    D3D11_TEXTURE2D_DESC desc;
    unsigned int options = 0;
    ID3D11Texture2D *texture;
 
    if (FAILED(IDXGISurface_QueryInterface(surface, &IID_ID3D11Texture2D, (void **)&texture)))
        return 0;
 
    ID3D11Texture2D_GetDesc(texture, &desc);
    ID3D11Texture2D_Release(texture);
 
    if (desc.BindFlags & D3D11_BIND_RENDER_TARGET)
        options |= D2D1_BITMAP_OPTIONS_TARGET;
    if (!(desc.BindFlags & D3D11_BIND_SHADER_RESOURCE))
        options |= D2D1_BITMAP_OPTIONS_CANNOT_DRAW;
    if (desc.MiscFlags & D3D11_RESOURCE_MISC_GDI_COMPATIBLE)
        options |= D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE;
    if (desc.Usage == D3D11_USAGE_STAGING && desc.CPUAccessFlags & D3D11_CPU_ACCESS_READ)
        options |= D2D1_BITMAP_OPTIONS_CPU_READ;
 
    return options;
}

Referenced by d2d_bitmap_create_shared(), d2d_device_context_CreateBitmapFromDxgiSurface(), and d2d_device_context_CreateSharedBitmap().

d2d_gradient_create()

HRESULT d2d_gradient_create	(	ID2D1Factory *	factory,
		ID3D11Device1 *	device,
		const D2D1_GRADIENT_STOP *	stops,
		UINT32	stop_count,
		D2D1_GAMMA	gamma,
		D2D1_EXTEND_MODE	extend_mode,
		struct d2d_gradient **	gradient
	)

Definition at line 130 of file brush.c.

{
    D3D11_SHADER_RESOURCE_VIEW_DESC srv_desc;
    D3D11_SUBRESOURCE_DATA buffer_data;
    ID3D11ShaderResourceView *view;
    struct d2d_gradient *gradient;
    D3D11_BUFFER_DESC buffer_desc;
    struct d2d_vec4 *data;
    ID3D11Buffer *buffer;
    unsigned int i;
    HRESULT hr;
 
    *out = NULL;
    if (!(data = calloc(stop_count, 2 * sizeof(*data))))
    {
        ERR("Failed to allocate data.\n");
        return E_OUTOFMEMORY;
    }
 
    for (i = 0; i < stop_count; ++i)
    {
        data[i * 2].x = stops[i].position;
        data[i * 2 + 1].x = stops[i].color.r;
        data[i * 2 + 1].y = stops[i].color.g;
        data[i * 2 + 1].z = stops[i].color.b;
        data[i * 2 + 1].w = stops[i].color.a;
    }
 
    buffer_desc.ByteWidth = 2 * stop_count * sizeof(*data);
    buffer_desc.Usage = D3D11_USAGE_DEFAULT;
    buffer_desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
    buffer_desc.CPUAccessFlags = 0;
    buffer_desc.MiscFlags = 0;
 
    buffer_data.pSysMem = data;
    buffer_data.SysMemPitch = 0;
    buffer_data.SysMemSlicePitch = 0;
 
    hr = ID3D11Device1_CreateBuffer(device, &buffer_desc, &buffer_data, &buffer);
    free(data);
    if (FAILED(hr))
    {
        ERR("Failed to create buffer, hr %#lx.\n", hr);
        return hr;
    }
 
    srv_desc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
    srv_desc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER;
    srv_desc.Buffer.ElementOffset = 0;
    srv_desc.Buffer.ElementWidth = 2 * stop_count;
 
    hr = ID3D11Device1_CreateShaderResourceView(device, (ID3D11Resource *)buffer, &srv_desc, &view);
    ID3D11Buffer_Release(buffer);
    if (FAILED(hr))
    {
        ERR("Failed to create view, hr %#lx.\n", hr);
        return hr;
    }
 
    if (!(gradient = calloc(1, sizeof(*gradient))))
    {
        ID3D11ShaderResourceView_Release(view);
        return E_OUTOFMEMORY;
    }
 
    if (gamma != D2D1_GAMMA_2_2)
        FIXME("Ignoring gamma %#x.\n", gamma);
    if (extend_mode != D2D1_EXTEND_MODE_CLAMP)
        FIXME("Ignoring extend mode %#x.\n", extend_mode);
 
    gradient->ID2D1GradientStopCollection_iface.lpVtbl = &d2d_gradient_vtbl;
    gradient->refcount = 1;
    ID2D1Factory_AddRef(gradient->factory = factory);
    gradient->view = view;
 
    gradient->stop_count = stop_count;
    if (!(gradient->stops = calloc(stop_count, sizeof(*stops))))
    {
        ID3D11ShaderResourceView_Release(view);
        free(gradient);
        return E_OUTOFMEMORY;
    }
    memcpy(gradient->stops, stops, stop_count * sizeof(*stops));
 
    TRACE("Created gradient %p.\n", gradient);
    *out = gradient;
    return S_OK;
}

Referenced by d2d_device_context_CreateGradientStopCollection().

d2d_hwnd_render_target_init()

HRESULT d2d_hwnd_render_target_init	(	struct d2d_hwnd_render_target *	render_target,
		ID2D1Factory1 *	factory,
		ID3D10Device1 *	d3d_device,
		const D2D1_RENDER_TARGET_PROPERTIES *	desc,
		const D2D1_HWND_RENDER_TARGET_PROPERTIES *	hwnd_desc
	)

Definition at line 813 of file hwnd_render_target.c.

{
    D2D1_RENDER_TARGET_PROPERTIES dxgi_rt_desc;
    DXGI_SWAP_CHAIN_DESC swapchain_desc;
    IDXGIAdapter *dxgi_adapter;
    IDXGIFactory *dxgi_factory;
    IDXGISurface *dxgi_surface;
    IDXGIDevice *dxgi_device;
    ID2D1Device *device;
    HRESULT hr;
 
    if (!IsWindow(hwnd_rt_desc->hwnd))
        return HRESULT_FROM_WIN32(ERROR_INVALID_WINDOW_HANDLE);
 
    render_target->ID2D1HwndRenderTarget_iface.lpVtbl = &d2d_hwnd_render_target_vtbl;
    render_target->hwnd = hwnd_rt_desc->hwnd;
    render_target->sync_interval = hwnd_rt_desc->presentOptions & D2D1_PRESENT_OPTIONS_IMMEDIATELY ? 0 : 1;
 
    if (FAILED(hr = ID3D10Device1_QueryInterface(d3d_device, &IID_IDXGIDevice, (void **)&dxgi_device)))
    {
        WARN("Failed to get IDXGIDevice interface, hr %#lx.\n", hr);
        return hr;
    }
 
    hr = IDXGIDevice_GetAdapter(dxgi_device, &dxgi_adapter);
    IDXGIDevice_Release(dxgi_device);
    if (FAILED(hr))
    {
        WARN("Failed to get IDXGIAdapter interface, hr %#lx.\n", hr);
        return hr;
    }
 
    hr = IDXGIAdapter_GetParent(dxgi_adapter, &IID_IDXGIFactory, (void **)&dxgi_factory);
    IDXGIAdapter_Release(dxgi_adapter);
    if (FAILED(hr))
    {
        WARN("Failed to get IDXGIFactory interface, hr %#lx.\n", hr);
        return hr;
    }
 
    dxgi_rt_desc = *desc;
    if (dxgi_rt_desc.dpiX == 0.0f && dxgi_rt_desc.dpiY == 0.0f)
        ID2D1Factory1_GetDesktopDpi(factory, &dxgi_rt_desc.dpiX, &dxgi_rt_desc.dpiY);
 
    if (dxgi_rt_desc.pixelFormat.format == DXGI_FORMAT_UNKNOWN)
        dxgi_rt_desc.pixelFormat.format = DXGI_FORMAT_B8G8R8A8_UNORM;
 
    if (dxgi_rt_desc.pixelFormat.alphaMode == D2D1_ALPHA_MODE_UNKNOWN)
        dxgi_rt_desc.pixelFormat.alphaMode = D2D1_ALPHA_MODE_IGNORE;
 
    if (dxgi_rt_desc.pixelFormat.alphaMode == D2D1_ALPHA_MODE_STRAIGHT)
    {
        IDXGIFactory_Release(dxgi_factory);
        WARN("Alpha mode %u is not supported.\n", dxgi_rt_desc.pixelFormat.alphaMode);
        return D2DERR_UNSUPPORTED_PIXEL_FORMAT;
    }
 
    render_target->desc = dxgi_rt_desc;
    /* FIXME: should be resolved to either HW or SW type. */
    if (render_target->desc.type == D2D1_RENDER_TARGET_TYPE_DEFAULT)
        render_target->desc.type = D2D1_RENDER_TARGET_TYPE_HARDWARE;
 
    swapchain_desc.BufferDesc.Width = hwnd_rt_desc->pixelSize.width;
    swapchain_desc.BufferDesc.Height = hwnd_rt_desc->pixelSize.height;
    swapchain_desc.BufferDesc.RefreshRate.Numerator = 60;
    swapchain_desc.BufferDesc.RefreshRate.Denominator = 1;
    swapchain_desc.BufferDesc.Format = dxgi_rt_desc.pixelFormat.format;
    swapchain_desc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
    swapchain_desc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
    swapchain_desc.SampleDesc.Count = 1;
    swapchain_desc.SampleDesc.Quality = 0;
    swapchain_desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
    swapchain_desc.BufferCount = 1;
    swapchain_desc.OutputWindow = hwnd_rt_desc->hwnd;
    swapchain_desc.Windowed = TRUE;
    swapchain_desc.SwapEffect = hwnd_rt_desc->presentOptions & D2D1_PRESENT_OPTIONS_RETAIN_CONTENTS ?
        DXGI_SWAP_EFFECT_SEQUENTIAL : DXGI_SWAP_EFFECT_DISCARD;
    swapchain_desc.Flags = 0;
    if (desc->usage & D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE)
        swapchain_desc.Flags = DXGI_SWAP_CHAIN_FLAG_GDI_COMPATIBLE;
 
    hr = IDXGIFactory_CreateSwapChain(dxgi_factory, (IUnknown *)d3d_device, &swapchain_desc, &render_target->swapchain);
    IDXGIFactory_Release(dxgi_factory);
    if (FAILED(hr))
    {
        WARN("Failed to create a swapchain, hr %#lx.\n", hr);
        return hr;
    }
 
    if (FAILED(hr = IDXGISwapChain_GetBuffer(render_target->swapchain, 0, &IID_IDXGISurface, (void **)&dxgi_surface)))
    {
        WARN("Failed to get buffer, hr %#lx.\n", hr);
        IDXGISwapChain_Release(render_target->swapchain);
        return hr;
    }
 
    render_target->ID2D1HwndRenderTarget_iface.lpVtbl = &d2d_hwnd_render_target_vtbl;
 
    if (FAILED(hr = IDXGISurface_GetDevice(dxgi_surface, &IID_IDXGIDevice, (void **)&dxgi_device)))
    {
        WARN("Failed to get DXGI device, hr %#lx.\n", hr);
        IDXGISurface_Release(dxgi_surface);
        IDXGISwapChain_Release(render_target->swapchain);
        return hr;
    }
 
    hr = d2d_factory_create_device(factory, dxgi_device, false, &IID_ID2D1Device, (void **)&device);
    IDXGIDevice_Release(dxgi_device);
    if (FAILED(hr))
    {
        WARN("Failed to create D2D device, hr %#lx.\n", hr);
        IDXGISurface_Release(dxgi_surface);
        IDXGISwapChain_Release(render_target->swapchain);
        return hr;
    }
 
    hr = d2d_d3d_create_render_target(unsafe_impl_from_ID2D1Device((ID2D1Device1 *)device), dxgi_surface,
            (IUnknown *)&render_target->ID2D1HwndRenderTarget_iface, &d2d_hwnd_render_target_ops,
            &dxgi_rt_desc, (void **)&render_target->dxgi_inner);
    IDXGISurface_Release(dxgi_surface);
    ID2D1Device_Release(device);
    if (FAILED(hr))
    {
        WARN("Failed to create DXGI surface render target, hr %#lx.\n", hr);
        IDXGISwapChain_Release(render_target->swapchain);
        return hr;
    }
 
    if (FAILED(hr = IUnknown_QueryInterface(render_target->dxgi_inner,
            &IID_ID2D1RenderTarget, (void **)&render_target->dxgi_target)))
    {
        WARN("Failed to retrieve ID2D1RenderTarget interface, hr %#lx.\n", hr);
        IUnknown_Release(render_target->dxgi_inner);
        IDXGISwapChain_Release(render_target->swapchain);
        return hr;
    }
 
    return S_OK;
}

Referenced by d2d_factory_CreateHwndRenderTarget().

d2d_image_brush_create()

HRESULT d2d_image_brush_create	(	ID2D1Factory *	factory,
		ID2D1Image *	image,
		const D2D1_IMAGE_BRUSH_PROPERTIES *	image_brush_desc,
		const D2D1_BRUSH_PROPERTIES *	brush_desc,
		struct d2d_brush **	brush
	)

Definition at line 1323 of file brush.c.

{
    if (!(*brush = calloc(1, sizeof(**brush))))
        return E_OUTOFMEMORY;
 
    d2d_brush_init(*brush, factory, D2D_BRUSH_TYPE_IMAGE,
            brush_desc, (ID2D1BrushVtbl *)&d2d_image_brush_vtbl);
    if (((*brush)->u.image.image = image))
        ID2D1Image_AddRef((*brush)->u.image.image);
 
    (*brush)->u.image.source_rect = image_brush_desc->sourceRectangle;
    (*brush)->u.image.extend_mode_x = image_brush_desc->extendModeX;
    (*brush)->u.image.extend_mode_y = image_brush_desc->extendModeY;
    (*brush)->u.image.interpolation_mode = image_brush_desc->interpolationMode;
 
    TRACE("Created brush %p.\n", *brush);
    return S_OK;
}

Referenced by d2d_device_context_CreateImageBrush().

d2d_layer_create()

HRESULT d2d_layer_create	(	ID2D1Factory *	factory,
		const D2D1_SIZE_F *	size,
		struct d2d_layer **	layer
	)

Definition at line 101 of file layer.c.

{
    if (!(*layer = calloc(1, sizeof(**layer))))
        return E_OUTOFMEMORY;
 
    (*layer)->ID2D1Layer_iface.lpVtbl = &d2d_layer_vtbl;
    (*layer)->refcount = 1;
    ID2D1Factory_AddRef((*layer)->factory = factory);
    if (size)
        (*layer)->size = *size;
 
    TRACE("Created layer %p.\n", *layer);
 
    return S_OK;
}

Referenced by d2d_device_context_CreateLayer().

d2d_linear_gradient_brush_create()

HRESULT d2d_linear_gradient_brush_create	(	ID2D1Factory *	factory,
		const D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES *	gradient_desc,
		const D2D1_BRUSH_PROPERTIES *	brush_desc,
		ID2D1GradientStopCollection *	gradient,
		struct d2d_brush **	brush
	)

Definition at line 572 of file brush.c.

{
    if (!(*brush = calloc(1, sizeof(**brush))))
        return E_OUTOFMEMORY;
 
    d2d_brush_init(*brush, factory, D2D_BRUSH_TYPE_LINEAR, brush_desc,
            (ID2D1BrushVtbl *)&d2d_linear_gradient_brush_vtbl);
    (*brush)->u.linear.gradient = unsafe_impl_from_ID2D1GradientStopCollection(gradient);
    ID2D1GradientStopCollection_AddRef(&(*brush)->u.linear.gradient->ID2D1GradientStopCollection_iface);
    (*brush)->u.linear.start = gradient_brush_desc->startPoint;
    (*brush)->u.linear.end = gradient_brush_desc->endPoint;
 
    TRACE("Created brush %p.\n", *brush);
    return S_OK;
}

Referenced by d2d_device_context_CreateLinearGradientBrush().

d2d_matrix_invert()

static BOOL d2d_matrix_invert ( D2D_MATRIX_3X2_F *  dst, const D2D_MATRIX_3X2_F *  src  )

inlinestatic

Definition at line 936 of file d2d1_private.h.

{
    float d = src->_11 * src->_22 - src->_21 * src->_12;
 
    if (d == 0.0f)
        return FALSE;
    dst->_11 = src->_22 / d;
    dst->_21 = -src->_21 / d;
    dst->_31 = (src->_21 * src->_32 - src->_31 * src->_22) / d;
    dst->_12 = -src->_12 / d;
    dst->_22 = src->_11 / d;
    dst->_32 = -(src->_11 * src->_32 - src->_31 * src->_12) / d;
 
    return TRUE;
}

Referenced by D2D1InvertMatrix(), d2d_path_geometry_FillContainsPoint(), and d2d_rectangle_geometry_FillContainsPoint().

d2d_matrix_multiply()

static void d2d_matrix_multiply ( D2D_MATRIX_3X2_F *  a, const D2D_MATRIX_3X2_F *  b  )

inlinestatic

Definition at line 923 of file d2d1_private.h.

{
    D2D_MATRIX_3X2_F tmp = *a;
 
    a->_11 = tmp._11 * b->_11 + tmp._12 * b->_21;
    a->_12 = tmp._11 * b->_12 + tmp._12 * b->_22;
    a->_21 = tmp._21 * b->_11 + tmp._22 * b->_21;
    a->_22 = tmp._21 * b->_12 + tmp._22 * b->_22;
    a->_31 = tmp._31 * b->_11 + tmp._32 * b->_21 + b->_31;
    a->_32 = tmp._31 * b->_12 + tmp._32 * b->_22 + b->_32;
}

Referenced by d2d_transformed_geometry_FillContainsPoint(), d2d_transformed_geometry_GetBounds(), d2d_transformed_geometry_init(), d2d_transformed_geometry_Simplify(), and d2d_transformed_geometry_StrokeContainsPoint().

d2d_mesh_create()

HRESULT d2d_mesh_create	(	ID2D1Factory *	factory,
		struct d2d_mesh **	mesh
	)

Definition at line 98 of file mesh.c.

{
    if (!(*mesh = calloc(1, sizeof(**mesh))))
        return E_OUTOFMEMORY;
 
    (*mesh)->ID2D1Mesh_iface.lpVtbl = &d2d_mesh_vtbl;
    (*mesh)->refcount = 1;
    ID2D1Factory_AddRef((*mesh)->factory = factory);
 
    TRACE("Created mesh %p.\n", *mesh);
    return S_OK;
}

Referenced by d2d_device_context_CreateMesh().

d2d_path_geometry_init()

void d2d_path_geometry_init	(	struct d2d_geometry *	geometry,
		ID2D1Factory *	factory
	)

Definition at line 3965 of file geometry.c.

{
    d2d_geometry_init(geometry, factory, &identity, (ID2D1GeometryVtbl *)&d2d_path_geometry_vtbl);
    geometry->u.path.ID2D1GeometrySink_iface.lpVtbl = &d2d_geometry_sink_vtbl;
    geometry->u.path.bounds.left = FLT_MAX;
    geometry->u.path.bounds.right = -FLT_MAX;
    geometry->u.path.bounds.top = FLT_MAX;
    geometry->u.path.bounds.bottom = -FLT_MAX;
}

Referenced by d2d_factory_CreatePathGeometry(), and d2d_factory_CreatePathGeometry1().

d2d_point_dot()

static float d2d_point_dot ( const D2D1_POINT_2F *  p0, const D2D1_POINT_2F *  p1  )

inlinestatic

Definition at line 958 of file d2d1_private.h.

{
    return p0->x * p1->x + p0->y * p1->y;
}

Referenced by d2d_brush_fill_cb(), d2d_point_length(), d2d_point_on_bezier_segment(), d2d_point_on_line_segment(), and d2d_rectangle_geometry_StrokeContainsPoint().

d2d_point_set()

static void d2d_point_set ( D2D1_POINT_2F *  dst, float  x, float  y  )

inlinestatic

Definition at line 952 of file d2d1_private.h.

{
    dst->x = x;
    dst->y = y;
}

Referenced by d2d_brush_fill_cb(), d2d_curve_outline_vertex_set(), d2d_device_context_DrawText(), d2d_ellipse_geometry_init(), d2d_outline_vertex_set(), d2d_point_on_line_segment(), d2d_rectangle_geometry_init(), d2d_rectangle_geometry_Simplify(), d2d_rectangle_geometry_StrokeContainsPoint(), and d2d_rounded_rectangle_geometry_init().

d2d_point_transform()

static void d2d_point_transform ( D2D1_POINT_2F *  dst, const D2D1_MATRIX_3X2_F *  matrix, float  x, float  y  )

inlinestatic

Definition at line 963 of file d2d1_private.h.

{
    dst->x = x * matrix->_11 + y * matrix->_21 + matrix->_31;
    dst->y = x * matrix->_12 + y * matrix->_22 + matrix->_32;
}

Referenced by d2d_brush_fill_cb(), d2d_device_context_PushAxisAlignedClip(), d2d_path_geometry_FillContainsPoint(), d2d_path_geometry_GetBounds(), d2d_path_geometry_Simplify(), d2d_point_on_bezier_segment(), d2d_point_on_line_segment(), d2d_rectangle_geometry_FillContainsPoint(), d2d_rectangle_geometry_GetBounds(), and d2d_rectangle_geometry_Simplify().

d2d_radial_gradient_brush_create()

HRESULT d2d_radial_gradient_brush_create	(	ID2D1Factory *	factory,
		const D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES *	gradient_desc,
		const D2D1_BRUSH_PROPERTIES *	brush_desc,
		ID2D1GradientStopCollection *	gradient,
		struct d2d_brush **	brush
	)

Definition at line 799 of file brush.c.

{
    struct d2d_brush *b;
 
    if (!(b = calloc(1, sizeof(*b))))
        return E_OUTOFMEMORY;
 
    d2d_brush_init(b, factory, D2D_BRUSH_TYPE_RADIAL, brush_desc, (ID2D1BrushVtbl *)&d2d_radial_gradient_brush_vtbl);
    b->u.radial.gradient = unsafe_impl_from_ID2D1GradientStopCollection(gradient);
    ID2D1GradientStopCollection_AddRef(&b->u.radial.gradient->ID2D1GradientStopCollection_iface);
    b->u.radial.centre = gradient_desc->center;
    b->u.radial.offset = gradient_desc->gradientOriginOffset;
    b->u.radial.radius.x = gradient_desc->radiusX;
    b->u.radial.radius.y = gradient_desc->radiusY;
 
    TRACE("Created brush %p.\n", b);
    *brush = b;
 
    return S_OK;
}

Referenced by d2d_device_context_CreateRadialGradientBrush().

d2d_rect_expand()

static void d2d_rect_expand ( D2D1_RECT_F *  dst, const D2D1_POINT_2F *  point  )

inlinestatic

Definition at line 969 of file d2d1_private.h.

{
    if (point->x < dst->left)
        dst->left = point->x;
    if (point->x > dst->right)
        dst->right = point->x;
    if (point->y < dst->top)
        dst->top = point->y;
    if (point->y > dst->bottom)
        dst->bottom = point->y;
}

Referenced by d2d_device_context_PushAxisAlignedClip(), d2d_figure_add_vertex(), d2d_figure_insert_vertex(), d2d_path_geometry_GetBounds(), d2d_rect_get_bezier_bounds(), and d2d_rectangle_geometry_GetBounds().

d2d_rectangle_geometry_init()

HRESULT d2d_rectangle_geometry_init	(	struct d2d_geometry *	geometry,
		ID2D1Factory *	factory,
		const D2D1_RECT_F *	rect
	)

Definition at line 4591 of file geometry.c.

{
    struct d2d_face *f;
    D2D1_POINT_2F *v;
    float l, r, t, b;
 
    static const D2D1_POINT_2F prev[] =
    {
        { 1.0f,  0.0f},
        { 0.0f, -1.0f},
        {-1.0f,  0.0f},
        { 0.0f,  1.0f},
    };
    static const D2D1_POINT_2F next[] =
    {
        { 0.0f,  1.0f},
        { 1.0f,  0.0f},
        { 0.0f, -1.0f},
        {-1.0f,  0.0f},
    };
 
    d2d_geometry_init(geometry, factory, &identity, (ID2D1GeometryVtbl *)&d2d_rectangle_geometry_vtbl);
    geometry->u.rectangle.rect = *rect;
 
    if (!(geometry->fill.vertices = malloc(4 * sizeof(*geometry->fill.vertices))))
        goto fail;
    if (!d2d_array_reserve((void **)&geometry->fill.faces,
            &geometry->fill.faces_size, 2, sizeof(*geometry->fill.faces)))
        goto fail;
 
    l = min(rect->left, rect->right);
    r = max(rect->left, rect->right);
    t = min(rect->top, rect->bottom);
    b = max(rect->top, rect->bottom);
 
    v = geometry->fill.vertices;
    d2d_point_set(&v[0], l, t);
    d2d_point_set(&v[1], l, b);
    d2d_point_set(&v[2], r, b);
    d2d_point_set(&v[3], r, t);
    geometry->fill.vertex_count = 4;
 
    f = geometry->fill.faces;
    d2d_face_set(&f[0], 1, 2, 0);
    d2d_face_set(&f[1], 0, 2, 3);
    geometry->fill.face_count = 2;
 
    if (!d2d_geometry_outline_add_line_segment(geometry, &v[0], &v[1]))
        goto fail;
    if (!d2d_geometry_outline_add_line_segment(geometry, &v[1], &v[2]))
        goto fail;
    if (!d2d_geometry_outline_add_line_segment(geometry, &v[2], &v[3]))
        goto fail;
    if (!d2d_geometry_outline_add_line_segment(geometry, &v[3], &v[0]))
        goto fail;
 
    if (!d2d_geometry_outline_add_join(geometry, &prev[0], &v[0], &next[0]))
        goto fail;
    if (!d2d_geometry_outline_add_join(geometry, &prev[1], &v[1], &next[1]))
        goto fail;
    if (!d2d_geometry_outline_add_join(geometry, &prev[2], &v[2], &next[2]))
        goto fail;
    if (!d2d_geometry_outline_add_join(geometry, &prev[3], &v[3], &next[3]))
        goto fail;
 
    return S_OK;
 
fail:
    d2d_geometry_cleanup(geometry);
    return E_OUTOFMEMORY;
}

Referenced by d2d_factory_CreateRectangleGeometry().

d2d_rounded_rectangle_geometry_init()

HRESULT d2d_rounded_rectangle_geometry_init	(	struct d2d_geometry *	geometry,
		ID2D1Factory *	factory,
		const D2D1_ROUNDED_RECT *	rounded_rect
	)

Definition at line 4876 of file geometry.c.

{
    D2D1_POINT_2F *v, v1, v2, v3, v4;
    struct d2d_face *f;
    float l, r, t, b;
    float rx, ry;
 
    d2d_geometry_init(geometry, factory, &identity, (ID2D1GeometryVtbl *)&d2d_rounded_rectangle_geometry_vtbl);
    geometry->u.rounded_rectangle.rounded_rect = *rounded_rect;
 
    if (!(geometry->fill.vertices = malloc(8 * sizeof(*geometry->fill.vertices))))
        goto fail;
    if (!d2d_array_reserve((void **)&geometry->fill.faces,
            &geometry->fill.faces_size, 6, sizeof(*geometry->fill.faces)))
        goto fail;
 
    l = min(rounded_rect->rect.left, rounded_rect->rect.right);
    r = max(rounded_rect->rect.left, rounded_rect->rect.right);
    t = min(rounded_rect->rect.top, rounded_rect->rect.bottom);
    b = max(rounded_rect->rect.top, rounded_rect->rect.bottom);
 
    rx = min(rounded_rect->radiusX, 0.5f * (r - l));
    ry = min(rounded_rect->radiusY, 0.5f * (b - t));
 
    d2d_point_set(&v1, r, t);
    d2d_point_set(&v2, r, b);
    d2d_point_set(&v3, l, b);
    d2d_point_set(&v4, l, t);
 
    v = geometry->fill.vertices;
    d2d_point_set(&v[0], l + rx, t);
    d2d_point_set(&v[1], r - rx, t);
    d2d_point_set(&v[2], r, t + ry);
    d2d_point_set(&v[3], r, b - ry);
    d2d_point_set(&v[4], r - rx, b);
    d2d_point_set(&v[5], l + rx, b);
    d2d_point_set(&v[6], l, b - ry);
    d2d_point_set(&v[7], l, t + ry);
    geometry->fill.vertex_count = 8;
 
    f = geometry->fill.faces;
    d2d_face_set(&f[0], 0, 7, 6);
    d2d_face_set(&f[1], 0, 6, 5);
    d2d_face_set(&f[2], 0, 5, 4);
    d2d_face_set(&f[3], 0, 4, 1);
    d2d_face_set(&f[4], 1, 4, 3);
    d2d_face_set(&f[5], 1, 3, 2);
    geometry->fill.face_count = 6;
 
    if (!d2d_geometry_fill_add_arc_triangle(geometry, &v[1], &v1, &v[2]))
        goto fail;
    if (!d2d_geometry_fill_add_arc_triangle(geometry, &v[3], &v2, &v[4]))
        goto fail;
    if (!d2d_geometry_fill_add_arc_triangle(geometry, &v[5], &v3, &v[6]))
        goto fail;
    if (!d2d_geometry_fill_add_arc_triangle(geometry, &v[7], &v4, &v[0]))
        goto fail;
 
    if (!d2d_geometry_outline_add_line_segment(geometry, &v[0], &v[1]))
        goto fail;
    if (!d2d_geometry_outline_add_arc_quadrant(geometry, &v[1], &v1, &v[2]))
        goto fail;
    if (!d2d_geometry_outline_add_line_segment(geometry, &v[2], &v[3]))
        goto fail;
    if (!d2d_geometry_outline_add_arc_quadrant(geometry, &v[3], &v2, &v[4]))
        goto fail;
    if (!d2d_geometry_outline_add_line_segment(geometry, &v[4], &v[5]))
        goto fail;
    if (!d2d_geometry_outline_add_arc_quadrant(geometry, &v[5], &v3, &v[6]))
        goto fail;
    if (!d2d_geometry_outline_add_line_segment(geometry, &v[6], &v[7]))
        goto fail;
    if (!d2d_geometry_outline_add_arc_quadrant(geometry, &v[7], &v4, &v[0]))
        goto fail;
 
    return S_OK;
 
fail:
    d2d_geometry_cleanup(geometry);
    return E_OUTOFMEMORY;
}

Referenced by d2d_factory_CreateRoundedRectangleGeometry().

d2d_solid_color_brush_create()

HRESULT d2d_solid_color_brush_create	(	ID2D1Factory *	factory,
		const D2D1_COLOR_F *	color,
		const D2D1_BRUSH_PROPERTIES *	desc,
		struct d2d_brush **	brush
	)

Definition at line 389 of file brush.c.

{
    if (!(*brush = calloc(1, sizeof(**brush))))
        return E_OUTOFMEMORY;
 
    d2d_brush_init(*brush, factory, D2D_BRUSH_TYPE_SOLID, desc,
            (ID2D1BrushVtbl *)&d2d_solid_color_brush_vtbl);
    (*brush)->u.solid.color = *color;
 
    TRACE("Created brush %p.\n", *brush);
    return S_OK;
}

Referenced by d2d_device_context_CreateSolidColorBrush().

d2d_state_block_init()

void d2d_state_block_init	(	struct d2d_state_block *	state_block,
		ID2D1Factory *	factory,
		const D2D1_DRAWING_STATE_DESCRIPTION1 *	desc,
		IDWriteRenderingParams *	text_rendering_params
	)

Definition at line 164 of file state_block.c.

{
    static const D2D1_MATRIX_3X2_F identity =
    {{{
        1.0f, 0.0f,
        0.0f, 1.0f,
        0.0f, 0.0f,
    }}};
 
    state_block->ID2D1DrawingStateBlock1_iface.lpVtbl = &d2d_state_block_vtbl;
    state_block->refcount = 1;
    ID2D1Factory_AddRef(state_block->factory = factory);
    if (desc)
        state_block->drawing_state = *desc;
    else
        state_block->drawing_state.transform = identity;
    if ((state_block->text_rendering_params = text_rendering_params))
        IDWriteRenderingParams_AddRef(state_block->text_rendering_params);
}

Referenced by d2d_factory_CreateDrawingStateBlock(), and d2d_factory_CreateDrawingStateBlock1().

d2d_stroke_style_init()

HRESULT d2d_stroke_style_init	(	struct d2d_stroke_style *	style,
		ID2D1Factory *	factory,
		const D2D1_STROKE_STYLE_PROPERTIES1 *	desc,
		const float *	dashes,
		UINT32	dash_count
	)

Definition at line 202 of file stroke.c.

{
    static const struct
    {
        UINT32 dash_count;
        float dashes[6];
    }
    builtin_dash_styles[] =
    {
        /* D2D1_DASH_STYLE_SOLID */        { 0 },
        /* D2D1_DASH_STYLE_DASH */         { 2, {2.0f, 2.0f}},
        /* D2D1_DASH_STYLE_DOT */          { 2, {0.0f, 2.0f}},
        /* D2D1_DASH_STYLE_DASH_DOT */     { 4, {2.0f, 2.0f, 0.0f, 2.0f}},
        /* D2D1_DASH_STYLE_DASH_DOT_DOT */ { 6, {2.0f, 2.0f, 0.0f, 2.0f, 0.0f, 2.0f}},
    };
 
    if (desc->dashStyle > D2D1_DASH_STYLE_CUSTOM)
        return E_INVALIDARG;
 
    if (desc->transformType != D2D1_STROKE_TRANSFORM_TYPE_NORMAL)
        FIXME("transformType %d is not supported\n", desc->transformType);
 
    style->ID2D1StrokeStyle1_iface.lpVtbl = &d2d_stroke_style_vtbl;
    style->refcount = 1;
 
    if (desc->dashStyle == D2D1_DASH_STYLE_CUSTOM)
    {
        if (!dashes || !dash_count)
            return E_INVALIDARG;
 
        if (!(style->dashes = calloc(dash_count, sizeof(*style->dashes))))
            return E_OUTOFMEMORY;
        memcpy(style->dashes, dashes, dash_count * sizeof(*style->dashes));
        style->dash_count = dash_count;
    }
    else
    {
        if (dashes)
            return E_INVALIDARG;
 
        style->dashes = (float *)builtin_dash_styles[desc->dashStyle].dashes;
        style->dash_count = builtin_dash_styles[desc->dashStyle].dash_count;
    }
 
    ID2D1Factory_AddRef(style->factory = factory);
    style->desc = *desc;
 
    return S_OK;
}

Referenced by d2d_factory_CreateStrokeStyle(), and d2d_factory_CreateStrokeStyle1().

d2d_transformed_geometry_init()

void d2d_transformed_geometry_init	(	struct d2d_geometry *	geometry,
		ID2D1Factory *	factory,
		ID2D1Geometry *	src_geometry,
		const D2D_MATRIX_3X2_F *	transform
	)

Definition at line 5226 of file geometry.c.

{
    struct d2d_geometry *src_impl;
    D2D_MATRIX_3X2_F g;
 
    src_impl = unsafe_impl_from_ID2D1Geometry(src_geometry);
 
    g = src_impl->transform;
    d2d_matrix_multiply(&g, transform);
    d2d_geometry_init(geometry, factory, &g, (ID2D1GeometryVtbl *)&d2d_transformed_geometry_vtbl);
    ID2D1Geometry_AddRef(geometry->u.transformed.src_geometry = src_geometry);
    geometry->u.transformed.transform = *transform;
    geometry->fill = src_impl->fill;
    geometry->outline = src_impl->outline;
}

Referenced by d2d_factory_CreateTransformedGeometry().

d2d_wic_render_target_init()

HRESULT d2d_wic_render_target_init	(	struct d2d_wic_render_target *	render_target,
		ID2D1Factory1 *	factory,
		ID3D10Device1 *	d3d_device,
		IWICBitmap *	bitmap,
		const D2D1_RENDER_TARGET_PROPERTIES *	desc
	)

Definition at line 152 of file wic_render_target.c.

{
    D3D10_TEXTURE2D_DESC texture_desc;
    ID3D10Texture2D *texture;
    IDXGIDevice *dxgi_device;
    ID2D1Device *device;
    HRESULT hr;
 
    render_target->IUnknown_iface.lpVtbl = &d2d_wic_render_target_vtbl;
 
    if (FAILED(hr = IWICBitmap_GetSize(bitmap, &render_target->width, &render_target->height)))
    {
        WARN("Failed to get bitmap dimensions, hr %#lx.\n", hr);
        return hr;
    }
 
    texture_desc.Width = render_target->width;
    texture_desc.Height = render_target->height;
    texture_desc.MipLevels = 1;
    texture_desc.ArraySize = 1;
 
    texture_desc.Format = desc->pixelFormat.format;
    if (texture_desc.Format == DXGI_FORMAT_UNKNOWN)
    {
        WICPixelFormatGUID bitmap_format;
 
        if (FAILED(hr = IWICBitmap_GetPixelFormat(bitmap, &bitmap_format)))
        {
            WARN("Failed to get bitmap format, hr %#lx.\n", hr);
            return hr;
        }
 
        if (IsEqualGUID(&bitmap_format, &GUID_WICPixelFormat32bppPBGRA)
                || IsEqualGUID(&bitmap_format, &GUID_WICPixelFormat32bppBGR))
        {
            texture_desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
        }
        else if (IsEqualGUID(&bitmap_format, &GUID_WICPixelFormat32bppPRGBA)
                || IsEqualGUID(&bitmap_format, &GUID_WICPixelFormat32bppRGB))
        {
            texture_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
        }
        else
        {
            WARN("Unsupported WIC bitmap format %s.\n", debugstr_guid(&bitmap_format));
            return D2DERR_UNSUPPORTED_PIXEL_FORMAT;
        }
    }
 
    switch (texture_desc.Format)
    {
        case DXGI_FORMAT_B8G8R8A8_UNORM:
        case DXGI_FORMAT_R8G8B8A8_UNORM:
            render_target->bpp = 4;
            break;
 
        default:
            FIXME("Unhandled format %#x.\n", texture_desc.Format);
            return D2DERR_UNSUPPORTED_PIXEL_FORMAT;
    }
 
    texture_desc.SampleDesc.Count = 1;
    texture_desc.SampleDesc.Quality = 0;
    texture_desc.Usage = D3D10_USAGE_DEFAULT;
    texture_desc.BindFlags = D3D10_BIND_RENDER_TARGET | D3D10_BIND_SHADER_RESOURCE;
    texture_desc.CPUAccessFlags = 0;
    texture_desc.MiscFlags = desc->usage & D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE ?
            D3D10_RESOURCE_MISC_GDI_COMPATIBLE : 0;
 
    if (FAILED(hr = ID3D10Device1_CreateTexture2D(d3d_device, &texture_desc, NULL, &texture)))
    {
        WARN("Failed to create texture, hr %#lx.\n", hr);
        return hr;
    }
 
    hr = ID3D10Texture2D_QueryInterface(texture, &IID_IDXGISurface, (void **)&render_target->dxgi_surface);
    ID3D10Texture2D_Release(texture);
    if (FAILED(hr))
    {
        WARN("Failed to get DXGI surface interface, hr %#lx.\n", hr);
        return hr;
    }
 
    texture_desc.Usage = D3D10_USAGE_STAGING;
    texture_desc.BindFlags = 0;
    texture_desc.CPUAccessFlags = D3D10_CPU_ACCESS_READ;
    texture_desc.MiscFlags = 0;
 
    if (FAILED(hr = ID3D10Device1_CreateTexture2D(d3d_device, &texture_desc, NULL, &render_target->readback_texture)))
    {
        WARN("Failed to create readback texture, hr %#lx.\n", hr);
        IDXGISurface_Release(render_target->dxgi_surface);
        return hr;
    }
 
    if (FAILED(hr = ID3D10Device1_QueryInterface(d3d_device, &IID_IDXGIDevice, (void **)&dxgi_device)))
    {
        WARN("Failed to get DXGI device, hr %#lx.\n", hr);
        IDXGISurface_Release(render_target->dxgi_surface);
        return hr;
    }
 
    hr = d2d_factory_create_device(factory, dxgi_device, false, &IID_ID2D1Device, (void **)&device);
    IDXGIDevice_Release(dxgi_device);
    if (FAILED(hr))
    {
        WARN("Failed to create D2D device, hr %#lx.\n", hr);
        IDXGISurface_Release(render_target->dxgi_surface);
        return hr;
    }
 
    hr = d2d_d3d_create_render_target(unsafe_impl_from_ID2D1Device((ID2D1Device1 *)device),
            render_target->dxgi_surface, &render_target->IUnknown_iface,
            &d2d_wic_render_target_ops, desc, (void **)&render_target->dxgi_inner);
    ID2D1Device_Release(device);
    if (FAILED(hr))
    {
        WARN("Failed to create DXGI surface render target, hr %#lx.\n", hr);
        ID3D10Texture2D_Release(render_target->readback_texture);
        IDXGISurface_Release(render_target->dxgi_surface);
        return hr;
    }
 
    if (FAILED(hr = IUnknown_QueryInterface(render_target->dxgi_inner,
            &IID_ID2D1RenderTarget, (void **)&render_target->dxgi_target)))
    {
        WARN("Failed to retrieve ID2D1RenderTarget interface, hr %#lx.\n", hr);
        IUnknown_Release(render_target->dxgi_inner);
        ID3D10Texture2D_Release(render_target->readback_texture);
        IDXGISurface_Release(render_target->dxgi_surface);
        return hr;
    }
 
    render_target->bitmap = bitmap;
    IWICBitmap_AddRef(bitmap);
 
    return S_OK;
}

Referenced by d2d_factory_CreateWicBitmapRenderTarget().

debug_d2d_color_f()

static const char * debug_d2d_color_f ( const D2D1_COLOR_F *  colour )

inlinestatic

Definition at line 986 of file d2d1_private.h.

{
    if (!colour)
        return "(null)";
    return wine_dbg_sprintf("{%.8e, %.8e, %.8e, %.8e}", colour->r, colour->g, colour->b, colour->a);
}

Referenced by D2D1ConvertColorSpace().

debug_d2d_ellipse()

static const char * debug_d2d_ellipse ( const D2D1_ELLIPSE *  ellipse )

inlinestatic

Definition at line 1029 of file d2d1_private.h.

{
    if (!ellipse)
        return "(null)";
    return wine_dbg_sprintf("(%.8e, %.8e)[%.8e, %.8e]",
            ellipse->point.x, ellipse->point.y, ellipse->radiusX, ellipse->radiusY);
}

Referenced by d2d_factory_CreateEllipseGeometry().

debug_d2d_point_2f()

static const char * debug_d2d_point_2f ( const D2D1_POINT_2F *  point )

inlinestatic

Definition at line 993 of file d2d1_private.h.

{
    if (!point)
        return "(null)";
    return wine_dbg_sprintf("{%.8e, %.8e}", point->x, point->y);
}

Referenced by D2D1MakeRotateMatrix(), D2D1MakeSkewMatrix(), d2d_bitmap_render_target_DrawGlyphRun(), d2d_bitmap_render_target_DrawLine(), d2d_bitmap_render_target_DrawTextLayout(), d2d_dc_render_target_DrawGlyphRun(), d2d_dc_render_target_DrawLine(), d2d_dc_render_target_DrawTextLayout(), d2d_device_context_BlendImage(), d2d_device_context_DrawColorBitmapGlyphRun(), d2d_device_context_DrawGdiMetafile(), d2d_device_context_DrawGlyphRun(), d2d_device_context_DrawImage(), d2d_device_context_DrawLine(), d2d_device_context_DrawSvgGlyphRun(), d2d_device_context_DrawTextLayout(), d2d_device_context_GetColorBitmapGlyphImage(), d2d_device_context_GetGlyphRunWorldBounds(), d2d_device_context_GetSvgGlyphImage(), d2d_device_context_ID2D1DeviceContext4_DrawTextLayout(), d2d_device_context_ID2D1DeviceContext_DrawGlyphRun(), d2d_ellipse_geometry_FillContainsPoint(), d2d_ellipse_geometry_StrokeContainsPoint(), d2d_geometry_group_FillContainsPoint(), d2d_geometry_group_StrokeContainsPoint(), d2d_geometry_sink_AddLine(), d2d_geometry_sink_BeginFigure(), d2d_hwnd_render_target_DrawGlyphRun(), d2d_hwnd_render_target_DrawLine(), d2d_hwnd_render_target_DrawTextLayout(), d2d_linear_gradient_brush_SetEndPoint(), d2d_linear_gradient_brush_SetStartPoint(), d2d_path_geometry_FillContainsPoint(), d2d_path_geometry_StrokeContainsPoint(), d2d_radial_gradient_brush_SetCenter(), d2d_radial_gradient_brush_SetGradientOriginOffset(), d2d_rectangle_geometry_FillContainsPoint(), d2d_rectangle_geometry_StrokeContainsPoint(), d2d_rounded_rectangle_geometry_FillContainsPoint(), d2d_rounded_rectangle_geometry_StrokeContainsPoint(), d2d_transformed_geometry_FillContainsPoint(), and d2d_transformed_geometry_StrokeContainsPoint().

debug_d2d_point_2l()

static const char * debug_d2d_point_2l ( const D2D1_POINT_2L *  point )

inlinestatic

Definition at line 1000 of file d2d1_private.h.

{
    if (!point)
        return "(null)";
    return wine_dbg_sprintf("{%ld, %ld}", point->x, point->y);
}

Referenced by d2d_effect_context_CreateOffsetTransform(), and d2d_offset_transform_SetOffset().

debug_d2d_rect_f()

static const char * debug_d2d_rect_f ( const D2D1_RECT_F *  rect )

inlinestatic

Definition at line 1007 of file d2d1_private.h.

{
    if (!rect)
        return "(null)";
    return wine_dbg_sprintf("(%.8e, %.8e)-(%.8e, %.8e)", rect->left, rect->top, rect->right, rect->bottom);
}

Referenced by d2d_bitmap_render_target_DrawBitmap(), d2d_bitmap_render_target_DrawRectangle(), d2d_bitmap_render_target_DrawText(), d2d_bitmap_render_target_FillOpacityMask(), d2d_bitmap_render_target_FillRectangle(), d2d_bitmap_render_target_PushAxisAlignedClip(), d2d_dc_render_target_DrawBitmap(), d2d_dc_render_target_DrawRectangle(), d2d_dc_render_target_DrawText(), d2d_dc_render_target_FillOpacityMask(), d2d_dc_render_target_FillRectangle(), d2d_dc_render_target_PushAxisAlignedClip(), d2d_device_context_BlendImage(), d2d_device_context_DrawBitmap(), d2d_device_context_DrawImage(), d2d_device_context_DrawRectangle(), d2d_device_context_DrawText(), d2d_device_context_FillOpacityMask(), d2d_device_context_FillRectangle(), d2d_device_context_GetEffectRequiredInputRectangles(), d2d_device_context_ID2D1DeviceContext2_DrawGdiMetafile(), d2d_device_context_ID2D1DeviceContext4_DrawText(), d2d_device_context_ID2D1DeviceContext_DrawBitmap(), d2d_device_context_ID2D1DeviceContext_FillOpacityMask(), d2d_device_context_InvalidateEffectInputRectangle(), d2d_device_context_PushAxisAlignedClip(), d2d_factory_CreateRectangleGeometry(), d2d_hwnd_render_target_DrawBitmap(), d2d_hwnd_render_target_DrawRectangle(), d2d_hwnd_render_target_DrawText(), d2d_hwnd_render_target_FillOpacityMask(), d2d_hwnd_render_target_FillRectangle(), d2d_hwnd_render_target_PushAxisAlignedClip(), and d2d_image_brush_SetSourceRectangle().

debug_d2d_rect_l()

static const char * debug_d2d_rect_l ( const D2D1_RECT_L *  rect )

inlinestatic

Definition at line 1014 of file d2d1_private.h.

{
    if (!rect)
        return "(null)";
    return wine_dbg_sprintf("(%ld, %ld)-(%ld, %ld)", rect->left, rect->top, rect->right, rect->bottom);
}

Referenced by d2d_effect_context_CreateBoundsAdjustmentTransform().

debug_d2d_rounded_rect()

static const char * debug_d2d_rounded_rect ( const D2D1_ROUNDED_RECT *  rounded_rect )

inlinestatic

Definition at line 1021 of file d2d1_private.h.

{
    if (!rounded_rect)
        return "(null)";
    return wine_dbg_sprintf("(%.8e, %.8e)-(%.8e, %.8e)[%.8e, %.8e]", rounded_rect->rect.left, rounded_rect->rect.top,
            rounded_rect->rect.right, rounded_rect->rect.bottom, rounded_rect->radiusX, rounded_rect->radiusY);
}

Referenced by d2d_factory_CreateRoundedRectangleGeometry().

unsafe_impl_from_ID2D1Bitmap()

struct d2d_bitmap * unsafe_impl_from_ID2D1Bitmap

(

ID2D1Bitmap *

iface

)

Definition at line 769 of file bitmap.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == (ID2D1BitmapVtbl *)&d2d_bitmap_vtbl);
    return CONTAINING_RECORD(iface, struct d2d_bitmap, ID2D1Bitmap1_iface);
}

Referenced by d2d_bitmap_brush_create(), d2d_bitmap_brush_SetBitmap(), d2d_bitmap_CopyFromBitmap(), d2d_bitmap_create_shared(), d2d_brush_bind_image(), d2d_brush_fill_cb(), d2d_dc_render_target_BindDC(), and d2d_device_context_SetTarget().

unsafe_impl_from_ID2D1Brush()

struct d2d_brush * unsafe_impl_from_ID2D1Brush

(

ID2D1Brush *

iface

)

Definition at line 1344 of file brush.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == (const ID2D1BrushVtbl *)&d2d_solid_color_brush_vtbl
            || iface->lpVtbl == (const ID2D1BrushVtbl *)&d2d_linear_gradient_brush_vtbl
            || iface->lpVtbl == (const ID2D1BrushVtbl *)&d2d_radial_gradient_brush_vtbl
            || iface->lpVtbl == (const ID2D1BrushVtbl *)&d2d_bitmap_brush_vtbl
            || iface->lpVtbl == (const ID2D1BrushVtbl *)&d2d_image_brush_vtbl);
    return CONTAINING_RECORD(iface, struct d2d_brush, ID2D1Brush_iface);
}

Referenced by d2d_command_list_create_brush(), d2d_device_context_draw_glyph_run_bitmap(), d2d_device_context_draw_glyph_run_outline(), d2d_device_context_DrawGeometry(), and d2d_device_context_FillGeometry().

unsafe_impl_from_ID2D1CommandList()

struct d2d_command_list * unsafe_impl_from_ID2D1CommandList

(

ID2D1CommandList *

iface

)

Definition at line 512 of file command_list.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == (ID2D1CommandListVtbl *)&d2d_command_list_vtbl);
    return CONTAINING_RECORD(iface, struct d2d_command_list, ID2D1CommandList_iface);
}

Referenced by d2d_device_context_SetTarget().

unsafe_impl_from_ID2D1Device()

struct d2d_device * unsafe_impl_from_ID2D1Device

(

ID2D1Device1 *

iface

)

Definition at line 4522 of file device.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == (ID2D1Device1Vtbl *)&d2d_device_vtbl);
    return CONTAINING_RECORD(iface, struct d2d_device, ID2D1Device6_iface);
}

Referenced by d2d_dc_render_target_init(), d2d_factory_CreateDxgiSurfaceRenderTarget(), d2d_hwnd_render_target_init(), and d2d_wic_render_target_init().

unsafe_impl_from_ID2D1DrawingStateBlock()

struct d2d_state_block * unsafe_impl_from_ID2D1DrawingStateBlock

(

ID2D1DrawingStateBlock *

iface

)

Definition at line 185 of file state_block.c.

{
    if (!iface)
        return NULL;
    if (iface->lpVtbl != (ID2D1DrawingStateBlockVtbl *)&d2d_state_block_vtbl)
    {
        WARN("Unexpected state block vtbl %p.\n", iface->lpVtbl);
        return NULL;
    }
    return CONTAINING_RECORD(iface, struct d2d_state_block, ID2D1DrawingStateBlock1_iface);
}

Referenced by d2d_device_context_RestoreDrawingState(), and d2d_device_context_SaveDrawingState().

unsafe_impl_from_ID2D1Factory()

static struct d2d_factory * unsafe_impl_from_ID2D1Factory ( ID2D1Factory *  iface )

inlinestatic

Definition at line 704 of file d2d1_private.h.

{
    return CONTAINING_RECORD(iface, struct d2d_factory, ID2D1Factory7_iface);
}

Referenced by d2d_device_context_init(), and d2d_factory_get_registered_effect().

unsafe_impl_from_ID2D1Geometry()

struct d2d_geometry * unsafe_impl_from_ID2D1Geometry

(

ID2D1Geometry *

iface

)

Definition at line 5520 of file geometry.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == (const ID2D1GeometryVtbl *)&d2d_ellipse_geometry_vtbl
            || iface->lpVtbl == (const ID2D1GeometryVtbl *)&d2d_path_geometry_vtbl
            || iface->lpVtbl == (const ID2D1GeometryVtbl *)&d2d_rectangle_geometry_vtbl
            || iface->lpVtbl == (const ID2D1GeometryVtbl *)&d2d_rounded_rectangle_geometry_vtbl
            || iface->lpVtbl == (const ID2D1GeometryVtbl *)&d2d_transformed_geometry_vtbl
            || iface->lpVtbl == (const ID2D1GeometryVtbl *)&d2d_geometry_group_vtbl);
    return CONTAINING_RECORD(iface, struct d2d_geometry, ID2D1Geometry_iface);
}

Referenced by d2d_device_context_draw_glyph_run_bitmap(), d2d_device_context_draw_glyph_run_outline(), d2d_device_context_DrawGeometry(), d2d_device_context_FillGeometry(), and d2d_transformed_geometry_init().

unsafe_impl_from_ID2D1StrokeStyle()

struct d2d_stroke_style * unsafe_impl_from_ID2D1StrokeStyle

(

ID2D1StrokeStyle *

iface

)

Definition at line 194 of file stroke.c.

{
    if (!iface)
        return NULL;
    assert((const struct ID2D1StrokeStyle1Vtbl *)iface->lpVtbl == &d2d_stroke_style_vtbl);
    return CONTAINING_RECORD(iface, struct d2d_stroke_style, ID2D1StrokeStyle1_iface);
}

Referenced by d2d_device_context_DrawGeometry().

Variable Documentation

d2d_settings

struct d2d_settings d2d_settings

extern

Definition at line 28 of file factory.c.