dlls/gdiplus/pen.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 #include "wine/debug.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
  32
  33 static DWORD gdip_to_gdi_dash(GpDashStyle dash)
  34 {
  35     switch(dash){
  36         case DashStyleSolid:
  37             return PS_SOLID;
  38         case DashStyleDash:
  39             return PS_DASH;
  40         case DashStyleDot:
  41             return PS_DOT;
  42         case DashStyleDashDot:
  43             return PS_DASHDOT;
  44         case DashStyleDashDotDot:
  45             return PS_DASHDOTDOT;
  46         case DashStyleCustom:
  47             return PS_USERSTYLE;
  48         default:
  49             ERR("Not a member of GpDashStyle enumeration\n");
  50             return 0;
  51     }
  52 }
  53
  54 static DWORD gdip_to_gdi_join(GpLineJoin join)
  55 {
  56     switch(join){
  57         case LineJoinRound:
  58             return PS_JOIN_ROUND;
  59         case LineJoinBevel:
  60             return PS_JOIN_BEVEL;
  61         case LineJoinMiter:
  62         case LineJoinMiterClipped:
  63             return PS_JOIN_MITER;
  64         default:
  65             ERR("Not a member of GpLineJoin enumeration\n");
  66             return 0;
  67     }
  68 }
  69
  70 static GpPenType bt_to_pt(GpBrushType bt)
  71 {
  72     switch(bt){
  73         case BrushTypeSolidColor:
  74             return PenTypeSolidColor;
  75         case BrushTypeHatchFill:
  76             return PenTypeHatchFill;
  77         case BrushTypeTextureFill:
  78             return PenTypeTextureFill;
  79         case BrushTypePathGradient:
  80             return PenTypePathGradient;
  81         case BrushTypeLinearGradient:
  82             return PenTypeLinearGradient;
  83         default:
  84             return PenTypeUnknown;
  85     }
  86 }
  87
  88 GpStatus WINGDIPAPI GdipClonePen(GpPen *pen, GpPen **clonepen)
  89 {
  90     GpStatus stat;
  91
  92     TRACE("(%p, %p)\n", pen, clonepen);
  93
  94     if(!pen || !clonepen)
  95         return InvalidParameter;
  96
  97     *clonepen = heap_alloc_zero(sizeof(GpPen));
  98     if(!*clonepen)  return OutOfMemory;
  99
 100     **clonepen = *pen;
 101
 102     (*clonepen)->customstart = NULL;
 103     (*clonepen)->customend = NULL;
 104     (*clonepen)->brush = NULL;
 105     (*clonepen)->dashes = NULL;
 106     (*clonepen)->compound_array = NULL;
 107
 108     stat = GdipCloneBrush(pen->brush, &(*clonepen)->brush);
 109
 110     if (stat == Ok && pen->customstart)
 111         stat = GdipCloneCustomLineCap(pen->customstart, &(*clonepen)->customstart);
 112
 113     if (stat == Ok && pen->customend)
 114         stat = GdipCloneCustomLineCap(pen->customend, &(*clonepen)->customend);
 115
 116     if (stat == Ok && pen->dashes)
 117     {
 118         (*clonepen)->dashes = heap_alloc_zero(pen->numdashes * sizeof(REAL));
 119         if ((*clonepen)->dashes)
 120             memcpy((*clonepen)->dashes, pen->dashes, pen->numdashes * sizeof(REAL));
 121         else
 122             stat = OutOfMemory;
 123     }
 124
 125     if (stat == Ok && pen->compound_array)
 126     {
 127         (*clonepen)->compound_array = heap_alloc_zero(pen->compound_array_size * sizeof(REAL));
 128         if ((*clonepen)->compound_array)
 129             memcpy((*clonepen)->compound_array, pen->compound_array, pen->compound_array_size * sizeof(REAL));
 130         else
 131             stat = OutOfMemory;
 132     }
 133
 134     if (stat != Ok)
 135     {
 136         GdipDeletePen(*clonepen);
 137         *clonepen = NULL;
 138         return stat;
 139     }
 140
 141     TRACE("<-- %p\n", *clonepen);
 142
 143     return Ok;
 144 }
 145
 146 GpStatus WINGDIPAPI GdipCreatePen1(ARGB color, REAL width, GpUnit unit,
 147     GpPen **pen)
 148 {
 149     GpBrush *brush;
 150     GpStatus status;
 151
 152     TRACE("(%lx, %.2f, %d, %p)\n", color, width, unit, pen);
 153
 154     GdipCreateSolidFill(color, (GpSolidFill **)(&brush));
 155     status = GdipCreatePen2(brush, width, unit, pen);
 156     GdipDeleteBrush(brush);
 157     return status;
 158 }
 159
 160 GpStatus WINGDIPAPI GdipCreatePen2(GpBrush *brush, REAL width, GpUnit unit,
 161     GpPen **pen)
 162 {
 163     GpPen *gp_pen;
 164     GpBrush *clone_brush;
 165
 166     TRACE("(%p, %.2f, %d, %p)\n", brush, width, unit, pen);
 167
 168     if(!pen || !brush)
 169         return InvalidParameter;
 170
 171     gp_pen = heap_alloc_zero(sizeof(GpPen));
 172     if(!gp_pen)    return OutOfMemory;
 173
 174     gp_pen->style = GP_DEFAULT_PENSTYLE;
 175     gp_pen->width = width;
 176     gp_pen->unit = unit;
 177     gp_pen->endcap = LineCapFlat;
 178     gp_pen->join = LineJoinMiter;
 179     gp_pen->miterlimit = 10.0;
 180     gp_pen->dash = DashStyleSolid;
 181     gp_pen->offset = 0.0;
 182     gp_pen->customstart = NULL;
 183     gp_pen->customend = NULL;
 184     gp_pen->compound_array = NULL;
 185     gp_pen->compound_array_size = 0;
 186     GdipSetMatrixElements(&gp_pen->transform, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
 187
 188     if(!((gp_pen->unit == UnitWorld) || (gp_pen->unit == UnitPixel))) {
 189         FIXME("UnitWorld, UnitPixel only supported units\n");
 190         heap_free(gp_pen);
 191         return NotImplemented;
 192     }
 193
 194     GdipCloneBrush(brush, &clone_brush);
 195     gp_pen->brush = clone_brush;
 196
 197     *pen = gp_pen;
 198
 199     TRACE("<-- %p\n", *pen);
 200
 201     return Ok;
 202 }
 203
 204 GpStatus WINGDIPAPI GdipDeletePen(GpPen *pen)
 205 {
 206     TRACE("(%p)\n", pen);
 207
 208     if(!pen)    return InvalidParameter;
 209
 210     GdipDeleteBrush(pen->brush);
 211     GdipDeleteCustomLineCap(pen->customstart);
 212     GdipDeleteCustomLineCap(pen->customend);
 213     heap_free(pen->compound_array);
 214     heap_free(pen->dashes);
 215     heap_free(pen);
 216
 217     return Ok;
 218 }
 219
 220 GpStatus WINGDIPAPI GdipGetPenBrushFill(GpPen *pen, GpBrush **brush)
 221 {
 222     TRACE("(%p, %p)\n", pen, brush);
 223
 224     if(!pen || !brush)
 225         return InvalidParameter;
 226
 227     return GdipCloneBrush(pen->brush, brush);
 228 }
 229
 230 GpStatus WINGDIPAPI GdipGetPenColor(GpPen *pen, ARGB *argb)
 231 {
 232     TRACE("(%p, %p)\n", pen, argb);
 233
 234     if(!pen || !argb)
 235         return InvalidParameter;
 236
 237     if(pen->brush->bt != BrushTypeSolidColor)
 238         return NotImplemented;
 239
 240     return GdipGetSolidFillColor(((GpSolidFill*)pen->brush), argb);
 241 }
 242
 243 GpStatus WINGDIPAPI GdipGetPenCustomEndCap(GpPen *pen, GpCustomLineCap** customCap)
 244 {
 245     TRACE("(%p, %p)\n", pen, customCap);
 246
 247     if(!pen || !customCap)
 248         return InvalidParameter;
 249
 250     if(!pen->customend){
 251         *customCap = NULL;
 252         return Ok;
 253     }
 254
 255     return GdipCloneCustomLineCap(pen->customend, customCap);
 256 }
 257
 258 GpStatus WINGDIPAPI GdipGetPenCustomStartCap(GpPen *pen, GpCustomLineCap** customCap)
 259 {
 260     TRACE("(%p, %p)\n", pen, customCap);
 261
 262     if(!pen || !customCap)
 263         return InvalidParameter;
 264
 265     if(!pen->customstart){
 266         *customCap = NULL;
 267         return Ok;
 268     }
 269
 270     return GdipCloneCustomLineCap(pen->customstart, customCap);
 271 }
 272
 273 GpStatus WINGDIPAPI GdipGetPenDashArray(GpPen *pen, REAL *dash, INT count)
 274 {
 275     TRACE("(%p, %p, %d)\n", pen, dash, count);
 276
 277     if(!pen || !dash || count > pen->numdashes)
 278         return InvalidParameter;
 279
 280     /* note: if you pass a negative value for count, it crashes native gdiplus. */
 281     if(count < 0)
 282         return GenericError;
 283
 284     memcpy(dash, pen->dashes, count * sizeof(REAL));
 285
 286     return Ok;
 287 }
 288
 289 GpStatus WINGDIPAPI GdipGetPenDashCap197819(GpPen *pen, GpDashCap *dashCap)
 290 {
 291     TRACE("(%p, %p)\n", pen, dashCap);
 292
 293     if(!pen || !dashCap)
 294         return InvalidParameter;
 295
 296     *dashCap = pen->dashcap;
 297
 298     return Ok;
 299 }
 300
 301 GpStatus WINGDIPAPI GdipGetPenDashCount(GpPen *pen, INT *count)
 302 {
 303     TRACE("(%p, %p)\n", pen, count);
 304
 305     if(!pen || !count)
 306         return InvalidParameter;
 307
 308     *count = pen->numdashes;
 309
 310     return Ok;
 311 }
 312
 313 GpStatus WINGDIPAPI GdipGetPenDashOffset(GpPen *pen, REAL *offset)
 314 {
 315     TRACE("(%p, %p)\n", pen, offset);
 316
 317     if(!pen || !offset)
 318         return InvalidParameter;
 319
 320     *offset = pen->offset;
 321
 322     return Ok;
 323 }
 324
 325 GpStatus WINGDIPAPI GdipGetPenDashStyle(GpPen *pen, GpDashStyle *dash)
 326 {
 327     TRACE("(%p, %p)\n", pen, dash);
 328
 329     if(!pen || !dash)
 330         return InvalidParameter;
 331
 332     *dash = pen->dash;
 333
 334     return Ok;
 335 }
 336
 337 GpStatus WINGDIPAPI GdipGetPenEndCap(GpPen *pen, GpLineCap *endCap)
 338 {
 339     TRACE("(%p, %p)\n", pen, endCap);
 340
 341     if(!pen || !endCap)
 342         return InvalidParameter;
 343
 344     *endCap = pen->endcap;
 345
 346     return Ok;
 347 }
 348
 349 GpStatus WINGDIPAPI GdipGetPenFillType(GpPen *pen, GpPenType* type)
 350 {
 351     TRACE("(%p, %p)\n", pen, type);
 352
 353     if(!pen || !type)
 354         return InvalidParameter;
 355
 356     *type = bt_to_pt(pen->brush->bt);
 357
 358     return Ok;
 359 }
 360
 361 GpStatus WINGDIPAPI GdipGetPenLineJoin(GpPen *pen, GpLineJoin *lineJoin)
 362 {
 363     TRACE("(%p, %p)\n", pen, lineJoin);
 364
 365     if(!pen || !lineJoin)
 366         return InvalidParameter;
 367
 368     *lineJoin = pen->join;
 369
 370     return Ok;
 371 }
 372
 373 GpStatus WINGDIPAPI GdipGetPenMode(GpPen *pen, GpPenAlignment *mode)
 374 {
 375     TRACE("(%p, %p)\n", pen, mode);
 376
 377     if(!pen || !mode)
 378         return InvalidParameter;
 379
 380     *mode = pen->align;
 381
 382     return Ok;
 383 }
 384
 385 GpStatus WINGDIPAPI GdipGetPenMiterLimit(GpPen *pen, REAL *miterLimit)
 386 {
 387     TRACE("(%p, %p)\n", pen, miterLimit);
 388
 389     if(!pen || !miterLimit)
 390         return InvalidParameter;
 391
 392     *miterLimit = pen->miterlimit;
 393
 394     return Ok;
 395 }
 396
 397 GpStatus WINGDIPAPI GdipGetPenStartCap(GpPen *pen, GpLineCap *startCap)
 398 {
 399     TRACE("(%p, %p)\n", pen, startCap);
 400
 401     if(!pen || !startCap)
 402         return InvalidParameter;
 403
 404     *startCap = pen->startcap;
 405
 406     return Ok;
 407 }
 408
 409 GpStatus WINGDIPAPI GdipGetPenUnit(GpPen *pen, GpUnit *unit)
 410 {
 411     TRACE("(%p, %p)\n", pen, unit);
 412
 413     if(!pen || !unit)
 414         return InvalidParameter;
 415
 416     *unit = pen->unit;
 417
 418     return Ok;
 419 }
 420
 421 GpStatus WINGDIPAPI GdipGetPenWidth(GpPen *pen, REAL *width)
 422 {
 423     TRACE("(%p, %p)\n", pen, width);
 424
 425     if(!pen || !width)
 426         return InvalidParameter;
 427
 428     *width = pen->width;
 429
 430     return Ok;
 431 }
 432
 433 GpStatus WINGDIPAPI GdipResetPenTransform(GpPen *pen)
 434 {
 435     TRACE("(%p)\n", pen);
 436
 437     if(!pen)
 438         return InvalidParameter;
 439
 440     GdipSetMatrixElements(&pen->transform, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
 441
 442     return Ok;
 443 }
 444
 445 GpStatus WINGDIPAPI GdipSetPenTransform(GpPen *pen, GpMatrix *matrix)
 446 {
 447     static int calls;
 448
 449     TRACE("(%p,%s)\n", pen, debugstr_matrix(matrix));
 450
 451     if(!pen || !matrix)
 452         return InvalidParameter;
 453
 454     if(!(calls++))
 455         FIXME("(%p,%p) Semi-stub\n", pen, matrix);
 456
 457     pen->transform = *matrix;
 458
 459     return Ok;
 460 }
 461
 462 GpStatus WINGDIPAPI GdipGetPenTransform(GpPen *pen, GpMatrix *matrix)
 463 {
 464     TRACE("(%p,%s)\n", pen, debugstr_matrix(matrix));
 465
 466     if(!pen || !matrix)
 467         return InvalidParameter;
 468
 469     *matrix = pen->transform;
 470
 471     return Ok;
 472 }
 473
 474 GpStatus WINGDIPAPI GdipTranslatePenTransform(GpPen *pen, REAL dx, REAL dy, GpMatrixOrder order)
 475 {
 476     TRACE("(%p,%0.2f,%0.2f,%u)\n", pen, dx, dy, order);
 477
 478     if(!pen)
 479         return InvalidParameter;
 480
 481     return GdipTranslateMatrix(&pen->transform, dx, dy, order);
 482 }
 483
 484 GpStatus WINGDIPAPI GdipScalePenTransform(GpPen *pen, REAL sx, REAL sy, GpMatrixOrder order)
 485 {
 486     TRACE("(%p,%0.2f,%0.2f,%u)\n", pen, sx, sy, order);
 487
 488     if(!pen)
 489         return InvalidParameter;
 490
 491     return GdipScaleMatrix(&pen->transform, sx, sy, order);
 492 }
 493
 494 GpStatus WINGDIPAPI GdipRotatePenTransform(GpPen *pen, REAL angle, GpMatrixOrder order)
 495 {
 496     TRACE("(%p,%0.2f,%u)\n", pen, angle, order);
 497
 498     if(!pen)
 499         return InvalidParameter;
 500
 501     return GdipRotateMatrix(&pen->transform, angle, order);
 502 }
 503
 504 GpStatus WINGDIPAPI GdipMultiplyPenTransform(GpPen *pen, GDIPCONST GpMatrix *matrix,
 505     GpMatrixOrder order)
 506 {
 507     TRACE("(%p,%s,%u)\n", pen, debugstr_matrix(matrix), order);
 508
 509     if(!pen)
 510         return InvalidParameter;
 511
 512     return GdipMultiplyMatrix(&pen->transform, matrix, order);
 513 }
 514
 515 GpStatus WINGDIPAPI GdipSetPenBrushFill(GpPen *pen, GpBrush *brush)
 516 {
 517     TRACE("(%p, %p)\n", pen, brush);
 518
 519     if(!pen || !brush)
 520         return InvalidParameter;
 521
 522     GdipDeleteBrush(pen->brush);
 523     return GdipCloneBrush(brush, &pen->brush);
 524 }
 525
 526 GpStatus WINGDIPAPI GdipSetPenColor(GpPen *pen, ARGB argb)
 527 {
 528     TRACE("(%p, %lx)\n", pen, argb);
 529
 530     if(!pen)
 531         return InvalidParameter;
 532
 533     if(pen->brush->bt != BrushTypeSolidColor)
 534         return NotImplemented;
 535
 536     return GdipSetSolidFillColor(((GpSolidFill*)pen->brush), argb);
 537 }
 538
 539 GpStatus WINGDIPAPI GdipGetPenCompoundArray(GpPen *pen, REAL *compoundarray, INT count)
 540 {
 541     TRACE("(%p, %p, %i)\n", pen, compoundarray, count);
 542
 543     if (!pen || !compoundarray || count > pen->compound_array_size)
 544         return InvalidParameter;
 545     if (pen->compound_array && count > 0)
 546         memcpy(compoundarray, pen->compound_array, count * sizeof(REAL));
 547     return Ok;
 548 }
 549
 550 GpStatus WINGDIPAPI GdipGetPenCompoundCount(GpPen *pen, INT *count)
 551 {
 552     TRACE("(%p, %p)\n", pen, count);
 553
 554     if (!pen || !count)
 555         return InvalidParameter;
 556     *count = pen->compound_array_size;
 557     return Ok;
 558 }
 559
 560 GpStatus WINGDIPAPI GdipSetPenCompoundArray(GpPen *pen, GDIPCONST REAL *compoundarray,
 561     INT count)
 562 {
 563     INT i;
 564     REAL *tmp;
 565     TRACE("(%p, %p, %i)\n", pen, compoundarray, count);
 566
 567     if(!pen || !compoundarray || count < 2 || count%2 == 1 || *compoundarray < 0.0 || *compoundarray > 1.0)
 568         return InvalidParameter;
 569
 570     for(i = 1; i<count; i++)
 571     {
 572         if((compoundarray[i] < compoundarray[i - 1]) || (compoundarray[i] > 1.0))
 573             return InvalidParameter;
 574     }
 575
 576     tmp = heap_alloc_zero(count * sizeof(REAL));
 577     if(!tmp)
 578         return OutOfMemory;
 579     heap_free(pen->compound_array);
 580     pen->compound_array = tmp;
 581     memcpy(pen->compound_array, compoundarray, count * sizeof(REAL));
 582     pen->compound_array_size = count;
 583     return Ok;
 584 }
 585
 586 GpStatus WINGDIPAPI GdipSetPenCustomEndCap(GpPen *pen, GpCustomLineCap* customCap)
 587 {
 588     GpCustomLineCap * cap;
 589     GpStatus ret;
 590
 591     TRACE("(%p, %p)\n", pen, customCap);
 592
 593     /* native crashes on pen == NULL, customCap != NULL */
 594     if(!customCap) return InvalidParameter;
 595
 596     if((ret = GdipCloneCustomLineCap(customCap, &cap)) == Ok){
 597         GdipDeleteCustomLineCap(pen->customend);
 598         pen->endcap = LineCapCustom;
 599         pen->customend = cap;
 600     }
 601
 602     return ret;
 603 }
 604
 605 GpStatus WINGDIPAPI GdipSetPenCustomStartCap(GpPen *pen, GpCustomLineCap* customCap)
 606 {
 607     GpCustomLineCap * cap;
 608     GpStatus ret;
 609
 610     TRACE("(%p, %p)\n", pen, customCap);
 611
 612     /* native crashes on pen == NULL, customCap != NULL */
 613     if(!customCap) return InvalidParameter;
 614
 615     if((ret = GdipCloneCustomLineCap(customCap, &cap)) == Ok){
 616         GdipDeleteCustomLineCap(pen->customstart);
 617         pen->startcap = LineCapCustom;
 618         pen->customstart = cap;
 619     }
 620
 621     return ret;
 622 }
 623
 624 GpStatus WINGDIPAPI GdipSetPenDashArray(GpPen *pen, GDIPCONST REAL *dash,
 625     INT count)
 626 {
 627     INT i;
 628     REAL sum = 0;
 629
 630     TRACE("(%p, %p, %d)\n", pen, dash, count);
 631
 632     if(!pen || !dash)
 633         return InvalidParameter;
 634
 635     if(count <= 0)
 636         return OutOfMemory;
 637
 638     for(i = 0; i < count; i++){
 639         sum += dash[i];
 640         if(dash[i] <= 0.0)
 641             return InvalidParameter;
 642     }
 643
 644     heap_free(pen->dashes);
 645     pen->dashes = NULL;
 646
 647     if(count > 0)
 648         pen->dashes = heap_alloc_zero(count * sizeof(REAL));
 649     if(!pen->dashes){
 650         pen->numdashes = 0;
 651         return OutOfMemory;
 652     }
 653
 654     GdipSetPenDashStyle(pen, DashStyleCustom);
 655     memcpy(pen->dashes, dash, count * sizeof(REAL));
 656     pen->numdashes = count;
 657
 658     return Ok;
 659 }
 660
 661 GpStatus WINGDIPAPI GdipSetPenDashCap197819(GpPen *pen, GpDashCap dashCap)
 662 {
 663     TRACE("(%p, %d)\n", pen, dashCap);
 664
 665     if(!pen)
 666         return InvalidParameter;
 667
 668     pen->dashcap = dashCap;
 669
 670     return Ok;
 671 }
 672
 673 /* FIXME: dash offset not used */
 674 GpStatus WINGDIPAPI GdipSetPenDashOffset(GpPen *pen, REAL offset)
 675 {
 676     TRACE("(%p, %.2f)\n", pen, offset);
 677
 678     if(!pen)
 679         return InvalidParameter;
 680
 681     pen->offset = offset;
 682
 683     return Ok;
 684 }
 685
 686 GpStatus WINGDIPAPI GdipSetPenDashStyle(GpPen *pen, GpDashStyle dash)
 687 {
 688     TRACE("(%p, %d)\n", pen, dash);
 689
 690     if(!pen)
 691         return InvalidParameter;
 692
 693     if(dash != DashStyleCustom){
 694         heap_free(pen->dashes);
 695         pen->dashes = NULL;
 696         pen->numdashes = 0;
 697     }
 698
 699     pen->dash = dash;
 700     pen->style &= ~(PS_ALTERNATE | PS_SOLID | PS_DASH | PS_DOT | PS_DASHDOT |
 701                     PS_DASHDOTDOT | PS_NULL | PS_USERSTYLE | PS_INSIDEFRAME);
 702     pen->style |= gdip_to_gdi_dash(dash);
 703
 704     return Ok;
 705 }
 706
 707 GpStatus WINGDIPAPI GdipSetPenEndCap(GpPen *pen, GpLineCap cap)
 708 {
 709     TRACE("(%p, %d)\n", pen, cap);
 710
 711     if(!pen)    return InvalidParameter;
 712
 713     /* The old custom cap gets deleted even if the new style is LineCapCustom. */
 714     GdipDeleteCustomLineCap(pen->customend);
 715     pen->customend = NULL;
 716     pen->endcap = cap;
 717
 718     return Ok;
 719 }
 720
 721 /* FIXME: startcap, dashcap not used. */
 722 GpStatus WINGDIPAPI GdipSetPenLineCap197819(GpPen *pen, GpLineCap start,
 723     GpLineCap end, GpDashCap dash)
 724 {
 725     TRACE("%p, %d, %d, %d)\n", pen, start, end, dash);
 726
 727     if(!pen)
 728         return InvalidParameter;
 729
 730     GdipDeleteCustomLineCap(pen->customend);
 731     GdipDeleteCustomLineCap(pen->customstart);
 732     pen->customend = NULL;
 733     pen->customstart = NULL;
 734
 735     pen->startcap = start;
 736     pen->endcap = end;
 737     pen->dashcap = dash;
 738
 739     return Ok;
 740 }
 741
 742 /* FIXME: Miter line joins behave a bit differently than they do in windows.
 743  * Both kinds of miter joins clip if the angle is less than 11 degrees. */
 744 GpStatus WINGDIPAPI GdipSetPenLineJoin(GpPen *pen, GpLineJoin join)
 745 {
 746     TRACE("(%p, %d)\n", pen, join);
 747
 748     if(!pen)    return InvalidParameter;
 749
 750     pen->join = join;
 751     pen->style &= ~(PS_JOIN_ROUND | PS_JOIN_BEVEL | PS_JOIN_MITER);
 752     pen->style |= gdip_to_gdi_join(join);
 753
 754     return Ok;
 755 }
 756
 757 GpStatus WINGDIPAPI GdipSetPenMiterLimit(GpPen *pen, REAL limit)
 758 {
 759     TRACE("(%p, %.2f)\n", pen, limit);
 760
 761     if(!pen)
 762         return InvalidParameter;
 763
 764     pen->miterlimit = limit;
 765
 766     return Ok;
 767 }
 768
 769 GpStatus WINGDIPAPI GdipSetPenStartCap(GpPen *pen, GpLineCap cap)
 770 {
 771     TRACE("(%p, %d)\n", pen, cap);
 772
 773     if(!pen)    return InvalidParameter;
 774
 775     GdipDeleteCustomLineCap(pen->customstart);
 776     pen->customstart = NULL;
 777     pen->startcap = cap;
 778
 779     return Ok;
 780 }
 781
 782 GpStatus WINGDIPAPI GdipSetPenWidth(GpPen *pen, REAL width)
 783 {
 784     TRACE("(%p, %.2f)\n", pen, width);
 785
 786     if(!pen)    return InvalidParameter;
 787
 788     pen->width = width;
 789
 790     return Ok;
 791 }
 792
 793 GpStatus WINGDIPAPI GdipSetPenMode(GpPen *pen, GpPenAlignment mode)
 794 {
 795     TRACE("(%p, %d)\n", pen, mode);
 796
 797     if(!pen)    return InvalidParameter;
 798
 799     pen->align = mode;
 800
 801     return Ok;
 802 }