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(unsafe_impl_from_ID2D1Device((ID2D1Device1 *)device), surface,
 499             NULL, NULL, desc, (void **)render_target);
 500     ID2D1Device_Release(device);
 501     return hr;
 502 }
 503
 504 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateDCRenderTarget(ID2D1Factory3 *iface,
 505         const D2D1_RENDER_TARGET_PROPERTIES *desc, ID2D1DCRenderTarget **render_target)
 506 {
 507     struct d2d_factory *factory = impl_from_ID2D1Factory3(iface);
 508     struct d2d_dc_render_target *object;
 509     ID3D10Device1 *device;
 510     HRESULT hr;
 511
 512     TRACE("iface %p, desc %p, render_target %p.\n", iface, desc, render_target);
 513
 514     if (FAILED(hr = d2d_factory_get_device(factory, &device)))
 515         return hr;
 516
 517     if (!(object = calloc(1, sizeof(*object))))
 518         return E_OUTOFMEMORY;
 519
 520     if (FAILED(hr = d2d_dc_render_target_init(object, (ID2D1Factory1 *)iface, device, desc)))
 521     {
 522         WARN("Failed to initialise render target, hr %#lx.\n", hr);
 523         free(object);
 524         return hr;
 525     }
 526
 527     TRACE("Created render target %p.\n", object);
 528     *render_target = &object->ID2D1DCRenderTarget_iface;
 529
 530     return S_OK;
 531 }
 532
 533 static HRESULT d2d_factory_create_device(ID2D1Factory3 *iface, IDXGIDevice *dxgi_device,
 534         ID2D1Device1 **device) {
 535     struct d2d_device *object;
 536
 537     if (!(object = calloc(1, sizeof(*object))))
 538         return E_OUTOFMEMORY;
 539
 540     d2d_device_init(object, (ID2D1Factory1 *)iface, dxgi_device);
 541
 542     TRACE("Create device %p.\n", object);
 543     *device = &object->ID2D1Device1_iface;
 544
 545     return S_OK;
 546 }
 547
 548 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateDevice(ID2D1Factory3 *iface,
 549         IDXGIDevice *dxgi_device, ID2D1Device **device)
 550 {
 551     TRACE("iface %p, dxgi_device %p, device %p.\n", iface, dxgi_device, device);
 552
 553     return d2d_factory_create_device(iface, dxgi_device, (ID2D1Device1 **)device);
 554 }
 555
 556 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateStrokeStyle1(ID2D1Factory3 *iface,
 557         const D2D1_STROKE_STYLE_PROPERTIES1 *desc, const float *dashes, UINT32 dash_count,
 558         ID2D1StrokeStyle1 **stroke_style)
 559 {
 560     struct d2d_stroke_style *object;
 561     HRESULT hr;
 562
 563     TRACE("iface %p, desc %p, dashes %p, dash_count %u, stroke_style %p.\n",
 564             iface, desc, dashes, dash_count, stroke_style);
 565
 566     if (!(object = calloc(1, sizeof(*object))))
 567         return E_OUTOFMEMORY;
 568
 569     if (FAILED(hr = d2d_stroke_style_init(object, (ID2D1Factory *)iface,
 570             desc, dashes, dash_count)))
 571     {
 572         WARN("Failed to initialise stroke style, hr %#lx.\n", hr);
 573         free(object);
 574         return hr;
 575     }
 576
 577     TRACE("Created stroke style %p.\n", object);
 578     *stroke_style = &object->ID2D1StrokeStyle1_iface;
 579
 580     return S_OK;
 581 }
 582
 583 static HRESULT STDMETHODCALLTYPE d2d_factory_CreatePathGeometry1(ID2D1Factory3 *iface, ID2D1PathGeometry1 **geometry)
 584 {
 585     struct d2d_geometry *object;
 586
 587     TRACE("iface %p, geometry %p.\n", iface, geometry);
 588
 589     if (!(object = calloc(1, sizeof(*object))))
 590         return E_OUTOFMEMORY;
 591
 592     d2d_path_geometry_init(object, (ID2D1Factory *)iface);
 593
 594     TRACE("Created path geometry %p.\n", object);
 595     *geometry = (ID2D1PathGeometry1 *)&object->ID2D1Geometry_iface;
 596
 597     return S_OK;
 598 }
 599
 600 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateDrawingStateBlock1(ID2D1Factory3 *iface,
 601         const D2D1_DRAWING_STATE_DESCRIPTION1 *desc, IDWriteRenderingParams *text_rendering_params,
 602         ID2D1DrawingStateBlock1 **state_block)
 603 {
 604     struct d2d_state_block *object;
 605
 606     TRACE("iface %p, desc %p, text_rendering_params %p, state_block %p.\n",
 607             iface, desc, text_rendering_params, state_block);
 608
 609     if (!(object = calloc(1, sizeof(*object))))
 610         return E_OUTOFMEMORY;
 611
 612     d2d_state_block_init(object, (ID2D1Factory *)iface, desc, text_rendering_params);
 613
 614     TRACE("Created state block %p.\n", object);
 615     *state_block = &object->ID2D1DrawingStateBlock1_iface;
 616
 617     return S_OK;
 618 }
 619
 620 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateGdiMetafile(ID2D1Factory3 *iface,
 621         IStream *stream, ID2D1GdiMetafile **metafile)
 622 {
 623     FIXME("iface %p, stream %p, metafile %p stub!\n", iface, stream, metafile);
 624
 625     return E_NOTIMPL;
 626 }
 627
 628 static HRESULT parse_effect_get_next_xml_node(IXmlReader *reader, XmlNodeType expected_type,
 629         const WCHAR *expected_name, unsigned int *depth)
 630 {
 631     const WCHAR *node_name;
 632     XmlNodeType node_type;
 633     HRESULT hr;
 634
 635     assert(expected_type != XmlNodeType_Whitespace);
 636
 637     while ((hr = IXmlReader_Read(reader, &node_type)) == S_OK)
 638     {
 639         if (node_type == XmlNodeType_Whitespace)
 640             continue;
 641
 642         if (expected_type != XmlNodeType_None && node_type != expected_type)
 643             return HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
 644
 645         if (expected_name)
 646         {
 647             if (FAILED(hr = IXmlReader_GetLocalName(reader, &node_name, NULL)))
 648                 return hr;
 649
 650             if (wcscmp(node_name, expected_name))
 651                 return HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
 652         }
 653
 654         if (depth)
 655             IXmlReader_GetDepth(reader, depth);
 656         return S_OK;
 657     }
 658
 659     return hr;
 660 }
 661
 662 static HRESULT parse_effect_skip_element(IXmlReader *reader, unsigned int element_depth)
 663 {
 664     XmlNodeType node_type;
 665     unsigned int depth;
 666     HRESULT hr;
 667
 668     if (IXmlReader_IsEmptyElement(reader)) return S_OK;
 669
 670     while ((hr = IXmlReader_Read(reader, &node_type)) == S_OK)
 671     {
 672         IXmlReader_GetDepth(reader, &depth);
 673         if (node_type == XmlNodeType_EndElement && depth == element_depth + 1)
 674         {
 675             return S_OK;
 676         }
 677     }
 678
 679     return hr;
 680 }
 681
 682 static HRESULT parse_effect_get_attribute(IXmlReader *reader, const WCHAR *name, WCHAR **ret)
 683 {
 684     const WCHAR *value;
 685
 686     *ret = NULL;
 687
 688     if (IXmlReader_MoveToAttributeByName(reader, name, NULL) != S_OK)
 689         return E_INVALIDARG;
 690     if (IXmlReader_GetValue(reader, &value, NULL) != S_OK)
 691         return E_INVALIDARG;
 692     if (!(*ret = wcsdup(value)))
 693         return E_OUTOFMEMORY;
 694
 695     return S_OK;
 696 }
 697
 698 static HRESULT parse_effect_get_property_type(IXmlReader *reader, D2D1_PROPERTY_TYPE *type)
 699 {
 700     static const WCHAR *types[] =
 701     {
 702         L"",             /* D2D1_PROPERTY_TYPE_UNKNOWN */
 703         L"string",       /* D2D1_PROPERTY_TYPE_STRING */
 704         L"bool",         /* D2D1_PROPERTY_TYPE_BOOL */
 705         L"uint32",       /* D2D1_PROPERTY_TYPE_UINT32 */
 706         L"int32",        /* D2D1_PROPERTY_TYPE_INT32 */
 707         L"float",        /* D2D1_PROPERTY_TYPE_FLOAT */
 708         L"vector2",      /* D2D1_PROPERTY_TYPE_VECTOR2 */
 709         L"vector3",      /* D2D1_PROPERTY_TYPE_VECTOR3 */
 710         L"vector4",      /* D2D1_PROPERTY_TYPE_VECTOR4 */
 711         L"blob",         /* D2D1_PROPERTY_TYPE_BLOB */
 712         L"iunknown",     /* D2D1_PROPERTY_TYPE_IUNKNOWN */
 713         L"enum",         /* D2D1_PROPERTY_TYPE_ENUM */
 714         L"array",        /* D2D1_PROPERTY_TYPE_ARRAY */
 715         L"clsid",        /* D2D1_PROPERTY_TYPE_CLSID */
 716         L"matrix3x2",    /* D2D1_PROPERTY_TYPE_MATRIX_3X2 */
 717         L"matrix4x3",    /* D2D1_PROPERTY_TYPE_MATRIX_4X3 */
 718         L"matrix4x4",    /* D2D1_PROPERTY_TYPE_MATRIX_4X4 */
 719         L"matrix5x4",    /* D2D1_PROPERTY_TYPE_MATRIX_5X4 */
 720         L"colorcontext", /* D2D1_PROPERTY_TYPE_COLOR_CONTEXT */
 721     };
 722     unsigned int i;
 723     WCHAR *value;
 724     HRESULT hr;
 725
 726     if (FAILED(hr = parse_effect_get_attribute(reader, L"type", &value))) return hr;
 727
 728     *type = D2D1_PROPERTY_TYPE_UNKNOWN;
 729
 730     for (i = 0; i < ARRAY_SIZE(types); ++i)
 731     {
 732         if (!wcscmp(value, types[i]))
 733         {
 734             *type = i;
 735             break;
 736         }
 737     }
 738
 739     free(value);
 740
 741     return *type == D2D1_PROPERTY_TYPE_UNKNOWN ? E_INVALIDARG : S_OK;
 742 }
 743
 744 static struct d2d_effect_property * parse_effect_get_property(const struct d2d_effect_registration *effect,
 745         const WCHAR *name)
 746 {
 747     unsigned int i;
 748
 749     for (i = 0; i < effect->properties.count; ++i)
 750     {
 751         if (!wcscmp(name, effect->properties.properties[i].name))
 752             return &effect->properties.properties[i];
 753     }
 754
 755     return NULL;
 756 }
 757
 758 static UINT32 parse_effect_get_property_index(struct d2d_effect_properties *props,
 759         const WCHAR *name)
 760 {
 761     if (!wcscmp(name, L"DisplayName")) return D2D1_PROPERTY_DISPLAYNAME;
 762     if (!wcscmp(name, L"Author")) return D2D1_PROPERTY_AUTHOR;
 763     if (!wcscmp(name, L"Category")) return D2D1_PROPERTY_CATEGORY;
 764     if (!wcscmp(name, L"Description")) return D2D1_PROPERTY_DESCRIPTION;
 765     return props->custom_count;
 766 }
 767
 768 static HRESULT parse_effect_property(IXmlReader *reader, struct d2d_effect_registration *effect)
 769 {
 770     WCHAR *name = NULL, *value = NULL;
 771     D2D1_PROPERTY_TYPE type;
 772     unsigned int depth;
 773     UINT32 index;
 774     HRESULT hr;
 775
 776     if (FAILED(hr = parse_effect_get_attribute(reader, L"name", &name)))
 777         return hr;
 778
 779     if (FAILED(hr = parse_effect_get_property_type(reader, &type)))
 780     {
 781         free(name);
 782         return hr;
 783     }
 784
 785     /* Check for duplicates. */
 786     if (parse_effect_get_property(effect, name))
 787         hr = E_INVALIDARG;
 788
 789     parse_effect_get_attribute(reader, L"value", &value);
 790
 791     if (SUCCEEDED(hr))
 792     {
 793         /* FIXME: sub properties are ignored */
 794         IXmlReader_MoveToElement(reader);
 795         IXmlReader_GetDepth(reader, &depth);
 796         hr = parse_effect_skip_element(reader, depth);
 797     }
 798
 799     if (SUCCEEDED(hr))
 800     {
 801         index = parse_effect_get_property_index(&effect->properties, name);
 802         hr = d2d_effect_properties_add(&effect->properties, name, index, type, value);
 803     }
 804
 805     free(value);
 806     free(name);
 807
 808     return hr;
 809 }
 810
 811 static HRESULT parse_effect_inputs(IXmlReader *reader, struct d2d_effect_registration *effect)
 812 {
 813     struct d2d_effect_properties *subproperties;
 814     unsigned int depth, input_count = 0;
 815     struct d2d_effect_property *inputs;
 816     XmlNodeType node_type;
 817     WCHAR nameW[16];
 818     WCHAR *name;
 819     HRESULT hr;
 820
 821     if (FAILED(hr = d2d_effect_properties_add(&effect->properties, L"Inputs",
 822             D2D1_PROPERTY_INPUTS, D2D1_PROPERTY_TYPE_ARRAY, NULL)))
 823         return hr;
 824
 825     if (!(inputs = d2d_effect_properties_get_property_by_name(&effect->properties, L"Inputs")))
 826         return E_FAIL;
 827     if (!(inputs->subproperties = calloc(1, sizeof(*inputs->subproperties))))
 828         return E_OUTOFMEMORY;
 829     subproperties = inputs->subproperties;
 830
 831     d2d_effect_subproperties_add(subproperties, L"IsReadOnly", D2D1_SUBPROPERTY_ISREADONLY,
 832             D2D1_PROPERTY_TYPE_BOOL, L"true");
 833     d2d_effect_subproperties_add(subproperties, L"DisplayName", D2D1_SUBPROPERTY_DISPLAYNAME,
 834             D2D1_PROPERTY_TYPE_STRING, L"Inputs");
 835
 836     if (IXmlReader_IsEmptyElement(reader)) return S_OK;
 837
 838     while (parse_effect_get_next_xml_node(reader, XmlNodeType_None, L"Input", &depth) == S_OK)
 839     {
 840         if (FAILED(hr = IXmlReader_GetNodeType(reader, &node_type))) return hr;
 841         if (node_type == XmlNodeType_EndElement) continue;
 842         if (node_type != XmlNodeType_Element) return HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
 843
 844         if (FAILED(hr = parse_effect_get_attribute(reader, L"name", &name))) return hr;
 845
 846         swprintf(nameW, ARRAY_SIZE(nameW), L"%lu", input_count);
 847         d2d_effect_subproperties_add(subproperties, nameW, input_count, D2D1_PROPERTY_TYPE_STRING, name);
 848         input_count++;
 849
 850         free(name);
 851     }
 852     *(UINT32 *)(effect->properties.data.ptr + inputs->data.offset) = input_count;
 853
 854     if (FAILED(hr = IXmlReader_GetNodeType(reader, &node_type))) return hr;
 855     if (node_type != XmlNodeType_EndElement) return HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
 856
 857     return S_OK;
 858 }
 859
 860 static HRESULT parse_effect_xml(IXmlReader *reader, struct d2d_effect_registration *effect)
 861 {
 862     const WCHAR *node_name;
 863     XmlNodeType node_type;
 864     unsigned int depth;
 865     HRESULT hr;
 866
 867     /* Xml declaration node is mandatory. */
 868     if ((hr = parse_effect_get_next_xml_node(reader, XmlNodeType_XmlDeclaration, L"xml", NULL)) != S_OK)
 869         return hr;
 870
 871     /* Top level "Effect" element. */
 872     if ((hr = parse_effect_get_next_xml_node(reader, XmlNodeType_Element, L"Effect", NULL)) != S_OK)
 873         return hr;
 874
 875     /* Loop inside effect node */
 876     while ((hr = parse_effect_get_next_xml_node(reader, XmlNodeType_None, NULL, &depth)) == S_OK)
 877     {
 878         if (FAILED(hr = IXmlReader_GetNodeType(reader, &node_type))) return hr;
 879         if (node_type != XmlNodeType_Element && node_type != XmlNodeType_EndElement) continue;
 880         if (FAILED(hr = IXmlReader_GetLocalName(reader, &node_name, NULL))) return hr;
 881         if (node_type == XmlNodeType_EndElement) break;
 882
 883         if (!wcscmp(node_name, L"Property"))
 884             hr = parse_effect_property(reader, effect);
 885         else if (!wcscmp(node_name, L"Inputs"))
 886             hr = parse_effect_inputs(reader, effect);
 887         else
 888         {
 889             WARN("Unexpected element %s.\n", debugstr_w(node_name));
 890             hr = parse_effect_skip_element(reader, depth);
 891         }
 892
 893         if (FAILED(hr))
 894             return hr;
 895     }
 896
 897     return hr;
 898 }
 899
 900 static HRESULT STDMETHODCALLTYPE d2d_factory_RegisterEffectFromStream(ID2D1Factory3 *iface,
 901         REFCLSID effect_id, IStream *property_xml, const D2D1_PROPERTY_BINDING *bindings,
 902         UINT32 binding_count, PD2D1_EFFECT_FACTORY effect_factory)
 903 {
 904     struct d2d_factory *factory = impl_from_ID2D1Factory3(iface);
 905     struct d2d_effect_registration *effect;
 906     IXmlReader *reader;
 907     unsigned int i;
 908     HRESULT hr;
 909
 910     TRACE("iface %p, effect_id %s, property_xml %p, bindings %p, binding_count %u, effect_factory %p.\n",
 911             iface, debugstr_guid(effect_id), property_xml, bindings, binding_count, effect_factory);
 912
 913     d2d_factory_init_builtin_effects(factory);
 914
 915     LIST_FOR_EACH_ENTRY_REV(effect, &factory->effects, struct d2d_effect_registration, entry)
 916     {
 917         if (IsEqualGUID(effect_id, &effect->id))
 918         {
 919             if (effect->builtin) return E_INVALIDARG;
 920             ++effect->registration_count;
 921             return S_OK;
 922         }
 923     }
 924
 925     if (FAILED(hr = CreateXmlReader(&IID_IXmlReader, (void **)&reader, NULL)))
 926         return hr;
 927
 928     if (FAILED(hr = IXmlReader_SetInput(reader, (IUnknown *)property_xml)))
 929     {
 930         IXmlReader_Release(reader);
 931         return hr;
 932     }
 933
 934     if (!(effect = calloc(1, sizeof(*effect))))
 935     {
 936         IXmlReader_Release(reader);
 937         return E_OUTOFMEMORY;
 938     }
 939
 940     hr = parse_effect_xml(reader, effect);
 941     IXmlReader_Release(reader);
 942     if (FAILED(hr))
 943     {
 944         WARN("Failed to parse effect xml, hr %#lx.\n", hr);
 945         d2d_effect_registration_cleanup(effect);
 946         return hr;
 947     }
 948
 949     /* Check required properties. */
 950     if (!parse_effect_get_property(effect, L"DisplayName")
 951             || !parse_effect_get_property(effect, L"Author")
 952             || !parse_effect_get_property(effect, L"Category")
 953             || !parse_effect_get_property(effect, L"Description")
 954             || !parse_effect_get_property(effect, L"Inputs"))
 955     {
 956         WARN("Missing required properties.\n");
 957         d2d_effect_registration_cleanup(effect);
 958         return E_INVALIDARG;
 959     }
 960
 961     /* Bind getter and setter. */
 962     for (i = 0; i < binding_count; ++i)
 963     {
 964         struct d2d_effect_property *property;
 965
 966         if (!(property = parse_effect_get_property(effect, bindings[i].propertyName)))
 967         {
 968             WARN("Failed to bind to missing property.\n");
 969             d2d_effect_registration_cleanup(effect);
 970             return D2DERR_INVALID_PROPERTY;
 971         }
 972
 973         property->get_function = bindings[i].getFunction;
 974         property->set_function = bindings[i].setFunction;
 975     }
 976
 977     effect->registration_count = 1;
 978     effect->id = *effect_id;
 979     effect->factory = effect_factory;
 980     d2d_effect_properties_add(&effect->properties, L"MinInputs", D2D1_PROPERTY_MIN_INPUTS,
 981             D2D1_PROPERTY_TYPE_UINT32, L"1");
 982     d2d_effect_properties_add(&effect->properties, L"MaxInputs", D2D1_PROPERTY_MAX_INPUTS,
 983             D2D1_PROPERTY_TYPE_UINT32, L"1" /* FIXME */);
 984     effect->default_input_count = 1;
 985     d2d_factory_register_effect(factory, effect);
 986
 987     return S_OK;
 988 }
 989
 990 static HRESULT STDMETHODCALLTYPE d2d_factory_RegisterEffectFromString(ID2D1Factory3 *iface,
 991         REFCLSID effect_id, const WCHAR *property_xml, const D2D1_PROPERTY_BINDING *bindings,
 992         UINT32 binding_count, PD2D1_EFFECT_FACTORY effect_factory)
 993 {
 994     static const LARGE_INTEGER zero;
 995     IStream *stream;
 996     ULONG size;
 997     HRESULT hr;
 998
 999     TRACE("iface %p, effect_id %s, property_xml %s, bindings %p, binding_count %u, effect_factory %p.\n",
1000           iface, debugstr_guid(effect_id), debugstr_w(property_xml), bindings, binding_count, effect_factory);
1001
1002     if (FAILED(hr = CreateStreamOnHGlobal(NULL, TRUE, &stream)))
1003         return hr;
1004
1005     size = sizeof(*property_xml) * (wcslen(property_xml) + 1);
1006     if (SUCCEEDED(hr = IStream_Write(stream, property_xml, size, NULL)))
1007         hr = IStream_Seek(stream, zero, SEEK_SET, NULL);
1008
1009     if (SUCCEEDED(hr))
1010         hr = ID2D1Factory3_RegisterEffectFromStream(iface, effect_id, stream, bindings,
1011                 binding_count, effect_factory);
1012
1013     IStream_Release(stream);
1014     return hr;
1015 }
1016
1017 static HRESULT STDMETHODCALLTYPE d2d_factory_UnregisterEffect(ID2D1Factory3 *iface, REFCLSID effect_id)
1018 {
1019     struct d2d_factory *factory = impl_from_ID2D1Factory3(iface);
1020     struct d2d_effect_registration *effect;
1021
1022     TRACE("iface %p, effect_id %s.\n", iface, debugstr_guid(effect_id));
1023
1024     d2d_factory_init_builtin_effects(factory);
1025
1026     LIST_FOR_EACH_ENTRY_REV(effect, &factory->effects, struct d2d_effect_registration, entry)
1027     {
1028         if (IsEqualGUID(effect_id, &effect->id))
1029         {
1030             if (effect->builtin) break;
1031             if (!--effect->registration_count)
1032             {
1033                 list_remove(&effect->entry);
1034                 d2d_effect_registration_cleanup(effect);
1035             }
1036             return S_OK;
1037         }
1038     }
1039
1040     return D2DERR_EFFECT_IS_NOT_REGISTERED;
1041 }
1042
1043 static HRESULT STDMETHODCALLTYPE d2d_factory_GetRegisteredEffects(ID2D1Factory3 *iface,
1044         CLSID *effects, UINT32 effect_count, UINT32 *returned, UINT32 *registered)
1045 {
1046     struct d2d_factory *factory = impl_from_ID2D1Factory3(iface);
1047     struct d2d_effect_registration *effect;
1048     UINT32 ret, reg;
1049
1050     TRACE("iface %p, effects %p, effect_count %u, returned %p, registered %p.\n",
1051             iface, effects, effect_count, returned, registered);
1052
1053     if (!returned) returned = &ret;
1054     if (!registered) registered = &reg;
1055
1056     *registered = 0;
1057     *returned = 0;
1058
1059     d2d_factory_init_builtin_effects(factory);
1060
1061     LIST_FOR_EACH_ENTRY(effect, &factory->effects, struct d2d_effect_registration, entry)
1062     {
1063         if (effects && effect_count)
1064         {
1065             *effects = effect->id;
1066             effects++;
1067             effect_count--;
1068             *returned += 1;
1069         }
1070
1071         *registered += 1;
1072     }
1073
1074     if (!effects) return S_OK;
1075     return *returned == *registered ? S_OK : D2DERR_INSUFFICIENT_BUFFER;
1076 }
1077
1078 static HRESULT STDMETHODCALLTYPE d2d_factory_GetEffectProperties(ID2D1Factory3 *iface,
1079         REFCLSID effect_id, ID2D1Properties **props)
1080 {
1081     FIXME("iface %p, effect_id %s, props %p stub!\n", iface, debugstr_guid(effect_id), props);
1082
1083     return E_NOTIMPL;
1084 }
1085
1086 static HRESULT STDMETHODCALLTYPE d2d_factory_ID2D1Factory2_CreateDevice(ID2D1Factory3 *iface, IDXGIDevice *dxgi_device,
1087         ID2D1Device1 **device)
1088 {
1089     TRACE("iface %p, dxgi_device %p, device %p.\n", iface, dxgi_device, device);
1090
1091     return d2d_factory_create_device(iface, dxgi_device, device);
1092 }
1093
1094 static HRESULT STDMETHODCALLTYPE d2d_factory_ID2D1Factory3_CreateDevice(ID2D1Factory3 *iface, IDXGIDevice *dxgi_device,
1095         ID2D1Device2 **device)
1096 {
1097     FIXME("iface %p, dxgi_device %p, device %p stub!\n", iface, dxgi_device, device);
1098
1099     return E_NOTIMPL;
1100 }
1101
1102 static const struct ID2D1Factory3Vtbl d2d_factory_vtbl =
1103 {
1104     d2d_factory_QueryInterface,
1105     d2d_factory_AddRef,
1106     d2d_factory_Release,
1107     d2d_factory_ReloadSystemMetrics,
1108     d2d_factory_GetDesktopDpi,
1109     d2d_factory_CreateRectangleGeometry,
1110     d2d_factory_CreateRoundedRectangleGeometry,
1111     d2d_factory_CreateEllipseGeometry,
1112     d2d_factory_CreateGeometryGroup,
1113     d2d_factory_CreateTransformedGeometry,
1114     d2d_factory_CreatePathGeometry,
1115     d2d_factory_CreateStrokeStyle,
1116     d2d_factory_CreateDrawingStateBlock,
1117     d2d_factory_CreateWicBitmapRenderTarget,
1118     d2d_factory_CreateHwndRenderTarget,
1119     d2d_factory_CreateDxgiSurfaceRenderTarget,
1120     d2d_factory_CreateDCRenderTarget,
1121     d2d_factory_CreateDevice,
1122     d2d_factory_CreateStrokeStyle1,
1123     d2d_factory_CreatePathGeometry1,
1124     d2d_factory_CreateDrawingStateBlock1,
1125     d2d_factory_CreateGdiMetafile,
1126     d2d_factory_RegisterEffectFromStream,
1127     d2d_factory_RegisterEffectFromString,
1128     d2d_factory_UnregisterEffect,
1129     d2d_factory_GetRegisteredEffects,
1130     d2d_factory_GetEffectProperties,
1131     d2d_factory_ID2D1Factory2_CreateDevice,
1132     d2d_factory_ID2D1Factory3_CreateDevice,
1133 };
1134
1135 static HRESULT STDMETHODCALLTYPE d2d_factory_mt_QueryInterface(ID2D1Multithread *iface, REFIID iid, void **out)
1136 {
1137     struct d2d_factory *factory = impl_from_ID2D1Multithread(iface);
1138     return d2d_factory_QueryInterface(&factory->ID2D1Factory3_iface, iid, out);
1139 }
1140
1141 static ULONG STDMETHODCALLTYPE d2d_factory_mt_AddRef(ID2D1Multithread *iface)
1142 {
1143     struct d2d_factory *factory = impl_from_ID2D1Multithread(iface);
1144     return d2d_factory_AddRef(&factory->ID2D1Factory3_iface);
1145 }
1146
1147 static ULONG STDMETHODCALLTYPE d2d_factory_mt_Release(ID2D1Multithread *iface)
1148 {
1149     struct d2d_factory *factory = impl_from_ID2D1Multithread(iface);
1150     return d2d_factory_Release(&factory->ID2D1Factory3_iface);
1151 }
1152
1153 static BOOL STDMETHODCALLTYPE d2d_factory_mt_GetMultithreadProtected(ID2D1Multithread *iface)
1154 {
1155     return TRUE;
1156 }
1157
1158 static void STDMETHODCALLTYPE d2d_factory_mt_Enter(ID2D1Multithread *iface)
1159 {
1160     struct d2d_factory *factory = impl_from_ID2D1Multithread(iface);
1161
1162     TRACE("%p.\n", iface);
1163
1164     EnterCriticalSection(&factory->cs);
1165 }
1166
1167 static void STDMETHODCALLTYPE d2d_factory_mt_Leave(ID2D1Multithread *iface)
1168 {
1169     struct d2d_factory *factory = impl_from_ID2D1Multithread(iface);
1170
1171     TRACE("%p.\n", iface);
1172
1173     LeaveCriticalSection(&factory->cs);
1174 }
1175
1176 static BOOL STDMETHODCALLTYPE d2d_factory_st_GetMultithreadProtected(ID2D1Multithread *iface)
1177 {
1178     return FALSE;
1179 }
1180
1181 static void STDMETHODCALLTYPE d2d_factory_st_Enter(ID2D1Multithread *iface)
1182 {
1183 }
1184
1185 static void STDMETHODCALLTYPE d2d_factory_st_Leave(ID2D1Multithread *iface)
1186 {
1187 }
1188
1189 static const struct ID2D1MultithreadVtbl d2d_factory_multithread_vtbl =
1190 {
1191     d2d_factory_mt_QueryInterface,
1192     d2d_factory_mt_AddRef,
1193     d2d_factory_mt_Release,
1194     d2d_factory_mt_GetMultithreadProtected,
1195     d2d_factory_mt_Enter,
1196     d2d_factory_mt_Leave,
1197 };
1198
1199 static const struct ID2D1MultithreadVtbl d2d_factory_multithread_noop_vtbl =
1200 {
1201     d2d_factory_mt_QueryInterface,
1202     d2d_factory_mt_AddRef,
1203     d2d_factory_mt_Release,
1204     d2d_factory_st_GetMultithreadProtected,
1205     d2d_factory_st_Enter,
1206     d2d_factory_st_Leave,
1207 };
1208
1209 static void d2d_factory_init(struct d2d_factory *factory, D2D1_FACTORY_TYPE factory_type,
1210         const D2D1_FACTORY_OPTIONS *factory_options)
1211 {
1212     if (factory_options && factory_options->debugLevel != D2D1_DEBUG_LEVEL_NONE)
1213         WARN("Ignoring debug level %#x.\n", factory_options->debugLevel);
1214
1215     factory->ID2D1Factory3_iface.lpVtbl = &d2d_factory_vtbl;
1216     factory->ID2D1Multithread_iface.lpVtbl = factory_type == D2D1_FACTORY_TYPE_SINGLE_THREADED ?
1217             &d2d_factory_multithread_noop_vtbl : &d2d_factory_multithread_vtbl;
1218     factory->refcount = 1;
1219     d2d_factory_reload_sysmetrics(factory);
1220     list_init(&factory->effects);
1221     InitializeCriticalSection(&factory->cs);
1222     InitOnceInitialize(&factory->init_builtins);
1223 }
1224
1225 HRESULT WINAPI D2D1CreateFactory(D2D1_FACTORY_TYPE factory_type, REFIID iid,
1226         const D2D1_FACTORY_OPTIONS *factory_options, void **factory)
1227 {
1228     struct d2d_factory *object;
1229     HRESULT hr;
1230
1231     TRACE("factory_type %#x, iid %s, factory_options %p, factory %p.\n",
1232             factory_type, debugstr_guid(iid), factory_options, factory);
1233
1234     if (factory_type != D2D1_FACTORY_TYPE_SINGLE_THREADED &&
1235             factory_type != D2D1_FACTORY_TYPE_MULTI_THREADED)
1236     {
1237         return E_INVALIDARG;
1238     }
1239
1240     if (!(object = calloc(1, sizeof(*object))))
1241         return E_OUTOFMEMORY;
1242
1243     d2d_factory_init(object, factory_type, factory_options);
1244
1245     TRACE("Created factory %p.\n", object);
1246
1247     hr = ID2D1Factory3_QueryInterface(&object->ID2D1Factory3_iface, iid, factory);
1248     ID2D1Factory3_Release(&object->ID2D1Factory3_iface);
1249
1250     return hr;
1251 }
1252
1253 void WINAPI D2D1MakeRotateMatrix(float angle, D2D1_POINT_2F center, D2D1_MATRIX_3X2_F *matrix)
1254 {
1255     float theta, sin_theta, cos_theta;
1256
1257     TRACE("angle %.8e, center %s, matrix %p.\n", angle, debug_d2d_point_2f(&center), matrix);
1258
1259     theta = angle * (M_PI / 180.0f);
1260     sin_theta = sinf(theta);
1261     cos_theta = cosf(theta);
1262
1263     /* translate(center) * rotate(theta) * translate(-center) */
1264     matrix->_11 = cos_theta;
1265     matrix->_12 = sin_theta;
1266     matrix->_21 = -sin_theta;
1267     matrix->_22 = cos_theta;
1268     matrix->_31 = center.x - center.x * cos_theta + center.y * sin_theta;
1269     matrix->_32 = center.y - center.x * sin_theta - center.y * cos_theta;
1270 }
1271
1272 void WINAPI D2D1MakeSkewMatrix(float angle_x, float angle_y, D2D1_POINT_2F center, D2D1_MATRIX_3X2_F *matrix)
1273 {
1274     float tan_x, tan_y;
1275
1276     TRACE("angle_x %.8e, angle_y %.8e, center %s, matrix %p.\n", angle_x, angle_y, debug_d2d_point_2f(&center), matrix);
1277
1278     tan_x = tan(angle_x * (M_PI / 180.0f));
1279     tan_y = tan(angle_y * (M_PI / 180.0f));
1280
1281     /* translate(-center) * skew() * translate(center) */
1282     matrix->_11 = 1.0f;
1283     matrix->_12 = tan_y;
1284     matrix->_21 = tan_x;
1285     matrix->_22 = 1.0f;
1286     matrix->_31 = -tan_x * center.y;
1287     matrix->_32 = -tan_y * center.x;
1288 }
1289
1290 BOOL WINAPI D2D1IsMatrixInvertible(const D2D1_MATRIX_3X2_F *matrix)
1291 {
1292     TRACE("matrix %p.\n", matrix);
1293
1294     return (matrix->_11 * matrix->_22 - matrix->_21 * matrix->_12) != 0.0f;
1295 }
1296
1297 BOOL WINAPI D2D1InvertMatrix(D2D1_MATRIX_3X2_F *matrix)
1298 {
1299     D2D1_MATRIX_3X2_F m = *matrix;
1300
1301     TRACE("matrix %p.\n", matrix);
1302
1303     return d2d_matrix_invert(matrix, &m);
1304 }
1305
1306 HRESULT WINAPI D2D1CreateDevice(IDXGIDevice *dxgi_device,
1307         const D2D1_CREATION_PROPERTIES *properties, ID2D1Device **device)
1308 {
1309     D2D1_CREATION_PROPERTIES default_properties = {0};
1310     D2D1_FACTORY_OPTIONS factory_options;
1311     ID3D11Device *d3d_device;
1312     ID2D1Factory1 *factory;
1313     HRESULT hr;
1314
1315     TRACE("dxgi_device %p, properties %p, device %p.\n", dxgi_device, properties, device);
1316
1317     if (!properties)
1318     {
1319         if (SUCCEEDED(IDXGIDevice_QueryInterface(dxgi_device, &IID_ID3D11Device, (void **)&d3d_device)))
1320         {
1321             if (!(ID3D11Device_GetCreationFlags(d3d_device) & D3D11_CREATE_DEVICE_SINGLETHREADED))
1322                 default_properties.threadingMode = D2D1_THREADING_MODE_MULTI_THREADED;
1323             ID3D11Device_Release(d3d_device);
1324         }
1325         properties = &default_properties;
1326     }
1327
1328     factory_options.debugLevel = properties->debugLevel;
1329     if (FAILED(hr = D2D1CreateFactory(properties->threadingMode,
1330             &IID_ID2D1Factory1, &factory_options, (void **)&factory)))
1331         return hr;
1332
1333     hr = ID2D1Factory1_CreateDevice(factory, dxgi_device, device);
1334     ID2D1Factory1_Release(factory);
1335     return hr;
1336 }
1337
1338 void WINAPI D2D1SinCos(float angle, float *s, float *c)
1339 {
1340     TRACE("angle %.8e, s %p, c %p.\n", angle, s, c);
1341
1342     *s = sinf(angle);
1343     *c = cosf(angle);
1344 }
1345
1346 float WINAPI D2D1Tan(float angle)
1347 {
1348     TRACE("angle %.8e.\n", angle);
1349
1350     return tanf(angle);
1351 }
1352
1353 float WINAPI D2D1Vec3Length(float x, float y, float z)
1354 {
1355     TRACE("x %.8e, y %.8e, z %.8e.\n", x, y, z);
1356
1357     return sqrtf(x * x + y * y + z * z);
1358 }
1359
1360 /* See IEC 61966-2-1:1999; also described in the EXT_texture_sRGB OpenGL
1361  * extension, among others. */
1362 static float srgb_transfer_function(float x)
1363 {
1364     if (x <= 0.0f)
1365         return 0.0f;
1366     else if (x >= 1.0f)
1367         return 1.0f;
1368     else if (x <= 0.0031308f)
1369         return 12.92f * x;
1370     else
1371         return 1.055f * powf(x, 1.0f / 2.4f) - 0.055f;
1372 }
1373
1374 static float srgb_inverse_transfer_function(float x)
1375 {
1376     if (x <= 0.0f)
1377         return 0.0f;
1378     else if (x >= 1.0f)
1379         return 1.0f;
1380     else if (x <= 0.04045f)
1381         return x / 12.92f;
1382     else
1383         return powf((x + 0.055f) / 1.055f, 2.4f);
1384 }
1385
1386 D2D1_COLOR_F WINAPI D2D1ConvertColorSpace(D2D1_COLOR_SPACE src_colour_space,
1387         D2D1_COLOR_SPACE dst_colour_space, const D2D1_COLOR_F *colour)
1388 {
1389     D2D1_COLOR_F ret;
1390
1391     TRACE("src_colour_space %#x, dst_colour_space %#x, colour %s.\n",
1392             src_colour_space, dst_colour_space, debug_d2d_color_f(colour));
1393
1394     if (src_colour_space == D2D1_COLOR_SPACE_CUSTOM || dst_colour_space == D2D1_COLOR_SPACE_CUSTOM)
1395     {
1396         ret.r = 0.0f;
1397         ret.g = 0.0f;
1398         ret.b = 0.0f;
1399         ret.a = 0.0f;
1400
1401         return ret;
1402     }
1403
1404     if (src_colour_space == dst_colour_space)
1405         return *colour;
1406
1407     if (src_colour_space == D2D1_COLOR_SPACE_SRGB && dst_colour_space == D2D1_COLOR_SPACE_SCRGB)
1408     {
1409         ret.r = srgb_inverse_transfer_function(colour->r);
1410         ret.g = srgb_inverse_transfer_function(colour->g);
1411         ret.b = srgb_inverse_transfer_function(colour->b);
1412         ret.a = colour->a;
1413
1414         return ret;
1415     }
1416
1417     if (src_colour_space == D2D1_COLOR_SPACE_SCRGB && dst_colour_space == D2D1_COLOR_SPACE_SRGB)
1418     {
1419         ret.r = srgb_transfer_function(colour->r);
1420         ret.g = srgb_transfer_function(colour->g);
1421         ret.b = srgb_transfer_function(colour->b);
1422         ret.a = colour->a;
1423
1424         return ret;
1425     }
1426
1427     FIXME("Unhandled conversion from source colour space %#x to destination colour space %#x.\n",
1428             src_colour_space, dst_colour_space);
1429     ret.r = 0.0f;
1430     ret.g = 0.0f;
1431     ret.b = 0.0f;
1432     ret.a = 0.0f;
1433
1434     return ret;
1435 }
1436
1437 static bool get_config_key_u32(HKEY default_key, HKEY application_key, const char *name, uint32_t *value)
1438 {
1439     DWORD type, size;
1440     uint32_t data;
1441
1442     size = sizeof(data);
1443     if (application_key && !RegQueryValueExA(application_key,
1444             name, 0, &type, (BYTE *)&data, &size) && type == REG_DWORD)
1445         goto success;
1446
1447     size = sizeof(data);
1448     if (default_key && !RegQueryValueExA(default_key,
1449             name, 0, &type, (BYTE *)&data, &size) && type == REG_DWORD)
1450         goto success;
1451
1452     return false;
1453
1454 success:
1455     *value = data;
1456     return true;
1457 }
1458
1459 static void d2d_settings_init(void)
1460 {
1461     HKEY default_key, tmp_key, application_key = NULL;
1462     char buffer[MAX_PATH + 10];
1463     DWORD len;
1464
1465     if (RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Direct2D", &default_key))
1466         default_key = NULL;
1467
1468     len = GetModuleFileNameA(0, buffer, MAX_PATH);
1469     if (len && len < MAX_PATH)
1470     {
1471         char *p, *appname = buffer;
1472
1473         if ((p = strrchr(appname, '/')))
1474             appname = p + 1;
1475         if ((p = strrchr(appname, '\\')))
1476             appname = p + 1;
1477         strcat(appname, "\\Direct2D");
1478
1479         if (!RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\AppDefaults", &tmp_key))
1480         {
1481             if (RegOpenKeyA(tmp_key, appname, &application_key))
1482                 application_key = NULL;
1483             RegCloseKey(tmp_key);
1484         }
1485     }
1486
1487     if (!default_key && !application_key)
1488         return;
1489
1490     if (get_config_key_u32(default_key, application_key, "max_version_factory", &d2d_settings.max_version_factory))
1491         ERR_(winediag)("Limiting maximum Direct2D factory version to %#x.\n", d2d_settings.max_version_factory);
1492
1493     if (application_key)
1494         RegCloseKey(application_key);
1495     if (default_key)
1496         RegCloseKey(default_key);
1497 }
1498
1499 BOOL WINAPI DllMain(HINSTANCE inst, DWORD reason, void *reserved)
1500 {
1501     if (reason == DLL_PROCESS_ATTACH)
1502         d2d_settings_init();
1503     return TRUE;
1504 }