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 /* FIXME: Sometimes when fillPath is non-null and stroke path is null, the native
 109  * version of this function returns NotImplemented. I cannot figure out why. */
 110 GpStatus WINGDIPAPI GdipCreateCustomLineCap(GpPath* fillPath, GpPath* strokePath,
 111     GpLineCap baseCap, REAL baseInset, GpCustomLineCap **customCap)
 112 {
 113     GpPathData *pathdata;
 114     GpStatus stat;
 115
 116     TRACE("%p %p %d %f %p\n", fillPath, strokePath, baseCap, baseInset, customCap);
 117
 118     if(!customCap || !(fillPath || strokePath))
 119         return InvalidParameter;
 120
 121     *customCap = heap_alloc_zero(sizeof(GpCustomLineCap));
 122     if(!*customCap)    return OutOfMemory;
 123
 124     if (strokePath)
 125         pathdata = &strokePath->pathdata;
 126     else
 127         pathdata = &fillPath->pathdata;
 128
 129     stat = init_custom_linecap(*customCap, pathdata, fillPath != NULL, baseCap, baseInset);
 130     if (stat != Ok)
 131     {
 132         heap_free(*customCap);
 133         return stat;
 134     }
 135
 136     TRACE("<-- %p\n", *customCap);
 137
 138     return Ok;
 139 }
 140
 141 GpStatus WINGDIPAPI GdipDeleteCustomLineCap(GpCustomLineCap *customCap)
 142 {
 143     TRACE("(%p)\n", customCap);
 144
 145     if(!customCap)
 146         return InvalidParameter;
 147
 148     heap_free(customCap->pathdata.Points);
 149     heap_free(customCap->pathdata.Types);
 150     heap_free(customCap);
 151
 152     return Ok;
 153 }
 154
 155 GpStatus WINGDIPAPI GdipGetCustomLineCapStrokeJoin(GpCustomLineCap* customCap,
 156     GpLineJoin* lineJoin)
 157 {
 158     TRACE("(%p, %p)\n", customCap, lineJoin);
 159
 160     if(!customCap || !lineJoin)
 161         return InvalidParameter;
 162
 163     *lineJoin = customCap->join;
 164
 165     return Ok;
 166 }
 167
 168 GpStatus WINGDIPAPI GdipGetCustomLineCapWidthScale(GpCustomLineCap* custom,
 169     REAL* widthScale)
 170 {
 171     TRACE("(%p, %p)\n", custom, widthScale);
 172
 173     if(!custom || !widthScale)
 174         return InvalidParameter;
 175
 176     *widthScale = custom->scale;
 177
 178     return Ok;
 179 }
 180
 181 GpStatus WINGDIPAPI GdipSetCustomLineCapStrokeCaps(GpCustomLineCap* custom,
 182     GpLineCap startcap, GpLineCap endcap)
 183 {
 184     TRACE("(%p,%u,%u)\n", custom, startcap, endcap);
 185
 186     if(!custom || startcap > LineCapTriangle || endcap > LineCapTriangle)
 187         return InvalidParameter;
 188
 189     custom->strokeStartCap = startcap;
 190     custom->strokeEndCap = endcap;
 191
 192     return Ok;
 193 }
 194
 195 GpStatus WINGDIPAPI GdipSetCustomLineCapBaseCap(GpCustomLineCap* custom,
 196     GpLineCap basecap)
 197 {
 198     TRACE("(%p,%u)\n", custom, basecap);
 199     if(!custom || basecap > LineCapTriangle)
 200         return InvalidParameter;
 201
 202     custom->basecap = basecap;
 203
 204     return Ok;
 205 }
 206
 207 GpStatus WINGDIPAPI GdipGetCustomLineCapBaseInset(GpCustomLineCap* custom,
 208     REAL* inset)
 209 {
 210     TRACE("(%p, %p)\n", custom, inset);
 211
 212     if(!custom || !inset)
 213         return InvalidParameter;
 214
 215     *inset = custom->inset;
 216
 217     return Ok;
 218 }
 219
 220 GpStatus WINGDIPAPI GdipSetCustomLineCapBaseInset(GpCustomLineCap* custom,
 221     REAL inset)
 222 {
 223     TRACE("(%p,%0.2f)\n", custom, inset);
 224
 225     if(!custom)
 226         return InvalidParameter;
 227
 228     custom->inset = inset;
 229
 230     return Ok;
 231 }
 232
 233 /*FIXME: LineJoin completely ignored now */
 234 GpStatus WINGDIPAPI GdipSetCustomLineCapStrokeJoin(GpCustomLineCap* custom,
 235     GpLineJoin join)
 236 {
 237     TRACE("(%p, %d)\n", custom, join);
 238
 239     if(!custom)
 240         return InvalidParameter;
 241
 242     custom->join = join;
 243
 244     return Ok;
 245 }
 246
 247 GpStatus WINGDIPAPI GdipSetCustomLineCapWidthScale(GpCustomLineCap* custom, REAL width)
 248 {
 249     TRACE("(%p,%0.2f)\n", custom, width);
 250
 251     if(!custom)
 252         return InvalidParameter;
 253
 254     custom->scale = width;
 255
 256     return Ok;
 257 }
 258
 259 GpStatus WINGDIPAPI GdipGetCustomLineCapBaseCap(GpCustomLineCap *customCap, GpLineCap *baseCap)
 260 {
 261     TRACE("(%p, %p)\n", customCap, baseCap);
 262
 263     if(!customCap || !baseCap)
 264         return InvalidParameter;
 265
 266     *baseCap = customCap->basecap;
 267
 268     return Ok;
 269 }
 270
 271 GpStatus WINGDIPAPI GdipGetCustomLineCapType(GpCustomLineCap *customCap, CustomLineCapType *type)
 272 {
 273     TRACE("(%p, %p)\n", customCap, type);
 274
 275     if(!customCap || !type)
 276         return InvalidParameter;
 277
 278     *type = customCap->type;
 279     return Ok;
 280 }
 281
 282 static void arrowcap_update_path(GpAdjustableArrowCap *cap)
 283 {
 284     static const BYTE types_filled[] =
 285     {
 286         PathPointTypeStart, PathPointTypeLine, PathPointTypeLine, PathPointTypeLine | PathPointTypeCloseSubpath
 287     };
 288     static const BYTE types_unfilled[] =
 289     {
 290         PathPointTypeStart, PathPointTypeLine, PathPointTypeLine
 291     };
 292     GpPointF *points;
 293
 294     assert(cap->cap.pathdata.Count == 3 || cap->cap.pathdata.Count == 4);
 295
 296     points = cap->cap.pathdata.Points;
 297     if (cap->cap.fill)
 298     {
 299         memcpy(cap->cap.pathdata.Types, types_filled, sizeof(types_filled));
 300         cap->cap.pathdata.Count = 4;
 301         points[0].X = -cap->width / 2.0;
 302         points[0].Y = -cap->height;
 303         points[1].X = 0.0;
 304         points[1].Y = 0.0;
 305         points[2].X = cap->width / 2.0;
 306         points[2].Y = -cap->height;
 307         points[3].X = 0.0;
 308         points[3].Y = -cap->height + cap->middle_inset;
 309     }
 310     else
 311     {
 312         memcpy(cap->cap.pathdata.Types, types_unfilled, sizeof(types_unfilled));
 313         cap->cap.pathdata.Count = 3;
 314         points[0].X = -cap->width / 2.0;
 315         points[0].Y = -cap->height;
 316         points[1].X = 0.0;
 317         points[1].Y = 0.0;
 318         points[2].X = cap->width / 2.0;
 319         points[2].Y = -cap->height;
 320     }
 321
 322     if (cap->width == 0.0)
 323         cap->cap.inset = 0.0;
 324     else
 325         cap->cap.inset = cap->height / cap->width;
 326 }
 327
 328 GpStatus WINGDIPAPI GdipCreateAdjustableArrowCap(REAL height, REAL width, BOOL fill,
 329     GpAdjustableArrowCap **cap)
 330 {
 331     GpPathData pathdata;
 332     GpStatus stat;
 333
 334     TRACE("(%0.2f,%0.2f,%i,%p)\n", height, width, fill, cap);
 335
 336     if (!cap)
 337         return InvalidParameter;
 338
 339     *cap = heap_alloc_zero(sizeof(**cap));
 340     if (!*cap)
 341         return OutOfMemory;
 342
 343     /* We'll need 4 points at most. */
 344     pathdata.Count = 4;
 345     pathdata.Points = NULL;
 346     pathdata.Types = NULL;
 347     stat = init_custom_linecap(&(*cap)->cap, &pathdata, fill, LineCapTriangle, width != 0.0 ? height / width : 0.0);
 348     if (stat != Ok)
 349     {
 350         heap_free(*cap);
 351         return stat;
 352     }
 353
 354     (*cap)->cap.type = CustomLineCapTypeAdjustableArrow;
 355     (*cap)->height = height;
 356     (*cap)->width = width;
 357     (*cap)->middle_inset = 0.0;
 358     arrowcap_update_path(*cap);
 359
 360     return Ok;
 361 }
 362
 363 GpStatus WINGDIPAPI GdipGetAdjustableArrowCapFillState(GpAdjustableArrowCap* cap, BOOL* fill)
 364 {
 365     TRACE("(%p,%p)\n", cap, fill);
 366
 367     if (!cap || !fill)
 368         return InvalidParameter;
 369
 370     *fill = cap->cap.fill;
 371     return Ok;
 372 }
 373
 374 GpStatus WINGDIPAPI GdipGetAdjustableArrowCapHeight(GpAdjustableArrowCap* cap, REAL* height)
 375 {
 376     TRACE("(%p,%p)\n", cap, height);
 377
 378     if (!cap || !height)
 379         return InvalidParameter;
 380
 381     *height = cap->height;
 382     return Ok;
 383 }
 384
 385 GpStatus WINGDIPAPI GdipGetAdjustableArrowCapMiddleInset(GpAdjustableArrowCap* cap, REAL* middle)
 386 {
 387     TRACE("(%p,%p)\n", cap, middle);
 388
 389     if (!cap || !middle)
 390         return InvalidParameter;
 391
 392     *middle = cap->middle_inset;
 393     return Ok;
 394 }
 395
 396 GpStatus WINGDIPAPI GdipGetAdjustableArrowCapWidth(GpAdjustableArrowCap* cap, REAL* width)
 397 {
 398     TRACE("(%p,%p)\n", cap, width);
 399
 400     if (!cap || !width)
 401         return InvalidParameter;
 402
 403     *width = cap->width;
 404     return Ok;
 405 }
 406
 407 GpStatus WINGDIPAPI GdipSetAdjustableArrowCapFillState(GpAdjustableArrowCap* cap, BOOL fill)
 408 {
 409     TRACE("(%p,%i)\n", cap, fill);
 410
 411     if (!cap)
 412         return InvalidParameter;
 413
 414     cap->cap.fill = fill;
 415     arrowcap_update_path(cap);
 416     return Ok;
 417 }
 418
 419 GpStatus WINGDIPAPI GdipSetAdjustableArrowCapHeight(GpAdjustableArrowCap* cap, REAL height)
 420 {
 421     TRACE("(%p,%0.2f)\n", cap, height);
 422
 423     if (!cap)
 424         return InvalidParameter;
 425
 426     cap->height = height;
 427     arrowcap_update_path(cap);
 428     return Ok;
 429 }
 430
 431 GpStatus WINGDIPAPI GdipSetAdjustableArrowCapMiddleInset(GpAdjustableArrowCap* cap, REAL middle)
 432 {
 433     TRACE("(%p,%0.2f)\n", cap, middle);
 434
 435     if (!cap)
 436         return InvalidParameter;
 437
 438     cap->middle_inset = middle;
 439     arrowcap_update_path(cap);
 440     return Ok;
 441 }
 442
 443 GpStatus WINGDIPAPI GdipSetAdjustableArrowCapWidth(GpAdjustableArrowCap* cap, REAL width)
 444 {
 445     TRACE("(%p,%0.2f)\n", cap, width);
 446
 447     if (!cap)
 448         return InvalidParameter;
 449
 450     cap->width = width;
 451     arrowcap_update_path(cap);
 452     return Ok;
 453 }