#import "CPTBarPlot.h"

#import "CPTColor.h"

#import "CPTExceptions.h"

#import "CPTGradient.h"

#import "CPTLegend.h"

#import "CPTMutableLineStyle.h"

#import "CPTMutableNumericData.h"

#import "CPTMutablePlotRange.h"

#import "CPTPathExtensions.h"

#import "CPTPlotArea.h"

#import "CPTPlotSpaceAnnotation.h"

#import "CPTUtilities.h"

#import "CPTXYPlotSpace.h"

#import "NSCoderExtensions.h"

#import <tgmath.h>

/** @defgroup plotAnimationBarPlot Bar Plot

* @brief Bar plot properties that can be animated using Core Animation.

* @ingroup plotAnimation

**/

/** @if MacOnly

* @defgroup plotBindingsBarPlot Bar Plot Bindings

* @brief Binding identifiers for bar plots.

* @ingroup plotBindings

* @endif

**/

NSString *const CPTBarPlotBindingBarLocations = @"barLocations"; ///< Bar locations.

NSString *const CPTBarPlotBindingBarTips = @"barTips"; ///< Bar tips.

NSString *const CPTBarPlotBindingBarBases = @"barBases"; ///< Bar bases.

NSString *const CPTBarPlotBindingBarFills = @"barFills"; ///< Bar fills.

NSString *const CPTBarPlotBindingBarLineStyles = @"barLineStyles"; ///< Bar line styles.

/// @cond

@interface CPTBarPlot()

@property (nonatomic, readwrite, copy, nullable) CPTNumberArray barLocations;

@property (nonatomic, readwrite, copy, nullable) CPTNumberArray barTips;

@property (nonatomic, readwrite, copy, nullable) CPTNumberArray barBases;

@property (nonatomic, readwrite, copy, nullable) CPTFillArray barFills;

@property (nonatomic, readwrite, copy, nullable) CPTLineStyleArray barLineStyles;

@property (nonatomic, readwrite, assign) NSUInteger pointingDeviceDownIndex;

-(BOOL)barAtRecordIndex:(NSUInteger)idx basePoint:(nonnull CGPoint *)basePoint tipPoint:(nonnull CGPoint *)tipPoint;

-(nonnull CGMutablePathRef)newBarPathWithContext:(nullable CGContextRef)context recordIndex:(NSUInteger)recordIndex;

-(nonnull CGMutablePathRef)newBarPathWithContext:(nullable CGContextRef)context basePoint:(CGPoint)basePoint tipPoint:(CGPoint)tipPoint;

-(nullable CPTFill *)barFillForIndex:(NSUInteger)idx;

-(nullable CPTLineStyle *)barLineStyleForIndex:(NSUInteger)idx;

-(void)drawBarInContext:(nonnull CGContextRef)context recordIndex:(NSUInteger)idx;

-(CGFloat)lengthInView:(NSDecimal)plotLength;

-(double)doubleLengthInPlotCoordinates:(NSDecimal)decimalLength;

-(BOOL)barIsVisibleWithBasePoint:(CGPoint)basePoint;

@end

/// @endcond

#pragma mark -

/**

* @brief A two-dimensional bar plot.

* @see See @ref plotAnimationBarPlot "Bar Plot" for a list of animatable properties.

* @if MacOnly

* @see See @ref plotBindingsBarPlot "Bar Plot Bindings" for a list of supported binding identifiers.

* @endif

**/

@implementation CPTBarPlot

@dynamic barLocations;

@dynamic barTips;

@dynamic barBases;

@dynamic barFills;

@dynamic barLineStyles;

/** @property CGFloat barCornerRadius

* @brief The corner radius for the end of the bars. Default is @num{0.0} for square corners.

* @ingroup plotAnimationBarPlot

**/

@synthesize barCornerRadius;

/** @property CGFloat barBaseCornerRadius

* @brief The corner radius for the end of the bars drawn at the base value. Default is @num{0.0} for square corners.

* @ingroup plotAnimationBarPlot

**/

@synthesize barBaseCornerRadius;

/** @property nonnull NSNumber *barOffset

* @brief The starting offset of the first bar in location data units.

* @ingroup plotAnimationBarPlot

**/

@synthesize barOffset;

/** @property BOOL barWidthsAreInViewCoordinates

* @brief Whether the bar width and bar offset is in view coordinates, or in plot coordinates.

* Default is @NO, meaning plot coordinates are used.

**/

@synthesize barWidthsAreInViewCoordinates;

/** @property nonnull NSNumber *barWidth

* @brief The width of each bar. Either view or plot coordinates can be used.

*

* With plot coordinates, the bar locations are one data unit apart (e.g., 1, 2, 3, etc.),

* a value of @num{1.0} will result in bars that touch each other; a value of @num{0.5} will result in bars that are as wide

* as the gap between them.

*

* @see barWidthsAreInViewCoordinates

* @ingroup plotAnimationBarPlot

**/

@synthesize barWidth;

/** @property nullable CPTLineStyle *lineStyle

* @brief The line style for the bar outline.

* If @nil, the outline is not drawn.

**/

@synthesize lineStyle;

/** @property nullable CPTFill *fill

* @brief The fill style for the bars.

* If @nil, the bars are not filled.

**/

@synthesize fill;

/** @property BOOL barsAreHorizontal

* @brief If @YES, the bars will have a horizontal orientation, otherwise they will be vertical.

**/

@synthesize barsAreHorizontal;

/** @property nonnull NSNumber *baseValue

* @brief The coordinate value of the fixed end of the bars.

* This is only used if @ref barBasesVary is @NO. Otherwise, the data source

* will be queried for an appropriate value of #CPTBarPlotFieldBarBase.

* @ingroup plotAnimationBarPlot

**/

@synthesize baseValue;

/** @property BOOL barBasesVary

* @brief If @NO, a constant base value is used for all bars.

* If @YES, the data source is queried to supply a base value for each bar.

* @see baseValue

**/

@synthesize barBasesVary;

/** @property nullable CPTPlotRange *plotRange

* @brief Sets the plot range for the independent axis.

*

* If a plot range is provided, the bars are spaced evenly throughout the plot range. If @ref plotRange is @nil,

* bar locations are provided by Cocoa bindings or the bar plot datasource. If locations are not provided by

* either bindings or the datasource, the first bar will be placed at zero (@num{0}) and subsequent bars will be at

* successive positive integer coordinates.

**/

@synthesize plotRange;

/** @internal

* @property NSUInteger pointingDeviceDownIndex

* @brief The index that was selected on the pointing device down event.

**/

@synthesize pointingDeviceDownIndex;

#pragma mark -

#pragma mark Convenience Factory Methods

/** @brief Creates and returns a new CPTBarPlot instance initialized with a bar fill consisting of a linear gradient between black and the given color.

* @param color The beginning color.

* @param horizontal If @YES, the bars will have a horizontal orientation, otherwise they will be vertical.

* @return A new CPTBarPlot instance initialized with a linear gradient bar fill.

**/

+(nonnull instancetype)tubularBarPlotWithColor:(nonnull CPTColor *)color horizontalBars:(BOOL)horizontal

{

CPTBarPlot *barPlot = [[CPTBarPlot alloc] init];

CPTMutableLineStyle *barLineStyle = [[CPTMutableLineStyle alloc] init];

barLineStyle.lineWidth = CPTFloat(1.0);

barLineStyle.lineColor = [CPTColor blackColor];

barPlot.lineStyle = barLineStyle;

barPlot.barsAreHorizontal = horizontal;

barPlot.barWidth = @0.8;

barPlot.barCornerRadius = CPTFloat(2.0);

CPTGradient *fillGradient = [CPTGradient gradientWithBeginningColor:color endingColor:[CPTColor blackColor]];

fillGradient.angle = CPTFloat(horizontal ? -90.0 : 0.0);

barPlot.fill = [CPTFill fillWithGradient:fillGradient];

barPlot.barWidthsAreInViewCoordinates = NO;

return barPlot;

}

#pragma mark -

#pragma mark Init/Dealloc

/// @cond

#if TARGET_IPHONE_SIMULATOR || TARGET_OS_IPHONE

#else

+(void)initialize

{

if ( self == [CPTBarPlot class] ) {

[self exposeBinding:CPTBarPlotBindingBarLocations];

[self exposeBinding:CPTBarPlotBindingBarTips];

[self exposeBinding:CPTBarPlotBindingBarBases];

[self exposeBinding:CPTBarPlotBindingBarFills];

[self exposeBinding:CPTBarPlotBindingBarLineStyles];

}

}

#endif

/// @endcond

/// @name Initialization

/// @{

/** @brief Initializes a newly allocated CPTBarPlot object with the provided frame rectangle.

*

* This is the designated initializer. The initialized layer will have the following properties:

* - @ref lineStyle = default line style

* - @ref fill = solid black fill

* - @ref barWidth = @num{0.5}

* - @ref barWidthsAreInViewCoordinates = @NO

* - @ref barOffset = @num{0.0}

* - @ref barCornerRadius = @num{0.0}

* - @ref barBaseCornerRadius = @num{0.0}

* - @ref baseValue = @num{0}

* - @ref barsAreHorizontal = @NO

* - @ref barBasesVary = @NO

* - @ref plotRange = @nil

* - @ref labelOffset = @num{10.0}

* - @ref labelField = #CPTBarPlotFieldBarTip

*

* @param newFrame The frame rectangle.

* @return The initialized CPTBarPlot object.

**/

-(nonnull instancetype)initWithFrame:(CGRect)newFrame

{

if ( (self = [super initWithFrame:newFrame]) ) {

lineStyle = [[CPTLineStyle alloc] init];

fill = [CPTFill fillWithColor:[CPTColor blackColor]];

barWidth = @0.5;

barWidthsAreInViewCoordinates = NO;

barOffset = @0.0;

barCornerRadius = CPTFloat(0.0);

barBaseCornerRadius = CPTFloat(0.0);

baseValue = @0.0;

barsAreHorizontal = NO;

barBasesVary = NO;

plotRange = nil;

pointingDeviceDownIndex = NSNotFound;

self.labelOffset = CPTFloat(10.0);

self.labelField = CPTBarPlotFieldBarTip;

}

return self;

}

/// @}

/// @cond

-(nonnull instancetype)initWithLayer:(nonnull id)layer

{

if ( (self = [super initWithLayer:layer]) ) {

CPTBarPlot *theLayer = (CPTBarPlot *)layer;

lineStyle = theLayer->lineStyle;

fill = theLayer->fill;

barWidth = theLayer->barWidth;

barWidthsAreInViewCoordinates = theLayer->barWidthsAreInViewCoordinates;

barOffset = theLayer->barOffset;

barCornerRadius = theLayer->barCornerRadius;

barBaseCornerRadius = theLayer->barBaseCornerRadius;

baseValue = theLayer->baseValue;

barBasesVary = theLayer->barBasesVary;

barsAreHorizontal = theLayer->barsAreHorizontal;

plotRange = theLayer->plotRange;

pointingDeviceDownIndex = NSNotFound;

}

return self;

}

/// @endcond

#pragma mark -

#pragma mark NSCoding Methods

/// @cond

-(void)encodeWithCoder:(nonnull NSCoder *)coder

{

[super encodeWithCoder:coder];

[coder encodeObject:self.lineStyle forKey:@"CPTBarPlot.lineStyle"];

[coder encodeObject:self.fill forKey:@"CPTBarPlot.fill"];

[coder encodeObject:self.barWidth forKey:@"CPTBarPlot.barWidth"];

[coder encodeObject:self.barOffset forKey:@"CPTBarPlot.barOffset"];

[coder encodeCGFloat:self.barCornerRadius forKey:@"CPTBarPlot.barCornerRadius"];

[coder encodeCGFloat:self.barBaseCornerRadius forKey:@"CPTBarPlot.barBaseCornerRadius"];

[coder encodeObject:self.baseValue forKey:@"CPTBarPlot.baseValue"];

[coder encodeBool:self.barsAreHorizontal forKey:@"CPTBarPlot.barsAreHorizontal"];

[coder encodeBool:self.barBasesVary forKey:@"CPTBarPlot.barBasesVary"];

[coder encodeBool:self.barWidthsAreInViewCoordinates forKey:@"CPTBarPlot.barWidthsAreInViewCoordinates"];

[coder encodeObject:self.plotRange forKey:@"CPTBarPlot.plotRange"];

// No need to archive these properties:

// pointingDeviceDownIndex

}

-(nullable instancetype)initWithCoder:(nonnull NSCoder *)coder

{

if ( (self = [super initWithCoder:coder]) ) {

NSNumber *num;

lineStyle = [[coder decodeObjectForKey:@"CPTBarPlot.lineStyle"] copy];

fill = [[coder decodeObjectForKey:@"CPTBarPlot.fill"] copy];

num = [coder decodeObjectForKey:@"CPTBarPlot.barWidth"];

barWidth = num ? num : @0.0;

num = [coder decodeObjectForKey:@"CPTBarPlot.barOffset"];

barOffset = num ? num : @0.0;

barCornerRadius = [coder decodeCGFloatForKey:@"CPTBarPlot.barCornerRadius"];

barBaseCornerRadius = [coder decodeCGFloatForKey:@"CPTBarPlot.barBaseCornerRadius"];

num = [coder decodeObjectForKey:@"CPTBarPlot.baseValue"];

baseValue = num ? num : @0.0;

barsAreHorizontal = [coder decodeBoolForKey:@"CPTBarPlot.barsAreHorizontal"];

barBasesVary = [coder decodeBoolForKey:@"CPTBarPlot.barBasesVary"];

barWidthsAreInViewCoordinates = [coder decodeBoolForKey:@"CPTBarPlot.barWidthsAreInViewCoordinates"];

plotRange = [[coder decodeObjectForKey:@"CPTBarPlot.plotRange"] copy];

pointingDeviceDownIndex = NSNotFound;

}

return self;

}

/// @endcond

#pragma mark -

#pragma mark Data Loading

/// @cond

-(void)reloadDataInIndexRange:(NSRange)indexRange

{

[super reloadDataInIndexRange:indexRange];

// Bar fills

[self reloadBarFillsInIndexRange:indexRange];

// Bar line styles

[self reloadBarLineStylesInIndexRange:indexRange];

// Legend

id<CPTBarPlotDataSource> theDataSource = (id<CPTBarPlotDataSource>)self.dataSource;

if ( [theDataSource respondsToSelector:@selector(legendTitleForBarPlot:recordIndex:)] ) {

[[NSNotificationCenter defaultCenter] postNotificationName:CPTLegendNeedsRedrawForPlotNotification object:self];

}

}

-(void)reloadPlotDataInIndexRange:(NSRange)indexRange

{

[super reloadPlotDataInIndexRange:indexRange];

if ( ![self loadNumbersForAllFieldsFromDataSourceInRecordIndexRange:indexRange] ) {

id<CPTBarPlotDataSource> theDataSource = (id<CPTBarPlotDataSource>)self.dataSource;

// Bar lengths

if ( theDataSource ) {

id newBarLengths = [self numbersFromDataSourceForField:CPTBarPlotFieldBarTip recordIndexRange:indexRange];

[self cacheNumbers:newBarLengths forField:CPTBarPlotFieldBarTip atRecordIndex:indexRange.location];

if ( self.barBasesVary ) {

id newBarBases = [self numbersFromDataSourceForField:CPTBarPlotFieldBarBase recordIndexRange:indexRange];

[self cacheNumbers:newBarBases forField:CPTBarPlotFieldBarBase atRecordIndex:indexRange.location];

}

else {

self.barBases = nil;

}

}

else {

self.barTips = nil;

self.barBases = nil;

}

// Locations of bars

if ( self.plotRange ) {

// Spread bars evenly over the plot range

CPTMutableNumericData *locationData = nil;

if ( self.doublePrecisionCache ) {

locationData = [[CPTMutableNumericData alloc] initWithData:[NSData data]

dataType:CPTDataType( CPTFloatingPointDataType, sizeof(double), CFByteOrderGetCurrent() )

shape:nil];

locationData.shape = @[@(indexRange.length)];

double doublePrecisionDelta = 1.0;

if ( indexRange.length > 1 ) {

doublePrecisionDelta = self.plotRange.lengthDouble / (double)(indexRange.length - 1);

}

double locationDouble = self.plotRange.locationDouble;

double *dataBytes = (double *)locationData.mutableBytes;

double *dataEnd = dataBytes + indexRange.length;

while ( dataBytes < dataEnd ) {

*dataBytes++ = locationDouble;

locationDouble += doublePrecisionDelta;

}

}

else {

locationData = [[CPTMutableNumericData alloc] initWithData:[NSData data]

dataType:CPTDataType( CPTDecimalDataType, sizeof(NSDecimal), CFByteOrderGetCurrent() )

shape:nil];

locationData.shape = @[@(indexRange.length)];

NSDecimal delta = CPTDecimalFromInteger(1);

if ( indexRange.length > 1 ) {

delta = CPTDecimalDivide( self.plotRange.lengthDecimal, CPTDecimalFromUnsignedInteger(indexRange.length - 1) );

}

NSDecimal locationDecimal = self.plotRange.locationDecimal;

NSDecimal *dataBytes = (NSDecimal *)locationData.mutableBytes;

NSDecimal *dataEnd = dataBytes + indexRange.length;

while ( dataBytes < dataEnd ) {

*dataBytes++ = locationDecimal;

locationDecimal = CPTDecimalAdd(locationDecimal, delta);

}

}

[self cacheNumbers:locationData forField:CPTBarPlotFieldBarLocation atRecordIndex:indexRange.location];

}

else if ( theDataSource ) {

// Get locations from the datasource

id newBarLocations = [self numbersFromDataSourceForField:CPTBarPlotFieldBarLocation recordIndexRange:indexRange];

[self cacheNumbers:newBarLocations forField:CPTBarPlotFieldBarLocation atRecordIndex:indexRange.location];

}

else {

// Make evenly spaced locations starting at zero

CPTMutableNumericData *locationData = nil;

if ( self.doublePrecisionCache ) {

locationData = [[CPTMutableNumericData alloc] initWithData:[NSData data]

dataType:CPTDataType( CPTFloatingPointDataType, sizeof(double), CFByteOrderGetCurrent() )

shape:nil];

locationData.shape = @[@(indexRange.length)];

double locationDouble = 0.0;

double *dataBytes = (double *)locationData.mutableBytes;

double *dataEnd = dataBytes + indexRange.length;

while ( dataBytes < dataEnd ) {

*dataBytes++ = locationDouble;

locationDouble += 1.0;

}

}

else {

locationData = [[CPTMutableNumericData alloc] initWithData:[NSData data]

dataType:CPTDataType( CPTDecimalDataType, sizeof(NSDecimal), CFByteOrderGetCurrent() )

shape:nil];

locationData.shape = @[@(indexRange.length)];

NSDecimal locationDecimal = CPTDecimalFromInteger(0);

NSDecimal *dataBytes = (NSDecimal *)locationData.mutableBytes;

NSDecimal *dataEnd = dataBytes + indexRange.length;

NSDecimal one = CPTDecimalFromInteger(1);

while ( dataBytes < dataEnd ) {

*dataBytes++ = locationDecimal;

locationDecimal = CPTDecimalAdd(locationDecimal, one);

}

}

[self cacheNumbers:locationData forField:CPTBarPlotFieldBarLocation atRecordIndex:indexRange.location];

}

}

}

/// @endcond

/**

* @brief Reload all bar fills from the data source immediately.

**/

-(void)reloadBarFills

{

[self reloadBarFillsInIndexRange:NSMakeRange(0, self.cachedDataCount)];

}

/** @brief Reload bar fills in the given index range from the data source immediately.

* @param indexRange The index range to load.

**/

-(void)reloadBarFillsInIndexRange:(NSRange)indexRange

{

id<CPTBarPlotDataSource> theDataSource = (id<CPTBarPlotDataSource>)self.dataSource;

BOOL needsLegendUpdate = NO;

if ( [theDataSource respondsToSelector:@selector(barFillsForBarPlot:recordIndexRange:)] ) {

needsLegendUpdate = YES;

[self cacheArray:[theDataSource barFillsForBarPlot:self recordIndexRange:indexRange]

forKey:CPTBarPlotBindingBarFills

atRecordIndex:indexRange.location];

}

else if ( [theDataSource respondsToSelector:@selector(barFillForBarPlot:recordIndex:)] ) {

needsLegendUpdate = YES;

id nilObject = [CPTPlot nilData];

CPTMutableFillArray array = [[NSMutableArray alloc] initWithCapacity:indexRange.length];

NSUInteger maxIndex = NSMaxRange(indexRange);

for ( NSUInteger idx = indexRange.location; idx < maxIndex; idx++ ) {

CPTFill *dataSourceFill = [theDataSource barFillForBarPlot:self recordIndex:idx];

if ( dataSourceFill ) {

[array addObject:dataSourceFill];

}

else {

[array addObject:nilObject];

}

}

[self cacheArray:array forKey:CPTBarPlotBindingBarFills atRecordIndex:indexRange.location];

}

// Legend

if ( needsLegendUpdate ) {

[[NSNotificationCenter defaultCenter] postNotificationName:CPTLegendNeedsRedrawForPlotNotification object:self];

}

[self setNeedsDisplay];

}

/**

* @brief Reload all bar line styles from the data source immediately.

**/

-(void)reloadBarLineStyles

{

[self reloadBarLineStylesInIndexRange:NSMakeRange(0, self.cachedDataCount)];

}

/** @brief Reload bar line styles in the given index range from the data source immediately.

* @param indexRange The index range to load.

**/

-(void)reloadBarLineStylesInIndexRange:(NSRange)indexRange

{

id<CPTBarPlotDataSource> theDataSource = (id<CPTBarPlotDataSource>)self.dataSource;

BOOL needsLegendUpdate = NO;

if ( [theDataSource respondsToSelector:@selector(barLineStylesForBarPlot:recordIndexRange:)] ) {

needsLegendUpdate = YES;

[self cacheArray:[theDataSource barLineStylesForBarPlot:self recordIndexRange:indexRange]

forKey:CPTBarPlotBindingBarLineStyles

atRecordIndex:indexRange.location];

}

else if ( [theDataSource respondsToSelector:@selector(barLineStyleForBarPlot:recordIndex:)] ) {

needsLegendUpdate = YES;

id nilObject = [CPTPlot nilData];

CPTMutableLineStyleArray array = [[NSMutableArray alloc] initWithCapacity:indexRange.length];

NSUInteger maxIndex = NSMaxRange(indexRange);

for ( NSUInteger idx = indexRange.location; idx < maxIndex; idx++ ) {

CPTLineStyle *dataSourceLineStyle = [theDataSource barLineStyleForBarPlot:self recordIndex:idx];

if ( dataSourceLineStyle ) {

[array addObject:dataSourceLineStyle];

}

else {

[array addObject:nilObject];

}

}

[self cacheArray:array forKey:CPTBarPlotBindingBarLineStyles atRecordIndex:indexRange.location];

}

// Legend

if ( needsLegendUpdate ) {

[[NSNotificationCenter defaultCenter] postNotificationName:CPTLegendNeedsRedrawForPlotNotification object:self];

}

[self setNeedsDisplay];

}

#pragma mark -

#pragma mark Length Conversions for Independent Coordinate (e.g., widths, offsets)

/// @cond

-(CGFloat)lengthInView:(NSDecimal)decimalLength

{

CGFloat length;

if ( self.barWidthsAreInViewCoordinates ) {

length = CPTDecimalCGFloatValue(decimalLength);

}

else {

CPTCoordinate coordinate = (self.barsAreHorizontal ? CPTCoordinateY : CPTCoordinateX);

CPTXYPlotSpace *thePlotSpace = (CPTXYPlotSpace *)self.plotSpace;

NSDecimal xLocation = thePlotSpace.xRange.locationDecimal;

NSDecimal yLocation = thePlotSpace.yRange.locationDecimal;

NSDecimal originPlotPoint[2];

NSDecimal displacedPlotPoint[2];

switch ( coordinate ) {

case CPTCoordinateX:

originPlotPoint[CPTCoordinateX] = xLocation;

originPlotPoint[CPTCoordinateY] = yLocation;

displacedPlotPoint[CPTCoordinateX] = CPTDecimalAdd(xLocation, decimalLength);

displacedPlotPoint[CPTCoordinateY] = yLocation;

break;

case CPTCoordinateY:

originPlotPoint[CPTCoordinateX] = xLocation;

originPlotPoint[CPTCoordinateY] = yLocation;

displacedPlotPoint[CPTCoordinateX] = xLocation;

displacedPlotPoint[CPTCoordinateY] = CPTDecimalAdd(yLocation, decimalLength);

break;

default:

break;

}

CGPoint originPoint = [thePlotSpace plotAreaViewPointForPlotPoint:originPlotPoint numberOfCoordinates:2];

CGPoint displacedPoint = [thePlotSpace plotAreaViewPointForPlotPoint:displacedPlotPoint numberOfCoordinates:2];

switch ( coordinate ) {

case CPTCoordinateX:

length = displacedPoint.x - originPoint.x;

break;

case CPTCoordinateY:

length = displacedPoint.y - originPoint.y;

break;

default:

length = CPTFloat(0.0);

break;

}

}

return length;

}

-(double)doubleLengthInPlotCoordinates:(NSDecimal)decimalLength

{

double length;

if ( self.barWidthsAreInViewCoordinates ) {

CGFloat floatLength = CPTDecimalCGFloatValue(decimalLength);

CGPoint originViewPoint = CGPointZero;

CGPoint displacedViewPoint = CPTPointMake(floatLength, floatLength);

double originPlotPoint[2], displacedPlotPoint[2];

CPTPlotSpace *thePlotSpace = self.plotSpace;

[thePlotSpace doublePrecisionPlotPoint:originPlotPoint numberOfCoordinates:2 forPlotAreaViewPoint:originViewPoint];

[thePlotSpace doublePrecisionPlotPoint:displacedPlotPoint numberOfCoordinates:2 forPlotAreaViewPoint:displacedViewPoint];

if ( self.barsAreHorizontal ) {

length = displacedPlotPoint[CPTCoordinateY] - originPlotPoint[CPTCoordinateY];

}

else {

length = displacedPlotPoint[CPTCoordinateX] - originPlotPoint[CPTCoordinateX];

}

}

else {

length = CPTDecimalDoubleValue(decimalLength);

}

return length;

}

-(NSDecimal)lengthInPlotCoordinates:(NSDecimal)decimalLength

{

NSDecimal length;

if ( self.barWidthsAreInViewCoordinates ) {

CGFloat floatLength = CPTDecimalCGFloatValue(decimalLength);

CGPoint originViewPoint = CGPointZero;

CGPoint displacedViewPoint = CPTPointMake(floatLength, floatLength);

NSDecimal originPlotPoint[2], displacedPlotPoint[2];

CPTPlotSpace *thePlotSpace = self.plotSpace;

[thePlotSpace plotPoint:originPlotPoint numberOfCoordinates:2 forPlotAreaViewPoint:originViewPoint];

[thePlotSpace plotPoint:displacedPlotPoint numberOfCoordinates:2 forPlotAreaViewPoint:displacedViewPoint];

if ( self.barsAreHorizontal ) {

length = CPTDecimalSubtract(displacedPlotPoint[CPTCoordinateY], originPlotPoint[CPTCoordinateY]);

}

else {

length = CPTDecimalSubtract(displacedPlotPoint[CPTCoordinateX], originPlotPoint[CPTCoordinateX]);

}

}

else {

length = decimalLength;

}

return length;

}

/// @endcond

#pragma mark -

#pragma mark Data Ranges

/// @cond

-(nullable CPTPlotRange *)plotRangeForCoordinate:(CPTCoordinate)coord

{

CPTPlotRange *range = [super plotRangeForCoordinate:coord];

if ( !self.barBasesVary ) {

switch ( coord ) {

case CPTCoordinateX:

if ( self.barsAreHorizontal ) {

NSDecimal base = self.baseValue.decimalValue;

if ( ![range contains:base] ) {

CPTMutablePlotRange *newRange = [range mutableCopy];

[newRange unionPlotRange:[CPTPlotRange plotRangeWithLocationDecimal:base lengthDecimal:CPTDecimalFromInteger(0)]];

range = newRange;

}

}

break;

case CPTCoordinateY:

if ( !self.barsAreHorizontal ) {

NSDecimal base = self.baseValue.decimalValue;

if ( ![range contains:base] ) {

CPTMutablePlotRange *newRange = [range mutableCopy];

[newRange unionPlotRange:[CPTPlotRange plotRangeWithLocationDecimal:base lengthDecimal:CPTDecimalFromInteger(0)]];

range = newRange;

}

}

break;

default:

break;

}

}

return range;

}

/// @endcond

/** @brief Computes a plot range that completely encloses all of the bars.

*

* For a horizontal bar plot, this range starts at the left edge of the first bar and continues to the right edge

* of the last bar. Similarly, this range starts at the bottom edge of the first bar and continues to the top edge

* of the last bar for vertical bar plots. The length will have the same sign as the corresponding plot range from the plot space.

*

* @return A plot range that completely encloses all of the bars.

**/

-(nullable CPTPlotRange *)plotRangeEnclosingBars

{

BOOL horizontalBars = self.barsAreHorizontal;

CPTMutablePlotRange *range;

if ( horizontalBars ) {

range = [[self plotRangeForCoordinate:CPTCoordinateY] mutableCopy];

}

else {

range = [[self plotRangeForCoordinate:CPTCoordinateX] mutableCopy];

}

NSDecimal barOffsetLength = [self lengthInPlotCoordinates:self.barOffset.decimalValue];

NSDecimal barWidthLength = [self lengthInPlotCoordinates:self.barWidth.decimalValue];

NSDecimal halfBarWidth = CPTDecimalDivide( barWidthLength, CPTDecimalFromInteger(2) );

NSDecimal rangeLocation = range.locationDecimal;

NSDecimal rangeLength = range.lengthDecimal;

if ( CPTDecimalGreaterThanOrEqualTo( rangeLength, CPTDecimalFromInteger(0) ) ) {

rangeLocation = CPTDecimalSubtract(rangeLocation, halfBarWidth);

range.locationDecimal = CPTDecimalAdd(rangeLocation, barOffsetLength);

range.lengthDecimal = CPTDecimalAdd(rangeLength, barWidthLength);

}

else {

rangeLocation = CPTDecimalAdd(rangeLocation, halfBarWidth);

range.locationDecimal = CPTDecimalSubtract(rangeLocation, barOffsetLength);

range.lengthDecimal = CPTDecimalSubtract(rangeLength, barWidthLength);

}

return range;

}

#pragma mark -

#pragma mark Drawing

/// @cond

-(void)renderAsVectorInContext:(nonnull CGContextRef)context

{

if ( self.hidden ) {

return;

}

CPTMutableNumericData *cachedLocations = [self cachedNumbersForField:CPTBarPlotFieldBarLocation];

CPTMutableNumericData *cachedLengths = [self cachedNumbersForField:CPTBarPlotFieldBarTip];

if ( (cachedLocations == nil) || (cachedLengths == nil) ) {

return;

}

BOOL basesVary = self.barBasesVary;

CPTMutableNumericData *cachedBases = [self cachedNumbersForField:CPTBarPlotFieldBarBase];

if ( basesVary && (cachedBases == nil) ) {

return;

}

NSUInteger barCount = self.cachedDataCount;

if ( barCount == 0 ) {

return;

}

if ( cachedLocations.numberOfSamples != cachedLengths.numberOfSamples ) {

[NSException raise:CPTException format:@"Number of bar locations and lengths do not match"];

}

if ( basesVary && (cachedLengths.numberOfSamples != cachedBases.numberOfSamples) ) {

[NSException raise:CPTException format:@"Number of bar lengths and bases do not match"];

}

[super renderAsVectorInContext:context];

CGContextBeginTransparencyLayer(context, NULL);

for ( NSUInteger ii = 0; ii < barCount; ii++ ) {

// Draw

[self drawBarInContext:context recordIndex:ii];

}

CGContextEndTransparencyLayer(context);

}

-(BOOL)barAtRecordIndex:(NSUInteger)idx basePoint:(nonnull CGPoint *)basePoint tipPoint:(nonnull CGPoint *)tipPoint

{

BOOL horizontalBars = self.barsAreHorizontal;

CPTCoordinate independentCoord = (horizontalBars ? CPTCoordinateY : CPTCoordinateX);

CPTCoordinate dependentCoord = (horizontalBars ? CPTCoordinateX : CPTCoordinateY);

CPTPlotSpace *thePlotSpace = self.plotSpace;

if ( self.doublePrecisionCache ) {

double plotPoint[2];

plotPoint[independentCoord] = [self cachedDoubleForField:CPTBarPlotFieldBarLocation recordIndex:idx];

if ( isnan(plotPoint[independentCoord]) ) {

return NO;

}

// Tip point

plotPoint[dependentCoord] = [self cachedDoubleForField:CPTBarPlotFieldBarTip recordIndex:idx];

if ( isnan(plotPoint[dependentCoord]) ) {

return NO;

}

*tipPoint = [thePlotSpace plotAreaViewPointForDoublePrecisionPlotPoint:plotPoint numberOfCoordinates:2];

// Base point

if ( !self.barBasesVary ) {

plotPoint[dependentCoord] = self.baseValue.doubleValue;

}

else {

plotPoint[dependentCoord] = [self cachedDoubleForField:CPTBarPlotFieldBarBase recordIndex:idx];

}

if ( isnan(plotPoint[dependentCoord]) ) {

return NO;

}

*basePoint = [thePlotSpace plotAreaViewPointForDoublePrecisionPlotPoint:plotPoint numberOfCoordinates:2];

}

else {

NSDecimal plotPoint[2];

plotPoint[independentCoord] = [self cachedDecimalForField:CPTBarPlotFieldBarLocation recordIndex:idx];

if ( NSDecimalIsNotANumber(&plotPoint[independentCoord]) ) {

return NO;

}

// Tip point

plotPoint[dependentCoord] = [self cachedDecimalForField:CPTBarPlotFieldBarTip recordIndex:idx];

if ( NSDecimalIsNotANumber(&plotPoint[dependentCoord]) ) {

return NO;

}

*tipPoint = [thePlotSpace plotAreaViewPointForPlotPoint:plotPoint numberOfCoordinates:2];

// Base point

if ( !self.barBasesVary ) {

plotPoint[dependentCoord] = self.baseValue.decimalValue;

}

else {

plotPoint[dependentCoord] = [self cachedDecimalForField:CPTBarPlotFieldBarBase recordIndex:idx];

}

if ( NSDecimalIsNotANumber(&plotPoint[dependentCoord]) ) {

return NO;

}

*basePoint = [thePlotSpace plotAreaViewPointForPlotPoint:plotPoint numberOfCoordinates:2];

}

// Determine bar width and offset.

CGFloat barOffsetLength = [self lengthInView:self.barOffset.decimalValue];

// Offset

if ( horizontalBars ) {

basePoint->y += barOffsetLength;

tipPoint->y += barOffsetLength;

}

else {

basePoint->x += barOffsetLength;

tipPoint->x += barOffsetLength;

}

return YES;

}

-(nonnull CGMutablePathRef)newBarPathWithContext:(nullable CGContextRef)context recordIndex:(NSUInteger)recordIndex

{

// Get base and tip points

CGPoint basePoint, tipPoint;

BOOL barExists = [self barAtRecordIndex:recordIndex basePoint:&basePoint tipPoint:&tipPoint];

if ( !barExists ) {

return NULL;

}

CGMutablePathRef path = [self newBarPathWithContext:context basePoint:basePoint tipPoint:tipPoint];

return path;

}

-(nonnull CGMutablePathRef)newBarPathWithContext:(nullable CGContextRef)context basePoint:(CGPoint)basePoint tipPoint:(CGPoint)tipPoint

{

// This function is used to create a path which is used for both

// drawing a bar and for doing hit-testing on a click/touch event

BOOL horizontalBars = self.barsAreHorizontal;

CGFloat barWidthLength = [self lengthInView:self.barWidth.decimalValue];

CGFloat halfBarWidth = CPTFloat(0.5) * barWidthLength;

CGRect barRect;

if ( horizontalBars ) {

barRect = CPTRectMake(basePoint.x, basePoint.y - halfBarWidth, tipPoint.x - basePoint.x, barWidthLength);

}

else {

barRect = CPTRectMake(basePoint.x - halfBarWidth, basePoint.y, barWidthLength, tipPoint.y - basePoint.y);

}

int widthNegative = signbit(barRect.size.width);

int heightNegative = signbit(barRect.size.height);

// Align to device pixels if there is a line border.

// Otherwise, align to view space, so fills are sharp at edges.

// Note: may not have a context if doing hit testing.

if ( self.alignsPointsToPixels && context ) {

// Round bar dimensions so adjacent bars always align to the right pixel position

const CGFloat roundingPrecision = CPTFloat(1.0e6);

barRect.origin.x = round(barRect.origin.x * roundingPrecision) / roundingPrecision;

barRect.origin.y = round(barRect.origin.y * roundingPrecision) / roundingPrecision;

barRect.size.width = round(barRect.size.width * roundingPrecision) / roundingPrecision;

barRect.size.height = round(barRect.size.height * roundingPrecision) / roundingPrecision;

CGContextRef theContext = context;

if ( self.lineStyle.lineWidth > CPTFloat(0.0) ) {

barRect = CPTAlignRectToUserSpace(theContext, barRect);

}

else {

barRect = CPTAlignIntegralRectToUserSpace(theContext, barRect);

}

}

CGFloat radius = MIN( MIN( self.barCornerRadius, ABS(barRect.size.width) * CPTFloat(0.5) ), ABS(barRect.size.height) * CPTFloat(0.5) );

CGFloat baseRadius = MIN( MIN( self.barBaseCornerRadius, ABS(barRect.size.width) * CPTFloat(0.5) ), ABS(barRect.size.height) * CPTFloat(0.5) );

if ( widthNegative && ( barRect.size.width > CPTFloat(0.0) ) ) {

barRect.origin.x += barRect.size.width;

barRect.size.width = -barRect.size.width;

}

if ( heightNegative && ( barRect.size.height > CPTFloat(0.0) ) ) {

barRect.origin.y += barRect.size.height;

barRect.size.height = -barRect.size.height;

}

CGMutablePathRef path = CGPathCreateMutable();

if ( radius == CPTFloat(0.0) ) {

if ( baseRadius == CPTFloat(0.0) ) {

// square corners

CGPathAddRect(path, NULL, barRect);

}

else {

CGFloat tipX = barRect.origin.x + barRect.size.width;

CGFloat tipY = barRect.origin.y + barRect.size.height;

// rounded at base end only

if ( horizontalBars ) {

CGPathMoveToPoint(path, NULL, tipX, tipY);

CGPathAddArcToPoint(path, NULL, barRect.origin.x, tipY, barRect.origin.x, CGRectGetMidY(barRect), baseRadius);

CGPathAddArcToPoint(path, NULL, barRect.origin.x, barRect.origin.y, tipX, barRect.origin.y, baseRadius);

CGPathAddLineToPoint(path, NULL, tipX, barRect.origin.y);

}

else {

CGPathMoveToPoint(path, NULL, barRect.origin.x, tipY);

CGPathAddArcToPoint(path, NULL, barRect.origin.x, barRect.origin.y, CGRectGetMidX(barRect), barRect.origin.y, baseRadius);

CGPathAddArcToPoint(path, NULL, tipX, barRect.origin.y, tipX, tipY, baseRadius);

CGPathAddLineToPoint(path, NULL, tipX, tipY);

}

CGPathCloseSubpath(path);

}

}

else {

CGFloat tipX = barRect.origin.x + barRect.size.width;

CGFloat tipY = barRect.origin.y + barRect.size.height;

if ( baseRadius == CPTFloat(0.0) ) {

// rounded at tip end only

CGPathMoveToPoint(path, NULL, barRect.origin.x, barRect.origin.y);