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 #include "gdiplus.h"
  25 #include "gdiplus_private.h"
  26 #include "wine/debug.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
  29
  30 static DWORD gdip_to_gdi_dash(GpDashStyle dash)
  31 {
  32     static int calls;
  33
  34     switch(dash){
  35         case DashStyleSolid:
  36             return PS_SOLID;
  37         case DashStyleDash:
  38             return PS_DASH;
  39         case DashStyleDot:
  40             return PS_DOT;
  41         case DashStyleDashDot:
  42             return PS_DASHDOT;
  43         case DashStyleDashDotDot:
  44             return PS_DASHDOTDOT;
  45         case DashStyleCustom:
  46             if(!(calls++))
  47                 FIXME("DashStyleCustom not implemented\n");
  48             return PS_SOLID;
  49         default:
  50             ERR("Not a member of GpDashStyle enumeration\n");
  51             return 0;
  52     }
  53 }
  54
  55 static DWORD gdip_to_gdi_join(GpLineJoin join)
  56 {
  57     switch(join){
  58         case LineJoinRound:
  59             return PS_JOIN_ROUND;
  60         case LineJoinBevel:
  61             return PS_JOIN_BEVEL;
  62         case LineJoinMiter:
  63         case LineJoinMiterClipped:
  64             return PS_JOIN_MITER;
  65         default:
  66             ERR("Not a member of GpLineJoin enumeration\n");
  67             return 0;
  68     }
  69 }
  70
  71 GpStatus WINGDIPAPI GdipClonePen(GpPen *pen, GpPen **clonepen)
  72 {
  73     if(!pen || !clonepen)
  74         return InvalidParameter;
  75
  76     *clonepen = GdipAlloc(sizeof(GpPen));
  77     if(!*clonepen)  return OutOfMemory;
  78
  79     memcpy(*clonepen, pen, sizeof(GpPen));
  80
  81     GdipCloneCustomLineCap(pen->customstart, &(*clonepen)->customstart);
  82     GdipCloneCustomLineCap(pen->customend, &(*clonepen)->customend);
  83     GdipCloneBrush(pen->brush, &(*clonepen)->brush);
  84
  85     return Ok;
  86 }
  87
  88 GpStatus WINGDIPAPI GdipCreatePen1(ARGB color, FLOAT width, GpUnit unit,
  89     GpPen **pen)
  90 {
  91     GpPen *gp_pen;
  92
  93     if(!pen)
  94         return InvalidParameter;
  95
  96     gp_pen = GdipAlloc(sizeof(GpPen));
  97     if(!gp_pen)    return OutOfMemory;
  98
  99     gp_pen->style = GP_DEFAULT_PENSTYLE;
 100     gp_pen->width = width;
 101     gp_pen->unit = unit;
 102     gp_pen->endcap = LineCapFlat;
 103     gp_pen->join = LineJoinMiter;
 104     gp_pen->miterlimit = 10.0;
 105     gp_pen->dash = DashStyleSolid;
 106     GdipCreateSolidFill(color, (GpSolidFill **)(&gp_pen->brush));
 107
 108     if(!((gp_pen->unit == UnitWorld) || (gp_pen->unit == UnitPixel))) {
 109         FIXME("UnitWorld, UnitPixel only supported units\n");
 110         GdipFree(gp_pen);
 111         return NotImplemented;
 112     }
 113
 114     *pen = gp_pen;
 115
 116     return Ok;
 117 }
 118
 119 GpStatus WINGDIPAPI GdipDeletePen(GpPen *pen)
 120 {
 121     if(!pen)    return InvalidParameter;
 122
 123     GdipDeleteBrush(pen->brush);
 124     GdipDeleteCustomLineCap(pen->customstart);
 125     GdipDeleteCustomLineCap(pen->customend);
 126     GdipFree(pen->dashes);
 127     GdipFree(pen);
 128
 129     return Ok;
 130 }
 131
 132 GpStatus WINGDIPAPI GdipGetPenBrushFill(GpPen *pen, GpBrush **brush)
 133 {
 134     if(!pen || !brush)
 135         return InvalidParameter;
 136
 137     return GdipCloneBrush(pen->brush, brush);
 138 }
 139
 140 GpStatus WINGDIPAPI GdipGetPenColor(GpPen *pen, ARGB *argb)
 141 {
 142     if(!pen || !argb)
 143         return InvalidParameter;
 144
 145     if(pen->brush->bt != BrushTypeSolidColor)
 146         return NotImplemented;
 147
 148     return GdipGetSolidFillColor(((GpSolidFill*)pen->brush), argb);
 149 }
 150
 151 GpStatus WINGDIPAPI GdipGetPenDashArray(GpPen *pen, REAL *dash, INT count)
 152 {
 153     if(!pen || !dash || count > pen->numdashes)
 154         return InvalidParameter;
 155
 156     /* note: if you pass a negative value for count, it crashes native gdiplus. */
 157     if(count < 0)
 158         return GenericError;
 159
 160     memcpy(dash, pen->dashes, count * sizeof(REAL));
 161
 162     return Ok;
 163 }
 164
 165 GpStatus WINGDIPAPI GdipGetPenDashStyle(GpPen *pen, GpDashStyle *dash)
 166 {
 167     if(!pen || !dash)
 168         return InvalidParameter;
 169
 170     *dash = pen->dash;
 171
 172     return Ok;
 173 }
 174
 175 GpStatus WINGDIPAPI GdipSetPenBrushFill(GpPen *pen, GpBrush *brush)
 176 {
 177     if(!pen || !brush)
 178         return InvalidParameter;
 179
 180     GdipDeleteBrush(pen->brush);
 181     return GdipCloneBrush(brush, &pen->brush);
 182 }
 183
 184 GpStatus WINGDIPAPI GdipSetPenColor(GpPen *pen, ARGB argb)
 185 {
 186     if(!pen)
 187         return InvalidParameter;
 188
 189     if(pen->brush->bt != BrushTypeSolidColor)
 190         return NotImplemented;
 191
 192     return GdipSetSolidFillColor(((GpSolidFill*)pen->brush), argb);
 193 }
 194
 195 GpStatus WINGDIPAPI GdipSetPenCustomEndCap(GpPen *pen, GpCustomLineCap* customCap)
 196 {
 197     GpCustomLineCap * cap;
 198     GpStatus ret;
 199
 200     if(!pen || !customCap) return InvalidParameter;
 201
 202     if((ret = GdipCloneCustomLineCap(customCap, &cap)) == Ok){
 203         GdipDeleteCustomLineCap(pen->customend);
 204         pen->endcap = LineCapCustom;
 205         pen->customend = cap;
 206     }
 207
 208     return ret;
 209 }
 210
 211 GpStatus WINGDIPAPI GdipSetPenCustomStartCap(GpPen *pen, GpCustomLineCap* customCap)
 212 {
 213     GpCustomLineCap * cap;
 214     GpStatus ret;
 215
 216     if(!pen || !customCap) return InvalidParameter;
 217
 218     if((ret = GdipCloneCustomLineCap(customCap, &cap)) == Ok){
 219         GdipDeleteCustomLineCap(pen->customstart);
 220         pen->startcap = LineCapCustom;
 221         pen->customstart = cap;
 222     }
 223
 224     return ret;
 225 }
 226
 227 GpStatus WINGDIPAPI GdipSetPenDashArray(GpPen *pen, GDIPCONST REAL *dash,
 228     INT count)
 229 {
 230     if(!pen || !dash)
 231         return InvalidParameter;
 232
 233     GdipFree(pen->dashes);
 234     pen->dashes = NULL;
 235
 236     if(count > 0)
 237         pen->dashes = GdipAlloc(count * sizeof(REAL));
 238     if(!pen->dashes){
 239         pen->numdashes = 0;
 240         return OutOfMemory;
 241     }
 242
 243     pen->dash = DashStyleCustom;
 244     memcpy(pen->dashes, dash, count * sizeof(REAL));
 245     pen->numdashes = count;
 246
 247     return Ok;
 248 }
 249
 250 GpStatus WINGDIPAPI GdipSetPenDashStyle(GpPen *pen, GpDashStyle dash)
 251 {
 252     if(!pen)
 253         return InvalidParameter;
 254
 255     if(dash != DashStyleCustom){
 256         GdipFree(pen->dashes);
 257         pen->dashes = NULL;
 258         pen->numdashes = 0;
 259     }
 260
 261     pen->dash = dash;
 262     pen->style &= ~(PS_ALTERNATE | PS_SOLID | PS_DASH | PS_DOT | PS_DASHDOT |
 263                     PS_DASHDOTDOT | PS_NULL | PS_USERSTYLE | PS_INSIDEFRAME);
 264     pen->style |= gdip_to_gdi_dash(dash);
 265
 266     return Ok;
 267 }
 268
 269 GpStatus WINGDIPAPI GdipSetPenEndCap(GpPen *pen, GpLineCap cap)
 270 {
 271     if(!pen)    return InvalidParameter;
 272
 273     /* The old custom cap gets deleted even if the new style is LineCapCustom. */
 274     GdipDeleteCustomLineCap(pen->customend);
 275     pen->customend = NULL;
 276     pen->endcap = cap;
 277
 278     return Ok;
 279 }
 280
 281 /* FIXME: startcap, dashcap not used. */
 282 GpStatus WINGDIPAPI GdipSetPenLineCap197819(GpPen *pen, GpLineCap start,
 283     GpLineCap end, GpDashCap dash)
 284 {
 285     if(!pen)
 286         return InvalidParameter;
 287
 288     GdipDeleteCustomLineCap(pen->customend);
 289     GdipDeleteCustomLineCap(pen->customstart);
 290     pen->customend = NULL;
 291     pen->customstart = NULL;
 292
 293     pen->startcap = start;
 294     pen->endcap = end;
 295     pen->dashcap = dash;
 296
 297     return Ok;
 298 }
 299
 300 /* FIXME: Miter line joins behave a bit differently than they do in windows.
 301  * Both kinds of miter joins clip if the angle is less than 11 degrees. */
 302 GpStatus WINGDIPAPI GdipSetPenLineJoin(GpPen *pen, GpLineJoin join)
 303 {
 304     if(!pen)    return InvalidParameter;
 305
 306     pen->join = join;
 307     pen->style &= ~(PS_JOIN_ROUND | PS_JOIN_BEVEL | PS_JOIN_MITER);
 308     pen->style |= gdip_to_gdi_join(join);
 309
 310     return Ok;
 311 }
 312
 313 GpStatus WINGDIPAPI GdipSetPenMiterLimit(GpPen *pen, REAL limit)
 314 {
 315     if(!pen)
 316         return InvalidParameter;
 317
 318     pen->miterlimit = limit;
 319
 320     return Ok;
 321 }
 322
 323 GpStatus WINGDIPAPI GdipSetPenStartCap(GpPen *pen, GpLineCap cap)
 324 {
 325     if(!pen)    return InvalidParameter;
 326
 327     GdipDeleteCustomLineCap(pen->customstart);
 328     pen->customstart = NULL;
 329     pen->startcap = cap;
 330
 331     return Ok;
 332 }