dlls/gdiplus/pathiterator.c

   1 /*
   2  * Copyright (C) 2007 Google (Evan Stade)
   3  * Copyright (C) 2008 Nikolay Sivov <bunglehead at gmail dot com>
   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 <stdarg.h>
  21
  22 #include "windef.h"
  23 #include "winbase.h"
  24 #include "wingdi.h"
  25
  26 #include "objbase.h"
  27
  28 #include "gdiplus.h"
  29 #include "gdiplus_private.h"
  30 #include "wine/debug.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
  33
  34 GpStatus WINGDIPAPI GdipCreatePathIter(GpPathIterator **iterator, GpPath* path)
  35 {
  36     INT size;
  37
  38     TRACE("(%p, %p)\n", iterator, path);
  39
  40     if(!iterator)
  41         return InvalidParameter;
  42
  43     *iterator = heap_alloc_zero(sizeof(GpPathIterator));
  44     if(!*iterator)  return OutOfMemory;
  45
  46     if(path){
  47         size = path->pathdata.Count;
  48
  49         (*iterator)->pathdata.Types  = heap_alloc_zero(size);
  50         (*iterator)->pathdata.Points = heap_alloc_zero(size * sizeof(PointF));
  51
  52         memcpy((*iterator)->pathdata.Types, path->pathdata.Types, size);
  53         memcpy((*iterator)->pathdata.Points, path->pathdata.Points,size * sizeof(PointF));
  54         (*iterator)->pathdata.Count = size;
  55     }
  56     else{
  57         (*iterator)->pathdata.Types  = NULL;
  58         (*iterator)->pathdata.Points = NULL;
  59         (*iterator)->pathdata.Count  = 0;
  60     }
  61
  62     (*iterator)->subpath_pos  = 0;
  63     (*iterator)->marker_pos   = 0;
  64     (*iterator)->pathtype_pos = 0;
  65
  66     return Ok;
  67 }
  68
  69 GpStatus WINGDIPAPI GdipDeletePathIter(GpPathIterator *iter)
  70 {
  71     TRACE("(%p)\n", iter);
  72
  73     if(!iter)
  74         return InvalidParameter;
  75
  76     heap_free(iter->pathdata.Types);
  77     heap_free(iter->pathdata.Points);
  78     heap_free(iter);
  79
  80     return Ok;
  81 }
  82
  83 GpStatus WINGDIPAPI GdipPathIterCopyData(GpPathIterator* iterator,
  84     INT* resultCount, GpPointF* points, BYTE* types, INT startIndex, INT endIndex)
  85 {
  86     TRACE("(%p, %p, %p, %p, %d, %d)\n", iterator, resultCount, points, types,
  87            startIndex, endIndex);
  88
  89     if(!iterator || !types || !points)
  90         return InvalidParameter;
  91
  92     if(endIndex > iterator->pathdata.Count - 1 || startIndex < 0 ||
  93         endIndex < startIndex){
  94         *resultCount = 0;
  95         return Ok;
  96     }
  97
  98     *resultCount = endIndex - startIndex + 1;
  99
 100     memcpy(types, &(iterator->pathdata.Types[startIndex]), *resultCount);
 101     memcpy(points, &(iterator->pathdata.Points[startIndex]),
 102         *resultCount * sizeof(PointF));
 103
 104     return Ok;
 105 }
 106
 107 GpStatus WINGDIPAPI GdipPathIterHasCurve(GpPathIterator* iterator, BOOL* hasCurve)
 108 {
 109     INT i;
 110
 111     TRACE("(%p, %p)\n", iterator, hasCurve);
 112
 113     if(!iterator)
 114         return InvalidParameter;
 115
 116     *hasCurve = FALSE;
 117
 118     for(i = 0; i < iterator->pathdata.Count; i++)
 119         if((iterator->pathdata.Types[i] & PathPointTypePathTypeMask) == PathPointTypeBezier){
 120             *hasCurve = TRUE;
 121             break;
 122         }
 123
 124     return Ok;
 125 }
 126
 127 GpStatus WINGDIPAPI GdipPathIterGetSubpathCount(GpPathIterator* iterator, INT* count)
 128 {
 129     INT i;
 130
 131     TRACE("(%p, %p)\n", iterator, count);
 132
 133     if(!iterator || !count)
 134         return InvalidParameter;
 135
 136     *count = 0;
 137     for(i = 0; i < iterator->pathdata.Count; i++){
 138         if(iterator->pathdata.Types[i] == PathPointTypeStart)
 139             (*count)++;
 140     }
 141
 142     return Ok;
 143 }
 144
 145 GpStatus WINGDIPAPI GdipPathIterNextMarker(GpPathIterator* iterator, INT *resultCount,
 146     INT* startIndex, INT* endIndex)
 147 {
 148     INT i;
 149
 150     TRACE("(%p, %p, %p, %p)\n", iterator, resultCount, startIndex, endIndex);
 151
 152     if(!iterator || !startIndex || !endIndex)
 153         return InvalidParameter;
 154
 155     *resultCount = 0;
 156
 157     /* first call could start with second point as all subsequent, cause
 158        path couldn't contain only one */
 159     for(i = iterator->marker_pos + 1; i < iterator->pathdata.Count; i++){
 160         if((iterator->pathdata.Types[i] & PathPointTypePathMarker) ||
 161            (i == iterator->pathdata.Count - 1)){
 162             *startIndex = iterator->marker_pos;
 163             if(iterator->marker_pos > 0) (*startIndex)++;
 164             *endIndex   = iterator->marker_pos = i;
 165             *resultCount= *endIndex - *startIndex + 1;
 166             break;
 167         }
 168     }
 169
 170     return Ok;
 171 }
 172
 173 GpStatus WINGDIPAPI GdipPathIterNextMarkerPath(GpPathIterator* iterator, INT* result,
 174     GpPath* path)
 175 {
 176     INT start, end;
 177
 178     TRACE("(%p, %p, %p)\n", iterator, result, path);
 179
 180     if(!iterator || !result)
 181         return InvalidParameter;
 182
 183     GdipPathIterNextMarker(iterator, result, &start, &end);
 184     /* return path */
 185     if(((*result) > 0) && path){
 186         GdipResetPath(path);
 187
 188         if(!lengthen_path(path, *result))
 189             return OutOfMemory;
 190
 191         memcpy(path->pathdata.Points, &(iterator->pathdata.Points[start]), sizeof(GpPointF)*(*result));
 192         memcpy(path->pathdata.Types,  &(iterator->pathdata.Types[start]),  sizeof(BYTE)*(*result));
 193         path->pathdata.Count = *result;
 194     }
 195
 196     return Ok;
 197 }
 198
 199 GpStatus WINGDIPAPI GdipPathIterNextSubpath(GpPathIterator* iterator,
 200     INT *resultCount, INT* startIndex, INT* endIndex, BOOL* isClosed)
 201 {
 202     INT i, count;
 203
 204     TRACE("(%p, %p, %p, %p, %p)\n", iterator, resultCount, startIndex,
 205            endIndex, isClosed);
 206
 207     if(!iterator || !startIndex || !endIndex || !isClosed || !resultCount)
 208         return InvalidParameter;
 209
 210     count = iterator->pathdata.Count;
 211
 212     /* iterator created with NULL path */
 213     if(count == 0){
 214         *resultCount = 0;
 215         return Ok;
 216     }
 217
 218     if(iterator->subpath_pos == count){
 219         *startIndex = *endIndex = *resultCount = 0;
 220         *isClosed = TRUE;
 221         return Ok;
 222     }
 223
 224     *startIndex = iterator->subpath_pos;
 225     /* Set new pathtype position */
 226     iterator->pathtype_pos = iterator->subpath_pos;
 227
 228     for(i = iterator->subpath_pos + 1; i < count &&
 229         !(iterator->pathdata.Types[i] == PathPointTypeStart); i++);
 230
 231     *endIndex = i - 1;
 232     iterator->subpath_pos = i;
 233
 234     *resultCount = *endIndex - *startIndex + 1;
 235
 236     if(iterator->pathdata.Types[*endIndex] & PathPointTypeCloseSubpath)
 237         *isClosed = TRUE;
 238     else
 239         *isClosed = FALSE;
 240
 241     return Ok;
 242 }
 243
 244 GpStatus WINGDIPAPI GdipPathIterRewind(GpPathIterator *iterator)
 245 {
 246     TRACE("(%p)\n", iterator);
 247
 248     if(!iterator)
 249         return InvalidParameter;
 250
 251     iterator->subpath_pos = 0;
 252     iterator->marker_pos = 0;
 253     iterator->pathtype_pos = 0;
 254
 255     return Ok;
 256 }
 257
 258 GpStatus WINGDIPAPI GdipPathIterGetCount(GpPathIterator* iterator, INT* count)
 259 {
 260     TRACE("(%p, %p)\n", iterator, count);
 261
 262     if(!iterator || !count)
 263         return InvalidParameter;
 264
 265     *count = iterator->pathdata.Count;
 266
 267     return Ok;
 268 }
 269
 270 GpStatus WINGDIPAPI GdipPathIterEnumerate(GpPathIterator* iterator, INT* resultCount,
 271     GpPointF *points, BYTE *types, INT count)
 272 {
 273     TRACE("(%p, %p, %p, %p, %d)\n", iterator, resultCount, points, types, count);
 274
 275     if((count < 0) || !resultCount)
 276         return InvalidParameter;
 277
 278     if(count == 0){
 279         *resultCount = 0;
 280         return Ok;
 281     }
 282
 283     return GdipPathIterCopyData(iterator, resultCount, points, types, 0, count-1);
 284 }
 285
 286 GpStatus WINGDIPAPI GdipPathIterIsValid(GpPathIterator* iterator, BOOL* valid)
 287 {
 288     TRACE("(%p, %p)\n", iterator, valid);
 289
 290     if(!iterator || !valid)
 291         return InvalidParameter;
 292
 293     *valid = TRUE;
 294
 295     return Ok;
 296 }
 297
 298 GpStatus WINGDIPAPI GdipPathIterNextPathType(GpPathIterator* iter, INT* result,
 299     BYTE* type, INT* start, INT* end)
 300 {
 301     INT i, stopIndex;
 302     TRACE("(%p, %p, %p, %p, %p)\n", iter, result, type, start, end);
 303
 304     if (!iter || !result || !type || !start || !end)
 305         return InvalidParameter;
 306
 307     i = iter->pathtype_pos;
 308     stopIndex = iter->subpath_pos;
 309     if (i >= stopIndex)  {
 310         *result = 0;
 311         return Ok;
 312     }
 313     if ((iter->pathdata.Types[i] & PathPointTypePathTypeMask) == PathPointTypeStart)
 314         i++;
 315
 316     *start = i - 1;
 317     if ((i < stopIndex) &&
 318        ((iter->pathdata.Types[i] & PathPointTypePathTypeMask) != PathPointTypeStart))
 319     {
 320         *type = iter->pathdata.Types[i] & PathPointTypePathTypeMask;
 321         i++;
 322         for ( ; i < stopIndex; i++) {
 323             if ((iter->pathdata.Types[i] & PathPointTypePathTypeMask) != *type)
 324                 break;
 325         }
 326     }
 327     iter->pathtype_pos = i;
 328     *end = i - 1;
 329     *result = *end - *start + 1;
 330     return Ok;
 331 }
 332
 333 GpStatus WINGDIPAPI GdipPathIterNextSubpathPath(GpPathIterator* iter, INT* result,
 334     GpPath* path, BOOL* closed)
 335 {
 336     INT start, end;
 337
 338     TRACE("(%p, %p, %p, %p)\n", iter, result, path, closed);
 339
 340     if(!iter || !result || !closed)
 341         return InvalidParameter;
 342
 343     GdipPathIterNextSubpath(iter, result, &start, &end, closed);
 344     /* return path */
 345     if(((*result) > 0) && path){
 346         GdipResetPath(path);
 347
 348         if(!lengthen_path(path, *result))
 349             return OutOfMemory;
 350
 351         memcpy(path->pathdata.Points, &(iter->pathdata.Points[start]), sizeof(GpPointF)*(*result));
 352         memcpy(path->pathdata.Types,  &(iter->pathdata.Types[start]),  sizeof(BYTE)*(*result));
 353         path->pathdata.Count = *result;
 354     }
 355
 356     return Ok;
 357 }