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