CPBezierPath.j

Go to the documentation of this file.

/*
 * CPBezierPath.j
 *
 * Created by Ross Boucher.
 * Copyright 2009, 280 North, Inc.
 *
 * Adapted from Kevin Wojniak, portions Copyright 2009 Kevin Wojniak.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 * Copyright 2009 280 North, Inc.
 */




// Class defaults

var DefaultLineWidth = 1.0;


@implementation CPBezierPath : CPObject
{
    CGPath  _path;
    float   _lineWidth;
    CPArray _lineDashes;
    float   _lineDashesPhase;
}

+ (CPBezierPath)bezierPath
{
    return [[self alloc] init];
}

+ (CPBezierPath)bezierPathWithOvalInRect:(CGRect)aRect
{
    var path = [self bezierPath];

    [path appendBezierPathWithOvalInRect:aRect];

    return path;
}

+ (CPBezierPath)bezierPathWithRect:(CGRect)aRect
{
    var path = [self bezierPath];

    [path appendBezierPathWithRect:aRect];

    return path;
}

+ (CPBezierPath)bezierPathWithRoundedRect:(CGRect)aRect xRadius:(float)xRadius yRadius:(float)yRadius
{
    var path = [self bezierPath];

    [path appendBezierPathWithRoundedRect:aRect xRadius:xRadius yRadius:yRadius];

    return path;
}

+ (float)defaultLineWidth
{
    return DefaultLineWidth;
}

+ (void)setDefaultLineWidth:(float)width
{
    DefaultLineWidth = width;
}

+ (void)fillRect:(CGRect)aRect
{
    [[self bezierPathWithRect:aRect] fill];
}

+ (void)strokeRect:(CGRect)aRect
{
    [[self bezierPathWithRect:aRect] stroke];
}

+ (void)strokeLineFromPoint:(CGPoint)point1 toPoint:(CGPoint)point2
{
    var path = [self bezierPath];

    [path moveToPoint:point1];
    [path lineToPoint:point2];

    [path stroke];
}

- (id)init
{
    if (self = [super init])
    {
        _path = CGPathCreateMutable();
        _lineWidth = [[self class] defaultLineWidth];
        _lineDashesPhase = 0;
        _lineDashes = [];
    }

    return self;
}

- (void)moveToPoint:(CGPoint)point
{
    CGPathMoveToPoint(_path, nil, point.x, point.y);
}

- (void)lineToPoint:(CGPoint)point
{
    CGPathAddLineToPoint(_path, nil, point.x, point.y);
}

- (void)curveToPoint:(CGPoint)endPoint controlPoint1:(CGPoint)controlPoint1 controlPoint2:(CGPoint)controlPoint2
{
    CGPathAddCurveToPoint(_path, nil, controlPoint1.x, controlPoint1.y, controlPoint2.x, controlPoint2.y, endPoint.x, endPoint.y);
}

- (CGRect)bounds
{
    // TODO: this should return this. The controlPointBounds is not a tight fit.
    // return CGPathGetBoundingBox(_path);

    return [self controlPointBounds];
}

- (CGRect)controlPointBounds
{
    return CGPathGetBoundingBox(_path);
}

- (void)closePath
{
    CGPathCloseSubpath(_path);
}

- (void)stroke
{
    var ctx = [[CPGraphicsContext currentContext] graphicsPort];

    CGContextBeginPath(ctx);
    CGContextAddPath(ctx, _path);
    CGContextSetLineWidth(ctx, [self lineWidth]);
    CGContextSetLineDash(ctx, _lineDashesPhase, _lineDashes);
    CGContextStrokePath(ctx);
}

- (void)fill
{
    var ctx = [[CPGraphicsContext currentContext] graphicsPort];

    CGContextBeginPath(ctx);
    CGContextAddPath(ctx, _path);
    CGContextSetLineWidth(ctx, [self lineWidth]);
    CGContextSetLineDash(ctx, _lineDashesPhase, _lineDashes);
    CGContextClosePath(ctx);
    CGContextFillPath(ctx);
}

- (void)getLineDash:(CPArrayRef)patternRef count:(NSInteger)count phase:(CGFloatRef)phaseRef
{
    return [self getLineDash:patternRef phase:phaseRef];
}

- (void)getLineDash:(CPArrayRef)patternRef phase:(CGFloatRef)phaseRef
{
    if (patternRef)
        @deref(patternRef) = [_lineDashes copy];
    if (phaseRef)
        @deref(phaseRef) = _lineDashesPhase;
}

- (void)setLineDash:(CPArray)aPattern count:(NSInteger)count phase:(CGFloat)aPhase
{
    [self setLineDash:aPattern phase:aPhase];
}

- (void)setLineDash:(CPArray)aPattern phase:(CGFloat)aPhase
{
    _lineDashes = aPattern;
    _lineDashesPhase = aPhase;
}

- (float)lineWidth
{
    return _lineWidth;
}

- (void)setLineWidth:(float)lineWidth
{
    _lineWidth = lineWidth;
}

- (unsigned)elementCount
{
    return _path.count;
}

- (BOOL)isEmpty
{
    return CGPathIsEmpty(_path);
}

- (CGPoint)currentPoint
{
    return CGPathGetCurrentPoint(_path);
}

- (void)appendBezierPathWithPoints:(CPArray)points count:(unsigned)count
{
    CGPathAddLines(_path, nil, points, count);
}

- (void)appendBezierPathWithRect:(CGRect)rect
{
    CGPathAddRect(_path, nil, rect);
}

- (void)appendBezierPathWithOvalInRect:(CGRect)rect
{
    CGPathAddPath(_path, nil, CGPathWithEllipseInRect(rect));
}

- (void)appendBezierPathWithRoundedRect:(CGRect)rect xRadius:(float)xRadius yRadius:(float)yRadius
{
    CGPathAddPath(_path, nil, CGPathWithRoundedRectangleInRect(rect, xRadius, yRadius, YES, YES, YES, YES));
}

- (void)appendBezierPathWithArcFromPoint:(CGPoint)fromPoint toPoint:(CGPoint)toPoint radius:(float)radius
{
    CGPathAddArcToPoint(_path, null, fromPoint.x, fromPoint.y, toPoint.x, toPoint.y, radius);
}

- (void)appendBezierPath:(CPBezierPath)other
{
    CGPathAddPath(_path, nil, other._path);
}

- (void)removeAllPoints
{
    _path = CGPathCreateMutable();
}

- (void)addClip
{
    var ctx = [[CPGraphicsContext currentContext] graphicsPort];

    CGContextAddPath(ctx, _path);
    CGContextClip(ctx);
}

- (void)setClip
{
    var ctx = [[CPGraphicsContext currentContext] graphicsPort];

    CGContextBeginPath(ctx);
    CGContextAddPath(ctx, _path);
    CGContextClip(ctx);
}

@end