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         HeapFree(GetProcessHeap(), 0, gradient);
  70
  71     return refcount;
  72 }
  73
  74 static void STDMETHODCALLTYPE d2d_gradient_GetFactory(ID2D1GradientStopCollection *iface, ID2D1Factory **factory)
  75 {
  76     FIXME("iface %p, factory %p stub!\n", iface, factory);
  77
  78     *factory = NULL;
  79 }
  80
  81 static UINT32 STDMETHODCALLTYPE d2d_gradient_GetGradientStopCount(ID2D1GradientStopCollection *iface)
  82 {
  83     FIXME("iface %p stub!\n", iface);
  84
  85     return 0;
  86 }
  87
  88 static void STDMETHODCALLTYPE d2d_gradient_GetGradientStops(ID2D1GradientStopCollection *iface,
  89         D2D1_GRADIENT_STOP *stops, UINT32 stop_count)
  90 {
  91     FIXME("iface %p, stops %p, stop_count %u stub!\n", iface, stops, stop_count);
  92 }
  93
  94 static D2D1_GAMMA STDMETHODCALLTYPE d2d_gradient_GetColorInterpolationGamma(ID2D1GradientStopCollection *iface)
  95 {
  96     FIXME("iface %p stub!\n", iface);
  97
  98     return D2D1_GAMMA_1_0;
  99 }
 100
 101 static D2D1_EXTEND_MODE STDMETHODCALLTYPE d2d_gradient_GetExtendMode(ID2D1GradientStopCollection *iface)
 102 {
 103     FIXME("iface %p stub!\n", iface);
 104
 105     return D2D1_EXTEND_MODE_CLAMP;
 106 }
 107
 108 static const struct ID2D1GradientStopCollectionVtbl d2d_gradient_vtbl =
 109 {
 110     d2d_gradient_QueryInterface,
 111     d2d_gradient_AddRef,
 112     d2d_gradient_Release,
 113     d2d_gradient_GetFactory,
 114     d2d_gradient_GetGradientStopCount,
 115     d2d_gradient_GetGradientStops,
 116     d2d_gradient_GetColorInterpolationGamma,
 117     d2d_gradient_GetExtendMode,
 118 };
 119
 120 void d2d_gradient_init(struct d2d_gradient *gradient, ID2D1RenderTarget *render_target,
 121         const D2D1_GRADIENT_STOP *stops, UINT32 stop_count, D2D1_GAMMA gamma, D2D1_EXTEND_MODE extend_mode)
 122 {
 123     FIXME("Ignoring gradient properties.\n");
 124
 125     gradient->ID2D1GradientStopCollection_iface.lpVtbl = &d2d_gradient_vtbl;
 126     gradient->refcount = 1;
 127 }
 128
 129 static void d2d_brush_init(struct d2d_brush *brush, ID2D1RenderTarget *render_target,
 130         const D2D1_BRUSH_PROPERTIES *desc, const struct ID2D1BrushVtbl *vtbl)
 131 {
 132     brush->ID2D1Brush_iface.lpVtbl = vtbl;
 133     brush->refcount = 1;
 134 }
 135
 136 static inline struct d2d_brush *impl_from_ID2D1SolidColorBrush(ID2D1SolidColorBrush *iface)
 137 {
 138     return CONTAINING_RECORD(iface, struct d2d_brush, ID2D1Brush_iface);
 139 }
 140
 141 static HRESULT STDMETHODCALLTYPE d2d_solid_color_brush_QueryInterface(ID2D1SolidColorBrush *iface,
 142         REFIID iid, void **out)
 143 {
 144     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 145
 146     if (IsEqualGUID(iid, &IID_ID2D1SolidColorBrush)
 147             || IsEqualGUID(iid, &IID_ID2D1Brush)
 148             || IsEqualGUID(iid, &IID_ID2D1Resource)
 149             || IsEqualGUID(iid, &IID_IUnknown))
 150     {
 151         ID2D1SolidColorBrush_AddRef(iface);
 152         *out = iface;
 153         return S_OK;
 154     }
 155
 156     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 157
 158     *out = NULL;
 159     return E_NOINTERFACE;
 160 }
 161
 162 static ULONG STDMETHODCALLTYPE d2d_solid_color_brush_AddRef(ID2D1SolidColorBrush *iface)
 163 {
 164     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 165     ULONG refcount = InterlockedIncrement(&brush->refcount);
 166
 167     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 168
 169     return refcount;
 170 }
 171
 172 static ULONG STDMETHODCALLTYPE d2d_solid_color_brush_Release(ID2D1SolidColorBrush *iface)
 173 {
 174     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 175     ULONG refcount = InterlockedDecrement(&brush->refcount);
 176
 177     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 178
 179     if (!refcount)
 180         HeapFree(GetProcessHeap(), 0, brush);
 181
 182     return refcount;
 183 }
 184
 185 static void STDMETHODCALLTYPE d2d_solid_color_brush_GetFactory(ID2D1SolidColorBrush *iface, ID2D1Factory **factory)
 186 {
 187     FIXME("iface %p, factory %p stub!\n", iface, factory);
 188
 189     *factory = NULL;
 190 }
 191
 192 static void STDMETHODCALLTYPE d2d_solid_color_brush_SetOpacity(ID2D1SolidColorBrush *iface, float opacity)
 193 {
 194     FIXME("iface %p, opacity %.8e stub!\n", iface, opacity);
 195 }
 196
 197 static void STDMETHODCALLTYPE d2d_solid_color_brush_SetTransform(ID2D1SolidColorBrush *iface,
 198         const D2D1_MATRIX_3X2_F *transform)
 199 {
 200     FIXME("iface %p, transform %p stub!\n", iface, transform);
 201 }
 202
 203 static float STDMETHODCALLTYPE d2d_solid_color_brush_GetOpacity(ID2D1SolidColorBrush *iface)
 204 {
 205     FIXME("iface %p stub!\n", iface);
 206
 207     return 0.0f;
 208 }
 209
 210 static void STDMETHODCALLTYPE d2d_solid_color_brush_GetTransform(ID2D1SolidColorBrush *iface,
 211         D2D1_MATRIX_3X2_F *transform)
 212 {
 213     static const D2D1_MATRIX_3X2_F identity =
 214     {
 215         1.0f, 0.0f,
 216         0.0f, 1.0f,
 217         0.0f, 0.0f,
 218     };
 219
 220     FIXME("iface %p, transform %p stub!\n", iface, transform);
 221
 222     *transform = identity;
 223 }
 224
 225 static void STDMETHODCALLTYPE d2d_solid_color_brush_SetColor(ID2D1SolidColorBrush *iface, const D2D1_COLOR_F *color)
 226 {
 227     FIXME("iface %p, color %p stub!\n", iface, color);
 228 }
 229
 230 static D2D1_COLOR_F STDMETHODCALLTYPE d2d_solid_color_brush_GetColor(ID2D1SolidColorBrush *iface)
 231 {
 232     static const D2D1_COLOR_F black = {0.0f, 0.0f, 0.0f, 1.0f};
 233
 234     FIXME("iface %p stub!\n", iface);
 235
 236     return black;
 237 }
 238
 239 static const struct ID2D1SolidColorBrushVtbl d2d_solid_color_brush_vtbl =
 240 {
 241     d2d_solid_color_brush_QueryInterface,
 242     d2d_solid_color_brush_AddRef,
 243     d2d_solid_color_brush_Release,
 244     d2d_solid_color_brush_GetFactory,
 245     d2d_solid_color_brush_SetOpacity,
 246     d2d_solid_color_brush_SetTransform,
 247     d2d_solid_color_brush_GetOpacity,
 248     d2d_solid_color_brush_GetTransform,
 249     d2d_solid_color_brush_SetColor,
 250     d2d_solid_color_brush_GetColor,
 251 };
 252
 253 void d2d_solid_color_brush_init(struct d2d_brush *brush, ID2D1RenderTarget *render_target,
 254         const D2D1_COLOR_F *color, const D2D1_BRUSH_PROPERTIES *desc)
 255 {
 256     FIXME("Ignoring brush properties.\n");
 257
 258     d2d_brush_init(brush, render_target, desc, (ID2D1BrushVtbl *)&d2d_solid_color_brush_vtbl);
 259 }
 260
 261 static inline struct d2d_brush *impl_from_ID2D1LinearGradientBrush(ID2D1LinearGradientBrush *iface)
 262 {
 263     return CONTAINING_RECORD(iface, struct d2d_brush, ID2D1Brush_iface);
 264 }
 265
 266 static HRESULT STDMETHODCALLTYPE d2d_linear_gradient_brush_QueryInterface(ID2D1LinearGradientBrush *iface,
 267         REFIID iid, void **out)
 268 {
 269     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 270
 271     if (IsEqualGUID(iid, &IID_ID2D1LinearGradientBrush)
 272             || IsEqualGUID(iid, &IID_ID2D1Brush)
 273             || IsEqualGUID(iid, &IID_ID2D1Resource)
 274             || IsEqualGUID(iid, &IID_IUnknown))
 275     {
 276         ID2D1LinearGradientBrush_AddRef(iface);
 277         *out = iface;
 278         return S_OK;
 279     }
 280
 281     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 282
 283     *out = NULL;
 284     return E_NOINTERFACE;
 285 }
 286
 287 static ULONG STDMETHODCALLTYPE d2d_linear_gradient_brush_AddRef(ID2D1LinearGradientBrush *iface)
 288 {
 289     struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface);
 290     ULONG refcount = InterlockedIncrement(&brush->refcount);
 291
 292     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 293
 294     return refcount;
 295 }
 296
 297 static ULONG STDMETHODCALLTYPE d2d_linear_gradient_brush_Release(ID2D1LinearGradientBrush *iface)
 298 {
 299     struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface);
 300     ULONG refcount = InterlockedDecrement(&brush->refcount);
 301
 302     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 303
 304     if (!refcount)
 305         HeapFree(GetProcessHeap(), 0, brush);
 306
 307     return refcount;
 308 }
 309
 310 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_GetFactory(ID2D1LinearGradientBrush *iface,
 311         ID2D1Factory **factory)
 312 {
 313     FIXME("iface %p, factory %p stub!\n", iface, factory);
 314
 315     *factory = NULL;
 316 }
 317
 318 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetOpacity(ID2D1LinearGradientBrush *iface, float opacity)
 319 {
 320     FIXME("iface %p, opacity %.8e stub!\n", iface, opacity);
 321 }
 322
 323 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetTransform(ID2D1LinearGradientBrush *iface,
 324         const D2D1_MATRIX_3X2_F *transform)
 325 {
 326     FIXME("iface %p, transform %p stub!\n", iface, transform);
 327 }
 328
 329 static float STDMETHODCALLTYPE d2d_linear_gradient_brush_GetOpacity(ID2D1LinearGradientBrush *iface)
 330 {
 331     FIXME("iface %p stub!\n", iface);
 332
 333     return 0.0f;
 334 }
 335
 336 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_GetTransform(ID2D1LinearGradientBrush *iface,
 337         D2D1_MATRIX_3X2_F *transform)
 338 {
 339     static const D2D1_MATRIX_3X2_F identity =
 340     {
 341         1.0f, 0.0f,
 342         0.0f, 1.0f,
 343         0.0f, 0.0f,
 344     };
 345
 346     FIXME("iface %p, transform %p stub!\n", iface, transform);
 347
 348     *transform = identity;
 349 }
 350
 351 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetStartPoint(ID2D1LinearGradientBrush *iface,
 352         D2D1_POINT_2F start_point)
 353 {
 354     FIXME("iface %p, start_point {%.8e, %.8e} stub!\n", iface, start_point.x, start_point.y);
 355 }
 356
 357 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetEndPoint(ID2D1LinearGradientBrush *iface,
 358         D2D1_POINT_2F end_point)
 359 {
 360     FIXME("iface %p, end_point {%.8e, %.8e} stub!\n", iface, end_point.x, end_point.y);
 361 }
 362
 363 static D2D1_POINT_2F STDMETHODCALLTYPE d2d_linear_gradient_brush_GetStartPoint(ID2D1LinearGradientBrush *iface)
 364 {
 365     static const D2D1_POINT_2F point = {0.0f, 0.0f};
 366
 367     FIXME("iface %p stub!\n", iface);
 368
 369     return point;
 370 }
 371
 372 static D2D1_POINT_2F STDMETHODCALLTYPE d2d_linear_gradient_brush_GetEndPoint(ID2D1LinearGradientBrush *iface)
 373 {
 374     static const D2D1_POINT_2F point = {0.0f, 0.0f};
 375
 376     FIXME("iface %p stub!\n", iface);
 377
 378     return point;
 379 }
 380
 381 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_GetGradientStopCollection(ID2D1LinearGradientBrush *iface,
 382         ID2D1GradientStopCollection **gradient)
 383 {
 384     FIXME("iface %p, gradient %p stub!\n", iface, gradient);
 385
 386     *gradient = NULL;
 387 }
 388
 389 static const struct ID2D1LinearGradientBrushVtbl d2d_linear_gradient_brush_vtbl =
 390 {
 391     d2d_linear_gradient_brush_QueryInterface,
 392     d2d_linear_gradient_brush_AddRef,
 393     d2d_linear_gradient_brush_Release,
 394     d2d_linear_gradient_brush_GetFactory,
 395     d2d_linear_gradient_brush_SetOpacity,
 396     d2d_linear_gradient_brush_SetTransform,
 397     d2d_linear_gradient_brush_GetOpacity,
 398     d2d_linear_gradient_brush_GetTransform,
 399     d2d_linear_gradient_brush_SetStartPoint,
 400     d2d_linear_gradient_brush_SetEndPoint,
 401     d2d_linear_gradient_brush_GetStartPoint,
 402     d2d_linear_gradient_brush_GetEndPoint,
 403     d2d_linear_gradient_brush_GetGradientStopCollection,
 404 };
 405
 406 void d2d_linear_gradient_brush_init(struct d2d_brush *brush, ID2D1RenderTarget *render_target,
 407         const D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES *gradient_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc,
 408         ID2D1GradientStopCollection *gradient)
 409 {
 410     FIXME("Ignoring brush properties.\n");
 411
 412     d2d_brush_init(brush, render_target, brush_desc, (ID2D1BrushVtbl *)&d2d_solid_color_brush_vtbl);
 413 }