dlls/gdiplus/pathiterator.c

   1 /*
   2  * Copyright (C) 2007 Google (Evan Stade)
   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 <stdarg.h>
  20
  21 #include "windef.h"
  22 #include "winbase.h"
  23 #include "wingdi.h"
  24
  25 #include "objbase.h"
  26
  27 #include "gdiplus.h"
  28 #include "gdiplus_private.h"
  29
  30 GpStatus WINGDIPAPI GdipCreatePathIter(GpPathIterator **iterator, GpPath* path)
  31 {
  32     INT size;
  33
  34     if(!iterator)
  35         return InvalidParameter;
  36
  37     *iterator = GdipAlloc(sizeof(GpPathIterator));
  38     if(!*iterator)  return OutOfMemory;
  39
  40     if(path){
  41         size = path->pathdata.Count;
  42
  43         (*iterator)->pathdata.Types  = GdipAlloc(size);
  44         (*iterator)->pathdata.Points = GdipAlloc(size * sizeof(PointF));
  45
  46         memcpy((*iterator)->pathdata.Types, path->pathdata.Types, size);
  47         memcpy((*iterator)->pathdata.Points, path->pathdata.Points,size * sizeof(PointF));
  48         (*iterator)->pathdata.Count = size;
  49     }
  50     else{
  51         (*iterator)->pathdata.Types  = NULL;
  52         (*iterator)->pathdata.Points = NULL;
  53         (*iterator)->pathdata.Count  = 0;
  54     }
  55
  56     (*iterator)->subpath_pos  = 0;
  57     (*iterator)->marker_pos   = 0;
  58     (*iterator)->pathtype_pos = 0;
  59
  60     return Ok;
  61 }
  62
  63 GpStatus WINGDIPAPI GdipDeletePathIter(GpPathIterator *iter)
  64 {
  65     if(!iter)
  66         return InvalidParameter;
  67
  68     GdipFree(iter->pathdata.Types);
  69     GdipFree(iter->pathdata.Points);
  70     GdipFree(iter);
  71
  72     return Ok;
  73 }
  74
  75 GpStatus WINGDIPAPI GdipPathIterCopyData(GpPathIterator* iterator,
  76     INT* resultCount, GpPointF* points, BYTE* types, INT startIndex, INT endIndex)
  77 {
  78     if(!iterator || !types || !points)
  79         return InvalidParameter;
  80
  81     if(endIndex > iterator->pathdata.Count - 1 || startIndex < 0 ||
  82         endIndex < startIndex){
  83         *resultCount = 0;
  84         return Ok;
  85     }
  86
  87     *resultCount = endIndex - startIndex + 1;
  88
  89     memcpy(types, &(iterator->pathdata.Types[startIndex]), *resultCount);
  90     memcpy(points, &(iterator->pathdata.Points[startIndex]),
  91         *resultCount * sizeof(PointF));
  92
  93     return Ok;
  94 }
  95
  96 GpStatus WINGDIPAPI GdipPathIterHasCurve(GpPathIterator* iterator, BOOL* hasCurve)
  97 {
  98     INT i;
  99
 100     if(!iterator)
 101         return InvalidParameter;
 102
 103     *hasCurve = FALSE;
 104
 105     for(i = 0; i < iterator->pathdata.Count; i++)
 106         if((iterator->pathdata.Types[i] & PathPointTypePathTypeMask) == PathPointTypeBezier){
 107             *hasCurve = TRUE;
 108             break;
 109         }
 110
 111     return Ok;
 112 }
 113
 114 GpStatus WINGDIPAPI GdipPathIterGetSubpathCount(GpPathIterator* iterator, INT* count)
 115 {
 116     INT i;
 117
 118     if(!iterator || !count)
 119         return InvalidParameter;
 120
 121     *count = 0;
 122     for(i = 0; i < iterator->pathdata.Count; i++){
 123         if(iterator->pathdata.Types[i] == PathPointTypeStart)
 124             (*count)++;
 125     }
 126
 127     return Ok;
 128 }
 129
 130 GpStatus WINGDIPAPI GdipPathIterNextMarker(GpPathIterator* iterator, INT *resultCount,
 131     INT* startIndex, INT* endIndex)
 132 {
 133     INT i;
 134
 135     if(!iterator || !startIndex || !endIndex)
 136         return InvalidParameter;
 137
 138     *resultCount = 0;
 139
 140     /* first call could start with second point as all subsequent, cause
 141        path couldn't contain only one */
 142     for(i = iterator->marker_pos + 1; i < iterator->pathdata.Count; i++){
 143         if((iterator->pathdata.Types[i] & PathPointTypePathMarker) ||
 144            (i == iterator->pathdata.Count - 1)){
 145             *startIndex = iterator->marker_pos;
 146             if(iterator->marker_pos > 0) (*startIndex)++;
 147             *endIndex   = iterator->marker_pos = i;
 148             *resultCount= *endIndex - *startIndex + 1;
 149             break;
 150         }
 151     }
 152
 153     return Ok;
 154 }
 155
 156 GpStatus WINGDIPAPI GdipPathIterNextSubpath(GpPathIterator* iterator,
 157     INT *resultCount, INT* startIndex, INT* endIndex, BOOL* isClosed)
 158 {
 159     INT i, count;
 160
 161     if(!iterator || !startIndex || !endIndex || !isClosed || !resultCount)
 162         return InvalidParameter;
 163
 164     count = iterator->pathdata.Count;
 165
 166     /* iterator created with NULL path */
 167     if(count == 0){
 168         *resultCount = 0;
 169         return Ok;
 170     }
 171
 172     if(iterator->subpath_pos == count){
 173         *startIndex = *endIndex = *resultCount = 0;
 174         *isClosed = 1;
 175         return Ok;
 176     }
 177
 178     *startIndex = iterator->subpath_pos;
 179
 180     for(i = iterator->subpath_pos + 1; i < count &&
 181         !(iterator->pathdata.Types[i] == PathPointTypeStart); i++);
 182
 183     *endIndex = i - 1;
 184     iterator->subpath_pos = i;
 185
 186     *resultCount = *endIndex - *startIndex + 1;
 187
 188     if(iterator->pathdata.Types[*endIndex] & PathPointTypeCloseSubpath)
 189         *isClosed = TRUE;
 190     else
 191         *isClosed = FALSE;
 192
 193     return Ok;
 194 }
 195 GpStatus WINGDIPAPI GdipPathIterRewind(GpPathIterator *iterator)
 196 {
 197     if(!iterator)
 198         return InvalidParameter;
 199
 200     iterator->subpath_pos = 0;
 201     iterator->marker_pos = 0;
 202     iterator->pathtype_pos = 0;
 203
 204     return Ok;
 205 }
 206
 207 GpStatus WINGDIPAPI GdipPathIterGetCount(GpPathIterator* iterator, INT* count)
 208 {
 209     if(!iterator || !count)
 210         return InvalidParameter;
 211
 212     *count = iterator->pathdata.Count;
 213
 214     return Ok;
 215 }
 216
 217 GpStatus WINGDIPAPI GdipPathIterEnumerate(GpPathIterator* iterator, INT* resultCount,
 218     GpPointF *points, BYTE *types, INT count)
 219 {
 220     if((count < 0) || !resultCount)
 221         return InvalidParameter;
 222
 223     if(count == 0){
 224         *resultCount = 0;
 225         return Ok;
 226     }
 227
 228     return GdipPathIterCopyData(iterator, resultCount, points, types, 0, count-1);
 229 }
 230
 231 GpStatus WINGDIPAPI GdipPathIterIsValid(GpPathIterator* iterator, BOOL* valid)
 232 {
 233     if(!iterator || !valid)
 234         return InvalidParameter;
 235
 236     *valid = TRUE;
 237
 238     return Ok;
 239 }
 240
 241 GpStatus WINGDIPAPI GdipPathIterNextSubpathPath(GpPathIterator* iter, INT* result,
 242     GpPath* path, BOOL* closed)
 243 {
 244     INT start, end;
 245
 246     if(!iter || !result || !closed)
 247         return InvalidParameter;
 248
 249     GdipPathIterNextSubpath(iter, result, &start, &end, closed);
 250     /* return path */
 251     if(((*result) > 0) && path){
 252         GdipResetPath(path);
 253
 254         if(!lengthen_path(path, *result))
 255             return OutOfMemory;
 256
 257         memcpy(path->pathdata.Points, &(iter->pathdata.Points[start]), sizeof(GpPointF)*(*result));
 258         memcpy(path->pathdata.Types,  &(iter->pathdata.Types[start]),  sizeof(BYTE)*(*result));
 259         path->pathdata.Count = *result;
 260     }
 261
 262     return Ok;
 263 }