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 #include "config.h"
  20 #include "wine/port.h"
  21
  22 #define D2D1_INIT_GUID
  23 #include "d2d1_private.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(d2d);
  26
  27 struct d2d_factory
  28 {
  29     ID2D1Factory ID2D1Factory_iface;
  30     LONG refcount;
  31
  32     ID3D10Device1 *device;
  33
  34     float dpi_x;
  35     float dpi_y;
  36 };
  37
  38 static inline struct d2d_factory *impl_from_ID2D1Factory(ID2D1Factory *iface)
  39 {
  40     return CONTAINING_RECORD(iface, struct d2d_factory, ID2D1Factory_iface);
  41 }
  42
  43 static HRESULT d2d_factory_reload_sysmetrics(struct d2d_factory *factory)
  44 {
  45     HDC hdc;
  46
  47     if (!(hdc = GetDC(NULL)))
  48     {
  49         factory->dpi_x = factory->dpi_y = 96.0f;
  50         return E_FAIL;
  51     }
  52
  53     factory->dpi_x = GetDeviceCaps(hdc, LOGPIXELSX);
  54     factory->dpi_y = GetDeviceCaps(hdc, LOGPIXELSY);
  55
  56     ReleaseDC(NULL, hdc);
  57
  58     return S_OK;
  59 }
  60
  61 static HRESULT STDMETHODCALLTYPE d2d_factory_QueryInterface(ID2D1Factory *iface, REFIID iid, void **out)
  62 {
  63     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
  64
  65     if (IsEqualGUID(iid, &IID_ID2D1Factory)
  66             || IsEqualGUID(iid, &IID_IUnknown))
  67     {
  68         ID2D1Factory_AddRef(iface);
  69         *out = iface;
  70         return S_OK;
  71     }
  72
  73     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
  74
  75     *out = NULL;
  76     return E_NOINTERFACE;
  77 }
  78
  79 static ULONG STDMETHODCALLTYPE d2d_factory_AddRef(ID2D1Factory *iface)
  80 {
  81     struct d2d_factory *factory = impl_from_ID2D1Factory(iface);
  82     ULONG refcount = InterlockedIncrement(&factory->refcount);
  83
  84     TRACE("%p increasing refcount to %u.\n", iface, refcount);
  85
  86     return refcount;
  87 }
  88
  89 static ULONG STDMETHODCALLTYPE d2d_factory_Release(ID2D1Factory *iface)
  90 {
  91     struct d2d_factory *factory = impl_from_ID2D1Factory(iface);
  92     ULONG refcount = InterlockedDecrement(&factory->refcount);
  93
  94     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
  95
  96     if (!refcount)
  97     {
  98         if (factory->device)
  99             ID3D10Device1_Release(factory->device);
 100         HeapFree(GetProcessHeap(), 0, factory);
 101     }
 102
 103     return refcount;
 104 }
 105
 106 static HRESULT STDMETHODCALLTYPE d2d_factory_ReloadSystemMetrics(ID2D1Factory *iface)
 107 {
 108     struct d2d_factory *factory = impl_from_ID2D1Factory(iface);
 109
 110     TRACE("iface %p.\n", iface);
 111
 112     return d2d_factory_reload_sysmetrics(factory);
 113 }
 114
 115 static void STDMETHODCALLTYPE d2d_factory_GetDesktopDpi(ID2D1Factory *iface, float *dpi_x, float *dpi_y)
 116 {
 117     struct d2d_factory *factory = impl_from_ID2D1Factory(iface);
 118
 119     TRACE("iface %p, dpi_x %p, dpi_y %p.\n", iface, dpi_x, dpi_y);
 120
 121     *dpi_x = factory->dpi_x;
 122     *dpi_y = factory->dpi_y;
 123 }
 124
 125 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateRectangleGeometry(ID2D1Factory *iface,
 126         const D2D1_RECT_F *rect, ID2D1RectangleGeometry **geometry)
 127 {
 128     struct d2d_geometry *object;
 129     HRESULT hr;
 130
 131     TRACE("iface %p, rect %p, geometry %p.\n", iface, rect, geometry);
 132
 133     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
 134         return E_OUTOFMEMORY;
 135
 136     if (FAILED(hr = d2d_rectangle_geometry_init(object, iface, rect)))
 137     {
 138         WARN("Failed to initialize rectangle geometry, hr %#x.\n", hr);
 139         HeapFree(GetProcessHeap(), 0, object);
 140         return hr;
 141     }
 142
 143     TRACE("Created rectangle geometry %p.\n", object);
 144     *geometry = (ID2D1RectangleGeometry *)&object->ID2D1Geometry_iface;
 145
 146     return S_OK;
 147 }
 148
 149 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateRoundedRectangleGeometry(ID2D1Factory *iface,
 150         const D2D1_ROUNDED_RECT *rect, ID2D1RoundedRectangleGeometry **geometry)
 151 {
 152     FIXME("iface %p, rect %p, geometry %p stub!\n", iface, rect, geometry);
 153
 154     return E_NOTIMPL;
 155 }
 156
 157 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateEllipseGeometry(ID2D1Factory *iface,
 158         const D2D1_ELLIPSE *ellipse, ID2D1EllipseGeometry **geometry)
 159 {
 160     FIXME("iface %p, ellipse %p, geometry %p stub!\n", iface, ellipse, geometry);
 161
 162     return E_NOTIMPL;
 163 }
 164
 165 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateGeometryGroup(ID2D1Factory *iface,
 166         D2D1_FILL_MODE fill_mode, ID2D1Geometry **geometries, UINT32 geometry_count, ID2D1GeometryGroup **group)
 167 {
 168     FIXME("iface %p, fill_mode %#x, geometries %p, geometry_count %u, group %p stub!\n",
 169             iface, fill_mode, geometries, geometry_count, group);
 170
 171     return E_NOTIMPL;
 172 }
 173
 174 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateTransformedGeometry(ID2D1Factory *iface,
 175         ID2D1Geometry *src_geometry, const D2D1_MATRIX_3X2_F *transform,
 176         ID2D1TransformedGeometry **transformed_geometry)
 177 {
 178     struct d2d_geometry *object;
 179
 180     TRACE("iface %p, src_geometry %p, transform %p, transformed_geometry %p.\n",
 181             iface, src_geometry, transform, transformed_geometry);
 182
 183     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
 184         return E_OUTOFMEMORY;
 185
 186     d2d_transformed_geometry_init(object, iface, src_geometry, transform);
 187
 188     TRACE("Created transformed geometry %p.\n", object);
 189     *transformed_geometry = (ID2D1TransformedGeometry *)&object->ID2D1Geometry_iface;
 190
 191     return S_OK;
 192 }
 193
 194 static HRESULT STDMETHODCALLTYPE d2d_factory_CreatePathGeometry(ID2D1Factory *iface, ID2D1PathGeometry **geometry)
 195 {
 196     struct d2d_geometry *object;
 197
 198     TRACE("iface %p, geometry %p.\n", iface, geometry);
 199
 200     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
 201         return E_OUTOFMEMORY;
 202
 203     d2d_path_geometry_init(object, iface);
 204
 205     TRACE("Created path geometry %p.\n", object);
 206     *geometry = (ID2D1PathGeometry *)&object->ID2D1Geometry_iface;
 207
 208     return S_OK;
 209 }
 210
 211 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateStrokeStyle(ID2D1Factory *iface,
 212         const D2D1_STROKE_STYLE_PROPERTIES *desc, const float *dashes, UINT32 dash_count,
 213         ID2D1StrokeStyle **stroke_style)
 214 {
 215     struct d2d_stroke_style *object;
 216     HRESULT hr;
 217
 218     TRACE("iface %p, desc %p, dashes %p, dash_count %u, stroke_style %p.\n",
 219             iface, desc, dashes, dash_count, stroke_style);
 220
 221     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
 222         return E_OUTOFMEMORY;
 223
 224     if (FAILED(hr = d2d_stroke_style_init(object, iface, desc, dashes, dash_count)))
 225     {
 226         WARN("Failed to initialize stroke style, hr %#x.\n", hr);
 227         HeapFree(GetProcessHeap(), 0, object);
 228         return hr;
 229     }
 230
 231     TRACE("Created stroke style %p.\n", object);
 232     *stroke_style = &object->ID2D1StrokeStyle_iface;
 233
 234     return S_OK;
 235 }
 236
 237 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateDrawingStateBlock(ID2D1Factory *iface,
 238         const D2D1_DRAWING_STATE_DESCRIPTION *desc, IDWriteRenderingParams *text_rendering_params,
 239         ID2D1DrawingStateBlock **state_block)
 240 {
 241     struct d2d_state_block *object;
 242
 243     TRACE("iface %p, desc %p, text_rendering_params %p, state_block %p.\n",
 244             iface, desc, text_rendering_params, state_block);
 245
 246     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
 247         return E_OUTOFMEMORY;
 248
 249     d2d_state_block_init(object, iface, desc, text_rendering_params);
 250
 251     TRACE("Created state block %p.\n", object);
 252     *state_block = &object->ID2D1DrawingStateBlock_iface;
 253
 254     return S_OK;
 255 }
 256
 257 static HRESULT d2d_factory_get_device(struct d2d_factory *factory, ID3D10Device1 **device)
 258 {
 259     HRESULT hr = S_OK;
 260
 261     if (!factory->device && FAILED(hr = D3D10CreateDevice1(NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL, D3D10_CREATE_DEVICE_BGRA_SUPPORT,
 262             D3D10_FEATURE_LEVEL_10_0, D3D10_1_SDK_VERSION, &factory->device)))
 263         WARN("Failed to create device, hr %#x.\n", hr);
 264
 265     *device = factory->device;
 266     return hr;
 267 }
 268
 269 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateWicBitmapRenderTarget(ID2D1Factory *iface,
 270         IWICBitmap *target, const D2D1_RENDER_TARGET_PROPERTIES *desc, ID2D1RenderTarget **render_target)
 271 {
 272     struct d2d_factory *factory = impl_from_ID2D1Factory(iface);
 273     struct d2d_wic_render_target *object;
 274     ID3D10Device1 *device;
 275     HRESULT hr;
 276
 277     TRACE("iface %p, target %p, desc %p, render_target %p.\n", iface, target, desc, render_target);
 278
 279     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
 280         return E_OUTOFMEMORY;
 281
 282     if (FAILED(hr = d2d_factory_get_device(factory, &device)))
 283     {
 284         HeapFree(GetProcessHeap(), 0, object);
 285         return hr;
 286     }
 287
 288     if (FAILED(hr = d2d_wic_render_target_init(object, iface, device, target, desc)))
 289     {
 290         WARN("Failed to initialize render target, hr %#x.\n", hr);
 291         HeapFree(GetProcessHeap(), 0, object);
 292         return hr;
 293     }
 294
 295     TRACE("Created render target %p.\n", object);
 296     *render_target = &object->ID2D1RenderTarget_iface;
 297
 298     return S_OK;
 299 }
 300
 301 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateHwndRenderTarget(ID2D1Factory *iface,
 302         const D2D1_RENDER_TARGET_PROPERTIES *desc, const D2D1_HWND_RENDER_TARGET_PROPERTIES *hwnd_rt_desc,
 303         ID2D1HwndRenderTarget **render_target)
 304 {
 305     struct d2d_factory *factory = impl_from_ID2D1Factory(iface);
 306     struct d2d_hwnd_render_target *object;
 307     ID3D10Device1 *device;
 308     HRESULT hr;
 309
 310     TRACE("iface %p, desc %p, hwnd_rt_desc %p, render_target %p.\n", iface, desc, hwnd_rt_desc, render_target);
 311
 312     if (FAILED(hr = d2d_factory_get_device(factory, &device)))
 313         return hr;
 314
 315     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
 316         return E_OUTOFMEMORY;
 317
 318     if (FAILED(hr = d2d_hwnd_render_target_init(object, iface, device, desc, hwnd_rt_desc)))
 319     {
 320         WARN("Failed to initialize render target, hr %#x.\n", hr);
 321         HeapFree(GetProcessHeap(), 0, object);
 322         return hr;
 323     }
 324
 325     TRACE("Created render target %p.\n", object);
 326     *render_target = &object->ID2D1HwndRenderTarget_iface;
 327
 328     return S_OK;
 329 }
 330
 331 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateDxgiSurfaceRenderTarget(ID2D1Factory *iface,
 332         IDXGISurface *surface, const D2D1_RENDER_TARGET_PROPERTIES *desc, ID2D1RenderTarget **render_target)
 333 {
 334     struct d2d_d3d_render_target *object;
 335     HRESULT hr;
 336
 337     TRACE("iface %p, surface %p, desc %p, render_target %p.\n", iface, surface, desc, render_target);
 338
 339     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
 340         return E_OUTOFMEMORY;
 341
 342     if (FAILED(hr = d2d_d3d_render_target_init(object, iface, surface, desc)))
 343     {
 344         WARN("Failed to initialize render target, hr %#x.\n", hr);
 345         HeapFree(GetProcessHeap(), 0, object);
 346         return hr;
 347     }
 348
 349     TRACE("Created render target %p.\n", object);
 350     *render_target = &object->ID2D1RenderTarget_iface;
 351
 352     return S_OK;
 353 }
 354
 355 static HRESULT STDMETHODCALLTYPE d2d_factory_CreateDCRenderTarget(ID2D1Factory *iface,
 356         const D2D1_RENDER_TARGET_PROPERTIES *desc, ID2D1DCRenderTarget **render_target)
 357 {
 358     struct d2d_factory *factory = impl_from_ID2D1Factory(iface);
 359     struct d2d_dc_render_target *object;
 360     ID3D10Device1 *device;
 361     HRESULT hr;
 362
 363     TRACE("iface %p, desc %p, render_target %p.\n", iface, desc, render_target);
 364
 365     if (FAILED(hr = d2d_factory_get_device(factory, &device)))
 366         return hr;
 367
 368     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
 369         return E_OUTOFMEMORY;
 370
 371     if (FAILED(hr = d2d_dc_render_target_init(object, iface, device, desc)))
 372     {
 373         WARN("Failed to initialize render target, hr %#x.\n", hr);
 374         HeapFree(GetProcessHeap(), 0, object);
 375         return hr;
 376     }
 377
 378     TRACE("Created render target %p.\n", object);
 379     *render_target = &object->ID2D1DCRenderTarget_iface;
 380
 381     return S_OK;
 382 }
 383
 384 static const struct ID2D1FactoryVtbl d2d_factory_vtbl =
 385 {
 386     d2d_factory_QueryInterface,
 387     d2d_factory_AddRef,
 388     d2d_factory_Release,
 389     d2d_factory_ReloadSystemMetrics,
 390     d2d_factory_GetDesktopDpi,
 391     d2d_factory_CreateRectangleGeometry,
 392     d2d_factory_CreateRoundedRectangleGeometry,
 393     d2d_factory_CreateEllipseGeometry,
 394     d2d_factory_CreateGeometryGroup,
 395     d2d_factory_CreateTransformedGeometry,
 396     d2d_factory_CreatePathGeometry,
 397     d2d_factory_CreateStrokeStyle,
 398     d2d_factory_CreateDrawingStateBlock,
 399     d2d_factory_CreateWicBitmapRenderTarget,
 400     d2d_factory_CreateHwndRenderTarget,
 401     d2d_factory_CreateDxgiSurfaceRenderTarget,
 402     d2d_factory_CreateDCRenderTarget,
 403 };
 404
 405 static void d2d_factory_init(struct d2d_factory *factory, D2D1_FACTORY_TYPE factory_type,
 406         const D2D1_FACTORY_OPTIONS *factory_options)
 407 {
 408     if (factory_type != D2D1_FACTORY_TYPE_SINGLE_THREADED)
 409         FIXME("Ignoring factory type %#x.\n", factory_type);
 410     if (factory_options && factory_options->debugLevel != D2D1_DEBUG_LEVEL_NONE)
 411         WARN("Ignoring debug level %#x.\n", factory_options->debugLevel);
 412
 413     factory->ID2D1Factory_iface.lpVtbl = &d2d_factory_vtbl;
 414     factory->refcount = 1;
 415     d2d_factory_reload_sysmetrics(factory);
 416 }
 417
 418 HRESULT WINAPI D2D1CreateFactory(D2D1_FACTORY_TYPE factory_type, REFIID iid,
 419         const D2D1_FACTORY_OPTIONS *factory_options, void **factory)
 420 {
 421     struct d2d_factory *object;
 422     HRESULT hr;
 423
 424     TRACE("factory_type %#x, iid %s, factory_options %p, factory %p.\n",
 425             factory_type, debugstr_guid(iid), factory_options, factory);
 426
 427     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
 428         return E_OUTOFMEMORY;
 429
 430     d2d_factory_init(object, factory_type, factory_options);
 431
 432     TRACE("Created factory %p.\n", object);
 433
 434     hr = ID2D1Factory_QueryInterface(&object->ID2D1Factory_iface, iid, factory);
 435     ID2D1Factory_Release(&object->ID2D1Factory_iface);
 436
 437     return hr;
 438 }
 439
 440 void WINAPI D2D1MakeRotateMatrix(float angle, D2D1_POINT_2F center, D2D1_MATRIX_3X2_F *matrix)
 441 {
 442     float theta, sin_theta, cos_theta;
 443
 444     TRACE("angle %.8e, center {%.8e, %.8e}, matrix %p.\n", angle, center.x, center.y, matrix);
 445
 446     theta = angle * (M_PI / 180.0f);
 447     sin_theta = sinf(theta);
 448     cos_theta = cosf(theta);
 449
 450     /* translate(center) * rotate(theta) * translate(-center) */
 451     matrix->_11 = cos_theta;
 452     matrix->_12 = sin_theta;
 453     matrix->_21 = -sin_theta;
 454     matrix->_22 = cos_theta;
 455     matrix->_31 = center.x - center.x * cos_theta + center.y * sin_theta;
 456     matrix->_32 = center.y - center.x * sin_theta - center.y * cos_theta;
 457 }