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, D2D1_COLOR_F *color)
 231 {
 232     static const D2D1_COLOR_F black = {0.0f, 0.0f, 0.0f, 1.0f};
 233
 234     FIXME("iface %p, color %p stub!\n", iface, color);
 235
 236     *color = black;
 237     return color;
 238 }
 239
 240 static const struct ID2D1SolidColorBrushVtbl d2d_solid_color_brush_vtbl =
 241 {
 242     d2d_solid_color_brush_QueryInterface,
 243     d2d_solid_color_brush_AddRef,
 244     d2d_solid_color_brush_Release,
 245     d2d_solid_color_brush_GetFactory,
 246     d2d_solid_color_brush_SetOpacity,
 247     d2d_solid_color_brush_SetTransform,
 248     d2d_solid_color_brush_GetOpacity,
 249     d2d_solid_color_brush_GetTransform,
 250     d2d_solid_color_brush_SetColor,
 251     d2d_solid_color_brush_GetColor,
 252 };
 253
 254 void d2d_solid_color_brush_init(struct d2d_brush *brush, ID2D1RenderTarget *render_target,
 255         const D2D1_COLOR_F *color, const D2D1_BRUSH_PROPERTIES *desc)
 256 {
 257     FIXME("Ignoring brush properties.\n");
 258
 259     d2d_brush_init(brush, render_target, desc, (ID2D1BrushVtbl *)&d2d_solid_color_brush_vtbl);
 260 }
 261
 262 static inline struct d2d_brush *impl_from_ID2D1LinearGradientBrush(ID2D1LinearGradientBrush *iface)
 263 {
 264     return CONTAINING_RECORD(iface, struct d2d_brush, ID2D1Brush_iface);
 265 }
 266
 267 static HRESULT STDMETHODCALLTYPE d2d_linear_gradient_brush_QueryInterface(ID2D1LinearGradientBrush *iface,
 268         REFIID iid, void **out)
 269 {
 270     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 271
 272     if (IsEqualGUID(iid, &IID_ID2D1LinearGradientBrush)
 273             || IsEqualGUID(iid, &IID_ID2D1Brush)
 274             || IsEqualGUID(iid, &IID_ID2D1Resource)
 275             || IsEqualGUID(iid, &IID_IUnknown))
 276     {
 277         ID2D1LinearGradientBrush_AddRef(iface);
 278         *out = iface;
 279         return S_OK;
 280     }
 281
 282     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 283
 284     *out = NULL;
 285     return E_NOINTERFACE;
 286 }
 287
 288 static ULONG STDMETHODCALLTYPE d2d_linear_gradient_brush_AddRef(ID2D1LinearGradientBrush *iface)
 289 {
 290     struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface);
 291     ULONG refcount = InterlockedIncrement(&brush->refcount);
 292
 293     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 294
 295     return refcount;
 296 }
 297
 298 static ULONG STDMETHODCALLTYPE d2d_linear_gradient_brush_Release(ID2D1LinearGradientBrush *iface)
 299 {
 300     struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface);
 301     ULONG refcount = InterlockedDecrement(&brush->refcount);
 302
 303     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 304
 305     if (!refcount)
 306         HeapFree(GetProcessHeap(), 0, brush);
 307
 308     return refcount;
 309 }
 310
 311 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_GetFactory(ID2D1LinearGradientBrush *iface,
 312         ID2D1Factory **factory)
 313 {
 314     FIXME("iface %p, factory %p stub!\n", iface, factory);
 315
 316     *factory = NULL;
 317 }
 318
 319 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetOpacity(ID2D1LinearGradientBrush *iface, float opacity)
 320 {
 321     FIXME("iface %p, opacity %.8e stub!\n", iface, opacity);
 322 }
 323
 324 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetTransform(ID2D1LinearGradientBrush *iface,
 325         const D2D1_MATRIX_3X2_F *transform)
 326 {
 327     FIXME("iface %p, transform %p stub!\n", iface, transform);
 328 }
 329
 330 static float STDMETHODCALLTYPE d2d_linear_gradient_brush_GetOpacity(ID2D1LinearGradientBrush *iface)
 331 {
 332     FIXME("iface %p stub!\n", iface);
 333
 334     return 0.0f;
 335 }
 336
 337 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_GetTransform(ID2D1LinearGradientBrush *iface,
 338         D2D1_MATRIX_3X2_F *transform)
 339 {
 340     static const D2D1_MATRIX_3X2_F identity =
 341     {
 342         1.0f, 0.0f,
 343         0.0f, 1.0f,
 344         0.0f, 0.0f,
 345     };
 346
 347     FIXME("iface %p, transform %p stub!\n", iface, transform);
 348
 349     *transform = identity;
 350 }
 351
 352 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetStartPoint(ID2D1LinearGradientBrush *iface,
 353         D2D1_POINT_2F start_point)
 354 {
 355     FIXME("iface %p, start_point {%.8e, %.8e} stub!\n", iface, start_point.x, start_point.y);
 356 }
 357
 358 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetEndPoint(ID2D1LinearGradientBrush *iface,
 359         D2D1_POINT_2F end_point)
 360 {
 361     FIXME("iface %p, end_point {%.8e, %.8e} stub!\n", iface, end_point.x, end_point.y);
 362 }
 363
 364 static D2D1_POINT_2F * STDMETHODCALLTYPE d2d_linear_gradient_brush_GetStartPoint(ID2D1LinearGradientBrush *iface,
 365         D2D1_POINT_2F *point)
 366 {
 367     FIXME("iface %p, point %p stub!\n", iface, point);
 368
 369     point->x = 0.0f;
 370     point->y = 0.0f;
 371     return point;
 372 }
 373
 374 static D2D1_POINT_2F * STDMETHODCALLTYPE d2d_linear_gradient_brush_GetEndPoint(ID2D1LinearGradientBrush *iface,
 375         D2D1_POINT_2F *point)
 376 {
 377     FIXME("iface %p, point %p stub!\n", iface, point);
 378
 379     point->x = 0.0f;
 380     point->y = 0.0f;
 381     return point;
 382 }
 383
 384 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_GetGradientStopCollection(ID2D1LinearGradientBrush *iface,
 385         ID2D1GradientStopCollection **gradient)
 386 {
 387     FIXME("iface %p, gradient %p stub!\n", iface, gradient);
 388
 389     *gradient = NULL;
 390 }
 391
 392 static const struct ID2D1LinearGradientBrushVtbl d2d_linear_gradient_brush_vtbl =
 393 {
 394     d2d_linear_gradient_brush_QueryInterface,
 395     d2d_linear_gradient_brush_AddRef,
 396     d2d_linear_gradient_brush_Release,
 397     d2d_linear_gradient_brush_GetFactory,
 398     d2d_linear_gradient_brush_SetOpacity,
 399     d2d_linear_gradient_brush_SetTransform,
 400     d2d_linear_gradient_brush_GetOpacity,
 401     d2d_linear_gradient_brush_GetTransform,
 402     d2d_linear_gradient_brush_SetStartPoint,
 403     d2d_linear_gradient_brush_SetEndPoint,
 404     d2d_linear_gradient_brush_GetStartPoint,
 405     d2d_linear_gradient_brush_GetEndPoint,
 406     d2d_linear_gradient_brush_GetGradientStopCollection,
 407 };
 408
 409 void d2d_linear_gradient_brush_init(struct d2d_brush *brush, ID2D1RenderTarget *render_target,
 410         const D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES *gradient_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc,
 411         ID2D1GradientStopCollection *gradient)
 412 {
 413     FIXME("Ignoring brush properties.\n");
 414
 415     d2d_brush_init(brush, render_target, brush_desc, (ID2D1BrushVtbl *)&d2d_solid_color_brush_vtbl);
 416 }