dlls/d2d1/hwnd_render_target.c

   1 /*
   2  * Copyright 2014 Henri Verbeet for CodeWeavers
   3  * Copyright 2016 Nikolay Sivov for CodeWeavers
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include "d2d1_private.h"
  21
  22 WINE_DEFAULT_DEBUG_CHANNEL(d2d);
  23
  24 static inline struct d2d_hwnd_render_target *impl_from_IUnknown(IUnknown *iface)
  25 {
  26     return CONTAINING_RECORD(iface, struct d2d_hwnd_render_target, ID2D1HwndRenderTarget_iface);
  27 }
  28
  29 static HRESULT d2d_hwnd_render_target_present(IUnknown *outer_unknown)
  30 {
  31     struct d2d_hwnd_render_target *render_target = impl_from_IUnknown(outer_unknown);
  32     HRESULT hr;
  33
  34     if (FAILED(hr = IDXGISwapChain_Present(render_target->swapchain, render_target->sync_interval, 0)))
  35         WARN("Present failed, %#lx.\n", hr);
  36
  37     return S_OK;
  38 }
  39
  40 static inline struct d2d_hwnd_render_target *impl_from_ID2D1HwndRenderTarget(ID2D1HwndRenderTarget *iface)
  41 {
  42     return CONTAINING_RECORD(iface, struct d2d_hwnd_render_target, ID2D1HwndRenderTarget_iface);
  43 }
  44
  45 static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_QueryInterface(ID2D1HwndRenderTarget *iface,
  46         REFIID iid, void **out)
  47 {
  48     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
  49
  50     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
  51
  52     if (IsEqualGUID(iid, &IID_ID2D1HwndRenderTarget)
  53             || IsEqualGUID(iid, &IID_ID2D1RenderTarget)
  54             || IsEqualGUID(iid, &IID_ID2D1Resource)
  55             || IsEqualGUID(iid, &IID_IUnknown))
  56     {
  57         ID2D1HwndRenderTarget_AddRef(iface);
  58         *out = iface;
  59         return S_OK;
  60     }
  61
  62     return IUnknown_QueryInterface(render_target->dxgi_inner, iid, out);
  63 }
  64
  65 static ULONG STDMETHODCALLTYPE d2d_hwnd_render_target_AddRef(ID2D1HwndRenderTarget *iface)
  66 {
  67     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
  68     ULONG refcount = InterlockedIncrement(&render_target->refcount);
  69
  70     TRACE("%p increasing refcount to %lu.\n", iface, refcount);
  71
  72     return refcount;
  73 }
  74
  75 static ULONG STDMETHODCALLTYPE d2d_hwnd_render_target_Release(ID2D1HwndRenderTarget *iface)
  76 {
  77     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
  78     ULONG refcount = InterlockedDecrement(&render_target->refcount);
  79
  80     TRACE("%p decreasing refcount to %lu.\n", iface, refcount);
  81
  82     if (!refcount)
  83     {
  84         IUnknown_Release(render_target->dxgi_inner);
  85         IDXGISwapChain_Release(render_target->swapchain);
  86         heap_free(render_target);
  87     }
  88
  89     return refcount;
  90 }
  91
  92 static void STDMETHODCALLTYPE d2d_hwnd_render_target_GetFactory(ID2D1HwndRenderTarget *iface, ID2D1Factory **factory)
  93 {
  94     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
  95
  96     TRACE("iface %p, factory %p.\n", iface, factory);
  97
  98     ID2D1RenderTarget_GetFactory(render_target->dxgi_target, factory);
  99 }
 100
 101 static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_CreateBitmap(ID2D1HwndRenderTarget *iface,
 102         D2D1_SIZE_U size, const void *src_data, UINT32 pitch, const D2D1_BITMAP_PROPERTIES *desc, ID2D1Bitmap **bitmap)
 103 {
 104     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 105
 106     TRACE("iface %p, size {%u, %u}, src_data %p, pitch %u, desc %p, bitmap %p.\n",
 107             iface, size.width, size.height, src_data, pitch, desc, bitmap);
 108
 109     return ID2D1RenderTarget_CreateBitmap(render_target->dxgi_target, size, src_data, pitch, desc, bitmap);
 110 }
 111
 112 static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_CreateBitmapFromWicBitmap(ID2D1HwndRenderTarget *iface,
 113         IWICBitmapSource *bitmap_source, const D2D1_BITMAP_PROPERTIES *desc, ID2D1Bitmap **bitmap)
 114 {
 115     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 116
 117     TRACE("iface %p, bitmap_source %p, desc %p, bitmap %p.\n",
 118             iface, bitmap_source, desc, bitmap);
 119
 120     return ID2D1RenderTarget_CreateBitmapFromWicBitmap(render_target->dxgi_target, bitmap_source, desc, bitmap);
 121 }
 122
 123 static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_CreateSharedBitmap(ID2D1HwndRenderTarget *iface,
 124         REFIID iid, void *data, const D2D1_BITMAP_PROPERTIES *desc, ID2D1Bitmap **bitmap)
 125 {
 126     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 127
 128     TRACE("iface %p, iid %s, data %p, desc %p, bitmap %p.\n",
 129             iface, debugstr_guid(iid), data, desc, bitmap);
 130
 131     return ID2D1RenderTarget_CreateSharedBitmap(render_target->dxgi_target, iid, data, desc, bitmap);
 132 }
 133
 134 static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_CreateBitmapBrush(ID2D1HwndRenderTarget *iface,
 135         ID2D1Bitmap *bitmap, const D2D1_BITMAP_BRUSH_PROPERTIES *bitmap_brush_desc,
 136         const D2D1_BRUSH_PROPERTIES *brush_desc, ID2D1BitmapBrush **brush)
 137 {
 138     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 139
 140     TRACE("iface %p, bitmap %p, bitmap_brush_desc %p, brush_desc %p, brush %p.\n",
 141             iface, bitmap, bitmap_brush_desc, brush_desc, brush);
 142
 143     return ID2D1RenderTarget_CreateBitmapBrush(render_target->dxgi_target,
 144             bitmap, bitmap_brush_desc, brush_desc, brush);
 145 }
 146
 147 static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_CreateSolidColorBrush(ID2D1HwndRenderTarget *iface,
 148         const D2D1_COLOR_F *color, const D2D1_BRUSH_PROPERTIES *desc, ID2D1SolidColorBrush **brush)
 149 {
 150     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 151
 152     TRACE("iface %p, color %p, desc %p, brush %p.\n", iface, color, desc, brush);
 153
 154     return ID2D1RenderTarget_CreateSolidColorBrush(render_target->dxgi_target, color, desc, brush);
 155 }
 156
 157 static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_CreateGradientStopCollection(ID2D1HwndRenderTarget *iface,
 158         const D2D1_GRADIENT_STOP *stops, UINT32 stop_count, D2D1_GAMMA gamma, D2D1_EXTEND_MODE extend_mode,
 159         ID2D1GradientStopCollection **gradient)
 160 {
 161     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 162
 163     TRACE("iface %p, stops %p, stop_count %u, gamma %#x, extend_mode %#x, gradient %p.\n",
 164             iface, stops, stop_count, gamma, extend_mode, gradient);
 165
 166     return ID2D1RenderTarget_CreateGradientStopCollection(render_target->dxgi_target,
 167             stops, stop_count, gamma, extend_mode, gradient);
 168 }
 169
 170 static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_CreateLinearGradientBrush(ID2D1HwndRenderTarget *iface,
 171         const D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES *gradient_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc,
 172         ID2D1GradientStopCollection *gradient, ID2D1LinearGradientBrush **brush)
 173 {
 174     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 175
 176     TRACE("iface %p, gradient_brush_desc %p, brush_desc %p, gradient %p, brush %p.\n",
 177             iface, gradient_brush_desc, brush_desc, gradient, brush);
 178
 179     return ID2D1RenderTarget_CreateLinearGradientBrush(render_target->dxgi_target,
 180             gradient_brush_desc, brush_desc, gradient, brush);
 181 }
 182
 183 static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_CreateRadialGradientBrush(ID2D1HwndRenderTarget *iface,
 184         const D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES *gradient_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc,
 185         ID2D1GradientStopCollection *gradient, ID2D1RadialGradientBrush **brush)
 186 {
 187     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 188
 189     TRACE("iface %p, gradient_brush_desc %p, brush_desc %p, gradient %p, brush %p.\n",
 190             iface, gradient_brush_desc, brush_desc, gradient, brush);
 191
 192     return ID2D1RenderTarget_CreateRadialGradientBrush(render_target->dxgi_target,
 193             gradient_brush_desc, brush_desc, gradient, brush);
 194 }
 195
 196 static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_CreateCompatibleRenderTarget(ID2D1HwndRenderTarget *iface,
 197         const D2D1_SIZE_F *size, const D2D1_SIZE_U *pixel_size, const D2D1_PIXEL_FORMAT *format,
 198         D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS options, ID2D1BitmapRenderTarget **render_target)
 199 {
 200     struct d2d_hwnd_render_target *rt = impl_from_ID2D1HwndRenderTarget(iface);
 201
 202     TRACE("iface %p, size %p, pixel_size %p, format %p, options %#x, render_target %p,\n",
 203             iface, size, pixel_size, format, options, render_target);
 204
 205     return ID2D1RenderTarget_CreateCompatibleRenderTarget(rt->dxgi_target,
 206             size, pixel_size, format, options, render_target);
 207 }
 208
 209 static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_CreateLayer(ID2D1HwndRenderTarget *iface,
 210         const D2D1_SIZE_F *size, ID2D1Layer **layer)
 211 {
 212     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 213
 214     TRACE("iface %p, size %p, layer %p.\n", iface, size, layer);
 215
 216     return ID2D1RenderTarget_CreateLayer(render_target->dxgi_target, size, layer);
 217 }
 218
 219 static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_CreateMesh(ID2D1HwndRenderTarget *iface, ID2D1Mesh **mesh)
 220 {
 221     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 222
 223     TRACE("iface %p, mesh %p.\n", iface, mesh);
 224
 225     return ID2D1RenderTarget_CreateMesh(render_target->dxgi_target, mesh);
 226 }
 227
 228 static void STDMETHODCALLTYPE d2d_hwnd_render_target_DrawLine(ID2D1HwndRenderTarget *iface,
 229         D2D1_POINT_2F p0, D2D1_POINT_2F p1, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style)
 230 {
 231     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 232
 233     TRACE("iface %p, p0 %s, p1 %s, brush %p, stroke_width %.8e, stroke_style %p.\n",
 234             iface, debug_d2d_point_2f(&p0), debug_d2d_point_2f(&p1), brush, stroke_width, stroke_style);
 235
 236     ID2D1RenderTarget_DrawLine(render_target->dxgi_target, p0, p1, brush, stroke_width, stroke_style);
 237 }
 238
 239 static void STDMETHODCALLTYPE d2d_hwnd_render_target_DrawRectangle(ID2D1HwndRenderTarget *iface,
 240         const D2D1_RECT_F *rect, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style)
 241 {
 242     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 243
 244     TRACE("iface %p, rect %s, brush %p, stroke_width %.8e, stroke_style %p.\n",
 245             iface, debug_d2d_rect_f(rect), brush, stroke_width, stroke_style);
 246
 247     ID2D1RenderTarget_DrawRectangle(render_target->dxgi_target, rect, brush, stroke_width, stroke_style);
 248 }
 249
 250 static void STDMETHODCALLTYPE d2d_hwnd_render_target_FillRectangle(ID2D1HwndRenderTarget *iface,
 251         const D2D1_RECT_F *rect, ID2D1Brush *brush)
 252 {
 253     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 254
 255     TRACE("iface %p, rect %s, brush %p.\n", iface, debug_d2d_rect_f(rect), brush);
 256
 257     ID2D1RenderTarget_FillRectangle(render_target->dxgi_target, rect, brush);
 258 }
 259
 260 static void STDMETHODCALLTYPE d2d_hwnd_render_target_DrawRoundedRectangle(ID2D1HwndRenderTarget *iface,
 261         const D2D1_ROUNDED_RECT *rect, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style)
 262 {
 263     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 264
 265     TRACE("iface %p, rect %p, brush %p, stroke_width %.8e, stroke_style %p.\n",
 266             iface, rect, brush, stroke_width, stroke_style);
 267
 268     ID2D1RenderTarget_DrawRoundedRectangle(render_target->dxgi_target, rect, brush, stroke_width, stroke_style);
 269 }
 270
 271 static void STDMETHODCALLTYPE d2d_hwnd_render_target_FillRoundedRectangle(ID2D1HwndRenderTarget *iface,
 272         const D2D1_ROUNDED_RECT *rect, ID2D1Brush *brush)
 273 {
 274     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 275
 276     TRACE("iface %p, rect %p, brush %p.\n", iface, rect, brush);
 277
 278     ID2D1RenderTarget_FillRoundedRectangle(render_target->dxgi_target, rect, brush);
 279 }
 280
 281 static void STDMETHODCALLTYPE d2d_hwnd_render_target_DrawEllipse(ID2D1HwndRenderTarget *iface,
 282         const D2D1_ELLIPSE *ellipse, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style)
 283 {
 284     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 285
 286     TRACE("iface %p, ellipse %p, brush %p, stroke_width %.8e, stroke_style %p.\n",
 287             iface, ellipse, brush, stroke_width, stroke_style);
 288
 289     ID2D1RenderTarget_DrawEllipse(render_target->dxgi_target, ellipse, brush, stroke_width, stroke_style);
 290 }
 291
 292 static void STDMETHODCALLTYPE d2d_hwnd_render_target_FillEllipse(ID2D1HwndRenderTarget *iface,
 293         const D2D1_ELLIPSE *ellipse, ID2D1Brush *brush)
 294 {
 295     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 296
 297     TRACE("iface %p, ellipse %p, brush %p.\n", iface, ellipse, brush);
 298
 299     ID2D1RenderTarget_FillEllipse(render_target->dxgi_target, ellipse, brush);
 300 }
 301
 302 static void STDMETHODCALLTYPE d2d_hwnd_render_target_DrawGeometry(ID2D1HwndRenderTarget *iface,
 303         ID2D1Geometry *geometry, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style)
 304 {
 305     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 306
 307     TRACE("iface %p, geometry %p, brush %p, stroke_width %.8e, stroke_style %p.\n",
 308             iface, geometry, brush, stroke_width, stroke_style);
 309
 310     ID2D1RenderTarget_DrawGeometry(render_target->dxgi_target, geometry, brush, stroke_width, stroke_style);
 311 }
 312
 313 static void STDMETHODCALLTYPE d2d_hwnd_render_target_FillGeometry(ID2D1HwndRenderTarget *iface,
 314         ID2D1Geometry *geometry, ID2D1Brush *brush, ID2D1Brush *opacity_brush)
 315 {
 316     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 317
 318     TRACE("iface %p, geometry %p, brush %p, opacity_brush %p.\n", iface, geometry, brush, opacity_brush);
 319
 320     ID2D1RenderTarget_FillGeometry(render_target->dxgi_target, geometry, brush, opacity_brush);
 321 }
 322
 323 static void STDMETHODCALLTYPE d2d_hwnd_render_target_FillMesh(ID2D1HwndRenderTarget *iface,
 324         ID2D1Mesh *mesh, ID2D1Brush *brush)
 325 {
 326     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 327
 328     TRACE("iface %p, mesh %p, brush %p.\n", iface, mesh, brush);
 329
 330     ID2D1RenderTarget_FillMesh(render_target->dxgi_target, mesh, brush);
 331 }
 332
 333 static void STDMETHODCALLTYPE d2d_hwnd_render_target_FillOpacityMask(ID2D1HwndRenderTarget *iface,
 334         ID2D1Bitmap *mask, ID2D1Brush *brush, D2D1_OPACITY_MASK_CONTENT content,
 335         const D2D1_RECT_F *dst_rect, const D2D1_RECT_F *src_rect)
 336 {
 337     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 338
 339     TRACE("iface %p, mask %p, brush %p, content %#x, dst_rect %s, src_rect %s.\n",
 340             iface, mask, brush, content, debug_d2d_rect_f(dst_rect), debug_d2d_rect_f(src_rect));
 341
 342     ID2D1RenderTarget_FillOpacityMask(render_target->dxgi_target,
 343             mask, brush, content, dst_rect, src_rect);
 344 }
 345
 346 static void STDMETHODCALLTYPE d2d_hwnd_render_target_DrawBitmap(ID2D1HwndRenderTarget *iface,
 347         ID2D1Bitmap *bitmap, const D2D1_RECT_F *dst_rect, float opacity,
 348         D2D1_BITMAP_INTERPOLATION_MODE interpolation_mode, const D2D1_RECT_F *src_rect)
 349 {
 350     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 351
 352     TRACE("iface %p, bitmap %p, dst_rect %s, opacity %.8e, interpolation_mode %#x, src_rect %s.\n",
 353             iface, bitmap, debug_d2d_rect_f(dst_rect), opacity, interpolation_mode, debug_d2d_rect_f(src_rect));
 354
 355     ID2D1RenderTarget_DrawBitmap(render_target->dxgi_target,
 356             bitmap, dst_rect, opacity, interpolation_mode, src_rect);
 357 }
 358
 359 static void STDMETHODCALLTYPE d2d_hwnd_render_target_DrawText(ID2D1HwndRenderTarget *iface,
 360         const WCHAR *string, UINT32 string_len, IDWriteTextFormat *text_format, const D2D1_RECT_F *layout_rect,
 361         ID2D1Brush *brush, D2D1_DRAW_TEXT_OPTIONS options, DWRITE_MEASURING_MODE measuring_mode)
 362 {
 363     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 364
 365     TRACE("iface %p, string %s, string_len %u, text_format %p, layout_rect %s, "
 366             "brush %p, options %#x, measuring_mode %#x.\n",
 367             iface, debugstr_wn(string, string_len), string_len, text_format, debug_d2d_rect_f(layout_rect),
 368             brush, options, measuring_mode);
 369
 370     ID2D1RenderTarget_DrawText(render_target->dxgi_target, string, string_len,
 371             text_format, layout_rect, brush, options, measuring_mode);
 372 }
 373
 374 static void STDMETHODCALLTYPE d2d_hwnd_render_target_DrawTextLayout(ID2D1HwndRenderTarget *iface,
 375         D2D1_POINT_2F origin, IDWriteTextLayout *layout, ID2D1Brush *brush, D2D1_DRAW_TEXT_OPTIONS options)
 376 {
 377     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 378
 379     TRACE("iface %p, origin %s, layout %p, brush %p, options %#x.\n",
 380             iface, debug_d2d_point_2f(&origin), layout, brush, options);
 381
 382     ID2D1RenderTarget_DrawTextLayout(render_target->dxgi_target, origin, layout, brush, options);
 383 }
 384
 385 static void STDMETHODCALLTYPE d2d_hwnd_render_target_DrawGlyphRun(ID2D1HwndRenderTarget *iface,
 386         D2D1_POINT_2F baseline_origin, const DWRITE_GLYPH_RUN *glyph_run, ID2D1Brush *brush,
 387         DWRITE_MEASURING_MODE measuring_mode)
 388 {
 389     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 390
 391     TRACE("iface %p, baseline_origin %s, glyph_run %p, brush %p, measuring_mode %#x.\n",
 392             iface, debug_d2d_point_2f(&baseline_origin), glyph_run, brush, measuring_mode);
 393
 394     ID2D1RenderTarget_DrawGlyphRun(render_target->dxgi_target,
 395             baseline_origin, glyph_run, brush, measuring_mode);
 396 }
 397
 398 static void STDMETHODCALLTYPE d2d_hwnd_render_target_SetTransform(ID2D1HwndRenderTarget *iface,
 399         const D2D1_MATRIX_3X2_F *transform)
 400 {
 401     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 402
 403     TRACE("iface %p, transform %p.\n", iface, transform);
 404
 405     ID2D1RenderTarget_SetTransform(render_target->dxgi_target, transform);
 406 }
 407
 408 static void STDMETHODCALLTYPE d2d_hwnd_render_target_GetTransform(ID2D1HwndRenderTarget *iface,
 409         D2D1_MATRIX_3X2_F *transform)
 410 {
 411     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 412
 413     TRACE("iface %p, transform %p.\n", iface, transform);
 414
 415     ID2D1RenderTarget_GetTransform(render_target->dxgi_target, transform);
 416 }
 417
 418 static void STDMETHODCALLTYPE d2d_hwnd_render_target_SetAntialiasMode(ID2D1HwndRenderTarget *iface,
 419         D2D1_ANTIALIAS_MODE antialias_mode)
 420 {
 421     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 422
 423     TRACE("iface %p, antialias_mode %#x.\n", iface, antialias_mode);
 424
 425     ID2D1RenderTarget_SetAntialiasMode(render_target->dxgi_target, antialias_mode);
 426 }
 427
 428 static D2D1_ANTIALIAS_MODE STDMETHODCALLTYPE d2d_hwnd_render_target_GetAntialiasMode(ID2D1HwndRenderTarget *iface)
 429 {
 430     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 431
 432     TRACE("iface %p.\n", iface);
 433
 434     return ID2D1RenderTarget_GetAntialiasMode(render_target->dxgi_target);
 435 }
 436
 437 static void STDMETHODCALLTYPE d2d_hwnd_render_target_SetTextAntialiasMode(ID2D1HwndRenderTarget *iface,
 438         D2D1_TEXT_ANTIALIAS_MODE antialias_mode)
 439 {
 440     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 441
 442     TRACE("iface %p, antialias_mode %#x.\n", iface, antialias_mode);
 443
 444     ID2D1RenderTarget_SetTextAntialiasMode(render_target->dxgi_target, antialias_mode);
 445 }
 446
 447 static D2D1_TEXT_ANTIALIAS_MODE STDMETHODCALLTYPE d2d_hwnd_render_target_GetTextAntialiasMode(
 448         ID2D1HwndRenderTarget *iface)
 449 {
 450     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 451
 452     TRACE("iface %p.\n", iface);
 453
 454     return ID2D1RenderTarget_GetTextAntialiasMode(render_target->dxgi_target);
 455 }
 456
 457 static void STDMETHODCALLTYPE d2d_hwnd_render_target_SetTextRenderingParams(ID2D1HwndRenderTarget *iface,
 458         IDWriteRenderingParams *text_rendering_params)
 459 {
 460     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 461
 462     TRACE("iface %p, text_rendering_params %p.\n", iface, text_rendering_params);
 463
 464     ID2D1RenderTarget_SetTextRenderingParams(render_target->dxgi_target, text_rendering_params);
 465 }
 466
 467 static void STDMETHODCALLTYPE d2d_hwnd_render_target_GetTextRenderingParams(ID2D1HwndRenderTarget *iface,
 468         IDWriteRenderingParams **text_rendering_params)
 469 {
 470     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 471
 472     TRACE("iface %p, text_rendering_params %p.\n", iface, text_rendering_params);
 473
 474     ID2D1RenderTarget_GetTextRenderingParams(render_target->dxgi_target, text_rendering_params);
 475 }
 476
 477 static void STDMETHODCALLTYPE d2d_hwnd_render_target_SetTags(ID2D1HwndRenderTarget *iface, D2D1_TAG tag1, D2D1_TAG tag2)
 478 {
 479     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 480
 481     TRACE("iface %p, tag1 %s, tag2 %s.\n", iface, wine_dbgstr_longlong(tag1), wine_dbgstr_longlong(tag2));
 482
 483     ID2D1RenderTarget_SetTags(render_target->dxgi_target, tag1, tag2);
 484 }
 485
 486 static void STDMETHODCALLTYPE d2d_hwnd_render_target_GetTags(ID2D1HwndRenderTarget *iface, D2D1_TAG *tag1,
 487         D2D1_TAG *tag2)
 488 {
 489     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 490
 491     TRACE("iface %p, tag1 %p, tag2 %p.\n", iface, tag1, tag2);
 492
 493     ID2D1RenderTarget_GetTags(render_target->dxgi_target, tag1, tag2);
 494 }
 495
 496 static void STDMETHODCALLTYPE d2d_hwnd_render_target_PushLayer(ID2D1HwndRenderTarget *iface,
 497         const D2D1_LAYER_PARAMETERS *layer_parameters, ID2D1Layer *layer)
 498 {
 499     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 500
 501     TRACE("iface %p, layer_parameters %p, layer %p.\n", iface, layer_parameters, layer);
 502
 503     ID2D1RenderTarget_PushLayer(render_target->dxgi_target, layer_parameters, layer);
 504 }
 505
 506 static void STDMETHODCALLTYPE d2d_hwnd_render_target_PopLayer(ID2D1HwndRenderTarget *iface)
 507 {
 508     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 509
 510     TRACE("iface %p.\n", iface);
 511
 512     ID2D1RenderTarget_PopLayer(render_target->dxgi_target);
 513 }
 514
 515 static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_Flush(ID2D1HwndRenderTarget *iface, D2D1_TAG *tag1,
 516         D2D1_TAG *tag2)
 517 {
 518     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 519
 520     TRACE("iface %p, tag1 %p, tag2 %p.\n", iface, tag1, tag2);
 521
 522     return ID2D1RenderTarget_Flush(render_target->dxgi_target, tag1, tag2);
 523 }
 524
 525 static void STDMETHODCALLTYPE d2d_hwnd_render_target_SaveDrawingState(ID2D1HwndRenderTarget *iface,
 526         ID2D1DrawingStateBlock *state_block)
 527 {
 528     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 529
 530     TRACE("iface %p, state_block %p.\n", iface, state_block);
 531
 532     ID2D1RenderTarget_SaveDrawingState(render_target->dxgi_target, state_block);
 533 }
 534
 535 static void STDMETHODCALLTYPE d2d_hwnd_render_target_RestoreDrawingState(ID2D1HwndRenderTarget *iface,
 536         ID2D1DrawingStateBlock *state_block)
 537 {
 538     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 539
 540     TRACE("iface %p, state_block %p.\n", iface, state_block);
 541
 542     ID2D1RenderTarget_RestoreDrawingState(render_target->dxgi_target, state_block);
 543 }
 544
 545 static void STDMETHODCALLTYPE d2d_hwnd_render_target_PushAxisAlignedClip(ID2D1HwndRenderTarget *iface,
 546         const D2D1_RECT_F *clip_rect, D2D1_ANTIALIAS_MODE antialias_mode)
 547 {
 548     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 549
 550     TRACE("iface %p, clip_rect %s, antialias_mode %#x.\n", iface, debug_d2d_rect_f(clip_rect), antialias_mode);
 551
 552     ID2D1RenderTarget_PushAxisAlignedClip(render_target->dxgi_target, clip_rect, antialias_mode);
 553 }
 554
 555 static void STDMETHODCALLTYPE d2d_hwnd_render_target_PopAxisAlignedClip(ID2D1HwndRenderTarget *iface)
 556 {
 557     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 558
 559     TRACE("iface %p.\n", iface);
 560
 561     ID2D1RenderTarget_PopAxisAlignedClip(render_target->dxgi_target);
 562 }
 563
 564 static void STDMETHODCALLTYPE d2d_hwnd_render_target_Clear(ID2D1HwndRenderTarget *iface, const D2D1_COLOR_F *color)
 565 {
 566     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 567
 568     TRACE("iface %p, color %p.\n", iface, color);
 569
 570     ID2D1RenderTarget_Clear(render_target->dxgi_target, color);
 571 }
 572
 573 static void STDMETHODCALLTYPE d2d_hwnd_render_target_BeginDraw(ID2D1HwndRenderTarget *iface)
 574 {
 575     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 576
 577     TRACE("iface %p.\n", iface);
 578
 579     ID2D1RenderTarget_BeginDraw(render_target->dxgi_target);
 580 }
 581
 582 static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_EndDraw(ID2D1HwndRenderTarget *iface,
 583         D2D1_TAG *tag1, D2D1_TAG *tag2)
 584 {
 585     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 586
 587     TRACE("iface %p, tag1 %p, tag2 %p.\n", iface, tag1, tag2);
 588
 589     return ID2D1RenderTarget_EndDraw(render_target->dxgi_target, tag1, tag2);
 590 }
 591
 592 static D2D1_PIXEL_FORMAT * STDMETHODCALLTYPE d2d_hwnd_render_target_GetPixelFormat(ID2D1HwndRenderTarget *iface,
 593         D2D1_PIXEL_FORMAT *format)
 594 {
 595     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 596
 597     TRACE("iface %p, format %p.\n", iface, format);
 598
 599     *format = ID2D1RenderTarget_GetPixelFormat(render_target->dxgi_target);
 600     return format;
 601 }
 602
 603 static void STDMETHODCALLTYPE d2d_hwnd_render_target_SetDpi(ID2D1HwndRenderTarget *iface, float dpi_x, float dpi_y)
 604 {
 605     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 606
 607     TRACE("iface %p, dpi_x %.8e, dpi_y %.8e.\n", iface, dpi_x, dpi_y);
 608
 609     ID2D1RenderTarget_SetDpi(render_target->dxgi_target, dpi_x, dpi_y);
 610 }
 611
 612 static void STDMETHODCALLTYPE d2d_hwnd_render_target_GetDpi(ID2D1HwndRenderTarget *iface, float *dpi_x, float *dpi_y)
 613 {
 614     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 615
 616     TRACE("iface %p, dpi_x %p, dpi_y %p.\n", iface, dpi_x, dpi_y);
 617
 618     ID2D1RenderTarget_GetDpi(render_target->dxgi_target, dpi_x, dpi_y);
 619 }
 620
 621 static D2D1_SIZE_F * STDMETHODCALLTYPE d2d_hwnd_render_target_GetSize(ID2D1HwndRenderTarget *iface, D2D1_SIZE_F *size)
 622 {
 623     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 624
 625     TRACE("iface %p, size %p.\n", iface, size);
 626
 627     *size = ID2D1RenderTarget_GetSize(render_target->dxgi_target);
 628     return size;
 629 }
 630
 631 static D2D1_SIZE_U * STDMETHODCALLTYPE d2d_hwnd_render_target_GetPixelSize(ID2D1HwndRenderTarget *iface,
 632         D2D1_SIZE_U *pixel_size)
 633 {
 634     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 635
 636     TRACE("iface %p, pixel_size %p.\n", iface, pixel_size);
 637
 638     *pixel_size = ID2D1RenderTarget_GetPixelSize(render_target->dxgi_target);
 639     return pixel_size;
 640 }
 641
 642 static UINT32 STDMETHODCALLTYPE d2d_hwnd_render_target_GetMaximumBitmapSize(ID2D1HwndRenderTarget *iface)
 643 {
 644     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 645
 646     TRACE("iface %p.\n", iface);
 647
 648     return ID2D1RenderTarget_GetMaximumBitmapSize(render_target->dxgi_target);
 649 }
 650
 651 static BOOL STDMETHODCALLTYPE d2d_hwnd_render_target_IsSupported(ID2D1HwndRenderTarget *iface,
 652         const D2D1_RENDER_TARGET_PROPERTIES *desc)
 653 {
 654     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 655
 656     TRACE("iface %p, desc %p.\n", iface, desc);
 657
 658     return ID2D1RenderTarget_IsSupported(render_target->dxgi_target, desc);
 659 }
 660
 661 static D2D1_WINDOW_STATE STDMETHODCALLTYPE d2d_hwnd_render_target_CheckWindowState(ID2D1HwndRenderTarget *iface)
 662 {
 663     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 664
 665     TRACE("iface %p.\n", iface);
 666
 667     return IDXGISwapChain_Present(render_target->swapchain, render_target->sync_interval, DXGI_PRESENT_TEST) ==
 668             DXGI_STATUS_OCCLUDED ? D2D1_WINDOW_STATE_OCCLUDED : D2D1_WINDOW_STATE_NONE;
 669 }
 670
 671 static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_Resize(ID2D1HwndRenderTarget *iface, const D2D1_SIZE_U *size)
 672 {
 673     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 674     IDXGISurface1 *dxgi_surface;
 675     ID2D1DeviceContext *context;
 676     ID2D1Bitmap1 *bitmap;
 677     HRESULT hr;
 678
 679     TRACE("iface %p, width %u, height %u.\n", iface, size->width, size->height);
 680
 681     ID2D1RenderTarget_QueryInterface(render_target->dxgi_target, &IID_ID2D1DeviceContext, (void **)&context);
 682     ID2D1DeviceContext_SetTarget(context, NULL);
 683
 684     if (SUCCEEDED(hr = IDXGISwapChain_ResizeBuffers(render_target->swapchain, 1, size->width, size->height,
 685         DXGI_FORMAT_UNKNOWN, 0)))
 686     {
 687         if (FAILED(hr = IDXGISwapChain_GetBuffer(render_target->swapchain, 0, &IID_IDXGISurface1,
 688                 (void **)&dxgi_surface)))
 689         {
 690             WARN("Failed to get buffer, hr %#lx.\n", hr);
 691             ID2D1DeviceContext_Release(context);
 692             return hr;
 693         }
 694
 695         hr = ID2D1DeviceContext_CreateBitmapFromDxgiSurface(context, (IDXGISurface *)dxgi_surface, NULL, &bitmap);
 696         IDXGISurface1_Release(dxgi_surface);
 697         if (FAILED(hr))
 698         {
 699             WARN("Failed to create target bitmap, hr %#lx.\n", hr);
 700             ID2D1DeviceContext_Release(context);
 701             return hr;
 702         }
 703
 704         ID2D1DeviceContext_SetTarget(context, (ID2D1Image *)bitmap);
 705         ID2D1Bitmap1_Release(bitmap);
 706     }
 707
 708     ID2D1DeviceContext_Release(context);
 709
 710     return hr;
 711 }
 712
 713 static HWND STDMETHODCALLTYPE d2d_hwnd_render_target_GetHwnd(ID2D1HwndRenderTarget *iface)
 714 {
 715     struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface);
 716
 717     TRACE("iface %p.\n", iface);
 718
 719     return render_target->hwnd;
 720 }
 721
 722 static const struct ID2D1HwndRenderTargetVtbl d2d_hwnd_render_target_vtbl =
 723 {
 724     d2d_hwnd_render_target_QueryInterface,
 725     d2d_hwnd_render_target_AddRef,
 726     d2d_hwnd_render_target_Release,
 727     d2d_hwnd_render_target_GetFactory,
 728     d2d_hwnd_render_target_CreateBitmap,
 729     d2d_hwnd_render_target_CreateBitmapFromWicBitmap,
 730     d2d_hwnd_render_target_CreateSharedBitmap,
 731     d2d_hwnd_render_target_CreateBitmapBrush,
 732     d2d_hwnd_render_target_CreateSolidColorBrush,
 733     d2d_hwnd_render_target_CreateGradientStopCollection,
 734     d2d_hwnd_render_target_CreateLinearGradientBrush,
 735     d2d_hwnd_render_target_CreateRadialGradientBrush,
 736     d2d_hwnd_render_target_CreateCompatibleRenderTarget,
 737     d2d_hwnd_render_target_CreateLayer,
 738     d2d_hwnd_render_target_CreateMesh,
 739     d2d_hwnd_render_target_DrawLine,
 740     d2d_hwnd_render_target_DrawRectangle,
 741     d2d_hwnd_render_target_FillRectangle,
 742     d2d_hwnd_render_target_DrawRoundedRectangle,
 743     d2d_hwnd_render_target_FillRoundedRectangle,
 744     d2d_hwnd_render_target_DrawEllipse,
 745     d2d_hwnd_render_target_FillEllipse,
 746     d2d_hwnd_render_target_DrawGeometry,
 747     d2d_hwnd_render_target_FillGeometry,
 748     d2d_hwnd_render_target_FillMesh,
 749     d2d_hwnd_render_target_FillOpacityMask,
 750     d2d_hwnd_render_target_DrawBitmap,
 751     d2d_hwnd_render_target_DrawText,
 752     d2d_hwnd_render_target_DrawTextLayout,
 753     d2d_hwnd_render_target_DrawGlyphRun,
 754     d2d_hwnd_render_target_SetTransform,
 755     d2d_hwnd_render_target_GetTransform,
 756     d2d_hwnd_render_target_SetAntialiasMode,
 757     d2d_hwnd_render_target_GetAntialiasMode,
 758     d2d_hwnd_render_target_SetTextAntialiasMode,
 759     d2d_hwnd_render_target_GetTextAntialiasMode,
 760     d2d_hwnd_render_target_SetTextRenderingParams,
 761     d2d_hwnd_render_target_GetTextRenderingParams,
 762     d2d_hwnd_render_target_SetTags,
 763     d2d_hwnd_render_target_GetTags,
 764     d2d_hwnd_render_target_PushLayer,
 765     d2d_hwnd_render_target_PopLayer,
 766     d2d_hwnd_render_target_Flush,
 767     d2d_hwnd_render_target_SaveDrawingState,
 768     d2d_hwnd_render_target_RestoreDrawingState,
 769     d2d_hwnd_render_target_PushAxisAlignedClip,
 770     d2d_hwnd_render_target_PopAxisAlignedClip,
 771     d2d_hwnd_render_target_Clear,
 772     d2d_hwnd_render_target_BeginDraw,
 773     d2d_hwnd_render_target_EndDraw,
 774     d2d_hwnd_render_target_GetPixelFormat,
 775     d2d_hwnd_render_target_SetDpi,
 776     d2d_hwnd_render_target_GetDpi,
 777     d2d_hwnd_render_target_GetSize,
 778     d2d_hwnd_render_target_GetPixelSize,
 779     d2d_hwnd_render_target_GetMaximumBitmapSize,
 780     d2d_hwnd_render_target_IsSupported,
 781     d2d_hwnd_render_target_CheckWindowState,
 782     d2d_hwnd_render_target_Resize,
 783     d2d_hwnd_render_target_GetHwnd
 784 };
 785
 786 static const struct d2d_device_context_ops d2d_hwnd_render_target_ops =
 787 {
 788     d2d_hwnd_render_target_present,
 789 };
 790
 791 HRESULT d2d_hwnd_render_target_init(struct d2d_hwnd_render_target *render_target, ID2D1Factory1 *factory,
 792         ID3D10Device1 *d3d_device, const D2D1_RENDER_TARGET_PROPERTIES *desc,
 793         const D2D1_HWND_RENDER_TARGET_PROPERTIES *hwnd_rt_desc)
 794 {
 795     D2D1_RENDER_TARGET_PROPERTIES dxgi_rt_desc;
 796     DXGI_SWAP_CHAIN_DESC swapchain_desc;
 797     IDXGIAdapter *dxgi_adapter;
 798     IDXGIFactory *dxgi_factory;
 799     IDXGISurface *dxgi_surface;
 800     IDXGIDevice *dxgi_device;
 801     ID2D1Device *device;
 802     HRESULT hr;
 803
 804     if (!IsWindow(hwnd_rt_desc->hwnd))
 805         return HRESULT_FROM_WIN32(ERROR_INVALID_WINDOW_HANDLE);
 806
 807     render_target->ID2D1HwndRenderTarget_iface.lpVtbl = &d2d_hwnd_render_target_vtbl;
 808     render_target->hwnd = hwnd_rt_desc->hwnd;
 809     render_target->sync_interval = hwnd_rt_desc->presentOptions & D2D1_PRESENT_OPTIONS_IMMEDIATELY ? 0 : 1;
 810
 811     if (FAILED(hr = ID3D10Device1_QueryInterface(d3d_device, &IID_IDXGIDevice, (void **)&dxgi_device)))
 812     {
 813         WARN("Failed to get IDXGIDevice interface, hr %#lx.\n", hr);
 814         return hr;
 815     }
 816
 817     hr = IDXGIDevice_GetAdapter(dxgi_device, &dxgi_adapter);
 818     IDXGIDevice_Release(dxgi_device);
 819     if (FAILED(hr))
 820     {
 821         WARN("Failed to get IDXGIAdapter interface, hr %#lx.\n", hr);
 822         return hr;
 823     }
 824
 825     hr = IDXGIAdapter_GetParent(dxgi_adapter, &IID_IDXGIFactory, (void **)&dxgi_factory);
 826     IDXGIAdapter_Release(dxgi_adapter);
 827     if (FAILED(hr))
 828     {
 829         WARN("Failed to get IDXGIFactory interface, hr %#lx.\n", hr);
 830         return hr;
 831     }
 832
 833     dxgi_rt_desc = *desc;
 834     if (dxgi_rt_desc.dpiX == 0.0f && dxgi_rt_desc.dpiY == 0.0f)
 835         ID2D1Factory1_GetDesktopDpi(factory, &dxgi_rt_desc.dpiX, &dxgi_rt_desc.dpiY);
 836
 837     if (dxgi_rt_desc.pixelFormat.format == DXGI_FORMAT_UNKNOWN)
 838     {
 839         dxgi_rt_desc.pixelFormat.format = DXGI_FORMAT_B8G8R8A8_UNORM;
 840         dxgi_rt_desc.pixelFormat.alphaMode = D2D1_ALPHA_MODE_IGNORE;
 841     }
 842
 843     swapchain_desc.BufferDesc.Width = hwnd_rt_desc->pixelSize.width;
 844     swapchain_desc.BufferDesc.Height = hwnd_rt_desc->pixelSize.height;
 845     swapchain_desc.BufferDesc.RefreshRate.Numerator = 60;
 846     swapchain_desc.BufferDesc.RefreshRate.Denominator = 1;
 847     swapchain_desc.BufferDesc.Format = dxgi_rt_desc.pixelFormat.format;
 848     swapchain_desc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
 849     swapchain_desc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
 850     swapchain_desc.SampleDesc.Count = 1;
 851     swapchain_desc.SampleDesc.Quality = 0;
 852     swapchain_desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
 853     swapchain_desc.BufferCount = 1;
 854     swapchain_desc.OutputWindow = hwnd_rt_desc->hwnd;
 855     swapchain_desc.Windowed = TRUE;
 856     swapchain_desc.SwapEffect = hwnd_rt_desc->presentOptions & D2D1_PRESENT_OPTIONS_RETAIN_CONTENTS ?
 857         DXGI_SWAP_EFFECT_SEQUENTIAL : DXGI_SWAP_EFFECT_DISCARD;
 858     swapchain_desc.Flags = DXGI_SWAP_CHAIN_FLAG_GDI_COMPATIBLE;
 859
 860     hr = IDXGIFactory_CreateSwapChain(dxgi_factory, (IUnknown *)d3d_device, &swapchain_desc, &render_target->swapchain);
 861     IDXGIFactory_Release(dxgi_factory);
 862     if (FAILED(hr))
 863     {
 864         WARN("Failed to create a swapchain, hr %#lx.\n", hr);
 865         return hr;
 866     }
 867
 868     if (FAILED(hr = IDXGISwapChain_GetBuffer(render_target->swapchain, 0, &IID_IDXGISurface, (void **)&dxgi_surface)))
 869     {
 870         WARN("Failed to get buffer, hr %#lx.\n", hr);
 871         IDXGISwapChain_Release(render_target->swapchain);
 872         return hr;
 873     }
 874
 875     render_target->ID2D1HwndRenderTarget_iface.lpVtbl = &d2d_hwnd_render_target_vtbl;
 876
 877     if (FAILED(hr = IDXGISurface_GetDevice(dxgi_surface, &IID_IDXGIDevice, (void **)&dxgi_device)))
 878     {
 879         WARN("Failed to get DXGI device, hr %#lx.\n", hr);
 880         IDXGISurface_Release(dxgi_surface);
 881         IDXGISwapChain_Release(render_target->swapchain);
 882         return hr;
 883     }
 884
 885     hr = ID2D1Factory1_CreateDevice(factory, dxgi_device, &device);
 886     IDXGIDevice_Release(dxgi_device);
 887     if (FAILED(hr))
 888     {
 889         WARN("Failed to create D2D device, hr %#lx.\n", hr);
 890         IDXGISurface_Release(dxgi_surface);
 891         IDXGISwapChain_Release(render_target->swapchain);
 892         return hr;
 893     }
 894
 895     hr = d2d_d3d_create_render_target(device, dxgi_surface,
 896             (IUnknown *)&render_target->ID2D1HwndRenderTarget_iface, &d2d_hwnd_render_target_ops,
 897             &dxgi_rt_desc, (void **)&render_target->dxgi_inner);
 898     IDXGISurface_Release(dxgi_surface);
 899     ID2D1Device_Release(device);
 900     if (FAILED(hr))
 901     {
 902         WARN("Failed to create DXGI surface render target, hr %#lx.\n", hr);
 903         IDXGISwapChain_Release(render_target->swapchain);
 904         return hr;
 905     }
 906
 907     if (FAILED(hr = IUnknown_QueryInterface(render_target->dxgi_inner,
 908             &IID_ID2D1RenderTarget, (void **)&render_target->dxgi_target)))
 909     {
 910         WARN("Failed to retrieve ID2D1RenderTarget interface, hr %#lx.\n", hr);
 911         IUnknown_Release(render_target->dxgi_inner);
 912         IDXGISwapChain_Release(render_target->swapchain);
 913         return hr;
 914     }
 915
 916     return S_OK;
 917 }