dlls/d2d1/brush.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 #include "d2d1_private.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(d2d);
  25
  26 static inline struct d2d_gradient *impl_from_ID2D1GradientStopCollection(ID2D1GradientStopCollection *iface)
  27 {
  28     return CONTAINING_RECORD(iface, struct d2d_gradient, ID2D1GradientStopCollection_iface);
  29 }
  30
  31 static HRESULT STDMETHODCALLTYPE d2d_gradient_QueryInterface(ID2D1GradientStopCollection *iface,
  32         REFIID iid, void **out)
  33 {
  34     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
  35
  36     if (IsEqualGUID(iid, &IID_ID2D1GradientStopCollection)
  37             || IsEqualGUID(iid, &IID_ID2D1Resource)
  38             || IsEqualGUID(iid, &IID_IUnknown))
  39     {
  40         ID2D1GradientStopCollection_AddRef(iface);
  41         *out = iface;
  42         return S_OK;
  43     }
  44
  45     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
  46
  47     *out = NULL;
  48     return E_NOINTERFACE;
  49 }
  50
  51 static ULONG STDMETHODCALLTYPE d2d_gradient_AddRef(ID2D1GradientStopCollection *iface)
  52 {
  53     struct d2d_gradient *gradient = impl_from_ID2D1GradientStopCollection(iface);
  54     ULONG refcount = InterlockedIncrement(&gradient->refcount);
  55
  56     TRACE("%p increasing refcount to %u.\n", iface, refcount);
  57
  58     return refcount;
  59 }
  60
  61 static ULONG STDMETHODCALLTYPE d2d_gradient_Release(ID2D1GradientStopCollection *iface)
  62 {
  63     struct d2d_gradient *gradient = impl_from_ID2D1GradientStopCollection(iface);
  64     ULONG refcount = InterlockedDecrement(&gradient->refcount);
  65
  66     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
  67
  68     if (!refcount)
  69     {
  70         HeapFree(GetProcessHeap(), 0, gradient->stops);
  71         HeapFree(GetProcessHeap(), 0, gradient);
  72     }
  73
  74     return refcount;
  75 }
  76
  77 static void STDMETHODCALLTYPE d2d_gradient_GetFactory(ID2D1GradientStopCollection *iface, ID2D1Factory **factory)
  78 {
  79     FIXME("iface %p, factory %p stub!\n", iface, factory);
  80
  81     *factory = NULL;
  82 }
  83
  84 static UINT32 STDMETHODCALLTYPE d2d_gradient_GetGradientStopCount(ID2D1GradientStopCollection *iface)
  85 {
  86     struct d2d_gradient *gradient = impl_from_ID2D1GradientStopCollection(iface);
  87
  88     TRACE("iface %p.\n", iface);
  89
  90     return gradient->stop_count;
  91 }
  92
  93 static void STDMETHODCALLTYPE d2d_gradient_GetGradientStops(ID2D1GradientStopCollection *iface,
  94         D2D1_GRADIENT_STOP *stops, UINT32 stop_count)
  95 {
  96     struct d2d_gradient *gradient = impl_from_ID2D1GradientStopCollection(iface);
  97
  98     TRACE("iface %p, stops %p, stop_count %u.\n", iface, stops, stop_count);
  99
 100     memcpy(stops, gradient->stops, min(gradient->stop_count, stop_count) * sizeof(*stops));
 101     if (stop_count > gradient->stop_count)
 102         memset(stops, 0, (stop_count - gradient->stop_count) * sizeof(*stops));
 103 }
 104
 105 static D2D1_GAMMA STDMETHODCALLTYPE d2d_gradient_GetColorInterpolationGamma(ID2D1GradientStopCollection *iface)
 106 {
 107     FIXME("iface %p stub!\n", iface);
 108
 109     return D2D1_GAMMA_1_0;
 110 }
 111
 112 static D2D1_EXTEND_MODE STDMETHODCALLTYPE d2d_gradient_GetExtendMode(ID2D1GradientStopCollection *iface)
 113 {
 114     FIXME("iface %p stub!\n", iface);
 115
 116     return D2D1_EXTEND_MODE_CLAMP;
 117 }
 118
 119 static const struct ID2D1GradientStopCollectionVtbl d2d_gradient_vtbl =
 120 {
 121     d2d_gradient_QueryInterface,
 122     d2d_gradient_AddRef,
 123     d2d_gradient_Release,
 124     d2d_gradient_GetFactory,
 125     d2d_gradient_GetGradientStopCount,
 126     d2d_gradient_GetGradientStops,
 127     d2d_gradient_GetColorInterpolationGamma,
 128     d2d_gradient_GetExtendMode,
 129 };
 130
 131 HRESULT d2d_gradient_init(struct d2d_gradient *gradient, ID2D1RenderTarget *render_target,
 132         const D2D1_GRADIENT_STOP *stops, UINT32 stop_count, D2D1_GAMMA gamma, D2D1_EXTEND_MODE extend_mode)
 133 {
 134     FIXME("Ignoring gradient properties.\n");
 135
 136     gradient->ID2D1GradientStopCollection_iface.lpVtbl = &d2d_gradient_vtbl;
 137     gradient->refcount = 1;
 138
 139     gradient->stop_count = stop_count;
 140     if (!(gradient->stops = HeapAlloc(GetProcessHeap(), 0, stop_count * sizeof(*stops))))
 141         return E_OUTOFMEMORY;
 142     memcpy(gradient->stops, stops, stop_count * sizeof(*stops));
 143
 144     return S_OK;
 145 }
 146
 147 static void d2d_brush_init(struct d2d_brush *brush, ID2D1RenderTarget *render_target,
 148         enum d2d_brush_type type, const D2D1_BRUSH_PROPERTIES *desc, const struct ID2D1BrushVtbl *vtbl)
 149 {
 150     static const D2D1_MATRIX_3X2_F identity =
 151     {
 152         1.0f, 0.0f,
 153         0.0f, 1.0f,
 154         0.0f, 0.0f,
 155     };
 156
 157     brush->ID2D1Brush_iface.lpVtbl = vtbl;
 158     brush->refcount = 1;
 159     brush->opacity = desc ? desc->opacity : 1.0f;
 160     brush->transform = desc ? desc->transform : identity;
 161     brush->type = type;
 162 }
 163
 164 static inline struct d2d_brush *impl_from_ID2D1SolidColorBrush(ID2D1SolidColorBrush *iface)
 165 {
 166     return CONTAINING_RECORD(iface, struct d2d_brush, ID2D1Brush_iface);
 167 }
 168
 169 static HRESULT STDMETHODCALLTYPE d2d_solid_color_brush_QueryInterface(ID2D1SolidColorBrush *iface,
 170         REFIID iid, void **out)
 171 {
 172     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 173
 174     if (IsEqualGUID(iid, &IID_ID2D1SolidColorBrush)
 175             || IsEqualGUID(iid, &IID_ID2D1Brush)
 176             || IsEqualGUID(iid, &IID_ID2D1Resource)
 177             || IsEqualGUID(iid, &IID_IUnknown))
 178     {
 179         ID2D1SolidColorBrush_AddRef(iface);
 180         *out = iface;
 181         return S_OK;
 182     }
 183
 184     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 185
 186     *out = NULL;
 187     return E_NOINTERFACE;
 188 }
 189
 190 static ULONG STDMETHODCALLTYPE d2d_solid_color_brush_AddRef(ID2D1SolidColorBrush *iface)
 191 {
 192     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 193     ULONG refcount = InterlockedIncrement(&brush->refcount);
 194
 195     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 196
 197     return refcount;
 198 }
 199
 200 static ULONG STDMETHODCALLTYPE d2d_solid_color_brush_Release(ID2D1SolidColorBrush *iface)
 201 {
 202     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 203     ULONG refcount = InterlockedDecrement(&brush->refcount);
 204
 205     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 206
 207     if (!refcount)
 208         HeapFree(GetProcessHeap(), 0, brush);
 209
 210     return refcount;
 211 }
 212
 213 static void STDMETHODCALLTYPE d2d_solid_color_brush_GetFactory(ID2D1SolidColorBrush *iface, ID2D1Factory **factory)
 214 {
 215     FIXME("iface %p, factory %p stub!\n", iface, factory);
 216
 217     *factory = NULL;
 218 }
 219
 220 static void STDMETHODCALLTYPE d2d_solid_color_brush_SetOpacity(ID2D1SolidColorBrush *iface, float opacity)
 221 {
 222     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 223
 224     TRACE("iface %p, opacity %.8e.\n", iface, opacity);
 225
 226     brush->opacity = opacity;
 227 }
 228
 229 static void STDMETHODCALLTYPE d2d_solid_color_brush_SetTransform(ID2D1SolidColorBrush *iface,
 230         const D2D1_MATRIX_3X2_F *transform)
 231 {
 232     FIXME("iface %p, transform %p stub!\n", iface, transform);
 233 }
 234
 235 static float STDMETHODCALLTYPE d2d_solid_color_brush_GetOpacity(ID2D1SolidColorBrush *iface)
 236 {
 237     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 238
 239     TRACE("iface %p.\n", iface);
 240
 241     return brush->opacity;
 242 }
 243
 244 static void STDMETHODCALLTYPE d2d_solid_color_brush_GetTransform(ID2D1SolidColorBrush *iface,
 245         D2D1_MATRIX_3X2_F *transform)
 246 {
 247     static const D2D1_MATRIX_3X2_F identity =
 248     {
 249         1.0f, 0.0f,
 250         0.0f, 1.0f,
 251         0.0f, 0.0f,
 252     };
 253
 254     FIXME("iface %p, transform %p stub!\n", iface, transform);
 255
 256     *transform = identity;
 257 }
 258
 259 static void STDMETHODCALLTYPE d2d_solid_color_brush_SetColor(ID2D1SolidColorBrush *iface, const D2D1_COLOR_F *color)
 260 {
 261     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 262
 263     TRACE("iface %p, color %p.\n", iface, color);
 264
 265     brush->u.solid.color = *color;
 266 }
 267
 268 static D2D1_COLOR_F * STDMETHODCALLTYPE d2d_solid_color_brush_GetColor(ID2D1SolidColorBrush *iface, D2D1_COLOR_F *color)
 269 {
 270     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 271
 272     TRACE("iface %p, color %p.\n", iface, color);
 273
 274     *color = brush->u.solid.color;
 275     return color;
 276 }
 277
 278 static const struct ID2D1SolidColorBrushVtbl d2d_solid_color_brush_vtbl =
 279 {
 280     d2d_solid_color_brush_QueryInterface,
 281     d2d_solid_color_brush_AddRef,
 282     d2d_solid_color_brush_Release,
 283     d2d_solid_color_brush_GetFactory,
 284     d2d_solid_color_brush_SetOpacity,
 285     d2d_solid_color_brush_SetTransform,
 286     d2d_solid_color_brush_GetOpacity,
 287     d2d_solid_color_brush_GetTransform,
 288     d2d_solid_color_brush_SetColor,
 289     d2d_solid_color_brush_GetColor,
 290 };
 291
 292 void d2d_solid_color_brush_init(struct d2d_brush *brush, ID2D1RenderTarget *render_target,
 293         const D2D1_COLOR_F *color, const D2D1_BRUSH_PROPERTIES *desc)
 294 {
 295     FIXME("Ignoring brush properties.\n");
 296
 297     d2d_brush_init(brush, render_target, D2D_BRUSH_TYPE_SOLID, desc,
 298             (ID2D1BrushVtbl *)&d2d_solid_color_brush_vtbl);
 299     brush->u.solid.color = *color;
 300 }
 301
 302 static inline struct d2d_brush *impl_from_ID2D1LinearGradientBrush(ID2D1LinearGradientBrush *iface)
 303 {
 304     return CONTAINING_RECORD(iface, struct d2d_brush, ID2D1Brush_iface);
 305 }
 306
 307 static HRESULT STDMETHODCALLTYPE d2d_linear_gradient_brush_QueryInterface(ID2D1LinearGradientBrush *iface,
 308         REFIID iid, void **out)
 309 {
 310     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 311
 312     if (IsEqualGUID(iid, &IID_ID2D1LinearGradientBrush)
 313             || IsEqualGUID(iid, &IID_ID2D1Brush)
 314             || IsEqualGUID(iid, &IID_ID2D1Resource)
 315             || IsEqualGUID(iid, &IID_IUnknown))
 316     {
 317         ID2D1LinearGradientBrush_AddRef(iface);
 318         *out = iface;
 319         return S_OK;
 320     }
 321
 322     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 323
 324     *out = NULL;
 325     return E_NOINTERFACE;
 326 }
 327
 328 static ULONG STDMETHODCALLTYPE d2d_linear_gradient_brush_AddRef(ID2D1LinearGradientBrush *iface)
 329 {
 330     struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface);
 331     ULONG refcount = InterlockedIncrement(&brush->refcount);
 332
 333     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 334
 335     return refcount;
 336 }
 337
 338 static ULONG STDMETHODCALLTYPE d2d_linear_gradient_brush_Release(ID2D1LinearGradientBrush *iface)
 339 {
 340     struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface);
 341     ULONG refcount = InterlockedDecrement(&brush->refcount);
 342
 343     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 344
 345     if (!refcount)
 346         HeapFree(GetProcessHeap(), 0, brush);
 347
 348     return refcount;
 349 }
 350
 351 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_GetFactory(ID2D1LinearGradientBrush *iface,
 352         ID2D1Factory **factory)
 353 {
 354     FIXME("iface %p, factory %p stub!\n", iface, factory);
 355
 356     *factory = NULL;
 357 }
 358
 359 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetOpacity(ID2D1LinearGradientBrush *iface, float opacity)
 360 {
 361     FIXME("iface %p, opacity %.8e stub!\n", iface, opacity);
 362 }
 363
 364 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetTransform(ID2D1LinearGradientBrush *iface,
 365         const D2D1_MATRIX_3X2_F *transform)
 366 {
 367     FIXME("iface %p, transform %p stub!\n", iface, transform);
 368 }
 369
 370 static float STDMETHODCALLTYPE d2d_linear_gradient_brush_GetOpacity(ID2D1LinearGradientBrush *iface)
 371 {
 372     FIXME("iface %p stub!\n", iface);
 373
 374     return 0.0f;
 375 }
 376
 377 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_GetTransform(ID2D1LinearGradientBrush *iface,
 378         D2D1_MATRIX_3X2_F *transform)
 379 {
 380     struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface);
 381
 382     TRACE("iface %p, transform %p.\n", iface, transform);
 383
 384     *transform = brush->transform;
 385 }
 386
 387 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetStartPoint(ID2D1LinearGradientBrush *iface,
 388         D2D1_POINT_2F start_point)
 389 {
 390     FIXME("iface %p, start_point {%.8e, %.8e} stub!\n", iface, start_point.x, start_point.y);
 391 }
 392
 393 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetEndPoint(ID2D1LinearGradientBrush *iface,
 394         D2D1_POINT_2F end_point)
 395 {
 396     FIXME("iface %p, end_point {%.8e, %.8e} stub!\n", iface, end_point.x, end_point.y);
 397 }
 398
 399 static D2D1_POINT_2F * STDMETHODCALLTYPE d2d_linear_gradient_brush_GetStartPoint(ID2D1LinearGradientBrush *iface,
 400         D2D1_POINT_2F *point)
 401 {
 402     FIXME("iface %p, point %p stub!\n", iface, point);
 403
 404     point->x = 0.0f;
 405     point->y = 0.0f;
 406     return point;
 407 }
 408
 409 static D2D1_POINT_2F * STDMETHODCALLTYPE d2d_linear_gradient_brush_GetEndPoint(ID2D1LinearGradientBrush *iface,
 410         D2D1_POINT_2F *point)
 411 {
 412     FIXME("iface %p, point %p stub!\n", iface, point);
 413
 414     point->x = 0.0f;
 415     point->y = 0.0f;
 416     return point;
 417 }
 418
 419 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_GetGradientStopCollection(ID2D1LinearGradientBrush *iface,
 420         ID2D1GradientStopCollection **gradient)
 421 {
 422     FIXME("iface %p, gradient %p stub!\n", iface, gradient);
 423
 424     *gradient = NULL;
 425 }
 426
 427 static const struct ID2D1LinearGradientBrushVtbl d2d_linear_gradient_brush_vtbl =
 428 {
 429     d2d_linear_gradient_brush_QueryInterface,
 430     d2d_linear_gradient_brush_AddRef,
 431     d2d_linear_gradient_brush_Release,
 432     d2d_linear_gradient_brush_GetFactory,
 433     d2d_linear_gradient_brush_SetOpacity,
 434     d2d_linear_gradient_brush_SetTransform,
 435     d2d_linear_gradient_brush_GetOpacity,
 436     d2d_linear_gradient_brush_GetTransform,
 437     d2d_linear_gradient_brush_SetStartPoint,
 438     d2d_linear_gradient_brush_SetEndPoint,
 439     d2d_linear_gradient_brush_GetStartPoint,
 440     d2d_linear_gradient_brush_GetEndPoint,
 441     d2d_linear_gradient_brush_GetGradientStopCollection,
 442 };
 443
 444 void d2d_linear_gradient_brush_init(struct d2d_brush *brush, ID2D1RenderTarget *render_target,
 445         const D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES *gradient_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc,
 446         ID2D1GradientStopCollection *gradient)
 447 {
 448     FIXME("Ignoring brush properties.\n");
 449
 450     d2d_brush_init(brush, render_target, D2D_BRUSH_TYPE_LINEAR, brush_desc,
 451             (ID2D1BrushVtbl *)&d2d_linear_gradient_brush_vtbl);
 452 }
 453
 454 static inline struct d2d_brush *impl_from_ID2D1BitmapBrush(ID2D1BitmapBrush *iface)
 455 {
 456     return CONTAINING_RECORD(iface, struct d2d_brush, ID2D1Brush_iface);
 457 }
 458
 459 static HRESULT STDMETHODCALLTYPE d2d_bitmap_brush_QueryInterface(ID2D1BitmapBrush *iface,
 460         REFIID iid, void **out)
 461 {
 462     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 463
 464     if (IsEqualGUID(iid, &IID_ID2D1BitmapBrush)
 465             || IsEqualGUID(iid, &IID_ID2D1Brush)
 466             || IsEqualGUID(iid, &IID_ID2D1Resource)
 467             || IsEqualGUID(iid, &IID_IUnknown))
 468     {
 469         ID2D1BitmapBrush_AddRef(iface);
 470         *out = iface;
 471         return S_OK;
 472     }
 473
 474     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 475
 476     *out = NULL;
 477     return E_NOINTERFACE;
 478 }
 479
 480 static ULONG STDMETHODCALLTYPE d2d_bitmap_brush_AddRef(ID2D1BitmapBrush *iface)
 481 {
 482     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 483     ULONG refcount = InterlockedIncrement(&brush->refcount);
 484
 485     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 486
 487     return refcount;
 488 }
 489
 490 static ULONG STDMETHODCALLTYPE d2d_bitmap_brush_Release(ID2D1BitmapBrush *iface)
 491 {
 492     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 493     ULONG refcount = InterlockedDecrement(&brush->refcount);
 494
 495     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 496
 497     if (!refcount)
 498         HeapFree(GetProcessHeap(), 0, brush);
 499
 500     return refcount;
 501 }
 502
 503 static void STDMETHODCALLTYPE d2d_bitmap_brush_GetFactory(ID2D1BitmapBrush *iface,
 504         ID2D1Factory **factory)
 505 {
 506     FIXME("iface %p, factory %p stub!\n", iface, factory);
 507
 508     *factory = NULL;
 509 }
 510
 511 static void STDMETHODCALLTYPE d2d_bitmap_brush_SetOpacity(ID2D1BitmapBrush *iface, float opacity)
 512 {
 513     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 514
 515     TRACE("iface %p, opacity %.8e.\n", iface, opacity);
 516
 517     brush->opacity = opacity;
 518 }
 519
 520 static void STDMETHODCALLTYPE d2d_bitmap_brush_SetTransform(ID2D1BitmapBrush *iface,
 521         const D2D1_MATRIX_3X2_F *transform)
 522 {
 523     FIXME("iface %p, transform %p stub!\n", iface, transform);
 524 }
 525
 526 static float STDMETHODCALLTYPE d2d_bitmap_brush_GetOpacity(ID2D1BitmapBrush *iface)
 527 {
 528     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 529
 530     TRACE("iface %p.\n", iface);
 531
 532     return brush->opacity;
 533 }
 534
 535 static void STDMETHODCALLTYPE d2d_bitmap_brush_GetTransform(ID2D1BitmapBrush *iface,
 536         D2D1_MATRIX_3X2_F *transform)
 537 {
 538     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 539
 540     TRACE("iface %p, transform %p.\n", iface, transform);
 541
 542     *transform = brush->transform;
 543 }
 544
 545 static void STDMETHODCALLTYPE d2d_bitmap_brush_SetExtendModeX(ID2D1BitmapBrush *iface, D2D1_EXTEND_MODE mode)
 546 {
 547     FIXME("iface %p, mode %#x stub!\n", iface, mode);
 548 }
 549
 550 static void STDMETHODCALLTYPE d2d_bitmap_brush_SetExtendModeY(ID2D1BitmapBrush *iface, D2D1_EXTEND_MODE mode)
 551 {
 552     FIXME("iface %p, mode %#x stub!\n", iface, mode);
 553 }
 554
 555 static void STDMETHODCALLTYPE d2d_bitmap_brush_SetInterpolationMode(ID2D1BitmapBrush *iface,
 556         D2D1_BITMAP_INTERPOLATION_MODE mode)
 557 {
 558     FIXME("iface %p, mode %#x stub!\n", iface, mode);
 559 }
 560
 561 static void STDMETHODCALLTYPE d2d_bitmap_brush_SetBitmap(ID2D1BitmapBrush *iface, ID2D1Bitmap *bitmap)
 562 {
 563     FIXME("iface %p, bitmap %p stub!\n", iface, bitmap);
 564 }
 565
 566 static D2D1_EXTEND_MODE STDMETHODCALLTYPE d2d_bitmap_brush_GetExtendModeX(ID2D1BitmapBrush *iface)
 567 {
 568     FIXME("iface %p stub!\n", iface);
 569
 570     return D2D1_EXTEND_MODE_CLAMP;
 571 }
 572
 573 static D2D1_EXTEND_MODE STDMETHODCALLTYPE d2d_bitmap_brush_GetExtendModeY(ID2D1BitmapBrush *iface)
 574 {
 575     FIXME("iface %p stub!\n", iface);
 576
 577     return D2D1_EXTEND_MODE_CLAMP;
 578 }
 579
 580 static D2D1_BITMAP_INTERPOLATION_MODE STDMETHODCALLTYPE d2d_bitmap_brush_GetInterpolationMode(ID2D1BitmapBrush *iface)
 581 {
 582     FIXME("iface %p stub!\n", iface);
 583
 584     return D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR;
 585 }
 586
 587 static void STDMETHODCALLTYPE d2d_bitmap_brush_GetBitmap(ID2D1BitmapBrush *iface, ID2D1Bitmap **bitmap)
 588 {
 589     FIXME("iface %p, bitmap %p stub!\n", iface, bitmap);
 590 }
 591
 592 static const struct ID2D1BitmapBrushVtbl d2d_bitmap_brush_vtbl =
 593 {
 594     d2d_bitmap_brush_QueryInterface,
 595     d2d_bitmap_brush_AddRef,
 596     d2d_bitmap_brush_Release,
 597     d2d_bitmap_brush_GetFactory,
 598     d2d_bitmap_brush_SetOpacity,
 599     d2d_bitmap_brush_SetTransform,
 600     d2d_bitmap_brush_GetOpacity,
 601     d2d_bitmap_brush_GetTransform,
 602     d2d_bitmap_brush_SetExtendModeX,
 603     d2d_bitmap_brush_SetExtendModeY,
 604     d2d_bitmap_brush_SetInterpolationMode,
 605     d2d_bitmap_brush_SetBitmap,
 606     d2d_bitmap_brush_GetExtendModeX,
 607     d2d_bitmap_brush_GetExtendModeY,
 608     d2d_bitmap_brush_GetInterpolationMode,
 609     d2d_bitmap_brush_GetBitmap,
 610 };
 611
 612 void d2d_bitmap_brush_init(struct d2d_brush *brush, ID2D1RenderTarget *render_target, const ID2D1Bitmap *bitmap,
 613         const D2D1_BITMAP_BRUSH_PROPERTIES *bitmap_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc)
 614 {
 615     FIXME("Ignoring brush properties.\n");
 616
 617     d2d_brush_init(brush, render_target, D2D_BRUSH_TYPE_BITMAP, brush_desc,
 618             (ID2D1BrushVtbl *)&d2d_bitmap_brush_vtbl);
 619 }
 620
 621 struct d2d_brush *unsafe_impl_from_ID2D1Brush(ID2D1Brush *iface)
 622 {
 623     if (!iface)
 624         return NULL;
 625     assert(iface->lpVtbl == (const ID2D1BrushVtbl *)&d2d_solid_color_brush_vtbl
 626             || iface->lpVtbl == (const ID2D1BrushVtbl *)&d2d_linear_gradient_brush_vtbl
 627             || iface->lpVtbl == (const ID2D1BrushVtbl *)&d2d_bitmap_brush_vtbl);
 628     return CONTAINING_RECORD(iface, struct d2d_brush, ID2D1Brush_iface);
 629 }