dlls/d2d1/factory.c

   1 /*
   2  * Copyright 2014 Henri Verbeet for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define D2D1_INIT_GUID
  20 #include "d2d1_private.h"
  21
  22 #include "xmllite.h"
  23 #include "wine/list.h"
  24
  25 WINE_DECLARE_DEBUG_CHANNEL(winediag);
  26 WINE_DEFAULT_DEBUG_CHANNEL(d2d);
  27
  28 struct d2d_settings d2d_settings =
  29 {
  30     ~0u,    /* No ID2D1Factory version limit by default. */
  31 };
  32
  33 static void d2d_effect_registration_cleanup(struct d2d_effect_registration *reg)
  34 {
  35     d2d_effect_properties_cleanup(&reg->properties);
  36     free(reg);
  37 }
  38
  39 struct d2d_factory
  40 {
  41     ID2D1Factory3 ID2D1Factory3_iface;
  42     ID2D1Multithread ID2D1Multithread_iface;
  43     LONG refcount;
  44
  45     ID3D10Device1 *device;
  46
  47     float dpi_x;
  48     float dpi_y;
  49
  50     struct list effects;
  51     INIT_ONCE init_builtins;
  52
  53     CRITICAL_SECTION cs;
  54 };
  55
  56 static inline struct d2d_factory *impl_from_ID2D1Factory3(ID2D1Factory3 *iface)
  57 {
  58     return CONTAINING_RECORD(iface, struct d2d_factory, ID2D1Factory3_iface);
  59 }
  60
  61 static inline struct d2d_factory *unsafe_impl_from_ID2D1Factory(ID2D1Factory *iface)
  62 {
  63     return CONTAINING_RECORD(iface, struct d2d_factory, ID2D1Factory3_iface);
  64 }
  65
  66 static inline struct d2d_factory *impl_from_ID2D1Multithread(ID2D1Multithread *iface)
  67 {
  68     return CONTAINING_RECORD(iface, struct d2d_factory, ID2D1Multithread_iface);
  69 }
  70
  71 static BOOL WINAPI d2d_factory_builtins_initonce(INIT_ONCE *once, void *param, void **context)
  72 {
  73     d2d_effects_init_builtins(param);
  74
  75     return TRUE;
  76 }
  77
  78 static void d2d_factory_init_builtin_effects(struct d2d_factory *factory)
  79 {
  80     InitOnceExecuteOnce(&factory->init_builtins, d2d_factory_builtins_initonce, factory, NULL);
  81 }
  82
  83 void d2d_factory_register_effect(struct d2d_factory *factory, struct d2d_effect_registration *effect)
  84 {
  85     list_add_tail(&factory->effects, &effect->entry);
  86 }
  87
  88 struct d2d_effect_registration * d2d_factory_get_registered_effect(ID2D1Factory *iface,
  89         const GUID *id)
  90 {
  91     struct d2d_factory *factory = unsafe_impl_from_ID2D1Factory(iface);
  92     struct d2d_effect_registration *reg;
  93
  94     d2d_effects_init_builtins(factory);
  95
  96     LIST_FOR_EACH_ENTRY(reg, &factory->effects, struct d2d_effect_registration, entry)
  97     {
  98         if (IsEqualGUID(id, &reg->id)) return reg;
  99     }
 100
 101     return NULL;
 102 }
 103
 104 static HRESULT d2d_factory_reload_sysmetrics(struct d2d_factory *factory)
 105 {
 106     HDC hdc;
 107
 108     if (!(hdc = GetDC(NULL)))
 109     {
 110         factory->dpi_x = factory->dpi_y = 96.0f;
 111         return E_FAIL;
 112     }
 113
 114     factory->dpi_x = GetDeviceCaps(hdc, LOGPIXELSX);
 115     factory->dpi_y = GetDeviceCaps(hdc, LOGPIXELSY);
 116
 117     ReleaseDC(NULL, hdc);
 118
 119     return S_OK;
 120 }
 121
 122 static HRESULT STDMETHODCALLTYPE d2d_factory_QueryInterface(ID2D1Factory3 *iface, REFIID iid, void **out)
 123 {
 124     struct d2d_factory *factory = impl_from_ID2D1Factory3(iface);
 125
 126     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 127
 128     if ((IsEqualGUID(iid, &IID_ID2D1Factory3) && d2d_settings.max_version_factory >= 3)
 129             || (IsEqualGUID(iid, &IID_ID2D1Factory2) && d2d_settings.max_version_factory >= 2)
 130             || (IsEqualGUID(iid, &IID_ID2D1Factory1) && d2d_settings.max_version_factory >= 1)
 131             || IsEqualGUID(iid, &IID_ID2D1Factory)
 132             || IsEqualGUID(iid, &IID_IUnknown))
 133     {
 134         ID2D1Factory3_AddRef(iface);
 135         *out = iface;
 136         return S_OK;
 137     }
 138     else if (IsEqualGUID(iid, &IID_ID2D1Multithread))
 139     {
 140         ID2D1Factory3_AddRef(iface);
 141         *out = &factory->ID2D1Multithread_iface;
 142         return S_OK;
 143     }
 144
 145     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 146
 147     *out = NULL;
 148     return E_NOINTERFACE;
 149 }
 150
 151 static ULONG STDMETHODCALLTYPE d2d_factory_AddRef(ID2D1Factory3 *iface)
 152 {
 153     struct d2d_factory *factory = impl_from_ID2D1Factory3(iface);
 154     ULONG refcount = InterlockedIncrement(&factory->refcount);
 155
 156     TRACE("%p increasing refcount to %lu.\n", iface, refcount);
 157
 158     return refcount;
 159 }
 160
 161 static ULONG STDMETHODCALLTYPE d2d_factory_Release(ID2D1Factory3 *iface)
 162 {
 163     struct d2d_factory *factory = impl_from_ID2D1Factory3(iface);
 164     ULONG refcount = InterlockedDecrement(&factory->refcount);
 165     struct d2d_effect_registration *reg, *reg2;
 166
 167     TRACE("%p decreasing refcount to %lu.\n", iface, refcount);
 168
 169     if (!refcount)
 170     {
 171         if (factory->device)
 172             ID3D10Device1_Release(factory->device);
 173         LIST_FOR_EACH_ENTRY_SAFE(reg, reg2, &factory->effects, struct d2d_effect_registration, entry)
 174         {
 175             d2d_effect_registration_cleanup(reg);
 176         }
 177         DeleteCriticalSection(&factory->cs);
 178         free(factory);
 179     }
 180
 181     return refcount;
 182 }
 183
 184 static HRESULT STDMETHODCALLTYPE d2d_factory_ReloadSystemMetrics(ID2D1Factory3 *iface)
 185 {
 186     struct d2d_factory *factory = impl_from_ID2D1Factory3(iface);
 187
 188     TRACE("iface %p.\n", iface);
 189
 190     return d2d_factory_reload_sysmetrics(factory);
 191 }
 192
 193 static void STDMETHODCALLTYPE d2d_factory_GetDesktopDpi(ID2D1Factory3 *iface, float *dpi_x, float *dpi_y)
 194 {
 195     struct d2d_factory *factory = impl_from_ID2D1Factory3(iface);
 196
 197     TRACE("iface %p, dpi_x %p, dpi_y %p.\n", iface, dpi_x, dpi_y);
 198
 199     *dpi_x = factory->dpi_x;
 200     *dpi_y = factory->dpi_y;
 201 }
 202
 203 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateRectangleGeometry(ID2D1Factory3 *iface,
 204         const D2D1_RECT_F *rect, ID2D1RectangleGeometry **geometry)
 205 {
 206     struct d2d_geometry *object;
 207     HRESULT hr;
 208
 209     TRACE("iface %p, rect %s, geometry %p.\n", iface, debug_d2d_rect_f(rect), geometry);
 210
 211     if (!(object = calloc(1, sizeof(*object))))
 212         return E_OUTOFMEMORY;
 213
 214     if (FAILED(hr = d2d_rectangle_geometry_init(object, (ID2D1Factory *)iface, rect)))
 215     {
 216         WARN("Failed to initialise rectangle geometry, hr %#lx.\n", hr);
 217         free(object);
 218         return hr;
 219     }
 220
 221     TRACE("Created rectangle geometry %p.\n", object);
 222     *geometry = (ID2D1RectangleGeometry *)&object->ID2D1Geometry_iface;
 223
 224     return S_OK;
 225 }
 226
 227 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateRoundedRectangleGeometry(ID2D1Factory3 *iface,
 228         const D2D1_ROUNDED_RECT *rounded_rect, ID2D1RoundedRectangleGeometry **geometry)
 229 {
 230     struct d2d_geometry *object;
 231     HRESULT hr;
 232
 233     TRACE("iface %p, rounded_rect %s, geometry %p.\n", iface, debug_d2d_rounded_rect(rounded_rect), geometry);
 234
 235     if (!(object = calloc(1, sizeof(*object))))
 236         return E_OUTOFMEMORY;
 237
 238     if (FAILED(hr = d2d_rounded_rectangle_geometry_init(object, (ID2D1Factory *)iface, rounded_rect)))
 239     {
 240         WARN("Failed to initialise rounded rectangle geometry, hr %#lx.\n", hr);
 241         free(object);
 242         return hr;
 243     }
 244
 245     TRACE("Created rounded rectangle geometry %p.\n", object);
 246     *geometry = (ID2D1RoundedRectangleGeometry *)&object->ID2D1Geometry_iface;
 247
 248     return S_OK;
 249 }
 250
 251 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateEllipseGeometry(ID2D1Factory3 *iface,
 252         const D2D1_ELLIPSE *ellipse, ID2D1EllipseGeometry **geometry)
 253 {
 254     struct d2d_geometry *object;
 255     HRESULT hr;
 256
 257     TRACE("iface %p, ellipse %s, geometry %p.\n", iface, debug_d2d_ellipse(ellipse), geometry);
 258
 259     if (!(object = calloc(1, sizeof(*object))))
 260         return E_OUTOFMEMORY;
 261
 262     if (FAILED(hr = d2d_ellipse_geometry_init(object, (ID2D1Factory *)iface, ellipse)))
 263     {
 264         WARN("Failed to initialise ellipse geometry, hr %#lx.\n", hr);
 265         free(object);
 266         return hr;
 267     }
 268
 269     TRACE("Created ellipse geometry %p.\n", object);
 270     *geometry = (ID2D1EllipseGeometry *)&object->ID2D1Geometry_iface;
 271
 272     return S_OK;
 273 }
 274
 275 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateGeometryGroup(ID2D1Factory3 *iface,
 276         D2D1_FILL_MODE fill_mode, ID2D1Geometry **geometries, UINT32 geometry_count, ID2D1GeometryGroup **group)
 277 {
 278     struct d2d_geometry *object;
 279     HRESULT hr;
 280
 281     TRACE("iface %p, fill_mode %#x, geometries %p, geometry_count %u, group %p.\n",
 282             iface, fill_mode, geometries, geometry_count, group);
 283
 284     if (!(object = calloc(1, sizeof(*object))))
 285         return E_OUTOFMEMORY;
 286
 287     if (FAILED(hr = d2d_geometry_group_init(object, (ID2D1Factory *)iface, fill_mode, geometries, geometry_count)))
 288     {
 289         WARN("Failed to initialise geometry group, hr %#lx.\n", hr);
 290         free(object);
 291         return hr;
 292     }
 293
 294     TRACE("Created geometry group %p.\n", object);
 295     *group = (ID2D1GeometryGroup *)&object->ID2D1Geometry_iface;
 296
 297     return S_OK;
 298 }
 299
 300 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateTransformedGeometry(ID2D1Factory3 *iface,
 301         ID2D1Geometry *src_geometry, const D2D1_MATRIX_3X2_F *transform,
 302         ID2D1TransformedGeometry **transformed_geometry)
 303 {
 304     struct d2d_geometry *object;
 305
 306     TRACE("iface %p, src_geometry %p, transform %p, transformed_geometry %p.\n",
 307             iface, src_geometry, transform, transformed_geometry);
 308
 309     if (!(object = calloc(1, sizeof(*object))))
 310         return E_OUTOFMEMORY;
 311
 312     d2d_transformed_geometry_init(object, (ID2D1Factory *)iface, src_geometry, transform);
 313
 314     TRACE("Created transformed geometry %p.\n", object);
 315     *transformed_geometry = (ID2D1TransformedGeometry *)&object->ID2D1Geometry_iface;
 316
 317     return S_OK;
 318 }
 319
 320 static HRESULT STDMETHODCALLTYPE d2d_factory_CreatePathGeometry(ID2D1Factory3 *iface, ID2D1PathGeometry **geometry)
 321 {
 322     struct d2d_geometry *object;
 323
 324     TRACE("iface %p, geometry %p.\n", iface, geometry);
 325
 326     if (!(object = calloc(1, sizeof(*object))))
 327         return E_OUTOFMEMORY;
 328
 329     d2d_path_geometry_init(object, (ID2D1Factory *)iface);
 330
 331     TRACE("Created path geometry %p.\n", object);
 332     *geometry = (ID2D1PathGeometry *)&object->ID2D1Geometry_iface;
 333
 334     return S_OK;
 335 }
 336
 337 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateStrokeStyle(ID2D1Factory3 *iface,
 338         const D2D1_STROKE_STYLE_PROPERTIES *desc, const float *dashes, UINT32 dash_count,
 339         ID2D1StrokeStyle **stroke_style)
 340 {
 341     struct d2d_stroke_style *object;
 342     D2D1_STROKE_STYLE_PROPERTIES1 desc1;
 343     HRESULT hr;
 344
 345     TRACE("iface %p, desc %p, dashes %p, dash_count %u, stroke_style %p.\n",
 346             iface, desc, dashes, dash_count, stroke_style);
 347
 348     if (!(object = calloc(1, sizeof(*object))))
 349         return E_OUTOFMEMORY;
 350
 351     desc1.startCap = desc->startCap;
 352     desc1.endCap = desc->endCap;
 353     desc1.dashCap = desc->dashCap;
 354     desc1.lineJoin = desc->lineJoin;
 355     desc1.miterLimit = desc->miterLimit;
 356     desc1.dashStyle = desc->dashStyle;
 357     desc1.dashOffset = desc->dashOffset;
 358     desc1.transformType = D2D1_STROKE_TRANSFORM_TYPE_NORMAL;
 359
 360     if (FAILED(hr = d2d_stroke_style_init(object, (ID2D1Factory *)iface, &desc1, dashes, dash_count)))
 361     {
 362         WARN("Failed to initialise stroke style, hr %#lx.\n", hr);
 363         free(object);
 364         return hr;
 365     }
 366
 367     TRACE("Created stroke style %p.\n", object);
 368     *stroke_style = (ID2D1StrokeStyle *)&object->ID2D1StrokeStyle1_iface;
 369
 370     return S_OK;
 371 }
 372
 373 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateDrawingStateBlock(ID2D1Factory3 *iface,
 374         const D2D1_DRAWING_STATE_DESCRIPTION *desc, IDWriteRenderingParams *text_rendering_params,
 375         ID2D1DrawingStateBlock **state_block)
 376 {
 377     D2D1_DRAWING_STATE_DESCRIPTION1 state_desc;
 378     struct d2d_state_block *object;
 379
 380     TRACE("iface %p, desc %p, text_rendering_params %p, state_block %p.\n",
 381             iface, desc, text_rendering_params, state_block);
 382
 383     if (!(object = calloc(1, sizeof(*object))))
 384         return E_OUTOFMEMORY;
 385
 386     if (desc)
 387     {
 388         memcpy(&state_desc, desc, sizeof(*desc));
 389         state_desc.primitiveBlend = D2D1_PRIMITIVE_BLEND_SOURCE_OVER;
 390         state_desc.unitMode = D2D1_UNIT_MODE_DIPS;
 391     }
 392
 393     d2d_state_block_init(object, (ID2D1Factory *)iface, desc ? &state_desc : NULL, text_rendering_params);
 394
 395     TRACE("Created state block %p.\n", object);
 396     *state_block = (ID2D1DrawingStateBlock *)&object->ID2D1DrawingStateBlock1_iface;
 397
 398     return S_OK;
 399 }
 400
 401 static HRESULT d2d_factory_get_device(struct d2d_factory *factory, ID3D10Device1 **device)
 402 {
 403     HRESULT hr = S_OK;
 404
 405     if (!factory->device && FAILED(hr = D3D10CreateDevice1(NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL, D3D10_CREATE_DEVICE_BGRA_SUPPORT,
 406             D3D10_FEATURE_LEVEL_10_0, D3D10_1_SDK_VERSION, &factory->device)))
 407         WARN("Failed to create device, hr %#lx.\n", hr);
 408
 409     *device = factory->device;
 410     return hr;
 411 }
 412
 413 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateWicBitmapRenderTarget(ID2D1Factory3 *iface,
 414         IWICBitmap *target, const D2D1_RENDER_TARGET_PROPERTIES *desc, ID2D1RenderTarget **render_target)
 415 {
 416     struct d2d_factory *factory = impl_from_ID2D1Factory3(iface);
 417     struct d2d_wic_render_target *object;
 418     ID3D10Device1 *device;
 419     HRESULT hr;
 420
 421     TRACE("iface %p, target %p, desc %p, render_target %p.\n", iface, target, desc, render_target);
 422
 423     if (!(object = calloc(1, sizeof(*object))))
 424         return E_OUTOFMEMORY;
 425
 426     if (FAILED(hr = d2d_factory_get_device(factory, &device)))
 427     {
 428         free(object);
 429         return hr;
 430     }
 431
 432     if (FAILED(hr = d2d_wic_render_target_init(object, (ID2D1Factory1 *)iface, device, target, desc)))
 433     {
 434         WARN("Failed to initialise render target, hr %#lx.\n", hr);
 435         free(object);
 436         return hr;
 437     }
 438
 439     TRACE("Created render target %p.\n", object);
 440     *render_target = object->dxgi_target;
 441
 442     return S_OK;
 443 }
 444
 445 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateHwndRenderTarget(ID2D1Factory3 *iface,
 446         const D2D1_RENDER_TARGET_PROPERTIES *desc, const D2D1_HWND_RENDER_TARGET_PROPERTIES *hwnd_rt_desc,
 447         ID2D1HwndRenderTarget **render_target)
 448 {
 449     struct d2d_factory *factory = impl_from_ID2D1Factory3(iface);
 450     struct d2d_hwnd_render_target *object;
 451     ID3D10Device1 *device;
 452     HRESULT hr;
 453
 454     TRACE("iface %p, desc %p, hwnd_rt_desc %p, render_target %p.\n", iface, desc, hwnd_rt_desc, render_target);
 455
 456     if (FAILED(hr = d2d_factory_get_device(factory, &device)))
 457         return hr;
 458
 459     if (!(object = calloc(1, sizeof(*object))))
 460         return E_OUTOFMEMORY;
 461
 462     if (FAILED(hr = d2d_hwnd_render_target_init(object, (ID2D1Factory1 *)iface, device, desc, hwnd_rt_desc)))
 463     {
 464         WARN("Failed to initialise render target, hr %#lx.\n", hr);
 465         free(object);
 466         return hr;
 467     }
 468
 469     TRACE("Created render target %p.\n", object);
 470     *render_target = &object->ID2D1HwndRenderTarget_iface;
 471
 472     return S_OK;
 473 }
 474
 475 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateDxgiSurfaceRenderTarget(ID2D1Factory3 *iface,
 476         IDXGISurface *surface, const D2D1_RENDER_TARGET_PROPERTIES *desc, ID2D1RenderTarget **render_target)
 477 {
 478     IDXGIDevice *dxgi_device;
 479     ID2D1Device *device;
 480     HRESULT hr;
 481
 482     TRACE("iface %p, surface %p, desc %p, render_target %p.\n", iface, surface, desc, render_target);
 483
 484     if (FAILED(hr = IDXGISurface_GetDevice(surface, &IID_IDXGIDevice, (void **)&dxgi_device)))
 485     {
 486         WARN("Failed to get DXGI device, hr %#lx.\n", hr);
 487         return hr;
 488     }
 489
 490     hr = ID2D1Factory1_CreateDevice((ID2D1Factory1 *)iface, dxgi_device, &device);
 491     IDXGIDevice_Release(dxgi_device);
 492     if (FAILED(hr))
 493     {
 494         WARN("Failed to create D2D device, hr %#lx.\n", hr);
 495         return hr;
 496     }
 497
 498     hr = d2d_d3d_create_render_target(device, surface, NULL, NULL, desc, (void **)render_target);
 499     ID2D1Device_Release(device);
 500     return hr;
 501 }
 502
 503 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateDCRenderTarget(ID2D1Factory3 *iface,
 504         const D2D1_RENDER_TARGET_PROPERTIES *desc, ID2D1DCRenderTarget **render_target)
 505 {
 506     struct d2d_factory *factory = impl_from_ID2D1Factory3(iface);
 507     struct d2d_dc_render_target *object;
 508     ID3D10Device1 *device;
 509     HRESULT hr;
 510
 511     TRACE("iface %p, desc %p, render_target %p.\n", iface, desc, render_target);
 512
 513     if (FAILED(hr = d2d_factory_get_device(factory, &device)))
 514         return hr;
 515
 516     if (!(object = calloc(1, sizeof(*object))))
 517         return E_OUTOFMEMORY;
 518
 519     if (FAILED(hr = d2d_dc_render_target_init(object, (ID2D1Factory1 *)iface, device, desc)))
 520     {
 521         WARN("Failed to initialise render target, hr %#lx.\n", hr);
 522         free(object);
 523         return hr;
 524     }
 525
 526     TRACE("Created render target %p.\n", object);
 527     *render_target = &object->ID2D1DCRenderTarget_iface;
 528
 529     return S_OK;
 530 }
 531
 532 static HRESULT d2d_factory_create_device(ID2D1Factory3 *iface, IDXGIDevice *dxgi_device,
 533         ID2D1Device1 **device) {
 534     struct d2d_device *object;
 535
 536     if (!(object = calloc(1, sizeof(*object))))
 537         return E_OUTOFMEMORY;
 538
 539     d2d_device_init(object, (ID2D1Factory1 *)iface, dxgi_device);
 540
 541     TRACE("Create device %p.\n", object);
 542     *device = &object->ID2D1Device1_iface;
 543
 544     return S_OK;
 545 }
 546
 547 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateDevice(ID2D1Factory3 *iface,
 548         IDXGIDevice *dxgi_device, ID2D1Device **device)
 549 {
 550     TRACE("iface %p, dxgi_device %p, device %p.\n", iface, dxgi_device, device);
 551
 552     return d2d_factory_create_device(iface, dxgi_device, (ID2D1Device1 **)device);
 553 }
 554
 555 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateStrokeStyle1(ID2D1Factory3 *iface,
 556         const D2D1_STROKE_STYLE_PROPERTIES1 *desc, const float *dashes, UINT32 dash_count,
 557         ID2D1StrokeStyle1 **stroke_style)
 558 {
 559     struct d2d_stroke_style *object;
 560     HRESULT hr;
 561
 562     TRACE("iface %p, desc %p, dashes %p, dash_count %u, stroke_style %p.\n",
 563             iface, desc, dashes, dash_count, stroke_style);
 564
 565     if (!(object = calloc(1, sizeof(*object))))
 566         return E_OUTOFMEMORY;
 567
 568     if (FAILED(hr = d2d_stroke_style_init(object, (ID2D1Factory *)iface,
 569             desc, dashes, dash_count)))
 570     {
 571         WARN("Failed to initialise stroke style, hr %#lx.\n", hr);
 572         free(object);
 573         return hr;
 574     }
 575
 576     TRACE("Created stroke style %p.\n", object);
 577     *stroke_style = &object->ID2D1StrokeStyle1_iface;
 578
 579     return S_OK;
 580 }
 581
 582 static HRESULT STDMETHODCALLTYPE d2d_factory_CreatePathGeometry1(ID2D1Factory3 *iface, ID2D1PathGeometry1 **geometry)
 583 {
 584     struct d2d_geometry *object;
 585
 586     TRACE("iface %p, geometry %p.\n", iface, geometry);
 587
 588     if (!(object = calloc(1, sizeof(*object))))
 589         return E_OUTOFMEMORY;
 590
 591     d2d_path_geometry_init(object, (ID2D1Factory *)iface);
 592
 593     TRACE("Created path geometry %p.\n", object);
 594     *geometry = (ID2D1PathGeometry1 *)&object->ID2D1Geometry_iface;
 595
 596     return S_OK;
 597 }
 598
 599 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateDrawingStateBlock1(ID2D1Factory3 *iface,
 600         const D2D1_DRAWING_STATE_DESCRIPTION1 *desc, IDWriteRenderingParams *text_rendering_params,
 601         ID2D1DrawingStateBlock1 **state_block)
 602 {
 603     struct d2d_state_block *object;
 604
 605     TRACE("iface %p, desc %p, text_rendering_params %p, state_block %p.\n",
 606             iface, desc, text_rendering_params, state_block);
 607
 608     if (!(object = calloc(1, sizeof(*object))))
 609         return E_OUTOFMEMORY;
 610
 611     d2d_state_block_init(object, (ID2D1Factory *)iface, desc, text_rendering_params);
 612
 613     TRACE("Created state block %p.\n", object);
 614     *state_block = &object->ID2D1DrawingStateBlock1_iface;
 615
 616     return S_OK;
 617 }
 618
 619 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateGdiMetafile(ID2D1Factory3 *iface,
 620         IStream *stream, ID2D1GdiMetafile **metafile)
 621 {
 622     FIXME("iface %p, stream %p, metafile %p stub!\n", iface, stream, metafile);
 623
 624     return E_NOTIMPL;
 625 }
 626
 627 static HRESULT parse_effect_get_next_xml_node(IXmlReader *reader, XmlNodeType expected_type,
 628         const WCHAR *expected_name, unsigned int *depth)
 629 {
 630     const WCHAR *node_name;
 631     XmlNodeType node_type;
 632     HRESULT hr;
 633
 634     assert(expected_type != XmlNodeType_Whitespace);
 635
 636     while ((hr = IXmlReader_Read(reader, &node_type)) == S_OK)
 637     {
 638         if (node_type == XmlNodeType_Whitespace)
 639             continue;
 640
 641         if (expected_type != XmlNodeType_None && node_type != expected_type)
 642             return HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
 643
 644         if (expected_name)
 645         {
 646             if (FAILED(hr = IXmlReader_GetLocalName(reader, &node_name, NULL)))
 647                 return hr;
 648
 649             if (wcscmp(node_name, expected_name))
 650                 return HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
 651         }
 652
 653         if (depth)
 654             IXmlReader_GetDepth(reader, depth);
 655         return S_OK;
 656     }
 657
 658     return hr;
 659 }
 660
 661 static HRESULT parse_effect_skip_element(IXmlReader *reader, unsigned int element_depth)
 662 {
 663     XmlNodeType node_type;
 664     unsigned int depth;
 665     HRESULT hr;
 666
 667     if (IXmlReader_IsEmptyElement(reader)) return S_OK;
 668
 669     while ((hr = IXmlReader_Read(reader, &node_type)) == S_OK)
 670     {
 671         IXmlReader_GetDepth(reader, &depth);
 672         if (node_type == XmlNodeType_EndElement && depth == element_depth + 1)
 673         {
 674             return S_OK;
 675         }
 676     }
 677
 678     return hr;
 679 }
 680
 681 static HRESULT parse_effect_get_attribute(IXmlReader *reader, const WCHAR *name, WCHAR **ret)
 682 {
 683     const WCHAR *value;
 684
 685     *ret = NULL;
 686
 687     if (IXmlReader_MoveToAttributeByName(reader, name, NULL) != S_OK)
 688         return E_INVALIDARG;
 689     if (IXmlReader_GetValue(reader, &value, NULL) != S_OK)
 690         return E_INVALIDARG;
 691     if (!(*ret = wcsdup(value)))
 692         return E_OUTOFMEMORY;
 693
 694     return S_OK;
 695 }
 696
 697 static HRESULT parse_effect_get_property_type(IXmlReader *reader, D2D1_PROPERTY_TYPE *type)
 698 {
 699     static const WCHAR *types[] =
 700     {
 701         L"",             /* D2D1_PROPERTY_TYPE_UNKNOWN */
 702         L"string",       /* D2D1_PROPERTY_TYPE_STRING */
 703         L"bool",         /* D2D1_PROPERTY_TYPE_BOOL */
 704         L"uint32",       /* D2D1_PROPERTY_TYPE_UINT32 */
 705         L"int32",        /* D2D1_PROPERTY_TYPE_INT32 */
 706         L"float",        /* D2D1_PROPERTY_TYPE_FLOAT */
 707         L"vector2",      /* D2D1_PROPERTY_TYPE_VECTOR2 */
 708         L"vector3",      /* D2D1_PROPERTY_TYPE_VECTOR3 */
 709         L"vector4",      /* D2D1_PROPERTY_TYPE_VECTOR4 */
 710         L"blob",         /* D2D1_PROPERTY_TYPE_BLOB */
 711         L"iunknown",     /* D2D1_PROPERTY_TYPE_IUNKNOWN */
 712         L"enum",         /* D2D1_PROPERTY_TYPE_ENUM */
 713         L"array",        /* D2D1_PROPERTY_TYPE_ARRAY */
 714         L"clsid",        /* D2D1_PROPERTY_TYPE_CLSID */
 715         L"matrix3x2",    /* D2D1_PROPERTY_TYPE_MATRIX_3X2 */
 716         L"matrix4x3",    /* D2D1_PROPERTY_TYPE_MATRIX_4X3 */
 717         L"matrix4x4",    /* D2D1_PROPERTY_TYPE_MATRIX_4X4 */
 718         L"matrix5x4",    /* D2D1_PROPERTY_TYPE_MATRIX_5X4 */
 719         L"colorcontext", /* D2D1_PROPERTY_TYPE_COLOR_CONTEXT */
 720     };
 721     unsigned int i;
 722     WCHAR *value;
 723     HRESULT hr;
 724
 725     if (FAILED(hr = parse_effect_get_attribute(reader, L"type", &value))) return hr;
 726
 727     *type = D2D1_PROPERTY_TYPE_UNKNOWN;
 728
 729     for (i = 0; i < ARRAY_SIZE(types); ++i)
 730     {
 731         if (!wcscmp(value, types[i]))
 732         {
 733             *type = i;
 734             break;
 735         }
 736     }
 737
 738     free(value);
 739
 740     return *type == D2D1_PROPERTY_TYPE_UNKNOWN ? E_INVALIDARG : S_OK;
 741 }
 742
 743 static struct d2d_effect_property * parse_effect_get_property(const struct d2d_effect_registration *effect,
 744         const WCHAR *name)
 745 {
 746     unsigned int i;
 747
 748     for (i = 0; i < effect->properties.count; ++i)
 749     {
 750         if (!wcscmp(name, effect->properties.properties[i].name))
 751             return &effect->properties.properties[i];
 752     }
 753
 754     return NULL;
 755 }
 756
 757 static UINT32 parse_effect_get_property_index(struct d2d_effect_properties *props,
 758         const WCHAR *name)
 759 {
 760     if (!wcscmp(name, L"DisplayName")) return D2D1_PROPERTY_DISPLAYNAME;
 761     if (!wcscmp(name, L"Author")) return D2D1_PROPERTY_AUTHOR;
 762     if (!wcscmp(name, L"Category")) return D2D1_PROPERTY_CATEGORY;
 763     if (!wcscmp(name, L"Description")) return D2D1_PROPERTY_DESCRIPTION;
 764     return props->custom_count;
 765 }
 766
 767 static HRESULT parse_effect_property(IXmlReader *reader, struct d2d_effect_registration *effect)
 768 {
 769     WCHAR *name = NULL, *value = NULL;
 770     D2D1_PROPERTY_TYPE type;
 771     unsigned int depth;
 772     UINT32 index;
 773     HRESULT hr;
 774
 775     if (FAILED(hr = parse_effect_get_attribute(reader, L"name", &name)))
 776         return hr;
 777
 778     if (FAILED(hr = parse_effect_get_property_type(reader, &type)))
 779     {
 780         free(name);
 781         return hr;
 782     }
 783
 784     /* Check for duplicates. */
 785     if (parse_effect_get_property(effect, name))
 786         hr = E_INVALIDARG;
 787
 788     parse_effect_get_attribute(reader, L"value", &value);
 789
 790     if (SUCCEEDED(hr))
 791     {
 792         /* FIXME: sub properties are ignored */
 793         IXmlReader_MoveToElement(reader);
 794         IXmlReader_GetDepth(reader, &depth);
 795         hr = parse_effect_skip_element(reader, depth);
 796     }
 797
 798     if (SUCCEEDED(hr))
 799     {
 800         index = parse_effect_get_property_index(&effect->properties, name);
 801         hr = d2d_effect_properties_add(&effect->properties, name, index, type, value);
 802     }
 803
 804     free(value);
 805     free(name);
 806
 807     return hr;
 808 }
 809
 810 static HRESULT parse_effect_inputs(IXmlReader *reader, struct d2d_effect_registration *effect)
 811 {
 812     struct d2d_effect_properties *subproperties;
 813     unsigned int depth, input_count = 0;
 814     struct d2d_effect_property *inputs;
 815     XmlNodeType node_type;
 816     WCHAR nameW[16];
 817     WCHAR *name;
 818     HRESULT hr;
 819
 820     if (FAILED(hr = d2d_effect_properties_add(&effect->properties, L"Inputs",
 821             D2D1_PROPERTY_INPUTS, D2D1_PROPERTY_TYPE_ARRAY, NULL)))
 822         return hr;
 823
 824     if (!(inputs = d2d_effect_properties_get_property_by_name(&effect->properties, L"Inputs")))
 825         return E_FAIL;
 826     if (!(inputs->subproperties = calloc(1, sizeof(*inputs->subproperties))))
 827         return E_OUTOFMEMORY;
 828     subproperties = inputs->subproperties;
 829
 830     d2d_effect_subproperties_add(subproperties, L"IsReadOnly", D2D1_SUBPROPERTY_ISREADONLY,
 831             D2D1_PROPERTY_TYPE_BOOL, L"true");
 832     d2d_effect_subproperties_add(subproperties, L"DisplayName", D2D1_SUBPROPERTY_DISPLAYNAME,
 833             D2D1_PROPERTY_TYPE_STRING, L"Inputs");
 834
 835     if (IXmlReader_IsEmptyElement(reader)) return S_OK;
 836
 837     while (parse_effect_get_next_xml_node(reader, XmlNodeType_None, L"Input", &depth) == S_OK)
 838     {
 839         if (FAILED(hr = IXmlReader_GetNodeType(reader, &node_type))) return hr;
 840         if (node_type == XmlNodeType_EndElement) continue;
 841         if (node_type != XmlNodeType_Element) return HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
 842
 843         if (FAILED(hr = parse_effect_get_attribute(reader, L"name", &name))) return hr;
 844
 845         swprintf(nameW, ARRAY_SIZE(nameW), L"%lu", input_count);
 846         d2d_effect_subproperties_add(subproperties, nameW, input_count, D2D1_PROPERTY_TYPE_STRING, name);
 847         input_count++;
 848
 849         free(name);
 850     }
 851     *(UINT32 *)(effect->properties.data.ptr + inputs->data.offset) = input_count;
 852
 853     if (FAILED(hr = IXmlReader_GetNodeType(reader, &node_type))) return hr;
 854     if (node_type != XmlNodeType_EndElement) return HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
 855
 856     return S_OK;
 857 }
 858
 859 static HRESULT parse_effect_xml(IXmlReader *reader, struct d2d_effect_registration *effect)
 860 {
 861     const WCHAR *node_name;
 862     XmlNodeType node_type;
 863     unsigned int depth;
 864     HRESULT hr;
 865
 866     /* Xml declaration node is mandatory. */
 867     if ((hr = parse_effect_get_next_xml_node(reader, XmlNodeType_XmlDeclaration, L"xml", NULL)) != S_OK)
 868         return hr;
 869
 870     /* Top level "Effect" element. */
 871     if ((hr = parse_effect_get_next_xml_node(reader, XmlNodeType_Element, L"Effect", NULL)) != S_OK)
 872         return hr;
 873
 874     /* Loop inside effect node */
 875     while ((hr = parse_effect_get_next_xml_node(reader, XmlNodeType_None, NULL, &depth)) == S_OK)
 876     {
 877         if (FAILED(hr = IXmlReader_GetNodeType(reader, &node_type))) return hr;
 878         if (node_type != XmlNodeType_Element && node_type != XmlNodeType_EndElement) continue;
 879         if (FAILED(hr = IXmlReader_GetLocalName(reader, &node_name, NULL))) return hr;
 880         if (node_type == XmlNodeType_EndElement) break;
 881
 882         if (!wcscmp(node_name, L"Property"))
 883             hr = parse_effect_property(reader, effect);
 884         else if (!wcscmp(node_name, L"Inputs"))
 885             hr = parse_effect_inputs(reader, effect);
 886         else
 887         {
 888             WARN("Unexpected element %s.\n", debugstr_w(node_name));
 889             hr = parse_effect_skip_element(reader, depth);
 890         }
 891
 892         if (FAILED(hr))
 893             return hr;
 894     }
 895
 896     return hr;
 897 }
 898
 899 static HRESULT STDMETHODCALLTYPE d2d_factory_RegisterEffectFromStream(ID2D1Factory3 *iface,
 900         REFCLSID effect_id, IStream *property_xml, const D2D1_PROPERTY_BINDING *bindings,
 901         UINT32 binding_count, PD2D1_EFFECT_FACTORY effect_factory)
 902 {
 903     struct d2d_factory *factory = impl_from_ID2D1Factory3(iface);
 904     struct d2d_effect_registration *effect;
 905     IXmlReader *reader;
 906     unsigned int i;
 907     HRESULT hr;
 908
 909     TRACE("iface %p, effect_id %s, property_xml %p, bindings %p, binding_count %u, effect_factory %p.\n",
 910             iface, debugstr_guid(effect_id), property_xml, bindings, binding_count, effect_factory);
 911
 912     d2d_factory_init_builtin_effects(factory);
 913
 914     LIST_FOR_EACH_ENTRY_REV(effect, &factory->effects, struct d2d_effect_registration, entry)
 915     {
 916         if (IsEqualGUID(effect_id, &effect->id))
 917         {
 918             if (effect->builtin) return E_INVALIDARG;
 919             ++effect->registration_count;
 920             return S_OK;
 921         }
 922     }
 923
 924     if (FAILED(hr = CreateXmlReader(&IID_IXmlReader, (void **)&reader, NULL)))
 925         return hr;
 926
 927     if (FAILED(hr = IXmlReader_SetInput(reader, (IUnknown *)property_xml)))
 928     {
 929         IXmlReader_Release(reader);
 930         return hr;
 931     }
 932
 933     if (!(effect = calloc(1, sizeof(*effect))))
 934     {
 935         IXmlReader_Release(reader);
 936         return E_OUTOFMEMORY;
 937     }
 938
 939     hr = parse_effect_xml(reader, effect);
 940     IXmlReader_Release(reader);
 941     if (FAILED(hr))
 942     {
 943         WARN("Failed to parse effect xml, hr %#lx.\n", hr);
 944         d2d_effect_registration_cleanup(effect);
 945         return hr;
 946     }
 947
 948     /* Check required properties. */
 949     if (!parse_effect_get_property(effect, L"DisplayName")
 950             || !parse_effect_get_property(effect, L"Author")
 951             || !parse_effect_get_property(effect, L"Category")
 952             || !parse_effect_get_property(effect, L"Description")
 953             || !parse_effect_get_property(effect, L"Inputs"))
 954     {
 955         WARN("Missing required properties.\n");
 956         d2d_effect_registration_cleanup(effect);
 957         return E_INVALIDARG;
 958     }
 959
 960     /* Bind getter and setter. */
 961     for (i = 0; i < binding_count; ++i)
 962     {
 963         struct d2d_effect_property *property;
 964
 965         if (!(property = parse_effect_get_property(effect, bindings[i].propertyName)))
 966         {
 967             WARN("Failed to bind to missing property.\n");
 968             d2d_effect_registration_cleanup(effect);
 969             return D2DERR_INVALID_PROPERTY;
 970         }
 971
 972         property->get_function = bindings[i].getFunction;
 973         property->set_function = bindings[i].setFunction;
 974     }
 975
 976     effect->registration_count = 1;
 977     effect->id = *effect_id;
 978     effect->factory = effect_factory;
 979     d2d_effect_properties_add(&effect->properties, L"MinInputs", D2D1_PROPERTY_MIN_INPUTS,
 980             D2D1_PROPERTY_TYPE_UINT32, L"1");
 981     d2d_effect_properties_add(&effect->properties, L"MaxInputs", D2D1_PROPERTY_MAX_INPUTS,
 982             D2D1_PROPERTY_TYPE_UINT32, L"1" /* FIXME */);
 983     effect->default_input_count = 1;
 984     d2d_factory_register_effect(factory, effect);
 985
 986     return S_OK;
 987 }
 988
 989 static HRESULT STDMETHODCALLTYPE d2d_factory_RegisterEffectFromString(ID2D1Factory3 *iface,
 990         REFCLSID effect_id, const WCHAR *property_xml, const D2D1_PROPERTY_BINDING *bindings,
 991         UINT32 binding_count, PD2D1_EFFECT_FACTORY effect_factory)
 992 {
 993     static const LARGE_INTEGER zero;
 994     IStream *stream;
 995     ULONG size;
 996     HRESULT hr;
 997
 998     TRACE("iface %p, effect_id %s, property_xml %s, bindings %p, binding_count %u, effect_factory %p.\n",
 999           iface, debugstr_guid(effect_id), debugstr_w(property_xml), bindings, binding_count, effect_factory);
1000
1001     if (FAILED(hr = CreateStreamOnHGlobal(NULL, TRUE, &stream)))
1002         return hr;
1003
1004     size = sizeof(*property_xml) * (wcslen(property_xml) + 1);
1005     if (SUCCEEDED(hr = IStream_Write(stream, property_xml, size, NULL)))
1006         hr = IStream_Seek(stream, zero, SEEK_SET, NULL);
1007
1008     if (SUCCEEDED(hr))
1009         hr = ID2D1Factory3_RegisterEffectFromStream(iface, effect_id, stream, bindings,
1010                 binding_count, effect_factory);
1011
1012     IStream_Release(stream);
1013     return hr;
1014 }
1015
1016 static HRESULT STDMETHODCALLTYPE d2d_factory_UnregisterEffect(ID2D1Factory3 *iface, REFCLSID effect_id)
1017 {
1018     struct d2d_factory *factory = impl_from_ID2D1Factory3(iface);
1019     struct d2d_effect_registration *effect;
1020
1021     TRACE("iface %p, effect_id %s.\n", iface, debugstr_guid(effect_id));
1022
1023     d2d_factory_init_builtin_effects(factory);
1024
1025     LIST_FOR_EACH_ENTRY_REV(effect, &factory->effects, struct d2d_effect_registration, entry)
1026     {
1027         if (IsEqualGUID(effect_id, &effect->id))
1028         {
1029             if (effect->builtin) break;
1030             if (!--effect->registration_count)
1031             {
1032                 list_remove(&effect->entry);
1033                 d2d_effect_registration_cleanup(effect);
1034             }
1035             return S_OK;
1036         }
1037     }
1038
1039     return D2DERR_EFFECT_IS_NOT_REGISTERED;
1040 }
1041
1042 static HRESULT STDMETHODCALLTYPE d2d_factory_GetRegisteredEffects(ID2D1Factory3 *iface,
1043         CLSID *effects, UINT32 effect_count, UINT32 *returned, UINT32 *registered)
1044 {
1045     struct d2d_factory *factory = impl_from_ID2D1Factory3(iface);
1046     struct d2d_effect_registration *effect;
1047     UINT32 ret, reg;
1048
1049     TRACE("iface %p, effects %p, effect_count %u, returned %p, registered %p.\n",
1050             iface, effects, effect_count, returned, registered);
1051
1052     if (!returned) returned = &ret;
1053     if (!registered) registered = &reg;
1054
1055     *registered = 0;
1056     *returned = 0;
1057
1058     d2d_factory_init_builtin_effects(factory);
1059
1060     LIST_FOR_EACH_ENTRY(effect, &factory->effects, struct d2d_effect_registration, entry)
1061     {
1062         if (effects && effect_count)
1063         {
1064             *effects = effect->id;
1065             effects++;
1066             effect_count--;
1067             *returned += 1;
1068         }
1069
1070         *registered += 1;
1071     }
1072
1073     if (!effects) return S_OK;
1074     return *returned == *registered ? S_OK : D2DERR_INSUFFICIENT_BUFFER;
1075 }
1076
1077 static HRESULT STDMETHODCALLTYPE d2d_factory_GetEffectProperties(ID2D1Factory3 *iface,
1078         REFCLSID effect_id, ID2D1Properties **props)
1079 {
1080     FIXME("iface %p, effect_id %s, props %p stub!\n", iface, debugstr_guid(effect_id), props);
1081
1082     return E_NOTIMPL;
1083 }
1084
1085 static HRESULT STDMETHODCALLTYPE d2d_factory_ID2D1Factory2_CreateDevice(ID2D1Factory3 *iface, IDXGIDevice *dxgi_device,
1086         ID2D1Device1 **device)
1087 {
1088     TRACE("iface %p, dxgi_device %p, device %p.\n", iface, dxgi_device, device);
1089
1090     return d2d_factory_create_device(iface, dxgi_device, device);
1091 }
1092
1093 static HRESULT STDMETHODCALLTYPE d2d_factory_ID2D1Factory3_CreateDevice(ID2D1Factory3 *iface, IDXGIDevice *dxgi_device,
1094         ID2D1Device2 **device)
1095 {
1096     FIXME("iface %p, dxgi_device %p, device %p stub!\n", iface, dxgi_device, device);
1097
1098     return E_NOTIMPL;
1099 }
1100
1101 static const struct ID2D1Factory3Vtbl d2d_factory_vtbl =
1102 {
1103     d2d_factory_QueryInterface,
1104     d2d_factory_AddRef,
1105     d2d_factory_Release,
1106     d2d_factory_ReloadSystemMetrics,
1107     d2d_factory_GetDesktopDpi,
1108     d2d_factory_CreateRectangleGeometry,
1109     d2d_factory_CreateRoundedRectangleGeometry,
1110     d2d_factory_CreateEllipseGeometry,
1111     d2d_factory_CreateGeometryGroup,
1112     d2d_factory_CreateTransformedGeometry,
1113     d2d_factory_CreatePathGeometry,
1114     d2d_factory_CreateStrokeStyle,
1115     d2d_factory_CreateDrawingStateBlock,
1116     d2d_factory_CreateWicBitmapRenderTarget,
1117     d2d_factory_CreateHwndRenderTarget,
1118     d2d_factory_CreateDxgiSurfaceRenderTarget,
1119     d2d_factory_CreateDCRenderTarget,
1120     d2d_factory_CreateDevice,
1121     d2d_factory_CreateStrokeStyle1,
1122     d2d_factory_CreatePathGeometry1,
1123     d2d_factory_CreateDrawingStateBlock1,
1124     d2d_factory_CreateGdiMetafile,
1125     d2d_factory_RegisterEffectFromStream,
1126     d2d_factory_RegisterEffectFromString,
1127     d2d_factory_UnregisterEffect,
1128     d2d_factory_GetRegisteredEffects,
1129     d2d_factory_GetEffectProperties,
1130     d2d_factory_ID2D1Factory2_CreateDevice,
1131     d2d_factory_ID2D1Factory3_CreateDevice,
1132 };
1133
1134 static HRESULT STDMETHODCALLTYPE d2d_factory_mt_QueryInterface(ID2D1Multithread *iface, REFIID iid, void **out)
1135 {
1136     struct d2d_factory *factory = impl_from_ID2D1Multithread(iface);
1137     return d2d_factory_QueryInterface(&factory->ID2D1Factory3_iface, iid, out);
1138 }
1139
1140 static ULONG STDMETHODCALLTYPE d2d_factory_mt_AddRef(ID2D1Multithread *iface)
1141 {
1142     struct d2d_factory *factory = impl_from_ID2D1Multithread(iface);
1143     return d2d_factory_AddRef(&factory->ID2D1Factory3_iface);
1144 }
1145
1146 static ULONG STDMETHODCALLTYPE d2d_factory_mt_Release(ID2D1Multithread *iface)
1147 {
1148     struct d2d_factory *factory = impl_from_ID2D1Multithread(iface);
1149     return d2d_factory_Release(&factory->ID2D1Factory3_iface);
1150 }
1151
1152 static BOOL STDMETHODCALLTYPE d2d_factory_mt_GetMultithreadProtected(ID2D1Multithread *iface)
1153 {
1154     return TRUE;
1155 }
1156
1157 static void STDMETHODCALLTYPE d2d_factory_mt_Enter(ID2D1Multithread *iface)
1158 {
1159     struct d2d_factory *factory = impl_from_ID2D1Multithread(iface);
1160
1161     TRACE("%p.\n", iface);
1162
1163     EnterCriticalSection(&factory->cs);
1164 }
1165
1166 static void STDMETHODCALLTYPE d2d_factory_mt_Leave(ID2D1Multithread *iface)
1167 {
1168     struct d2d_factory *factory = impl_from_ID2D1Multithread(iface);
1169
1170     TRACE("%p.\n", iface);
1171
1172     LeaveCriticalSection(&factory->cs);
1173 }
1174
1175 static BOOL STDMETHODCALLTYPE d2d_factory_st_GetMultithreadProtected(ID2D1Multithread *iface)
1176 {
1177     return FALSE;
1178 }
1179
1180 static void STDMETHODCALLTYPE d2d_factory_st_Enter(ID2D1Multithread *iface)
1181 {
1182 }
1183
1184 static void STDMETHODCALLTYPE d2d_factory_st_Leave(ID2D1Multithread *iface)
1185 {
1186 }
1187
1188 static const struct ID2D1MultithreadVtbl d2d_factory_multithread_vtbl =
1189 {
1190     d2d_factory_mt_QueryInterface,
1191     d2d_factory_mt_AddRef,
1192     d2d_factory_mt_Release,
1193     d2d_factory_mt_GetMultithreadProtected,
1194     d2d_factory_mt_Enter,
1195     d2d_factory_mt_Leave,
1196 };
1197
1198 static const struct ID2D1MultithreadVtbl d2d_factory_multithread_noop_vtbl =
1199 {
1200     d2d_factory_mt_QueryInterface,
1201     d2d_factory_mt_AddRef,
1202     d2d_factory_mt_Release,
1203     d2d_factory_st_GetMultithreadProtected,
1204     d2d_factory_st_Enter,
1205     d2d_factory_st_Leave,
1206 };
1207
1208 static void d2d_factory_init(struct d2d_factory *factory, D2D1_FACTORY_TYPE factory_type,
1209         const D2D1_FACTORY_OPTIONS *factory_options)
1210 {
1211     if (factory_options && factory_options->debugLevel != D2D1_DEBUG_LEVEL_NONE)
1212         WARN("Ignoring debug level %#x.\n", factory_options->debugLevel);
1213
1214     factory->ID2D1Factory3_iface.lpVtbl = &d2d_factory_vtbl;
1215     factory->ID2D1Multithread_iface.lpVtbl = factory_type == D2D1_FACTORY_TYPE_SINGLE_THREADED ?
1216             &d2d_factory_multithread_noop_vtbl : &d2d_factory_multithread_vtbl;
1217     factory->refcount = 1;
1218     d2d_factory_reload_sysmetrics(factory);
1219     list_init(&factory->effects);
1220     InitializeCriticalSection(&factory->cs);
1221     InitOnceInitialize(&factory->init_builtins);
1222 }
1223
1224 HRESULT WINAPI D2D1CreateFactory(D2D1_FACTORY_TYPE factory_type, REFIID iid,
1225         const D2D1_FACTORY_OPTIONS *factory_options, void **factory)
1226 {
1227     struct d2d_factory *object;
1228     HRESULT hr;
1229
1230     TRACE("factory_type %#x, iid %s, factory_options %p, factory %p.\n",
1231             factory_type, debugstr_guid(iid), factory_options, factory);
1232
1233     if (factory_type != D2D1_FACTORY_TYPE_SINGLE_THREADED &&
1234             factory_type != D2D1_FACTORY_TYPE_MULTI_THREADED)
1235     {
1236         return E_INVALIDARG;
1237     }
1238
1239     if (!(object = calloc(1, sizeof(*object))))
1240         return E_OUTOFMEMORY;
1241
1242     d2d_factory_init(object, factory_type, factory_options);
1243
1244     TRACE("Created factory %p.\n", object);
1245
1246     hr = ID2D1Factory3_QueryInterface(&object->ID2D1Factory3_iface, iid, factory);
1247     ID2D1Factory3_Release(&object->ID2D1Factory3_iface);
1248
1249     return hr;
1250 }
1251
1252 void WINAPI D2D1MakeRotateMatrix(float angle, D2D1_POINT_2F center, D2D1_MATRIX_3X2_F *matrix)
1253 {
1254     float theta, sin_theta, cos_theta;
1255
1256     TRACE("angle %.8e, center %s, matrix %p.\n", angle, debug_d2d_point_2f(&center), matrix);
1257
1258     theta = angle * (M_PI / 180.0f);
1259     sin_theta = sinf(theta);
1260     cos_theta = cosf(theta);
1261
1262     /* translate(center) * rotate(theta) * translate(-center) */
1263     matrix->_11 = cos_theta;
1264     matrix->_12 = sin_theta;
1265     matrix->_21 = -sin_theta;
1266     matrix->_22 = cos_theta;
1267     matrix->_31 = center.x - center.x * cos_theta + center.y * sin_theta;
1268     matrix->_32 = center.y - center.x * sin_theta - center.y * cos_theta;
1269 }
1270
1271 void WINAPI D2D1MakeSkewMatrix(float angle_x, float angle_y, D2D1_POINT_2F center, D2D1_MATRIX_3X2_F *matrix)
1272 {
1273     float tan_x, tan_y;
1274
1275     TRACE("angle_x %.8e, angle_y %.8e, center %s, matrix %p.\n", angle_x, angle_y, debug_d2d_point_2f(&center), matrix);
1276
1277     tan_x = tan(angle_x * (M_PI / 180.0f));
1278     tan_y = tan(angle_y * (M_PI / 180.0f));
1279
1280     /* translate(-center) * skew() * translate(center) */
1281     matrix->_11 = 1.0f;
1282     matrix->_12 = tan_y;
1283     matrix->_21 = tan_x;
1284     matrix->_22 = 1.0f;
1285     matrix->_31 = -tan_x * center.y;
1286     matrix->_32 = -tan_y * center.x;
1287 }
1288
1289 BOOL WINAPI D2D1IsMatrixInvertible(const D2D1_MATRIX_3X2_F *matrix)
1290 {
1291     TRACE("matrix %p.\n", matrix);
1292
1293     return (matrix->_11 * matrix->_22 - matrix->_21 * matrix->_12) != 0.0f;
1294 }
1295
1296 BOOL WINAPI D2D1InvertMatrix(D2D1_MATRIX_3X2_F *matrix)
1297 {
1298     D2D1_MATRIX_3X2_F m = *matrix;
1299
1300     TRACE("matrix %p.\n", matrix);
1301
1302     return d2d_matrix_invert(matrix, &m);
1303 }
1304
1305 HRESULT WINAPI D2D1CreateDevice(IDXGIDevice *dxgi_device,
1306         const D2D1_CREATION_PROPERTIES *properties, ID2D1Device **device)
1307 {
1308     D2D1_CREATION_PROPERTIES default_properties = {0};
1309     D2D1_FACTORY_OPTIONS factory_options;
1310     ID3D11Device *d3d_device;
1311     ID2D1Factory1 *factory;
1312     HRESULT hr;
1313
1314     TRACE("dxgi_device %p, properties %p, device %p.\n", dxgi_device, properties, device);
1315
1316     if (!properties)
1317     {
1318         if (SUCCEEDED(IDXGIDevice_QueryInterface(dxgi_device, &IID_ID3D11Device, (void **)&d3d_device)))
1319         {
1320             if (!(ID3D11Device_GetCreationFlags(d3d_device) & D3D11_CREATE_DEVICE_SINGLETHREADED))
1321                 default_properties.threadingMode = D2D1_THREADING_MODE_MULTI_THREADED;
1322             ID3D11Device_Release(d3d_device);
1323         }
1324         properties = &default_properties;
1325     }
1326
1327     factory_options.debugLevel = properties->debugLevel;
1328     if (FAILED(hr = D2D1CreateFactory(properties->threadingMode,
1329             &IID_ID2D1Factory1, &factory_options, (void **)&factory)))
1330         return hr;
1331
1332     hr = ID2D1Factory1_CreateDevice(factory, dxgi_device, device);
1333     ID2D1Factory1_Release(factory);
1334     return hr;
1335 }
1336
1337 void WINAPI D2D1SinCos(float angle, float *s, float *c)
1338 {
1339     TRACE("angle %.8e, s %p, c %p.\n", angle, s, c);
1340
1341     *s = sinf(angle);
1342     *c = cosf(angle);
1343 }
1344
1345 float WINAPI D2D1Tan(float angle)
1346 {
1347     TRACE("angle %.8e.\n", angle);
1348
1349     return tanf(angle);
1350 }
1351
1352 float WINAPI D2D1Vec3Length(float x, float y, float z)
1353 {
1354     TRACE("x %.8e, y %.8e, z %.8e.\n", x, y, z);
1355
1356     return sqrtf(x * x + y * y + z * z);
1357 }
1358
1359 /* See IEC 61966-2-1:1999; also described in the EXT_texture_sRGB OpenGL
1360  * extension, among others. */
1361 static float srgb_transfer_function(float x)
1362 {
1363     if (x <= 0.0f)
1364         return 0.0f;
1365     else if (x >= 1.0f)
1366         return 1.0f;
1367     else if (x <= 0.0031308f)
1368         return 12.92f * x;
1369     else
1370         return 1.055f * powf(x, 1.0f / 2.4f) - 0.055f;
1371 }
1372
1373 static float srgb_inverse_transfer_function(float x)
1374 {
1375     if (x <= 0.0f)
1376         return 0.0f;
1377     else if (x >= 1.0f)
1378         return 1.0f;
1379     else if (x <= 0.04045f)
1380         return x / 12.92f;
1381     else
1382         return powf((x + 0.055f) / 1.055f, 2.4f);
1383 }
1384
1385 D2D1_COLOR_F WINAPI D2D1ConvertColorSpace(D2D1_COLOR_SPACE src_colour_space,
1386         D2D1_COLOR_SPACE dst_colour_space, const D2D1_COLOR_F *colour)
1387 {
1388     D2D1_COLOR_F ret;
1389
1390     TRACE("src_colour_space %#x, dst_colour_space %#x, colour %s.\n",
1391             src_colour_space, dst_colour_space, debug_d2d_color_f(colour));
1392
1393     if (src_colour_space == D2D1_COLOR_SPACE_CUSTOM || dst_colour_space == D2D1_COLOR_SPACE_CUSTOM)
1394     {
1395         ret.r = 0.0f;
1396         ret.g = 0.0f;
1397         ret.b = 0.0f;
1398         ret.a = 0.0f;
1399
1400         return ret;
1401     }
1402
1403     if (src_colour_space == dst_colour_space)
1404         return *colour;
1405
1406     if (src_colour_space == D2D1_COLOR_SPACE_SRGB && dst_colour_space == D2D1_COLOR_SPACE_SCRGB)
1407     {
1408         ret.r = srgb_inverse_transfer_function(colour->r);
1409         ret.g = srgb_inverse_transfer_function(colour->g);
1410         ret.b = srgb_inverse_transfer_function(colour->b);
1411         ret.a = colour->a;
1412
1413         return ret;
1414     }
1415
1416     if (src_colour_space == D2D1_COLOR_SPACE_SCRGB && dst_colour_space == D2D1_COLOR_SPACE_SRGB)
1417     {
1418         ret.r = srgb_transfer_function(colour->r);
1419         ret.g = srgb_transfer_function(colour->g);
1420         ret.b = srgb_transfer_function(colour->b);
1421         ret.a = colour->a;
1422
1423         return ret;
1424     }
1425
1426     FIXME("Unhandled conversion from source colour space %#x to destination colour space %#x.\n",
1427             src_colour_space, dst_colour_space);
1428     ret.r = 0.0f;
1429     ret.g = 0.0f;
1430     ret.b = 0.0f;
1431     ret.a = 0.0f;
1432
1433     return ret;
1434 }
1435
1436 static bool get_config_key_u32(HKEY default_key, HKEY application_key, const char *name, uint32_t *value)
1437 {
1438     DWORD type, size;
1439     uint32_t data;
1440
1441     size = sizeof(data);
1442     if (application_key && !RegQueryValueExA(application_key,
1443             name, 0, &type, (BYTE *)&data, &size) && type == REG_DWORD)
1444         goto success;
1445
1446     size = sizeof(data);
1447     if (default_key && !RegQueryValueExA(default_key,
1448             name, 0, &type, (BYTE *)&data, &size) && type == REG_DWORD)
1449         goto success;
1450
1451     return false;
1452
1453 success:
1454     *value = data;
1455     return true;
1456 }
1457
1458 static void d2d_settings_init(void)
1459 {
1460     HKEY default_key, tmp_key, application_key = NULL;
1461     char buffer[MAX_PATH + 10];
1462     DWORD len;
1463
1464     if (RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Direct2D", &default_key))
1465         default_key = NULL;
1466
1467     len = GetModuleFileNameA(0, buffer, MAX_PATH);
1468     if (len && len < MAX_PATH)
1469     {
1470         char *p, *appname = buffer;
1471
1472         if ((p = strrchr(appname, '/')))
1473             appname = p + 1;
1474         if ((p = strrchr(appname, '\\')))
1475             appname = p + 1;
1476         strcat(appname, "\\Direct2D");
1477
1478         if (!RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\AppDefaults", &tmp_key))
1479         {
1480             if (RegOpenKeyA(tmp_key, appname, &application_key))
1481                 application_key = NULL;
1482             RegCloseKey(tmp_key);
1483         }
1484     }
1485
1486     if (!default_key && !application_key)
1487         return;
1488
1489     if (get_config_key_u32(default_key, application_key, "max_version_factory", &d2d_settings.max_version_factory))
1490         ERR_(winediag)("Limiting maximum Direct2D factory version to %#x.\n", d2d_settings.max_version_factory);
1491
1492     if (application_key)
1493         RegCloseKey(application_key);
1494     if (default_key)
1495         RegCloseKey(default_key);
1496 }
1497
1498 BOOL WINAPI DllMain(HINSTANCE inst, DWORD reason, void *reserved)
1499 {
1500     if (reason == DLL_PROCESS_ATTACH)
1501         d2d_settings_init();
1502     return TRUE;
1503 }