dlls/gdiplus/customlinecap.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 #include <assert.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 GdipCloneCustomLineCap(GpCustomLineCap* from,
  35     GpCustomLineCap** to)
  36 {
  37     TRACE("(%p, %p)\n", from, to);
  38
  39     if(!from || !to)
  40         return InvalidParameter;
  41
  42     if (from->type == CustomLineCapTypeDefault)
  43         *to = heap_alloc_zero(sizeof(GpCustomLineCap));
  44     else
  45         *to = heap_alloc_zero(sizeof(GpAdjustableArrowCap));
  46
  47     if (!*to)
  48         return OutOfMemory;
  49
  50     if (from->type == CustomLineCapTypeDefault)
  51         **to = *from;
  52     else
  53         *(GpAdjustableArrowCap *)*to = *(GpAdjustableArrowCap *)from;
  54
  55     /* Duplicate path data */
  56     (*to)->pathdata.Points = heap_alloc_zero(from->pathdata.Count * sizeof(PointF));
  57     (*to)->pathdata.Types = heap_alloc_zero(from->pathdata.Count);
  58
  59     if((!(*to)->pathdata.Types  || !(*to)->pathdata.Points) && (*to)->pathdata.Count){
  60         heap_free((*to)->pathdata.Points);
  61         heap_free((*to)->pathdata.Types);
  62         heap_free(*to);
  63         return OutOfMemory;
  64     }
  65
  66     memcpy((*to)->pathdata.Points, from->pathdata.Points, from->pathdata.Count
  67            * sizeof(PointF));
  68     memcpy((*to)->pathdata.Types, from->pathdata.Types, from->pathdata.Count);
  69
  70     TRACE("<-- %p\n", *to);
  71
  72     return Ok;
  73 }
  74
  75 static GpStatus init_custom_linecap(GpCustomLineCap *cap, GpPathData *pathdata, BOOL fill, GpLineCap basecap,
  76     REAL base_inset)
  77 {
  78     cap->fill = fill;
  79
  80     cap->pathdata.Points = heap_alloc_zero(pathdata->Count * sizeof(PointF));
  81     cap->pathdata.Types = heap_alloc_zero(pathdata->Count);
  82
  83     if ((!cap->pathdata.Types || !cap->pathdata.Points) && pathdata->Count)
  84     {
  85         heap_free(cap->pathdata.Points);
  86         heap_free(cap->pathdata.Types);
  87         cap->pathdata.Points = NULL;
  88         cap->pathdata.Types = NULL;
  89         return OutOfMemory;
  90     }
  91
  92     if (pathdata->Points)
  93         memcpy(cap->pathdata.Points, pathdata->Points, pathdata->Count * sizeof(PointF));
  94     if (pathdata->Types)
  95         memcpy(cap->pathdata.Types, pathdata->Types, pathdata->Count);
  96     cap->pathdata.Count = pathdata->Count;
  97
  98     cap->inset = base_inset;
  99     cap->basecap = basecap;
 100     cap->strokeStartCap = LineCapFlat;
 101     cap->strokeEndCap = LineCapFlat;
 102     cap->join = LineJoinMiter;
 103     cap->scale = 1.0;
 104
 105     return Ok;
 106 }
 107
 108 /* Custom line cap position (0, 0) is a place corresponding to the end of line.
 109 *  If Custom Line Cap is too big and too far from position (0, 0),
 110 *  then NotImplemented will be returned, due to floating point precision limitation. */
 111 GpStatus WINGDIPAPI GdipCreateCustomLineCap(GpPath* fillPath, GpPath* strokePath,
 112     GpLineCap baseCap, REAL baseInset, GpCustomLineCap **customCap)
 113 {
 114     GpPathData *pathdata;
 115     GpStatus stat;
 116
 117     TRACE("%p %p %d %f %p\n", fillPath, strokePath, baseCap, baseInset, customCap);
 118
 119     if(!customCap || !(fillPath || strokePath))
 120         return InvalidParameter;
 121
 122     *customCap = heap_alloc_zero(sizeof(GpCustomLineCap));
 123     if(!*customCap)    return OutOfMemory;
 124
 125     if (strokePath)
 126         pathdata = &strokePath->pathdata;
 127     else
 128         pathdata = &fillPath->pathdata;
 129
 130     stat = init_custom_linecap(*customCap, pathdata, fillPath != NULL, baseCap, baseInset);
 131     if (stat != Ok)
 132     {
 133         heap_free(*customCap);
 134         return stat;
 135     }
 136
 137     TRACE("<-- %p\n", *customCap);
 138
 139     return Ok;
 140 }
 141
 142 GpStatus WINGDIPAPI GdipDeleteCustomLineCap(GpCustomLineCap *customCap)
 143 {
 144     TRACE("(%p)\n", customCap);
 145
 146     if(!customCap)
 147         return InvalidParameter;
 148
 149     heap_free(customCap->pathdata.Points);
 150     heap_free(customCap->pathdata.Types);
 151     heap_free(customCap);
 152
 153     return Ok;
 154 }
 155
 156 GpStatus WINGDIPAPI GdipGetCustomLineCapStrokeJoin(GpCustomLineCap* customCap,
 157     GpLineJoin* lineJoin)
 158 {
 159     TRACE("(%p, %p)\n", customCap, lineJoin);
 160
 161     if(!customCap || !lineJoin)
 162         return InvalidParameter;
 163
 164     *lineJoin = customCap->join;
 165
 166     return Ok;
 167 }
 168
 169 GpStatus WINGDIPAPI GdipGetCustomLineCapWidthScale(GpCustomLineCap* custom,
 170     REAL* widthScale)
 171 {
 172     TRACE("(%p, %p)\n", custom, widthScale);
 173
 174     if(!custom || !widthScale)
 175         return InvalidParameter;
 176
 177     *widthScale = custom->scale;
 178
 179     return Ok;
 180 }
 181
 182 GpStatus WINGDIPAPI GdipSetCustomLineCapStrokeCaps(GpCustomLineCap* custom,
 183     GpLineCap startcap, GpLineCap endcap)
 184 {
 185     TRACE("(%p,%u,%u)\n", custom, startcap, endcap);
 186
 187     if(!custom || startcap > LineCapTriangle || endcap > LineCapTriangle)
 188         return InvalidParameter;
 189
 190     custom->strokeStartCap = startcap;
 191     custom->strokeEndCap = endcap;
 192
 193     return Ok;
 194 }
 195
 196 GpStatus WINGDIPAPI GdipSetCustomLineCapBaseCap(GpCustomLineCap* custom,
 197     GpLineCap basecap)
 198 {
 199     TRACE("(%p,%u)\n", custom, basecap);
 200     if(!custom || basecap > LineCapTriangle)
 201         return InvalidParameter;
 202
 203     custom->basecap = basecap;
 204
 205     return Ok;
 206 }
 207
 208 GpStatus WINGDIPAPI GdipGetCustomLineCapBaseInset(GpCustomLineCap* custom,
 209     REAL* inset)
 210 {
 211     TRACE("(%p, %p)\n", custom, inset);
 212
 213     if(!custom || !inset)
 214         return InvalidParameter;
 215
 216     *inset = custom->inset;
 217
 218     return Ok;
 219 }
 220
 221 GpStatus WINGDIPAPI GdipSetCustomLineCapBaseInset(GpCustomLineCap* custom,
 222     REAL inset)
 223 {
 224     TRACE("(%p,%0.2f)\n", custom, inset);
 225
 226     if(!custom)
 227         return InvalidParameter;
 228
 229     custom->inset = inset;
 230
 231     return Ok;
 232 }
 233
 234 /*FIXME: LineJoin completely ignored now */
 235 GpStatus WINGDIPAPI GdipSetCustomLineCapStrokeJoin(GpCustomLineCap* custom,
 236     GpLineJoin join)
 237 {
 238     TRACE("(%p, %d)\n", custom, join);
 239
 240     if(!custom)
 241         return InvalidParameter;
 242
 243     custom->join = join;
 244
 245     return Ok;
 246 }
 247
 248 GpStatus WINGDIPAPI GdipSetCustomLineCapWidthScale(GpCustomLineCap* custom, REAL width)
 249 {
 250     TRACE("(%p,%0.2f)\n", custom, width);
 251
 252     if(!custom)
 253         return InvalidParameter;
 254
 255     custom->scale = width;
 256
 257     return Ok;
 258 }
 259
 260 GpStatus WINGDIPAPI GdipGetCustomLineCapBaseCap(GpCustomLineCap *customCap, GpLineCap *baseCap)
 261 {
 262     TRACE("(%p, %p)\n", customCap, baseCap);
 263
 264     if(!customCap || !baseCap)
 265         return InvalidParameter;
 266
 267     *baseCap = customCap->basecap;
 268
 269     return Ok;
 270 }
 271
 272 GpStatus WINGDIPAPI GdipGetCustomLineCapType(GpCustomLineCap *customCap, CustomLineCapType *type)
 273 {
 274     TRACE("(%p, %p)\n", customCap, type);
 275
 276     if(!customCap || !type)
 277         return InvalidParameter;
 278
 279     *type = customCap->type;
 280     return Ok;
 281 }
 282
 283 static void arrowcap_update_path(GpAdjustableArrowCap *cap)
 284 {
 285     static const BYTE types_filled[] =
 286     {
 287         PathPointTypeStart, PathPointTypeLine, PathPointTypeLine, PathPointTypeLine | PathPointTypeCloseSubpath
 288     };
 289     static const BYTE types_unfilled[] =
 290     {
 291         PathPointTypeStart, PathPointTypeLine, PathPointTypeLine
 292     };
 293     GpPointF *points;
 294
 295     assert(cap->cap.pathdata.Count == 3 || cap->cap.pathdata.Count == 4);
 296
 297     points = cap->cap.pathdata.Points;
 298     if (cap->cap.fill)
 299     {
 300         memcpy(cap->cap.pathdata.Types, types_filled, sizeof(types_filled));
 301         cap->cap.pathdata.Count = 4;
 302         points[0].X = -cap->width / 2.0;
 303         points[0].Y = -cap->height;
 304         points[1].X = 0.0;
 305         points[1].Y = 0.0;
 306         points[2].X = cap->width / 2.0;
 307         points[2].Y = -cap->height;
 308         points[3].X = 0.0;
 309         points[3].Y = -cap->height + cap->middle_inset;
 310     }
 311     else
 312     {
 313         memcpy(cap->cap.pathdata.Types, types_unfilled, sizeof(types_unfilled));
 314         cap->cap.pathdata.Count = 3;
 315         points[0].X = -cap->width / 2.0;
 316         points[0].Y = -cap->height;
 317         points[1].X = 0.0;
 318         points[1].Y = 0.0;
 319         points[2].X = cap->width / 2.0;
 320         points[2].Y = -cap->height;
 321     }
 322
 323     if (cap->width == 0.0)
 324         cap->cap.inset = 0.0;
 325     else
 326         cap->cap.inset = cap->height / cap->width;
 327 }
 328
 329 GpStatus WINGDIPAPI GdipCreateAdjustableArrowCap(REAL height, REAL width, BOOL fill,
 330     GpAdjustableArrowCap **cap)
 331 {
 332     GpPathData pathdata;
 333     GpStatus stat;
 334
 335     TRACE("(%0.2f,%0.2f,%i,%p)\n", height, width, fill, cap);
 336
 337     if (!cap)
 338         return InvalidParameter;
 339
 340     *cap = heap_alloc_zero(sizeof(**cap));
 341     if (!*cap)
 342         return OutOfMemory;
 343
 344     /* We'll need 4 points at most. */
 345     pathdata.Count = 4;
 346     pathdata.Points = NULL;
 347     pathdata.Types = NULL;
 348     stat = init_custom_linecap(&(*cap)->cap, &pathdata, fill, LineCapTriangle, width != 0.0 ? height / width : 0.0);
 349     if (stat != Ok)
 350     {
 351         heap_free(*cap);
 352         return stat;
 353     }
 354
 355     (*cap)->cap.type = CustomLineCapTypeAdjustableArrow;
 356     (*cap)->height = height;
 357     (*cap)->width = width;
 358     (*cap)->middle_inset = 0.0;
 359     arrowcap_update_path(*cap);
 360
 361     return Ok;
 362 }
 363
 364 GpStatus WINGDIPAPI GdipGetAdjustableArrowCapFillState(GpAdjustableArrowCap* cap, BOOL* fill)
 365 {
 366     TRACE("(%p,%p)\n", cap, fill);
 367
 368     if (!cap || !fill)
 369         return InvalidParameter;
 370
 371     *fill = cap->cap.fill;
 372     return Ok;
 373 }
 374
 375 GpStatus WINGDIPAPI GdipGetAdjustableArrowCapHeight(GpAdjustableArrowCap* cap, REAL* height)
 376 {
 377     TRACE("(%p,%p)\n", cap, height);
 378
 379     if (!cap || !height)
 380         return InvalidParameter;
 381
 382     *height = cap->height;
 383     return Ok;
 384 }
 385
 386 GpStatus WINGDIPAPI GdipGetAdjustableArrowCapMiddleInset(GpAdjustableArrowCap* cap, REAL* middle)
 387 {
 388     TRACE("(%p,%p)\n", cap, middle);
 389
 390     if (!cap || !middle)
 391         return InvalidParameter;
 392
 393     *middle = cap->middle_inset;
 394     return Ok;
 395 }
 396
 397 GpStatus WINGDIPAPI GdipGetAdjustableArrowCapWidth(GpAdjustableArrowCap* cap, REAL* width)
 398 {
 399     TRACE("(%p,%p)\n", cap, width);
 400
 401     if (!cap || !width)
 402         return InvalidParameter;
 403
 404     *width = cap->width;
 405     return Ok;
 406 }
 407
 408 GpStatus WINGDIPAPI GdipSetAdjustableArrowCapFillState(GpAdjustableArrowCap* cap, BOOL fill)
 409 {
 410     TRACE("(%p,%i)\n", cap, fill);
 411
 412     if (!cap)
 413         return InvalidParameter;
 414
 415     cap->cap.fill = fill;
 416     arrowcap_update_path(cap);
 417     return Ok;
 418 }
 419
 420 GpStatus WINGDIPAPI GdipSetAdjustableArrowCapHeight(GpAdjustableArrowCap* cap, REAL height)
 421 {
 422     TRACE("(%p,%0.2f)\n", cap, height);
 423
 424     if (!cap)
 425         return InvalidParameter;
 426
 427     cap->height = height;
 428     arrowcap_update_path(cap);
 429     return Ok;
 430 }
 431
 432 GpStatus WINGDIPAPI GdipSetAdjustableArrowCapMiddleInset(GpAdjustableArrowCap* cap, REAL middle)
 433 {
 434     TRACE("(%p,%0.2f)\n", cap, middle);
 435
 436     if (!cap)
 437         return InvalidParameter;
 438
 439     cap->middle_inset = middle;
 440     arrowcap_update_path(cap);
 441     return Ok;
 442 }
 443
 444 GpStatus WINGDIPAPI GdipSetAdjustableArrowCapWidth(GpAdjustableArrowCap* cap, REAL width)
 445 {
 446     TRACE("(%p,%0.2f)\n", cap, width);
 447
 448     if (!cap)
 449         return InvalidParameter;
 450
 451     cap->width = width;
 452     arrowcap_update_path(cap);
 453     return Ok;
 454 }