dlls/d2d1/geometry.c

   1 /*
   2  * Copyright 2015 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_geometry *impl_from_ID2D1GeometrySink(ID2D1GeometrySink *iface)
  27 {
  28     return CONTAINING_RECORD(iface, struct d2d_geometry, ID2D1GeometrySink_iface);
  29 }
  30
  31 static HRESULT STDMETHODCALLTYPE d2d_geometry_sink_QueryInterface(ID2D1GeometrySink *iface, REFIID iid, void **out)
  32 {
  33     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
  34
  35     if (IsEqualGUID(iid, &IID_ID2D1GeometrySink)
  36             || IsEqualGUID(iid, &IID_ID2D1SimplifiedGeometrySink)
  37             || IsEqualGUID(iid, &IID_IUnknown))
  38     {
  39         ID2D1GeometrySink_AddRef(iface);
  40         *out = iface;
  41         return S_OK;
  42     }
  43
  44     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
  45
  46     *out = NULL;
  47     return E_NOINTERFACE;
  48 }
  49
  50 static ULONG STDMETHODCALLTYPE d2d_geometry_sink_AddRef(ID2D1GeometrySink *iface)
  51 {
  52     struct d2d_geometry *geometry = impl_from_ID2D1GeometrySink(iface);
  53
  54     TRACE("iface %p.\n", iface);
  55
  56     return ID2D1Geometry_AddRef(&geometry->ID2D1Geometry_iface);
  57 }
  58
  59 static ULONG STDMETHODCALLTYPE d2d_geometry_sink_Release(ID2D1GeometrySink *iface)
  60 {
  61     struct d2d_geometry *geometry = impl_from_ID2D1GeometrySink(iface);
  62
  63     TRACE("iface %p.\n", iface);
  64
  65     return ID2D1Geometry_Release(&geometry->ID2D1Geometry_iface);
  66 }
  67
  68 static void STDMETHODCALLTYPE d2d_geometry_sink_SetFillMode(ID2D1GeometrySink *iface, D2D1_FILL_MODE mode)
  69 {
  70     FIXME("iface %p, mode %#x stub!\n", iface, mode);
  71 }
  72
  73 static void STDMETHODCALLTYPE d2d_geometry_sink_SetSegmentFlags(ID2D1GeometrySink *iface, D2D1_PATH_SEGMENT flags)
  74 {
  75     FIXME("iface %p, flags %#x stub!\n", iface, flags);
  76 }
  77
  78 static void STDMETHODCALLTYPE d2d_geometry_sink_BeginFigure(ID2D1GeometrySink *iface,
  79         D2D1_POINT_2F start_point, D2D1_FIGURE_BEGIN figure_begin)
  80 {
  81     FIXME("iface %p, start_point {%.8e, %.8e}, figure_begin %#x stub!\n",
  82             iface, start_point.x, start_point.y, figure_begin);
  83 }
  84
  85 static void STDMETHODCALLTYPE d2d_geometry_sink_AddLines(ID2D1GeometrySink *iface,
  86         const D2D1_POINT_2F *points, UINT32 count)
  87 {
  88     FIXME("iface %p, points %p, count %u stub!\n", iface, points, count);
  89 }
  90
  91 static void STDMETHODCALLTYPE d2d_geometry_sink_AddBeziers(ID2D1GeometrySink *iface,
  92         const D2D1_BEZIER_SEGMENT *beziers, UINT32 count)
  93 {
  94     FIXME("iface %p, beziers %p, count %u stub!\n", iface, beziers, count);
  95 }
  96
  97 static void STDMETHODCALLTYPE d2d_geometry_sink_EndFigure(ID2D1GeometrySink *iface, D2D1_FIGURE_END figure_end)
  98 {
  99     FIXME("iface %p, figure_end %#x stub!\n", iface, figure_end);
 100 }
 101
 102 static HRESULT STDMETHODCALLTYPE d2d_geometry_sink_Close(ID2D1GeometrySink *iface)
 103 {
 104     FIXME("iface %p stub!\n", iface);
 105
 106     return E_NOTIMPL;
 107 }
 108
 109 static void STDMETHODCALLTYPE d2d_geometry_sink_AddLine(ID2D1GeometrySink *iface, D2D1_POINT_2F point)
 110 {
 111     TRACE("iface %p, point {%.8e, %.8e}.\n", iface, point.x, point.y);
 112
 113     d2d_geometry_sink_AddLines(iface, &point, 1);
 114 }
 115
 116 static void STDMETHODCALLTYPE d2d_geometry_sink_AddBezier(ID2D1GeometrySink *iface, const D2D1_BEZIER_SEGMENT *bezier)
 117 {
 118     TRACE("iface %p, bezier %p.\n", iface, bezier);
 119
 120     d2d_geometry_sink_AddBeziers(iface, bezier, 1);
 121 }
 122
 123 static void STDMETHODCALLTYPE d2d_geometry_sink_AddQuadraticBezier(ID2D1GeometrySink *iface,
 124         const D2D1_QUADRATIC_BEZIER_SEGMENT *bezier)
 125 {
 126     TRACE("iface %p, bezier %p.\n", iface, bezier);
 127
 128     ID2D1GeometrySink_AddQuadraticBeziers(iface, bezier, 1);
 129 }
 130
 131 static void STDMETHODCALLTYPE d2d_geometry_sink_AddQuadraticBeziers(ID2D1GeometrySink *iface,
 132         const D2D1_QUADRATIC_BEZIER_SEGMENT *beziers, UINT32 bezier_count)
 133 {
 134     FIXME("iface %p, beziers %p, bezier_count %u stub!\n", iface, beziers, bezier_count);
 135 }
 136
 137 static void STDMETHODCALLTYPE d2d_geometry_sink_AddArc(ID2D1GeometrySink *iface, const D2D1_ARC_SEGMENT *arc)
 138 {
 139     FIXME("iface %p, arc %p stub!\n", iface, arc);
 140 }
 141
 142 struct ID2D1GeometrySinkVtbl d2d_geometry_sink_vtbl =
 143 {
 144     d2d_geometry_sink_QueryInterface,
 145     d2d_geometry_sink_AddRef,
 146     d2d_geometry_sink_Release,
 147     d2d_geometry_sink_SetFillMode,
 148     d2d_geometry_sink_SetSegmentFlags,
 149     d2d_geometry_sink_BeginFigure,
 150     d2d_geometry_sink_AddLines,
 151     d2d_geometry_sink_AddBeziers,
 152     d2d_geometry_sink_EndFigure,
 153     d2d_geometry_sink_Close,
 154     d2d_geometry_sink_AddLine,
 155     d2d_geometry_sink_AddBezier,
 156     d2d_geometry_sink_AddQuadraticBezier,
 157     d2d_geometry_sink_AddQuadraticBeziers,
 158     d2d_geometry_sink_AddArc,
 159 };
 160
 161 static inline struct d2d_geometry *impl_from_ID2D1PathGeometry(ID2D1PathGeometry *iface)
 162 {
 163     return CONTAINING_RECORD(iface, struct d2d_geometry, ID2D1Geometry_iface);
 164 }
 165
 166 static HRESULT STDMETHODCALLTYPE d2d_path_geometry_QueryInterface(ID2D1PathGeometry *iface, REFIID iid, void **out)
 167 {
 168     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 169
 170     if (IsEqualGUID(iid, &IID_ID2D1PathGeometry)
 171             || IsEqualGUID(iid, &IID_ID2D1Geometry)
 172             || IsEqualGUID(iid, &IID_ID2D1Resource)
 173             || IsEqualGUID(iid, &IID_IUnknown))
 174     {
 175         ID2D1PathGeometry_AddRef(iface);
 176         *out = iface;
 177         return S_OK;
 178     }
 179
 180     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 181
 182     *out = NULL;
 183     return E_NOINTERFACE;
 184 }
 185
 186 static ULONG STDMETHODCALLTYPE d2d_path_geometry_AddRef(ID2D1PathGeometry *iface)
 187 {
 188     struct d2d_geometry *geometry = impl_from_ID2D1PathGeometry(iface);
 189     ULONG refcount = InterlockedIncrement(&geometry->refcount);
 190
 191     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 192
 193     return refcount;
 194 }
 195
 196 static ULONG STDMETHODCALLTYPE d2d_path_geometry_Release(ID2D1PathGeometry *iface)
 197 {
 198     struct d2d_geometry *geometry = impl_from_ID2D1PathGeometry(iface);
 199     ULONG refcount = InterlockedDecrement(&geometry->refcount);
 200
 201     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 202
 203     if (!refcount)
 204         HeapFree(GetProcessHeap(), 0, geometry);
 205
 206     return refcount;
 207 }
 208
 209 static void STDMETHODCALLTYPE d2d_path_geometry_GetFactory(ID2D1PathGeometry *iface, ID2D1Factory **factory)
 210 {
 211     FIXME("iface %p, factory %p stub!\n", iface, factory);
 212
 213     *factory = NULL;
 214 }
 215
 216 static HRESULT STDMETHODCALLTYPE d2d_path_geometry_GetBounds(ID2D1PathGeometry *iface,
 217         const D2D1_MATRIX_3X2_F *transform, D2D1_RECT_F *bounds)
 218 {
 219     FIXME("iface %p, transform %p, bounds %p stub!\n", iface, transform, bounds);
 220
 221     return E_NOTIMPL;
 222 }
 223
 224 static HRESULT STDMETHODCALLTYPE d2d_path_geometry_GetWidenedBounds(ID2D1PathGeometry *iface, float stroke_width,
 225         ID2D1StrokeStyle *stroke_style, const D2D1_MATRIX_3X2_F *transform, float tolerance, D2D1_RECT_F *bounds)
 226 {
 227     FIXME("iface %p, stroke_width %.8e, stroke_style %p, transform %p, tolerance %.8e, bounds %p stub!\n",
 228             iface, stroke_width, stroke_style, transform, tolerance, bounds);
 229
 230     return E_NOTIMPL;
 231 }
 232
 233 static HRESULT STDMETHODCALLTYPE d2d_path_geometry_StrokeContainsPoint(ID2D1PathGeometry *iface,
 234         D2D1_POINT_2F point, float stroke_width, ID2D1StrokeStyle *stroke_style, const D2D1_MATRIX_3X2_F *transform,
 235         float tolerance, BOOL *contains)
 236 {
 237     FIXME("iface %p, point {%.8e, %.8e}, stroke_width %.8e, stroke_style %p, "
 238             "transform %p, tolerance %.8e, contains %p stub!\n",
 239             iface, point.x, point.y, stroke_width, stroke_style, transform, tolerance, contains);
 240
 241     return E_NOTIMPL;
 242 }
 243
 244 static HRESULT STDMETHODCALLTYPE d2d_path_geometry_FillContainsPoint(ID2D1PathGeometry *iface,
 245         D2D1_POINT_2F point, const D2D1_MATRIX_3X2_F *transform, float tolerance, BOOL *contains)
 246 {
 247     FIXME("iface %p, point {%.8e, %.8e}, transform %p, tolerance %.8e, contains %p stub!\n",
 248             iface, point.x, point.y, transform, tolerance, contains);
 249
 250     return E_NOTIMPL;
 251 }
 252
 253 static HRESULT STDMETHODCALLTYPE d2d_path_geometry_CompareWithGeometry(ID2D1PathGeometry *iface,
 254         ID2D1Geometry *geometry, const D2D1_MATRIX_3X2_F *transform, float tolerance, D2D1_GEOMETRY_RELATION *relation)
 255 {
 256     FIXME("iface %p, geometry %p, transform %p, tolerance %.8e, relation %p stub!\n",
 257             iface, geometry, transform, tolerance, relation);
 258
 259     return E_NOTIMPL;
 260 }
 261
 262 static HRESULT STDMETHODCALLTYPE d2d_path_geometry_Simplify(ID2D1PathGeometry *iface,
 263         D2D1_GEOMETRY_SIMPLIFICATION_OPTION option, const D2D1_MATRIX_3X2_F *transform, float tolerance,
 264         ID2D1SimplifiedGeometrySink *sink)
 265 {
 266     FIXME("iface %p, option %#x, transform %p, tolerance %.8e, sink %p stub!\n",
 267             iface, option, transform, tolerance, sink);
 268
 269     return E_NOTIMPL;
 270 }
 271
 272 static HRESULT STDMETHODCALLTYPE d2d_path_geometry_Tessellate(ID2D1PathGeometry *iface,
 273         const D2D1_MATRIX_3X2_F *transform, float tolerance, ID2D1TessellationSink *sink)
 274 {
 275     FIXME("iface %p, transform %p, tolerance %.8e, sink %p stub!\n", iface, transform, tolerance, sink);
 276
 277     return E_NOTIMPL;
 278 }
 279
 280 static HRESULT STDMETHODCALLTYPE d2d_path_geometry_CombineWithGeometry(ID2D1PathGeometry *iface,
 281         ID2D1Geometry *geometry, D2D1_COMBINE_MODE combine_mode, const D2D1_MATRIX_3X2_F *transform,
 282         float tolerance, ID2D1SimplifiedGeometrySink *sink)
 283 {
 284     FIXME("iface %p, geometry %p, combine_mode %#x, transform %p, tolerance %.8e, sink %p stub!\n",
 285             iface, geometry, combine_mode, transform, tolerance, sink);
 286
 287     return E_NOTIMPL;
 288 }
 289
 290 static HRESULT STDMETHODCALLTYPE d2d_path_geometry_Outline(ID2D1PathGeometry *iface,
 291         const D2D1_MATRIX_3X2_F *transform, float tolerance, ID2D1SimplifiedGeometrySink *sink)
 292 {
 293     FIXME("iface %p, transform %p, tolerance %.8e, sink %p stub!\n", iface, transform, tolerance, sink);
 294
 295     return E_NOTIMPL;
 296 }
 297
 298 static HRESULT STDMETHODCALLTYPE d2d_path_geometry_ComputeArea(ID2D1PathGeometry *iface,
 299         const D2D1_MATRIX_3X2_F *transform, float tolerance, float *area)
 300 {
 301     FIXME("iface %p, transform %p, tolerance %.8e, area %p stub!\n", iface, transform, tolerance, area);
 302
 303     return E_NOTIMPL;
 304 }
 305
 306 static HRESULT STDMETHODCALLTYPE d2d_path_geometry_ComputeLength(ID2D1PathGeometry *iface,
 307         const D2D1_MATRIX_3X2_F *transform, float tolerance, float *length)
 308 {
 309     FIXME("iface %p, transform %p, tolerance %.8e, length %p stub!\n", iface, transform, tolerance, length);
 310
 311     return E_NOTIMPL;
 312 }
 313
 314 static HRESULT STDMETHODCALLTYPE d2d_path_geometry_ComputePointAtLength(ID2D1PathGeometry *iface, float length,
 315         const D2D1_MATRIX_3X2_F *transform, float tolerance, D2D1_POINT_2F *point, D2D1_POINT_2F *tangent)
 316 {
 317     FIXME("iface %p, length %.8e, transform %p, tolerance %.8e, point %p, tangent %p stub!\n",
 318             iface, length, transform, tolerance, point, tangent);
 319
 320     return E_NOTIMPL;
 321 }
 322
 323 static HRESULT STDMETHODCALLTYPE d2d_path_geometry_Widen(ID2D1PathGeometry *iface, float stroke_width,
 324         ID2D1StrokeStyle *stroke_style, const D2D1_MATRIX_3X2_F *transform, float tolerance,
 325         ID2D1SimplifiedGeometrySink *sink)
 326 {
 327     FIXME("iface %p, stroke_width %.8e, stroke_style %p, transform %p, tolerance %.8e, sink %p stub!\n",
 328             iface, stroke_width, stroke_style, transform, tolerance, sink);
 329
 330     return E_NOTIMPL;
 331 }
 332
 333 static HRESULT STDMETHODCALLTYPE d2d_path_geometry_Open(ID2D1PathGeometry *iface, ID2D1GeometrySink **sink)
 334 {
 335     struct d2d_geometry *geometry = impl_from_ID2D1PathGeometry(iface);
 336
 337     TRACE("iface %p, sink %p.\n", iface, sink);
 338
 339     *sink = &geometry->ID2D1GeometrySink_iface;
 340     ID2D1GeometrySink_AddRef(*sink);
 341
 342     return S_OK;
 343 }
 344
 345 static HRESULT STDMETHODCALLTYPE d2d_path_geometry_Stream(ID2D1PathGeometry *iface, ID2D1GeometrySink *sink)
 346 {
 347     FIXME("iface %p, sink %p stub!\n", iface, sink);
 348
 349     return E_NOTIMPL;
 350 }
 351
 352 static HRESULT STDMETHODCALLTYPE d2d_path_geometry_GetSegmentCount(ID2D1PathGeometry *iface, UINT32 *count)
 353 {
 354     FIXME("iface %p, count %p stub!\n", iface, count);
 355
 356     return E_NOTIMPL;
 357 }
 358
 359 static HRESULT STDMETHODCALLTYPE d2d_path_geometry_GetFigureCount(ID2D1PathGeometry *iface, UINT32 *count)
 360 {
 361     FIXME("iface %p, count %p stub!\n", iface, count);
 362
 363     return E_NOTIMPL;
 364 }
 365
 366 static const struct ID2D1PathGeometryVtbl d2d_path_geometry_vtbl =
 367 {
 368     d2d_path_geometry_QueryInterface,
 369     d2d_path_geometry_AddRef,
 370     d2d_path_geometry_Release,
 371     d2d_path_geometry_GetFactory,
 372     d2d_path_geometry_GetBounds,
 373     d2d_path_geometry_GetWidenedBounds,
 374     d2d_path_geometry_StrokeContainsPoint,
 375     d2d_path_geometry_FillContainsPoint,
 376     d2d_path_geometry_CompareWithGeometry,
 377     d2d_path_geometry_Simplify,
 378     d2d_path_geometry_Tessellate,
 379     d2d_path_geometry_CombineWithGeometry,
 380     d2d_path_geometry_Outline,
 381     d2d_path_geometry_ComputeArea,
 382     d2d_path_geometry_ComputeLength,
 383     d2d_path_geometry_ComputePointAtLength,
 384     d2d_path_geometry_Widen,
 385     d2d_path_geometry_Open,
 386     d2d_path_geometry_Stream,
 387     d2d_path_geometry_GetSegmentCount,
 388     d2d_path_geometry_GetFigureCount,
 389 };
 390
 391 void d2d_path_geometry_init(struct d2d_geometry *geometry)
 392 {
 393     geometry->ID2D1Geometry_iface.lpVtbl = (ID2D1GeometryVtbl *)&d2d_path_geometry_vtbl;
 394     geometry->ID2D1GeometrySink_iface.lpVtbl = &d2d_geometry_sink_vtbl;
 395     geometry->refcount = 1;
 396 }