#import "CPTGradient.h"

#import "CPTColor.h"

#import "CPTColorSpace.h"

#import "CPTPlatformSpecificFunctions.h"

#import "CPTUtilities.h"

#import "NSCoderExtensions.h"

#import <tgmath.h>

@interface CPTGradient()

@property (nonatomic, readwrite, strong, nonnull) CPTColorSpace *colorspace;

@property (nonatomic, readwrite, assign) CPTGradientBlendingMode blendingMode;

@property (nonatomic, readwrite, assign) CPTGradientElement *elementList;

@property (nonatomic, readwrite, assign, nonnull) CGFunctionRef gradientFunction;

-(void)commonInit;

-(void)addElement:(nonnull CPTGradientElement *)newElement;

-(nonnull CGShadingRef)newAxialGradientInRect:(CGRect)rect;

-(nonnull CGShadingRef)newRadialGradientInRect:(CGRect)rect context:(nonnull CGContextRef)context;

-(nullable CPTGradientElement *)elementAtIndex:(NSUInteger)idx NS_RETURNS_INNER_POINTER;

-(NSUInteger)elementCount;

-(CPTGradientElement)removeElementAtIndex:(NSUInteger)idx;

-(CPTGradientElement)removeElementAtPosition:(CGFloat)position;

-(void)removeAllElements;

static void CPTLinearEvaluation(void *__nullable info, const CGFloat *__nonnull in, CGFloat *__nonnull out);

static void CPTChromaticEvaluation(void *__nullable info, const CGFloat *__nonnull in, CGFloat *__nonnull out);

static void CPTInverseChromaticEvaluation(void *__nullable info, const CGFloat *__nonnull in, CGFloat *__nonnull out);

static void CPTTransformRGB_HSV(CGFloat *__nonnull components);

static void CPTTransformHSV_RGB(CGFloat *__nonnull components);

static void CPTResolveHSV(CGFloat *__nonnull color1, CGFloat *__nonnull color2);

#pragma mark -

@implementation CPTGradient

@synthesize colorspace;

@synthesize blendingMode;

@synthesize angle;

@synthesize gradientType;

@synthesize startAnchor;

@synthesize endAnchor;

@dynamic opaque;

@synthesize elementList;

@synthesize gradientFunction;

#pragma mark -

#pragma mark Init/Dealloc

-(nonnull instancetype)init

{

if ((self = [super init])) {

[self commonInit];

self.blendingMode = CPTLinearBlendingMode;

angle = CPTFloat(0.0);

gradientType = CPTGradientTypeAxial;

startAnchor = CPTPointMake(0.5, 0.5);

endAnchor = CPTPointMake(0.5, 0.5);

}

return self;

}

-(void)commonInit

{

self.colorspace = [CPTColorSpace genericRGBSpace];

self.elementList = NULL;

}

-(void)dealloc

{

CGFunctionRelease(gradientFunction);

[self removeAllElements];

}

#pragma mark -

#pragma mark NSCopying Methods

-(nonnull id)copyWithZone:(nullable NSZone *)zone

{

CPTGradient *copy = [[[self class] allocWithZone:zone] init];

CPTGradientElement *currentElement = self.elementList;

while ( currentElement != NULL ) {

[copy addElement:currentElement];

currentElement = currentElement->nextElement;

}

copy.blendingMode = self.blendingMode;

copy.angle = self.angle;

copy.gradientType = self.gradientType;

copy.startAnchor = self.startAnchor;

copy.endAnchor = self.endAnchor;

return copy;

}

#pragma mark -

#pragma mark NSCoding Methods

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

{

NSUInteger count = 0;

CPTGradientElement *currentElement = self.elementList;

while ( currentElement != NULL ) {

[coder encodeCGFloat:currentElement->color.red forKey:[NSString stringWithFormat:@"red%lu", (unsigned long)count]];

[coder encodeCGFloat:currentElement->color.green forKey:[NSString stringWithFormat:@"green%lu", (unsigned long)count]];

[coder encodeCGFloat:currentElement->color.blue forKey:[NSString stringWithFormat:@"blue%lu", (unsigned long)count]];

[coder encodeCGFloat:currentElement->color.alpha forKey:[NSString stringWithFormat:@"alpha%lu", (unsigned long)count]];

[coder encodeCGFloat:currentElement->position forKey:[NSString stringWithFormat:@"position%lu", (unsigned long)count]];

count++;

currentElement = currentElement->nextElement;

}

[coder encodeInteger:(NSInteger)count forKey:@"CPTGradient.elementCount"];

[coder encodeInteger:self.blendingMode forKey:@"CPTGradient.blendingMode"];

[coder encodeCGFloat:self.angle forKey:@"CPTGradient.angle"];

[coder encodeInteger:self.gradientType forKey:@"CPTGradient.type"];

[coder encodeCPTPoint:self.startAnchor forKey:@"CPTPlotSymbol.startAnchor"];

[coder encodeCPTPoint:self.endAnchor forKey:@"CPTPlotSymbol.endAnchor"];

}

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

{

if ((self = [super init])) {

[self commonInit];

gradientType = (CPTGradientType)[coder decodeIntegerForKey:@"CPTGradient.type"];

angle = [coder decodeCGFloatForKey:@"CPTGradient.angle"];

self.blendingMode = (CPTGradientBlendingMode)[coder decodeIntegerForKey:@"CPTGradient.blendingMode"];

startAnchor = [coder decodeCPTPointForKey:@"CPTPlotSymbol.startAnchor"];

endAnchor = [coder decodeCPTPointForKey:@"CPTPlotSymbol.endAnchor"];

NSUInteger count = (NSUInteger)[coder decodeIntegerForKey:@"CPTGradient.elementCount"];

for ( NSUInteger i = 0; i < count; i++ ) {

CPTGradientElement newElement;

newElement.color.red = [coder decodeCGFloatForKey:[NSString stringWithFormat:@"red%lu", (unsigned long)i]];

newElement.color.green = [coder decodeCGFloatForKey:[NSString stringWithFormat:@"green%lu", (unsigned long)i]];

newElement.color.blue = [coder decodeCGFloatForKey:[NSString stringWithFormat:@"blue%lu", (unsigned long)i]];

newElement.color.alpha = [coder decodeCGFloatForKey:[NSString stringWithFormat:@"alpha%lu", (unsigned long)i]];

newElement.position = [coder decodeCGFloatForKey:[NSString stringWithFormat:@"position%lu", (unsigned long)i]];

[self addElement:&newElement];

}

}

return self;

}

#pragma mark -

#pragma mark NSSecureCoding Methods

+(BOOL)supportsSecureCoding

{

return YES;

}

#pragma mark -

#pragma mark Factory Methods

+(nonnull instancetype)gradientWithBeginningColor:(nonnull CPTColor *)begin endingColor:(nonnull CPTColor *)end

{

return [self gradientWithBeginningColor:begin endingColor:end beginningPosition:CPTFloat(0.0) endingPosition:CPTFloat(1.0)];

}

+(nonnull instancetype)gradientWithBeginningColor:(nonnull CPTColor *)begin endingColor:(nonnull CPTColor *)end beginningPosition:(CGFloat)beginningPosition endingPosition:(CGFloat)endingPosition

{

CPTGradient *newInstance = [[self alloc] init];

CPTGradientElement color1;

CPTGradientElement color2;

color1.color = CPTRGBAColorFromCGColor(begin.cgColor);

color2.color = CPTRGBAColorFromCGColor(end.cgColor);

color1.position = beginningPosition;

color2.position = endingPosition;

[newInstance addElement:&color1];

[newInstance addElement:&color2];

return newInstance;

}

+(nonnull instancetype)aquaSelectedGradient

{

CPTGradient *newInstance = [[self alloc] init];

CPTGradientElement color1;

color1.color.red = CPTFloat(0.58);

color1.color.green = CPTFloat(0.86);

color1.color.blue = CPTFloat(0.98);

color1.color.alpha = CPTFloat(1.00);

color1.position = CPTFloat(0.0);

CPTGradientElement color2;

color2.color.red = CPTFloat(0.42);

color2.color.green = CPTFloat(0.68);

color2.color.blue = CPTFloat(0.90);

color2.color.alpha = CPTFloat(1.00);

color2.position = CPTFloat(0.5);

CPTGradientElement color3;

color3.color.red = CPTFloat(0.64);

color3.color.green = CPTFloat(0.80);

color3.color.blue = CPTFloat(0.94);

color3.color.alpha = CPTFloat(1.00);

color3.position = CPTFloat(0.5);

CPTGradientElement color4;

color4.color.red = CPTFloat(0.56);

color4.color.green = CPTFloat(0.70);

color4.color.blue = CPTFloat(0.90);

color4.color.alpha = CPTFloat(1.00);

color4.position = CPTFloat(1.0);

[newInstance addElement:&color1];

[newInstance addElement:&color2];

[newInstance addElement:&color3];

[newInstance addElement:&color4];

return newInstance;

}

+(nonnull instancetype)aquaNormalGradient

{

CPTGradient *newInstance = [[self alloc] init];

CPTGradientElement color1;

color1.color.red = color1.color.green = color1.color.blue = CPTFloat(0.95);

color1.color.alpha = CPTFloat(1.00);

color1.position = CPTFloat(0.0);

CPTGradientElement color2;

color2.color.red = color2.color.green = color2.color.blue = CPTFloat(0.83);

color2.color.alpha = CPTFloat(1.00);

color2.position = CPTFloat(0.5);

CPTGradientElement color3;

color3.color.red = color3.color.green = color3.color.blue = CPTFloat(0.95);

color3.color.alpha = CPTFloat(1.00);

color3.position = CPTFloat(0.5);

CPTGradientElement color4;

color4.color.red = color4.color.green = color4.color.blue = CPTFloat(0.92);

color4.color.alpha = CPTFloat(1.00);

color4.position = CPTFloat(1.0);

[newInstance addElement:&color1];

[newInstance addElement:&color2];

[newInstance addElement:&color3];

[newInstance addElement:&color4];

return newInstance;

}

+(nonnull instancetype)aquaPressedGradient

{

CPTGradient *newInstance = [[self alloc] init];

CPTGradientElement color1;

color1.color.red = color1.color.green = color1.color.blue = CPTFloat(0.80);

color1.color.alpha = CPTFloat(1.00);

color1.position = CPTFloat(0.0);

CPTGradientElement color2;

color2.color.red = color2.color.green = color2.color.blue = CPTFloat(0.64);

color2.color.alpha = CPTFloat(1.00);

color2.position = CPTFloat(0.5);

CPTGradientElement color3;

color3.color.red = color3.color.green = color3.color.blue = CPTFloat(0.80);

color3.color.alpha = CPTFloat(1.00);

color3.position = CPTFloat(0.5);

CPTGradientElement color4;

color4.color.red = color4.color.green = color4.color.blue = CPTFloat(0.77);

color4.color.alpha = CPTFloat(1.00);

color4.position = CPTFloat(1.0);

[newInstance addElement:&color1];

[newInstance addElement:&color2];

[newInstance addElement:&color3];

[newInstance addElement:&color4];

return newInstance;

}

+(nonnull instancetype)unifiedSelectedGradient

{

CPTGradient *newInstance = [[self alloc] init];

CPTGradientElement color1;

color1.color.red = color1.color.green = color1.color.blue = CPTFloat(0.85);

color1.color.alpha = CPTFloat(1.00);

color1.position = CPTFloat(0.0);

CPTGradientElement color2;

color2.color.red = color2.color.green = color2.color.blue = CPTFloat(0.95);

color2.color.alpha = CPTFloat(1.00);

color2.position = CPTFloat(1.0);

[newInstance addElement:&color1];

[newInstance addElement:&color2];

return newInstance;

}

+(nonnull instancetype)unifiedNormalGradient

{

CPTGradient *newInstance = [[self alloc] init];

CPTGradientElement color1;

color1.color.red = color1.color.green = color1.color.blue = CPTFloat(0.75);

color1.color.alpha = CPTFloat(1.00);

color1.position = CPTFloat(0.0);

CPTGradientElement color2;

color2.color.red = color2.color.green = color2.color.blue = CPTFloat(0.90);

color2.color.alpha = CPTFloat(1.00);

color2.position = CPTFloat(1.0);

[newInstance addElement:&color1];

[newInstance addElement:&color2];

return newInstance;

}

+(nonnull instancetype)unifiedPressedGradient

{

CPTGradient *newInstance = [[self alloc] init];

CPTGradientElement color1;

color1.color.red = color1.color.green = color1.color.blue = CPTFloat(0.60);

color1.color.alpha = CPTFloat(1.00);

color1.position = CPTFloat(0.0);

CPTGradientElement color2;

color2.color.red = color2.color.green = color2.color.blue = CPTFloat(0.75);

color2.color.alpha = CPTFloat(1.00);

color2.position = CPTFloat(1.0);

[newInstance addElement:&color1];

[newInstance addElement:&color2];

return newInstance;

}

+(nonnull instancetype)unifiedDarkGradient

{

CPTGradient *newInstance = [[self alloc] init];

CPTGradientElement color1;

color1.color.red = color1.color.green = color1.color.blue = CPTFloat(0.68);

color1.color.alpha = CPTFloat(1.00);

color1.position = CPTFloat(0.0);

CPTGradientElement color2;

color2.color.red = color2.color.green = color2.color.blue = CPTFloat(0.83);

color2.color.alpha = CPTFloat(1.00);

color2.position = CPTFloat(1.0);

[newInstance addElement:&color1];

[newInstance addElement:&color2];

return newInstance;

}

+(nonnull instancetype)sourceListSelectedGradient

{

CPTGradient *newInstance = [[self alloc] init];

CPTGradientElement color1;

color1.color.red = CPTFloat(0.06);

color1.color.green = CPTFloat(0.37);

color1.color.blue = CPTFloat(0.85);

color1.color.alpha = CPTFloat(1.00);

color1.position = CPTFloat(0.0);

CPTGradientElement color2;

color2.color.red = CPTFloat(0.30);

color2.color.green = CPTFloat(0.60);

color2.color.blue = CPTFloat(0.92);

color2.color.alpha = CPTFloat(1.00);

color2.position = CPTFloat(1.0);

[newInstance addElement:&color1];

[newInstance addElement:&color2];

return newInstance;

}

+(nonnull instancetype)sourceListUnselectedGradient

{

CPTGradient *newInstance = [[self alloc] init];

CPTGradientElement color1;

color1.color.red = CPTFloat(0.43);

color1.color.green = CPTFloat(0.43);

color1.color.blue = CPTFloat(0.43);

color1.color.alpha = CPTFloat(1.00);

color1.position = CPTFloat(0.0);

CPTGradientElement color2;

color2.color.red = CPTFloat(0.60);

color2.color.green = CPTFloat(0.60);

color2.color.blue = CPTFloat(0.60);

color2.color.alpha = CPTFloat(1.00);

color2.position = CPTFloat(1.0);

[newInstance addElement:&color1];

[newInstance addElement:&color2];

return newInstance;

}

+(nonnull instancetype)rainbowGradient

{

CPTGradient *newInstance = [[self alloc] init];

CPTGradientElement color1;

color1.color.red = CPTFloat(1.00);

color1.color.green = CPTFloat(0.00);

color1.color.blue = CPTFloat(0.00);

color1.color.alpha = CPTFloat(1.00);

color1.position = CPTFloat(0.0);

CPTGradientElement color2;

color2.color.red = CPTFloat(0.54);

color2.color.green = CPTFloat(0.00);

color2.color.blue = CPTFloat(1.00);

color2.color.alpha = CPTFloat(1.00);

color2.position = CPTFloat(1.0);

[newInstance addElement:&color1];

[newInstance addElement:&color2];

newInstance.blendingMode = CPTChromaticBlendingMode;

return newInstance;

}

+(nonnull instancetype)hydrogenSpectrumGradient

{

CPTGradient *newInstance = [[self alloc] init];

struct {

CGFloat hue;

CGFloat position;

CGFloat width;

}

colorBands[4];

colorBands[0].hue = CPTFloat(22);

colorBands[0].position = CPTFloat(0.145);

colorBands[0].width = CPTFloat(0.01);

colorBands[1].hue = CPTFloat(200);

colorBands[1].position = CPTFloat(0.71);

colorBands[1].width = CPTFloat(0.008);

colorBands[2].hue = CPTFloat(253);

colorBands[2].position = CPTFloat(0.885);

colorBands[2].width = CPTFloat(0.005);

colorBands[3].hue = CPTFloat(275);

colorBands[3].position = CPTFloat(0.965);

colorBands[3].width = CPTFloat(0.003);

for ( NSUInteger i = 0; i < 4; i++ ) {

CGFloat color[4];

color[0] = colorBands[i].hue - CPTFloat(180.0) * colorBands[i].width;

color[1] = CPTFloat(1.0);

color[2] = CPTFloat(0.001);

color[3] = CPTFloat(1.0);

CPTTransformHSV_RGB(color);

CPTGradientElement fadeIn;

fadeIn.color.red = color[0];

fadeIn.color.green = color[1];

fadeIn.color.blue = color[2];

fadeIn.color.alpha = color[3];

fadeIn.position = colorBands[i].position - colorBands[i].width;

color[0] = colorBands[i].hue;

color[1] = CPTFloat(1.0);

color[2] = CPTFloat(1.0);

color[3] = CPTFloat(1.0);

CPTTransformHSV_RGB(color);

CPTGradientElement band;

band.color.red = color[0];

band.color.green = color[1];

band.color.blue = color[2];

band.color.alpha = color[3];

band.position = colorBands[i].position;

color[0] = colorBands[i].hue + CPTFloat(180.0) * colorBands[i].width;

color[1] = CPTFloat(1.0);

color[2] = CPTFloat(0.001);

color[3] = CPTFloat(1.0);

CPTTransformHSV_RGB(color);

CPTGradientElement fadeOut;

fadeOut.color.red = color[0];

fadeOut.color.green = color[1];

fadeOut.color.blue = color[2];

fadeOut.color.alpha = color[3];

fadeOut.position = colorBands[i].position + colorBands[i].width;

[newInstance addElement:&fadeIn];

[newInstance addElement:&band];

[newInstance addElement:&fadeOut];

}

newInstance.blendingMode = CPTChromaticBlendingMode;

return newInstance;

}

#pragma mark -

#pragma mark Modification

-(CPTGradient *)gradientWithAlphaComponent:(CGFloat)alpha

{

CPTGradient *newGradient = [[[self class] alloc] init];

CPTGradientElement *curElement = self.elementList;

CPTGradientElement tempElement;

while ( curElement != NULL ) {

tempElement = *curElement;

tempElement.color.alpha = alpha;

[newGradient addElement:&tempElement];

curElement = curElement->nextElement;

}

newGradient.blendingMode = self.blendingMode;

newGradient.angle = self.angle;

newGradient.gradientType = self.gradientType;

return newGradient;

}

-(CPTGradient *)gradientWithBlendingMode:(CPTGradientBlendingMode)mode

{

CPTGradient *newGradient = [self copy];

newGradient.blendingMode = mode;

return newGradient;

}

-(CPTGradient *)addColorStop:(nonnull CPTColor *)color atPosition:(CGFloat)position

{

CPTGradient *newGradient = [self copy];

CPTGradientElement newGradientElement;

// put the components of color into the newGradientElement - must make sure it is a RGB color (not Gray or CMYK)

newGradientElement.color = CPTRGBAColorFromCGColor(color.cgColor);

newGradientElement.position = position;

// Pass it off to addElement to take care of adding it to the elementList

[newGradient addElement:&newGradientElement];

return newGradient;

}

-(CPTGradient *)removeColorStopAtPosition:(CGFloat)position

{

CPTGradient *newGradient = [self copy];

CPTGradientElement removedElement = [newGradient removeElementAtPosition:position];

if ( isnan(removedElement.position)) {

[NSException raise:NSRangeException format:@"-[%@ removeColorStopAtPosition:]: no such colorStop at position (%g)", [self class], (double)position];

}

return newGradient;

}

-(CPTGradient *)removeColorStopAtIndex:(NSUInteger)idx

{

CPTGradient *newGradient = [self copy];

CPTGradientElement removedElement = [newGradient removeElementAtIndex:idx];

if ( isnan(removedElement.position)) {

[NSException raise:NSRangeException format:@"-[%@ removeColorStopAtIndex:]: index (%lu) beyond bounds", [self class], (unsigned long)idx];

}

return newGradient;

}

#pragma mark -

#pragma mark Information

-(CGColorRef)newColorStopAtIndex:(NSUInteger)idx

{

CPTGradientElement *element = [self elementAtIndex:idx];

if ( element != NULL ) {

#if TARGET_OS_SIMULATOR || TARGET_OS_IPHONE

CGFloat colorComponents[4] = { element->color.red, element->color.green, element->color.blue, element->color.alpha };

return CGColorCreate(self.colorspace.cgColorSpace, colorComponents);

#else

return CGColorCreateGenericRGB(element->color.red, element->color.green, element->color.blue, element->color.alpha);

#endif

}

[NSException raise:NSRangeException format:@"-[%@ colorStopAtIndex:]: index (%lu) beyond bounds", [self class], (unsigned long)idx];

return NULL;

}

-(CGColorRef)newColorAtPosition:(CGFloat)position

{

CGFloat components[4] = { CPTFloat(0.0), CPTFloat(0.0), CPTFloat(0.0), CPTFloat(0.0) };

CGColorRef gradientColor;

switch ( self.blendingMode ) {

case CPTLinearBlendingMode:

CPTLinearEvaluation((__bridge void *)(self), &position, components);

break;

case CPTChromaticBlendingMode:

CPTChromaticEvaluation((__bridge void *)(self), &position, components);

break;

case CPTInverseChromaticBlendingMode:

CPTInverseChromaticEvaluation((__bridge void *)(self), &position, components);

break;

}

#if TARGET_OS_SIMULATOR || TARGET_OS_IPHONE

CGFloat colorComponents[4] = { components[0], components[1], components[2], components[3] };

gradientColor = CGColorCreate(self.colorspace.cgColorSpace, colorComponents);

#else

gradientColor = CGColorCreateGenericRGB(components[0], components[1], components[2], components[3]);

#endif

return gradientColor;

}

#pragma mark -

#pragma mark Drawing

-(void)drawSwatchInRect:(CGRect)rect inContext:(nonnull CGContextRef)context

{

[self fillRect:rect inContext:context];

}

-(void)fillRect:(CGRect)rect inContext:(nonnull CGContextRef)context

{

CGShadingRef myCGShading = NULL;

CGContextSaveGState(context);

CGContextClipToRect(context, rect);

switch ( self.gradientType ) {

case CPTGradientTypeAxial:

myCGShading = [self newAxialGradientInRect:rect];

break;

case CPTGradientTypeRadial:

myCGShading = [self newRadialGradientInRect:rect context:context];

break;

}

CGContextDrawShading(context, myCGShading);

CGShadingRelease(myCGShading);

CGContextRestoreGState(context);

}

-(void)fillPathInContext:(nonnull CGContextRef)context

{

if ( !CGContextIsPathEmpty(context)) {

CGShadingRef myCGShading = NULL;

CGContextSaveGState(context);

CGRect bounds = CGContextGetPathBoundingBox(context);

CGContextClip(context);

switch ( self.gradientType ) {

case CPTGradientTypeAxial:

myCGShading = [self newAxialGradientInRect:bounds];

break;

case CPTGradientTypeRadial:

myCGShading = [self newRadialGradientInRect:bounds context:context];

break;

}

CGContextDrawShading(context, myCGShading);

CGShadingRelease(myCGShading);

CGContextRestoreGState(context);

}

}

#pragma mark -

#pragma mark Opacity

-(BOOL)isOpaque

{

BOOL opaqueGradient = YES;

CPTGradientElement *list = self.elementList;

while ( opaqueGradient && (list != NULL)) {

opaqueGradient = opaqueGradient && (list->color.alpha >= CPTFloat(1.0));

list = list->nextElement;

}

return opaqueGradient;

}

#pragma mark -

#pragma mark Gradient comparison

-(BOOL)isEqual:(nullable id)object

{

if ( self == object ) {

return YES;

}

else if ( [object isKindOfClass:[self class]] ) {

CPTGradient *otherGradient = (CPTGradient *)object;

BOOL equalGradients = (self.blendingMode == otherGradient.blendingMode) &&

(self.angle == otherGradient.angle) &&

(self.gradientType == otherGradient.gradientType);

if ( equalGradients ) {

equalGradients = ([self elementCount] == [otherGradient elementCount]);

}

if ( equalGradients ) {

CPTGradientElement *selfCurrentElement = self.elementList;

CPTGradientElement *otherCurrentElement = otherGradient.elementList;

while ( selfCurrentElement && otherCurrentElement ) {

if ( selfCurrentElement->color.red != otherCurrentElement->color.red ) {

equalGradients = NO;

break;

}

if ( selfCurrentElement->color.green != otherCurrentElement->color.green ) {

equalGradients = NO;

break;

}

if ( selfCurrentElement->color.blue != otherCurrentElement->color.blue ) {

equalGradients = NO;

break;

}

if ( selfCurrentElement->color.alpha != otherCurrentElement->color.alpha ) {

equalGradients = NO;

break;

}

if ( selfCurrentElement->position != otherCurrentElement->position ) {

equalGradients = NO;

break;

}

selfCurrentElement = selfCurrentElement->nextElement;

otherCurrentElement = otherCurrentElement->nextElement;

}

}

return equalGradients;

}

else {

return NO;

}

}

-(NSUInteger)hash

{

// Equal objects must hash the same.

CGFloat theHash = CPTFloat(0.0);

CGFloat multiplier = CPTFloat(256.0);

CPTGradientElement *curElement = self.elementList;

if ( curElement ) {

CPTRGBAColor color = curElement->color;

theHash += multiplier * color.red;

multiplier *= CPTFloat(256.0);

theHash += multiplier * color.green;

multiplier *= CPTFloat(256.0);

theHash += multiplier * color.blue;

multiplier *= CPTFloat(256.0);

theHash += multiplier * color.alpha;